@probelabs/probe 0.6.0-rc252 → 0.6.0-rc253

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc252",
+  "version": "0.6.0-rc253",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",

package/src/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)}...`);
@@ -4795,10 +4800,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/src/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;
 }
 
 /**