@khalilgharbaoui/opencode-claude-code-plugin 0.1.6 → 0.2.1

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
@@ -607,7 +751,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 +768,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();
@@ -884,12 +1036,12 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
           hasInput: input != null
         });
         const result = await new Promise(
-          (resolve2, reject) => {
+          (resolve3, reject) => {
             const entry = {
               id: callId,
               toolName,
               input,
-              resolve: resolve2,
+              resolve: resolve3,
               reject
             };
             pending.set(callId, entry);
@@ -946,11 +1098,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       }
     }
   });
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     server2.once("error", reject);
     server2.listen(0, "127.0.0.1", () => {
       server2.off("error", reject);
-      resolve2();
+      resolve3();
     });
   });
   const addr = server2.address();
@@ -997,8 +1149,8 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         entry.reject(new Error("proxy MCP server closed"));
       }
       pending.clear();
-      await new Promise((resolve2) => {
-        server2.close(() => resolve2());
+      await new Promise((resolve3) => {
+        server2.close(() => resolve3());
       });
     }
   };
@@ -1022,10 +1174,10 @@ function disallowedToolFlags(tools) {
   return out;
 }
 function readBody(req) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     const chunks = [];
     req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve2(Buffer.concat(chunks).toString("utf8")));
+    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf8")));
     req.on("error", reject);
   });
 }
@@ -1139,18 +1291,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 +1645,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,
@@ -1512,7 +1675,7 @@ var ClaudeCodeLanguageModel = class {
     let thinkingText = "";
     let resultMeta = {};
     const toolCalls = [];
-    const result = await new Promise((resolve2, reject) => {
+    const result = await new Promise((resolve3, reject) => {
       rl.on("line", (line) => {
         if (!line.trim()) return;
         try {
@@ -1603,7 +1766,7 @@ ${plan}
               durationMs: msg.duration_ms,
               usage: msg.usage
             };
-            resolve2({
+            resolve3({
               ...resultMeta,
               text: responseText,
               thinking: thinkingText,
@@ -1614,7 +1777,7 @@ ${plan}
         }
       });
       rl.on("close", () => {
-        resolve2({
+        resolve3({
           ...resultMeta,
           text: responseText,
           thinking: thinkingText,
@@ -1661,7 +1824,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 +1925,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 +1941,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 +2062,7 @@ ${plan}
               }
             });
             controllerClosed = true;
-            lineEmitter.off("line", lineHandler);
-            lineEmitter.off("close", closeHandler);
-            pendingProxyUnsubscribe?.();
-            pendingProxyUnsubscribe = null;
+            cleanupTurn();
             try {
               controller.close();
             } catch {
@@ -1930,7 +2121,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 +2242,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 +2362,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 +2482,7 @@ ${plan}
                   }
                 });
                 controllerClosed = true;
-                lineEmitter.off("line", lineHandler);
-                lineEmitter.off("close", closeHandler);
+                cleanupTurn();
                 try {
                   controller.close();
                 } catch {
@@ -2303,12 +2497,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 +2513,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 +2545,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 +2555,7 @@ ${plan}
                   { cwd }
                 );
                 controllerClosed = true;
-                lineEmitter.off("line", lineHandler);
-                lineEmitter.off("close", closeHandler);
-                pendingProxyUnsubscribe?.();
-                pendingProxyUnsubscribe = null;
+                cleanupTurn();
                 try {
                   controller.close();
                 } catch {
@@ -2695,6 +2892,117 @@ function titleizeAccount(account) {
   return normalizeAccountName(account).split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
 
+// src/cleanup-stale.ts
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  realpathSync,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
+var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
+var alreadyRan = false;
+function candidateCacheRoots() {
+  const xdg = process.env.XDG_CACHE_HOME;
+  return [
+    xdg ? join3(xdg, "opencode") : null,
+    join3(homedir2(), ".cache", "opencode"),
+    join3(homedir2(), "Library", "Caches", "opencode")
+  ].filter((p) => Boolean(p));
+}
+function userOpencodeJsonPath() {
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config");
+  return join3(xdgConfig, "opencode", "opencode.json");
+}
+function userIntendsToUseUnscoped() {
+  const cfg = userOpencodeJsonPath();
+  if (!existsSync2(cfg)) return false;
+  try {
+    const json = JSON.parse(readFileSync2(cfg, "utf8"));
+    const plugins = json.plugin;
+    if (!Array.isArray(plugins)) return false;
+    return plugins.some(
+      (entry) => typeof entry === "string" && /^opencode-claude-code-plugin(@[^/]+)?$/.test(entry)
+    );
+  } catch {
+    return false;
+  }
+}
+function ourLoadedDir() {
+  try {
+    const filePath = fileURLToPath(import.meta.url);
+    return realpathSync(resolve2(filePath, "..", ".."));
+  } catch {
+    return null;
+  }
+}
+function cleanupStaleUnscopedInstall() {
+  if (alreadyRan) return;
+  alreadyRan = true;
+  if (process.env.OPENCODE_CLAUDE_CODE_PLUGIN_NO_CLEANUP === "1") return;
+  if (userIntendsToUseUnscoped()) return;
+  const ourDir = ourLoadedDir();
+  for (const cacheRoot of candidateCacheRoots()) {
+    try {
+      cleanupOne(cacheRoot, ourDir);
+    } catch (err) {
+      log.warn("cleanup-stale: error processing cache root", {
+        cacheRoot,
+        error: String(err)
+      });
+    }
+  }
+}
+function cleanupOne(cacheRoot, ourDir) {
+  if (!existsSync2(cacheRoot)) return;
+  const stalePath = join3(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  if (!existsSync2(stalePath)) return;
+  let realStalePath = stalePath;
+  try {
+    realStalePath = realpathSync(stalePath);
+  } catch {
+  }
+  if (ourDir && realStalePath === ourDir) return;
+  const pkgJsonPath = join3(stalePath, "package.json");
+  if (!existsSync2(pkgJsonPath)) return;
+  let pkg = {};
+  try {
+    pkg = JSON.parse(readFileSync2(pkgJsonPath, "utf8"));
+  } catch {
+    return;
+  }
+  if (pkg.name !== STALE_PACKAGE_NAME) return;
+  if (!pkg.description?.includes(SUSPECT_DESCRIPTION_TOKEN)) return;
+  log.info("cleanup-stale: removing unscoped install", { stalePath });
+  try {
+    rmSync(stalePath, { recursive: true, force: true });
+  } catch (err) {
+    log.warn("cleanup-stale: rmSync failed", {
+      stalePath,
+      error: String(err)
+    });
+    return;
+  }
+  const cachePkgJson = join3(cacheRoot, "package.json");
+  if (!existsSync2(cachePkgJson)) return;
+  try {
+    const cfg = JSON.parse(readFileSync2(cachePkgJson, "utf8"));
+    if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
+      delete cfg.dependencies[STALE_PACKAGE_NAME];
+      writeFileSync3(cachePkgJson, JSON.stringify(cfg, null, 2) + "\n");
+      log.info("cleanup-stale: pruned dep from cache package.json");
+    }
+  } catch (err) {
+    log.warn("cleanup-stale: cache package.json update failed", {
+      error: String(err)
+    });
+  }
+}
+
 // src/index.ts
 function createClaudeCode(settings = {}) {
   const cliPath = settings.cliPath ?? process.env.CLAUDE_CLI_PATH ?? "claude";
@@ -2716,7 +3024,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) {
@@ -2872,22 +3182,32 @@ async function expandAccountProviders(config) {
   }
   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)
+var server = async (input) => {
+  cleanupStaleUnscopedInstall();
+  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)
+      };
+    },
+    // No `event` hook: MCP config drift is detected at turn start by the
+    // hot-reload check in `claude-code-language-model.ts`, which respawns
+    // claude safely between turns. Eviction on `global.disposed` would kill
+    // an in-flight stream and abort the user's current turn.
+    provider: {
+      id: PROVIDER_ID2,
+      models: async (provider) => defaultModelsForProvider(provider.models)
+    }
+  };
+};
 var index_default = {
   id: "@khalilgharbaoui/opencode-claude-code-plugin",
   server