@probelabs/probe 0.6.0-rc265 → 0.6.0-rc267

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/tasks/index.js

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