@probelabs/probe 0.6.0-rc253 → 0.6.0-rc254

package/build/agent/ProbeAgent.js

@@ -4005,6 +4005,33 @@ Follow these instructions carefully:
             break;
           }
 
+          // Issue #443: Check if response contains valid schema-matching JSON
+          // Before triggering error.no_tool_call, strip markdown fences and validate
+          // This handles cases where AI returns valid JSON without using attempt_completion
+          if (options.schema) {
+            // Remove thinking tags first
+            let contentToCheck = assistantResponseContent;
+            contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
+            contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*$/gi, '').trim();
+
+            // Try to extract and validate JSON
+            const cleanedJson = cleanSchemaResponse(contentToCheck);
+            try {
+              JSON.parse(cleanedJson);
+              const validation = validateJsonResponse(cleanedJson, { debug: this.debug, schema: options.schema });
+              if (validation.isValid) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Issue #443: Accepting valid JSON response without attempt_completion (${cleanedJson.length} chars)`);
+                }
+                finalResult = cleanedJson;
+                completionAttempted = true;
+                break;
+              }
+            } catch {
+              // Not valid JSON - continue to standard no_tool_call handling
+            }
+          }
+
           // Increment consecutive no-tool counter (catches alternating stuck responses)
           consecutiveNoToolCount++;
 

package/build/agent/dsl/environment.js

@@ -183,6 +183,16 @@ export function generateSandboxGlobals(options) {
         });
       }
 
+      // Issue #444: Auto-coerce object paths to strings for search()
+      // AI-generated DSL sometimes passes field objects instead of field.file_path strings
+      if (params.path && typeof params.path === 'object') {
+        const coercedPath = params.path.file_path || params.path.path || params.path.directory || params.path.filename;
+        if (coercedPath && typeof coercedPath === 'string') {
+          logFn?.(`[${name}] Warning: Coerced object path to string "${coercedPath}" (issue #444)`);
+          params.path = coercedPath;
+        }
+      }
+
       const validated = schema.safeParse(params);
       if (!validated.success) {
         throw new Error(`Invalid parameters for ${name}: ${validated.error.message}`);
@@ -232,6 +242,15 @@ export function generateSandboxGlobals(options) {
   // When schema is provided, auto-parse the JSON result for easier downstream processing
   if (llmCall) {
     const rawLLM = async (instruction, data, opts = {}) => {
+      // Issue #444: Guard against error strings being passed as data
+      // When previous tool calls fail, they return "ERROR: ..." strings
+      // Passing these to LLM() spawns useless delegates that can't help
+      const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
+      if (dataStr && dataStr.startsWith('ERROR:')) {
+        logFn?.('[LLM] Blocked: data contains error from previous tool call');
+        return 'ERROR: Previous tool call failed - ' + dataStr.substring(0, 200);
+      }
+
       const result = await llmCall(instruction, data, opts);
       // Auto-parse JSON when schema is provided and result is a string
       if (opts.schema && typeof result === 'string') {

package/build/agent/index.js

@@ -21944,6 +21944,13 @@ function generateSandboxGlobals(options) {
           if (i < keys2.length) params[keys2[i]] = arg;
         });
       }
+      if (params.path && typeof params.path === "object") {
+        const coercedPath = params.path.file_path || params.path.path || params.path.directory || params.path.filename;
+        if (coercedPath && typeof coercedPath === "string") {
+          logFn?.(`[${name}] Warning: Coerced object path to string "${coercedPath}" (issue #444)`);
+          params.path = coercedPath;
+        }
+      }
       const validated = schema.safeParse(params);
       if (!validated.success) {
         throw new Error(`Invalid parameters for ${name}: ${validated.error.message}`);
@@ -21980,6 +21987,11 @@ function generateSandboxGlobals(options) {
   }
   if (llmCall) {
     const rawLLM = async (instruction, data2, opts = {}) => {
+      const dataStr = typeof data2 === "string" ? data2 : JSON.stringify(data2);
+      if (dataStr && dataStr.startsWith("ERROR:")) {
+        logFn?.("[LLM] Blocked: data contains error from previous tool call");
+        return "ERROR: Previous tool call failed - " + dataStr.substring(0, 200);
+      }
       const result = await llmCall(instruction, data2, opts);
       if (opts.schema && typeof result === "string") {
         try {
@@ -29334,6 +29346,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH \u2014 pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) \u2014 the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -29342,7 +29355,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools \u2014 write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) \u2014 use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() \u2014 handle or skip it.`;
               const fixedCode = await llmCallFn(fixPrompt, "", { maxTokens: 4e3, temperature: 0.2 });
               currentCode = stripCodeWrapping(fixedCode);
               planSpan?.addEvent?.("dsl.self_heal_complete", {
@@ -68566,6 +68580,7 @@ __export(schemaUtils_exports, {
   processSchemaResponse: () => processSchemaResponse,
   replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
   replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  sanitizeMarkdownEscapesInJson: () => sanitizeMarkdownEscapesInJson,
   tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
   tryMaidAutoFix: () => tryMaidAutoFix,
   validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
@@ -68669,6 +68684,17 @@ function decodeHtmlEntities2(text) {
   }
   return decoded;
 }
+function sanitizeMarkdownEscapesInJson(jsonString) {
+  if (!jsonString || typeof jsonString !== "string") {
+    return jsonString;
+  }
+  return jsonString.replace(/\\\\|\\([^"\\\/bfnrtu])/g, (match2, captured) => {
+    if (match2 === "\\\\") {
+      return "\\\\";
+    }
+    return captured;
+  });
+}
 function normalizeJsonQuotes(str) {
   if (!str || typeof str !== "string") {
     return str;
@@ -68721,6 +68747,15 @@ function cleanSchemaResponse(response) {
   if (resultWrapperMatch) {
     return cleanSchemaResponse(resultWrapperMatch[1]);
   }
+  const toolCodeMatch = trimmed.match(/<tool_code>\s*([\s\S]*?)\s*<\/tool_code>/);
+  if (toolCodeMatch) {
+    let innerContent = toolCodeMatch[1].trim();
+    const funcCallMatch = innerContent.match(/(?:print|attempt_completion)\s*\(\s*([{\[][\s\S]*[}\]])\s*\)/);
+    if (funcCallMatch) {
+      return cleanSchemaResponse(funcCallMatch[1]);
+    }
+    return cleanSchemaResponse(innerContent);
+  }
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
   if (jsonBlockMatch) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
@@ -68788,9 +68823,25 @@ function validateJsonResponse(response, options = {}) {
       console.log(`[DEBUG] JSON validation: Schema validation enabled`);
     }
   }
+  let responseToValidate = response;
+  try {
+    JSON.parse(response);
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      const sanitized = sanitizeMarkdownEscapesInJson(response);
+      try {
+        JSON.parse(sanitized);
+        responseToValidate = sanitized;
+        if (debug) {
+          console.log(`[DEBUG] JSON validation: Fixed Markdown escapes in JSON (issue #441)`);
+        }
+      } catch {
+      }
+    }
+  }
   try {
     const parseStart = Date.now();
-    const parsed = JSON.parse(response);
+    const parsed = JSON.parse(responseToValidate);
     const parseTime = Date.now() - parseStart;
     if (debug) {
       console.log(`[DEBUG] JSON validation: Successfully parsed in ${parseTime}ms`);
@@ -69132,7 +69183,21 @@ function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
       console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
     }
     return null;
-  } catch {
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      try {
+        const sanitized = sanitizeMarkdownEscapesInJson(response);
+        JSON.parse(sanitized);
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Fixed Markdown escapes in JSON (issue #441), returning sanitized JSON`);
+        }
+        return sanitized;
+      } catch {
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Markdown escape sanitization didn't fix JSON, proceeding with wrapping`);
+        }
+      }
+    }
   }
   const wrapped = JSON.stringify({ [wrapperInfo.fieldName]: response });
   if (debug) {
@@ -84466,6 +84531,25 @@ ${errorXml}
                 }
                 break;
               }
+              if (options.schema) {
+                let contentToCheck = assistantResponseContent;
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                const cleanedJson = cleanSchemaResponse(contentToCheck);
+                try {
+                  JSON.parse(cleanedJson);
+                  const validation = validateJsonResponse(cleanedJson, { debug: this.debug, schema: options.schema });
+                  if (validation.isValid) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Issue #443: Accepting valid JSON response without attempt_completion (${cleanedJson.length} chars)`);
+                    }
+                    finalResult = cleanedJson;
+                    completionAttempted = true;
+                    break;
+                  }
+                } catch {
+                }
+              }
               consecutiveNoToolCount++;
               const isIdentical = lastNoToolResponse !== null && assistantResponseContent === lastNoToolResponse;
               const isSemanticallyStuck = lastNoToolResponse !== null && areBothStuckResponses(lastNoToolResponse, assistantResponseContent);

package/build/agent/schemaUtils.js

@@ -165,6 +165,39 @@ export function decodeHtmlEntities(text) {
   return decoded;
 }
 
+/**
+ * Sanitize Markdown escape sequences in JSON strings
+ *
+ * Markdown uses backslash escapes like \*, \_, \#, \~ etc. which are NOT valid
+ * JSON escape sequences. When AI models produce JSON with Markdown content,
+ * these escapes cause JSON.parse() to fail with "Invalid \escape" errors.
+ *
+ * This function removes the backslash from invalid escape sequences while
+ * preserving valid JSON escapes: \\, \", \/, \b, \f, \n, \r, \t, \uXXXX
+ *
+ * @param {string} jsonString - JSON string that may contain Markdown escapes
+ * @returns {string} - JSON string with invalid escapes sanitized
+ */
+export function sanitizeMarkdownEscapesInJson(jsonString) {
+  if (!jsonString || typeof jsonString !== 'string') {
+    return jsonString;
+  }
+
+  // Strategy: Match either:
+  // 1. \\\\ (escaped backslash) - preserve as-is
+  // 2. \\X where X is NOT a valid JSON escape char - remove the backslash
+  //
+  // Valid JSON escape chars: " \ / b f n r t u
+  // This converts: \* → *, \_ → _, \# → #, \~ → ~, etc.
+  // But preserves: \\, \", \n, \t, \r, \b, \f, \/, \uXXXX
+  return jsonString.replace(/\\\\|\\([^"\\\/bfnrtu])/g, (match, captured) => {
+    if (match === '\\\\') {
+      return '\\\\'; // Preserve escaped backslash
+    }
+    return captured; // Remove backslash from invalid escape
+  });
+}
+
 /**
  * Normalize JavaScript syntax to valid JSON syntax
  * Converts single quotes to double quotes for strings in JSON-like structures
@@ -261,6 +294,22 @@ export function cleanSchemaResponse(response) {
     return cleanSchemaResponse(resultWrapperMatch[1]);
   }
 
+  // Strip <tool_code>...</tool_code> wrapper (Gemini-style code execution format)
+  // Issue #443: Gemini sometimes wraps responses in <plan> + <tool_code> tags
+  // e.g., <tool_code>print(attempt_completion({"projects": ["repo1"]}))</tool_code>
+  const toolCodeMatch = trimmed.match(/<tool_code>\s*([\s\S]*?)\s*<\/tool_code>/);
+  if (toolCodeMatch) {
+    let innerContent = toolCodeMatch[1].trim();
+    // Extract JSON from print() or attempt_completion() wrappers
+    // e.g., print({"key": "value"}) or attempt_completion({"key": "value"})
+    const funcCallMatch = innerContent.match(/(?:print|attempt_completion)\s*\(\s*([{\[][\s\S]*[}\]])\s*\)/);
+    if (funcCallMatch) {
+      return cleanSchemaResponse(funcCallMatch[1]);
+    }
+    // Try cleaning the inner content directly
+    return cleanSchemaResponse(innerContent);
+  }
+
   // First, look for JSON after code block markers - similar to mermaid extraction
   // Try with json language specifier
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
@@ -370,9 +419,30 @@ export function validateJsonResponse(response, options = {}) {
     }
   }
 
+  // Try to parse the response, with fallback to sanitizing Markdown escapes (issue #441)
+  let responseToValidate = response;
+  try {
+    JSON.parse(response);
+  } catch (initialError) {
+    // Check if the error is due to invalid escape sequences (Markdown escapes like \*, \_)
+    if (initialError.message && initialError.message.includes('escape')) {
+      const sanitized = sanitizeMarkdownEscapesInJson(response);
+      try {
+        JSON.parse(sanitized);
+        // Sanitized version parses - use it instead
+        responseToValidate = sanitized;
+        if (debug) {
+          console.log(`[DEBUG] JSON validation: Fixed Markdown escapes in JSON (issue #441)`);
+        }
+      } catch {
+        // Sanitization didn't help, continue with original (will fail below with proper error)
+      }
+    }
+  }
+
   try {
     const parseStart = Date.now();
-    const parsed = JSON.parse(response);
+    const parsed = JSON.parse(responseToValidate);
     const parseTime = Date.now() - parseStart;
 
     if (debug) {
@@ -853,7 +923,26 @@ export function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
       console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
     }
     return null;
-  } catch {
+  } catch (initialError) {
+    // Not valid JSON - check if it's due to Markdown escapes (issue #441)
+    // AI models sometimes produce JSON with Markdown escapes like \* or \_
+    // which are valid Markdown but NOT valid JSON escape sequences
+    if (initialError.message && initialError.message.includes('escape')) {
+      try {
+        const sanitized = sanitizeMarkdownEscapesInJson(response);
+        JSON.parse(sanitized);
+        // Sanitized JSON is valid! Return it instead of wrapping
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Fixed Markdown escapes in JSON (issue #441), returning sanitized JSON`);
+        }
+        return sanitized;
+      } catch {
+        // Sanitization didn't help, proceed with wrapping
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Markdown escape sanitization didn't fix JSON, proceeding with wrapping`);
+        }
+      }
+    }
     // Not valid JSON, proceed with wrapping
   }
 

package/build/tools/executePlan.js

@@ -436,6 +436,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH — pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) — the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -444,7 +445,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools — write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) — use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() — handle or skip it.`;
 
               const fixedCode = await llmCallFn(fixPrompt, '', { maxTokens: 4000, temperature: 0.2 });
               // Strip markdown fences and XML tags the LLM might add

package/cjs/agent/ProbeAgent.cjs

@@ -51415,6 +51415,13 @@ function generateSandboxGlobals(options) {
           if (i5 < keys2.length) params[keys2[i5]] = arg;
         });
       }
+      if (params.path && typeof params.path === "object") {
+        const coercedPath = params.path.file_path || params.path.path || params.path.directory || params.path.filename;
+        if (coercedPath && typeof coercedPath === "string") {
+          logFn?.(`[${name14}] Warning: Coerced object path to string "${coercedPath}" (issue #444)`);
+          params.path = coercedPath;
+        }
+      }
       const validated = schema.safeParse(params);
       if (!validated.success) {
         throw new Error(`Invalid parameters for ${name14}: ${validated.error.message}`);
@@ -51451,6 +51458,11 @@ function generateSandboxGlobals(options) {
   }
   if (llmCall) {
     const rawLLM = async (instruction, data3, opts = {}) => {
+      const dataStr = typeof data3 === "string" ? data3 : JSON.stringify(data3);
+      if (dataStr && dataStr.startsWith("ERROR:")) {
+        logFn?.("[LLM] Blocked: data contains error from previous tool call");
+        return "ERROR: Previous tool call failed - " + dataStr.substring(0, 200);
+      }
       const result = await llmCall(instruction, data3, opts);
       if (opts.schema && typeof result === "string") {
         try {
@@ -58804,6 +58816,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH \u2014 pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) \u2014 the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -58812,7 +58825,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools \u2014 write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) \u2014 use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() \u2014 handle or skip it.`;
               const fixedCode = await llmCallFn(fixPrompt, "", { maxTokens: 4e3, temperature: 0.2 });
               currentCode = stripCodeWrapping(fixedCode);
               planSpan?.addEvent?.("dsl.self_heal_complete", {
@@ -97603,6 +97617,7 @@ __export(schemaUtils_exports, {
   processSchemaResponse: () => processSchemaResponse,
   replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
   replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  sanitizeMarkdownEscapesInJson: () => sanitizeMarkdownEscapesInJson,
   tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
   tryMaidAutoFix: () => tryMaidAutoFix,
   validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
@@ -97706,6 +97721,17 @@ function decodeHtmlEntities2(text) {
   }
   return decoded;
 }
+function sanitizeMarkdownEscapesInJson(jsonString) {
+  if (!jsonString || typeof jsonString !== "string") {
+    return jsonString;
+  }
+  return jsonString.replace(/\\\\|\\([^"\\\/bfnrtu])/g, (match2, captured) => {
+    if (match2 === "\\\\") {
+      return "\\\\";
+    }
+    return captured;
+  });
+}
 function normalizeJsonQuotes(str) {
   if (!str || typeof str !== "string") {
     return str;
@@ -97758,6 +97784,15 @@ function cleanSchemaResponse(response) {
   if (resultWrapperMatch) {
     return cleanSchemaResponse(resultWrapperMatch[1]);
   }
+  const toolCodeMatch = trimmed.match(/<tool_code>\s*([\s\S]*?)\s*<\/tool_code>/);
+  if (toolCodeMatch) {
+    let innerContent = toolCodeMatch[1].trim();
+    const funcCallMatch = innerContent.match(/(?:print|attempt_completion)\s*\(\s*([{\[][\s\S]*[}\]])\s*\)/);
+    if (funcCallMatch) {
+      return cleanSchemaResponse(funcCallMatch[1]);
+    }
+    return cleanSchemaResponse(innerContent);
+  }
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
   if (jsonBlockMatch) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
@@ -97825,9 +97860,25 @@ function validateJsonResponse(response, options = {}) {
       console.log(`[DEBUG] JSON validation: Schema validation enabled`);
     }
   }
+  let responseToValidate = response;
+  try {
+    JSON.parse(response);
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      const sanitized = sanitizeMarkdownEscapesInJson(response);
+      try {
+        JSON.parse(sanitized);
+        responseToValidate = sanitized;
+        if (debug) {
+          console.log(`[DEBUG] JSON validation: Fixed Markdown escapes in JSON (issue #441)`);
+        }
+      } catch {
+      }
+    }
+  }
   try {
     const parseStart = Date.now();
-    const parsed = JSON.parse(response);
+    const parsed = JSON.parse(responseToValidate);
     const parseTime = Date.now() - parseStart;
     if (debug) {
       console.log(`[DEBUG] JSON validation: Successfully parsed in ${parseTime}ms`);
@@ -98169,7 +98220,21 @@ function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
       console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
     }
     return null;
-  } catch {
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      try {
+        const sanitized = sanitizeMarkdownEscapesInJson(response);
+        JSON.parse(sanitized);
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Fixed Markdown escapes in JSON (issue #441), returning sanitized JSON`);
+        }
+        return sanitized;
+      } catch {
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Markdown escape sanitization didn't fix JSON, proceeding with wrapping`);
+        }
+      }
+    }
   }
   const wrapped = JSON.stringify({ [wrapperInfo.fieldName]: response });
   if (debug) {
@@ -113502,6 +113567,25 @@ ${errorXml}
                 }
                 break;
               }
+              if (options.schema) {
+                let contentToCheck = assistantResponseContent;
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                const cleanedJson = cleanSchemaResponse(contentToCheck);
+                try {
+                  JSON.parse(cleanedJson);
+                  const validation = validateJsonResponse(cleanedJson, { debug: this.debug, schema: options.schema });
+                  if (validation.isValid) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Issue #443: Accepting valid JSON response without attempt_completion (${cleanedJson.length} chars)`);
+                    }
+                    finalResult = cleanedJson;
+                    completionAttempted = true;
+                    break;
+                  }
+                } catch {
+                }
+              }
               consecutiveNoToolCount++;
               const isIdentical = lastNoToolResponse !== null && assistantResponseContent === lastNoToolResponse;
               const isSemanticallyStuck = lastNoToolResponse !== null && areBothStuckResponses(lastNoToolResponse, assistantResponseContent);

package/cjs/index.cjs

@@ -83496,6 +83496,7 @@ __export(schemaUtils_exports, {
   processSchemaResponse: () => processSchemaResponse,
   replaceMermaidDiagramsInJson: () => replaceMermaidDiagramsInJson,
   replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  sanitizeMarkdownEscapesInJson: () => sanitizeMarkdownEscapesInJson,
   tryAutoWrapForSimpleSchema: () => tryAutoWrapForSimpleSchema,
   tryMaidAutoFix: () => tryMaidAutoFix,
   validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
@@ -83599,6 +83600,17 @@ function decodeHtmlEntities(text) {
   }
   return decoded;
 }
+function sanitizeMarkdownEscapesInJson(jsonString) {
+  if (!jsonString || typeof jsonString !== "string") {
+    return jsonString;
+  }
+  return jsonString.replace(/\\\\|\\([^"\\\/bfnrtu])/g, (match2, captured) => {
+    if (match2 === "\\\\") {
+      return "\\\\";
+    }
+    return captured;
+  });
+}
 function normalizeJsonQuotes(str) {
   if (!str || typeof str !== "string") {
     return str;
@@ -83651,6 +83663,15 @@ function cleanSchemaResponse(response) {
   if (resultWrapperMatch) {
     return cleanSchemaResponse(resultWrapperMatch[1]);
   }
+  const toolCodeMatch = trimmed.match(/<tool_code>\s*([\s\S]*?)\s*<\/tool_code>/);
+  if (toolCodeMatch) {
+    let innerContent = toolCodeMatch[1].trim();
+    const funcCallMatch = innerContent.match(/(?:print|attempt_completion)\s*\(\s*([{\[][\s\S]*[}\]])\s*\)/);
+    if (funcCallMatch) {
+      return cleanSchemaResponse(funcCallMatch[1]);
+    }
+    return cleanSchemaResponse(innerContent);
+  }
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
   if (jsonBlockMatch) {
     return normalizeJsonQuotes(jsonBlockMatch[1].trim());
@@ -83718,9 +83739,25 @@ function validateJsonResponse(response, options = {}) {
       console.log(`[DEBUG] JSON validation: Schema validation enabled`);
     }
   }
+  let responseToValidate = response;
+  try {
+    JSON.parse(response);
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      const sanitized = sanitizeMarkdownEscapesInJson(response);
+      try {
+        JSON.parse(sanitized);
+        responseToValidate = sanitized;
+        if (debug) {
+          console.log(`[DEBUG] JSON validation: Fixed Markdown escapes in JSON (issue #441)`);
+        }
+      } catch {
+      }
+    }
+  }
   try {
     const parseStart = Date.now();
-    const parsed = JSON.parse(response);
+    const parsed = JSON.parse(responseToValidate);
     const parseTime = Date.now() - parseStart;
     if (debug) {
       console.log(`[DEBUG] JSON validation: Successfully parsed in ${parseTime}ms`);
@@ -84062,7 +84099,21 @@ function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
       console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
     }
     return null;
-  } catch {
+  } catch (initialError) {
+    if (initialError.message && initialError.message.includes("escape")) {
+      try {
+        const sanitized = sanitizeMarkdownEscapesInJson(response);
+        JSON.parse(sanitized);
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Fixed Markdown escapes in JSON (issue #441), returning sanitized JSON`);
+        }
+        return sanitized;
+      } catch {
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Markdown escape sanitization didn't fix JSON, proceeding with wrapping`);
+        }
+      }
+    }
   }
   const wrapped = JSON.stringify({ [wrapperInfo.fieldName]: response });
   if (debug) {
@@ -104258,6 +104309,13 @@ function generateSandboxGlobals(options) {
           if (i5 < keys2.length) params[keys2[i5]] = arg;
         });
       }
+      if (params.path && typeof params.path === "object") {
+        const coercedPath = params.path.file_path || params.path.path || params.path.directory || params.path.filename;
+        if (coercedPath && typeof coercedPath === "string") {
+          logFn?.(`[${name14}] Warning: Coerced object path to string "${coercedPath}" (issue #444)`);
+          params.path = coercedPath;
+        }
+      }
       const validated = schema.safeParse(params);
       if (!validated.success) {
         throw new Error(`Invalid parameters for ${name14}: ${validated.error.message}`);
@@ -104294,6 +104352,11 @@ function generateSandboxGlobals(options) {
   }
   if (llmCall) {
     const rawLLM = async (instruction, data3, opts = {}) => {
+      const dataStr = typeof data3 === "string" ? data3 : JSON.stringify(data3);
+      if (dataStr && dataStr.startsWith("ERROR:")) {
+        logFn?.("[LLM] Blocked: data contains error from previous tool call");
+        return "ERROR: Previous tool call failed - " + dataStr.substring(0, 200);
+      }
       const result = await llmCall(instruction, data3, opts);
       if (opts.schema && typeof result === "string") {
         try {
@@ -106591,6 +106654,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH \u2014 pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) \u2014 the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -106599,7 +106663,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools \u2014 write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) \u2014 use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() \u2014 handle or skip it.`;
               const fixedCode = await llmCallFn(fixPrompt, "", { maxTokens: 4e3, temperature: 0.2 });
               currentCode = stripCodeWrapping(fixedCode);
               planSpan?.addEvent?.("dsl.self_heal_complete", {
@@ -111855,6 +111920,25 @@ ${errorXml}
                 }
                 break;
               }
+              if (options.schema) {
+                let contentToCheck = assistantResponseContent;
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*?<\/thinking>/gi, "").trim();
+                contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*$/gi, "").trim();
+                const cleanedJson = cleanSchemaResponse(contentToCheck);
+                try {
+                  JSON.parse(cleanedJson);
+                  const validation = validateJsonResponse(cleanedJson, { debug: this.debug, schema: options.schema });
+                  if (validation.isValid) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] Issue #443: Accepting valid JSON response without attempt_completion (${cleanedJson.length} chars)`);
+                    }
+                    finalResult = cleanedJson;
+                    completionAttempted = true;
+                    break;
+                  }
+                } catch {
+                }
+              }
               consecutiveNoToolCount++;
               const isIdentical = lastNoToolResponse !== null && assistantResponseContent === lastNoToolResponse;
               const isSemanticallyStuck = lastNoToolResponse !== null && areBothStuckResponses(lastNoToolResponse, assistantResponseContent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc253",
+  "version": "0.6.0-rc254",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/agent/ProbeAgent.js

@@ -4005,6 +4005,33 @@ Follow these instructions carefully:
             break;
           }
 
+          // Issue #443: Check if response contains valid schema-matching JSON
+          // Before triggering error.no_tool_call, strip markdown fences and validate
+          // This handles cases where AI returns valid JSON without using attempt_completion
+          if (options.schema) {
+            // Remove thinking tags first
+            let contentToCheck = assistantResponseContent;
+            contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*?<\/thinking>/gi, '').trim();
+            contentToCheck = contentToCheck.replace(/<thinking>[\s\S]*$/gi, '').trim();
+
+            // Try to extract and validate JSON
+            const cleanedJson = cleanSchemaResponse(contentToCheck);
+            try {
+              JSON.parse(cleanedJson);
+              const validation = validateJsonResponse(cleanedJson, { debug: this.debug, schema: options.schema });
+              if (validation.isValid) {
+                if (this.debug) {
+                  console.log(`[DEBUG] Issue #443: Accepting valid JSON response without attempt_completion (${cleanedJson.length} chars)`);
+                }
+                finalResult = cleanedJson;
+                completionAttempted = true;
+                break;
+              }
+            } catch {
+              // Not valid JSON - continue to standard no_tool_call handling
+            }
+          }
+
           // Increment consecutive no-tool counter (catches alternating stuck responses)
           consecutiveNoToolCount++;
 

package/src/agent/dsl/environment.js

@@ -183,6 +183,16 @@ export function generateSandboxGlobals(options) {
         });
       }
 
+      // Issue #444: Auto-coerce object paths to strings for search()
+      // AI-generated DSL sometimes passes field objects instead of field.file_path strings
+      if (params.path && typeof params.path === 'object') {
+        const coercedPath = params.path.file_path || params.path.path || params.path.directory || params.path.filename;
+        if (coercedPath && typeof coercedPath === 'string') {
+          logFn?.(`[${name}] Warning: Coerced object path to string "${coercedPath}" (issue #444)`);
+          params.path = coercedPath;
+        }
+      }
+
       const validated = schema.safeParse(params);
       if (!validated.success) {
         throw new Error(`Invalid parameters for ${name}: ${validated.error.message}`);
@@ -232,6 +242,15 @@ export function generateSandboxGlobals(options) {
   // When schema is provided, auto-parse the JSON result for easier downstream processing
   if (llmCall) {
     const rawLLM = async (instruction, data, opts = {}) => {
+      // Issue #444: Guard against error strings being passed as data
+      // When previous tool calls fail, they return "ERROR: ..." strings
+      // Passing these to LLM() spawns useless delegates that can't help
+      const dataStr = typeof data === 'string' ? data : JSON.stringify(data);
+      if (dataStr && dataStr.startsWith('ERROR:')) {
+        logFn?.('[LLM] Blocked: data contains error from previous tool call');
+        return 'ERROR: Previous tool call failed - ' + dataStr.substring(0, 200);
+      }
+
       const result = await llmCall(instruction, data, opts);
       // Auto-parse JSON when schema is provided and result is a string
       if (opts.schema && typeof result === 'string') {

package/src/agent/schemaUtils.js

@@ -165,6 +165,39 @@ export function decodeHtmlEntities(text) {
   return decoded;
 }
 
+/**
+ * Sanitize Markdown escape sequences in JSON strings
+ *
+ * Markdown uses backslash escapes like \*, \_, \#, \~ etc. which are NOT valid
+ * JSON escape sequences. When AI models produce JSON with Markdown content,
+ * these escapes cause JSON.parse() to fail with "Invalid \escape" errors.
+ *
+ * This function removes the backslash from invalid escape sequences while
+ * preserving valid JSON escapes: \\, \", \/, \b, \f, \n, \r, \t, \uXXXX
+ *
+ * @param {string} jsonString - JSON string that may contain Markdown escapes
+ * @returns {string} - JSON string with invalid escapes sanitized
+ */
+export function sanitizeMarkdownEscapesInJson(jsonString) {
+  if (!jsonString || typeof jsonString !== 'string') {
+    return jsonString;
+  }
+
+  // Strategy: Match either:
+  // 1. \\\\ (escaped backslash) - preserve as-is
+  // 2. \\X where X is NOT a valid JSON escape char - remove the backslash
+  //
+  // Valid JSON escape chars: " \ / b f n r t u
+  // This converts: \* → *, \_ → _, \# → #, \~ → ~, etc.
+  // But preserves: \\, \", \n, \t, \r, \b, \f, \/, \uXXXX
+  return jsonString.replace(/\\\\|\\([^"\\\/bfnrtu])/g, (match, captured) => {
+    if (match === '\\\\') {
+      return '\\\\'; // Preserve escaped backslash
+    }
+    return captured; // Remove backslash from invalid escape
+  });
+}
+
 /**
  * Normalize JavaScript syntax to valid JSON syntax
  * Converts single quotes to double quotes for strings in JSON-like structures
@@ -261,6 +294,22 @@ export function cleanSchemaResponse(response) {
     return cleanSchemaResponse(resultWrapperMatch[1]);
   }
 
+  // Strip <tool_code>...</tool_code> wrapper (Gemini-style code execution format)
+  // Issue #443: Gemini sometimes wraps responses in <plan> + <tool_code> tags
+  // e.g., <tool_code>print(attempt_completion({"projects": ["repo1"]}))</tool_code>
+  const toolCodeMatch = trimmed.match(/<tool_code>\s*([\s\S]*?)\s*<\/tool_code>/);
+  if (toolCodeMatch) {
+    let innerContent = toolCodeMatch[1].trim();
+    // Extract JSON from print() or attempt_completion() wrappers
+    // e.g., print({"key": "value"}) or attempt_completion({"key": "value"})
+    const funcCallMatch = innerContent.match(/(?:print|attempt_completion)\s*\(\s*([{\[][\s\S]*[}\]])\s*\)/);
+    if (funcCallMatch) {
+      return cleanSchemaResponse(funcCallMatch[1]);
+    }
+    // Try cleaning the inner content directly
+    return cleanSchemaResponse(innerContent);
+  }
+
   // First, look for JSON after code block markers - similar to mermaid extraction
   // Try with json language specifier
   const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
@@ -370,9 +419,30 @@ export function validateJsonResponse(response, options = {}) {
     }
   }
 
+  // Try to parse the response, with fallback to sanitizing Markdown escapes (issue #441)
+  let responseToValidate = response;
+  try {
+    JSON.parse(response);
+  } catch (initialError) {
+    // Check if the error is due to invalid escape sequences (Markdown escapes like \*, \_)
+    if (initialError.message && initialError.message.includes('escape')) {
+      const sanitized = sanitizeMarkdownEscapesInJson(response);
+      try {
+        JSON.parse(sanitized);
+        // Sanitized version parses - use it instead
+        responseToValidate = sanitized;
+        if (debug) {
+          console.log(`[DEBUG] JSON validation: Fixed Markdown escapes in JSON (issue #441)`);
+        }
+      } catch {
+        // Sanitization didn't help, continue with original (will fail below with proper error)
+      }
+    }
+  }
+
   try {
     const parseStart = Date.now();
-    const parsed = JSON.parse(response);
+    const parsed = JSON.parse(responseToValidate);
     const parseTime = Date.now() - parseStart;
 
     if (debug) {
@@ -853,7 +923,26 @@ export function tryAutoWrapForSimpleSchema(response, schema, options = {}) {
       console.log(`[DEBUG] Auto-wrap: Response is already valid JSON, skipping`);
     }
     return null;
-  } catch {
+  } catch (initialError) {
+    // Not valid JSON - check if it's due to Markdown escapes (issue #441)
+    // AI models sometimes produce JSON with Markdown escapes like \* or \_
+    // which are valid Markdown but NOT valid JSON escape sequences
+    if (initialError.message && initialError.message.includes('escape')) {
+      try {
+        const sanitized = sanitizeMarkdownEscapesInJson(response);
+        JSON.parse(sanitized);
+        // Sanitized JSON is valid! Return it instead of wrapping
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Fixed Markdown escapes in JSON (issue #441), returning sanitized JSON`);
+        }
+        return sanitized;
+      } catch {
+        // Sanitization didn't help, proceed with wrapping
+        if (debug) {
+          console.log(`[DEBUG] Auto-wrap: Markdown escape sanitization didn't fix JSON, proceeding with wrapping`);
+        }
+      }
+    }
     // Not valid JSON, proceed with wrapping
   }
 

package/src/tools/executePlan.js

@@ -436,6 +436,7 @@ ${lastError}
 
 RULES REMINDER:
 - search(query) is KEYWORD SEARCH — pass a search query, NOT a filename. Use extract(filepath) to read file contents.
+- search(query, path) — the path argument must be a STRING, not an object. Use field.file_path, not field.
 - search() returns up to 20K tokens by default. Use search(query, path, {maxTokens: null}) for unlimited, or searchAll(query) to auto-paginate ALL results.
 - search(), searchAll(), query(), extract(), listFiles(), bash() all return STRINGS, not arrays.
 - Use chunk(stringData) to split a string into an array of chunks.
@@ -444,7 +445,8 @@ RULES REMINDER:
 - Do NOT define helper functions that call tools — write logic inline.
 - Do NOT use async/await, template literals, or shorthand properties.
 - Do NOT use regex literals (/pattern/) — use String methods like indexOf, includes, startsWith instead.
-- String concatenation with +, not template literals.`;
+- String concatenation with +, not template literals.
+- IMPORTANT: If a tool returns "ERROR: ...", do NOT pass that error string to LLM() — handle or skip it.`;
 
               const fixedCode = await llmCallFn(fixPrompt, '', { maxTokens: 4000, temperature: 0.2 });
               // Strip markdown fences and XML tags the LLM might add