trinity-config 1.2.1 → 1.2.2

package/README.md

@@ -1,25 +1,21 @@
 # trinity-config
 
-> 一键把 [Trinity API](https://trinitydesk.ai) 接入 **Claude Code** / **Codex CLI** / **OpenCode** / **OpenClaw**
+一键接入 Trinity：Claude Code / Codex / OpenCode / OpenClaw / ZCode。
 
-## 快速开始
+协议按 `GET /v1/models/{code}` 的 `capabilities.text.interfaces` **自动择优**（Anthropic → Responses → Completions），再与工具能力求交。
 
 ```bash
-npx -y trinity-config --type claude -k xh-你的key
-npx -y trinity-config --type codex -k xh-你的key --model gpt-5.4
-npx -y trinity-config --type opencode -k xh-你的key --model gpt-5.4
-npx -y trinity-config --type openclaw -k xh-你的key --model gpt-5.4
+npx -y trinity-config --type zcode -k xh-你的key --model gpt-5.4
 ```
 
-| `--type` | 默认模型 | 接口 | 写入 |
-| --- | --- | --- | --- |
-| `claude` | `claude-sonnet-4-6` | `/v1/messages` | `~/.claude/settings.json` |
-| `codex` | `gpt-5.4` | `/v1/responses` | `~/.codex/config.toml` + `auth.json` |
-| `opencode` | `gpt-5.4` | `/v1/chat/completions` | `~/.config/opencode/opencode.json` |
-| `openclaw` | `gpt-5.4` | `/v1/chat/completions` | `~/.openclaw/openclaw.json` |
+| type | 配置文件 |
+| --- | --- |
+| claude | `~/.claude/settings.json` |
+| codex | `~/.codex/config.toml` |
+| opencode | `~/.config/opencode/opencode.json` |
+| openclaw | `~/.openclaw/openclaw.json` |
+| zcode | `~/.zcode/v2/config.json` |
 
-OpenClaw 改完后请重启 Gateway（或重新 `openclaw dashboard`）。
+Anthropic Base **不带** `/v1`；Responses / Completions **带** `/v1`。
 
-## License
-
-MIT
+License: MIT

package/dist/index.js

@@ -5,13 +5,14 @@ import pc from "picocolors";
 
 // src/constants.ts
 var PACKAGE_NAME = "trinity-config";
-var PACKAGE_VERSION = "1.2.1";
+var PACKAGE_VERSION = "1.2.2";
 var TRINITY_BASE_URL = "https://api.trinitydesk.ai";
 var DEFAULT_CLAUDE_MODEL = "claude-sonnet-4-6";
 var DEFAULT_CLAUDE_FAST_MODEL = "claude-sonnet-4-6";
 var DEFAULT_CODEX_MODEL = "gpt-5.4";
 var DEFAULT_OPENCODE_MODEL = "gpt-5.4";
 var DEFAULT_OPENCLAW_MODEL = "gpt-5.4";
+var DEFAULT_ZCODE_MODEL = "gpt-5.4";
 var VERIFY_TIMEOUT_MS = 15e3;
 
 // src/model.ts
@@ -25,6 +26,8 @@ function defaultModelForType(type) {
       return DEFAULT_OPENCODE_MODEL;
     case "openclaw":
       return DEFAULT_OPENCLAW_MODEL;
+    case "zcode":
+      return DEFAULT_ZCODE_MODEL;
   }
 }
 function resolveModel(type, model) {
@@ -32,10 +35,10 @@ function resolveModel(type, model) {
 }
 function parseToolType(raw) {
   const value = raw.trim().toLowerCase();
-  if (value === "claude" || value === "codex" || value === "opencode" || value === "openclaw") {
+  if (value === "claude" || value === "codex" || value === "opencode" || value === "openclaw" || value === "zcode") {
     return value;
   }
-  throw new Error("--type \u987B\u4E3A claude\u3001codex\u3001opencode \u6216 openclaw");
+  throw new Error("--type \u987B\u4E3A claude\u3001codex\u3001opencode\u3001openclaw \u6216 zcode");
 }
 function toolLabel(type) {
   switch (type) {
@@ -47,6 +50,8 @@ function toolLabel(type) {
       return "OpenCode";
     case "openclaw":
       return "OpenClaw";
+    case "zcode":
+      return "ZCode";
   }
 }
 function launchCommand(type) {
@@ -59,33 +64,32 @@ function launchCommand(type) {
       return "opencode";
     case "openclaw":
       return "openclaw dashboard";
+    case "zcode":
+      return "ZCode \u684C\u9762\u5E94\u7528";
   }
 }
 
 // src/args.ts
 function printHelp() {
   console.log(`
-trinity-config \u2014 \u4E00\u952E\u628A Trinity API \u63A5\u5165\u7EC8\u7AEF\u7F16\u7A0B\u52A9\u624B / Agent \u7F51\u5173
+trinity-config \u2014 \u4E00\u952E\u628A Trinity API \u63A5\u5165\u7EC8\u7AEF / Agent / \u684C\u9762\u7F16\u7A0B\u52A9\u624B
 
 \u7528\u6CD5:
-  npx -y trinity-config --type <claude|codex|opencode|openclaw> [\u9009\u9879]
+  npx -y trinity-config --type <claude|codex|opencode|openclaw|zcode> [\u9009\u9879]
 
 \u9009\u9879:
-  -t, --type <claude|codex|opencode|openclaw>  \u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u975E\u4EA4\u4E92\u987B\u6307\u5B9A\uFF09
-  -k, --api-key <key>                          Trinity API Key\uFF08xh- \u524D\u7F00\uFF09
-  -M, --model <model_code>                     \u9ED8\u8BA4\u6A21\u578B\uFF08\u7701\u7565\u5219\u6309 type \u63A8\u8350\uFF09
-  --base-url <url>                             API \u6839\u5730\u5740\uFF08\u9ED8\u8BA4 https://api.trinitydesk.ai\uFF09
-  --skip-verify                                \u8DF3\u8FC7 GET /v1/models \u8FDE\u901A\u6027\u68C0\u67E5
-  -v, --verbose                                \u663E\u793A zcf \u8BE6\u7EC6\u8F93\u51FA\uFF08\u4EC5 Claude\uFF09
-  -h, --help                                   \u663E\u793A\u5E2E\u52A9
-  -V, --version                                \u663E\u793A\u7248\u672C
+  -t, --type <\u2026>         \u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u975E\u4EA4\u4E92\u987B\u6307\u5B9A\uFF09
+  -k, --api-key <key>    Trinity API Key\uFF08xh- \u524D\u7F00\uFF09
+  -M, --model <code>     \u9ED8\u8BA4\u6A21\u578B\uFF1B\u534F\u8BAE\u6309\u6A21\u578B\u8BE6\u60C5\u81EA\u52A8\u62E9\u4F18\uFF08\u975E completions \u4F18\u5148\uFF09
+  --base-url <url>       API \u6839\u5730\u5740\uFF08\u9ED8\u8BA4 https://api.trinitydesk.ai\uFF09
+  --skip-verify          \u8DF3\u8FC7\u8FDE\u901A\u6027 / \u8BE6\u60C5\u62C9\u53D6
+  -v, --verbose          \u663E\u793A zcf \u8BE6\u7EC6\u8F93\u51FA\uFF08\u4EC5 Claude\uFF09
+  -h, --help             \u663E\u793A\u5E2E\u52A9
+  -V, --version          \u663E\u793A\u7248\u672C
 
 \u793A\u4F8B:
-  npx -y trinity-config --type claude -k xh-your-key
-  npx -y trinity-config --type codex -k xh-your-key --model gpt-5.4
-  npx -y trinity-config --type opencode -k xh-your-key --model gpt-5.4
-  npx -y trinity-config --type openclaw -k xh-your-key --model gpt-5.4
-  npx -y trinity-config
+  npx -y trinity-config --type zcode -k xh-your-key --model gpt-5.4
+  npx -y trinity-config --type openclaw -k xh-your-key
 `);
 }
 function parseArgs(argv) {
@@ -163,7 +167,7 @@ function normalizeApiKey(raw) {
 function requireType(type, hasApiKeyFlag) {
   if (type) return type;
   if (!hasApiKeyFlag) return void 0;
-  throw new Error("\u975E\u4EA4\u4E92\u6A21\u5F0F\u987B\u6307\u5B9A --type claude\u3001codex\u3001opencode \u6216 openclaw");
+  throw new Error("\u975E\u4EA4\u4E92\u6A21\u5F0F\u987B\u6307\u5B9A --type claude\u3001codex\u3001opencode\u3001openclaw \u6216 zcode");
 }
 
 // src/merge-claude-env.ts
@@ -196,6 +200,167 @@ function mergeClaudeEnv(claudeModel, fastModel, baseUrl) {
 `, "utf8");
 }
 
+// src/protocol.ts
+import https from "https";
+var PROTOCOL_PRIORITY = [
+  "anthropic_messages",
+  "responses",
+  "chat_completions"
+];
+var TOOL_SUPPORTED_PROTOCOLS = {
+  claude: ["anthropic_messages"],
+  codex: ["responses"],
+  opencode: ["anthropic_messages", "responses", "chat_completions"],
+  openclaw: ["anthropic_messages", "responses", "chat_completions"],
+  zcode: ["anthropic_messages", "responses", "chat_completions"]
+};
+var INTERFACE_ALIASES = {
+  "text.anthropic_messages": "anthropic_messages",
+  anthropic_messages: "anthropic_messages",
+  "text.responses": "responses",
+  responses: "responses",
+  "text.chat_completions": "chat_completions",
+  chat_completions: "chat_completions",
+  chat: "chat_completions"
+};
+function getJson(url, apiKey) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(url);
+    const req = https.request(
+      {
+        protocol: target.protocol,
+        hostname: target.hostname,
+        port: target.port || 443,
+        path: `${target.pathname}${target.search}`,
+        method: "GET",
+        headers: {
+          Accept: "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        timeout: VERIFY_TIMEOUT_MS
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+        res.on("end", () => {
+          const text2 = Buffer.concat(chunks).toString("utf8");
+          try {
+            resolve({
+              statusCode: res.statusCode ?? 0,
+              body: JSON.parse(text2)
+            });
+          } catch {
+            reject(new Error(`\u54CD\u5E94\u4E0D\u662F JSON\uFF08HTTP ${res.statusCode}\uFF09`));
+          }
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`\u8FDE\u63A5\u8D85\u65F6\uFF08>${VERIFY_TIMEOUT_MS}ms\uFF09`));
+    });
+    req.on("error", reject);
+    req.end();
+  });
+}
+function normalizeInterface(raw) {
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  return INTERFACE_ALIASES[raw.trim().toLowerCase()] ?? null;
+}
+function parseInterfacesFromDetail(body) {
+  if (!body || typeof body !== "object") return [];
+  const root = body;
+  const caps = root.capabilities;
+  if (!caps || typeof caps !== "object") return [];
+  const text2 = caps.text;
+  if (!text2 || typeof text2 !== "object") return [];
+  const textObj = text2;
+  const rawList = textObj.interfaces ?? textObj.protocols;
+  if (!Array.isArray(rawList)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of rawList) {
+    const proto = normalizeInterface(item);
+    if (proto && !seen.has(proto)) {
+      seen.add(proto);
+      out.push(proto);
+    }
+  }
+  return out;
+}
+function rootBaseUrl(baseUrl) {
+  const root = (baseUrl ?? TRINITY_BASE_URL).replace(/\/+$/, "");
+  return root.endsWith("/v1") ? root.slice(0, -3) : root;
+}
+function baseUrlForProtocol(protocol, root) {
+  const cleaned = rootBaseUrl(root);
+  return protocol === "anthropic_messages" ? cleaned : `${cleaned}/v1`;
+}
+function defaultProtocolForTool(tool) {
+  return TOOL_SUPPORTED_PROTOCOLS[tool][0];
+}
+function pickProtocol(tool, modelProtocols) {
+  const supported = TOOL_SUPPORTED_PROTOCOLS[tool];
+  const candidates = PROTOCOL_PRIORITY.filter(
+    (p2) => modelProtocols.includes(p2) && supported.includes(p2)
+  );
+  if (candidates.length > 0) {
+    return { protocol: candidates[0] };
+  }
+  if (modelProtocols.length === 0) {
+    return {
+      protocol: defaultProtocolForTool(tool),
+      note: "\u6A21\u578B\u8BE6\u60C5\u672A\u8FD4\u56DE interfaces\uFF0C\u5DF2\u6309\u5DE5\u5177\u9ED8\u8BA4\u534F\u8BAE\u964D\u7EA7"
+    };
+  }
+  throw new Error(
+    `\u6A21\u578B\u4E0D\u652F\u6301 ${tool} \u53EF\u7528\u534F\u8BAE\uFF08\u6A21\u578B: ${modelProtocols.join(", ") || "\u65E0"}\uFF1B\u5DE5\u5177: ${supported.join(", ")}\uFF09`
+  );
+}
+async function fetchModelProtocols(apiKey, modelCode, root) {
+  const base = rootBaseUrl(root);
+  const url = `${base}/v1/models/${encodeURIComponent(modelCode)}`;
+  const { statusCode, body } = await getJson(url, apiKey);
+  if (statusCode < 200 || statusCode >= 300) {
+    return [];
+  }
+  return parseInterfacesFromDetail(body);
+}
+async function resolveProtocol(options) {
+  let modelProtocols = [];
+  let fromApi = false;
+  if (!options.skipFetch) {
+    try {
+      modelProtocols = await fetchModelProtocols(
+        options.apiKey,
+        options.model,
+        options.rootBaseUrl
+      );
+      fromApi = modelProtocols.length > 0;
+    } catch {
+      modelProtocols = [];
+    }
+  }
+  const picked = pickProtocol(options.tool, modelProtocols);
+  return {
+    protocol: picked.protocol,
+    baseUrl: baseUrlForProtocol(picked.protocol, options.rootBaseUrl),
+    modelProtocols,
+    fromApi,
+    note: picked.note
+  };
+}
+function protocolLabel(protocol) {
+  switch (protocol) {
+    case "anthropic_messages":
+      return "Anthropic Messages\uFF08/v1/messages\uFF09";
+    case "responses":
+      return "OpenAI Responses\uFF08/v1/responses\uFF09";
+    case "chat_completions":
+      return "Chat Completions\uFF08/v1/chat/completions\uFF09";
+  }
+}
+
 // src/zcf.ts
 import { execa } from "execa";
 function sharedZcfArgs(verbose) {
@@ -256,41 +421,43 @@ async function configureCodex(apiKey, codexBaseUrl, codexModel, _verbose) {
   const { configureCodexDirect } = await import("./merge-codex-config-GC7ZDP7R.js");
   return configureCodexDirect(apiKey, codexBaseUrl, codexModel);
 }
-function resolveBaseUrls(baseUrl) {
-  const root = (baseUrl ?? TRINITY_BASE_URL).replace(/\/+$/, "");
-  const codexBaseUrl = root.endsWith("/v1") ? root : `${root}/v1`;
-  const claudeBaseUrl = root.endsWith("/v1") ? root.slice(0, -3) : root;
-  return { claudeBaseUrl, codexBaseUrl };
-}
-function baseUrlForType(type, baseUrl) {
-  const { claudeBaseUrl, codexBaseUrl } = resolveBaseUrls(baseUrl);
-  return type === "claude" ? claudeBaseUrl : codexBaseUrl;
-}
-async function configureOpenCode(apiKey, openCodeBaseUrl, model, modelIds) {
-  const { configureOpenCodeDirect } = await import("./merge-opencode-config-P4QJ63DF.js");
+async function configureOpenCode(apiKey, openCodeBaseUrl, model, modelIds, protocol) {
+  const { configureOpenCodeDirect } = await import("./merge-opencode-config-24P7MV7L.js");
   return configureOpenCodeDirect({
     apiKey,
     baseUrl: openCodeBaseUrl,
     model,
-    modelIds
+    modelIds,
+    protocol
   });
 }
-async function configureOpenClaw(apiKey, openClawBaseUrl, model, modelIds) {
-  const { configureOpenClawDirect } = await import("./merge-openclaw-config-XV25MSSC.js");
+async function configureOpenClaw(apiKey, openClawBaseUrl, model, modelIds, protocol) {
+  const { configureOpenClawDirect } = await import("./merge-openclaw-config-BNKTK35F.js");
   return configureOpenClawDirect({
     apiKey,
     baseUrl: openClawBaseUrl,
     model,
-    modelIds
+    modelIds,
+    protocol
+  });
+}
+async function configureZCode(apiKey, zcodeBaseUrl, model, modelIds, protocol) {
+  const { configureZCodeDirect } = await import("./merge-zcode-config-U4V7XCYT.js");
+  return configureZCodeDirect({
+    apiKey,
+    baseUrl: zcodeBaseUrl,
+    model,
+    modelIds,
+    protocol
   });
 }
 
 // src/verify.ts
-import https from "https";
-function getJson(url, apiKey) {
+import https2 from "https";
+function getJson2(url, apiKey) {
   return new Promise((resolve, reject) => {
     const target = new URL(url);
-    const req = https.request(
+    const req = https2.request(
       {
         protocol: target.protocol,
         hostname: target.hostname,
@@ -331,7 +498,7 @@ async function verifyTrinityApi(apiKey, baseUrl = TRINITY_BASE_URL) {
   const root = baseUrl.replace(/\/+$/, "");
   const modelsUrl = `${root}/v1/models`;
   try {
-    const { statusCode, body } = await getJson(modelsUrl, apiKey);
+    const { statusCode, body } = await getJson2(modelsUrl, apiKey);
     if (statusCode === 401 || statusCode === 403) {
       return {
         ok: false,
@@ -381,7 +548,8 @@ function pickRecommendedModels(modelIds) {
   const codex = modelIds.find((id) => id === DEFAULT_CODEX_MODEL) ?? modelIds.find((id) => id === "gpt-5.4") ?? modelIds.find((id) => id.startsWith("gpt-5")) ?? modelIds.find((id) => id.toLowerCase().includes("gpt"));
   const opencode = modelIds.find((id) => id === DEFAULT_OPENCODE_MODEL) ?? codex ?? modelIds.find((id) => id.toLowerCase().includes("qwen"));
   const openclaw = modelIds.find((id) => id === DEFAULT_OPENCLAW_MODEL) ?? opencode ?? codex;
-  return { claude, codex, opencode, openclaw };
+  const zcode = modelIds.find((id) => id === DEFAULT_ZCODE_MODEL) ?? opencode ?? codex;
+  return { claude, codex, opencode, openclaw, zcode };
 }
 
 // src/index.ts
@@ -409,10 +577,11 @@ async function promptToolType(initial) {
   const value = await p.select({
     message: "\u8981\u914D\u7F6E\u54EA\u4E2A\u5DE5\u5177\uFF1F",
     options: [
-      { value: "claude", label: "Claude Code\uFF08/v1/messages\uFF09" },
-      { value: "codex", label: "Codex CLI\uFF08/v1/responses\uFF09" },
-      { value: "opencode", label: "OpenCode\uFF08/v1/chat/completions\uFF09" },
-      { value: "openclaw", label: "OpenClaw\uFF08/v1/chat/completions\uFF09" }
+      { value: "claude", label: "Claude Code" },
+      { value: "codex", label: "Codex CLI" },
+      { value: "opencode", label: "OpenCode" },
+      { value: "openclaw", label: "OpenClaw" },
+      { value: "zcode", label: "ZCode" }
     ]
   });
   if (p.isCancel(value)) {
@@ -450,6 +619,8 @@ function recommendedHint(toolType, recommended) {
       return recommended.opencode;
     case "openclaw":
       return recommended.openclaw;
+    case "zcode":
+      return recommended.zcode;
   }
 }
 async function run() {
@@ -472,14 +643,14 @@ async function run() {
   const toolType = await promptToolType(opts.type);
   const apiKey = await promptApiKey(opts.apiKey);
   const model = opts.model?.trim() ? opts.model.trim() : opts.apiKey ? resolveModel(toolType) : await promptModel(toolType);
-  const apiBaseUrl = baseUrlForType(toolType, opts.baseUrl);
-  const { claudeBaseUrl } = resolveBaseUrls(opts.baseUrl);
+  const apiRoot = rootBaseUrl(opts.baseUrl);
   p.log.info(`\u5DE5\u5177: ${toolLabel(toolType)} \xB7 \u6A21\u578B: ${model}`);
   const spinner2 = p.spinner();
   let verifiedModelIds;
+  let verifyFailed = false;
   if (!opts.skipVerify) {
     spinner2.start("\u9A8C\u8BC1 Trinity API \u8FDE\u901A\u6027\u2026");
-    const result = await verifyTrinityApi(apiKey, claudeBaseUrl);
+    const result = await verifyTrinityApi(apiKey, apiRoot);
     if (result.ok) {
       spinner2.stop(pc.green(result.message));
       verifiedModelIds = result.modelIds;
@@ -489,6 +660,7 @@ async function run() {
         p.note(`\u540C\u7C7B\u578B\u63A8\u8350\u6A21\u578B: ${hint}`, "\u6A21\u578B");
       }
     } else {
+      verifyFailed = true;
       spinner2.stop(pc.yellow(result.message));
       p.note(
         "\u8FDE\u901A\u6027\u68C0\u67E5\u672A\u901A\u8FC7\uFF1B\u4ECD\u5C06\u5C1D\u8BD5\u5199\u5165\u672C\u5730\u914D\u7F6E\u3002\u8BF7\u68C0\u67E5 API Key\u3001\u7F51\u7EDC\uFF0C\u6216\u5728\u63A7\u5236\u53F0\u786E\u8BA4 Key \u6709\u6548\u3002",
@@ -496,11 +668,34 @@ async function run() {
       );
     }
   }
+  spinner2.start("\u89E3\u6790\u6A21\u578B\u534F\u8BAE\u2026");
+  let protocolRes;
+  try {
+    protocolRes = await resolveProtocol({
+      tool: toolType,
+      apiKey,
+      model,
+      rootBaseUrl: apiRoot,
+      skipFetch: opts.skipVerify
+    });
+    spinner2.stop(
+      `\u534F\u8BAE: ${protocolLabel(protocolRes.protocol)}` + (protocolRes.fromApi ? "" : "\uFF08\u964D\u7EA7\uFF09")
+    );
+    if (protocolRes.note) {
+      p.note(protocolRes.note, "\u534F\u8BAE");
+    }
+  } catch (error) {
+    spinner2.stop(pc.red("\u534F\u8BAE\u89E3\u6790\u5931\u8D25"));
+    console.error(pc.red(error instanceof Error ? error.message : String(error)));
+    return 1;
+  }
+  const writeBase = protocolRes.baseUrl;
+  const protocol = protocolRes.protocol;
   if (toolType === "claude") {
     spinner2.start("\u914D\u7F6E Claude Code\u2026");
     try {
-      await configureClaude(apiKey, apiBaseUrl, model, opts.verbose);
-      mergeClaudeEnv(model, model, apiBaseUrl);
+      await configureClaude(apiKey, writeBase, model, opts.verbose);
+      mergeClaudeEnv(model, model, writeBase);
       spinner2.stop("Claude Code \u914D\u7F6E\u5DF2\u5199\u5165 ~/.claude/settings.json");
     } catch (error) {
       spinner2.stop(pc.red("Claude Code \u914D\u7F6E\u5931\u8D25"));
@@ -510,7 +705,7 @@ async function run() {
   } else if (toolType === "codex") {
     spinner2.start("\u914D\u7F6E Codex CLI\u2026");
     try {
-      const backupDir = await configureCodex(apiKey, apiBaseUrl, model, opts.verbose);
+      const backupDir = await configureCodex(apiKey, writeBase, model, opts.verbose);
       const backupHint = backupDir ? `
 \u5907\u4EFD: ${backupDir}` : "";
       spinner2.stop(`Codex \u914D\u7F6E\u5DF2\u5199\u5165 ~/.codex/config.toml \u4E0E auth.json${backupHint}`);
@@ -524,9 +719,10 @@ async function run() {
     try {
       const backupDir = await configureOpenCode(
         apiKey,
-        apiBaseUrl,
+        writeBase,
         model,
-        verifiedModelIds
+        verifiedModelIds,
+        protocol
       );
       const backupHint = backupDir ? `
 \u5907\u4EFD: ${backupDir}` : "";
@@ -538,14 +734,15 @@ async function run() {
       console.error(formatConfigError(error));
       return 1;
     }
-  } else {
+  } else if (toolType === "openclaw") {
     spinner2.start("\u914D\u7F6E OpenClaw\u2026");
     try {
       const backupDir = await configureOpenClaw(
         apiKey,
-        apiBaseUrl,
+        writeBase,
         model,
-        verifiedModelIds
+        verifiedModelIds,
+        protocol
       );
       const backupHint = backupDir ? `
 \u5907\u4EFD: ${backupDir}` : "";
@@ -557,18 +754,41 @@ async function run() {
       console.error(formatConfigError(error));
       return 1;
     }
+  } else {
+    spinner2.start("\u914D\u7F6E ZCode\u2026");
+    try {
+      const backupDir = await configureZCode(
+        apiKey,
+        writeBase,
+        model,
+        verifiedModelIds,
+        protocol
+      );
+      const backupHint = backupDir ? `
+\u5907\u4EFD: ${backupDir}` : "";
+      spinner2.stop(
+        `ZCode \u914D\u7F6E\u5DF2\u5199\u5165 ~/.zcode/v2/config.json${backupHint}`
+      );
+    } catch (error) {
+      spinner2.stop(pc.red("ZCode \u914D\u7F6E\u5931\u8D25"));
+      console.error(formatConfigError(error));
+      return 1;
+    }
   }
-  if (!opts.skipVerify && verifiedModelIds === void 0) {
+  if (verifyFailed) {
     p.outro(pc.yellow("\u914D\u7F6E\u5B8C\u6210\uFF08\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF09"));
     return 1;
   }
   const nextSteps = [
-    `\u8FD0\u884C ${launchCommand(toolType)} \u542F\u52A8 ${toolLabel(toolType)}`
+    `\u8FD0\u884C ${launchCommand(toolType)} \u542F\u52A8 ${toolLabel(toolType)}`,
+    `\u5DF2\u6309\u534F\u8BAE\u63A5\u5165: ${protocolLabel(protocol)}`
   ];
   if (toolType === "opencode") {
     nextSteps.push("\u5728 OpenCode \u5185\u7528 /models \u9009\u62E9 trinity/<model_code>");
   } else if (toolType === "openclaw") {
-    nextSteps.push("\u9ED8\u8BA4\u6A21\u578B\u4E3A trinity/<model_code>\uFF1B\u6539\u5B8C\u914D\u7F6E\u540E\u8BF7\u91CD\u542F Gateway");
+    nextSteps.push("\u6539\u5B8C\u914D\u7F6E\u540E\u8BF7\u91CD\u542F Gateway");
+  } else if (toolType === "zcode") {
+    nextSteps.push("\u91CD\u542F ZCode \u540E\uFF0C\u5728\u6A21\u578B\u8BBE\u7F6E\u4E2D\u542F\u7528 Trinity \u4F9B\u5E94\u5546");
   } else {
     nextSteps.push("\u5728\u5DE5\u5177\u5185\u7528 /model \u5207\u6362\u4E3A Trinity \u5DF2\u4E0A\u67B6\u7684 model_code");
   }

package/dist/{merge-openclaw-config-XV25MSSC.js → merge-openclaw-config-BNKTK35F.js}

@@ -74,6 +74,8 @@ function buildModelEntries(primaryModel, modelIds) {
 function mergeOpenClawConfig(options) {
   const configPath = openclawConfigPath();
   const doc = readOpenClawConfig();
+  const protocol = options.protocol ?? "chat_completions";
+  const api = protocol === "anthropic_messages" ? "anthropic-messages" : protocol === "responses" ? "openai-responses" : "openai-completions";
   const modelsBlock = doc.models && typeof doc.models === "object" ? { ...doc.models } : {};
   modelsBlock.mode = modelsBlock.mode ?? "merge";
   const providers = modelsBlock.providers && typeof modelsBlock.providers === "object" ? { ...modelsBlock.providers } : {};
@@ -92,7 +94,7 @@ function mergeOpenClawConfig(options) {
     ...existing,
     baseUrl: options.baseUrl.replace(/\/+$/, ""),
     apiKey: options.apiKey,
-    api: "openai-completions",
+    api,
     models: [...byId.values()]
   };
   modelsBlock.providers = providers;

package/dist/{merge-opencode-config-P4QJ63DF.js → merge-opencode-config-24P7MV7L.js}

@@ -68,6 +68,8 @@ function buildModelMap(primaryModel, modelIds) {
 function mergeOpenCodeConfig(options) {
   const configPath = opencodeConfigPath();
   const doc = readOpenCodeConfig();
+  const protocol = options.protocol ?? "chat_completions";
+  const npm = protocol === "anthropic_messages" ? "@ai-sdk/anthropic" : protocol === "responses" ? "@ai-sdk/openai" : "@ai-sdk/openai-compatible";
   doc.$schema = doc.$schema ?? "https://opencode.ai/config.json";
   doc.model = `${TRINITY_OPENCODE_PROVIDER}/${options.model}`;
   const providers = doc.provider && typeof doc.provider === "object" ? { ...doc.provider } : {};
@@ -75,7 +77,7 @@ function mergeOpenCodeConfig(options) {
   const existingModels = existing.models && typeof existing.models === "object" ? existing.models : {};
   providers[TRINITY_OPENCODE_PROVIDER] = {
     ...existing,
-    npm: "@ai-sdk/openai-compatible",
+    npm,
     name: "Trinity",
     options: {
       ...existing.options ?? {},

package/dist/merge-zcode-config-U4V7XCYT.js

@@ -0,0 +1,114 @@
+// src/merge-zcode-config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var TRINITY_ZCODE_PROVIDER = "trinity";
+function zcodeHome() {
+  if (process.env.ZCODE_HOME?.trim()) {
+    return process.env.ZCODE_HOME.trim();
+  }
+  return path.join(os.homedir(), ".zcode");
+}
+function zcodeConfigPath() {
+  if (process.env.ZCODE_CONFIG?.trim()) {
+    return process.env.ZCODE_CONFIG.trim();
+  }
+  return path.join(zcodeHome(), "v2", "config.json");
+}
+function timestampLabel() {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}`;
+}
+function backupZCodeConfig() {
+  const configPath = zcodeConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  const backupDir = path.join(zcodeHome(), "backup", `trinity-config-${timestampLabel()}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+  fs.copyFileSync(configPath, path.join(backupDir, "config.json"));
+  return backupDir;
+}
+function readZCodeConfig() {
+  const configPath = zcodeConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(configPath, "utf8");
+  if (!raw.trim()) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`\u65E0\u6CD5\u89E3\u6790 ${configPath}\uFF0C\u8BF7\u68C0\u67E5 JSON \u8BED\u6CD5\u540E\u91CD\u8BD5\u3002`);
+  }
+}
+function buildModels(primary, modelIds) {
+  const ids = /* @__PURE__ */ new Set([primary]);
+  for (const id of modelIds ?? []) {
+    const t = id?.trim();
+    if (!t) continue;
+    const lower = t.toLowerCase();
+    if (lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling")) {
+      continue;
+    }
+    ids.add(t);
+    if (ids.size >= 80) break;
+  }
+  const models = {};
+  for (const id of ids) {
+    models[id] = { name: id };
+  }
+  return models;
+}
+function mergeZCodeConfig(options) {
+  const configPath = zcodeConfigPath();
+  const doc = readZCodeConfig();
+  const providers = doc.provider && typeof doc.provider === "object" ? { ...doc.provider } : {};
+  for (const [id, provider] of Object.entries(providers)) {
+    if (id === TRINITY_ZCODE_PROVIDER) continue;
+    if (provider && typeof provider === "object") {
+      providers[id] = { ...provider, enabled: false };
+    }
+  }
+  const existing = providers[TRINITY_ZCODE_PROVIDER] ?? {};
+  const existingModels = existing.models && typeof existing.models === "object" ? existing.models : {};
+  const root = options.baseUrl.replace(/\/v1\/?$/, "").replace(/\/+$/, "");
+  const withV1 = `${root}/v1`;
+  const withoutV1 = root;
+  const primaryBase = options.protocol === "anthropic_messages" ? withoutV1 : withV1;
+  providers[TRINITY_ZCODE_PROVIDER] = {
+    ...existing,
+    enabled: true,
+    name: "Trinity",
+    options: {
+      ...existing.options ?? {},
+      baseURL: primaryBase,
+      apiKey: options.apiKey,
+      openaiBaseURL: withV1,
+      anthropicBaseURL: withoutV1
+    },
+    models: {
+      ...existingModels,
+      ...buildModels(options.model, options.modelIds)
+    }
+  };
+  doc.provider = providers;
+  doc.model = `${TRINITY_ZCODE_PROVIDER}/${options.model}`;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(doc, null, 2)}
+`, "utf8");
+}
+function configureZCodeDirect(options) {
+  const backupDir = backupZCodeConfig();
+  mergeZCodeConfig(options);
+  return backupDir;
+}
+export {
+  TRINITY_ZCODE_PROVIDER,
+  backupZCodeConfig,
+  configureZCodeDirect,
+  mergeZCodeConfig,
+  zcodeConfigPath,
+  zcodeHome
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trinity-config",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "一键把 Trinity API 接入 Claude Code、Codex、OpenCode、OpenClaw",
   "license": "MIT",
   "type": "module",