@khalilgharbaoui/opencode-claude-code-plugin 0.3.1 → 0.4.2

package/dist/index.d.ts

@@ -114,6 +114,7 @@ interface ClaudeCodeConfig {
     proxyTools?: string[];
     webSearch?: WebSearchRouting;
     hotReloadMcp?: boolean;
+    proxyOpencodeMcpTools?: boolean;
 }
 type WebSearchRouting = "claude" | "disabled" | (string & {});
 interface ClaudeCodeProviderSettings {
@@ -191,6 +192,21 @@ interface ClaudeCodeProviderSettings {
      * survives MCP changes until the chat is reset).
      */
     hotReloadMcp?: boolean;
+    /**
+     * Route opencode MCP server tools through the in-process `opencode_proxy`
+     * MCP server instead of bridging them directly into Claude CLI's
+     * `--mcp-config`. With both layers configured for the same MCP server,
+     * direct bridging causes each tool invocation to execute twice — once by
+     * Claude CLI's own MCP child process and once by opencode. Routing through
+     * the proxy keeps a single execution site (opencode) while preserving the
+     * tool-call/result surface in opencode's UI and its permission prompts.
+     *
+     * Defaults to `true`. Set to `false` to restore the prior direct-bridge
+     * behavior (Claude CLI executes MCP tools itself; opencode also re-executes
+     * — accept the duplication if you need Claude to invoke the tool without
+     * an opencode round-trip).
+     */
+    proxyOpencodeMcpTools?: boolean;
 }
 type PermissionMode = "acceptEdits" | "auto" | "bypassPermissions" | "default" | "dontAsk" | "plan";
 type ControlRequestBehavior = "allow" | "deny";
@@ -305,6 +321,16 @@ declare class ClaudeCodeLanguageModel implements LanguageModelV3 {
     private effectiveMcpConfig;
     /** Resolve ProxyToolDef[] for the configured proxyTools names. */
     private resolvedProxyTools;
+    /**
+     * 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.
+     */
+    private resolvedProxyMcpTools;
     /**
      * Create a proxy MCP server for a single active Claude process/session.
      * The process lifecycle owns the server lifecycle via session-manager.
@@ -339,6 +365,18 @@ interface BridgedMcp {
     path: string;
     /** Stable hash of the merged opencode mcp block (pre-translation). */
     hash: string;
+    /**
+     * Names of opencode MCP servers that were bridged into Claude CLI's
+     * `--mcp-config`. Excludes any servers passed in `excludeServers`.
+     */
+    serverNames: string[];
+    /**
+     * Names of every enabled opencode MCP server after merge + runtime
+     * overlay, regardless of whether they ended up bridged or excluded.
+     * Callers (e.g. the proxy-tool builder) use this to decide which
+     * `<server>_<tool>` IDs in opencode's tool catalog are MCP-origin.
+     */
+    allEnabledServerNames: string[];
 }
 /**
  * Per-server runtime status from opencode's `client.mcp.status()`. Used as
@@ -362,7 +400,7 @@ type RuntimeMcpStatus = Record<string, string>;
  * return its path + a stable hash. Returns null when no enabled MCP servers
  * remain after the merge + overlay.
  */
-declare function bridgeOpencodeMcp(cwd: string, runtimeStatus?: RuntimeMcpStatus): BridgedMcp | null;
+declare function bridgeOpencodeMcp(cwd: string, runtimeStatus?: RuntimeMcpStatus, excludeServers?: ReadonlySet<string>): BridgedMcp | null;
 
 declare const defaultModels: Record<string, OpenCodeModel>;
 

package/dist/index.js

@@ -637,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()));
@@ -676,15 +676,37 @@ 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 = path2.join(
     pluginTmpDir(),
     `mcp-${hash}.json`
@@ -702,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
@@ -736,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";
@@ -1262,33 +1319,71 @@ function writeJson(res, body) {
 
 // src/proxy-broker.ts
 import { EventEmitter as EventEmitter3 } from "events";
-var pendingBySession = /* @__PURE__ */ new Map();
+var pendingByCallId = /* @__PURE__ */ new Map();
+var callIdsBySession = /* @__PURE__ */ new Map();
 var emitter = new EventEmitter3();
+var PENDING_PROXY_CALL_TIMEOUT_MS = 10 * 60 * 1e3;
 function eventName(sessionKey2) {
   return `pending:${sessionKey2}`;
 }
+function indexAdd(sessionKey2, callId) {
+  let s = callIdsBySession.get(sessionKey2);
+  if (!s) {
+    s = /* @__PURE__ */ new Set();
+    callIdsBySession.set(sessionKey2, s);
+  }
+  s.add(callId);
+}
+function indexRemove(sessionKey2, callId) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return;
+  s.delete(callId);
+  if (s.size === 0) callIdsBySession.delete(sessionKey2);
+}
 function onPendingProxyCall(sessionKey2, handler) {
   const name = eventName(sessionKey2);
   emitter.on(name, handler);
   return () => emitter.off(name, handler);
 }
 function queuePendingProxyCall(sessionKey2, call) {
-  const existing = pendingBySession.get(sessionKey2);
-  if (existing) {
-    existing.reject(
-      new Error(`Another proxy tool call is already pending for ${sessionKey2}`)
+  const previous = pendingByCallId.get(call.id);
+  if (previous) {
+    clearTimeout(previous.timer);
+    previous.reject(
+      new Error(`Replaced pending proxy call ${call.id} with a fresh one`)
     );
-    pendingBySession.delete(sessionKey2);
-  }
+    pendingByCallId.delete(call.id);
+    indexRemove(previous.sessionKey, call.id);
+  }
+  const timer = setTimeout(() => {
+    const current = pendingByCallId.get(call.id);
+    if (!current) return;
+    pendingByCallId.delete(call.id);
+    indexRemove(current.sessionKey, call.id);
+    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: current.sessionKey,
+      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
   };
-  pendingBySession.set(sessionKey2, pending);
+  pendingByCallId.set(call.id, pending);
+  indexAdd(sessionKey2, call.id);
   emitter.emit(eventName(sessionKey2), pending);
   log.info("queued pending proxy call", {
     sessionKey: sessionKey2,
@@ -1297,21 +1392,55 @@ function queuePendingProxyCall(sessionKey2, call) {
   });
   return pending;
 }
-function getPendingProxyCall(sessionKey2) {
-  return pendingBySession.get(sessionKey2);
+function getPendingProxyCalls(sessionKey2) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s || s.size === 0) return [];
+  const out = [];
+  for (const id of s) {
+    const p = pendingByCallId.get(id);
+    if (p) out.push(p);
+  }
+  return out;
 }
-function resolvePendingProxyCall(sessionKey2, result) {
-  const pending = pendingBySession.get(sessionKey2);
+function resolvePendingProxyCallById(toolCallId, result) {
+  const pending = pendingByCallId.get(toolCallId);
   if (!pending) return false;
-  pendingBySession.delete(sessionKey2);
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
+  clearTimeout(pending.timer);
   pending.resolve(result);
   log.info("resolved pending proxy call", {
-    sessionKey: sessionKey2,
+    sessionKey: pending.sessionKey,
     toolCallId: pending.toolCallId,
     toolName: pending.toolName
   });
   return true;
 }
+function rejectPendingProxyCallById(toolCallId, error) {
+  const pending = pendingByCallId.get(toolCallId);
+  if (!pending) return false;
+  pendingByCallId.delete(toolCallId);
+  indexRemove(pending.sessionKey, toolCallId);
+  clearTimeout(pending.timer);
+  pending.reject(error);
+  log.warn("rejected pending proxy call", {
+    sessionKey: pending.sessionKey,
+    toolCallId: pending.toolCallId,
+    toolName: pending.toolName,
+    error: error.message
+  });
+  return true;
+}
+function rejectAllPendingProxyCallsForSession(sessionKey2, error) {
+  const s = callIdsBySession.get(sessionKey2);
+  if (!s) return 0;
+  const ids = [...s];
+  let count = 0;
+  for (const id of ids) {
+    if (rejectPendingProxyCallById(id, error)) count++;
+  }
+  return count;
+}
 
 // src/claude-code-language-model.ts
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
@@ -1432,18 +1561,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() {
@@ -1459,6 +1590,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.
@@ -1740,7 +1910,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") {
@@ -2104,8 +2274,14 @@ ${plan}
     );
     const resolvedProxy = this.resolvedProxyTools();
     const self = this;
-    const pendingProxyCall = getPendingProxyCall(sk);
-    const pendingProxyResult = pendingProxyCall ? this.extractPendingProxyResult(options.prompt, pendingProxyCall.toolCallId) : null;
+    const previousPendingProxyCalls = getPendingProxyCalls(sk);
+    const previousPendingProxyMatches = previousPendingProxyCalls.map((call) => ({
+      call,
+      result: this.extractPendingProxyResult(options.prompt, call.toolCallId)
+    }));
+    const hasMatchedPendingResults = previousPendingProxyMatches.some(
+      (m) => m.result !== null
+    );
     const runtimeStatus = await getRuntimeMcpStatus();
     log.info("doStream starting", {
       cwd,
@@ -2137,8 +2313,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 = [];
@@ -2147,7 +2333,8 @@ ${plan}
           const mcp = self.effectiveMcpConfig(
             cwd,
             proxyServer?.configPath(),
-            runtimeStatus
+            runtimeStatus,
+            excludeServers
           );
           const systemPromptFile = activeProcess ? void 0 : buildAppendedSystemPrompt(cwd);
           const cliArgs = buildCliArgs({
@@ -2224,21 +2411,27 @@ ${plan}
           const skipResultForIds = /* @__PURE__ */ new Set();
           const toolCallsById = /* @__PURE__ */ new Map();
           let resultMeta = {};
-          const finishWithToolCall = (call) => {
+          const drainBuffer = [];
+          let drainTimer = null;
+          const DRAIN_QUIET_MS = 100;
+          const finishWithToolCalls = (calls) => {
             if (controllerClosed) return;
-            controller.enqueue({
-              type: "tool-input-start",
-              id: call.toolCallId,
-              toolName: call.toolName
-            });
-            controller.enqueue({
-              type: "tool-call",
-              toolCallId: call.toolCallId,
-              toolName: call.toolName,
-              input: JSON.stringify(call.input),
-              providerExecuted: false
-            });
-            skipResultForIds.add(call.toolCallId);
+            if (calls.length === 0) return;
+            for (const call of calls) {
+              controller.enqueue({
+                type: "tool-input-start",
+                id: call.toolCallId,
+                toolName: call.toolName
+              });
+              controller.enqueue({
+                type: "tool-call",
+                toolCallId: call.toolCallId,
+                toolName: call.toolName,
+                input: JSON.stringify(call.input),
+                providerExecuted: false
+              });
+              skipResultForIds.add(call.toolCallId);
+            }
             controller.enqueue({
               type: "finish",
               finishReason: toFinishReason("tool-calls"),
@@ -2254,6 +2447,21 @@ ${plan}
             } catch {
             }
           };
+          const drainNow = () => {
+            if (drainTimer) {
+              clearTimeout(drainTimer);
+              drainTimer = null;
+            }
+            if (drainBuffer.length === 0) return;
+            if (controllerClosed) return;
+            const batch = drainBuffer.splice(0, drainBuffer.length);
+            log.info("draining pending proxy calls into stream finish", {
+              sessionKey: sk,
+              count: batch.length,
+              toolCallIds: batch.map((c) => c.toolCallId)
+            });
+            finishWithToolCalls(batch);
+          };
           let gotPartialEvents = false;
           const lineHandler = (line) => {
             if (!line.trim()) return;
@@ -2686,6 +2894,15 @@ ${plan}
           const closeHandler = () => {
             log.debug("readline closed");
             if (controllerClosed) return;
+            if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
+              rejectAllPendingProxyCallsForSession(
+                sk,
+                new Error(
+                  "Claude CLI subprocess closed before pending tool calls were resolved"
+                )
+              );
+              drainBuffer.length = 0;
+            }
             controllerClosed = true;
             cleanupTurn();
             endTextBlock();
@@ -2707,6 +2924,10 @@ ${plan}
             if (cleanedUp) return;
             cleanedUp = true;
             clearFallbackTimer();
+            if (drainTimer) {
+              clearTimeout(drainTimer);
+              drainTimer = null;
+            }
             lineEmitter.off("line", lineHandler);
             lineEmitter.off("close", closeHandler);
             pendingProxyUnsubscribe?.();
@@ -2716,6 +2937,15 @@ ${plan}
           const procErrorHandler = (err) => {
             log.error("process error", { error: err.message });
             if (controllerClosed) return;
+            if (drainBuffer.length > 0 || getPendingProxyCalls(sk).length > 0) {
+              rejectAllPendingProxyCallsForSession(
+                sk,
+                new Error(
+                  `Claude CLI subprocess error: ${err.message}`
+                )
+              );
+              drainBuffer.length = 0;
+            }
             controllerClosed = true;
             cleanupTurn();
             controller.enqueue({ type: "error", error: err });
@@ -2727,12 +2957,31 @@ ${plan}
           lineEmitter.on("line", lineHandler);
           lineEmitter.on("close", closeHandler);
           pendingProxyUnsubscribe = onPendingProxyCall(sk, (call) => {
+            if (controllerClosed) {
+              log.warn(
+                "pending proxy call arrived after stream close; rejecting",
+                {
+                  sessionKey: sk,
+                  toolCallId: call.toolCallId,
+                  toolName: call.toolName
+                }
+              );
+              rejectPendingProxyCallById(
+                call.toolCallId,
+                new Error(
+                  `Pending proxy call '${call.toolName}' arrived after the stream was already closed`
+                )
+              );
+              return;
+            }
             log.info("received pending proxy call for session", {
               sessionKey: sk,
               toolCallId: call.toolCallId,
               toolName: call.toolName
             });
-            finishWithToolCall(call);
+            drainBuffer.push(call);
+            if (drainTimer) clearTimeout(drainTimer);
+            drainTimer = setTimeout(drainNow, DRAIN_QUIET_MS);
           });
           proc.on("error", procErrorHandler);
           if (options.abortSignal) {
@@ -2758,21 +3007,44 @@ ${plan}
               startResultFallback(5e3);
             });
           }
-          if (pendingProxyCall && pendingProxyResult) {
-            log.info("resolving pending proxy call from tool result prompt", {
-              sessionKey: sk,
-              toolCallId: pendingProxyCall.toolCallId,
-              toolName: pendingProxyCall.toolName
-            });
-            const resolved = resolvePendingProxyCall(sk, pendingProxyResult);
-            if (!resolved) {
-              log.warn("failed to resolve pending proxy call; no pending state", {
-                sessionKey: sk,
-                toolCallId: pendingProxyCall.toolCallId
-              });
+          if (hasMatchedPendingResults) {
+            for (const { call, result } of previousPendingProxyMatches) {
+              if (result) {
+                log.info("resolving pending proxy call from tool result prompt", {
+                  sessionKey: sk,
+                  toolCallId: call.toolCallId,
+                  toolName: call.toolName
+                });
+                resolvePendingProxyCallById(call.toolCallId, result);
+              } else {
+                log.warn(
+                  "pending proxy call had no matching tool-result; rejecting as orphan",
+                  {
+                    sessionKey: sk,
+                    toolCallId: call.toolCallId,
+                    toolName: call.toolName
+                  }
+                );
+                rejectPendingProxyCallById(
+                  call.toolCallId,
+                  new Error(
+                    `Pending proxy call '${call.toolName}' (${call.toolCallId}) was not matched in tool-result turn; rejecting as orphaned`
+                  )
+                );
+              }
             }
             return;
           }
+          if (previousPendingProxyCalls.length > 0) {
+            for (const call of previousPendingProxyCalls) {
+              rejectPendingProxyCallById(
+                call.toolCallId,
+                new Error(
+                  `Pending proxy call '${call.toolName}' (${call.toolCallId}) was orphaned by a new user turn; rejecting`
+                )
+              );
+            }
+          }
           proc.stdin?.write(userMsg + "\n");
           log.debug("sent user message", { textLength: userMsg.length });
         };
@@ -3225,7 +3497,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) {