@probelabs/probe 0.6.0-rc161 → 0.6.0-rc163

package/build/agent/schemaUtils.js

@@ -7,6 +7,80 @@ import { createMessagePreview } from '../tools/common.js';
 import { validate, fixText, extractMermaidBlocks } from '@probelabs/maid';
 import Ajv from 'ajv';
 
+/**
+ * Generate an example JSON object from a JSON schema
+ * @param {Object|string} schema - JSON schema object or string
+ * @param {Object} options - Options for generation
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @returns {Object|null} - Example object, or null if schema cannot be processed
+ */
+export function generateExampleFromSchema(schema, options = {}) {
+  const { debug = false } = options;
+
+  try {
+    const parsedSchema = typeof schema === 'string' ? JSON.parse(schema) : schema;
+
+    if (parsedSchema.type !== 'object' || !parsedSchema.properties) {
+      return null;
+    }
+
+    const exampleObj = {};
+    for (const [key, value] of Object.entries(parsedSchema.properties)) {
+      if (value.type === 'boolean') {
+        exampleObj[key] = false;
+      } else if (value.type === 'number') {
+        exampleObj[key] = 0;
+      } else if (value.type === 'string') {
+        exampleObj[key] = value.description || 'your answer here';
+      } else if (value.type === 'array') {
+        exampleObj[key] = [];
+      } else {
+        exampleObj[key] = {};
+      }
+    }
+
+    return exampleObj;
+  } catch (e) {
+    if (debug) {
+      console.error('[DEBUG] generateExampleFromSchema: Failed to parse schema:', e.message);
+    }
+    return null;
+  }
+}
+
+/**
+ * Generate schema instructions for AI to follow
+ * @param {Object|string} schema - JSON schema object or string
+ * @param {Object} options - Options for generation
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @returns {string} - Formatted schema instructions
+ */
+export function generateSchemaInstructions(schema, options = {}) {
+  const { debug = false } = options;
+
+  let instructions = '\n\nIMPORTANT: When you provide your final answer using attempt_completion, you MUST format it as valid JSON matching this schema:\n\n';
+
+  try {
+    const parsedSchema = typeof schema === 'string' ? JSON.parse(schema) : schema;
+    instructions += `${JSON.stringify(parsedSchema, null, 2)}\n\n`;
+
+    // Generate example using helper function
+    const exampleObj = generateExampleFromSchema(parsedSchema, { debug });
+    if (exampleObj) {
+      instructions += `Example:\n<attempt_completion>\n${JSON.stringify(exampleObj, null, 2)}\n</attempt_completion>\n\n`;
+    }
+  } catch (e) {
+    if (debug) {
+      console.error('[DEBUG] generateSchemaInstructions: Failed to parse schema:', e.message);
+    }
+    instructions += `${schema}\n\n`;
+  }
+
+  instructions += 'Your response inside attempt_completion must be ONLY valid JSON - no plain text, no explanations, no markdown.';
+
+  return instructions;
+}
+
 /**
  * Recursively apply additionalProperties: false to all object schemas
  * This ensures strict validation at all nesting levels
@@ -100,6 +174,13 @@ export function decodeHtmlEntities(text) {
 /**
  * Clean AI response by extracting JSON content when response contains JSON
  * Only processes responses that contain JSON structures { or [
+ *
+ * NOTE: This function handles both JSON extraction AND content stripping.
+ * Future improvement: Consider splitting into separate functions for better separation of concerns:
+ * - extractJsonContent() - Find and extract JSON from response
+ * - stripNonJsonContent() - Remove explanatory text while preserving validation-relevant content
+ * This would allow validation to run on full responses before content is discarded.
+ *
  * @param {string} response - Raw AI response
  * @returns {string} - Cleaned response with JSON boundaries extracted if applicable
  */

package/build/agent/xmlParsingUtils.js

@@ -59,10 +59,30 @@ export function extractThinkingContent(xmlString) {
 export function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
   // Check for <attempt_completion> with content (with or without closing tag)
   // This handles: "<attempt_completion>content" or "<attempt_completion>content</attempt_completion>"
-  const attemptCompletionMatch = cleanedXmlString.match(/<attempt_completion>([\s\S]*?)(?:<\/attempt_completion>|$)/);
-  if (attemptCompletionMatch) {
-    const content = attemptCompletionMatch[1].trim();
-    const hasClosingTag = cleanedXmlString.includes('</attempt_completion>');
+
+  // IMPORTANT: Use greedy match ([\s\S]*) instead of non-greedy ([\s\S]*?) to handle cases
+  // where the content contains the string "</attempt_completion>" (e.g., in regex patterns or code examples).
+  // We want to find the LAST occurrence of </attempt_completion>, not the first one.
+  const openTagIndex = cleanedXmlString.indexOf('<attempt_completion>');
+  if (openTagIndex !== -1) {
+    const afterOpenTag = cleanedXmlString.substring(openTagIndex + '<attempt_completion>'.length);
+    const closeTagIndex = cleanedXmlString.lastIndexOf('</attempt_completion>');
+
+    let content;
+    let hasClosingTag = false;
+
+    if (closeTagIndex !== -1 && closeTagIndex >= openTagIndex + '<attempt_completion>'.length) {
+      // Found a closing tag at or after the opening tag - extract content between them
+      content = cleanedXmlString.substring(
+        openTagIndex + '<attempt_completion>'.length,
+        closeTagIndex
+      ).trim();
+      hasClosingTag = true;
+    } else {
+      // No closing tag - use content from opening tag to end of string
+      content = afterOpenTag.trim();
+      hasClosingTag = false;
+    }
 
     if (content) {
       // If there's content after the tag, use it as the result

package/build/tools/common.js

@@ -384,7 +384,22 @@ export function parseXmlToolCall(xmlString, validTools = DEFAULT_VALID_TOOLS) {
 			continue; // Tool not found, try next tool
 		}
 
-		let closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+		// For attempt_completion, use lastIndexOf to find the LAST occurrence of closing tag
+		// This prevents issues where the content contains the closing tag string (e.g., in regex patterns)
+		// For other tools, use indexOf from the opening tag position
+		let closeIndex;
+		if (toolName === 'attempt_completion') {
+			// Find the last occurrence of the closing tag in the entire string
+			// This assumes attempt_completion doesn't have nested tags of the same name
+			closeIndex = xmlString.lastIndexOf(closeTag);
+			// Make sure the closing tag is after the opening tag
+			if (closeIndex !== -1 && closeIndex <= openIndex + openTag.length) {
+				closeIndex = -1; // Invalid, treat as no closing tag
+			}
+		} else {
+			closeIndex = xmlString.indexOf(closeTag, openIndex + openTag.length);
+		}
+
 		let hasClosingTag = closeIndex !== -1;
 
 		// If no closing tag found, use content until end of string