@rama_nigg/open-cursor 2.4.4 → 2.4.6

package/src/provider/tool-schema-compat.ts

@@ -49,6 +49,7 @@ export interface ToolSchemaValidationResult {
 export interface ToolSchemaCompatResult {
   toolCall: OpenAiToolCall;
   normalizedArgs: JsonRecord;
+  originalArgs: JsonRecord;
   originalArgKeys: string[];
   normalizedArgKeys: string[];
   collisionKeys: string[];
@@ -89,6 +90,10 @@ export function applyToolSchemaCompat(
     sanitization.args,
     schema,
     sanitization.unexpected,
+    {
+      originalArgs: parsedArgs,
+      writeSchema: toolSchemaMap.get("write"),
+    },
   );
 
   const normalizedToolCall: OpenAiToolCall = {
@@ -102,6 +107,7 @@ export function applyToolSchemaCompat(
   return {
     toolCall: normalizedToolCall,
     normalizedArgs: sanitization.args,
+    originalArgs: parsedArgs,
     originalArgKeys,
     normalizedArgKeys: Object.keys(sanitization.args),
     collisionKeys,
@@ -109,6 +115,96 @@ export function applyToolSchemaCompat(
   };
 }
 
+export function isFullFileShapedEditValidationFailure(
+  toolName: string,
+  args: JsonRecord,
+  validation: ToolSchemaValidationResult,
+  originalArgs: JsonRecord,
+  writeSchema?: unknown,
+): boolean {
+  if (toolName.toLowerCase() !== "edit" || validation.ok) {
+    return false;
+  }
+  return buildEditFullFileHint(args, validation.missing, validation.typeErrors, {
+    originalArgs,
+    writeSchema,
+  }) !== null;
+}
+
+function buildWriteArguments(
+  filePath: string,
+  content: string,
+  writeSchema: unknown,
+): JsonRecord {
+  if (!isRecord(writeSchema)) {
+    return { path: filePath, content };
+  }
+  const required = Array.isArray(writeSchema.required)
+    ? writeSchema.required.filter((value): value is string => typeof value === "string")
+    : [];
+  if (required.includes("filePath")) {
+    return { filePath, content };
+  }
+  return { path: filePath, content };
+}
+
+/** Malformed full-file edit (path + body, no old_string) → write tool call when write is available. */
+export function tryRerouteEditToWrite(
+  toolCall: OpenAiToolCall,
+  compat: ToolSchemaCompatResult,
+  allowedToolNames: Set<string>,
+  toolSchemaMap: Map<string, unknown>,
+): OpenAiToolCall | null {
+  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: string): JsonRecord {
   try {
     const parsed = JSON.parse(rawArguments);
@@ -350,11 +446,17 @@ function sanitizeArgumentsForSchema(
   return { args: sanitized, unexpected };
 }
 
+type ValidateToolArgumentsContext = {
+  originalArgs?: JsonRecord;
+  writeSchema?: unknown;
+};
+
 function validateToolArguments(
   toolName: string,
   args: JsonRecord,
   schema: unknown,
   unexpected: string[],
+  context: ValidateToolArgumentsContext = {},
 ): ToolSchemaValidationResult {
   if (!isRecord(schema)) {
     return {
@@ -399,16 +501,90 @@ function validateToolArguments(
     missing,
     unexpected,
     typeErrors,
-    repairHint: ok ? undefined : buildRepairHint(toolName, missing, unexpected, typeErrors),
+    repairHint: ok
+      ? undefined
+      : buildRepairHint(toolName, args, missing, unexpected, typeErrors, context),
   };
 }
 
+function hadOldStringPropertyInPayload(args: JsonRecord): boolean {
+  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: JsonRecord): boolean {
+  const pathValue = args.path ?? args.filePath;
+  return typeof pathValue === "string" && pathValue.trim().length > 0;
+}
+
+function hasEditBody(args: JsonRecord): boolean {
+  const body = args.new_string ?? args.newString ?? args.content;
+  return typeof body === "string" && body.length > 0;
+}
+
+function writeToolExample(writeSchema: unknown): string {
+  if (!isRecord(writeSchema)) {
+    return "write with path and content";
+  }
+  const required = Array.isArray(writeSchema.required)
+    ? writeSchema.required.filter((value): value is string => typeof value === "string")
+    : [];
+  if (required.includes("filePath")) {
+    return "write with filePath and content";
+  }
+  return "write with path and content";
+}
+
+function buildEditFullFileHint(
+  args: JsonRecord,
+  missing: string[],
+  typeErrors: string[],
+  context: ValidateToolArgumentsContext,
+): string | null {
+  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: string,
+  args: JsonRecord,
   missing: string[],
   unexpected: string[],
   typeErrors: string[],
+  context: ValidateToolArgumentsContext = {},
 ): string {
+  const fullFileHint = toolName.toLowerCase() === "edit"
+    ? buildEditFullFileHint(args, missing, typeErrors, context)
+    : null;
+  if (fullFileHint) {
+    return fullFileHint;
+  }
+
   const hints: string[] = [];
   if (missing.length > 0) {
     hints.push(`missing required: ${missing.join(", ")}`);
@@ -419,12 +595,14 @@ function buildRepairHint(
   if (typeErrors.length > 0) {
     hints.push(`fix type errors: ${typeErrors.join("; ")}`);
   }
+
   if (
     toolName.toLowerCase() === "edit"
-    && (missing.includes("old_string") || missing.includes("new_string"))
+    && (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(" | ");
 }
 

package/src/proxy/prompt-builder.ts

@@ -1,43 +1,13 @@
-import { appendFileSync, existsSync, mkdirSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
 import { createLogger } from "../utils/logger.js";
 
 const log = createLogger("proxy:prompt-builder");
 
-// Debug log file for tool-loop investigation
-const DEBUG_LOG_DIR = join(homedir(), ".config", "opencode", "logs");
-const DEBUG_LOG_FILE = join(DEBUG_LOG_DIR, "tool-loop-debug.log");
-
-function ensureLogDir(): void {
-  try {
-    if (!existsSync(DEBUG_LOG_DIR)) {
-      mkdirSync(DEBUG_LOG_DIR, { recursive: true });
-    }
-  } catch {
-    // Ignore errors creating log directory
-  }
-}
-
-function debugLogToFile(message: string, data: any): void {
-  try {
-    ensureLogDir();
-    const timestamp = new Date().toISOString();
-    const logLine = `[${timestamp}] ${message}: ${JSON.stringify(data, null, 2)}\n`;
-    appendFileSync(DEBUG_LOG_FILE, logLine);
-  } catch (err) {
-    // Fall back to regular debug log if file writing fails
-    log.debug(message, data);
-  }
-}
-
 /**
  * Build a text prompt from OpenAI chat messages + tool definitions.
  * Handles role:"tool" result messages and assistant tool_calls that
  * plain text flattening would silently drop.
  */
 export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>, subagentNames: string[] = []): string {
-  // DEBUG: Log incoming message structure to file for root cause analysis
   const messageSummary = messages.map((m: any, i: number) => {
     const role = m?.role ?? "?";
     const hasToolCalls = Array.isArray(m?.tool_calls) ? m.tool_calls.length : 0;
@@ -52,7 +22,7 @@ export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>,
   const assistantEmpty = messages.filter((m: any) => m?.role === "assistant" && (!m?.tool_calls || m.tool_calls.length === 0) && (!m?.content || m.content === "" || m.content === null));
   const toolResults = messages.filter((m: any) => m?.role === "tool");
 
-  debugLogToFile("buildPromptFromMessages", {
+  log.debug("buildPromptFromMessages", {
     totalMessages: messages.length,
     totalTools: tools.length,
     messageSummary,
@@ -165,16 +135,15 @@ export function buildPromptFromMessages(messages: Array<any>, tools: Array<any>,
     );
   }
 
-  // DEBUG: Log the final prompt structure
   const finalPrompt = lines.join("\n\n");
-  debugLogToFile("buildPromptFromMessages: final prompt", {
+  log.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;
-}
+}

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

@@ -8,7 +8,7 @@ import {
   type StreamJsonEvent,
   type StreamJsonToolCallEvent,
 } from "./types.js";
-import { DeltaTracker } from "./delta-tracker.js";
+import { MixedDeltaTracker } from "./delta-tracker.js";
 
 export type AiSdkStreamPart =
   | {
@@ -34,44 +34,22 @@ export type AiSdkStreamPart =
     };
 
 export class StreamToAiSdkParts {
-  private readonly tracker = new DeltaTracker();
   private readonly toolArgsById = new Map<string, string>();
   private readonly startedToolIds = new Set<string>();
-  private sawAssistantPartials = false;
-  private sawThinkingPartials = false;
+  private readonly tracker = new MixedDeltaTracker();
 
   handleEvent(event: StreamJsonEvent): AiSdkStreamPart[] {
     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) {
-        return [];
-      }
-      const delta = this.tracker.nextText(extractText(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 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) {
-        return [];
-      }
-      const delta = this.tracker.nextThinking(extractThinking(event));
+      const text = extractThinking(event);
+      if (!text) return [];
+      const delta = this.tracker.nextThinking(text);
       return delta ? [{ type: "text-delta", textDelta: delta }] : [];
     }
 

package/src/streaming/delta-tracker.ts

@@ -45,3 +45,45 @@ export class DeltaTracker {
     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/openai-sse.ts

@@ -8,7 +8,7 @@ import {
   type StreamJsonEvent,
   type StreamJsonToolCallEvent,
 } from "./types.js";
-import { DeltaTracker } from "./delta-tracker.js";
+import { MixedDeltaTracker } from "./delta-tracker.js";
 
 type OpenAiToolCall = {
   index: number;
@@ -60,12 +60,7 @@ export class StreamToSseConverter {
   private readonly id: string;
   private readonly created: number;
   private readonly model: string;
-  private readonly tracker = new DeltaTracker();
-  // Events with timestamp_ms carry delta text; events without carry accumulated text.
-  // DeltaTracker handles accumulated text only. When partials (delta) were seen,
-  // the final accumulated event must be skipped to prevent 2x duplication.
-  private sawAssistantPartials = false;
-  private sawThinkingPartials = false;
+  private readonly tracker = new MixedDeltaTracker();
 
   constructor(model: string, options?: { id?: string; created?: number }) {
     this.model = model;
@@ -75,36 +70,16 @@ export class StreamToSseConverter {
 
   handleEvent(event: StreamJsonEvent): string[] {
     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) {
-        return [];
-      }
-      const delta = this.tracker.nextText(extractText(event));
+      const text = extractText(event);
+      if (!text) return [];
+      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) {
-        return [];
-      }
-      const delta = this.tracker.nextThinking(extractThinking(event));
+      const text = extractThinking(event);
+      if (!text) return [];
+      const delta = this.tracker.nextThinking(text);
       return delta ? [this.chunkWith({ reasoning_content: delta })] : [];
     }
 

package/src/tools/defaults.ts

@@ -533,10 +533,6 @@ function resolveEditArguments(args: Record<string, unknown>): {
     }
   }
 
-  if (oldString === undefined && newString !== undefined) {
-    oldString = "";
-  }
-
   return {
     path,
     old_string: oldString,

package/src/utils/binary.ts

@@ -3,9 +3,10 @@
 // Resolves the cursor-agent executable path. On Windows the binary is a `.cmd`
 // shim, which Node's spawn cannot execute directly without `shell: true` —
 // callers therefore pair this resolver with `shell: process.platform === "win32"`
-// at every spawn site. That re-enables shell metacharacter interpretation, so
-// any user-controlled string passed as an argument on Windows must be treated
-// as untrusted; never concatenate user input into argv on win32.
+// and `formatShellCommandForPlatform()` at every Node spawn site. That re-enables
+// shell metacharacter interpretation, so any user-controlled string passed as an
+// argument on Windows must be treated as untrusted; never concatenate user input
+// into argv on win32.
 import { existsSync as fsExistsSync } from "fs";
 import * as pathModule from "path";
 import { homedir as osHomedir } from "os";
@@ -55,3 +56,16 @@ export function resolveCursorAgentBinary(deps: BinaryDeps = {}): string {
   log.warn("cursor-agent not found at known paths, falling back to PATH", { checkedPaths: knownPaths });
   return "cursor-agent";
 }
+
+export function formatShellCommandForPlatform(
+  command: string,
+  platform: NodeJS.Platform = process.platform,
+): string {
+  if (platform !== "win32") {
+    return command;
+  }
+  if (command.startsWith("\"") && command.endsWith("\"")) {
+    return command;
+  }
+  return `"${command}"`;
+}