@probelabs/probe 0.6.0-rc131 → 0.6.0-rc132

package/build/agent/index.js

@@ -46421,6 +46421,28 @@ var init_out = __esm({
 });
 
 // src/agent/schemaUtils.js
+var schemaUtils_exports = {};
+__export(schemaUtils_exports, {
+  JsonFixingAgent: () => JsonFixingAgent,
+  MermaidFixingAgent: () => MermaidFixingAgent,
+  cleanSchemaResponse: () => cleanSchemaResponse,
+  createJsonCorrectionPrompt: () => createJsonCorrectionPrompt,
+  createMermaidCorrectionPrompt: () => createMermaidCorrectionPrompt,
+  createSchemaDefinitionCorrectionPrompt: () => createSchemaDefinitionCorrectionPrompt,
+  decodeHtmlEntities: () => decodeHtmlEntities,
+  extractMermaidFromMarkdown: () => extractMermaidFromMarkdown,
+  isJsonSchema: () => isJsonSchema,
+  isJsonSchemaDefinition: () => isJsonSchemaDefinition,
+  isMermaidSchema: () => isMermaidSchema,
+  processSchemaResponse: () => processSchemaResponse,
+  replaceMermaidDiagramsInMarkdown: () => replaceMermaidDiagramsInMarkdown,
+  tryMaidAutoFix: () => tryMaidAutoFix,
+  validateAndFixMermaidResponse: () => validateAndFixMermaidResponse,
+  validateJsonResponse: () => validateJsonResponse,
+  validateMermaidDiagram: () => validateMermaidDiagram,
+  validateMermaidResponse: () => validateMermaidResponse,
+  validateXmlResponse: () => validateXmlResponse
+});
 function decodeHtmlEntities(text) {
   if (!text || typeof text !== "string") {
     return text;
@@ -46509,9 +46531,49 @@ function validateJsonResponse(response, options = {}) {
     }
     return { isValid: true, parsed };
   } catch (error) {
+    const positionMatch = error.message.match(/position (\d+)/);
+    let errorPosition = positionMatch ? parseInt(positionMatch[1], 10) : null;
+    if (errorPosition === null) {
+      const tokenMatch = error.message.match(/Unexpected token '(.)', /);
+      if (tokenMatch && tokenMatch[1]) {
+        const problematicToken = tokenMatch[1];
+        errorPosition = response.indexOf(problematicToken);
+      }
+    }
+    let enhancedError = error.message;
+    let errorContext = null;
+    if (errorPosition !== null && errorPosition >= 0 && response && response.length > 0) {
+      const contextRadius = 50;
+      const startPos = Math.max(0, errorPosition - contextRadius);
+      const endPos = Math.min(response.length, errorPosition + contextRadius);
+      const beforeError = response.substring(startPos, errorPosition);
+      const atError = response[errorPosition] || "";
+      const afterError = response.substring(errorPosition + 1, endPos);
+      const snippet = beforeError + atError + afterError;
+      const pointerOffset = beforeError.length;
+      const pointer = " ".repeat(pointerOffset) + "^";
+      errorContext = {
+        position: errorPosition,
+        snippet,
+        pointer,
+        beforeError,
+        atError,
+        afterError
+      };
+      enhancedError = `${error.message}
+
+Error location (position ${errorPosition}):
+${snippet}
+${pointer} here`;
+    }
     if (debug) {
       console.log(`[DEBUG] JSON validation: Parse failed with error: ${error.message}`);
-      console.log(`[DEBUG] JSON validation: Error at position: ${error.message.match(/position (\d+)/) ? error.message.match(/position (\d+)/)[1] : "unknown"}`);
+      console.log(`[DEBUG] JSON validation: Error at position: ${errorPosition !== null ? errorPosition : "unknown"}`);
+      if (errorContext) {
+        console.log(`[DEBUG] JSON validation: Error context:
+${errorContext.snippet}
+${errorContext.pointer}`);
+      }
       if (error.message.includes("Unexpected token")) {
         console.log(`[DEBUG] JSON validation: Likely syntax error - unexpected character`);
       } else if (error.message.includes("Unexpected end")) {
@@ -46520,7 +46582,12 @@ function validateJsonResponse(response, options = {}) {
         console.log(`[DEBUG] JSON validation: Likely unquoted property names`);
       }
     }
-    return { isValid: false, error: error.message };
+    return {
+      isValid: false,
+      error: error.message,
+      enhancedError,
+      errorContext
+    };
   }
 }
 function validateXmlResponse(response) {
@@ -46640,7 +46707,16 @@ function isJsonSchemaDefinition(jsonString, options = {}) {
     return false;
   }
 }
-function createJsonCorrectionPrompt(invalidResponse, schema, error, retryCount = 0) {
+function createJsonCorrectionPrompt(invalidResponse, schema, errorOrValidation, retryCount = 0) {
+  let errorMessage;
+  let enhancedError;
+  if (typeof errorOrValidation === "object" && errorOrValidation !== null) {
+    errorMessage = errorOrValidation.error;
+    enhancedError = errorOrValidation.enhancedError || errorMessage;
+  } else {
+    errorMessage = errorOrValidation;
+    enhancedError = errorMessage;
+  }
   const strengthLevels = [
     {
       prefix: "CRITICAL JSON ERROR:",
@@ -46664,7 +46740,7 @@ function createJsonCorrectionPrompt(invalidResponse, schema, error, retryCount =
 
 ${invalidResponse.substring(0, 500)}${invalidResponse.length > 500 ? "..." : ""}
 
-Error: ${error}
+Error: ${enhancedError}
 
 ${currentLevel.instruction}
 
@@ -46709,6 +46785,28 @@ ${currentLevel.example}
 Return ONLY the JSON data object/array that follows the schema structure. NO schema definitions, NO explanations, NO markdown formatting.`;
   return prompt;
 }
+function isMermaidSchema(schema) {
+  if (!schema || typeof schema !== "string") {
+    return false;
+  }
+  const trimmedSchema = schema.trim().toLowerCase();
+  const mermaidIndicators = [
+    trimmedSchema.includes("mermaid"),
+    trimmedSchema.includes("diagram"),
+    trimmedSchema.includes("flowchart"),
+    trimmedSchema.includes("sequence"),
+    trimmedSchema.includes("gantt"),
+    trimmedSchema.includes("pie chart"),
+    trimmedSchema.includes("state diagram"),
+    trimmedSchema.includes("class diagram"),
+    trimmedSchema.includes("entity relationship"),
+    trimmedSchema.includes("user journey"),
+    trimmedSchema.includes("git graph"),
+    trimmedSchema.includes("requirement diagram"),
+    trimmedSchema.includes("c4 context")
+  ];
+  return mermaidIndicators.some((indicator) => indicator);
+}
 function extractMermaidFromMarkdown(response) {
   if (!response || typeof response !== "string") {
     return { diagrams: [], cleanedResponse: response };
@@ -46729,6 +46827,24 @@ function extractMermaidFromMarkdown(response) {
   }
   return { diagrams, cleanedResponse: response };
 }
+function replaceMermaidDiagramsInMarkdown(originalResponse, correctedDiagrams) {
+  if (!originalResponse || typeof originalResponse !== "string") {
+    return originalResponse;
+  }
+  if (!correctedDiagrams || correctedDiagrams.length === 0) {
+    return originalResponse;
+  }
+  let modifiedResponse = originalResponse;
+  const sortedDiagrams = [...correctedDiagrams].sort((a, b) => b.startIndex - a.startIndex);
+  for (const diagram of sortedDiagrams) {
+    const attributesStr = diagram.attributes ? ` ${diagram.attributes}` : "";
+    const newCodeBlock = `\`\`\`mermaid${attributesStr}
+${diagram.content}
+\`\`\``;
+    modifiedResponse = modifiedResponse.slice(0, diagram.startIndex) + newCodeBlock + modifiedResponse.slice(diagram.endIndex);
+  }
+  return modifiedResponse;
+}
 async function validateMermaidDiagram(diagram) {
   if (!diagram || typeof diagram !== "string") {
     return { isValid: false, error: "Empty or invalid diagram input" };
@@ -46795,6 +46911,45 @@ async function validateMermaidResponse(response) {
     errors: errors.length > 0 ? errors : void 0
   };
 }
+function createMermaidCorrectionPrompt(invalidResponse, schema, errors, diagrams) {
+  let prompt = `Your previous response contains invalid Mermaid diagrams that cannot be parsed. Here's what you returned:
+
+${invalidResponse}
+
+Validation Errors:`;
+  errors.forEach((error, index) => {
+    prompt += `
+${index + 1}. ${error}`;
+  });
+  if (diagrams && diagrams.length > 0) {
+    prompt += `
+
+Diagram Details:`;
+    diagrams.forEach((diagramResult, index) => {
+      if (!diagramResult.isValid) {
+        prompt += `
+
+Diagram ${index + 1}:`;
+        const diagramContent = diagramResult.content || diagramResult.diagram || "";
+        prompt += `
+- Content: ${diagramContent.substring(0, 100)}${diagramContent.length > 100 ? "..." : ""}`;
+        prompt += `
+- Error: ${diagramResult.error}`;
+        if (diagramResult.detailedError && diagramResult.detailedError !== diagramResult.error) {
+          prompt += `
+- Details: ${diagramResult.detailedError}`;
+        }
+      }
+    });
+  }
+  prompt += `
+
+Please correct your response to include valid Mermaid diagrams that match this schema:
+${schema}
+
+Ensure all Mermaid diagrams are properly formatted within \`\`\`mermaid code blocks and follow correct Mermaid syntax.`;
+  return prompt;
+}
 async function tryMaidAutoFix(diagramContent, options = {}) {
   const { debug = false } = options;
   try {
@@ -47104,7 +47259,7 @@ ${fixedContent}
     };
   }
 }
-var HTML_ENTITY_MAP, MermaidFixingAgent;
+var HTML_ENTITY_MAP, JsonFixingAgent, MermaidFixingAgent;
 var init_schemaUtils = __esm({
   "src/agent/schemaUtils.js"() {
     "use strict";
@@ -47120,6 +47275,156 @@ var init_schemaUtils = __esm({
       // Also handle XML/HTML5 apostrophe entity
       " ": " "
     };
+    JsonFixingAgent = class {
+      constructor(options = {}) {
+        this.ProbeAgent = null;
+        this.options = {
+          sessionId: options.sessionId || `json-fixer-${Date.now()}`,
+          path: options.path || process.cwd(),
+          provider: options.provider,
+          model: options.model,
+          debug: options.debug,
+          tracer: options.tracer,
+          // Set to false since we're only fixing JSON syntax, not implementing code
+          allowEdit: false
+        };
+      }
+      /**
+       * Get the specialized prompt for JSON fixing
+       */
+      getJsonFixingPrompt() {
+        return `You are a world-class JSON syntax correction specialist. Your expertise lies in analyzing and fixing JSON syntax errors while preserving the original data structure and intent.
+
+CORE RESPONSIBILITIES:
+- Analyze JSON for syntax errors and structural issues
+- Fix syntax errors while maintaining the original data's semantic meaning
+- Ensure JSON follows proper RFC 8259 specification
+- Handle all JSON structures: objects, arrays, primitives, nested structures
+
+JSON SYNTAX RULES:
+1. **Property names**: Must be enclosed in double quotes
+2. **String values**: Must use double quotes (not single quotes)
+3. **Numbers**: Can be integers or decimals, no quotes needed
+4. **Booleans**: true or false (lowercase, no quotes)
+5. **Null**: null (lowercase, no quotes)
+6. **Arrays**: Comma-separated values in square brackets [...]
+7. **Objects**: Comma-separated key-value pairs in curly braces {...}
+8. **No trailing commas**: Last item in array/object must not have a trailing comma
+9. **Escape sequences**: Special characters must be escaped (\\n, \\t, \\", \\\\, etc.)
+
+COMMON ERRORS TO FIX:
+1. **Unquoted property names**: {name: "value"} \u2192 {"name": "value"}
+2. **Single quotes**: {'key': 'value'} \u2192 {"key": "value"}
+3. **Trailing commas**: {"a": 1,} \u2192 {"a": 1}
+4. **Unquoted strings**: {key: value} \u2192 {"key": "value"}
+5. **Missing commas**: {"a": 1 "b": 2} \u2192 {"a": 1, "b": 2}
+6. **Extra commas**: {"a": 1,, "b": 2} \u2192 {"a": 1, "b": 2}
+7. **Unclosed brackets/braces**: {"key": "value" \u2192 {"key": "value"}
+8. **Invalid escape sequences**: Fix or remove
+9. **Comments**: Remove // or /* */ comments (not allowed in JSON)
+10. **Undefined values**: Replace undefined with null
+
+FIXING METHODOLOGY:
+1. **Identify the error location** from the error message
+2. **Analyze the context** around the error
+3. **Apply the appropriate fix** based on JSON syntax rules
+4. **Preserve data intent** - never change the meaning of the data
+5. **Validate the result** - ensure it's parseable JSON
+
+CRITICAL RULES:
+- ALWAYS output only the corrected JSON
+- NEVER add explanations, comments, or additional text
+- NEVER wrap in markdown code blocks (no \`\`\`json)
+- PRESERVE the original data structure and values
+- FIX only syntax errors, don't modify the data itself
+- ENSURE the output is valid, parseable JSON
+
+When presented with broken JSON, analyze it thoroughly and provide the corrected version that maintains the original intent while fixing all syntax issues.`;
+      }
+      /**
+       * Initialize the ProbeAgent if not already done
+       */
+      async initializeAgent() {
+        if (!this.ProbeAgent) {
+          const { ProbeAgent: ProbeAgent2 } = await Promise.resolve().then(() => (init_ProbeAgent(), ProbeAgent_exports));
+          this.ProbeAgent = ProbeAgent2;
+        }
+        if (!this.agent) {
+          this.agent = new this.ProbeAgent({
+            sessionId: this.options.sessionId,
+            customPrompt: this.getJsonFixingPrompt(),
+            path: this.options.path,
+            provider: this.options.provider,
+            model: this.options.model,
+            debug: this.options.debug,
+            tracer: this.options.tracer,
+            allowEdit: this.options.allowEdit,
+            maxIterations: 5,
+            // Allow multiple iterations for JSON fixing
+            disableJsonValidation: true
+            // CRITICAL: Disable JSON validation in nested agent to prevent infinite recursion
+          });
+        }
+        return this.agent;
+      }
+      /**
+       * Fix invalid JSON using the specialized agent
+       * @param {string} invalidJson - The broken JSON string
+       * @param {string} schema - The original schema for context
+       * @param {Object} validationResult - Validation result with error details
+       * @param {number} attemptNumber - Current attempt number (for logging)
+       * @returns {Promise<string>} - The corrected JSON
+       */
+      async fixJson(invalidJson, schema, validationResult, attemptNumber = 1) {
+        await this.initializeAgent();
+        let errorContext = validationResult.error;
+        if (validationResult.enhancedError) {
+          errorContext = validationResult.enhancedError;
+        }
+        const prompt = `Fix the following invalid JSON.
+
+Error: ${errorContext}
+
+Invalid JSON:
+${invalidJson}
+
+Expected schema structure:
+${schema}
+
+Provide only the corrected JSON without any markdown formatting or explanations.`;
+        try {
+          if (this.options.debug) {
+            console.log(`[DEBUG] JSON fixing: Attempt ${attemptNumber} to fix JSON with separate agent`);
+          }
+          const result = await this.agent.answer(prompt, []);
+          const cleaned = cleanSchemaResponse(result);
+          if (this.options.debug) {
+            console.log(`[DEBUG] JSON fixing: Agent returned ${cleaned.length} chars`);
+          }
+          return cleaned;
+        } catch (error) {
+          if (this.options.debug) {
+            console.error(`[DEBUG] JSON fixing failed: ${error.message}`);
+          }
+          throw new Error(`Failed to fix JSON: ${error.message}`);
+        }
+      }
+      /**
+       * Get token usage information from the specialized agent
+       * @returns {Object} - Token usage statistics
+       */
+      getTokenUsage() {
+        return this.agent ? this.agent.getTokenUsage() : null;
+      }
+      /**
+       * Cancel any ongoing operations
+       */
+      cancel() {
+        if (this.agent) {
+          this.agent.cancel();
+        }
+      }
+    };
     MermaidFixingAgent = class {
       constructor(options = {}) {
         this.ProbeAgent = null;
@@ -48112,6 +48417,7 @@ var init_ProbeAgent = __esm({
        * @param {number} [options.maxResponseTokens] - Maximum tokens for AI responses
        * @param {number} [options.maxIterations] - Maximum tool iterations (overrides MAX_TOOL_ITERATIONS env var)
        * @param {boolean} [options.disableMermaidValidation=false] - Disable automatic mermaid diagram validation and fixing
+       * @param {boolean} [options.disableJsonValidation=false] - Disable automatic JSON validation and fixing (prevents infinite recursion in JsonFixingAgent)
        * @param {boolean} [options.enableMcp=false] - Enable MCP tool integration
        * @param {string} [options.mcpConfigPath] - Path to MCP configuration file
        * @param {Object} [options.mcpConfig] - MCP configuration object (overrides mcpConfigPath)
@@ -48131,6 +48437,7 @@ var init_ProbeAgent = __esm({
         this.maxResponseTokens = options.maxResponseTokens || parseInt(process.env.MAX_RESPONSE_TOKENS || "0", 10) || null;
         this.maxIterations = options.maxIterations || null;
         this.disableMermaidValidation = !!options.disableMermaidValidation;
+        this.disableJsonValidation = !!options.disableJsonValidation;
         this.storageAdapter = options.storageAdapter || new InMemoryStorageAdapter();
         this.hooks = new HookManager();
         if (options.hooks) {
@@ -49345,15 +49652,16 @@ Remember: Use proper XML format with BOTH opening and closing tags:
 <parameter>value</parameter>
 </tool_name>
 
-IMPORTANT: A schema was provided. You MUST respond with data that matches this schema.
-Use attempt_completion with your response directly inside the tags:
+IMPORTANT: A schema was provided for the final output format. You have two options:
 
+Option 1 - Use attempt_completion with your complete answer:
 <attempt_completion>
-[Your response content matching the provided schema format]
+[Your complete answer here - will be automatically formatted to match the schema]
 </attempt_completion>
 
-Your response must conform to this schema:
-${options.schema}`;
+Option 2 - Provide a natural response without any tool, and it will be automatically formatted.
+
+Do NOT try to format your response as JSON yourself - this will be done automatically.`;
               } else {
                 reminderContent = `Please use one of the available tools to help answer the question, or use attempt_completion if you have enough information to provide a final answer.
 
@@ -49500,6 +49808,10 @@ Convert your previous response content into actual JSON data that follows this s
                   console.log(`[DEBUG] JSON validation: Starting validation process for schema response`);
                   console.log(`[DEBUG] JSON validation: Response length: ${finalResult.length} chars`);
                 }
+                finalResult = cleanSchemaResponse(finalResult);
+                if (this.debug) {
+                  console.log(`[DEBUG] JSON validation: After cleaning, length: ${finalResult.length} chars`);
+                }
                 if (this.tracer) {
                   this.tracer.recordJsonValidationEvent("started", {
                     "json_validation.response_length": finalResult.length,
@@ -49511,75 +49823,66 @@ Convert your previous response content into actual JSON data that follows this s
                 const maxRetries = 3;
                 if (validation.isValid && isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
                   if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: Response is a JSON schema definition instead of data, correcting...`);
+                    console.log(`[DEBUG] JSON validation: Response is a JSON schema definition instead of data, needs correction...`);
                   }
-                  const schemaDefinitionPrompt = createSchemaDefinitionCorrectionPrompt(
-                    finalResult,
-                    options.schema,
-                    0
-                  );
-                  finalResult = await this.answer(schemaDefinitionPrompt, [], {
-                    ...options,
-                    _schemaFormatted: true
-                  });
-                  finalResult = cleanSchemaResponse(finalResult);
-                  validation = validateJsonResponse(finalResult);
-                  retryCount = 1;
+                  validation = {
+                    isValid: false,
+                    error: "Response is a JSON schema definition instead of actual data",
+                    enhancedError: "Response is a JSON schema definition instead of actual data. Please return data that conforms to the schema, not the schema itself."
+                  };
                 }
-                while (!validation.isValid && retryCount < maxRetries) {
+                if (!validation.isValid) {
                   if (this.debug) {
-                    console.log(`[DEBUG] JSON validation: Validation failed (attempt ${retryCount + 1}/${maxRetries}):`, validation.error);
-                    console.log(`[DEBUG] JSON validation: Invalid response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? "..." : ""}`);
+                    console.log(`[DEBUG] JSON validation: Starting separate JsonFixingAgent session...`);
                   }
-                  let correctionPrompt;
-                  try {
-                    if (isJsonSchemaDefinition(finalResult, { debug: this.debug })) {
-                      if (this.debug) {
-                        console.log(`[DEBUG] JSON validation: Response is still a schema definition, using specialized correction`);
-                      }
-                      correctionPrompt = createSchemaDefinitionCorrectionPrompt(
-                        finalResult,
-                        options.schema,
-                        retryCount
-                      );
-                    } else {
-                      correctionPrompt = createJsonCorrectionPrompt(
-                        finalResult,
+                  const { JsonFixingAgent: JsonFixingAgent2 } = await Promise.resolve().then(() => (init_schemaUtils(), schemaUtils_exports));
+                  const jsonFixer = new JsonFixingAgent2({
+                    path: this.allowedFolders[0],
+                    provider: this.clientApiProvider,
+                    model: this.model,
+                    debug: this.debug,
+                    tracer: this.tracer
+                  });
+                  let currentResult = finalResult;
+                  let currentValidation = validation;
+                  while (!currentValidation.isValid && retryCount < maxRetries) {
+                    if (this.debug) {
+                      console.log(`[DEBUG] JSON validation: Validation failed (attempt ${retryCount + 1}/${maxRetries}):`, currentValidation.error);
+                      console.log(`[DEBUG] JSON validation: Invalid response sample: ${currentResult.substring(0, 300)}${currentResult.length > 300 ? "..." : ""}`);
+                    }
+                    try {
+                      currentResult = await jsonFixer.fixJson(
+                        currentResult,
                         options.schema,
-                        validation.error,
-                        retryCount
+                        currentValidation,
+                        retryCount + 1
                       );
+                      currentValidation = validateJsonResponse(currentResult, { debug: this.debug });
+                      retryCount++;
+                      if (this.debug) {
+                        if (!currentValidation.isValid && retryCount < maxRetries) {
+                          console.log(`[DEBUG] JSON validation: Still invalid after correction ${retryCount}, retrying...`);
+                          console.log(`[DEBUG] JSON validation: Corrected response sample: ${currentResult.substring(0, 300)}${currentResult.length > 300 ? "..." : ""}`);
+                        } else if (currentValidation.isValid) {
+                          console.log(`[DEBUG] JSON validation: Successfully corrected after ${retryCount} attempts with JsonFixingAgent`);
+                        }
+                      }
+                    } catch (error) {
+                      if (this.debug) {
+                        console.error(`[DEBUG] JSON validation: JsonFixingAgent error on attempt ${retryCount + 1}:`, error.message);
+                      }
+                      break;
                     }
-                  } catch (error) {
-                    correctionPrompt = createJsonCorrectionPrompt(
-                      finalResult,
-                      options.schema,
-                      validation.error,
-                      retryCount
-                    );
                   }
-                  finalResult = await this.answer(correctionPrompt, [], {
-                    ...options,
-                    _schemaFormatted: true
-                  });
-                  finalResult = cleanSchemaResponse(finalResult);
-                  validation = validateJsonResponse(finalResult, { debug: this.debug });
-                  retryCount++;
-                  if (this.debug) {
-                    if (!validation.isValid && retryCount < maxRetries) {
-                      console.log(`[DEBUG] JSON validation: Still invalid after correction ${retryCount}, retrying...`);
-                      console.log(`[DEBUG] JSON validation: Corrected response sample: ${finalResult.substring(0, 300)}${finalResult.length > 300 ? "..." : ""}`);
-                    } else if (validation.isValid) {
-                      console.log(`[DEBUG] JSON validation: Successfully corrected after ${retryCount} attempts`);
-                    }
+                  finalResult = currentResult;
+                  validation = currentValidation;
+                  if (!validation.isValid && this.debug) {
+                    console.log(`[DEBUG] JSON validation: Still invalid after ${maxRetries} correction attempts with JsonFixingAgent:`, validation.error);
+                    console.log(`[DEBUG] JSON validation: Final invalid response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
+                  } else if (validation.isValid && this.debug) {
+                    console.log(`[DEBUG] JSON validation: Final validation successful`);
                   }
                 }
-                if (!validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: Still invalid after ${maxRetries} correction attempts:`, validation.error);
-                  console.log(`[DEBUG] JSON validation: Final invalid response: ${finalResult.substring(0, 500)}${finalResult.length > 500 ? "..." : ""}`);
-                } else if (validation.isValid && this.debug) {
-                  console.log(`[DEBUG] JSON validation: Final validation successful`);
-                }
                 if (this.tracer) {
                   this.tracer.recordJsonValidationEvent("completed", {
                     "json_validation.success": validation.isValid,
@@ -49827,6 +50130,7 @@ Convert your previous response content into actual JSON data that follows this s
           maxResponseTokens: this.maxResponseTokens,
           maxIterations: this.maxIterations,
           disableMermaidValidation: this.disableMermaidValidation,
+          disableJsonValidation: this.disableJsonValidation,
           enableMcp: !!this.mcpBridge,
           mcpConfig: this.mcpConfig,
           enableBash: this.enableBash,
@@ -49845,11 +50149,44 @@ Convert your previous response content into actual JSON data that follows this s
       }
       /**
        * Internal method to strip internal/temporary messages from history
-       * Removes: schema reminders, mermaid fix prompts, tool use reminders, etc.
-       * Keeps: system message, user messages, assistant responses, tool results
+       * Strategy: Find the FIRST schema-related message and truncate everything from that point onwards.
+       * This ensures that all schema formatting iterations (IMPORTANT, CRITICAL, corrections, etc.) are removed.
+       * Keeps: system message, user messages, assistant responses, tool results up to the first schema message
        * @private
        */
       _stripInternalMessages(history, keepSystemMessage = true) {
+        let firstSchemaMessageIndex = -1;
+        for (let i = 0; i < history.length; i++) {
+          const message = history[i];
+          if (message.role === "system") {
+            continue;
+          }
+          if (this._isSchemaMessage(message)) {
+            firstSchemaMessageIndex = i;
+            if (this.debug) {
+              console.log(`[DEBUG] Found first schema message at index ${i}, truncating from here`);
+            }
+            break;
+          }
+        }
+        if (firstSchemaMessageIndex === -1) {
+          return this._stripNonSchemaInternalMessages(history, keepSystemMessage);
+        }
+        const truncated = history.slice(0, firstSchemaMessageIndex);
+        const filtered = this._stripNonSchemaInternalMessages(truncated, keepSystemMessage);
+        if (this.debug) {
+          const removedCount = history.length - filtered.length;
+          console.log(`[DEBUG] Truncated at schema message (index ${firstSchemaMessageIndex}) and filtered non-schema internal messages`);
+          console.log(`[DEBUG] Removed ${removedCount} messages total (${history.length} \u2192 ${filtered.length})`);
+        }
+        return filtered;
+      }
+      /**
+       * Strip non-schema internal messages (mermaid fixes, tool reminders, etc.) individually
+       * Used when no schema messages are present in history
+       * @private
+       */
+      _stripNonSchemaInternalMessages(history, keepSystemMessage = true) {
         const filtered = [];
         for (let i = 0; i < history.length; i++) {
           const message = history[i];
@@ -49861,9 +50198,9 @@ Convert your previous response content into actual JSON data that follows this s
             }
             continue;
           }
-          if (this._isInternalMessage(message, i, history)) {
+          if (this._isNonSchemaInternalMessage(message)) {
             if (this.debug) {
-              console.log(`[DEBUG] Stripping internal message at index ${i}: ${message.role}`);
+              console.log(`[DEBUG] Stripping non-schema internal message at index ${i}: ${message.role}`);
             }
             continue;
           }
@@ -49872,20 +50209,50 @@ Convert your previous response content into actual JSON data that follows this s
         return filtered;
       }
       /**
-       * Determine if a message is an internal/temporary message
+       * Check if a message is schema-related (IMPORTANT, CRITICAL, etc.)
        * @private
        */
-      _isInternalMessage(message, index, history) {
+      _isSchemaMessage(message) {
         if (message.role !== "user") {
           return false;
         }
         if (!message.content) {
           return false;
         }
-        const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
-        if (content.includes("IMPORTANT: A schema was provided") || content.includes("You MUST respond with data that matches this schema") || content.includes("Your response must conform to this schema:")) {
+        let content;
+        try {
+          content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+        } catch (error) {
+          if (this.debug) {
+            console.log(`[DEBUG] Could not stringify message content in _isSchemaMessage: ${error.message}`);
+          }
+          return false;
+        }
+        if (content.includes("IMPORTANT: A schema was provided") || content.includes("You MUST respond with data that matches this schema") || content.includes("Your response must conform to this schema:") || content.includes("CRITICAL: You MUST respond with ONLY valid JSON DATA") || content.includes("Schema to follow (this is just the structure")) {
           return true;
         }
+        return false;
+      }
+      /**
+       * Check if a message is a non-schema internal message (mermaid, tool reminders, JSON corrections)
+       * @private
+       */
+      _isNonSchemaInternalMessage(message) {
+        if (message.role !== "user") {
+          return false;
+        }
+        if (!message.content) {
+          return false;
+        }
+        let content;
+        try {
+          content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+        } catch (error) {
+          if (this.debug) {
+            console.log(`[DEBUG] Could not stringify message content in _isNonSchemaInternalMessage: ${error.message}`);
+          }
+          return false;
+        }
         if (content.includes("Please use one of the available tools") && content.includes("or use attempt_completion") && content.includes("Remember: Use proper XML format")) {
           return true;
         }