@khalilgharbaoui/opencode-claude-code-plugin 0.3.0 → 0.4.1

package/dist/index.js

@@ -19,7 +19,7 @@ var log = {
     console.error(fmt("NOTICE", msg, data));
   },
   warn(msg, data) {
-    if (DEBUG) console.error(fmt("WARN", msg, data));
+    console.error(fmt("WARN", msg, data));
   },
   error(msg, data) {
     console.error(fmt("ERROR", msg, data));
@@ -381,22 +381,49 @@ Now continuing with the current message:
 }
 
 // src/mcp-bridge.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import * as crypto from "crypto";
+
+// src/tmp.ts
 import * as fs from "fs";
-import * as path from "path";
 import * as os from "os";
-import * as crypto from "crypto";
+import * as path from "path";
+var PLUGIN_TMP_DIR = path.join(
+  os.tmpdir(),
+  `opencode-claude-code-${process.pid}`
+);
+var registered = false;
+function pluginTmpDir() {
+  if (!fs.existsSync(PLUGIN_TMP_DIR)) {
+    fs.mkdirSync(PLUGIN_TMP_DIR, { recursive: true });
+  }
+  if (!registered) {
+    registered = true;
+    process.on("exit", () => {
+      try {
+        fs.rmSync(PLUGIN_TMP_DIR, { recursive: true, force: true });
+      } catch {
+      }
+    });
+  }
+  return PLUGIN_TMP_DIR;
+}
+
+// src/mcp-bridge.ts
 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();
+    return fs2.statSync(p).isFile();
   } catch {
     return false;
   }
 }
 function dirExists(p) {
   try {
-    return fs.statSync(p).isDirectory();
+    return fs2.statSync(p).isDirectory();
   } catch {
     return false;
   }
@@ -442,7 +469,7 @@ function stripJsonComments(text) {
 }
 function readAndParse(file) {
   try {
-    const raw = fs.readFileSync(file, "utf8");
+    const raw = fs2.readFileSync(file, "utf8");
     return JSON.parse(stripJsonComments(raw));
   } catch (e) {
     log.warn("failed to parse opencode config", {
@@ -470,14 +497,14 @@ function deepMerge(target, source) {
 }
 function walkUp(opts) {
   const out = [];
-  let current = path.resolve(opts.start);
+  let current = path2.resolve(opts.start);
   while (true) {
     for (const target of opts.targets) {
-      const candidate = path.join(current, target);
+      const candidate = path2.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 (opts.stop && current === path2.resolve(opts.stop)) break;
+    const parent = path2.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -485,28 +512,28 @@ function walkUp(opts) {
 }
 function detectWorktree(cwd) {
   const override = process.env.OPENCODE_WORKTREE;
-  if (override) return path.resolve(override);
-  let current = path.resolve(cwd);
+  if (override) return path2.resolve(override);
+  let current = path2.resolve(cwd);
   while (true) {
-    const gitPath = path.join(current, ".git");
+    const gitPath = path2.join(current, ".git");
     try {
-      if (fs.existsSync(gitPath)) return current;
+      if (fs2.existsSync(gitPath)) return current;
     } catch {
     }
-    const parent = path.dirname(current);
+    const parent = path2.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");
+  const xdg = process.env.XDG_CONFIG_HOME ?? path2.join(os2.homedir(), ".config");
+  return path2.join(xdg, "opencode");
 }
 function loadGlobalConfig() {
   const dir = globalConfigDir();
   let merged = {};
   for (const name of FILE_NAMES.slice().reverse()) {
-    const file = path.join(dir, name);
+    const file = path2.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -516,7 +543,7 @@ function loadGlobalConfig() {
 function loadProjectFilesInDir(dir) {
   let merged = {};
   for (const name of PROJECT_FILE_NAMES) {
-    const file = path.join(dir, name);
+    const file = path2.join(dir, name);
     if (!fileExists(file)) continue;
     const parsed = readAndParse(file);
     if (parsed) merged = deepMerge(merged, parsed);
@@ -527,7 +554,7 @@ function dotOpencodeDirs(cwd, worktree) {
   const dirs = [];
   const seen = /* @__PURE__ */ new Set();
   const push = (p) => {
-    const abs = path.resolve(p);
+    const abs = path2.resolve(p);
     if (!seen.has(abs) && dirExists(abs)) {
       seen.add(abs);
       dirs.push(abs);
@@ -541,9 +568,9 @@ function dotOpencodeDirs(cwd, worktree) {
   })) {
     push(dir);
   }
-  const home = os.homedir();
+  const home = os2.homedir();
   if (home) {
-    const homeDot = path.join(home, ".opencode");
+    const homeDot = path2.join(home, ".opencode");
     if (dirExists(homeDot)) push(homeDot);
   }
   const envDir = process.env.OPENCODE_CONFIG_DIR;
@@ -610,7 +637,7 @@ function mergeMcp(target, source) {
   }
   return out;
 }
-function bridgeOpencodeMcp(cwd, runtimeStatus) {
+function bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers) {
   const worktree = detectWorktree(cwd);
   let merged = {};
   merged = mergeMcp(merged, extractMcpBlock(loadGlobalConfig()));
@@ -628,7 +655,7 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
   const projectDirs = [];
   const seenProjectDirs = /* @__PURE__ */ new Set();
   for (const f of projectFiles) {
-    const d = path.dirname(f);
+    const d = path2.dirname(f);
     if (!seenProjectDirs.has(d)) {
       seenProjectDirs.add(d);
       projectDirs.push(d);
@@ -649,22 +676,44 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
       merged[name] = { ...base, enabled: status === "connected" };
     }
   }
+  const allEnabledServerNames = [];
+  for (const [name, spec] of Object.entries(merged)) {
+    if (!spec || typeof spec !== "object") continue;
+    const enabled = spec.enabled;
+    if (enabled === false) continue;
+    allEnabledServerNames.push(name);
+  }
   const servers = {};
+  const bridgedServerNames = [];
   for (const [name, spec] of Object.entries(merged)) {
     if (!spec || typeof spec !== "object") continue;
+    if (excludeServers?.has(name)) continue;
     const translated = translateServer(name, spec);
-    if (translated) servers[name] = translated;
+    if (translated) {
+      servers[name] = translated;
+      bridgedServerNames.push(name);
+    }
+  }
+  const mergedBody = JSON.stringify({ mcpServers: merged }, null, 2);
+  const hash = crypto.createHash("sha256").update(mergedBody).digest("hex").slice(0, 12);
+  if (Object.keys(servers).length === 0) {
+    const allEnabledServersExcluded = excludeServers && allEnabledServerNames.length > 0 && allEnabledServerNames.every((name) => excludeServers.has(name));
+    if (!allEnabledServersExcluded) return null;
+    return {
+      path: "",
+      hash,
+      serverNames: [],
+      allEnabledServerNames
+    };
   }
-  if (Object.keys(servers).length === 0) return null;
   const body = JSON.stringify({ mcpServers: servers }, null, 2);
-  const hash = crypto.createHash("sha256").update(body).digest("hex").slice(0, 12);
-  const outPath = path.join(
-    os.tmpdir(),
-    `opencode-claude-code-mcp-${hash}.json`
+  const outPath = path2.join(
+    pluginTmpDir(),
+    `mcp-${hash}.json`
   );
   try {
     if (!fileExists(outPath)) {
-      fs.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs2.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
     }
   } catch (e) {
     log.warn("failed to write bridged MCP config", {
@@ -675,9 +724,15 @@ function bridgeOpencodeMcp(cwd, runtimeStatus) {
   log.info("bridged opencode MCP config", {
     target: outPath,
     hash,
-    servers: Object.keys(servers)
+    servers: bridgedServerNames,
+    excluded: excludeServers ? Array.from(excludeServers) : []
   });
-  return { path: outPath, hash };
+  return {
+    path: outPath,
+    hash,
+    serverNames: bridgedServerNames,
+    allEnabledServerNames
+  };
 }
 
 // src/runtime-status.ts
@@ -709,6 +764,35 @@ async function getRuntimeMcpStatus() {
     return void 0;
   }
 }
+async function fetchOpencodeToolList(provider, model, directory) {
+  const client = opencodeClient;
+  if (!client?.tool?.list) return void 0;
+  try {
+    const res = await client.tool.list({
+      query: { provider, model, ...directory ? { directory } : {} }
+    });
+    const data = res.data;
+    if (!Array.isArray(data)) return void 0;
+    const out = [];
+    for (const entry of data) {
+      if (!entry || typeof entry !== "object") continue;
+      const e = entry;
+      const id = typeof e.id === "string" ? e.id : null;
+      const description = typeof e.description === "string" ? e.description : "";
+      const parameters = e.parameters && typeof e.parameters === "object" ? e.parameters : {};
+      if (!id) continue;
+      out.push({ id, description, parameters });
+    }
+    return out;
+  } catch (err) {
+    log.warn("failed to fetch opencode tool list", {
+      provider,
+      model,
+      error: err instanceof Error ? err.message : String(err)
+    });
+    return void 0;
+  }
+}
 
 // src/session-manager.ts
 import { spawn } from "child_process";
@@ -872,14 +956,14 @@ function sessionKey(cwd, modelId) {
 
 // src/proxy-mcp.ts
 import { createServer } from "http";
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as os2 from "os";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import * as crypto2 from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
 var PROTOCOL_VERSION = "2024-11-05";
 var SERVER_NAME = "opencode_proxy";
 var PROXY_TOOL_PREFIX = `mcp__${SERVER_NAME}__`;
+var PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 var DEFAULT_PROXY_TOOLS = [
   {
     name: "bash",
@@ -1050,6 +1134,7 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
           toolName,
           hasInput: input != null
         });
+        let timer = null;
         const result = await new Promise(
           (resolve3, reject) => {
             const entry = {
@@ -1060,9 +1145,24 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
               reject
             };
             pending.set(callId, entry);
+            timer = setTimeout(() => {
+              if (!pending.has(callId)) return;
+              pending.delete(callId);
+              log.warn("proxy-mcp tool call timed out", {
+                callId,
+                toolName,
+                timeoutMs: PROXY_CALL_TIMEOUT_MS
+              });
+              reject(
+                new Error(
+                  `Proxy tool '${toolName}' timed out after ${PROXY_CALL_TIMEOUT_MS}ms waiting for opencode to resolve the call`
+                )
+              );
+            }, PROXY_CALL_TIMEOUT_MS);
             calls.emit("call", entry);
           }
         ).finally(() => {
+          if (timer) clearTimeout(timer);
           pending.delete(callId);
         });
         if (result.kind === "error") {
@@ -1151,11 +1251,11 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
         2
       );
       const hash = crypto2.createHash("sha256").update(body).digest("hex").slice(0, 12);
-      const outPath = path2.join(
-        os2.tmpdir(),
-        `opencode-claude-code-proxy-${hash}.json`
+      const outPath = path3.join(
+        pluginTmpDir(),
+        `proxy-${hash}.json`
       );
-      fs2.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
+      fs3.writeFileSync(outPath, body, { encoding: "utf8", mode: 384 });
       configFilePath = outPath;
       return outPath;
     },
@@ -1167,6 +1267,13 @@ async function createProxyMcpServer(tools = DEFAULT_PROXY_TOOLS) {
       await new Promise((resolve3) => {
         server2.close(() => resolve3());
       });
+      if (configFilePath) {
+        try {
+          fs3.unlinkSync(configFilePath);
+        } catch {
+        }
+        configFilePath = null;
+      }
     }
   };
   return api;
@@ -1214,6 +1321,7 @@ function writeJson(res, body) {
 import { EventEmitter as EventEmitter3 } from "events";
 var pendingBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter3();
+var PENDING_PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 function eventName(sessionKey2) {
   return `pending:${sessionKey2}`;
 }
@@ -1225,16 +1333,50 @@ function onPendingProxyCall(sessionKey2, handler) {
 function queuePendingProxyCall(sessionKey2, call) {
   const existing = pendingBySession.get(sessionKey2);
   if (existing) {
+    if (Date.now() - existing.createdAt < PENDING_PROXY_CALL_TIMEOUT_MS) {
+      call.reject(
+        new Error(`Another proxy tool call is already pending for ${sessionKey2}`)
+      );
+      log.warn("rejected overlapping proxy call", {
+        sessionKey: sessionKey2,
+        existingToolCallId: existing.toolCallId,
+        existingToolName: existing.toolName,
+        toolCallId: call.id,
+        toolName: call.toolName
+      });
+      return existing;
+    }
+    clearTimeout(existing.timer);
     existing.reject(
-      new Error(`Another proxy tool call is already pending for ${sessionKey2}`)
+      new Error(
+        `Stale proxy tool call expired after ${PENDING_PROXY_CALL_TIMEOUT_MS}ms for ${sessionKey2}`
+      )
     );
     pendingBySession.delete(sessionKey2);
   }
+  const timer = setTimeout(() => {
+    const current = pendingBySession.get(sessionKey2);
+    if (!current || current.toolCallId !== call.id) return;
+    pendingBySession.delete(sessionKey2);
+    current.reject(
+      new Error(
+        `Proxy tool call '${call.toolName}' timed out after ${PENDING_PROXY_CALL_TIMEOUT_MS}ms waiting for opencode to resolve the call`
+      )
+    );
+    log.warn("timed out pending proxy call", {
+      sessionKey: sessionKey2,
+      toolCallId: call.id,
+      toolName: call.toolName,
+      timeoutMs: PENDING_PROXY_CALL_TIMEOUT_MS
+    });
+  }, PENDING_PROXY_CALL_TIMEOUT_MS);
   const pending = {
     sessionKey: sessionKey2,
     toolCallId: call.id,
     toolName: call.toolName,
     input: call.input,
+    createdAt: Date.now(),
+    timer,
     resolve: call.resolve,
     reject: call.reject
   };
@@ -1254,6 +1396,7 @@ function resolvePendingProxyCall(sessionKey2, result) {
   const pending = pendingBySession.get(sessionKey2);
   if (!pending) return false;
   pendingBySession.delete(sessionKey2);
+  clearTimeout(pending.timer);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
     sessionKey: sessionKey2,
@@ -1266,9 +1409,9 @@ function resolvePendingProxyCall(sessionKey2, result) {
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { unlink as unlink2 } from "fs/promises";
-import { homedir as homedir2, tmpdir as tmpdir3 } from "os";
+import { homedir as homedir2, tmpdir as tmpdir2 } from "os";
 import { randomUUID as randomUUID2 } from "crypto";
-import { dirname as dirname2, join as join3 } from "path";
+import { dirname as dirname2, join as join4 } from "path";
 function hasNewUserContent(prompt) {
   for (let i = prompt.length - 1; i >= 0; i--) {
     const msg = prompt[i];
@@ -1283,14 +1426,15 @@ function hasNewUserContent(prompt) {
       for (const part of content) {
         if (part.type === "text" && part.text && part.text.trim()) return true;
         if (part.type === "tool-result") return true;
+        if (part.type === "image" || part.type === "file") return true;
       }
     }
   }
   return false;
 }
-function readPromptFileIfPresent(path4) {
+function readPromptFileIfPresent(path5) {
   try {
-    const content = readFileSync2(path4, "utf8").trim();
+    const content = readFileSync2(path5, "utf8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -1299,7 +1443,7 @@ function readPromptFileIfPresent(path4) {
 function nearestWorkspaceAgentsPrompt(cwd) {
   let dir = cwd;
   while (true) {
-    const content = readPromptFileIfPresent(join3(dir, "AGENTS.md"));
+    const content = readPromptFileIfPresent(join4(dir, "AGENTS.md"));
     if (content) return content;
     const parent = dirname2(dir);
     if (parent === dir) return void 0;
@@ -1308,17 +1452,17 @@ function nearestWorkspaceAgentsPrompt(cwd) {
 }
 function buildAppendedSystemPrompt(cwd) {
   const parts = [];
-  const configRoot = process.env.XDG_CONFIG_HOME ?? join3(homedir2(), ".config");
-  const globalAgents = readPromptFileIfPresent(join3(configRoot, "opencode", "AGENTS.md"));
+  const configRoot = process.env.XDG_CONFIG_HOME ?? join4(homedir2(), ".config");
+  const globalAgents = readPromptFileIfPresent(join4(configRoot, "opencode", "AGENTS.md"));
   const workspaceAgents = nearestWorkspaceAgentsPrompt(cwd);
   if (globalAgents) parts.push(globalAgents);
   if (workspaceAgents && workspaceAgents !== globalAgents) parts.push(workspaceAgents);
   const content = parts.join("\n\n");
   if (!content) return void 0;
-  const path4 = join3(tmpdir3(), `opencode-cc-sys-${randomUUID2()}.md`);
+  const path5 = join4(tmpdir2(), `opencode-cc-sys-${randomUUID2()}.md`);
   try {
-    writeFileSync3(path4, content, "utf8");
-    return path4;
+    writeFileSync3(path5, content, "utf8");
+    return path5;
   } catch (err) {
     log.warn("failed to write system prompt file", { error: String(err) });
     return void 0;
@@ -1381,18 +1525,20 @@ var ClaudeCodeLanguageModel = class {
    * 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, runtimeStatus) {
+  effectiveMcpConfig(cwd, proxyConfigPath, runtimeStatus, excludeServers) {
     const paths = Array.isArray(this.config.mcpConfig) ? this.config.mcpConfig.slice() : this.config.mcpConfig ? [this.config.mcpConfig] : [];
     let bridgedHash = null;
+    let allEnabledServerNames = [];
     if (this.config.bridgeOpencodeMcp !== false) {
-      const bridged = bridgeOpencodeMcp(cwd, runtimeStatus);
+      const bridged = bridgeOpencodeMcp(cwd, runtimeStatus, excludeServers);
       if (bridged) {
-        paths.push(bridged.path);
+        if (bridged.path) paths.push(bridged.path);
         bridgedHash = bridged.hash;
+        allEnabledServerNames = bridged.allEnabledServerNames;
       }
     }
     if (proxyConfigPath) paths.push(proxyConfigPath);
-    return { paths, bridgedHash };
+    return { paths, bridgedHash, allEnabledServerNames };
   }
   /** Resolve ProxyToolDef[] for the configured proxyTools names. */
   resolvedProxyTools() {
@@ -1408,6 +1554,45 @@ var ClaudeCodeLanguageModel = class {
     }
     return picked.length > 0 ? picked : null;
   }
+  /**
+   * Resolve ProxyToolDef[] for opencode's MCP-bridged tools so they go
+   * through the in-process proxy instead of being bridged into Claude CLI's
+   * `--mcp-config`. Direct bridging causes double execution because both
+   * Claude CLI's own MCP child and opencode hold their own connection to
+   * the same server; routing through the proxy keeps a single execution
+   * site (opencode). Returns null when the feature is disabled, the SDK
+   * client is unavailable, or no MCP servers are configured.
+   */
+  async resolvedProxyMcpTools(allEnabledServerNames) {
+    if (this.config.proxyOpencodeMcpTools === false) return null;
+    if (this.config.bridgeOpencodeMcp === false) return null;
+    if (allEnabledServerNames.length === 0) return null;
+    const items = await fetchOpencodeToolList(
+      this.config.provider,
+      this.modelId,
+      this.config.cwd
+    );
+    if (!items || items.length === 0) return null;
+    const serversByLengthDesc = [...allEnabledServerNames].sort(
+      (a, b) => b.length - a.length
+    );
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of items) {
+      const matchedServer = serversByLengthDesc.find(
+        (name) => item.id === name || item.id.startsWith(`${name}_`)
+      );
+      if (!matchedServer) continue;
+      if (seen.has(item.id)) continue;
+      seen.add(item.id);
+      out.push({
+        name: item.id,
+        description: item.description ?? "",
+        inputSchema: item.parameters && typeof item.parameters === "object" ? item.parameters : { type: "object", properties: {} }
+      });
+    }
+    return out.length > 0 ? out : null;
+  }
   /**
    * Create a proxy MCP server for a single active Claude process/session.
    * The process lifecycle owns the server lifecycle via session-manager.
@@ -1689,7 +1874,7 @@ var ClaudeCodeLanguageModel = class {
     const scope = this.requestScope(options);
     const affinity = this.sessionAffinity(options);
     const sk = sessionKey(cwd, `${this.modelId}::${scope}::${affinity}`);
-    if (scope === "tools" && this.resolvedProxyTools()) {
+    if (scope === "tools" && (this.resolvedProxyTools() || this.config.proxyOpencodeMcpTools !== false && this.config.bridgeOpencodeMcp !== false)) {
       return this.doGenerateViaStream(options);
     }
     if (scope === "no-tools") {
@@ -2086,8 +2271,18 @@ ${plan}
           }
         }
         const setup = async () => {
-          if (!proxyServer && resolvedProxy) {
-            proxyServer = await self.ensureProxyServer(resolvedProxy, sk);
+          const discovery = self.effectiveMcpConfig(
+            cwd,
+            void 0,
+            runtimeStatus
+          );
+          const proxyMcpTools = await self.resolvedProxyMcpTools(
+            discovery.allEnabledServerNames
+          );
+          const excludeServers = proxyMcpTools ? new Set(discovery.allEnabledServerNames) : void 0;
+          const combinedProxyTools = resolvedProxy || proxyMcpTools ? [...resolvedProxy ?? [], ...proxyMcpTools ?? []] : null;
+          if (!proxyServer && combinedProxyTools) {
+            proxyServer = await self.ensureProxyServer(combinedProxyTools, sk);
           }
           const proxyDisallowed = resolvedProxy ? disallowedToolFlags(resolvedProxy) : [];
           const extraDisallowed = [];
@@ -2096,7 +2291,8 @@ ${plan}
           const mcp = self.effectiveMcpConfig(
             cwd,
             proxyServer?.configPath(),
-            runtimeStatus
+            runtimeStatus,
+            excludeServers
           );
           const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(cwd);
           const cliArgs = buildCliArgs({
@@ -2889,7 +3085,7 @@ var defaultModels = {
 
 // src/accounts.ts
 import { chmod, lstat, mkdir, readlink, symlink, writeFile } from "fs/promises";
-import path3 from "path";
+import path4 from "path";
 var BASE_PROVIDER_ID = "claude-code";
 var DEFAULT_ACCOUNT = "default";
 var SHARED_CAPABILITY_ITEMS = [
@@ -2927,7 +3123,7 @@ function expandHome(value) {
   const home = process.env.HOME ?? process.env.USERPROFILE;
   if (value === "~") return home ?? value;
   if (value.startsWith("~/") || value.startsWith("~\\")) {
-    return home ? path3.join(home, value.slice(2)) : value;
+    return home ? path4.join(home, value.slice(2)) : value;
   }
   return value;
 }
@@ -2959,8 +3155,8 @@ async function ensureSharedCapabilities(targetRoot) {
   }
 }
 async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
-  const source = path3.join(sourceRoot, item);
-  const target = path3.join(targetRoot, item);
+  const source = path4.join(sourceRoot, item);
+  const target = path4.join(targetRoot, item);
   let sourceStat;
   try {
     sourceStat = await lstat(source);
@@ -2971,8 +3167,8 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
     const targetStat = await lstat(target);
     if (targetStat.isSymbolicLink()) {
       const current = await readlink(target);
-      const resolvedCurrent = path3.resolve(path3.dirname(target), current);
-      const resolvedSource = path3.resolve(source);
+      const resolvedCurrent = path4.resolve(path4.dirname(target), current);
+      const resolvedSource = path4.resolve(source);
       if (resolvedCurrent === resolvedSource) return;
     }
     log.warn("shared Claude capability already exists; leaving untouched", {
@@ -2987,11 +3183,11 @@ async function ensureSharedCapabilityItem(sourceRoot, targetRoot, item) {
   await symlink(source, target, type);
 }
 async function writeAccountWrapper(account, baseCliPath, configDir) {
-  const cacheRoot = path3.join(
+  const cacheRoot = path4.join(
     process.env.XDG_CACHE_HOME ?? expandHome("~/.cache"),
     "opencode-claude-code-plugin"
   );
-  const wrapperPath = path3.join(cacheRoot, `claude-${account}`);
+  const wrapperPath = path4.join(cacheRoot, `claude-${account}`);
   const suffix = `@${account}`;
   await mkdir(cacheRoot, { recursive: true });
   const script = `#!/usr/bin/env bash
@@ -3031,14 +3227,14 @@ function titleizeAccount(account) {
 
 // src/cleanup-stale.ts
 import {
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   readFileSync as readFileSync3,
   realpathSync,
-  rmSync,
+  rmSync as rmSync2,
   writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join4, resolve as resolve2 } from "path";
+import { join as join5, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var STALE_PACKAGE_NAME = "opencode-claude-code-plugin";
 var SUSPECT_DESCRIPTION_TOKEN = "Claude Code";
@@ -3046,18 +3242,18 @@ var alreadyRan = false;
 function candidateCacheRoots() {
   const xdg = process.env.XDG_CACHE_HOME;
   return [
-    xdg ? join4(xdg, "opencode") : null,
-    join4(homedir3(), ".cache", "opencode"),
-    join4(homedir3(), "Library", "Caches", "opencode")
+    xdg ? join5(xdg, "opencode") : null,
+    join5(homedir3(), ".cache", "opencode"),
+    join5(homedir3(), "Library", "Caches", "opencode")
   ].filter((p) => Boolean(p));
 }
 function userOpencodeJsonPath() {
-  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join4(homedir3(), ".config");
-  return join4(xdgConfig, "opencode", "opencode.json");
+  const xdgConfig = process.env.XDG_CONFIG_HOME ?? join5(homedir3(), ".config");
+  return join5(xdgConfig, "opencode", "opencode.json");
 }
 function userIntendsToUseUnscoped() {
   const cfg = userOpencodeJsonPath();
-  if (!existsSync2(cfg)) return false;
+  if (!existsSync3(cfg)) return false;
   try {
     const json = JSON.parse(readFileSync3(cfg, "utf8"));
     const plugins = json.plugin;
@@ -3095,17 +3291,17 @@ function cleanupStaleUnscopedInstall() {
   }
 }
 function cleanupOne(cacheRoot, ourDir) {
-  if (!existsSync2(cacheRoot)) return;
-  const stalePath = join4(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
-  if (!existsSync2(stalePath)) return;
+  if (!existsSync3(cacheRoot)) return;
+  const stalePath = join5(cacheRoot, "node_modules", STALE_PACKAGE_NAME);
+  if (!existsSync3(stalePath)) return;
   let realStalePath = stalePath;
   try {
     realStalePath = realpathSync(stalePath);
   } catch {
   }
   if (ourDir && realStalePath === ourDir) return;
-  const pkgJsonPath = join4(stalePath, "package.json");
-  if (!existsSync2(pkgJsonPath)) return;
+  const pkgJsonPath = join5(stalePath, "package.json");
+  if (!existsSync3(pkgJsonPath)) return;
   let pkg = {};
   try {
     pkg = JSON.parse(readFileSync3(pkgJsonPath, "utf8"));
@@ -3116,7 +3312,7 @@ function cleanupOne(cacheRoot, ourDir) {
   if (!pkg.description?.includes(SUSPECT_DESCRIPTION_TOKEN)) return;
   log.info("cleanup-stale: removing unscoped install", { stalePath });
   try {
-    rmSync(stalePath, { recursive: true, force: true });
+    rmSync2(stalePath, { recursive: true, force: true });
   } catch (err) {
     log.warn("cleanup-stale: rmSync failed", {
       stalePath,
@@ -3124,8 +3320,8 @@ function cleanupOne(cacheRoot, ourDir) {
     });
     return;
   }
-  const cachePkgJson = join4(cacheRoot, "package.json");
-  if (!existsSync2(cachePkgJson)) return;
+  const cachePkgJson = join5(cacheRoot, "package.json");
+  if (!existsSync3(cachePkgJson)) return;
   try {
     const cfg = JSON.parse(readFileSync3(cachePkgJson, "utf8"));
     if (cfg?.dependencies?.[STALE_PACKAGE_NAME]) {
@@ -3174,7 +3370,8 @@ function createClaudeCode(settings = {}) {
       controlRequestDenyMessage: settings.controlRequestDenyMessage,
       proxyTools,
       webSearch: settings.webSearch,
-      hotReloadMcp: settings.hotReloadMcp ?? true
+      hotReloadMcp: settings.hotReloadMcp ?? true,
+      proxyOpencodeMcpTools: settings.proxyOpencodeMcpTools ?? true
     });
   };
   const provider = function(modelId) {
@@ -3342,12 +3539,12 @@ var server = async (input) => {
       config.provider ??= {};
       const expanded = await expandAccountProviders(config);
       if (expanded) {
-        const registered = Object.entries(config.provider).filter(([id]) => id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)).map(([id, p]) => ({
+        const registered2 = Object.entries(config.provider).filter(([id]) => id === PROVIDER_ID2 || id.startsWith(`${PROVIDER_ID2}-`)).map(([id, p]) => ({
           id,
           name: p?.name ?? id,
           cwd: p?.options?.cwd
         }));
-        log.notice("registered claude-code providers", { providers: registered });
+        log.notice("registered claude-code providers", { providers: registered2 });
         return;
       }
       const existing = config.provider[PROVIDER_ID2];