서버 도구

# If "stop_reason" is "tool_use" and a server_tool_use block has no matching
# result block, run the client tools and re-run with a user message of only
# their tool_result blocks appended (see the SDK tabs).
ant messages create <<'YAML'
model: claude-opus-4-8
max_tokens: 1024
messages:
  - role: user
    content: "Summarize https://example.com/article and run uname -a to tell me what system this is on."
tools:
  - {type: web_fetch_20250910, name: web_fetch, max_uses: 5}
  - name: run_command
    description: Run a shell command on this computer and return its output.
    input_schema:
      type: object
      properties:
        command: {type: string, description: The command to run}
      required: [command]
YAML

client = anthropic.Anthropic()

tools = [
    {"type": "web_fetch_20250910", "name": "web_fetch", "max_uses": 5},
    {
        "name": "run_command",
        "description": "Run a shell command on this computer and return its output.",
        "input_schema": {
            "type": "object",
            "properties": {
                "command": {"type": "string", "description": "The command to run"}
            },
            "required": ["command"],
        },
    },
]
messages = [
    {
        "role": "user",
        "content": "Summarize https://example.com/article and run uname -a to tell me what system this is on.",
    }
]

response = client.messages.create(
    model="claude-opus-4-8", max_tokens=1024, tools=tools, messages=messages
)

tool_results = [
    {
        "type": "tool_result",
        "tool_use_id": block.id,
        # Run your tool here. This example returns a fixed string.
        "content": "Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux",
    }
    for block in response.content
    if block.type == "tool_use"
]

if response.stop_reason == "tool_use" and tool_results:
    # A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
    # Send back only the client tool_result blocks, with the same tools.
    continuation = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=1024,
        tools=tools,
        messages=[
            *messages,
            {"role": "assistant", "content": response.content},
            {"role": "user", "content": tool_results},
        ],
    )
    # If a web_fetch was deferred, it runs on this request and its
    # web_fetch_tool_result is the first block of continuation.content.
    print(continuation)
else:
    print(response)

const client = new Anthropic();

const webFetchTool = {
  type: "web_fetch_20250910",
  name: "web_fetch",
  max_uses: 5
} as const;
const runCommandTool: Anthropic.Tool = {
  name: "run_command",
  description: "Run a shell command on this computer and return its output.",
  input_schema: {
    type: "object" as const,
    properties: {
      command: { type: "string", description: "The command to run" }
    },
    required: ["command"]
  }
};
const messages: Anthropic.MessageParam[] = [
  {
    role: "user",
    content:
      "Summarize https://example.com/article and run uname -a to tell me what system this is on."
  }
];

const response = await client.messages.create({
  model: "claude-opus-4-8",
  max_tokens: 1024,
  tools: [webFetchTool, runCommandTool],
  messages
});

const toolResults: Anthropic.ToolResultBlockParam[] = [];
for (const block of response.content) {
  if (block.type === "tool_use") {
    toolResults.push({
      type: "tool_result",
      tool_use_id: block.id,
      // Run your tool here. This example returns a fixed string.
      content: "Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux"
    });
  }
}

if (response.stop_reason === "tool_use" && toolResults.length > 0) {
  // A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
  // Send back only the client tool_result blocks, with the same tools.
  const continuation = await client.messages.create({
    model: "claude-opus-4-8",
    max_tokens: 1024,
    tools: [webFetchTool, runCommandTool],
    messages: [
      ...messages,
      { role: "assistant", content: response.content },
      { role: "user", content: toolResults }
    ]
  });
  // If a web_fetch was deferred, it runs on this request and its
  // web_fetch_tool_result is the first block of continuation.content.
  console.log(continuation);
} else {
  console.log(response);
}

AnthropicClient client = new();

List<ToolUnion> tools =
[
    new ToolUnion(new WebFetchTool20250910() { MaxUses = 5 }),
    new ToolUnion(new Tool()
    {
        Name = "run_command",
        Description = "Run a shell command on this computer and return its output.",
        InputSchema = new InputSchema()
        {
            Properties = new Dictionary<string, JsonElement>
            {
                ["command"] = JsonSerializer.SerializeToElement(
                    new { type = "string", description = "The command to run" }
                ),
            },
            Required = ["command"],
        },
    }),
];
MessageParam userMessage = new()
{
    Role = Role.User,
    Content = "Summarize https://example.com/article and run uname -a to tell me what system this is on."
};

var response = await client.Messages.Create(new MessageCreateParams
{
    Model = Model.ClaudeOpus4_8,
    MaxTokens = 1024,
    Tools = tools,
    Messages = [userMessage]
});

var toolResults = new List<ContentBlockParam>();
foreach (var block in response.Content)
{
    if (block.TryPickToolUse(out var toolUse))
    {
        toolResults.Add(new ContentBlockParam(new ToolResultBlockParam()
        {
            ToolUseID = toolUse.ID,
            // Run your tool here. This example returns a fixed string.
            Content = "Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux",
        }));
    }
}

if (response.StopReason?.Value() == StopReason.ToolUse && toolResults.Count > 0)
{
    // A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
    // Send back only the client tool_result blocks, with the same tools.
    var continuation = await client.Messages.Create(new MessageCreateParams
    {
        Model = Model.ClaudeOpus4_8,
        MaxTokens = 1024,
        Tools = tools,
        Messages =
        [
            userMessage,
            new()
            {
                Role = Role.Assistant,
                Content = response.Content.Select(block => new ContentBlockParam(block.Json)).ToList()
            },
            new() { Role = Role.User, Content = new MessageParamContent(toolResults) }
        ]
    });
    // If a web_fetch was deferred, it runs on this request and its
    // web_fetch_tool_result is the first block of continuation.Content.
    Console.WriteLine(continuation);
}
else
{
    Console.WriteLine(response);
}

client := anthropic.NewClient()

tools := []anthropic.ToolUnionParam{
	{OfWebFetchTool20250910: &anthropic.WebFetchTool20250910Param{
		MaxUses: anthropic.Int(5),
	}},
	{OfTool: &anthropic.ToolParam{
		Name:        "run_command",
		Description: anthropic.String("Run a shell command on this computer and return its output."),
		InputSchema: anthropic.ToolInputSchemaParam{
			Properties: map[string]any{
				"command": map[string]any{
					"type":        "string",
					"description": "The command to run",
				},
			},
			Required: []string{"command"},
		},
	}},
}
userMessage := anthropic.NewUserMessage(anthropic.NewTextBlock("Summarize https://example.com/article and run uname -a to tell me what system this is on."))

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus4_8,
	MaxTokens: 1024,
	Tools:     tools,
	Messages:  []anthropic.MessageParam{userMessage},
})
if err != nil {
	log.Fatal(err)
}

var toolResults []anthropic.ContentBlockParamUnion
for _, block := range response.Content {
	if toolUse, ok := block.AsAny().(anthropic.ToolUseBlock); ok {
		// Run your tool here. This example returns a fixed string.
		output := "Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux"
		toolResults = append(toolResults, anthropic.NewToolResultBlock(toolUse.ID, output, false))
	}
}

if response.StopReason == anthropic.StopReasonToolUse && len(toolResults) > 0 {
	// A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
	// Send back only the client tool_result blocks, with the same tools.
	continuation, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     anthropic.ModelClaudeOpus4_8,
		MaxTokens: 1024,
		Tools:     tools,
		Messages: []anthropic.MessageParam{
			userMessage,
			response.ToParam(),
			anthropic.NewUserMessage(toolResults...),
		},
	})
	if err != nil {
		log.Fatal(err)
	}
	// If a web_fetch was deferred, it runs on this request and its
	// web_fetch_tool_result is the first block of continuation.Content.
	fmt.Println(continuation)
} else {
	fmt.Println(response)
}

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

    Tool runCommandTool = Tool.builder()
        .name("run_command")
        .description("Run a shell command on this computer and return its output.")
        .inputSchema(Tool.InputSchema.builder()
            .properties(JsonValue.from(Map.of(
                "command", Map.of("type", "string", "description", "The command to run")
            )))
            .putAdditionalProperty("required", JsonValue.from(List.of("command")))
            .build())
        .build();
    String prompt = "Summarize https://example.com/article and run uname -a to tell me what system this is on.";

    Message response = client.messages().create(MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_4_8)
        .maxTokens(1024L)
        .addTool(WebFetchTool20250910.builder().maxUses(5L).build())
        .addTool(runCommandTool)
        .addUserMessage(prompt)
        .build());

    List<ContentBlockParam> toolResults = new ArrayList<>();
    for (ContentBlock block : response.content()) {
        block.toolUse().ifPresent(toolUse -> toolResults.add(ContentBlockParam.ofToolResult(
            ToolResultBlockParam.builder()
                .toolUseId(toolUse.id())
                // Run your tool here. This example returns a fixed string.
                .content("Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux")
                .build()
        )));
    }

    boolean isToolUse = response.stopReason()
        .map(StopReason.TOOL_USE::equals)
        .orElse(false);
    if (isToolUse && !toolResults.isEmpty()) {
        // A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
        // Send back only the client tool_result blocks, with the same tools.
        Message continuation = client.messages().create(MessageCreateParams.builder()
            .model(Model.CLAUDE_OPUS_4_8)
            .maxTokens(1024L)
            .addTool(WebFetchTool20250910.builder().maxUses(5L).build())
            .addTool(runCommandTool)
            .addUserMessage(prompt)
            .addMessage(response)
            .addUserMessageOfBlockParams(toolResults)
            .build());
        // If a web_fetch was deferred, it runs on this request and its
        // web_fetch_tool_result is the first block of continuation.content().
        IO.println(continuation);
    } else {
        IO.println(response);
    }
}

$client = new Client();

$tools = [
    ['type' => 'web_fetch_20250910', 'name' => 'web_fetch', 'max_uses' => 5],
    [
        'name' => 'run_command',
        'description' => 'Run a shell command on this computer and return its output.',
        'input_schema' => [
            'type' => 'object',
            'properties' => [
                'command' => ['type' => 'string', 'description' => 'The command to run']
            ],
            'required' => ['command']
        ]
    ]
];
$userMessage = ['role' => 'user', 'content' => 'Summarize https://example.com/article and run uname -a to tell me what system this is on.'];

$response = $client->messages->create(
    maxTokens: 1024,
    messages: [$userMessage],
    model: 'claude-opus-4-8',
    tools: $tools,
);

$toolResults = [];
foreach ($response->content as $block) {
    if ($block->type === 'tool_use') {
        $toolResults[] = [
            'type' => 'tool_result',
            'tool_use_id' => $block->id,
            // Run your tool here. This example returns a fixed string.
            'content' => 'Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux'
        ];
    }
}

if ($response->stopReason === 'tool_use' && count($toolResults) > 0) {
    // A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
    // Send back only the client tool_result blocks, with the same tools.
    $continuation = $client->messages->create(
        maxTokens: 1024,
        messages: [
            $userMessage,
            ['role' => 'assistant', 'content' => $response->content],
            ['role' => 'user', 'content' => $toolResults],
        ],
        model: 'claude-opus-4-8',
        tools: $tools,
    );
    // If a web_fetch was deferred, it runs on this request and its
    // web_fetch_tool_result is the first block of $continuation->content.
    echo $continuation;
} else {
    echo $response;
}

client = Anthropic::Client.new

tools = [
  { type: "web_fetch_20250910", name: "web_fetch", max_uses: 5 },
  {
    name: "run_command",
    description: "Run a shell command on this computer and return its output.",
    input_schema: {
      type: "object",
      properties: {
        command: { type: "string", description: "The command to run" }
      },
      required: ["command"]
    }
  }
]
user_message = {
  role: "user",
  content: "Summarize https://example.com/article and run uname -a to tell me what system this is on."
}

response = client.messages.create(
  model: "claude-opus-4-8",
  max_tokens: 1024,
  tools: tools,
  messages: [user_message]
)

tool_results = []
response.content.each do |block|
  next unless block.type == :tool_use

  tool_results << {
    type: "tool_result",
    tool_use_id: block.id,
    # Run your tool here. This example returns a fixed string.
    content: "Linux demo-host 6.8.0-52-generic x86_64 GNU/Linux"
  }
end

if response.stop_reason == :tool_use && !tool_results.empty?
  # A server_tool_use block with no result block in this response is not finished; its result arrives in a later response.
  # Send back only the client tool_result blocks, with the same tools.
  continuation = client.messages.create(
    model: "claude-opus-4-8",
    max_tokens: 1024,
    tools: tools,
    messages: [
      user_message,
      { role: "assistant", content: response.content },
      { role: "user", content: tool_results }
    ]
  )
  # If a web_fetch was deferred, it runs on this request and its
  # web_fetch_tool_result is the first block of continuation.content.
  puts continuation
else
  puts response
end