세밀한 도구 스트리밍

ant messages create --stream --format jsonl <<'YAML' |
model: claude-opus-5-5
max_tokens: 65536
tools:
  - name: make_file
    description: Write text to a file
    eager_input_streaming: true
    input_schema:
      type: object
      properties:
        filename:
          type: string
          description: The filename to write text to
        lines_of_text:
          type: array
          description: An array of lines of text to write to the file
      required:
        - filename
        - lines_of_text
messages:
  - role: user
    content: Can you write a long poem and make a file called poem.txt?
YAML
  jq -rj 'select(.delta.type == "input_json_delta") | .delta.partial_json'

client = anthropic.Anthropic()

with client.messages.stream(
    max_tokens=65536,
    model="claude-opus-5-5",
    tools=[
        {
            "name": "make_file",
            "description": "Write text to a file",
            "eager_input_streaming": True,
            "input_schema": {
                "type": "object",
                "properties": {
                    "filename": {
                        "type": "string",
                        "description": "The filename to write text to",
                    },
                    "lines_of_text": {
                        "type": "array",
                        "description": "An array of lines of text to write to the file",
                    },
                },
                "required": ["filename", "lines_of_text"],
            },
        }
    ],
    messages=[
        {
            "role": "user",
            "content": "Can you write a long poem and make a file called poem.txt?",
        }
    ],
) as stream:
    for event in stream:
        if event.type == "input_json":
            print(event.partial_json, end="", flush=True)
    final_message = stream.get_final_message()

print()
for block in final_message.content:
    if block.type == "tool_use":
        print(f"Complete tool input: {block.input}")

const client = new Anthropic();

const stream = client.messages.stream({
  model: "claude-opus-5-5",
  max_tokens: 65536,
  tools: [
    {
      name: "make_file",
      description: "Write text to a file",
      eager_input_streaming: true,
      input_schema: {
        type: "object",
        properties: {
          filename: {
            type: "string",
            description: "The filename to write text to"
          },
          lines_of_text: {
            type: "array",
            description: "An array of lines of text to write to the file"
          }
        },
        required: ["filename", "lines_of_text"]
      }
    }
  ],
  messages: [
    {
      role: "user",
      content: "Can you write a long poem and make a file called poem.txt?"
    }
  ]
});

stream.on("inputJson", (partialJson) => {
  process.stdout.write(partialJson);
});

const message = await stream.finalMessage();
console.log();
for (const block of message.content) {
  if (block.type === "tool_use") {
    console.log("Complete tool input:", block.input);
  }
}

AnthropicClient client = new();

MessageCreateParams parameters = new()
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 65536,
    Tools =
    [
        new Tool
        {
            Name = "make_file",
            Description = "Write text to a file",
            EagerInputStreaming = true,
            InputSchema = new InputSchema
            {
                Properties = new Dictionary<string, JsonElement>
                {
                    ["filename"] = JsonSerializer.SerializeToElement(
                        new { type = "string", description = "The filename to write text to" }
                    ),
                    ["lines_of_text"] = JsonSerializer.SerializeToElement(
                        new { type = "array", description = "An array of lines of text to write to the file" }
                    ),
                },
                Required = ["filename", "lines_of_text"],
            },
        },
    ],
    Messages =
    [
        new()
        {
            Role = Role.User,
            Content = "Can you write a long poem and make a file called poem.txt?",
        },
    ],
};

// The C# example assembles the input itself: content block index -> accumulated JSON
var toolInputs = new Dictionary<long, StringBuilder>();

await foreach (var streamEvent in client.Messages.CreateStreaming(parameters))
{
    if (
        streamEvent.TryPickContentBlockStart(out var start)
        && start.ContentBlock.TryPickToolUse(out _)
    )
    {
        toolInputs[start.Index] = new StringBuilder();
    }
    else if (
        streamEvent.TryPickContentBlockDelta(out var delta)
        && delta.Delta.TryPickInputJson(out var inputJson)
    )
    {
        Console.Write(inputJson.PartialJson);
        toolInputs[delta.Index].Append(inputJson.PartialJson);
    }
}

Console.WriteLine();
foreach (var accumulatedInput in toolInputs.Values)
{
    Console.WriteLine($"Complete tool input: {accumulatedInput}");
}

client := anthropic.NewClient()

makeFileTool := anthropic.ToolParam{
	Name:                "make_file",
	Description:         anthropic.String("Write text to a file"),
	EagerInputStreaming: anthropic.Bool(true),
	InputSchema: anthropic.ToolInputSchemaParam{
		Properties: map[string]any{
			"filename": map[string]any{
				"type":        "string",
				"description": "The filename to write text to",
			},
			"lines_of_text": map[string]any{
				"type":        "array",
				"description": "An array of lines of text to write to the file",
			},
		},
		Required: []string{"filename", "lines_of_text"},
	},
}

stream := client.Messages.NewStreaming(context.Background(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 65536,
	Tools:     []anthropic.ToolUnionParam{{OfTool: &makeFileTool}},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock(
			"Can you write a long poem and make a file called poem.txt?",
		)),
	},
})

message := anthropic.Message{}
for stream.Next() {
	event := stream.Current()
	if err := message.Accumulate(event); err != nil {
		panic(err)
	}
	if delta, ok := event.AsAny().(anthropic.ContentBlockDeltaEvent); ok {
		if inputJSON, ok := delta.Delta.AsAny().(anthropic.InputJSONDelta); ok {
			fmt.Print(inputJSON.PartialJSON)
		}
	}
}
if err := stream.Err(); err != nil {
	panic(err)
}

fmt.Println()
for _, block := range message.Content {
	if toolUse, ok := block.AsAny().(anthropic.ToolUseBlock); ok {
		fmt.Printf("Complete tool input: %s\n", toolUse.Input)
	}
}

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

Tool makeFileTool = Tool.builder()
    .name("make_file")
    .description("Write text to a file")
    .eagerInputStreaming(true)
    .inputSchema(Tool.InputSchema.builder()
        .properties(Tool.InputSchema.Properties.builder()
            .putAdditionalProperty("filename", JsonValue.from(Map.of(
                "type", "string",
                "description", "The filename to write text to")))
            .putAdditionalProperty("lines_of_text", JsonValue.from(Map.of(
                "type", "array",
                "description", "An array of lines of text to write to the file")))
            .build())
        .addRequired("filename")
        .addRequired("lines_of_text")
        .build())
    .build();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(65536L)
    .addTool(makeFileTool)
    .addUserMessage("Can you write a long poem and make a file called poem.txt?")
    .build();

MessageAccumulator accumulator = MessageAccumulator.create();

try (StreamResponse<RawMessageStreamEvent> streamResponse =
        client.messages().createStreaming(params)) {
    streamResponse.stream().forEach(event -> {
        accumulator.accumulate(event);
        if (event.isContentBlockDelta()) {
            var delta = event.asContentBlockDelta().delta();
            if (delta.isInputJson()) {
                IO.print(delta.asInputJson().partialJson());
            }
        }
    });
}

IO.println("");
accumulator.message().content().forEach(block ->
    block.toolUse().ifPresent(toolUse ->
        IO.println("Complete tool input: " + toolUse._input())));

use Anthropic\Client;
use Anthropic\Messages\InputJSONDelta;
use Anthropic\Messages\Model;
use Anthropic\Messages\RawContentBlockDeltaEvent;
use Anthropic\Messages\RawContentBlockStartEvent;
use Anthropic\Messages\ToolUseBlock;

$client = new Client();

$stream = $client->messages->createStream(
    maxTokens: 65536,
    model: Model::CLAUDE_OPUS_5_5,
    tools: [
        [
            'name' => 'make_file',
            'description' => 'Write text to a file',
            'eager_input_streaming' => true,
            'input_schema' => [
                'type' => 'object',
                'properties' => [
                    'filename' => [
                        'type' => 'string',
                        'description' => 'The filename to write text to',
                    ],
                    'lines_of_text' => [
                        'type' => 'array',
                        'description' => 'An array of lines of text to write to the file',
                    ],
                ],
                'required' => ['filename', 'lines_of_text'],
            ],
        },
    ],
    messages: [
        [
            'role' => 'user',
            'content' => 'Can you write a long poem and make a file called poem.txt?',
        ],
    ],
);

// The PHP example assembles the input itself: index => accumulated JSON string
$toolInputs = [];

foreach ($stream as $event) {
    switch (true) {
        case $event instanceof RawContentBlockStartEvent:
            if ($event->contentBlock instanceof ToolUseBlock) {
                $toolInputs[$event->index] = '';
            }
            break;
        case $event instanceof RawContentBlockDeltaEvent:
            if ($event->delta instanceof InputJSONDelta) {
                echo $event->delta->partialJSON;
                $toolInputs[$event->index] .= $event->delta->partialJSON;
            }
            break;
    }
}

echo "\n";
foreach ($toolInputs as $toolInput) {
    echo "Complete tool input: {$toolInput}\n";
}

client = Anthropic::Client.new

stream = client.messages.stream(
  model: Anthropic::Models::Model::CLAUDE_OPUS_5_5,
  max_tokens: 65_536,
  tools: [
    {
      name: "make_file",
      description: "Write text to a file",
      eager_input_streaming: true,
      input_schema: {
        type: "object",
        properties: {
          filename: {
            type: "string",
            description: "The filename to write text to"
          },
          lines_of_text: {
            type: "array",
            description: "An array of lines of text to write to the file"
          }
        },
        required: ["filename", "lines_of_text"]
      }
    }
  ],
  messages: [
    {
      role: "user",
      content: "Can you write a long poem and make a file called poem.txt?"
    }
  ]
)

stream.each do |event|
  print event.partial_json if event.is_a?(Anthropic::Streaming::InputJsonEvent)
end

puts
stream.accumulated_message.content.each do |block|
  puts "Complete tool input: #{block.input}" if block.type == :tool_use
end

# Accumulating per-block input deltas needs a programming language; the first
# example's CLI tab shows the raw fragments with jq. See the SDK tabs.

client = anthropic.Anthropic()

tool_inputs: dict[int, str] = {}  # index -> accumulated JSON string

with client.messages.stream(
    model="claude-opus-5-5",
    max_tokens=1024,
    tools=[
        {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "eager_input_streaming": True,
            "input_schema": {
                "type": "object",
                "properties": {"city": {"type": "string"}},
                "required": ["city"],
            },
        }
    ],
    messages=[{"role": "user", "content": "Weather in Paris?"}],
) as stream:
    for event in stream:
        match event.type:
            case "content_block_start" if event.content_block.type == "tool_use":
                tool_inputs[event.index] = ""
            case "content_block_delta" if event.delta.type == "input_json_delta":
                tool_inputs[event.index] += event.delta.partial_json
            case "content_block_stop" if event.index in tool_inputs:
                raw_input = tool_inputs[event.index]
                try:
                    parsed = json.loads(raw_input)
                except json.JSONDecodeError:
                    # The accumulated string is not guaranteed to be valid JSON.
                    # See "Handling invalid JSON in tool responses" on this page.
                    print(f"Invalid tool input: {raw_input}")
                else:
                    print(f"Tool input: {parsed}")

const client = new Anthropic();

const toolInputs = new Map<number, string>();

const stream = client.messages.stream({
  model: "claude-opus-5-5",
  max_tokens: 1024,
  tools: [
    {
      name: "get_weather",
      description: "Get current weather for a city",
      eager_input_streaming: true,
      input_schema: {
        type: "object",
        properties: { city: { type: "string" } },
        required: ["city"]
      }
    }
  ],
  messages: [{ role: "user", content: "Weather in Paris?" }]
});

for await (const event of stream) {
  switch (event.type) {
    case "content_block_start":
      if (event.content_block.type === "tool_use") {
        toolInputs.set(event.index, "");
      }
      break;
    case "content_block_delta":
      if (event.delta.type === "input_json_delta") {
        toolInputs.set(
          event.index,
          (toolInputs.get(event.index) ?? "") + event.delta.partial_json
        );
      }
      break;
    case "content_block_stop":
      if (toolInputs.has(event.index)) {
        const rawInput = toolInputs.get(event.index)!;
        try {
          console.log("Tool input:", JSON.parse(rawInput));
        } catch {
          // The accumulated string is not guaranteed to be valid JSON.
          // See "Handling invalid JSON in tool responses" on this page.
          console.log("Invalid tool input:", rawInput);
        }
      }
      break;
  }
}

AnthropicClient client = new();

MessageCreateParams parameters = new()
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 1024,
    Tools =
    [
        new Tool
        {
            Name = "get_weather",
            Description = "Get current weather for a city",
            EagerInputStreaming = true,
            InputSchema = new InputSchema
            {
                Properties = new Dictionary<string, JsonElement>
                {
                    ["city"] = JsonSerializer.SerializeToElement(new { type = "string" }),
                },
                Required = ["city"],
            },
        },
    ],
    Messages = [new() { Role = Role.User, Content = "Weather in Paris?" }],
};

// Block index -> accumulated JSON fragments
// This example accumulates the deltas manually to show the raw stream;
// the SDK's MessageContentAggregator can also accumulate tool input automatically.
var toolInputs = new Dictionary<long, StringBuilder>();

await foreach (var streamEvent in client.Messages.CreateStreaming(parameters))
{
    if (
        streamEvent.TryPickContentBlockStart(out var start)
        && start.ContentBlock.TryPickToolUse(out _)
    )
    {
        toolInputs[start.Index] = new StringBuilder();
    }
    else if (
        streamEvent.TryPickContentBlockDelta(out var delta)
        && delta.Delta.TryPickInputJson(out var inputJson)
    )
    {
        toolInputs[delta.Index].Append(inputJson.PartialJson);
    }
    else if (
        streamEvent.TryPickContentBlockStop(out var stop)
        && toolInputs.TryGetValue(stop.Index, out var accumulated)
    )
    {
        try
        {
            using var parsed = JsonDocument.Parse(accumulated.ToString());
            Console.WriteLine($"Tool input: {parsed.RootElement}");
        }
        catch (JsonException)
        {
            // The accumulated string is not guaranteed to be valid JSON.
            // See "Handling invalid JSON in tool responses" on this page.
            Console.WriteLine($"Invalid tool input: {accumulated}");
        }
    }
}

client := anthropic.NewClient()

toolInputs := map[int64]string{} // content block index -> accumulated JSON

stream := client.Messages.NewStreaming(context.Background(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 1024,
	Tools: []anthropic.ToolUnionParam{{
		OfTool: &anthropic.ToolParam{
			Name:                "get_weather",
			Description:         anthropic.String("Get current weather for a city"),
			EagerInputStreaming: anthropic.Bool(true),
			InputSchema: anthropic.ToolInputSchemaParam{
				Properties: map[string]any{
					"city": map[string]any{"type": "string"},
				},
				Required: []string{"city"},
			},
		},
	}},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Weather in Paris?")),
	},
})

for stream.Next() {
	switch event := stream.Current().AsAny().(type) {
	case anthropic.ContentBlockStartEvent:
		if _, ok := event.ContentBlock.AsAny().(anthropic.ToolUseBlock); ok {
			toolInputs[event.Index] = ""
		}
	case anthropic.ContentBlockDeltaEvent:
		if delta, ok := event.Delta.AsAny().(anthropic.InputJSONDelta); ok {
			toolInputs[event.Index] += delta.PartialJSON
		}
	case anthropic.ContentBlockStopEvent:
		if accumulated, ok := toolInputs[event.Index]; ok {
			var parsed map[string]any
			if err := json.Unmarshal([]byte(accumulated), &parsed); err != nil {
				// The accumulated string is not guaranteed to be valid JSON.
				// See "Handling invalid JSON in tool responses" on this page.
				fmt.Println("Invalid tool input:", accumulated)
			} else {
				fmt.Println("Tool input:", parsed)
			}
		}
	}
}
if err := stream.Err(); err != nil {
	panic(err)
}

AnthropicClient client = AnthropicOkHttpClient.fromEnv();
ObjectMapper objectMapper = new ObjectMapper();

Tool weatherTool = Tool.builder()
        .name("get_weather")
        .description("Get current weather for a city")
        .eagerInputStreaming(true)
        .inputSchema(Tool.InputSchema.builder()
                .properties(Tool.InputSchema.Properties.builder()
                        .putAdditionalProperty("city", JsonValue.from(Map.of("type", "string")))
                        .build())
                .addRequired("city")
                .build())
        .build();

MessageCreateParams createParams = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(1024)
        .addTool(weatherTool)
        .addUserMessage("Weather in Paris?")
        .build();

// Content block index -> accumulated tool input JSON
Map<Long, StringBuilder> toolInputs = new HashMap<>();

try (StreamResponse<RawMessageStreamEvent> streamResponse = client.messages().createStreaming(createParams)) {
    var eventIterator = streamResponse.stream().iterator();
    while (eventIterator.hasNext()) {
        RawMessageStreamEvent event = eventIterator.next();
        switch (event.type().value()) {
            case CONTENT_BLOCK_START -> {
                var blockStart = event.asContentBlockStart();
                if (blockStart.contentBlock().isToolUse()) {
                    toolInputs.put(blockStart.index(), new StringBuilder());
                }
            }
            case CONTENT_BLOCK_DELTA -> {
                var blockDelta = event.asContentBlockDelta();
                if (blockDelta.delta().isInputJson() && toolInputs.containsKey(blockDelta.index())) {
                    toolInputs.get(blockDelta.index()).append(blockDelta.delta().asInputJson().partialJson());
                }
            }
            case CONTENT_BLOCK_STOP -> {
                var blockStop = event.asContentBlockStop();
                if (toolInputs.containsKey(blockStop.index())) {
                    String accumulated = toolInputs.get(blockStop.index()).toString();
                    try {
                        IO.println("Tool input: " + objectMapper.readTree(accumulated));
                    } catch (JsonProcessingException e) {
                        // The accumulated string is not guaranteed to be valid JSON.
                        // See "Handling invalid JSON in tool responses" on this page.
                        IO.println("Invalid tool input: " + accumulated);
                    }
                }
            }
        }
    }
}

use Anthropic\Client;
use Anthropic\Messages\InputJSONDelta;
use Anthropic\Messages\Model;
use Anthropic\Messages\RawContentBlockDeltaEvent;
use Anthropic\Messages\RawContentBlockStartEvent;
use Anthropic\Messages\RawContentBlockStopEvent;
use Anthropic\Messages\ToolUseBlock;

$client = new Client();

// The PHP SDK does not provide a stream accumulator for tool input;
// the manual pattern shown here is the supported approach.
$toolInputs = []; // index => accumulated JSON string

$stream = $client->messages->createStream(
    maxTokens: 1024,
    model: Model::CLAUDE_OPUS_5_5,
    tools: [
        [
            'name' => 'get_weather',
            'description' => 'Get current weather for a city',
            'eager_input_streaming' => true,
            'input_schema' => [
                'type' => 'object',
                'properties' => ['city' => ['type' => 'string']],
                'required' => ['city'],
            ],
        ],
    ],
    messages: [['role' => 'user', 'content' => 'Weather in Paris?']],
);

foreach ($stream as $event) {
    switch (true) {
        case $event instanceof RawContentBlockStartEvent:
            if ($event->contentBlock instanceof ToolUseBlock) {
                $toolInputs[$event->index] = '';
            }
            break;
        case $event instanceof RawContentBlockDeltaEvent:
            if ($event->delta instanceof InputJSONDelta) {
                $toolInputs[$event->index] .= $event->delta->partialJSON;
            }
            break;
        case $event instanceof RawContentBlockStopEvent:
            if (isset($toolInputs[$event->index])) {
                $accumulated = $toolInputs[$event->index];
                try {
                    $parsed = json_decode($accumulated, associative: true, flags: JSON_THROW_ON_ERROR);
                    echo "Tool input: " . json_encode($parsed) . "\n";
                } catch (JsonException $e) {
                    // The accumulated string is not guaranteed to be valid JSON.
                    // See "Handling invalid JSON in tool responses" on this page.
                    echo "Invalid tool input: {$accumulated}\n";
                }
            }
            break;
    }
}

client = Anthropic::Client.new

tool_inputs = {} # index -> accumulated JSON string

stream = client.messages.stream_raw(
  model: Anthropic::Models::Model::CLAUDE_OPUS_5_5,
  max_tokens: 1024,
  tools: [
    {
      name: "get_weather",
      description: "Get current weather for a city",
      eager_input_streaming: true,
      input_schema: {
        type: "object",
        properties: {city: {type: "string"}},
        required: ["city"]
      }
    }
  ],
  messages: [{role: "user", content: "Weather in Paris?"}]
)

stream.each do |event|
  case event
  when Anthropic::Models::RawContentBlockStartEvent
    tool_inputs[event.index] = +"" if event.content_block.type == :tool_use
  when Anthropic::Models::RawContentBlockDeltaEvent
    if event.delta.is_a?(Anthropic::Models::InputJSONDelta)
      tool_inputs[event.index] << event.delta.partial_json
    end
  when Anthropic::Models::RawContentBlockStopEvent
    if tool_inputs.key?(event.index)
      accumulated = tool_inputs[event.index]
      begin
        parsed = JSON.parse(accumulated)
        puts "Tool input: #{parsed}"
      rescue JSON::ParserError
        # The accumulated string is not guaranteed to be valid JSON.
        # See "Handling invalid JSON in tool responses" on this page.
        puts "Invalid tool input: #{accumulated}"
      end
    end
  end
end