@agent-proxy/zcode 0.12.0 → 0.12.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import type { HostServices, GatewayPlugin } from "@agent-proxy/plugin-api";
+import type { HostServices, GatewayPlugin, ClientProtocol } from "@agent-proxy/plugin-api";
 import type { ZcodeConfigCache, ZcodeSelection } from "./config.ts";
 import { ZcodeEndpointRouting } from "./endpoint-routing.ts";
 import { ZcodeClientSigning } from "./client-signing.ts";
@@ -32,15 +32,13 @@ export interface ZcodeDependencies {
 export type GatewayHandler = ((request: Request) => Promise<Response>) & {
     close(): void;
 };
-/** 插件启停仅由 ZCode 开关决定，default 上游路由策略不参与。 */
-export declare function zcodeEnabled<Config extends AgentConfig>(config: Config): boolean;
-export declare function validateZcodeConfig<Config extends AgentConfig>(config: Config): void;
+export declare function validateZcodeConfig(config: AgentConfig): void;
 export declare function zcodeError(status: number, message: string, type?: string): Response;
-export declare function createZcodeAdapter<Config extends AgentConfig>(config: Config, dependencies?: ZcodeDependencies): {
+export declare function createZcodeAdapter(config: AgentConfig, dependencies?: ZcodeDependencies): {
     catalog(): Promise<ModelCatalog>;
     refreshCatalog: () => Promise<ModelCatalog>;
     reloadCatalog(): Promise<ModelCatalog>;
-    forward(request: Request, input: Record<string, unknown>, mapResult?: (payload: Record<string, unknown>) => Response): Promise<Response>;
+    forward(request: Request, input: Record<string, unknown>, to?: ClientProtocol, mapResult?: (payload: Record<string, unknown>) => Response): Promise<Response>;
     close(): void;
 };
 export declare const ZCODE_MODEL_PATTERNS: readonly string[];

package/dist/index.js

@@ -6,7 +6,7 @@ import { createZcodeConfigCache, readZcodeAPIKeyProviders, zcodeConfigPresent, Z
 import { clearModelsCacheEntries, invalidateModelsCache, withAgentSystemPrompt } from "@agent-proxy/plugin-api";
 import { buildZcodeVendorCatalog, createZcodeCatalog, isZcodeModel, writeZcodeServedCatalog, zcodeAPIProviderIDFromModel, zcodeModelPlan, zcodeUpstreamModel, } from "./catalog.js";
 import { translateZcodeRequest, ZcodeRequestError } from "./request.js";
-import { createZcodeResponse } from "./response.js";
+import { createZcodeClientResponse } from "./response.js";
 import { executeZcodeAnalyzeImage, matchZcodeAnalyzeImage } from "./vision.js";
 import { ZcodeEndpointRouting } from "./endpoint-routing.js";
 import { clientSigningVerifyRejection, ZcodeClientSigning } from "./client-signing.js";
@@ -14,37 +14,22 @@ import { isZcodeRecord } from "./wire.js";
 import { buildZcodeModelHeaders, createZcodeContexts, decorateZcodeBody, readZcodeIdentity, zcodePlan, ZCODE_AGENT_SYSTEM_PROMPT } from "./request-context.js";
 import { localTime, logExchange, logGroupFromPath, requestLogDir } from "@agent-proxy/plugin-api";
 import { logGatewayError, logRequestSummary } from "@agent-proxy/plugin-api";
-/** 插件启停仅由 ZCode 开关决定，default 上游路由策略不参与。 */
-export function zcodeEnabled(config) {
-    return config.zcode === undefined || config.zcode === true;
-}
 export function validateZcodeConfig(config) {
-    if (config.zcode !== undefined && typeof config.zcode !== "boolean")
-        throw new Error("zcode 必须为 boolean");
-    if (!zcodeEnabled(config))
-        return;
     const host = config.host;
     if (!(host === "localhost" || host === "::1" || host === "[::1]" || (isIP(host) === 4 && host.startsWith("127.")))) {
         throw new Error("启用 ZCode 时网关只能监听环回地址");
     }
-    if (config.prefix && ("zcode/".startsWith(config.prefix) || config.prefix.startsWith("zcode/")
-        || config.prefix.startsWith("zcode-"))) {
-        throw new Error("启用 ZCode 时 zcode/ 与 zcode- 前缀保留给 ZCode，请调整第三方 prefix");
-    }
 }
 export function zcodeError(status, message, type = "invalid_request_error") {
     return Response.json({ error: { type, message } }, { status });
 }
 function buildZcodeAdapter(config, dependencies = {}) {
     validateZcodeConfig(config);
-    const enabled = zcodeEnabled(config);
     const manual = dependencies.catalogMode === "manual";
     // 自管目录文件一律放运行主目录，不从 catalogPath 位置倒推。
     const cacheDirectory = dependencies.cacheDirectory ?? resolvePaths().runtimeHome;
     // 厂商元数据只取模型包预设；账号或套餐刷新仅重新投影支持集合。
-    const vendorCatalog = enabled
-        ? buildZcodeVendorCatalog()
-        : undefined;
+    const vendorCatalog = buildZcodeVendorCatalog();
     /** 套餐或选择变化时立即撤下 Codex 缓存里的旧 ZCode 条目，避免旧套餐模型继续可选。 */
     const dropCachedZcodeModels = () => {
         if (dependencies.codexModelsCacheFile) {
@@ -84,8 +69,6 @@ function buildZcodeAdapter(config, dependencies = {}) {
     ];
     let synchronizeAPIKeyRoutes = () => { };
     const republishFromPlans = (force = false) => {
-        if (!vendorCatalog)
-            return;
         const current = planRoutes.map((route) => route.snapshot);
         const previous = publishedSnapshots;
         if (!force && previous && current.length === previous.length
@@ -108,121 +91,119 @@ function buildZcodeAdapter(config, dependencies = {}) {
         }
         publishServedCatalog({ models });
     };
-    if (enabled) {
-        // 注入模式（测试）只为显式给出的套餐建缓存，避免读到真实的 ~/.zcode。
-        const injected = dependencies.planCaches
-            ?? (dependencies.apiKeyCaches ? {} : dependencies.configCache ? { "api-key": dependencies.configCache } : undefined);
-        for (const route of planRoutes) {
-            route.cache = injected?.[route.plan]
-                ?? (injected ? undefined : createZcodeConfigCache(home, {
-                    plan: route.plan,
-                    refreshOnStart: false,
-                    // 选择变化只撤下本套餐的快照并重发并集；另一个套餐的条目不受影响。
-                    onSelectionChange: () => {
-                        if (manual)
-                            return;
-                        route.snapshot = undefined;
-                        republishFromPlans();
-                    },
-                    onSnapshotChange: (snapshot) => {
-                        if (manual)
-                            return;
-                        route.snapshot = snapshot;
-                        republishFromPlans();
-                    },
-                }));
+    // 注入模式（测试）只为显式给出的套餐建缓存，避免读到真实的 ~/.zcode。
+    const injected = dependencies.planCaches
+        ?? (dependencies.apiKeyCaches ? {} : dependencies.configCache ? { "api-key": dependencies.configCache } : undefined);
+    for (const route of planRoutes) {
+        route.cache = injected?.[route.plan]
+            ?? (injected ? undefined : createZcodeConfigCache(home, {
+                plan: route.plan,
+                refreshOnStart: false,
+                // 选择变化只撤下本套餐的快照并重发并集；另一个套餐的条目不受影响。
+                onSelectionChange: () => {
+                    if (manual)
+                        return;
+                    route.snapshot = undefined;
+                    republishFromPlans();
+                },
+                onSnapshotChange: (snapshot) => {
+                    if (manual)
+                        return;
+                    route.snapshot = snapshot;
+                    republishFromPlans();
+                },
+            }));
+    }
+    if (injected) {
+        const apiCaches = dependencies.apiKeyCaches
+            ?? (dependencies.planCaches?.["api-key"] || dependencies.configCache
+                ? { current: dependencies.planCaches?.["api-key"] ?? dependencies.configCache }
+                : {});
+        for (const [apiProviderID, cache] of Object.entries(apiCaches)) {
+            planRoutes.push({ plan: "api-key", ...(apiProviderID === "current" ? {} : { apiProviderID }), cache });
         }
-        if (injected) {
-            const apiCaches = dependencies.apiKeyCaches
-                ?? (dependencies.planCaches?.["api-key"] || dependencies.configCache
-                    ? { current: dependencies.planCaches?.["api-key"] ?? dependencies.configCache }
-                    : {});
-            for (const [apiProviderID, cache] of Object.entries(apiCaches)) {
-                planRoutes.push({ plan: "api-key", ...(apiProviderID === "current" ? {} : { apiProviderID }), cache });
+    }
+    else {
+        const createAPIRoute = (provider) => {
+            const route = { plan: "api-key", apiProviderID: provider.providerID };
+            route.cache = createZcodeConfigCache(home, {
+                plan: "api-key",
+                apiProviderID: provider.providerID,
+                refreshOnStart: false,
+                onSelectionChange: () => {
+                    if (manual)
+                        return;
+                    route.snapshot = undefined;
+                    republishFromPlans();
+                },
+                onSnapshotChange: (snapshot) => {
+                    if (manual)
+                        return;
+                    route.snapshot = snapshot;
+                    republishFromPlans();
+                },
+            });
+            return route;
+        };
+        const synchronize = (republish = true, strict = false) => {
+            let providers = [];
+            try {
+                providers = readZcodeAPIKeyProviders(home);
             }
-        }
-        else {
-            const createAPIRoute = (provider) => {
-                const route = { plan: "api-key", apiProviderID: provider.providerID };
-                route.cache = createZcodeConfigCache(home, {
-                    plan: "api-key",
-                    apiProviderID: provider.providerID,
-                    refreshOnStart: false,
-                    onSelectionChange: () => {
-                        if (manual)
-                            return;
-                        route.snapshot = undefined;
-                        republishFromPlans();
-                    },
-                    onSnapshotChange: (snapshot) => {
-                        if (manual)
-                            return;
-                        route.snapshot = snapshot;
-                        republishFromPlans();
-                    },
-                });
-                return route;
-            };
-            const synchronize = (republish = true, strict = false) => {
-                let providers = [];
-                try {
-                    providers = readZcodeAPIKeyProviders(home);
-                }
-                catch (error) {
-                    if (strict)
-                        throw error;
-                    /* 动态目录撤下无效 API Key；套餐路由不受影响。 */
-                }
-                const targetIDs = new Set(providers.map((provider) => provider.providerID));
-                let changed = false;
-                const removed = planRoutes.filter((route) => route.plan === "api-key" && route.apiProviderID && !targetIDs.has(route.apiProviderID));
-                for (const route of removed)
-                    route.cache?.close();
-                if (removed.length) {
-                    for (let index = planRoutes.length - 1; index >= 0; index--) {
-                        if (removed.includes(planRoutes[index]))
-                            planRoutes.splice(index, 1);
-                    }
-                    changed = true;
-                }
-                for (const provider of providers) {
-                    if (planRoutes.some((route) => route.plan === "api-key" && route.apiProviderID === provider.providerID))
-                        continue;
-                    planRoutes.push(createAPIRoute(provider));
-                    changed = true;
+            catch (error) {
+                if (strict)
+                    throw error;
+                /* 动态目录撤下无效 API Key；套餐路由不受影响。 */
+            }
+            const targetIDs = new Set(providers.map((provider) => provider.providerID));
+            let changed = false;
+            const removed = planRoutes.filter((route) => route.plan === "api-key" && route.apiProviderID && !targetIDs.has(route.apiProviderID));
+            for (const route of removed)
+                route.cache?.close();
+            if (removed.length) {
+                for (let index = planRoutes.length - 1; index >= 0; index--) {
+                    if (removed.includes(planRoutes[index]))
+                        planRoutes.splice(index, 1);
                 }
-                if (changed && republish)
-                    republishFromPlans();
-            };
-            synchronizeAPIKeyRoutes = (strict) => synchronize(!manual, strict);
-            synchronize(false);
-            // /models 与未知 API 前缀请求都会重新同步，支持新增/删除 provider；现有
-            // provider 的 Key 与模型变化由各自 cache 的 provider_config watcher 驱动。
-        }
+                changed = true;
+            }
+            for (const provider of providers) {
+                if (planRoutes.some((route) => route.plan === "api-key" && route.apiProviderID === provider.providerID))
+                    continue;
+                planRoutes.push(createAPIRoute(provider));
+                changed = true;
+            }
+            if (changed && republish)
+                republishFromPlans();
+        };
+        synchronizeAPIKeyRoutes = (strict) => synchronize(!manual, strict);
+        synchronize(false);
+        // /models 与未知 API 前缀请求都会重新同步，支持新增/删除 provider；现有
+        // provider 的 Key 与模型变化由各自 cache 的 provider_config watcher 驱动。
     }
     const fetchUpstream = dependencies.fetch ?? ((url, init) => fetch(url, init));
     const activeRequests = new Set();
-    const identity = enabled ? dependencies.identity ?? readZcodeIdentity() : undefined;
-    const endpointRouting = enabled && dependencies.endpointRouting !== null
+    const identity = dependencies.identity ?? readZcodeIdentity();
+    const endpointRouting = dependencies.endpointRouting !== null
         ? dependencies.endpointRouting ?? new ZcodeEndpointRouting({
-            identity: identity,
+            identity,
             fetch: (url, init) => fetchUpstream(url, init),
         })
         : undefined;
     // coding plan 官方客户端签名：逐请求补 X-Client-* 签名头；fail-open，失败按未签名继续。
-    const clientSigning = enabled && dependencies.clientSigning !== null
+    const clientSigning = dependencies.clientSigning !== null
         ? dependencies.clientSigning ?? new ZcodeClientSigning({ fetch: (url, init) => fetchUpstream(url, init) })
         : undefined;
     const contexts = createZcodeContexts();
     const sink = config.requestLogging === true ? {
-        dir: requestLogDir(config),
+        dir: requestLogDir(),
         maxLogs: Math.max(0, Math.trunc(config.maxRequestLogs ?? 0)),
         processLog: dependencies.processLog,
     } : undefined;
     let closed = false;
     let refreshPromise;
     const readCatalog = async (mode) => {
-        if (closed || !enabled)
+        if (closed)
             return { models: [] };
         synchronizeAPIKeyRoutes(manual && mode !== "get");
         const neverPublished = publishedSnapshots === undefined;
@@ -279,7 +260,7 @@ function buildZcodeAdapter(config, dependencies = {}) {
         return promise;
     };
     /** 启动首读仍允许凭据授权，手动策略仅停止后续目录自动发布。 */
-    const startup = enabled && vendorCatalog && dependencies.refreshCatalogOnStart !== false
+    const startup = dependencies.refreshCatalogOnStart !== false
         ? refreshCatalog() : Promise.resolve({ models: [] });
     // 构造适配器与等待 modelsReady 之间允许异步间隙；失败由公开目录接口传递。
     void startup.catch(() => { });
@@ -297,7 +278,7 @@ function buildZcodeAdapter(config, dependencies = {}) {
                 await refreshPromise;
             return readCatalog("reload");
         },
-        async forward(request, input, mapResult) {
+        async forward(request, input, to = "responses", mapResult) {
             const start = Date.now();
             const requestTime = localTime();
             const incoming = new URL(request.url);
@@ -426,7 +407,7 @@ function buildZcodeAdapter(config, dependencies = {}) {
                     cleanup();
                     return fail(404, "此模型不属于 ZCode 当前套餐或厂商目录");
                 }
-                const translated = translateZcodeRequest(input, model);
+                const translated = await translateZcodeRequest(input, model, to);
                 const baseUpstreamUrl = `${snapshot.baseURL}${snapshot.baseURL.endsWith("/v1") ? "/messages" : "/v1/messages"}`;
                 const routedUrl = endpointRouting
                     // 跟随 z.ai 服务端下发的端点映射（如 zcode.z.ai ultra 中转）；resolve 内部 fail-open，失败保持原 URL。
@@ -562,7 +543,7 @@ function buildZcodeAdapter(config, dependencies = {}) {
                 }
                 let chunks = "";
                 const stream = !mapResult && input.stream === true;
-                const response = await createZcodeResponse(upstream, {
+                const response = await createZcodeClientResponse(to, upstream, {
                     model: String(input.model), tools: translated.tools, stream, signal: abort.signal,
                     gatewayTools,
                     sanitizeError: (error) => ({
@@ -637,9 +618,7 @@ export function createZcodePlugin(host, dependencies = {}) {
                 const input = await context.body.json();
                 if (!input || typeof input !== "object" || Array.isArray(input))
                     return Response.json({ error: { type: "invalid_request_error", message: "请求正文必须是 JSON 对象" } }, { status: 400 });
-                if (context.from !== "responses")
-                    return Response.json({ error: { type: "invalid_request_error", message: "Zcode 模型仅支持 Responses API" } }, { status: 400 });
-                return adapter.forward(context.request, input);
+                return adapter.forward(context.request, input, context.to);
             },
             getCatalog: () => adapter.catalog(),
             refreshCatalog: () => adapter.refreshCatalog(),

package/dist/request.d.ts

@@ -1,5 +1,16 @@
+import type { ClientProtocol } from "@agent-proxy/plugin-api";
 import type { ZcodeTranslatedRequest } from "./wire.ts";
+/**
+ * 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 declare class ZcodeRequestError extends Error {
     constructor(message: string);
 }
-export declare function translateZcodeRequest(body: Record<string, unknown>, upstreamModel: string): ZcodeTranslatedRequest;
+/** to 为路由端点（客户端入口）协议：请求方向 to → anthropic，响应方向 anthropic → to。 */
+export declare function translateZcodeRequest(body: Record<string, unknown>, upstreamModel: string, to?: ClientProtocol): Promise<ZcodeTranslatedRequest>;

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;
 }

package/dist/response.d.ts

@@ -1,3 +1,4 @@
+import type { ClientProtocol } from "@agent-proxy/plugin-api";
 import { type ZcodeToolMap } from "./wire.ts";
 import { type ZcodeGatewayCall } from "./vision.ts";
 /** 网关代执行工具（analyze_image）的驱动层钩子：执行调用并按需发起上游续跑。 */
@@ -24,4 +25,11 @@ export interface ZcodeResponseOptions {
     /** 声明了网关代执行工具时必须提供；否则吸收到相关调用会让响应失败。 */
     gatewayTools?: ZcodeGatewayToolsHook;
 }
+/**
+ * 四种客户端协议的统一入口：zcode 始终以帧级驱动器合成 Responses 事件（多腿、
+ * server tool 折叠与 thinking 信封都在该层），chat-completions / anthropic / gemini
+ * 客户端由 @agent-proxy/llm-bridge 从同一事件流渲染，语义与 Responses 输出一致。
+ */
+/** to 为路由端点（客户端入口）协议：上游 anthropic → to。 */
+export declare function createZcodeClientResponse(to: ClientProtocol, upstream: Response, options: ZcodeResponseOptions): Promise<Response>;
 export declare function createZcodeResponse(upstream: Response, options: ZcodeResponseOptions): Promise<Response>;

package/dist/response.js

@@ -1,4 +1,4 @@
-import { parseAnthropicStream } from "@agent-proxy/llm-bridge";
+import { createClientResponse } from "@agent-proxy/llm-bridge";
 import { encodeZcodeThinking, isZcodeRecord } from "./wire.js";
 import { gatewayToolCallNarration, gatewayToolResultNarration } from "./vision.js";
 /** z.ai 的服务端搜索按 web_search_prime/search_query 形状返回 query；兼容 Anthropic 标准的 query。 */
@@ -108,29 +108,74 @@ async function* readFrames(reader) {
         }
     }
 }
-/** 库只保存一个工具上下文；按帧补入对应块，使交错的块仍通过库正确归一化。 */
+/**
+ * anthropic 帧级归一化（工具事件抽取）。库的 parseAnthropicStream 只保存一个工具
+ * 上下文，交错块会串扰；这里直接从帧结构提取 tool_call_start/delta 事件，不依赖
+ * npm llm-bridge（桥接包不再转发库原语）。
+ */
 async function normalize(frame, block) {
-    const frames = [];
-    if (block?.source.type === "tool_use" && (frame.type === "content_block_delta" || frame.type === "content_block_stop")) {
-        frames.push({ type: "content_block_start", index: frame.index, content_block: block.source });
+    const events = [];
+    if (frame.type === "message_start") {
+        // 驱动器以事件存在性校验 message_start 的可归一化；保持该合同。
+        return [{ type: "message_start" }];
     }
-    frames.push(frame);
-    const stream = new ReadableStream({
-        start(controller) {
-            controller.enqueue(encoder.encode(frames.map((value) => `event: ${value.type}\ndata: ${JSON.stringify(value)}\n\n`).join("")));
-            controller.close();
-        },
-    });
-    const result = [];
-    let skipContext = frames.length > 1;
-    for await (const value of parseAnthropicStream(stream)) {
-        if (skipContext) {
-            skipContext = false;
-            continue;
+    if (frame.type === "error") {
+        // 错误帧透传原始字段（request_id 等），并把 anthropic 的 type 映射为 code
+        //（驱动器按 code 生成 failed 终态的错误标识）。
+        const original = record(frame.error, "error");
+        return [{ type: "error", error: { ...original, ...(original.code === undefined && typeof original.type === "string" ? { code: original.type } : {}) } }];
+    }
+    if (frame.type === "content_block_start") {
+        const source = record(frame.content_block, "content_block");
+        if (source.type === "tool_use") {
+            events.push({ type: "tool_call_start", tool_call: { id: source.id ?? "", name: source.name ?? "" } });
+        }
+        return events;
+    }
+    if (frame.type === "content_block_delta") {
+        const delta = record(frame.delta, "delta");
+        if (block?.source.type === "tool_use") {
+            if (delta.type === "input_json_delta" && typeof delta.partial_json === "string") {
+                events.push({ type: "tool_call_delta", tool_call: { id: block.source.id ?? "", arguments_delta: delta.partial_json } });
+            }
+            return events;
+        }
+        // 文本/思考增量保持 content_delta 事件形状，驱动器按块类型取对应字段。
+        if (delta.type === "text_delta" && typeof delta.text === "string") {
+            events.push({ type: "content_delta", delta: { text: delta.text } });
+        }
+        else if (delta.type === "thinking_delta" && typeof delta.thinking === "string") {
+            events.push({ type: "content_delta", delta: { thinking: delta.thinking } });
         }
-        result.push(value);
+        return events;
     }
-    return result;
+    if (frame.type === "content_block_stop" && block?.source.type === "tool_use") {
+        events.push({ type: "tool_call_end", tool_call: { id: block.source.id ?? "" } });
+        return events;
+    }
+    return events;
+}
+/**
+ * 四种客户端协议的统一入口：zcode 始终以帧级驱动器合成 Responses 事件（多腿、
+ * server tool 折叠与 thinking 信封都在该层），chat-completions / anthropic / gemini
+ * 客户端由 @agent-proxy/llm-bridge 从同一事件流渲染，语义与 Responses 输出一致。
+ */
+/** to 为路由端点（客户端入口）协议：上游 anthropic → to。 */
+export async function createZcodeClientResponse(to, upstream, options) {
+    const responsesOutput = await createZcodeResponse(upstream, options);
+    if (to === "responses")
+        return responsesOutput;
+    const result = await createClientResponse(to, responsesOutput, {
+        upstreamProtocol: "responses",
+        model: options.model,
+        stream: options.stream,
+        signal: options.signal,
+        abort: options.abort,
+        onChunk: options.onChunk,
+        sanitizeError: options.sanitizeError,
+        // Responses 输出已由 zcode 驱动器还原原始工具名，无需再做身份映射。
+    });
+    return result.response;
 }
 export async function createZcodeResponse(upstream, options) {
     let reader = upstream.body?.getReader();

package/dist/wire.d.ts

@@ -1,8 +1,6 @@
+import type { ToolIdentity } from "@agent-proxy/llm-bridge";
 /** ZCode 协议共享类型；元数据不包含授权凭据。 */
-export interface ZcodeToolDefinition {
-    name: string;
-    custom: boolean;
-    namespace?: string;
+export interface ZcodeToolDefinition extends ToolIdentity {
     /** 网关代执行标记：该工具由网关在上游续跑中执行并吸收，不回传客户端。 */
     gateway?: "analyze_image";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-proxy/zcode",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Agent Proxy zcode 插件；保留基线转换行为。",
   "type": "module",
   "exports": {
@@ -26,7 +26,8 @@
     "prepack": "bun ../../scripts/verify-package.ts ."
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "timeout": 30000
   },
   "license": "MIT",
   "repository": {
@@ -34,11 +35,11 @@
     "url": "git+https://github.com/aceHubert/codex-cliproxy-gateway.git"
   },
   "devDependencies": {
-    "@agent-proxy/models": "0.12.0"
+    "@agent-proxy/models": "0.12.2"
   },
   "dependencies": {
-    "@agent-proxy/llm-bridge": "0.12.0",
-    "@agent-proxy/plugin-api": "0.12.0"
+    "@agent-proxy/llm-bridge": "0.12.2",
+    "@agent-proxy/plugin-api": "0.12.2"
   },
-  "gitHead": "d589acd7af461ab0bc38d1b89b59c68b84731ea1"
+  "gitHead": "3461eb517c21cd330f2c3495f6bc01ca4191690c"
 }