@rama_nigg/open-cursor 2.4.4 → 2.4.6

package/dist/index.js

@@ -456,6 +456,15 @@ function resolveCursorAgentBinary(deps = {}) {
   log.warn("cursor-agent not found at known paths, falling back to PATH", { checkedPaths: knownPaths });
   return "cursor-agent";
 }
+function formatShellCommandForPlatform(command, platform = process.platform) {
+  if (platform !== "win32") {
+    return command;
+  }
+  if (command.startsWith('"') && command.endsWith('"')) {
+    return command;
+  }
+  return `"${command}"`;
+}
 var log;
 var init_binary = __esm(() => {
   init_logger();
@@ -505,7 +514,7 @@ async function pollForAuthFile(timeoutMs = AUTH_POLL_TIMEOUT, intervalMs = AUTH_
 async function startCursorOAuth() {
   return new Promise((resolve, reject) => {
     log2.info("Starting cursor-cli login process");
-    const proc = spawn(resolveCursorAgentBinary(), ["login"], {
+    const proc = spawn(formatShellCommandForPlatform(resolveCursorAgentBinary()), ["login"], {
       stdio: ["pipe", "pipe", "pipe"],
       shell: process.platform === "win32"
     });
@@ -699,29 +708,6 @@ class LineBuffer {
   }
 }
 
-// src/streaming/types.ts
-var hasTextContent = (event) => event.message.content.some((content) => content.type === "text"), hasThinkingContent = (event) => event.message.content.some((content) => content.type === "thinking"), isAssistantText = (event) => event.type === "assistant" && hasTextContent(event), isThinking = (event) => {
-  if (event.type === "thinking") {
-    return true;
-  }
-  return event.type === "assistant" && hasThinkingContent(event);
-}, isToolCall = (event) => event.type === "tool_call", isResult = (event) => event.type === "result", extractText = (event) => event.message.content.filter((content) => content.type === "text").map((content) => content.text).join(""), extractThinking = (event) => {
-  if (event.type === "thinking") {
-    return event.text ?? "";
-  }
-  return event.message.content.filter((content) => content.type === "thinking").map((content) => content.thinking).join("");
-}, inferToolName = (event) => {
-  const [key] = Object.keys(event.tool_call ?? {});
-  if (!key) {
-    return "";
-  }
-  if (key.endsWith("ToolCall")) {
-    const base = key.slice(0, -"ToolCall".length);
-    return base.charAt(0).toLowerCase() + base.slice(1);
-  }
-  return key;
-};
-
 // src/streaming/delta-tracker.ts
 class DeltaTracker {
   lastText = "";
@@ -759,14 +745,70 @@ class DeltaTracker {
   }
 }
 
+class MixedDeltaTracker {
+  emittedText = "";
+  emittedThinking = "";
+  nextText(value) {
+    const delta = this.diff(this.emittedText, value);
+    if (delta) {
+      this.emittedText += delta;
+    }
+    return delta;
+  }
+  nextThinking(value) {
+    const delta = this.diff(this.emittedThinking, value);
+    if (delta) {
+      this.emittedThinking += delta;
+    }
+    return delta;
+  }
+  reset() {
+    this.emittedText = "";
+    this.emittedThinking = "";
+  }
+  diff(emitted, current) {
+    if (!emitted) {
+      return current;
+    }
+    if (current.startsWith(emitted)) {
+      return current.slice(emitted.length);
+    }
+    if (emitted.startsWith(current)) {
+      return "";
+    }
+    return current;
+  }
+}
+
+// src/streaming/types.ts
+var hasTextContent = (event) => event.message.content.some((content) => content.type === "text"), hasThinkingContent = (event) => event.message.content.some((content) => content.type === "thinking"), isAssistantText = (event) => event.type === "assistant" && hasTextContent(event), isThinking = (event) => {
+  if (event.type === "thinking") {
+    return true;
+  }
+  return event.type === "assistant" && hasThinkingContent(event);
+}, isToolCall = (event) => event.type === "tool_call", isResult = (event) => event.type === "result", extractText = (event) => event.message.content.filter((content) => content.type === "text").map((content) => content.text).join(""), extractThinking = (event) => {
+  if (event.type === "thinking") {
+    return event.text ?? "";
+  }
+  return event.message.content.filter((content) => content.type === "thinking").map((content) => content.thinking).join("");
+}, inferToolName = (event) => {
+  const [key] = Object.keys(event.tool_call ?? {});
+  if (!key) {
+    return "";
+  }
+  if (key.endsWith("ToolCall")) {
+    const base = key.slice(0, -"ToolCall".length);
+    return base.charAt(0).toLowerCase() + base.slice(1);
+  }
+  return key;
+};
+
 // src/streaming/openai-sse.ts
 class StreamToSseConverter {
   id;
   created;
   model;
-  tracker = new DeltaTracker;
-  sawAssistantPartials = false;
-  sawThinkingPartials = false;
+  tracker = new MixedDeltaTracker;
   constructor(model, options) {
     this.model = model;
     this.id = options?.id ?? `cursor-acp-${Date.now()}`;
@@ -774,35 +816,17 @@ class StreamToSseConverter {
   }
   handleEvent(event) {
     if (isAssistantText(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractText(event);
-        if (text) {
-          this.sawAssistantPartials = true;
-          return [this.chunkWith({ content: text })];
-        }
-        return [];
-      }
-      if (this.sawAssistantPartials) {
+      const text = extractText(event);
+      if (!text)
         return [];
-      }
-      const delta = this.tracker.nextText(extractText(event));
+      const delta = this.tracker.nextText(text);
       return delta ? [this.chunkWith({ content: delta })] : [];
     }
     if (isThinking(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractThinking(event);
-        if (text) {
-          this.sawThinkingPartials = true;
-          return [this.chunkWith({ reasoning_content: text })];
-        }
-        return [];
-      }
-      if (this.sawThinkingPartials) {
+      const text = extractThinking(event);
+      if (!text)
         return [];
-      }
-      const delta = this.tracker.nextThinking(extractThinking(event));
+      const delta = this.tracker.nextThinking(text);
       return delta ? [this.chunkWith({ reasoning_content: delta })] : [];
     }
     if (isToolCall(event)) {
@@ -978,27 +1002,6 @@ var init_perf = __esm(() => {
 });
 
 // src/proxy/prompt-builder.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
-function ensureLogDir2() {
-  try {
-    if (!existsSync3(DEBUG_LOG_DIR)) {
-      mkdirSync2(DEBUG_LOG_DIR, { recursive: true });
-    }
-  } catch {}
-}
-function debugLogToFile(message, data) {
-  try {
-    ensureLogDir2();
-    const timestamp = new Date().toISOString();
-    const logLine = `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
-`;
-    appendFileSync2(DEBUG_LOG_FILE, logLine);
-  } catch (err) {
-    log5.debug(message, data);
-  }
-}
 function buildPromptFromMessages(messages, tools, subagentNames = []) {
   const messageSummary = messages.map((m, i) => {
     const role = m?.role ?? "?";
@@ -1012,7 +1015,7 @@ function buildPromptFromMessages(messages, tools, subagentNames = []) {
   const assistantWithToolCalls = messages.filter((m) => m?.role === "assistant" && Array.isArray(m?.tool_calls) && m.tool_calls.length > 0);
   const assistantEmpty = messages.filter((m) => m?.role === "assistant" && (!m?.tool_calls || m.tool_calls.length === 0) && (!m?.content || m.content === "" || m.content === null));
   const toolResults = messages.filter((m) => m?.role === "tool");
-  debugLogToFile("buildPromptFromMessages", {
+  log5.debug("buildPromptFromMessages", {
     totalMessages: messages.length,
     totalTools: tools.length,
     messageSummary,
@@ -1107,22 +1110,20 @@ ${toolDescs}`);
   const finalPrompt = lines.join(`
 
 `);
-  debugLogToFile("buildPromptFromMessages: final prompt", {
+  log5.debug("buildPromptFromMessages: final prompt", {
     lineCount: lines.length,
     promptLength: finalPrompt.length,
     promptPreview: finalPrompt.slice(0, 500),
     hasToolResultFormat: finalPrompt.includes("TOOL_RESULT"),
     hasAssistantToolCallFormat: finalPrompt.includes("tool_call(id:"),
-    hasCompletionSignal: finalPrompt.includes("Based on the tool results")
+    hasCompletionSignal: finalPrompt.includes("The above tool calls have been executed")
   });
   return finalPrompt;
 }
-var log5, DEBUG_LOG_DIR, DEBUG_LOG_FILE;
+var log5;
 var init_prompt_builder = __esm(() => {
   init_logger();
   log5 = createLogger("proxy:prompt-builder");
-  DEBUG_LOG_DIR = join4(homedir3(), ".config", "opencode", "logs");
-  DEBUG_LOG_FILE = join4(DEBUG_LOG_DIR, "tool-loop-debug.log");
 });
 
 // src/proxy/tool-loop.ts
@@ -1803,9 +1804,9 @@ var init_model_discovery = __esm(() => {
 });
 
 // src/plugin-toggle.ts
-import { existsSync as existsSync4, readFileSync } from "fs";
-import { homedir as homedir4 } from "os";
-import { join as join5, resolve } from "path";
+import { existsSync as existsSync3, readFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join4, resolve } from "path";
 function matchesPlugin(entry) {
   if (entry === CURSOR_PROVIDER_ID)
     return true;
@@ -1819,8 +1820,8 @@ function resolveOpenCodeConfigPath(env = process.env) {
   if (env.OPENCODE_CONFIG && env.OPENCODE_CONFIG.length > 0) {
     return resolve(env.OPENCODE_CONFIG);
   }
-  const configHome = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0 ? env.XDG_CONFIG_HOME : join5(homedir4(), ".config");
-  return join5(configHome, "opencode", "opencode.json");
+  const configHome = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME.length > 0 ? env.XDG_CONFIG_HOME : join4(homedir3(), ".config");
+  return join4(configHome, "opencode", "opencode.json");
 }
 function isCursorPluginEnabledInConfig(config) {
   if (!config || typeof config !== "object") {
@@ -1839,7 +1840,7 @@ function isCursorPluginEnabledInConfig(config) {
 }
 function shouldEnableCursorPlugin(env = process.env) {
   const configPath = resolveOpenCodeConfigPath(env);
-  if (!existsSync4(configPath)) {
+  if (!existsSync3(configPath)) {
     return {
       enabled: true,
       configPath,
@@ -11975,7 +11976,7 @@ function buildMcpToolDefinitions(tools) {
 function namespaceMcpTool(serverName, toolName) {
   const sanitizedServer = serverName.replace(/[^a-zA-Z0-9]/g, "_");
   const sanitizedTool = toolName.replace(/[^a-zA-Z0-9]/g, "_");
-  return `mcp__${sanitizedServer}__${sanitizedTool}`;
+  return `${MCP_TOOL_PREFIX}${sanitizedServer}__${sanitizedTool}`;
 }
 function mcpSchemaToZod(inputSchema, z2) {
   if (!inputSchema || typeof inputSchema !== "object") {
@@ -12017,7 +12018,7 @@ function mcpSchemaToZod(inputSchema, z2) {
   }
   return shape;
 }
-var log13;
+var log13, MCP_TOOL_PREFIX = "mcp__";
 var init_tool_bridge = __esm(() => {
   init_logger();
   log13 = createLogger("mcp:tool-bridge");
@@ -14022,9 +14023,6 @@ function resolveEditArguments(args) {
       newString = fallbackContent;
     }
   }
-  if (oldString === undefined && newString !== undefined) {
-    oldString = "";
-  }
   return {
     path: path2,
     old_string: oldString,
@@ -14431,7 +14429,10 @@ function applyToolSchemaCompat(toolCall, toolSchemaMap) {
   const toolSpecificArgs = normalizeToolSpecificArgs(toolCall.function.name, normalizedArgs);
   const schema = toolSchemaMap.get(toolCall.function.name);
   const sanitization = sanitizeArgumentsForSchema(toolSpecificArgs, schema);
-  const validation = validateToolArguments(toolCall.function.name, sanitization.args, schema, sanitization.unexpected);
+  const validation = validateToolArguments(toolCall.function.name, sanitization.args, schema, sanitization.unexpected, {
+    originalArgs: parsedArgs,
+    writeSchema: toolSchemaMap.get("write")
+  });
   const normalizedToolCall = {
     ...toolCall,
     function: {
@@ -14442,12 +14443,59 @@ function applyToolSchemaCompat(toolCall, toolSchemaMap) {
   return {
     toolCall: normalizedToolCall,
     normalizedArgs: sanitization.args,
+    originalArgs: parsedArgs,
     originalArgKeys,
     normalizedArgKeys: Object.keys(sanitization.args),
     collisionKeys,
     validation
   };
 }
+function isFullFileShapedEditValidationFailure(toolName, args, validation, originalArgs, writeSchema) {
+  if (toolName.toLowerCase() !== "edit" || validation.ok) {
+    return false;
+  }
+  return buildEditFullFileHint(args, validation.missing, validation.typeErrors, {
+    originalArgs,
+    writeSchema
+  }) !== null;
+}
+function buildWriteArguments(filePath, content, writeSchema) {
+  if (!isRecord3(writeSchema)) {
+    return { path: filePath, content };
+  }
+  const required = Array.isArray(writeSchema.required) ? writeSchema.required.filter((value) => typeof value === "string") : [];
+  if (required.includes("filePath")) {
+    return { filePath, content };
+  }
+  return { path: filePath, content };
+}
+function tryRerouteEditToWrite(toolCall, compat, allowedToolNames, toolSchemaMap) {
+  if (toolCall.function.name.toLowerCase() !== "edit") {
+    return null;
+  }
+  if (!allowedToolNames.has("write") || !toolSchemaMap.has("write")) {
+    return null;
+  }
+  const writeSchema = toolSchemaMap.get("write");
+  if (!isFullFileShapedEditValidationFailure(toolCall.function.name, compat.normalizedArgs, compat.validation, compat.originalArgs, writeSchema)) {
+    return null;
+  }
+  const filePath = typeof compat.normalizedArgs.path === "string" && compat.normalizedArgs.path.length > 0 ? compat.normalizedArgs.path : typeof compat.normalizedArgs.filePath === "string" && compat.normalizedArgs.filePath.length > 0 ? compat.normalizedArgs.filePath : null;
+  if (!filePath) {
+    return null;
+  }
+  const content = typeof compat.normalizedArgs.new_string === "string" ? compat.normalizedArgs.new_string : typeof compat.normalizedArgs.newString === "string" ? compat.normalizedArgs.newString : typeof compat.normalizedArgs.content === "string" ? compat.normalizedArgs.content : null;
+  if (content === null) {
+    return null;
+  }
+  return {
+    ...toolCall,
+    function: {
+      name: "write",
+      arguments: JSON.stringify(buildWriteArguments(filePath, content, writeSchema))
+    }
+  };
+}
 function parseArguments(rawArguments) {
   try {
     const parsed = JSON.parse(rawArguments);
@@ -14630,7 +14678,7 @@ function sanitizeArgumentsForSchema(args, schema) {
   }
   return { args: sanitized, unexpected };
 }
-function validateToolArguments(toolName, args, schema, unexpected) {
+function validateToolArguments(toolName, args, schema, unexpected, context = {}) {
   if (!isRecord3(schema)) {
     return {
       hasSchema: false,
@@ -14666,10 +14714,59 @@ function validateToolArguments(toolName, args, schema, unexpected) {
     missing,
     unexpected,
     typeErrors,
-    repairHint: ok ? undefined : buildRepairHint(toolName, missing, unexpected, typeErrors)
+    repairHint: ok ? undefined : buildRepairHint(toolName, args, missing, unexpected, typeErrors, context)
   };
 }
-function buildRepairHint(toolName, missing, unexpected, typeErrors) {
+function hadOldStringPropertyInPayload(args) {
+  for (const key of Object.keys(args)) {
+    const token = key.toLowerCase().replace(/[^a-z0-9]/g, "");
+    if (token === "oldstring") {
+      return true;
+    }
+  }
+  return false;
+}
+function hasEditFilePath(args) {
+  const pathValue = args.path ?? args.filePath;
+  return typeof pathValue === "string" && pathValue.trim().length > 0;
+}
+function hasEditBody(args) {
+  const body = args.new_string ?? args.newString ?? args.content;
+  return typeof body === "string" && body.length > 0;
+}
+function writeToolExample(writeSchema) {
+  if (!isRecord3(writeSchema)) {
+    return "write with path and content";
+  }
+  const required = Array.isArray(writeSchema.required) ? writeSchema.required.filter((value) => typeof value === "string") : [];
+  if (required.includes("filePath")) {
+    return "write with filePath and content";
+  }
+  return "write with path and content";
+}
+function buildEditFullFileHint(args, missing, typeErrors, context) {
+  if (typeErrors.length > 0) {
+    return null;
+  }
+  const missingOldStringOnly = (missing.includes("old_string") || missing.includes("oldString")) && missing.every((key) => key === "old_string" || key === "oldString");
+  if (!missingOldStringOnly) {
+    return null;
+  }
+  const originalArgs = context.originalArgs ?? {};
+  if (hadOldStringPropertyInPayload(originalArgs)) {
+    return null;
+  }
+  if (!hasEditFilePath(args) || !hasEditBody(args)) {
+    return null;
+  }
+  const example = writeToolExample(context.writeSchema);
+  return `For a full file body, use ${example} instead of edit without old_string`;
+}
+function buildRepairHint(toolName, args, missing, unexpected, typeErrors, context = {}) {
+  const fullFileHint = toolName.toLowerCase() === "edit" ? buildEditFullFileHint(args, missing, typeErrors, context) : null;
+  if (fullFileHint) {
+    return fullFileHint;
+  }
   const hints = [];
   if (missing.length > 0) {
     hints.push(`missing required: ${missing.join(", ")}`);
@@ -14680,7 +14777,7 @@ function buildRepairHint(toolName, missing, unexpected, typeErrors) {
   if (typeErrors.length > 0) {
     hints.push(`fix type errors: ${typeErrors.join("; ")}`);
   }
-  if (toolName.toLowerCase() === "edit" && (missing.includes("old_string") || missing.includes("new_string"))) {
+  if (toolName.toLowerCase() === "edit" && (missing.includes("old_string") || missing.includes("oldString") || missing.includes("new_string") || missing.includes("newString"))) {
     hints.push("edit requires path, old_string, and new_string");
   }
   return hints.join(" | ");
@@ -14867,6 +14964,14 @@ async function handleToolLoopEventLegacy(options) {
         }
         return { intercepted: false, skipConverter: true, terminate: validationTermination };
       }
+      const reroutedWrite = tryRerouteEditToWrite(normalizedToolCall, compat, allowedToolNames, toolSchemaMap);
+      if (reroutedWrite) {
+        log18.debug("Rerouting malformed edit call to write (legacy)", {
+          missing: compat.validation.missing
+        });
+        await onInterceptedToolCall(reroutedWrite);
+        return { intercepted: true, skipConverter: true };
+      }
       if (shouldEmitNonFatalSchemaValidationHint(normalizedToolCall, compat.validation)) {
         const hintChunk = createNonFatalSchemaValidationHintChunk(responseMeta, normalizedToolCall, compat.validation);
         log18.debug("Emitting non-fatal schema validation hint in legacy and skipping malformed tool execution", {
@@ -15018,6 +15123,18 @@ async function handleToolLoopEventV1(options) {
         terminate: createSchemaValidationTermination(normalizedToolCall, compat.validation)
       };
     }
+    const reroutedWrite = tryRerouteEditToWrite(normalizedToolCall, compat, allowedToolNames, toolSchemaMap);
+    if (reroutedWrite) {
+      log18.debug("Rerouting malformed edit call to write", {
+        missing: compat.validation.missing,
+        typeErrors: compat.validation.typeErrors
+      });
+      await onInterceptedToolCall(reroutedWrite);
+      return {
+        intercepted: true,
+        skipConverter: true
+      };
+    }
     if (schemaValidationFailureMode === "pass_through" && shouldEmitNonFatalSchemaValidationHint(normalizedToolCall, compat.validation)) {
       const hintChunk = createNonFatalSchemaValidationHintChunk(responseMeta, normalizedToolCall, compat.validation);
       log18.debug("Emitting non-fatal schema validation hint and skipping malformed tool execution", {
@@ -15228,8 +15345,9 @@ function shouldTerminateOnSchemaValidation(toolCall, validation) {
 }
 function createNonFatalSchemaValidationHintChunk(meta, toolCall, validation) {
   const termination = createSchemaValidationTermination(toolCall, validation);
-  const hint = termination.repairHint || "Use write for full-file replacement, or provide path, old_string, and new_string for edit.";
-  const content = `Skipped malformed tool call "${toolCall.function.name}": ${termination.message} ${hint}`.trim();
+  const fallbackHint = "Use write for full-file replacement, or provide path, old_string, and new_string for edit.";
+  const suffix = termination.repairHint ? "" : ` ${fallbackHint}`;
+  const content = `Skipped malformed tool call "${toolCall.function.name}": ${termination.message}${suffix}`.trim();
   return {
     id: meta.id,
     object: "chat.completion.chunk",
@@ -15870,25 +15988,13 @@ __export(exports_plugin, {
   CursorPlugin: () => CursorPlugin
 });
 import { tool as tool2 } from "@opencode-ai/plugin";
-import { appendFileSync as appendFileSync3, existsSync as existsSync5, realpathSync } from "fs";
+import { realpathSync } from "fs";
 import { mkdir } from "fs/promises";
-import { homedir as homedir5 } from "os";
-import { isAbsolute, join as join6, relative, resolve as resolve2 } from "path";
-function ensureDebugLogDir() {
-  try {
-    if (!existsSync5(DEBUG_LOG_DIR2)) {
-      mkdir(DEBUG_LOG_DIR2, { recursive: true }).catch(() => {});
-    }
-  } catch {}
-}
-function debugLogToFile2(message, data) {
-  try {
-    ensureDebugLogDir();
-    const timestamp = new Date().toISOString();
-    const logLine = `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}
-`;
-    appendFileSync3(DEBUG_LOG_FILE2, logLine);
-  } catch {}
+import { homedir as homedir4 } from "os";
+import { isAbsolute, join as join5, relative, resolve as resolve2 } from "path";
+function getMcpToolDefinitionName(mcpToolDefs, index) {
+  const name = mcpToolDefs[index]?.function?.name;
+  return typeof name === "string" && name.length > 0 ? name : undefined;
 }
 function buildAvailableToolsSystemMessage(lastToolNames, lastToolMap, mcpToolDefs, mcpToolSummaries, subagentNames = []) {
   const parts = [];
@@ -15898,27 +16004,27 @@ function buildAvailableToolsSystemMessage(lastToolNames, lastToolMap, mcpToolDef
     parts.push(`Available OpenCode tools (use via tool calls): ${names}. Original skill ids mapped as: ${mapping}. Aliases include oc_skill_* and oc_superskill_* when applicable.`);
   }
   if (mcpToolSummaries && mcpToolSummaries.length > 0) {
+    const summariesWithCallNames = mcpToolSummaries.map((summary, index) => ({
+      ...summary,
+      callName: summary.callName ?? getMcpToolDefinitionName(mcpToolDefs, index) ?? namespaceMcpTool(summary.serverName, summary.toolName)
+    }));
     const servers = new Map;
-    for (const s of mcpToolSummaries) {
+    for (const s of summariesWithCallNames) {
       const list = servers.get(s.serverName) ?? [];
       list.push(s);
       servers.set(s.serverName, list);
     }
     const lines = [
-      "MCP TOOLS — Use via Shell with the `mcptool` CLI.",
-      "Syntax: mcptool call <server> <tool> [json-args]",
+      `MCP TOOLS — Use via direct tool calls (\`${MCP_TOOL_PREFIX}<server>__<tool>\`).`,
+      "These tools are exposed as first-class tool calls (e.g. mcp__filesystem__read_file).",
       ""
     ];
     for (const [server2, tools] of servers) {
       lines.push(`Server: ${server2}`);
       for (const t of tools) {
         const paramHint = t.params?.length ? ` (params: ${t.params.join(", ")})` : "";
-        lines.push(`  - ${t.toolName}${paramHint}${t.description ? " — " + t.description : ""}`);
-      }
-      if (tools.length > 0) {
-        const ex = tools[0];
-        const exArgs = ex.params?.length ? ` '{"${ex.params[0]}":"..."}'` : "";
-        lines.push(`  Example: mcptool call ${server2} ${ex.toolName}${exArgs}`);
+        const sourceHint = t.callName === t.toolName ? "" : ` (server: ${t.serverName}; tool: ${t.toolName})`;
+        lines.push(`  - ${t.callName}${paramHint}${t.description ? " — " + t.description : ""}${sourceHint}`);
       }
       lines.push("");
     }
@@ -15933,8 +16039,8 @@ function buildAvailableToolsSystemMessage(lastToolNames, lastToolMap, mcpToolDef
 `) : null;
 }
 async function ensurePluginDirectory() {
-  const configHome = process.env.XDG_CONFIG_HOME ? resolve2(process.env.XDG_CONFIG_HOME) : join6(homedir5(), ".config");
-  const pluginDir = join6(configHome, "opencode", "plugin");
+  const configHome = process.env.XDG_CONFIG_HOME ? resolve2(process.env.XDG_CONFIG_HOME) : join5(homedir4(), ".config");
+  const pluginDir = join5(configHome, "opencode", "plugin");
   try {
     await mkdir(pluginDir, { recursive: true });
     log20.debug("Plugin directory ensured", { path: pluginDir });
@@ -15951,8 +16057,8 @@ function getGlobalKey() {
   return "__opencode_cursor_proxy_server__";
 }
 function getOpenCodeConfigPrefix() {
-  const configHome = process.env.XDG_CONFIG_HOME ? resolve2(process.env.XDG_CONFIG_HOME) : join6(homedir5(), ".config");
-  return join6(configHome, "opencode");
+  const configHome = process.env.XDG_CONFIG_HOME ? resolve2(process.env.XDG_CONFIG_HOME) : join5(homedir4(), ".config");
+  return join5(configHome, "opencode");
 }
 function canonicalizePathForCompare(pathValue) {
   const resolvedPath = resolve2(pathValue);
@@ -16029,7 +16135,7 @@ function resolveWorkspaceDirectory(worktree, directory) {
   if (isAcceptableWorkspace(cwd, configPrefix)) {
     return cwd;
   }
-  const home = resolveCandidate(homedir5());
+  const home = resolveCandidate(homedir4());
   if (home && !isRootPath(home)) {
     return home;
   }
@@ -16110,6 +16216,7 @@ function extractCompletionFromStream(output) {
   let usage;
   let sawAssistantPartials = false;
   let sawThinkingPartials = false;
+  const tracker = new MixedDeltaTracker;
   for (const line of lines) {
     const event = parseStreamJsonLine(line);
     if (!event) {
@@ -16121,8 +16228,8 @@ function extractCompletionFromStream(output) {
         continue;
       const isPartial = typeof event.timestamp_ms === "number";
       if (isPartial) {
-        assistantText += text;
         sawAssistantPartials = true;
+        assistantText += tracker.nextText(text);
       } else if (!sawAssistantPartials) {
         assistantText = text;
       }
@@ -16132,8 +16239,8 @@ function extractCompletionFromStream(output) {
       if (thinking) {
         const isPartial = typeof event.timestamp_ms === "number";
         if (isPartial) {
-          reasoningText += thinking;
           sawThinkingPartials = true;
+          reasoningText += tracker.nextThinking(thinking);
         } else if (!sawThinkingPartials) {
           reasoningText = thinking;
         }
@@ -16330,7 +16437,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       const messages = Array.isArray(body?.messages) ? body.messages : [];
       const stream = body?.stream === true;
       const tools = Array.isArray(body?.tools) ? body.tools : [];
-      debugLogToFile2("raw_request_body", {
+      log20.debug("raw request body", {
         model: body?.model,
         cursorModel: body?.cursorModel,
         stream,
@@ -16820,7 +16927,7 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
       if (FORCE_TOOL_MODE) {
         cmd.push("--force");
       }
-      const child = spawn3(cmd[0], cmd.slice(1), {
+      const child = spawn3(formatShellCommandForPlatform(cmd[0]), cmd.slice(1), {
         stdio: ["pipe", "pipe", "pipe"],
         shell: process.platform === "win32"
       });
@@ -16967,22 +17074,18 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
             child.kill();
           } catch {}
         };
-        child.stdout.on("data", async (chunk) => {
-          if (streamTerminated || res.writableEnded) {
-            return;
-          }
-          if (!firstTokenReceived) {
-            perf.mark("first-token");
-            firstTokenReceived = true;
-          }
-          for (const line of lineBuffer.push(chunk)) {
-            if (streamTerminated || res.writableEnded) {
+        const chunkQueue = [];
+        let draining = false;
+        let childClosed = false;
+        let childCloseHandled = false;
+        let childExitCode = null;
+        const processLines = async (lines) => {
+          for (const line of lines) {
+            if (streamTerminated || res.writableEnded)
               break;
-            }
             const event = parseStreamJsonLine(line);
-            if (!event) {
+            if (!event)
               continue;
-            }
             if (isResult(event)) {
               usage = extractOpenAiUsageFromResult(event) ?? usage;
             }
@@ -17031,148 +17134,100 @@ async function ensureCursorProxyServer(workspaceDirectory, toolRouter) {
                 }
                 break;
               }
-              if (result.intercepted) {
+              if (result.intercepted)
                 break;
-              }
-              if (result.skipConverter) {
+              if (result.skipConverter)
                 continue;
-              }
             }
-            if (streamTerminated || res.writableEnded) {
+            if (streamTerminated || res.writableEnded)
               break;
-            }
             for (const sse of converter.handleEvent(event)) {
               res.write(sse);
             }
           }
-        });
-        child.on("close", async (code) => {
-          if (streamTerminated || res.writableEnded) {
+        };
+        const drainQueue = async () => {
+          if (draining)
             return;
-          }
-          for (const line of lineBuffer.flush()) {
-            if (streamTerminated || res.writableEnded) {
-              break;
-            }
-            const event = parseStreamJsonLine(line);
-            if (!event) {
-              continue;
-            }
-            if (isResult(event)) {
-              usage = extractOpenAiUsageFromResult(event) ?? usage;
-            }
-            if (event.type === "tool_call") {
-              const result = await handleToolLoopEventWithFallback({
-                event,
-                boundary: boundaryContext.getBoundary(),
-                boundaryMode: boundaryContext.getBoundary().mode,
-                autoFallbackToLegacy: ENABLE_PROVIDER_BOUNDARY_AUTOFALLBACK,
-                toolLoopMode: TOOL_LOOP_MODE,
-                allowedToolNames,
-                toolSchemaMap,
-                toolLoopGuard,
-                toolMapper,
-                toolSessionId,
-                shouldEmitToolUpdates: SHOULD_EMIT_TOOL_UPDATES,
-                proxyExecuteToolCalls: PROXY_EXECUTE_TOOL_CALLS,
-                suppressConverterToolEvents: SUPPRESS_CONVERTER_TOOL_EVENTS,
-                toolRouter,
-                responseMeta: { id, created, model },
-                passThroughTracker,
-                onToolUpdate: (update) => {
-                  res.write(formatToolUpdateEvent(update));
-                },
-                onToolResult: (toolResult) => {
-                  res.write(`data: ${JSON.stringify(toolResult)}
-
-`);
-                },
-                onInterceptedToolCall: (toolCall) => {
-                  emitToolCallAndTerminate(toolCall);
-                },
-                onFallbackToLegacy: (error) => {
-                  boundaryContext.activateLegacyFallback("handleToolLoopEvent.close", error);
-                }
-              });
-              if (result.terminate) {
-                if (!result.terminate.silent) {
-                  emitTerminalAssistantErrorAndTerminate(result.terminate.message);
-                } else {
-                  streamTerminated = true;
-                  try {
-                    child.kill();
-                  } catch {}
-                }
-                break;
-              }
-              if (result.intercepted) {
+          draining = true;
+          try {
+            while (chunkQueue.length > 0) {
+              if (streamTerminated || res.writableEnded)
                 break;
+              const chunk = chunkQueue.shift();
+              if (!firstTokenReceived) {
+                perf.mark("first-token");
+                firstTokenReceived = true;
               }
-              if (result.skipConverter) {
-                continue;
-              }
-            }
-            if (streamTerminated || res.writableEnded) {
-              break;
-            }
-            for (const sse of converter.handleEvent(event)) {
-              res.write(sse);
+              await processLines(lineBuffer.push(chunk));
             }
-          }
-          if (streamTerminated || res.writableEnded) {
-            return;
-          }
-          perf.mark("request:done");
-          perf.summarize();
-          const stderrText = Buffer.concat(stderrChunks).toString().trim();
-          log20.debug("cursor-agent completed (node stream)", {
-            code,
-            stderrChars: stderrText.length
-          });
-          if (code !== 0) {
-            const errSource = stderrText || `cursor-agent exited with code ${String(code ?? "unknown")} and no output`;
-            const parsed = parseAgentError(errSource);
-            const msg = formatErrorForUser(parsed);
-            const errChunk = createChatCompletionChunk(id, created, model, msg, true);
-            res.write(`data: ${JSON.stringify(errChunk)}
+            if (childClosed && !childCloseHandled && !streamTerminated && !res.writableEnded) {
+              childCloseHandled = true;
+              await processLines(lineBuffer.flush());
+              if (streamTerminated || res.writableEnded)
+                return;
+              perf.mark("request:done");
+              perf.summarize();
+              const stderrText = Buffer.concat(stderrChunks).toString().trim();
+              log20.debug("cursor-agent completed (node stream)", {
+                code: childExitCode,
+                stderrChars: stderrText.length
+              });
+              if (childExitCode !== 0) {
+                const errSource = stderrText || `cursor-agent exited with code ${String(childExitCode ?? "unknown")} and no output`;
+                const parsed = parseAgentError(errSource);
+                const msg = formatErrorForUser(parsed);
+                const errChunk = createChatCompletionChunk(id, created, model, msg, true);
+                res.write(`data: ${JSON.stringify(errChunk)}
 
 `);
-            res.write(formatSseDone());
-            streamTerminated = true;
-            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",
-            created,
-            model,
-            choices: [
-              {
-                index: 0,
-                delta: {},
-                finish_reason: "stop"
+                res.write(formatSseDone());
+                streamTerminated = true;
+                res.end();
+                return;
               }
-            ]
-          };
-          res.write(`data: ${JSON.stringify(doneChunk)}
+              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",
+                created,
+                model,
+                choices: [{ index: 0, delta: {}, finish_reason: "stop" }]
+              };
+              res.write(`data: ${JSON.stringify(doneChunk)}
 
 `);
-          if (usage) {
-            const usageChunk = createChatCompletionUsageChunk(id, created, model, usage);
-            res.write(`data: ${JSON.stringify(usageChunk)}
+              if (usage) {
+                const usageChunk = createChatCompletionUsageChunk(id, created, model, usage);
+                res.write(`data: ${JSON.stringify(usageChunk)}
 
 `);
+              }
+              res.write(formatSseDone());
+              streamTerminated = true;
+              res.end();
+            }
+          } finally {
+            draining = false;
+            if (!streamTerminated && !res.writableEnded && (chunkQueue.length > 0 || childClosed && !childCloseHandled)) {
+              drainQueue();
+            }
           }
-          res.write(formatSseDone());
-          res.end();
+        };
+        child.stdout.on("data", (chunk) => {
+          chunkQueue.push(Buffer.from(chunk));
+          drainQueue();
+        });
+        child.on("close", (code) => {
+          childClosed = true;
+          childExitCode = code;
+          drainQueue();
         });
       }
     } catch (error) {
@@ -17373,7 +17428,7 @@ function buildToolHookEntries(registry, fallbackBaseDir) {
   }
   return entries;
 }
-var log20, 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, NATIVE_TOOL_HOOK_EXCLUSIONS, CursorPlugin = async ({ $, directory, worktree, client: client3, serverUrl }) => {
+var log20, 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, NATIVE_TOOL_HOOK_EXCLUSIONS, CursorPlugin = async ({ $, directory, worktree, client: client3, serverUrl }) => {
   const workspaceDirectory = resolveWorkspaceDirectory(worktree, directory);
   log20.debug("Plugin initializing", {
     directory,
@@ -17429,6 +17484,7 @@ var log20, DEBUG_LOG_DIR2, DEBUG_LOG_FILE2, CURSOR_PROVIDER_ID2 = "cursor-acp",
           mcpToolSummaries = tools.map((t) => ({
             serverName: t.serverName,
             toolName: t.name,
+            callName: namespaceMcpTool(t.serverName, t.name),
             description: t.description,
             params: t.inputSchema ? Object.keys(t.inputSchema.properties ?? {}) : undefined
           }));
@@ -17646,8 +17702,6 @@ var init_plugin = __esm(() => {
   init_tool_loop_guard();
   init_binary();
   log20 = createLogger("plugin");
-  DEBUG_LOG_DIR2 = join6(homedir5(), ".config", "opencode", "logs");
-  DEBUG_LOG_FILE2 = join6(DEBUG_LOG_DIR2, "tool-loop-debug.log");
   CURSOR_PROVIDER_PREFIX = `${CURSOR_PROVIDER_ID2}/`;
   CURSOR_PROXY_DEFAULT_BASE_URL = `http://${CURSOR_PROXY_HOST}:${CURSOR_PROXY_DEFAULT_PORT}/v1`;
   REUSE_EXISTING_PROXY = process.env.CURSOR_ACP_REUSE_EXISTING_PROXY !== "false";
@@ -17727,7 +17781,7 @@ class SimpleCursorClient {
       args.push("--resume", resumeId);
     }
     this.log.debug("Executing prompt stream", { promptLength: prompt.length, mode, model });
-    const child = spawn3(this.config.cursorAgentPath, args, {
+    const child = spawn3(formatShellCommandForPlatform(this.config.cursorAgentPath), args, {
       cwd,
       stdio: ["pipe", "pipe", "pipe"],
       shell: process.platform === "win32"
@@ -17814,7 +17868,7 @@ class SimpleCursorClient {
     }
     this.log.debug("Executing prompt", { promptLength: prompt.length, mode, model });
     return new Promise((resolve3, reject) => {
-      const child = spawn3(this.config.cursorAgentPath, args, {
+      const child = spawn3(formatShellCommandForPlatform(this.config.cursorAgentPath), args, {
         cwd,
         stdio: ["pipe", "pipe", "pipe"],
         shell: process.platform === "win32"
@@ -18063,42 +18117,22 @@ function createProxyServer(config) {
 
 // src/streaming/ai-sdk-parts.ts
 class StreamToAiSdkParts {
-  tracker = new DeltaTracker;
   toolArgsById = new Map;
   startedToolIds = new Set;
-  sawAssistantPartials = false;
-  sawThinkingPartials = false;
+  tracker = new MixedDeltaTracker;
   handleEvent(event) {
     if (isAssistantText(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractText(event);
-        if (text) {
-          this.sawAssistantPartials = true;
-          return [{ type: "text-delta", textDelta: text }];
-        }
-        return [];
-      }
-      if (this.sawAssistantPartials) {
+      const text = extractText(event);
+      if (!text)
         return [];
-      }
-      const delta = this.tracker.nextText(extractText(event));
+      const delta = this.tracker.nextText(text);
       return delta ? [{ type: "text-delta", textDelta: delta }] : [];
     }
     if (isThinking(event)) {
-      const isPartial = typeof event.timestamp_ms === "number";
-      if (isPartial) {
-        const text = extractThinking(event);
-        if (text) {
-          this.sawThinkingPartials = true;
-          return [{ type: "text-delta", textDelta: text }];
-        }
-        return [];
-      }
-      if (this.sawThinkingPartials) {
+      const text = extractThinking(event);
+      if (!text)
         return [];
-      }
-      const delta = this.tracker.nextThinking(extractThinking(event));
+      const delta = this.tracker.nextThinking(text);
       return delta ? [{ type: "text-delta", textDelta: delta }] : [];
     }
     if (isToolCall(event)) {
@@ -18400,11 +18434,11 @@ init_auth();
 // src/commands/status.ts
 init_auth();
 init_logger();
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 var log22 = createLogger("status");
 function checkAuthStatus() {
   const authFilePath = getAuthFilePath();
-  const exists = existsSync6(authFilePath);
+  const exists = existsSync4(authFilePath);
   log22.debug("Checking auth status", { path: authFilePath });
   if (exists) {
     return {