@probelabs/probe 0.6.0-rc252 → 0.6.0-rc254

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc252",
+  "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

@@ -3571,7 +3571,12 @@ Follow these instructions carefully:
                 } else {
                   // Content was mostly/entirely inside thinking tags.
                   // Extract thinking content and use it as the actual answer.
-                  const thinkingContent = extractThinkingContent(prevContent);
+                  // extractThinkingContent now handles nested thinking tags (issue #439)
+                  let thinkingContent = extractThinkingContent(prevContent);
+                  // Also apply removeThinkingTags as extra safety to catch any edge cases
+                  if (thinkingContent) {
+                    thinkingContent = removeThinkingTags(thinkingContent) || thinkingContent.replace(/<\/?thinking>/g, '');
+                  }
                   if (thinkingContent && thinkingContent.length > 50) {
                     finalResult = thinkingContent;
                     if (this.debug) console.log(`[DEBUG] Previous response was mostly in thinking tags — using thinking content as completion: ${finalResult.substring(0, 100)}...`);
@@ -4000,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++;
 
@@ -4795,10 +4827,25 @@ Convert your previous response content into actual JSON data that follows this s
       }
 
       // Remove thinking tags from final result before returning to user
+      // Skip for valid JSON to avoid destroying JSON structure when <thinking> appears
+      // inside string values (e.g., after tryAutoWrapForSimpleSchema embeds content with
+      // residual thinking tag fragments — issue #439)
       if (!options._schemaFormatted) {
-        finalResult = removeThinkingTags(finalResult);
-        if (this.debug) {
-          console.log(`[DEBUG] Removed thinking tags from final result`);
+        let isValidJson = false;
+        try {
+          JSON.parse(finalResult);
+          isValidJson = true;
+        } catch {
+          // Not valid JSON, proceed with thinking tag removal
+        }
+
+        if (!isValidJson) {
+          finalResult = removeThinkingTags(finalResult);
+          if (this.debug) {
+            console.log(`[DEBUG] Removed thinking tags from final result`);
+          }
+        } else if (this.debug) {
+          console.log(`[DEBUG] Skipped thinking tag removal for valid JSON result (issue #439)`);
         }
       }
 

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/agent/xmlParsingUtils.js

@@ -45,12 +45,38 @@ export function removeThinkingTags(xmlString) {
 
 /**
  * Extract thinking content for potential logging
+ * Handles nested thinking tags by recursively stripping inner tags.
  * @param {string} xmlString - The XML string to extract from
- * @returns {string|null} - Thinking content or null if not found
+ * @returns {string|null} - Thinking content (cleaned of nested tags) or null if not found
  */
 export function extractThinkingContent(xmlString) {
   const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  return thinkingMatch ? thinkingMatch[1].trim() : null;
+  if (!thinkingMatch) {
+    return null;
+  }
+
+  let content = thinkingMatch[1].trim();
+
+  // Handle nested thinking tags: if the extracted content itself starts with <thinking>,
+  // recursively extract from it until we get clean content.
+  // This handles: <thinking><thinking>content</thinking></thinking>
+  // where non-greedy match captures "<thinking>content" (issue #439)
+  while (content.startsWith('<thinking>')) {
+    const innerMatch = content.match(/<thinking>([\s\S]*?)<\/thinking>/);
+    if (innerMatch) {
+      content = innerMatch[1].trim();
+    } else {
+      // Unclosed inner <thinking> tag - strip the opening tag and use remaining content
+      // e.g., "<thinking>content" becomes "content"
+      content = content.substring('<thinking>'.length).trim();
+      break;
+    }
+  }
+
+  // Also strip any remaining thinking tags that might be embedded in the content
+  content = content.replace(/<\/?thinking>/g, '').trim();
+
+  return content || null;
 }
 
 /**

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