opencode-resolve 0.1.7 → 0.1.9

package/scripts/postinstall.mjs

@@ -17,6 +17,19 @@ const ADDITIVE_DEFAULTS = {
   autoApprove: true,
 }
 
+// ZAI local MCP server bootstrap for GLM users.
+// Do not copy provider secrets from OpenCode's auth store into opencode.json.
+// The MCP process should receive credentials from the user's runtime environment.
+const ZAI_MCP_SERVERS = {
+  "zai-mcp-server": {
+    type: "local",
+    command: ["npx", "-y", "@z_ai/mcp-server"],
+    environment: {
+      Z_AI_MODE: "ZAI",
+    },
+  },
+}
+
 const COMPANION_PLUGINS = [
   {
     pkg: "@tarquinen/opencode-dcp",
@@ -28,6 +41,26 @@ const COMPANION_PLUGINS = [
   },
 ]
 
+const OPENAI_MODEL_HINTS = [
+  "openai/gpt-5.5",
+  "openai/gpt-5.4",
+  "openai/gpt-5.3-codex",
+  "openai/gpt-5.3-codex-spark",
+  "openai/gpt-5.2",
+  "openai/gpt-5-mini",
+  "openai/gpt-4o-mini",
+]
+
+const GLM_MODEL_HINTS = [
+  "zai-coding-plan/glm-5.1",
+  "zai/glm-5.1",
+  "zai/glm-5",
+  "zai/glm-4.7-flash",
+  "zai/glm-4.5-flash",
+  "zai/glm-4.5",
+  "zai/glm-4.5-air",
+]
+
 if (process.env.OPENCODE_RESOLVE_SKIP_POSTINSTALL === "1") {
   process.exit(0)
 }
@@ -56,34 +89,162 @@ async function readOwnVersion() {
 
 async function registerPlugin() {
   await mkdir(configDir, { recursive: true })
+  const scriptedAnswers = await readScriptedAnswersIfNeeded()
 
   const config = await readOpenCodeConfig()
-  const changed = addPlugin(config)
+  let configChanged = addPlugin(config)
+
+  // Inject ZAI MCP servers when GLM is detected
+  const allModels = detectAllModels(config)
+  const hasGLM = allModels.some((m) => isGLMModel(m))
+  if (hasGLM) {
+    const mcpChanged = await injectZAIMCPs(config)
+    configChanged = configChanged || mcpChanged
+  }
 
-  if (changed) {
+  if (configChanged) {
     await writeFile(opencodeConfigPath, `${JSON.stringify(config, null, 2)}\n`)
-    console.log(`[${packageName}] registered in ${opencodeConfigPath}`)
+    console.log(`[${packageName}] updated ${opencodeConfigPath}`)
   } else {
     console.log(`[${packageName}] already registered in ${opencodeConfigPath}`)
   }
 
   if (!(await exists(resolveConfigPath))) {
-    await createAdaptiveResolveConfig(config)
+    await createAdaptiveResolveConfig(config, scriptedAnswers)
+    return
+  }
+
+  await handleExistingResolveConfig(config, scriptedAnswers)
+}
+
+async function handleExistingResolveConfig(opencodeConfig, scriptedAnswers) {
+  const action = await chooseExistingResolveConfigAction(scriptedAnswers)
+  if (action === "fresh") {
+    await backupResolveConfig()
+    await createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers)
     return
   }
 
   await migrateResolveConfig()
 }
 
-async function createAdaptiveResolveConfig(opencodeConfig) {
+async function chooseExistingResolveConfigAction(scriptedAnswers) {
+  const requested = (process.env.OPENCODE_RESOLVE_REINSTALL ?? "").trim().toLowerCase()
+  if (["fresh", "reset", "recreate", "new"].includes(requested)) return "fresh"
+  if (["update", "keep", "migrate", "preserve"].includes(requested)) return "update"
+  if (requested) {
+    console.warn(`[${packageName}] ignoring unknown OPENCODE_RESOLVE_REINSTALL=${JSON.stringify(requested)}; use "fresh" or "update".`)
+  }
+
+  const forcePrompt = process.env.OPENCODE_RESOLVE_FORCE_PROMPT === "1"
+  const canPrompt = Boolean((process.stdin.isTTY && process.stdout.isTTY) || forcePrompt)
+  if (!canPrompt) {
+    console.log(`[${packageName}] existing ${resolveConfigPath} found; preserving it and applying additive updates.`)
+    console.log(`[${packageName}] for a fresh reinstall, rerun in a TTY or set OPENCODE_RESOLVE_REINSTALL=fresh.`)
+    return "update"
+  }
+
+  const rl = createPromptInterface(scriptedAnswers)
+  try {
+    console.log("")
+    console.log(`[${packageName}] Existing resolve config found: ${resolveConfigPath}`)
+    console.log("  1. update existing config — preserve your settings and add missing defaults")
+    console.log("  2. fresh reinstall — back up resolve.json and run setup again")
+    const answer = await askChoice(rl, "Existing config [1=update, 2=fresh reinstall, default 1]: ", ["1", "2"], "1")
+    return answer === "2" ? "fresh" : "update"
+  } finally {
+    rl.close()
+  }
+}
+
+async function backupResolveConfig() {
+  const raw = await readFile(resolveConfigPath, "utf8")
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-")
+  const backupPath = `${resolveConfigPath}.bak.${stamp}`
+  await writeFile(backupPath, raw)
+  console.log(`[${packageName}] backed up existing resolve config to ${backupPath}`)
+}
+
+async function createAdaptiveResolveConfig(opencodeConfig, scriptedAnswers) {
   await assertReadable(exampleConfigPath)
   const raw = await readFile(exampleConfigPath, "utf8")
   const example = JSON.parse(raw)
 
   const currentModel = detectOpenCodeModel(opencodeConfig)
-  const preset = buildModelPreset(currentModel)
-
+  const allModels = detectAllModels(opencodeConfig)
   const resolveConfig = { ...example }
+  const forcePrompt = process.env.OPENCODE_RESOLVE_FORCE_PROMPT === "1"
+  const canPrompt = Boolean(
+    (process.stdin.isTTY && process.stdout.isTTY) || forcePrompt,
+  )
+  const interactivePreset = canPrompt
+    ? await buildInteractivePreset(currentModel, allModels, scriptedAnswers)
+    : undefined
+
+  if (interactivePreset) {
+    resolveConfig.profile = interactivePreset.profile
+    if (interactivePreset.tier) resolveConfig.tier = interactivePreset.tier
+    else delete resolveConfig.tier
+    if (interactivePreset.enabled) resolveConfig.enabled = interactivePreset.enabled
+    resolveConfig.models = interactivePreset.models
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      ...(interactivePreset.agents ?? {}),
+    }
+    await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
+    console.log(`[${packageName}] created ${resolveConfigPath} (preset: ${interactivePreset.label})`)
+    return
+  }
+
+  if (process.env.OPENCODE_RESOLVE_AUTO_PRESET !== "1") {
+    resolveConfig.profile = "mix"
+    delete resolveConfig.tier
+    resolveConfig.models = {}
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+      glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
+    }
+    await writeFile(resolveConfigPath, `${JSON.stringify(resolveConfig, null, 2)}\n`)
+    console.log(`[${packageName}] created ${resolveConfigPath} (preset: prompt-required)`)
+    console.log(`[${packageName}] model pinning was not guessed because no interactive prompt was available.`)
+    console.log(`[${packageName}] rerun setup in a TTY or edit ${resolveConfigPath} to choose GPT/GLM three-tier models.`)
+    return
+  }
+
+  // Profile selection based on detected providers
+  const hasGLM = allModels.some((m) => isGLMModel(m))
+  const hasGPT = allModels.some((m) => isGPTModel(m))
+  const preset = buildModelPreset(currentModel, allModels)
+
+  if (hasGLM && !hasGPT) {
+    // GLM only → GLM profile, silver tier (token-efficient, no deep-reviewer)
+    resolveConfig.profile = "glm"
+    resolveConfig.tier = "silver"
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
+    }
+  } else if (hasGPT && !hasGLM) {
+    // GPT only → GPT profile, gold tier (full power)
+    resolveConfig.profile = "gpt"
+    resolveConfig.tier = "gold"
+    resolveConfig.agents = {
+      ...resolveConfig.agents,
+      codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+    }
+  } else {
+    // Mixed or unknown provider → explicit mix profile. No tier: use DEFAULT_ENABLED.
+    resolveConfig.profile = "mix"
+    if (hasGLM && hasGPT) {
+      resolveConfig.agents = {
+        ...resolveConfig.agents,
+        codex: { ...(resolveConfig.agents?.codex ?? {}), enabled: true },
+        glm: { ...(resolveConfig.agents?.glm ?? {}), enabled: true },
+      }
+    }
+  }
+
   if (preset && Object.keys(preset).length > 0) {
     resolveConfig.models = preset
   }
@@ -121,54 +282,389 @@ function detectOpenCodeModel(config) {
   return null
 }
 
-function buildModelPreset(currentModel) {
-  if (!currentModel) return {}
+function buildModelPreset(currentModel, allModels = []) {
+  const detectedGLMModels = allModels.filter(isGLMModel)
+  const detectedGPTModels = allModels.filter(isGPTModel)
+  const glmModels = detectedGLMModels.length > 0 ? collectModelChoices(detectedGLMModels, isGLMModel, GLM_MODEL_HINTS, false) : []
+  const gptModels = detectedGPTModels.length > 0 ? collectModelChoices(detectedGPTModels, isGPTModel, OPENAI_MODEL_HINTS, false) : []
+  const glmModel = glmModels[0]
+  const gptModel = gptModels[0]
+
+  if (glmModel && gptModel) {
+    const glmTiers = chooseThreeTier(glmModels, "glm", false)
+    const gptTiers = chooseThreeTier(gptModels, "gpt", false)
+    return {
+      mix: "gpt",
+      gpt: gptTiers.gold,
+      bronze: glmTiers.bronze,
+      silver: glmTiers.silver,
+      gold: gptTiers.gold,
+      "glm-bronze": glmTiers.bronze,
+      "glm-silver": glmTiers.silver,
+      "glm-gold": glmTiers.gold,
+      "gpt-bronze": gptTiers.bronze,
+      "gpt-silver": gptTiers.silver,
+      "gpt-gold": gptTiers.gold,
+      fast: "bronze",
+      strong: "gold",
+      mini: "bronze",
+      codex: "gpt-gold",
+      glm: glmTiers.gold,
+      explorer: "bronze",
+      coder: "silver",
+      resolver: "gold",
+      reviewer: "gold",
+      "deep-reviewer": "gold",
+      planner: "gold",
+    }
+  }
+
+  if (!currentModel) {
+    return {}
+  }
 
   const lower = currentModel.toLowerCase()
 
-  // GLM / ZAI mixed preset
+  // GLM / ZAI — GLM-only preset (no GPT dependency, avoids token-exhaustion errors)
   if (lower.includes("glm") || lower.includes("zai")) {
-    return {
-      glm: "zai-coding-plan/glm-5.1",
-      gpt: "openai/gpt-5.5",
-      fast: "glm",
-      strong: "gpt",
-      coder: "glm",
-      resolver: "gpt",
-      reviewer: "gpt",
-      "deep-reviewer": "gpt",
-      explorer: "fast",
-    }
+    return buildGLMOnlyPreset(currentModel)
   }
 
   // OpenAI / GPT single-provider preset
   if (lower.includes("openai/") || lower.includes("gpt")) {
-    return {
-      gpt: currentModel,
-      fast: "gpt",
-      strong: "gpt",
-      mini: "gpt",
-      codex: "gpt",
-      coder: "gpt",
-      resolver: "gpt",
-      explorer: "gpt",
-      reviewer: "gpt",
-      "deep-reviewer": "gpt",
-    }
+    return buildGPTOnlyPreset(currentModel)
   }
 
   // Unknown provider — keep model-neutral
   return {}
 }
 
+function buildGLMOnlyPreset(model) {
+  const tiers = chooseThreeTier(collectModelChoices([model], isGLMModel, GLM_MODEL_HINTS, false), "glm", false)
+  return {
+    glm: tiers.gold,
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    explorer: "bronze",
+    planner: "gold",
+  }
+}
+
+function buildGPTOnlyPreset(model) {
+  const tiers = chooseThreeTier(collectModelChoices([model], isGPTModel, OPENAI_MODEL_HINTS, false), "gpt", false)
+  return {
+    gpt: tiers.gold,
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    codex: "gold",
+    coder: "silver",
+    resolver: "gold",
+    explorer: "bronze",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+  }
+}
+
+async function buildInteractivePreset(currentModel, allModels, scriptedAnswers) {
+  const choices = {
+    gpt: collectModelChoices(allModels, isGPTModel, OPENAI_MODEL_HINTS),
+    glm: collectModelChoices(allModels, isGLMModel, GLM_MODEL_HINTS),
+  }
+  if (currentModel) {
+    if (isGPTModel(currentModel)) choices.gpt = unique([currentModel, ...choices.gpt])
+    if (isGLMModel(currentModel)) choices.glm = unique([currentModel, ...choices.glm])
+  }
+
+  const rl = createPromptInterface(scriptedAnswers)
+  try {
+    console.log("")
+    console.log(`[${packageName}] Choose resolve profile:`)
+    console.log("  1. mix — neutral resolver plus optional Codex and GLM primary agents")
+    console.log("  2. gpt — GPT/Codex-only, three-tier")
+    console.log("  3. glm — GLM-only, three-tier")
+    const profileAnswer = await askChoice(rl, "Profile [1=mix, 2=gpt, 3=glm, default 1]: ", ["1", "2", "3"], "1")
+    const profile = profileAnswer === "2" ? "gpt" : profileAnswer === "3" ? "glm" : "mix"
+
+    if (profile === "gpt") {
+      const tiers = await askThreeTier(rl, "GPT/Codex", choices.gpt)
+      return {
+        label: "gpt-three-tier",
+        profile: "gpt",
+        tier: "gold",
+        models: buildGPTThreeTierModels(tiers),
+        agents: { codex: { enabled: true } },
+      }
+    }
+
+    if (profile === "glm") {
+      const tiers = await askThreeTier(rl, "GLM", choices.glm)
+      return {
+        label: "glm-three-tier",
+        profile: "glm",
+        tier: "gold",
+        models: buildGLMThreeTierModels(tiers),
+        agents: { glm: { enabled: true } },
+      }
+    }
+
+    const useCodex = await askYesNo(rl, "Enable dedicated Codex primary agent too? [Y/n]: ", true)
+    const useGLM = await askYesNo(rl, "Enable dedicated GLM primary agent too? [Y/n]: ", true)
+    const gptTiers = await askThreeTier(rl, "Codex/GPT", choices.gpt)
+    const glmTiers = await askThreeTier(rl, "GLM", choices.glm)
+    return {
+      label: "mix-three-tier",
+      profile: "mix",
+      models: buildMixedThreeTierModels(gptTiers, glmTiers),
+      agents: {
+        codex: { enabled: useCodex },
+        glm: { enabled: useGLM },
+      },
+    }
+  } finally {
+    rl.close()
+  }
+}
+
+function createPromptInterface(scriptedAnswers) {
+  return scriptedAnswers
+    ? {
+        async question(prompt) {
+          const answer = scriptedAnswers.length > 0 ? scriptedAnswers.shift() ?? "" : ""
+          process.stdout.write(prompt)
+          process.stdout.write(`${answer}\n`)
+          return answer
+        },
+        close() {},
+      }
+    : createInterface({ input: process.stdin, output: process.stdout })
+}
+
+async function askThreeTier(rl, label, models) {
+  const choices = models.length > 0 ? models : (label.toLowerCase().includes("glm") ? GLM_MODEL_HINTS : OPENAI_MODEL_HINTS)
+  console.log("")
+  console.log(`[${packageName}] ${label} model choices:`)
+  choices.forEach((model, index) => console.log(`  ${index + 1}. ${model}`))
+  const defaults = chooseThreeTier(choices, label.toLowerCase().includes("glm") ? "glm" : "gpt")
+  const bronze = await askModel(rl, choices, `Pick ${label} bronze/scout [default ${defaults.bronze}]: `, defaults.bronze)
+  const silver = await askModel(rl, choices, `Pick ${label} silver/coder [default ${defaults.silver}]: `, defaults.silver)
+  const gold = await askModel(rl, choices, `Pick ${label} gold/reasoner [default ${defaults.gold}]: `, defaults.gold)
+  return { bronze, silver, gold }
+}
+
+async function askModel(rl, choices, question, defaultValue) {
+  const answer = (await rl.question(question)).trim()
+  if (!answer) return defaultValue
+  const index = Number.parseInt(answer, 10)
+  if (Number.isInteger(index) && index >= 1 && index <= choices.length) return choices[index - 1]
+  return answer
+}
+
+async function askChoice(rl, question, valid, defaultValue) {
+  const answer = (await rl.question(question)).trim().toLowerCase()
+  if (!answer) return defaultValue
+  return valid.includes(answer) ? answer : defaultValue
+}
+
+async function askYesNo(rl, question, defaultValue) {
+  const answer = (await rl.question(question)).trim().toLowerCase()
+  if (!answer) return defaultValue
+  return answer === "y" || answer === "yes"
+}
+
+function buildMixedThreeTierModels(gptTiers, glmTiers) {
+  return {
+    mix: "gpt-gold",
+    gpt: "gpt-gold",
+    glm: "glm-gold",
+    bronze: "glm-bronze",
+    silver: "glm-silver",
+    gold: "gpt-gold",
+    "gpt-bronze": gptTiers.bronze,
+    "gpt-silver": gptTiers.silver,
+    "gpt-gold": gptTiers.gold,
+    "glm-bronze": glmTiers.bronze,
+    "glm-silver": glmTiers.silver,
+    "glm-gold": glmTiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    codex: "gpt-gold",
+    explorer: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    planner: "gold",
+  }
+}
+
+function buildGPTThreeTierModels(tiers) {
+  return {
+    gpt: "gold",
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    codex: "gold",
+    explorer: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    planner: "gold",
+  }
+}
+
+function buildGLMThreeTierModels(tiers) {
+  return {
+    glm: "gold",
+    bronze: tiers.bronze,
+    silver: tiers.silver,
+    gold: tiers.gold,
+    fast: "bronze",
+    strong: "gold",
+    mini: "bronze",
+    explorer: "bronze",
+    coder: "silver",
+    resolver: "gold",
+    reviewer: "gold",
+    "deep-reviewer": "gold",
+    planner: "gold",
+  }
+}
+
+function collectModelChoices(allModels, predicate, hints, includeFallbackHints = true) {
+  const detected = allModels.filter(predicate)
+  const providerIds = new Set(detected.map((model) => model.split("/")[0]).filter(Boolean))
+  const matchingHints = includeFallbackHints
+    ? hints.filter((model) => providerIds.size === 0 || providerIds.has(model.split("/")[0]) || detected.length < 3)
+    : []
+  return unique([...detected, ...matchingHints])
+}
+
+function chooseThreeTier(models, family, includeFallbackHints = true) {
+  const fallback = family === "glm" ? GLM_MODEL_HINTS : OPENAI_MODEL_HINTS
+  const choices = unique(includeFallbackHints ? [...models, ...fallback] : models)
+  return {
+    bronze: preferModel(choices, family === "glm" ? ["flash", "air", "mini"] : ["spark", "mini", "4o-mini"], choices[0]),
+    silver: preferModel(choices, family === "glm" ? ["5.1", "4.5"] : ["codex", "5.3", "5.2"], choices[1] ?? choices[0]),
+    gold: preferModel(choices, family === "glm" ? ["5.1", "5", "4.5"] : ["5.5", "5.4", "gpt-5.3-codex"], choices[2] ?? choices[1] ?? choices[0]),
+  }
+}
+
+function preferModel(models, needles, fallback) {
+  return models.find((model) => {
+    const lower = model.toLowerCase()
+    return needles.some((needle) => lower.includes(needle))
+  }) ?? fallback
+}
+
+function unique(values) {
+  return [...new Set(values.filter((value) => typeof value === "string" && value.length > 0))]
+}
+
+async function readAllStdin() {
+  let raw = ""
+  for await (const chunk of process.stdin) {
+    raw += chunk
+  }
+  return raw
+}
+
+async function readScriptedAnswersIfNeeded() {
+  if (process.env.OPENCODE_RESOLVE_FORCE_PROMPT === "1" && !process.stdin.isTTY) {
+    return (await readAllStdin()).split(/\r?\n/)
+  }
+  return undefined
+}
+
 function getPresetLabel(currentModel) {
   if (!currentModel) return "inherited"
   const lower = currentModel.toLowerCase()
-  if (lower.includes("glm") || lower.includes("zai")) return "glm+gpt"
+  if (lower.includes("glm") || lower.includes("zai")) return "glm-only"
   if (lower.includes("openai/") || lower.includes("gpt")) return "gpt-only"
   return "inherited"
 }
 
+function isGLMModel(currentModel) {
+  if (!currentModel) return false
+  const lower = currentModel.toLowerCase()
+  return lower.includes("glm") || lower.includes("zai")
+}
+
+function isGPTModel(currentModel) {
+  if (!currentModel) return false
+  const lower = currentModel.toLowerCase()
+  return lower.includes("openai/") || lower.includes("gpt")
+}
+
+function detectAllModels(config) {
+  const models = new Set()
+
+  // Top-level model
+  if (typeof config.model === "string" && config.model.length > 0) {
+    models.add(config.model)
+  }
+
+  // Top-level models object values
+  if (isObject(config.models)) {
+    for (const value of Object.values(config.models)) {
+      if (typeof value === "string" && value.length > 0) {
+        models.add(value)
+      }
+    }
+  }
+
+  // Provider model lists
+  if (isObject(config.provider)) {
+    for (const [providerId, providerConfig] of Object.entries(config.provider)) {
+      if (isObject(providerConfig) && isObject(providerConfig.models)) {
+        for (const [modelKey, modelEntry] of Object.entries(providerConfig.models)) {
+          if (typeof modelKey === "string" && modelKey.length > 0) {
+            models.add(qualifyModelId(providerId, modelKey))
+          }
+          if (typeof modelEntry === "string") {
+            models.add(qualifyModelId(providerId, modelEntry))
+          } else if (isObject(modelEntry) && typeof modelEntry.id === "string") {
+            models.add(qualifyModelId(providerId, modelEntry.id))
+          }
+        }
+      }
+    }
+  }
+
+  // Agent model values
+  if (isObject(config.agent)) {
+    for (const agentConfig of Object.values(config.agent)) {
+      if (isObject(agentConfig) && typeof agentConfig.model === "string" && agentConfig.model.length > 0) {
+        models.add(agentConfig.model)
+      }
+    }
+  }
+
+  return [...models]
+}
+
+function qualifyModelId(providerId, modelId) {
+  if (typeof modelId !== "string" || modelId.length === 0) return modelId
+  if (modelId.includes("/")) return modelId
+  return `${providerId}/${modelId}`
+}
+
 async function migrateResolveConfig() {
   let raw
   try {
@@ -239,6 +735,28 @@ function addPlugin(config) {
   return true
 }
 
+async function injectZAIMCPs(config) {
+  config.mcp ??= {}
+  if (!isObject(config.mcp)) return false
+
+  const added = []
+  for (const [name, mcpConfig] of Object.entries(ZAI_MCP_SERVERS)) {
+    if (config.mcp[name] === undefined) {
+      config.mcp[name] = mcpConfig
+      added.push(name)
+    }
+  }
+
+  if (added.length > 0) {
+    console.log(`[${packageName}] injected ZAI MCP server config: ${added.join(", ")}`)
+    console.log(`[${packageName}] note: API keys are not copied into opencode.json; export Z_AI_API_KEY if the MCP server requires it.`)
+    return true
+  }
+
+  console.log(`[${packageName}] ZAI MCP server already present — skipping`)
+  return false
+}
+
 function isRegisteredPluginEntry(entry) {
   if (typeof entry === "string") return isResolvePluginName(entry)
   if (Array.isArray(entry) && typeof entry[0] === "string") return isResolvePluginName(entry[0])