@probelabs/probe 0.6.0-rc251 → 0.6.0-rc253

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc251",
+  "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

@@ -819,6 +819,11 @@ export class ProbeAgent {
     // reset at the start of each answer() call
     this._outputBuffer = { items: [] };
 
+    // Separate accumulator for extracted RAW_OUTPUT blocks from tool results.
+    // This is distinct from _outputBuffer to prevent the cycle where:
+    // formatSuccess wraps → extract re-adds → next execute_plan re-wraps (issue #438)
+    this._extractedRawBlocks = [];
+
     const configOptions = {
       sessionId: this.sessionId,
       debug: this.debug,
@@ -2910,6 +2915,8 @@ Follow these instructions carefully:
       // Both must preserve the output buffer so the parent call can append it.
       if (this._outputBuffer && !options?._schemaFormatted && !options?._completionPromptProcessed) {
         this._outputBuffer.items = [];
+        // Also reset the extracted blocks accumulator (issue #438)
+        this._extractedRawBlocks = [];
       }
 
       // START CHECKPOINT: Initialize task management for this request
@@ -3564,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)}...`);
@@ -3629,15 +3641,17 @@ Follow these instructions carefully:
 
                 let toolResultContent = typeof executionResult === 'string' ? executionResult : JSON.stringify(executionResult, null, 2);
 
-                // Extract raw output blocks and pass them through to output buffer (before truncation)
+                // Extract raw output blocks from tool result (before truncation)
                 // This prevents LLM from processing/hallucinating large structured output from execute_plan
-                if (this._outputBuffer) {
-                  const { cleanedContent, extractedBlocks } = extractRawOutputBlocks(toolResultContent, this._outputBuffer);
-                  if (extractedBlocks.length > 0) {
-                    toolResultContent = cleanedContent;
-                    if (this.debug) {
-                      console.log(`[DEBUG] Extracted ${extractedBlocks.length} raw output blocks (${extractedBlocks.reduce((sum, b) => sum + b.length, 0)} chars) to output buffer`);
-                    }
+                // Push to _extractedRawBlocks (NOT _outputBuffer) to prevent the cycle where:
+                // formatSuccess wraps → extract re-adds → next execute_plan re-wraps (issue #438)
+                const { cleanedContent, extractedBlocks } = extractRawOutputBlocks(toolResultContent);
+                if (extractedBlocks.length > 0) {
+                  toolResultContent = cleanedContent;
+                  // Accumulate extracted blocks separately from DSL output() buffer
+                  this._extractedRawBlocks.push(...extractedBlocks);
+                  if (this.debug) {
+                    console.log(`[DEBUG] Extracted ${extractedBlocks.length} raw output blocks (${extractedBlocks.reduce((sum, b) => sum + b.length, 0)} chars) from tool result`);
                   }
                 }
 
@@ -3887,15 +3901,17 @@ Follow these instructions carefully:
                   toolResultContent = toolResultContent.split(wsPrefix).join('');
                 }
 
-                // Extract raw output blocks and pass them through to output buffer (before truncation)
+                // Extract raw output blocks from tool result (before truncation)
                 // This prevents LLM from processing/hallucinating large structured output from execute_plan
-                if (this._outputBuffer) {
-                  const { cleanedContent, extractedBlocks } = extractRawOutputBlocks(toolResultContent, this._outputBuffer);
-                  if (extractedBlocks.length > 0) {
-                    toolResultContent = cleanedContent;
-                    if (this.debug) {
-                      console.log(`[DEBUG] Extracted ${extractedBlocks.length} raw output blocks (${extractedBlocks.reduce((sum, b) => sum + b.length, 0)} chars) to output buffer`);
-                    }
+                // Push to _extractedRawBlocks (NOT _outputBuffer) to prevent the cycle where:
+                // formatSuccess wraps → extract re-adds → next execute_plan re-wraps (issue #438)
+                const { cleanedContent, extractedBlocks } = extractRawOutputBlocks(toolResultContent);
+                if (extractedBlocks.length > 0) {
+                  toolResultContent = cleanedContent;
+                  // Accumulate extracted blocks separately from DSL output() buffer
+                  this._extractedRawBlocks.push(...extractedBlocks);
+                  if (this.debug) {
+                    console.log(`[DEBUG] Extracted ${extractedBlocks.length} raw output blocks (${extractedBlocks.reduce((sum, b) => sum + b.length, 0)} chars) from tool result`);
                   }
                 }
 
@@ -4314,16 +4330,18 @@ After reviewing, provide your final answer using attempt_completion.`;
 
           // Make a follow-up call with the completion prompt
           // Pass _completionPromptProcessed to prevent infinite loops
-          // Save output buffer — the recursive answer() must not destroy DSL output() content
+          // Save output buffers — the recursive answer() must not destroy DSL output() content
           const savedOutputItems = this._outputBuffer ? [...this._outputBuffer.items] : [];
+          const savedExtractedBlocks = this._extractedRawBlocks ? [...this._extractedRawBlocks] : [];
           const completionResult = await this.answer(completionPromptMessage, [], {
             ...options,
             _completionPromptProcessed: true
           });
-          // Restore output buffer so the parent call can append it to the final result
+          // Restore output buffers so the parent call can append them to the final result
           if (this._outputBuffer) {
             this._outputBuffer.items = savedOutputItems;
           }
+          this._extractedRawBlocks = savedExtractedBlocks;
 
           // Update finalResult with the result from the completion prompt
           finalResult = completionResult;
@@ -4782,17 +4800,38 @@ 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)`);
         }
       }
 
       // Append DSL output buffer directly to response (bypasses LLM rewriting)
       // Skip during _completionPromptProcessed — only the parent answer() should append the buffer.
-      if (this._outputBuffer && this._outputBuffer.items.length > 0 && !options._schemaFormatted && !options._completionPromptProcessed) {
-        const outputContent = this._outputBuffer.items.join('\n\n');
+      // Combine _outputBuffer (from DSL output() calls) and _extractedRawBlocks (from tool results)
+      // Using separate accumulators prevents the cycle described in issue #438.
+      const allOutputItems = [
+        ...(this._outputBuffer?.items || []),
+        ...(this._extractedRawBlocks || [])
+      ];
+      if (allOutputItems.length > 0 && !options._schemaFormatted && !options._completionPromptProcessed) {
+        const outputContent = allOutputItems.join('\n\n');
         if (options.schema) {
           // Schema response — the finalResult is JSON. Wrap output in RAW_OUTPUT
           // delimiters so clients (visor, etc.) can extract and propagate the
@@ -4805,9 +4844,10 @@ Convert your previous response content into actual JSON data that follows this s
           options.onStream('\n\n' + outputContent);
         }
         if (this.debug) {
-          console.log(`[DEBUG] Appended ${this._outputBuffer.items.length} output buffer items (${outputContent.length} chars) to final result${options.schema ? ' (with RAW_OUTPUT delimiters)' : ''}`);
+          console.log(`[DEBUG] Appended ${allOutputItems.length} output items (${outputContent.length} chars) to final result${options.schema ? ' (with RAW_OUTPUT delimiters)' : ''}`);
         }
         this._outputBuffer.items = [];
+        this._extractedRawBlocks = [];
       }
 
       return finalResult;

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;
 }
 
 /**

package/src/tools/executePlan.js

@@ -65,14 +65,28 @@ function stripCodeWrapping(code) {
   return s.trim();
 }
 
+/**
+ * Generate a unique session ID for this execute_plan invocation.
+ * Uses crypto.randomUUID if available, falls back to timestamp + random.
+ */
+function generatePlanSessionId(baseSessionId) {
+  const uniquePart = typeof crypto !== 'undefined' && crypto.randomUUID
+    ? crypto.randomUUID().slice(0, 8)
+    : `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  return `${baseSessionId || 'plan'}-${uniquePart}`;
+}
+
 /**
  * Build DSL-compatible tool implementations from the agent's configOptions.
  *
  * @param {Object} configOptions - Agent config (sessionId, cwd, provider, model, etc.)
+ * @param {string} [planSessionId] - Unique session ID for this execute_plan invocation
  * @returns {Object} toolImplementations for createDSLRuntime
  */
-function buildToolImplementations(configOptions) {
-  const { sessionId, cwd } = configOptions;
+function buildToolImplementations(configOptions, planSessionId) {
+  const { cwd } = configOptions;
+  // Use planSessionId for isolated pagination per execute_plan, fall back to global sessionId
+  const sessionId = planSessionId || configOptions.sessionId;
   const tools = {};
 
   tools.search = {
@@ -311,9 +325,11 @@ export function createExecutePlanTool(options) {
 
   /**
    * Build or rebuild the DSL runtime.
-   * Called lazily on first execute() and when MCP bridge changes.
+   * Called for each execute() invocation with a unique planSessionId.
+   *
+   * @param {string} [planSessionId] - Unique session ID for this execute_plan invocation
    */
-  function buildRuntime() {
+  function buildRuntime(planSessionId) {
     const currentMcpBridge = getMcpBridge();
     const currentMcpTools = getMcpTools();
 
@@ -340,7 +356,7 @@ export function createExecutePlanTool(options) {
       // Agent configOptions — build everything from the agent's config
       llmCallFn = llmCallFn || buildLLMCall(options);
       runtimeOptions = {
-        toolImplementations: buildToolImplementations(options),
+        toolImplementations: buildToolImplementations(options, planSessionId),
         llmCall: llmCallFn,
         mcpBridge: currentMcpBridge,
         mcpTools: filteredMcpTools,
@@ -360,6 +376,7 @@ export function createExecutePlanTool(options) {
 
   /**
    * Get or rebuild the runtime if MCP state has changed.
+   * @deprecated Use buildRuntime(planSessionId) directly for unique sessions per execution
    */
   function getRuntime() {
     const currentMcpBridge = getMcpBridge();
@@ -378,14 +395,22 @@ export function createExecutePlanTool(options) {
       'Write simple synchronous-looking code — do NOT use async/await.',
     parameters: executePlanSchema,
     execute: async ({ code, description }) => {
+      // Generate a unique session ID for this execute_plan invocation
+      // This ensures search pagination is isolated per execute_plan call
+      const planSessionId = generatePlanSessionId(options.sessionId);
+
       // Create top-level OTEL span for the entire execute_plan invocation
       const planSpan = tracer?.createToolSpan?.('execute_plan', {
         'dsl.description': description || '',
         'dsl.code_length': code.length,
         'dsl.code': code,
         'dsl.max_retries': maxRetries,
+        'dsl.plan_session_id': planSessionId,
       }) || null;
 
+      // Build runtime with the unique planSessionId for isolated search pagination
+      const planRuntime = buildRuntime(planSessionId);
+
       // Strip XML tags and markdown fences LLMs sometimes wrap code in
       let currentCode = stripCodeWrapping(code);
       let lastError = null;
@@ -446,7 +471,7 @@ RULES REMINDER:
             }
           }
 
-          const result = await getRuntime().execute(currentCode, description);
+          const result = await planRuntime.execute(currentCode, description);
 
           if (result.status === 'success') {
             finalOutput = formatSuccess(result, description, attempt, outputBuffer);
@@ -574,8 +599,15 @@ function formatSuccess(result, description, attempt, outputBuffer) {
 
   // Format the result value
   const resultValue = result.result;
+  const hasOutputBufferContent = outputBuffer && outputBuffer.items && outputBuffer.items.length > 0;
   if (resultValue === undefined || resultValue === null) {
-    output += 'Plan completed (no return value).';
+    if (hasOutputBufferContent) {
+      // output() was used but no return statement — tell LLM the script succeeded
+      const totalChars = outputBuffer.items.reduce((sum, item) => sum + item.length, 0);
+      output += `Plan completed successfully. Output captured (${totalChars} chars) via output() and will be included in the final response.`;
+    } else {
+      output += 'Plan completed (no return value).';
+    }
   } else if (typeof resultValue === 'string') {
     output += `Result:\n${resultValue}`;
   } else {