@probelabs/probe 0.6.0-rc239 → 0.6.0-rc241

package/build/agent/schemaUtils.js

@@ -784,18 +784,42 @@ export function isSimpleTextWrapperSchema(schema) {
 
   const trimmed = schema.trim();
 
-  // Match patterns like: {text: string}, {"text": "string"}, {response: string}, etc.
-  // These are simple wrappers that just need a single text field
-  const simplePatterns = [
-    /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i,
-    /^\{\s*["']?type["']?\s*:\s*["']?object["']?\s*,\s*["']?properties["']?\s*:\s*\{\s*["']?(\w+)["']?\s*:\s*\{\s*["']?type["']?\s*:\s*["']?string["']?\s*\}\s*\}\s*\}$/i
-  ];
+  // First, try parsing as JSON for full JSON Schema format
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed !== 'object' || parsed === null) {
+      // Fall through to regex matching
+    } else {
+      // Shorthand JSON format: {"text": "string"} or {"fieldName": "string"}
+      const keys = Object.keys(parsed);
+      if (keys.length === 1 && parsed[keys[0]] === 'string') {
+        return { fieldName: keys[0] };
+      }
 
-  for (const pattern of simplePatterns) {
-    const match = trimmed.match(pattern);
-    if (match) {
-      return { fieldName: match[1] };
+      // Full JSON Schema format: {"type":"object","properties":{"text":{"type":"string",...}}}
+      // Handles schemas with "required", "description", and other extra fields
+      if (parsed.type === 'object' && parsed.properties) {
+        const propKeys = Object.keys(parsed.properties);
+        if (propKeys.length === 1) {
+          const prop = parsed.properties[propKeys[0]];
+          if (prop && prop.type === 'string') {
+            return { fieldName: propKeys[0] };
+          }
+        }
+      }
+
+      // Valid JSON but not a simple wrapper
+      return null;
     }
+  } catch {
+    // Not valid JSON, fall through to regex matching
+  }
+
+  // Fallback: regex matching for shorthand formats like {text: string}, {'text': 'string'}
+  const simplePattern = /^\{\s*["']?(\w+)["']?\s*:\s*["']?string["']?\s*\}$/i;
+  const match = trimmed.match(simplePattern);
+  if (match) {
+    return { fieldName: match[1] };
   }
 
   return null;

package/build/agent/tools.js

@@ -6,6 +6,7 @@ import {
   delegateTool,
   analyzeAllTool,
   createExecutePlanTool,
+  createCleanupExecutePlanTool,
   bashTool,
   editTool,
   createTool,
@@ -18,6 +19,7 @@ import {
   delegateSchema,
   analyzeAllSchema,
   executePlanSchema,
+  cleanupExecutePlanSchema,
   bashSchema,
   editSchema,
   createSchema,
@@ -27,6 +29,7 @@ import {
   delegateToolDefinition,
   analyzeAllToolDefinition,
   getExecutePlanToolDefinition,
+  getCleanupExecutePlanToolDefinition,
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,
@@ -63,6 +66,10 @@ export function createTools(configOptions) {
   }
   if (configOptions.enableExecutePlan && isToolAllowed('execute_plan')) {
     tools.executePlanTool = createExecutePlanTool(configOptions);
+    // cleanup_execute_plan is enabled together with execute_plan
+    if (isToolAllowed('cleanup_execute_plan')) {
+      tools.cleanupExecutePlanTool = createCleanupExecutePlanTool(configOptions);
+    }
   } else if (isToolAllowed('analyze_all')) {
     // analyze_all is fallback when execute_plan is not enabled
     tools.analyzeAllTool = analyzeAllTool(configOptions);
@@ -104,6 +111,7 @@ export {
   delegateSchema,
   analyzeAllSchema,
   executePlanSchema,
+  cleanupExecutePlanSchema,
   bashSchema,
   editSchema,
   createSchema,
@@ -114,6 +122,7 @@ export {
   delegateToolDefinition,
   analyzeAllToolDefinition,
   getExecutePlanToolDefinition,
+  getCleanupExecutePlanToolDefinition,
   bashToolDefinition,
   editToolDefinition,
   createToolDefinition,

package/build/index.js

@@ -27,6 +27,7 @@ import {
 	delegateSchema,
 	analyzeAllSchema,
 	executePlanSchema,
+	cleanupExecutePlanSchema,
 	attemptCompletionSchema,
 	bashSchema,
 	searchToolDefinition,
@@ -47,7 +48,7 @@ import {
 	createToolDefinition
 } from './tools/edit.js';
 import { searchTool, queryTool, extractTool, delegateTool, analyzeAllTool } from './tools/vercel.js';
-import { createExecutePlanTool, getExecutePlanToolDefinition } from './tools/executePlan.js';
+import { createExecutePlanTool, getExecutePlanToolDefinition, createCleanupExecutePlanTool, getCleanupExecutePlanToolDefinition } from './tools/executePlan.js';
 import { bashTool } from './tools/bash.js';
 import { editTool, createTool } from './tools/edit.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
@@ -93,6 +94,7 @@ export {
 	delegateTool,
 	analyzeAllTool,
 	createExecutePlanTool,
+	createCleanupExecutePlanTool,
 	bashTool,
 	editTool,
 	createTool,
@@ -106,6 +108,7 @@ export {
 	delegateSchema,
 	analyzeAllSchema,
 	executePlanSchema,
+	cleanupExecutePlanSchema,
 	attemptCompletionSchema,
 	bashSchema,
 	editSchema,
@@ -117,6 +120,7 @@ export {
 	delegateToolDefinition,
 	analyzeAllToolDefinition,
 	getExecutePlanToolDefinition,
+	getCleanupExecutePlanToolDefinition,
 	attemptCompletionToolDefinition,
 	bashToolDefinition,
 	editToolDefinition,

package/build/tools/common.js

@@ -59,6 +59,11 @@ export const executePlanSchema = z.object({
 	description: z.string().optional().describe('Human-readable description of what this plan does, for logging.')
 });
 
+export const cleanupExecutePlanSchema = z.object({
+	clearOutputBuffer: z.boolean().optional().default(true).describe('Clear the output buffer from previous execute_plan calls'),
+	clearSessionStore: z.boolean().optional().default(false).describe('Clear the session store (persisted data across execute_plan calls)')
+});
+
 // Schema for the attempt_completion tool - flexible validation for direct XML response
 export const attemptCompletionSchema = {
 	// Custom validation that requires result parameter but allows direct XML response
@@ -431,6 +436,7 @@ export const DEFAULT_VALID_TOOLS = [
 	'delegate',
 	'analyze_all',
 	'execute_plan',
+	'cleanup_execute_plan',
 	'listSkills',
 	'useSkill',
 	'listFiles',

package/build/tools/executePlan.js

@@ -6,7 +6,7 @@
  */
 
 import { tool } from 'ai';
-import { executePlanSchema, parseAndResolvePaths } from './common.js';
+import { executePlanSchema, cleanupExecutePlanSchema, parseAndResolvePaths } from './common.js';
 import { createDSLRuntime } from '../agent/dsl/runtime.js';
 import { search } from '../search.js';
 import { query } from '../query.js';
@@ -16,8 +16,42 @@ import { glob } from 'glob';
 
 export { executePlanSchema };
 
+/**
+ * Decode common HTML entities that LLMs sometimes produce when generating code.
+ * This handles entities like &amp;&amp; → &&, &lt;= → <=, etc.
+ */
+function decodeHtmlEntities(str) {
+  const entities = {
+    '&amp;': '&',
+    '&lt;': '<',
+    '&gt;': '>',
+    '&quot;': '"',
+    '&apos;': "'",
+    '&#39;': "'",
+    '&#x27;': "'",
+  };
+
+  // Replace named/common entities
+  let result = str.replace(/&(?:amp|lt|gt|quot|apos|#39|#x27);/gi, (match) => {
+    return entities[match.toLowerCase()] || match;
+  });
+
+  // Handle numeric entities (decimal): &#60; → <
+  result = result.replace(/&#(\d+);/g, (match, dec) => {
+    return String.fromCharCode(parseInt(dec, 10));
+  });
+
+  // Handle numeric entities (hex): &#x3C; → <
+  result = result.replace(/&#x([0-9a-f]+);/gi, (match, hex) => {
+    return String.fromCharCode(parseInt(hex, 16));
+  });
+
+  return result;
+}
+
 /**
  * Strip markdown fences and XML tags that LLMs sometimes wrap code in.
+ * Also decodes HTML entities that may appear in XML-extracted code.
  */
 function stripCodeWrapping(code) {
   let s = String(code || '');
@@ -25,6 +59,8 @@ function stripCodeWrapping(code) {
   s = s.replace(/^```(?:javascript|js)?\n?/gm, '').replace(/```$/gm, '');
   // Strip XML-style tags: <execute_plan>, </execute_plan>, <code>, </code>
   s = s.replace(/<\/?(?:execute_plan|code)>/g, '');
+  // Decode HTML entities (e.g., &amp;&amp; → &&, &lt;= → <=)
+  s = decodeHtmlEntities(s);
   return s.trim();
 }
 
@@ -347,7 +383,16 @@ RULES REMINDER:
           });
         }
 
-        // All retries exhausted
+        // All retries exhausted — auto-cleanup output buffer to prevent stale data
+        if (outputBuffer && outputBuffer.items && outputBuffer.items.length > 0) {
+          const clearedChars = outputBuffer.items.reduce((sum, item) => sum + item.length, 0);
+          outputBuffer.items = [];
+          planSpan?.addEvent?.('dsl.auto_cleanup', {
+            'cleanup.chars_cleared': clearedChars,
+            'cleanup.reason': 'all_retries_exhausted',
+          });
+        }
+
         finalOutput = `Plan execution failed after ${maxRetries} retries.\n\nLast error: ${lastError}`;
         planSpan?.setAttributes?.({
           'dsl.result': 'all_retries_exhausted',
@@ -358,6 +403,11 @@ RULES REMINDER:
         planSpan?.end?.();
         return finalOutput;
       } catch (e) {
+        // Auto-cleanup output buffer on exception to prevent stale data
+        if (outputBuffer && outputBuffer.items && outputBuffer.items.length > 0) {
+          outputBuffer.items = [];
+        }
+
         planSpan?.setStatus?.('ERROR');
         planSpan?.addEvent?.('exception', {
           'exception.message': e.message,
@@ -808,3 +858,87 @@ output(table);
 return "Generated table with " + results.length + " items.";
 \`\`\``;
 }
+
+/**
+ * Create the cleanup_execute_plan tool for the Vercel AI SDK.
+ *
+ * Cleans up output buffer and optionally session store from previous
+ * failed or interrupted execute_plan calls.
+ *
+ * @param {Object} options
+ * @param {Object} [options.outputBuffer] - Output buffer to clear
+ * @param {Object} [options.sessionStore] - Session store to clear
+ * @param {Object} [options.tracer] - OTEL tracer for tracing
+ * @returns {Object} Vercel AI SDK tool
+ */
+export function createCleanupExecutePlanTool(options) {
+  const { outputBuffer, sessionStore, tracer } = options;
+
+  return tool({
+    description: 'Clean up output buffer and session store from previous execute_plan calls. ' +
+      'Use this when a previous execute_plan failed and left stale data, or before starting a fresh analysis.',
+    parameters: cleanupExecutePlanSchema,
+    execute: async ({ clearOutputBuffer = true, clearSessionStore = false }) => {
+      const span = tracer?.createToolSpan?.('cleanup_execute_plan', {
+        'cleanup.clear_output_buffer': clearOutputBuffer,
+        'cleanup.clear_session_store': clearSessionStore,
+      }) || null;
+
+      const results = [];
+
+      try {
+        if (clearOutputBuffer && outputBuffer) {
+          const itemCount = outputBuffer.items?.length || 0;
+          const charCount = outputBuffer.items?.reduce((sum, item) => sum + item.length, 0) || 0;
+          outputBuffer.items = [];
+          results.push(`Output buffer cleared (${itemCount} items, ${charCount} chars)`);
+        }
+
+        if (clearSessionStore && sessionStore) {
+          const keyCount = Object.keys(sessionStore).length;
+          for (const key of Object.keys(sessionStore)) {
+            delete sessionStore[key];
+          }
+          results.push(`Session store cleared (${keyCount} keys)`);
+        }
+
+        const output = results.length > 0
+          ? `Cleanup complete:\n- ${results.join('\n- ')}`
+          : 'Nothing to clean up';
+
+        span?.setAttributes?.({
+          'cleanup.result': output,
+          'cleanup.success': true,
+        });
+        span?.setStatus?.('OK');
+        span?.end?.();
+
+        return output;
+      } catch (e) {
+        span?.setStatus?.('ERROR');
+        span?.addEvent?.('exception', { 'exception.message': e.message });
+        span?.end?.();
+        return `Cleanup failed: ${e.message}`;
+      }
+    },
+  });
+}
+
+/**
+ * XML tool definition for cleanup_execute_plan.
+ *
+ * @returns {string} Tool definition text
+ */
+export function getCleanupExecutePlanToolDefinition() {
+  return `## cleanup_execute_plan
+Description: Clean up output buffer and session store from previous execute_plan calls. Use when a previous execute_plan failed and left stale data, or before starting a fresh analysis.
+
+Parameters:
+- clearOutputBuffer: (optional, default: true) Clear the output buffer from previous execute_plan calls
+- clearSessionStore: (optional, default: false) Clear the session store (persisted data across execute_plan calls)
+
+Example:
+<cleanup_execute_plan>
+<clearOutputBuffer>true</clearOutputBuffer>
+</cleanup_execute_plan>`;
+}

package/build/tools/index.js

@@ -11,8 +11,8 @@ export { editTool, createTool } from './edit.js';
 // Export LangChain tools
 export { createSearchTool, createQueryTool, createExtractTool } from './langchain.js';
 
-// Export execute_plan tool
-export { createExecutePlanTool, getExecutePlanToolDefinition } from './executePlan.js';
+// Export execute_plan and cleanup_execute_plan tools
+export { createExecutePlanTool, getExecutePlanToolDefinition, createCleanupExecutePlanTool, getCleanupExecutePlanToolDefinition } from './executePlan.js';
 
 // Export common schemas and utilities
 export {
@@ -22,6 +22,7 @@ export {
 	delegateSchema,
 	bashSchema,
 	executePlanSchema,
+	cleanupExecutePlanSchema,
 	delegateDescription,
 	delegateToolDefinition,
 	bashDescription,