@probelabs/probe 0.6.0-rc121 → 0.6.0-rc123

package/index.d.ts

@@ -303,6 +303,51 @@ export declare function query(
   }
 ): Promise<any>;
 
+/**
+ * Standard grep-style search that works across multiple operating systems
+ *
+ * Use this for searching non-code files (logs, config files, text files, etc.)
+ * that are not supported by probe's semantic search. For code files, prefer
+ * using the search() function which provides AST-aware semantic search.
+ *
+ * @param options - Grep options
+ * @param options.pattern - Regular expression pattern to search for
+ * @param options.paths - Path or array of paths to search in
+ * @param options.ignoreCase - Case-insensitive search (-i flag)
+ * @param options.lineNumbers - Show line numbers in output (-n flag)
+ * @param options.count - Only show count of matches per file (-c flag)
+ * @param options.filesWithMatches - Only show filenames that contain matches (-l flag)
+ * @param options.filesWithoutMatches - Only show filenames that do not contain matches (-L flag)
+ * @param options.invertMatch - Invert match: show lines that do NOT match (-v flag)
+ * @param options.beforeContext - Number of lines of context before match (-B flag)
+ * @param options.afterContext - Number of lines of context after match (-A flag)
+ * @param options.context - Number of lines of context before and after match (-C flag)
+ * @param options.noGitignore - Do not respect .gitignore files (--no-gitignore flag)
+ * @param options.color - Colorize output: 'always', 'never', 'auto' (--color flag)
+ * @param options.maxCount - Stop reading a file after N matching lines (-m flag)
+ * @returns Promise resolving to grep results as string
+ */
+export declare function grep(options: {
+  pattern: string;
+  paths: string | string[];
+  ignoreCase?: boolean;
+  lineNumbers?: boolean;
+  count?: boolean;
+  filesWithMatches?: boolean;
+  filesWithoutMatches?: boolean;
+  invertMatch?: boolean;
+  beforeContext?: number;
+  afterContext?: number;
+  context?: number;
+  noGitignore?: boolean;
+  color?: 'always' | 'never' | 'auto';
+  maxCount?: number;
+  binaryOptions?: {
+    forceDownload?: boolean;
+    version?: string;
+  };
+}): Promise<string>;
+
 /**
  * Extract code blocks from files
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@probelabs/probe",
-  "version": "0.6.0-rc121",
+  "version": "0.6.0-rc123",
   "description": "Node.js wrapper for the probe code search tool",
   "main": "src/index.js",
   "module": "src/index.js",
@@ -80,7 +80,7 @@
     "@opentelemetry/sdk-node": "^0.203.0",
     "@opentelemetry/sdk-trace-base": "^1.30.0",
     "@opentelemetry/semantic-conventions": "^1.36.0",
-    "@probelabs/maid": "^0.0.8",
+    "@probelabs/maid": "^0.0.9",
     "ai": "^5.0.0",
     "axios": "^1.8.3",
     "fs-extra": "^11.1.1",

package/src/agent/ProbeAgent.js

@@ -141,6 +141,7 @@ export class ProbeAgent {
     this.mcpConfig = options.mcpConfig || null;
     this.mcpServers = options.mcpServers || null; // Deprecated, keep for backward compatibility
     this.mcpBridge = null;
+    this._mcpInitialized = false; // Track if MCP initialization has been attempted
 
     // Initialize the AI model
     this.initializeModel();
@@ -154,8 +155,9 @@ export class ProbeAgent {
    * This method initializes MCP and merges MCP tools into the tool list
    */
   async initialize() {
-    // Initialize MCP if enabled
-    if (this.enableMcp) {
+    // Initialize MCP if enabled and not already initialized
+    if (this.enableMcp && !this._mcpInitialized) {
+      this._mcpInitialized = true; // Prevent multiple initialization attempts
       try {
         await this.initializeMCP();
 
@@ -184,7 +186,10 @@ export class ProbeAgent {
           console.error('[DEBUG] ========================================\n');
         }
       } catch (error) {
-        console.error('[MCP] Failed to initialize MCP:', error);
+        console.error('[MCP ERROR] Failed to initialize MCP:', error.message);
+        if (this.debug) {
+          console.error('[MCP DEBUG] Full error details:', error);
+        }
         this.mcpBridge = null;
       }
     }
@@ -742,14 +747,14 @@ export class ProbeAgent {
         // Direct config object provided (SDK usage)
         mcpConfig = this.mcpConfig;
         if (this.debug) {
-          console.log('[DEBUG] Using provided MCP config object');
+          console.error('[MCP DEBUG] Using provided MCP config object');
         }
       } else if (this.mcpConfigPath) {
         // Explicit config path provided
         try {
           mcpConfig = loadMCPConfigurationFromPath(this.mcpConfigPath);
           if (this.debug) {
-            console.log(`[DEBUG] Loaded MCP config from: ${this.mcpConfigPath}`);
+            console.error(`[MCP DEBUG] Loaded MCP config from: ${this.mcpConfigPath}`);
           }
         } catch (error) {
           throw new Error(`Failed to load MCP config from ${this.mcpConfigPath}: ${error.message}`);
@@ -758,10 +763,17 @@ export class ProbeAgent {
         // Backward compatibility: convert old mcpServers format
         mcpConfig = { mcpServers: this.mcpServers };
         if (this.debug) {
-          console.warn('[DEBUG] Using deprecated mcpServers option. Consider using mcpConfig instead.');
+          console.error('[MCP DEBUG] Using deprecated mcpServers option. Consider using mcpConfig instead.');
         }
+      } else {
+        // No explicit config provided - will attempt auto-discovery
+        // This is important for CLI usage where config files may exist
+        if (this.debug) {
+          console.error('[MCP DEBUG] No explicit MCP config provided, will attempt auto-discovery');
+        }
+        // Pass null to trigger auto-discovery in MCPXmlBridge
+        mcpConfig = null;
       }
-      // Note: auto-discovery fallback is removed - user must explicitly provide config
 
       // Initialize the MCP XML bridge
       this.mcpBridge = new MCPXmlBridge({ debug: this.debug });
@@ -771,24 +783,27 @@ export class ProbeAgent {
       const mcpToolCount = mcpToolNames.length;
       if (mcpToolCount > 0) {
         if (this.debug) {
-          console.error('\n[DEBUG] ========================================');
-          console.error(`[DEBUG] MCP Tools Initialized (${mcpToolCount} tools)`);
-          console.error('[DEBUG] Available MCP tools:');
+          console.error('\n[MCP DEBUG] ========================================');
+          console.error(`[MCP DEBUG] MCP Tools Initialized (${mcpToolCount} tools)`);
+          console.error('[MCP DEBUG] Available MCP tools:');
           for (const toolName of mcpToolNames) {
-            console.error(`[DEBUG]   - ${toolName}`);
+            console.error(`[MCP DEBUG]   - ${toolName}`);
           }
-          console.error('[DEBUG] ========================================\n');
+          console.error('[MCP DEBUG] ========================================\n');
         }
       } else {
         // For backward compatibility: if no tools were loaded, set bridge to null
         // This maintains the behavior expected by existing tests
         if (this.debug) {
-          console.error('[DEBUG] No MCP tools loaded, setting bridge to null');
+          console.error('[MCP DEBUG] No MCP tools loaded, setting bridge to null');
         }
         this.mcpBridge = null;
       }
     } catch (error) {
-      console.error('[MCP] Error initializing MCP:', error);
+      console.error('[MCP ERROR] Error initializing MCP:', error.message);
+      if (this.debug) {
+        console.error('[MCP DEBUG] Full error details:', error);
+      }
       this.mcpBridge = null;
     }
   }
@@ -797,6 +812,27 @@ export class ProbeAgent {
    * Get the system message with instructions for the AI (XML Tool Format)
    */
   async getSystemMessage() {
+    // Lazy initialize MCP if enabled but not yet initialized
+    if (this.enableMcp && !this.mcpBridge && !this._mcpInitialized) {
+      this._mcpInitialized = true; // Prevent multiple initialization attempts
+      try {
+        await this.initializeMCP();
+
+        // Merge MCP tools into toolImplementations for unified access
+        if (this.mcpBridge) {
+          const mcpTools = this.mcpBridge.mcpTools || {};
+          for (const [toolName, toolImpl] of Object.entries(mcpTools)) {
+            this.toolImplementations[toolName] = toolImpl;
+          }
+        }
+      } catch (error) {
+        console.error('[MCP ERROR] Failed to lazy-initialize MCP:', error.message);
+        if (this.debug) {
+          console.error('[MCP DEBUG] Full error details:', error);
+        }
+      }
+    }
+
     // Build tool definitions
     let toolDefinitions = `
 ${searchToolDefinition}

package/src/agent/index.js

@@ -305,7 +305,7 @@ class ProbeAgentMcpServer {
     this.agent = null;
 
     this.setupToolHandlers();
-    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    this.server.onerror = (error) => console.error('[MCP ERROR]', error);
     process.on('SIGINT', async () => {
       await this.server.close();
       process.exit(0);

package/src/agent/mcp/client.js

@@ -128,14 +128,30 @@ export class MCPClientManager {
     this.config = config || loadMCPConfiguration();
     const servers = parseEnabledServers(this.config);
 
+    // Always log the number of servers found
+    console.error(`[MCP INFO] Found ${servers.length} enabled MCP server${servers.length !== 1 ? 's' : ''}`);
+
+    if (servers.length === 0) {
+      console.error('[MCP INFO] No MCP servers configured or enabled');
+      console.error('[MCP INFO] 0 MCP tools available');
+      return {
+        connected: 0,
+        total: 0,
+        tools: []
+      };
+    }
+
     if (this.debug) {
-      console.error(`[MCP] Found ${servers.length} enabled servers`);
+      console.error('[MCP DEBUG] Server details:');
+      servers.forEach(server => {
+        console.error(`[MCP DEBUG]   - ${server.name} (${server.transport})`);
+      });
     }
 
     // Connect to each enabled server
     const connectionPromises = servers.map(server =>
       this.connectToServer(server).catch(error => {
-        console.error(`[MCP] Failed to connect to ${server.name}:`, error.message);
+        console.error(`[MCP ERROR] Failed to connect to ${server.name}:`, error.message);
         return null;
       })
     );
@@ -143,9 +159,23 @@ export class MCPClientManager {
     const results = await Promise.all(connectionPromises);
     const connectedCount = results.filter(Boolean).length;
 
-    if (this.debug) {
-      console.error(`[MCP] Successfully connected to ${connectedCount}/${servers.length} servers`);
-      console.error(`[MCP] Total tools available: ${this.tools.size}`);
+    // Always log connection results
+    if (connectedCount === 0) {
+      console.error(`[MCP ERROR] Failed to connect to all ${servers.length} server${servers.length !== 1 ? 's' : ''}`);
+      console.error('[MCP INFO] 0 MCP tools available');
+    } else if (connectedCount < servers.length) {
+      console.error(`[MCP INFO] Successfully connected to ${connectedCount}/${servers.length} servers`);
+      console.error(`[MCP INFO] ${this.tools.size} MCP tool${this.tools.size !== 1 ? 's' : ''} available`);
+    } else {
+      console.error(`[MCP INFO] Successfully connected to all ${connectedCount} server${connectedCount !== 1 ? 's' : ''}`);
+      console.error(`[MCP INFO] ${this.tools.size} MCP tool${this.tools.size !== 1 ? 's' : ''} available`);
+    }
+
+    if (this.debug && this.tools.size > 0) {
+      console.error('[MCP DEBUG] Available tools:');
+      Array.from(this.tools.keys()).forEach(toolName => {
+        console.error(`[MCP DEBUG]   - ${toolName}`);
+      });
     }
 
     return {
@@ -164,7 +194,7 @@ export class MCPClientManager {
 
     try {
       if (this.debug) {
-        console.error(`[MCP] Connecting to ${name} via ${serverConfig.transport}...`);
+        console.error(`[MCP DEBUG] Connecting to ${name} via ${serverConfig.transport}...`);
       }
 
       // Create transport
@@ -193,6 +223,7 @@ export class MCPClientManager {
 
       // Fetch and register tools
       const toolsResponse = await client.listTools();
+      const toolCount = toolsResponse?.tools?.length || 0;
 
       if (toolsResponse && toolsResponse.tools) {
         for (const tool of toolsResponse.tools) {
@@ -205,18 +236,19 @@ export class MCPClientManager {
           });
 
           if (this.debug) {
-            console.error(`[MCP]   Registered tool: ${qualifiedName}`);
+            console.error(`[MCP DEBUG]     Registered tool: ${qualifiedName}`);
           }
         }
       }
 
-      if (this.debug) {
-        console.error(`[MCP] Connected to ${name} with ${toolsResponse?.tools?.length || 0} tools`);
-      }
+      console.error(`[MCP INFO] Connected to ${name}: ${toolCount} tool${toolCount !== 1 ? 's' : ''} loaded`);
 
       return true;
     } catch (error) {
-      console.error(`[MCP] Error connecting to ${name}:`, error.message);
+      console.error(`[MCP ERROR] Error connecting to ${name}:`, error.message);
+      if (this.debug) {
+        console.error(`[MCP DEBUG] Full error details:`, error);
+      }
       return false;
     }
   }
@@ -239,7 +271,7 @@ export class MCPClientManager {
 
     try {
       if (this.debug) {
-        console.error(`[MCP] Calling ${toolName} with args:`, args);
+        console.error(`[MCP DEBUG] Calling ${toolName} with args:`, JSON.stringify(args, null, 2));
       }
 
       // Get timeout from config (default 30 seconds)
@@ -261,9 +293,16 @@ export class MCPClientManager {
         timeoutPromise
       ]);
 
+      if (this.debug) {
+        console.error(`[MCP DEBUG] Tool ${toolName} executed successfully`);
+      }
+
       return result;
     } catch (error) {
-      console.error(`[MCP] Error calling tool ${toolName}:`, error);
+      console.error(`[MCP ERROR] Error calling tool ${toolName}:`, error.message);
+      if (this.debug) {
+        console.error(`[MCP DEBUG] Full error details:`, error);
+      }
       throw error;
     }
   }
@@ -316,16 +355,27 @@ export class MCPClientManager {
   async disconnect() {
     const disconnectPromises = [];
 
+    if (this.clients.size === 0) {
+      if (this.debug) {
+        console.error('[MCP DEBUG] No MCP clients to disconnect');
+      }
+      return;
+    }
+
+    if (this.debug) {
+      console.error(`[MCP DEBUG] Disconnecting from ${this.clients.size} MCP server${this.clients.size !== 1 ? 's' : ''}...`);
+    }
+
     for (const [name, clientInfo] of this.clients.entries()) {
       disconnectPromises.push(
         clientInfo.client.close()
           .then(() => {
             if (this.debug) {
-              console.error(`[MCP] Disconnected from ${name}`);
+              console.error(`[MCP DEBUG] Disconnected from ${name}`);
             }
           })
           .catch(error => {
-            console.error(`[MCP] Error disconnecting from ${name}:`, error);
+            console.error(`[MCP ERROR] Error disconnecting from ${name}:`, error.message);
           })
       );
     }
@@ -333,6 +383,10 @@ export class MCPClientManager {
     await Promise.all(disconnectPromises);
     this.clients.clear();
     this.tools.clear();
+
+    if (this.debug) {
+      console.error('[MCP DEBUG] All MCP connections closed');
+    }
   }
 }
 

package/src/agent/mcp/config.js

@@ -51,8 +51,8 @@ export function loadMCPConfigurationFromPath(configPath) {
     const content = readFileSync(configPath, 'utf8');
     const config = JSON.parse(content);
 
-    if (process.env.DEBUG === '1') {
-      console.error(`[MCP] Loaded configuration from: ${configPath}`);
+    if (process.env.DEBUG === '1' || process.env.DEBUG_MCP === '1') {
+      console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
     }
 
     // Merge with environment variable overrides
@@ -94,12 +94,12 @@ export function loadMCPConfiguration() {
       try {
         const content = readFileSync(configPath, 'utf8');
         config = JSON.parse(content);
-        if (process.env.DEBUG === '1') {
-          console.error(`[MCP] Loaded configuration from: ${configPath}`);
+        if (process.env.DEBUG === '1' || process.env.DEBUG_MCP === '1') {
+          console.error(`[MCP DEBUG] Loaded configuration from: ${configPath}`);
         }
         break;
       } catch (error) {
-        console.error(`[MCP] Failed to parse config from ${configPath}:`, error.message);
+        console.error(`[MCP ERROR] Failed to parse config from ${configPath}:`, error.message);
       }
     }
   }
@@ -209,12 +209,12 @@ export function parseEnabledServers(config) {
     // Validate required fields based on transport
     if (server.transport === 'stdio') {
       if (!server.command) {
-        console.error(`[MCP] Server ${name} missing required 'command' for stdio transport`);
+        console.error(`[MCP ERROR] Server ${name} missing required 'command' for stdio transport`);
         continue;
       }
     } else if (['websocket', 'sse', 'http'].includes(server.transport)) {
       if (!server.url) {
-        console.error(`[MCP] Server ${name} missing required 'url' for ${server.transport} transport`);
+        console.error(`[MCP ERROR] Server ${name} missing required 'url' for ${server.transport} transport`);
         continue;
       }
     }
@@ -301,7 +301,7 @@ export function saveConfig(config, path) {
   }
 
   writeFileSync(path, JSON.stringify(config, null, 2), 'utf8');
-  console.log(`[MCP] Configuration saved to: ${path}`);
+  console.error(`[MCP INFO] Configuration saved to: ${path}`);
 }
 
 export default {

package/src/agent/mcp/xmlBridge.js

@@ -141,23 +141,44 @@ export class MCPXmlBridge {
 
     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:');
+        console.error('[MCP INFO]   - mcpConfig option when creating ProbeAgent');
+        console.error('[MCP INFO]   - mcpConfigPath option pointing to a config file');
+        console.error('[MCP INFO]   - Config file in standard locations (~/.mcp/config.json, etc.)');
+        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');
+      }
       mcpConfigs = config;
     }
 
     if (!mcpConfigs || !mcpConfigs.mcpServers || Object.keys(mcpConfigs.mcpServers).length === 0) {
-      if (this.debug) {
-        console.error('[MCP] No MCP servers configured');
-      }
+      console.error('[MCP INFO] 0 MCP tools available');
       return;
     }
 
     try {
+      if (this.debug) {
+        console.error('[MCP DEBUG] Initializing MCP client manager...');
+      }
+
       // Initialize the MCP client manager
       this.mcpManager = new MCPClientManager({ debug: this.debug });
       const result = await this.mcpManager.initialize(mcpConfigs);
@@ -165,17 +186,27 @@ export class MCPXmlBridge {
       // Get tools from the manager
       const vercelTools = this.mcpManager.getVercelTools();
       this.mcpTools = vercelTools;
+      const toolCount = Object.keys(vercelTools).length;
 
       // 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)`);
+      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] Failed to initialize MCP connections:', error);
+      console.error('[MCP ERROR] Failed to initialize MCP connections:', error.message);
+      if (this.debug) {
+        console.error('[MCP DEBUG] Full error details:', error);
+      }
     }
   }
 
@@ -204,28 +235,42 @@ export class MCPXmlBridge {
     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] Executing MCP tool: ${toolName} with params:`, params);
+      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,

package/src/agent/schemaUtils.js

@@ -40,7 +40,7 @@ export function decodeHtmlEntities(text) {
 
 /**
  * Clean AI response by extracting JSON content when response contains JSON
- * Only processes responses that contain JSON structures { or [ 
+ * Only processes responses that contain JSON structures { or [
  * @param {string} response - Raw AI response
  * @returns {string} - Cleaned response with JSON boundaries extracted if applicable
  */
@@ -50,34 +50,47 @@ export function cleanSchemaResponse(response) {
   }
 
   const trimmed = response.trim();
-  
-  // First, look for JSON after code block markers
+
+  // First, look for JSON after code block markers - similar to mermaid extraction
+  // Try with json language specifier
+  const jsonBlockMatch = trimmed.match(/```json\s*\n([\s\S]*?)\n```/);
+  if (jsonBlockMatch) {
+    return jsonBlockMatch[1].trim();
+  }
+
+  // Try any code block with JSON content
+  const anyBlockMatch = trimmed.match(/```\s*\n([{\[][\s\S]*?[}\]])\s*```/);
+  if (anyBlockMatch) {
+    return anyBlockMatch[1].trim();
+  }
+
+  // Legacy patterns for more specific matching
   const codeBlockPatterns = [
     /```json\s*\n?([{\[][\s\S]*?[}\]])\s*\n?```/,
     /```\s*\n?([{\[][\s\S]*?[}\]])\s*\n?```/,
     /`([{\[][\s\S]*?[}\]])`/
   ];
-  
+
   for (const pattern of codeBlockPatterns) {
     const match = trimmed.match(pattern);
     if (match) {
       return match[1].trim();
     }
   }
-  
+
   // Look for code block start followed immediately by JSON
   const codeBlockStartPattern = /```(?:json)?\s*\n?\s*([{\[])/;
   const codeBlockMatch = trimmed.match(codeBlockStartPattern);
-  
+
   if (codeBlockMatch) {
     const startIndex = codeBlockMatch.index + codeBlockMatch[0].length - 1; // Position of the bracket
-    
+
     // Find the matching closing bracket
     const openChar = codeBlockMatch[1];
     const closeChar = openChar === '{' ? '}' : ']';
     let bracketCount = 1;
     let endIndex = startIndex + 1;
-    
+
     while (endIndex < trimmed.length && bracketCount > 0) {
       const char = trimmed[endIndex];
       if (char === openChar) {
@@ -87,36 +100,36 @@ export function cleanSchemaResponse(response) {
       }
       endIndex++;
     }
-    
+
     if (bracketCount === 0) {
       return trimmed.substring(startIndex, endIndex);
     }
   }
-  
+
   // Fallback: Find JSON boundaries anywhere in the text
   const firstBracket = Math.min(
     trimmed.indexOf('{') >= 0 ? trimmed.indexOf('{') : Infinity,
     trimmed.indexOf('[') >= 0 ? trimmed.indexOf('[') : Infinity
   );
-  
+
   const lastBracket = Math.max(
     trimmed.lastIndexOf('}'),
     trimmed.lastIndexOf(']')
   );
-  
+
   // Only extract if we found valid JSON boundaries
   if (firstBracket < Infinity && lastBracket >= 0 && firstBracket < lastBracket) {
     // Check if the response likely starts with JSON (directly or after minimal content)
     const beforeFirstBracket = trimmed.substring(0, firstBracket).trim();
-    
+
     // If there's minimal content before the first bracket, extract the JSON
-    if (beforeFirstBracket === '' || 
+    if (beforeFirstBracket === '' ||
         beforeFirstBracket.match(/^```\w*$/) ||
         beforeFirstBracket.split('\n').length <= 2) {
       return trimmed.substring(firstBracket, lastBracket + 1);
     }
   }
-  
+
   return response; // Return original if no extractable JSON found
 }