@khalilgharbaoui/opencode-claude-code-plugin 0.1.5 → 0.2.0

package/dist/index.js

@@ -102,7 +102,7 @@ var CLAUDE_INTERNAL_TOOLS = /* @__PURE__ */ new Set([
   "Agent",
   "AskFollowupQuestion"
 ]);
-function mapTool(name, input) {
+function mapTool(name, input, opts) {
   if (CLAUDE_INTERNAL_TOOLS.has(name)) {
     log.debug("skipping Claude CLI internal tool", { name });
     return { name, input, executed: true, skip: true };
@@ -115,8 +115,13 @@ function mapTool(name, input) {
   }
   if (name === "WebSearch" || name === "web_search") {
     const mappedInput = input?.query ? { query: input.query } : input;
-    log.debug("mapping WebSearch", { originalInput: input, mappedInput });
-    return { name: "websearch_web_search_exa", input: mappedInput, executed: false };
+    const route = opts?.webSearch;
+    if (route && route !== "claude" && route !== "disabled") {
+      log.debug("routing WebSearch to opencode tool", { target: route, mappedInput });
+      return { name: route, input: mappedInput, executed: false };
+    }
+    log.debug("WebSearch executed by Claude CLI", { mappedInput });
+    return { name: "WebSearch", input: mappedInput, executed: true };
   }
   if (name === "TaskOutput") {
     if (!input) return { name: "bash", executed: false };
@@ -377,7 +382,8 @@ import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
-var CONFIG_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
+var FILE_NAMES = ["opencode.jsonc", "opencode.json", "config.json"];
+var PROJECT_FILE_NAMES = ["opencode.json", "opencode.jsonc"];
 function fileExists(p) {
   try {
     return fs.statSync(p).isFile();
@@ -385,35 +391,12 @@ function fileExists(p) {
     return false;
   }
 }
-function findConfigInDir(dir) {
-  for (const name of CONFIG_NAMES) {
-    const p = path.join(dir, name);
-    if (fileExists(p)) return p;
+function dirExists(p) {
+  try {
+    return fs.statSync(p).isDirectory();
+  } catch {
+    return false;
   }
-  return null;
-}
-function walkUpForConfig(startDir) {
-  const closestFirst = [];
-  let dir = path.resolve(startDir);
-  while (true) {
-    const hit = findConfigInDir(dir);
-    if (hit) closestFirst.push(hit);
-    const dotdir = path.join(dir, ".opencode");
-    const dothit = findConfigInDir(dotdir);
-    if (dothit) closestFirst.push(dothit);
-    const parent = path.dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return closestFirst.reverse();
-}
-function globalConfigs() {
-  const out = [];
-  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
-  const dir = path.join(xdg, "opencode");
-  const hit = findConfigInDir(dir);
-  if (hit) out.push(hit);
-  return out;
 }
 function stripJsonComments(text) {
   let out = "";
@@ -454,26 +437,120 @@ function stripJsonComments(text) {
   }
   return out;
 }
-function discoverConfigFiles(cwd) {
-  const files = [];
-  files.push(...globalConfigs());
-  files.push(...walkUpForConfig(cwd));
-  const dir = process.env.OPENCODE_CONFIG_DIR;
-  if (dir) {
-    const hit = findConfigInDir(dir);
-    if (hit) files.push(hit);
-  }
-  const explicit = process.env.OPENCODE_CONFIG;
-  if (explicit && fileExists(explicit)) files.push(explicit);
-  const resolvedOrder = files.map((f) => path.resolve(f));
-  const lastIndex = /* @__PURE__ */ new Map();
-  resolvedOrder.forEach((f, i) => lastIndex.set(f, i));
-  return resolvedOrder.filter((f, i) => lastIndex.get(f) === i);
+function readAndParse(file) {
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    return JSON.parse(stripJsonComments(raw));
+  } catch (e) {
+    log.warn("failed to parse opencode config", {
+      file,
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return null;
+  }
+}
+function isPlainObject(x) {
+  return typeof x === "object" && x !== null && !Array.isArray(x);
+}
+function deepMerge(target, source) {
+  const out = { ...target };
+  for (const [k, v] of Object.entries(source)) {
+    if (v === void 0) continue;
+    const existing = out[k];
+    if (isPlainObject(existing) && isPlainObject(v)) {
+      out[k] = deepMerge(existing, v);
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}
+function walkUp(opts) {
+  const out = [];
+  let current = path.resolve(opts.start);
+  while (true) {
+    for (const target of opts.targets) {
+      const candidate = path.join(current, target);
+      if (opts.predicate(candidate)) out.push(candidate);
+    }
+    if (opts.stop && current === path.resolve(opts.stop)) break;
+    const parent = path.dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return out;
+}
+function detectWorktree(cwd) {
+  const override = process.env.OPENCODE_WORKTREE;
+  if (override) return path.resolve(override);
+  let current = path.resolve(cwd);
+  while (true) {
+    const gitPath = path.join(current, ".git");
+    try {
+      if (fs.existsSync(gitPath)) return current;
+    } catch {
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+}
+function globalConfigDir() {
+  const xdg = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(xdg, "opencode");
+}
+function loadGlobalConfig() {
+  const dir = globalConfigDir();
+  let merged = {};
+  for (const name of FILE_NAMES.slice().reverse()) {
+    const file = path.join(dir, name);
+    if (!fileExists(file)) continue;
+    const parsed = readAndParse(file);
+    if (parsed) merged = deepMerge(merged, parsed);
+  }
+  return merged;
+}
+function loadProjectFilesInDir(dir) {
+  let merged = {};
+  for (const name of PROJECT_FILE_NAMES) {
+    const file = path.join(dir, name);
+    if (!fileExists(file)) continue;
+    const parsed = readAndParse(file);
+    if (parsed) merged = deepMerge(merged, parsed);
+  }
+  return merged;
+}
+function dotOpencodeDirs(cwd, worktree) {
+  const dirs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (p) => {
+    const abs = path.resolve(p);
+    if (!seen.has(abs) && dirExists(abs)) {
+      seen.add(abs);
+      dirs.push(abs);
+    }
+  };
+  for (const dir of walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: [".opencode"],
+    predicate: dirExists
+  })) {
+    push(dir);
+  }
+  const home = os.homedir();
+  if (home) {
+    const homeDot = path.join(home, ".opencode");
+    if (dirExists(homeDot)) push(homeDot);
+  }
+  const envDir = process.env.OPENCODE_CONFIG_DIR;
+  if (envDir && dirExists(envDir)) push(envDir);
+  return dirs;
 }
 function translateServer(name, spec) {
-  if (!spec || typeof spec !== "object") return null;
   if (spec.enabled === false) return null;
-  if (spec.type === "local") {
+  const type = spec.type;
+  if (type === "local") {
     const cmd = spec.command;
     if (!Array.isArray(cmd) || cmd.length === 0) {
       log.warn("skipping local MCP server with no command", { name });
@@ -489,8 +566,8 @@ function translateServer(name, spec) {
     }
     return out;
   }
-  if (spec.type === "remote") {
-    if (!spec.url || typeof spec.url !== "string") {
+  if (type === "remote") {
+    if (typeof spec.url !== "string" || !spec.url) {
       log.warn("skipping remote MCP server with no url", { name });
       return null;
     }
@@ -505,36 +582,73 @@ function translateServer(name, spec) {
   }
   log.warn("skipping MCP server with unknown type", {
     name,
-    type: spec?.type
+    type: type ?? null
   });
   return null;
 }
-function readAndParse(file) {
-  try {
-    const raw = fs.readFileSync(file, "utf8");
-    return JSON.parse(stripJsonComments(raw));
-  } catch (e) {
-    log.warn("failed to parse opencode config", {
-      file,
-      error: e instanceof Error ? e.message : String(e)
-    });
-    return null;
+function extractMcpBlock(config) {
+  const mcp = config.mcp;
+  if (!mcp || typeof mcp !== "object" || Array.isArray(mcp)) return {};
+  return mcp;
+}
+function mergeMcp(target, source) {
+  const out = { ...target };
+  for (const [name, spec] of Object.entries(source)) {
+    if (!spec || typeof spec !== "object") continue;
+    const existing = out[name];
+    if (existing && typeof existing === "object") {
+      out[name] = deepMerge(
+        existing,
+        spec
+      );
+    } else {
+      out[name] = spec;
+    }
   }
+  return out;
 }
-function bridgeOpencodeMcp(cwd) {
-  const files = discoverConfigFiles(cwd);
-  if (files.length === 0) return null;
-  const merged = {};
-  for (const file of files) {
-    const parsed = readAndParse(file);
-    const mcp = parsed?.mcp ?? null;
-    if (!mcp || typeof mcp !== "object") continue;
-    for (const [name, spec] of Object.entries(mcp)) {
-      merged[name] = spec;
+function bridgeOpencodeMcp(cwd, runtimeStatus) {
+  const worktree = detectWorktree(cwd);
+  let merged = {};
+  merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
+  const explicitConfig = process.env.OPENCODE_CONFIG;
+  if (explicitConfig && fileExists(explicitConfig)) {
+    const parsed = readAndParse(explicitConfig);
+    if (parsed) merged = mergeMcp(merged, extractMcpBlock(parsed));
+  }
+  const projectFiles = walkUp({
+    start: cwd,
+    stop: worktree,
+    targets: PROJECT_FILE_NAMES,
+    predicate: fileExists
+  });
+  const projectDirs = [];
+  const seenProjectDirs = /* @__PURE__ */ new Set();
+  for (const f of projectFiles) {
+    const d = path.dirname(f);
+    if (!seenProjectDirs.has(d)) {
+      seenProjectDirs.add(d);
+      projectDirs.push(d);
+    }
+  }
+  for (const dir of projectDirs.slice().reverse()) {
+    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
+  }
+  for (const dir of dotOpencodeDirs(cwd, worktree)) {
+    merged = mergeMcp(merged, extractMcpBlock(loadProjectFilesInDir(dir)));
+  }
+  if (runtimeStatus) {
+    for (const name of Object.keys(merged)) {
+      const status = runtimeStatus[name];
+      if (status === void 0) continue;
+      const existing = merged[name];
+      const base = existing && typeof existing === "object" ? existing : {};
+      merged[name] = { ...base, enabled: status === "connected" };
     }
   }
   const servers = {};
   for (const [name, spec] of Object.entries(merged)) {
+    if (!spec || typeof spec !== "object") continue;
     const translated = translateServer(name, spec);
     if (translated) servers[name] = translated;
   }
@@ -556,11 +670,41 @@ function bridgeOpencodeMcp(cwd) {
     return null;
   }
   log.info("bridged opencode MCP config", {
-    sources: files,
     target: outPath,
+    hash,
     servers: Object.keys(servers)
   });
-  return outPath;
+  return { path: outPath, hash };
+}
+
+// src/runtime-status.ts
+var opencodeClient = null;
+function setOpencodeClient(client) {
+  if (client && typeof client === "object") {
+    opencodeClient = client;
+  }
+}
+async function getRuntimeMcpStatus() {
+  const client = opencodeClient;
+  if (!client?.mcp?.status) return void 0;
+  try {
+    const res = await client.mcp.status();
+    const data = res.data;
+    if (!data || typeof data !== "object") return void 0;
+    const out = {};
+    for (const [name, entry] of Object.entries(data)) {
+      if (entry && typeof entry === "object") {
+        const status = entry.status;
+        if (typeof status === "string") out[name] = status;
+      }
+    }
+    return out;
+  } catch (err) {
+    log.warn("failed to fetch opencode MCP runtime status", {
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
 }
 
 // src/session-manager.ts
@@ -598,6 +742,15 @@ function deleteActiveProcess(key) {
     activeProcesses.delete(key);
   }
 }
+function evictAllSessions(reason) {
+  const count = activeProcesses.size;
+  if (count === 0) return 0;
+  log.info("evicting all claude processes", { reason, count });
+  for (const key of Array.from(activeProcesses.keys())) {
+    deleteActiveProcess(key);
+  }
+  return count;
+}
 function getClaudeSessionId(key) {
   return claudeSessions.get(key);
 }
@@ -607,7 +760,7 @@ function setClaudeSessionId(key, sessionId) {
 function deleteClaudeSessionId(key) {
   claudeSessions.delete(key);
 }
-function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer) {
+function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer, mcpHash) {
   evictIfNeeded();
   log.info("spawning new claude process", { cliPath, cliArgs, cwd, sessionKey: sessionKey2 });
   const proc = spawn(cliPath, cliArgs, {
@@ -624,8 +777,16 @@ function spawnClaudeProcess(cliPath, cliArgs, cwd, sessionKey2, proxyServer) {
   rl.on("close", () => {
     lineEmitter.emit("close");
   });
-  const ap = { proc, lineEmitter, proxyServer: proxyServer ?? null };
+  const ap = {
+    proc,
+    lineEmitter,
+    proxyServer: proxyServer ?? null,
+    mcpHash
+  };
   activeProcesses.set(sessionKey2, ap);
+  proc.on("error", (err) => {
+    log.error("claude process error", { sessionKey: sessionKey2, error: err.message });
+  });
   proc.on("exit", (code, signal) => {
     log.info("claude process exited", { code, signal, sessionKey: sessionKey2 });
     void proxyServer?.close();
@@ -1139,18 +1300,27 @@ var ClaudeCodeLanguageModel = class {
     return "no-tools";
   }
   /**
-   * Build the combined `--mcp-config` list: user-configured paths plus the
-   * auto-bridged opencode MCP config (when enabled and present) and the
-   * proxy MCP scratch file (when proxyTools are enabled).
+   * Build the combined `--mcp-config` list and return both the list and the
+   * hash of the bridged opencode MCP block (or null when bridging is off /
+   * yields nothing). The hash is used to detect mid-session config changes
+   * and respawn the underlying claude process.
+   *
+   * `runtimeStatus` is a snapshot of opencode's `client.mcp.status()`. When
+   * provided it overlays opencode's UI-toggled state on top of disk config
+   * so `/mcps` toggles propagate without a config file write.
    */
-  effectiveMcpConfig(cwd, proxyConfigPath) {
-    const user = Array.isArray(this.config.mcpConfig) ? this.config.mcpConfig.slice() : this.config.mcpConfig ? [this.config.mcpConfig] : [];
+  effectiveMcpConfig(cwd, proxyConfigPath, runtimeStatus) {
+    const paths = Array.isArray(this.config.mcpConfig) ? this.config.mcpConfig.slice() : this.config.mcpConfig ? [this.config.mcpConfig] : [];
+    let bridgedHash = null;
     if (this.config.bridgeOpencodeMcp !== false) {
-      const bridged = bridgeOpencodeMcp(cwd);
-      if (bridged) user.push(bridged);
+      const bridged = bridgeOpencodeMcp(cwd, runtimeStatus);
+      if (bridged) {
+        paths.push(bridged.path);
+        bridgedHash = bridged.hash;
+      }
     }
-    if (proxyConfigPath) user.push(proxyConfigPath);
-    return user;
+    if (proxyConfigPath) paths.push(proxyConfigPath);
+    return { paths, bridgedHash };
   }
   /** Resolve ProxyToolDef[] for the configured proxyTools names. */
   resolvedProxyTools() {
@@ -1484,14 +1654,16 @@ var ClaudeCodeLanguageModel = class {
       includeHistoryContext,
       reasoningEffort
     );
+    const runtimeStatus = await getRuntimeMcpStatus();
     const cliArgs = buildCliArgs({
       sessionKey: sk,
       skipPermissions: this.config.skipPermissions !== false,
       includeSessionId: false,
       model: this.modelId,
       permissionMode: this.config.permissionMode,
-      mcpConfig: this.effectiveMcpConfig(cwd),
-      strictMcpConfig: this.config.strictMcpConfig
+      mcpConfig: this.effectiveMcpConfig(cwd, void 0, runtimeStatus).paths,
+      strictMcpConfig: this.config.strictMcpConfig,
+      disallowedTools: this.config.webSearch === "disabled" ? ["WebSearch"] : void 0
     });
     log.info("doGenerate starting", {
       cwd,
@@ -1661,7 +1833,7 @@ ${plan}
         input: mappedInput,
         executed,
         skip
-      } = mapTool(tc.name, tc.args);
+      } = mapTool(tc.name, tc.args, { webSearch: this.config.webSearch });
       if (skip) continue;
       content.push({
         type: "tool-call",
@@ -1762,6 +1934,7 @@ ${plan}
     const self = this;
     const pendingProxyCall = getPendingProxyCall(sk);
     const pendingProxyResult = pendingProxyCall ? this.extractPendingProxyResult(options.prompt, pendingProxyCall.toolCallId) : null;
+    const runtimeStatus = await getRuntimeMcpStatus();
     log.info("doStream starting", {
       cwd,
       model: this.modelId,
@@ -1777,25 +1950,55 @@ ${plan}
         let proc;
         let lineEmitter;
         let proxyServer = activeProcess?.proxyServer ?? null;
+        if (activeProcess && self.config.hotReloadMcp !== false && self.config.bridgeOpencodeMcp !== false) {
+          const probe = self.effectiveMcpConfig(cwd, void 0, runtimeStatus);
+          const previousHash = activeProcess.mcpHash ?? null;
+          if (previousHash !== probe.bridgedHash) {
+            log.info("opencode MCP config changed, respawning claude", {
+              sk,
+              previousHash,
+              currentHash: probe.bridgedHash
+            });
+            deleteActiveProcess(sk);
+            activeProcess = void 0;
+            proxyServer = null;
+          }
+        }
         const setup = async () => {
           if (!proxyServer && resolvedProxy) {
             proxyServer = await self.ensureProxyServer(resolvedProxy, sk);
           }
+          const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
+          const extraDisallowed = [];
+          if (self.config.webSearch === "disabled") extraDisallowed.push("WebSearch");
+          const allDisallowed = [...proxyDisallowed, ...extraDisallowed];
+          const mcp = self.effectiveMcpConfig(
+            cwd,
+            proxyServer?.configPath(),
+            runtimeStatus
+          );
           const cliArgs = buildCliArgs({
             sessionKey: sk,
             skipPermissions,
             model: self.modelId,
             permissionMode: self.config.permissionMode,
-            mcpConfig: self.effectiveMcpConfig(cwd, proxyServer?.configPath()),
+            mcpConfig: mcp.paths,
             strictMcpConfig: self.config.strictMcpConfig,
-            disallowedTools: resolvedProxy ? disallowedToolFlags(resolvedProxy) : void 0
+            disallowedTools: allDisallowed.length > 0 ? allDisallowed : void 0
           });
           if (activeProcess) {
             proc = activeProcess.proc;
             lineEmitter = activeProcess.lineEmitter;
             log.debug("reusing active process", { sk });
           } else {
-            const ap = spawnClaudeProcess(cliPath, cliArgs, cwd, sk, proxyServer);
+            const ap = spawnClaudeProcess(
+              cliPath,
+              cliArgs,
+              cwd,
+              sk,
+              proxyServer,
+              mcp.bridgedHash
+            );
             proc = ap.proc;
             lineEmitter = ap.lineEmitter;
             activeProcess = ap;
@@ -1868,10 +2071,7 @@ ${plan}
               }
             });
             controllerClosed = true;
-            lineEmitter.off("line", lineHandler);
-            lineEmitter.off("close", closeHandler);
-            pendingProxyUnsubscribe?.();
-            pendingProxyUnsubscribe = null;
+            cleanupTurn();
             try {
               controller.close();
             } catch {
@@ -1930,7 +2130,11 @@ ${plan}
                     inputJson: ""
                   });
                   if (block.name !== "AskUserQuestion" && block.name !== "ask_user_question" && block.name !== "ExitPlanMode" && !block.name.startsWith(PROXY_TOOL_PREFIX)) {
-                    const { name: mappedName, skip, executed } = mapTool(block.name);
+                    const { name: mappedName, skip, executed } = mapTool(
+                      block.name,
+                      void 0,
+                      { webSearch: self.config.webSearch }
+                    );
                     if (!skip) {
                       controller.enqueue({
                         type: "tool-input-start",
@@ -2047,7 +2251,7 @@ ${plan}
                       input: mappedInput,
                       executed,
                       skip
-                    } = mapTool(tc.name, parsedInput);
+                    } = mapTool(tc.name, parsedInput, { webSearch: self.config.webSearch });
                     if (!skip) {
                       toolCallsById.set(tc.id, {
                         id: tc.id,
@@ -2167,7 +2371,7 @@ ${plan}
                         input: mappedInput,
                         executed,
                         skip
-                      } = mapTool(block.name, parsedInput);
+                      } = mapTool(block.name, parsedInput, { webSearch: self.config.webSearch });
                       if (!skip) {
                         if (!executed) skipResultForIds.add(block.id);
                         controller.enqueue({
@@ -2287,8 +2491,7 @@ ${plan}
                   }
                 });
                 controllerClosed = true;
-                lineEmitter.off("line", lineHandler);
-                lineEmitter.off("close", closeHandler);
+                cleanupTurn();
                 try {
                   controller.close();
                 } catch {
@@ -2303,12 +2506,8 @@ ${plan}
           const closeHandler = () => {
             log.debug("readline closed");
             if (controllerClosed) return;
-            clearFallbackTimer();
             controllerClosed = true;
-            lineEmitter.off("line", lineHandler);
-            lineEmitter.off("close", closeHandler);
-            pendingProxyUnsubscribe?.();
-            pendingProxyUnsubscribe = null;
+            cleanupTurn();
             endTextBlock();
             controller.enqueue({
               type: "finish",
@@ -2323,6 +2522,28 @@ ${plan}
             } catch {
             }
           };
+          let cleanedUp = false;
+          const cleanupTurn = () => {
+            if (cleanedUp) return;
+            cleanedUp = true;
+            clearFallbackTimer();
+            lineEmitter.off("line", lineHandler);
+            lineEmitter.off("close", closeHandler);
+            pendingProxyUnsubscribe?.();
+            pendingProxyUnsubscribe = null;
+            proc.off("error", procErrorHandler);
+          };
+          const procErrorHandler = (err) => {
+            log.error("process error", { error: err.message });
+            if (controllerClosed) return;
+            controllerClosed = true;
+            cleanupTurn();
+            controller.enqueue({ type: "error", error: err });
+            try {
+              controller.close();
+            } catch {
+            }
+          };
           lineEmitter.on("line", lineHandler);
           lineEmitter.on("close", closeHandler);
           pendingProxyUnsubscribe = onPendingProxyCall(sk, (call) => {
@@ -2333,19 +2554,7 @@ ${plan}
             });
             finishWithToolCall(call);
           });
-          proc.on("error", (err) => {
-            log.error("process error", { error: err.message });
-            clearFallbackTimer();
-            if (controllerClosed) return;
-            controllerClosed = true;
-            pendingProxyUnsubscribe?.();
-            pendingProxyUnsubscribe = null;
-            controller.enqueue({ type: "error", error: err });
-            try {
-              controller.close();
-            } catch {
-            }
-          });
+          proc.on("error", procErrorHandler);
           if (options.abortSignal) {
             options.abortSignal.addEventListener("abort", () => {
               if (turnCompleted || controllerClosed) return;
@@ -2355,10 +2564,7 @@ ${plan}
                   { cwd }
                 );
                 controllerClosed = true;
-                lineEmitter.off("line", lineHandler);
-                lineEmitter.off("close", closeHandler);
-                pendingProxyUnsubscribe?.();
-                pendingProxyUnsubscribe = null;
+                cleanupTurn();
                 try {
                   controller.close();
                 } catch {
@@ -2457,10 +2663,43 @@ function defineModel(opts) {
 var haikuCost = { input: 1e-6, output: 5e-6, cacheRead: 1e-7, cacheWrite: 125e-8 };
 var sonnetCost = { input: 3e-6, output: 15e-6, cacheRead: 3e-7, cacheWrite: 375e-8 };
 var opusCost = { input: 15e-6, output: 75e-6, cacheRead: 15e-7, cacheWrite: 1875e-8 };
+function toConfigModel(model) {
+  const inputMods = [];
+  const outputMods = [];
+  for (const [k, v] of Object.entries(model.capabilities.input)) {
+    if (v) inputMods.push(k);
+  }
+  for (const [k, v] of Object.entries(model.capabilities.output)) {
+    if (v) outputMods.push(k);
+  }
+  return {
+    id: model.api.id,
+    name: model.name,
+    status: model.status,
+    family: model.family ?? "",
+    release_date: model.release_date,
+    temperature: model.capabilities.temperature,
+    reasoning: model.capabilities.reasoning,
+    attachment: model.capabilities.attachment,
+    tool_call: model.capabilities.toolcall,
+    modalities: { input: inputMods, output: outputMods },
+    interleaved: model.capabilities.interleaved,
+    cost: {
+      input: model.cost.input,
+      output: model.cost.output,
+      cache_read: model.cost.cache.read,
+      cache_write: model.cost.cache.write
+    },
+    limit: model.limit,
+    options: model.options,
+    headers: model.headers,
+    variants: model.variants
+  };
+}
 var defaultModels = {
   "claude-haiku-4-5": defineModel({
     id: "claude-haiku-4-5",
-    name: "Claude Code Haiku 4.5",
+    name: "Claude Haiku 4.5",
     family: "haiku",
     reasoning: false,
     context: 2e5,
@@ -2470,7 +2709,7 @@ var defaultModels = {
   }),
   "claude-sonnet-4-5": defineModel({
     id: "claude-sonnet-4-5",
-    name: "Claude Code Sonnet 4.5",
+    name: "Claude Sonnet 4.5",
     family: "sonnet",
     reasoning: true,
     context: 1e6,
@@ -2480,7 +2719,7 @@ var defaultModels = {
   }),
   "claude-sonnet-4-6": defineModel({
     id: "claude-sonnet-4-6",
-    name: "Claude Code Sonnet 4.6",
+    name: "Claude Sonnet 4.6",
     family: "sonnet",
     reasoning: true,
     context: 1e6,
@@ -2490,7 +2729,7 @@ var defaultModels = {
   }),
   "claude-opus-4-5": defineModel({
     id: "claude-opus-4-5",
-    name: "Claude Code Opus 4.5",
+    name: "Claude Opus 4.5",
     family: "opus",
     reasoning: true,
     context: 1e6,
@@ -2500,7 +2739,7 @@ var defaultModels = {
   }),
   "claude-opus-4-6": defineModel({
     id: "claude-opus-4-6",
-    name: "Claude Code Opus 4.6",
+    name: "Claude Opus 4.6",
     family: "opus",
     reasoning: true,
     context: 1e6,
@@ -2510,7 +2749,7 @@ var defaultModels = {
   }),
   "claude-opus-4-7": defineModel({
     id: "claude-opus-4-7",
-    name: "Claude Code Opus 4.7",
+    name: "Claude Opus 4.7",
     family: "opus",
     reasoning: true,
     context: 1e6,
@@ -2569,7 +2808,15 @@ async function ensureAccountRuntime(account, baseCliPath) {
   if (!configDir) return { cliPath: baseCliPath };
   const expandedConfigDir = expandHome(configDir);
   await mkdir(expandedConfigDir, { recursive: true });
-  await ensureSharedCapabilities(expandedConfigDir);
+  try {
+    await ensureSharedCapabilities(expandedConfigDir);
+  } catch (err) {
+    log.warn("failed to symlink shared capabilities; continuing anyway", {
+      account,
+      configDir: expandedConfigDir,
+      error: String(err)
+    });
+  }
   const cliPath = await writeAccountWrapper(
     normalizeAccountName(account),
     baseCliPath,
@@ -2675,7 +2922,9 @@ function createClaudeCode(settings = {}) {
       controlRequestBehavior: settings.controlRequestBehavior ?? "allow",
       controlRequestToolBehaviors: settings.controlRequestToolBehaviors,
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
-      proxyTools
+      proxyTools,
+      webSearch: settings.webSearch,
+      hotReloadMcp: settings.hotReloadMcp ?? true
     });
   };
   const provider = function(modelId) {
@@ -2742,6 +2991,31 @@ function defaultModelsForProvider(providerModels, providerID = PROVIDER_ID2, mod
   }
   return models;
 }
+function configModelsForProvider(providerModels, providerID, modelSuffix) {
+  const models = {};
+  for (const [id, model] of Object.entries(defaultModels)) {
+    const modelId = modelSuffix ? `${id}@${modelSuffix}` : id;
+    const existing = providerModels[id] ?? providerModels[modelId];
+    const full = {
+      ...model,
+      id: modelId,
+      providerID,
+      api: {
+        ...model.api,
+        id: modelId,
+        npm: existing?.api?.npm ?? model.api.npm,
+        url: existing?.api?.url ?? model.api.url
+      }
+    };
+    models[modelId] = toConfigModel(full);
+  }
+  for (const [id, model] of Object.entries(providerModels)) {
+    if (!(id in models)) {
+      models[id] = toConfigModel({ ...model, providerID });
+    }
+  }
+  return models;
+}
 async function providerConfig(existing, providerID = PROVIDER_ID2, optionDefaults = {}, displayName) {
   const mergedOptions = {
     cliPath: "claude",
@@ -2769,47 +3043,80 @@ async function expandAccountProviders(config) {
   if (!accounts) return false;
   config.provider ??= {};
   const seedOptions = cleanProviderOptions(seed?.options);
+  let expandedCount = 0;
   for (const account of accounts) {
     const providerID = accountProviderId(account);
-    const existing = config.provider[providerID];
-    const modelSuffix = accountModelSuffix(account);
-    config.provider[providerID] = {
-      ...existing,
-      ...await providerConfig(
-        existing,
-        providerID,
-        {
-          ...seedOptions,
-          account
-        },
-        accountDisplayName(account)
-      ),
-      models: defaultModelsForProvider(
-        existing?.models ?? seed?.models ?? {},
+    try {
+      const existing = config.provider[providerID];
+      const modelSuffix = accountModelSuffix(account);
+      config.provider[providerID] = {
+        ...existing,
+        ...await providerConfig(
+          existing,
+          providerID,
+          {
+            ...seedOptions,
+            account
+          },
+          accountDisplayName(account)
+        ),
+        models: configModelsForProvider(
+          existing?.models ?? seed?.models ?? {},
+          providerID,
+          modelSuffix
+        )
+      };
+      expandedCount++;
+    } catch (err) {
+      log.error("failed to expand account provider", {
+        account,
         providerID,
-        modelSuffix
-      )
-    };
+        error: String(err)
+      });
+    }
   }
-  delete config.provider[PROVIDER_ID2];
-  return true;
+  if (expandedCount > 0) {
+    delete config.provider[PROVIDER_ID2];
+  }
+  return expandedCount > 0;
 }
-var server = async () => ({
-  config: async (config) => {
-    config.provider ??= {};
-    const expanded = await expandAccountProviders(config);
-    if (expanded) return;
-    const existing = config.provider[PROVIDER_ID2];
-    config.provider[PROVIDER_ID2] = {
-      ...existing,
-      ...await providerConfig(existing)
-    };
-  },
-  provider: {
-    id: PROVIDER_ID2,
-    models: async (provider) => defaultModelsForProvider(provider.models)
+function readEventType(ev) {
+  if (!ev || typeof ev !== "object") return void 0;
+  const e = ev;
+  if (typeof e.type === "string") return e.type;
+  const payload = e.payload;
+  if (payload && typeof payload === "object") {
+    const t = payload.type;
+    if (typeof t === "string") return t;
+  }
+  return void 0;
+}
+var server = async (input) => {
+  if (input && typeof input === "object" && "client" in input) {
+    setOpencodeClient(input.client);
   }
-});
+  return {
+    config: async (config) => {
+      config.provider ??= {};
+      const expanded = await expandAccountProviders(config);
+      if (expanded) return;
+      const existing = config.provider[PROVIDER_ID2];
+      config.provider[PROVIDER_ID2] = {
+        ...existing,
+        ...await providerConfig(existing)
+      };
+    },
+    event: async ({ event }) => {
+      if (readEventType(event) === "global.disposed") {
+        evictAllSessions("global.disposed");
+      }
+    },
+    provider: {
+      id: PROVIDER_ID2,
+      models: async (provider) => defaultModelsForProvider(provider.models)
+    }
+  };
+};
 var index_default = {
   id: "@khalilgharbaoui/opencode-claude-code-plugin",
   server