코드 실행 도구

ant messages create \
  --model claude-opus-5-5 \
  --max-tokens 4096 \
  --message '{
    role: user,
    content: "Use the code execution tool to calculate the mean and standard
      deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
  }' \
  --tool '{type: code_execution_20250825, name: code_execution}'

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

print(response.to_json())

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content:
        "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
    }
  ],
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});

console.log(JSON.stringify(response));

AnthropicClient client = new();

var message = await client.Messages.Create(new()
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [new() { Role = Role.User, Content = "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]" }],
    Tools = [new CodeExecutionTool20250825()]
});

Console.WriteLine(message);

client := anthropic.NewClient()

response, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]")),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response.RawJSON())

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

MessageCreateParams params = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(4096L)
    .addUserMessage("Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]")
    .addTool(CodeExecutionTool20250825.builder().build())
    .build();

Message response = client.messages().create(params);
IO.println(ObjectMappers.jsonMapper().valueToTree(response));

$client = new Client();

$message = $client->messages->create(
    maxTokens: 4096,
    messages: [
        [
            'role' => 'user',
            'content' => 'Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]',
        ],
    ],
    model: Model::CLAUDE_OPUS_5_5,
    tools: [new CodeExecutionTool20250825()],
);

echo json_encode($message, JSON_PRETTY_PRINT), PHP_EOL;

client = Anthropic::Client.new

message = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Use the code execution tool to calculate the mean and standard deviation of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
    }
  ],
  tools: [Anthropic::CodeExecutionTool20250825.new]
)

puts message.to_json

Then use the file_id with code execution

curl --fail-with-body -sS https://api.anthropic.com/v1/messages
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "content-type: application/json"
-d '{ "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [{ "role": "user", "content": [ {"type": "text", "text": "Analyze this CSV data"}, {"type": "container_upload", "file_id": "'"$FILE_ID"'"} ] }], "tools": [{ "type": "code_execution_20250825", "name": "code_execution" }] }'

```bash CLI
# First, upload a file and capture the file ID
FILE_ID=$(ant files upload --file ./data.csv --transform id --raw-output)

# Then use the file_id with code execution
ant messages create <<YAML
model: claude-opus-5-5
max_tokens: 4096
messages:
  - role: user
    content:
      - type: text
        text: Analyze this CSV data
      - type: container_upload
        file_id: $FILE_ID
tools:
  - type: code_execution_20250825
    name: code_execution
YAML

client = anthropic.Anthropic()

# Upload a file
file_object = client.files.upload(file=Path("data.csv"))

# Use the file_id with code execution
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Analyze this CSV data"},
                {"type": "container_upload", "file_id": file_object.id},
            ],
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

print(response.to_json())

import { createReadStream } from "node:fs";
// ...
const client = new Anthropic();

// Upload a file
const fileObject = await client.files.upload({
  file: createReadStream("data.csv")
});

// Use the file_id with code execution
const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Analyze this CSV data" },
        { type: "container_upload", file_id: fileObject.id }
      ]
    }
  ],
  tools: [
    {
      type: "code_execution_20250825",
      name: "code_execution"
    }
  ]
});

console.log(JSON.stringify(response));

AnthropicClient client = new();

// Upload a file
var fileObject = await client.Files.Upload(new FileUploadParams
{
    File = File.OpenRead("data.csv")
});

// Use the file_id with code execution
var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [
        new()
        {
            Role = Role.User,
            Content = new([
                new TextBlockParam { Text = "Analyze this CSV data" },
                new ContainerUploadBlockParam { FileID = fileObject.ID }
            ])
        }
    ],
    Tools = [new CodeExecutionTool20250825()]
};

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

ctx := context.Background()
client := anthropic.NewClient()

// Upload a file
file, err := os.Open("data.csv")
if err != nil {
	log.Fatal(err)
}
defer file.Close()

fileObject, err := client.Files.Upload(ctx, anthropic.FileUploadParams{
	File: file,
})
if err != nil {
	log.Fatal(err)
}

// Use the file_id with code execution
response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(
			anthropic.NewTextBlock("Analyze this CSV data"),
			anthropic.NewContainerUploadBlock(fileObject.ID),
		),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(response.RawJSON())

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

// Upload a file
FileMetadata fileObject = client.files().upload(
    FileUploadParams.builder()
        .file(Path.of("data.csv"))
        .build()
);

// Use the file_id with code execution
Message response = client.messages().create(
    MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(4096L)
        .addUserMessageOfBlockParams(List.of(
            ContentBlockParam.ofText(TextBlockParam.builder()
                .text("Analyze this CSV data")
                .build()),
            ContentBlockParam.ofContainerUpload(ContainerUploadBlockParam.builder()
                .fileId(fileObject.id())
                .build())
        ))
        .addTool(CodeExecutionTool20250825.builder().build())
        .build()
);

IO.println(ObjectMappers.jsonMapper().valueToTree(response));

$client = new Client();

// Upload a file
$fileObject = $client->files->upload(
    file: FileParam::fromResource(fopen('data.csv', 'r')),
);

// Use the file_id with code execution
$response = $client->messages->create(
    model: Model::CLAUDE_OPUS_5_5,
    maxTokens: 4096,
    messages: [
        [
            'role' => 'user',
            'content' => [
                TextBlockParam::with(text: 'Analyze this CSV data'),
                ContainerUploadBlockParam::with(fileID: $fileObject->id),
            ],
        ],
    ],
    tools: [new CodeExecutionTool20250825()],
);

echo json_encode($response), PHP_EOL;

client = Anthropic::Client.new

# Upload a file
file_object = client.files.upload(
  file: Pathname("data.csv")
)

# Use the file_id with code execution
response = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "Analyze this CSV data" },
        { type: "container_upload", file_id: file_object.id }
      ]
    }
  ],
  tools: [
    Anthropic::CodeExecutionTool20250825.new
  ]
)

puts response.to_json

# Extracting every file ID from the tool results and downloading each one
# requires a loop, which doesn't translate well to a one-off CLI command.
# Use one of the SDK examples instead.

client = Anthropic()

# Request code execution that creates files
response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Create a matplotlib visualization and save it as output.png",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)


# Extract file IDs from the response
def extract_file_ids(response: Message) -> list[str]:
    file_ids: list[str] = []
    for item in response.content:
        if item.type == "bash_code_execution_tool_result":
            content_item = item.content
            if content_item.type == "bash_code_execution_result":
                for output_block in content_item.content:
                    file_ids.append(output_block.file_id)
    return file_ids


# Download the created files
for file_id in extract_file_ids(response):
    file_metadata = client.files.retrieve_metadata(file_id)
    file_content = client.files.download(file_id)
    file_content.write_to_file(file_metadata.filename)
    print(f"Downloaded: {file_metadata.filename}")

import { writeFile } from "node:fs/promises";

const client = new Anthropic();

// Request code execution that creates files
const response = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Create a matplotlib visualization and save it as output.png"
    }
  ],
  tools: [
    {
      type: "code_execution_20250825",
      name: "code_execution"
    }
  ]
});

// Extract the file IDs from the response and download each created file
for (const block of response.content) {
  if (block.type === "bash_code_execution_tool_result") {
    const result = block.content;
    if (result.type === "bash_code_execution_result") {
      for (const outputBlock of result.content) {
        const [fileMetadata, fileResponse] = await Promise.all([
          client.files.retrieveMetadata(outputBlock.file_id),
          client.files.download(outputBlock.file_id)
        ]);
        await writeFile(fileMetadata.filename, await fileResponse.bytes());
        console.log(`Downloaded: ${fileMetadata.filename}`);
      }
    }
  }
}

AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [new() { Role = Role.User, Content = "Create a matplotlib visualization and save it as output.png" }],
    Tools = [new CodeExecutionTool20250825()]
};

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

// Collect the file IDs from the tool results
List<string> fileIds = [];
foreach (var block in response.Content)
{
    if (!block.TryPickBashCodeExecutionToolResult(out var toolResult))
        continue;
    if (!toolResult.Content.TryPickBashCodeExecutionResultBlock(out var result))
        continue;
    foreach (var output in result.Content)
    {
        fileIds.Add(output.FileID);
    }
}

// Download each created file
foreach (var fileId in fileIds)
{
    var fileMetadata = await client.Files.RetrieveMetadata(fileId);
    using var download = await client.Files.Download(fileId);
    var downloadStream = await download.ReadAsStream();
    await using var target = File.Create(fileMetadata.Filename);
    await downloadStream.CopyToAsync(target);
    Console.WriteLine($"Downloaded: {fileMetadata.Filename}");
}

	client := anthropic.NewClient()
	ctx := context.Background()

	response, err := client.Messages.New(ctx, anthropic.MessageNewParams{
		Model:     anthropic.ModelClaudeOpus5_5,
		MaxTokens: 4096,
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Create a matplotlib visualization and save it as output.png")),
		},
		Tools: []anthropic.ToolUnionParam{
			{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
		},
	})
	if err != nil {
		log.Fatal(err)
	}

	fileIDs := extractFileIDs(response)

	for _, fileID := range fileIDs {
		fileMetadata, err := client.Files.GetMetadata(ctx, fileID, anthropic.FileGetMetadataParams{})
		if err != nil {
			log.Fatal(err)
		}

		fileContent, err := client.Files.Download(ctx, fileID, anthropic.FileDownloadParams{})
		if err != nil {
			log.Fatal(err)
		}

		outFile, err := os.Create(fileMetadata.Filename)
		if err != nil {
			log.Fatal(err)
		}

		_, err = io.Copy(outFile, fileContent.Body)
		if err != nil {
			log.Fatal(err)
		}
		outFile.Close()
		fileContent.Body.Close()

		fmt.Printf("Downloaded: %s\n", fileMetadata.Filename)
	}
// ...

func extractFileIDs(response *anthropic.Message) []string {
	var fileIDs []string
	for _, item := range response.Content {
		switch variant := item.AsAny().(type) {
		case anthropic.BashCodeExecutionToolResultBlock:
			// Collect the file IDs from the tool result
			for _, file := range variant.Content.Content {
				if file.FileID != "" {
					fileIDs = append(fileIDs, file.FileID)
				}
			}
		}
	}
	return fileIDs
}

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

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5_5)
        .maxTokens(4096L)
        .addUserMessage("Create a matplotlib visualization and save it as output.png")
        .addTool(CodeExecutionTool20250825.builder().build())
        .build();

    Message response = client.messages().create(params);

    List<String> fileIds = extractFileIds(response);

    for (String fileId : fileIds) {
        FileMetadata fileMetadata = client.files().retrieveMetadata(fileId);
        try (HttpResponse fileContent = client.files().download(fileId)) {
            Files.copy(
                fileContent.body(),
                Path.of(fileMetadata.filename()),
                StandardCopyOption.REPLACE_EXISTING);
        }
        IO.println("Downloaded: " + fileMetadata.filename());
    }
}

List<String> extractFileIds(Message response) {
    List<String> fileIds = new ArrayList<>();
    // Collect the file IDs from the tool results
    for (ContentBlock item : response.content()) {
        item.bashCodeExecutionToolResult().ifPresent(toolResult -> {
            if (toolResult.content().isBashCodeExecutionResultBlock()) {
                BashCodeExecutionResultBlock result =
                    toolResult.content().asBashCodeExecutionResultBlock();
                for (BashCodeExecutionOutputBlock output : result.content()) {
                    fileIds.add(output.fileId());
                }
            }
        });
    }
    return fileIds;
}

$client = new Client();

// Request code execution that creates files
$response = $client->messages->create(
    maxTokens: 4096,
    messages: [
        [
            'role' => 'user',
            'content' => 'Create a matplotlib visualization and save it as output.png',
        ],
    ],
    model: Model::CLAUDE_OPUS_5_5,
    tools: [new CodeExecutionTool20250825()],
);

/**
 * Extract file IDs from the response.
 *
 * @return list<string>
 */
function extractFileIds(Message $response): array
{
    $fileIds = [];
    foreach ($response->content as $block) {
        if ($block->type !== 'bash_code_execution_tool_result') {
            continue;
        }
        $resultBlock = $block->content;
        if ($resultBlock->type !== 'bash_code_execution_result') {
            continue;
        }
        foreach ($resultBlock->content as $outputBlock) {
            $fileIds[] = $outputBlock->fileID;
        }
    }
    return $fileIds;
}

// Download the created files
foreach (extractFileIds($response) as $fileId) {
    $fileMetadata = $client->files->retrieveMetadata($fileId);
    $fileContent = $client->files->download($fileId);

    file_put_contents($fileMetadata->filename, $fileContent);
    echo "Downloaded: {$fileMetadata->filename}\n";
}

client = Anthropic::Client.new

response = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Create a matplotlib visualization and save it as output.png"
    }
  ],
  tools: [
    {
      type: "code_execution_20250825",
      name: "code_execution"
    }
  ]
)

def extract_file_ids(response)
  file_ids = []
  response.content.each do |item|
    if item.type == :bash_code_execution_tool_result
      # WORKAROUND for anthropic-sdk-ruby union coercion bug (SDK-636): item.content is a
      # nested content union, so the typed accessors on `item.content` are unreliable.
      # Read the raw response data through the public `BaseModel#[]` API instead.
      content_item = item.content
      if content_item[:type].to_s == "bash_code_execution_result"
        Array(content_item[:content]).each do |output_block|
          file_ids << output_block[:file_id]
        end
      end
    end
  end
  file_ids
end

extract_file_ids(response).each do |file_id|
  file_metadata = client.files.retrieve_metadata(file_id)
  file_content = client.files.download(file_id)

  File.open(file_metadata.filename, "wb") do |f|
    f.write(file_content.read)
  end

  puts "Downloaded: #{file_metadata.filename}"
end

Second request: Reuse the container to read the file

curl https://api.anthropic.com/v1/messages
-H "x-api-key: $ANTHR...KEY"
-H "anthropic-version: 2023-06-01"
-H "content-type: application/json"
-d '{ "container": "'"$CONTAINER_ID"'", "model": "claude-opus-5-5", "max_tokens": 4096, "messages": [{ "role": "user", "content": "Read the number from "/tmp/number.txt" and calculate its square" }], "tools": [{ "type": "code_execution_20250825", "name": "code_execution" }] }'

```bash CLI
# First request: Create a file with a random number
CONTAINER_ID=$(ant messages create \
  --model claude-opus-5-5 \
  --max-tokens 4096 \
  --message '{role: user, content: Write a file with a random number and save it to "/tmp/number.txt"}' \
  --tool '{type: code_execution_20250825, name: code_execution}' \
  --transform container.id --raw-output)

# Second request: Reuse the container to read the file
ant messages create \
  --container "$CONTAINER_ID" \
  --model claude-opus-5-5 \
  --max-tokens 4096 \
  --message '{role: user, content: Read the number from "/tmp/number.txt" and calculate its square}' \
  --tool '{type: code_execution_20250825, name: code_execution}'

client = anthropic.Anthropic()

# First request: create a file with a random number in a new container
response1 = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Write a file with a random number and save it to '/tmp/number.txt'",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

# Second request: pass the container ID back so Claude reuses the same container
response2 = client.messages.create(
    container=response1.container.id,
    model="claude-opus-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Read the number from '/tmp/number.txt' and calculate its square",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

print(response2.to_json())

const client = new Anthropic();

// First request: Claude creates a file inside a fresh code execution container
const response1 = await client.messages.create({
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Write a file with a random number and save it to '/tmp/number.txt'"
    }
  ],
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});

// The response includes the container once the code execution tool has run
if (!response1.container) {
  throw new Error("Expected the first response to include a container");
}

// Second request: pass the container ID back so it reuses the same container
const response2 = await client.messages.create({
  container: response1.container.id,
  model: "claude-opus-5-5",
  max_tokens: 4096,
  messages: [
    { role: "user", content: "Read the number from /tmp/number.txt and calculate its square" }
  ],
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});

console.log(JSON.stringify(response2));

AnthropicClient client = new();

// First request: Claude creates a file inside a fresh code execution container
var response1 = await client.Messages.Create(new()
{
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [new() { Role = Role.User, Content = "Write a file with a random number and save it to '/tmp/number.txt'" }],
    Tools = [new CodeExecutionTool20250825()]
});

// Second request: pass the container ID back so Claude reuses the same container
var response2 = await client.Messages.Create(new()
{
    Container = response1.Container!.ID,
    Model = Model.ClaudeOpus5_5,
    MaxTokens = 4096,
    Messages = [new() { Role = Role.User, Content = "Read the number from '/tmp/number.txt' and calculate its square'" }],
    Tools = [new CodeExecutionTool20250825()]
});

Console.WriteLine(response2);

client := anthropic.NewClient()
ctx := context.Background()

codeExecution := []anthropic.ToolUnionParam{
	{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
}

// First request: create a file with a random number in a new container
response1, err := client.Messages.New(ctx, anthropic.MessageNewParams{
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Write a file with a random number and save it to '/tmp/number.txt'")),
	},
	Tools: codeExecution,
})
if err != nil {
	log.Fatal(err)
}

// Reuse the container from the first request so the file is still there.
response2, err := client.Messages.New(ctx, anthropic.MessageNewParams{
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfString: anthropic.String(response1.Container.ID),
	},
	Model:     anthropic.ModelClaudeOpus5_5,
	MaxTokens: 4096,
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Read the number from '/tmp/number.txt' and calculate its square")),
	},
	Tools: codeExecution,
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(response2.RawJSON())

AnthropicClient client = AnthropicOkHttpClient.fromEnv();

// First request: create a file with a random number in a new container
MessageCreateParams params1 = MessageCreateParams.builder()
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(4096L)
    .addUserMessage("Write a file with a random number and save it to '/tmp/number.txt'")
    .addTool(CodeExecutionTool20250825.builder().build())
    .build();

Message response1 = client.messages().create(params1);

// Second request: pass the container ID back so it reuses the same container
MessageCreateParams params2 = MessageCreateParams.builder()
    .container(response1.container().orElseThrow().id())
    .model(Model.CLAUDE_OPUS_5_5)
    .maxTokens(4096L)
    .addUserMessage("Read the number from '/tmp/number.txt' and calculate its square")
    .addTool(CodeExecutionTool20250825.builder().build())
    .build();

Message response2 = client.messages().create(params2);
IO.println(ObjectMappers.jsonMapper().valueToTree(response2));

$client = new Client();

// First request: Claude writes the file inside a fresh code execution container
$response1 = $client->messages->create(
    maxTokens: 4096,
    messages: [
        [
            'role' => 'user',
            'content' => "Write a file with a random number and save it to '/tmp/number.txt'",
        ],
    ],
    model: Model::CLAUDE_OPUS_5_5,
    tools: [new CodeExecutionTool20250825()],
);

// Second request: reuse the container so '/tmp/number.txt' is still there
$response2 = $client->messages->create(
    container: $response1->container->id,
    maxTokens: 4096,
    messages: [
        [
            'role' => 'user',
            'content' => "Read the number from '/tmp/number.txt' and calculate its square",
        ],
    ],
    model: Model::CLAUDE_OPUS_5_5,
    tools: [new CodeExecutionTool20250825()],
);

echo json_encode($response2), PHP_EOL;

client = Anthropic::Client.new

# First request: Claude creates the file inside a fresh code execution container
response1 = client.messages.create(
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Write a file with a random number and save it to '/tmp/number.txt'"
    }
  ],
  tools: [Anthropic::CodeExecutionTool20250825.new]
)

# Second request: pass the container ID back so Claude reuses the same container
response2 = client.messages.create(
  container: response1.container.id,
  model: Anthropic::Model::CLAUDE_OPUS_5_5,
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Read the number from '/tmp/number.txt' and calculate its square"
    }
  ],
  tools: [Anthropic::CodeExecutionTool20250825.new]
)

puts response2.to_json