@rama_nigg/open-cursor 2.3.2 → 2.3.4

package/dist/index.js

@@ -1,20 +1,5 @@
 import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -13629,41 +13614,46 @@ function extractAllowedToolNames(tools) {
 }
 function extractOpenAiToolCall(event, allowedToolNames) {
   if (allowedToolNames.size === 0) {
-    return null;
+    return { action: "skip", skipReason: "no_allowed_tools" };
   }
   const { name, args, skipped } = extractToolNameAndArgs(event);
   if (skipped) {
-    return null;
+    return { action: "skip", skipReason: "event_skipped" };
   }
   if (!name) {
-    return null;
+    return { action: "skip", skipReason: "no_name" };
   }
   const resolvedName = resolveAllowedToolName(name, allowedToolNames);
-  if (!resolvedName) {
-    log5.debug("Tool call name not allowed; skipping interception", {
-      name,
-      normalized: normalizeAliasKey(name),
-      allowedToolCount: allowedToolNames.size,
-      aliasTarget: TOOL_NAME_ALIASES.get(normalizeAliasKey(name)) ?? null
-    });
-    return null;
-  }
-  if (args === undefined && event.subtype === "started") {
-    log5.debug("Tool call args extraction returned undefined", {
-      toolName: name,
-      subtype: event.subtype ?? "none",
-      payloadKeys: Object.entries(event.tool_call || {}).map(([k, v]) => `${k}:[${isRecord(v) ? Object.keys(v).join(",") : typeof v}]`),
-      hasCallId: Boolean(event.call_id)
-    });
+  if (resolvedName) {
+    if (args === undefined && event.subtype === "started") {
+      log5.debug("Tool call args extraction returned undefined", {
+        toolName: name,
+        subtype: event.subtype ?? "none",
+        payloadKeys: Object.entries(event.tool_call || {}).map(([k, v]) => `${k}:[${isRecord(v) ? Object.keys(v).join(",") : typeof v}]`),
+        hasCallId: Boolean(event.call_id)
+      });
+    }
+    const callId = event.call_id || event.tool_call_id || "call_unknown";
+    return {
+      action: "intercept",
+      toolCall: {
+        id: callId,
+        type: "function",
+        function: {
+          name: resolvedName,
+          arguments: toOpenAiArguments(args)
+        }
+      }
+    };
   }
-  const callId = event.call_id || event.tool_call_id || "call_unknown";
+  log5.debug("Tool call not in allowlist; passing through to cursor-agent", {
+    name,
+    normalized: normalizeAliasKey(name),
+    allowedToolCount: allowedToolNames.size
+  });
   return {
-    id: callId,
-    type: "function",
-    function: {
-      name: resolvedName,
-      arguments: toOpenAiArguments(args)
-    }
+    action: "passthrough",
+    passthroughName: name
   };
 }
 function createToolCallCompletionResponse(meta, toolCall) {
@@ -16403,7 +16393,7 @@ function createSharedBoundary(providerId) {
     },
     maybeExtractToolCall(event, allowedToolNames, toolLoopMode) {
       if (toolLoopMode !== "opencode") {
-        return null;
+        return { action: "skip", skipReason: "tool_loop_mode_not_opencode" };
       }
       return extractOpenAiToolCall(event, allowedToolNames);
     },
@@ -16830,9 +16820,33 @@ async function handleToolLoopEventLegacy(options) {
     responseMeta,
     onToolUpdate,
     onToolResult,
-    onInterceptedToolCall
+    onInterceptedToolCall,
+    passThroughTracker
   } = options;
-  const interceptedToolCall = toolLoopMode === "opencode" ? extractOpenAiToolCall(event, allowedToolNames) : null;
+  const extraction = toolLoopMode === "opencode" ? extractOpenAiToolCall(event, allowedToolNames) : { action: "skip", skipReason: "tool_loop_mode_not_opencode" };
+  if (extraction.action === "passthrough") {
+    passThroughTracker?.trackTool(extraction.passthroughName);
+    log13.debug("MCP tool passed through to cursor-agent (legacy)", {
+      tool: extraction.passthroughName
+    });
+    return { intercepted: false, skipConverter: false };
+  }
+  if (extraction.action === "skip" || !extraction.toolCall) {
+    const updates2 = await toolMapper.mapCursorEventToAcp(event, event.session_id ?? toolSessionId);
+    if (shouldEmitToolUpdates) {
+      for (const update of updates2) {
+        await onToolUpdate(update);
+      }
+    }
+    if (toolRouter && proxyExecuteToolCalls) {
+      const toolResult = await toolRouter.handleToolCall(event, responseMeta);
+      if (toolResult) {
+        await onToolResult(toolResult);
+      }
+    }
+    return { intercepted: false, skipConverter: suppressConverterToolEvents };
+  }
+  const interceptedToolCall = extraction.toolCall;
   if (interceptedToolCall) {
     const compat2 = applyToolSchemaCompat(interceptedToolCall, toolSchemaMap);
     let normalizedToolCall = compat2.toolCall;
@@ -16909,118 +16923,125 @@ async function handleToolLoopEventV1(options) {
     responseMeta,
     onToolUpdate,
     onToolResult,
-    onInterceptedToolCall
+    onInterceptedToolCall,
+    passThroughTracker
   } = options;
-  let interceptedToolCall;
+  let extraction;
   try {
-    interceptedToolCall = boundary.maybeExtractToolCall(event, allowedToolNames, toolLoopMode);
+    extraction = boundary.maybeExtractToolCall(event, allowedToolNames, toolLoopMode);
   } catch (error45) {
     throw new ToolBoundaryExtractionError("Boundary tool extraction failed", error45);
   }
-  if (interceptedToolCall) {
-    const compat2 = applyToolSchemaCompat(interceptedToolCall, toolSchemaMap);
-    interceptedToolCall = compat2.toolCall;
-    const editDiag = interceptedToolCall.function.name.toLowerCase() === "edit" ? {
-      rawArgs: safeArgTypeSummary(event),
-      normalizedArgs: compat2.normalizedArgs
-    } : undefined;
-    log13.debug("Applied tool schema compatibility", {
-      tool: interceptedToolCall.function.name,
-      originalArgKeys: compat2.originalArgKeys,
-      normalizedArgKeys: compat2.normalizedArgKeys,
-      collisionKeys: compat2.collisionKeys,
-      validationOk: compat2.validation.ok,
-      ...editDiag ? { editDiag } : {}
+  if (extraction.action === "passthrough") {
+    passThroughTracker?.trackTool(extraction.passthroughName);
+    log13.debug("MCP tool passed through to cursor-agent (v1)", {
+      tool: extraction.passthroughName
     });
-    if (compat2.validation.hasSchema && !compat2.validation.ok) {
-      log13.debug("Tool schema compatibility validation failed", {
-        tool: interceptedToolCall.function.name,
+    return { intercepted: false, skipConverter: false };
+  }
+  if (extraction.action === "skip" || !extraction.toolCall) {
+    const updates = await toolMapper.mapCursorEventToAcp(event, event.session_id ?? toolSessionId);
+    if (shouldEmitToolUpdates) {
+      for (const update of updates) {
+        await onToolUpdate(update);
+      }
+    }
+    if (toolRouter && proxyExecuteToolCalls) {
+      const toolResult = await toolRouter.handleToolCall(event, responseMeta);
+      if (toolResult) {
+        await onToolResult(toolResult);
+      }
+    }
+    return { intercepted: false, skipConverter: suppressConverterToolEvents };
+  }
+  const interceptedToolCall = extraction.toolCall;
+  const compat2 = applyToolSchemaCompat(interceptedToolCall, toolSchemaMap);
+  let normalizedToolCall = compat2.toolCall;
+  const editDiag = normalizedToolCall.function.name.toLowerCase() === "edit" ? {
+    rawArgs: safeArgTypeSummary(event),
+    normalizedArgs: compat2.normalizedArgs
+  } : undefined;
+  log13.debug("Applied tool schema compatibility", {
+    tool: normalizedToolCall.function.name,
+    originalArgKeys: compat2.originalArgKeys,
+    normalizedArgKeys: compat2.normalizedArgKeys,
+    collisionKeys: compat2.collisionKeys,
+    validationOk: compat2.validation.ok,
+    ...editDiag ? { editDiag } : {}
+  });
+  if (compat2.validation.hasSchema && !compat2.validation.ok) {
+    log13.debug("Tool schema compatibility validation failed", {
+      tool: normalizedToolCall.function.name,
+      missing: compat2.validation.missing,
+      unexpected: compat2.validation.unexpected,
+      typeErrors: compat2.validation.typeErrors,
+      repairHint: compat2.validation.repairHint
+    });
+    const validationTermination = evaluateSchemaValidationLoopGuard(toolLoopGuard, normalizedToolCall, compat2.validation);
+    if (validationTermination) {
+      return { intercepted: false, skipConverter: true, terminate: validationTermination };
+    }
+    const termination2 = evaluateToolLoopGuard(toolLoopGuard, normalizedToolCall);
+    if (termination2) {
+      return { intercepted: false, skipConverter: true, terminate: termination2 };
+    }
+    const reroutedWrite = tryRerouteEditToWrite(normalizedToolCall, compat2.normalizedArgs, allowedToolNames, toolSchemaMap);
+    if (reroutedWrite) {
+      log13.debug("Rerouting malformed edit call to write", {
+        path: reroutedWrite.path,
         missing: compat2.validation.missing,
-        unexpected: compat2.validation.unexpected,
-        typeErrors: compat2.validation.typeErrors,
-        repairHint: compat2.validation.repairHint
+        typeErrors: compat2.validation.typeErrors
       });
-      const validationTermination = evaluateSchemaValidationLoopGuard(toolLoopGuard, interceptedToolCall, compat2.validation);
-      if (validationTermination) {
-        return { intercepted: false, skipConverter: true, terminate: validationTermination };
-      }
-      const termination2 = evaluateToolLoopGuard(toolLoopGuard, interceptedToolCall);
-      if (termination2) {
-        return { intercepted: false, skipConverter: true, terminate: termination2 };
-      }
-      const reroutedWrite = tryRerouteEditToWrite(interceptedToolCall, compat2.normalizedArgs, allowedToolNames, toolSchemaMap);
-      if (reroutedWrite) {
-        log13.debug("Rerouting malformed edit call to write", {
-          path: reroutedWrite.path,
-          missing: compat2.validation.missing,
-          typeErrors: compat2.validation.typeErrors
-        });
-        await onInterceptedToolCall(reroutedWrite.toolCall);
-        return {
-          intercepted: true,
-          skipConverter: true
-        };
-      }
-      if (schemaValidationFailureMode === "pass_through" && shouldTerminateOnSchemaValidation(interceptedToolCall, compat2.validation)) {
-        return {
-          intercepted: false,
-          skipConverter: true,
-          terminate: createSchemaValidationTermination(interceptedToolCall, compat2.validation)
-        };
-      }
-      if (schemaValidationFailureMode === "pass_through" && shouldEmitNonFatalSchemaValidationHint(interceptedToolCall, compat2.validation)) {
-        const hintChunk = createNonFatalSchemaValidationHintChunk(responseMeta, interceptedToolCall, compat2.validation);
-        log13.debug("Emitting non-fatal schema validation hint and skipping malformed tool execution", {
-          tool: interceptedToolCall.function.name,
-          missing: compat2.validation.missing,
-          typeErrors: compat2.validation.typeErrors
-        });
-        await onToolResult(hintChunk);
-        return {
-          intercepted: false,
-          skipConverter: true
-        };
-      }
-      if (schemaValidationFailureMode === "terminate") {
-        return {
-          intercepted: false,
-          skipConverter: true,
-          terminate: createSchemaValidationTermination(interceptedToolCall, compat2.validation)
-        };
-      }
-      log13.debug("Forwarding schema-invalid tool call to OpenCode loop", {
-        tool: interceptedToolCall.function.name,
-        repairHint: compat2.validation.repairHint
-      });
-      await onInterceptedToolCall(interceptedToolCall);
+      await onInterceptedToolCall(reroutedWrite.toolCall);
       return {
         intercepted: true,
         skipConverter: true
       };
     }
-    const termination = evaluateToolLoopGuard(toolLoopGuard, interceptedToolCall);
-    if (termination) {
-      return { intercepted: false, skipConverter: true, terminate: termination };
+    if (schemaValidationFailureMode === "pass_through" && shouldTerminateOnSchemaValidation(normalizedToolCall, compat2.validation)) {
+      return {
+        intercepted: false,
+        skipConverter: true,
+        terminate: createSchemaValidationTermination(normalizedToolCall, compat2.validation)
+      };
     }
-    await onInterceptedToolCall(interceptedToolCall);
-    return { intercepted: true, skipConverter: true };
-  }
-  const updates = await toolMapper.mapCursorEventToAcp(event, event.session_id ?? toolSessionId);
-  if (shouldEmitToolUpdates) {
-    for (const update of updates) {
-      await onToolUpdate(update);
+    if (schemaValidationFailureMode === "pass_through" && shouldEmitNonFatalSchemaValidationHint(normalizedToolCall, compat2.validation)) {
+      const hintChunk = createNonFatalSchemaValidationHintChunk(responseMeta, normalizedToolCall, compat2.validation);
+      log13.debug("Emitting non-fatal schema validation hint and skipping malformed tool execution", {
+        tool: normalizedToolCall.function.name,
+        missing: compat2.validation.missing,
+        typeErrors: compat2.validation.typeErrors
+      });
+      await onToolResult(hintChunk);
+      return {
+        intercepted: false,
+        skipConverter: true
+      };
     }
-  }
-  if (toolRouter && proxyExecuteToolCalls) {
-    const toolResult = await toolRouter.handleToolCall(event, responseMeta);
-    if (toolResult) {
-      await onToolResult(toolResult);
+    if (schemaValidationFailureMode === "terminate") {
+      return {
+        intercepted: false,
+        skipConverter: true,
+        terminate: createSchemaValidationTermination(normalizedToolCall, compat2.validation)
+      };
     }
+    log13.debug("Forwarding schema-invalid tool call to OpenCode loop", {
+      tool: normalizedToolCall.function.name,
+      repairHint: compat2.validation.repairHint
+    });
+    await onInterceptedToolCall(normalizedToolCall);
+    return {
+      intercepted: true,
+      skipConverter: true
+    };
   }
-  return {
-    intercepted: false,
-    skipConverter: suppressConverterToolEvents
-  };
+  const termination = evaluateToolLoopGuard(toolLoopGuard, normalizedToolCall);
+  if (termination) {
+    return { intercepted: false, skipConverter: true, terminate: termination };
+  }
+  await onInterceptedToolCall(normalizedToolCall);
+  return { intercepted: true, skipConverter: true };
+  return { intercepted: false, skipConverter: suppressConverterToolEvents };
 }
 async function handleToolLoopEventWithFallback(options) {
   const {
@@ -17301,6 +17322,80 @@ var init_runtime_interception = __esm(() => {
   };
 });
 
+// src/provider/passthrough-tracker.ts
+class PassThroughTracker {
+  tools = new Set;
+  errors = [];
+  trackTool(name) {
+    this.tools.add(name);
+  }
+  trackError(toolName, message) {
+    this.errors.push(`${toolName}: ${message}`);
+  }
+  getSummary() {
+    return {
+      tools: Array.from(this.tools),
+      errors: [...this.errors],
+      hasActivity: this.tools.size > 0
+    };
+  }
+  reset() {
+    this.tools.clear();
+    this.errors.length = 0;
+  }
+}
+
+// src/services/toast-service.ts
+class ToastService {
+  client = null;
+  setClient(client3) {
+    this.client = client3;
+  }
+  async show(options) {
+    if (!this.client?.tui?.showToast) {
+      log14.debug("Toast not available; client.tui.showToast missing", { message: options.message });
+      return;
+    }
+    try {
+      await this.client.tui.showToast({
+        body: {
+          title: options.title,
+          message: options.message,
+          variant: options.variant
+        }
+      });
+    } catch (error45) {
+      log14.debug("Toast failed", { error: error45, message: options.message });
+    }
+  }
+  async showPassThroughSummary(tools) {
+    if (tools.length === 0)
+      return;
+    const toolList = tools.length <= 3 ? tools.join(", ") : `${tools.slice(0, 3).join(", ")} +${tools.length - 3} more`;
+    await this.show({
+      title: "MCP Tools",
+      message: `\uD83C\uDFAD ${tools.length} tool${tools.length > 1 ? "s" : ""} handled by cursor-agent: ${toolList}`,
+      variant: "info"
+    });
+  }
+  async showErrorSummary(errors3) {
+    if (errors3.length === 0)
+      return;
+    const errorList = errors3.length <= 2 ? errors3.join("; ") : `${errors3.slice(0, 2).join("; ")} +${errors3.length - 2} more`;
+    await this.show({
+      title: "MCP Errors",
+      message: `⚠️ ${errors3.length} MCP tool${errors3.length > 1 ? "s" : ""} failed: ${errorList}`,
+      variant: "warning"
+    });
+  }
+}
+var log14, toastService;
+var init_toast_service = __esm(() => {
+  init_logger();
+  log14 = createLogger("services:toast");
+  toastService = new ToastService;
+});
+
 // src/provider/tool-loop-guard.ts
 function parseToolLoopMaxRepeat(value) {
   if (value === undefined) {
@@ -17443,25 +17538,6 @@ function indexToolLoopHistory(messages) {
     incrementCount(initialValidationCounts, `${call.name}|schema:${schemaSignature}|validation`);
     incrementCount(initialValidationCoarseCounts, `${call.name}|validation`);
   }
-  const strippedRounds = countStrippedAssistantRounds(messages);
-  if (strippedRounds > 0 && assistantCalls.length > 0) {
-    for (const call of assistantCalls) {
-      const errorClass = normalizeErrorClassForTool(call.name, byCallId.get(call.id) ?? latestByToolName.get(call.name) ?? latest ?? "unknown");
-      if (errorClass !== "success") {
-        continue;
-      }
-      const coarseSuccessFP = deriveSuccessCoarseFingerprint(call.name, call.rawArguments);
-      if (coarseSuccessFP) {
-        for (let i = 0;i < strippedRounds; i++) {
-          incrementCount(initialCoarseCounts, coarseSuccessFP);
-        }
-      }
-      const successFP = `${call.name}|values:${call.argValueSignature}|success`;
-      for (let i = 0;i < strippedRounds; i++) {
-        incrementCount(initialCounts, successFP);
-      }
-    }
-  }
   return {
     byCallId,
     latest,
@@ -17684,23 +17760,6 @@ function normalizeErrorClassForTool(toolName, errorClass) {
   }
   return errorClass;
 }
-function countStrippedAssistantRounds(messages) {
-  let count = 0;
-  for (const message of messages) {
-    if (!isRecord4(message) || message.role !== "assistant") {
-      continue;
-    }
-    if (Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-      continue;
-    }
-    const content = message.content;
-    const hasContent = typeof content === "string" && content.trim().length > 0 || Array.isArray(content) && content.length > 0;
-    if (!hasContent) {
-      count++;
-    }
-  }
-  return count;
-}
 function toLowerText(content) {
   const rendered = renderContent(content);
   return rendered.trim().toLowerCase();
@@ -17785,9 +17844,9 @@ async function ensurePluginDirectory() {
   const pluginDir = join4(configHome, "opencode", "plugin");
   try {
     await mkdir(pluginDir, { recursive: true });
-    log14.debug("Plugin directory ensured", { path: pluginDir });
+    log15.debug("Plugin directory ensured", { path: pluginDir });
   } catch (error45) {
-    log14.warn("Failed to create plugin directory", { error: String(error45) });
+    log15.warn("Failed to create plugin directory", { error: String(error45) });
   }
 }
 function shouldProcessModel(model) {
@@ -17975,9 +18034,9 @@ function createBoundaryRuntimeContext(scope) {
       error: toErrorMessage(error45)
     };
     if (!fallbackActive) {
-      log14.warn("Provider boundary v1 failed; switching to legacy for this request", details);
+      log15.warn("Provider boundary v1 failed; switching to legacy for this request", details);
     } else {
-      log14.debug("Provider boundary fallback already active", details);
+      log15.debug("Provider boundary fallback already active", details);
     }
     fallbackActive = true;
     return true;
@@ -18115,7 +18174,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             headers: { "Content-Type": "application/json" }
           });
         } catch (err) {
-          log14.error("Failed to list models", { error: String(err) });
+          log15.error("Failed to list models", { error: String(err) });
           return new Response(JSON.stringify({ error: "Failed to fetch models from cursor-agent" }), {
             status: 500,
             headers: { "Content-Type": "application/json" }
@@ -18128,7 +18187,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           headers: { "Content-Type": "application/json" }
         });
       }
-      log14.debug("Proxy request (bun)", { method: req.method, path: url2.pathname });
+      log15.debug("Proxy request (bun)", { method: req.method, path: url2.pathname });
       const body = await req.json().catch(() => ({}));
       const messages = Array.isArray(body?.messages) ? body.messages : [];
       const stream = body?.stream === true;
@@ -18155,7 +18214,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const clen = typeof m?.content === "string" ? m.content.length : Array.isArray(m?.content) ? `arr${m.content.length}` : typeof m?.content;
         return `${i}:${role}${hasTc ? `(tc:${hasTc})` : ""}(clen:${clen})`;
       });
-      log14.debug("Proxy chat request (bun)", {
+      log15.debug("Proxy chat request (bun)", {
         stream,
         model,
         messages: messages.length,
@@ -18201,7 +18260,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const stdout = (stdoutText || "").trim();
         const stderr = (stderrText || "").trim();
         const exitCode = await child.exited;
-        log14.debug("cursor-agent completed (bun non-stream)", {
+        log15.debug("cursor-agent completed (bun non-stream)", {
           exitCode,
           stdoutChars: stdout.length,
           stderrChars: stderr.length
@@ -18227,7 +18286,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           });
         }
         if (intercepted.toolCall) {
-          log14.debug("Intercepted OpenCode tool call (non-stream)", {
+          log15.debug("Intercepted OpenCode tool call (non-stream)", {
             name: intercepted.toolCall.function.name,
             callId: intercepted.toolCall.id
           });
@@ -18241,7 +18300,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           const errSource = stderr || stdout || `cursor-agent exited with code ${String(exitCode ?? "unknown")} and no output`;
           const parsed = parseAgentError(errSource);
           const userError = formatErrorForUser(parsed);
-          log14.error("cursor-cli failed", {
+          log15.error("cursor-cli failed", {
             type: parsed.type,
             message: parsed.message,
             code: exitCode
@@ -18265,6 +18324,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       const perf = new RequestPerf(id);
       const toolMapper = new ToolMapper;
       const toolSessionId = id;
+      const passThroughTracker = new PassThroughTracker;
       perf.mark("spawn");
       const sse = new ReadableStream({
         async start(controller) {
@@ -18275,7 +18335,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             const converter = new StreamToSseConverter(model, { id, created });
             const lineBuffer = new LineBuffer;
             const emitToolCallAndTerminate = (toolCall) => {
-              log14.debug("Intercepted OpenCode tool call (stream)", {
+              log15.debug("Intercepted OpenCode tool call (stream)", {
                 name: toolCall.function.name,
                 callId: toolCall.id
               });
@@ -18342,6 +18402,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                     suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
                     toolRouter,
                     responseMeta: { id, created, model },
+                    passThroughTracker,
                     onToolUpdate: (update) => {
                       controller.enqueue(encoder.encode(formatToolUpdateEvent(update)));
                     },
@@ -18408,6 +18469,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                   suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
                   toolRouter,
                   responseMeta: { id, created, model },
+                  passThroughTracker,
                   onToolUpdate: (update) => {
                     controller.enqueue(encoder.encode(formatToolUpdateEvent(update)));
                   },
@@ -18455,7 +18517,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
               const errSource = (stderrText || "").trim() || `cursor-agent exited with code ${String(exitCode ?? "unknown")} and no output`;
               const parsed = parseAgentError(errSource);
               const msg = formatErrorForUser(parsed);
-              log14.error("cursor-cli streaming failed", {
+              log15.error("cursor-cli streaming failed", {
                 type: parsed.type,
                 code: exitCode
               });
@@ -18466,9 +18528,16 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
               controller.enqueue(encoder.encode(formatSseDone()));
               return;
             }
-            log14.debug("cursor-agent completed (bun stream)", {
+            log15.debug("cursor-agent completed (bun stream)", {
               exitCode
             });
+            const passThroughSummary = passThroughTracker.getSummary();
+            if (passThroughSummary.hasActivity) {
+              await toastService.showPassThroughSummary(passThroughSummary.tools);
+            }
+            if (passThroughSummary.errors.length > 0) {
+              await toastService.showErrorSummary(passThroughSummary.errors);
+            }
             const doneChunk = createChatCompletionChunk(id, created, model, "", true);
             controller.enqueue(encoder.encode(`data: ${JSON.stringify(doneChunk)}
 
@@ -18541,7 +18610,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           res.writeHead(200, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ object: "list", data: models }));
         } catch (err) {
-          log14.error("Failed to list models", { error: String(err) });
+          log15.error("Failed to list models", { error: String(err) });
           res.writeHead(500, { "Content-Type": "application/json" });
           res.end(JSON.stringify({ error: "Failed to fetch models" }));
         }
@@ -18552,7 +18621,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         res.end(JSON.stringify({ error: `Unsupported path: ${url2.pathname}` }));
         return;
       }
-      log14.debug("Proxy request (node)", { method: req.method, path: url2.pathname });
+      log15.debug("Proxy request (node)", { method: req.method, path: url2.pathname });
       let body = "";
       for await (const chunk of req) {
         body += chunk;
@@ -18575,7 +18644,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const contentLen = typeof m?.content === "string" ? m.content.length : Array.isArray(m?.content) ? `arr${m.content.length}` : typeof m?.content;
         return `${i}:${role}${hasTc ? `(tc:${hasTc})` : ""}${role === "tool" ? `(tcid:${tcId},name:${tcName},clen:${contentLen})` : `(clen:${contentLen})`}`;
       });
-      log14.debug("Proxy chat request (node)", {
+      log15.debug("Proxy chat request (node)", {
         stream,
         model,
         messages: messages.length,
@@ -18606,14 +18675,14 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         let spawnErrorText = null;
         child.on("error", (error45) => {
           spawnErrorText = String(error45?.message || error45);
-          log14.error("Failed to spawn cursor-agent", { error: spawnErrorText, model });
+          log15.error("Failed to spawn cursor-agent", { error: spawnErrorText, model });
         });
         child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
         child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
         child.on("close", async (code) => {
           const stdout = Buffer.concat(stdoutChunks).toString().trim();
           const stderr = Buffer.concat(stderrChunks).toString().trim();
-          log14.debug("cursor-agent completed (node non-stream)", {
+          log15.debug("cursor-agent completed (node non-stream)", {
             code,
             stdoutChars: stdout.length,
             stderrChars: stderr.length,
@@ -18639,7 +18708,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             return;
           }
           if (intercepted.toolCall) {
-            log14.debug("Intercepted OpenCode tool call (non-stream)", {
+            log15.debug("Intercepted OpenCode tool call (non-stream)", {
               name: intercepted.toolCall.function.name,
               callId: intercepted.toolCall.id
             });
@@ -18653,7 +18722,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             const errSource = stderr || stdout || spawnErrorText || `cursor-agent exited with code ${String(code ?? "unknown")} and no output`;
             const parsed = parseAgentError(errSource);
             const userError = formatErrorForUser(parsed);
-            log14.error("cursor-cli failed", {
+            log15.error("cursor-cli failed", {
               type: parsed.type,
               message: parsed.message,
               code
@@ -18681,6 +18750,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
         const lineBuffer = new LineBuffer;
         const toolMapper = new ToolMapper;
         const toolSessionId = id;
+        const passThroughTracker = new PassThroughTracker;
         const stderrChunks = [];
         let streamTerminated = false;
         let firstTokenReceived = false;
@@ -18692,7 +18762,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             return;
           }
           const errSource = String(error45?.message || error45);
-          log14.error("Failed to spawn cursor-agent (stream)", { error: errSource, model });
+          log15.error("Failed to spawn cursor-agent (stream)", { error: errSource, model });
           const parsed = parseAgentError(errSource);
           const msg = formatErrorForUser(parsed);
           const errChunk = createChatCompletionChunk(id, created, model, msg, true);
@@ -18707,7 +18777,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           if (streamTerminated || res.writableEnded) {
             return;
           }
-          log14.debug("Intercepted OpenCode tool call (stream)", {
+          log15.debug("Intercepted OpenCode tool call (stream)", {
             name: toolCall.function.name,
             callId: toolCall.id
           });
@@ -18773,6 +18843,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
                 toolRouter,
                 responseMeta: { id, created, model },
+                passThroughTracker,
                 onToolUpdate: (update) => {
                   res.write(formatToolUpdateEvent(update));
                 },
@@ -18843,6 +18914,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
                 toolRouter,
                 responseMeta: { id, created, model },
+                passThroughTracker,
                 onToolUpdate: (update) => {
                   res.write(formatToolUpdateEvent(update));
                 },
@@ -18889,7 +18961,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
           perf.mark("request:done");
           perf.summarize();
           const stderrText = Buffer.concat(stderrChunks).toString().trim();
-          log14.debug("cursor-agent completed (node stream)", {
+          log15.debug("cursor-agent completed (node stream)", {
             code,
             stderrChars: stderrText.length
           });
@@ -18906,6 +18978,13 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             res.end();
             return;
           }
+          const passThroughSummary = passThroughTracker.getSummary();
+          if (passThroughSummary.hasActivity) {
+            await toastService.showPassThroughSummary(passThroughSummary.tools);
+          }
+          if (passThroughSummary.errors.length > 0) {
+            await toastService.showErrorSummary(passThroughSummary.errors);
+          }
           const doneChunk = {
             id,
             object: "chat.completion.chunk",
@@ -19110,7 +19189,7 @@ function buildToolHookEntries(registry2, fallbackBaseDir) {
           const normalizedArgs = applyToolContextDefaults(toolName, args, context, fallbackBaseDir, sessionWorkspaceBySession);
           return await handler(normalizedArgs);
         } catch (error45) {
-          log14.debug("Tool hook execution failed", { tool: toolName, error: String(error45?.message || error45) });
+          log15.debug("Tool hook execution failed", { tool: toolName, error: String(error45?.message || error45) });
           throw error45;
         }
       }
@@ -19122,9 +19201,9 @@ function buildToolHookEntries(registry2, fallbackBaseDir) {
   }
   return entries;
 }
-var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROVIDER_PREFIX, CURSOR_PROXY_HOST = "127.0.0.1", CURSOR_PROXY_DEFAULT_PORT = 32124, CURSOR_PROXY_DEFAULT_BASE_URL, REUSE_EXISTING_PROXY, SESSION_WORKSPACE_CACHE_LIMIT = 200, FORCE_TOOL_MODE, EMIT_TOOL_UPDATES, FORWARD_TOOL_CALLS, TOOL_LOOP_MODE_RAW, TOOL_LOOP_MODE, TOOL_LOOP_MODE_VALID, PROVIDER_BOUNDARY_MODE_RAW, PROVIDER_BOUNDARY_MODE, PROVIDER_BOUNDARY_MODE_VALID, LEGACY_PROVIDER_BOUNDARY, PROVIDER_BOUNDARY, ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK, TOOL_LOOP_MAX_REPEAT_RAW, TOOL_LOOP_MAX_REPEAT, TOOL_LOOP_MAX_REPEAT_VALID, PROXY_EXECUTE_TOOL_CALLS, SUPPRESS_CONVERTER_TOOL_EVENTS, SHOULD_EMIT_TOOL_UPDATES, CursorPlugin = async ({ $, directory, worktree, client: client3, serverUrl }) => {
+var log15, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", CURSOR_PROVIDER_PREFIX, CURSOR_PROXY_HOST = "127.0.0.1", CURSOR_PROXY_DEFAULT_PORT = 32124, CURSOR_PROXY_DEFAULT_BASE_URL, REUSE_EXISTING_PROXY, SESSION_WORKSPACE_CACHE_LIMIT = 200, FORCE_TOOL_MODE, EMIT_TOOL_UPDATES, FORWARD_TOOL_CALLS, TOOL_LOOP_MODE_RAW, TOOL_LOOP_MODE, TOOL_LOOP_MODE_VALID, PROVIDER_BOUNDARY_MODE_RAW, PROVIDER_BOUNDARY_MODE, PROVIDER_BOUNDARY_MODE_VALID, LEGACY_PROVIDER_BOUNDARY, PROVIDER_BOUNDARY, ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK, TOOL_LOOP_MAX_REPEAT_RAW, TOOL_LOOP_MAX_REPEAT, TOOL_LOOP_MAX_REPEAT_VALID, PROXY_EXECUTE_TOOL_CALLS, SUPPRESS_CONVERTER_TOOL_EVENTS, SHOULD_EMIT_TOOL_UPDATES, CursorPlugin = async ({ $, directory, worktree, client: client3, serverUrl }) => {
   const workspaceDirectory = resolveWorkspaceDirectory(worktree, directory);
-  log14.debug("Plugin initializing", {
+  log15.debug("Plugin initializing", {
     directory,
     worktree,
     workspaceDirectory,
@@ -19132,22 +19211,22 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
     serverUrl: serverUrl?.toString()
   });
   if (!TOOL_LOOP_MODE_VALID) {
-    log14.warn("Invalid CURSOR_ACP_TOOL_LOOP_MODE; defaulting to opencode", { value: TOOL_LOOP_MODE_RAW });
+    log15.warn("Invalid CURSOR_ACP_TOOL_LOOP_MODE; defaulting to opencode", { value: TOOL_LOOP_MODE_RAW });
   }
   if (!PROVIDER_BOUNDARY_MODE_VALID) {
-    log14.warn("Invalid CURSOR_ACP_PROVIDER_BOUNDARY; defaulting to v1", {
+    log15.warn("Invalid CURSOR_ACP_PROVIDER_BOUNDARY; defaulting to v1", {
       value: PROVIDER_BOUNDARY_MODE_RAW
     });
   }
   if (!TOOL_LOOP_MAX_REPEAT_VALID) {
-    log14.warn("Invalid CURSOR_ACP_TOOL_LOOP_MAX_REPEAT; defaulting to 3", {
+    log15.warn("Invalid CURSOR_ACP_TOOL_LOOP_MAX_REPEAT; defaulting to 3", {
       value: TOOL_LOOP_MAX_REPEAT_RAW
     });
   }
   if (ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK && PROVIDER_BOUNDARY.mode !== "v1") {
-    log14.debug("Provider boundary auto-fallback is enabled but inactive unless mode=v1");
+    log15.debug("Provider boundary auto-fallback is enabled but inactive unless mode=v1");
   }
-  log14.info("Tool loop mode configured", {
+  log15.info("Tool loop mode configured", {
     mode: TOOL_LOOP_MODE,
     providerBoundary: PROVIDER_BOUNDARY.mode,
     proxyExecToolCalls: PROXY_EXECUTE_TOOL_CALLS,
@@ -19155,12 +19234,14 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
     toolLoopMaxRepeat: TOOL_LOOP_MAX_REPEAT
   });
   await ensurePluginDirectory();
+  toastService.setClient(client3);
+  toastService.setClient(client3);
   const toolsEnabled = process.env.CURSOR_ACP_ENABLE_OPENCODE_TOOLS !== "false";
   const legacyProxyToolPathsEnabled = toolsEnabled && TOOL_LOOP_MODE === "proxy-exec";
   if (toolsEnabled && TOOL_LOOP_MODE === "opencode") {
-    log14.debug("OpenCode mode active; skipping legacy SDK/MCP discovery and proxy-side tool execution");
+    log15.debug("OpenCode mode active; skipping legacy SDK/MCP discovery and proxy-side tool execution");
   } else if (toolsEnabled && TOOL_LOOP_MODE === "off") {
-    log14.debug("Tool loop mode off; proxy-side tool execution disabled");
+    log15.debug("Tool loop mode off; proxy-side tool execution disabled");
   }
   const serverClient = legacyProxyToolPathsEnabled ? createOpencodeClient({ baseUrl: serverUrl.toString(), directory: workspaceDirectory }) : null;
   const discovery = legacyProxyToolPathsEnabled ? new OpenCodeToolDiscovery(serverClient ?? client3) : null;
@@ -19212,7 +19293,7 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
         discoveredList = await discovery.listTools();
         discoveredList.forEach((t) => toolsByName.set(t.name, t));
       } catch (err) {
-        log14.debug("Tool discovery failed, using local tools only", { error: String(err) });
+        log15.debug("Tool discovery failed, using local tools only", { error: String(err) });
       }
     }
     const allTools = [...localTools, ...discoveredList];
@@ -19242,11 +19323,11 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
     }
     lastToolNames = toolEntries.map((e) => e.function.name);
     lastToolMap = allTools.map((t) => ({ id: t.id, name: t.name }));
-    log14.debug("Tools refreshed", { local: localTools.length, discovered: discoveredList.length, total: toolEntries.length });
+    log15.debug("Tools refreshed", { local: localTools.length, discovered: discoveredList.length, total: toolEntries.length });
     return toolEntries;
   }
   const proxyBaseURL = await ensureCursorProxyServer(workspaceDirectory, router);
-  log14.debug("Proxy server started", { baseURL: proxyBaseURL });
+  log15.debug("Proxy server started", { baseURL: proxyBaseURL });
   const toolHookEntries = buildToolHookEntries(localRegistry, workspaceDirectory);
   return {
     tool: toolHookEntries,
@@ -19261,9 +19342,9 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
           type: "oauth",
           async authorize() {
             try {
-              log14.info("Starting OAuth flow");
+              log15.info("Starting OAuth flow");
               const { url: url2, instructions, callback } = await startCursorOAuth();
-              log14.debug("Got OAuth URL", { url: url2.substring(0, 50) + "..." });
+              log15.debug("Got OAuth URL", { url: url2.substring(0, 50) + "..." });
               return {
                 url: url2,
                 instructions,
@@ -19271,7 +19352,7 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
                 callback
               };
             } catch (error45) {
-              log14.error("OAuth error", { error: error45 });
+              log15.error("OAuth error", { error: error45 });
               throw error45;
             }
           }
@@ -19295,10 +19376,10 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID = "cursor-acp", C
             output.options.tools = resolved.tools;
           } else if (resolved.action === "preserve") {
             const count = Array.isArray(existingTools) ? existingTools.length : 0;
-            log14.debug("Using OpenCode-provided tools from chat.params", { count });
+            log15.debug("Using OpenCode-provided tools from chat.params", { count });
           }
         } catch (err) {
-          log14.debug("Failed to refresh tools", { error: String(err) });
+          log15.debug("Failed to refresh tools", { error: String(err) });
         }
       }
     },
@@ -19331,9 +19412,10 @@ var init_plugin = __esm(() => {
   init_executor();
   init_boundary();
   init_runtime_interception();
+  init_toast_service();
   init_tool_schema_compat();
   init_tool_loop_guard();
-  log14 = createLogger("plugin");
+  log15 = createLogger("plugin");
   DEBUG_LOG_DIR2 = join4(homedir4(), ".config", "opencode", "logs");
   DEBUG_LOG_FILE2 = join4(DEBUG_LOG_DIR2, "tool-loop-debug.log");
   CURSOR_PROVIDER_PREFIX = `${CURSOR_PROVIDER_ID}/`;
@@ -19577,7 +19659,7 @@ init_logger();
 import { execSync } from "node:child_process";
 import { createServer } from "node:net";
 import { platform as platform2 } from "node:os";
-var log15 = createLogger("proxy-server");
+var log16 = createLogger("proxy-server");
 var DEFAULT_PORT = 32124;
 var PORT_RANGE_SIZE = 256;
 async function isPortAvailable(port, host) {
@@ -19624,11 +19706,11 @@ function getUsedPortsInRange(minPort, maxPort) {
         }
       }
     } else {
-      log15.debug(`Port detection not supported on ${os2}. Using probe-based discovery.`);
+      log16.debug(`Port detection not supported on ${os2}. Using probe-based discovery.`);
     }
   } catch (error45) {
     const msg = error45 instanceof Error ? error45.message : String(error45);
-    log15.debug(`Port detection failed: ${msg}. Using probe-based discovery.`);
+    log16.debug(`Port detection failed: ${msg}. Using probe-based discovery.`);
   }
   return used;
 }
@@ -19679,7 +19761,7 @@ function createProxyServer(config2) {
       const err = error45 instanceof Error ? error45 : new Error(String(error45));
       const isPortInUse = err.message.includes("EADDRINUSE") || err.message.includes("address already in use") || err.message.includes("port is already in use");
       if (!isPortInUse) {
-        log15.debug(`Unexpected error starting on port ${port}: ${err.message}`);
+        log16.debug(`Unexpected error starting on port ${port}: ${err.message}`);
       }
       return { success: false, error: err };
     }
@@ -19695,13 +19777,13 @@ function createProxyServer(config2) {
         if (result.success) {
           port = requestedPort;
         } else {
-          log15.debug(`Requested port ${requestedPort} unavailable: ${result.error?.message ?? "unknown"}. Falling back to automatic port selection.`);
+          log16.debug(`Requested port ${requestedPort} unavailable: ${result.error?.message ?? "unknown"}. Falling back to automatic port selection.`);
           port = await findAvailablePort(host);
           const fallbackResult = tryStart(port);
           if (!fallbackResult.success) {
             throw new Error(`Failed to start server on port ${requestedPort} (${result.error?.message ?? "unknown"}) ` + `and fallback port ${port} (${fallbackResult.error?.message ?? "unknown"})`);
           }
-          log15.debug(`Server started on fallback port ${port} instead of requested port ${requestedPort}`);
+          log16.debug(`Server started on fallback port ${port} instead of requested port ${requestedPort}`);
         }
       } else {
         port = await findAvailablePort(host);
@@ -20047,11 +20129,11 @@ init_auth();
 init_auth();
 init_logger();
 import { existsSync as existsSync5 } from "fs";
-var log16 = createLogger("status");
+var log17 = createLogger("status");
 function checkAuthStatus() {
   const authFilePath = getAuthFilePath();
   const exists = existsSync5(authFilePath);
-  log16.debug("Checking auth status", { path: authFilePath });
+  log17.debug("Checking auth status", { path: authFilePath });
   if (exists) {
     return {
       authenticated: true,