@probelabs/probe 0.6.0-rc240 → 0.6.0-rc242

package/build/tools/executePlan.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();
 }
 
@@ -384,6 +420,51 @@ RULES REMINDER:
   });
 }
 
+// Delimiters for raw output passthrough - prevents LLM from processing/hallucinating large structured output
+export const RAW_OUTPUT_START = '<<<RAW_OUTPUT>>>';
+export const RAW_OUTPUT_END = '<<<END_RAW_OUTPUT>>>';
+
+/**
+ * Extract raw output blocks from tool result content and pass them through to the output buffer.
+ * This prevents parent LLMs from processing/hallucinating large structured output.
+ *
+ * @param {string} content - The tool result content
+ * @param {Object} [outputBuffer] - The output buffer to append extracted content to
+ * @returns {{ cleanedContent: string, extractedBlocks: string[] }} - Content with blocks removed and extracted blocks
+ */
+export function extractRawOutputBlocks(content, outputBuffer = null) {
+  if (typeof content !== 'string') {
+    return { cleanedContent: content, extractedBlocks: [] };
+  }
+
+  const extractedBlocks = [];
+  const regex = new RegExp(`${RAW_OUTPUT_START}\\n([\\s\\S]*?)\\n${RAW_OUTPUT_END}`, 'g');
+
+  let cleanedContent = content;
+  let match;
+
+  // Extract all blocks
+  while ((match = regex.exec(content)) !== null) {
+    extractedBlocks.push(match[1]);
+  }
+
+  // Remove the blocks and any following instruction line from content
+  cleanedContent = content
+    .replace(new RegExp(`${RAW_OUTPUT_START}\\n[\\s\\S]*?\\n${RAW_OUTPUT_END}`, 'g'), '')
+    .replace(/\n\n\[The above raw output \(\d+ chars\) will be passed directly to the final response\. Do NOT repeat, summarize, or modify it\.\]/g, '')
+    .trim();
+
+  // If output buffer provided, append extracted content
+  if (outputBuffer && extractedBlocks.length > 0) {
+    for (const block of extractedBlocks) {
+      outputBuffer.items = outputBuffer.items || [];
+      outputBuffer.items.push(block);
+    }
+  }
+
+  return { cleanedContent, extractedBlocks };
+}
+
 function formatSuccess(result, description, attempt, outputBuffer) {
   let output = '';
 
@@ -416,10 +497,12 @@ function formatSuccess(result, description, attempt, outputBuffer) {
     }
   }
 
-  // If output buffer has content, tell the LLM the data was written to direct output
+  // If output buffer has content, wrap it in delimiters for passthrough
+  // This prevents parent LLMs from processing/hallucinating the raw data
   if (outputBuffer && outputBuffer.items && outputBuffer.items.length > 0) {
-    const totalChars = outputBuffer.items.reduce((sum, item) => sum + item.length, 0);
-    output += `\n\n[Output buffer: ${totalChars} chars written via output(). This content will be appended directly to your response. Do NOT repeat or summarize it.]`;
+    const rawContent = outputBuffer.items.join('\n');
+    output += `\n\n${RAW_OUTPUT_START}\n${rawContent}\n${RAW_OUTPUT_END}`;
+    output += `\n\n[The above raw output (${rawContent.length} chars) will be passed directly to the final response. Do NOT repeat, summarize, or modify it.]`;
   }
 
   return output;

package/cjs/agent/ProbeAgent.cjs

@@ -6314,7 +6314,9 @@ var init_HttpBindingProtocol = __esm({
           if (bytes.byteLength > 0) {
             const dataFromBody = await deserializer.read(ns, bytes);
             for (const member2 of nonHttpBindingMembers) {
-              dataObject[member2] = dataFromBody[member2];
+              if (dataFromBody[member2] != null) {
+                dataObject[member2] = dataFromBody[member2];
+              }
             }
           }
         } else if (nonHttpBindingMembers.discardResponseBody) {
@@ -50930,6 +50932,50 @@ var init_walk = __esm({
 });
 
 // src/agent/dsl/validator.js
+function offsetToLineColumn(code, offset2) {
+  const lines = code.split("\n");
+  let pos = 0;
+  for (let i5 = 0; i5 < lines.length; i5++) {
+    const lineLength = lines[i5].length + 1;
+    if (pos + lineLength > offset2) {
+      return { line: i5 + 1, column: offset2 - pos + 1 };
+    }
+    pos += lineLength;
+  }
+  return { line: lines.length, column: 1 };
+}
+function generateErrorSnippet(code, line, column, contextLines = 2) {
+  const lines = code.split("\n");
+  const startLine = Math.max(0, line - 1 - contextLines);
+  const endLine = Math.min(lines.length, line + contextLines);
+  const snippetLines = [];
+  const lineNumWidth = String(endLine).length;
+  for (let i5 = startLine; i5 < endLine; i5++) {
+    const lineNum = String(i5 + 1).padStart(lineNumWidth, " ");
+    const marker15 = i5 + 1 === line ? ">" : " ";
+    snippetLines.push(`${marker15} ${lineNum} | ${lines[i5]}`);
+    if (i5 + 1 === line) {
+      const padding = " ".repeat(lineNumWidth + 4);
+      const arrow = " ".repeat(Math.max(0, column - 1)) + "^";
+      snippetLines.push(`${padding}${arrow}`);
+    }
+  }
+  return snippetLines.join("\n");
+}
+function formatErrorWithSnippet(message, code, offset2 = -1, line = 0, column = 0) {
+  if (offset2 >= 0) {
+    const loc = offsetToLineColumn(code, offset2);
+    line = loc.line;
+    column = loc.column;
+  }
+  if (line <= 0) {
+    return message;
+  }
+  const snippet = generateErrorSnippet(code, line, column);
+  return `${message}
+
+${snippet}`;
+}
 function validateDSL(code) {
   const errors = [];
   let ast;
@@ -50937,40 +50983,54 @@ function validateDSL(code) {
     ast = parse3(code, {
       ecmaVersion: 2022,
       sourceType: "script",
-      allowReturnOutsideFunction: true
+      allowReturnOutsideFunction: true,
+      locations: true
+      // Enable location tracking for better error messages
     });
   } catch (e5) {
-    return { valid: false, errors: [`Syntax error: ${e5.message}`] };
+    const line = e5.loc?.line || 0;
+    const column = e5.loc?.column ? e5.loc.column + 1 : 0;
+    const formattedError = formatErrorWithSnippet(
+      `Syntax error: ${e5.message}`,
+      code,
+      -1,
+      line,
+      column
+    );
+    return { valid: false, errors: [formattedError] };
   }
+  const addError = (message, position) => {
+    errors.push(formatErrorWithSnippet(message, code, position));
+  };
   full(ast, (node) => {
     if (!ALLOWED_NODE_TYPES.has(node.type)) {
-      errors.push(`Blocked node type: ${node.type} at position ${node.start}`);
+      addError(`Blocked node type: ${node.type}`, node.start);
       return;
     }
     if ((node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.async) {
-      errors.push(`Async functions are not allowed at position ${node.start}. Write synchronous code \u2014 the runtime handles async.`);
+      addError(`Async functions are not allowed. Write synchronous code \u2014 the runtime handles async.`, node.start);
     }
     if (node.type === "FunctionExpression" && node.generator) {
-      errors.push(`Generator functions are not allowed at position ${node.start}`);
+      addError(`Generator functions are not allowed`, node.start);
     }
     if (node.type === "Identifier" && BLOCKED_IDENTIFIERS.has(node.name)) {
-      errors.push(`Blocked identifier: '${node.name}' at position ${node.start}`);
+      addError(`Blocked identifier: '${node.name}'`, node.start);
     }
     if (node.type === "MemberExpression" && !node.computed) {
       if (node.property.type === "Identifier" && BLOCKED_PROPERTIES.has(node.property.name)) {
-        errors.push(`Blocked property access: '.${node.property.name}' at position ${node.property.start}`);
+        addError(`Blocked property access: '.${node.property.name}'`, node.property.start);
       }
     }
     if (node.type === "MemberExpression" && node.computed) {
       if (node.property.type === "Literal" && typeof node.property.value === "string") {
         if (BLOCKED_PROPERTIES.has(node.property.value) || BLOCKED_IDENTIFIERS.has(node.property.value)) {
-          errors.push(`Blocked computed property access: '["${node.property.value}"]' at position ${node.property.start}`);
+          addError(`Blocked computed property access: '["${node.property.value}"]'`, node.property.start);
         }
       }
     }
     if (node.type === "VariableDeclarator" && node.id.type === "Identifier") {
       if (BLOCKED_IDENTIFIERS.has(node.id.name)) {
-        errors.push(`Cannot declare variable with blocked name: '${node.id.name}' at position ${node.id.start}`);
+        addError(`Cannot declare variable with blocked name: '${node.id.name}'`, node.id.start);
       }
     }
   });
@@ -51294,7 +51354,16 @@ function generateSandboxGlobals(options) {
   }
   if (llmCall) {
     const rawLLM = async (instruction, data3, opts = {}) => {
-      return llmCall(instruction, data3, opts);
+      const result = await llmCall(instruction, data3, opts);
+      if (opts.schema && typeof result === "string") {
+        try {
+          return JSON.parse(result);
+        } catch (e5) {
+          logFn?.("[LLM] Warning: schema provided but result is not valid JSON");
+          return result;
+        }
+      }
+      return result;
     };
     globals.LLM = traceToolCall("LLM", rawLLM, tracer, logFn);
   }
@@ -51351,6 +51420,54 @@ function generateSandboxGlobals(options) {
     }
     return chunks;
   };
+  globals.chunkByKey = (data3, keyFn, maxTokens = 2e4) => {
+    const CHARS_PER_TOKEN3 = 4;
+    const maxChars = maxTokens * CHARS_PER_TOKEN3;
+    const text = typeof data3 === "string" ? data3 : JSON.stringify(data3);
+    const blockRegex = /^File: ([^\n]+)/gm;
+    const markers = [];
+    let match2;
+    while ((match2 = blockRegex.exec(text)) !== null) {
+      markers.push({ index: match2.index, file: match2[1].trim() });
+    }
+    if (markers.length === 0) {
+      return globals.chunk(data3, maxTokens);
+    }
+    const chunks = [];
+    let currentChunk = "";
+    let currentSize = 0;
+    let keysInChunk = /* @__PURE__ */ new Set();
+    for (let i5 = 0; i5 < markers.length; i5++) {
+      const start = markers[i5].index;
+      const end = i5 + 1 < markers.length ? markers[i5 + 1].index : text.length;
+      const block = text.slice(start, end).trim();
+      const file = markers[i5].file;
+      const key = typeof keyFn === "function" ? keyFn(file) : file;
+      const blockSize = block.length + 2;
+      const wouldOverflow = currentSize + blockSize > maxChars;
+      const keyAlreadyInChunk = keysInChunk.has(key);
+      if (!keyAlreadyInChunk && wouldOverflow && currentChunk) {
+        chunks.push(currentChunk.trim());
+        currentChunk = "";
+        currentSize = 0;
+        keysInChunk = /* @__PURE__ */ new Set();
+      }
+      if (currentChunk) currentChunk += "\n\n";
+      currentChunk += block;
+      currentSize += blockSize;
+      keysInChunk.add(key);
+    }
+    if (currentChunk.trim()) {
+      chunks.push(currentChunk.trim());
+    }
+    return chunks.length > 0 ? chunks : [""];
+  };
+  globals.extractPaths = (searchResults) => {
+    const text = typeof searchResults === "string" ? searchResults : JSON.stringify(searchResults);
+    const matches = text.match(/^File: ([^\n]+)/gm) || [];
+    const paths = matches.map((m5) => m5.replace("File: ", "").trim());
+    return [...new Set(paths)];
+  };
   globals.log = (message) => {
     if (globals._logs) globals._logs.push(String(message));
   };
@@ -58284,10 +58401,32 @@ var init_esm5 = __esm({
 });
 
 // src/tools/executePlan.js
+function decodeHtmlEntities(str) {
+  const entities = {
+    "&amp;": "&",
+    "&lt;": "<",
+    "&gt;": ">",
+    "&quot;": '"',
+    "&apos;": "'",
+    "&#39;": "'",
+    "&#x27;": "'"
+  };
+  let result = str.replace(/&(?:amp|lt|gt|quot|apos|#39|#x27);/gi, (match2) => {
+    return entities[match2.toLowerCase()] || match2;
+  });
+  result = result.replace(/&#(\d+);/g, (match2, dec) => {
+    return String.fromCharCode(parseInt(dec, 10));
+  });
+  result = result.replace(/&#x([0-9a-f]+);/gi, (match2, hex) => {
+    return String.fromCharCode(parseInt(hex, 16));
+  });
+  return result;
+}
 function stripCodeWrapping(code) {
   let s5 = String(code || "");
   s5 = s5.replace(/^```(?:javascript|js)?\n?/gm, "").replace(/```$/gm, "");
   s5 = s5.replace(/<\/?(?:execute_plan|code)>/g, "");
+  s5 = decodeHtmlEntities(s5);
   return s5.trim();
 }
 function buildToolImplementations(configOptions) {
@@ -58573,6 +58712,26 @@ Last error: ${lastError}`;
     }
   });
 }
+function extractRawOutputBlocks(content, outputBuffer = null) {
+  if (typeof content !== "string") {
+    return { cleanedContent: content, extractedBlocks: [] };
+  }
+  const extractedBlocks = [];
+  const regex = new RegExp(`${RAW_OUTPUT_START}\\n([\\s\\S]*?)\\n${RAW_OUTPUT_END}`, "g");
+  let cleanedContent = content;
+  let match2;
+  while ((match2 = regex.exec(content)) !== null) {
+    extractedBlocks.push(match2[1]);
+  }
+  cleanedContent = content.replace(new RegExp(`${RAW_OUTPUT_START}\\n[\\s\\S]*?\\n${RAW_OUTPUT_END}`, "g"), "").replace(/\n\n\[The above raw output \(\d+ chars\) will be passed directly to the final response\. Do NOT repeat, summarize, or modify it\.\]/g, "").trim();
+  if (outputBuffer && extractedBlocks.length > 0) {
+    for (const block of extractedBlocks) {
+      outputBuffer.items = outputBuffer.items || [];
+      outputBuffer.items.push(block);
+    }
+  }
+  return { cleanedContent, extractedBlocks };
+}
 function formatSuccess(result, description, attempt, outputBuffer) {
   let output = "";
   if (description) {
@@ -58609,10 +58768,15 @@ ${JSON.stringify(resultValue, null, 2)}`;
     }
   }
   if (outputBuffer && outputBuffer.items && outputBuffer.items.length > 0) {
-    const totalChars = outputBuffer.items.reduce((sum, item) => sum + item.length, 0);
+    const rawContent = outputBuffer.items.join("\n");
     output += `
 
-[Output buffer: ${totalChars} chars written via output(). This content will be appended directly to your response. Do NOT repeat or summarize it.]`;
+${RAW_OUTPUT_START}
+${rawContent}
+${RAW_OUTPUT_END}`;
+    output += `
+
+[The above raw output (${rawContent.length} chars) will be passed directly to the final response. Do NOT repeat, summarize, or modify it.]`;
   }
   return output;
 }
@@ -59061,7 +59225,7 @@ Example:
 <clearOutputBuffer>true</clearOutputBuffer>
 </cleanup_execute_plan>`;
 }
-var import_ai4;
+var import_ai4, RAW_OUTPUT_START, RAW_OUTPUT_END;
 var init_executePlan = __esm({
   "src/tools/executePlan.js"() {
     "use strict";
@@ -59073,6 +59237,8 @@ var init_executePlan = __esm({
     init_extract();
     init_delegate();
     init_esm5();
+    RAW_OUTPUT_START = "<<<RAW_OUTPUT>>>";
+    RAW_OUTPUT_END = "<<<END_RAW_OUTPUT>>>";
   }
 });
 
@@ -97220,7 +97386,7 @@ __export(schemaUtils_exports, {
   createJsonCorrectionPrompt: () => createJsonCorrectionPrompt,
   createMermaidCorrectionPrompt: () => createMermaidCorrectionPrompt,
   createSchemaDefinitionCorrectionPrompt: () => createSchemaDefinitionCorrectionPrompt,
-  decodeHtmlEntities: () => decodeHtmlEntities,
+  decodeHtmlEntities: () => decodeHtmlEntities2,
   extractMermaidFromJson: () => extractMermaidFromJson,
   extractMermaidFromMarkdown: () => extractMermaidFromMarkdown,
   generateExampleFromSchema: () => generateExampleFromSchema,
@@ -97325,7 +97491,7 @@ function enforceNoAdditionalProperties(schema) {
   applyRecursively(cloned);
   return cloned;
 }
-function decodeHtmlEntities(text) {
+function decodeHtmlEntities2(text) {
   if (!text || typeof text !== "string") {
     return text;
   }
@@ -98768,7 +98934,7 @@ When presented with a broken Mermaid diagram, analyze it thoroughly and provide
        * @returns {Promise<string>} - The corrected Mermaid diagram
        */
       async fixMermaidDiagram(diagramContent, originalErrors = [], diagramInfo = {}) {
-        const decodedContent = decodeHtmlEntities(diagramContent);
+        const decodedContent = decodeHtmlEntities2(diagramContent);
         if (decodedContent !== diagramContent) {
           try {
             const quickValidation = await validateMermaidDiagram(decodedContent);
@@ -110083,6 +110249,7 @@ var init_ProbeAgent = __esm({
     init_path_validation();
     init_outputTruncator();
     init_delegate();
+    init_executePlan();
     init_tasks();
     import_dotenv2.default.config();
     ENGINE_ACTIVITY_TIMEOUT_DEFAULT = 18e4;
@@ -112814,6 +112981,15 @@ You are working with a workspace. Available paths: ${workspaceDesc}
                     }
                     const executionResult = await this.mcpBridge.mcpTools[toolName].execute(params);
                     let toolResultContent = typeof executionResult === "string" ? executionResult : JSON.stringify(executionResult, null, 2);
+                    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, b5) => sum + b5.length, 0)} chars) to output buffer`);
+                        }
+                      }
+                    }
                     try {
                       const truncateResult = await truncateIfNeeded(toolResultContent, this.tokenCounter, this.sessionId, this.maxOutputTokens);
                       if (truncateResult.truncated) {
@@ -113020,6 +113196,15 @@ ${errorXml}
                       const wsPrefix = this.workspaceRoot.endsWith(import_path17.sep) ? this.workspaceRoot : this.workspaceRoot + import_path17.sep;
                       toolResultContent = toolResultContent.split(wsPrefix).join("");
                     }
+                    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, b5) => sum + b5.length, 0)} chars) to output buffer`);
+                        }
+                      }
+                    }
                     try {
                       const truncateResult = await truncateIfNeeded(toolResultContent, this.tokenCounter, this.sessionId, this.maxOutputTokens);
                       if (truncateResult.truncated) {