克劳德·阿皮伊

What does your application need?

0. Are you deploying through Amazon Bedrock, Google Vertex AI, or Microsoft Foundry?
    Yes -> Claude API (+ tool use for agents) - Managed Agents is 1P only.
   No -> continue.

1. Single LLM call (classification, summarization, extraction, Q&A)
    Claude API - one request, one response

2. Do you want Anthropic to run the agent loop and host a per-session
   container where Claude executes tools (bash, file ops, code)?
    Yes -> Managed Agents - server-managed sessions, persisted agent configs,
       SSE event stream, Skills + MCP, file mounts.
       Examples: "stateful coding agent with a workspace per task",
                 "long-running research agent that streams events to a UI",
                 "agent with persisted, versioned config used across many sessions"

3. Workflow (multi-step, code-orchestrated, with your own tools)
    Claude API with tool use - you control the loop

4. Open-ended agent (model decides its own trajectory, your own tools, you host the compute)
    Claude API agentic loop (maximum flexibility)

# Message Batches API — Python

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```python
进口人择
从 anthropic.types.message_create_params 导入 MessageCreateParamsNonStreaming
从 anthropic.types.messages.batch_create_params 导入请求

客户端 = anthropic.Anthropic()

message_batch = client.messages.batches.create(
    请求=[
        请求（
            custom_id =“请求-1”，
            参数=MessageCreateParamsNonStreaming(
                型号=“claude-opus-4-7”，
                最大令牌=16000,
                messages=[{"role": "user", "content": "总结气候变化影响"}]
            ）
        ),
        请求（
            custom_id="请求-2",
            参数=MessageCreateParamsNonStreaming(
                型号=“claude-opus-4-7”，
                最大令牌=16000,
                messages=[{"role": "user", "content": "解释量子计算基础知识"}]
            ）
        ),
    ]
）

print(f"批次 ID: {message_batch.id}")
print(f"状态：{message_batch.processing_status}")

导入时间

而真实：
    批处理 = client.messages.batches.retrieve(message_batch.id)
    如果batch.processing_status ==“结束”：
        打破
    print(f"状态：{batch.processing_status}，处理中：{batch.request_counts.processing}")
    时间.睡眠(60)

print("批量完成！")
print(f"成功：{batch.request_counts.succeeded}")
print(f"错误：{batch.request_counts.errored}")

对于 client.messages.batches.results(message_batch.id) 中的结果：
    匹配结果.结果.类型：
        案例“成功”：
            msg = 结果.结果.消息
            text = next((b.text for b in msg.content if b.type == "text"), "")
            打印（f“[{result.custom_id}] {文本[：100]}”）
        案例“错误”：
            如果 result.result.error.type == "invalid_request":
                print(f"[{result.custom_id}] 验证错误 - 修复请求并重试")
            其他：
                print(f"[{result.custom_id}] 服务器错误 - 可以安全重试")
        案件“取消”：
            print(f"[{result.custom_id}] 已取消")
        案例“过期”：
            print(f"[{result.custom_id}] 已过期 - 重新提交")

取消 = client.messages.batches.cancel(message_batch.id)
print(f"状态：{cancelled.processing_status}") # "取消"

共享系统 = [
    {"type": "text", "text": "你是一名文学分析师。"},
    {
        “类型”：“文本”，
        "text": large_document_text, # 在所有请求之间共享
        “cache_control”：{“类型”：“短暂”}
    }
]

message_batch = client.messages.batches.create(
    请求=[
        请求（
            custom_id=f"分析-{i}",
            参数=MessageCreateParamsNonStreaming(
                型号=“claude-opus-4-7”，
                最大令牌=16000,
                系统=共享系统，
                messages=[{“角色”：“用户”，“内容”：问题}]
            ）
        ）
        对于我来说，枚举中的问题（问题）
    ]
）

进口人择
导入时间
从 anthropic.types.message_create_params 导入 MessageCreateParamsNonStreaming
从 anthropic.types.messages.batch_create_params 导入请求

客户端 = anthropic.Anthropic()

# 1. 准备请求
要分类的项目 = [
    “产品质量非常好！”,
    “糟糕的客户服务，再也不会了。”,
    “没事，没什么特别的。”,
]

请求= [
    请求（
        custom_id=f"分类-{i}",
        参数=MessageCreateParamsNonStreaming(
            模型=“claude-haiku-4-5”，
            最大令牌数=50,
            消息=[{
                “角色”：“用户”，
                "content": f"分类为正面/负面/中性（一个词）：{text}"
            }]
        ）
    ）
    对于 i，枚举中的文本（items_to_classify）
]

# 2.创建批次
批处理 = client.messages.batches.create(requests=requests)
print(f"已创建批次：{batch.id}")

# 3.等待完成
而真实：
    批处理 = client.messages.batches.retrieve(batch.id)
    如果batch.processing_status ==“结束”：
        打破
    时间.睡眠(10)

# 4. 收集结果
结果={}
对于 client.messages.batches.results(batch.id) 中的结果：
    如果 result.result.type == "成功":
        msg = 结果.结果.消息
        results[result.custom_id] = next((b.text for b in msg.content if b.type == "text"), "")

对于custom_id，在sorted(results.items())中进行分类：
    打印（f“{custom_id}：{classification}”）

### python/claude-api/files-api.md

[下载 python/claude-api/files-api.md](/skills/claude-api/python/claude-api/files-api.md)

```markdown
# Files API — Python

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas=["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```python
进口人择

客户端 = anthropic.Anthropic()

已上传 = client.beta.files.upload(
    file=("report.pdf", open("report.pdf", "rb"), "application/pdf"),
）
print(f"文件 ID：{uploaded.id}")
print(f"大小：{uploaded.size_bytes} 字节")

响应 = client.beta.messages.create(
    型号=“claude-opus-4-7”，
    最大令牌=16000,
    消息=[{
        “角色”：“用户”，
        “内容”：[
            {"type": "text", "text": "总结本报告中的主要发现。"},
            {
                “类型”：“文档”，
                "source": {"type": "file", "file_id": uploaded.id},
                "title": "第四季度报告", # 可选
                "itations": {"enabled": True} # 可选，启用引用
            }
        ]
    }],
    betas=["files-api-2025-04-14"],
）
对于响应中的块。内容：
    if block.type == "text":
        打印（块.文本）

image_file = client.beta.files.upload(
    文件=（“照片.png”，打开（“照片.png”，“rb”），“图像/ png”），
）

响应 = client.beta.messages.create(
    型号=“claude-opus-4-7”，
    最大令牌=16000,
    消息=[{
        “角色”：“用户”，
        “内容”：[
            {"type": "text", "text": "这张图片里有什么？"},
            {
                “类型”：“图像”，
                "source": {"type": "file", "file_id": image_file.id}
            }
        ]
    }],
    betas=["files-api-2025-04-14"],
）

文件 = client.beta.files.list()
对于 files.data 中的 f：
    print(f"{f.id}: {f.filename} ({f.size_bytes} 字节)")

file_info = client.beta.files.retrieve_metadata("file_011CNha8iCJcU1wXNR6q4V8w")
print(f"文件名：{file_info.filename}")
print(f"MIME 类型：{file_info.mime_type}")

client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w")

file_content = client.beta.files.download("file_011CNha8iCJcU1wXNR6q4V8w")
file_content.write_to_file("输出.txt")

进口人择

客户端 = anthropic.Anthropic()

# 1.上传一次
已上传 = client.beta.files.upload(
    file=("contract.pdf", open("contract.pdf", "rb"), "application/pdf"),
）
print(f"已上传：{uploaded.id}")

# 2. 使用相同的 file_id 提出多个问题
问题=[
    “主要条款和条件是什么？”,
    “什么是终止条款？”,
    “总结付款计划。”,
]

对于问题中的问题：
    响应 = client.beta.messages.create(
        型号=“claude-opus-4-7”，
        最大令牌=16000,
        消息=[{
            “角色”：“用户”，
            “内容”：[
                {“类型”：“文本”，“文本”：问题}，
                {
                    “类型”：“文档”，
                    "source": {"type": "file", "file_id": uploaded.id}
                }
            ]
        }],
        betas=["files-api-2025-04-14"],
    ）
    print(f"\nQ: {question}")
    text = next((b.text for b in response.content if b.type == "text"), "")
    打印（f“A：{文本[：200]}”）

# 3.完成后清理
client.beta.files.delete(uploaded.id)

### python/claude-api/streaming.md

[下载 python/claude-api/streaming.md](/skills/claude-api/python/claude-api/streaming.md)

```markdown
# Streaming — Python

## Quick Start

```python
与 client.messages.stream(
    型号=“claude-opus-4-7”，
    最大令牌数=64000,
    messages=[{"role": "user", "content": "写一个故事"}]
) 作为流：
    对于stream.text_stream中的文本：
        打印（文本，结束=“”，冲洗=真）

与 async_client.messages.stream 异步（
    型号=“claude-opus-4-7”，
    最大令牌数=64000,
    messages=[{"role": "user", "content": "写一个故事"}]
) 作为流：
    Stream.text_stream 中的文本异步：
        打印（文本，结束=“”，冲洗=真）

与 client.messages.stream(
    型号=“claude-opus-4-7”，
    最大令牌数=64000,
    思考={"type": "自适应"},
    messages=[{"role": "user", "content": "分析这个问题"}]
) 作为流：
    对于流中的事件：
        if event.type == "content_block_start":
            if event.content_block.type == "思考":
                print("\n[思考...]")
            elif event.content_block.type == "文本":
                打印（“\n[响应：]”）

        elif event.type == "content_block_delta":
            if event.delta.type == "thinking_delta":
                打印（event.delta.thinking，end =“”，flush = True）
            elif event.delta.type == "text_delta":
                打印（event.delta.text，end =“”，flush = True）

与 client.messages.stream(
    型号=“claude-opus-4-7”，
    最大令牌数=64000,
    工具=工具，
    消息=消息
) 作为流：
    对于stream.text_stream中的文本：
        打印（文本，结束=“”，冲洗=真）

    响应=stream.get_final_message()
    # 如果 response.stop_reason == "tool_use" 则继续执行工具

与 client.messages.stream(
    型号=“claude-opus-4-7”，
    最大令牌数=64000,
    消息=[{“角色”：“用户”，“内容”：“你好”}]
) 作为流：
    对于stream.text_stream中的文本：
        打印（文本，结束=“”，冲洗=真）

    # 流式传输后获取完整消息
    最终消息=stream.get_final_message()
    print(f"\n\n使用的令牌：{final_message.usage.output_tokens}")

def stream_with_progress(客户端, **kwargs):
    """流式传输带有进度更新的响应。"""
    总代币 = 0
    内容部分 = []

    使用 client.messages.stream(**kwargs) 作为流：
        对于流中的事件：
            if event.type == "content_block_delta":
                如果 event.delta.type == "text_delta":
                    文本=事件.delta.文本
                    content_parts.append(文本)
                    打印（文本，结束=“”，冲洗=真）

            elif event.type == "message_delta":
                如果 event.usage 和 event.usage.output_tokens 不是 None：
                    Total_tokens = event.usage.output_tokens

        最终消息=stream.get_final_message()

    print(f"\n\n[使用的令牌：{total_tokens}]")
    返回“”.join(content_parts)

尝试：
    与 client.messages.stream(
        型号=“claude-opus-4-7”，
        最大令牌数=64000,
        messages=[{"role": "user", "content": "写一个故事"}]
    ) 作为流：
        对于stream.text_stream中的文本：
            打印（文本，结束=“”，冲洗=真）
除了 anthropic.APIConnectionError：
    print("\n连接丢失。请重试。")
除了 anthropic.RateLimitError：
    print("\n速率有限。请等待并重试。")
除了 anthropic.APIStatusError 为 e：
    print(f"\nAPI 错误: {e.status_code}")

### python/claude-api/tool-use.md

[下载 python/claude-api/tool-use.md](/skills/claude-api/python/claude-api/tool-use.md)

_二进制资源_

### python/托管代理/README.md

[下载 python/托管代理/README.md](/skills/claude-api/python/托管代理/README.md)

_二进制资源_

### ruby/claude-api.md

[下载 ruby​​/claude-api.md](/skills/claude-api/ruby/claude-api.md)

```markdown
# Claude API — Ruby

> **Note:** The Ruby SDK supports the Claude API. A tool runner is available in beta via `client.beta.messages.tool_runner()`. Agent SDK is not yet available for Ruby.

## Installation

```bash
gem 安装人类

要求“人为”

# 默认（使用 ANTHROPIC_API_KEY 环境变量）
客户端 = Anthropic::Client.new

# 显式 API 密钥
客户端 = Anthropic::Client.new(api_key: "your-api-key")

消息 = client.messages.create(
  型号：：“claude-opus-4-7”，
  最大令牌数：16000，
  消息：[
    { role: "user", content: "法国的首都是哪里？" }
  ]
）
# content 是多态块对象的数组（TextBlock、ThinkingBlock、
# 工具使用块，...）。.type 是一个符号 — 与:text 比较，而不是“text”。
# .text 在非 TextBlock 条目上引发 NoMethodError。
message.content.each 做 |block|
  如果 block.type ==:text 则放置 block.text
结束

流 = client.messages.stream(
  型号：：“claude-opus-4-7”，
  最大令牌数：64000，
  messages: [{ 角色: "用户", 内容: "写俳句" }]
）

Stream.text.each { |文本|打印（文本）}

类 GetWeatherInput < Anthropic::BaseModel
  必需：位置，字符串，文档：“城市和州，例如加利福尼亚州旧金山”
结束

类 GetWeather < Anthropic::BaseTool
  doc“获取某个位置的当前天气”

  input_schema GetWeatherInput

  def 调用（输入）
    “#{input.location} 天气晴朗，气温为 72°F。”
  结束
结束

客户端.beta.messages.tool_runner(
  型号：：“claude-opus-4-7”，
  最大令牌数：16000，
  工具：[GetWeather.new]，
  messages: [{ role: "user", content: "旧金山的天气怎么样？" }]
).each_message 执行 |message|
  放置消息.内容
结束

消息 = client.messages.create(
  型号：：“claude-opus-4-7”，
  最大令牌数：16000，
  系统_：[
    { 类型：“文本”，文本：long_system_prompt，cache_control：{ 类型：“短暂” } }
  ],
  messages: [{ role: "用户", content: "总结要点" }]
）

### ruby/托管代理/README.md

[下载 ruby​​/托管代理/README.md](/skills/claude-api/ruby/托管代理/README.md)

_二进制资源_

### 共享/代理设计.md

[下载shared/agent-design.md](/skills/claude-api/shared/agent-design.md)

_二进制资源_

### 共享/错误代码.md

[下载shared/error-codes.md](/skills/claude-api/shared/error-codes.md)

_二进制资源_

### 共享/live-sources.md

[下载shared/live-sources.md](/skills/claude-api/shared/live-sources.md)

_二进制资源_

### 共享/托管代理-api-reference.md

[下载共享/托管代理-api-reference.md](/skills/claude-api/shared/托管代理-api-reference.md)

_二进制资源_

### 共享/托管代理-客户端-patterns.md

[下载共享/托管代理-客户端-模式.md](/skills/claude-api/shared/托管代理-客户端-模式.md)

_二进制资源_

### 共享/托管代理-core.md

[下载共享/托管代理核心.md](/skills/claude-api/shared/托管代理核心.md)

_二进制资源_

### 共享/托管代理环境.md

[下载共享/托管代理环境.md](/skills/claude-api/shared/托管代理环境.md)

_二进制资源_

### 共享/托管代理事件.md

[下载共享/托管代理事件.md](/skills/claude-api/shared/托管代理事件.md)

_二进制资源_

### 共享/托管代理内存.md

[下载共享/托管代理内存.md](/skills/claude-api/shared/托管代理内存.md)

_二进制资源_

### 共享/托管代理-multiagent.md

[下载共享/托管代理-multiagent.md](/skills/claude-api/shared/托管代理-multiagent.md)

_二进制资源_

### 共享/托管代理-onboarding.md

[下载共享/托管代理-onboarding.md](/skills/claude-api/shared/托管代理-onboarding.md)

_二进制资源_

### 共享/托管代理结果.md

[下载共享/托管代理-结果.md](/skills/claude-api/shared/托管代理-结果.md)

_二进制资源_

### 共享/托管代理-overview.md

[下载共享/托管代理-overview.md](/skills/claude-api/shared/托管代理-overview.md)

_二进制资源_

### 共享/托管代理工具.md

[下载共享/托管代理工具.md](/skills/claude-api/shared/托管代理工具.md)

_二进制资源_

### 共享/托管代理-webhooks.md

[下载共享/托管代理-webhooks.md](/skills/claude-api/shared/托管代理-webhooks.md)

```markdown
# Managed Agents — Webhooks

Anthropic can POST to your HTTPS endpoint when a Managed Agents resource changes state — an alternative to holding an SSE stream or polling. Payloads are **thin** (event type + resource IDs only); on receipt, fetch the resource for current state. Every delivery is HMAC-signed.

> **Direction matters.** This page covers *Anthropic → you* notifications about session/vault state. It does **not** cover *third-party → you* webhooks that *trigger* a session (e.g. a GitHub push handler that calls `sessions.create()`) — that's ordinary application code on your side with no Anthropic-specific wire format.

---

## Register an endpoint (Console only)

Console → **Manage → Webhooks**. There is no programmatic endpoint-management API yet. Secret rotation is supported from the same page.

| Field | Constraint |
|---|---|
| URL | HTTPS on port 443, publicly resolvable hostname |
| Event types | Subscribe per `data.type` — you only receive subscribed types (plus test events) |
| Signing secret | `whsec_`-prefixed, 32 bytes, **shown once at creation** — store it |

---

## Verify the signature

Every delivery is HMAC-signed. **Use the SDK's `client.beta.webhooks.unwrap()`** — it verifies the signature, rejects payloads more than ~5 minutes old, and returns the parsed event. It reads the `whsec_` secret from `ANTHROPIC_WEBHOOK_SIGNING_KEY`.

```python
进口人择
从烧瓶导入烧瓶，请求

client = anthropic.Anthropic() # 从 env 读取 ANTHROPIC_WEBHOOK_SIGNING_KEY
应用程序=烧瓶（__名称__）


@app.route("/webhook",methods=["POST"])
def webhook():
    尝试：
        事件 = client.beta.webhooks.unwrap(
            request.get_data(as_text=True),
            headers=dict(request.headers),
        ）
    除了例外：
        返回“无效签名”，400

    if event.id in saw_event_ids: # 重复数据删除重试 — id 是每个事件，而不是每个交付
        返回“”，204
    saw_event_ids.add(event.id)

    匹配事件.数据.类型：
        案例“session.status_idled”：
            会话 = client.beta.sessions.retrieve(event.data.id)
            通知用户（会话）
        案例“vault_credential.refresh_failed”：
            Alert_oncall(事件.data.id)

    返回“”，204

{
  “类型”：“事件”，
  "id": "event_01ABC...",
  “创建时间”：“2026-03-18T14：05：22Z”，
  “数据”：{
    "type": "session.status_idled",
    "id": "session_01XYZ...",
    "organization_id": "8a3d2f1e-...",
    “workspace_id”：“c7b0e4d9-...”
  }
}

### 共享/模型迁移.md

[下载shared/model-migration.md](/skills/claude-api/shared/model-migration.md)

_二进制资源_

### 共享/models.md

[下载shared/models.md](/skills/claude-api/shared/models.md)

_二进制资源_

### 共享/提示缓存.md

[下载shared/prompt-caching.md](/skills/claude-api/shared/prompt-caching.md)

_二进制资源_

### 共享/工具使用概念.md

[下载shared/tool-use-concepts.md](/skills/claude-api/shared/tool-use-concepts.md)

_二进制资源_

### 打字稿/claude-api/README.md

[下载 typescript/claude-api/README.md](/skills/claude-api/typescript/claude-api/README.md)

_二进制资源_

### 打字稿/claude-api/batches.md

[下载 typescript/claude-api/batches.md](/skills/claude-api/typescript/claude-api/batches.md)

```markdown
# Message Batches API — TypeScript

The Batches API (`POST /v1/messages/batches`) processes Messages API requests asynchronously at 50% of standard prices.

## Key Facts

- Up to 100,000 requests or 256 MB per batch
- Most batches complete within 1 hour; maximum 24 hours
- Results available for 29 days after creation
- 50% cost reduction on all token usage
- All Messages API features supported (vision, tools, caching, etc.)

---

## Create a Batch

```typescript
从“@anthropic-ai/sdk”导入 Anthropic；

const client = new Anthropic();

const messageBatch = 等待 client.messages.batches.create({
  请求：[
    {
      custom_id: "请求-1",
      参数：{
        型号：“claude-opus-4-7”，
        最大令牌数：16000，
        消息：[
          { role: "user", content: "总结气候变化影响" },
        ],
      },
    },
    {
      custom_id: "请求-2",
      参数：{
        型号：“claude-opus-4-7”，
        最大令牌数：16000，
        消息：[
          { role: "user", content: "讲解量子计算基础知识" },
        ],
      },
    },
  ],
});

控制台.log(`Batch ID: ${messageBatch.id}`);
控制台.log(`Status: ${messageBatch.processing_status}`);

让批次；
而（真）{
  批处理=等待client.messages.batches.retrieve(messageBatch.id);
  if (batch.processing_status === "结束") 中断;
  控制台.日志(
   `Status: ${batch.processing_status}, processing: ${batch.request_counts.processing}`,
  ）；
  等待新的 Promise((resolve) => setTimeout(resolve, 60_000));
}

console.log("批量完成！");
控制台.log(`Succeeded: ${batch.request_counts.succeeded}`);
控制台.log(`Errored: ${batch.request_counts.errored}`);

对于等待（等待 client.messages.batches.results 的 const 结果（
  messageBatch.id,
））{
  开关（结果.结果.类型）{
    案例“成功”：
      控制台.日志(
       `[${result.custom_id}] ${result.result.message.content[0].text.slice(0, 100)}`,
      ）；
      休息;
    案例“错误”：
      if (result.result.error.type === "invalid_request") {
        控制台.log(`[${result.custom_id}] Validation error - fix and retry`);
      } 否则{
        控制台.log(`[${result.custom_id}] Server error - safe to retry`);
      }
      休息;
    案例“过期”：
      控制台.log(`[${result.custom_id}] Expired - resubmit`);
      休息;
  }
}

const 取消=等待 client.messages.batches.cancel(messageBatch.id);
控制台.log(`Status: ${cancelled.processing_status}`); //“取消”

### 打字稿/claude-api/files-api.md

[下载 typescript/claude-api/files-api.md](/skills/claude-api/typescript/claude-api/files-api.md)

```markdown
# Files API — TypeScript

The Files API uploads files for use in Messages API requests. Reference files via `file_id` in content blocks, avoiding re-uploads across multiple API calls.

**Beta:** Pass `betas: ["files-api-2025-04-14"]` in your API calls (the SDK sets the required header automatically).

## Key Facts

- Maximum file size: 500 MB
- Total storage: 100 GB per organization
- Files persist until deleted
- File operations (upload, list, delete) are free; content used in messages is billed as input tokens
- Not available on Amazon Bedrock or Google Vertex AI

---

## Upload a File

```typescript
从“@anthropic-ai/sdk”导入 Anthropic, { toFile };
从“fs”导入 fs；

const client = new Anthropic();

const uploaded = 等待 client.beta.files.upload({
  文件：await toFile（fs.createReadStream（“report.pdf”），未定义，{
    类型：“应用程序/pdf”，
  }),
  测试版：[“files-api-2025-04-14”]，
});

控制台.log(`File ID: ${uploaded.id}`);
控制台.log(`Size: ${uploaded.size_bytes} bytes`);

const 响应 = 等待 client.beta.messages.create({
  型号：“claude-opus-4-7”，
  最大令牌数：16000，
  消息：[
    {
      角色：“用户”，
      内容：[
        { type: "text", text: "总结本报告中的主要发现。" },
        {
          类型：“文档”，
          来源: { type: "file", file_id: uploaded.id },
          标题：“第四季度报告”，
          引用：{启用：true}，
        },
      ],
    },
  ],
  测试版：[“files-api-2025-04-14”]，
});

console.log(response.content[0].text);

const 文件 = 等待 client.beta.files.list({
  测试版：[“files-api-2025-04-14”]，
});
for (const f of files.data) {
  控制台.log(`${f.id}: ${f.filename} (${f.size_bytes} bytes)`);
}

等待 client.beta.files.delete("file_011CNha8iCJcU1wXNR6q4V8w", {
  测试版：[“files-api-2025-04-14”]，
});

const 响应 = 等待 client.beta.files.download(
  “file_011CNha8iCJcU1wXNR6q4V8w”，
  { betas: ["files-api-2025-04-14"] },
）；
const content = Buffer.from(await response.arrayBuffer());
等待 fs.promises.writeFile("output.txt", 内容);

### 打字稿/claude-api/streaming.md

[下载 typescript/claude-api/streaming.md](/skills/claude-api/typescript/claude-api/streaming.md)

```markdown
# Streaming — TypeScript

## Quick Start

```typescript
const 流 = client.messages.stream({
  型号：“claude-opus-4-7”，
  最大令牌数：64000，
  消息：[{角色：“用户”，内容：“写一个故事”}]，
});

for等待（流的常量事件）{
  如果（
    event.type ===“content_block_delta”&&
    event.delta.type ===“text_delta”
  ）{
    process.stdout.write(event.delta.text);
  }
}

const 流 = client.messages.stream({
  型号：“claude-opus-4-7”，
  最大令牌数：64000，
  思考：{ 类型：“自适应” }，
  messages: [{ role: "user", content: "分析这个问题" }],
});

for等待（流的常量事件）{
  开关（事件类型）{
    案例“content_block_start”：
      开关 (event.content_block.type) {
        案例“思考”：
          console.log("\n[思考...]");
          休息;
        案例“文本”：
          console.log("\n[响应:]");
          休息;
      }
      休息;
    案例“content_block_delta”：
      开关 (event.delta.type) {
        案例“thinking_delta”：
          process.stdout.write(event.delta.thinking);
          休息;
        案例“text_delta”：
          process.stdout.write(event.delta.text);
          休息;
      }
      休息;
  }
}

从“@anthropic-ai/sdk”导入 Anthropic；
从“@anthropic-ai/sdk/helpers/beta/zod”导入{ betaZodTool }；
从“zod”导入{z}；

const client = new Anthropic();

const getWeather = betaZodTool({
  名称：“获取天气”，
  描述：“获取某个位置的当前天气”，
  输入模式： z.object({
    location: z.string().describe("城市和州，例如加利福尼亚州旧金山"),
  }),
  运行： async ({ location }) =>`72°F and sunny in ${location}`，
});

const runner = client.beta.messages.toolRunner({
  型号：“claude-opus-4-7”，
  最大令牌数：64000，
  工具：[获取天气]、
  消息：[
    { role: "user", content: "巴黎和伦敦的天气怎么样？" },
  ],
  流：真实，
});

// 外循环：每个工具运行器迭代
for wait (runner 的 const messageStream) {
  // 内部循环：本次迭代的流事件
  for wait (messageStream 的 const 事件) {
    开关（事件类型）{
      案例“content_block_delta”：
        开关 (event.delta.type) {
          案例“text_delta”：
            process.stdout.write(event.delta.text);
            休息;
          案例“input_json_delta”：
            // 工具输入正在流式传输
            打破；
        }
        休息;
    }
  }
}

const 流 = client.messages.stream({
  型号：“claude-opus-4-7”，
  最大令牌数：64000，
  消息：[{角色：“用户”，内容：“你好”}]，
});

for等待（流的常量事件）{
  // 处理事件...
}

const FinalMessage =等待流.finalMessage();
控制台.log(`Tokens used: ${finalMessage.usage.output_tokens}`);

事件：message_start
数据：{“type”：“message_start”，“message”：{“id”：“msg_...”，“type”：“message”，...}}

事件：内容块开始
数据：{“type”：“content_block_start”，“index”：0，“content_block”：{“type”：“text”，“text”：“”}}

事件：内容块增量
数据：{“type”：“content_block_delta”，“index”：0，“delta”：{“type”：“text_delta”，“text”：“你好”}}

事件：内容块停止
数据：{“类型”：“content_block_stop”，“索引”：0}

事件：message_delta
数据：{“type”：“message_delta”，“delta”：{“stop_reason”：“end_turn”}，“usage”：{“output_tokens”：12}}

事件：message_stop
数据：{“type”：“message_stop”}

### 打字稿/claude-api/tool-use.md

[下载 typescript/claude-api/tool-use.md](/skills/claude-api/typescript/claude-api/tool-use.md)

_二进制资源_

### 打字稿/托管代理/README.md

[下载 typescript/托管代理/README.md](/skills/claude-api/typescript/托管代理/README.md)

_二进制资源_

## 参见 GitHub

[参见 GitHub](https://github.com/anthropics/skills/tree/main/claude-api)