trinity-config 1.1.1 → 1.2.2

package/README.md

@@ -1,58 +1,21 @@
 # trinity-config
 
-> 一键把 [Trinity API](https://trinitydesk.ai) 接入 **Claude Code** 或 **Codex CLI** —— 指定工具类型 + 粘贴 `xh-` Key 即用
+一键接入 Trinity：Claude Code / Codex / OpenCode / OpenClaw / ZCode。
 
-## 快速开始
-
-### 交互式
-
-```bash
-npx -y trinity-config
-```
-
-按提示选择 **工具类型**、粘贴 Key、确认 **model_code**。
-
-### 一行命令（推荐）
+协议按 `GET /v1/models/{code}` 的 `capabilities.text.interfaces` **自动择优**（Anthropic → Responses → Completions），再与工具能力求交。
 
 ```bash
-# Claude Code
-npx -y trinity-config --type claude -k xh-你的key
-
-# Codex CLI
-npx -y trinity-config --type codex -k xh-你的key --model gpt-5.4
+npx -y trinity-config --type zcode -k xh-你的key --model gpt-5.4
 ```
 
-每次只配置 **一个** 工具；两个都要用时各执行一次。
-
-## 命令行参数
-
-| 参数 | 简写 | 说明 |
-| --- | --- | --- |
-| `--type` | `-t` | **必填（非交互）**：`claude` \| `codex` |
-| `--api-key` | `-k` | Trinity API Key |
-| `--model` | `-M` | 默认 model_code（省略则按 type 内置推荐） |
-| `--base-url` | | 默认 `https://api.trinitydesk.ai` |
-| `--skip-verify` | | 跳过连通性验证 |
-| `--verbose` | `-v` | 显示 zcf 详细输出 |
-
-### 按 type 的默认模型
-
-| `--type` | 默认 `--model` |
+| type | 配置文件 |
 | --- | --- |
-| `claude` | `claude-sonnet-4-6` |
-| `codex` | `gpt-5.4` |
-
-## 扩展新工具
-
-后续增加 Cursor、OpenCode 等时，只需新增 `type` 枚举与对应写入逻辑，**不再**为每个工具增加 `--xxx-model` 参数。
-
-## 注意
-
-- 配置后**所有模型调用走 Trinity 计费**。
-- 非交互模式必须同时提供 `--type` 与 `-k`。
-- **Claude Code**：经 zcf 写入 `~/.claude/settings.json`
-- **Codex CLI**：**直接** merge `~/.codex/config.toml` + `auth.json`（不调用 zcf；zcf cx 会重置为 ChatGPT 官方登录）
+| claude | `~/.claude/settings.json` |
+| codex | `~/.codex/config.toml` |
+| opencode | `~/.config/opencode/opencode.json` |
+| openclaw | `~/.openclaw/openclaw.json` |
+| zcode | `~/.zcode/v2/config.json` |
 
-## License
+Anthropic Base **不带** `/v1`；Responses / Completions **带** `/v1`。
 
-MIT
+License: MIT

package/dist/index.js

@@ -5,53 +5,91 @@ import pc from "picocolors";
 
 // src/constants.ts
 var PACKAGE_NAME = "trinity-config";
-var PACKAGE_VERSION = "1.1.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
 function defaultModelForType(type) {
-  return type === "claude" ? DEFAULT_CLAUDE_MODEL : DEFAULT_CODEX_MODEL;
+  switch (type) {
+    case "claude":
+      return DEFAULT_CLAUDE_MODEL;
+    case "codex":
+      return DEFAULT_CODEX_MODEL;
+    case "opencode":
+      return DEFAULT_OPENCODE_MODEL;
+    case "openclaw":
+      return DEFAULT_OPENCLAW_MODEL;
+    case "zcode":
+      return DEFAULT_ZCODE_MODEL;
+  }
 }
 function resolveModel(type, model) {
   return model?.trim() || defaultModelForType(type);
 }
 function parseToolType(raw) {
   const value = raw.trim().toLowerCase();
-  if (value === "claude" || value === "codex") {
+  if (value === "claude" || value === "codex" || value === "opencode" || value === "openclaw" || value === "zcode") {
     return value;
   }
-  throw new Error("--type \u987B\u4E3A claude \u6216 codex");
+  throw new Error("--type \u987B\u4E3A claude\u3001codex\u3001opencode\u3001openclaw \u6216 zcode");
 }
 function toolLabel(type) {
-  return type === "claude" ? "Claude Code" : "Codex CLI";
+  switch (type) {
+    case "claude":
+      return "Claude Code";
+    case "codex":
+      return "Codex CLI";
+    case "opencode":
+      return "OpenCode";
+    case "openclaw":
+      return "OpenClaw";
+    case "zcode":
+      return "ZCode";
+  }
+}
+function launchCommand(type) {
+  switch (type) {
+    case "claude":
+      return "claude";
+    case "codex":
+      return "codex";
+    case "opencode":
+      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
+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> [\u9009\u9879]
+  npx -y trinity-config --type <claude|codex|opencode|openclaw|zcode> [\u9009\u9879]
 
 \u9009\u9879:
-  -t, --type <claude|codex>  \u8981\u914D\u7F6E\u7684\u5DE5\u5177\uFF08\u975E\u4EA4\u4E92\u987B\u6307\u5B9A\uFF1B\u4EA4\u4E92\u5F0F\u53EF\u7701\u7565\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 \u4F7F\u7528\u5185\u7F6E\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
-  -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
+  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) {
@@ -98,7 +136,7 @@ function parseArgs(argv) {
         break;
       case "--only": {
         const legacy = args.shift();
-        console.warn("\u8B66\u544A: --only \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u6539\u7528 --type claude \u6216 --type codex");
+        console.warn("\u8B66\u544A: --only \u5DF2\u5E9F\u5F03\uFF0C\u8BF7\u6539\u7528 --type");
         opts.type = parseToolType(String(legacy ?? ""));
         break;
       }
@@ -129,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 \u6216 --type codex");
+  throw new Error("\u975E\u4EA4\u4E92\u6A21\u5F0F\u987B\u6307\u5B9A --type claude\u3001codex\u3001opencode\u3001openclaw \u6216 zcode");
 }
 
 // src/merge-claude-env.ts
@@ -162,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) {
@@ -222,23 +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 };
+async function configureOpenCode(apiKey, openCodeBaseUrl, model, modelIds, protocol) {
+  const { configureOpenCodeDirect } = await import("./merge-opencode-config-24P7MV7L.js");
+  return configureOpenCodeDirect({
+    apiKey,
+    baseUrl: openCodeBaseUrl,
+    model,
+    modelIds,
+    protocol
+  });
 }
-function baseUrlForType(type, baseUrl) {
-  const { claudeBaseUrl, codexBaseUrl } = resolveBaseUrls(baseUrl);
-  return type === "claude" ? claudeBaseUrl : codexBaseUrl;
+async function configureOpenClaw(apiKey, openClawBaseUrl, model, modelIds, protocol) {
+  const { configureOpenClawDirect } = await import("./merge-openclaw-config-BNKTK35F.js");
+  return configureOpenClawDirect({
+    apiKey,
+    baseUrl: openClawBaseUrl,
+    model,
+    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,
@@ -279,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,
@@ -327,7 +546,10 @@ async function verifyTrinityApi(apiKey, baseUrl = TRINITY_BASE_URL) {
 function pickRecommendedModels(modelIds) {
   const claude = modelIds.find((id) => id === DEFAULT_CLAUDE_MODEL) ?? modelIds.find((id) => id.includes("claude-sonnet")) ?? modelIds.find((id) => id.toLowerCase().includes("claude"));
   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"));
-  return { claude, codex };
+  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;
+  const zcode = modelIds.find((id) => id === DEFAULT_ZCODE_MODEL) ?? opencode ?? codex;
+  return { claude, codex, opencode, openclaw, zcode };
 }
 
 // src/index.ts
@@ -355,8 +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: "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)) {
@@ -384,6 +609,20 @@ async function promptModel(type, initial) {
   }
   return String(value).trim();
 }
+function recommendedHint(toolType, recommended) {
+  switch (toolType) {
+    case "claude":
+      return recommended.claude;
+    case "codex":
+      return recommended.codex;
+    case "opencode":
+      return recommended.opencode;
+    case "openclaw":
+      return recommended.openclaw;
+    case "zcode":
+      return recommended.zcode;
+  }
+}
 async function run() {
   let opts;
   try {
@@ -404,67 +643,161 @@ 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, apiRoot);
+    if (result.ok) {
+      spinner2.stop(pc.green(result.message));
+      verifiedModelIds = result.modelIds;
+      const recommended = pickRecommendedModels(result.modelIds ?? []);
+      const hint = recommendedHint(toolType, recommended);
+      if (hint && hint !== model) {
+        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",
+        "\u63D0\u793A"
+      );
+    }
+  }
+  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"));
-      console.error(formatZcfError(error));
+      console.error(formatConfigError(error));
       return 1;
     }
-  } else {
+  } 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}`);
     } catch (error) {
       spinner2.stop(pc.red("Codex \u914D\u7F6E\u5931\u8D25"));
-      console.error(formatZcfError(error));
+      console.error(formatConfigError(error));
       return 1;
     }
-  }
-  if (!opts.skipVerify) {
-    spinner2.start("\u9A8C\u8BC1 Trinity API \u8FDE\u901A\u6027\u2026");
-    const result = await verifyTrinityApi(apiKey, claudeBaseUrl);
-    if (result.ok) {
-      spinner2.stop(pc.green(result.message));
-      const recommended = pickRecommendedModels(result.modelIds ?? []);
-      const hint = toolType === "claude" ? recommended.claude : recommended.codex;
-      if (hint && hint !== model) {
-        p.note(`\u540C\u7C7B\u578B\u63A8\u8350\u6A21\u578B: ${hint}`, "\u6A21\u578B");
-      }
-    } else {
-      spinner2.stop(pc.yellow(result.message));
-      p.note(
-        "\u672C\u5730\u914D\u7F6E\u5DF2\u5199\u5165\uFF0C\u4F46\u8FDE\u901A\u6027\u68C0\u67E5\u672A\u901A\u8FC7\u3002\u8BF7\u68C0\u67E5 API Key\u3001\u7F51\u7EDC\uFF0C\u6216\u5728\u63A7\u5236\u53F0\u786E\u8BA4 Key \u6709\u6548\u3002",
-        "\u63D0\u793A"
+  } else if (toolType === "opencode") {
+    spinner2.start("\u914D\u7F6E OpenCode\u2026");
+    try {
+      const backupDir = await configureOpenCode(
+        apiKey,
+        writeBase,
+        model,
+        verifiedModelIds,
+        protocol
+      );
+      const backupHint = backupDir ? `
+\u5907\u4EFD: ${backupDir}` : "";
+      spinner2.stop(
+        `OpenCode \u914D\u7F6E\u5DF2\u5199\u5165 ~/.config/opencode/opencode.json${backupHint}`
+      );
+    } catch (error) {
+      spinner2.stop(pc.red("OpenCode \u914D\u7F6E\u5931\u8D25"));
+      console.error(formatConfigError(error));
+      return 1;
+    }
+  } else if (toolType === "openclaw") {
+    spinner2.start("\u914D\u7F6E OpenClaw\u2026");
+    try {
+      const backupDir = await configureOpenClaw(
+        apiKey,
+        writeBase,
+        model,
+        verifiedModelIds,
+        protocol
+      );
+      const backupHint = backupDir ? `
+\u5907\u4EFD: ${backupDir}` : "";
+      spinner2.stop(
+        `OpenClaw \u914D\u7F6E\u5DF2\u5199\u5165 ~/.openclaw/openclaw.json${backupHint}`
+      );
+    } catch (error) {
+      spinner2.stop(pc.red("OpenClaw \u914D\u7F6E\u5931\u8D25"));
+      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}`
       );
-      p.outro(pc.yellow("\u914D\u7F6E\u5B8C\u6210\uFF08\u9A8C\u8BC1\u672A\u901A\u8FC7\uFF09"));
+    } catch (error) {
+      spinner2.stop(pc.red("ZCode \u914D\u7F6E\u5931\u8D25"));
+      console.error(formatConfigError(error));
       return 1;
     }
   }
-  const launchCmd = toolType === "claude" ? "claude" : "codex";
-  p.note(
-    [
-      `\u8FD0\u884C ${launchCmd} \u542F\u52A8 ${toolLabel(toolType)}`,
-      "\u5728\u5DE5\u5177\u5185\u7528 /model \u5207\u6362\u4E3A Trinity \u5DF2\u4E0A\u67B6\u7684 model_code",
-      "\u914D\u7F6E\u540E\u8BF7\u6C42\u8D70 Trinity \u8BA1\u8D39\uFF0C\u4E0D\u518D\u4F7F\u7528 Anthropic/OpenAI \u5B98\u65B9\u989D\u5EA6"
-    ].join("\n"),
-    "\u4E0B\u4E00\u6B65"
-  );
+  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)}`,
+    `\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("\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");
+  }
+  nextSteps.push("\u914D\u7F6E\u540E\u8BF7\u6C42\u8D70 Trinity \u8BA1\u8D39\uFF0C\u4E0D\u518D\u4F7F\u7528\u5B98\u65B9\u989D\u5EA6");
+  p.note(nextSteps.join("\n"), "\u4E0B\u4E00\u6B65");
   p.outro(pc.green("\u5B8C\u6210"));
   return 0;
 }
-function formatZcfError(error) {
+function formatConfigError(error) {
   if (error instanceof Error && "timed out" in error) {
     return "zcf \u6267\u884C\u8D85\u65F6\uFF08>3 \u5206\u949F\uFF09\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u7A0D\u540E\u91CD\u8BD5\u3002";
   }

package/dist/merge-openclaw-config-BNKTK35F.js

@@ -0,0 +1,128 @@
+// src/merge-openclaw-config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var TRINITY_OPENCLAW_PROVIDER = "trinity";
+function openclawHome() {
+  if (process.env.OPENCLAW_HOME?.trim()) {
+    return process.env.OPENCLAW_HOME.trim();
+  }
+  return path.join(os.homedir(), ".openclaw");
+}
+function openclawConfigPath() {
+  if (process.env.OPENCLAW_CONFIG?.trim()) {
+    return process.env.OPENCLAW_CONFIG.trim();
+  }
+  return path.join(openclawHome(), "openclaw.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 backupOpenClawConfig() {
+  const configPath = openclawConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  const backupDir = path.join(openclawHome(), "backup", `trinity-config-${timestampLabel()}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+  fs.copyFileSync(configPath, path.join(backupDir, path.basename(configPath)));
+  return backupDir;
+}
+function readOpenClawConfig() {
+  const configPath = openclawConfigPath();
+  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}\u3002\u82E5\u6587\u4EF6\u4E3A JSON5\uFF0C\u8BF7\u5148\u6539\u4E3A\u6807\u51C6 JSON\uFF0C\u6216\u5907\u4EFD\u540E\u5220\u9664\u518D\u91CD\u8DD1\u3002`
+    );
+  }
+}
+function isLikelyNonTextModel(id) {
+  const lower = id.toLowerCase();
+  return lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling");
+}
+function buildModelEntries(primaryModel, modelIds) {
+  const ids = [primaryModel];
+  const seen = new Set(ids);
+  for (const id of modelIds ?? []) {
+    const trimmed = id?.trim();
+    if (!trimmed || seen.has(trimmed) || isLikelyNonTextModel(trimmed)) continue;
+    seen.add(trimmed);
+    ids.push(trimmed);
+    if (ids.length >= 80) break;
+  }
+  return ids.map((id) => ({
+    id,
+    name: id,
+    reasoning: false,
+    input: ["text"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 128e3,
+    maxTokens: 8192
+  }));
+}
+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 } : {};
+  const existing = providers[TRINITY_OPENCLAW_PROVIDER] ?? {};
+  const existingModels = Array.isArray(existing.models) ? existing.models : [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of existingModels) {
+    if (m && typeof m === "object" && typeof m.id === "string") {
+      byId.set(m.id, m);
+    }
+  }
+  for (const m of buildModelEntries(options.model, options.modelIds)) {
+    byId.set(m.id, { ...byId.get(m.id), ...m });
+  }
+  providers[TRINITY_OPENCLAW_PROVIDER] = {
+    ...existing,
+    baseUrl: options.baseUrl.replace(/\/+$/, ""),
+    apiKey: options.apiKey,
+    api,
+    models: [...byId.values()]
+  };
+  modelsBlock.providers = providers;
+  doc.models = modelsBlock;
+  const agents = doc.agents && typeof doc.agents === "object" ? { ...doc.agents } : {};
+  const defaults = agents.defaults && typeof agents.defaults === "object" ? { ...agents.defaults } : {};
+  const modelCfg = defaults.model && typeof defaults.model === "object" ? { ...defaults.model } : {};
+  modelCfg.primary = `${TRINITY_OPENCLAW_PROVIDER}/${options.model}`;
+  defaults.model = modelCfg;
+  const allow = defaults.models && typeof defaults.models === "object" ? { ...defaults.models } : {};
+  allow[`${TRINITY_OPENCLAW_PROVIDER}/*`] = allow[`${TRINITY_OPENCLAW_PROVIDER}/*`] ?? {};
+  defaults.models = allow;
+  agents.defaults = defaults;
+  doc.agents = agents;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(doc, null, 2)}
+`, "utf8");
+}
+function configureOpenClawDirect(options) {
+  const backupDir = backupOpenClawConfig();
+  mergeOpenClawConfig(options);
+  return backupDir;
+}
+export {
+  TRINITY_OPENCLAW_PROVIDER,
+  backupOpenClawConfig,
+  configureOpenClawDirect,
+  mergeOpenClawConfig,
+  openclawConfigPath,
+  openclawHome
+};

package/dist/merge-opencode-config-24P7MV7L.js

@@ -0,0 +1,109 @@
+// src/merge-opencode-config.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var TRINITY_OPENCODE_PROVIDER = "trinity";
+function opencodeConfigDir() {
+  if (process.env.OPENCODE_CONFIG_DIR?.trim()) {
+    return process.env.OPENCODE_CONFIG_DIR.trim();
+  }
+  return path.join(os.homedir(), ".config", "opencode");
+}
+function opencodeConfigPath() {
+  if (process.env.OPENCODE_CONFIG?.trim()) {
+    return process.env.OPENCODE_CONFIG.trim();
+  }
+  return path.join(opencodeConfigDir(), "opencode.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 backupOpenCodeConfig() {
+  const configPath = opencodeConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+  const backupDir = path.join(opencodeConfigDir(), "backup", `trinity-config-${timestampLabel()}`);
+  fs.mkdirSync(backupDir, { recursive: true });
+  fs.copyFileSync(configPath, path.join(backupDir, path.basename(configPath)));
+  return backupDir;
+}
+function readOpenCodeConfig() {
+  const configPath = opencodeConfigPath();
+  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 buildModelMap(primaryModel, modelIds) {
+  const ids = [primaryModel];
+  const seen = new Set(ids);
+  for (const id of modelIds ?? []) {
+    const trimmed = id?.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    const lower = trimmed.toLowerCase();
+    if (lower.includes("image") || lower.includes("video") || lower.includes("seedance") || lower.includes("wan-") || lower.includes("kling")) {
+      continue;
+    }
+    seen.add(trimmed);
+    ids.push(trimmed);
+    if (ids.length >= 80) break;
+  }
+  const models = {};
+  for (const id of ids) {
+    models[id] = { name: id };
+  }
+  return models;
+}
+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 } : {};
+  const existing = providers[TRINITY_OPENCODE_PROVIDER] ?? {};
+  const existingModels = existing.models && typeof existing.models === "object" ? existing.models : {};
+  providers[TRINITY_OPENCODE_PROVIDER] = {
+    ...existing,
+    npm,
+    name: "Trinity",
+    options: {
+      ...existing.options ?? {},
+      baseURL: options.baseUrl.replace(/\/+$/, ""),
+      apiKey: options.apiKey
+    },
+    models: {
+      ...existingModels,
+      ...buildModelMap(options.model, options.modelIds)
+    }
+  };
+  doc.provider = providers;
+  fs.mkdirSync(path.dirname(configPath), { recursive: true });
+  fs.writeFileSync(configPath, `${JSON.stringify(doc, null, 2)}
+`, "utf8");
+}
+function configureOpenCodeDirect(options) {
+  const backupDir = backupOpenCodeConfig();
+  mergeOpenCodeConfig(options);
+  return backupDir;
+}
+export {
+  TRINITY_OPENCODE_PROVIDER,
+  backupOpenCodeConfig,
+  configureOpenCodeDirect,
+  mergeOpenCodeConfig,
+  opencodeConfigDir,
+  opencodeConfigPath
+};

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,7 +1,7 @@
 {
   "name": "trinity-config",
-  "version": "1.1.1",
-  "description": "一键把 Trinity API 接入 Claude Code 与 Codex CLI",
+  "version": "1.2.2",
+  "description": "一键把 Trinity API 接入 Claude Code、Codex、OpenCode、OpenClaw",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -29,6 +29,8 @@
     "trinitydesk",
     "claude-code",
     "codex",
+    "opencode",
+    "openclaw",
     "cli",
     "ai-gateway",
     "zcf"