@agent-proxy/zcode 0.11.3 → 0.12.1

package/dist/request.js

@@ -1,9 +1,21 @@
-import { translateBetweenProviders } from "@agent-proxy/llm-bridge";
+import { BridgeConversionError, convertRequest } from "@agent-proxy/llm-bridge";
 import { createHash } from "node:crypto";
 import { decodeZcodeThinking, isZcodeRecord } from "./wire.js";
 import { ANALYZE_IMAGE_SYSTEM_NOTE, ANALYZE_IMAGE_TOOL_DECLARATION, ANALYZE_IMAGE_TOOL_NAME, collectZcodeImages } from "./vision.js";
+/**
+ * ZCode 请求准备：标准消息/工具/参数统一经 @agent-proxy/llm-bridge 的
+ * convertRequest(to, "anthropic")；z.ai 私有形状（web_search_20250305 服务端工具、
+ * thinking 预算表、zcode-thinking 信封回放、analyze_image 代执行）作为插件前后处理。
+ *
+ * Responses 源的私有 history 项（reasoning / web_search_call / 其它服务器调用）不能
+ * 进标准转换：按项把 input 切成「标准段 + 私有项」，标准段逐段调用公共入口，私有段
+ * 由本模块转换，最后按 main 的同角色合并语义拼装。
+ */
 export class ZcodeRequestError extends Error {
-    constructor(message) { super(message); this.name = "ZcodeRequestError"; }
+    constructor(message) {
+        super(message);
+        this.name = "ZcodeRequestError";
+    }
 }
 const CUSTOM_INPUT_SCHEMA = {
     type: "object", properties: { input: { type: "string" } }, required: ["input"], additionalProperties: false,
@@ -11,8 +23,12 @@ const CUSTOM_INPUT_SCHEMA = {
 const THINKING_BUDGETS = {
     minimal: 1024, low: 2048, medium: 4096, high: 8192, xhigh: 10240, max: 10240, ultra: 10240,
 };
-function fail(message) { throw new ZcodeRequestError(message); }
-function record(value) { return isZcodeRecord(value); }
+function fail(message) {
+    throw new ZcodeRequestError(message);
+}
+function record(value) {
+    return isZcodeRecord(value);
+}
 function string(value, field) {
     if (typeof value !== "string")
         fail(`${field} 必须是字符串`);
@@ -29,6 +45,8 @@ function safeToolName(name) {
     const base = name.replace(/[^A-Za-z0-9_-]/g, "_").replace(/^_+/, "tool_") || "tool";
     return `${base.slice(0, 112)}_${createHash("sha256").update(name).digest("hex").slice(0, 12)}`;
 }
+/** 与声明/历史/choice 共用的 zcode 服务安全名策略（作为 mapToolName 传入桥接）。 */
+const zcodeToolMapper = (identity) => safeToolName(identity.namespace === undefined ? identity.name : JSON.stringify([identity.namespace, identity.name]));
 function addMessage(messages, role, blocks) {
     if (!blocks.length)
         return;
@@ -38,91 +56,6 @@ function addMessage(messages, role, blocks) {
     else
         messages.push({ role, content: blocks });
 }
-function image(part) {
-    const source = part.image_url ?? part.url;
-    const url = typeof source === "string" ? source : record(source) ? source.url : undefined;
-    if (typeof url !== "string" || !url)
-        fail("input_image 缺少 image_url");
-    const data = /^data:([^;,]+);base64,([A-Za-z0-9+/=]+)$/i.exec(url);
-    return data
-        ? { type: "image", source: { type: "base64", media_type: data[1], data: data[2] } }
-        : { type: "image", source: { type: "url", url } };
-}
-function content(value, field) {
-    if (typeof value === "string")
-        return [{ type: "text", text: value }];
-    if (!Array.isArray(value))
-        fail(`${field} 必须是字符串或内容数组`);
-    return value.map((raw) => {
-        if (!record(raw))
-            fail(`${field} 包含无效内容块`);
-        if (raw.type === "input_text" || raw.type === "output_text" || raw.type === "text") {
-            return { type: "text", text: string(raw.text, `${field}.text`) };
-        }
-        if (raw.type === "input_image" || raw.type === "image")
-            return image(raw);
-        fail(`${field} 包含不支持的内容块类型 ${String(raw.type)}`);
-    });
-}
-function callInput(value, custom) {
-    if (custom)
-        return { input: string(value, "custom_tool_call.input") };
-    if (record(value))
-        return value;
-    if (typeof value !== "string")
-        fail("function_call 的 arguments 必须是 JSON 对象或 JSON 字符串");
-    try {
-        const parsed = JSON.parse(value);
-        if (!record(parsed))
-            fail("function_call 的 arguments 必须解码为 JSON 对象");
-        return parsed;
-    }
-    catch (cause) {
-        if (cause instanceof ZcodeRequestError)
-            throw cause;
-        fail("function_call 的 arguments 不是有效 JSON 对象");
-    }
-}
-function toolResult(value) {
-    if (typeof value === "string")
-        return value;
-    if (Array.isArray(value)) {
-        return value.map((part) => {
-            if (record(part) && part.type === "input_image")
-                return image(part);
-            if (!record(part) || (part.type !== "input_text" && part.type !== "output_text" && part.type !== "text")) {
-                fail("function_call_output 包含不支持的内容块");
-            }
-            return { type: "text", text: string(part.text, "tool 输出文本") };
-        });
-    }
-    return JSON.stringify(value ?? null);
-}
-function bridgeText(input, model, maxTokens) {
-    // llm-bridge 是普通 Responses 文本的基础转换器；其遗漏的工具与 custom 语义由下方严格补齐。
-    const converted = translateBetweenProviders("openai-responses", "anthropic", {
-        model, input, max_output_tokens: maxTokens,
-    });
-    if (!record(converted) || !Array.isArray(converted.messages))
-        fail("llm-bridge 未返回有效 Anthropic 请求");
-    return converted.messages.map((raw) => {
-        if (!record(raw) || (raw.role !== "user" && raw.role !== "assistant") || !Array.isArray(raw.content)) {
-            fail("llm-bridge 返回了无效消息");
-        }
-        return { role: raw.role, content: raw.content.filter(record) };
-    });
-}
-function toolIdentity(rawName, rawNamespace) {
-    const original = string(rawName, "工具 name");
-    if (!original)
-        fail("工具 name 不能为空");
-    const namespace = rawNamespace === undefined || rawNamespace === null ? undefined : string(rawNamespace, "工具 namespace");
-    if (namespace === "")
-        fail("工具 namespace 不能为空");
-    // 数组编码区分 namespace/name 和带点的普通工具名，声明与历史共享稳定映射。
-    const name = safeToolName(namespace === undefined ? original : JSON.stringify([namespace, original]));
-    return { name, original, ...(namespace === undefined ? {} : { namespace }) };
-}
 /** z.ai 对 web_search_20250305 的实测回放形状：工具名映射为 web_search_prime，query 走 search_query。 */
 function serverToolQuery(input) {
     for (const key of ["search_query", "query"]) {
@@ -142,11 +75,11 @@ function webSearchServerTool(raw) {
         tool.user_location = raw.user_location;
     return tool;
 }
-function translateTools(value) {
-    const tools = [];
+/** Responses 工具声明规划（web_search 服务端工具、custom/namespace 安全名身份表）。 */
+function planResponsesTools(value, map) {
+    const declarations = [];
     const serverTools = [];
-    const map = new Map();
-    const dropped = new Set();
+    const dropped = [];
     function visit(entries, namespace, description) {
         if (!Array.isArray(entries))
             fail("tools 必须是数组");
@@ -159,47 +92,42 @@ function translateTools(value) {
                 const segment = string(raw.name, "namespace.name");
                 if (!segment)
                     fail("namespace.name 不能为空");
-                visit(raw.tools, segment, typeof raw.description === "string" ? raw.description : undefined);
+                visit(raw.tools, segment, typeof raw.description === "string" ? raw.description : description);
                 continue;
             }
             if (raw.type === "web_search") {
                 // 服务器内置工具按上游原生等价物映射；客户端显式禁用外部访问或嵌在 namespace 内时降级剥离。
                 if (raw.external_web_access === false || namespace !== undefined)
-                    dropped.add("web_search");
+                    dropped.push("web_search");
                 else
                     serverTools.push(webSearchServerTool(raw));
                 continue;
             }
             if (raw.type !== "function" && raw.type !== "custom") {
-                dropped.add(typeof raw.type === "string" ? raw.type : "unknown");
+                dropped.push(typeof raw.type === "string" ? raw.type : "unknown");
                 continue;
             }
-            const identity = toolIdentity(raw.name, namespace);
-            if (map.has(identity.name))
-                fail(`工具名映射冲突：${identity.original}`);
             const custom = raw.type === "custom";
+            const original = string(raw.name, "工具 name");
+            if (!original)
+                fail("工具 name 不能为空");
+            const ns = namespace === undefined || namespace === null ? undefined : string(namespace, "工具 namespace");
+            const mapped = zcodeToolMapper({ name: original, namespace: ns });
+            if (map.has(mapped))
+                fail(`工具名映射冲突：${original}`);
             if (!custom && !record(raw.parameters))
-                fail(`function 工具 ${identity.original} 缺少对象 parameters`);
-            const tool = { name: identity.name, input_schema: custom ? CUSTOM_INPUT_SCHEMA : raw.parameters };
+                fail(`function 工具 ${original} 缺少对象 parameters`);
+            const tool = { name: mapped, input_schema: custom ? CUSTOM_INPUT_SCHEMA : raw.parameters };
             const details = [description, typeof raw.description === "string" ? raw.description : undefined].filter((item) => item !== undefined);
             if (details.length)
                 tool.description = details.join("\n\n");
-            tools.push(tool);
-            map.set(identity.name, { name: identity.original, custom, ...(namespace === undefined ? {} : { namespace }) });
+            declarations.push(tool);
+            map.set(mapped, { name: original, custom, ...(ns === undefined ? {} : { namespace: ns }) });
         }
     }
     if (value !== undefined)
         visit(value);
-    return { tools, map, serverTools, dropped };
-}
-function callTool(raw, tools) {
-    const identity = toolIdentity(raw.name, raw.namespace);
-    const tool = tools.get(identity.name);
-    if (!tool || tool.name !== identity.original || tool.namespace !== identity.namespace)
-        fail(`工具选择引用了未声明的工具 ${identity.original}`);
-    if (tool.custom !== (raw.type === "custom"))
-        fail("tool_choice 与工具声明类型不一致");
-    return { name: identity.name, custom: tool.custom };
+    return { declarations, serverTools, dropped };
 }
 function webSearchCallQuery(item) {
     const action = record(item.action) ? item.action : {};
@@ -237,117 +165,82 @@ function serverCallSummary(item) {
     const detail = query ? `（查询：${query}）` : "";
     return { type: "text", text: `[已省略服务器内置工具调用 ${String(item.type)}${detail}；本通道不支持该工具]` };
 }
-function translateInput(input, model, maxTokens, nativeWebSearch) {
-    if (typeof input === "string")
-        return { messages: bridgeText(input, model, maxTokens), system: [] };
-    if (!Array.isArray(input))
+/** 公共转换结果 → Message[]（anthropic 消息形状校验与收口）。 */
+function anthropicMessagesOf(converted) {
+    const raw = converted.body.messages;
+    if (!Array.isArray(raw))
+        fail("convertRequest 未返回有效 Anthropic 消息");
+    return raw.map((entry) => {
+        if (!record(entry) || (entry.role !== "user" && entry.role !== "assistant") || !Array.isArray(entry.content)) {
+            fail("convertRequest 返回了无效消息");
+        }
+        return { role: entry.role, content: entry.content.filter(record) };
+    });
+}
+/**
+ * R4 统一请求前处理：responses 源按私有项切段——thinking 信封、web_search 回放
+ * 等私有段在本模块就地转换，标准段交给桥接；其余来源没有 zcode 私有项，整段返回。
+ * 主路径对所有来源统一执行一次 convertRequest(to, "anthropic", …)；to 表示路由
+ * 端点协议（响应方向 anthropic → to 的视角命名，请求方向即桥接的源协议位）。
+ */
+function segmentZcodeRequestLegs(to, body, options) {
+    if (to !== "responses")
+        return [{ body }];
+    const input = body.input;
+    if (typeof input !== "string" && !Array.isArray(input))
         fail("input 必须是字符串或数组");
-    const messages = [];
-    const system = [];
-    const calls = new Map();
-    const results = new Set();
-    for (const item of input) {
+    const items = typeof input === "string" ? [{ type: "message", role: "user", content: input }] : input;
+    const legs = [];
+    let run = [];
+    const flush = () => {
+        if (!run.length)
+            return;
+        // 标准段沿用源体的其余字段；instructions 由本层统一管理，不重复下发。
+        legs.push({ body: { ...body, input: run, instructions: undefined } });
+        run = [];
+    };
+    for (const item of items) {
         if (!record(item))
-            fail("input 包含非对象 history 项");
-        if (item.type === "reasoning") {
-            const blocks = decodeZcodeThinking(item.encrypted_content, model);
-            // 外部或不同模型的私有载荷不能转发；自身匹配的载荷按原块还原。
-            if (blocks)
-                addMessage(messages, "assistant", blocks);
-            continue;
-        }
-        if (item.type === "message" || item.type === undefined) {
-            if (item.role === "system" || item.role === "developer") {
-                for (const block of content(item.content, `${item.role} 消息`)) {
-                    if (block.type !== "text")
-                        fail(`${item.role} 消息不支持图片`);
-                    system.push(string(block.text, `${item.role} 消息文本`));
-                }
-                continue;
-            }
-            if (item.role !== "user" && item.role !== "assistant")
-                fail(`不支持的消息 role ${String(item.role)}`);
-            addMessage(messages, item.role, content(item.content, `${item.role} 消息`));
-            continue;
-        }
-        if (item.type === "function_call" || item.type === "custom_tool_call") {
-            const tool = toolIdentity(item.name, item.namespace);
-            const custom = item.type === "custom_tool_call";
-            const callId = string(item.call_id ?? item.id, `${item.type}.call_id`);
-            if (calls.has(callId))
-                fail(`history 中重复的工具调用 ID ${callId}`);
-            calls.set(callId, item.type);
-            addMessage(messages, "assistant", [{
-                    type: "tool_use", id: callId, name: tool.name,
-                    input: callInput(custom ? item.input : item.arguments, custom),
-                }]);
+            fail("Responses input 包含非对象 history 项");
+        const type = typeof item.type === "string" ? item.type : "message";
+        const privateKind = type === "reasoning" || type === "web_search_call"
+            || (type.endsWith("_call") && type !== "function_call" && type !== "custom_tool_call")
+            || type === "mcp_list_tools" || type === "mcp_list_resources";
+        if (!privateKind) {
+            run.push(item);
             continue;
         }
-        if (item.type === "function_call_output" || item.type === "custom_tool_call_output") {
-            const callId = string(item.call_id, `${item.type}.call_id`);
-            const callType = calls.get(callId);
-            if (!callType || (item.type === "function_call_output") !== (callType === "function_call")) {
-                fail(`${item.type} 未关联到同一 input 中匹配的工具调用 ${callId}`);
-            }
-            if (results.has(callId))
-                fail(`history 中重复的工具输出 ID ${callId}`);
-            results.add(callId);
-            addMessage(messages, "user", [{
-                    type: "tool_result", tool_use_id: callId, content: toolResult(item.output ?? item.content),
-                }]);
+        flush();
+        if (type === "reasoning") {
+            const blocks = decodeZcodeThinking(item.encrypted_content, options.clientModel);
+            // 外部或不同模型的私有载荷不能转发；自身匹配的载荷按原块还原。
+            if (blocks)
+                legs.push({ private: blocks });
             continue;
         }
-        if (item.type === "web_search_call") {
+        if (type === "web_search_call") {
             const query = webSearchCallQuery(item);
-            if (nativeWebSearch) {
+            if (options.nativeWebSearch) {
                 // 还原为 z.ai 实测回放形状：server_tool_use（web_search_prime/search_query）+ 同轮 tool_result 文本块。
                 const id = webSearchUpstreamID(item);
-                const content = webSearchResultContent(item);
-                addMessage(messages, "assistant", [
-                    { type: "server_tool_use", id, name: "web_search_prime", input: query ? { search_query: query } : {} },
-                    { type: "tool_result", tool_use_id: id, content },
-                ]);
+                legs.push({ private: [
+                        { type: "server_tool_use", id, name: "web_search_prime", input: query ? { search_query: query } : {} },
+                        { type: "tool_result", tool_use_id: id, content: webSearchResultContent(item) },
+                    ] });
             }
             else {
-                addMessage(messages, "assistant", [serverCallSummary(item)]);
+                legs.push({ private: [serverCallSummary(item)] });
             }
             continue;
         }
-        if (typeof item.type === "string" && (item.type.endsWith("_call") || item.type === "mcp_list_tools" || item.type === "mcp_list_resources")) {
-            // 其余服务器执行的历史调用（file_search_call、image_generation_call、托管 MCP 等）无法在上游执行，降级为文本摘要。
-            addMessage(messages, "assistant", [serverCallSummary(item)]);
-            continue;
-        }
-        fail(`不支持的 Responses history 项类型 ${typeof item.type === "string" ? item.type : "unknown"}`);
+        // 其余服务器执行的历史调用（file_search_call、image_generation_call、托管 MCP 等）无法在上游执行，降级为文本摘要。
+        legs.push({ private: [serverCallSummary(item)] });
     }
-    return { messages, system };
+    flush();
+    return legs;
 }
-function translateChoice(value, tools, parallel) {
-    if (parallel !== undefined && typeof parallel !== "boolean")
-        fail("parallel_tool_calls 必须是布尔值");
-    const noParallel = parallel === false;
-    if (value === undefined)
-        return noParallel ? { type: "auto", disable_parallel_tool_use: true } : undefined;
-    let choice;
-    if (value === "auto")
-        choice = { type: "auto" };
-    else if (value === "none")
-        choice = { type: "none" };
-    else if (value === "required")
-        choice = { type: "any" };
-    else if (record(value) && (value.type === "function" || value.type === "custom"))
-        choice = { type: "tool", name: callTool(value, tools).name };
-    else if (record(value) && typeof value.type === "string" && value.type !== "") {
-        // 指向服务器内置工具（含被剥离工具）的选择无法跨格式表达，省略让上游回到默认 auto。
-        return noParallel ? { type: "auto", disable_parallel_tool_use: true } : undefined;
-    }
-    else
-        fail("不支持的 tool_choice");
-    if (noParallel && choice.type !== "none")
-        choice.disable_parallel_tool_use = true;
-    return choice;
-}
-export function translateZcodeRequest(body, upstreamModel) {
+/** to 为路由端点（客户端入口）协议：请求方向 to → anthropic，响应方向 anthropic → to。 */
+export async function translateZcodeRequest(body, upstreamModel, to = "responses") {
     if (typeof upstreamModel !== "string" || !upstreamModel)
         fail("上游模型不能为空");
     if (body.previous_response_id !== undefined && body.previous_response_id !== null && body.previous_response_id !== "") {
@@ -364,51 +257,168 @@ export function translateZcodeRequest(body, upstreamModel) {
     }
     if (body.instructions !== undefined && typeof body.instructions !== "string")
         fail("instructions 必须是字符串");
-    const maxTokens = body.max_output_tokens === undefined ? 16384 : positiveInteger(body.max_output_tokens, "max_output_tokens");
-    const convertedTools = translateTools(body.tools);
-    const nativeWebSearch = convertedTools.serverTools.length > 0;
+    // 上游 token 上限按来源取参：responses 用 max_output_tokens，chat-completions /
+    // anthropic 用 max_tokens，gemini 用 generationConfig.maxOutputTokens；缺省走服务默认 16384。
+    const sourceLimit = to === "responses"
+        ? body.max_output_tokens
+        : to === "gemini"
+            ? (record(body.generationConfig) ? body.generationConfig.maxOutputTokens : undefined)
+            : body.max_tokens;
+    const maxTokens = sourceLimit === undefined ? 16384 : positiveInteger(sourceLimit, "token 上限");
+    const toolMap = new Map();
+    const plan = to === "responses" ? planResponsesTools(body.tools, toolMap) : { declarations: [], serverTools: [], dropped: [] };
+    const nativeWebSearch = plan.serverTools.length > 0;
     const clientModel = body.model === undefined ? upstreamModel : string(body.model, "model");
-    const convertedInput = translateInput(body.input, clientModel, maxTokens, nativeWebSearch);
-    const system = [...(body.instructions ? [body.instructions] : []), ...convertedInput.system];
-    if (convertedTools.dropped.size) {
+    const identities = new Map();
+    const messages = [];
+    const system = [];
+    if (typeof body.instructions === "string" && body.instructions)
+        system.push(body.instructions);
+    let passthroughChoice;
+    let passthroughStopSequences;
+    let passthroughTools;
+    try {
+        // R4 统一形态：前处理切段（私有段就地转换），主路径对所有来源统一执行一次
+        // convertRequest(from, to)——from 是网关识别的真实客户端协议，目标恒为 anthropic。
+        for (const leg of segmentZcodeRequestLegs(to, body, { nativeWebSearch, clientModel })) {
+            if (leg.private !== undefined) {
+                addMessage(messages, "assistant", leg.private);
+                continue;
+            }
+            // 桥接统一形态 convertRequest(from, to, body)：from 为上游 endpoint（anthropic），to 为调用方 route 协议。
+            const converted = await convertRequest("anthropic", to, leg.body, { model: upstreamModel, mapToolName: zcodeToolMapper });
+            for (const [mapped, identity] of converted.tools)
+                identities.set(mapped, identity);
+            for (const message of anthropicMessagesOf(converted))
+                addMessage(messages, message.role, message.content);
+            if (typeof converted.body.system === "string" && converted.body.system)
+                system.push(converted.body.system);
+            passthroughTools = Array.isArray(converted.body.tools) ? converted.body.tools.filter(record) : undefined;
+            passthroughChoice = converted.body.tool_choice;
+            if (Array.isArray(converted.body.stop_sequences) && converted.body.stop_sequences.every((entry) => typeof entry === "string")) {
+                passthroughStopSequences = converted.body.stop_sequences;
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof BridgeConversionError)
+            throw new ZcodeRequestError(error.message);
+        throw error;
+    }
+    // chat/gemini/anthropic 源的工具声明来自公共转换（anthropic 为同协议直通的
+    // 原名身份表），身份表同步进 zcode 工具表；responses 源的 toolMap 只含声明工具
+    // （压缩历史中未声明的调用按需注册，不进入响应校验表）。
+    if (to === "chat-completions" || to === "gemini" || to === "anthropic") {
+        for (const [mapped, identity] of identities) {
+            if (!toolMap.has(mapped))
+                toolMap.set(mapped, { ...identity });
+        }
+    }
+    const declarations = to === "responses" ? plan.declarations : passthroughTools ?? [];
+    const serverTools = plan.serverTools;
+    if (plan.dropped.length) {
         // 剥离后必须告知模型，否则模型会声称拥有已被移除的能力。
-        system.push(`本通道无法执行以下服务器内置工具，已从本请求移除：${[...convertedTools.dropped].join("、")}。请勿声称已使用这些工具。`);
+        system.push(`本通道无法执行以下服务器内置工具，已从本请求移除：${plan.dropped.join("、")}。请勿声称已使用这些工具。`);
     }
     // 请求含图片时声明网关代执行的 analyze_image（GLM 文本模型经此识别图片）；
     // 客户端自己声明了同名工具则让位，不注入适配说明避免行为冲突。
-    const images = collectZcodeImages(convertedInput.messages);
-    const vision = images.length > 0 && !convertedTools.map.has(ANALYZE_IMAGE_TOOL_NAME);
+    const images = collectZcodeImages(messages);
+    const vision = images.length > 0 && !toolMap.has(ANALYZE_IMAGE_TOOL_NAME);
     if (vision) {
-        convertedTools.tools.push(ANALYZE_IMAGE_TOOL_DECLARATION);
-        convertedTools.map.set(ANALYZE_IMAGE_TOOL_NAME, { name: ANALYZE_IMAGE_TOOL_NAME, custom: false, gateway: "analyze_image" });
+        declarations.push(ANALYZE_IMAGE_TOOL_DECLARATION);
+        toolMap.set(ANALYZE_IMAGE_TOOL_NAME, { name: ANALYZE_IMAGE_TOOL_NAME, custom: false, gateway: "analyze_image" });
         system.push(ANALYZE_IMAGE_SYSTEM_NOTE);
     }
-    const translated = { model: upstreamModel, stream: true, max_tokens: maxTokens, messages: convertedInput.messages };
+    const translated = { model: upstreamModel, stream: true, max_tokens: maxTokens, messages };
     if (system.length)
         translated.system = system.join("\n\n");
-    if (convertedTools.tools.length || convertedTools.serverTools.length)
-        translated.tools = [...convertedTools.tools, ...convertedTools.serverTools];
+    if (declarations.length || serverTools.length)
+        translated.tools = [...declarations, ...serverTools];
     if (body.temperature !== undefined)
         translated.temperature = body.temperature;
+    else if (to === "gemini" && record(body.generationConfig) && typeof body.generationConfig.temperature === "number") {
+        // gemini 源的采样参数在 generationConfig；不修改调用方原始请求。
+        translated.temperature = body.generationConfig.temperature;
+    }
     if (body.top_p !== undefined)
         translated.top_p = body.top_p;
-    const choice = translateChoice(body.tool_choice, convertedTools.map, body.parallel_tool_calls);
-    if (choice)
-        translated.tool_choice = choice;
-    if (body.reasoning !== undefined) {
-        if (!record(body.reasoning))
-            fail("reasoning 必须是对象");
-        if (body.reasoning.effort === "none")
+    else if (to === "gemini" && record(body.generationConfig) && typeof body.generationConfig.topP === "number") {
+        translated.top_p = body.generationConfig.topP;
+    }
+    if (to === "responses") {
+        const choice = translateChoice(body.tool_choice, toolMap, body.parallel_tool_calls);
+        if (choice)
+            translated.tool_choice = choice;
+    }
+    else {
+        // chat/anthropic 源的 named choice 已由公共转换映射到同一身份表；服务端搜索与
+        // disable_parallel 语义按 anthropic 原生形状透传。
+        if (record(passthroughChoice) || typeof passthroughChoice === "string")
+            translated.tool_choice = passthroughChoice;
+        if (passthroughStopSequences !== undefined)
+            translated.stop_sequences = passthroughStopSequences;
+    }
+    if (to === "responses" || to === "chat-completions") {
+        const effort = to === "responses"
+            ? (record(body.reasoning) && typeof body.reasoning.effort === "string" ? body.reasoning.effort : undefined)
+            : (typeof body.reasoning_effort === "string" ? body.reasoning_effort : undefined);
+        if (to === "responses" && record(body.reasoning) && body.reasoning.effort === "none") {
             translated.thinking = { type: "disabled" };
-        else if (body.reasoning.effort !== undefined) {
-            const effort = body.reasoning.effort;
-            if (typeof effort !== "string" || THINKING_BUDGETS[effort] === undefined)
-                fail("不支持的 reasoning.effort");
+        }
+        else if (effort !== undefined) {
+            if (THINKING_BUDGETS[effort] === undefined)
+                fail("不支持的 reasoning 档位");
             const budget = Math.min(THINKING_BUDGETS[effort], maxTokens - 1);
             if (budget < 1024)
                 fail("启用 reasoning 至少需要 max_output_tokens 为 1025");
             translated.thinking = { type: "enabled", budget_tokens: budget };
         }
     }
-    return { body: translated, tools: convertedTools.map, dropped: [...convertedTools.dropped], vision, images };
+    if (to === "anthropic" && body.thinking !== undefined && record(body.thinking)) {
+        // 原生 Anthropic thinking 输入按同一服务能力验证，不静默覆盖。
+        if (body.thinking.type === "enabled") {
+            const budget = positiveInteger(body.thinking.budget_tokens, "thinking.budget_tokens");
+            if (budget >= maxTokens)
+                fail("thinking.budget_tokens 必须小于 max_tokens");
+            translated.thinking = { type: "enabled", budget_tokens: budget };
+        }
+        else if (body.thinking.type === "disabled") {
+            translated.thinking = { type: "disabled" };
+        }
+    }
+    return { body: translated, tools: toolMap, dropped: [...plan.dropped], vision, images };
+}
+function translateChoice(value, tools, parallel) {
+    if (parallel !== undefined && typeof parallel !== "boolean")
+        fail("parallel_tool_calls 必须是布尔值");
+    const noParallel = parallel === false;
+    if (value === undefined)
+        return noParallel ? { type: "auto", disable_parallel_tool_use: true } : undefined;
+    let choice;
+    if (value === "auto")
+        choice = { type: "auto" };
+    else if (value === "none")
+        choice = { type: "none" };
+    else if (value === "required")
+        choice = { type: "any" };
+    else if (record(value) && (value.type === "function" || value.type === "custom")) {
+        const name = string(value.name, "tool_choice.name");
+        const namespace = value.namespace === undefined || value.namespace === null ? undefined : string(value.namespace, "tool_choice.namespace");
+        const mapped = zcodeToolMapper({ name, namespace });
+        const tool = tools.get(mapped);
+        if (!tool || tool.name !== name || tool.namespace !== namespace)
+            fail(`工具选择引用了未声明的工具 ${name}`);
+        if (tool.custom !== (value.type === "custom"))
+            fail("tool_choice 与工具声明类型不一致");
+        choice = { type: "tool", name: mapped };
+    }
+    else if (record(value) && typeof value.type === "string" && value.type !== "") {
+        // 指向服务器内置工具（含被剥离工具）的选择无法跨格式表达，省略让上游回到默认 auto。
+        return noParallel ? { type: "auto", disable_parallel_tool_use: true } : undefined;
+    }
+    else
+        fail("不支持的 tool_choice");
+    if (noParallel && choice.type !== "none")
+        choice.disable_parallel_tool_use = true;
+    return choice;
 }