@rama_nigg/open-cursor 2.3.3 → 2.3.5

package/dist/plugin-entry.js

@@ -13614,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) {
@@ -16388,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);
     },
@@ -16815,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;
@@ -16894,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 {
@@ -17286,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) {
@@ -17298,6 +17408,7 @@ function parseToolLoopMaxRepeat(value) {
   return { value: Math.floor(parsed), valid: true };
 }
 function createToolLoopGuard(messages, maxRepeat) {
+  const coarseMaxRepeat = maxRepeat * COARSE_LIMIT_MULTIPLIER;
   const {
     byCallId,
     latest,
@@ -17337,13 +17448,13 @@ function createToolLoopGuard(messages, maxRepeat) {
       }
       const strictFingerprint = `${toolCall.function.name}|${argShape}|${errorClass}`;
       const coarseFingerprint = `${toolCall.function.name}|${errorClass}`;
-      return evaluateWithFingerprints(errorClass, strictFingerprint, coarseFingerprint, counts, coarseCounts, maxRepeat);
+      return evaluateWithFingerprints(errorClass, strictFingerprint, coarseFingerprint, counts, coarseCounts, maxRepeat, coarseMaxRepeat);
     },
     evaluateValidation(toolCall, validationSignature) {
       const normalizedSignature = normalizeValidationSignature(validationSignature);
       const strictFingerprint = `${toolCall.function.name}|schema:${normalizedSignature}|validation`;
       const coarseFingerprint = `${toolCall.function.name}|validation`;
-      return evaluateWithFingerprints("validation", strictFingerprint, coarseFingerprint, validationCounts, validationCoarseCounts, maxRepeat);
+      return evaluateWithFingerprints("validation", strictFingerprint, coarseFingerprint, validationCounts, validationCoarseCounts, maxRepeat, coarseMaxRepeat);
     },
     resetFingerprint(fingerprint) {
       counts.delete(fingerprint);
@@ -17428,25 +17539,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,
@@ -17593,7 +17685,7 @@ function normalizeValidationSignature(signature) {
   const normalized = signature.trim().toLowerCase();
   return normalized.length > 0 ? normalized : "invalid";
 }
-function evaluateWithFingerprints(errorClass, strictFingerprint, coarseFingerprint, strictCounts, coarseCounts, maxRepeat) {
+function evaluateWithFingerprints(errorClass, strictFingerprint, coarseFingerprint, strictCounts, coarseCounts, maxRepeat, coarseMaxRepeat) {
   if (errorClass === "success") {
     return {
       fingerprint: strictFingerprint,
@@ -17609,12 +17701,12 @@ function evaluateWithFingerprints(errorClass, strictFingerprint, coarseFingerpri
   const coarseRepeatCount = (coarseCounts.get(coarseFingerprint) ?? 0) + 1;
   coarseCounts.set(coarseFingerprint, coarseRepeatCount);
   const strictTriggered = strictRepeatCount > maxRepeat;
-  const coarseTriggered = coarseRepeatCount > maxRepeat;
+  const coarseTriggered = coarseRepeatCount > coarseMaxRepeat;
   const preferCoarseFingerprint = coarseTriggered && !strictTriggered;
   return {
     fingerprint: preferCoarseFingerprint ? coarseFingerprint : strictFingerprint,
     repeatCount: preferCoarseFingerprint ? coarseRepeatCount : strictRepeatCount,
-    maxRepeat,
+    maxRepeat: preferCoarseFingerprint ? coarseMaxRepeat : maxRepeat,
     errorClass,
     triggered: strictTriggered || coarseTriggered,
     tracked: true
@@ -17669,23 +17761,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();
@@ -17716,7 +17791,7 @@ function containsAny(text, patterns) {
 function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var UNKNOWN_AS_SUCCESS_TOOLS;
+var UNKNOWN_AS_SUCCESS_TOOLS, COARSE_LIMIT_MULTIPLIER = 3;
 var init_tool_loop_guard = __esm(() => {
   UNKNOWN_AS_SUCCESS_TOOLS = new Set([
     "bash",
@@ -17770,9 +17845,9 @@ async function ensurePluginDirectory() {
   const pluginDir = join5(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) {
@@ -17960,9 +18035,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;
@@ -18100,7 +18175,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" }
@@ -18113,7 +18188,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;
@@ -18140,7 +18215,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,
@@ -18186,7 +18261,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
@@ -18212,7 +18287,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
           });
@@ -18226,7 +18301,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
@@ -18250,6 +18325,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) {
@@ -18260,7 +18336,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
               });
@@ -18327,6 +18403,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)));
                     },
@@ -18393,6 +18470,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)));
                   },
@@ -18440,7 +18518,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
               });
@@ -18451,9 +18529,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)}
 
@@ -18526,7 +18611,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" }));
         }
@@ -18537,7 +18622,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;
@@ -18560,7 +18645,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,
@@ -18591,14 +18676,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,
@@ -18624,7 +18709,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
             });
@@ -18638,7 +18723,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
@@ -18666,6 +18751,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;
@@ -18677,7 +18763,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);
@@ -18692,7 +18778,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
           });
@@ -18758,6 +18844,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
                 toolRouter,
                 responseMeta: { id, created, model },
+                passThroughTracker,
                 onToolUpdate: (update) => {
                   res.write(formatToolUpdateEvent(update));
                 },
@@ -18828,6 +18915,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
                 toolRouter,
                 responseMeta: { id, created, model },
+                passThroughTracker,
                 onToolUpdate: (update) => {
                   res.write(formatToolUpdateEvent(update));
                 },
@@ -18874,7 +18962,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
           });
@@ -18891,6 +18979,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",
@@ -19095,7 +19190,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;
         }
       }
@@ -19107,9 +19202,9 @@ function buildToolHookEntries(registry2, fallbackBaseDir) {
   }
   return entries;
 }
-var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "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_ID2 = "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,
@@ -19117,22 +19212,22 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
     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,
@@ -19140,12 +19235,14 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
     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;
@@ -19197,7 +19294,7 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
         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];
@@ -19227,11 +19324,11 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
     }
     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,
@@ -19246,9 +19343,9 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
           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,
@@ -19256,7 +19353,7 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
                 callback
               };
             } catch (error45) {
-              log14.error("OAuth error", { error: error45 });
+              log15.error("OAuth error", { error: error45 });
               throw error45;
             }
           }
@@ -19280,10 +19377,10 @@ var log14, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
             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) });
         }
       }
     },
@@ -19316,9 +19413,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 = join5(homedir5(), ".config", "opencode", "logs");
   DEBUG_LOG_FILE2 = join5(DEBUG_LOG_DIR2, "tool-loop-debug.log");
   CURSOR_PROVIDER_PREFIX = `${CURSOR_PROVIDER_ID2}/`;
@@ -19411,11 +19509,11 @@ function shouldEnableCursorPlugin(env = process.env) {
 
 // src/plugin-entry.ts
 init_logger();
-var log15 = createLogger("plugin-entry");
+var log16 = createLogger("plugin-entry");
 var CursorPluginEntry = async (input) => {
   const state = shouldEnableCursorPlugin();
   if (!state.enabled) {
-    log15.info("Plugin disabled in OpenCode config; skipping initialization", {
+    log16.info("Plugin disabled in OpenCode config; skipping initialization", {
       configPath: state.configPath,
       reason: state.reason
     });