대화 중 시스템 메시지와 도구 변경

ant beta:messages create --beta mid-conversation-tool-changes-2026-07-01 \
  --transform 'content.#(type=="text").text' --raw-output <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
tools:
  - name: get_weather
    description: Get the current weather for a location.
    input_schema:
      type: object
      properties:
        location:
          type: string
          description: City name
      required:
        - location
messages:
  - role: user
    content: Say OK.
  - role: system
    content:
      - type: tool_removal
        tool:
          type: tool_reference
          name: get_weather
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    betas=["mid-conversation-tool-changes-2026-07-01"],
    # The full tool set is declared up front and never changes, so the
    # cached prefix stays intact.
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather for a location.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                },
                "required": ["location"],
            },
        },
    ],
    messages=[
        {
            "role": "user",
            "content": "Say OK.",
        },
        # Withdraw get_weather from this point onward. The block references
        # the tool by name instead of editing `tools`, so earlier turns stay
        # byte-identical and the cache still hits.
        {
            "role": "system",
            "content": [
                {
                    "type": "tool_removal",
                    "tool": {"type": "tool_reference", "name": "get_weather"},
                },
            ],
        },
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  betas: ["mid-conversation-tool-changes-2026-07-01"],
  // The full tool set is declared up front and never changes, so the
  // cached prefix stays intact.
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location.",
      input_schema: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "City name"
          }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    { role: "user", content: "Say OK." },
    // Withdraw get_weather from this point onward. The block references the
    // tool by name instead of editing `tools`, so earlier turns stay
    // byte-identical and the cache still hits.
    {
      role: "system",
      content: [
        {
          type: "tool_removal",
          tool: { type: "tool_reference", name: "get_weather" }
        }
      ]
    }
  ]
});

for (const block of response.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Betas = ["mid-conversation-tool-changes-2026-07-01"],
    // The full tool set is declared up front and never changes, so the
    // cached prefix stays intact.
    Tools =
    [
        new BetaTool
        {
            Name = "get_weather",
            Description = "Get the current weather for a location.",
            InputSchema = new InputSchema
            {
                Properties = new Dictionary<string, JsonElement>
                {
                    ["location"] = JsonSerializer.SerializeToElement(new { type = "string", description = "City name" }),
                },
                Required = ["location"],
            },
        },
    ],
    Messages =
    [
        new() { Role = Role.User, Content = "Say OK." },
        // Withdraw get_weather from this point onward. The block references
        // the tool by name instead of editing `Tools`, so earlier turns stay
        // byte-identical and the cache still hits.
        new()
        {
            Role = Role.System,
            Content = new(
            [
                new BetaRequestToolRemovalBlock
                {
                    Tool = new BetaToolChangeToolReference { Name = "get_weather" },
                },
            ]),
        },
    ],
});

foreach (var block in response.Content)
{
    if (block.TryPickText(out var text))
    {
        Console.WriteLine(text.Text);
    }
}

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Betas:     []anthropic.AnthropicBeta{"mid-conversation-tool-changes-2026-07-01"},
	// The full tool set is declared up front and never changes, so the
	// cached prefix stays intact.
	Tools: []anthropic.BetaToolUnionParam{
		{OfTool: &anthropic.BetaToolParam{
			Name:        "get_weather",
			Description: anthropic.String("Get the current weather for a location."),
			InputSchema: anthropic.BetaToolInputSchemaParam{
				Properties: map[string]any{
					"location": map[string]any{
						"type":        "string",
						"description": "City name",
					},
				},
				Required: []string{"location"},
			},
		}},
	},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Say OK.")),
		// Withdraw get_weather from this point onward. The block references
		// the tool by name instead of editing Tools, so earlier turns stay
		// byte-identical and the cache still hits.
		{
			Role: anthropic.BetaMessageParamRoleSystem,
			Content: []anthropic.BetaContentBlockParamUnion{
				anthropic.NewBetaToolRemovalBlock(anthropic.BetaToolChangeToolReferenceParam{
					Name: "get_weather",
				}),
			},
		},
	},
})
if err != nil {
	log.Fatal(err)
}

for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.BetaRequestToolRemovalBlock;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.MessageCreateParams;
// ...
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    // The full tool set is declared up front and never changes, so the
    // cached prefix stays intact.
    BetaTool weatherTool = BetaTool.builder()
        .name("get_weather")
        .description("Get the current weather for a location.")
        .inputSchema(BetaTool.InputSchema.builder()
            .properties(BetaTool.InputSchema.Properties.builder()
                .putAdditionalProperty("location", JsonValue.from(Map.of(
                    "type", "string",
                    "description", "City name")))
                .build())
            .addRequired("location")
            .build())
        .build();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addBeta("mid-conversation-tool-changes-2026-07-01")
        .addTool(weatherTool)
        .addUserMessage("Say OK.")
        // Withdraw get_weather from this point onward. The block references
        // the tool by name instead of editing `tools`, so earlier turns stay
        // byte-identical and the cache still hits.
        .addMessage(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.SYSTEM)
            .contentOfBetaContentBlockParams(List.of(
                BetaContentBlockParam.ofToolRemoval(BetaRequestToolRemovalBlock.builder()
                    .referenceTool("get_weather")
                    .build())))
            .build())
        .build();

    BetaMessage response = client.beta().messages().create(params);
    response.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));

$client = new Client();

$response = $client->beta->messages->create(
    model: 'claude-opus-5-5',
    maxTokens: 1024,
    betas: ['mid-conversation-tool-changes-2026-07-01'],
    // The full tool set is declared up front and never changes, so the
    // cached prefix stays intact.
    tools: [
        [
            'name' => 'get_weather',
            'description' => 'Get the current weather for a location.',
            'input_schema' => [
                'type' => 'object',
                'properties' => [
                    'location' => [
                        'type' => 'string',
                        'description' => 'City name',
                    ],
                ],
                'required' => ['location'],
            ],
        ],
    ],
    messages: [
        ['role' => 'user', 'content' => 'Say OK.'],
        // Withdraw get_weather from this point onward. The block references
        // the tool by name instead of editing `tools`, so earlier turns stay
        // byte-identical and the cache still hits.
        [
            'role' => 'system',
            'content' => [
                [
                    'type' => 'tool_removal',
                    'tool' => ['type' => 'tool_reference', 'name' => 'get_weather'],
                ],
            ],
        ],
    ],
);

foreach ($response->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  betas: ["mid-conversation-tool-changes-2026-07-01"],
  # The full tool set is declared up front and never changes, so the
  # cached prefix stays intact.
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location.",
      input_schema: {
        type: "object",
        properties: {
          location: { type: "string", description: "City name" }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    { role: "user", content: "Say OK." },
    # Withdraw get_weather from this point onward. The block references
    # the tool by name instead of editing `tools`, so earlier turns stay
    # byte-identical and the cache still hits.
    {
      role: "system",
      content: [
        {
          type: "tool_removal",
          tool: { type: "tool_reference", name: "get_weather" }
        }
      ]
    }
  ]
)

response.content.each do |block|
  puts block.text if block.type == :text
end

ant beta:messages create --beta inline-tools-2026-09-15 <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
# Keep at least one non-deferred tool in `tools`, so a tool defined
# later doesn't change the start of the rendered prompt.
tools:
  - name: get_weather
    description: Get the current weather for a location.
    input_schema:
      type: object
      properties:
        location:
          type: string
          description: City name
      required:
        - location
messages:
  - role: user
    content: How many orders shipped yesterday?
  # Define db_query by value from this point onward. `tools` and the
  # earlier messages stay exactly as sent, so the cache still hits.
  - role: system
    content:
      - type: tool_addition
        tool:
          type: tool_definition
          definition:
            name: db_query
            description: Run a read-only SQL query against the analytics database.
            input_schema:
              type: object
              properties:
                sql:
                  type: string
              required:
                - sql
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    betas=["inline-tools-2026-09-15"],
    # Keep at least one non-deferred tool in `tools`, so a tool defined
    # later doesn't change the start of the rendered prompt.
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather for a location.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                },
                "required": ["location"],
            },
        },
    ],
    messages=[
        {"role": "user", "content": "How many orders shipped yesterday?"},
        # Define db_query by value from this point onward. `tools` and the
        # earlier messages stay exactly as sent, so the cache still hits.
        {
            "role": "system",
            "content": [
                {
                    "type": "tool_addition",
                    "tool": {
                        "type": "tool_definition",
                        "definition": {
                            "name": "db_query",
                            "description": "Run a read-only SQL query against the analytics database.",
                            "input_schema": {
                                "type": "object",
                                "properties": {"sql": {"type": "string"}},
                                "required": ["sql"],
                            },
                        },
                    },
                },
            ],
        },
    ],
)

for block in response.content:
    if block.type == "tool_use":
        print(block.name, block.input)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  betas: ["inline-tools-2026-09-15"],
  // Keep at least one non-deferred tool in `tools`, so a tool defined
  // later doesn't change the start of the rendered prompt.
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location.",
      input_schema: {
        type: "object",
        properties: {
          location: { type: "string", description: "City name" }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    { role: "user", content: "How many orders shipped yesterday?" },
    // Define db_query by value from this point onward. `tools` and the
    // earlier messages stay exactly as sent, so the cache still hits.
    {
      role: "system",
      content: [
        {
          type: "tool_addition",
          tool: {
            type: "tool_definition",
            definition: {
              name: "db_query",
              description: "Run a read-only SQL query against the analytics database.",
              input_schema: {
                type: "object",
                properties: { sql: { type: "string" } },
                required: ["sql"]
              }
            }
          }
        }
      ]
    }
  ]
});

for (const block of response.content) {
  if (block.type === "tool_use") {
    console.log(block.name, JSON.stringify(block.input));
  }
}

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Betas = [AnthropicBeta.InlineTools2026_09_15],
    // Keep at least one non-deferred tool in `Tools`, so a tool defined
    // later doesn't change the start of the rendered prompt.
    Tools =
    [
        new BetaTool
        {
            Name = "get_weather",
            Description = "Get the current weather for a location.",
            InputSchema = new InputSchema
            {
                Properties = new Dictionary<string, JsonElement>
                {
                    ["location"] = JsonSerializer.SerializeToElement(new { type = "string", description = "City name" }),
                },
                Required = ["location"],
            },
        },
    ],
    Messages =
    [
        new() { Role = Role.User, Content = "How many orders shipped yesterday?" },
        // Define db_query by value from this point onward. `Tools` and the
        // earlier messages stay exactly as sent, so the cache still hits.
        new()
        {
            Role = Role.System,
            Content = new(
            [
                new BetaRequestToolAdditionBlock
                {
                    Tool = new BetaToolChangeToolDefinitionParam
                    {
                        Definition = new BetaTool
                        {
                            Name = "db_query",
                            Description = "Run a read-only SQL query against the analytics database.",
                            InputSchema = new InputSchema
                            {
                                Properties = new Dictionary<string, JsonElement>
                                {
                                    ["sql"] = JsonSerializer.SerializeToElement(new { type = "string" }),
                                },
                                Required = ["sql"],
                            },
                        },
                    },
                },
            ]),
        },
    ],
});

foreach (var block in response.Content)
{
    if (block.TryPickToolUse(out var toolUse))
    {
        Console.WriteLine($"{toolUse.Name} {JsonSerializer.Serialize(toolUse.Input)}");
    }
}

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Betas:     []anthropic.AnthropicBeta{anthropic.AnthropicBetaInlineTools2026_09_15},
	// Keep at least one non-deferred tool in Tools, so a tool defined
	// later doesn't change the start of the rendered prompt.
	Tools: []anthropic.BetaToolUnionParam{
		{OfTool: &anthropic.BetaToolParam{
			Name:        "get_weather",
			Description: anthropic.String("Get the current weather for a location."),
			InputSchema: anthropic.BetaToolInputSchemaParam{
				Properties: map[string]any{
					"location": map[string]any{
						"type":        "string",
						"description": "City name",
					},
				},
				Required: []string{"location"},
			},
		}},
	},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("How many orders shipped yesterday?")),
		// Define db_query by value from this point onward. Tools and the
		// earlier messages stay exactly as sent, so the cache still hits.
		{
			Role: anthropic.BetaMessageParamRoleSystem,
			Content: []anthropic.BetaContentBlockParamUnion{
				anthropic.NewBetaToolAdditionBlock(anthropic.BetaToolChangeToolDefinitionParam{
					Definition: anthropic.BetaToolUnionParam{OfTool: &anthropic.BetaToolParam{
						Name:        "db_query",
						Description: anthropic.String("Run a read-only SQL query against the analytics database."),
						InputSchema: anthropic.BetaToolInputSchemaParam{
							Properties: map[string]any{
								"sql": map[string]any{"type": "string"},
							},
							Required: []string{"sql"},
						},
					}},
				}),
			},
		},
	},
})
if err != nil {
	log.Fatal(err)
}

for _, block := range response.Content {
	if toolUse, ok := block.AsAny().(anthropic.BetaToolUseBlock); ok {
		fmt.Println(toolUse.Name, toolUse.Input)
	}
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaRequestToolAdditionBlock;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.MessageCreateParams;
// ...

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    BetaTool weatherTool = BetaTool.builder()
        .name("get_weather")
        .description("Get the current weather for a location.")
        .inputSchema(BetaTool.InputSchema.builder()
            .properties(BetaTool.InputSchema.Properties.builder()
                .putAdditionalProperty("location", JsonValue.from(Map.of(
                    "type", "string",
                    "description", "City name")))
                .build())
            .addRequired("location")
            .build())
        .build();

    BetaTool dbQueryTool = BetaTool.builder()
        .name("db_query")
        .description("Run a read-only SQL query against the analytics database.")
        .inputSchema(BetaTool.InputSchema.builder()
            .properties(BetaTool.InputSchema.Properties.builder()
                .putAdditionalProperty("sql", JsonValue.from(Map.of("type", "string")))
                .build())
            .addRequired("sql")
            .build())
        .build();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addBeta(AnthropicBeta.INLINE_TOOLS_2026_09_15)
        // Keep at least one non-deferred tool in `tools`, so a tool defined
        // later doesn't change the start of the rendered prompt.
        .addTool(weatherTool)
        .addUserMessage("How many orders shipped yesterday?")
        // Define db_query by value from this point onward. `tools` and the
        // earlier messages stay exactly as sent, so the cache still hits.
        .addSystemMessageOfBetaContentBlockParams(List.of(
            BetaContentBlockParam.ofToolAddition(BetaRequestToolAdditionBlock.builder()
                .definitionTool(dbQueryTool)
                .build())))
        .build();

    BetaMessage response = client.beta().messages().create(params);
    response.content().stream()
        .flatMap(block -> block.toolUse().stream())
        .forEach(toolUse -> IO.println(toolUse.name() + " " + toolUse._input()));
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaToolUseBlock;
// ...

$client = new Client();

$response = $client->beta->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    maxTokens: 1024,
    betas: [AnthropicBeta::INLINE_TOOLS_2026_09_15],
    // Keep at least one non-deferred tool in `tools`, so a tool defined
    // later doesn't change the start of the rendered prompt.
    tools: [
        [
            'name' => 'get_weather',
            'description' => 'Get the current weather for a location.',
            'input_schema' => [
                'type' => 'object',
                'properties' => [
                    'location' => [
                        'type' => 'string',
                        'description' => 'City name',
                    ],
                ],
                'required' => ['location'],
            ],
        ],
    ],
    messages: [
        ['role' => 'user', 'content' => 'How many orders shipped yesterday?'],
        // Define db_query by value from this point onward. `tools` and the
        // earlier messages stay exactly as sent, so the cache still hits.
        [
            'role' => 'system',
            'content' => [
                [
                    'type' => 'tool_addition',
                    'tool' => [
                        'type' => 'tool_definition',
                        'definition' => [
                            'name' => 'db_query',
                            'description' => 'Run a read-only SQL query against the analytics database.',
                            'input_schema' => [
                                'type' => 'object',
                                'properties' => ['sql' => ['type' => 'string']],
                                'required' => ['sql'],
                            ],
                        ],
                    ],
                ],
            ],
        ],
    ],
);

foreach ($response->content as $block) {
    if ($block instanceof BetaToolUseBlock) {
        echo $block->name, ' ', json_encode($block->input), PHP_EOL;
    }
}

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  betas: [Anthropic::AnthropicBeta::INLINE_TOOLS_2026_09_15],
  # Keep at least one non-deferred tool in `tools`, so a tool defined
  # later doesn't change the start of the rendered prompt.
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location.",
      input_schema: {
        type: "object",
        properties: {
          location: { type: "string", description: "City name" }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    { role: "user", content: "How many orders shipped yesterday?" },
    # Define db_query by value from this point onward. `tools` and the
    # earlier messages stay exactly as sent, so the cache still hits.
    {
      role: "system",
      content: [
        {
          type: "tool_addition",
          tool: {
            type: "tool_definition",
            definition: {
              name: "db_query",
              description: "Run a read-only SQL query against the analytics database.",
              input_schema: {
                type: "object",
                properties: { sql: { type: "string" } },
                required: ["sql"]
              }
            }
          }
        }
      ]
    }
  ]
)

response.content.each do |block|
  puts "#{block.name} #{block.input}" if block.is_a?(Anthropic::Beta::BetaToolUseBlock)
end

ant beta:messages create \
  --beta inline-tools-2026-09-15,mcp-client-2026-09-15 <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
mcp_servers:
  - type: url
    url: https://mcp.example.com/calendar
    name: calendar
    authorization_token: YOUR_TOKEN
tools:
  - name: get_weather
    description: Get the current weather for a location.
    input_schema:
      type: object
      properties:
        location:
          type: string
          description: City name
      required:
        - location
messages:
  - role: user
    content: What's on my calendar tomorrow?
  # Make the calendar server's tools available from this point onward.
  # The block names the server; it never holds a URL or token.
  - role: system
    content:
      - type: tool_addition
        tool:
          type: tool_definition
          definition:
            type: mcp_toolset
            mcp_server_name: calendar
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    betas=["inline-tools-2026-09-15", "mcp-client-2026-09-15"],
    mcp_servers=[
        {
            "type": "url",
            "url": "https://mcp.example.com/calendar",
            "name": "calendar",
            "authorization_token": "YOUR_TOKEN",
        },
    ],
    tools=[
        {
            "name": "get_weather",
            "description": "Get the current weather for a location.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"},
                },
                "required": ["location"],
            },
        },
    ],
    messages=[
        {"role": "user", "content": "What's on my calendar tomorrow?"},
        # Make the calendar server's tools available from this point onward.
        # The block names the server; it never holds a URL or token.
        {
            "role": "system",
            "content": [
                {
                    "type": "tool_addition",
                    "tool": {
                        "type": "tool_definition",
                        "definition": {
                            "type": "mcp_toolset",
                            "mcp_server_name": "calendar",
                        },
                    },
                },
            ],
        },
    ],
)

# The response starts with an mcp_tool_listing block for the calendar server,
# so check each block's type instead of reading content[0].
for block in response.content:
    match block.type:
        case "mcp_tool_listing":
            print(block.mcp_server_name, [tool.name for tool in block.tools])
        case "text":
            print(block.text)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  betas: ["inline-tools-2026-09-15", "mcp-client-2026-09-15"],
  mcp_servers: [
    {
      type: "url",
      url: "https://mcp.example.com/calendar",
      name: "calendar",
      authorization_token: "YOUR_TOKEN"
    }
  ],
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location.",
      input_schema: {
        type: "object",
        properties: {
          location: { type: "string", description: "City name" }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    { role: "user", content: "What's on my calendar tomorrow?" },
    // Make the calendar server's tools available from this point onward.
    // The block names the server; it never holds a URL or token.
    {
      role: "system",
      content: [
        {
          type: "tool_addition",
          tool: {
            type: "tool_definition",
            definition: { type: "mcp_toolset", mcp_server_name: "calendar" }
          }
        }
      ]
    }
  ]
});

// The response starts with an mcp_tool_listing block for the calendar server,
// so check each block's type instead of reading content[0].
for (const block of response.content) {
  switch (block.type) {
    case "mcp_tool_listing":
      console.log(
        block.mcp_server_name,
        block.tools.map((tool) => tool.name)
      );
      break;
    case "text":
      console.log(block.text);
      break;
  }
}

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;
using Messages = Anthropic.Models.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = Messages::Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Betas = [AnthropicBeta.InlineTools2026_09_15, AnthropicBeta.McpClient2026_09_15],
    McpServers =
    [
        new BetaRequestMcpServerUrlDefinition
        {
            Url = "https://mcp.example.com/calendar",
            Name = "calendar",
            AuthorizationToken = "YOUR_TOKEN",
        },
    ],
    Tools =
    [
        new BetaTool
        {
            Name = "get_weather",
            Description = "Get the current weather for a location.",
            InputSchema = new InputSchema
            {
                Properties = new Dictionary<string, JsonElement>
                {
                    ["location"] = JsonSerializer.SerializeToElement(new { type = "string", description = "City name" }),
                },
                Required = ["location"],
            },
        },
    ],
    Messages =
    [
        new() { Role = Role.User, Content = "What's on my calendar tomorrow?" },
        // Make the calendar server's tools available from this point onward.
        // The block names the server; it never holds a URL or token.
        new()
        {
            Role = Role.System,
            Content = new(
            [
                new BetaRequestToolAdditionBlock
                {
                    Tool = new BetaToolChangeToolDefinitionParam
                    {
                        Definition = new BetaMcpToolset("calendar"),
                    },
                },
            ]),
        },
    ],
});

// The response starts with an mcp_tool_listing block for the calendar server,
// so check each block's type instead of reading Content[0].
foreach (var block in response.Content)
{
    if (block.TryPickMcpToolListing(out var listing))
    {
        Console.WriteLine($"{listing.McpServerName} {JsonSerializer.Serialize(listing.Tools.Select(tool => tool.Name))}");
    }
    else if (block.TryPickText(out var text))
    {
        Console.WriteLine(text.Text);
    }
}

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.TODO(), anthropic.BetaMessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Betas: []anthropic.AnthropicBeta{
		anthropic.AnthropicBetaInlineTools2026_09_15,
		anthropic.AnthropicBetaMCPClient2026_09_15,
	},
	MCPServers: []anthropic.BetaRequestMCPServerURLDefinitionParam{
		{
			URL:                "https://mcp.example.com/calendar",
			Name:               "calendar",
			AuthorizationToken: anthropic.String("YOUR_TOKEN"),
		},
	},
	Tools: []anthropic.BetaToolUnionParam{
		{OfTool: &anthropic.BetaToolParam{
			Name:        "get_weather",
			Description: anthropic.String("Get the current weather for a location."),
			InputSchema: anthropic.BetaToolInputSchemaParam{
				Properties: map[string]any{
					"location": map[string]any{
						"type":        "string",
						"description": "City name",
					},
				},
				Required: []string{"location"},
			},
		}},
	},
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("What's on my calendar tomorrow?")),
		// Make the calendar server's tools available from this point onward.
		// The block names the server; it never holds a URL or token.
		{
			Role: anthropic.BetaMessageParamRoleSystem,
			Content: []anthropic.BetaContentBlockParamUnion{
				anthropic.NewBetaToolAdditionBlock(anthropic.BetaToolChangeToolDefinitionParam{
					Definition: anthropic.BetaToolUnionParam{OfMCPToolset: &anthropic.BetaMCPToolsetParam{
						MCPServerName: "calendar",
					}},
				}),
			},
		},
	},
})
if err != nil {
	log.Fatal(err)
}

// The response starts with an mcp_tool_listing block for the calendar server,
// so check each block's type instead of reading Content[0].
for _, block := range response.Content {
	switch variant := block.AsAny().(type) {
	case anthropic.BetaMCPToolListingBlock:
		var toolNames []string
		for _, tool := range variant.Tools {
			toolNames = append(toolNames, tool.Name)
		}
		fmt.Println(variant.MCPServerName, toolNames)
	case anthropic.BetaTextBlock:
		fmt.Println(variant.Text)
	}
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaContentBlockParam;
import com.anthropic.models.beta.messages.BetaMcpTool;
import com.anthropic.models.beta.messages.BetaMcpToolset;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaRequestMcpServerUrlDefinition;
import com.anthropic.models.beta.messages.BetaRequestToolAdditionBlock;
import com.anthropic.models.beta.messages.BetaTool;
import com.anthropic.models.beta.messages.MessageCreateParams;
// ...

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    BetaTool weatherTool = BetaTool.builder()
        .name("get_weather")
        .description("Get the current weather for a location.")
        .inputSchema(BetaTool.InputSchema.builder()
            .properties(BetaTool.InputSchema.Properties.builder()
                .putAdditionalProperty("location", JsonValue.from(Map.of(
                    "type", "string",
                    "description", "City name")))
                .build())
            .addRequired("location")
            .build())
        .build();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addBeta(AnthropicBeta.INLINE_TOOLS_2026_09_15)
        .addBeta(AnthropicBeta.MCP_CLIENT_2026_09_15)
        .addMcpServer(BetaRequestMcpServerUrlDefinition.builder()
            .url("https://mcp.example.com/calendar")
            .name("calendar")
            .authorizationToken("YOUR_TOKEN")
            .build())
        .addTool(weatherTool)
        .addUserMessage("What's on my calendar tomorrow?")
        // Make the calendar server's tools available from this point onward.
        // The block names the server; it never holds a URL or token.
        .addSystemMessageOfBetaContentBlockParams(List.of(
            BetaContentBlockParam.ofToolAddition(BetaRequestToolAdditionBlock.builder()
                .definitionTool(BetaMcpToolset.builder()
                    .mcpServerName("calendar")
                    .build())
                .build())))
        .build();

    BetaMessage response = client.beta().messages().create(params);

    // The response starts with an mcp_tool_listing block for the calendar server,
    // so check each block's type instead of reading the first block.
    for (var block : response.content()) {
        switch (block.type().value()) {
            case MCP_TOOL_LISTING -> {
                var listing = block.asMcpToolListing();
                var toolNames = listing.tools().stream().map(BetaMcpTool::name).toList();
                IO.println(listing.mcpServerName() + " " + toolNames);
            }
            case TEXT -> IO.println(block.asText().text());
        }
    }
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaMCPTool;
use Anthropic\Beta\Messages\BetaMCPToolListingBlock;
use Anthropic\Beta\Messages\BetaTextBlock;
// ...

$client = new Client();

$response = $client->beta->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    maxTokens: 1024,
    betas: [
        AnthropicBeta::INLINE_TOOLS_2026_09_15,
        AnthropicBeta::MCP_CLIENT_2026_09_15,
    ],
    mcpServers: [
        [
            'type' => 'url',
            'url' => 'https://mcp.example.com/calendar',
            'name' => 'calendar',
            'authorization_token' => 'YOUR_TOKEN',
        ],
    ],
    tools: [
        [
            'name' => 'get_weather',
            'description' => 'Get the current weather for a location.',
            'input_schema' => [
                'type' => 'object',
                'properties' => [
                    'location' => [
                        'type' => 'string',
                        'description' => 'City name',
                    ],
                ],
                'required' => ['location'],
            ],
        ],
    ],
    messages: [
        ['role' => 'user', 'content' => "What's on my calendar tomorrow?"],
        // Make the calendar server's tools available from this point onward.
        // The block names the server; it never holds a URL or token.
        [
            'role' => 'system',
            'content' => [
                [
                    'type' => 'tool_addition',
                    'tool' => [
                        'type' => 'tool_definition',
                        'definition' => [
                            'type' => 'mcp_toolset',
                            'mcp_server_name' => 'calendar',
                        ],
                    ],
                ],
            ],
        ],
    ],
);

// The response starts with an mcp_tool_listing block for the calendar server,
// so check each block's type instead of reading content[0].
foreach ($response->content as $block) {
    switch (true) {
        case $block instanceof BetaMCPToolListingBlock:
            $toolNames = array_map(fn (BetaMCPTool $tool) => $tool->name, $block->tools);
            echo $block->mcpServerName, ' ', json_encode($toolNames), PHP_EOL;
            break;
        case $block instanceof BetaTextBlock:
            echo $block->text, PHP_EOL;
            break;
    }
}

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  betas: [
    Anthropic::AnthropicBeta::INLINE_TOOLS_2026_09_15,
    Anthropic::AnthropicBeta::MCP_CLIENT_2026_09_15
  ],
  mcp_servers: [
    {
      type: "url",
      url: "https://mcp.example.com/calendar",
      name: "calendar",
      authorization_token: "YOUR_TOKEN"
    }
  ],
  tools: [
    {
      name: "get_weather",
      description: "Get the current weather for a location.",
      input_schema: {
        type: "object",
        properties: {
          location: { type: "string", description: "City name" }
        },
        required: ["location"]
      }
    }
  ],
  messages: [
    { role: "user", content: "What's on my calendar tomorrow?" },
    # Make the calendar server's tools available from this point onward.
    # The block names the server; it never holds a URL or token.
    {
      role: "system",
      content: [
        {
          type: "tool_addition",
          tool: {
            type: "tool_definition",
            definition: { type: "mcp_toolset", mcp_server_name: "calendar" }
          }
        }
      ]
    }
  ]
)

# The response starts with an mcp_tool_listing block for the calendar server,
# so check each block's type instead of reading content[0].
response.content.each do |block|
  case block
  when Anthropic::Beta::BetaMCPToolListingBlock
    puts "#{block.mcp_server_name} #{block.tools.map(&:name)}"
  when Anthropic::Beta::BetaTextBlock
    puts block.text
  end
end

ant messages create --transform 'content.#(type=="text").text' --raw-output <<'YAML'
model: claude-opus-5-5
max_tokens: 1024
cache_control:
  type: ephemeral
system: You are a code review assistant. Be concise.
messages:
  - role: user
    content: Review process() in utils.py for performance issues.
  - role: assistant
    content: >-
      The list comprehension is fine for small inputs. For large inputs,
      consider a generator to avoid materializing the full list.
  - role: user
    content: Now review the calling code that invokes process().
  - role: system
    content: From now on, every suggestion must include explicit type annotations.
YAML

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    # Automatic prompt caching: each request caches the conversation so far,
    # and the next request reads the unchanged prefix from cache.
    cache_control={"type": "ephemeral"},
    system="You are a code review assistant. Be concise.",
    messages=[
        {
            "role": "user",
            "content": "Review process() in utils.py for performance issues.",
        },
        {
            "role": "assistant",
            "content": "The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list.",
        },
        {
            "role": "user",
            "content": "Now review the calling code that invokes process().",
        },
        # The reviewer realizes mid-session that all suggestions must
        # also pass the team's strict typing policy. Appending the
        # instruction here keeps earlier turns byte-identical, so the
        # prefix cached by the previous request is still read from cache.
        {
            "role": "system",
            "content": "From now on, every suggestion must include explicit type annotations.",
        },
    ],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  // Automatic prompt caching: each request caches the conversation so far,
  // and the next request reads the unchanged prefix from cache.
  cache_control: { type: "ephemeral" },
  system: "You are a code review assistant. Be concise.",
  messages: [
    {
      role: "user",
      content: "Review process() in utils.py for performance issues."
    },
    {
      role: "assistant",
      content:
        "The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list."
    },
    {
      role: "user",
      content: "Now review the calling code that invokes process()."
    },
    // The reviewer realizes mid-session that all suggestions must also pass
    // the team's strict typing policy. Appending the instruction here keeps
    // earlier turns byte-identical, so the prefix cached by the previous
    // request is still read from cache.
    {
      role: "system",
      content: "From now on, every suggestion must include explicit type annotations."
    }
  ]
});

const textBlock = response.content.find(
  (block): block is Anthropic.TextBlock => block.type === "text"
);
console.log(textBlock?.text);

AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    // Automatic prompt caching: each request caches the conversation so far,
    // and the next request reads the unchanged prefix from cache.
    CacheControl = new CacheControlEphemeral(),
    System = "You are a code review assistant. Be concise.",
    Messages =
    [
        new()
        {
            Role = Role.User,
            Content = "Review process() in utils.py for performance issues."
        },
        new()
        {
            Role = Role.Assistant,
            Content = "The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list."
        },
        new()
        {
            Role = Role.User,
            Content = "Now review the calling code that invokes process()."
        },
        // The reviewer realizes mid-session that all suggestions must also pass
        // the team's strict typing policy. Appending the instruction here keeps
        // earlier turns byte-identical, so the prefix cached by the previous
        // request is still read from cache.
        new()
        {
            Role = Role.System,
            Content = "From now on, every suggestion must include explicit type annotations."
        }
    ]
};

var response = await client.Messages.Create(parameters);
Console.WriteLine(response);

client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	// Automatic prompt caching: each request caches the conversation so far,
	// and the next request reads the unchanged prefix from cache.
	CacheControl: anthropic.NewCacheControlEphemeralParam(),
	System: []anthropic.TextBlockParam{
		{Text: "You are a code review assistant. Be concise."},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Review process() in utils.py for performance issues.")),
		anthropic.NewAssistantMessage(anthropic.NewTextBlock("The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list.")),
		anthropic.NewUserMessage(anthropic.NewTextBlock("Now review the calling code that invokes process().")),
		// The reviewer realizes mid-session that all suggestions must also
		// pass the team's strict typing policy. Appending the instruction
		// here keeps earlier turns byte-identical, so the prefix cached by
		// the previous request is still read from cache.
		{
			Role: anthropic.MessageParamRoleSystem,
			Content: []anthropic.ContentBlockParamUnion{
				anthropic.NewTextBlock("From now on, every suggestion must include explicit type annotations."),
			},
		},
	},
})
if err != nil {
	log.Fatal(err)
}
for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

import com.anthropic.models.messages.CacheControlEphemeral;
// ...
import com.anthropic.models.messages.MessageParam;
// ...
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        // Automatic prompt caching: each request caches the conversation so far,
        // and the next request reads the unchanged prefix from cache.
        .cacheControl(CacheControlEphemeral.builder().build())
        .system("You are a code review assistant. Be concise.")
        .addUserMessage("Review process() in utils.py for performance issues.")
        .addAssistantMessage("The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list.")
        .addUserMessage("Now review the calling code that invokes process().")
        // The reviewer realizes mid-session that all suggestions must also pass
        // the team's strict typing policy. Appending the instruction here keeps
        // earlier turns byte-identical, so the prefix cached by the previous
        // request is still read from cache.
        .addMessage(MessageParam.builder()
            .role(MessageParam.Role.SYSTEM)
            .content("From now on, every suggestion must include explicit type annotations.")
            .build())
        .build();

    Message response = client.messages().create(params);
    response.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));

use Anthropic\Messages\CacheControlEphemeral;
// ...
$client = new Client();

$response = $client->messages->create(
    maxTokens: 1024,
    messages: [
        ['role' => 'user', 'content' => 'Review process() in utils.py for performance issues.'],
        ['role' => 'assistant', 'content' => 'The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list.'],
        ['role' => 'user', 'content' => 'Now review the calling code that invokes process().'],
        // The reviewer realizes mid-session that all suggestions must also pass
        // the team's strict typing policy. Appending the instruction here keeps
        // earlier turns byte-identical, so the prefix cached by the previous
        // request is still read from cache.
        ['role' => 'system', 'content' => 'From now on, every suggestion must include explicit type annotations.']
    ],
    model: 'claude-opus-5-5',
    // Automatic prompt caching: each request caches the conversation so far,
    // and the next request reads the unchanged prefix from cache.
    cacheControl: CacheControlEphemeral::with(),
    system: 'You are a code review assistant. Be concise.',
);

foreach ($response->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

client = Anthropic::Client.new

response = client.messages.create(
  model: "claude-opus-5-5",
  max_tokens: 1024,
  # Automatic prompt caching: each request caches the conversation so far,
  # and the next request reads the unchanged prefix from cache.
  cache_control: { type: "ephemeral" },
  system: "You are a code review assistant. Be concise.",
  messages: [
    { role: "user", content: "Review process() in utils.py for performance issues." },
    { role: "assistant", content: "The list comprehension is fine for small inputs. For large inputs, consider a generator to avoid materializing the full list." },
    { role: "user", content: "Now review the calling code that invokes process()." },
    # The reviewer realizes mid-session that all suggestions must also pass
    # the team's strict typing policy. Appending the instruction here keeps
    # earlier turns byte-identical, so the prefix cached by the previous
    # request is still read from cache.
    { role: "system", content: "From now on, every suggestion must include explicit type annotations." }
  ]
)

response.content.each do |block|
  puts block.text if block.type == :text
end

ant beta:messages create --beta mid-conversation-system-clear-at-2026-08-21 \
  --transform 'content.#(type=="text").text' --raw-output <<'YAML'
model: claude-fable-5-1
max_tokens: 4096
messages:
  - role: user
    content: Draft a short status update on the database migration for the team channel.
  # Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
  - role: system
    clear_at: next_user_message
    content: "The reader is on call: keep this reply under 50 words."
YAML

client = anthropic.Anthropic()

response = client.beta.messages.create(
    model="claude-fable-5-1",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Draft a short status update on the database migration for the team channel.",
        },
        # Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
        {
            "role": "system",
            "clear_at": "next_user_message",
            "content": "The reader is on call: keep this reply under 50 words.",
        },
    ],
    betas=["mid-conversation-system-clear-at-2026-08-21"],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

const client = new Anthropic();

const response = await client.beta.messages.create({
  model: "claude-fable-5-1",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Draft a short status update on the database migration for the team channel."
    },
    // Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
    {
      role: "system",
      clear_at: "next_user_message",
      content: "The reader is on call: keep this reply under 50 words."
    }
  ],
  betas: ["mid-conversation-system-clear-at-2026-08-21"]
});

for (const block of response.content) {
  if (block.type === "text") {
    console.log(block.text);
  }
}

using Anthropic.Models.Beta;
using Anthropic.Models.Beta.Messages;

AnthropicClient client = new();

var response = await client.Beta.Messages.Create(new MessageCreateParams
{
    Model = "claude-fable-5-1",
    MaxTokens = 4096,
    Messages =
    [
        new() { Role = Role.User, Content = "Draft a short status update on the database migration for the team channel." },
        // Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
        new()
        {
            Role = Role.System,
            ClearAt = ClearAt.NextUserMessage,
            Content = "The reader is on call: keep this reply under 50 words.",
        },
    ],
    Betas = [AnthropicBeta.MidConversationSystemClearAt2026_08_21],
});

foreach (var block in response.Content)
{
    if (block.TryPickText(out var textBlock))
    {
        Console.WriteLine(textBlock.Text);
    }
}

client := anthropic.NewClient()

response, err := client.Beta.Messages.New(context.Background(), anthropic.BetaMessageNewParams{
	Model:     "claude-fable-5-1",
	MaxTokens: 4096,
	Messages: []anthropic.BetaMessageParam{
		anthropic.NewBetaUserMessage(anthropic.NewBetaTextBlock("Draft a short status update on the database migration for the team channel.")),
		// Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
		{
			Role:    anthropic.BetaMessageParamRoleSystem,
			ClearAt: anthropic.BetaMessageParamClearAtNextUserMessage,
			Content: []anthropic.BetaContentBlockParamUnion{anthropic.NewBetaTextBlock("The reader is on call: keep this reply under 50 words.")},
		},
	},
	Betas: []anthropic.AnthropicBeta{anthropic.AnthropicBetaMidConversationSystemClearAt2026_08_21},
})
if err != nil {
	log.Fatal(err)
}

for _, block := range response.Content {
	if textBlock, ok := block.AsAny().(anthropic.BetaTextBlock); ok {
		fmt.Println(textBlock.Text)
	}
}

import com.anthropic.models.beta.AnthropicBeta;
import com.anthropic.models.beta.messages.BetaMessage;
import com.anthropic.models.beta.messages.BetaMessageParam;
import com.anthropic.models.beta.messages.MessageCreateParams;

void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model("claude-fable-5-1")
        .maxTokens(4096L)
        .addBeta(AnthropicBeta.MID_CONVERSATION_SYSTEM_CLEAR_AT_2026_08_21)
        .addUserMessage("Draft a short status update on the database migration for the team channel.")
        // Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
        .addMessage(BetaMessageParam.builder()
            .role(BetaMessageParam.Role.SYSTEM)
            .clearAt(BetaMessageParam.ClearAt.NEXT_USER_MESSAGE)
            .content("The reader is on call: keep this reply under 50 words.")
            .build())
        .build();

    BetaMessage response = client.beta().messages().create(params);
    response.content().stream()
        .flatMap(block -> block.text().stream())
        .forEach(textBlock -> IO.println(textBlock.text()));
}

use Anthropic\Beta\AnthropicBeta;
use Anthropic\Beta\Messages\BetaMessageParam;
use Anthropic\Client;

$client = new Client();

$response = $client->beta->messages->create(
    model: 'claude-fable-5-1',
    maxTokens: 4096,
    messages: [
        BetaMessageParam::with(role: 'user', content: 'Draft a short status update on the database migration for the team channel.'),
        // Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
        BetaMessageParam::with(
            role: 'system',
            clearAt: 'next_user_message',
            content: 'The reader is on call: keep this reply under 50 words.',
        ),
    ],
    betas: [AnthropicBeta::MID_CONVERSATION_SYSTEM_CLEAR_AT_2026_08_21],
);

foreach ($response->content as $block) {
    if ($block->type === 'text') {
        echo $block->text, PHP_EOL;
    }
}

client = Anthropic::Client.new

response = client.beta.messages.create(
  model: "claude-fable-5-1",
  max_tokens: 4096,
  messages: [
    {role: "user", content: "Draft a short status update on the database migration for the team channel."},
    # Turn-scoped reminder: renders for this turn, then clears once a later user message exists.
    {role: "system", clear_at: :next_user_message, content: "The reader is on call: keep this reply under 50 words."}
  ],
  betas: [Anthropic::AnthropicBeta::MID_CONVERSATION_SYSTEM_CLEAR_AT_2026_08_21]
)

response.content.each do |block|
  puts block.text if block.type == :text
end