@rama_nigg/open-cursor 2.4.5 → 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/tools/defaults.ts

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