@probelabs/probe 0.6.0-rc255 → 0.6.0-rc256

package/src/agent/index.js

@@ -623,9 +623,9 @@ class ProbeAgentMcpServer {
                 // Retry once with correction prompt
                 const correctionPrompt = createJsonCorrectionPrompt(result, schema, validation.error);
                 try {
-                  result = await agent.answer(correctionPrompt, [], { schema, _schemaFormatted: true, _disableTools: true });
+                  result = await agent.answer(correctionPrompt, [], { schema, _schemaFormatted: true, _disableTools: true, _maxIterationsOverride: 3 });
                   result = cleanSchemaResponse(result);
-                  
+
                   // Validate again after correction
                   const finalValidation = validateJsonResponse(result);
                   if (!finalValidation.isValid && args.debug) {
@@ -971,11 +971,11 @@ async function main() {
             try {
               if (appTracer) {
                 result = await appTracer.withSpan('agent.json_correction',
-                  () => agent.answer(correctionPrompt, [], { schema, _schemaFormatted: true, _disableTools: true }),
+                  () => agent.answer(correctionPrompt, [], { schema, _schemaFormatted: true, _disableTools: true, _maxIterationsOverride: 3 }),
                   { 'original_error': validation.error }
                 );
               } else {
-                result = await agent.answer(correctionPrompt, [], { schema, _schemaFormatted: true, _disableTools: true });
+                result = await agent.answer(correctionPrompt, [], { schema, _schemaFormatted: true, _disableTools: true, _maxIterationsOverride: 3 });
               }
               result = cleanSchemaResponse(result);
               

package/src/agent/mcp/xmlBridge.js

@@ -6,6 +6,7 @@
 import { MCPClientManager } from './client.js';
 import { loadMCPConfiguration } from './config.js';
 import { processXmlWithThinkingAndRecovery } from '../xmlParsingUtils.js';
+import { unescapeXmlEntities } from '../../tools/common.js';
 
 /**
  * Convert MCP tool to XML definition format
@@ -111,7 +112,7 @@ export function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
       let match;
       while ((match = paramPattern.exec(content)) !== null) {
         const [, paramName, paramValue] = match;
-        params[paramName] = paramValue.trim();
+        params[paramName] = unescapeXmlEntities(paramValue.trim());
       }
     }
 
@@ -393,7 +394,7 @@ function parseNativeXmlTool(xmlString, toolName) {
     const [, paramName, paramValue] = match;
     // Skip if this is the params tag itself (MCP format)
     if (paramName !== 'params') {
-      params[paramName] = paramValue.trim();
+      params[paramName] = unescapeXmlEntities(paramValue.trim());
     }
   }
 

package/src/agent/schemaUtils.js

@@ -603,6 +603,17 @@ export function validateJsonResponse(response, options = {}) {
       }
     }
 
+    // Quick recovery: try to extract a valid JSON prefix before returning error.
+    // This handles the common case where AI returns valid JSON followed by markdown content,
+    // e.g., "Unexpected non-whitespace character after JSON at position 477" (issue #447).
+    const prefixResult = tryExtractValidJsonPrefix(responseToValidate, { schema, debug });
+    if (prefixResult && prefixResult.isValid) {
+      if (debug) {
+        console.log(`[DEBUG] JSON validation: Recovered valid JSON prefix (${prefixResult.extracted.length} chars) from response with trailing content`);
+      }
+      return { isValid: true, parsed: prefixResult.parsed };
+    }
+
     // Create enhanced error message with context snippet
     let enhancedError = error.message;
     let errorContext = null;
@@ -667,6 +678,122 @@ ${pointer} here`;
   }
 }
 
+/**
+ * Try to extract a valid JSON prefix from a string that has trailing non-JSON content.
+ * This handles the common case where an AI returns valid JSON followed by markdown text.
+ *
+ * Uses bracket-matching to find the end of the first complete JSON object/array,
+ * then validates the prefix with JSON.parse(). Optionally validates against a schema.
+ *
+ * @param {string} response - The full response string
+ * @param {Object} [options] - Options
+ * @param {Object|string} [options.schema] - JSON schema to validate against
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @returns {Object|null} - {isValid: true, parsed: Object, extracted: string} or null if no valid prefix found
+ */
+export function tryExtractValidJsonPrefix(response, options = {}) {
+  const { schema = null, debug = false } = options;
+
+  if (!response || typeof response !== 'string') {
+    return null;
+  }
+
+  const trimmed = response.trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
+
+  // Must start with { or [
+  const firstChar = trimmed[0];
+  if (firstChar !== '{' && firstChar !== '[') {
+    return null;
+  }
+
+  // First, check if the full string already parses - no need to extract prefix
+  try {
+    JSON.parse(trimmed);
+    return null; // Full string is valid JSON, no extraction needed
+  } catch {
+    // Expected - continue with prefix extraction
+  }
+
+  // Find the end of the first complete JSON object/array using bracket matching
+  const openChar = firstChar;
+  const closeChar = openChar === '{' ? '}' : ']';
+  let depth = 0;
+  let inString = false;
+  let escapeNext = false;
+  let endPos = -1;
+
+  for (let i = 0; i < trimmed.length; i++) {
+    const char = trimmed[i];
+
+    if (escapeNext) {
+      escapeNext = false;
+      continue;
+    }
+
+    if (char === '\\' && inString) {
+      escapeNext = true;
+      continue;
+    }
+
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+
+    if (inString) {
+      continue;
+    }
+
+    if (char === openChar) {
+      depth++;
+    } else if (char === closeChar) {
+      depth--;
+      if (depth === 0) {
+        endPos = i + 1;
+        break;
+      }
+    }
+  }
+
+  if (endPos <= 0 || endPos >= trimmed.length) {
+    return null; // No complete JSON found, or JSON spans the entire string
+  }
+
+  // Check that there's actual non-whitespace trailing content
+  const remainder = trimmed.substring(endPos).trim();
+  if (remainder.length === 0) {
+    return null; // Only whitespace after JSON, no trailing content issue
+  }
+
+  // Try to parse the prefix
+  const prefix = trimmed.substring(0, endPos);
+  try {
+    const parsed = JSON.parse(prefix);
+
+    if (debug) {
+      console.log(`[DEBUG] tryExtractValidJsonPrefix: Extracted valid JSON prefix (${prefix.length} chars), stripped trailing content (${remainder.length} chars)`);
+    }
+
+    // If schema provided, validate against it
+    if (schema) {
+      const schemaValidation = validateJsonResponse(prefix, { debug, schema });
+      if (!schemaValidation.isValid) {
+        if (debug) {
+          console.log(`[DEBUG] tryExtractValidJsonPrefix: Prefix is valid JSON but fails schema validation: ${schemaValidation.error}`);
+        }
+        return null;
+      }
+    }
+
+    return { isValid: true, parsed, extracted: prefix };
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Validate that the cleaned response is valid XML if expected
  * @param {string} response - Cleaned response

package/src/tools/common.js

@@ -521,6 +521,23 @@ function getValidParamsForTool(toolName) {
 	return [];
 }
 
+/**
+ * Unescape standard XML entities in a string value.
+ * Order matters: & must be decoded LAST to avoid double-decoding
+ * (e.g., &amp;lt; should become &lt;, not <).
+ * @param {string} str - The string to unescape
+ * @returns {string} The unescaped string
+ */
+export function unescapeXmlEntities(str) {
+	if (typeof str !== 'string') return str;
+	return str
+		.replace(/&lt;/g, '<')
+		.replace(/&gt;/g, '>')
+		.replace(/&quot;/g, '"')
+		.replace(/&apos;/g, "'")
+		.replace(/&amp;/g, '&');
+}
+
 // Simple XML parser helper - safer string-based approach
 export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 	// Find the tool that appears EARLIEST in the string
@@ -609,10 +626,10 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			paramCloseIndex = nextTagIndex;
 		}
 
-		let paramValue = innerContent.substring(
+		let paramValue = unescapeXmlEntities(innerContent.substring(
 			paramOpenIndex + paramOpenTag.length,
 			paramCloseIndex
-		).trim();
+		).trim());
 
 		// Basic type inference (can be improved)
 		if (paramValue.toLowerCase() === 'true') {
@@ -633,7 +650,7 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 
 	// Special handling for attempt_completion - use entire inner content as result
 	if (toolName === 'attempt_completion') {
-		params['result'] = innerContent.trim();
+		params['result'] = unescapeXmlEntities(innerContent.trim());
 		// Remove command parameter if it was parsed by generic logic above (legacy compatibility)
 		if (params.command) {
 			delete params.command;