@evanovation/open-cursor 2.4.15

package/src/proxy/tool-loop.ts

@@ -0,0 +1,359 @@
+import type { StreamJsonToolCallEvent } from "../streaming/types.js";
+import { createLogger } from "../utils/logger.js";
+
+const log = createLogger("proxy:tool-loop");
+
+export interface OpenAiToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+export interface ToolCallExtractionResult {
+  action: "intercept" | "passthrough" | "skip";
+  toolCall?: OpenAiToolCall;
+  passthroughName?: string;
+  skipReason?: string;
+}
+
+export interface ToolLoopMeta {
+  id: string;
+  created: number;
+  model: string;
+}
+
+const TOOL_NAME_ALIASES = new Map<string, string>([
+  // bash aliases
+  ["runcommand", "bash"],
+  ["executecommand", "bash"],
+  ["runterminalcommand", "bash"],
+  ["terminalcommand", "bash"],
+  ["shellcommand", "bash"],
+  ["shell", "bash"],
+  ["terminal", "bash"],
+  ["bashcommand", "bash"],
+  ["runbash", "bash"],
+  ["executebash", "bash"],
+  // edit/write aliases
+  ["ocedit", "edit"],
+  ["strreplace", "edit"],
+  ["ocwrite", "write"],
+  ["writefile", "write"],
+  // read aliases
+  ["ocread", "read"],
+  // grep aliases
+  ["ocgrep", "grep"],
+  // glob aliases
+  ["findfiles", "glob"],
+  ["searchfiles", "glob"],
+  ["globfiles", "glob"],
+  ["fileglob", "glob"],
+  ["matchfiles", "glob"],
+  // mkdir aliases
+  ["createdirectory", "mkdir"],
+  ["makedirectory", "mkdir"],
+  ["mkdirp", "mkdir"],
+  ["createdir", "mkdir"],
+  ["makefolder", "mkdir"],
+  // rm aliases
+  ["delete", "rm"],
+  ["deletefile", "rm"],
+  ["deletepath", "rm"],
+  ["deletedirectory", "rm"],
+  ["remove", "rm"],
+  ["removefile", "rm"],
+  ["removepath", "rm"],
+  ["unlink", "rm"],
+  ["rmdir", "rm"],
+  // stat aliases
+  ["getfileinfo", "stat"],
+  ["fileinfo", "stat"],
+  ["filestat", "stat"],
+  ["pathinfo", "stat"],
+  // ls aliases
+  ["listdirectory", "ls"],
+  ["listfiles", "ls"],
+  ["listdir", "ls"],
+  ["readdir", "ls"],
+  // todo write aliases
+  ["updatetodos", "todowrite"],
+  ["updatetodostoolcall", "todowrite"],
+  ["todowrite", "todowrite"],
+  ["todowritetoolcall", "todowrite"],
+  ["writetodos", "todowrite"],
+  ["todowritefn", "todowrite"],
+  // todo read aliases
+  ["readtodos", "todoread"],
+  ["readtodostoolcall", "todoread"],
+  ["todoread", "todoread"],
+  ["todoreadtoolcall", "todoread"],
+  // sub-agent and delegation aliases
+  ["callomoagent", "call_omo_agent"],
+  ["callagent", "call_omo_agent"],
+  ["invokeagent", "call_omo_agent"],
+  ["delegatetask", "task"],
+  ["delegate", "task"],
+  ["runtask", "task"],
+  ["subagent", "task"],
+  // skill aliases
+  ["useskill", "skill"],
+  ["invokeskill", "skill"],
+  ["runskill", "skill"],
+  ["skillmcp", "skill_mcp"],
+  ["mcp_skill", "skill_mcp"],
+  ["runmcpskill", "skill_mcp"],
+  ["invokeskillmcp", "skill_mcp"],
+  // question aliases (Cursor-trained models often emit AskQuestion / ask_user)
+  ["askquestion", "question"],
+  ["askuser", "question"],
+  ["askuserquestion", "question"],
+  ["askquestions", "question"],
+  ["promptuser", "question"],
+]);
+
+export function extractAllowedToolNames(tools: Array<any>): Set<string> {
+  const names = new Set<string>();
+  for (const tool of tools) {
+    const fn = tool?.function ?? tool;
+    if (fn && typeof fn.name === "string" && fn.name.length > 0) {
+      names.add(fn.name);
+    }
+  }
+  return names;
+}
+
+export function extractOpenAiToolCall(
+  event: StreamJsonToolCallEvent,
+  allowedToolNames: Set<string>,
+): ToolCallExtractionResult {
+  if (allowedToolNames.size === 0) {
+    return { action: "skip", skipReason: "no_allowed_tools" };
+  }
+
+  const { name, args, skipped } = extractToolNameAndArgs(event);
+  if (skipped) {
+    return { action: "skip", skipReason: "event_skipped" };
+  }
+  if (!name) {
+    return { action: "skip", skipReason: "no_name" };
+  }
+
+  // Defensive check: if model tries to call "mcp" directly, it's a mistake.
+  // MCP tools must be called with their full names like mcp__server__tool.
+  if (name.toLowerCase() === "mcp") {
+    log.warn("Model attempted to call 'mcp' directly (not a valid tool name)", {
+      args,
+      hint: "MCP tools must be called by their full name (e.g. mcp__engram__mem_save), not 'mcp'",
+    });
+    return {
+      action: "passthrough",
+      passthroughName: name,
+    };
+  }
+
+  const resolvedName = resolveAllowedToolName(name, allowedToolNames);
+  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),
+      });
+    }
+
+    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),
+        },
+      },
+    };
+  }
+
+  // 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 {
+    action: "passthrough",
+    passthroughName: name,
+  };
+}
+
+export function createToolCallCompletionResponse(meta: ToolLoopMeta, toolCall: OpenAiToolCall) {
+  return {
+    id: meta.id,
+    object: "chat.completion",
+    created: meta.created,
+    model: meta.model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: null,
+          tool_calls: [toolCall],
+        },
+        finish_reason: "tool_calls",
+      },
+    ],
+  };
+}
+
+export function createToolCallStreamChunks(meta: ToolLoopMeta, toolCall: OpenAiToolCall): Array<any> {
+  const toolDelta = {
+    id: meta.id,
+    object: "chat.completion.chunk",
+    created: meta.created,
+    model: meta.model,
+    choices: [
+      {
+        index: 0,
+        delta: {
+          role: "assistant",
+          tool_calls: [
+            {
+              index: 0,
+              ...toolCall,
+            },
+          ],
+        },
+        finish_reason: null,
+      },
+    ],
+  };
+
+  const finishChunk = {
+    id: meta.id,
+    object: "chat.completion.chunk",
+    created: meta.created,
+    model: meta.model,
+    choices: [
+      {
+        index: 0,
+        delta: {},
+        finish_reason: "tool_calls",
+      },
+    ],
+  };
+
+  return [toolDelta, finishChunk];
+}
+
+function extractToolNameAndArgs(event: StreamJsonToolCallEvent): {
+  name: string | null;
+  args: unknown;
+  skipped: boolean;
+} {
+  let name = typeof (event as any).name === "string" ? (event as any).name : null;
+  let args: unknown = undefined;
+
+  const entries = Object.entries(event.tool_call || {});
+  if (entries.length > 0) {
+    const [rawName, payload] = entries[0];
+    if (!name) {
+      name = normalizeToolName(rawName);
+    }
+    const payloadRecord = isRecord(payload) ? payload : null;
+    args = payloadRecord?.args;
+
+    // Some tool-call events include a flat payload without an `args` wrapper.
+    if (args === undefined && payloadRecord) {
+      const { result: _result, ...rest } = payloadRecord;
+      const restKeys = Object.keys(rest);
+      if (restKeys.length === 0) {
+        if (name) {
+          name = normalizeToolName(name);
+        }
+        return { name, args: undefined, skipped: true };
+      }
+      args = rest;
+    }
+  }
+
+  if (name) {
+    name = normalizeToolName(name);
+  }
+
+  return { name, args, skipped: false };
+}
+
+function normalizeToolName(raw: string): string {
+  if (raw.endsWith("ToolCall")) {
+    const base = raw.slice(0, -"ToolCall".length);
+    return base.charAt(0).toLowerCase() + base.slice(1);
+  }
+  return raw;
+}
+
+function resolveAllowedToolName(name: string, allowedToolNames: Set<string>): string | null {
+  if (allowedToolNames.has(name)) {
+    return name;
+  }
+
+  const normalizedName = normalizeAliasKey(name);
+  for (const allowedName of allowedToolNames) {
+    if (normalizeAliasKey(allowedName) === normalizedName) {
+      return allowedName;
+    }
+  }
+
+  const aliasedCanonical = TOOL_NAME_ALIASES.get(normalizedName);
+  if (!aliasedCanonical) {
+    return null;
+  }
+
+  const canonicalNormalized = normalizeAliasKey(aliasedCanonical);
+  for (const allowedName of allowedToolNames) {
+    if (normalizeAliasKey(allowedName) === canonicalNormalized) {
+      return allowedName;
+    }
+  }
+
+  return null;
+}
+
+function normalizeAliasKey(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function toOpenAiArguments(args: unknown): string {
+  if (args === undefined) {
+    return "{}";
+  }
+
+  if (typeof args === "string") {
+    try {
+      const parsed = JSON.parse(args);
+      if (parsed && typeof parsed === "object") {
+        return JSON.stringify(parsed);
+      }
+      return JSON.stringify({ value: parsed });
+    } catch {
+      return JSON.stringify({ value: args });
+    }
+  }
+
+  if (typeof args === "object" && args !== null) {
+    return JSON.stringify(args);
+  }
+
+  return JSON.stringify({ value: args });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/proxy/types.ts

@@ -0,0 +1,13 @@
+export interface ProxyConfig {
+  port?: number;
+  host?: string;
+  healthCheckPath?: string;
+  requestTimeout?: number;
+}
+
+export interface ProxyServer {
+  start(): Promise<string>;
+  stop(): Promise<void>;
+  getBaseURL(): string;
+  getPort(): number | null;
+}

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();

package/src/streaming/ai-sdk-parts.ts

@@ -0,0 +1,109 @@
+import {
+  extractText,
+  extractThinking,
+  inferToolName,
+  isAssistantText,
+  isThinking,
+  isToolCall,
+  type StreamJsonEvent,
+  type StreamJsonToolCallEvent,
+} from "./types.js";
+import { MixedDeltaTracker } from "./delta-tracker.js";
+
+export type AiSdkStreamPart =
+  | {
+      type: "text-delta";
+      textDelta: string;
+    }
+  | {
+      type: "tool-call-streaming-start";
+      toolCallId: string;
+      toolName: string;
+    }
+  | {
+      type: "tool-call-delta";
+      toolCallId: string;
+      toolName: string;
+      argsTextDelta: string;
+    }
+  | {
+      type: "tool-input-available";
+      toolCallId: string;
+      toolName: string;
+      inputText: string;
+    };
+
+export class StreamToAiSdkParts {
+  private readonly toolArgsById = new Map<string, string>();
+  private readonly startedToolIds = new Set<string>();
+  private readonly tracker = new MixedDeltaTracker();
+
+  handleEvent(event: StreamJsonEvent): AiSdkStreamPart[] {
+    if (isAssistantText(event)) {
+      const text = extractText(event);
+      if (!text) return [];
+      const delta = this.tracker.nextText(text);
+      return delta ? [{ type: "text-delta", textDelta: delta }] : [];
+    }
+
+    if (isThinking(event)) {
+      const text = extractThinking(event);
+      if (!text) return [];
+      const delta = this.tracker.nextThinking(text);
+      return delta ? [{ type: "text-delta", textDelta: delta }] : [];
+    }
+
+    if (isToolCall(event)) {
+      return this.handleToolCall(event);
+    }
+
+    return [];
+  }
+
+  private handleToolCall(event: StreamJsonToolCallEvent): AiSdkStreamPart[] {
+    const toolCallId = event.call_id || (event as { tool_call_id?: string }).tool_call_id || "unknown";
+    const toolName = inferToolName(event) || "tool";
+    const toolKey = Object.keys(event.tool_call ?? {})[0];
+    const entry = toolKey ? event.tool_call[toolKey] : undefined;
+    const parts: AiSdkStreamPart[] = [];
+
+    if (entry?.args) {
+      const argsText = JSON.stringify(entry.args);
+      const previous = this.toolArgsById.get(toolCallId) ?? "";
+      const delta = argsText.startsWith(previous)
+        ? argsText.slice(previous.length)
+        : argsText;
+
+      this.toolArgsById.set(toolCallId, argsText);
+
+      if (!this.startedToolIds.has(toolCallId)) {
+        this.startedToolIds.add(toolCallId);
+        parts.push({
+          type: "tool-call-streaming-start",
+          toolCallId,
+          toolName,
+        });
+      }
+
+      if (delta) {
+        parts.push({
+          type: "tool-call-delta",
+          toolCallId,
+          toolName,
+          argsTextDelta: delta,
+        });
+      }
+    }
+
+    if (entry?.result) {
+      parts.push({
+        type: "tool-input-available",
+        toolCallId,
+        toolName,
+        inputText: JSON.stringify(entry.result),
+      });
+    }
+
+    return parts;
+  }
+}

package/src/streaming/delta-tracker.ts

@@ -0,0 +1,89 @@
+export class DeltaTracker {
+  private lastText = "";
+  private lastThinking = "";
+
+  nextText(value: string): string {
+    const delta = this.diff(this.lastText, value);
+    this.lastText = value;
+    return delta;
+  }
+
+  nextThinking(value: string): string {
+    const delta = this.diff(this.lastThinking, value);
+    this.lastThinking = value;
+    return delta;
+  }
+
+  reset(): void {
+    this.lastText = "";
+    this.lastThinking = "";
+  }
+
+  private diff(previous: string, current: string): string {
+    if (!previous) {
+      return current;
+    }
+
+    // Happy path: accumulated text grows with exact prefix match
+    if (current.startsWith(previous)) {
+      return current.slice(previous.length);
+    }
+
+    // Accumulated text was already fully emitted (e.g. duplicate or trimmed event)
+    if (previous.startsWith(current)) {
+      return "";
+    }
+
+    // Prefix mismatch (formatting drift, unicode normalization, whitespace changes):
+    // find longest common prefix and emit only the new suffix.
+    // This prevents re-emitting the entire accumulated text as a "delta".
+    let i = 0;
+    const minLen = Math.min(previous.length, current.length);
+    while (i < minLen && previous[i] === current[i]) {
+      i++;
+    }
+    return current.slice(i);
+  }
+}
+
+export class MixedDeltaTracker {
+  private emittedText = "";
+  private emittedThinking = "";
+
+  nextText(value: string): string {
+    const delta = this.diff(this.emittedText, value);
+    if (delta) {
+      this.emittedText += delta;
+    }
+    return delta;
+  }
+
+  nextThinking(value: string): string {
+    const delta = this.diff(this.emittedThinking, value);
+    if (delta) {
+      this.emittedThinking += delta;
+    }
+    return delta;
+  }
+
+  reset(): void {
+    this.emittedText = "";
+    this.emittedThinking = "";
+  }
+
+  private diff(emitted: string, current: string): string {
+    if (!emitted) {
+      return current;
+    }
+
+    if (current.startsWith(emitted)) {
+      return current.slice(emitted.length);
+    }
+
+    if (emitted.startsWith(current)) {
+      return "";
+    }
+
+    return current;
+  }
+}

package/src/streaming/line-buffer.ts

@@ -0,0 +1,44 @@
+export class LineBuffer {
+  private buffer = "";
+  private decoder = new TextDecoder();
+
+  push(chunk: string | Uint8Array): string[] {
+    const text = typeof chunk === "string" ? chunk : this.decoder.decode(chunk);
+    if (!text) {
+      return [];
+    }
+
+    this.buffer += text;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+
+    const completed: string[] = [];
+    for (const line of lines) {
+      const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
+      if (!normalized.trim()) {
+        continue;
+      }
+      completed.push(normalized);
+    }
+
+    return completed;
+  }
+
+  flush(): string[] {
+    if (!this.buffer.trim()) {
+      this.buffer = "";
+      return [];
+    }
+
+    const normalized = this.buffer.endsWith("\r")
+      ? this.buffer.slice(0, -1)
+      : this.buffer;
+    this.buffer = "";
+
+    if (!normalized.trim()) {
+      return [];
+    }
+
+    return [normalized];
+  }
+}