@probelabs/probe 0.6.0-rc104 → 0.6.0-rc106

package/build/agent/mcp/xmlBridge.js

@@ -5,6 +5,7 @@
 
 import { MCPClientManager } from './client.js';
 import { loadMCPConfiguration } from './config.js';
+import { processXmlWithThinkingAndRecovery } from '../xmlParsingUtils.js';
 
 /**
  * Convert MCP tool to XML definition format
@@ -254,18 +255,18 @@ 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 standard XML parsing
-  for (const toolName of nativeTools) {
-    const nativeResult = parseNativeXmlTool(xmlString, toolName);
-    if (nativeResult) {
-      return { ...nativeResult, type: 'native' };
-    }
+  // 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) {
+    return { ...nativeResult, type: 'native' };
   }
 
   // Then try MCP tools if bridge is available
@@ -279,6 +280,33 @@ export function parseHybridXmlToolCall(xmlString, nativeTools = [], mcpBridge =
   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 } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  
+  // If recovery found an attempt_complete pattern, return it
+  if (recoveryResult) {
+    return recoveryResult;
+  }
+
+  // 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;
+    }
+  }
+
+  return null;
+}
+
 /**
  * Parse native XML tool (existing format)
  * @param {string} xmlString - XML string

package/build/agent/probeTool.js

@@ -201,6 +201,15 @@ export function createWrappedTools(baseTools) {
     );
   }
 
+  // Wrap bash tool
+  if (baseTools.bashTool) {
+    wrappedTools.bashToolInstance = wrapToolWithEmitter(
+      baseTools.bashTool, 
+      'bash', 
+      baseTools.bashTool.execute
+    );
+  }
+
   return wrappedTools;
 }
 

package/build/agent/schemaUtils.js

@@ -1191,8 +1191,13 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
             // Check if content needs quoting (contains problematic patterns)
             if (needsQuoting(content)) {
               wasFixed = true;
-              // Replace internal double quotes with single quotes to avoid nesting
-              const safeContent = content.replace(/"/g, "'");
+              // Use HTML entities for quotes as per Mermaid best practices:
+              // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+              // - HTML entities are the official way to escape quotes in Mermaid
+              // - Always use double quotes with square brackets ["..."] for node labels
+              const safeContent = content
+                .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                .replace(/'/g, ''');  // Replace single quotes with HTML entity
               return `["${safeContent}"]`;
             }
             
@@ -1211,8 +1216,13 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
             // Check if content needs quoting (contains problematic patterns)
             if (needsQuoting(content)) {
               wasFixed = true;
-              // Replace internal double quotes with single quotes to avoid nesting
-              const safeContent = content.replace(/"/g, "'");
+              // Use HTML entities for quotes as per Mermaid best practices:
+              // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+              // - HTML entities are the official way to escape quotes in Mermaid
+              // - Always use double quotes with curly brackets {"..."} for diamond nodes
+              const safeContent = content
+                .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                .replace(/'/g, ''');  // Replace single quotes with HTML entity
               return `{"${safeContent}"}`;
             }
             
@@ -1446,8 +1456,13 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
               // Check if content needs quoting (contains problematic patterns)
               if (needsQuoting(content)) {
                 wasFixed = true;
-                // Replace internal double quotes with single quotes to avoid nesting
-                const safeContent = content.replace(/"/g, "'");
+                // Use HTML entities for quotes as per Mermaid best practices:
+                // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+                // - HTML entities are the official way to escape quotes in Mermaid
+                // - Always use double quotes with square brackets ["..."] for node labels
+                const safeContent = content
+                  .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                  .replace(/'/g, ''');  // Replace single quotes with HTML entity
                 return `["${safeContent}"]`;
               }
               
@@ -1466,8 +1481,13 @@ export async function validateAndFixMermaidResponse(response, options = {}) {
               // Check if content needs quoting (contains problematic patterns)
               if (needsQuoting(content)) {
                 wasFixed = true;
-                // Replace internal double quotes with single quotes to avoid nesting
-                const safeContent = content.replace(/"/g, "'");
+                // Use HTML entities for quotes as per Mermaid best practices:
+                // - GitHub doesn't support single quotes in node labels (causes 'got PS' error)
+                // - HTML entities are the official way to escape quotes in Mermaid
+                // - Always use double quotes with curly brackets {"..."} for diamond nodes
+                const safeContent = content
+                  .replace(/"/g, '"')  // Replace double quotes with HTML entity
+                  .replace(/'/g, ''');  // Replace single quotes with HTML entity
                 return `{"${safeContent}"}`;
               }
               

package/build/agent/tools.js

@@ -4,6 +4,7 @@ import {
   queryTool,
   extractTool,
   delegateTool,
+  bashTool,
   DEFAULT_SYSTEM_MESSAGE,
   attemptCompletionSchema,
   attemptCompletionToolDefinition,
@@ -11,22 +12,32 @@ import {
   querySchema,
   extractSchema,
   delegateSchema,
+  bashSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
   delegateToolDefinition,
+  bashToolDefinition,
   parseXmlToolCall
 } from '../index.js';
 import { randomUUID } from 'crypto';
+import { processXmlWithThinkingAndRecovery } from './xmlParsingUtils.js';
 
 // Create configured tool instances
 export function createTools(configOptions) {
-  return {
+  const tools = {
     searchTool: searchTool(configOptions),
     queryTool: queryTool(configOptions),
     extractTool: extractTool(configOptions),
     delegateTool: delegateTool(configOptions)
   };
+
+  // Add bash tool if enabled
+  if (configOptions.enableBash) {
+    tools.bashTool = bashTool(configOptions);
+  }
+
+  return tools;
 }
 
 // Export tool definitions and schemas
@@ -36,11 +47,13 @@ export {
   querySchema,
   extractSchema,
   delegateSchema,
+  bashSchema,
   attemptCompletionSchema,
   searchToolDefinition,
   queryToolDefinition,
   extractToolDefinition,
   delegateToolDefinition,
+  bashToolDefinition,
   attemptCompletionToolDefinition,
   parseXmlToolCall
 };
@@ -134,82 +147,15 @@ User: Find all markdown files in the docs directory, but only at the top level.
  * @returns {Object|null} - The parsed tool call or null if no valid tool call found
  */
 export function parseXmlToolCallWithThinking(xmlString, validTools) {
-  // Extract thinking content if present (for potential logging or analysis)
-  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
-  const thinkingContent = thinkingMatch ? thinkingMatch[1].trim() : null;
-
-  // Remove thinking tags and their content from the XML string
-  let cleanedXmlString = xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
-
-  // Enhanced recovery logic for attempt_complete shorthand
-  // Check for various forms of attempt_complete tags:
-  // 1. Perfect shorthand: <attempt_complete>
-  // 2. Self-closing: <attempt_complete/>  
-  // 3. Empty with closing tag: <attempt_complete></attempt_complete>
-  // 4. Incomplete: <attempt_complete (missing closing bracket)
-  // 5. With trailing content that should be ignored
-  const attemptCompletePatterns = [
-    // Standard shorthand with optional whitespace
-    /^<attempt_complete>\s*$/,
-    // Empty with proper closing tag (common case from the logs)
-    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
-    // Self-closing variant
-    /^<attempt_complete\s*\/>\s*$/,
-    // Incomplete opening tag (missing closing bracket)
-    /^<attempt_complete\s*$/,
-    // With trailing content (extract just the tag part) - must come after empty tag pattern
-    /^<attempt_complete>(.*)$/s,
-    // Self-closing with trailing content
-    /^<attempt_complete\s*\/>(.*)$/s
-  ];
-
-  for (const pattern of attemptCompletePatterns) {
-    const match = cleanedXmlString.match(pattern);
-    if (match) {
-      // Convert any form of attempt_complete to the standard format
-      return {
-        toolName: 'attempt_completion',
-        params: { result: '__PREVIOUS_RESPONSE__' }
-      };
-    }
-  }
-
-  // Additional recovery: check if the string contains attempt_complete anywhere
-  // and treat the entire response as a completion signal if no other tool tags are found
-  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
-    // This handles malformed cases where attempt_complete appears but is broken
-    return {
-      toolName: 'attempt_completion', 
-      params: { result: '__PREVIOUS_RESPONSE__' }
-    };
-  }
-
-  // Use the original parseXmlToolCall function to parse the cleaned XML string
-  const parsedTool = parseXmlToolCall(cleanedXmlString, validTools);
-
-  // If debugging is enabled, log the thinking content
-  if (process.env.DEBUG === '1' && thinkingContent) {
-    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
+  // Use the shared processing logic
+  const { cleanedXmlString, recoveryResult } = processXmlWithThinkingAndRecovery(xmlString, validTools);
+  
+  // If recovery found an attempt_complete pattern, return it
+  if (recoveryResult) {
+    return recoveryResult;
   }
 
-  return parsedTool;
+  // Otherwise, use the original parseXmlToolCall function to parse the cleaned XML string
+  return parseXmlToolCall(cleanedXmlString, validTools);
 }
 
-/**
- * Helper function to check if the XML string contains other tool tags
- * @param {string} xmlString - The XML string to check
- * @param {string[]} validTools - List of valid tool names
- * @returns {boolean} - True if other tool tags are found
- */
-function hasOtherToolTags(xmlString, validTools = []) {
-  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
-  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
-  
-  // Check for any tool tags other than attempt_complete variants
-  for (const tool of toolsToCheck) {
-    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
-      return true;
-    }
-  }
-  return false;
-}

package/build/agent/xmlParsingUtils.js

@@ -0,0 +1,118 @@
+/**
+ * Shared XML parsing utilities used by both CLI/SDK and MCP modes
+ * This module contains the core logic for thinking tag removal and attempt_complete recovery
+ */
+
+/**
+ * Remove thinking tags and their content from XML string
+ * @param {string} xmlString - The XML string to clean
+ * @returns {string} - Cleaned XML string without thinking tags
+ */
+export function removeThinkingTags(xmlString) {
+  return xmlString.replace(/<thinking>[\s\S]*?<\/thinking>/g, '').trim();
+}
+
+/**
+ * Extract thinking content for potential logging
+ * @param {string} xmlString - The XML string to extract from
+ * @returns {string|null} - Thinking content or null if not found
+ */
+export function extractThinkingContent(xmlString) {
+  const thinkingMatch = xmlString.match(/<thinking>([\s\S]*?)<\/thinking>/);
+  return thinkingMatch ? thinkingMatch[1].trim() : null;
+}
+
+/**
+ * Check for attempt_complete recovery patterns and return standardized result
+ * @param {string} cleanedXmlString - XML string with thinking tags already removed
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object|null} - Standardized attempt_completion result or null
+ */
+export function checkAttemptCompleteRecovery(cleanedXmlString, validTools = []) {
+  // Enhanced recovery logic for attempt_complete shorthand
+  const attemptCompletePatterns = [
+    // Standard shorthand with optional whitespace
+    /^<attempt_complete>\s*$/,
+    // Empty with proper closing tag (common case from the logs)
+    /^<attempt_complete>\s*<\/attempt_complete>\s*$/,
+    // Self-closing variant
+    /^<attempt_complete\s*\/>\s*$/,
+    // Incomplete opening tag (missing closing bracket)
+    /^<attempt_complete\s*$/,
+    // With trailing content (extract just the tag part) - must come after empty tag pattern
+    /^<attempt_complete>(.*)$/s,
+    // Self-closing with trailing content
+    /^<attempt_complete\s*\/>(.*)$/s
+  ];
+
+  for (const pattern of attemptCompletePatterns) {
+    const match = cleanedXmlString.match(pattern);
+    if (match) {
+      // Convert any form of attempt_complete to the standard format
+      return {
+        toolName: 'attempt_completion',
+        params: { result: '__PREVIOUS_RESPONSE__' }
+      };
+    }
+  }
+
+  // Additional recovery: check if the string contains attempt_complete anywhere
+  // and treat the entire response as a completion signal if no other tool tags are found
+  if (cleanedXmlString.includes('<attempt_complete') && !hasOtherToolTags(cleanedXmlString, validTools)) {
+    // This handles malformed cases where attempt_complete appears but is broken
+    return {
+      toolName: 'attempt_completion', 
+      params: { result: '__PREVIOUS_RESPONSE__' }
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Helper function to check if the XML string contains other tool tags
+ * @param {string} xmlString - The XML string to check
+ * @param {string[]} validTools - List of valid tool names
+ * @returns {boolean} - True if other tool tags are found
+ */
+function hasOtherToolTags(xmlString, validTools = []) {
+  const defaultTools = ['search', 'query', 'extract', 'listFiles', 'searchFiles', 'implement', 'attempt_completion'];
+  const toolsToCheck = validTools.length > 0 ? validTools : defaultTools;
+  
+  // Check for any tool tags other than attempt_complete variants
+  for (const tool of toolsToCheck) {
+    if (tool !== 'attempt_completion' && xmlString.includes(`<${tool}`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Apply the full thinking tag removal and attempt_complete recovery logic
+ * This replicates the core logic from parseXmlToolCallWithThinking
+ * @param {string} xmlString - The XML string to process
+ * @param {Array<string>} validTools - List of valid tool names
+ * @returns {Object} - Processing result with cleanedXml and potentialRecovery
+ */
+export function processXmlWithThinkingAndRecovery(xmlString, validTools = []) {
+  // Extract thinking content if present (for potential logging or analysis)
+  const thinkingContent = extractThinkingContent(xmlString);
+
+  // Remove thinking tags and their content from the XML string
+  const cleanedXmlString = removeThinkingTags(xmlString);
+
+  // Check for attempt_complete recovery patterns
+  const recoveryResult = checkAttemptCompleteRecovery(cleanedXmlString, validTools);
+
+  // If debugging is enabled, log the thinking content
+  if (process.env.DEBUG === '1' && thinkingContent) {
+    console.log(`[DEBUG] AI Thinking Process:\n${thinkingContent}`);
+  }
+
+  return {
+    cleanedXmlString,
+    thinkingContent,
+    recoveryResult
+  };
+}

package/build/index.js

@@ -21,14 +21,17 @@ import {
 	extractSchema,
 	delegateSchema,
 	attemptCompletionSchema,
+	bashSchema,
 	searchToolDefinition,
 	queryToolDefinition,
 	extractToolDefinition,
 	delegateToolDefinition,
 	attemptCompletionToolDefinition,
+	bashToolDefinition,
 	parseXmlToolCall
 } from './tools/common.js';
 import { searchTool, queryTool, extractTool, delegateTool } from './tools/vercel.js';
+import { bashTool } from './tools/bash.js';
 import { ProbeAgent } from './agent/ProbeAgent.js';
 import { SimpleTelemetry, SimpleAppTracer, initializeSimpleTelemetryFromOptions } from './agent/simpleTelemetry.js';
 
@@ -53,18 +56,21 @@ export {
 	queryTool,
 	extractTool,
 	delegateTool,
+	bashTool,
 	// Export schemas
 	searchSchema,
 	querySchema,
 	extractSchema,
 	delegateSchema,
 	attemptCompletionSchema,
+	bashSchema,
 	// Export tool definitions
 	searchToolDefinition,
 	queryToolDefinition,
 	extractToolDefinition,
 	delegateToolDefinition,
 	attemptCompletionToolDefinition,
+	bashToolDefinition,
 	// Export parser function
 	parseXmlToolCall
 };

package/build/tools/bash.js

@@ -0,0 +1,216 @@
+/**
+ * Bash command execution tool for Vercel AI SDK
+ * @module tools/bash
+ */
+
+import { tool } from 'ai';
+import { resolve } from 'path';
+import { BashPermissionChecker } from '../agent/bashPermissions.js';
+import { executeBashCommand, formatExecutionResult, validateExecutionOptions } from '../agent/bashExecutor.js';
+
+/**
+ * Bash tool generator
+ * 
+ * @param {Object} [options] - Configuration options
+ * @param {Object} [options.bashConfig] - Bash-specific configuration
+ * @param {string[]} [options.bashConfig.allow] - Additional allow patterns
+ * @param {string[]} [options.bashConfig.deny] - Additional deny patterns
+ * @param {boolean} [options.bashConfig.disableDefaultAllow] - Disable default allow list
+ * @param {boolean} [options.bashConfig.disableDefaultDeny] - Disable default deny list
+ * @param {number} [options.bashConfig.timeout=120000] - Command timeout in milliseconds
+ * @param {string} [options.bashConfig.workingDirectory] - Default working directory
+ * @param {Object} [options.bashConfig.env={}] - Default environment variables
+ * @param {number} [options.bashConfig.maxBuffer] - Maximum output buffer size
+ * @param {boolean} [options.debug=false] - Enable debug logging
+ * @param {string} [options.defaultPath] - Default working directory from probe config
+ * @param {string[]} [options.allowedFolders] - Allowed directories for execution
+ * @returns {Object} Configured bash tool
+ */
+export const bashTool = (options = {}) => {
+  const { 
+    bashConfig = {},
+    debug = false,
+    defaultPath,
+    allowedFolders = []
+  } = options;
+
+  // Create permission checker
+  const permissionChecker = new BashPermissionChecker({
+    allow: bashConfig.allow,
+    deny: bashConfig.deny,
+    disableDefaultAllow: bashConfig.disableDefaultAllow,
+    disableDefaultDeny: bashConfig.disableDefaultDeny,
+    debug
+  });
+
+  // Determine default working directory
+  const getDefaultWorkingDirectory = () => {
+    if (bashConfig.workingDirectory) {
+      return bashConfig.workingDirectory;
+    }
+    if (defaultPath) {
+      return defaultPath;
+    }
+    if (allowedFolders && allowedFolders.length > 0) {
+      return allowedFolders[0];
+    }
+    return process.cwd();
+  };
+
+  return tool({
+    name: 'bash',
+    description: `Execute bash commands for system exploration and development tasks.
+
+Security: This tool has built-in security with allow/deny lists. By default, only safe read-only commands are allowed for code exploration.
+
+Parameters:
+- command: (required) The bash command to execute
+- workingDirectory: (optional) Directory to execute command in
+- timeout: (optional) Command timeout in milliseconds
+- env: (optional) Additional environment variables
+
+Examples of allowed commands by default:
+- File exploration: ls, cat, head, tail, find, grep
+- Git operations: git status, git log, git diff, git show
+- Package info: npm list, pip list, cargo --version
+- System info: whoami, pwd, uname, date
+
+Dangerous commands are blocked by default (rm -rf, sudo, npm install, etc.)`,
+
+    inputSchema: {
+      type: 'object',
+      properties: {
+        command: {
+          type: 'string',
+          description: 'The bash command to execute'
+        },
+        workingDirectory: {
+          type: 'string',
+          description: 'Directory to execute the command in (optional)'
+        },
+        timeout: {
+          type: 'number',
+          description: 'Command timeout in milliseconds (optional)',
+          minimum: 1000,
+          maximum: 600000
+        },
+        env: {
+          type: 'object',
+          description: 'Additional environment variables (optional)',
+          additionalProperties: {
+            type: 'string'
+          }
+        }
+      },
+      required: ['command'],
+      additionalProperties: false
+    },
+
+    execute: async ({ command, workingDirectory, timeout, env }) => {
+      try {
+        // Validate command
+        if (command === null || command === undefined || typeof command !== 'string') {
+          return 'Error: Command is required and must be a string';
+        }
+
+        if (command.trim().length === 0) {
+          return 'Error: Command cannot be empty';
+        }
+
+        // Check permissions
+        const permissionResult = permissionChecker.check(command.trim());
+        if (!permissionResult.allowed) {
+          if (debug) {
+            console.log(`[BashTool] Permission denied for command: "${command}"`);
+            console.log(`[BashTool] Reason: ${permissionResult.reason}`);
+          }
+          return `Permission denied: ${permissionResult.reason}
+
+This command is not allowed by the current security policy. 
+
+Common reasons:
+1. The command is in the deny list (potentially dangerous)
+2. The command is not in the allow list (not a recognized safe command)
+
+If you believe this command should be allowed, you can:
+- Use the --bash-allow option to add specific patterns
+- Use the --no-default-bash-deny flag to remove default restrictions (not recommended)
+
+For code exploration, try these safe alternatives:
+- ls, cat, head, tail for file operations
+- find, grep, rg for searching
+- git status, git log, git show for git operations
+- npm list, pip list for package information`;
+        }
+
+        // Determine working directory
+        const workingDir = workingDirectory || getDefaultWorkingDirectory();
+
+        // Validate working directory is within allowed folders if specified
+        if (allowedFolders && allowedFolders.length > 0) {
+          const resolvedWorkingDir = resolve(workingDir);
+          const isAllowed = allowedFolders.some(folder => {
+            const resolvedFolder = resolve(folder);
+            return resolvedWorkingDir.startsWith(resolvedFolder);
+          });
+
+          if (!isAllowed) {
+            return `Error: Working directory "${workingDir}" is not within allowed folders: ${allowedFolders.join(', ')}`;
+          }
+        }
+
+        // Prepare execution options
+        const executionOptions = {
+          workingDirectory: workingDir,
+          timeout: timeout || bashConfig.timeout || 120000,
+          env: { ...bashConfig.env, ...env },
+          maxBuffer: bashConfig.maxBuffer,
+          debug
+        };
+
+        // Validate execution options
+        const validation = validateExecutionOptions(executionOptions);
+        if (!validation.valid) {
+          return `Error: Invalid execution options: ${validation.errors.join(', ')}`;
+        }
+
+        if (validation.warnings.length > 0 && debug) {
+          console.log('[BashTool] Warnings:', validation.warnings);
+        }
+
+        if (debug) {
+          console.log(`[BashTool] Executing command: "${command}"`);
+          console.log(`[BashTool] Working directory: "${workingDir}"`);
+          console.log(`[BashTool] Timeout: ${executionOptions.timeout}ms`);
+        }
+
+        // Execute command
+        const result = await executeBashCommand(command.trim(), executionOptions);
+
+        if (debug) {
+          console.log(`[BashTool] Command completed - Success: ${result.success}, Duration: ${result.duration}ms`);
+        }
+
+        // Format and return result
+        const formattedResult = formatExecutionResult(result, debug);
+        
+        // Add metadata for failed commands
+        if (!result.success) {
+          let errorInfo = `\n\nCommand failed with exit code ${result.exitCode}`;
+          if (result.killed) {
+            errorInfo += ` (${result.error})`;
+          }
+          return formattedResult + errorInfo;
+        }
+
+        return formattedResult;
+
+      } catch (error) {
+        if (debug) {
+          console.error('[BashTool] Execution error:', error);
+        }
+        return `Error executing bash command: ${error.message}`;
+      }
+    }
+  });
+};