@probelabs/probe 0.6.0-rc252 → 0.6.0-rc254

package/build/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/build/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') {