@nvae/llmswitch 0.6.0 → 0.8.0

package/README.md

@@ -146,6 +146,216 @@ llms bridge reload claude
 llms bridge reload codex --profile my-provider
 ```
 
+### 8. 对外提供 AI 网关
+
+Bridge 服务的是本机的 Claude Code / Codex / OpenCode。如果要让**第三方客户端**通过一个端口访问你配置的模型，用 gateway：
+
+```bash
+# 1. 准备供应商（可从已有工具配置导入，按上游去重）
+llms gateway provider import
+# 或手动添加（自动探测接口类型与模型列表）
+llms gateway provider add
+
+# 2. 创建网关 API Key（明文只显示一次，请立即保存）
+llms gateway key create --name my-app
+
+# 3. 启动网关
+llms gateway start
+
+# 4. 查看状态与可路由模型
+llms gateway status
+llms gateway models
+```
+
+默认监听 `127.0.0.1:17900`。第三方客户端直接把它当成 OpenAI 或 Anthropic 端点使用：
+
+```bash
+# OpenAI 格式
+curl http://127.0.0.1:17900/v1/chat/completions \
+  -H "Authorization: Bearer llmsk-..." \
+  -H "Content-Type: application/json" \
+  -d '{"model":"deepseek-chat","messages":[{"role":"user","content":"hi"}]}'
+
+# Anthropic 格式（同一个上游，网关自动转换）
+curl http://127.0.0.1:17900/v1/messages \
+  -H "x-api-key: llmsk-..." \
+  -H "Content-Type: application/json" \
+  -d '{"model":"deepseek-chat","max_tokens":1024,"messages":[{"role":"user","content":"hi"}]}'
+```
+
+**任意入口格式 ↔ 任意上游格式**。三种入口（OpenAI Chat、OpenAI Responses、Anthropic Messages）与三种上游格式可自由组合，含流式与工具调用；入口与上游格式相同时原样透传，避免无谓的转换损耗。已知限制：OpenAI Responses 的有状态特性（`previous_response_id`、`store`、后台模式）只在同格式透传时可用，跨格式转换不支持。
+
+上游地址默认拼 `/v1` 前缀；非标准路径的上游可自定义：
+
+```bash
+# 直连 baseUrl（如 Gemini OpenAI 兼容端点 …/v1beta/openai）
+llms gateway provider add --path-prefix ""
+# 自定义前缀
+llms gateway provider edit my-provider --path-prefix v2
+```
+
+| 端点 | 说明 |
+| --- | --- |
+| `GET /v1/models` | 可路由模型列表（按 Key 作用域过滤） |
+| `GET /v1/models/{id}` | 单个模型详情（OpenAI 客户端兼容） |
+| `POST /v1/chat/completions` | OpenAI Chat Completions |
+| `POST /v1/completions` | Legacy Text Completions（`prompt` 自动转为消息） |
+| `POST /v1/messages` | Anthropic Messages |
+| `POST /v1/messages/count_tokens` | Anthropic 上游走原生接口，其他上游本地计算（见下） |
+| `POST /v1/responses` | OpenAI Responses |
+| `POST /v1/embeddings` | 仅 OpenAI 兼容上游 |
+| `GET /health` | 存活探针（无需鉴权，不含任何配置信息） |
+
+每个响应都带 `x-request-id`（客户端可传入以关联日志），并转发到上游，方便全链路排查。
+
+**模型路由解析顺序**：
+
+1. 显式别名（`llms gateway route add`）
+2. 限定写法 `provider/model` 或 `provider:model`
+3. 裸模型 id（在某个 provider 的模型列表中）
+4. 未声明模型列表的 provider（作为 passthrough 兜底）
+5. `config set --default-provider` 指定的兜底供应商
+
+多个供应商提供同一模型时，按 `priority` 升序排列，自动构成 fallback 链：
+
+```bash
+# 别名 + 显式 fallback
+llms gateway route add gpt-4o --provider azure --model gpt-4o-2024-11 --fallback openrouter/openai/gpt-4o
+
+# 查看某个模型 id 的实际路由顺序
+llms gateway resolve gpt-4o
+```
+
+**Provider fallback**：上游返回 429/5xx 等可重试状态或连接失败时自动换下一个供应商。响应一旦开始写出（流式首帧之后）便不再切换，避免给客户端拼接两段不一致的输出。
+
+```bash
+llms gateway config set --fallback true --max-attempts 3 --retry-statuses 429,500,502,503,504
+```
+
+**熔断冷却**：连续失败的上游会进入指数退避冷却（5s 起，封顶 2 分钟），冷却期内路由直接跳过它；全部候选都在冷却时仍会照常尝试。`llms gateway status` 会显示当前冷却中的供应商。
+
+```bash
+# 测试供应商连通性（拉模型列表；--call 额外发一次 1-token 补全）
+llms gateway provider test my-provider --call
+
+# 从上游重新拉取模型列表
+llms gateway provider refresh-models my-provider
+
+# 自定义上游请求头（可重复传）
+llms gateway provider edit my-provider --header "X-Title: my-app"
+```
+
+**API Key 管理**：仅存储哈希，支持作用域、限额、过期、编辑与换发。
+
+```bash
+# 限定供应商、模型、接口格式与速率
+llms gateway key create --name partner \
+  --providers deepseek --models deepseek-chat \
+  --formats openai-chat --rate-limit 60 --expires-in-days 30 \
+  --daily-requests 5000
+
+llms gateway key list
+llms gateway key edit <id> --rate-limit 120          # 改限额/作用域/续期
+llms gateway key rotate <id>                          # 换发明文，旧 Key 立即失效
+llms gateway key revoke <id>
+```
+
+作用域说明：`--models` 按"客户端请求里的模型写法"匹配——限定别名就只用别名拼写访问，限定 `provider/model` 则两种写法都可；拼写错误在创建时会收到警告。
+
+**限流**：计数持久化在 `gateway/rate-limit.json`，重启不丢失，多个网关进程共享同一份计数。响应会带标准限流头，客户端可据此自行退避：
+
+```
+X-RateLimit-Limit: 60
+X-RateLimit-Remaining: 59
+X-RateLimit-Reset: 1787894760
+Retry-After: 43          # 仅 429 时出现
+```
+
+```bash
+# 默认限额（Key 未单独设置时生效）
+llms gateway config set --rate-limit 120
+
+# 查看各 Key 当前窗口用量 / 清空计数
+llms gateway ratelimit show
+llms gateway ratelimit reset
+```
+
+`--rate-limit` 的语义：`-1` 完全不限流（豁免全局默认），`0` 继承全局默认，`> 0` 硬上限；`--daily-requests` 额外提供按 UTC 日的请求配额。
+
+计数文件读写有锁保护；极端争用下拿不到锁时会放行请求而非阻塞流量，宁可限额略松也不卡住线上调用。
+
+**Token 计数**：`count_tokens` 优先走上游原生接口（Anthropic 格式上游），拿不到时在本地计算并在 `llm_switch` 字段里说明来源：
+
+```json
+{
+  "input_tokens": 1234,
+  "llm_switch": {
+    "estimated": true,
+    "reason": "upstream_not_anthropic",
+    "method": "heuristic",
+    "breakdown": { "text": 30, "images": 1190, "tools": 0, "overhead": 14 }
+  }
+}
+```
+
+本地计算分两档：
+
+- `heuristic`（默认，无额外依赖）：按书写系统分别计数（中日韩、拉丁、数字各有不同的字符/token 比），再加上每条消息、每个工具 schema 与请求信封的结构开销。实测对中英日韩散文、JSON 与表情符号的平均绝对误差约 11%，且绝大多数样本偏高而非偏低——用于判断"这个请求装不装得下"时偏保守更安全。标点密集的源码是已知弱项，可能低估约 15%。
+- `tokenizer`（可选，精确）：装上 `gpt-tokenizer` 后自动启用，对 OpenAI 系编码是精确值，其他词表下也比启发式更接近。
+
+```bash
+# 需要精确计数时自行安装，llmswitch 不强制依赖它
+npm install -g gpt-tokenizer
+
+# 强制使用启发式
+export LLM_SWITCH_DISABLE_TOKENIZER=1
+```
+
+两档都会额外计入图片开销：从 base64 头部解析 PNG / JPEG / GIF / WebP 的真实像素尺寸，按 `宽 × 高 / 750` 折算；无法判定尺寸时（例如 URL 图片）按保守值计入。
+
+**用量统计**：网关按天记录每个（Key / 供应商 / 模型）组合的请求数与 token 用量，持久化在 `gateway/usage.json`（保留 90 天）：
+
+```bash
+llms gateway usage --days 7
+llms gateway usage --json
+llms gateway usage reset
+```
+
+**日志**：写入 `~/.config/llm-switch/gateway/gateway.log`，仅记录 Key 的 id，不记录明文或上游密钥；每行含 `req=<request-id>` 可与客户端和上游日志关联。启动时若超过 10MB 自动轮转为 `gateway.log.old`：
+
+```bash
+llms gateway logs              # 最后 100 行
+llms gateway logs --lines 500
+llms gateway logs --follow     # 持续跟踪
+```
+
+**运行时限额**（超时/并发/请求体大小）通过环境变量调整，与 Bridge 共用：
+
+| 环境变量 | 默认 | 说明 |
+| --- | --- | --- |
+| `LLM_SWITCH_MAX_CONCURRENCY` | 16 | 最大并发请求数 |
+| `LLM_SWITCH_MAX_BODY_BYTES` | 16MB | 请求体上限 |
+| `LLM_SWITCH_MAX_RESPONSE_BYTES` | 32MB | 上游响应上限 |
+| `LLM_SWITCH_CONNECT_TIMEOUT_MS` | 30000 | 上游连接超时 |
+| `LLM_SWITCH_IDLE_TIMEOUT_MS` | 90000 | 流式空闲超时 |
+| `LLM_SWITCH_TOTAL_TIMEOUT_MS` | 600000 | 单请求总超时 |
+
+`llms gateway config show` 会一并显示当前生效值。
+
+**对外暴露的安全要求**：默认只绑回环地址。绑到非回环地址必须显式传 `--allow-remote`，且至少存在一个有效 API Key，否则拒绝启动。
+
+```bash
+llms gateway start --host 0.0.0.0 --allow-remote
+```
+
+网关只提供明文 HTTP，请放在反向代理（Nginx / Caddy）后面终止 TLS，不要把裸 HTTP 直接暴露到公网。浏览器直连需显式开启 CORS（已允许 `anthropic-beta` 等请求头，并暴露限流与 request-id 响应头）：
+
+```bash
+llms gateway config set --cors-origins https://app.example.com
+```
+
+日志写入 `~/.config/llm-switch/gateway/gateway.log`，仅记录 Key 的 id，不记录明文或上游密钥。
+
 ---
 
 ## 常用命令
@@ -161,6 +371,15 @@ llms bridge reload codex --profile my-provider
 | `llms <tool> model` | 选择模型 |
 | `llms launch/run <tool> [model]` | 启动工具 |
 | `llms bridge status` | 查看 Bridge 状态 |
+| `llms gateway start` | 启动对外 AI 网关 |
+| `llms gateway provider import` | 从工具配置导入网关供应商 |
+| `llms gateway provider test <name>` | 测试供应商连通性 |
+| `llms gateway key create` | 创建网关 API Key |
+| `llms gateway key rotate <id>` | 换发 API Key |
+| `llms gateway status` | 查看网关状态 |
+| `llms gateway ratelimit show` | 查看各 Key 限流用量 |
+| `llms gateway usage` | 查看按天聚合的用量统计 |
+| `llms gateway logs` | 查看网关日志 |
 | `llms path` | 查看数据目录 |
 
 `<tool>` 可选 `claude`、`codex`、`opencode`。
@@ -179,6 +398,7 @@ llms launch --help
 | 数据 | 位置 |
 | --- | --- |
 | llmswitch 配置 | `~/.config/llm-switch/` |
+| 网关供应商 / Key / 日志 | `~/.config/llm-switch/gateway/` |
 | Claude Code | `~/.claude/settings.json` |
 | Codex | `~/.codex/config.toml` |
 | OpenCode | `~/.config/opencode/opencode.json` |

package/dist/adapters/opencode.js

@@ -6,6 +6,7 @@ import { atomicWriteFile, backupFile, ensureDir } from "../utils/fs.js";
 import { applyProxyToEnvRecord, clearProxyEnvKeys } from "../utils/proxy.js";
 import { getBackupsDir, getOpenCodeAuthPath, getOpenCodeConfigDir, getOpenCodeConfigPath, } from "../utils/paths.js";
 import { setActiveProfile } from "../store/profiles.js";
+import { ensureBridgeForProfile, profileNeedsBridge, } from "../bridge/manager.js";
 function providerId(name) {
     return `llms-${name}`.replace(/[^a-zA-Z0-9_-]/g, "-");
 }
@@ -30,7 +31,7 @@ export function readOpenCodeAuth(path = getOpenCodeAuthPath()) {
         return {};
     return JSON.parse(readFileSync(path, "utf8"));
 }
-export function buildOpenCodeProviderBlock(profile) {
+export function buildOpenCodeProviderBlock(profile, overrides) {
     const models = {};
     for (const id of profile.models.list) {
         models[id] = { name: id };
@@ -39,10 +40,12 @@ export function buildOpenCodeProviderBlock(profile) {
         models[profile.models.default] = { name: profile.models.default };
     }
     const options = {
-        baseURL: normalizeBaseUrlForFormat(profile.apiFormat, profile.baseUrl),
+        baseURL: overrides?.baseURL ||
+            normalizeBaseUrlForFormat(profile.apiFormat, profile.baseUrl),
     };
-    if (profile.apiKey) {
-        options.apiKey = profile.apiKey;
+    const apiKey = overrides?.apiKey ?? profile.apiKey;
+    if (apiKey) {
+        options.apiKey = apiKey;
     }
     if (profile.headers && Object.keys(profile.headers).length > 0) {
         options.headers = { ...profile.headers };
@@ -54,19 +57,23 @@ export function buildOpenCodeProviderBlock(profile) {
         models,
     };
 }
-export function buildOpenCodeConfig(existing, profile) {
+export function buildOpenCodeConfig(existing, profile, overrides) {
     assertCompatible("opencode", profile.apiFormat);
     const id = providerId(profile.name);
     const providers = {
         ...(existing.provider || {}),
     };
-    providers[id] = buildOpenCodeProviderBlock(profile);
-    // Optional top-level env for proxy (OpenCode may pass through)
+    providers[id] = buildOpenCodeProviderBlock(profile, overrides);
+    // Optional top-level env for proxy (OpenCode may pass through). When the
+    // profile routes through the bridge, the upstream proxy is applied inside the
+    // bridge; skip env-var proxy injection so OpenCode doesn't apply its own.
     const env = {
         ...(existing.env || {}),
     };
     clearProxyEnvKeys(env);
-    applyProxyToEnvRecord(env, profile.proxy);
+    if (!overrides) {
+        applyProxyToEnvRecord(env, profile.proxy);
+    }
     const next = {
         ...existing,
         $schema: existing.$schema || "https://opencode.ai/config.json",
@@ -92,18 +99,25 @@ export function buildOpenCodeAuth(existing, profile) {
     }
     return next;
 }
-export function applyOpenCodeProfile(profile) {
+export async function applyOpenCodeProfile(profile) {
     assertCompatible("opencode", profile.apiFormat);
     ensureDir(getOpenCodeConfigDir());
     ensureDir(dirname(getOpenCodeAuthPath()));
+    let bridgeConnection = null;
+    if (profileNeedsBridge(profile)) {
+        bridgeConnection = await ensureBridgeForProfile(profile, "opencode");
+    }
     const configPath = getOpenCodeConfigPath();
     const authPath = getOpenCodeAuthPath();
     const existing = readOpenCodeConfig(configPath);
     const backupPath = backupFile(configPath, getBackupsDir("opencode"), "opencode");
     backupFile(authPath, getBackupsDir("opencode"), "auth");
-    const nextConfig = buildOpenCodeConfig(existing, profile);
+    const nextConfig = buildOpenCodeConfig(existing, profile, bridgeConnection
+        ? { baseURL: bridgeConnection.baseUrl, apiKey: bridgeConnection.clientToken }
+        : undefined);
     atomicWriteFile(configPath, JSON.stringify(nextConfig, null, 2) + "\n");
-    const nextAuth = buildOpenCodeAuth(readOpenCodeAuth(authPath), profile);
+    const bridgeApiKey = bridgeConnection?.clientToken || profile.apiKey;
+    const nextAuth = buildOpenCodeAuth(readOpenCodeAuth(authPath), { ...profile, apiKey: bridgeApiKey });
     atomicWriteFile(authPath, JSON.stringify(nextAuth, null, 2) + "\n");
     setActiveProfile("opencode", profile.name);
     return {
@@ -111,7 +125,9 @@ export function applyOpenCodeProfile(profile) {
         profile: profile.name,
         configPath,
         backupPath,
-        restartHint: "请重新启动 OpenCode 会话以使配置与代理生效。",
+        restartHint: bridgeConnection
+            ? "已通过本地 bridge 启用供应商（上游代理在 bridge 内生效）。请重新启动 OpenCode 会话使配置生效。"
+            : "请重新启动 OpenCode 会话以使配置与代理生效。",
     };
 }
 export function deactivateOpenCodeProfile(profileName) {

package/dist/bridge/anthropic-to-chat-response.js

@@ -0,0 +1,332 @@
+/**
+ * Translate Anthropic Messages responses (stream/non-stream) → OpenAI Chat
+ * Completions.
+ *
+ * Reverse direction of `anthropic-translate-response.ts`. Used by the gateway
+ * when an Anthropic upstream must be presented in Chat Completions shape (the
+ * gateway's hub format).
+ */
+function newId(prefix) {
+    return `${prefix}-${Date.now().toString(36)}${Math.random().toString(36).slice(2, 10)}`;
+}
+function asRecord(value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return null;
+}
+function numberOr(value, fallback = 0) {
+    return typeof value === "number" ? value : fallback;
+}
+/** Anthropic stop_reason → Chat Completions finish_reason. */
+export function anthropicStopReasonToFinishReason(reason) {
+    switch (reason) {
+        case "tool_use":
+            return "tool_calls";
+        case "max_tokens":
+            return "length";
+        case "refusal":
+            return "content_filter";
+        case "end_turn":
+        case "stop_sequence":
+            return "stop";
+        default:
+            return reason == null ? null : "stop";
+    }
+}
+function mapUsage(usage) {
+    if (!usage)
+        return undefined;
+    const prompt = numberOr(usage.input_tokens);
+    const completion = numberOr(usage.output_tokens);
+    const out = {
+        prompt_tokens: prompt,
+        completion_tokens: completion,
+        total_tokens: prompt + completion,
+    };
+    const cacheRead = usage.cache_read_input_tokens;
+    const cacheWrite = usage.cache_creation_input_tokens;
+    if (typeof cacheRead === "number") {
+        out.prompt_tokens_details = { cached_tokens: cacheRead };
+    }
+    if (typeof cacheWrite === "number") {
+        out.cache_creation_input_tokens = cacheWrite;
+    }
+    return out;
+}
+function stringifyToolInput(input) {
+    if (typeof input === "string")
+        return input;
+    try {
+        return JSON.stringify(input ?? {});
+    }
+    catch {
+        return "{}";
+    }
+}
+/** Non-streaming Anthropic message → Chat Completions object. */
+export function anthropicMessageToChatCompletion(message, fallbackModel = "") {
+    const blocks = Array.isArray(message.content) ? message.content : [];
+    const textParts = [];
+    const thinkingParts = [];
+    const toolCalls = [];
+    for (const raw of blocks) {
+        const block = asRecord(raw);
+        if (!block)
+            continue;
+        const type = String(block.type || "");
+        if (type === "text" && typeof block.text === "string") {
+            textParts.push(block.text);
+            continue;
+        }
+        if (type === "thinking" && typeof block.thinking === "string") {
+            thinkingParts.push(block.thinking);
+            continue;
+        }
+        if (type === "tool_use") {
+            toolCalls.push({
+                index: toolCalls.length,
+                id: String(block.id || newId("call")),
+                type: "function",
+                function: {
+                    name: String(block.name || "tool"),
+                    arguments: stringifyToolInput(block.input),
+                },
+            });
+        }
+    }
+    const chatMessage = {
+        role: "assistant",
+        content: textParts.length ? textParts.join("") : null,
+    };
+    if (thinkingParts.length) {
+        chatMessage.reasoning_content = thinkingParts.join("");
+    }
+    if (toolCalls.length)
+        chatMessage.tool_calls = toolCalls;
+    const finishReason = anthropicStopReasonToFinishReason(message.stop_reason) ??
+        (toolCalls.length ? "tool_calls" : "stop");
+    const out = {
+        id: typeof message.id === "string" && message.id
+            ? message.id.replace(/^msg_/, "chatcmpl-")
+            : newId("chatcmpl"),
+        object: "chat.completion",
+        created: Math.floor(Date.now() / 1000),
+        model: String(message.model || fallbackModel || ""),
+        choices: [
+            {
+                index: 0,
+                message: chatMessage,
+                finish_reason: finishReason,
+                logprobs: null,
+            },
+        ],
+    };
+    const usage = mapUsage(asRecord(message.usage));
+    if (usage)
+        out.usage = usage;
+    return out;
+}
+export function createAnthropicToChatStreamState(model, options = {}) {
+    return {
+        id: newId("chatcmpl"),
+        model,
+        created: Math.floor(Date.now() / 1000),
+        blocks: new Map(),
+        nextToolIndex: 0,
+        roleEmitted: false,
+        finishReason: null,
+        inputTokens: 0,
+        outputTokens: 0,
+        hasUsage: false,
+        completed: false,
+        includeUsage: options.includeUsage !== false,
+    };
+}
+function chunk(state, delta, finishReason = null) {
+    return {
+        id: state.id,
+        object: "chat.completion.chunk",
+        created: state.created,
+        model: state.model,
+        choices: [
+            {
+                index: 0,
+                delta,
+                finish_reason: finishReason,
+                logprobs: null,
+            },
+        ],
+    };
+}
+function ensureRole(state, out) {
+    if (state.roleEmitted)
+        return;
+    state.roleEmitted = true;
+    out.push(chunk(state, { role: "assistant", content: "" }));
+}
+/**
+ * Parse one Anthropic SSE line into an event object. Anthropic sends
+ * `event: <name>` followed by `data: {...}`; the JSON payload carries `type`,
+ * so only data lines are meaningful.
+ */
+export function parseAnthropicSseLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("data:"))
+        return null;
+    const data = trimmed.slice(5).trim();
+    if (!data)
+        return null;
+    if (data === "[DONE]")
+        return "done";
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export class AnthropicStreamError extends Error {
+    errorType;
+    constructor(message, errorType = "api_error") {
+        super(message);
+        this.errorType = errorType;
+        this.name = "AnthropicStreamError";
+    }
+}
+/**
+ * Convert one Anthropic SSE event into zero or more Chat Completions chunks.
+ * Throws `AnthropicStreamError` when the upstream emits an error event.
+ */
+export function anthropicEventToChatChunks(event, state) {
+    const out = [];
+    const type = String(event.type || "");
+    switch (type) {
+        case "message_start": {
+            const message = asRecord(event.message);
+            if (message) {
+                if (typeof message.model === "string" && message.model) {
+                    state.model = message.model;
+                }
+                if (typeof message.id === "string" && message.id) {
+                    state.id = message.id.replace(/^msg_/, "chatcmpl-");
+                }
+                const usage = asRecord(message.usage);
+                if (usage) {
+                    state.inputTokens = numberOr(usage.input_tokens, state.inputTokens);
+                    state.outputTokens = numberOr(usage.output_tokens, state.outputTokens);
+                    state.hasUsage = true;
+                }
+            }
+            ensureRole(state, out);
+            return out;
+        }
+        case "content_block_start": {
+            ensureRole(state, out);
+            const index = numberOr(event.index, -1);
+            const block = asRecord(event.content_block);
+            if (!block || index < 0)
+                return out;
+            if (String(block.type || "") !== "tool_use")
+                return out;
+            const toolIndex = state.nextToolIndex++;
+            const id = String(block.id || newId("call"));
+            const name = String(block.name || "tool");
+            state.blocks.set(index, { toolIndex, id, name });
+            out.push(chunk(state, {
+                tool_calls: [
+                    {
+                        index: toolIndex,
+                        id,
+                        type: "function",
+                        function: { name, arguments: "" },
+                    },
+                ],
+            }));
+            return out;
+        }
+        case "content_block_delta": {
+            ensureRole(state, out);
+            const delta = asRecord(event.delta);
+            if (!delta)
+                return out;
+            const deltaType = String(delta.type || "");
+            if (deltaType === "text_delta" && typeof delta.text === "string") {
+                if (delta.text)
+                    out.push(chunk(state, { content: delta.text }));
+                return out;
+            }
+            if (deltaType === "thinking_delta" && typeof delta.thinking === "string") {
+                if (delta.thinking) {
+                    out.push(chunk(state, { reasoning_content: delta.thinking }));
+                }
+                return out;
+            }
+            if (deltaType === "input_json_delta" &&
+                typeof delta.partial_json === "string") {
+                const index = numberOr(event.index, -1);
+                const entry = state.blocks.get(index);
+                if (!entry || !delta.partial_json)
+                    return out;
+                out.push(chunk(state, {
+                    tool_calls: [
+                        {
+                            index: entry.toolIndex,
+                            function: { arguments: delta.partial_json },
+                        },
+                    ],
+                }));
+            }
+            return out;
+        }
+        case "message_delta": {
+            const delta = asRecord(event.delta);
+            const finish = anthropicStopReasonToFinishReason(delta?.stop_reason);
+            if (finish)
+                state.finishReason = finish;
+            const usage = asRecord(event.usage);
+            if (usage) {
+                state.outputTokens = numberOr(usage.output_tokens, state.outputTokens);
+                state.inputTokens = numberOr(usage.input_tokens, state.inputTokens);
+                state.hasUsage = true;
+            }
+            return out;
+        }
+        case "message_stop":
+            return finishAnthropicToChatStream(state);
+        case "error": {
+            const error = asRecord(event.error);
+            throw new AnthropicStreamError(String(error?.message || "上游 Anthropic 流返回错误"), String(error?.type || "api_error"));
+        }
+        default:
+            // ping / content_block_stop / unknown events carry no chat payload.
+            return out;
+    }
+}
+function finishAnthropicToChatStream(state) {
+    if (state.completed)
+        return [];
+    state.completed = true;
+    const out = [];
+    const finishReason = state.finishReason || (state.blocks.size ? "tool_calls" : "stop");
+    out.push(chunk(state, {}, finishReason));
+    if (state.includeUsage && state.hasUsage) {
+        out.push({
+            id: state.id,
+            object: "chat.completion.chunk",
+            created: state.created,
+            model: state.model,
+            choices: [],
+            usage: {
+                prompt_tokens: state.inputTokens,
+                completion_tokens: state.outputTokens,
+                total_tokens: state.inputTokens + state.outputTokens,
+            },
+        });
+    }
+    return out;
+}
+/** Emit the terminal chunks when the upstream stream ends without message_stop. */
+export function forceCompleteAnthropicToChatStream(state) {
+    return finishAnthropicToChatStream(state);
+}