@probelabs/probe 0.6.0-rc252 → 0.6.0-rc254

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/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/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