AI 原生开放教材

外观

Anthropic 平台文档（英文全量）官方文档·英文原文 ↗原件 ↓仓库 ↗

Using Skills in Messages ​

Container parameter ​

Skills are specified using the container parameter in the Messages API. You can include up to 20 Skills for each request.

The structure is identical for both Anthropic and custom Skills. Specify the required type and skill_id, and optionally include version to pin to a specific version:

bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "container": {
      "skills": [
        {
          "type": "anthropic",
          "skill_id": "pptx",
          "version": "latest"
        }
      ]
    },
    "messages": [{
      "role": "user",
      "content": "Create a presentation about renewable energy"
    }],
    "tools": [{
      "type": "code_execution_20250825",
      "name": "code_execution"
    }]
  }'
bash
ant messages create <<'YAML'
model: claude-opus-5
max_tokens: 4096
container:
  skills:
    - type: anthropic
      skill_id: pptx
      version: latest
messages:
  - role: user
    content: Create a presentation about renewable energy
tools:
  - type: code_execution_20250825
    name: code_execution
YAML
python
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    container={
        "skills": [{"type": "anthropic", "skill_id": "pptx", "version": "latest"}]
    },
    messages=[
        {"role": "user", "content": "Create a presentation about renewable energy"}
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)
typescript
const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [
      {
        type: "anthropic",
        skill_id: "pptx",
        version: "latest"
      }
    ]
  },
  messages: [
    {
      role: "user",
      content: "Create a presentation about renewable energy"
    }
  ],
  tools: [
    {
      type: "code_execution_20250825",
      name: "code_execution"
    }
  ]
});
csharp
AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Container = new ContainerParams
    {
        Skills =
        [
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "pptx",
                Version = "latest",
            },
        ],
    },
    Messages = [new() { Role = Role.User, Content = "Create a presentation about renewable energy" }],
    Tools = [new CodeExecutionTool20250825()],
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);
go
client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-opus-5",
	MaxTokens: 4096,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "pptx",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Create a presentation about renewable energy")),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)
java
import com.anthropic.models.messages.ContainerParams;
import com.anthropic.models.messages.SkillParams;
import com.anthropic.models.messages.CodeExecutionTool20250825;
// ...
void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(4096L)
        .container(ContainerParams.builder()
            .addSkill(SkillParams.builder()
                .type(SkillParams.Type.ANTHROPIC)
                .skillId("pptx")
                .version("latest")
                .build())
            .build())
        .addUserMessage("Create a presentation about renewable energy")
        .addTool(CodeExecutionTool20250825.builder().build())
        .build();

    Message response = client.messages().create(params);
    System.out.println(response);
}
php
$client = new Client();

$message = $client->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Create a presentation about renewable energy']
    ],
    model: 'claude-opus-5',
    container: [
        'skills' => [
            [
                'type' => 'anthropic',
                'skillID' => 'pptx',
                'version' => 'latest'
            ]
        ]
    ],
    tools: [
        ['type' => 'code_execution_20250825', 'name' => 'code_execution']
    ]
);

echo $message;
ruby
client = Anthropic::Client.new

message = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [
      {
        type: "anthropic",
        skill_id: "pptx",
        version: "latest"
      }
    ]
  },
  messages: [
    { role: "user", content: "Create a presentation about renewable energy" }
  ],
  tools: [
    { type: "code_execution_20250825", name: "code_execution" }
  ]
)
puts message

Downloading generated files ​

When Skills create documents (Excel, PowerPoint, PDF, Word), they return file_id attributes in the response. You must use the Files API to download these files.

How it works:

  1. Skills create files during code execution.
  2. The response includes a file_id for each created file, inside code-execution tool result blocks (see Response format).
  3. Use the Files API to download the actual file content.
  4. Save locally or process as needed.

To provide input files for Skills to work on, upload them with the Files API and reference them in your request with a container upload block.

Example: creating and downloading an Excel file

bash
# Step 1: Use a Skill to create a file
RESPONSE=$(curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "container": {
      "skills": [
        {"type": "anthropic", "skill_id": "xlsx", "version": "latest"}
      ]
    },
    "messages": [{
      "role": "user",
      "content": "Create an Excel file with a simple budget spreadsheet"
    }],
    "tools": [{
      "type": "code_execution_20250825",
      "name": "code_execution"
    }]
  }')

# Step 2: Extract file_id from response (using jq)
FILE_ID=$(echo "$RESPONSE" | jq -r '.content[] | select(.type=="bash_code_execution_tool_result") | .content | select(.type=="bash_code_execution_result") | .content[] | select(.file_id) | .file_id')

# Step 3: Get filename from metadata
FILENAME=$(curl "https://api.anthropic.com/v1/files/$FILE_ID" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" | jq -r '.filename')

# Step 4: Download the file using Files API
curl "https://api.anthropic.com/v1/files/$FILE_ID/content" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  --output "$FILENAME"

echo "Downloaded: $FILENAME"
bash
# Step 1: Use the xlsx Skill to create a file
# Step 2: Extract file_id from the response with --transform (GJSON path)
FILE_ID=$(ant messages create \
  --transform 'content.#.content.content.#.file_id|@flatten|0' \
  --raw-output <<'YAML'
model: claude-opus-5
max_tokens: 4096
container:
  skills:
    - type: anthropic
      skill_id: xlsx
      version: latest
messages:
  - role: user
    content: Create an Excel file with a simple budget spreadsheet
tools:
  - type: code_execution_20250825
    name: code_execution
YAML
)

# Step 3: Get the filename from file metadata
FILENAME=$(ant files retrieve-metadata \
  --file-id "$FILE_ID" \
  --transform filename \
  --raw-output)

# Step 4: Download the file using Files API
ant files download --file-id "$FILE_ID" --output "$FILENAME" > /dev/null

printf 'Downloaded: %s\n' "$FILENAME"
python
client = anthropic.Anthropic()

# Step 1: Use a Skill to create a file
response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    container={
        "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
    },
    messages=[
        {
            "role": "user",
            "content": "Create an Excel file with a simple budget spreadsheet",
        }
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

# Step 2: Extract file IDs from the response
def extract_file_ids(response):
    file_ids = []
    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":
                # each content item is a bash_code_execution_output block carrying a file_id
                for file in content_item.content:
                    file_ids.append(file.file_id)
    return file_ids

# Step 3: Download the file using Files API
for file_id in extract_file_ids(response):
    file_metadata = client.files.retrieve_metadata(file_id=file_id)
    file_content = client.files.download(file_id=file_id)

    # Step 4: Save to disk
    file_content.write_to_file(file_metadata.filename)
    print(f"Downloaded: {file_metadata.filename}")
typescript
import { writeFile } from "node:fs/promises";

const client = new Anthropic();

// Step 1: Use a Skill to create a file
const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
  },
  messages: [
    {
      role: "user",
      content: "Create an Excel file with a simple budget spreadsheet"
    }
  ],
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});

// Step 2: Extract file IDs from the response
const fileIds: string[] = [];
for (const block of response.content) {
  if (
    block.type === "bash_code_execution_tool_result" &&
    block.content.type === "bash_code_execution_result"
  ) {
    for (const outputBlock of block.content.content) {
      fileIds.push(outputBlock.file_id);
    }
  }
}

// Step 3: Download each file and save to disk
for (const fileId of fileIds) {
  const fileMetadata = await client.files.retrieveMetadata(fileId);
  const fileResponse = await client.files.download(fileId);

  await writeFile(fileMetadata.filename, Buffer.from(await fileResponse.arrayBuffer()));
  console.log(`Downloaded: ${fileMetadata.filename}`);
}
csharp
AnthropicClient client = new();

// Step 1: Use a Skill to create a file
var parameters = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Container = new ContainerParams
    {
        Skills =
        [
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "xlsx",
                Version = "latest",
            },
        ],
    },
    Messages = [new() { Role = Role.User, Content = "Create an Excel file with a simple budget spreadsheet" }],
    Tools = [new CodeExecutionTool20250825()],
};

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

// Step 2: Extract file IDs from the response
List<string> fileIds = [];
foreach (var block in response.Content)
{
    if (block.TryPickBashCodeExecutionToolResult(out var toolResult)
        && toolResult.Content.TryPickBashCodeExecutionResultBlock(out var result))
    {
        foreach (var output in result.Content)
        {
            fileIds.Add(output.FileID);
        }
    }
}

// Step 3: Download each file and save to disk
foreach (var fileId in fileIds)
{
    var fileMetadata = await client.Files.RetrieveMetadata(fileId);
    using var download = await client.Files.Download(fileId);
    using var downloadStream = await download.ReadAsStream();
    using var outputFile = File.Create(fileMetadata.Filename);
    await downloadStream.CopyToAsync(outputFile);
    Console.WriteLine($"Downloaded: {fileMetadata.Filename}");
}
go
func main() {
	client := anthropic.NewClient()

	// Step 1: Use a Skill to create a file
	response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     "claude-opus-5",
		MaxTokens: 4096,
		Container: anthropic.MessageCreateParamsContainerUnion{
			OfContainers: &anthropic.ContainerParams{
				Skills: []anthropic.SkillParams{
					{
						Type:    anthropic.SkillParamsTypeAnthropic,
						SkillID: "xlsx",
						Version: anthropic.String("latest"),
					},
				},
			},
		},
		Messages: []anthropic.MessageParam{
			anthropic.NewUserMessage(anthropic.NewTextBlock("Create an Excel file with a simple budget spreadsheet")),
		},
		Tools: []anthropic.ToolUnionParam{
			{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
		},
	})
	if err != nil {
		log.Fatal(err)
	}

	// Step 2: Extract file IDs from the response
	fileIDs := extractFileIDs(response)

	// Step 3: Download the file using Files API
	for _, fileID := range fileIDs {
		fileMetadata, err := client.Files.GetMetadata(context.TODO(), fileID)
		if err != nil {
			log.Fatal(err)
		}

		fileContent, err := client.Files.Download(context.TODO(), fileID)
		if err != nil {
			log.Fatal(err)
		}

		// Step 4: Save to disk
		out, err := os.Create(fileMetadata.Filename)
		if err != nil {
			log.Fatal(err)
		}
		if _, err := io.Copy(out, fileContent.Body); err != nil {
			log.Fatal(err)
		}
		out.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 v := item.AsAny().(type) {
		case anthropic.BashCodeExecutionToolResultBlock:
			if v.Content.Type == "bash_code_execution_result" {
				for _, output := range v.Content.Content {
					fileIDs = append(fileIDs, output.FileID)
				}
			}
		}
	}
	return fileIDs
}
java
import com.anthropic.models.messages.ContainerParams;
import com.anthropic.models.messages.SkillParams;
import com.anthropic.models.messages.CodeExecutionTool20250825;
import com.anthropic.models.messages.ContentBlock;
import com.anthropic.models.files.FileMetadata;
import com.anthropic.core.http.HttpResponse;
// ...
void main() throws Exception {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    // Step 1: Use a Skill to create a file
    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(4096L)
        .container(ContainerParams.builder()
            .addSkill(SkillParams.builder()
                .type(SkillParams.Type.ANTHROPIC)
                .skillId("xlsx")
                .version("latest")
                .build())
            .build())
        .addUserMessage("Create an Excel file with a simple budget spreadsheet")
        .addTool(CodeExecutionTool20250825.builder().build())
        .build();

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

    // Step 2: Extract file IDs from the response
    List<String> fileIds = new ArrayList<>();
    for (ContentBlock block : response.content()) {
        if (block.isBashCodeExecutionToolResult()) {
            var content = block.asBashCodeExecutionToolResult().content();
            if (content.isBashCodeExecutionResultBlock()) {
                for (var outputBlock : content.asBashCodeExecutionResultBlock().content()) {
                    fileIds.add(outputBlock.fileId());
                }
            }
        }
    }

    // Step 3: Download the file using Files API
    for (String fileId : fileIds) {
        FileMetadata fileMetadata = client.files().retrieveMetadata(fileId);
        HttpResponse fileContent = client.files().download(fileId);

        // Step 4: Save to disk
        try (InputStream is = fileContent.body();
             FileOutputStream fos = new FileOutputStream(fileMetadata.filename())) {
            is.transferTo(fos);
        }
        System.out.println("Downloaded: " + fileMetadata.filename());
    }
}
php
$client = new Client();

// Step 1: Use a Skill to create a file
$response = $client->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Create an Excel file with a simple budget spreadsheet']
    ],
    model: 'claude-opus-5',
    container: [
        'skills' => [
            ['type' => 'anthropic', 'skillID' => 'xlsx', 'version' => 'latest']
        ]
    ],
    tools: [
        ['type' => 'code_execution_20250825', 'name' => 'code_execution']
    ]
);

// Step 2: Extract file IDs from the response
function extractFileIds($response) {
    $fileIds = [];
    foreach ($response->content as $item) {
        if ($item->type === 'bash_code_execution_tool_result') {
            $contentItem = $item->content;
            if ($contentItem->type === 'bash_code_execution_result') {
                foreach ($contentItem->content as $file) {
                    $fileIds[] = $file->fileID;
                }
            }
        }
    }
    return $fileIds;
}

// Step 3: Download the file using Files API
foreach (extractFileIds($response) as $fileId) {
    $fileMetadata = $client->files->retrieveMetadata($fileId);
    $fileContent = $client->files->download($fileId);

    // Step 4: Save to disk
    file_put_contents($fileMetadata->filename, $fileContent);
    echo "Downloaded: {$fileMetadata->filename}\n";
}
ruby
client = Anthropic::Client.new

# Step 1: Use a Skill to create a file
response = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
  },
  messages: [
    {
      role: "user",
      content: "Create an Excel file with a simple budget spreadsheet"
    }
  ],
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
)

# Step 2: Extract file IDs from the response
def extract_file_ids(response)
  file_ids = []
  response.content.each do |item|
    if item.type == :bash_code_execution_tool_result
      content_item = item.content
      if content_item.type == :bash_code_execution_result
        content_item.content.each do |file|
          file_ids << file.file_id
        end
      end
    end
  end
  file_ids
end

# Step 3: Download the file using Files API
extract_file_ids(response).each do |file_id|
  file_metadata = client.files.retrieve_metadata(file_id)

  file_content = client.files.download(file_id)

  # Step 4: Save to disk
  File.binwrite(file_metadata.filename, file_content.read)
  puts "Downloaded: #{file_metadata.filename}"
end

Additional Files API operations:

bash
# Get file metadata
curl "https://api.anthropic.com/v1/files/$FILE_ID" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"

# List all files
curl "https://api.anthropic.com/v1/files" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"

# Delete a file
curl -X DELETE "https://api.anthropic.com/v1/files/$FILE_ID" \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01"
bash
# Get file metadata
ant files retrieve-metadata \
  --file-id "$FILE_ID" \
  --transform '{filename,size_bytes}' \
  --format yaml

# List all files
ant files list --transform '{filename,created_at}' --format yaml

# Delete a file
ant files delete --file-id "$FILE_ID" >/dev/null
python
client = anthropic.Anthropic()
file_id = "file_011CNha8iCJcU1wXNR6q4V8w"
# Get file metadata
file_info = client.files.retrieve_metadata(file_id=file_id)
print(f"Filename: {file_info.filename}, Size: {file_info.size_bytes} bytes")

# List all files
for file in client.files.list():
    print(f"{file.filename} - {file.created_at}")

# Delete a file
client.files.delete(file_id=file_id)
typescript
const client = new Anthropic();
const fileId = "file_011CNha8iCJcU1wXNR6q4V8w";

// Get file metadata
const fileInfo = await client.files.retrieveMetadata(fileId);
console.log(`Filename: ${fileInfo.filename}, Size: ${fileInfo.size_bytes} bytes`);

// List all files
for await (const file of client.files.list()) {
  console.log(`${file.filename} - ${file.created_at}`);
}

// Delete a file
await client.files.delete(fileId);
csharp
AnthropicClient client = new();

var fileId = "file_011CNha8iCJcU1wXNR6q4V8w";

// Get file metadata
var fileInfo = await client.Files.RetrieveMetadata(fileId);
Console.WriteLine($"Filename: {fileInfo.Filename}, Size: {fileInfo.SizeBytes} bytes");

// List files
await foreach (var file in (await client.Files.List()).Paginate())
{
    Console.WriteLine($"{file.Filename} - {file.CreatedAt}");
}

// Delete the file
await client.Files.Delete(fileId);
go
client := anthropic.NewClient()
fileID := "file_011CNha8iCJcU1wXNR6q4V8w"

// Get file metadata
fileInfo, err := client.Files.GetMetadata(context.TODO(), fileID)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Filename: %s, Size: %d bytes\n", fileInfo.Filename, fileInfo.SizeBytes)

// List all files
files := client.Files.ListAutoPaging(context.TODO(), anthropic.FileListParams{})
for files.Next() {
	file := files.Current()
	fmt.Printf("%s - %s\n", file.Filename, file.CreatedAt)
}
if files.Err() != nil {
	log.Fatal(files.Err())
}

// Delete a file
_, err = client.Files.Delete(context.TODO(), fileID)
if err != nil {
	log.Fatal(err)
}
java
import com.anthropic.models.files.FileMetadata;
import com.anthropic.models.files.FileListPage;
// ...
void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();
    String fileId = "file_011CNha8iCJcU1wXNR6q4V8w";

    // Get file metadata
    FileMetadata fileInfo = client.files().retrieveMetadata(fileId);
    System.out.println("Filename: " + fileInfo.filename() + ", Size: " + fileInfo.sizeBytes() + " bytes");

    // List files (first page)
    FileListPage files = client.files().list();
    for (var file : files.data()) {
        System.out.println(file.filename() + " - " + file.createdAt());
    }

    // Delete a file
    client.files().delete(fileId);
}
php
$client = new Client();
$fileId = 'file_011CNha8iCJcU1wXNR6q4V8w';

// Get file metadata
$fileInfo = $client->files->retrieveMetadata($fileId);
echo "Filename: {$fileInfo->filename}, Size: {$fileInfo->sizeBytes} bytes\n";

// List files (first page)
foreach ($client->files->list()->getItems() as $file) {
    echo "{$file->filename} - {$file->createdAt->format(DATE_ATOM)}\n";
}

// Delete a file
$client->files->delete($fileId);
ruby
client = Anthropic::Client.new
file_id = "file_011CNha8iCJcU1wXNR6q4V8w"

# Get file metadata
file_info = client.files.retrieve_metadata(file_id)
puts "Filename: #{file_info.filename}, Size: #{file_info.size_bytes} bytes"

# List all files
client.files.list.auto_paging_each do |file|
  puts "#{file.filename} - #{file.created_at}"
end

# Delete a file
client.files.delete(file_id)

For complete details, see Files API.

Multi-turn conversations ​

The response's container object carries the container's id and expires_at timestamp (see Container reuse for lifetime details). Reuse the same container across multiple messages by specifying the container ID:

bash
# Multi-turn container reuse doesn't translate well to a one-off shell
# command; one of the SDK options would be a better fit. Capture
# container.id from the first response, then pass it in the next request as
# "container": {"id": "...", "skills": [...]} with the conversation history.
bash
# First request creates container
CONTAINER_ID=$(ant messages create \
  --transform container.id \
  --raw-output <<'YAML'
model: claude-opus-5
max_tokens: 4096
container:
  skills:
    - {type: anthropic, skill_id: xlsx, version: latest}
messages:
  - role: user
    content: Create a sample sales dataset and analyze it
tools:
  - {type: code_execution_20250825, name: code_execution}
YAML
)

# Continue conversation with same container
ant messages create <<YAML
model: claude-opus-5
max_tokens: 4096
container:
  id: $CONTAINER_ID  # Reuse container
  skills:
    - {type: anthropic, skill_id: xlsx, version: latest}
messages:
  - role: user
    content: Create a sample sales dataset and analyze it
  - role: assistant
    content: []  # the assistant's text from the first response
  - role: user
    content: What was the total revenue?
tools:
  - {type: code_execution_20250825, name: code_execution}
YAML
python
client = anthropic.Anthropic()

# First request creates container
response1 = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    container={
        "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}]
    },
    messages=[
        {"role": "user", "content": "Create a sample sales dataset and analyze it"}
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

# Continue conversation with same container
messages = [
    {"role": "user", "content": "Create a sample sales dataset and analyze it"},
    {
        # Carry the assistant's text forward; container.id carries the execution state
        "role": "assistant",
        "content": "\n".join(
            block.text for block in response1.content if block.type == "text"
        ),
    },
    {"role": "user", "content": "What was the total revenue?"},
]

response2 = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    container={
        "id": response1.container.id,  # Reuse container
        "skills": [{"type": "anthropic", "skill_id": "xlsx", "version": "latest"}],
    },
    messages=messages,
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)
typescript
const client = new Anthropic();

// First request creates container
const response1 = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
  },
  messages: [{ role: "user", content: "Create a sample sales dataset and analyze it" }],
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});

// Continue conversation with same container
const messages: Anthropic.MessageParam[] = [
  { role: "user", content: "Create a sample sales dataset and analyze it" },
  {
    role: "assistant",
    // Carry the assistant's text forward; container.id carries the execution state
    content: response1.content
      .filter((block) => block.type === "text")
      .map((block) => block.text)
      .join("\n")
  },
  { role: "user", content: "What was the total revenue?" }
];

const response2 = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    id: response1.container!.id, // Reuse container
    skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
  },
  messages,
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});
csharp
AnthropicClient client = new();

// First request with a Skill
var parameters1 = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Container = new ContainerParams
    {
        Skills =
        [
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "xlsx",
                Version = "latest",
            },
        ],
    },
    Messages = [new() { Role = Role.User, Content = "Create a sample sales dataset and analyze it" }],
    Tools = [new CodeExecutionTool20250825()],
};

var response1 = await client.Messages.Create(parameters1);

// Continue the conversation in the same container
// Carry the assistant's text forward; container.id carries the execution state
var assistantText = string.Join(
    "\n",
    response1.Content.Select(block => block.TryPickText(out var text) ? text.Text : null).Where(text => text is not null)
);

var parameters2 = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Container = new ContainerParams
    {
        ID = response1.Container!.ID,
        Skills =
        [
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "xlsx",
                Version = "latest",
            },
        ],
    },
    Messages =
    [
        new() { Role = Role.User, Content = "Create a sample sales dataset and analyze it" },
        new() { Role = Role.Assistant, Content = assistantText },
        new() { Role = Role.User, Content = "What was the total revenue?" },
    ],
    Tools = [new CodeExecutionTool20250825()],
};

var response2 = await client.Messages.Create(parameters2);
Console.WriteLine(response2);
go
client := anthropic.NewClient()

response1, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-opus-5",
	MaxTokens: 4096,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "xlsx",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Create a sample sales dataset and analyze it")),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}

// Carry the assistant's text forward; container.id carries the execution state
var textParts []string
for _, block := range response1.Content {
	if block.Type == "text" {
		textParts = append(textParts, block.Text)
	}
}
assistantText := strings.Join(textParts, "\n")

response2, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-opus-5",
	MaxTokens: 4096,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			ID: anthropic.String(response1.Container.ID), // Reuse container
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "xlsx",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Create a sample sales dataset and analyze it")),
		{
			Role:    anthropic.MessageParamRoleAssistant,
			Content: []anthropic.ContentBlockParamUnion{anthropic.NewTextBlock(assistantText)},
		},
		anthropic.NewUserMessage(anthropic.NewTextBlock("What was the total revenue?")),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}

fmt.Println(response2)
java
import com.anthropic.models.messages.ContainerParams;
import com.anthropic.models.messages.SkillParams;
import com.anthropic.models.messages.CodeExecutionTool20250825;
import com.anthropic.models.messages.ContentBlock;
// ...
void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params1 = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(4096L)
        .container(ContainerParams.builder()
            .addSkill(SkillParams.builder()
                .type(SkillParams.Type.ANTHROPIC)
                .skillId("xlsx")
                .version("latest")
                .build())
            .build())
        .addUserMessage("Create a sample sales dataset and analyze it")
        .addTool(CodeExecutionTool20250825.builder().build())
        .build();

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

    MessageCreateParams params2 = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(4096L)
        .container(ContainerParams.builder()
            .id(response1.container().get().id())
            .addSkill(SkillParams.builder()
                .type(SkillParams.Type.ANTHROPIC)
                .skillId("xlsx")
                .version("latest")
                .build())
            .build())
        .addUserMessage("Create a sample sales dataset and analyze it")
        // Carry the assistant's text forward; container.id carries the execution state
        .addAssistantMessage(response1.content().stream()
            .filter(ContentBlock::isText)
            .map(block -> block.asText().text())
            .collect(Collectors.joining("\n")))
        .addUserMessage("What was the total revenue?")
        .addTool(CodeExecutionTool20250825.builder().build())
        .build();

    Message response2 = client.messages().create(params2);
    System.out.println(response2);
}
php
$client = new Client();

$response1 = $client->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Create a sample sales dataset and analyze it']
    ],
    model: 'claude-opus-5',
    container: [
        'skills' => [
            ['type' => 'anthropic', 'skillID' => 'xlsx', 'version' => 'latest']
        ]
    ],
    tools: [
        ['type' => 'code_execution_20250825', 'name' => 'code_execution']
    ]
);

$messages = [
    ['role' => 'user', 'content' => 'Create a sample sales dataset and analyze it'],
    // Carry the assistant's text forward; container.id carries the execution state
    ['role' => 'assistant', 'content' => implode("\n", array_map(
        fn ($block) => $block->text,
        array_filter($response1->content, fn ($block) => $block->type === 'text'),
    ))],
    ['role' => 'user', 'content' => 'What was the total revenue?']
];

$response2 = $client->messages->create(
    maxTokens: 4096,
    messages: $messages,
    model: 'claude-opus-5',
    container: [
        'id' => $response1->container->id,
        'skills' => [
            ['type' => 'anthropic', 'skillID' => 'xlsx', 'version' => 'latest']
        ]
    ],
    tools: [
        ['type' => 'code_execution_20250825', 'name' => 'code_execution']
    ]
);

echo $response2;
ruby
client = Anthropic::Client.new

response1 = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [{ type: "anthropic", skill_id: "xlsx", version: "latest" }]
  },
  messages: [
    { role: "user", content: "Create a sample sales dataset and analyze it" }
  ],
  tools: [
    { type: "code_execution_20250825", name: "code_execution" }
  ]
)

messages = [
  { role: "user", content: "Create a sample sales dataset and analyze it" },
  {
    # Carry the assistant's text forward; container.id carries the execution state
    role: "assistant",
    content: response1.content.filter_map { |block| block.text if block.type == :text }.join("\n")
  },
  { role: "user", content: "What was the total revenue?" }
]

response2 = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    id: response1.container.id,
    skills: [
      { type: "anthropic", skill_id: "xlsx", version: "latest" }
    ]
  },
  messages: messages,
  tools: [
    { type: "code_execution_20250825", name: "code_execution" }
  ]
)

puts response2

Long-running operations ​

Skills may perform operations that require multiple turns. Handle pause_turn stop reasons:

bash
# Initial request
RESPONSE=$(curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "container": {
      "skills": [
        {
          "type": "custom",
          "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
          "version": "latest"
        }
      ]
    },
    "messages": [{
      "role": "user",
      "content": "Generate and process a large sample dataset"
    }],
    "tools": [{
      "type": "code_execution_20250825",
      "name": "code_execution"
    }]
  }')

# If stop_reason is "pause_turn", continue in the same container, appending
# the prior response's content array to messages as the assistant turn.
# Repeat this continuation request until stop_reason is no longer "pause_turn".
STOP_REASON=$(echo "$RESPONSE" | jq -r '.stop_reason')
CONTAINER_ID=$(echo "$RESPONSE" | jq -r '.container.id')

RESPONSE=$(curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d "{
    \"model\": \"claude-opus-5\",
    \"max_tokens\": 4096,
    \"container\": {
      \"id\": \"$CONTAINER_ID\",
      \"skills\": [{
        \"type\": \"custom\",
        \"skill_id\": \"skill_01AbCdEfGhIjKlMnOpQrStUv\",
        \"version\": \"latest\"
      }]
    },
    \"messages\": [],
    \"tools\": [{
      \"type\": \"code_execution_20250825\",
      \"name\": \"code_execution\"
    }]
  }")
bash
RESP=$(mktemp)

# Initial request: capture the full JSON response to a temp file
ant messages create > "$RESP" <<'YAML'
model: claude-opus-5
max_tokens: 4096
container:
  skills:
    - type: custom
      skill_id: skill_01AbCdEfGhIjKlMnOpQrStUv
      version: latest
messages:
  - role: user
    content: Generate and process a large sample dataset
tools:
  - type: code_execution_20250825
    name: code_execution
YAML

# If stop_reason is "pause_turn", continue in the same container,
# appending the prior response's content array to messages as the
# assistant turn. Repeat until stop_reason is no longer "pause_turn".
CONTAINER_ID=$(jq -r '.container.id' "$RESP")

ant messages create > "$RESP" <<YAML
model: claude-opus-5
max_tokens: 4096
container:
  id: $CONTAINER_ID
  skills:
    - type: custom
      skill_id: skill_01AbCdEfGhIjKlMnOpQrStUv
      version: latest
messages: [] # replace with conversation history + prior assistant content
tools:
  - type: code_execution_20250825
    name: code_execution
YAML
python
client = anthropic.Anthropic()

messages = [{"role": "user", "content": "Generate and process a large sample dataset"}]
max_retries = 10

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    container={
        "skills": [
            {
                "type": "custom",
                "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
                "version": "latest",
            }
        ]
    },
    messages=messages,
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)

# Handle pause_turn for long operations
for _ in range(max_retries):
    if response.stop_reason != "pause_turn":
        break

    messages.append({"role": "assistant", "content": response.content})
    response = client.messages.create(
        model="claude-opus-5",
        max_tokens=4096,
        container={
            "id": response.container.id,
            "skills": [
                {
                    "type": "custom",
                    "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
                    "version": "latest",
                }
            ],
        },
        messages=messages,
        tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
    )
typescript
const client = new Anthropic();
const messages: Anthropic.MessageParam[] = [
  { role: "user", content: "Generate and process a large sample dataset" }
];
const maxRetries = 10;

let response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [{ type: "custom", skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv", version: "latest" }]
  },
  messages,
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
});

// Handle pause_turn for long operations
for (let i = 0; i < maxRetries; i++) {
  if (response.stop_reason !== "pause_turn") {
    break;
  }

  messages.push({
    role: "assistant",
    content: response.content as Anthropic.ContentBlockParam[]
  });
  response = await client.messages.create({
    model: "claude-opus-5",
    max_tokens: 4096,
    container: {
      id: response.container!.id,
      skills: [
        { type: "custom", skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv", version: "latest" }
      ]
    },
    messages,
    tools: [{ type: "code_execution_20250825", name: "code_execution" }]
  });
}
csharp
using System.Text.Json;
// ...
AnthropicClient client = new();

List<MessageParam> messages =
[
    new() { Role = Role.User, Content = "Generate and process a large sample dataset" },
];

var maxRetries = 10;
string? containerId = null;
Message? response = null;

for (var i = 0; i < maxRetries; i++)
{
    var parameters = new MessageCreateParams
    {
        Model = "claude-opus-5",
        MaxTokens = 4096,
        Container = containerId is null
            ? new ContainerParams
            {
                Skills =
                [
                    new SkillParams
                    {
                        Type = SkillParamsType.Custom,
                        SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
                        Version = "latest",
                    },
                ],
            }
            : new ContainerParams
            {
                ID = containerId,
                Skills =
                [
                    new SkillParams
                    {
                        Type = SkillParamsType.Custom,
                        SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
                        Version = "latest",
                    },
                ],
            },
        Messages = messages,
        Tools = [new CodeExecutionTool20250825()],
    };

    response = await client.Messages.Create(parameters);
    containerId = response.Container!.ID;

    if (response.StopReason != StopReason.PauseTurn)
    {
        break;
    }

    // Append the paused turn's content and continue
    var assistantContent = JsonSerializer.SerializeToElement(
        response.Content.Select(block => block.Json).ToArray()
    );
    messages.Add(new() { Role = Role.Assistant, Content = new MessageParamContent(assistantContent) });
}
go
client := anthropic.NewClient()

messages := []anthropic.MessageParam{
	anthropic.NewUserMessage(anthropic.NewTextBlock("Generate and process a large sample dataset")),
}
maxRetries := 10

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-opus-5",
	MaxTokens: 4096,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeCustom,
					SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: messages,
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}

for i := 0; i < maxRetries; i++ {
	if response.StopReason != anthropic.StopReasonPauseTurn {
		break
	}

	messages = append(messages, response.ToParam())

	response, err = client.Messages.New(context.TODO(), anthropic.MessageNewParams{
		Model:     "claude-opus-5",
		MaxTokens: 4096,
		Container: anthropic.MessageCreateParamsContainerUnion{
			OfContainers: &anthropic.ContainerParams{
				ID: anthropic.String(response.Container.ID), // Reuse container
				Skills: []anthropic.SkillParams{
					{
						Type:    anthropic.SkillParamsTypeCustom,
						SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
						Version: anthropic.String("latest"),
					},
				},
			},
		},
		Messages: messages,
		Tools: []anthropic.ToolUnionParam{
			{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
		},
	})
	if err != nil {
		log.Fatal(err)
	}
}

fmt.Println(response)
java
import com.anthropic.models.messages.ContainerParams;
import com.anthropic.models.messages.SkillParams;
import com.anthropic.models.messages.CodeExecutionTool20250825;
import com.anthropic.models.messages.StopReason;
// ...
void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    List<MessageParam> messages = new ArrayList<>();
    messages.add(
        MessageParam.builder()
            .role(MessageParam.Role.USER)
            .content("Generate and process a large sample dataset")
            .build()
    );
    int maxRetries = 10;

    Message response = client.messages().create(
        MessageCreateParams.builder()
            .model(Model.CLAUDE_OPUS_5)
            .maxTokens(4096L)
            .container(ContainerParams.builder()
                .addSkill(SkillParams.builder()
                    .type(SkillParams.Type.CUSTOM)
                    .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
                    .version("latest")
                    .build())
                .build())
            .messages(messages)
            .addTool(CodeExecutionTool20250825.builder().build())
            .build());

    for (int i = 0; i < maxRetries; i++) {
        if (!response.stopReason().isPresent()
                || !response.stopReason().get().equals(StopReason.PAUSE_TURN)) {
            break;
        }

        messages.add(response.toParam());

        response = client.messages().create(
            MessageCreateParams.builder()
                .model(Model.CLAUDE_OPUS_5)
                .maxTokens(4096L)
                .container(ContainerParams.builder()
                    .id(response.container().get().id())
                    .addSkill(SkillParams.builder()
                        .type(SkillParams.Type.CUSTOM)
                        .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
                        .version("latest")
                        .build())
                    .build())
                .messages(messages)
                .addTool(CodeExecutionTool20250825.builder().build())
                .build());
    }
}
php
$client = new Client();

$messages = [
    ['role' => 'user', 'content' => 'Generate and process a large sample dataset']
];
$maxRetries = 10;

$response = $client->messages->create(
    maxTokens: 4096,
    messages: $messages,
    model: 'claude-opus-5',
    container: [
        'skills' => [
            [
                'type' => 'custom',
                'skillID' => 'skill_01AbCdEfGhIjKlMnOpQrStUv',
                'version' => 'latest'
            ]
        ]
    ],
    tools: [['type' => 'code_execution_20250825', 'name' => 'code_execution']]
);

for ($i = 0; $i < $maxRetries; $i++) {
    if ($response->stopReason !== 'pause_turn') {
        break;
    }

    $messages[] = ['role' => 'assistant', 'content' => $response->content];

    $response = $client->messages->create(
        maxTokens: 4096,
        messages: $messages,
        model: 'claude-opus-5',
        container: [
            'id' => $response->container->id,
            'skills' => [
                [
                    'type' => 'custom',
                    'skillID' => 'skill_01AbCdEfGhIjKlMnOpQrStUv',
                    'version' => 'latest'
                ]
            ]
        ],
        tools: [['type' => 'code_execution_20250825', 'name' => 'code_execution']]
    );
}
ruby
client = Anthropic::Client.new

messages = [
  { role: "user", content: "Generate and process a large sample dataset" }
]
max_retries = 10

response = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [
      {
        type: "custom",
        skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
        version: "latest"
      }
    ]
  },
  messages: messages,
  tools: [{ type: "code_execution_20250825", name: "code_execution" }]
)

max_retries.times do
  break if response.stop_reason != :pause_turn

  messages << { role: "assistant", content: response.content }

  response = client.messages.create(
    model: "claude-opus-5",
    max_tokens: 4096,
    container: {
      id: response.container.id,
      skills: [
        {
          type: "custom",
          skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
          version: "latest"
        }
      ]
    },
    messages: messages,
    tools: [{ type: "code_execution_20250825", name: "code_execution" }]
  )
end

The response may include a pause_turn stop reason, which indicates that the API paused a long-running Skill operation. You can provide the response back as-is in a subsequent request to let Claude continue its turn, or modify the content if you want to interrupt the conversation and provide additional guidance.

Using multiple Skills ​

Combine multiple Skills in a single request to handle complex workflows:

bash
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-opus-5",
    "max_tokens": 4096,
    "container": {
      "skills": [
        {
          "type": "anthropic",
          "skill_id": "xlsx",
          "version": "latest"
        },
        {
          "type": "anthropic",
          "skill_id": "pptx",
          "version": "latest"
        },
        {
          "type": "custom",
          "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
          "version": "latest"
        }
      ]
    },
    "messages": [{
      "role": "user",
      "content": "Analyze sales data and create a presentation"
    }],
    "tools": [{
      "type": "code_execution_20250825",
      "name": "code_execution"
    }]
  }'
bash
ant messages create <<'YAML'
model: claude-opus-5
max_tokens: 4096
container:
  skills:
    - type: anthropic
      skill_id: xlsx
      version: latest
    - type: anthropic
      skill_id: pptx
      version: latest
    - type: custom
      skill_id: skill_01AbCdEfGhIjKlMnOpQrStUv
      version: latest
messages:
  - role: user
    content: Analyze sales data and create a presentation
tools:
  - type: code_execution_20250825
    name: code_execution
YAML
python
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5",
    max_tokens=4096,
    container={
        "skills": [
            {"type": "anthropic", "skill_id": "xlsx", "version": "latest"},
            {"type": "anthropic", "skill_id": "pptx", "version": "latest"},
            {
                "type": "custom",
                "skill_id": "skill_01AbCdEfGhIjKlMnOpQrStUv",
                "version": "latest",
            },
        ]
    },
    messages=[
        {"role": "user", "content": "Analyze sales data and create a presentation"}
    ],
    tools=[{"type": "code_execution_20250825", "name": "code_execution"}],
)
typescript
const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [
      {
        type: "anthropic",
        skill_id: "xlsx",
        version: "latest"
      },
      {
        type: "anthropic",
        skill_id: "pptx",
        version: "latest"
      },
      {
        type: "custom",
        skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
        version: "latest"
      }
    ]
  },
  messages: [
    {
      role: "user",
      content: "Analyze sales data and create a presentation"
    }
  ],
  tools: [
    {
      type: "code_execution_20250825",
      name: "code_execution"
    }
  ]
});
csharp
AnthropicClient client = new();

var parameters = new MessageCreateParams
{
    Model = "claude-opus-5",
    MaxTokens = 4096,
    Container = new ContainerParams
    {
        Skills =
        [
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "xlsx",
                Version = "latest",
            },
            new SkillParams
            {
                Type = SkillParamsType.Anthropic,
                SkillID = "pptx",
                Version = "latest",
            },
            new SkillParams
            {
                Type = SkillParamsType.Custom,
                SkillID = "skill_01AbCdEfGhIjKlMnOpQrStUv",
                Version = "latest",
            },
        ],
    },
    Messages = [new() { Role = Role.User, Content = "Analyze sales data and create a presentation" }],
    Tools = [new CodeExecutionTool20250825()],
};

var message = await client.Messages.Create(parameters);
Console.WriteLine(message);
go
client := anthropic.NewClient()

response, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{
	Model:     "claude-opus-5",
	MaxTokens: 4096,
	Container: anthropic.MessageCreateParamsContainerUnion{
		OfContainers: &anthropic.ContainerParams{
			Skills: []anthropic.SkillParams{
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "xlsx",
					Version: anthropic.String("latest"),
				},
				{
					Type:    anthropic.SkillParamsTypeAnthropic,
					SkillID: "pptx",
					Version: anthropic.String("latest"),
				},
				{
					Type:    anthropic.SkillParamsTypeCustom,
					SkillID: "skill_01AbCdEfGhIjKlMnOpQrStUv",
					Version: anthropic.String("latest"),
				},
			},
		},
	},
	Messages: []anthropic.MessageParam{
		anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze sales data and create a presentation")),
	},
	Tools: []anthropic.ToolUnionParam{
		{OfCodeExecutionTool20250825: &anthropic.CodeExecutionTool20250825Param{}},
	},
})
if err != nil {
	log.Fatal(err)
}
fmt.Println(response)
java
import com.anthropic.models.messages.ContainerParams;
import com.anthropic.models.messages.SkillParams;
import com.anthropic.models.messages.CodeExecutionTool20250825;
// ...
void main() {
    AnthropicClient client = AnthropicOkHttpClient.fromEnv();

    MessageCreateParams params = MessageCreateParams.builder()
        .model(Model.CLAUDE_OPUS_5)
        .maxTokens(4096L)
        .container(ContainerParams.builder()
            .skills(List.of(
                SkillParams.builder()
                    .type(SkillParams.Type.ANTHROPIC)
                    .skillId("xlsx")
                    .version("latest")
                    .build(),
                SkillParams.builder()
                    .type(SkillParams.Type.ANTHROPIC)
                    .skillId("pptx")
                    .version("latest")
                    .build(),
                SkillParams.builder()
                    .type(SkillParams.Type.CUSTOM)
                    .skillId("skill_01AbCdEfGhIjKlMnOpQrStUv")
                    .version("latest")
                    .build()
            ))
            .build())
        .addUserMessage("Analyze sales data and create a presentation")
        .addTool(CodeExecutionTool20250825.builder().build())
        .build();

    Message response = client.messages().create(params);
    System.out.println(response);
}
php
$client = new Client();

$message = $client->messages->create(
    maxTokens: 4096,
    messages: [
        ['role' => 'user', 'content' => 'Analyze sales data and create a presentation']
    ],
    model: 'claude-opus-5',
    container: [
        'skills' => [
            [
                'type' => 'anthropic',
                'skillID' => 'xlsx',
                'version' => 'latest'
            ],
            [
                'type' => 'anthropic',
                'skillID' => 'pptx',
                'version' => 'latest'
            ],
            [
                'type' => 'custom',
                'skillID' => 'skill_01AbCdEfGhIjKlMnOpQrStUv',
                'version' => 'latest'
            ]
        ]
    ],
    tools: [
        ['type' => 'code_execution_20250825', 'name' => 'code_execution']
    ]
);

echo $message;
ruby
client = Anthropic::Client.new

message = client.messages.create(
  model: "claude-opus-5",
  max_tokens: 4096,
  container: {
    skills: [
      {
        type: "anthropic",
        skill_id: "xlsx",
        version: "latest"
      },
      {
        type: "anthropic",
        skill_id: "pptx",
        version: "latest"
      },
      {
        type: "custom",
        skill_id: "skill_01AbCdEfGhIjKlMnOpQrStUv",
        version: "latest"
      }
    ]
  },
  messages: [
    { role: "user", content: "Analyze sales data and create a presentation" }
  ],
  tools: [
    { type: "code_execution_20250825", name: "code_execution" }
  ]
)
puts message