@rama_nigg/open-cursor 2.3.3 → 2.3.4

package/src/proxy/tool-loop.ts

@@ -12,6 +12,13 @@ export interface OpenAiToolCall {
   };
 }
 
+export interface ToolCallExtractionResult {
+  action: "intercept" | "passthrough" | "skip";
+  toolCall?: OpenAiToolCall;
+  passthroughName?: string;
+  skipReason?: string;
+}
+
 export interface ToolLoopMeta {
   id: string;
   created: number;
@@ -106,48 +113,55 @@ export function extractAllowedToolNames(tools: Array<any>): Set<string> {
 export function extractOpenAiToolCall(
   event: StreamJsonToolCallEvent,
   allowedToolNames: Set<string>,
-): OpenAiToolCall | null {
+): ToolCallExtractionResult {
   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) {
-    log.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 (resolvedName) {
+    // Known tool → intercept and forward to OpenCode
+    if (args === undefined && event.subtype === "started") {
+      log.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 (args === undefined && event.subtype === "started") {
-    log.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 as any).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 as any).tool_call_id || "call_unknown";
+  // Unknown tool → pass through to cursor-agent
+  log.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,
   };
 }
 

package/src/services/toast-service.ts

@@ -0,0 +1,81 @@
+/**
+ * ToastService - OpenCode toast notification integration
+ *
+ * Provides toast notifications for MCP tool pass-through visibility.
+ * Gracefully degrades when client.tui.showToast is unavailable.
+ */
+
+import { createLogger } from "../utils/logger.js";
+
+const log = createLogger("services:toast");
+
+export interface ToastOptions {
+  title?: string;
+  message: string;
+  variant: "info" | "success" | "warning" | "error";
+}
+
+export interface OpenCodeTuiClient {
+  showToast: (options: { body: { title?: string; message: string; variant: string } }) => Promise<void>;
+}
+
+export interface OpenCodeClientWithTui {
+  tui?: OpenCodeTuiClient;
+}
+
+export class ToastService {
+  private client: OpenCodeClientWithTui | null = null;
+
+  setClient(client: OpenCodeClientWithTui): void {
+    this.client = client;
+  }
+
+  async show(options: ToastOptions): Promise<void> {
+    if (!this.client?.tui?.showToast) {
+      log.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 (error) {
+      log.debug("Toast failed", { error, message: options.message });
+    }
+  }
+
+  async showPassThroughSummary(tools: string[]): Promise<void> {
+    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: `🎭 ${tools.length} tool${tools.length > 1 ? "s" : ""} handled by cursor-agent: ${toolList}`,
+      variant: "info",
+    });
+  }
+
+  async showErrorSummary(errors: string[]): Promise<void> {
+    if (errors.length === 0) return;
+
+    const errorList = errors.length <= 2
+      ? errors.join("; ")
+      : `${errors.slice(0, 2).join("; ")} +${errors.length - 2} more`;
+
+    await this.show({
+      title: "MCP Errors",
+      message: `⚠️ ${errors.length} MCP tool${errors.length > 1 ? "s" : ""} failed: ${errorList}`,
+      variant: "warning",
+    });
+  }
+}
+
+export const toastService = new ToastService();