@probelabs/probe 0.6.0-rc100

package/build/agent/mcp/xmlBridge.js

@@ -0,0 +1,371 @@
+/**
+ * XML-to-MCP Bridge
+ * Allows using MCP tools with XML-like syntax while maintaining JSON parameters
+ */
+
+import { MCPClientManager } from './client.js';
+import { loadMCPConfiguration } from './config.js';
+
+/**
+ * Convert MCP tool to XML definition format
+ * @param {string} name - Tool name
+ * @param {Object} tool - MCP tool object
+ * @returns {string} XML-formatted tool definition
+ */
+export function mcpToolToXmlDefinition(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):';
+    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] = paramValue.trim();
+      }
+    }
+
+    return { toolName, params };
+  }
+
+  return null;
+}
+
+/**
+ * MCP Tool Manager that bridges XML and MCP
+ */
+export class MCPXmlBridge {
+  constructor(options = {}) {
+    this.debug = options.debug || false;
+    this.mcpTools = {};
+    this.mcpManager = null;
+    this.xmlDefinitions = {};
+  }
+
+  /**
+   * Initialize MCP connections and load tools
+   * @param {Object|Array<Object>} config - MCP configuration object or server configurations (deprecated)
+   */
+  async initialize(config = null) {
+    let mcpConfigs = null;
+
+    if (!config) {
+      // No config provided - fall back to auto-discovery for backward compatibility
+      mcpConfigs = loadMCPConfiguration();
+    } else if (Array.isArray(config)) {
+      // Deprecated: Array of server configs (backward compatibility)
+      mcpConfigs = { mcpServers: config };
+    } else {
+      // New: Full config object provided directly
+      mcpConfigs = config;
+    }
+
+    if (!mcpConfigs || !mcpConfigs.mcpServers || Object.keys(mcpConfigs.mcpServers).length === 0) {
+      if (this.debug) {
+        console.error('[MCP] No MCP servers configured');
+      }
+      return;
+    }
+
+    try {
+      // Initialize the MCP client manager
+      this.mcpManager = new MCPClientManager({ debug: this.debug });
+      const result = await this.mcpManager.initialize(mcpConfigs);
+
+      // Get tools from the manager
+      const vercelTools = this.mcpManager.getVercelTools();
+      this.mcpTools = vercelTools;
+
+      // Generate XML definitions for all tools
+      for (const [name, tool] of Object.entries(vercelTools)) {
+        this.xmlDefinitions[name] = mcpToolToXmlDefinition(name, tool);
+      }
+
+      if (this.debug) {
+        console.error(`[MCP] Loaded ${Object.keys(vercelTools).length} MCP tools from ${result.connected} server(s)`);
+      }
+    } catch (error) {
+      console.error('[MCP] Failed to initialize MCP connections:', error);
+    }
+  }
+
+  /**
+   * Get all XML tool definitions for inclusion in system prompt
+   * @returns {string} Combined XML tool definitions
+   */
+  getXmlToolDefinitions() {
+    return Object.values(this.xmlDefinitions).join('\n\n');
+  }
+
+  /**
+   * Get list of MCP tool names
+   * @returns {Array<string>} Tool names
+   */
+  getToolNames() {
+    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) {
+      throw new Error('No valid MCP tool call found in XML');
+    }
+
+    const { toolName, params } = parsed;
+
+    if (this.debug) {
+      console.error(`[MCP] Executing MCP tool: ${toolName} with params:`, params);
+    }
+
+    const tool = this.mcpTools[toolName];
+    if (!tool) {
+      throw new Error(`Unknown MCP tool: ${toolName}`);
+    }
+
+    try {
+      const result = await tool.execute(params);
+      return {
+        success: true,
+        toolName,
+        result
+      };
+    } catch (error) {
+      return {
+        success: false,
+        toolName,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Check if a tool call is an MCP tool
+   * @param {string} toolName - Tool name to check
+   * @returns {boolean} True if it's an MCP tool
+   */
+  isMcpTool(toolName) {
+    return toolName in this.mcpTools;
+  }
+
+  /**
+   * Clean up MCP connections
+   */
+  async cleanup() {
+    if (this.mcpManager) {
+      await this.mcpManager.disconnect();
+    }
+  }
+}
+
+/**
+ * Enhanced XML parser that handles both native and MCP tools
+ * @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 standard XML parsing
+  for (const toolName of nativeTools) {
+    const nativeResult = parseNativeXmlTool(xmlString, toolName);
+    if (nativeResult) {
+      return { ...nativeResult, type: 'native' };
+    }
+  }
+
+  // Then try MCP tools if bridge is available
+  if (mcpBridge) {
+    const mcpResult = parseXmlMcpToolCall(xmlString, mcpBridge.getToolNames());
+    if (mcpResult) {
+      return { ...mcpResult, type: 'mcp' };
+    }
+  }
+
+  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] = 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;

package/build/agent/mockProvider.js

@@ -0,0 +1,53 @@
+/**
+ * Mock AI provider for testing purposes
+ * This provider simulates AI responses without making actual API calls
+ */
+
+export function createMockProvider() {
+  return {
+    languageModel: (modelName) => ({
+      modelId: `mock-${modelName}`,
+      provider: 'mock',
+
+      // Mock the doGenerate method used by Vercel AI SDK
+      doGenerate: async ({ messages, tools }) => {
+        // Simulate processing time
+        await new Promise(resolve => setTimeout(resolve, 10));
+
+        // Return a mock response
+        return {
+          text: 'This is a mock response for testing',
+          toolCalls: [],
+          usage: {
+            promptTokens: 10,
+            completionTokens: 5,
+            totalTokens: 15
+          }
+        };
+      },
+
+      // Mock the doStream method for streaming responses
+      doStream: async function* ({ messages, tools }) {
+        // Simulate streaming response
+        yield {
+          type: 'text-delta',
+          textDelta: 'Mock streaming response'
+        };
+
+        yield {
+          type: 'finish',
+          usage: {
+            promptTokens: 10,
+            completionTokens: 5,
+            totalTokens: 15
+          }
+        };
+      }
+    })
+  };
+}
+
+export function createMockModel(modelName = 'mock-model') {
+  const provider = createMockProvider();
+  return provider.languageModel(modelName);
+}

package/build/agent/probeTool.js

@@ -0,0 +1,257 @@
+// Simplified tool wrapper for probe agent (based on examples/chat/probeTool.js)
+import { listFilesByLevel } from '../index.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { randomUUID } from 'crypto';
+import { EventEmitter } from 'events';
+import fs from 'fs';
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+import { glob } from 'glob';
+
+// Create an event emitter for tool calls (simplified for single-shot operations)
+export const toolCallEmitter = new EventEmitter();
+
+// Map to track active tool executions by session ID
+const activeToolExecutions = new Map();
+
+// Function to check if a session has been cancelled
+export function isSessionCancelled(sessionId) {
+  return activeToolExecutions.get(sessionId)?.cancelled || false;
+}
+
+// Function to cancel all tool executions for a session
+export function cancelToolExecutions(sessionId) {
+  if (process.env.DEBUG === '1') {
+    console.log(`Cancelling tool executions for session: ${sessionId}`);
+  }
+  const sessionData = activeToolExecutions.get(sessionId);
+  if (sessionData) {
+    sessionData.cancelled = true;
+    return true;
+  }
+  return false;
+}
+
+// Function to register a new tool execution
+function registerToolExecution(sessionId) {
+  if (!sessionId) return;
+
+  if (!activeToolExecutions.has(sessionId)) {
+    activeToolExecutions.set(sessionId, { cancelled: false });
+  } else {
+    // Reset cancelled flag if session already exists for a new execution
+    activeToolExecutions.get(sessionId).cancelled = false;
+  }
+}
+
+// Function to clear tool execution data for a session
+export function clearToolExecutionData(sessionId) {
+  if (!sessionId) return;
+
+  if (activeToolExecutions.has(sessionId)) {
+    activeToolExecutions.delete(sessionId);
+    if (process.env.DEBUG === '1') {
+      console.log(`Cleared tool execution data for session: ${sessionId}`);
+    }
+  }
+}
+
+// Wrap the tools to emit events and handle cancellation
+const wrapToolWithEmitter = (tool, toolName, baseExecute) => {
+  return {
+    ...tool, // Spread schema, description etc.
+    execute: async (params) => { // The execute function now receives parsed params
+      const debug = process.env.DEBUG === '1';
+      // Get the session ID from params (passed down from ProbeAgent)
+      const toolSessionId = params.sessionId || randomUUID();
+
+      if (debug) {
+        console.log(`[DEBUG] probeTool: Executing ${toolName} for session ${toolSessionId}`);
+      }
+
+      registerToolExecution(toolSessionId);
+
+      let executionError = null;
+      let result = null;
+
+      try {
+        // Emit the tool call start event
+        const toolCallStartData = {
+          timestamp: new Date().toISOString(),
+          name: toolName,
+          args: params,
+          status: 'started'
+        };
+
+        if (debug) {
+          console.log(`[DEBUG] probeTool: Emitting toolCallStart:${toolSessionId}`);
+        }
+        toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallStartData);
+
+        // Check for cancellation before execution
+        if (isSessionCancelled(toolSessionId)) {
+          if (debug) {
+            console.log(`Tool execution cancelled before start for ${toolSessionId}`);
+          }
+          throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+        }
+
+        // Execute the base function
+        result = await baseExecute(params);
+
+        // Check for cancellation after execution
+        if (isSessionCancelled(toolSessionId)) {
+          if (debug) {
+            console.log(`Tool execution cancelled after completion for ${toolSessionId}`);
+          }
+          throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+        }
+
+      } catch (error) {
+        executionError = error;
+        if (debug) {
+          console.error(`[DEBUG] probeTool: Error in ${toolName}:`, error);
+        }
+      }
+
+      // Handle execution results and emit appropriate events
+      if (executionError) {
+        const toolCallErrorData = {
+          timestamp: new Date().toISOString(),
+          name: toolName,
+          args: params,
+          error: executionError.message || 'Unknown error',
+          status: 'error'
+        };
+        if (debug) {
+          console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (error)`);
+        }
+        toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallErrorData);
+
+        throw executionError;
+      } else {
+        // If loop exited due to cancellation within the loop
+        if (isSessionCancelled(toolSessionId)) {
+          if (process.env.DEBUG === '1') {
+            console.log(`Tool execution finished but session was cancelled for ${toolSessionId}`);
+          }
+          throw new Error(`Tool execution cancelled for session ${toolSessionId}`);
+        }
+
+        // Emit the tool call completion event
+        const toolCallData = {
+          timestamp: new Date().toISOString(),
+          name: toolName,
+          args: params,
+          // Safely preview result
+          resultPreview: typeof result === 'string'
+            ? (result.length > 200 ? result.substring(0, 200) + '...' : result)
+            : (result ? JSON.stringify(result).substring(0, 200) + '...' : 'No Result'),
+          status: 'completed'
+        };
+        if (debug) {
+          console.log(`[DEBUG] probeTool: Emitting toolCall:${toolSessionId} (completed)`);
+        }
+        toolCallEmitter.emit(`toolCall:${toolSessionId}`, toolCallData);
+
+        return result;
+      }
+    }
+  };
+};
+
+// Create wrapped tool instances - these will be created by the ProbeAgent
+export function createWrappedTools(baseTools) {
+  const wrappedTools = {};
+
+  // Wrap search tool
+  if (baseTools.searchTool) {
+    wrappedTools.searchToolInstance = wrapToolWithEmitter(
+      baseTools.searchTool, 
+      'search', 
+      baseTools.searchTool.execute
+    );
+  }
+
+  // Wrap query tool
+  if (baseTools.queryTool) {
+    wrappedTools.queryToolInstance = wrapToolWithEmitter(
+      baseTools.queryTool, 
+      'query', 
+      baseTools.queryTool.execute
+    );
+  }
+
+  // Wrap extract tool
+  if (baseTools.extractTool) {
+    wrappedTools.extractToolInstance = wrapToolWithEmitter(
+      baseTools.extractTool, 
+      'extract', 
+      baseTools.extractTool.execute
+    );
+  }
+
+  // Wrap delegate tool
+  if (baseTools.delegateTool) {
+    wrappedTools.delegateToolInstance = wrapToolWithEmitter(
+      baseTools.delegateTool, 
+      'delegate', 
+      baseTools.delegateTool.execute
+    );
+  }
+
+  return wrappedTools;
+}
+
+// Simple file listing tool
+export const listFilesTool = {
+  execute: async (params) => {
+    const { directory = '.' } = params;
+    
+    try {
+      const files = await listFilesByLevel({
+        directory,
+        maxFiles: 100,
+        respectGitignore: !process.env.PROBE_NO_GITIGNORE || process.env.PROBE_NO_GITIGNORE === '',
+        cwd: process.cwd()
+      });
+      
+      return files;
+    } catch (error) {
+      throw new Error(`Failed to list files: ${error.message}`);
+    }
+  }
+};
+
+// Simple file search tool
+export const searchFilesTool = {
+  execute: async (params) => {
+    const { pattern, directory = '.', recursive = true } = params;
+    
+    if (!pattern) {
+      throw new Error('Pattern is required for file search');
+    }
+    
+    try {
+      const options = {
+        cwd: directory,
+        ignore: ['node_modules/**', '.git/**'],
+        absolute: false
+      };
+      
+      if (!recursive) {
+        options.deep = 1;
+      }
+      
+      const files = await glob(pattern, options);
+      return files;
+    } catch (error) {
+      throw new Error(`Failed to search files: ${error.message}`);
+    }
+  }
+};
+
+// Wrap the additional tools
+export const listFilesToolInstance = wrapToolWithEmitter(listFilesTool, 'listFiles', listFilesTool.execute);
+export const searchFilesToolInstance = wrapToolWithEmitter(searchFilesTool, 'searchFiles', searchFilesTool.execute);