@zergai/ztc 0.4.0-beta.1 → 0.4.1-dev.36919234045

package/dist/zlm-embed.mjs

@@ -16,6 +16,200 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// packages/model-contracts/index.js
+function normalizeContractProvider(provider) {
+  const normalized = provider.trim().toLowerCase();
+  return normalized === "moonshot" ? "kimi" : normalized === "claude" ? "anthropic" : normalized;
+}
+function normalizeContractModel(provider, model) {
+  const canonicalProvider = normalizeContractProvider(provider);
+  let id = model.trim().toLowerCase();
+  if (id.startsWith(`${canonicalProvider}/`)) id = id.slice(canonicalProvider.length + 1);
+  if (canonicalProvider === "fireworks" && id.startsWith("accounts/fireworks/models/")) {
+    id = id.slice("accounts/fireworks/models/".length);
+  }
+  return id;
+}
+function modelContract(provider, model, surface = "native_api") {
+  const canonicalProvider = normalizeContractProvider(provider);
+  const id = normalizeContractModel(canonicalProvider, model);
+  const contracts = MODEL_CONTRACTS.get(canonicalProvider);
+  const contract = contracts?.get(id) ?? (canonicalProvider === "anthropic" ? contracts?.get(id.replace(/-\d{8}$/, "")) : void 0);
+  if (contract === void 0) return void 0;
+  return {
+    reasoningEfforts: [...surface === "chat_tools" ? contract.chatToolReasoningEfforts ?? contract.reasoningEfforts : contract.reasoningEfforts],
+    ...contract.chatToolReasoningEfforts ? { chatToolReasoningEfforts: [...contract.chatToolReasoningEfforts] } : {},
+    maxOutputTokens: contract.maxOutputTokens === null ? null : { ...contract.maxOutputTokens },
+    fallbackRouting: contract.fallbackRouting
+  };
+}
+function reasoningRequestParams(provider, model, effort) {
+  const canonicalProvider = normalizeContractProvider(provider);
+  const id = normalizeContractModel(canonicalProvider, model);
+  const contract = modelContract(canonicalProvider, id);
+  const selected = typeof effort === "string" && contract?.reasoningEfforts.includes(effort) ? effort : null;
+  if (canonicalProvider === "deepseek" && contract?.reasoningEfforts.length) {
+    if (selected === "none") return { thinking: { type: "disabled" } };
+    return { thinking: { type: "enabled" }, reasoning_effort: selected ?? "high" };
+  }
+  if (selected === null) return {};
+  if (canonicalProvider === "anthropic") return { output_config: { effort: selected } };
+  if (canonicalProvider === "gemini") {
+    const thinkingConfig = id.startsWith("gemini-2.5-") ? { thinkingBudget: selected === "none" ? 0 : selected === "low" ? 1024 : selected === "medium" ? 8192 : id === "gemini-2.5-pro" ? 32768 : 24576 } : { thinkingLevel: selected };
+    return { generationConfig: { thinkingConfig } };
+  }
+  if (canonicalProvider === "zai") {
+    const thinking = { type: selected === "none" ? "disabled" : "enabled" };
+    return id === "glm-5.2" || id === "glm-5.3" || id === "glm-5.3-flash" ? { thinking, ...selected === "none" ? {} : { reasoning_effort: selected } } : { thinking };
+  }
+  if (canonicalProvider === "cohere") return { thinking: { type: selected === "none" ? "disabled" : "enabled" } };
+  return { reasoning_effort: selected };
+}
+function fireworksRequestModel(model) {
+  const upstream = model.trim().replace(/^fireworks\//i, "");
+  if (upstream.startsWith("accounts/")) return upstream;
+  return `accounts/fireworks/models/${normalizeContractModel("fireworks", model)}`;
+}
+var MODEL_CONTRACTS, CONTRACT_PROVIDERS;
+var init_model_contracts = __esm({
+  "packages/model-contracts/index.js"() {
+    "use strict";
+    MODEL_CONTRACTS = /* @__PURE__ */ new Map([
+      ["openai", /* @__PURE__ */ new Map([
+        ["gpt-4o", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 16384 }, fallbackRouting: true }],
+        ["gpt-4o-mini", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 16384 }, fallbackRouting: true }],
+        ["gpt-5", { reasoningEfforts: ["minimal", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5-mini", { reasoningEfforts: ["minimal", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.2", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.2-codex", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.3-codex", { reasoningEfforts: ["low", "medium", "high", "xhigh"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: false }],
+        ["gpt-5.4", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.4-mini", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.5", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.6", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.6-current", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: true }],
+        ["gpt-5.6-luna", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.6-sol", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-5.6-terra", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-6-sol", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }],
+        ["gpt-6-luna", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: { "min": 256, "max": 128e3 }, fallbackRouting: true }]
+      ])],
+      ["anthropic", /* @__PURE__ */ new Map([
+        ["claude-3-5-haiku-20241022", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["claude-3-5-sonnet-20241022", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["claude-opus-4-6", { reasoningEfforts: ["low", "medium", "high", "max"], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["claude-opus-4.8", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["claude-sonnet-4", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 64e3 }, fallbackRouting: true }],
+        ["claude-sonnet-4-5", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 64e3 }, fallbackRouting: true }],
+        ["claude-sonnet-4-6", { reasoningEfforts: ["low", "medium", "high", "max"], maxOutputTokens: { "min": 256, "max": 64e3 }, fallbackRouting: true }],
+        ["claude-sonnet-4-20250514", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 64e3 }, fallbackRouting: true }],
+        ["claude-opus-4-5", { reasoningEfforts: ["low", "medium", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-opus-4-8", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-opus-4-7", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-opus-5", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-opus-5-5", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-sonnet-5", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-sonnet-5-5", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-fable-5", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-fable-5-1", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-mythos-5", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["claude-mythos-5-1", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }]
+      ])],
+      ["gemini", /* @__PURE__ */ new Map([
+        ["gemini-2.0-flash", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["gemini-2.5-flash", { reasoningEfforts: ["none", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }],
+        ["gemini-2.5-pro", { reasoningEfforts: ["low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }],
+        ["gemini-3.6-flash", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["gemini-2.5-flash-lite", { reasoningEfforts: ["none", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }],
+        ["gemini-3-flash-preview", { reasoningEfforts: ["minimal", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }],
+        ["gemini-3.5-flash", { reasoningEfforts: ["minimal", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }],
+        ["gemini-3.8-flash", { reasoningEfforts: ["minimal", "low", "medium", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }],
+        ["gemini-3.1-pro-preview", { reasoningEfforts: ["low", "high"], maxOutputTokens: { "min": 256, "max": 65536 }, fallbackRouting: true }]
+      ])],
+      ["deepseek", /* @__PURE__ */ new Map([
+        ["deepseek-flash", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["deepseek-chat", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["deepseek-reasoner", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 8192 }, fallbackRouting: true }],
+        ["deepseek-v4-flash", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["deepseek-v4-flash-vision-exp", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["deepseek-v4-pro", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }]
+      ])],
+      ["kimi", /* @__PURE__ */ new Map([
+        ["kimi-for-coding", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 32e3 }, fallbackRouting: true }],
+        ["kimi-for-coding-highspeed", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 32e3 }, fallbackRouting: true }],
+        ["kimi-k2.6", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 32e3 }, fallbackRouting: true }],
+        ["kimi-k2.7-code", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: true }],
+        ["kimi-k2.7-code-highspeed", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: true }],
+        ["kimi-k3", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: { "min": 256, "max": 64e3 }, fallbackRouting: true }]
+      ])],
+      ["cohere", /* @__PURE__ */ new Map([
+        ["command-a-03-2025", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["command-r", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["command-r-plus", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["command-a-reasoning-08-2025", { reasoningEfforts: ["none", "high"], maxOutputTokens: { "min": 256, "max": 32e3 }, fallbackRouting: true }]
+      ])],
+      ["zai", /* @__PURE__ */ new Map([
+        ["glm-4-air", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["glm-4-flash", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["glm-4-plus", { reasoningEfforts: [], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["glm-4.5", { reasoningEfforts: ["none", "high"], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["glm-4.6", { reasoningEfforts: ["none", "high"], maxOutputTokens: { "min": 256, "max": 4096 }, fallbackRouting: true }],
+        ["glm-4.5-air", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-4.7", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5.1", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5.2", { reasoningEfforts: ["none", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5.3", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5.3-flash", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: null, fallbackRouting: true }]
+      ])],
+      ["codex", /* @__PURE__ */ new Map([
+        ["gpt-5.2", { reasoningEfforts: ["low", "medium", "high", "xhigh"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.3-codex", { reasoningEfforts: ["low", "medium", "high", "xhigh"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.3-codex-spark", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.4", { reasoningEfforts: ["low", "medium", "high", "xhigh"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.4-mini", { reasoningEfforts: ["low", "medium", "high", "xhigh"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.5", { reasoningEfforts: ["low", "medium", "high", "xhigh"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.5-codex", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.6", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.6-luna", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.6-sol", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-5.6-terra", { reasoningEfforts: ["low", "medium", "high", "xhigh", "max", "ultra"], maxOutputTokens: null, fallbackRouting: false }]
+      ])],
+      ["openai_compatible", /* @__PURE__ */ new Map([
+        ["gpt-6-sol", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: null, fallbackRouting: false }],
+        ["gpt-6-luna", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], chatToolReasoningEfforts: ["none"], maxOutputTokens: null, fallbackRouting: false }]
+      ])],
+      ["modal", /* @__PURE__ */ new Map([
+        ["deepseek-v4.1-flash", { reasoningEfforts: ["none", "low", "high", "xhigh", "max"], maxOutputTokens: { "min": 256, "max": 1048576 }, fallbackRouting: false }],
+        ["epoch--ep-deepseek-v4-1-flash-server.us-west.modal.direct", { reasoningEfforts: ["none", "low", "high", "xhigh", "max"], maxOutputTokens: { "min": 256, "max": 1048576 }, fallbackRouting: false }],
+        ["kimi-k3", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: null, fallbackRouting: false }],
+        ["moonshot--kimi-k3-fast.modal.run", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: null, fallbackRouting: false }]
+      ])],
+      ["fireworks", /* @__PURE__ */ new Map([
+        ["deepseek-v4p1-flash", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["deepseek-v4-pro-0813", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["deepseek-v4-flash-0731", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["deepseek-v4-flash-vision-exp", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: { "min": 256, "max": 384e3 }, fallbackRouting: true }],
+        ["kimi-k3", { reasoningEfforts: ["none", "low", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["gpt-oss-120b", { reasoningEfforts: ["low", "medium", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["qwen3p8-max", { reasoningEfforts: ["none", "low", "medium", "high", "xhigh", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5p2", { reasoningEfforts: ["none", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5p3", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["glm-5p3-flash", { reasoningEfforts: ["low", "high", "max"], maxOutputTokens: null, fallbackRouting: true }],
+        ["ember-1", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["minimax-m3", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["nemotron-lightning-3p5-30b-a3b", { reasoningEfforts: ["none", "high"], maxOutputTokens: null, fallbackRouting: true }],
+        ["muse-glimmer-30b", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["kimi-k2p7-code", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["nemotron-3-ultra-nvfp4", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["inkling", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }],
+        ["kimi-k2p6", { reasoningEfforts: [], maxOutputTokens: null, fallbackRouting: false }]
+      ])]
+    ]);
+    CONTRACT_PROVIDERS = Object.freeze(["anthropic", "openai", "gemini", "deepseek", "fireworks", "kimi", "voyage", "cohere", "elevenlabs", "replicate", "fal", "zai", "modal", "codex", "self_hosted", "openai_compatible", "typesafe"]);
+  }
+});
+
 // src/agent/backends/sse.ts
 async function* parseSSEEvents(body) {
   const decoder = new TextDecoder();
@@ -78,255 +272,6 @@ var init_sse = __esm({
   }
 });
 
-// src/agent/backends/provider_ids.ts
-function normalizeProviderId(provider) {
-  const normalized = provider.trim().toLowerCase();
-  if (CODEX_APP_SERVER_ALIASES.has(normalized)) {
-    return CODEX_APP_SERVER_PROVIDER;
-  }
-  if (CODEX_LEGACY_ALIASES.has(normalized)) {
-    return CODEX_LEGACY_PROVIDER;
-  }
-  return normalized;
-}
-function isCodexAppServerProvider(provider) {
-  return normalizeProviderId(provider) === CODEX_APP_SERVER_PROVIDER;
-}
-function isCodexLegacyProvider(provider) {
-  return normalizeProviderId(provider) === CODEX_LEGACY_PROVIDER;
-}
-var CODEX_APP_SERVER_PROVIDER, CODEX_LEGACY_PROVIDER, CODEX_LEGACY_ALIAS, CODEX_APP_SERVER_SENTINEL, CODEX_APP_SERVER_ALIASES, CODEX_LEGACY_ALIASES;
-var init_provider_ids = __esm({
-  "src/agent/backends/provider_ids.ts"() {
-    "use strict";
-    CODEX_APP_SERVER_PROVIDER = "codex_app_server";
-    CODEX_LEGACY_PROVIDER = "codex_legacy";
-    CODEX_LEGACY_ALIAS = "codex";
-    CODEX_APP_SERVER_SENTINEL = "codex-app-server";
-    CODEX_APP_SERVER_ALIASES = /* @__PURE__ */ new Set([
-      CODEX_APP_SERVER_PROVIDER,
-      "codex-official"
-    ]);
-    CODEX_LEGACY_ALIASES = /* @__PURE__ */ new Set([
-      CODEX_LEGACY_PROVIDER,
-      CODEX_LEGACY_ALIAS,
-      "codex-chatgpt-legacy"
-    ]);
-  }
-});
-
-// src/utils/deepseek.ts
-function isModalDeepSeekFlashModel(model) {
-  return model?.toLowerCase().replace(/^modal\//, "") === MODAL_DEEPSEEK_FLASH_MODEL;
-}
-function isDeepSeekFlashModel(model) {
-  if (isModalDeepSeekFlashModel(model)) return true;
-  return model !== void 0 && [
-    DEEPSEEK_FLASH_MODEL,
-    "deepseek-v4-flash",
-    "deepseek-v4-flash-vision-exp"
-  ].includes(model.toLowerCase().replace(/^deepseek\//, ""));
-}
-function deepseekRequestParams(request) {
-  if (!isDeepSeekFlashModel(request.model)) return {};
-  if (isModalDeepSeekFlashModel(request.model)) {
-    const effort2 = request.codexEffort;
-    return effort2 && MODAL_DEEPSEEK_FLASH_EFFORTS.includes(effort2) ? { reasoning_effort: effort2 } : {};
-  }
-  if (request.codexEffort === "none") return { thinking: { type: "disabled" } };
-  const effort = request.codexEffort;
-  const reasoning = effort === "minimal" || effort === "low" ? "low" : effort === "max" || effort === "ultra" ? "max" : "high";
-  return { thinking: { type: "enabled" }, reasoning_effort: reasoning };
-}
-var DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_CONTEXT, MODAL_DEEPSEEK_FLASH_MAX_OUTPUT, MODAL_DEEPSEEK_FLASH_EFFORTS, DEEPSEEK_FLASH_CONTEXT, DEEPSEEK_FLASH_MAX_OUTPUT, DEEPSEEK_FLASH_EFFORTS;
-var init_deepseek = __esm({
-  "src/utils/deepseek.ts"() {
-    "use strict";
-    DEEPSEEK_FLASH_MODEL = "deepseek-flash";
-    MODAL_DEEPSEEK_FLASH_MODEL = "deepseek-v4.1-flash";
-    MODAL_DEEPSEEK_FLASH_CONTEXT = 1048576;
-    MODAL_DEEPSEEK_FLASH_MAX_OUTPUT = 1048576;
-    MODAL_DEEPSEEK_FLASH_EFFORTS = ["none", "low", "high", "xhigh", "max"];
-    DEEPSEEK_FLASH_CONTEXT = 1e6;
-    DEEPSEEK_FLASH_MAX_OUTPUT = 384e3;
-    DEEPSEEK_FLASH_EFFORTS = ["none", "low", "high", "max"];
-  }
-});
-
-// src/utils/models.ts
-function getKimiModelInfo(model) {
-  if (!model) return void 0;
-  const id = KIMI_ALIAS_TO_ID.get(model.toLowerCase());
-  return id ? KIMI_MODEL_INFO[id] : void 0;
-}
-function getOfficialCodexModelInfo(model) {
-  if (!model) return void 0;
-  const normalized = model.toLowerCase() === "gpt-5.6" ? "gpt-5.6-sol" : model.toLowerCase();
-  if (!OFFICIAL_CODEX_MODEL_IDS.includes(normalized)) return void 0;
-  return OFFICIAL_CODEX_MODEL_INFO[normalized];
-}
-function getSupportedClaudeReasoningEfforts(model) {
-  if (!model) return void 0;
-  const id = model.toLowerCase();
-  if (!id.startsWith("claude")) return void 0;
-  if (id.includes("haiku")) return [];
-  if (id.includes("opus") || id.includes("sonnet")) return CLAUDE_REASONING_EFFORTS;
-  return void 0;
-}
-function getSupportedCodexReasoningEfforts(model, provider) {
-  if (isModalDeepSeekFlashModel(model)) return MODAL_DEEPSEEK_FLASH_EFFORTS;
-  if (isDeepSeekFlashModel(model)) return DEEPSEEK_FLASH_EFFORTS;
-  const kimiInfo = getKimiModelInfo(model);
-  if (kimiInfo) return kimiInfo.supportedReasoningEfforts ?? [];
-  const appServerEfforts = getOfficialCodexModelInfo(model)?.supportedReasoningEfforts;
-  if (!appServerEfforts) return getSupportedClaudeReasoningEfforts(model);
-  if ((provider === "openai" || provider === "openai_compatible") && (model === "gpt-6-sol" || model === "gpt-6-luna")) {
-    return GPT_6_API_EFFORTS;
-  }
-  if (provider && isCodexLegacyProvider(provider)) return CODEX_LEGACY_EFFORTS;
-  if (provider === void 0) {
-    return [.../* @__PURE__ */ new Set([...appServerEfforts, ...CODEX_LEGACY_EFFORTS])];
-  }
-  return appServerEfforts;
-}
-function isCodexReasoningEffortSupported(provider, model, effort) {
-  const supported = getSupportedCodexReasoningEfforts(model, provider);
-  return supported === void 0 || supported.includes(effort);
-}
-var OFFICIAL_CODEX_MODEL_IDS, STANDARD_CODEX_EFFORTS, GPT_5_6_EFFORTS, GPT_5_6_ULTRA_EFFORTS, GPT_6_API_EFFORTS, CODEX_LEGACY_EFFORTS, OFFICIAL_CODEX_MODEL_INFO, KIMI_REASONING_EFFORTS, KIMI_MODEL_INFO, KIMI_ALIAS_TO_ID, CLAUDE_REASONING_EFFORTS;
-var init_models = __esm({
-  "src/utils/models.ts"() {
-    "use strict";
-    init_provider_ids();
-    init_deepseek();
-    OFFICIAL_CODEX_MODEL_IDS = [
-      "gpt-6-sol",
-      "gpt-6-luna",
-      "gpt-5.6-sol",
-      "gpt-5.6-terra",
-      "gpt-5.6-luna",
-      "gpt-5.5",
-      "gpt-5.4",
-      "gpt-5.4-mini",
-      "gpt-5.3-codex",
-      "gpt-5.2"
-    ];
-    STANDARD_CODEX_EFFORTS = ["low", "medium", "high", "xhigh"];
-    GPT_5_6_EFFORTS = [...STANDARD_CODEX_EFFORTS, "max"];
-    GPT_5_6_ULTRA_EFFORTS = [...GPT_5_6_EFFORTS, "ultra"];
-    GPT_6_API_EFFORTS = ["none", "low", "medium", "high", "xhigh", "max"];
-    CODEX_LEGACY_EFFORTS = ["none", "minimal", ...STANDARD_CODEX_EFFORTS];
-    OFFICIAL_CODEX_MODEL_INFO = {
-      "gpt-6-sol": {
-        displayName: "GPT-6 Sol",
-        description: "Frontier agentic coding model.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS
-      },
-      "gpt-6-luna": {
-        displayName: "GPT-6 Luna",
-        description: "Fast and affordable model for everyday work.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: GPT_5_6_EFFORTS
-      },
-      "gpt-5.6-sol": {
-        displayName: "GPT-5.6 Sol",
-        description: "Latest frontier agentic coding model.",
-        defaultReasoningEffort: "low",
-        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS
-      },
-      "gpt-5.6-terra": {
-        displayName: "GPT-5.6 Terra",
-        description: "Balanced agentic coding model for everyday work.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS
-      },
-      "gpt-5.6-luna": {
-        displayName: "GPT-5.6 Luna",
-        description: "Fast and affordable agentic coding model.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: GPT_5_6_EFFORTS
-      },
-      "gpt-5.5": {
-        displayName: "GPT-5.5",
-        description: "Frontier model for complex coding, research, and real-world work.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
-      },
-      "gpt-5.4": {
-        displayName: "GPT-5.4",
-        description: "Strong model for everyday coding.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
-      },
-      "gpt-5.4-mini": {
-        displayName: "GPT-5.4 Mini",
-        description: "Small, fast, and cost-efficient model for simpler coding tasks.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
-      },
-      "gpt-5.3-codex": {
-        displayName: "GPT-5.3 Codex",
-        description: "Codex-tuned agentic coding model.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
-      },
-      "gpt-5.2": {
-        displayName: "GPT-5.2",
-        description: "Earlier general-purpose Codex model.",
-        defaultReasoningEffort: "medium",
-        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
-      }
-    };
-    KIMI_REASONING_EFFORTS = ["low", "high", "max"];
-    KIMI_MODEL_INFO = {
-      "kimi-k3": {
-        displayName: "Kimi K3",
-        description: "Moonshot flagship \u2014 1M context, reasoning on by default, vision and tools.",
-        supportedReasoningEfforts: KIMI_REASONING_EFFORTS,
-        defaultReasoningEffort: "max",
-        aliases: ["k3", "kimi k3", "moonshot-kimi-k3", "moonshotai/kimi-k3"]
-      },
-      "kimi-k2.6": {
-        displayName: "Kimi K2.6",
-        description: "Smaller, cheaper Kimi \u2014 256K context, multimodal.",
-        // No supportedReasoningEfforts: Moonshot lists `reasoning_effort` as "Not
-        // supported" for K2.6, which instead takes a `thinking: {type}` object. ZTC
-        // does not send that object yet, so the picker must not offer a depth control
-        // here — the effort ladder and the thinking switch are different contracts.
-        aliases: ["k2.6", "kimi k2.6", "moonshotai/kimi-k2.6"]
-      },
-      "kimi-for-coding": {
-        displayName: "Kimi K2.7 Coding",
-        description: "Kimi Code subscription coding model \u2014 256K context, always-thinking, vision and tools.",
-        // No supportedReasoningEfforts: the subscription coding models are
-        // always-thinking with no documented effort ladder, so /effort stays
-        // rejected rather than forwarding a value the API silently ignores.
-        aliases: ["k2.7", "kimi k2.7", "kimi-k2.7-coding"]
-      },
-      "kimi-for-coding-highspeed": {
-        displayName: "Kimi K2.7 Coding Highspeed",
-        description: "High-speed variant of the Kimi Code subscription coding model \u2014 256K context.",
-        aliases: ["k2.7-highspeed", "kimi-for-coding-fast"]
-      }
-    };
-    KIMI_ALIAS_TO_ID = /* @__PURE__ */ new Map();
-    for (const id of Object.keys(KIMI_MODEL_INFO)) {
-      KIMI_ALIAS_TO_ID.set(id, id);
-      for (const alias of KIMI_MODEL_INFO[id].aliases) {
-        KIMI_ALIAS_TO_ID.set(alias.toLowerCase(), id);
-      }
-    }
-    CLAUDE_REASONING_EFFORTS = [
-      "low",
-      "medium",
-      "high",
-      "xhigh",
-      "max"
-    ];
-  }
-});
-
 // src/agent/backends/anthropic.ts
 function anthropicInputTokens(usage) {
   if (!usage) return 0;
@@ -336,8 +281,8 @@ var EXTENDED_CACHE_BETA, AnthropicBackend, AnthropicApiError;
 var init_anthropic = __esm({
   "src/agent/backends/anthropic.ts"() {
     "use strict";
+    init_model_contracts();
     init_sse();
-    init_models();
     EXTENDED_CACHE_BETA = "extended-cache-ttl-2025-04-11";
     AnthropicBackend = class {
       apiKey;
@@ -416,8 +361,8 @@ var init_anthropic = __esm({
           }
         }
         const effort = request.codexEffort;
-        const supportedEfforts = getSupportedClaudeReasoningEfforts(request.model);
-        const modelAllowsEffort = supportedEfforts === void 0 || effort !== void 0 && supportedEfforts.includes(effort);
+        const supportedEfforts = modelContract("anthropic", request.model)?.reasoningEfforts ?? [];
+        const modelAllowsEffort = effort !== void 0 && supportedEfforts.includes(effort);
         const outputConfig = effort && ["low", "medium", "high", "xhigh", "max"].includes(effort) && modelAllowsEffort ? { output_config: { effort } } : {};
         return {
           model: request.model,
@@ -854,52 +799,495 @@ function buildOpenAIMessages(request) {
       if (msg.reasoning) {
         assistantMsg.reasoning_content = msg.reasoning;
       }
-      out.push(assistantMsg);
-      continue;
-    }
-    if (toolResults.length > 0) {
-      for (const tr of toolResults) {
-        const resultText = typeof tr.content === "string" ? tr.content : tr.content.map((b) => b.type === "text" ? b.text || "" : "[image]").join("\n");
-        out.push({
-          role: "tool",
-          tool_call_id: tr.tool_use_id,
-          content: tr.is_error && !/^error\b/i.test(resultText) ? `Error: ${resultText}` : resultText
-        });
+      out.push(assistantMsg);
+      continue;
+    }
+    if (toolResults.length > 0) {
+      for (const tr of toolResults) {
+        const resultText = typeof tr.content === "string" ? tr.content : tr.content.map((b) => b.type === "text" ? b.text || "" : "[image]").join("\n");
+        out.push({
+          role: "tool",
+          tool_call_id: tr.tool_use_id,
+          content: tr.is_error && !/^error\b/i.test(resultText) ? `Error: ${resultText}` : resultText
+        });
+      }
+      if (textParts.length > 0 || mediaParts.length > 0) {
+        if (mediaParts.length > 0) {
+          const parts = textParts.map((t) => ({ type: "text", text: t }));
+          parts.push(...mediaParts);
+          out.push({ role: "user", content: parts });
+        } else {
+          out.push({ role: "user", content: textParts.join("\n") });
+        }
+      }
+      continue;
+    }
+    if (mediaParts.length > 0) {
+      const parts = textParts.map((t) => ({ type: "text", text: t }));
+      parts.push(...mediaParts);
+      out.push(withReasoning({ role: msg.role, content: parts }, msg));
+    } else {
+      out.push(withReasoning({ role: msg.role, content: textParts.join("\n") }, msg));
+    }
+  }
+  return out;
+}
+function buildOpenAIToolDefs(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: {
+      name: t.name,
+      description: t.description,
+      parameters: t.parameters
+    }
+  }));
+}
+var init_openai_format = __esm({
+  "src/agent/backends/openai_format.ts"() {
+    "use strict";
+  }
+});
+
+// src/config/profiles.ts
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+function builtinProfileEmulation(name) {
+  const builtin = BUILTIN_CONFIG_PROFILES.find((profile) => profile === name);
+  if (!builtin) return void 0;
+  const root = process.env.ZTC_CONFIG_DIR || join(homedir(), ".ztc");
+  return existsSync(join(root, "profiles", name)) ? void 0 : builtin;
+}
+function validateProfileName(name) {
+  if (name !== "default" && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
+    throw new Error("Profile name must be 1\u201364 characters: letters, numbers, dots, underscores, or hyphens; it must start with a letter or number.");
+  }
+  if (name === "." || name === "..") {
+    throw new Error("Profile name cannot be . or ..");
+  }
+  return name;
+}
+function activeProfile() {
+  return validateProfileName(process.env.ZTC_PROFILE || "default");
+}
+function profileConfigDir(profile = activeProfile()) {
+  const root = process.env.ZTC_CONFIG_DIR || join(homedir(), ".ztc");
+  const name = validateProfileName(profile);
+  if (name === "default") return root;
+  const namedDir = join(root, "profiles", name);
+  return builtinProfileEmulation(name) ? root : namedDir;
+}
+async function listConfigProfiles() {
+  const root = process.env.ZTC_CONFIG_DIR || join(homedir(), ".ztc");
+  let entries;
+  try {
+    entries = await readdir(join(root, "profiles"), { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [...BUILTIN_CONFIG_PROFILES, "default", activeProfile()].filter((name, index, names) => names.indexOf(name) === index).sort(profileOrder);
+    }
+    throw error;
+  }
+  const named = entries.filter((entry) => entry.isDirectory() && entry.name !== "default").map((entry) => entry.name).filter((name) => {
+    try {
+      validateProfileName(name);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+  const profiles = /* @__PURE__ */ new Set([activeProfile(), ...BUILTIN_CONFIG_PROFILES, ...named]);
+  profiles.delete("default");
+  return ["default", ...profiles].sort(profileOrder);
+}
+function profileOrder(left, right) {
+  const rank = (name) => {
+    if (name === "default") return 0;
+    const index = BUILTIN_CONFIG_PROFILES.findIndex((profile) => profile === name);
+    return index < 0 ? Number.MAX_SAFE_INTEGER : index + 1;
+  };
+  return rank(left) - rank(right) || left.localeCompare(right);
+}
+var BUILTIN_CONFIG_PROFILES;
+var init_profiles = __esm({
+  "src/config/profiles.ts"() {
+    "use strict";
+    BUILTIN_CONFIG_PROFILES = ["ztc", "ztc-coder", "ztc-datascience", "scientist"];
+  }
+});
+
+// src/utils/router_catalog.ts
+import { createHash, randomUUID as randomUUID2 } from "node:crypto";
+import { statSync, readFileSync } from "node:fs";
+import { dirname, join as join2 } from "node:path";
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function identifier(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 512 && !/[\x00-\x1f\x7f]/.test(value);
+}
+function identifiers(value, max) {
+  return Array.isArray(value) && value.length <= max && value.every(identifier);
+}
+function descriptor(value, legacy) {
+  if (!record2(value)) return void 0;
+  const id = value.id ?? (legacy ? value.name : void 0);
+  if (!identifier(id) || !identifier(value.owned_by)) return void 0;
+  const result = { id, owned_by: value.owned_by };
+  if (value.object !== void 0 && value.object !== "model") return void 0;
+  if (value.object === "model") result.object = "model";
+  for (const key of ["display_name", "provider_display_name"]) {
+    if (value[key] !== void 0) {
+      if (!identifier(value[key])) return void 0;
+      result[key] = value[key];
+    }
+  }
+  for (const key of ["is_default", "available"]) {
+    if (value[key] !== void 0) {
+      if (typeof value[key] !== "boolean") return void 0;
+      result[key] = value[key];
+    }
+  }
+  if (value.aliases !== void 0) {
+    if (!identifiers(value.aliases, 32)) return void 0;
+    result.aliases = value.aliases;
+  }
+  if (value.capabilities !== void 0) {
+    const caps = value.capabilities;
+    if (!record2(caps) || typeof caps.chat !== "boolean") return void 0;
+    const capabilities = { chat: caps.chat };
+    for (const key of ["tools", "images"]) {
+      if (caps[key] !== void 0) {
+        if (typeof caps[key] !== "boolean") return void 0;
+        capabilities[key] = caps[key];
+      }
+    }
+    for (const key of ["context_window", "max_output_tokens"]) {
+      if (caps[key] !== void 0) {
+        if (typeof caps[key] !== "number" || !Number.isSafeInteger(caps[key]) || caps[key] <= 0) return void 0;
+        capabilities[key] = caps[key];
+      }
+    }
+    if (caps.reasoning !== void 0) {
+      const reasoning = caps.reasoning;
+      if (!record2(reasoning) || !identifiers(reasoning.choices, 32) || reasoning.default !== void 0 && !identifier(reasoning.default)) return void 0;
+      capabilities.reasoning = { choices: reasoning.choices, ...reasoning.default === void 0 ? {} : { default: reasoning.default } };
+    }
+    result.capabilities = capabilities;
+  }
+  return result;
+}
+function resolveRouterModel(catalog, provider, model) {
+  const owner = provider === "moonshot" ? "kimi" : provider;
+  const rows = catalog.models.filter((row) => row.owned_by === owner);
+  const exact = rows.find((row) => row.id === model);
+  if (exact) return exact;
+  const matches = rows.filter((row) => row.id === `${owner}/${model}` || row.aliases?.includes(model));
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function routerCatalogScope(connection) {
+  const key = createHash("sha256").update(JSON.stringify([connection.origin.replace(/\/+$/, ""), connection.token, connection.workspaceId ?? ""])).digest("hex");
+  return join2(profileConfigDir(), `router-models-${key}.json`);
+}
+function parseCatalog(value) {
+  if (!record2(value)) throw new Error("Invalid Router catalog");
+  if (value.model_contract_version !== void 0 && value.model_contract_version !== 1) throw new Error("Unsupported Router model contract");
+  const data = value.data ?? value.models ?? value.items ?? [];
+  if (!Array.isArray(data) || data.length > 4096) throw new Error("Invalid Router catalog");
+  const version = value.model_contract_version === 1 ? 1 : 0;
+  return { version, models: data.flatMap((value2) => {
+    const row = descriptor(value2, version === 0);
+    return row ? [row] : [];
+  }) };
+}
+function readRouterCatalog(connection) {
+  const file = routerCatalogScope(connection);
+  try {
+    const stat3 = statSync(file, { bigint: true });
+    const stamp = `${stat3.mtimeNs}:${stat3.size}:${stat3.ino}`;
+    const previous = memo.get(file);
+    if (previous?.stamp === stamp) return previous.catalog;
+    const saved = JSON.parse(readFileSync(file, "utf8"));
+    const parsed = parseCatalog(saved);
+    const catalog = { ...parsed, cached: true, fetchedAt: Number(saved.fetchedAt) || 0 };
+    if (memo.size >= 32) memo.delete(memo.keys().next().value);
+    memo.set(file, { stamp, catalog });
+    return catalog;
+  } catch {
+    memo.delete(file);
+    return void 0;
+  }
+}
+var memo;
+var init_router_catalog = __esm({
+  "src/utils/router_catalog.ts"() {
+    "use strict";
+    init_profiles();
+    memo = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/agent/backends/provider_ids.ts
+function normalizeProviderId(provider) {
+  const normalized = provider.trim().toLowerCase();
+  if (CODEX_APP_SERVER_ALIASES.has(normalized)) {
+    return CODEX_APP_SERVER_PROVIDER;
+  }
+  if (CODEX_LEGACY_ALIASES.has(normalized)) {
+    return CODEX_LEGACY_PROVIDER;
+  }
+  return normalized;
+}
+function isCodexAppServerProvider(provider) {
+  return normalizeProviderId(provider) === CODEX_APP_SERVER_PROVIDER;
+}
+function isCodexLegacyProvider(provider) {
+  return normalizeProviderId(provider) === CODEX_LEGACY_PROVIDER;
+}
+function isLocalSubscriptionProvider(provider) {
+  return ["codex_app_server", "codex_legacy", "claude_code", "claude-code", "claude_code_direct", "claude-code-direct", "kimi_code", "kimi-code"].includes(normalizeProviderId(provider));
+}
+var CODEX_APP_SERVER_PROVIDER, CODEX_LEGACY_PROVIDER, CODEX_LEGACY_ALIAS, CODEX_APP_SERVER_SENTINEL, CODEX_APP_SERVER_ALIASES, CODEX_LEGACY_ALIASES;
+var init_provider_ids = __esm({
+  "src/agent/backends/provider_ids.ts"() {
+    "use strict";
+    CODEX_APP_SERVER_PROVIDER = "codex_app_server";
+    CODEX_LEGACY_PROVIDER = "codex_legacy";
+    CODEX_LEGACY_ALIAS = "codex";
+    CODEX_APP_SERVER_SENTINEL = "codex-app-server";
+    CODEX_APP_SERVER_ALIASES = /* @__PURE__ */ new Set([
+      CODEX_APP_SERVER_PROVIDER,
+      "codex-official"
+    ]);
+    CODEX_LEGACY_ALIASES = /* @__PURE__ */ new Set([
+      CODEX_LEGACY_PROVIDER,
+      CODEX_LEGACY_ALIAS,
+      "codex-chatgpt-legacy"
+    ]);
+  }
+});
+
+// src/utils/deepseek.ts
+function isModalDeepSeekFlashModel(model) {
+  return model?.toLowerCase().replace(/^modal\//, "") === MODAL_DEEPSEEK_FLASH_MODEL;
+}
+function isDeepSeekFlashModel(model) {
+  if (isModalDeepSeekFlashModel(model)) return true;
+  return model !== void 0 && [
+    DEEPSEEK_FLASH_MODEL,
+    "deepseek-v4-flash",
+    "deepseek-v4-flash-vision-exp"
+  ].includes(model.toLowerCase().replace(/^deepseek\//, "")) || model !== void 0 && ["deepseek-v4p1-flash", "deepseek-v4-flash-0731"].includes(normalizeContractModel("fireworks", model));
+}
+function deepseekRequestParams(request) {
+  if (!isDeepSeekFlashModel(request.model)) {
+    return reasoningRequestParams("deepseek", request.model, request.codexEffort);
+  }
+  if (normalizeContractModel("fireworks", request.model) === "deepseek-v4p1-flash" || request.model.toLowerCase().startsWith("fireworks/")) {
+    return reasoningRequestParams("fireworks", request.model, request.codexEffort);
+  }
+  if (isModalDeepSeekFlashModel(request.model)) {
+    const effort2 = request.codexEffort;
+    return effort2 && MODAL_DEEPSEEK_FLASH_EFFORTS.includes(effort2) ? { reasoning_effort: effort2 } : {};
+  }
+  if (request.codexEffort === "none") return { thinking: { type: "disabled" } };
+  const effort = request.codexEffort;
+  const reasoning = effort === "minimal" || effort === "low" ? "low" : effort === "max" || effort === "ultra" ? "max" : "high";
+  return { thinking: { type: "enabled" }, reasoning_effort: reasoning };
+}
+var DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_CONTEXT, MODAL_DEEPSEEK_FLASH_MAX_OUTPUT, MODAL_DEEPSEEK_FLASH_EFFORTS, DEEPSEEK_FLASH_CONTEXT, DEEPSEEK_FLASH_MAX_OUTPUT, DEEPSEEK_FLASH_EFFORTS;
+var init_deepseek = __esm({
+  "src/utils/deepseek.ts"() {
+    "use strict";
+    init_model_contracts();
+    DEEPSEEK_FLASH_MODEL = "deepseek-flash";
+    MODAL_DEEPSEEK_FLASH_MODEL = "deepseek-v4.1-flash";
+    MODAL_DEEPSEEK_FLASH_CONTEXT = 1048576;
+    MODAL_DEEPSEEK_FLASH_MAX_OUTPUT = 1048576;
+    MODAL_DEEPSEEK_FLASH_EFFORTS = modelContract("modal", MODAL_DEEPSEEK_FLASH_MODEL).reasoningEfforts;
+    DEEPSEEK_FLASH_CONTEXT = 1e6;
+    DEEPSEEK_FLASH_MAX_OUTPUT = 384e3;
+    DEEPSEEK_FLASH_EFFORTS = modelContract("deepseek", DEEPSEEK_FLASH_MODEL).reasoningEfforts;
+  }
+});
+
+// src/utils/models.ts
+function getKimiModelInfo(model) {
+  if (!model) return void 0;
+  const id = KIMI_ALIAS_TO_ID.get(model.toLowerCase());
+  return id ? KIMI_MODEL_INFO[id] : void 0;
+}
+function getOfficialCodexModelInfo(model) {
+  if (!model) return void 0;
+  const normalized = model.toLowerCase() === "gpt-5.6" ? "gpt-5.6-sol" : model.toLowerCase();
+  if (!OFFICIAL_CODEX_MODEL_IDS.includes(normalized)) return void 0;
+  return OFFICIAL_CODEX_MODEL_INFO[normalized];
+}
+function getSupportedClaudeReasoningEfforts(model) {
+  if (!model) return void 0;
+  const id = model.toLowerCase();
+  if (!id.startsWith("claude")) return void 0;
+  if (id.includes("haiku")) return [];
+  if (id.includes("opus") || id.includes("sonnet")) return CLAUDE_REASONING_EFFORTS;
+  return void 0;
+}
+function getSupportedCodexReasoningEfforts(model, provider, surface = provider === "openai_compatible" ? "chat_tools" : "native_api") {
+  if (provider && model && CONTRACT_PROVIDERS.includes(normalizeContractProvider(provider))) {
+    return modelContract(provider, model, surface)?.reasoningEfforts ?? [];
+  }
+  if (isModalDeepSeekFlashModel(model)) return MODAL_DEEPSEEK_FLASH_EFFORTS;
+  if (isDeepSeekFlashModel(model)) return DEEPSEEK_FLASH_EFFORTS;
+  const kimiInfo = getKimiModelInfo(model);
+  if (kimiInfo) return kimiInfo.supportedReasoningEfforts ?? [];
+  const appServerEfforts = getOfficialCodexModelInfo(model)?.supportedReasoningEfforts;
+  if (!appServerEfforts) return getSupportedClaudeReasoningEfforts(model);
+  if ((provider === "openai" || provider === "openai_compatible") && (model === "gpt-6-sol" || model === "gpt-6-luna")) {
+    return GPT_6_API_EFFORTS;
+  }
+  if (provider && isCodexLegacyProvider(provider)) return CODEX_LEGACY_EFFORTS;
+  if (provider === void 0) {
+    return [.../* @__PURE__ */ new Set([...appServerEfforts, ...CODEX_LEGACY_EFFORTS])];
+  }
+  return appServerEfforts;
+}
+function isCodexReasoningEffortSupported(provider, model, effort, surface) {
+  const supported = getSupportedCodexReasoningEfforts(model, provider, surface);
+  return supported === void 0 || supported.includes(effort);
+}
+var OFFICIAL_CODEX_MODEL_IDS, STANDARD_CODEX_EFFORTS, GPT_5_6_EFFORTS, GPT_5_6_ULTRA_EFFORTS, GPT_6_API_EFFORTS, CODEX_LEGACY_EFFORTS, OFFICIAL_CODEX_MODEL_INFO, KIMI_REASONING_EFFORTS, KIMI_MODEL_INFO, KIMI_ALIAS_TO_ID, CLAUDE_REASONING_EFFORTS;
+var init_models = __esm({
+  "src/utils/models.ts"() {
+    "use strict";
+    init_model_contracts();
+    init_router_catalog();
+    init_provider_ids();
+    init_deepseek();
+    OFFICIAL_CODEX_MODEL_IDS = [
+      "gpt-6-sol",
+      "gpt-6-luna",
+      "gpt-5.6-sol",
+      "gpt-5.6-terra",
+      "gpt-5.6-luna",
+      "gpt-5.5",
+      "gpt-5.4",
+      "gpt-5.4-mini",
+      "gpt-5.3-codex",
+      "gpt-5.2"
+    ];
+    STANDARD_CODEX_EFFORTS = ["low", "medium", "high", "xhigh"];
+    GPT_5_6_EFFORTS = [...STANDARD_CODEX_EFFORTS, "max"];
+    GPT_5_6_ULTRA_EFFORTS = [...GPT_5_6_EFFORTS, "ultra"];
+    GPT_6_API_EFFORTS = ["none", "low", "medium", "high", "xhigh", "max"];
+    CODEX_LEGACY_EFFORTS = ["none", "minimal", ...STANDARD_CODEX_EFFORTS];
+    OFFICIAL_CODEX_MODEL_INFO = {
+      "gpt-6-sol": {
+        displayName: "GPT-6 Sol",
+        description: "Frontier agentic coding model.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS
+      },
+      "gpt-6-luna": {
+        displayName: "GPT-6 Luna",
+        description: "Fast and affordable model for everyday work.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: GPT_5_6_EFFORTS
+      },
+      "gpt-5.6-sol": {
+        displayName: "GPT-5.6 Sol",
+        description: "Latest frontier agentic coding model.",
+        defaultReasoningEffort: "low",
+        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS
+      },
+      "gpt-5.6-terra": {
+        displayName: "GPT-5.6 Terra",
+        description: "Balanced agentic coding model for everyday work.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: GPT_5_6_ULTRA_EFFORTS
+      },
+      "gpt-5.6-luna": {
+        displayName: "GPT-5.6 Luna",
+        description: "Fast and affordable agentic coding model.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: GPT_5_6_EFFORTS
+      },
+      "gpt-5.5": {
+        displayName: "GPT-5.5",
+        description: "Frontier model for complex coding, research, and real-world work.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
+      },
+      "gpt-5.4": {
+        displayName: "GPT-5.4",
+        description: "Strong model for everyday coding.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
+      },
+      "gpt-5.4-mini": {
+        displayName: "GPT-5.4 Mini",
+        description: "Small, fast, and cost-efficient model for simpler coding tasks.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
+      },
+      "gpt-5.3-codex": {
+        displayName: "GPT-5.3 Codex",
+        description: "Codex-tuned agentic coding model.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
+      },
+      "gpt-5.2": {
+        displayName: "GPT-5.2",
+        description: "Earlier general-purpose Codex model.",
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: STANDARD_CODEX_EFFORTS
+      }
+    };
+    KIMI_REASONING_EFFORTS = ["low", "high", "max"];
+    KIMI_MODEL_INFO = {
+      "kimi-k3": {
+        displayName: "Kimi K3",
+        description: "Moonshot flagship \u2014 1M context, reasoning on by default, vision and tools.",
+        supportedReasoningEfforts: KIMI_REASONING_EFFORTS,
+        defaultReasoningEffort: "max",
+        aliases: ["k3", "kimi k3", "moonshot-kimi-k3", "moonshotai/kimi-k3"]
+      },
+      "kimi-k2.6": {
+        displayName: "Kimi K2.6",
+        description: "Smaller, cheaper Kimi \u2014 256K context, multimodal.",
+        // No supportedReasoningEfforts: Moonshot lists `reasoning_effort` as "Not
+        // supported" for K2.6, which instead takes a `thinking: {type}` object. ZTC
+        // does not send that object yet, so the picker must not offer a depth control
+        // here — the effort ladder and the thinking switch are different contracts.
+        aliases: ["k2.6", "kimi k2.6", "moonshotai/kimi-k2.6"]
+      },
+      "kimi-for-coding": {
+        displayName: "Kimi K2.7 Coding",
+        description: "Kimi Code subscription coding model \u2014 256K context, always-thinking, vision and tools.",
+        // No supportedReasoningEfforts: the subscription coding models are
+        // always-thinking with no documented effort ladder, so /effort stays
+        // rejected rather than forwarding a value the API silently ignores.
+        aliases: ["k2.7", "kimi k2.7", "kimi-k2.7-coding"]
+      },
+      "kimi-for-coding-highspeed": {
+        displayName: "Kimi K2.7 Coding Highspeed",
+        description: "High-speed variant of the Kimi Code subscription coding model \u2014 256K context.",
+        aliases: ["k2.7-highspeed", "kimi-for-coding-fast"]
       }
-      if (textParts.length > 0 || mediaParts.length > 0) {
-        if (mediaParts.length > 0) {
-          const parts = textParts.map((t) => ({ type: "text", text: t }));
-          parts.push(...mediaParts);
-          out.push({ role: "user", content: parts });
-        } else {
-          out.push({ role: "user", content: textParts.join("\n") });
-        }
+    };
+    KIMI_ALIAS_TO_ID = /* @__PURE__ */ new Map();
+    for (const id of Object.keys(KIMI_MODEL_INFO)) {
+      KIMI_ALIAS_TO_ID.set(id, id);
+      for (const alias of KIMI_MODEL_INFO[id].aliases) {
+        KIMI_ALIAS_TO_ID.set(alias.toLowerCase(), id);
       }
-      continue;
-    }
-    if (mediaParts.length > 0) {
-      const parts = textParts.map((t) => ({ type: "text", text: t }));
-      parts.push(...mediaParts);
-      out.push(withReasoning({ role: msg.role, content: parts }, msg));
-    } else {
-      out.push(withReasoning({ role: msg.role, content: textParts.join("\n") }, msg));
-    }
-  }
-  return out;
-}
-function buildOpenAIToolDefs(tools) {
-  return tools.map((t) => ({
-    type: "function",
-    function: {
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters
     }
-  }));
-}
-var init_openai_format = __esm({
-  "src/agent/backends/openai_format.ts"() {
-    "use strict";
+    CLAUDE_REASONING_EFFORTS = [
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+      "max"
+    ];
   }
 });
 
@@ -961,6 +1349,7 @@ var OpenAICompatibleApiError, OpenAICompatibleBackend;
 var init_openai_compatible = __esm({
   "src/agent/backends/openai_compatible.ts"() {
     "use strict";
+    init_model_contracts();
     init_request_metrics();
     init_sse();
     init_token_usage();
@@ -984,6 +1373,7 @@ var init_openai_compatible = __esm({
       apiPath;
       headers;
       extraBody;
+      provider;
       requestBodyExtras;
       authTokenProvider;
       constructor(config) {
@@ -992,6 +1382,7 @@ var init_openai_compatible = __esm({
         this.apiPath = config.apiPath || "/chat/completions";
         this.headers = config.headers || {};
         this.extraBody = config.extraBody || {};
+        this.provider = config.provider;
         this.requestBodyExtras = config.requestBodyExtras;
         this.authTokenProvider = config.authTokenProvider;
       }
@@ -999,22 +1390,29 @@ var init_openai_compatible = __esm({
        *  and generateStream(). generateStream() adds `stream`/`stream_options`. */
       async buildCall(request) {
         const url = `${this.baseUrl}${this.apiPath}`;
-        const useCompletionTokens = /^o\d/.test(request.model) || /^gpt-[56]/.test(request.model) || isKimiModel(request.model);
+        const useCompletionTokens = this.provider === "fireworks" ? false : /^o\d/.test(request.model) || /^gpt-[56]/.test(request.model) || isKimiModel(request.model);
         const isGpt4o = request.model.startsWith("gpt-4o");
-        const limit = isGpt4o ? 16384 : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity;
+        const reviewedLimit = this.provider ? modelContract(this.provider, request.model)?.maxOutputTokens?.max : void 0;
+        const limit = reviewedLimit ?? (isGpt4o ? 16384 : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity);
         const effectiveMaxTokens = request.maxTokens === void 0 ? void 0 : Math.min(request.maxTokens, limit);
         const tokenParam = effectiveMaxTokens === void 0 ? {} : useCompletionTokens ? { max_completion_tokens: effectiveMaxTokens } : { max_tokens: effectiveMaxTokens };
-        const isGpt6Model = /^gpt-6-(?:sol|luna)$/i.test(request.model);
-        const reasoningEffort = (request.model === "gpt-5.6-sol" || isGpt6Model) && request.tools.length > 0 ? "none" : isGpt6Model ? request.codexEffort : void 0;
+        const policyProvider = this.provider ?? "openai";
+        const chatEfforts = modelContract(policyProvider, request.model)?.chatToolReasoningEfforts;
+        const toolRestricted = request.tools.length > 0 && chatEfforts !== void 0;
+        if (toolRestricted && request.codexEffort !== void 0 && !chatEfforts.includes(request.codexEffort)) {
+          throw new Error("Use Responses for graded reasoning with tools on this model. Chat Completions supports effort none.");
+        }
+        const reasoningEffort = toolRestricted ? request.codexEffort ?? "none" : request.codexEffort;
         const body = {
           ...this.extraBody,
+          ...reasoningRequestParams(policyProvider, request.model, reasoningEffort),
           ...this.requestBodyExtras?.(request) ?? {},
-          model: request.model,
+          model: this.provider === "fireworks" ? fireworksRequestModel(request.model) : request.model,
           ...tokenParam,
           // Chat Completions accepts GPT-6 Sol/Luna function tools only with
           // reasoning disabled. The direct OpenAI backend uses Responses instead;
           // keep this rule for explicitly configured compatible endpoints.
-          ...reasoningEffort ? { reasoning_effort: reasoningEffort } : {},
+          ...toolRestricted ? { reasoning_effort: reasoningEffort } : {},
           messages: buildOpenAIMessages(request),
           ...request.tools.length > 0 ? { tools: buildOpenAIToolDefs(request.tools) } : {}
         };
@@ -1712,12 +2110,13 @@ var init_openai_responses = __esm({
 
 // src/agent/backends/openai.ts
 function needsResponsesAPI(model) {
-  return RESPONSES_API_PATTERNS.some((p) => p.test(model));
+  return modelContract("openai", model)?.chatToolReasoningEfforts !== void 0 || RESPONSES_API_PATTERNS.some((p) => p.test(model));
 }
 var RESPONSES_API_PATTERNS, OpenAIBackend;
 var init_openai = __esm({
   "src/agent/backends/openai.ts"() {
     "use strict";
+    init_model_contracts();
     init_openai_compatible();
     init_openai_responses();
     RESPONSES_API_PATTERNS = [
@@ -1733,7 +2132,8 @@ var init_openai = __esm({
         this.chatBackend = new OpenAICompatibleBackend({
           apiKey: config.apiKey,
           baseUrl,
-          apiPath: "/chat/completions"
+          apiPath: "/chat/completions",
+          provider: "openai"
         });
         this.responsesBackend = new OpenAIResponsesBackend({
           apiKey: config.apiKey,
@@ -1787,6 +2187,7 @@ var GeminiBackend;
 var init_gemini = __esm({
   "src/agent/backends/gemini.ts"() {
     "use strict";
+    init_model_contracts();
     init_base();
     GeminiBackend = class extends BaseBackend {
       apiKey;
@@ -1817,6 +2218,7 @@ var init_gemini = __esm({
           });
         };
         const body = {
+          ...reasoningRequestParams("gemini", request.model, request.codexEffort),
           systemInstruction: { parts: [{ text: request.system }] },
           contents: request.messages.map((m) => ({
             role: m.role === "assistant" ? "model" : "user",
@@ -1901,43 +2303,6 @@ var init_kimi = __esm({
   }
 });
 
-// src/config/profiles.ts
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { existsSync } from "node:fs";
-function builtinProfileEmulation(name) {
-  const builtin = BUILTIN_CONFIG_PROFILES.find((profile) => profile === name);
-  if (!builtin) return void 0;
-  const root = process.env.ZTC_CONFIG_DIR || join(homedir(), ".ztc");
-  return existsSync(join(root, "profiles", name)) ? void 0 : builtin;
-}
-function validateProfileName(name) {
-  if (name !== "default" && !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(name)) {
-    throw new Error("Profile name must be 1\u201364 characters: letters, numbers, dots, underscores, or hyphens; it must start with a letter or number.");
-  }
-  if (name === "." || name === "..") {
-    throw new Error("Profile name cannot be . or ..");
-  }
-  return name;
-}
-function activeProfile() {
-  return validateProfileName(process.env.ZTC_PROFILE || "default");
-}
-function profileConfigDir(profile = activeProfile()) {
-  const root = process.env.ZTC_CONFIG_DIR || join(homedir(), ".ztc");
-  const name = validateProfileName(profile);
-  if (name === "default") return root;
-  const namedDir = join(root, "profiles", name);
-  return builtinProfileEmulation(name) ? root : namedDir;
-}
-var BUILTIN_CONFIG_PROFILES;
-var init_profiles = __esm({
-  "src/config/profiles.ts"() {
-    "use strict";
-    BUILTIN_CONFIG_PROFILES = ["ztc", "ztc-coder", "ztc-datascience", "scientist"];
-  }
-});
-
 // src/agent/backends/rate_limit.ts
 function parseResetAt(opts) {
   const { now } = opts;
@@ -1990,13 +2355,13 @@ var init_rate_limit = __esm({
 });
 
 // src/agent/backends/claude_code_auth.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { homedir as homedir2, platform, userInfo } from "os";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 import { execFileSync } from "child_process";
 function getClaudeCodeCredentialsFilePath() {
-  const configDir2 = process.env.CLAUDE_CONFIG_DIR || join2(homedir2(), ".claude");
-  return join2(configDir2, ".credentials.json");
+  const configDir2 = process.env.CLAUDE_CONFIG_DIR || join3(homedir2(), ".claude");
+  return join3(configDir2, ".credentials.json");
 }
 function parseClaudeCodeCredentials(raw) {
   const data = JSON.parse(raw);
@@ -2078,7 +2443,7 @@ var init_claude_code_auth = __esm({
           return;
         }
         if (existsSync2(this.credentialsFilePath)) {
-          this.credentials = parseClaudeCodeCredentials(readFileSync(this.credentialsFilePath, "utf8"));
+          this.credentials = parseClaudeCodeCredentials(readFileSync2(this.credentialsFilePath, "utf8"));
           return;
         }
         const keychainRaw = this.keychainReader ? this.keychainReader() : readMacOSKeychainCredentials(this.keychainAccount);
@@ -2150,9 +2515,9 @@ var init_claude_code_auth = __esm({
 
 // src/agent/backends/codex_auth.ts
 import { randomBytes } from "crypto";
-import { chmodSync, readFileSync as readFileSync2, renameSync, unlinkSync, writeFileSync } from "fs";
+import { chmodSync, readFileSync as readFileSync3, renameSync, unlinkSync, writeFileSync } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 function resolveClientId(fileClientId) {
   return process.env.CODEX_OAUTH_CLIENT_ID || fileClientId || DEFAULT_CODEX_CLIENT_ID;
 }
@@ -2235,7 +2600,7 @@ function hasUsableCodexAuth(authFilePath = CODEX_AUTH_FILE_PATH) {
 }
 function _probeAuthFile(path) {
   try {
-    parseCodexAuthFile(readFileSync2(path, "utf-8"));
+    parseCodexAuthFile(readFileSync3(path, "utf-8"));
     return true;
   } catch {
     return false;
@@ -2248,7 +2613,7 @@ var init_codex_auth = __esm({
     init_openai_responses();
     init_rate_limit();
     init_provider_ids();
-    CODEX_AUTH_FILE_PATH = join3(homedir3(), ".codex", "auth.json");
+    CODEX_AUTH_FILE_PATH = join4(homedir3(), ".codex", "auth.json");
     CODEX_AUTH_SENTINEL = "codex-subscription-auth";
     OAUTH_TOKEN_URL = "https://auth.openai.com/oauth/token";
     DEFAULT_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
@@ -2271,7 +2636,7 @@ var init_codex_auth = __esm({
       loadCredentialsSync() {
         let raw;
         try {
-          raw = readFileSync2(this.authFilePath, "utf-8");
+          raw = readFileSync3(this.authFilePath, "utf-8");
         } catch {
           throw new Error(
             "Codex auth not found. Run 'codex' to authenticate with ChatGPT first."
@@ -2591,7 +2956,7 @@ var init_codex_auth = __esm({
 
 // src/agent/backends/codex_app_server.ts
 import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 function buildCodexAppServerEnv(codexHome, base = process.env) {
   const env = { ...base };
   if (codexHome) env.CODEX_HOME = codexHome;
@@ -2607,7 +2972,7 @@ function buildCodexAppServerEnv(codexHome, base = process.env) {
   return env;
 }
 function sha1(value) {
-  return createHash("sha1").update(value).digest("hex");
+  return createHash2("sha1").update(value).digest("hex");
 }
 function nonEmptyId(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : null;
@@ -3826,7 +4191,7 @@ var init_codex_app_server = __esm({
 
 // src/utils/debug_log.ts
 import { appendFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 import { tmpdir } from "os";
 function debugLog(message) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -3856,7 +4221,7 @@ var init_debug_log = __esm({
   "src/utils/debug_log.ts"() {
     "use strict";
     DEBUG_ENABLED = process.env.ZTC_DEBUG === "1";
-    DEBUG_LOG_FILE = join4(tmpdir(), `ztc-debug-${process.pid}.log`);
+    DEBUG_LOG_FILE = join5(tmpdir(), `ztc-debug-${process.pid}.log`);
     if (DEBUG_ENABLED) {
       writeFileSync2(DEBUG_LOG_FILE, `[${(/* @__PURE__ */ new Date()).toISOString()}] ZTC starting, PID=${process.pid}
 `);
@@ -3869,14 +4234,14 @@ var init_debug_log = __esm({
 });
 
 // src/agent/backends/kimi_code_auth.ts
-import { mkdirSync, chmodSync as chmodSync2, readFileSync as readFileSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
+import { mkdirSync, chmodSync as chmodSync2, readFileSync as readFileSync4, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { dirname, join as join5 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 function kimiCodeHome() {
-  return process.env.KIMI_CODE_HOME || join5(homedir4(), ".kimi-code");
+  return process.env.KIMI_CODE_HOME || join6(homedir4(), ".kimi-code");
 }
 function defaultKimiCodeAuthFilePath() {
-  return join5(kimiCodeHome(), "credentials", "kimi-code.json");
+  return join6(kimiCodeHome(), "credentials", "kimi-code.json");
 }
 function kimiCodeOAuthHost() {
   return (process.env.KIMI_CODE_OAUTH_HOST || process.env.KIMI_OAUTH_HOST || DEFAULT_OAUTH_HOST).replace(/\/+$/, "");
@@ -3905,14 +4270,14 @@ function parseKimiCodeAuthFile(raw) {
 }
 function hasUsableKimiCodeAuth(authFilePath = defaultKimiCodeAuthFilePath()) {
   try {
-    parseKimiCodeAuthFile(readFileSync3(authFilePath, "utf-8"));
+    parseKimiCodeAuthFile(readFileSync4(authFilePath, "utf-8"));
     return true;
   } catch {
     return false;
   }
 }
 function writeKimiCodeCredentials(authFilePath, creds) {
-  const dir = dirname(authFilePath);
+  const dir = dirname2(authFilePath);
   mkdirSync(dir, { recursive: true, mode: 448 });
   try {
     chmodSync2(dir, 448);
@@ -3938,7 +4303,7 @@ function writeKimiCodeCredentials(authFilePath, creds) {
   try {
     renameSync2(tmp, authFilePath);
   } catch {
-    writeFileSync3(authFilePath, readFileSync3(tmp, "utf-8"), { encoding: "utf-8", mode: 384 });
+    writeFileSync3(authFilePath, readFileSync4(tmp, "utf-8"), { encoding: "utf-8", mode: 384 });
   }
   chmodSync2(authFilePath, 384);
 }
@@ -4055,7 +4420,7 @@ var init_kimi_code_auth = __esm({
       loadCredentialsSync() {
         let raw;
         try {
-          raw = readFileSync3(this.authFilePath, "utf-8");
+          raw = readFileSync4(this.authFilePath, "utf-8");
         } catch {
           throw new Error(
             "Kimi Code auth not found. Run 'kimi' and use /login, or sign in via /accounts (kimi_code provider)."
@@ -4131,7 +4496,7 @@ var init_kimi_code_auth = __esm({
         const detail = typeof data.error_description === "string" ? data.error_description : typeof data.error === "string" ? data.error : `HTTP ${status}`;
         if (status === 401 || status === 403 || data.error === "invalid_grant") {
           try {
-            const onDisk = parseKimiCodeAuthFile(readFileSync3(this.authFilePath, "utf-8"));
+            const onDisk = parseKimiCodeAuthFile(readFileSync4(this.authFilePath, "utf-8"));
             if (onDisk.refreshToken !== refreshToken && !this.isExpiringSoon(onDisk.expiresAt)) {
               this.credentials = onDisk;
               return;
@@ -4194,7 +4559,7 @@ var init_kimi_code_auth = __esm({
 
 // src/agent/backends/account_pool.ts
 import { homedir as homedir5 } from "node:os";
-import { basename, dirname as dirname2, join as join6, resolve } from "node:path";
+import { basename, dirname as dirname3, join as join7, resolve } from "node:path";
 function canonicalAccountProvider(provider) {
   const norm = normalizeProviderId(provider);
   switch (norm) {
@@ -4247,7 +4612,7 @@ function probeAccountIsolated(account) {
   switch (source.kind) {
     case "claude_config_dir":
       return hasUsableClaudeCodeAuth({
-        credentialsFilePath: join6(source.path, ".credentials.json"),
+        credentialsFilePath: join7(source.path, ".credentials.json"),
         envToken: null,
         keychainReader: () => void 0
       });
@@ -4258,7 +4623,7 @@ function probeAccountIsolated(account) {
         keychainReader: () => void 0
       });
     case "codex_home":
-      return hasUsableCodexAuth(join6(source.path, "auth.json"));
+      return hasUsableCodexAuth(join7(source.path, "auth.json"));
     case "codex_auth_file":
       return hasUsableCodexAuth(source.path);
     case "kimi_creds_file":
@@ -4276,7 +4641,7 @@ var init_account_pool = __esm({
     init_kimi_code_auth();
     init_debug_log();
     init_profiles();
-    ACCOUNTS_ROOT = join6(homedir5(), ".ztc", "accounts");
+    ACCOUNTS_ROOT = join7(homedir5(), ".ztc", "accounts");
     DEFAULT_ACCOUNT_ROTATION = {
       enabled: false,
       mode: "failover",
@@ -4334,7 +4699,7 @@ var init_trace = __esm({
 
 // src/agent/backends/claude_cli.ts
 import { spawn as spawn2, spawnSync } from "child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 function endStdinToleratingBrokenPipe(child, prompt) {
   const stdin = child.stdin;
   if (!stdin) return;
@@ -4699,7 +5064,7 @@ ${detail}` : ""}`,
         const call = extractToolCall(text);
         if (!call) return resp;
         return {
-          content: [{ type: "tool_use", id: `cli_${randomUUID2()}`, name: call.name, input: call.input }],
+          content: [{ type: "tool_use", id: `cli_${randomUUID3()}`, name: call.name, input: call.input }],
           stopReason: "tool_use",
           usage: resp.usage
         };
@@ -4832,7 +5197,7 @@ ${detail}` : ""}`, "claude_cli_exit", { exitCode: code ?? void 0, stderr: detail
           if (call) {
             const open = fullText.indexOf(TOOL_CALL_OPEN);
             if (open > emittedLen) push({ type: "text_delta", text: fullText.slice(emittedLen, open) });
-            const id = `cli_${randomUUID2()}`;
+            const id = `cli_${randomUUID3()}`;
             push({ type: "tool_use_start", id, name: call.name });
             push({ type: "tool_use_delta", id, input_json: JSON.stringify(call.input) });
             push({ type: "tool_use_end", id });
@@ -4878,14 +5243,16 @@ var init_fireworks = __esm({
 });
 
 // src/config/defaults.ts
-function resolveCodexEffort(config, provider, model) {
+function resolveCodexEffort(config, provider, model, contract = config.authMode === "zrouter" || provider === "openai_compatible" ? "chat_tools" : "native_api") {
   const candidates = [
     model ? config.codexEffortByModel?.[model] : void 0,
     provider ? config.codexEffortByProvider?.[provider] : void 0,
     config.codexEffort
   ];
   for (const candidate of candidates) {
-    if (candidate && isCodexReasoningEffortSupported(provider, model, candidate)) return candidate;
+    if (!candidate) continue;
+    const supported = typeof contract === "string" ? isCodexReasoningEffortSupported(provider, model, candidate, contract) : contract.reasoning?.choices.includes(candidate);
+    if (candidate && supported) return candidate;
   }
   return void 0;
 }
@@ -4984,6 +5351,8 @@ function getDefaultApiKeyForProvider(provider) {
     case "modal":
       return void 0;
     // Modal credentials belong to the Router platform.
+    case "fireworks":
+      return process.env.FIREWORKS_API_KEY;
     default:
       return process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY || process.env.KIMI_API_KEY || process.env.MOONSHOT_API_KEY || process.env.OPENAI_COMPAT_API_KEY || process.env.INCEPTION_API_KEY;
   }
@@ -5078,17 +5447,17 @@ var init_atomic_write = __esm({
 });
 
 // src/config/repo_config.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname3, join as join7 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
 function repoConfigPath(cwd) {
-  return join7(cwd, REPO_CONFIG_RELATIVE_PATH);
+  return join8(cwd, REPO_CONFIG_RELATIVE_PATH);
 }
 function readRepoConfig(cwd) {
   if (isExplicitExtensionDiscovery()) return null;
   const path = repoConfigPath(cwd);
   if (!existsSync3(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync4(path, "utf8"));
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
     return parsed && typeof parsed === "object" ? parsed : null;
   } catch {
     return null;
@@ -5107,19 +5476,19 @@ var init_repo_config = __esm({
     "use strict";
     init_extension_discovery();
     init_atomic_write();
-    REPO_CONFIG_RELATIVE_PATH = join7(".ztc", "config.json");
+    REPO_CONFIG_RELATIVE_PATH = join8(".ztc", "config.json");
   }
 });
 
 // src/utils/version.ts
-import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { readFileSync as readFileSync6 } from "fs";
+import { dirname as dirname5, resolve as resolve3 } from "path";
 import { fileURLToPath } from "url";
 function getVersion() {
   try {
-    const here = dirname4(fileURLToPath(import.meta.url));
+    const here = dirname5(fileURLToPath(import.meta.url));
     const pkgPath = resolve3(here, "../../package.json");
-    const raw = readFileSync5(pkgPath, "utf-8");
+    const raw = readFileSync6(pkgPath, "utf-8");
     const parsed = JSON.parse(raw);
     return parsed.version || "0.0.0";
   } catch {
@@ -5134,12 +5503,12 @@ var init_version = __esm({
 
 // src/router_auth.ts
 import { chmod, mkdir, readFile, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function credentialDirectory() {
   return profileConfigDir();
 }
 function credentialPath() {
-  return join8(credentialDirectory(), "router-auth.json");
+  return join9(credentialDirectory(), "router-auth.json");
 }
 function routerOrigin(value) {
   const url = new URL(value);
@@ -5149,7 +5518,7 @@ function routerOrigin(value) {
   }
   return url.origin;
 }
-function record2(value) {
+function record3(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Router returned an invalid response.");
   }
@@ -5175,10 +5544,10 @@ async function loadRouterCredentials() {
     throw error;
   }
   try {
-    const saved = record2(JSON.parse(data));
+    const saved = record3(JSON.parse(data));
     let previousConfig;
     if (saved.previousConfig !== void 0) {
-      const previous = record2(saved.previousConfig);
+      const previous = record3(saved.previousConfig);
       if (previous.authMode !== void 0 && !["auto", "direct", "zrouter"].includes(String(previous.authMode))) {
         throw new Error("Invalid previous authentication mode.");
       }
@@ -5251,7 +5620,9 @@ function estimateTokens(text) {
   if (!text) return 0;
   return Math.ceil(text.length / 4);
 }
-function getContextWindowSize(model) {
+function getContextWindowSize(model, windowOverride) {
+  if (windowOverride === null) return 0;
+  if (typeof windowOverride === "number" && windowOverride > 0) return windowOverride;
   if (MODEL_CONTEXT_WINDOWS[model]) {
     return MODEL_CONTEXT_WINDOWS[model];
   }
@@ -5413,7 +5784,7 @@ var init_loop_policy = __esm({
 });
 
 // src/agent/tool_compression.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 function isReadToolName(name) {
   return READ_TOOL_NAMES.has(name);
 }
@@ -5427,7 +5798,7 @@ function extractSourcePath(toolName, args) {
   return null;
 }
 function hashToolResultBody(content) {
-  return createHash2("sha256").update(stripRepeatGuard(content), "utf-8").digest("hex").slice(0, 16);
+  return createHash3("sha256").update(stripRepeatGuard(content), "utf-8").digest("hex").slice(0, 16);
 }
 function compressionMarker(mode, toolUseId, savedTokensApprox) {
   return {
@@ -5694,8 +6065,8 @@ var init_deferred = __esm({
 });
 
 // src/agent/tool_response_store.ts
-import { mkdir as mkdir2, readFile as readFile2, readdir } from "fs/promises";
-import { join as join9 } from "path";
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2 } from "fs/promises";
+import { join as join10 } from "path";
 function formatOffloadPlaceholder(meta) {
   const partialNote = meta.partial ? ", partial=true" : "";
   const base = `[tool result offloaded \u2014 tool_use_id=${meta.tool_use_id}, tool=${meta.tool_name}, size_tokens\u2248${meta.size_tokens}, turn=${meta.turn}${partialNote}. Call recall_tool_response with tool_use_id to retrieve full content.]`;
@@ -5827,9 +6198,10 @@ var init_tool_response_store = __esm({
        * fraction of the active model's context window so a small-context model
        * (gpt-4 8k → 2k effective) doesn't get crushed by a Claude-tuned default.
        */
-      effectiveBudget(model) {
+      effectiveBudget(model, windowOverride) {
         const configured = this.config.configuredInlineBudgetTokens;
-        const window = getContextWindowSize(model);
+        const window = getContextWindowSize(model, windowOverride);
+        if (window === 0) return configured;
         return Math.min(configured, Math.floor(window * PER_MODEL_BUDGET_FRACTION));
       }
       cacheBudgetTokens() {
@@ -5854,7 +6226,7 @@ var init_tool_response_store = __esm({
         await mkdir2(dir, { recursive: true });
         let files;
         try {
-          files = await readdir(dir);
+          files = await readdir2(dir);
         } catch {
           return;
         }
@@ -5862,7 +6234,7 @@ var init_tool_response_store = __esm({
         const records = await Promise.all(
           jsonFiles.map(async (f) => {
             try {
-              const raw = await readFile2(join9(dir, f), "utf-8");
+              const raw = await readFile2(join10(dir, f), "utf-8");
               const rec = JSON.parse(raw);
               return rec?.meta?.tool_use_id ? rec.meta : null;
             } catch {
@@ -5931,7 +6303,7 @@ var init_tool_response_store = __esm({
         this.renderMemo.delete(toolUseId);
         this.cacheContent(toolUseId, content);
         if (this.dir) {
-          const path = join9(this.dir, `${toolUseId}.json`);
+          const path = join10(this.dir, `${toolUseId}.json`);
           const write = writeFileAtomic(path, JSON.stringify({ meta, content })).catch((err) => {
             const message = err instanceof Error ? err.message : String(err);
             debugLog2(`[ToolResponseStore] atomic write failed for ${toolUseId}: ${message}`);
@@ -5949,7 +6321,7 @@ var init_tool_response_store = __esm({
         if (cached2 !== void 0) return cached2;
         if (!this.dir) return null;
         try {
-          const raw = await readFile2(join9(this.dir, `${toolUseId}.json`), "utf-8");
+          const raw = await readFile2(join10(this.dir, `${toolUseId}.json`), "utf-8");
           const rec = JSON.parse(raw);
           if (rec && typeof rec.content === "string") {
             if (rec.meta && !this.meta.has(toolUseId)) {
@@ -6032,8 +6404,8 @@ var init_tool_response_store = __esm({
       renderInline(e) {
         if (!this.compressionActive()) return e.content;
         if (e.meta.recalledAtTurn !== void 0) return e.content;
-        const memo = this.renderMemo.get(e.id);
-        if (memo) return memo.text;
+        const memo2 = this.renderMemo.get(e.id);
+        if (memo2) return memo2.text;
         const mode = this.config.toolCompression === "aggressive" ? "aggressive" : "safe";
         const stub = this.duplicateStubFor(e.meta);
         const text = stub ?? compressToolResult({
@@ -6060,8 +6432,8 @@ var init_tool_response_store = __esm({
       }
       /** Cost of an inline render: the memoized token count when one was prepared. */
       inlineCost(e, rendered) {
-        const memo = this.renderMemo.get(e.id);
-        if (memo && memo.text === rendered) return memo.tokens;
+        const memo2 = this.renderMemo.get(e.id);
+        if (memo2 && memo2.text === rendered) return memo2.tokens;
         return e.meta.size_tokens;
       }
       /**
@@ -6620,9 +6992,9 @@ var init_status_line_config = __esm({
 });
 
 // src/config.ts
-import { join as join10 } from "path";
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, chmod as chmod2, unlink as unlink3, rename as rename3, realpath } from "fs/promises";
-import { randomUUID as randomUUID3 } from "crypto";
+import { dirname as dirname6, join as join11 } from "path";
+import { stat, readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, chmod as chmod2, rm, unlink as unlink3, rename as rename3, realpath } from "fs/promises";
+import { randomUUID as randomUUID4 } from "crypto";
 function isLocalEndpoint(url) {
   try {
     const parsed = new URL(url);
@@ -6746,6 +7118,20 @@ function build_default_config() {
 function normalizedOrigin(value) {
   return value?.trim().replace(/\/+$/, "") || void 0;
 }
+function routerOriginFromEnvironment() {
+  if (process.env.ZERG_PROXY_URL) return process.env.ZERG_PROXY_URL;
+  if (process.env.ZERG_ROUTER_BASE_URL) return normalizedOrigin(process.env.ZERG_ROUTER_BASE_URL);
+  const tiers = {
+    local: "http://host.docker.internal:8000/api/zrouter",
+    dev: "https://api-dev.zergai.com/api/zrouter",
+    development: "https://api-dev.zergai.com/api/zrouter",
+    prod: "https://api.zergai.com/api/zrouter",
+    production: "https://api.zergai.com/api/zrouter",
+    main: "https://api.zergai.com/api/zrouter"
+  };
+  const tier = process.env.ZERG_DEPLOY_TIER || "";
+  return Object.hasOwn(tiers, tier) ? tiers[tier] : void 0;
+}
 function savedRouteIsUsable(saved) {
   if (!saved.provider) return false;
   const provider = normalizeProviderId(saved.provider);
@@ -6761,12 +7147,12 @@ function savedRouteIsUsable(saved) {
 function migrateSettingsDefaults(saved) {
   const defaults = build_default_config();
   const migrated = { ...saved, settingsDefaultsVersion: SETTINGS_DEFAULTS_VERSION };
-  const record3 = migrated;
+  const record4 = migrated;
   const fresh = defaults;
   const adopted = savedRouteIsUsable(saved) ? ADOPTED_DEFAULT_KEYS : [...ADOPTED_DEFAULT_KEYS, ...ROUTING_SETTING_KEYS];
   for (const key of adopted) {
-    if (fresh[key] === void 0) delete record3[key];
-    else record3[key] = fresh[key];
+    if (fresh[key] === void 0) delete record4[key];
+    else record4[key] = fresh[key];
   }
   if (saved.apiKey !== void 0) {
     const oldProvider = saved.provider || inferDefaultProvider();
@@ -6791,7 +7177,7 @@ async function writeMigratedSettings(path, settings, original) {
   } catch (error) {
     if (error.code !== "EEXIST") throw error;
   }
-  const temporary = `${target}.${process.pid}.${randomUUID3()}.tmp`;
+  const temporary = `${target}.${process.pid}.${randomUUID4()}.tmp`;
   try {
     await writeFile3(temporary, JSON.stringify(settings, null, 2), { encoding: "utf-8", mode: 384, flag: "wx" });
     await rename3(temporary, target);
@@ -6807,12 +7193,15 @@ function configDir() {
   return profileConfigDir();
 }
 function configFile() {
-  return join10(configDir(), "config.json");
+  return join11(configDir(), "config.json");
 }
 var API_ENDPOINTS, DEFAULT_TOOL_PERMISSIONS, DEFAULT_PERMISSION_PROFILES, DEFAULT_INTENTS, DEFAULT_SANDBOX, DEFAULT_CONTEXT_PROGRESS_BAR, DEFAULT_WORKFLOWS, SETTINGS_DEFAULTS_VERSION, PERSONAL_DEFAULT_PROVIDER, PERSONAL_DEFAULT_MODEL, PERSONAL_DEFAULT_PROXY_URL, ROUTE_CREDENTIAL_ENV, ADOPTED_DEFAULT_KEYS, ROUTING_SETTING_KEYS, SUPERUSER_STATUS_TIMEOUT_MS, ConfigStore, configStore;
 var init_config = __esm({
   "src/config.ts"() {
     "use strict";
+    init_model_contracts();
+    init_provider_ids();
+    init_router_catalog();
     init_profiles();
     init_account_pool();
     init_account_events();
@@ -6960,6 +7349,12 @@ var init_config = __esm({
       // The legacy slot also carries runtime defaults. Only a configured key may
       // be migrated into apiKeys or written to disk.
       legacyApiKeyFromEnvironment = true;
+      /**
+       * Whether the routing in `this.config` came from a saved file or an explicit
+       * choice, rather than the built-in default. A config-less process that never
+       * picked a route must not hard-fail on the preset Router route it inherited.
+       */
+      routingIsConfigured = false;
       routerCredentials = null;
       routerCredentialsError = null;
       routerFallbackWarning = null;
@@ -6967,6 +7362,7 @@ var init_config = __esm({
       configScope = "global";
       /** Session-local overrides. Never persisted to config.json. */
       sessionOverrides = {};
+      restoredSessionSelection = false;
       /** CLI-only overrides. Never persisted to config.json. */
       cliOverrides = {};
       /**
@@ -7020,15 +7416,9 @@ var init_config = __esm({
           else if (tier === "dev" || tier === "development") this.config.apiEnvironment = "development";
           else if (tier === "prod" || tier === "production" || tier === "main") this.config.apiEnvironment = "production";
         }
-        if (process.env.ZERG_PROXY_URL) {
-          this.config.zergProxyUrl = process.env.ZERG_PROXY_URL;
-        } else if (process.env.ZERG_ROUTER_BASE_URL) {
-          this.config.zergProxyUrl = process.env.ZERG_ROUTER_BASE_URL.replace(/\/+$/, "");
-        } else if (process.env.ZERG_DEPLOY_TIER) {
-          const tier = process.env.ZERG_DEPLOY_TIER;
-          if (tier === "local") this.config.zergProxyUrl = "http://host.docker.internal:8000/api/zrouter";
-          else if (tier === "dev" || tier === "development") this.config.zergProxyUrl = "https://api-dev.zergai.com/api/zrouter";
-          else if (tier === "prod" || tier === "production" || tier === "main") this.config.zergProxyUrl = "https://api.zergai.com/api/zrouter";
+        const originOverride = routerOriginFromEnvironment();
+        if (originOverride) {
+          this.config.zergProxyUrl = originOverride;
         } else if (!this.config.zergProxyUrl) {
           this.config.zergProxyUrl = this.routerCredentials?.origin || this.deriveZRouterUrl(this.getApiBaseUrl());
         }
@@ -7119,12 +7509,59 @@ var init_config = __esm({
         this.sessionOverrides = sessionOverrides;
         this.configScope = scope;
       }
+      /** Copy saved settings and Router credentials, then activate them transactionally.
+       * Account registrations retain their credential paths; account homes are not cloned.
+       */
+      async duplicateProfile(requestedName, source = activeProfile(), activate = () => {
+      }) {
+        const name = validateProfileName(requestedName.trim());
+        const from = validateProfileName(source);
+        if (name === "default" || builtinProfileEmulation(name)) {
+          throw new Error(`Cannot duplicate onto "${name}": it is a built-in profile sharing the default settings. Pick another name.`);
+        }
+        if (name === from || (await listConfigProfiles()).includes(name)) {
+          throw new Error(`Config profile "${name}" already exists. Pick another name.`);
+        }
+        const sourceDir = profileConfigDir(from);
+        const emulation = builtinProfileEmulation(from);
+        if (from !== "default" && !emulation && !(await stat(sourceDir)).isDirectory()) {
+          throw new Error(`Config profile "${from}" does not exist.`);
+        }
+        let saved = {};
+        try {
+          const parsed = JSON.parse(await readFile3(join11(sourceDir, "config.json"), "utf8"));
+          if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            throw new Error(`Invalid config profile "${from}": expected an object.`);
+          }
+          saved = parsed;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+        if (emulation) saved.emulationId = emulation;
+        const destination = profileConfigDir(name);
+        await mkdir3(dirname6(destination), { recursive: true, mode: 448 });
+        await mkdir3(destination, { mode: 448 });
+        try {
+          await writeFile3(join11(destination, "config.json"), JSON.stringify(saved, null, 2), { flag: "wx", mode: 384 });
+          try {
+            const auth = await readFile3(join11(sourceDir, "router-auth.json"));
+            await writeFile3(join11(destination, "router-auth.json"), auth, { flag: "wx", mode: 384 });
+          } catch (error) {
+            if (error.code !== "ENOENT") throw error;
+          }
+          await this.switchProfile(name, activate);
+        } catch (error) {
+          await rm(destination, { recursive: true, force: true });
+          throw error;
+        }
+        return name;
+      }
       /** Load a profile in this process; restore the old view if runtime activation fails. */
       async switchProfile(name, activate) {
         const next = validateProfileName(name);
         if (next === activeProfile()) return;
         const sameConfigDirectory = profileConfigDir(next) === profileConfigDir();
-        const target = join10(profileConfigDir(next), "config.json");
+        const target = join11(profileConfigDir(next), "config.json");
         try {
           const saved = JSON.parse(await readFile3(target, "utf-8"));
           if (!saved || typeof saved !== "object" || Array.isArray(saved)) {
@@ -7145,6 +7582,7 @@ var init_config = __esm({
           routerCredentialsError: this.routerCredentialsError,
           routerFallbackWarning: this.routerFallbackWarning,
           sessionOverrides: this.sessionOverrides,
+          restoredSessionSelection: this.restoredSessionSelection,
           cliOverrides: this.cliOverrides,
           runtimeActivePerProvider: this.runtimeActivePerProvider,
           configScope: this.configScope
@@ -7155,6 +7593,7 @@ var init_config = __esm({
           this.sessionOverrides = remainingOverrides;
         } else {
           this.sessionOverrides = {};
+          this.restoredSessionSelection = false;
           this.cliOverrides = {};
           this.runtimeActivePerProvider = {};
           this.configScope = "global";
@@ -7193,7 +7632,7 @@ var init_config = __esm({
       }
       /** Clear the active profile's saved settings and reset this process's settings view. */
       async factoryReset() {
-        for (const path of [configFile(), join10(configDir(), "router-auth.json")]) {
+        for (const path of [configFile(), join11(configDir(), "router-auth.json")]) {
           try {
             await unlink3(path);
           } catch (error) {
@@ -7235,7 +7674,9 @@ var init_config = __esm({
       cliOverridesWithoutEffort() {
         return {
           ...this.cliOverrides.provider !== void 0 ? { provider: this.cliOverrides.provider } : {},
-          ...this.cliOverrides.model !== void 0 ? { model: this.cliOverrides.model } : {}
+          ...this.cliOverrides.model !== void 0 ? { model: this.cliOverrides.model } : {},
+          ...this.cliOverrides.authMode !== void 0 ? { authMode: this.cliOverrides.authMode } : {},
+          ...this.cliOverrides.zergProxyUrl !== void 0 ? { zergProxyUrl: this.cliOverrides.zergProxyUrl } : {}
         };
       }
       getMaxTokensSource() {
@@ -7250,6 +7691,7 @@ var init_config = __esm({
       }
       clearSessionOverrides() {
         this.sessionOverrides = {};
+        this.restoredSessionSelection = false;
       }
       async withConfigScope(scope, fn) {
         const previous = this.configScope;
@@ -7260,7 +7702,13 @@ var init_config = __esm({
           this.configScope = previous;
         }
       }
+      releaseRestoredSelection(key) {
+        if (!this.restoredSessionSelection || !["provider", "model", "authMode", "zergProxyUrl"].includes(key)) return;
+        for (const route of ["provider", "model", "authMode", "zergProxyUrl"]) delete this.sessionOverrides[route];
+        this.restoredSessionSelection = false;
+      }
       set(key, value) {
+        this.releaseRestoredSelection(key);
         if (this.configScope === "session" || key === "emulationId" && this.profileEmulation) {
           this.sessionOverrides[key] = value;
           return;
@@ -7269,10 +7717,12 @@ var init_config = __esm({
         if (key === "apiKey") this.legacyApiKeyFromEnvironment = false;
       }
       setGlobal(key, value) {
+        this.releaseRestoredSelection(key);
         this.config[key] = value;
         if (key === "apiKey") this.legacyApiKeyFromEnvironment = false;
       }
       setAll(next) {
+        for (const key of Object.keys(next)) this.releaseRestoredSelection(key);
         this.config = { ...build_default_config(), ...this.config, ...next };
         if (Object.hasOwn(next, "apiKey")) this.legacyApiKeyFromEnvironment = false;
         if (this.config.model === "claude-opus-4-5-20250514" || this.config.model === "claude-opus-4-20250514") {
@@ -7487,8 +7937,28 @@ var init_config = __esm({
        * Effective Codex effort for the active (or given) provider/model. Priority:
        * per-model > per-provider > global. Defaults to the current provider/model.
        */
+      getReasoningWireSurface(provider = this.getProvider(), model = this.getModel()) {
+        if (provider === "openai_compatible") return "chat_tools";
+        if (modelContract(provider, model)?.chatToolReasoningEfforts === void 0) return "native_api";
+        try {
+          return this.resolveLLMBackendConfig({ provider, model }).useProxy ? "chat_tools" : "native_api";
+        } catch (error) {
+          if (error instanceof RouterConfigurationError) return "chat_tools";
+          throw error;
+        }
+      }
       getCodexEffort(provider, model) {
-        return resolveCodexEffort(this.get(), provider ?? this.getProvider(), model ?? this.getModel());
+        const selectedProvider = provider ?? this.getProvider();
+        const selectedModel = model ?? this.getModel();
+        const catalog = this.getRoutedModelCatalog();
+        const capabilities = catalog ? resolveRouterModel(catalog, selectedProvider, selectedModel)?.capabilities : void 0;
+        return resolveCodexEffort(this.get(), selectedProvider, selectedModel, capabilities ?? this.getReasoningWireSurface(selectedProvider, selectedModel));
+      }
+      /** The active transport owns the model's choices, aliases and advertised default. */
+      getReasoningContract(provider = this.getProvider(), model = this.getModel()) {
+        const catalog = this.getRoutedModelCatalog();
+        if (catalog?.version === 1) return resolveRouterModel(catalog, provider, model)?.capabilities?.reasoning ?? [];
+        return this.getReasoningWireSurface(provider, model);
       }
       /** Saved effort the active (or given) model rejects; undefined when it applies. */
       getUnsupportedCodexEffort(provider, model) {
@@ -7647,6 +8117,69 @@ var init_config = __esm({
           authMode: this.getAuthMode()
         };
       }
+      restoreSessionSelection(metadata) {
+        if (!metadata.authMode || this.cliOverrides.provider || this.cliOverrides.model || metadata.configProfile && metadata.configProfile !== activeProfile()) return;
+        this.restoredSessionSelection = true;
+        this.sessionOverrides.provider = metadata.provider;
+        this.sessionOverrides.model = metadata.model;
+        this.sessionOverrides.authMode = metadata.authMode;
+        if (metadata.authMode !== "direct" && metadata.routerOrigin && !routerOriginFromEnvironment()) this.sessionOverrides.zergProxyUrl = metadata.routerOrigin;
+      }
+      getRouterCatalogConnection(destination = this.get().zergProxyUrl) {
+        const origin = normalizedOrigin(destination);
+        if (!origin) return void 0;
+        const credentials = this.routerCredentials;
+        if (credentials && !this.routerCredentialsError && credentials.origin === origin) {
+          return { origin, token: credentials.token, workspaceId: credentials.workspaceId };
+        }
+        const token = origin === this.deriveZRouterUrl(this.getApiBaseUrl()) ? this.getAuthToken() : void 0;
+        return token ? { origin, token, workspaceId: this.getActiveWorkspace()?.id.toString() } : void 0;
+      }
+      /** New children use configured routing, not a parent's restored inference route. */
+      getChildAuthMode() {
+        if (!this.restoredSessionSelection) return this.getAuthMode();
+        const { authMode: _restored, ...session } = this.sessionOverrides;
+        return resolveAuthMode({ ...this.config, ...session, ...this.cliOverrides });
+      }
+      async adoptRouterCatalog(catalog) {
+        if (catalog.version !== 1 || catalog.authRequired || this.getResolvedAuthMode() !== "zrouter") return;
+        const provider = this.getProvider(), model = this.getModel();
+        const row = resolveRouterModel(catalog, provider, model);
+        if (!row || row.id === model && row.owned_by === provider) return;
+        if (this.cliOverrides.provider || this.cliOverrides.model) {
+          this.cliOverrides.provider = row.owned_by;
+          this.cliOverrides.model = row.id;
+        } else if (this.sessionOverrides.provider || this.sessionOverrides.model) {
+          this.sessionOverrides.provider = row.owned_by;
+          this.sessionOverrides.model = row.id;
+        } else {
+          this.config.provider = row.owned_by;
+          this.config.model = row.id;
+          await this.save();
+        }
+      }
+      getRouterCatalog() {
+        const connection = this.getRouterCatalogConnection();
+        return connection ? readRouterCatalog(connection) : void 0;
+      }
+      getResolvedAuthMode() {
+        const mode = this.getAuthMode();
+        if (mode !== "auto") return mode;
+        try {
+          return this.resolveLLMBackendConfig().useProxy ? "zrouter" : "direct";
+        } catch {
+          return mode;
+        }
+      }
+      getRoutedModelCatalog() {
+        if (isLocalSubscriptionProvider(this.getProvider())) return void 0;
+        return this.getResolvedAuthMode() === "zrouter" ? this.getRouterCatalog() : void 0;
+      }
+      getModelContextWindow(model = this.getModel(), provider = this.getProvider()) {
+        const catalog = this.getRoutedModelCatalog();
+        if (catalog?.version !== 1) return void 0;
+        return resolveRouterModel(catalog, provider, model)?.capabilities?.context_window ?? null;
+      }
       /**
        * Resolve everything a backend factory needs into one struct. Folds in the
        * provider/model override precedence, the direct-key precedence
@@ -7661,17 +8194,16 @@ var init_config = __esm({
        *
        * Reads through `get()` and the env-aware getters (never raw `this.config`)
        * so cli/session overrides stay honored. `apiKey` is the DIRECT provider key;
-       * `authToken`/`useProxy` describe the proxy route separately, so a caller can
-       * still prefer a direct key (e.g. Gemini) over the proxy.
+       * `authToken`/`useProxy` describe the selected proxy route separately.
        */
       resolveLLMBackendConfig(opts = {}) {
         const cfg = opts.config ?? this.get();
         const repoOverride = !opts.provider && !opts.model && !this.hasExplicitModelOverride() && opts.cwd ? resolveRepoModelOverride(opts.cwd) : null;
-        const provider = repoOverride?.provider ?? normalizeProviderId(opts.provider || cfg.provider || this.getProvider());
+        let provider = repoOverride?.provider ?? normalizeProviderId(opts.provider || cfg.provider || this.getProvider());
         const configProvider = cfg.provider ? normalizeProviderId(cfg.provider) : void 0;
-        const model = repoOverride?.model ?? opts.model ?? (configProvider === provider ? cfg.model : void 0) ?? getDefaultModelForProvider(provider);
-        const authMode = resolveAuthMode(cfg);
-        const proxyUrl = cfg.zergProxyUrl;
+        let model = repoOverride?.model ?? opts.model ?? (configProvider === provider ? cfg.model : void 0) ?? getDefaultModelForProvider(provider);
+        const authMode = isLocalSubscriptionProvider(provider) ? "direct" : resolveAuthMode(cfg);
+        const proxyUrl = normalizedOrigin(cfg.zergProxyUrl);
         const platformProxyUrl = this.deriveZRouterUrl(this.getApiBaseUrl());
         let authToken = provider !== "modal" && proxyUrl?.replace(/\/+$/, "") === platformProxyUrl ? this.getAuthToken() : void 0;
         let routerError = this.routerCredentialsError;
@@ -7704,7 +8236,16 @@ var init_config = __esm({
         const apiKey = opts.apiKeyOverride || providerScopedKey || this.getApiKey(provider);
         const rawCompatBaseUrl = opts.compatBaseUrlOverride || this.getOpenAICompatibleSettings(cfg).baseUrl || cfg.openaiCompatibleBaseUrl;
         const proxyAvailable = Boolean(proxyUrl && authToken);
-        const useProxy = authMode === "direct" ? false : proxyAvailable;
+        const localSubscription = isLocalSubscriptionProvider(provider);
+        const useProxy = authMode === "direct" ? false : proxyAvailable && !localSubscription && !(authMode === "auto" && provider === "gemini" && Boolean(apiKey));
+        if (useProxy) {
+          const catalog = readRouterCatalog({ origin: proxyUrl, token: authToken, workspaceId: this.getRouterCatalogConnection(proxyUrl)?.workspaceId });
+          const descriptor2 = catalog?.version === 1 ? resolveRouterModel(catalog, provider, model) : void 0;
+          if (descriptor2) {
+            provider = descriptor2.owned_by;
+            model = descriptor2.id;
+          }
+        }
         const compatBaseUrl = provider === "openai_compatible" && rawCompatBaseUrl ? compatEndpoint(rawCompatBaseUrl, { apiKey }) : rawCompatBaseUrl;
         const activeAccount = resolveActiveAccount(cfg, provider);
         const accountOptions = activeAccount ? accountSourceToBackendOptions(activeAccount.source) : {};
@@ -7723,7 +8264,7 @@ var init_config = __esm({
           codexHome: accountOptions.codexHome,
           codexAuthFilePath: accountOptions.codexAuthFilePath,
           kimiCredsFilePath: accountOptions.kimiCredsFilePath,
-          codexEffort: this.getCodexEffort(provider, model)
+          codexEffort: resolveCodexEffort(cfg, provider, model, (useProxy ? this.getRouterCatalog()?.models.find((row) => row.id === model && row.owned_by === provider)?.capabilities : void 0) ?? (useProxy || provider === "openai_compatible" ? "chat_tools" : "native_api"))
         };
       }
       getEnvKey(provider) {
@@ -7743,6 +8284,8 @@ var init_config = __esm({
             return process.env.OPENAI_API_KEY;
           case "deepseek":
             return process.env.DEEPSEEK_API_KEY;
+          case "fireworks":
+            return process.env.FIREWORKS_API_KEY;
           case "gemini":
             return process.env.GOOGLE_API_KEY || process.env.GEMINI_API_KEY;
           case "inception":
@@ -8120,7 +8663,7 @@ var init_zerg_api = __esm({
 });
 
 // src/agent/backends/zrouter_stream.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 function isPinnableDecoration(value) {
   return value !== void 0 && PINNABLE_DECORATION.test(value);
 }
@@ -8137,7 +8680,7 @@ function resolveReconnectPolicy() {
   };
 }
 function withTransportTurn(request) {
-  return request.transportTurnId ? request : { ...request, transportTurnId: randomUUID4() };
+  return request.transportTurnId ? request : { ...request, transportTurnId: randomUUID5() };
 }
 async function fetchWithHeadersTimeout(fetcher, input, init, timeoutMs) {
   const timeoutController = new AbortController();
@@ -8172,6 +8715,14 @@ async function waitForReconnect(delayMs, signal) {
     signal?.addEventListener("abort", abort, { once: true });
   });
 }
+function failureHeaderSuffix(response) {
+  const parts = [];
+  for (const name of ["fly-request-id", "x-request-id", "cf-ray", "x-zerg-error-code"]) {
+    const value = response.headers.get(name)?.trim();
+    if (value && value.length <= 128 && !/[\r\n\0]/.test(value)) parts.push(`${name}=${value}`);
+  }
+  return parts.length > 0 ? ` [${parts.join(" ")}]` : "";
+}
 function isRetryableResumeStatus(error) {
   if (!(error instanceof Error)) return false;
   const match = error.message.match(/ZRouter API error \((\d{3})\)/);
@@ -8190,10 +8741,22 @@ function normalizeHeaderValue(value, label, maxLength) {
   }
   return normalized;
 }
+function chatOnlyRequest(request) {
+  return { ...request, tools: [], messages: request.messages.map((message) => ({
+    ...message,
+    content: typeof message.content === "string" ? message.content : message.content.map((block) => {
+      if (block.type === "tool_use") return { type: "text", text: `Previous tool call ${block.name} (${block.id}): ${JSON.stringify(block.input)}` };
+      if (block.type === "tool_result") return { type: "text", text: `Previous tool result (${block.tool_use_id}): ${typeof block.content === "string" ? block.content : block.content.map((part) => part.type === "text" ? part.text : "[image]").join("\n")}` };
+      return block;
+    })
+  })) };
+}
 var ZROUTER_HEADERS_TIMEOUT_MS, routerClientSession, ROUTER_PIN_MAX_LENGTH, PINNABLE_DECORATION, DEFAULT_RECONNECT_ATTEMPTS, DEFAULT_RECONNECT_BASE_MS, DEFAULT_RECONNECT_CAP_MS, MAX_RECONNECT_ATTEMPTS, MAX_RECONNECT_MS, ZRouterStreamBackend;
 var init_zrouter_stream = __esm({
   "src/agent/backends/zrouter_stream.ts"() {
     "use strict";
+    init_model_contracts();
+    init_router_catalog();
     init_request_metrics();
     init_sse();
     init_openai_format();
@@ -8205,15 +8768,16 @@ var init_zrouter_stream = __esm({
     init_version();
     init_transport_errors();
     ZROUTER_HEADERS_TIMEOUT_MS = 9e4;
-    routerClientSession = randomUUID4();
+    routerClientSession = randomUUID5();
     ROUTER_PIN_MAX_LENGTH = 128;
     PINNABLE_DECORATION = /^[A-Za-z0-9._:-]{1,64}$/;
-    DEFAULT_RECONNECT_ATTEMPTS = 6;
-    DEFAULT_RECONNECT_BASE_MS = 500;
-    DEFAULT_RECONNECT_CAP_MS = 1e4;
-    MAX_RECONNECT_ATTEMPTS = 20;
+    DEFAULT_RECONNECT_ATTEMPTS = 120;
+    DEFAULT_RECONNECT_BASE_MS = 1e3;
+    DEFAULT_RECONNECT_CAP_MS = 3e4;
+    MAX_RECONNECT_ATTEMPTS = 120;
     MAX_RECONNECT_MS = 3e5;
     ZRouterStreamBackend = class {
+      catalog;
       apiKey;
       proxyUrl;
       provider;
@@ -8222,6 +8786,7 @@ var init_zrouter_stream = __esm({
       conversationId;
       clientName;
       constructor(config) {
+        this.catalog = config.catalog ? structuredClone(config.catalog) : void 0;
         this.apiKey = config.apiKey;
         this.proxyUrl = config.proxyUrl.replace(/\/+$/, "");
         this.provider = config.provider;
@@ -8242,10 +8807,38 @@ var init_zrouter_stream = __esm({
       handlesTransportRetries() {
         return true;
       }
+      getModelCapabilities(model) {
+        return this.catalog?.version === 1 ? resolveRouterModel(this.catalog, this.provider, model)?.capabilities : void 0;
+      }
       buildOpenAIBody(request) {
+        if (this.catalog?.version === 1) {
+          const descriptor2 = resolveRouterModel(this.catalog, this.provider, request.model);
+          if (!descriptor2?.capabilities?.chat) throw new Error("This model is no longer in the Router chat catalog. Refresh /model.");
+          const caps = descriptor2.capabilities;
+          if (request.codexEffort && caps.reasoning && !caps.reasoning.choices.includes(request.codexEffort)) {
+            throw new Error(`Unsupported reasoning effort: ${request.codexEffort}`);
+          }
+          if (request.maxTokens !== void 0 && caps.max_output_tokens !== void 0 && request.maxTokens > caps.max_output_tokens) {
+            throw new Error(`Max output tokens exceeds the advertised limit (${caps.max_output_tokens}).`);
+          }
+          if (caps.images === false && request.messages.some((message) => Array.isArray(message.content) && message.content.some((block) => block.type === "image" || block.type === "video"))) throw new Error("This model does not support images.");
+          const prepared = caps.tools === false ? chatOnlyRequest(request) : request;
+          return {
+            provider: descriptor2.owned_by,
+            model: descriptor2.id,
+            ...request.routePlan ? { route: request.routePlan } : {},
+            ...request.maxTokens === void 0 ? {} : { max_output_tokens: request.maxTokens },
+            ...caps.reasoning && request.codexEffort ? { reasoning_effort: request.codexEffort } : {},
+            messages: buildOpenAIMessages(prepared),
+            ...prepared.tools.length ? { tools: buildOpenAIToolDefs(prepared.tools) } : {}
+          };
+        }
         if (this.provider === "modal" && !/^modal\//i.test(request.model)) {
           request = { ...request, model: `modal/${request.model}` };
         }
+        if (this.provider === "fireworks") {
+          request = { ...request, model: `fireworks/${normalizeContractModel("fireworks", request.model)}` };
+        }
         const useCompletionTokens = /^o\d/.test(request.model) || /^gpt-5/.test(request.model) || isKimiModel(request.model);
         const isGpt4o = request.model.startsWith("gpt-4o");
         const limit = isGpt4o ? 16384 : isModalDeepSeekFlashModel(request.model) ? MODAL_DEEPSEEK_FLASH_MAX_OUTPUT : isDeepSeekFlashModel(request.model) ? DEEPSEEK_FLASH_MAX_OUTPUT : Infinity;
@@ -8256,18 +8849,32 @@ var init_zrouter_stream = __esm({
           model: request.model,
           ...request.routePlan ? { route: request.routePlan } : {},
           ...tokenParam,
-          // Kimi honors a reasoning_effort the picker exposes; without this the same
-          // selection applied on a direct key and vanished through the proxy.
-          // No-op for every non-Kimi model.
-          // Modal uses Kimi's effort ladder but keeps its own max_tokens contract.
-          ...buildKimiRequestParams(this.provider === "modal" ? { ...request, model: request.model.slice("modal/".length) } : request),
-          ...deepseekRequestParams(request),
+          ...request.codexEffort && modelContract(this.provider, request.model, "chat_tools")?.reasoningEfforts.includes(request.codexEffort) ? { reasoning_effort: request.codexEffort } : {},
           messages: buildOpenAIMessages(request),
           ...request.tools.length > 0 ? { tools: buildOpenAIToolDefs(request.tools) } : {}
         };
       }
-      buildBody(request) {
-        return this.buildOpenAIBody(request);
+      serializeBody(request, stream = false) {
+        const body = {
+          ...this.buildOpenAIBody(request),
+          ...stream ? { stream: true } : {}
+        };
+        const serialized = JSON.stringify(body);
+        if (body.model === "modal/deepseek-v4.1-flash" || body.model === "fireworks/deepseek-v4p1-flash") {
+          const pending = [JSON.parse(serialized)];
+          let values = 1;
+          while (pending.length > 0) {
+            const value = pending.pop();
+            if (value === null || typeof value !== "object") continue;
+            for (const child of Object.values(value)) {
+              if (++values > 1e4) {
+                throw new Error("Prompt is too long for Router's context structure limit (10,000 JSON values). Compact the conversation before retrying.");
+              }
+              pending.push(child);
+            }
+          }
+        }
+        return serialized;
       }
       async buildHeaders(request) {
         const token = this.authTokenProvider ? await this.authTokenProvider() : this.apiKey;
@@ -8278,6 +8885,7 @@ var init_zrouter_stream = __esm({
         const conversationPin = this.conversationPin(request);
         return {
           "Content-Type": "application/json",
+          ...this.catalog?.version === 1 ? { "X-Zerg-Model-Contract": "1" } : {},
           "Authorization": `Bearer ${normalizedToken}`,
           "X-Zerg-Client": this.clientName,
           "X-Zerg-Client-Version": getVersion(),
@@ -8319,7 +8927,7 @@ var init_zrouter_stream = __esm({
         return measureResponse(routedRequest, (fetcher) => this.generateResponse(routedRequest, fetcher));
       }
       async generateResponse(request, fetcher) {
-        const body = this.buildBody(request);
+        const body = this.serializeBody(request);
         const headers = await this.buildHeaders(request);
         runtimeDiag("info", `[ztc] zrouter dispatch ${JSON.stringify({
           endpoint: this.endpointFor(),
@@ -8330,15 +8938,19 @@ var init_zrouter_stream = __esm({
         const response = await fetcher(this.endpointFor(), {
           method: "POST",
           headers,
-          body: JSON.stringify(body),
+          body,
           signal: request.signal
         });
         if (!response.ok) {
           const errorText = await response.text();
-          throw new Error(`ZRouter API error (${response.status}): ${errorText}`);
+          throw new Error(`ZRouter API error (${response.status}): ${errorText}${failureHeaderSuffix(response)}`);
         }
         const data = await response.json();
-        return this.parseOpenAIResponse(data);
+        const parsed = this.parseOpenAIResponse(data);
+        if (this.getModelCapabilities(request.model)?.tools === false && parsed.content.some((block) => block.type === "tool_use")) {
+          throw new Error("Chat-only model returned tools; execution is disabled.");
+        }
+        return parsed;
       }
       parseOpenAIResponse(data) {
         const choices = data.choices || [];
@@ -8376,12 +8988,15 @@ var init_zrouter_stream = __esm({
         return measureStream(routedRequest, (fetcher) => this.streamResponse(routedRequest, fetcher));
       }
       async *streamResponse(request, fetcher) {
-        const body = { ...this.buildBody(request), stream: true };
+        const body = this.serializeBody(request, true);
         const mapEvent = createZrouterEventMapper();
         let resumeAfter;
         let emittedMappedEvent = false;
         let resumeSupported = false;
         const policy = resolveReconnectPolicy();
+        let reconnectStarted;
+        const budget = () => resumeAfter ? 3e5 : 3e4;
+        const remaining = () => budget() - (reconnectStarted === void 0 ? 0 : Date.now() - reconnectStarted);
         for (let attempt = 1; attempt <= policy.attempts; attempt++) {
           try {
             const headers = await this.buildHeaders(request);
@@ -8389,12 +9004,12 @@ var init_zrouter_stream = __esm({
             const response = await fetchWithHeadersTimeout(fetcher, this.endpointFor(), {
               method: "POST",
               headers,
-              body: JSON.stringify(body),
+              body,
               signal: request.signal
-            }, ZROUTER_HEADERS_TIMEOUT_MS);
+            }, Math.min(ZROUTER_HEADERS_TIMEOUT_MS, Math.max(1, remaining())));
             if (!response.ok) {
               const errorText = await response.text();
-              throw new Error(`ZRouter API error (${response.status}): ${errorText}`);
+              throw new Error(`ZRouter API error (${response.status}): ${errorText}${failureHeaderSuffix(response)}`);
             }
             if (!response.body) {
               throw new Error("ZRouter API error: no response body for streaming request");
@@ -8415,6 +9030,9 @@ var init_zrouter_stream = __esm({
                 throw new Error(`ZRouter API error (${status}): ${JSON.stringify(ev.body ?? {})}`);
               }
               const mapped = mapEvent(ev);
+              if (this.getModelCapabilities(request.model)?.tools === false && mapped.some((event2) => event2.type.startsWith("tool_use"))) {
+                throw new Error("Chat-only model returned tools; execution is disabled.");
+              }
               if (mapped.length > 0) {
                 if (mapped.some((event2) => event2.type !== "heartbeat")) emittedMappedEvent = true;
                 if (!validEventId) resumeSupported = false;
@@ -8427,12 +9045,16 @@ var init_zrouter_stream = __esm({
             if (request.signal?.aborted || !retryable || emittedMappedEvent && (!resumeSupported || !resumeAfter)) {
               throw error;
             }
-            if (attempt === policy.attempts) throw error;
-            const delayMs = reconnectDelay(policy, attempt);
+            reconnectStarted ??= Date.now();
+            const attempts = resumeAfter ? policy.attempts : Math.min(6, policy.attempts);
+            if (attempt >= attempts || remaining() <= 0) throw error;
+            const delayMs = Math.min(reconnectDelay(policy, attempt), remaining());
             const reason = error instanceof Error ? error.message : String(error);
             runtimeDiag("warn", `[ztc] zrouter stream dropped (${reason}); reconnecting in ${delayMs}ms (attempt ${attempt + 1}/${policy.attempts})`);
-            request.onTransportRetry?.({ attempt, maxAttempts: policy.attempts, delayMs, reason });
+            const publicReason = isRetryableResumeStatus(error) ? `Router temporarily unavailable ${reason.match(/\(\d{3}\)/)?.[0] ?? ""}. Resuming the response.` : reason;
+            request.onTransportRetry?.({ attempt, maxAttempts: attempts, delayMs, reason: publicReason });
             await waitForReconnect(delayMs, request.signal);
+            if (remaining() <= 0) throw error;
           }
         }
       }
@@ -8759,10 +9381,17 @@ function createBackendForProvider(provider, opts) {
       return traced(provider, new KimiBackend({ apiKey: opts.apiKey }));
     case "deepseek":
       return traced(provider, new OpenAICompatibleBackend({
+        provider: "deepseek",
         apiKey: opts.apiKey,
         baseUrl: opts.baseUrl || "https://api.deepseek.com/v1",
         requestBodyExtras: deepseekRequestParams
       }));
+    case "fireworks":
+      return traced(provider, new OpenAICompatibleBackend({
+        apiKey: opts.apiKey,
+        baseUrl: opts.baseUrl || "https://api.fireworks.ai/inference/v1",
+        provider: "fireworks"
+      }));
     case "clarifai":
       return traced(provider, new ClarifaiBackend({ apiKey: opts.apiKey, headers: opts.extraHeaders }));
     case CODEX_APP_SERVER_PROVIDER:
@@ -8802,8 +9431,9 @@ function createBackendForProvider(provider, opts) {
     }
     case "anthropic":
     case "claude":
-    default:
       return traced(provider, new AnthropicBackend({ apiKey: opts.apiKey, apiEndpoint: opts.apiEndpoint }));
+    default:
+      throw new Error(`Unknown provider: ${provider}. Select a Router integration or a supported direct provider.`);
   }
 }
 var TracedBackend;
@@ -8850,6 +9480,9 @@ var init_backends = __esm({
       }
       provider;
       backend;
+      getModelCapabilities(model) {
+        return this.backend.getModelCapabilities?.(model);
+      }
       async steerUserMessage(message) {
         return this.backend.steerUserMessage?.(message) ?? false;
       }
@@ -9315,8 +9948,8 @@ init_backends();
 init_token_usage();
 init_transport_errors();
 init_defaults();
-import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync5, readFileSync as readFileSync8 } from "fs";
+import { randomUUID as randomUUID7 } from "node:crypto";
+import { existsSync as existsSync5, readFileSync as readFileSync9 } from "fs";
 import { extname } from "path";
 
 // src/config/api_retry.ts
@@ -9427,10 +10060,10 @@ function createRecoveryGuard(settings) {
 }
 
 // src/agent/runtime/command_jobs.ts
-import { randomUUID as randomUUID5, createHash as createHash3 } from "node:crypto";
-import { appendFileSync as appendFileSync4, closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync6, readSync, readdirSync, rmSync, rmdirSync, statSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { randomUUID as randomUUID6, createHash as createHash4 } from "node:crypto";
+import { appendFileSync as appendFileSync4, closeSync, mkdirSync as mkdirSync3, openSync, readFileSync as readFileSync7, readSync, readdirSync, rmSync, rmdirSync, statSync as statSync2, writeFileSync as writeFileSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 
 // src/utils/subprocess_env.ts
 var USER_SUBPROCESS_STRIPPED_ZTC_ENV = [
@@ -9466,14 +10099,14 @@ var MAX_LOG_BYTES = 16 * 1024 * 1024;
 var RETENTION_MS = 7 * 24 * 60 * 60 * 1e3;
 var sessions = /* @__PURE__ */ new Map();
 function directory(sessionId) {
-  return join11(
-    process.env.ZTC_CONFIG_DIR || join11(homedir6(), ".ztc"),
+  return join12(
+    process.env.ZTC_CONFIG_DIR || join12(homedir6(), ".ztc"),
     "command-jobs",
-    createHash3("sha256").update(sessionId).digest("hex").slice(0, 32)
+    createHash4("sha256").update(sessionId).digest("hex").slice(0, 32)
   );
 }
 function save(sessionId, receipt) {
-  writeFileSync5(join11(directory(sessionId), `${receipt.job_id}.json`), JSON.stringify(receipt), { mode: 384 });
+  writeFileSync5(join12(directory(sessionId), `${receipt.job_id}.json`), JSON.stringify(receipt), { mode: 384 });
 }
 function resolveJob(sessionId, jobId) {
   if (!/^[0-9a-f-]{36}$/.test(jobId)) throw new Error("Command job not found in this session");
@@ -9481,7 +10114,7 @@ function resolveJob(sessionId, jobId) {
   if (live) return live;
   let receipt;
   try {
-    receipt = JSON.parse(readFileSync6(join11(directory(sessionId), `${jobId}.json`), "utf8"));
+    receipt = JSON.parse(readFileSync7(join12(directory(sessionId), `${jobId}.json`), "utf8"));
   } catch {
     throw new Error("Command job not found in this session");
   }
@@ -9489,7 +10122,7 @@ function resolveJob(sessionId, jobId) {
     receipt = { ...receipt, status: "interrupted", ended_at: (/* @__PURE__ */ new Date()).toISOString(), error: "Owning ZTC process ended; inspect output before retrying." };
     save(sessionId, receipt);
   }
-  return { receipt, controller: new AbortController(), done: Promise.resolve(), loggedBytes: statSync(receipt.log_path).size };
+  return { receipt, controller: new AbortController(), done: Promise.resolve(), loggedBytes: statSync2(receipt.log_path).size };
 }
 function listCommandJobs(sessionId) {
   const jobs = [...sessions.get(sessionId)?.values() ?? []];
@@ -9859,8 +10492,8 @@ init_tool_response_store();
 
 // src/utils/mirror_media.ts
 import { tmpdir as tmpdir2 } from "os";
-import { join as join12, resolve as resolve5, sep as sep2 } from "path";
-var MIRROR_MEDIA_ROOT = join12(tmpdir2(), "ztc-mirror-media");
+import { join as join13, resolve as resolve5, sep as sep2 } from "path";
+var MIRROR_MEDIA_ROOT = join13(tmpdir2(), "ztc-mirror-media");
 function isMirrorMediaPath(localPath) {
   if (!localPath) return false;
   const root = resolve5(MIRROR_MEDIA_ROOT);
@@ -10089,13 +10722,13 @@ init_tool_compression();
 // src/agent/runtime/tool_runtime.ts
 init_capabilities();
 init_config();
-import { basename as basename3, dirname as dirname6, join as join14, relative as relative2, resolve as resolve7 } from "path";
+import { basename as basename3, dirname as dirname8, join as join15, relative as relative2, resolve as resolve7 } from "path";
 import { realpathSync } from "node:fs";
 import { appendFile } from "node:fs/promises";
 
 // src/context/intents_loader.ts
-import { appendFileSync as appendFileSync5, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { basename as basename2, dirname as dirname5, join as join13, relative, resolve as resolve6 } from "path";
+import { appendFileSync as appendFileSync5, existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync8, statSync as statSync3, writeFileSync as writeFileSync6 } from "fs";
+import { basename as basename2, dirname as dirname7, join as join14, relative, resolve as resolve6 } from "path";
 var DEFAULT_MAX_BYTES = 32 * 1024;
 var DEFAULT_FILE_INTENT_THRESHOLD_LINES = 400;
 function loadIntentsContext(cwd = process.cwd(), settings, options = {}) {
@@ -10166,7 +10799,7 @@ function buildIntentCandidates(cwd, relatedPaths, includeHierarchy) {
   if (includeHierarchy) {
     const roots = findRootToCwd(resolve6(cwd));
     for (const dir of roots) {
-      pushUnique(candidates, seen, join13(dir, ".ztc-intents.md"));
+      pushUnique(candidates, seen, join14(dir, ".ztc-intents.md"));
     }
   }
   for (const relatedPath of relatedPaths) {
@@ -10180,10 +10813,10 @@ function findRootToCwd(cwd) {
   let current = cwd;
   for (; ; ) {
     chain.push(current);
-    if (existsSync4(join13(current, ".git"))) {
+    if (existsSync4(join14(current, ".git"))) {
       break;
     }
-    const parent = dirname5(current);
+    const parent = dirname7(current);
     if (parent === current) {
       break;
     }
@@ -10195,16 +10828,16 @@ function selectIntentTarget(cwd, absolutePath, threshold) {
   if (isLargeFile(absolutePath, threshold)) {
     return fileIntentPath(absolutePath);
   }
-  const dir = existsSync4(absolutePath) && statSync2(absolutePath).isDirectory() ? absolutePath : dirname5(absolutePath);
+  const dir = existsSync4(absolutePath) && statSync3(absolutePath).isDirectory() ? absolutePath : dirname7(absolutePath);
   const normalizedCwd = resolve6(cwd);
   const normalizedDir = resolve6(dir);
   if (!isInside(normalizedDir, normalizedCwd)) {
-    return join13(normalizedCwd, ".ztc-intents.md");
+    return join14(normalizedCwd, ".ztc-intents.md");
   }
-  return join13(normalizedDir, ".ztc-intents.md");
+  return join14(normalizedDir, ".ztc-intents.md");
 }
 function ensureIntentFile(path) {
-  mkdirSync4(dirname5(path), { recursive: true });
+  mkdirSync4(dirname7(path), { recursive: true });
   if (existsSync4(path)) {
     return;
   }
@@ -10219,14 +10852,14 @@ function ensureIntentFile(path) {
   ].join("\n") + "\n", "utf-8");
 }
 function fileIntentPath(absolutePath) {
-  return join13(dirname5(absolutePath), `.ztc-intents-${basename2(absolutePath)}.md`);
+  return join14(dirname7(absolutePath), `.ztc-intents-${basename2(absolutePath)}.md`);
 }
 function isLargeFile(path, threshold) {
   try {
-    if (!existsSync4(path) || statSync2(path).isDirectory()) {
+    if (!existsSync4(path) || statSync3(path).isDirectory()) {
       return false;
     }
-    const raw = readFileSync7(path, "utf-8");
+    const raw = readFileSync8(path, "utf-8");
     return raw.split("\n").length >= threshold;
   } catch {
     return false;
@@ -10237,7 +10870,7 @@ function loadBudgetedFile(path, maxBytes) {
     return null;
   }
   try {
-    const raw = readFileSync7(path, "utf-8");
+    const raw = readFileSync8(path, "utf-8");
     const bytes = Buffer.byteLength(raw, "utf-8");
     if (bytes <= maxBytes) {
       return {
@@ -10282,7 +10915,7 @@ function isHostControlPlaneWrite(tool, args, cwd) {
   try {
     const noFollowLeaf = (path) => {
       const absolute = resolve7(path);
-      return join14(realpathSync(dirname6(absolute)), basename3(absolute));
+      return join15(realpathSync(dirname8(absolute)), basename3(absolute));
     };
     return noFollowLeaf(resolve7(cwd, args.path)) === noFollowLeaf(tool.hostControlPlaneWritePath);
   } catch {
@@ -10350,7 +10983,7 @@ ${intentContext}`;
 async function recordToolTrace(entry) {
   const configured = process.env.ZTC_TOOL_TRACE;
   if (!configured) return;
-  const target = configured === "1" ? join14(process.cwd(), "ztc-tool-trace.jsonl") : configured;
+  const target = configured === "1" ? join15(process.cwd(), "ztc-tool-trace.jsonl") : configured;
   try {
     await appendFile(target, `${JSON.stringify(entry)}
 `, "utf-8");
@@ -10803,7 +11436,7 @@ var Agent = class _Agent {
       routePlan: config.routePlan,
       maxIterations: config.maxIterations || 10,
       execution: resolveExecutionSettings(config.execution),
-      sessionId: config.sessionId ?? randomUUID6(),
+      sessionId: config.sessionId ?? randomUUID7(),
       runtimeFacts: config.runtimeFacts ?? {},
       apiRetry: resolveApiRetrySettings({ apiRetry: config.apiRetry }),
       llmRequestTimeoutMs: resolveLlmRequestTimeoutMs(
@@ -10829,6 +11462,10 @@ var Agent = class _Agent {
       this.alwaysLoadedToolNames.add(name);
     }
     this.backend = this.config.backend;
+    if (this.backend.getModelCapabilities?.(this.config.model)?.tools === false) {
+      this.config.tools = [];
+      this.config.autoContinue = false;
+    }
     this.policy = this.config.policy;
     this.tracer = this.config.tracer;
     this._cwd = this.config.cwd;
@@ -10843,7 +11480,7 @@ var Agent = class _Agent {
     this._hasCustomSystemPrompt = typeof config.systemPrompt === "string" && config.systemPrompt.trim().length > 0;
   }
   setAutoContinue(enabled2) {
-    this._autoContinue = enabled2;
+    this._autoContinue = enabled2 && this.backend.getModelCapabilities?.(this.config.model)?.tools !== false;
   }
   /** Override the agent's system prompt (e.g., for simulation persona injection). */
   setSystemPrompt(prompt) {
@@ -10978,7 +11615,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
     this._currentRequestToolIds = currentTurnToolIds;
     if (allToolIds.length > 0) {
       const activeModel = this.config.model || "default";
-      const budget = this.toolResponseStore.effectiveBudget(activeModel);
+      const budget = this.toolResponseStore.effectiveBudget(activeModel, this.backend.getModelCapabilities?.(activeModel) ? this.backend.getModelCapabilities(activeModel)?.context_window ?? null : void 0);
       this._selectorVerdict = this.toolResponseStore.selectInlineSet(
         allToolIds,
         currentTurnToolIds,
@@ -11033,7 +11670,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
       const ext = extname(path).toLowerCase();
       const mediaType = this.getImageMediaType(ext);
       if (!mediaType) return null;
-      const buffer = readFileSync8(path);
+      const buffer = readFileSync9(path);
       return {
         type: "image",
         mediaType,
@@ -11093,7 +11730,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
       const ext = extname(path).toLowerCase();
       const mediaType = this.getVideoMediaType(ext);
       if (!mediaType) return null;
-      const buffer = readFileSync8(path);
+      const buffer = readFileSync9(path);
       return {
         type: "video",
         mediaType,
@@ -11538,7 +12175,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
       }
       const result = await this.runCore(workingMessages, signal);
       const assistantMessage = {
-        id: `host_assistant_${randomUUID6()}`,
+        id: `host_assistant_${randomUUID7()}`,
         role: "assistant",
         content: result.content,
         timestamp: /* @__PURE__ */ new Date(),
@@ -11647,6 +12284,28 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
               finalReasoning = response.reasoning;
             }
             if (!this._lastResponseStreamed) await this.emitStreamText(iterationText, signal);
+            if (iterations < this.config.maxIterations) {
+              const steering = takeSteering?.() ?? [];
+              if (steering.length > 0) {
+                if (iterationText.trim()) {
+                  const answer = {
+                    id: `assistant_${Date.now()}_${iterations}`,
+                    role: "assistant",
+                    content: iterationText,
+                    timestamp: /* @__PURE__ */ new Date(),
+                    ...response.reasoning ? { metadata: { reasoningContent: response.reasoning } } : {}
+                  };
+                  messages.push(answer);
+                  turnMessages.push(answer);
+                }
+                messages.push(...steering);
+                turnMessages.push(...steering);
+                this.emit({ type: "history_checkpoint", messages: [...turnMessages] });
+                finalContent = "";
+                finalReasoning = void 0;
+                continue;
+              }
+            }
             if (this.shouldContinue(iterationText) && this._consecutiveAutoContinues < this.config.maxConsecutiveAutoContinues) {
               this._consecutiveAutoContinues++;
               const acTodos = getLatestTodos();
@@ -11880,7 +12539,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
           if (recoveryAction === "stop") throw new AgentError("Automatic recovery budget exhausted after repeated tool failures. Inspect the retained results and current capabilities before retrying.", "RECOVERY_EXHAUSTED");
           if (recoveryAction === "recover") {
             const recoveryMessage = {
-              id: `recovery_${randomUUID6()}`,
+              id: `recovery_${randomUUID7()}`,
               role: "user",
               content: "[Recovery] Repeated failures share the same cause. Stop that sequence. Inspect current capabilities and active jobs, then make one changed recovery attempt. Use file/stdin tools for scripts and raw Ctrl+C for stuck shell input, then read the pane in the same response or immediately afterward. A silent running-job poll allows one further inspection before stopping; do not repeat empty polls. Continue authorized work; use ask_user only for a concrete missing prerequisite. Do not repeat an acknowledgement as proof of success.",
               metadata: { synthetic: true },
@@ -12042,7 +12701,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
     const { maxAttempts, baseDelayMs: baseDelay } = this.config.apiRetry;
     const timeoutMs = this.config.llmRequestTimeoutMs;
     if (this.backend.handlesTransportRetries?.(request) === true) {
-      request = { ...request, transportTurnId: request.transportTurnId ?? randomUUID6() };
+      request = { ...request, transportTurnId: request.transportTurnId ?? randomUUID7() };
     }
     const useStream = process.env.ZTC_NO_STREAM !== "1" && !this.backend.streamsSyntheticallyFor?.(request);
     let answerOutputEmitted = false;
@@ -12191,7 +12850,8 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
     let errorMessage = "";
     let admissionMessage = "";
     try {
-      const jsonMatch = message.match(/:\s*(\{[\s\S]*\})\s*$/);
+      const bodyMessage = message.replace(/ \[(?:(?:fly-request-id|x-request-id|cf-ray|x-zerg-error-code)=[^\]\r\n ]+ ?)+\]$/, "");
+      const jsonMatch = bodyMessage.match(/:\s*(\{[\s\S]*\})\s*$/);
       if (jsonMatch) {
         const parsed = JSON.parse(jsonMatch[1]);
         const errorPayload = parsed.error;
@@ -12218,6 +12878,9 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
       }
     } catch {
     }
+    if (statusCode === 410 && message.startsWith("ZRouter API error (") && ["stream_producer_lost", "stream_producer_failed", "stream_resume_expired"].includes(errorCode)) {
+      return { retryable: false, reason: "The Router stream was interrupted and cannot be resumed. Send a message to continue from the existing conversation." };
+    }
     if (errorCode === "context_length_exceeded" || isContextOverflowMessage(`${errorMessage} ${message}`)) {
       return { retryable: false, reason: "Context window exceeded", kind: "context_overflow" };
     }
@@ -12228,7 +12891,10 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
       return { retryable: true, reason: "Rate limit exceeded" };
     }
     if (statusCode === 503 || statusCode === 502 || statusCode === 500 || errorType === "UNAVAILABLE" || errorType === "INTERNAL") {
-      return { retryable: true, reason: "Server temporarily unavailable" };
+      const requestId = /(?:fly-request-id|x-request-id)=([A-Za-z0-9._:-]{1,128})(?:[ \]]|$)/.exec(message)?.[1];
+      const detail = [admissionMessage.trim().replace(/\s+/g, " "), requestId && `request_id: ${requestId}`].filter(Boolean).join("; ");
+      const cause = detail ? `: ${detail.length > 160 ? `${detail.slice(0, 159)}\u2026` : detail}` : "";
+      return { retryable: true, reason: `Upstream server error (${statusCode || "no status"})${cause}` };
     }
     if (statusCode === 401 || errorType === "authentication_error" || errorType === "UNAUTHENTICATED") {
       return {
@@ -12239,7 +12905,7 @@ INVESTIGATION STRATEGY \u2014 before making tool calls to explore or debug, foll
     if (statusCode === 403 || errorType === "PERMISSION_DENIED") {
       return { retryable: false, reason: admissionMessage || "Permission denied" };
     }
-    if (statusCode === 402) {
+    if (statusCode === 402 || errorCode === "billing_required") {
       const guidance = "Subscribe in Zerg Router (Dashboard \u2192 Billing), or choose another model with /model.";
       return {
         retryable: false,
@@ -12274,8 +12940,8 @@ init_capabilities();
 init_logger();
 init_extension_discovery();
 import { homedir as homedir8 } from "os";
-import { join as join15, resolve as resolve8, basename as basename4 } from "path";
-import { readdir as readdir2, readFile as readFile4 } from "fs/promises";
+import { join as join16, resolve as resolve8, basename as basename4 } from "path";
+import { readdir as readdir3, readFile as readFile4 } from "fs/promises";
 var MAX_DEPTH = 4;
 function defaultMarkdownRoots() {
   const explicitRoots = extensionPathsFromEnvironment("ZTC_SKILL_PATHS");
@@ -12283,20 +12949,20 @@ function defaultMarkdownRoots() {
   const home = homedir8();
   return [
     ...explicitRoots,
-    join15(process.cwd(), ".ztc", "skills"),
-    join15(process.cwd(), ".claude", "skills"),
-    join15(home, ".ztc", "skills"),
-    join15(home, ".claude", "skills")
+    join16(process.cwd(), ".ztc", "skills"),
+    join16(process.cwd(), ".claude", "skills"),
+    join16(home, ".ztc", "skills"),
+    join16(home, ".claude", "skills")
   ];
 }
 async function walk(dir, depth = 0) {
   if (depth > MAX_DEPTH) return [];
   try {
-    const entries = await readdir2(dir, { withFileTypes: true });
+    const entries = await readdir3(dir, { withFileTypes: true });
     const results = [];
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const full = join15(dir, entry.name);
+      const full = join16(dir, entry.name);
       if (entry.isDirectory()) {
         results.push(...await walk(full, depth + 1));
       } else if (entry.isFile() && entry.name.toLowerCase() === "skill.md") {
@@ -12438,12 +13104,12 @@ async function loadSkills(roots = defaultMarkdownRoots()) {
 }
 
 // src/skills/bundled/index.ts
-import { dirname as dirname7, resolve as resolve9 } from "path";
+import { dirname as dirname9, resolve as resolve9 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/skills/bundled/init-context.ts
-import { readdir as readdir3, readFile as readFile5, stat } from "fs/promises";
-import { join as join16 } from "path";
+import { readdir as readdir4, readFile as readFile5, stat as stat2 } from "fs/promises";
+import { join as join17 } from "path";
 var MAX_ENTRIES = 60;
 var TOP_LEVEL_DIRS_OF_INTEREST = [
   "src",
@@ -12487,7 +13153,7 @@ var MANIFESTS = [
 var CLAUDE_MD_CANDIDATES = ["CLAUDE.md", "AGENTS.md", "claude.md"];
 async function fileExists(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch {
     return false;
@@ -12495,7 +13161,7 @@ async function fileExists(path) {
 }
 async function safeReadDir(path) {
   try {
-    const entries = await readdir3(path, { withFileTypes: true });
+    const entries = await readdir4(path, { withFileTypes: true });
     return entries.filter((e) => !e.name.startsWith(".")).map((e) => e.isDirectory() ? `${e.name}/` : e.name);
   } catch {
     return [];
@@ -12504,7 +13170,7 @@ async function safeReadDir(path) {
 async function detectManifests(cwd) {
   const found = [];
   for (const { file, label } of MANIFESTS) {
-    if (await fileExists(join16(cwd, file))) {
+    if (await fileExists(join17(cwd, file))) {
       found.push(`- ${file} \u2014 ${label}`);
     }
   }
@@ -12512,7 +13178,7 @@ async function detectManifests(cwd) {
 }
 async function readClaudeMd(cwd) {
   for (const name of CLAUDE_MD_CANDIDATES) {
-    const path = join16(cwd, name);
+    const path = join17(cwd, name);
     if (await fileExists(path)) {
       try {
         const contents = await readFile5(path, "utf-8");
@@ -12592,7 +13258,7 @@ var bundledCodeSkills = [
   initContextSkill
 ];
 function bundledMarkdownRoot() {
-  const here = dirname7(fileURLToPath2(import.meta.url));
+  const here = dirname9(fileURLToPath2(import.meta.url));
   return resolve9(here);
 }
 
@@ -12771,7 +13437,7 @@ var invokeSkillTool = makeInvokeSkillTool(resolveAmbientSkills);
 // src/zlm.ts
 var ZLM_EMBED_API_VERSION = "zerglang.ztc-embed/1";
 var ZLM_STDIO_PROTOCOL = "zerglang.ztc-host/1";
-var ZLM_ZTC_VERSION = true ? "0.4.0-beta.1" : "development";
+var ZLM_ZTC_VERSION = true ? "0.4.1-dev.36919234045" : "development";
 var ZLM_MAX_HOST_TOOLS = 64;
 var ZLM_MAX_SYSTEM_PROMPT_BYTES = 128 * 1024;
 var ZLM_HOST_APPROVAL_CAPABILITIES = Object.freeze([