dsh-router-core 0.4.5 → 0.4.7

package/lib/index.js

@@ -10,6 +10,19 @@ import { homedir } from "node:os";
 //#region src/shared.ts
 /** Same-origin API base the client panel fetches (host half serves it). */
 const ROUTER_API_BASE = "/router/api";
+/**
+* 外部 OpenAI 兼容客户端的归因标签（`/v1` 没有宿主内部头 `x-dsh-router-session`
+* 时的兜底）——否则 usage 记录里全是匿名流量，出事反查不出是谁在打
+* （2026-10-15 实测：296 条匿名记录对不上任何会话）。
+*
+* 取值优先级：`user`（OpenAI 标准终端用户字段）→ `prompt_cache_key`
+* （Zed 等客户端的缓存键，常带线程粒度）→ `User-Agent`（保底到客户端粒度）。
+* 值截断到 64 字符；三者皆无返回 undefined（保持匿名）。
+*/
+function clientIdentityOf(body, userAgent) {
+	const tag = (kind, v) => typeof v === "string" && v !== "" ? `ext/${kind}:${v.slice(0, 64)}` : void 0;
+	return tag("user", body.user) ?? tag("cache", body.prompt_cache_key) ?? (userAgent !== void 0 && userAgent !== "" ? `ext/ua:${userAgent.slice(0, 64)}` : void 0);
+}
 //#endregion
 //#region src/router/prefix-affinity.ts
 /**
@@ -116,7 +129,9 @@ const MINUTE = 6e4;
 *
 * 冷却策略对齐 9router 的 accountFallback / errorConfig：
 *  - `rate_limit` 用**指数退避**（9router 的 `backoff: true`）：偶发限流只
-*    短冷，持续限流越退越久，比固定 1 分钟两头不讨好要准。
+*    短冷，持续限流越退越久，比固定 1 分钟两头不讨好要准。上游自己声明了
+*    **重置时刻**（resetAt，如 6004「将在 … 重置」）时冷到该点——频率配额是
+*    小时级的，退避上限（5min）只会到点回来再撞。
 *  - 未知/瞬时错误用**瞬时短冷却**（9router 默认分支 TRANSIENT_COOLDOWN_MS）：
 *    每次失败都冻结，坏号不会留在池里被下一个请求再选中。
 *
@@ -473,8 +488,13 @@ var AccountPool = class {
 	blockKey(modelId) {
 		return `${this.supplierId}${SEP}${modelId}`;
 	}
-	/** 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。 */
-	noteFailure(uid, modelId, state, message) {
+	/**
+	* 记录一次失败：按状态处置（冷却/退避），落在「(模型, 连接)」这个冷却单元上。
+	* `resetAt` = 上游声明的重置时刻（epoch ms）：限流退避优先冷到该点——
+	* 频率配额是小时级的，5min 上限的指数退避只会到点回来再撞 6004，
+	* 把号轮流打冷（2026-10-15 的 11 号全灭事故）。
+	*/
+	noteFailure(uid, modelId, state, message, resetAt) {
 		const rule = RULES[state];
 		if (rule.cooldown === 0) return;
 		if (state === "session_dead") {
@@ -488,7 +508,9 @@ var AccountPool = class {
 		e.reason = message;
 		if (rule.cooldown === "backoff") {
 			e.backoffLevel = Math.min(e.backoffLevel + 1, BACKOFF_MAX_LEVEL);
-			e.until = Math.max(e.until, Date.now() + backoffMs(e.backoffLevel));
+			const backoffUntil = Date.now() + backoffMs(e.backoffLevel);
+			const until = resetAt !== void 0 && resetAt > Date.now() ? resetAt : backoffUntil;
+			e.until = Math.max(e.until, until);
 			return;
 		}
 		if (rule.cooldown === "transient") {
@@ -1185,7 +1207,7 @@ function top(map) {
 //#endregion
 //#region src/router/usage-tokens.ts
 /** 取有限数，其余当 0（NaN 会毒穿整个累加：`Math.max(x, NaN) === NaN`）。 */
-function num(v) {
+function num$1(v) {
 	const n = Number(v);
 	return Number.isFinite(n) ? n : 0;
 }
@@ -1209,10 +1231,10 @@ function num(v) {
 function normalizeUsage(raw) {
 	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
 	const u = raw;
-	const cached = num(u.cached_tokens) + num(u.cache_read_input_tokens) + num(u.cachedContentTokenCount) + num(u.prompt_tokens_details?.cached_tokens);
-	let prompt = num(u.prompt_tokens) + num(u.input_tokens) + num(u.promptTokenCount);
-	if (u.cache_read_input_tokens !== void 0 && u.prompt_tokens === void 0) prompt += num(u.cache_read_input_tokens);
-	const completion = num(u.completion_tokens) + num(u.output_tokens) + num(u.candidatesTokenCount);
+	const cached = num$1(u.cached_tokens) + num$1(u.cache_read_input_tokens) + num$1(u.cachedContentTokenCount) + num$1(u.prompt_tokens_details?.cached_tokens);
+	let prompt = num$1(u.prompt_tokens) + num$1(u.input_tokens) + num$1(u.promptTokenCount);
+	if (u.cache_read_input_tokens !== void 0 && u.prompt_tokens === void 0) prompt += num$1(u.cache_read_input_tokens);
+	const completion = num$1(u.completion_tokens) + num$1(u.output_tokens) + num$1(u.candidatesTokenCount);
 	if (prompt === 0 && completion === 0 && cached === 0) return null;
 	return {
 		promptTokens: prompt,
@@ -1423,23 +1445,2209 @@ function tapStreamUsage(source, startedAt) {
 	};
 }
 /**
-* 补齐估算：上游没给的字段用字符数估，并打标记。
+* 补齐估算：上游没给的字段用字符数估，并打标记。
+*
+* `requestChars` = 请求体字符数（估输入），`outputChars` = 输出字符数（估输出）。
+* 上游给了的字段**不覆盖**——估算只填空，不抢真数据。
+*/
+function withEstimates(usage, requestChars, outputChars) {
+	const prompt = usage?.promptTokens ?? 0;
+	const completion = usage?.completionTokens ?? 0;
+	const inputEstimated = prompt === 0;
+	const outputEstimated = completion === 0;
+	return {
+		promptTokens: inputEstimated ? estimateTokens(requestChars) : prompt,
+		completionTokens: outputEstimated ? estimateTokens(outputChars) : completion,
+		cachedTokens: usage?.cachedTokens ?? 0,
+		inputEstimated,
+		outputEstimated
+	};
+}
+//#endregion
+//#region src/protocol/types.ts
+/** 取对象字段（不是对象则 undefined）。 */
+function obj(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) ? v : void 0;
+}
+/** 取数组字段（不是数组则 undefined）。 */
+function arr(v) {
+	return Array.isArray(v) ? v : void 0;
+}
+/** 取非空字符串字段。 */
+function str(v) {
+	return typeof v === "string" && v !== "" ? v : void 0;
+}
+/** 取有限数字字段。 */
+function num(v) {
+	return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+}
+/** 把 `finish` 原因在各协议间对齐（各家词汇不同，这里是唯一的对照表）。 */
+function finishOf(v) {
+	switch (v) {
+		case "length":
+		case "max_tokens":
+		case "MAX_TOKENS": return "length";
+		case "tool_calls":
+		case "tool_use":
+		case "function_call": return "tool-calls";
+		case "content_filter":
+		case "SAFETY":
+		case "safety": return "content-filter";
+		case "error": return "error";
+		default: return "stop";
+	}
+}
+//#endregion
+//#region src/protocol/sse.ts
+/**
+* 增量分帧器：喂字节进去，吐出完整帧。
+*
+* 用类而不是纯函数，是因为「半个帧」必须留在实例里 —— 每次调用都是无状态的
+* 函数做不到这件事，而每个流都要一个独立缓冲。
+*/
+var SseSplitter = class {
+	buf = "";
+	/** 喂入一块字节，返回其中包含的完整帧（可能 0..n 个）。 */
+	push(bytes) {
+		this.buf += new TextDecoder().decode(bytes, { stream: true });
+		return this.drain();
+	}
+	/** 流结束时冲刷：把残留的、不以空行结尾的尾帧也吐出来（上游不发尾空行是有的）。 */
+	end() {
+		this.buf += new TextDecoder().decode();
+		const out = this.drain();
+		if (this.buf.trim() !== "") {
+			const frame = parseFrame(this.buf);
+			this.buf = "";
+			if (frame.data !== "") out.push(frame);
+		}
+		return out;
+	}
+	/** 把已缓冲的完整帧全部切出来。 */
+	drain() {
+		const out = [];
+		let sep;
+		while ((sep = this.buf.search(/\r?\n\r?\n/)) >= 0) {
+			const match = /\r?\n\r?\n/.exec(this.buf);
+			const raw = this.buf.slice(0, sep);
+			this.buf = this.buf.slice(sep + (match?.[0].length ?? 2));
+			if (raw.trim() !== "") out.push(parseFrame(raw));
+		}
+		return out;
+	}
+};
+/** 把一帧原文拆成 `event` + `data`。空 data 的帧（注释/keep-alive）返回空 data。 */
+function parseFrame(raw) {
+	let event = "";
+	const dataLines = [];
+	for (const line of raw.split(/\r?\n/)) {
+		if (line === "" || line.startsWith(":")) continue;
+		const colon = line.indexOf(":");
+		const field = colon < 0 ? line : line.slice(0, colon);
+		let value = colon < 0 ? "" : line.slice(colon + 1);
+		if (value.startsWith(" ")) value = value.slice(1);
+		if (field === "event") event = value;
+		else if (field === "data") dataLines.push(value);
+	}
+	return {
+		event,
+		data: dataLines.join("\n")
+	};
+}
+/** 拼一帧字节（`data:` 帧；不带 `event:`）。 */
+function dataFrame(data) {
+	return `data: ${data}\n\n`;
+}
+/** 拼一帧字节（带 `event:`）。 */
+function eventFrame(event, data) {
+	return `event: ${event}\ndata: ${data}\n\n`;
+}
+/** 把若干帧原文拼成字节。 */
+function framesToBytes(frames) {
+	return new TextEncoder().encode(frames.join(""));
+}
+//#endregion
+//#region src/protocol/chat.ts
+/**
+* OpenAI Chat Completions 协议 —— **规范形态本身**，所以编解码是恒等变换。
+*
+* 这个文件承担两件别处不做的事：
+*
+* 1. **请求侧恒等**：`toChat`/`fromChat` 原样返回。供应商契约
+*    （`suppliers/contract.ts` 的 `chatOnce`）吃的就是 Chat Completions 请求体，
+*    多一层拷贝只会让「哪一层改的」变难查。
+*
+* 2. **响应侧的规范事件翻译**：OpenAI SSE → `ChatEvent`，以及反向。这是**所有
+*    协议共用的脊柱** —— Anthropic/Gemini 的 `decodeFrame` 拿到自己的帧后，
+*    也要靠这里的逻辑把内容映射成同一组事件，才能让「Anthropic 客户端问、
+*    Gemini 供应商答」这条路只有两个模块参与，而不是 12 条路径。
+*
+* ⚠️ 这里的映射规则与 `llm/adapter.ts` 的 `translateSse` 是**同一套语义的两种
+*    落点**：那边翻译成 DSH 的 `StreamChunk`（给宿主 agent loop 用），这边翻译
+*    成 `ChatEvent`（给协议矩阵用）。两处都留着，因为消费方不同、且
+*    `translateSse` 里那些踩过坑的处理（残缺 tool_call 收尾、空串 name 剥除）
+*    只对 DSH 有意义；但**改任何一处规则都必须看另一处**，否则同一个上游在
+*    两个入口表现不一致。
+*/
+const chatCodec = {
+	id: "chat",
+	toChat: (body) => body,
+	fromChat: (body) => body,
+	decodeFrame(frame) {
+		let chunk;
+		try {
+			chunk = JSON.parse(frame);
+		} catch {
+			return [];
+		}
+		return chatBodyEvents(chunk);
+	},
+	/**
+	* 非流式响应体 → 规范事件。
+	*
+	* 复用同一个 `chatBodyEvents`：一个非流式 body 就是一帧（内容在
+	* `choices[0].message` 里、`finish_reason` 已给、`usage` 在外层）。单独实现
+	* 一份只会让「流式与非流式行为不一致」有地方可长。
+	*/
+	decodeJson(body) {
+		return chatBodyEvents(body);
+	},
+	encodeFrame(event) {
+		switch (event.type) {
+			case "text": return [dataFrame(JSON.stringify(choiceDelta({ content: event.text })))];
+			case "reasoning": return [dataFrame(JSON.stringify(choiceDelta({ reasoning_content: event.text })))];
+			case "tool-start": return [dataFrame(JSON.stringify(choiceDelta({ tool_calls: [{
+				index: event.index,
+				...event.id === void 0 ? {} : { id: event.id },
+				type: "function",
+				function: {
+					name: event.name ?? "",
+					arguments: ""
+				}
+			}] })))];
+			case "tool-args": return [dataFrame(JSON.stringify(choiceDelta({ tool_calls: [{
+				index: event.index,
+				function: { arguments: event.delta }
+			}] })))];
+			case "usage":
+				if (event.promptTokens === 0 && event.completionTokens === 0 && event.cachedTokens === 0) return [];
+				return [dataFrame(JSON.stringify({
+					choices: [],
+					usage: {
+						prompt_tokens: event.promptTokens,
+						completion_tokens: event.completionTokens,
+						total_tokens: event.promptTokens + event.completionTokens
+					}
+				}))];
+			case "error": return [dataFrame(JSON.stringify({ error: {
+				message: event.message,
+				type: "api_error"
+			} }))];
+			case "finish": return [dataFrame(JSON.stringify(choiceDelta({}, finishToOpenAi(event.reason)))), "data: [DONE]\n\n"];
+		}
+	},
+	startFrames: () => [],
+	endFrames: () => [],
+	/** 规范事件 → 非流式 body。 */
+	encodeJson(events, ctx) {
+		let content = "";
+		let reasoning = "";
+		let finish = "stop";
+		let usage;
+		const calls = /* @__PURE__ */ new Map();
+		for (const ev of events) switch (ev.type) {
+			case "text":
+				content += ev.text;
+				break;
+			case "reasoning":
+				reasoning += ev.text;
+				break;
+			case "tool-start":
+				calls.set(ev.index, {
+					...ev.id === void 0 ? {} : { id: ev.id },
+					name: ev.name ?? "",
+					args: ""
+				});
+				break;
+			case "tool-args": {
+				const c = calls.get(ev.index) ?? {
+					name: "",
+					args: ""
+				};
+				c.args += ev.delta;
+				calls.set(ev.index, c);
+				break;
+			}
+			case "finish":
+				finish = ev.reason;
+				break;
+			case "usage": usage = ev;
+		}
+		const message = {
+			role: "assistant",
+			content
+		};
+		if (reasoning !== "") message.reasoning_content = reasoning;
+		const toolCalls = [...calls.entries()].sort((a, b) => a[0] - b[0]).filter(([, c]) => c.name !== "").map(([i, c]) => ({
+			id: c.id ?? `call_${i}`,
+			type: "function",
+			function: {
+				name: c.name,
+				arguments: c.args
+			}
+		}));
+		if (toolCalls.length > 0) message.tool_calls = toolCalls;
+		const body = {
+			id: `chatcmpl-${Date.now().toString(36)}`,
+			object: "chat.completion",
+			created: Math.floor(Date.now() / 1e3),
+			model: ctx.model,
+			choices: [{
+				index: 0,
+				message,
+				finish_reason: finishToOpenAi(finish)
+			}]
+		};
+		if (usage !== void 0) body.usage = {
+			prompt_tokens: usage.promptTokens,
+			completion_tokens: usage.completionTokens,
+			total_tokens: usage.promptTokens + usage.completionTokens
+		};
+		return body;
+	}
+};
+/** OpenAI 的一帧 `choices[0].delta`。 */
+function choiceDelta(delta, finish) {
+	return {
+		id: "chatcmpl-stream",
+		object: "chat.completion.chunk",
+		choices: [{
+			index: 0,
+			delta,
+			finish_reason: finish ?? null
+		}]
+	};
+}
+/**
+* 一个 OpenAI 响应体（流式帧或非流式 body，两者形状一致）→ 规范事件。
+*
+* 流式与非流式共用：非流式 body 就是「一帧」（`choices[0].message` 带全量
+* 内容、`finish_reason` 已给、`usage` 在外层）。分开写两份只会让两边行为
+* 漂移 —— 而漂移的表现是「同一个上游在流式下工具名对、非流式下为空」。
+*/
+function chatBodyEvents(chunk) {
+	const out = [];
+	const usage = decodeUsage(chunk);
+	if (usage !== void 0) out.push(usage);
+	const err = obj(chunk.error);
+	if (err !== void 0) {
+		out.push({
+			type: "error",
+			message: str(err.message) ?? "upstream error"
+		});
+		return out;
+	}
+	const ch = obj(arr(chunk.choices)?.[0]);
+	if (ch === void 0) return out;
+	const delta = obj(ch.delta) ?? obj(ch.message);
+	if (delta !== void 0) {
+		const text = str(delta.content);
+		if (text !== void 0) out.push({
+			type: "text",
+			text
+		});
+		const reasoning = str(delta.reasoning_content) ?? str(obj(delta.reasoning)?.text);
+		if (reasoning !== void 0) out.push({
+			type: "reasoning",
+			text: reasoning
+		});
+		for (const ev of decodeToolCalls(delta.tool_calls)) out.push(ev);
+	}
+	const finish = ch.finish_reason;
+	if (finish !== void 0 && finish !== null) out.push({
+		type: "finish",
+		reason: finishOf(finish)
+	});
+	return out;
+}
+function finishToOpenAi(reason) {
+	switch (reason) {
+		case "length": return "length";
+		case "tool-calls": return "tool_calls";
+		case "content-filter": return "content_filter";
+		case "error": return "stop";
+		default: return "stop";
+	}
+}
+/** OpenAI SSE 帧 → 工具调用增量。 */
+function decodeToolCalls(v) {
+	const list = arr(v);
+	if (list === void 0) return [];
+	const out = [];
+	for (const item of list) {
+		const tc = obj(item);
+		if (tc === void 0) continue;
+		const index = num(tc.index) ?? 0;
+		const fn = obj(tc.function);
+		const name = fn === void 0 ? void 0 : str(fn.name);
+		const id = str(tc.id);
+		if (name !== void 0 || id !== void 0) out.push({
+			type: "tool-start",
+			index,
+			...id === void 0 ? {} : { id },
+			...name === void 0 ? {} : { name }
+		});
+		const args = fn === void 0 ? void 0 : str(fn.arguments);
+		if (args !== void 0 && args !== "") out.push({
+			type: "tool-args",
+			index,
+			delta: args
+		});
+	}
+	return out;
+}
+/**
+* 从一帧 OpenAI 响应里取用量。
+*
+* 口径与 `router/usage-tokens.ts` 的 `normalizeUsage` 一致：`prompt_tokens`
+* **含**缓存（OpenAI 系如此），`cachedTokens` 是它的子集。
+*/
+function decodeUsage(chunk) {
+	const u = obj(chunk.usage);
+	if (u === void 0) return void 0;
+	return {
+		type: "usage",
+		promptTokens: num(u.prompt_tokens) ?? num(u.input_tokens) ?? 0,
+		completionTokens: num(u.completion_tokens) ?? num(u.output_tokens) ?? 0,
+		cachedTokens: num(u.cached_tokens) ?? num(obj(u.prompt_tokens_details)?.cached_tokens) ?? 0
+	};
+}
+//#endregion
+//#region src/protocol/anthropic.ts
+/**
+* Anthropic Messages 协议。
+*
+* ════════════════════════════════════════════════════════════════════
+* 为什么第一个做它
+* ════════════════════════════════════════════════════════════════════
+* Claude Code 只会说这一种协议，而它对 `ANTHROPIC_BASE_URL` 的支持是现成的：
+* 把它指到我们的端点，就**直接**能用上账号池/组合/用量看板。其余三种协议
+* （Responses/Gemini）没有这样的「一个客户端在等」的理由。
+*
+* ════════════════════════════════════════════════════════════════════
+* 翻译表（唯一的事实来源）
+* ════════════════════════════════════════════════════════════════════
+*  请求  system            → messages[0] 的 system-role 消息（字符串或块数组都要吃）
+*        tools[].input_schema → tools[].function.parameters
+*        tool_use / tool_result 块 → assistant.tool_calls / role:"tool"
+*        max_tokens / temperature / stop_sequences → 同名（下划线差异两处）
+*  响应  message_start     → usage（input_tokens 在这帧）
+*        content_block_start(text)     → text 增量开始
+*        content_block_delta(text_delta) → text 增量
+*        content_block_delta(input_json_delta) → tool-args 增量
+*        content_block_delta(thinking_delta) → reasoning 增量
+*        content_block_stop  → 该 index 结束（无对应规范事件，吃掉）
+*        message_delta      → usage + finish_reason
+*        message_stop       → 无对应事件（finish 已由 message_delta 给）
+*
+* 丢弃（明确不做翻译，见下）：
+*   - `cache_control`：Anthropic 的提示缓存标记。跨到 Chat 后失去意义
+*     （Chat 的缓存是上游自动的），硬造一个 `prompt_cache_key` 反而是猜。
+*   - `thinking.budget_tokens`：只在响应侧保留为 reasoning 增量。
+*   - `mcp_servers` / `container` / `context_management`：客户端侧特性，
+*     转发到只懂 Chat 的上游只会得到 400。
+*/
+const anthropicCodec = {
+	id: "anthropic",
+	/** Anthropic 请求 → Chat Completions 请求。 */
+	toChat(body, ctx) {
+		const out = { ...body };
+		delete out.system;
+		delete out.tools;
+		delete out.max_tokens;
+		delete out.stop_sequences;
+		const messages = [];
+		const system = body.system;
+		if (system !== void 0) {
+			const text = systemText$1(system);
+			if (text !== "") messages.push({
+				role: "system",
+				content: text
+			});
+		}
+		for (const m of messagePairs(body.messages)) messages.push(m);
+		out.messages = messages;
+		if (body.max_tokens !== void 0) out.max_tokens = body.max_tokens;
+		if (body.stop_sequences !== void 0) out.stop = body.stop_sequences;
+		if (body.temperature !== void 0) out.temperature = body.temperature;
+		if (body.top_p !== void 0) out.top_p = body.top_p;
+		const tools = convertTools$2(body.tools);
+		if (tools.length > 0) out.tools = tools;
+		if (ctx.stream) out.stream = true;
+		return out;
+	},
+	/** Chat Completions 请求 → Anthropic 请求（供应商说 Anthropic 时用）。 */
+	fromChat(body, ctx) {
+		const out = { ...body };
+		delete out.messages;
+		delete out.tools;
+		delete out.stop;
+		delete out.stream;
+		const systemParts = [];
+		const messages = [];
+		for (const m of body.messages) {
+			const msg = obj(m);
+			if (msg === void 0) continue;
+			const role = str(msg.role);
+			if (role === "system") {
+				const t = contentText$2(msg.content);
+				if (t !== "") systemParts.push(t);
+				continue;
+			}
+			if (role === "assistant") {
+				messages.push(assistantMessage(msg));
+				continue;
+			}
+			if (role === "tool") {
+				messages.push({
+					role: "user",
+					content: [{
+						type: "tool_result",
+						tool_use_id: str(msg.tool_call_id) ?? "",
+						content: contentText$2(msg.content)
+					}]
+				});
+				continue;
+			}
+			messages.push({
+				role: "user",
+				content: contentText$2(msg.content)
+			});
+		}
+		if (systemParts.length > 0) out.system = systemParts.join("\n\n");
+		out.messages = messages;
+		out.max_tokens = num(body.max_tokens) ?? 4096;
+		if (body.stop !== void 0) out.stop_sequences = body.stop;
+		const tools = body.tools?.map(chatToolToAnthropic).filter((t) => t !== void 0);
+		if (tools !== void 0 && tools.length > 0) out.tools = tools;
+		if (ctx.stream) out.stream = true;
+		return out;
+	},
+	decodeFrame(frame, event) {
+		let payload;
+		try {
+			payload = JSON.parse(frame);
+		} catch {
+			return [];
+		}
+		switch (event) {
+			case "message_start": return messageStartEvents(payload);
+			case "content_block_start": return contentBlockStartEvents(payload);
+			case "content_block_delta": return contentDeltaEvents(payload);
+			case "message_delta": return messageDeltaEvents(payload);
+			case "error": return [{
+				type: "error",
+				message: str(obj(payload.error)?.message) ?? "upstream error"
+			}];
+			default: return [];
+		}
+	},
+	encodeFrame(event, session) {
+		switch (event.type) {
+			case "text": return [eventFrame("content_block_delta", JSON.stringify({
+				type: "content_block_delta",
+				index: 0,
+				delta: {
+					type: "text_delta",
+					text: event.text
+				}
+			}))];
+			case "reasoning": return [eventFrame("content_block_delta", JSON.stringify({
+				type: "content_block_delta",
+				index: 0,
+				delta: {
+					type: "thinking_delta",
+					thinking: event.text
+				}
+			}))];
+			case "tool-start": return [eventFrame("content_block_start", JSON.stringify({
+				type: "content_block_start",
+				index: event.index,
+				content_block: {
+					type: "tool_use",
+					id: event.id ?? `toolu_${event.index}`,
+					name: event.name ?? "",
+					input: {}
+				}
+			}))];
+			case "tool-args": return [eventFrame("content_block_delta", JSON.stringify({
+				type: "content_block_delta",
+				index: event.index,
+				delta: {
+					type: "input_json_delta",
+					partial_json: event.delta
+				}
+			}))];
+			case "usage": return [];
+			case "error": return [eventFrame("error", JSON.stringify({
+				type: "error",
+				error: {
+					type: "api_error",
+					message: event.message
+				}
+			}))];
+			case "finish": {
+				const tokens = session?.usage?.completionTokens ?? 0;
+				return [eventFrame("message_delta", JSON.stringify({
+					type: "message_delta",
+					delta: {
+						stop_reason: finishToAnthropic(event.reason),
+						stop_sequence: null
+					},
+					usage: { output_tokens: tokens }
+				}))];
+			}
+		}
+	},
+	startFrames(ctx) {
+		return [eventFrame("message_start", JSON.stringify({
+			type: "message_start",
+			message: {
+				id: `msg_${Date.now().toString(36)}`,
+				type: "message",
+				role: "assistant",
+				content: [],
+				model: ctx.model,
+				stop_reason: null,
+				stop_sequence: null,
+				usage: {
+					input_tokens: 0,
+					output_tokens: 0
+				}
+			}
+		}))];
+	},
+	endFrames() {
+		return [eventFrame("message_stop", JSON.stringify({ type: "message_stop" }))];
+	},
+	/**
+	* 非流式响应体 → 规范事件。
+	*
+	* Anthropic 非流式 body 形状：`{content:[{type:'text',text}|{type:'tool_use',...}],
+	* stop_reason, usage:{input_tokens,output_tokens,cache_read_input_tokens}}`。
+	* 与流式共用同一组 block→事件 的映射，见 `blockEvents`。
+	*/
+	decodeJson(body) {
+		const out = [];
+		let index = 0;
+		let text = "";
+		for (const b of arr(body.content) ?? []) {
+			const block = obj(b);
+			if (block === void 0) continue;
+			if (block.type === "text") {
+				const t = str(block.text);
+				if (t !== void 0) {
+					text += t;
+					index += 1;
+				}
+				continue;
+			}
+			if (block.type === "thinking") {
+				const t = str(block.thinking);
+				if (t !== void 0) {
+					out.push({
+						type: "reasoning",
+						text: t
+					});
+					index += 1;
+				}
+				continue;
+			}
+			if (block.type === "tool_use") {
+				out.push({
+					type: "tool-start",
+					index,
+					...str(block.id) === void 0 ? {} : { id: str(block.id) },
+					name: str(block.name) ?? ""
+				});
+				out.push({
+					type: "tool-args",
+					index,
+					delta: JSON.stringify(block.input ?? {})
+				});
+				index += 1;
+			}
+		}
+		if (text !== "") out.unshift({
+			type: "text",
+			text
+		});
+		const usage = obj(body.usage);
+		if (usage !== void 0) out.push({
+			type: "usage",
+			promptTokens: num(usage.input_tokens) ?? 0,
+			completionTokens: num(usage.output_tokens) ?? 0,
+			cachedTokens: num(usage.cache_read_input_tokens) ?? 0
+		});
+		const stop = body.stop_reason;
+		if (stop !== void 0 && stop !== null) out.push({
+			type: "finish",
+			reason: finishOf(stop === "max_tokens" ? "length" : stop)
+		});
+		return out;
+	},
+	/** 规范事件 → 非流式 body。 */
+	encodeJson(events, ctx) {
+		const content = [];
+		let stop = "end_turn";
+		let usage = {
+			input: 0,
+			output: 0,
+			cached: 0
+		};
+		for (const ev of events) switch (ev.type) {
+			case "text":
+				if (content.length > 0 && content[content.length - 1]?.type === "text") content[content.length - 1].text += ev.text;
+				else content.push({
+					type: "text",
+					text: ev.text
+				});
+				break;
+			case "reasoning":
+				if (content.length > 0 && content[content.length - 1]?.type === "thinking") content[content.length - 1].thinking += ev.text;
+				else content.push({
+					type: "thinking",
+					thinking: ev.text
+				});
+				break;
+			case "tool-start":
+				content.push({
+					type: "tool_use",
+					id: ev.id ?? `toolu_${ev.index}`,
+					name: ev.name ?? "",
+					input: {}
+				});
+				break;
+			case "tool-args": {
+				const last = content[content.length - 1];
+				if (last?.type === "tool_use") last.input = parseArgs$1((str(last.input) ?? "") + ev.delta);
+				break;
+			}
+			case "finish":
+				stop = finishToAnthropic(ev.reason);
+				break;
+			case "usage": usage = {
+				input: ev.promptTokens,
+				output: ev.completionTokens,
+				cached: ev.cachedTokens
+			};
+		}
+		return {
+			id: `msg_${Date.now().toString(36)}`,
+			type: "message",
+			role: "assistant",
+			content,
+			model: ctx.model,
+			stop_reason: stop,
+			stop_sequence: null,
+			usage: {
+				input_tokens: usage.input,
+				output_tokens: usage.output,
+				...usage.cached > 0 ? { cache_read_input_tokens: usage.cached } : {}
+			}
+		};
+	}
+};
+/** Anthropic 的 system 字段：字符串或 [{type:'text',text}] 数组。 */
+function systemText$1(system) {
+	if (typeof system === "string") return system;
+	const parts = [];
+	for (const b of arr(system) ?? []) {
+		const t = str(obj(b)?.text);
+		if (t !== void 0) parts.push(t);
+	}
+	return parts.join("\n\n");
+}
+/**
+* Anthropic messages → Chat messages。
+*
+* 关键差异：Anthropic 把「模型发起的工具调用」与「用户回传的工具结果」都放在
+* content 块里，而 Chat 把它们拆成 `assistant.tool_calls` 与 `role:'tool'` 消息。
+* 且 Anthropic 允许 tool_result 单独成一条 user 消息，Chat 也允许 —— 但**连续
+* 多条 tool_result 必须各自一条**，合并不了（每个 tool_use_id 要能对上）。
+*/
+function messagePairs(messages) {
+	const out = [];
+	for (const m of arr(messages) ?? []) {
+		const msg = obj(m);
+		if (msg === void 0) continue;
+		const role = str(msg.role);
+		if (role !== "user" && role !== "assistant") continue;
+		const blocks = arr(msg.content);
+		if (blocks === void 0) {
+			out.push({
+				role,
+				content: typeof msg.content === "string" ? msg.content : ""
+			});
+			continue;
+		}
+		const texts = [];
+		const toolCalls = [];
+		const toolResults = [];
+		for (const b of blocks) {
+			const block = obj(b);
+			if (block === void 0) continue;
+			switch (block.type) {
+				case "text": {
+					const t = str(block.text);
+					if (t !== void 0) texts.push(t);
+					break;
+				}
+				case "tool_use":
+					toolCalls.push({
+						id: str(block.id) ?? "",
+						type: "function",
+						function: {
+							name: str(block.name) ?? "",
+							arguments: JSON.stringify(block.input ?? {})
+						}
+					});
+					break;
+				case "tool_result": toolResults.push({
+					role: "tool",
+					tool_call_id: str(block.tool_use_id) ?? "",
+					content: blockContentText(block.content)
+				});
+			}
+		}
+		if (role === "assistant") {
+			const msg2 = {
+				role: "assistant",
+				content: texts.join("\n\n")
+			};
+			if (toolCalls.length > 0) msg2.tool_calls = toolCalls;
+			out.push(msg2);
+		} else {
+			if (texts.length > 0) out.push({
+				role: "user",
+				content: texts.join("\n\n")
+			});
+			for (const tr of toolResults) out.push(tr);
+		}
+	}
+	return out;
+}
+/** tool_result 的 content：字符串或 [{type:'text'}] 数组。 */
+function blockContentText(content) {
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const b of arr(content) ?? []) {
+		const t = str(obj(b)?.text);
+		if (t !== void 0) parts.push(t);
+	}
+	return parts.join("\n\n");
+}
+/** Chat 的 content（字符串或 parts 数组）→ 纯文本。 */
+function contentText$2(content) {
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const p of arr(content) ?? []) {
+		const part = obj(p);
+		if (part === void 0) continue;
+		const t = str(part.text) ?? str(part.content);
+		if (t !== void 0) parts.push(t);
+	}
+	return parts.join("\n\n");
+}
+/** Chat assistant 消息 → Anthropic assistant 消息（tool_calls → tool_use 块）。 */
+function assistantMessage(msg) {
+	const content = [];
+	const text = contentText$2(msg.content);
+	if (text !== "") content.push({
+		type: "text",
+		text
+	});
+	for (const tc of arr(msg.tool_calls) ?? []) {
+		const call = obj(tc);
+		if (call === void 0) continue;
+		const fn = obj(call.function);
+		content.push({
+			type: "tool_use",
+			id: str(call.id) ?? "",
+			name: str(fn?.name) ?? "",
+			input: parseArgs$1(str(fn?.arguments))
+		});
+	}
+	return {
+		role: "assistant",
+		content
+	};
+}
+/** 解析工具参数字符串；坏 JSON 返回空对象（上游偶发半截参数，别让整条消息失败）。 */
+function parseArgs$1(s) {
+	if (s === void 0 || s === "") return {};
+	try {
+		return obj(JSON.parse(s)) ?? {};
+	} catch {
+		return {};
+	}
+}
+/**
+* Anthropic tool → Chat tool（`toChat` 方向）。
+*
+* Anthropic 的工具是**扁平**的 `{ name, description, input_schema }`，而 Chat
+* 要多包一层 `function`、并把 `input_schema` 改名为 `parameters`。两件事都要做。
+*
+* ⚠️ 曾经这里读的是 `tool.function.*`（Chat 的形状）—— 方向搞反了，于是从
+*    Anthropic 客户端进来的工具**被静默丢光**，Claude Code 接上来后模型会说
+*    「我没有这个工具」（2026-10-21 在 3080 实测）。现按 Anthropic 结构读，
+*    并兼容已经带 `function` 包装的输入（中间层可能提前转过）。
+*/
+function convertTools$2(tools) {
+	const out = [];
+	for (const t of arr(tools) ?? []) {
+		const tool = obj(t);
+		if (tool === void 0) continue;
+		const fn = obj(tool.function) ?? tool;
+		const name = str(fn.name);
+		if (name === void 0) continue;
+		out.push({
+			type: "function",
+			function: {
+				name,
+				description: str(fn.description) ?? "",
+				parameters: obj(fn.input_schema) ?? obj(fn.parameters) ?? {
+					type: "object",
+					properties: {}
+				}
+			}
+		});
+	}
+	return out;
+}
+/**
+* Chat tool → Anthropic tool（`fromChat` 方向，与上面的 `convertTools` 反着走）。
+*
+* Chat 的具名工具是 `{ type:'function', function:{ name, description, parameters } }`
+* —— **多包了一层** `function`。直接读 `tool.name` 会永远 undefined，于是所有
+* 工具被静默丢掉（Claude Code 接上来就看不到任何 tool）。所以这里先解包，
+* 再兼容已经扁平化的输入（有些中间层会提前拍平）。
+*/
+function chatToolToAnthropic(t) {
+	const tool = obj(t);
+	if (tool === void 0) return void 0;
+	const fn = obj(tool.function) ?? tool;
+	const name = str(fn.name);
+	if (name === void 0) return void 0;
+	return {
+		name,
+		description: str(fn.description) ?? "",
+		input_schema: obj(fn.parameters) ?? {
+			type: "object",
+			properties: {}
+		}
+	};
+}
+/** message_start：把 input_tokens 带出来（Anthropic 只在这帧给输入用量）。 */
+function messageStartEvents(payload) {
+	const usage = obj(obj(payload.message)?.usage);
+	return [{
+		type: "usage",
+		promptTokens: num(usage?.input_tokens) ?? 0,
+		completionTokens: 0,
+		cachedTokens: num(usage?.cache_read_input_tokens) ?? 0
+	}];
+}
+/**
+* content_block_start：`tool_use` 块的**名字**只在这一帧给，后面的
+* `input_json_delta` 只有参数增量。所以这里必须产出 `tool-start`，否则
+* tool-start 永远丢失，客户端收到一堆没有名字的参数。
+*
+* `text` 块与 `thinking` 块不产出事件：它们的内容全在后续 delta 里，
+* 这里发空文本只会造成一个多余的空增量。
+*/
+function contentBlockStartEvents(payload) {
+	const block = obj(payload.content_block);
+	if (block === void 0 || block.type !== "tool_use") return [];
+	const index = num(payload.index) ?? 0;
+	const name = str(block.name);
+	const id = str(block.id);
+	return [{
+		type: "tool-start",
+		index,
+		...id === void 0 ? {} : { id },
+		...name === void 0 ? {} : { name }
+	}];
+}
+/** content_block_delta：四种 delta 各对应一种规范事件。 */
+function contentDeltaEvents(payload) {
+	const delta = obj(payload.delta);
+	if (delta === void 0) return [];
+	const index = num(payload.index) ?? 0;
+	switch (delta.type) {
+		case "text_delta": {
+			const text = str(delta.text);
+			return text === void 0 ? [] : [{
+				type: "text",
+				text
+			}];
+		}
+		case "thinking_delta":
+		case "signature_delta": {
+			const text = str(delta.thinking);
+			return text === void 0 ? [] : [{
+				type: "reasoning",
+				text
+			}];
+		}
+		case "input_json_delta": {
+			const partial = str(delta.partial_json);
+			return partial === void 0 || partial === "" ? [] : [{
+				type: "tool-args",
+				index,
+				delta: partial
+			}];
+		}
+		default: return [];
+	}
+}
+/** message_delta：finish_reason + 输出用量。 */
+function messageDeltaEvents(payload) {
+	const out = [];
+	const stop = obj(payload.delta)?.stop_reason;
+	if (stop !== void 0 && stop !== null) out.push({
+		type: "finish",
+		reason: finishOf(stop === "max_tokens" ? "length" : stop)
+	});
+	const usage = obj(payload.usage);
+	if (usage !== void 0) {
+		const prompt = num(usage.input_tokens);
+		const completion = num(usage.output_tokens);
+		if (prompt !== void 0 || completion !== void 0) out.push({
+			type: "usage",
+			promptTokens: prompt ?? 0,
+			completionTokens: completion ?? 0,
+			cachedTokens: num(usage.cache_read_input_tokens) ?? 0
+		});
+	}
+	return out;
+}
+function finishToAnthropic(reason) {
+	switch (reason) {
+		case "length": return "max_tokens";
+		case "tool-calls": return "tool_use";
+		case "content-filter": return "refusal";
+		default: return "end_turn";
+	}
+}
+//#endregion
+//#region src/protocol/responses.ts
+/**
+* OpenAI Responses 协议（Codex 用的是它）。
+*
+* ════════════════════════════════════════════════════════════════════
+* 与 Chat Completions 的关键差异
+* ════════════════════════════════════════════════════════════════════
+*  请求  `input` 是**消息数组**（与 messages 同构）而不是 messages 本身
+*        `instructions` 替代 `system` 消息
+*        `max_output_tokens` 替代 `max_tokens`
+*        `tools` 项是扁平的 `{type:'function', name, parameters}`，
+*        没有 `function` 这一层包装
+*  响应  事件名带语义：`response.output_text.delta` / `response.function_call_arguments.delta`
+*        / `response.reasoning_summary_text.delta`，全部带 `sequence_number`
+*        收尾是 `response.completed`（带完整 response 对象），不是 finish_reason
+*
+* 丢弃（明确不做）：
+*   - `previous_response_id` / `store`：服务端会话态。我们的供应商契约是
+*     无状态的（`chatOnce` 一次一请求），转发过去只会拿到错误。
+*   - `reasoning.effort` 之外的 `reasoning.summary`：摘要粒度由上游定，
+*     我们只透传 reasoning 增量。
+*   - `include` / `text.format`（结构化输出）：跨协议没有对应物。
+*/
+const responsesCodec = {
+	id: "responses",
+	/** Responses 请求 → Chat Completions 请求。 */
+	toChat(body, ctx) {
+		const out = { ...body };
+		delete out.input;
+		delete out.instructions;
+		delete out.tools;
+		delete out.max_output_tokens;
+		delete out.previous_response_id;
+		delete out.store;
+		delete out.include;
+		delete out.reasoning;
+		const messages = [];
+		const instructions = str(body.instructions);
+		if (instructions !== void 0) messages.push({
+			role: "system",
+			content: instructions
+		});
+		for (const m of arr(body.input) ?? []) messages.push(inputItem(m));
+		out.messages = messages;
+		if (body.max_output_tokens !== void 0) out.max_tokens = body.max_output_tokens;
+		if (body.temperature !== void 0) out.temperature = body.temperature;
+		if (body.top_p !== void 0) out.top_p = body.top_p;
+		const tools = convertTools$1(body.tools);
+		if (tools.length > 0) out.tools = tools;
+		if (ctx.stream) out.stream = true;
+		return out;
+	},
+	/** Chat Completions 请求 → Responses 请求。 */
+	fromChat(body, ctx) {
+		const out = { ...body };
+		delete out.messages;
+		delete out.tools;
+		delete out.stream;
+		delete out.max_tokens;
+		const input = [];
+		const instructions = [];
+		for (const m of arr(body.messages) ?? []) {
+			const msg = obj(m);
+			if (msg === void 0) continue;
+			const role = str(msg.role);
+			if (role === "system" || role === "developer") {
+				const t = contentText$1(msg.content);
+				if (t !== "") instructions.push(t);
+				continue;
+			}
+			if (role === "tool") {
+				input.push({
+					type: "function_call_output",
+					call_id: str(msg.tool_call_id) ?? "",
+					output: contentText$1(msg.content)
+				});
+				continue;
+			}
+			const text = contentText$1(msg.content);
+			if (text !== "") input.push({
+				type: "message",
+				role: role === "assistant" ? "assistant" : "user",
+				content: [{
+					type: role === "assistant" ? "output_text" : "input_text",
+					text
+				}]
+			});
+			if (role === "assistant") for (const tc of arr(msg.tool_calls) ?? []) {
+				const call = obj(tc);
+				const fn = obj(call?.function);
+				if (call === void 0 || fn === void 0) continue;
+				const name = str(fn.name);
+				if (name === void 0) continue;
+				input.push({
+					type: "function_call",
+					call_id: str(call.id) ?? "",
+					name,
+					arguments: str(fn.arguments) ?? "{}"
+				});
+			}
+		}
+		if (instructions.length > 0) out.instructions = instructions.join("\n\n");
+		out.input = input;
+		if (body.max_tokens !== void 0) out.max_output_tokens = body.max_tokens;
+		const tools = body.tools?.map(chatToolToResponses).filter((t) => t !== void 0);
+		if (tools !== void 0 && tools.length > 0) out.tools = tools;
+		if (ctx.stream) out.stream = true;
+		return out;
+	},
+	decodeFrame(frame, event) {
+		let payload;
+		try {
+			payload = JSON.parse(frame);
+		} catch {
+			return [];
+		}
+		switch (event) {
+			case "response.output_text.delta": {
+				const delta = str(payload.delta);
+				return delta === void 0 ? [] : [{
+					type: "text",
+					text: delta
+				}];
+			}
+			case "response.reasoning_summary_text.delta":
+			case "response.reasoning_text.delta": {
+				const delta = str(payload.delta);
+				return delta === void 0 ? [] : [{
+					type: "reasoning",
+					text: delta
+				}];
+			}
+			case "response.function_call_arguments.delta": {
+				const delta = str(payload.delta);
+				if (delta === void 0 || delta === "") return [];
+				return [{
+					type: "tool-args",
+					index: num(payload.output_index) ?? 0,
+					delta
+				}];
+			}
+			case "response.output_item.added": return outputItemEvents(payload);
+			case "response.completed": return completedEvents(payload);
+			case "response.failed":
+			case "error": return [{
+				type: "error",
+				message: str((obj(obj(payload.response)?.error) ?? obj(payload.error))?.message) ?? str(payload.message) ?? "upstream error"
+			}];
+			default: return [];
+		}
+	},
+	encodeFrame(event) {
+		switch (event.type) {
+			case "text": return [eventFrame("response.output_text.delta", JSON.stringify({
+				type: "response.output_text.delta",
+				output_index: 0,
+				delta: event.text
+			}))];
+			case "reasoning": return [eventFrame("response.reasoning_summary_text.delta", JSON.stringify({
+				type: "response.reasoning_summary_text.delta",
+				output_index: 0,
+				delta: event.text
+			}))];
+			case "tool-start": return [eventFrame("response.output_item.added", JSON.stringify({
+				type: "response.output_item.added",
+				output_index: event.index,
+				item: {
+					type: "function_call",
+					id: event.id ?? `fc_${event.index}`,
+					call_id: event.id ?? `call_${event.index}`,
+					name: event.name ?? "",
+					arguments: ""
+				}
+			}))];
+			case "tool-args": return [eventFrame("response.function_call_arguments.delta", JSON.stringify({
+				type: "response.function_call_arguments.delta",
+				item_id: `fc_${event.index}`,
+				output_index: event.index,
+				delta: event.delta
+			}))];
+			case "usage": return [];
+			case "error": return [eventFrame("error", JSON.stringify({
+				type: "error",
+				code: "server_error",
+				message: event.message
+			}))];
+			case "finish": return [];
+		}
+	},
+	startFrames() {
+		return [eventFrame("response.created", JSON.stringify({
+			type: "response.created",
+			response: {
+				id: `resp_${Date.now().toString(36)}`,
+				status: "in_progress",
+				output: []
+			}
+		}))];
+	},
+	/**
+	* 流结束帧：`response.completed` 带一个完整的 response 对象。
+	*
+	* 用量与收尾原因都从 `ctx` 来（`StreamState.finishStream` 填），因为 Codex
+	* 读的是 `response.completed` 里的 `status`/`usage`，而不是一个 finish_reason
+	* 字段 —— 少了这一帧客户端会一直等流结束。
+	*/
+	endFrames(ctx) {
+		return [completedFrame(ctx.model, ctx.stream ? ctx.usage : void 0, ctx.finish)];
+	},
+	/**
+	* 非流式响应体 → 规范事件。
+	*
+	* 非流式 Responses body 形状：`{output:[{type:'message',content:[{type:'output_text',text}]}
+	* |{type:'function_call',name,arguments}], status, usage:{input_tokens,output_tokens}}`。
+	* 与流式的 `response.output_item.added` / `response.completed` 共用同一组
+	* item→事件 映射，见 `outputItemEvents`。
+	*/
+	decodeJson(body) {
+		const out = [];
+		let index = 0;
+		let text = "";
+		for (const item of arr(body.output) ?? []) {
+			const it = obj(item);
+			if (it === void 0) continue;
+			if (it.type === "message") {
+				for (const p of arr(it.content) ?? []) {
+					const t = str(obj(p)?.text);
+					if (t !== void 0) text += t;
+				}
+				continue;
+			}
+			if (it.type === "function_call") {
+				out.push({
+					type: "tool-start",
+					index,
+					name: str(it.name) ?? ""
+				});
+				out.push({
+					type: "tool-args",
+					index,
+					delta: str(it.arguments) ?? ""
+				});
+				index += 1;
+				continue;
+			}
+			if (it.type === "reasoning") for (const s of arr(it.summary) ?? []) {
+				const t = str(obj(s)?.text);
+				if (t !== void 0) out.push({
+					type: "reasoning",
+					text: t
+				});
+			}
+		}
+		if (text !== "") out.unshift({
+			type: "text",
+			text
+		});
+		const usage = obj(body.usage);
+		if (usage !== void 0) out.push({
+			type: "usage",
+			promptTokens: num(usage.input_tokens) ?? 0,
+			completionTokens: num(usage.output_tokens) ?? 0,
+			cachedTokens: num(obj(usage.input_tokens_details)?.cached_tokens) ?? 0
+		});
+		const status = str(body.status);
+		if (status === "incomplete") out.push({
+			type: "finish",
+			reason: "length"
+		});
+		else if (status === "failed") out.push({
+			type: "finish",
+			reason: "error"
+		});
+		else out.push({
+			type: "finish",
+			reason: "stop"
+		});
+		return out;
+	},
+	/** 规范事件 → 非流式 body。 */
+	encodeJson(events, ctx) {
+		const output = [];
+		let status = "completed";
+		let usage = {
+			input: 0,
+			output: 0
+		};
+		for (const ev of events) switch (ev.type) {
+			case "text":
+				if (output.length > 0 && output[output.length - 1]?.type === "message") {
+					const c = output[output.length - 1].content;
+					if (c.length > 0 && c[c.length - 1]?.type === "output_text") {
+						c[c.length - 1].text += ev.text;
+						break;
+					}
+					c.push({
+						type: "output_text",
+						text: ev.text
+					});
+					break;
+				}
+				output.push({
+					type: "message",
+					role: "assistant",
+					content: [{
+						type: "output_text",
+						text: ev.text
+					}]
+				});
+				break;
+			case "reasoning": {
+				const last = output[output.length - 1];
+				if (last?.type === "reasoning") last.summary[0].text += ev.text;
+				else output.push({
+					type: "reasoning",
+					summary: [{
+						type: "summary_text",
+						text: ev.text
+					}]
+				});
+				break;
+			}
+			case "tool-start":
+				output.push({
+					type: "function_call",
+					id: ev.id ?? `fc_${ev.index}`,
+					call_id: ev.id ?? `call_${ev.index}`,
+					name: ev.name ?? "",
+					arguments: ""
+				});
+				break;
+			case "tool-args": {
+				const last = output[output.length - 1];
+				if (last?.type === "function_call") last.arguments += ev.delta;
+				break;
+			}
+			case "finish":
+				if (ev.reason === "length") status = "incomplete";
+				else if (ev.reason === "error") status = "failed";
+				break;
+			case "usage": usage = {
+				input: ev.promptTokens,
+				output: ev.completionTokens
+			};
+		}
+		return {
+			id: `resp_${Date.now().toString(36)}`,
+			object: "response",
+			status,
+			model: ctx.model,
+			output,
+			usage: {
+				input_tokens: usage.input,
+				output_tokens: usage.output,
+				total_tokens: usage.input + usage.output
+			}
+		};
+	}
+};
+/** Responses 的 input 项 → Chat message。 */
+function inputItem(item) {
+	const it = obj(item);
+	if (it === void 0) return void 0;
+	const type = str(it.type);
+	if (type === "message" || type === void 0) {
+		const role = str(it.role) ?? "user";
+		const content = it.content;
+		if (typeof content === "string") return {
+			role,
+			content
+		};
+		const text = [];
+		for (const p of arr(content) ?? []) {
+			const part = obj(p);
+			const t = part === void 0 ? void 0 : str(part.text) ?? str(part.output_text);
+			if (t !== void 0) text.push(t);
+		}
+		return {
+			role,
+			content: text.join("\n\n")
+		};
+	}
+	if (type === "function_call") return {
+		role: "assistant",
+		content: "",
+		tool_calls: [{
+			id: str(it.call_id) ?? str(it.id) ?? "",
+			type: "function",
+			function: {
+				name: str(it.name) ?? "",
+				arguments: str(it.arguments) ?? ""
+			}
+		}]
+	};
+	if (type === "function_call_output") return {
+		role: "tool",
+		tool_call_id: str(it.call_id) ?? "",
+		content: str(it.output) ?? ""
+	};
+}
+/** Chat 的 content（字符串或 parts）→ 纯文本。 */
+function contentText$1(content) {
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const p of arr(content) ?? []) {
+		const t = str(obj(p)?.text);
+		if (t !== void 0) parts.push(t);
+	}
+	return parts.join("\n\n");
+}
+/** Chat tools → Responses tools（扁平形态）。 */
+function convertTools$1(tools) {
+	const out = [];
+	for (const t of arr(tools) ?? []) {
+		const tool = obj(t);
+		const fn = tool === void 0 ? void 0 : obj(tool.function) ?? tool;
+		if (fn === void 0) continue;
+		const name = str(fn.name);
+		if (name === void 0) continue;
+		out.push({
+			type: "function",
+			function: {
+				name,
+				description: str(fn.description) ?? "",
+				parameters: obj(fn.parameters) ?? {
+					type: "object",
+					properties: {}
+				}
+			}
+		});
+	}
+	return out;
+}
+/**
+* Chat tool → Responses tool（`fromChat` 方向）。Responses 的 tools 是**扁平**的
+* `{ type:'function', name, description, parameters }`，而 Chat 的具名工具多包了
+* 一层 `function`。不解包的话 `tool.name` 恒为 undefined，工具被静默全部丢掉。
+*/
+function chatToolToResponses(t) {
+	const tool = obj(t);
+	if (tool === void 0) return void 0;
+	const fn = obj(tool.function) ?? tool;
+	const name = str(fn.name);
+	if (name === void 0) return void 0;
+	return {
+		type: "function",
+		name,
+		description: str(fn.description) ?? "",
+		parameters: obj(fn.parameters) ?? {
+			type: "object",
+			properties: {}
+		}
+	};
+}
+/** `response.output_item.added`：函数调用项给出名字。 */
+function outputItemEvents(payload) {
+	const item = obj(payload.item);
+	if (item === void 0 || item.type !== "function_call") return [];
+	return [{
+		type: "tool-start",
+		index: num(payload.output_index) ?? 0,
+		...str(item.id) === void 0 ? {} : { id: str(item.id) },
+		name: str(item.name) ?? ""
+	}];
+}
+/** `response.completed`：收尾 + 用量都在这帧。 */
+function completedEvents(payload) {
+	const response = obj(payload.response);
+	const out = [];
+	const usage = obj(response?.usage);
+	if (usage !== void 0) out.push({
+		type: "usage",
+		promptTokens: num(usage.input_tokens) ?? 0,
+		completionTokens: num(usage.output_tokens) ?? 0,
+		cachedTokens: num(obj(usage.input_tokens_details)?.cached_tokens) ?? 0
+	});
+	const status = str(response?.status);
+	if (status === "failed") out.push({
+		type: "finish",
+		reason: "error"
+	});
+	else if (status === "incomplete") out.push({
+		type: "finish",
+		reason: finishOf(str(obj(response?.incomplete_details)?.reason))
+	});
+	else out.push({
+		type: "finish",
+		reason: outputHasToolCall(response?.output) ? "tool-calls" : "stop"
+	});
+	return out;
+}
+/** `response.output` 里有没有 `function_call` 项。 */
+function outputHasToolCall(output) {
+	for (const item of Array.isArray(output) ? output : []) if (obj(item)?.type === "function_call") return true;
+	return false;
+}
+/**
+* 拼 `response.completed` 帧（收尾时由调用方带用量与收尾原因调）。
+*
+* `output` 里要写一条 `function_call` 占位项（当 finish 是 tool-calls 时）——
+* Responses 没有 finish_reason 字段，客户端（以及我们自己的 `completedEvents`）
+* 只能靠 `output` 里有没有 function_call 判断「这轮是调工具还是说完」。
+* 少了这条，工具轮在往返后会被认成普通结束。
+*/
+function completedFrame(model, usage, finish) {
+	const response = {
+		id: `resp_${Date.now().toString(36)}`,
+		object: "response",
+		status: finish === "length" ? "incomplete" : "completed",
+		model,
+		output: finish === "tool-calls" ? [{
+			type: "function_call",
+			id: `fc_${Date.now().toString(36)}`,
+			call_id: `call_${Date.now().toString(36)}`,
+			name: "",
+			arguments: ""
+		}] : []
+	};
+	if (finish === "length") response.incomplete_details = { reason: "max_output_tokens" };
+	if (usage !== void 0) response.usage = {
+		input_tokens: usage.promptTokens,
+		output_tokens: usage.completionTokens,
+		total_tokens: usage.promptTokens + usage.completionTokens,
+		...usage.cachedTokens !== void 0 && usage.cachedTokens > 0 ? { input_tokens_details: { cached_tokens: usage.cachedTokens } } : {}
+	};
+	return eventFrame("response.completed", JSON.stringify({
+		type: "response.completed",
+		response
+	}));
+}
+//#endregion
+//#region src/protocol/gemini.ts
+/**
+* Google Gemini 协议（`generateContent` / `streamGenerateContent`）。
+*
+* ════════════════════════════════════════════════════════════════════
+* 与其他三种的差异
+* ════════════════════════════════════════════════════════════════════
+*  1. **模型名在 URL 路径里**：`/v1beta/models/<model>:generateContent`，
+*     请求体里没有 `model` 字段。
+*  2. **角色名不同**：`user` / `model`（不是 assistant）。
+*  3. **内容是 parts**：`{parts:[{text}]}`，不是字符串。
+*  4. **工具调用是整块**：`functionCall` part 一次给全 `{name,args}`，
+*     没有增量形态 —— 故 decode 时拆成 tool-start + tool-args 一段。
+*  5. **鉴权走 query 参数 `?key=`** 或 `x-goog-api-key` 头（不是 Bearer）。
+*  6. **流式响应是 JSON 数组分片**（`[{...},{...}]`），不是 SSE ——
+*     `streamGenerateContent?alt=sse` 才给 SSE。我们只支持 `alt=sse`，
+*     非 SSE 形态明确不支持（见文件尾 `geminiStreamSse` 的说明）。
+*
+* 丢弃：`safetySettings` / `tools[].googleSearch` / `cachedContent` /
+*      `systemInstruction` 之外的 `generationConfig` 大部分字段（只留
+*      temperature / maxOutputTokens / stopSequences）。
+*/
+const geminiCodec = {
+	id: "gemini",
+	/** Gemini 请求 → Chat Completions 请求。 */
+	toChat(body, ctx) {
+		const out = {};
+		const messages = geminiMessages(body);
+		const sys = systemText(body.systemInstruction);
+		if (sys !== "") messages.unshift({
+			role: "system",
+			content: sys
+		});
+		out.messages = messages;
+		const gen = obj(body.generationConfig);
+		if (gen !== void 0) {
+			if (num(gen.temperature) !== void 0) out.temperature = gen.temperature;
+			if (num(gen.maxOutputTokens) !== void 0) out.max_tokens = gen.maxOutputTokens;
+			if (arr(gen.stopSequences) !== void 0) out.stop = gen.stopSequences;
+		}
+		const tools = convertTools(body.tools);
+		if (tools.length > 0) out.tools = tools;
+		if (ctx.stream) out.stream = true;
+		out.model = ctx.model;
+		return out;
+	},
+	/** Chat Completions 请求 → Gemini 请求。 */
+	fromChat(body, ctx) {
+		const out = {};
+		const systemParts = [];
+		const contents = [];
+		for (const m of arr(body.messages) ?? []) {
+			const msg = obj(m);
+			if (msg === void 0) continue;
+			const role = str(msg.role);
+			if (role === "system" || role === "developer") {
+				const t = contentText(msg.content);
+				if (t !== "") systemParts.push(t);
+				continue;
+			}
+			if (role === "assistant") {
+				const parts = [];
+				const text = contentText(msg.content);
+				if (text !== "") parts.push({ text });
+				for (const tc of arr(msg.tool_calls) ?? []) {
+					const fn = obj(obj(tc)?.function);
+					parts.push({ functionCall: {
+						name: str(fn?.name) ?? "",
+						args: parseArgs(str(fn?.arguments))
+					} });
+				}
+				contents.push({
+					role: "model",
+					parts
+				});
+				continue;
+			}
+			if (role === "tool") {
+				contents.push({
+					role: "user",
+					parts: [{ functionResponse: {
+						name: str(msg.name) ?? "",
+						response: { result: contentText(msg.content) }
+					} }]
+				});
+				continue;
+			}
+			contents.push({
+				role: "user",
+				parts: [{ text: contentText(msg.content) }]
+			});
+		}
+		out.contents = contents;
+		if (systemParts.length > 0) out.systemInstruction = { parts: [{ text: systemParts.join("\n\n") }] };
+		if (num(body.temperature) !== void 0 || num(body.max_tokens) !== void 0) out.generationConfig = {
+			...num(body.temperature) === void 0 ? {} : { temperature: body.temperature },
+			...num(body.max_tokens) === void 0 ? {} : { maxOutputTokens: body.max_tokens }
+		};
+		if (arr(body.stop) !== void 0) out.generationConfig.stopSequences = body.stop;
+		const tools = body.tools?.map(chatToolToGemini).filter((t) => t !== void 0);
+		if (tools !== void 0 && tools.length > 0) out.tools = [{ functionDeclarations: tools }];
+		return out;
+	},
+	createSession() {
+		return { state: newGeminiToolMap() };
+	},
+	decodeFrame(frame, _event, session) {
+		let payload;
+		try {
+			payload = JSON.parse(frame);
+		} catch {
+			return [];
+		}
+		return geminiBodyEvents(payload, mapOf(session));
+	},
+	encodeFrame(event, session) {
+		const toolMap = mapOf(session);
+		const chunk = (parts, finish) => [dataFrame(JSON.stringify({ candidates: [{
+			content: {
+				role: "model",
+				parts
+			},
+			...finish === void 0 ? {} : { finishReason: finish }
+		}] }))];
+		switch (event.type) {
+			case "text": return chunk([{ text: event.text }]);
+			case "reasoning": return chunk([{
+				text: event.text,
+				thought: true
+			}]);
+			case "tool-start": {
+				const name = event.name ?? "";
+				if (name !== "") toolMap.remember(event.index, name);
+				return [];
+			}
+			case "tool-args":
+				toolMap.appendArgs(event.index, event.delta);
+				return [];
+			case "usage": return [dataFrame(JSON.stringify({ usageMetadata: {
+				promptTokenCount: event.promptTokens,
+				candidatesTokenCount: event.completionTokens,
+				totalTokenCount: event.promptTokens + event.completionTokens,
+				...event.cachedTokens > 0 ? { cachedContentTokenCount: event.cachedTokens } : {}
+			} }))];
+			case "error": return [dataFrame(JSON.stringify({ error: {
+				code: 500,
+				message: event.message,
+				status: "INTERNAL"
+			} }))];
+			case "finish": return [];
+		}
+	},
+	startFrames: () => [],
+	/**
+	* 流末一次性发出**完整的** functionCall。
+	*
+	* 为什么集中在这里：Gemini 没有参数增量形态，一个调用必须「名字+完整参数」
+	* 用一个 part 给出。上游（OpenAI 系）逐帧发参数增量，`tool-args` 只能攒；
+	* 攒到流末参数才完整，此时才发得出合法的 `functionCall`。
+	*
+	* 半截 JSON（上游断流）**不发**：发出去客户端会拿坏参数执行工具，
+	* 比少一次调用危险得多。
+	*/
+	endFrames(ctx, session) {
+		const toolMap = mapOf(session);
+		const out = [];
+		for (const index of toolMap.pendingIndexes()) {
+			const name = toolMap.nameOf(index);
+			if (name === "") continue;
+			const args = toolMap.completeArgs(index);
+			if (args === void 0) continue;
+			out.push(dataFrame(JSON.stringify({ candidates: [{ content: {
+				role: "model",
+				parts: [{ functionCall: {
+					name,
+					args
+				} }]
+			} }] })));
+		}
+		out.push(...chunkOf([], finishToGemini(ctx.finish ?? "stop")));
+		return out;
+	},
+	/**
+	* 非流式响应体 → 规范事件。
+	*
+	* Gemini 非流式 body 与流式一帧同形（`{candidates:[{content:{parts},finishReason}],
+	* usageMetadata}`），所以直接复用 `decodeFrame` —— 这是四种协议里唯一
+	* 「流与非流形状一致」的，没有第二份映射可写。
+	*/
+	decodeJson(body) {
+		return geminiBodyEvents(body, newGeminiToolMap());
+	},
+	/** 规范事件 → 非流式 body。 */
+	encodeJson(events, ctx) {
+		const toolMap = newGeminiToolMap();
+		const parts = [];
+		let finish = "STOP";
+		let usage = {
+			prompt: 0,
+			output: 0,
+			cached: 0
+		};
+		for (const ev of events) switch (ev.type) {
+			case "text":
+				parts.push({ text: ev.text });
+				break;
+			case "reasoning":
+				parts.push({
+					text: ev.text,
+					thought: true
+				});
+				break;
+			case "tool-start": {
+				const name = ev.name ?? "";
+				if (name !== "") toolMap.remember(ev.index, name);
+				break;
+			}
+			case "tool-args": {
+				const name = toolMap.nameOf(ev.index);
+				if (name !== "") parts.push({ functionCall: {
+					name,
+					args: parseArgs(ev.delta)
+				} });
+				break;
+			}
+			case "finish":
+				finish = finishToGemini(ev.reason);
+				break;
+			case "usage": usage = {
+				prompt: ev.promptTokens,
+				output: ev.completionTokens,
+				cached: ev.cachedTokens
+			};
+		}
+		return {
+			candidates: [{
+				content: {
+					role: "model",
+					parts
+				},
+				finishReason: finish,
+				index: 0
+			}],
+			usageMetadata: {
+				promptTokenCount: usage.prompt,
+				candidatesTokenCount: usage.output,
+				totalTokenCount: usage.prompt + usage.output,
+				...usage.cached > 0 ? { cachedContentTokenCount: usage.cached } : {}
+			}
+		};
+	}
+};
+/** 一帧 `candidates`。与 `encodeFrame` 里的闭包同形，供 `endFrames` 用。 */
+function chunkOf(parts, finish) {
+	return [dataFrame(JSON.stringify({ candidates: [{
+		content: {
+			role: "model",
+			parts
+		},
+		...finish === void 0 ? {} : { finishReason: finish }
+	}] }))];
+}
+/** 新建一份空的工具名映射。 */
+function newGeminiToolMap() {
+	const byName = /* @__PURE__ */ new Map();
+	const byIndex = /* @__PURE__ */ new Map();
+	/** index → 已累积的参数片段（跨帧拼接后才是完整 JSON）。 */
+	const argsByIndex = /* @__PURE__ */ new Map();
+	let seq = 0;
+	return {
+		indexOf(name) {
+			const existing = byName.get(name);
+			if (existing !== void 0) return existing;
+			const index = seq++;
+			byName.set(name, index);
+			byIndex.set(index, name);
+			return index;
+		},
+		nameOf(index) {
+			return byIndex.get(index) ?? "";
+		},
+		remember(index, name) {
+			byIndex.set(index, name);
+			if (!byName.has(name)) byName.set(name, index);
+		},
+		appendArgs(index, delta) {
+			const next = (argsByIndex.get(index) ?? "") + delta;
+			argsByIndex.set(index, next);
+			return next;
+		},
+		completeArgs(index) {
+			const raw = argsByIndex.get(index);
+			if (raw === void 0 || raw === "") return {};
+			try {
+				return obj(JSON.parse(raw)) ?? void 0;
+			} catch {
+				return;
+			}
+		},
+		pendingIndexes() {
+			return [...argsByIndex.keys()].sort((a, b) => a - b);
+		}
+	};
+}
+/**
+* 取本次调用的工具名映射：有会话用会话的，没有就临时建一份。
+*
+* 「没有会话」= 单帧独立转换（测试、非流式一次性）。结果与无状态等价 ——
+* 名字在自己的调用里总能拿到，只是不跨帧复用。
+*/
+function mapOf(session) {
+	const st = session?.state;
+	return st instanceof Object && "indexOf" in st ? st : newGeminiToolMap();
+}
+/**
+* 一个 Gemini 响应体（流式一帧或非流式 body，两者同形）→ 规范事件。
+*
+* Gemini 是四种协议里唯一「流与非流形状一致」的，所以只有这一份映射。
+*/
+function geminiBodyEvents(payload, tools) {
+	const out = [];
+	const candidate = obj(arr(payload.candidates)?.[0]);
+	if (candidate !== void 0) {
+		const finish = candidate.finishReason;
+		if (finish !== void 0 && finish !== null) out.push({
+			type: "finish",
+			reason: finishOf(finish)
+		});
+		for (const p of arr(obj(candidate.content)?.parts) ?? []) {
+			const part = obj(p);
+			if (part === void 0) continue;
+			const text = str(part.text);
+			if (text !== void 0) {
+				if (part.thought === true) out.push({
+					type: "reasoning",
+					text
+				});
+				else out.push({
+					type: "text",
+					text
+				});
+				continue;
+			}
+			const fc = obj(part.functionCall);
+			if (fc !== void 0) {
+				const name = str(fc.name) ?? "";
+				if (name === "") continue;
+				const index = tools.indexOf(name);
+				out.push({
+					type: "tool-start",
+					index,
+					name
+				});
+				out.push({
+					type: "tool-args",
+					index,
+					delta: JSON.stringify(fc.args ?? {})
+				});
+			}
+		}
+	}
+	const usage = obj(payload.usageMetadata);
+	if (usage !== void 0) out.push({
+		type: "usage",
+		promptTokens: num(usage.promptTokenCount) ?? 0,
+		completionTokens: num(usage.candidatesTokenCount) ?? 0,
+		cachedTokens: num(usage.cachedContentTokenCount) ?? 0
+	});
+	return out;
+}
+/** Gemini 的 systemInstruction → 纯文本。 */
+function systemText(sys) {
+	const parts = [];
+	for (const p of arr(obj(sys)?.parts) ?? []) {
+		const t = str(obj(p)?.text);
+		if (t !== void 0) parts.push(t);
+	}
+	return parts.join("\n\n");
+}
+/** Gemini contents → Chat messages。 */
+function geminiMessages(body) {
+	const out = [];
+	for (const c of arr(body.contents) ?? []) {
+		const item = obj(c);
+		if (item === void 0) continue;
+		const role = str(item.role) === "model" ? "assistant" : "user";
+		const text = [];
+		const toolCalls = [];
+		for (const p of arr(item.parts) ?? []) {
+			const part = obj(p);
+			if (part === void 0) continue;
+			const t = str(part.text);
+			if (t !== void 0) {
+				text.push(t);
+				continue;
+			}
+			const fc = obj(part.functionCall);
+			if (fc !== void 0) {
+				toolCalls.push({
+					id: `call_${str(fc.name) ?? ""}`,
+					type: "function",
+					function: {
+						name: str(fc.name) ?? "",
+						arguments: JSON.stringify(fc.args ?? {})
+					}
+				});
+				continue;
+			}
+			const fr = obj(part.functionResponse);
+			if (fr !== void 0) out.push({
+				role: "tool",
+				tool_call_id: `call_${str(fr.name) ?? ""}`,
+				content: JSON.stringify(obj(fr.response)?.result ?? {})
+			});
+		}
+		if (role === "assistant") {
+			const msg = {
+				role: "assistant",
+				content: text.join("\n\n")
+			};
+			if (toolCalls.length > 0) msg.tool_calls = toolCalls;
+			out.push(msg);
+		} else if (text.length > 0) out.push({
+			role: "user",
+			content: text.join("\n\n")
+		});
+	}
+	return out;
+}
+/** Chat 的 content（字符串或 parts）→ 纯文本。 */
+function contentText(content) {
+	if (typeof content === "string") return content;
+	const parts = [];
+	for (const p of arr(content) ?? []) {
+		const t = str(obj(p)?.text);
+		if (t !== void 0) parts.push(t);
+	}
+	return parts.join("\n\n");
+}
+function parseArgs(s) {
+	if (s === void 0 || s === "") return {};
+	try {
+		return obj(JSON.parse(s)) ?? {};
+	} catch {
+		return {};
+	}
+}
+/** Chat tools → Gemini functionDeclarations。 */
+function chatToolToGemini(t) {
+	const fn = obj(obj(t)?.function);
+	const name = fn === void 0 ? void 0 : str(fn.name);
+	if (fn === void 0 || name === void 0) return void 0;
+	return {
+		name,
+		description: str(fn.description) ?? "",
+		parameters: obj(fn.parameters) ?? {
+			type: "object",
+			properties: {}
+		}
+	};
+}
+/** Gemini tools → Chat tools。 */
+function convertTools(tools) {
+	const out = [];
+	for (const t of arr(tools) ?? []) for (const d of arr(obj(t)?.functionDeclarations) ?? []) {
+		const decl = obj(d);
+		if (decl === void 0) continue;
+		const name = str(decl.name);
+		if (name === void 0) continue;
+		out.push({
+			type: "function",
+			function: {
+				name,
+				description: str(decl.description) ?? "",
+				parameters: obj(decl.parameters) ?? {
+					type: "object",
+					properties: {}
+				}
+			}
+		});
+	}
+	return out;
+}
+function finishToGemini(reason) {
+	switch (reason) {
+		case "length": return "MAX_TOKENS";
+		case "tool-calls": return "STOP";
+		case "content-filter": return "SAFETY";
+		case "error": return "OTHER";
+		default: return "STOP";
+	}
+}
+//#endregion
+//#region src/protocol/index.ts
+const CODECS = {
+	chat: chatCodec,
+	anthropic: anthropicCodec,
+	responses: responsesCodec,
+	gemini: geminiCodec
+};
+/** 取编解码器。id 已由 `isProtocolId` 校验过，这里不再兜底。 */
+function codecOf(id) {
+	return CODECS[id];
+}
+//#endregion
+//#region src/protocol/stream.ts
+/** 一次流式转码的有状态累加。 */
+var StreamState = class {
+	/** 上游协议（解码用）。 */
+	from;
+	/** 客户端协议（编码用）。 */
+	to;
+	/** 上游 usage（跨帧合并，字段级 max —— 见 mergeUsage 的注释）。 */
+	usage = {
+		promptTokens: 0,
+		completionTokens: 0,
+		cachedTokens: 0
+	};
+	/** 已经吐过起始帧没有（起始帧只能在流最前发一次）。 */
+	started = false;
+	/** 收尾原因（用于补 endFrames；缺省 stop）。 */
+	finish;
+	/** 模型名（回显进 startFrames/endFrames，如 Anthropic 的 message_start）。 */
+	model = "";
+	/**
+	* 解码侧会话与编码侧会话，各一份。
+	*
+	* **必须每帧复用同一个**：Gemini 的工具名↔index 映射就存在这里；每帧新建
+	* 会让 `tool-args` 找不到 `tool-start` 给的名字（参数被丢），而放模块级会
+	* 跨请求串名。会话在 `StreamState` 构造时建、随流结束丢弃 —— 生命周期与
+	* 「一条流」严格对齐。
+	*/
+	decodeSession;
+	encodeSession;
+	constructor(from, to, model = "") {
+		this.from = from;
+		this.to = to;
+		this.model = model;
+		this.decodeSession = codecOf(from).createSession?.();
+		this.encodeSession = codecOf(to).createSession?.();
+	}
+	/** 当前累计的用量。 */
+	currentUsage() {
+		return { ...this.usage };
+	}
+	/** 把上游一帧原文（`data:` 载荷）翻成出站帧原文列表。 */
+	translateFrame(frame, event) {
+		const events = codecOf(this.from).decodeFrame(frame, event, this.decodeSession);
+		const out = [];
+		if (!this.started) {
+			this.started = true;
+			out.push(...codecOf(this.to).startFrames({
+				model: this.model,
+				stream: true
+			}));
+		}
+		for (const ev of events) {
+			if (ev.type === "usage") this.mergeUsage(ev);
+			if (ev.type === "finish") this.finish = ev;
+			if (ev.type === "finish" || ev.type === "usage") continue;
+			out.push(...codecOf(this.to).encodeFrame(ev, this.encodeSession));
+		}
+		return out;
+	}
+	/**
+	* 上游流结束：补发收尾帧。
+	*
+	* **顺序固定**：finish → usage → endFrames。各协议的收尾帧都要求这个次序
+	* （Anthropic 的 message_delta 必须在 message_stop 前，Responses 的
+	* `response.completed` 是最后一件且自带 usage）。
+	*
+	* `endFrames` 拿得到 finish 与 usage —— 有的协议（Responses）只有收尾帧
+	* 里才有地方放 usage 与「是否被截断」。
+	*/
+	finishStream() {
+		const enc = codecOf(this.to);
+		const ctx = {
+			model: this.model,
+			stream: true,
+			finish: this.finish?.reason ?? "stop",
+			usage: { ...this.usage }
+		};
+		if (!this.started) {
+			this.started = true;
+			return [...enc.startFrames(ctx), ...enc.endFrames(ctx, this.encodeSession)];
+		}
+		const finishSession = this.finishSessionWithUsage();
+		const out = [];
+		out.push(...enc.encodeFrame(this.finish ?? {
+			type: "finish",
+			reason: "stop"
+		}, finishSession));
+		out.push(...enc.encodeFrame({
+			type: "usage",
+			...this.usage
+		}, finishSession));
+		out.push(...enc.endFrames(ctx, finishSession));
+		return out;
+	}
+	/**
+	* 带当前用量派生的编码会话。
+	*
+	* 不能只在 `encodeSession` 存在时才派生：`createSession` 是**可选**的
+	* （只有 Gemini 这类有跨帧映射的协议实现它），Anthropic 没有 —— 按
+	* `encodeSession === undefined` 就返回 undefined 会让 usage 永远送不进去
+	* （2026-10-21 实测：output_tokens 恒为 0）。所以无论如何都造一个，
+	* 有 state 就带上。
+	*/
+	finishSessionWithUsage() {
+		return {
+			...this.encodeSession,
+			usage: { ...this.usage }
+		};
+	}
+	/**
+	* usage 合并：字段级 max。
+	*
+	* 与 `router/usage-tokens.ts` 的 `mergeUsage` 同规则（那里照 9router）：
+	* Claude 把输入用量放 `message_start`、输出放 `message_delta`，两帧都给
+	* `usage` 字段，**覆盖**会让后一帧把前面的输入清零。
+	*/
+	mergeUsage(ev) {
+		this.usage.promptTokens = Math.max(this.usage.promptTokens, ev.promptTokens);
+		this.usage.completionTokens = Math.max(this.usage.completionTokens, ev.completionTokens);
+		this.usage.cachedTokens = Math.max(this.usage.cachedTokens, ev.cachedTokens);
+	}
+};
+/**
+* 把上游 SSE 字节流转成客户端协议的 SSE 字节流。
 *
-* `requestChars` = 请求体字符数（估输入），`outputChars` = 输出字符数（估输出）。
-* 上游给了的字段**不覆盖**——估算只填空，不抢真数据。
+* 生命周期：上游正常读完 / 上游 error / 消费方取消，三条路径都要**释放上游
+* reader** 并把取消传下去 —— 否则上游 fetch body 永不 cancel，长跑会漏连接
+* （`router/index.ts` 的 `normalizeSSEStream` 里同一个坑，判据在
+* `router/disconnect-leak.test.ts`）。
 */
-function withEstimates(usage, requestChars, outputChars) {
-	const prompt = usage?.promptTokens ?? 0;
-	const completion = usage?.completionTokens ?? 0;
-	const inputEstimated = prompt === 0;
-	const outputEstimated = completion === 0;
-	return {
-		promptTokens: inputEstimated ? estimateTokens(requestChars) : prompt,
-		completionTokens: outputEstimated ? estimateTokens(outputChars) : completion,
-		cachedTokens: usage?.cachedTokens ?? 0,
-		inputEstimated,
-		outputEstimated
+function translateStream(upstream, state) {
+	const splitter = new SseSplitter();
+	let reader;
+	let released = false;
+	const release = () => {
+		if (released) return;
+		released = true;
+		try {
+			reader?.releaseLock();
+		} catch {}
 	};
+	return new ReadableStream({
+		async start(ctrl) {
+			reader = upstream.getReader();
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					const frames = splitter.push(value);
+					for (const f of frames) {
+						if (f.data === "[DONE]" || f.data === "") continue;
+						const out = state.translateFrame(f.data, f.event);
+						if (out.length > 0) ctrl.enqueue(framesToBytes(out));
+					}
+				}
+				for (const f of splitter.end()) {
+					if (f.data === "[DONE]" || f.data === "") continue;
+					const out = state.translateFrame(f.data, f.event);
+					if (out.length > 0) ctrl.enqueue(framesToBytes(out));
+				}
+				const tail = state.finishStream();
+				if (tail.length > 0) ctrl.enqueue(framesToBytes(tail));
+			} catch {} finally {
+				release();
+			}
+			try {
+				ctrl.close();
+			} catch {}
+		},
+		cancel: (reason) => reader?.cancel(reason)
+	});
 }
 //#endregion
 //#region src/router/index.ts
@@ -1603,28 +3811,35 @@ function reqMessages(rawBody) {
 		return;
 	}
 }
-/** 丢弃响应的假 ServerResponse（测试模型用：记录状态+内容，用于判定成败）。 */
-function sinkRes() {
-	let status = 200;
-	let text = "";
+/** 把 ResponseSink 包成一个 Router 能写的 ServerResponse。 */
+function sinkRes(sink) {
 	const self = {
 		headersSent: false,
 		writableEnded: false,
-		writeHead: (code) => {
-			status = code;
+		destroyed: false,
+		writeHead: (code, headers) => {
+			sink.head?.(code, headers ?? {});
 			return self;
 		},
 		write: (chunk) => {
-			if (chunk !== void 0) text += String(chunk);
+			if (chunk !== void 0) sink.write(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
 			return true;
 		},
 		end: (chunk) => {
-			if (chunk !== void 0) text += String(chunk);
+			if (chunk !== void 0) self.write(chunk);
+			sink.end();
 			return self;
 		},
 		flushHeaders: () => {},
-		status: () => status,
-		body: () => text
+		once: () => self,
+		on: () => self,
+		removeListener: () => self,
+		destroy: () => {
+			self.destroyed = true;
+		},
+		setHeader: () => self,
+		removeHeader: () => self,
+		writeableEnded: false
 	};
 	return self;
 }
@@ -1978,6 +4193,51 @@ async function writeChatResult(res, r, wantsStream, probe, startedAt = 0, firstB
 }
 /** SSE 终止帧（断流兜底补发用）。 */
 const DONE_FRAME = new TextEncoder().encode("data: [DONE]\n\n");
+/**
+* 取该供应商的 `chatOnce`，按它声明的 wire 包一层协议翻译。
+*
+* ════════════════════════════════════════════════════════════════════
+* 为什么翻译放在核心、而不是让插件自己做
+* ════════════════════════════════════════════════════════════════════
+* 插件自己翻译意味着「每个只会说 Anthropic 的供应商各写一份 Anthropic→OpenAI
+* 转换」，与账号池/冷却表/积分落盘是同一个错误：N 份互相不一致的实现，核心
+* 也就无从判断该不该换号。放在核心，插件契约不变（仍只吐 OpenAI SSE），
+* 换号/冷却/用量全部照旧生效。
+*
+* 翻译**只碰请求体与响应流**，不碰 `chatOnce` 的返回值语义：失败仍然返回
+* `{ok:false, state, message}`，核心的冷却/回退逻辑一行不改。
+*
+* 非流式同理：上游给 JSON 时，先把它翻成规范 JSON 再交给核心（`writeChatResult`
+* 的 `!('stream' in r)` 分支），客户端要流式而上游只给 JSON 时由现有的
+* `aggregateSSE` 兜底（那条路径本来就要把 JSON 折成流）。
+*/
+function wireChatOnce(s) {
+	const wire = s.wire ?? "chat";
+	if (wire === "chat") return (uid, lv, req) => s.chatOnce(uid, lv, req);
+	const codec = codecOf(wire);
+	return async (uid, lv, req) => {
+		let outReq = req;
+		let body;
+		try {
+			body = JSON.parse(req.rawBody);
+		} catch {
+			body = void 0;
+		}
+		if (body !== void 0) outReq = {
+			...req,
+			rawBody: JSON.stringify(codec.fromChat(body, {
+				model: req.model,
+				stream: req.stream
+			}))
+		};
+		const r = await s.chatOnce(uid, lv, outReq);
+		if (!r.ok || !("stream" in r)) return r;
+		return {
+			ok: true,
+			stream: translateStream(r.stream, new StreamState(wire, "chat"))
+		};
+	};
+}
 /** 从上游响应体提取错误信息（OpenAI {error:{message}} 或 {code,msg}/{message}）。 */
 function extractUpstreamError(body) {
 	try {
@@ -2164,6 +4424,15 @@ var Router = class {
 		} catch {}
 		return out;
 	}
+	/**
+	* 该供应商的 `chatOnce`，已按它声明的 wire 包好协议翻译。
+	*
+	* 每次调用都现取（而不是构造时缓存）：供应商会被开关/热重载替换，
+	* 缓存会把旧实例的翻译绑在新实例上。
+	*/
+	wireOf(s) {
+		return wireChatOnce(s);
+	}
 	/** 组合列表（面板用）：用户自定义组合。 */
 	async combos() {
 		return [...this.customCombos];
@@ -2402,7 +4671,17 @@ var Router = class {
 	* - model 命中组合名 → 在组合模型里按策略选一个，交给供应商；失败按回退顺序尝试剩余模型。
 	* - 否则 → 依次尝试供应商，直到某个返回 true（已写响应）或全部返回 false。
 	*/
-	async chatCompletions(req, res) {
+	/**
+	* 规范请求入口。
+	*
+	* @param res 真实的客户端响应。协议非 chat 时**不直接用它**，而是经
+	*   `sink` 先收集再翻译（见 `protocol/entry.ts`）—— 因为 Router 只知道
+	*   怎么写 OpenAI 形态，而客户端说的可能是 Anthropic/Gemini。
+	* @param sink 可选的响应收集器：给了就把「写给 res 的东西」改成写给 sink，
+	*   由调用方翻译后自己写真正的 res。只给非 chat 协议用。
+	*/
+	async chatCompletions(req, res, sink) {
+		const out = sink === void 0 ? res : sinkRes(sink);
 		const probe = {
 			requested: req.model,
 			supplier: "",
@@ -2439,34 +4718,34 @@ var Router = class {
 				const model = combo.models[i];
 				if (model === void 0) continue;
 				const trace = { attempts: 0 };
-				if (await this.chatWithModel(req, res, model, probe, trace, Date.now() + this.firstByteBudgetMs)) {
+				if (await this.chatWithModel(req, out, model, probe, trace, Date.now() + this.firstByteBudgetMs)) {
 					settle(true);
 					return;
 				}
 				if (trace.lastState !== void 0 && isTransient(trace.lastState) && i < combo.models.length - 1) await new Promise((r) => setTimeout(r, TRANSIENT_SETTLE_MS));
 			}
 			settle(false, "combo: all models unavailable");
-			writeJson$2(res, 503, openAIError("no_healthy_supplier", `combo ${JSON.stringify(req.model)}: all models unavailable`));
+			writeJson$2(out, 503, openAIError("no_healthy_supplier", `combo ${JSON.stringify(req.model)}: all models unavailable`));
 			return;
 		}
 		const slash = req.model.indexOf("/");
 		const alias = slash > 0 ? req.model.slice(0, slash) : "";
 		const target = alias === "" ? void 0 : this.supplierByAlias(alias);
 		if (target !== void 0) {
-			if (await this.chatWithTarget(target, req, res, probe)) {
+			if (await this.chatWithTarget(target, req, out, probe)) {
 				settle(true);
 				return;
 			}
 			settle(false, `supplier ${target.id}: all accounts unavailable`);
-			writeJson$2(res, 503, openAIError("no_healthy_supplier", `supplier ${JSON.stringify(target.id)}: all accounts unavailable`));
+			writeJson$2(out, 503, openAIError("no_healthy_supplier", `supplier ${JSON.stringify(target.id)}: all accounts unavailable`));
 			return;
 		}
-		if (await this.chatWithModel(req, res, req.model, probe)) {
+		if (await this.chatWithModel(req, out, req.model, probe)) {
 			settle(true);
 			return;
 		}
 		settle(false, "all suppliers unavailable");
-		writeJson$2(res, 503, openAIError("no_healthy_supplier", "all suppliers unavailable"));
+		writeJson$2(out, 503, openAIError("no_healthy_supplier", "all suppliers unavailable"));
 	}
 	/** 调指定供应商。
 	*  模型名**原样**传给插件（不在这剥 alias/）——插件自己认得自己的别名
@@ -2550,8 +4829,9 @@ var Router = class {
 	async chatWithSupplier(s, req, res, trace, probe, firstByteDeadlineAt = Date.now() + this.firstByteBudgetMs, onlyUid) {
 		const pool = s.pool;
 		const cfg = this.store.get(s.id);
+		const chatOnce = this.wireOf(s);
 		if (s.accounts !== void 0 && s.accounts().length === 0) {
-			const r = await s.chatOnce("", req.lv ?? "auto", req);
+			const r = await chatOnce("", req.lv ?? "auto", req);
 			if (!r.ok) {
 				if (r.state === "no_such_model" || r.state === "bad_request") return false;
 				if (trace !== void 0) trace.lastState = r.state;
@@ -2587,7 +4867,7 @@ var Router = class {
 			}
 			pickWhy = pool.lastWhy;
 			tried.add(uid);
-			const r = await s.chatOnce(uid, req.lv ?? "auto", req);
+			const r = await chatOnce(uid, req.lv ?? "auto", req);
 			if (!r.ok) {
 				if (r.state === "no_such_model" || r.state === "bad_request") {
 					if (trace !== void 0) {
@@ -2596,7 +4876,7 @@ var Router = class {
 					}
 					return false;
 				}
-				pool.noteFailure(uid, req.model, r.state, r.message);
+				pool.noteFailure(uid, req.model, r.state, r.message, r.resetAt);
 				pool.dropBlock(req.model);
 				if (trace !== void 0) {
 					trace.attempts += 1;
@@ -2642,7 +4922,19 @@ var Router = class {
 			ok: false,
 			error: `unknown supplier ${JSON.stringify(supplierId)}`
 		};
-		const sink = sinkRes();
+		let sinkStatus = 200;
+		let sinkBody = "";
+		const sink = sinkRes({
+			head: (code) => {
+				sinkStatus = code;
+			},
+			write: (bytes) => {
+				sinkBody += new TextDecoder().decode(bytes);
+			},
+			end: () => {}
+		});
+		const statusOf = () => sinkStatus;
+		const bodyOf = () => sinkBody;
 		const req = {
 			model,
 			stream: false,
@@ -2666,8 +4958,8 @@ var Router = class {
 				error: err.message
 			};
 		}
-		if (served && sink.status() < 400) return { ok: true };
-		const fromSink = served && sink.status() >= 400 ? extractUpstreamError(sink.body()) : "";
+		if (served && statusOf() < 400) return { ok: true };
+		const fromSink = served && statusOf() >= 400 ? extractUpstreamError(bodyOf()) : "";
 		const detail = fromSink !== "" ? fromSink : trace.lastError;
 		return {
 			ok: false,
@@ -3036,16 +5328,18 @@ async function* translateSse(payloads) {
 					usage
 				};
 			}
+			const hasCompleteToolCall = complete.some((block) => block.kind === "tool-call");
 			const reason = pendingFinish ?? { kind: "stop" };
+			const resolved = reason.kind === "stop" && hasCompleteToolCall ? { kind: "tool-calls" } : reason;
 			yield {
 				type: "finish",
-				reason: reason.kind === "stop" && order.length === 0 ? {
+				reason: resolved.kind === "stop" && order.length === 0 ? {
 					kind: "error",
 					failure: {
 						message: "model returned a completed response with no content",
 						code: EMPTY_RESPONSE_CODE
 					}
-				} : reason
+				} : resolved
 			};
 			return;
 		}
@@ -4096,7 +6390,7 @@ function guard(handler) {
 		}
 	};
 }
-async function readBody$1(req, limit = 65536) {
+async function readBody$2(req, limit = 65536) {
 	const chunks = [];
 	let size = 0;
 	return await new Promise((resolve, reject) => {
@@ -4169,7 +6463,7 @@ function supplierRoutes(base, loaded, store, router) {
 		handler: async (req, res) => {
 			let body;
 			try {
-				body = JSON.parse(await readBody$1(req));
+				body = JSON.parse(await readBody$2(req));
 			} catch {
 				writeJson$1(res, 400, {
 					ok: false,
@@ -4206,7 +6500,7 @@ function supplierRoutes(base, loaded, store, router) {
 			}
 			try {
 				let pick = {};
-				const raw = (await readBody$1(req)).trim();
+				const raw = (await readBody$2(req)).trim();
 				if (raw !== "") {
 					const body = JSON.parse(raw);
 					pick = {
@@ -4267,7 +6561,7 @@ function supplierRoutes(base, loaded, store, router) {
 		kind: "exact",
 		path: `${p}/alias`,
 		handler: async (req, res) => {
-			const clean = (JSON.parse(await readBody$1(req)).alias ?? "").trim();
+			const clean = (JSON.parse(await readBody$2(req)).alias ?? "").trim();
 			if (clean !== "" && !/^[A-Za-z0-9_-]+$/.test(clean)) {
 				writeJson$1(res, 400, {
 					ok: false,
@@ -4290,7 +6584,7 @@ function supplierRoutes(base, loaded, store, router) {
 		kind: "exact",
 		path: `${p}/models/toggle`,
 		handler: guard(async (req, res) => {
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			store.get(s.id);
 			const models = await router.modelsOf(s.id);
 			if (!body.id || !models.some((mm) => mm.id === body.id)) {
@@ -4309,7 +6603,7 @@ function supplierRoutes(base, loaded, store, router) {
 		kind: "exact",
 		path: `${p}/models/add`,
 		handler: guard(async (req, res) => {
-			const id = (JSON.parse(await readBody$1(req)).id ?? "").trim();
+			const id = (JSON.parse(await readBody$2(req)).id ?? "").trim();
 			if (id === "") {
 				writeJson$1(res, 400, {
 					ok: false,
@@ -4333,7 +6627,7 @@ function supplierRoutes(base, loaded, store, router) {
 		kind: "exact",
 		path: `${p}/models/remove`,
 		handler: async (req, res) => {
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			const cfg = store.get(s.id);
 			if (!body.id || !cfg.custom.includes(body.id)) {
 				writeJson$1(res, 400, {
@@ -4351,7 +6645,7 @@ function supplierRoutes(base, loaded, store, router) {
 		kind: "exact",
 		path: `${p}/models/bulk`,
 		handler: guard(async (req, res) => {
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			const models = await router.modelsOf(s.id);
 			store.setAllModelsEnabled(s.id, !!body.enabled, models.map((mm) => mm.id));
 			router.invalidateModels(s.id);
@@ -4369,7 +6663,7 @@ function supplierRoutes(base, loaded, store, router) {
 				});
 				return;
 			}
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			if (!Array.isArray(body.uids) || body.uids.some((u) => typeof u !== "string")) {
 				writeJson$1(res, 400, {
 					ok: false,
@@ -4395,7 +6689,7 @@ function supplierRoutes(base, loaded, store, router) {
 		kind: "exact",
 		path: `${p}/models/test`,
 		handler: async (req, res) => {
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			const onlyUid = typeof body.uid === "string" && body.uid !== "" ? body.uid : void 0;
 			const result = await router.testModel(s.id, body.id ?? "", onlyUid);
 			writeJson$1(res, result.ok ? 200 : 400, result);
@@ -4431,7 +6725,7 @@ function supplierRoutes(base, loaded, store, router) {
 				});
 				return;
 			}
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			try {
 				writeJson$1(res, 200, {
 					ok: true,
@@ -4456,7 +6750,7 @@ function supplierRoutes(base, loaded, store, router) {
 				});
 				return;
 			}
-			const body = JSON.parse(await readBody$1(req));
+			const body = JSON.parse(await readBody$2(req));
 			try {
 				const r = await m.addApiKey.call(loaded.supplier, {
 					name: (body.name ?? "").trim(),
@@ -4482,7 +6776,7 @@ function supplierRoutes(base, loaded, store, router) {
 				});
 				return;
 			}
-			const uid = JSON.parse(await readBody$1(req)).uid ?? "";
+			const uid = JSON.parse(await readBody$2(req)).uid ?? "";
 			const ok = await s.removeLink(uid);
 			if (ok) store.clearCredits(s.id, uid);
 			writeJson$1(res, ok ? 200 : 404, ok ? { ok: true } : {
@@ -4887,6 +7181,332 @@ var ExtStore = class {
 	}
 };
 //#endregion
+//#region src/protocol/entry.ts
+/**
+* 读请求体 + 按协议翻成规范请求。
+*
+* 模型名从哪来因协议而异：Chat/Anthropic/Responses 在 body 的 `model`，
+* Gemini 在 URL 路径（`:generateContent` 之前那段）—— 由 `modelFromPath`
+* 调用方先解析好传进来。
+*/
+async function parseInbound(req, protocol, opts) {
+	const raw = await readBody$1(req, opts.limitBytes);
+	if (raw === void 0) return {
+		error: "request body too large",
+		status: 413
+	};
+	let body;
+	try {
+		body = JSON.parse(raw);
+	} catch {
+		return {
+			error: "invalid JSON body",
+			status: 400
+		};
+	}
+	const codec = codecOf(protocol);
+	const model = opts.modelFromPath ?? str(body.model) ?? "";
+	const stream = opts.streamFromPath ?? body.stream === true;
+	const canonical = codec.toChat(body, {
+		model,
+		stream
+	});
+	canonical.stream = stream;
+	canonical.model = model;
+	return {
+		body: canonical,
+		stream,
+		model,
+		lv: opts.lvFromBody?.(body) ?? "auto",
+		protocol
+	};
+}
+/**
+* 一段上游字节像不像 SSE。
+*
+* 只在 content-type **没有**任何提示时才用（流式路径的 `head` 可能一次都不来）。
+* 判据是「第一段非空白内容是否 SSE 行」，不是「包含 data:」—— 后者会让一个
+* 错误 JSON（`{"error":"data: bad"}`）被误判成流。
+*/
+function looksLikeSse(text) {
+	const head = text.replace(/^\s+/, "");
+	return head.startsWith("data:") || head.startsWith("event:") || head.startsWith(":");
+}
+/** 上游字节 → 文本（逐字节流式解码，跨 chunk 的多字节字符不会被打断）。 */
+const decoder = new TextDecoder();
+/** 文本 → 字节。 */
+const encoder = new TextEncoder();
+/**
+* 给 Router 的**非 chat 出口**：收集 OpenAI 形态的响应，翻译成客户端协议。
+*
+* ════════════════════════════════════════════════════════════════════
+* 两条路径分开处理，因为时序完全不同
+* ════════════════════════════════════════════════════════════════════
+*  非流式：Router 一次 `head(200) + end(json)`。整份 JSON 已在手里，
+*          `decodeJson` → `encodeJson` 一个来回就完。
+*  流式：  Router 分很多次 `write(bytes)`，且**第一个字节前可能失败换号**。
+*          不能等收齐再翻（那就没有流式了）；每收到一段就翻一段。
+*
+* 流式那条为什么插一层 sink 而不是让 Router 直接写翻译后的字节：Router 的
+* `writeChatResult` 里有一整套「客户端断开就取消上游流」「断流补 `[DONE]`」
+* 的逻辑，那些必须继续对真实的 `res` 生效。sink 只是**转发的中继**：
+* 它翻译字节、写给真正的 res；断开时调用方取消本层（见 index.ts 挂载处），
+* Router 那侧的取消链路原样传到上游。
+*/
+function outboundSink(protocol, model, res) {
+	const codec = codecOf(protocol);
+	let headSent = false;
+	/** 流式：转码器（收到第一段 SSE 时初始化，跨 write 保持分帧状态）。 */
+	let translator;
+	/** 非流式：攒起来的 JSON（`undefined` = 还没收到过 body）。 */
+	let jsonBuf;
+	let status = 200;
+	/**
+	* 上游给的 content-type —— **判断流还是 JSON 只看它**，不看内容。
+	*
+	* 早先靠 `text.startsWith('data:')` 猜：那是错的。非流式 JSON body 里如果
+	* 有以 `data:` 开头的字符串值（错误信息里带 "data: ..."）、或者上游先发一段
+	* 空白，就会被误判成 SSE，然后 JSON 被当帧喂给翻译器 —— 客户端拿到一个
+	* 空流而不是错误信息。content-type 是 Router/上游**明确给出的**事实。
+	*/
+	let contentType = "";
+	const sendHead = (code, contentType) => {
+		if (headSent) return;
+		headSent = true;
+		res.writeHead(code, {
+			"Content-Type": contentType,
+			"Cache-Control": "no-store"
+		});
+		if (typeof res.flushHeaders === "function") res.flushHeaders();
+	};
+	return {
+		head(code, headers) {
+			status = code;
+			const ct = headers["content-type"] ?? headers["Content-Type"] ?? "";
+			if (ct !== "") contentType = ct.toLowerCase();
+			if (code !== 200) sendHead(code, ct !== "" ? ct : "application/json; charset=utf-8");
+		},
+		write(bytes) {
+			const text = decoder.decode(bytes, { stream: true });
+			if (text === "") return;
+			if (translator === void 0 && (contentType.includes("text/event-stream") || contentType === "" && looksLikeSse(text))) translator = new ChunkTranslator(new StreamState("chat", protocol, model));
+			if (translator !== void 0) {
+				const frames = translator.push(text);
+				if (frames.length > 0) {
+					sendHead(200, "text/event-stream");
+					res.write(encoder.encode(frames.join("")));
+				} else if (!headSent) sendHead(200, "text/event-stream");
+				return;
+			}
+			jsonBuf = (jsonBuf ?? "") + text;
+		},
+		end() {
+			const tailChunk = decoder.decode();
+			if (tailChunk !== "") {
+				if (translator !== void 0) {
+					const frames = translator.push(tailChunk);
+					if (frames.length > 0) res.write(encoder.encode(frames.join("")));
+				} else jsonBuf = (jsonBuf ?? "") + tailChunk;
+			}
+			if (jsonBuf !== void 0 && jsonBuf !== "") {
+				finishJson(codec, protocol, model, res, sendHead, status, jsonBuf);
+				return;
+			}
+			if (translator !== void 0) {
+				const tail = translator.end();
+				if (tail.length > 0) {
+					sendHead(200, "text/event-stream");
+					res.write(encoder.encode(tail.join("")));
+				}
+				if (headSent) res.end();
+				else finishEmptyStream(codec, protocol, model, res, sendHead);
+				return;
+			}
+			finishEmptyStream(codec, protocol, model, res, sendHead);
+		}
+	};
+}
+/**
+* 非流式：整份 JSON 翻译后写出。
+*
+* ⚠️ 方向在这里：Router 吐的是 **OpenAI Chat** 形态（`choices[0].message`），
+* 而客户端要的是 `protocol` 说的形态。所以**解码用 chat codec、编码用客户端
+* codec** —— 曾经两处都用客户端的 codec，于是 Chat JSON 被当成 Anthropic
+* body 解（`choices` 字段根本不存在），客户端拿到一个 content 为空的回复。
+*/
+function finishJson(clientCodec, protocol, model, res, sendHead, status, jsonBuf) {
+	let events;
+	try {
+		events = codecOf("chat").decodeJson(JSON.parse(jsonBuf));
+	} catch {
+		sendHead(status, "application/json; charset=utf-8");
+		res.end(jsonBuf);
+		return;
+	}
+	const err = events.find((e) => e.type === "error");
+	if (err !== void 0 && err.type === "error") {
+		sendHead(502, "application/json; charset=utf-8");
+		res.end(JSON.stringify(errBody(protocol, err.message)));
+		return;
+	}
+	const body = clientCodec.encodeJson(events, {
+		model,
+		stream: false
+	});
+	sendHead(status, "application/json; charset=utf-8");
+	res.end(JSON.stringify(body));
+}
+/**
+* 流式但一个内容帧都没翻译出来（上游刚连上就断 / 首字节超时前就失败）。
+*
+* 给客户端一个**协议合法的空流**，别让 HTTP 连接裸断：客户端会把「没有响应」
+* 当成网络故障重试，而「上游没答」才是事实——用协议的 error 收尾说出来。
+*/
+function finishEmptyStream(codec, protocol, model, res, sendHead) {
+	const ctx = {
+		model,
+		stream: true,
+		finish: "error"
+	};
+	const frames = [
+		...codec.startFrames(ctx),
+		...codec.encodeFrame({
+			type: "error",
+			message: "upstream closed before any content"
+		}),
+		...codec.encodeFrame({
+			type: "finish",
+			reason: "error"
+		}),
+		...codec.endFrames(ctx)
+	];
+	sendHead(200, "text/event-stream");
+	res.end(new TextEncoder().encode(frames.join("")));
+}
+/** 每种协议的 error body 形状。 */
+function errBody(protocol, message) {
+	if (protocol === "anthropic") return {
+		type: "error",
+		error: {
+			type: "api_error",
+			message
+		}
+	};
+	if (protocol === "gemini") return { error: {
+		code: 502,
+		message,
+		status: "UNAVAILABLE"
+	} };
+	return { error: {
+		message,
+		type: "api_error",
+		code: "upstream_error"
+	} };
+}
+/**
+* 一段上游 OpenAI SSE 文本的转码器 —— **有状态**。
+*
+* 上游一帧被拆在两个 TCP 段里是常态（Router 按拿到的字节原样转交），所以
+* 分帧缓冲必须跨 `write()` 调用存活。这里用 `sse.ts` 的 `SseSplitter`（它内部
+* 留着半个帧）而不是每次现切 —— 早先每次现切会把不完整帧当完整帧解析，
+* 表现是「文本丢一半、工具参数截断」，而 HTTP 200，客户端看不到任何错误。
+*
+* 生命周期与 sink 一致：一个请求一个实例。
+*/
+var ChunkTranslator = class {
+	splitter = new SseSplitter();
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	/** 喂一段文本，返回可写给客户端的帧。 */
+	push(text) {
+		return this.emit(this.splitter.push(new TextEncoder().encode(text)));
+	}
+	/** 流结束：冲刷残留帧（上游不发尾空行是有的），返回收尾帧。 */
+	end() {
+		return [...this.emit(this.splitter.end()), ...this.state.finishStream()];
+	}
+	emit(frames) {
+		const out = [];
+		for (const f of frames) {
+			if (f.data === "" || f.data === "[DONE]") continue;
+			out.push(...this.state.translateFrame(f.data, f.event));
+		}
+		return out;
+	}
+};
+/** 读请求体（带大小上限）。超限返回 undefined。 */
+function readBody$1(req, limit) {
+	return new Promise((resolve) => {
+		const chunks = [];
+		let size = 0;
+		req.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > limit) {
+				req.destroy();
+				resolve(void 0);
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+		req.on("error", () => resolve(void 0));
+	});
+}
+/**
+* 从 Gemini 的 URL 路径里取模型名。
+*
+* 形如 `/v1beta/models/<model>:generateContent`（或 `:streamGenerateContent`），
+* `<model>` 本身可以含斜杠，所以取 `models/` 之后到最后一个 `:` 之前那段。
+*
+* **必须先切掉 query**：Gemini CLI 默认带 `?alt=sse`，不切的话 `$` 锚点匹配
+* 不上，模型名变空 —— 表现为「404 model not found」而不是参数错误，很难查。
+* 顺便支持 `/v1beta/models/<model>` 这种带版本号但无方法的形态（走 GET 列表时
+* 会撞上，这里取不到 `/` 就是取不到，返回 undefined 让上层报 400）。
+*/
+function geminiModelFromPath(pathname) {
+	const path = pathname.split("?")[0] ?? "";
+	return /\/models\/(.+?):(?:streamGenerateContent|generateContent|countTokens)$/.exec(path)?.[1];
+}
+/**
+* Gemini 的流式意图在**路径尾部**：`:streamGenerateContent` 是流式、
+* `:generateContent` 是非流式。返回 `undefined` 表示路径没表态（不是 Gemini
+* 形态，或路径不可识别），交给 body 的 `stream` 决定。
+*
+* 为什么不能只看 body：Gemini 的请求体里**没有** `stream` 字段 —— 它的官方
+* 契约就是靠 URL 区分两种方法。不认这个，流式请求会被当成非流式，客户端按
+* SSE 解析一整个 JSON ⇒ 空响应（2026-10-21 在 3080 实测到）。
+*/
+function geminiStreamFromPath(pathname) {
+	const path = pathname.split("?")[0] ?? "";
+	if (/:streamGenerateContent$/.test(path)) return true;
+	if (/:generateContent$/.test(path)) return false;
+}
+/**
+* 从请求体取推理等级（各协议字段名不同）。
+*
+* 只认「明确说了要多少思考」的形态，其余一律 'auto'：把「有这个字段」当成
+* 「要高档推理」会让所有带 thinking 块的请求都按 high 走，费用与延迟都变。
+*/
+function lvOf(body, protocol) {
+	const direct = str(body.reasoning_effort);
+	if (direct !== void 0) return direct;
+	const effort = str(body.reasoning) ?? str(body.effort);
+	if (effort !== void 0) return effort;
+	const budget = body.generationConfig;
+	if (budget !== void 0) {
+		const tb = budget.thinkingConfig?.thinkingBudget;
+		if (typeof tb === "number" && tb > 0) return "high";
+	}
+	const thinking = body.thinking;
+	if (thinking !== void 0) {
+		const tb = thinking.budget_tokens;
+		if (typeof tb === "number" && tb > 0) return "high";
+	}
+	return "auto";
+}
+//#endregion
 //#region src/index.ts
 /**
 * Plugin identity for cordis.yml rows — 必须与 package.json 的 name 一致。
@@ -4925,6 +7545,33 @@ function writeJson(res, status, body) {
 	});
 	res.end(payload);
 }
+/**
+* 每种协议的 error body 形状。
+*
+* 为什么必须有：非 chat 入口的 400/413/501 若照 OpenAI 的
+* `{error:{message,type,code}}` 写，Claude Code 解析不到 `error.message`
+* 会显示「未知错误」——用户看到的是一个空错误，而真因（如 body 太大）
+* 就在手边却送不出去。
+*/
+function errBodyFor(protocol, message) {
+	if (protocol === "anthropic") return {
+		type: "error",
+		error: {
+			type: "invalid_request_error",
+			message
+		}
+	};
+	if (protocol === "gemini") return { error: {
+		code: 400,
+		message,
+		status: "INVALID_ARGUMENT"
+	} };
+	return { error: {
+		message,
+		type: "api_error",
+		code: "invalid_request"
+	} };
+}
 function readBody(req, limit) {
 	return new Promise((resolve, reject) => {
 		const chunks = [];
@@ -5108,15 +7755,67 @@ function apply(rawContext) {
 		}
 		const lv = typeof peek.reasoning_effort === "string" && peek.reasoning_effort !== "" ? peek.reasoning_effort : "auto";
 		const sessionRaw = req.headers["x-dsh-router-session"];
-		const session = typeof sessionRaw === "string" && sessionRaw !== "" ? sessionRaw : void 0;
+		const session = (typeof sessionRaw === "string" && sessionRaw !== "" ? sessionRaw : void 0) ?? clientIdentityOf(peek, req.headers["user-agent"]);
 		await router.chatCompletions({
 			rawBody: body,
 			stream: !!peek.stream,
 			model: typeof peek.model === "string" ? peek.model : "",
 			lv,
-			...session === void 0 ? {} : { session }
+			...session === void 0 ? {} : { session },
+			protocol: "chat"
 		}, res);
 	}));
+	/**
+	* Anthropic / Responses / Gemini 三个非 chat 入口的**公共前半段**：
+	* 鉴权 → 读 body → 翻成规范请求 → 交给 Router → 把响应翻回客户端协议。
+	*
+	* 抽出来是因为三者的差别只有「协议 id 是什么、模型名从哪取」，而鉴权/限流/
+	* 归因/错误形状必须完全一致 —— 各写一份就会出现「Anthropic 入口认了
+	* x-dsh-router-session、Gemini 入口不认」这种只能靠实测发现的漂移。
+	*/
+	const enterProtocol = (protocol) => withV1Auth(async (req, res) => {
+		const parsed = await parseInbound(req, protocol, {
+			limitBytes: 8 << 20,
+			modelFromPath: protocol === "gemini" ? geminiModelFromPath(req.url ?? "") : void 0,
+			streamFromPath: protocol === "gemini" ? geminiStreamFromPath(req.url ?? "") : void 0,
+			lvFromBody: (body) => lvOf(body, protocol)
+		});
+		if ("error" in parsed) {
+			writeJson(res, parsed.status, errBodyFor(protocol, parsed.error));
+			return;
+		}
+		if (parsed.model === "") {
+			writeJson(res, 400, errBodyFor(protocol, "missing model"));
+			return;
+		}
+		const sessionRaw = req.headers["x-dsh-router-session"];
+		const session = (typeof sessionRaw === "string" && sessionRaw !== "" ? sessionRaw : void 0) ?? clientIdentityOf(parsed.body, req.headers["user-agent"]);
+		const sink = outboundSink(protocol, parsed.model, res);
+		await router.chatCompletions({
+			rawBody: JSON.stringify(parsed.body),
+			stream: parsed.stream,
+			model: parsed.model,
+			lv: parsed.lv,
+			...session === void 0 ? {} : { session },
+			protocol
+		}, res, sink);
+	});
+	route("/v1/messages", enterProtocol("anthropic"));
+	route("/v1/messages/count_tokens", withV1Auth(async (_req, res) => {
+		writeJson(res, 501, {
+			type: "error",
+			error: {
+				type: "not_supported",
+				message: "count_tokens is not supported; send the message instead"
+			}
+		});
+	}));
+	route("/v1/responses", enterProtocol("responses"));
+	disposers.push(ctx.webServer.register({
+		kind: "prefix",
+		path: "/v1beta/models",
+		handler: enterProtocol("gemini")
+	}));
 	route(`${ROUTER_API_BASE}/health`, (_req, res) => {
 		const { suppliers } = router.status();
 		writeJson(res, 200, {
@@ -5362,6 +8061,8 @@ function apply(rawContext) {
 					...c.detail !== void 0 ? { detail: c.detail } : {},
 					...typeof c.body === "string" ? { body: c.body } : {},
 					...c.editable === true ? { editable: true } : {},
+					...c.group !== void 0 ? { group: c.group } : {},
+					...c.sortable !== void 0 ? { sortable: c.sortable } : {},
 					custom: c.custom === true,
 					overridden: c.overridden === true
 				})) } : {},