@probelabs/probe 0.6.0-rc264 → 0.6.0-rc266

package/build/agent/mcp/index.js

@@ -3,7 +3,7 @@
  *
  * This module provides:
  * - MCP client management for connecting to MCP servers
- * - XML/JSON hybrid tool interface
+ * - Native Vercel AI SDK tool interface
  * - Configuration management
  */
 
@@ -18,10 +18,7 @@ export {
 } from './config.js';
 export {
   MCPXmlBridge,
-  mcpToolToXmlDefinition,
-  parseXmlMcpToolCall,
-  parseHybridXmlToolCall,
-  createHybridSystemMessage
+  mcpToolToDescription
 } from './xmlBridge.js';
 
 // Import for default export
@@ -35,10 +32,7 @@ import {
 } from './config.js';
 import {
   MCPXmlBridge,
-  mcpToolToXmlDefinition,
-  parseXmlMcpToolCall,
-  parseHybridXmlToolCall,
-  createHybridSystemMessage
+  mcpToolToDescription
 } from './xmlBridge.js';
 
 // Default export for convenience
@@ -55,10 +49,7 @@ export default {
   createSampleConfig,
   saveConfig,
 
-  // XML Bridge
+  // MCP Bridge
   MCPXmlBridge,
-  mcpToolToXmlDefinition,
-  parseXmlMcpToolCall,
-  parseHybridXmlToolCall,
-  createHybridSystemMessage
-};
+  mcpToolToDescription
+};

package/build/agent/mcp/xmlBridge.js

@@ -1,129 +1,36 @@
 /**
- * XML-to-MCP Bridge
- * Allows using MCP tools with XML-like syntax while maintaining JSON parameters
+ * MCP Bridge - manages MCP tool connections and provides Vercel-compatible tools
  */
 
 import { MCPClientManager } from './client.js';
 import { loadMCPConfiguration } from './config.js';
-import { processXmlWithThinkingAndRecovery } from '../xmlParsingUtils.js';
-import { unescapeXmlEntities } from '../../tools/common.js';
 
 /**
- * Convert MCP tool to XML definition format
+ * Convert MCP tool to description string (for debug logging)
  * @param {string} name - Tool name
  * @param {Object} tool - MCP tool object
- * @returns {string} XML-formatted tool definition
+ * @returns {string} Description of the tool
  */
-export function mcpToolToXmlDefinition(name, tool) {
+export function mcpToolToDescription(name, tool) {
   const description = tool.description || 'MCP tool';
   const inputSchema = tool.inputSchema || tool.parameters || {};
 
-  // Build parameter documentation
   let paramDocs = '';
   if (inputSchema.properties) {
-    paramDocs = '\n\nParameters (provide as JSON object):';
+    paramDocs = '\nParameters:';
     for (const [paramName, paramSchema] of Object.entries(inputSchema.properties)) {
       const required = inputSchema.required?.includes(paramName) ? ' (required)' : ' (optional)';
       const desc = paramSchema.description || '';
       const type = paramSchema.type || 'any';
       paramDocs += `\n- ${paramName}: ${type}${required} - ${desc}`;
-
-      if (paramSchema.enum) {
-        paramDocs += ` [choices: ${paramSchema.enum.join(', ')}]`;
-      }
     }
   }
 
-  return `## ${name}
-Description: ${description}${paramDocs}
-
-Usage:
-<${name}>
-<params>
-{
-  "param1": "value1",
-  "param2": "value2"
-}
-</params>
-</${name}>
-
-Or for simple single parameter:
-<${name}>
-<params>value</params>
-</${name}>`;
-}
-
-/**
- * Parse XML tool call with JSON parameters
- * Handles both JSON object parameters and simple string parameters
- * @param {string} xmlString - XML string containing tool call
- * @param {Array<string>} mcpToolNames - List of available MCP tool names
- * @returns {Object|null} Parsed tool call with name and params
- */
-export function parseXmlMcpToolCall(xmlString, mcpToolNames = []) {
-  // Clean the XML string
-  const cleanedXml = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
-
-  for (const toolName of mcpToolNames) {
-    // Look for the tool in XML format
-    const openTag = `<${toolName}>`;
-    const closeTag = `</${toolName}>`;
-
-    const openIndex = cleanedXml.indexOf(openTag);
-    if (openIndex === -1) continue;
-
-    const closeIndex = cleanedXml.indexOf(closeTag, openIndex);
-    if (closeIndex === -1) continue;
-
-    // Extract content between tags
-    const contentStart = openIndex + openTag.length;
-    const content = cleanedXml.substring(contentStart, closeIndex).trim();
-
-    // Look for params tag
-    const paramsMatch = content.match(/<params>([\s\S]*?)<\/params>/);
-
-    let params = {};
-    if (paramsMatch) {
-      let paramsContent = paramsMatch[1].trim();
-
-      // Handle CDATA sections
-      const cdataMatch = paramsContent.match(/^<!\[CDATA\[([\s\S]*?)\]\]>$/);
-      if (cdataMatch) {
-        paramsContent = cdataMatch[1];
-      }
-
-      // Try to parse as JSON first
-      try {
-        // Handle JSON object
-        if (paramsContent.startsWith('{')) {
-          params = JSON.parse(paramsContent);
-        } else {
-          // Handle simple string parameter
-          // For backwards compatibility with simple XML params
-          params = { value: paramsContent };
-        }
-      } catch (e) {
-        // If JSON parsing fails, treat as simple string
-        params = { value: paramsContent };
-      }
-    } else {
-      // Legacy format: parse individual XML parameters
-      const paramPattern = /<(\w+)>([\s\S]*?)<\/\1>/g;
-      let match;
-      while ((match = paramPattern.exec(content)) !== null) {
-        const [, paramName, paramValue] = match;
-        params[paramName] = unescapeXmlEntities(paramValue.trim());
-      }
-    }
-
-    return { toolName, params };
-  }
-
-  return null;
+  return `## ${name}\nDescription: ${description}${paramDocs}`;
 }
 
 /**
- * MCP Tool Manager that bridges XML and MCP
+ * MCP Bridge - manages MCP connections and provides native Vercel AI SDK tools
  */
 export class MCPXmlBridge {
   constructor(options = {}) {
@@ -131,7 +38,7 @@ export class MCPXmlBridge {
     this.tracer = options.tracer || null;
     this.mcpTools = {};
     this.mcpManager = null;
-    this.xmlDefinitions = {};
+    this.toolDescriptions = {};
   }
 
   /**
@@ -142,13 +49,11 @@ export class MCPXmlBridge {
     let mcpConfigs = null;
 
     if (!config) {
-      // No config provided - fall back to auto-discovery for backward compatibility
       if (this.debug) {
         console.error('[MCP DEBUG] No config provided, attempting auto-discovery...');
       }
       mcpConfigs = loadMCPConfiguration();
 
-      // Check if auto-discovery found anything
       if (!mcpConfigs || !mcpConfigs.mcpServers || Object.keys(mcpConfigs.mcpServers).length === 0) {
         console.error('[MCP WARNING] MCP enabled but no configuration found');
         console.error('[MCP INFO] To use MCP, provide configuration via:');
@@ -158,13 +63,11 @@ export class MCPXmlBridge {
         console.error('[MCP INFO]   - Environment variable MCP_CONFIG_PATH');
       }
     } else if (Array.isArray(config)) {
-      // Deprecated: Array of server configs (backward compatibility)
       if (this.debug) {
         console.error('[MCP DEBUG] Using deprecated array config format (consider using mcpConfig object)');
       }
       mcpConfigs = { mcpServers: config };
     } else {
-      // New: Full config object provided directly
       if (this.debug) {
         console.error('[MCP DEBUG] Using provided MCP config object');
       }
@@ -181,28 +84,23 @@ export class MCPXmlBridge {
         console.error('[MCP DEBUG] Initializing MCP client manager...');
       }
 
-      // Initialize the MCP client manager with tracer support
       this.mcpManager = new MCPClientManager({ debug: this.debug, tracer: this.tracer });
       const result = await this.mcpManager.initialize(mcpConfigs);
 
-      // Get tools from the manager
+      // Get tools from the manager (already in Vercel format)
       const vercelTools = this.mcpManager.getVercelTools();
       this.mcpTools = vercelTools;
       const toolCount = Object.keys(vercelTools).length;
 
-      // Generate XML definitions for all tools
+      // Generate descriptions for debug logging
       for (const [name, tool] of Object.entries(vercelTools)) {
-        this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool);
+        this.toolDescriptions[name] = mcpToolToDescription(name, tool);
       }
 
       if (toolCount === 0) {
         console.error('[MCP INFO] MCP initialization complete: 0 tools loaded');
       } else {
         console.error(`[MCP INFO] MCP initialization complete: ${toolCount} tool${toolCount !== 1 ? 's' : ''} loaded from ${result.connected} server${result.connected !== 1 ? 's' : ''}`);
-
-        if (this.debug) {
-          console.error('[MCP DEBUG] Tool definitions generated for XML bridge');
-        }
       }
     } catch (error) {
       console.error('[MCP ERROR] Failed to initialize MCP connections:', error.message);
@@ -213,20 +111,21 @@ export class MCPXmlBridge {
   }
 
   /**
-   * Get XML tool definitions for inclusion in system prompt
-   * @param {Array<string>|null} filterToolNames - Optional list of tool names to include (if null, include all)
-   * @returns {string} Combined XML tool definitions
+   * Get Vercel AI SDK compatible tools for use with streamText
+   * @param {Array<string>|null} filterToolNames - Optional list of tool names to include
+   * @returns {Object} Map of tool name to Vercel tool object
    */
-  getXmlToolDefinitions(filterToolNames = null) {
+  getVercelTools(filterToolNames = null) {
     if (filterToolNames === null) {
-      return Object.values(this.xmlDefinitions).join('\n\n');
+      return { ...this.mcpTools };
     }
-
-    // Filter definitions based on provided tool names
-    return Object.entries(this.xmlDefinitions)
-      .filter(([name]) => filterToolNames.includes(name))
-      .map(([, def]) => def)
-      .join('\n\n');
+    const filtered = {};
+    for (const name of filterToolNames) {
+      if (this.mcpTools[name]) {
+        filtered[name] = this.mcpTools[name];
+      }
+    }
+    return filtered;
   }
 
   /**
@@ -237,59 +136,6 @@ export class MCPXmlBridge {
     return Object.keys(this.mcpTools);
   }
 
-  /**
-   * Execute an MCP tool from XML call
-   * @param {string} xmlString - XML tool call string
-   * @returns {Promise<Object>} Tool execution result
-   */
-  async executeFromXml(xmlString) {
-    const parsed = parseXmlMcpToolCall(xmlString, this.getToolNames());
-
-    if (!parsed) {
-      console.error('[MCP ERROR] No valid MCP tool call found in XML');
-      throw new Error('No valid MCP tool call found in XML');
-    }
-
-    const { toolName, params } = parsed;
-
-    if (this.debug) {
-      console.error(`[MCP DEBUG] Executing MCP tool: ${toolName}`);
-      console.error(`[MCP DEBUG] Parameters:`, JSON.stringify(params, null, 2));
-    }
-
-    const tool = this.mcpTools[toolName];
-    if (!tool) {
-      console.error(`[MCP ERROR] Unknown MCP tool: ${toolName}`);
-      console.error(`[MCP ERROR] Available tools: ${this.getToolNames().join(', ')}`);
-      throw new Error(`Unknown MCP tool: ${toolName}`);
-    }
-
-    try {
-      const result = await tool.execute(params);
-
-      if (this.debug) {
-        console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
-      }
-
-      return {
-        success: true,
-        toolName,
-        result
-      };
-    } catch (error) {
-      console.error(`[MCP ERROR] Tool ${toolName} execution failed:`, error.message);
-      if (this.debug) {
-        console.error(`[MCP DEBUG] Full error details:`, error);
-      }
-
-      return {
-        success: false,
-        toolName,
-        error: error.message
-      };
-    }
-  }
-
   /**
    * Check if a tool call is an MCP tool
    * @param {string} toolName - Tool name to check
@@ -309,150 +155,4 @@ export class MCPXmlBridge {
   }
 }
 
-/**
- * Enhanced XML parser that handles both native and MCP tools
- * Uses the exact same logic as CLI/SDK mode to ensure consistency
- * @param {string} xmlString - XML string to parse
- * @param {Array<string>} nativeTools - List of native tool names
- * @param {MCPXmlBridge} mcpBridge - MCP bridge instance
- * @returns {Object|null} Parsed tool call
- */
-export function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge = null) {
-  // First try native tools with the same logic as CLI/SDK mode
-  // This includes thinking tag removal and attempt_complete recovery logic
-  const nativeResult = parseNativeXmlToolWithThinking(xmlString, nativeTools);
-  if (nativeResult) {
-    const { thinkingContent, ...rest } = nativeResult;
-    return { ...rest, type: 'native', thinkingContent };
-  }
-
-  // Then try MCP tools if bridge is available
-  if (mcpBridge) {
-    const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
-    if (mcpResult) {
-      // Extract thinking content for MCP tools as well
-      const { thinkingContent } = processXmlWithThinkingAndRecovery(xmlString, []);
-      return { ...mcpResult, type: 'mcp', thinkingContent };
-    }
-  }
-
-  return null;
-}
-
-/**
- * Parse native XML tools using the same logic as CLI/SDK mode
- * Now uses shared utilities instead of duplicating code
- * @param {string} xmlString - XML string to parse
- * @param {Array<string>} validTools - List of valid tool names
- * @returns {Object|null} Parsed tool call
- */
-function parseNativeXmlToolWithThinking(xmlString, validTools) {
-  // Use the shared processing logic
-  const { cleanedXmlString, recoveryResult, thinkingContent } = processXmlWithThinkingAndRecovery(xmlString, validTools);
-
-  // If recovery found an attempt_complete pattern, return it with thinking content
-  if (recoveryResult) {
-    return { ...recoveryResult, thinkingContent };
-  }
-
-  // Use the original parseNativeXmlTool function to parse the cleaned XML string
-  for (const toolName of validTools) {
-    const result = parseNativeXmlTool(cleanedXmlString, toolName);
-    if (result) {
-      return { ...result, thinkingContent };
-    }
-  }
-
-  return null;
-}
-
-/**
- * Parse native XML tool (existing format)
- * @param {string} xmlString - XML string
- * @param {string} toolName - Tool name to look for
- * @returns {Object|null} Parsed tool call
- */
-function parseNativeXmlTool(xmlString, toolName) {
-  const openTag = `<${toolName}>`;
-  const closeTag = `</${toolName}>`;
-
-  const openIndex = xmlString.indexOf(openTag);
-  if (openIndex === -1) return null;
-
-  const closeIndex = xmlString.indexOf(closeTag, openIndex);
-  if (closeIndex === -1) return null;
-
-  const contentStart = openIndex + openTag.length;
-  const content = xmlString.substring(contentStart, closeIndex).trim();
-
-  // Parse individual XML parameters (native format)
-  const params = {};
-  const paramPattern = /<(\w+)>([\s\S]*?)<\/\1>/g;
-  let match;
-
-  while ((match = paramPattern.exec(content)) !== null) {
-    const [, paramName, paramValue] = match;
-    // Skip if this is the params tag itself (MCP format)
-    if (paramName !== 'params') {
-      params[paramName] = unescapeXmlEntities(paramValue.trim());
-    }
-  }
-
-  // Only return if we found actual parameters (not MCP format)
-  if (Object.keys(params).length > 0) {
-    return { toolName, params };
-  }
-
-  return null;
-}
-
-/**
- * Create a combined system message with both native and MCP tools
- * @param {string} baseSystemMessage - Base system message
- * @param {string} nativeToolDefinitions - Native tool definitions in XML format
- * @param {MCPXmlBridge} mcpBridge - MCP bridge with loaded tools
- * @returns {string} Combined system message
- */
-export function createHybridSystemMessage(baseSystemMessage, nativeToolDefinitions, mcpBridge) {
-  let message = baseSystemMessage;
-
-  // Add native tools section
-  if (nativeToolDefinitions) {
-    message += '\n\n=== NATIVE TOOLS ===\n';
-    message += 'These tools use standard XML parameter format:\n\n';
-    message += nativeToolDefinitions;
-  }
-
-  // Add MCP tools section if available
-  if (mcpBridge && mcpBridge.getToolNames().length > 0) {
-    message += '\n\n=== MCP TOOLS ===\n';
-    message += 'These tools use JSON parameters within the params tag:\n\n';
-    message += mcpBridge.getXmlToolDefinitions();
-  }
-
-  // Add usage instructions
-  message += '\n\n=== TOOL USAGE INSTRUCTIONS ===\n';
-  message += `
-For NATIVE tools, use standard XML format:
-<search>
-<query>authentication</query>
-<path>./src</path>
-</search>
-
-For MCP tools, use JSON within params tag:
-<mcp_tool_name>
-<params>
-{
-  "param1": "value1",
-  "param2": 123
-}
-</params>
-</mcp_tool_name>
-
-IMPORTANT: Always check the tool definition to determine whether it's a native tool (XML params) or MCP tool (JSON params).
-`;
-
-  return message;
-}
-
-export default MCPXmlBridge;
+export default MCPXmlBridge;

package/build/agent/shared/prompts.js

@@ -87,6 +87,7 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 - Avoid implementing special cases when a general approach works
 - Never expose secrets, API keys, or credentials in generated code. Never log sensitive information.
 - Do not surprise the user with unrequested changes. Do what was asked, including reasonable follow-up actions, but do not refactor surrounding code or add features that were not requested.
+- When editing files, keep edits focused and minimal. For changes spanning more than a few lines, prefer line-targeted editing (start_line/end_line) over text replacement (old_string) — it constrains scope and prevents accidental removal of adjacent content. Never include unrelated sections in an edit operation.
 - After every significant change, verify the project still builds and passes linting. Do not wait until the end to discover breakage.
 
 # After Implementation
@@ -97,11 +98,33 @@ If the solution is clear, you can jump to implementation right away. If not, ask
 
 # GitHub Integration
 - Use the \`gh\` CLI for all GitHub operations: issues, pull requests, checks, releases.
-- To create a pull request: commit your changes, push the branch, then use \`gh pr create --title "..." --body "..."\`.
 - To view issues or PRs: \`gh issue view <number>\`, \`gh pr view <number>\`.
 - If given a GitHub URL, use \`gh\` to fetch the relevant information rather than guessing.
 - Always return the pull request URL to the user after creating one.
-- When checking GitHub Actions, only read logs of failed jobs — do not waste time on successful ones. Use \`gh run view <run-id> --log-failed\` to fetch only the relevant output.`,
+- When checking GitHub Actions, only read logs of failed jobs — do not waste time on successful ones. Use \`gh run view <run-id> --log-failed\` to fetch only the relevant output.
+
+# Pull Request Creation
+- Commit your changes, push the branch, then use \`gh pr create --title "..." --body "..."\`.
+- **PR title**: Keep it short (under 72 characters). Use imperative mood describing the change (e.g. "Add retry logic for API calls", "Fix race condition in cache invalidation"). Prefix with the type of change when useful: \`fix:\`, \`feat:\`, \`refactor:\`, \`docs:\`, \`test:\`, \`chore:\`.
+- **PR body**: MUST follow this structure:
+
+\`\`\`
+## Problem / Task
+<What problem is being solved or what task was requested. If there is a linked issue, reference it with #number. Be specific about the root cause or motivation.>
+
+## Changes
+<Concise list of what was actually changed. Describe each meaningful change — files modified, logic added/removed, and why. Do NOT just list filenames; explain what each change does.>
+
+## Testing
+<What tests were added, modified, or run. Include:
+- New test names and what they verify
+- Whether existing tests still pass
+- Manual verification steps if applicable
+- Commands used to validate (e.g. \`make test\`, \`npm test\`)>
+\`\`\`
+
+- If the task originated from a GitHub issue, always reference it in the PR body (e.g. "Fixes #123" or "Closes #123") so the issue is automatically closed on merge. If it originated from an external ticket system (Jira, Linear, etc.), include the ticket ID and link in the Problem / Task section (e.g. "Resolves PROJ-456").
+- Do not leave the PR body empty or vague. Every PR must clearly communicate what was done and why so reviewers can understand the change without reading every line of diff.`,
 
   'support': `You are ProbeChat Support, a specialized AI assistant focused on helping developers troubleshoot issues and solve problems. Your primary function is to help users diagnose errors, understand unexpected behaviors, and find solutions using the provided code analysis tools.
 

package/build/agent/tasks/index.js

@@ -6,7 +6,6 @@
 export { TaskManager, default as TaskManagerDefault } from './TaskManager.js';
 export {
   taskSchema,
-  taskToolDefinition,
   taskSystemPrompt,
   taskGuidancePrompt,
   createTaskCompletionBlockedMessage,