Prompt caching

response = client.converse(
    modelId="claude-sonnet-4-6",
    system=[
        {"text": long_system_prompt},
        {"cachePoint": {"type": "default"}},
    ],
    messages=[{
        "role": "user",
        "content": [
            {"text": big_reference_document},
            {"cachePoint": {"type": "default"}},
            {"text": "Summarise the key risks."},
        ],
    }],
)

# Cache activity is reported in usage (Bedrock names):
print(response["usage"]["cacheReadInputTokens"])   # tokens served from cache
print(response["usage"]["cacheWriteInputTokens"])  # tokens written to cache

const response = await client.send(
  new ConverseCommand({
    modelId: "claude-sonnet-4-6",
    system: [
      { text: longSystemPrompt },
      { cachePoint: { type: "default" } },
    ],
    messages: [
      {
        role: "user",
        content: [
          { text: bigReferenceDocument },
          { cachePoint: { type: "default" } },
          { text: "Summarise the key risks." },
        ],
      },
    ],
  })
);

// Cache activity is reported in usage (Bedrock names):
console.log(response.usage?.cacheReadInputTokens);  // tokens served from cache
console.log(response.usage?.cacheWriteInputTokens); // tokens written to cache

resp, err := client.Converse(ctx, &audacityruntime.ConverseInput{
    ModelId: audacity.String("claude-sonnet-4-6"),
    System: []types.SystemContentBlock{
        {Text: longSystemPrompt},
        {CachePoint: &types.CachePointBlock{Type: types.CachePointTypeDefault}},
    },
    Messages: []types.Message{{
        Role: types.ConversationRoleUser,
        Content: []types.ContentBlock{
            &types.ContentBlockMemberText{Value: bigReferenceDocument},
            &types.ContentBlockMemberCachePoint{
                Value: types.CachePointBlock{Type: types.CachePointTypeDefault},
            },
            &types.ContentBlockMemberText{Value: "Summarise the key risks."},
        },
    }},
})

// Cache activity is reported in usage (Bedrock names):
fmt.Println(resp.Usage.CacheReadInputTokens)  // tokens served from cache
fmt.Println(resp.Usage.CacheWriteInputTokens) // tokens written to cache

ConverseResponse resp = client.converse(request -> request
    .modelId("claude-sonnet-4-6")
    .system(
        SystemContentBlock.fromText(longSystemPrompt),
        SystemContentBlock.fromCachePoint(CachePointBlock.defaultType()))
    .messages(Message.builder()
        .role(ConversationRole.USER)
        .content(
            ContentBlock.fromText(bigReferenceDocument),
            ContentBlock.fromCachePoint(CachePointBlock.defaultType()),
            ContentBlock.fromText("Summarise the key risks."))
        .build()));

// Cache activity is reported in usage (Bedrock names):
System.out.println(resp.usage().cacheReadInputTokens());  // tokens served from cache
System.out.println(resp.usage().cacheWriteInputTokens()); // tokens written to cache

use audacity_sdk::{CachePointBlock, ContentBlock, SystemContentBlock};

let response = client.converse()
    .model_id("claude-sonnet-4-6")
    .system(SystemContentBlock::text(long_system_prompt))
    .system(SystemContentBlock::cache_point())
    .messages(
        Message::builder()
            .role(ConversationRole::User)
            .content(ContentBlock::Text(big_reference_document))
            .content(ContentBlock::CachePoint(CachePointBlock::new()))
            .content(ContentBlock::Text("Summarise the key risks.".into()))
            .build()?
    )
    .send()
    .await?;

// Cache activity is reported in usage (Bedrock names):
println!("{}", response.usage().cache_read_input_tokens);  // tokens served from cache
println!("{}", response.usage().cache_write_input_tokens); // tokens written to cache