@librechat/agents 3.0.66 → 3.0.68

package/src/tools/__tests__/ToolSearch.test.ts

@@ -0,0 +1,734 @@
+// src/tools/__tests__/ToolSearch.test.ts
+/**
+ * Unit tests for Tool Search.
+ * Tests helper functions and sanitization logic without hitting the API.
+ */
+import { describe, it, expect } from '@jest/globals';
+import {
+  sanitizeRegex,
+  escapeRegexSpecialChars,
+  isDangerousPattern,
+  countNestedGroups,
+  hasNestedQuantifiers,
+  performLocalSearch,
+  extractMcpServerName,
+  isFromMcpServer,
+  isFromAnyMcpServer,
+  normalizeServerFilter,
+  getBaseToolName,
+  formatServerListing,
+} from '../ToolSearch';
+import type { ToolMetadata } from '@/types';
+
+describe('ToolSearch', () => {
+  describe('escapeRegexSpecialChars', () => {
+    it('escapes special regex characters', () => {
+      expect(escapeRegexSpecialChars('hello.world')).toBe('hello\\.world');
+      expect(escapeRegexSpecialChars('test*pattern')).toBe('test\\*pattern');
+      expect(escapeRegexSpecialChars('query+result')).toBe('query\\+result');
+      expect(escapeRegexSpecialChars('a?b')).toBe('a\\?b');
+      expect(escapeRegexSpecialChars('(group)')).toBe('\\(group\\)');
+      expect(escapeRegexSpecialChars('[abc]')).toBe('\\[abc\\]');
+      expect(escapeRegexSpecialChars('a|b')).toBe('a\\|b');
+      expect(escapeRegexSpecialChars('a^b$c')).toBe('a\\^b\\$c');
+      expect(escapeRegexSpecialChars('a{2,3}')).toBe('a\\{2,3\\}');
+    });
+
+    it('handles empty string', () => {
+      expect(escapeRegexSpecialChars('')).toBe('');
+    });
+
+    it('handles string with no special chars', () => {
+      expect(escapeRegexSpecialChars('hello_world')).toBe('hello_world');
+      expect(escapeRegexSpecialChars('test123')).toBe('test123');
+    });
+
+    it('handles multiple consecutive special chars', () => {
+      expect(escapeRegexSpecialChars('...')).toBe('\\.\\.\\.');
+      expect(escapeRegexSpecialChars('***')).toBe('\\*\\*\\*');
+    });
+  });
+
+  describe('countNestedGroups', () => {
+    it('counts simple nesting', () => {
+      expect(countNestedGroups('(a)')).toBe(1);
+      expect(countNestedGroups('((a))')).toBe(2);
+      expect(countNestedGroups('(((a)))')).toBe(3);
+    });
+
+    it('counts maximum depth with multiple groups', () => {
+      expect(countNestedGroups('(a)(b)(c)')).toBe(1);
+      expect(countNestedGroups('(a(b)c)')).toBe(2);
+      expect(countNestedGroups('(a(b(c)))')).toBe(3);
+    });
+
+    it('handles mixed nesting levels', () => {
+      expect(countNestedGroups('(a)((b)(c))')).toBe(2);
+      expect(countNestedGroups('((a)(b))((c))')).toBe(2);
+    });
+
+    it('ignores escaped parentheses', () => {
+      expect(countNestedGroups('\\(not a group\\)')).toBe(0);
+      expect(countNestedGroups('(a\\(b\\)c)')).toBe(1);
+    });
+
+    it('handles no groups', () => {
+      expect(countNestedGroups('abc')).toBe(0);
+      expect(countNestedGroups('test.*pattern')).toBe(0);
+    });
+
+    it('handles unbalanced groups', () => {
+      expect(countNestedGroups('((a)')).toBe(2);
+      expect(countNestedGroups('(a))')).toBe(1);
+    });
+  });
+
+  describe('hasNestedQuantifiers', () => {
+    it('detects nested quantifiers', () => {
+      expect(hasNestedQuantifiers('(a+)+')).toBe(true);
+      expect(hasNestedQuantifiers('(a*)*')).toBe(true);
+      expect(hasNestedQuantifiers('(a+)*')).toBe(true);
+      expect(hasNestedQuantifiers('(a*)?')).toBe(true);
+    });
+
+    it('allows safe quantifiers', () => {
+      expect(hasNestedQuantifiers('a+')).toBe(false);
+      expect(hasNestedQuantifiers('(abc)+')).toBe(false);
+      expect(hasNestedQuantifiers('a+b*c?')).toBe(false);
+    });
+
+    it('handles complex patterns', () => {
+      expect(hasNestedQuantifiers('(a|b)+')).toBe(false);
+      // Note: This pattern might not be detected by the simple regex check
+      const complexPattern = '((a|b)+)+';
+      const result = hasNestedQuantifiers(complexPattern);
+      // Just verify it doesn't crash - detection may vary
+      expect(typeof result).toBe('boolean');
+    });
+  });
+
+  describe('isDangerousPattern', () => {
+    it('detects nested quantifiers', () => {
+      expect(isDangerousPattern('(a+)+')).toBe(true);
+      expect(isDangerousPattern('(a*)*')).toBe(true);
+      expect(isDangerousPattern('(.+)+')).toBe(true);
+      expect(isDangerousPattern('(.*)*')).toBe(true);
+    });
+
+    it('detects excessive nesting', () => {
+      expect(isDangerousPattern('((((((a))))))')).toBe(true); // Depth > 5
+    });
+
+    it('detects excessive wildcards', () => {
+      const pattern = '.{1000,}';
+      expect(isDangerousPattern(pattern)).toBe(true);
+    });
+
+    it('allows safe patterns', () => {
+      expect(isDangerousPattern('weather')).toBe(false);
+      expect(isDangerousPattern('get_.*_data')).toBe(false);
+      expect(isDangerousPattern('(a|b|c)')).toBe(false);
+      expect(isDangerousPattern('test\\d+')).toBe(false);
+    });
+
+    it('detects various dangerous patterns', () => {
+      expect(isDangerousPattern('(.*)+')).toBe(true);
+      expect(isDangerousPattern('(.+)*')).toBe(true);
+    });
+  });
+
+  describe('sanitizeRegex', () => {
+    it('returns safe pattern unchanged', () => {
+      const result = sanitizeRegex('weather');
+      expect(result.safe).toBe('weather');
+      expect(result.wasEscaped).toBe(false);
+    });
+
+    it('escapes dangerous patterns', () => {
+      const result = sanitizeRegex('(a+)+');
+      expect(result.safe).toBe('\\(a\\+\\)\\+');
+      expect(result.wasEscaped).toBe(true);
+    });
+
+    it('escapes invalid regex', () => {
+      const result = sanitizeRegex('(unclosed');
+      expect(result.wasEscaped).toBe(true);
+      expect(result.safe).toContain('\\(');
+    });
+
+    it('allows complex but safe patterns', () => {
+      const result = sanitizeRegex('get_[a-z]+_data');
+      expect(result.safe).toBe('get_[a-z]+_data');
+      expect(result.wasEscaped).toBe(false);
+    });
+
+    it('handles alternation patterns', () => {
+      const result = sanitizeRegex('weather|forecast');
+      expect(result.safe).toBe('weather|forecast');
+      expect(result.wasEscaped).toBe(false);
+    });
+  });
+
+  describe('Pattern Validation Edge Cases', () => {
+    it('handles empty pattern', () => {
+      expect(countNestedGroups('')).toBe(0);
+      expect(hasNestedQuantifiers('')).toBe(false);
+      expect(isDangerousPattern('')).toBe(false);
+    });
+
+    it('handles pattern with only quantifiers', () => {
+      expect(hasNestedQuantifiers('+++')).toBe(false);
+      expect(hasNestedQuantifiers('***')).toBe(false);
+    });
+
+    it('handles escaped special sequences', () => {
+      const result = sanitizeRegex('\\d+\\w*\\s?');
+      expect(result.wasEscaped).toBe(false);
+    });
+
+    it('sanitizes exponential backtracking patterns', () => {
+      // These can cause catastrophic backtracking
+      expect(isDangerousPattern('(a+)+')).toBe(true);
+      expect(isDangerousPattern('(a*)*')).toBe(true);
+      expect(isDangerousPattern('(.*)*')).toBe(true);
+    });
+  });
+
+  describe('Real-World Pattern Examples', () => {
+    it('handles common search patterns safely', () => {
+      const safePatterns = [
+        'expense',
+        'weather|forecast',
+        'data.*query',
+        '_tool$',
+      ];
+
+      for (const pattern of safePatterns) {
+        const result = sanitizeRegex(pattern);
+        expect(result.wasEscaped).toBe(false);
+      }
+    });
+
+    it('escapes clearly dangerous patterns', () => {
+      const dangerousPatterns = ['(a+)+', '(.*)+', '(.+)*'];
+
+      for (const pattern of dangerousPatterns) {
+        const result = sanitizeRegex(pattern);
+        expect(result.wasEscaped).toBe(true);
+      }
+    });
+
+    it('handles patterns that may or may not be escaped', () => {
+      // These patterns might be escaped depending on validation logic
+      const edgeCasePatterns = [
+        '(?i)email',
+        '^create_',
+        'get_[a-z]+_info',
+        'get_.*',
+        '((((((a))))))',
+        '(a|a)*',
+      ];
+
+      for (const pattern of edgeCasePatterns) {
+        const result = sanitizeRegex(pattern);
+        // Just verify it returns a result without crashing
+        expect(typeof result.safe).toBe('string');
+        expect(typeof result.wasEscaped).toBe('boolean');
+      }
+    });
+  });
+
+  describe('performLocalSearch', () => {
+    const mockTools: ToolMetadata[] = [
+      {
+        name: 'get_weather',
+        description: 'Get current weather data',
+        parameters: undefined,
+      },
+      {
+        name: 'get_forecast',
+        description: 'Get weather forecast for multiple days',
+        parameters: undefined,
+      },
+      {
+        name: 'send_email',
+        description: 'Send an email message',
+        parameters: undefined,
+      },
+      {
+        name: 'get_expenses',
+        description: 'Retrieve expense reports',
+        parameters: undefined,
+      },
+      {
+        name: 'calculate_expense_totals',
+        description: 'Sum up expenses by category',
+        parameters: undefined,
+      },
+      {
+        name: 'run_database_query',
+        description: 'Execute a database query',
+        parameters: {
+          type: 'object',
+          properties: {
+            query: { type: 'string' },
+            timeout: { type: 'number' },
+          },
+        },
+      },
+    ];
+
+    it('finds tools by exact name match', () => {
+      const result = performLocalSearch(mockTools, 'get_weather', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(1);
+      expect(result.tool_references[0].tool_name).toBe('get_weather');
+      expect(result.tool_references[0].match_score).toBe(1.0);
+      expect(result.tool_references[0].matched_field).toBe('name');
+    });
+
+    it('finds tools by partial name match (starts with)', () => {
+      const result = performLocalSearch(mockTools, 'get_', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(3);
+      expect(result.tool_references[0].match_score).toBe(0.95);
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_weather'
+      );
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_forecast'
+      );
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_expenses'
+      );
+    });
+
+    it('finds tools by substring match in name', () => {
+      const result = performLocalSearch(mockTools, 'expense', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(2);
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_expenses'
+      );
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'calculate_expense_totals'
+      );
+      expect(result.tool_references[0].match_score).toBe(0.85);
+    });
+
+    it('performs case-insensitive search', () => {
+      const result = performLocalSearch(
+        mockTools,
+        'WEATHER',
+        ['name', 'description'],
+        10
+      );
+
+      expect(result.tool_references.length).toBe(2);
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_weather'
+      );
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_forecast'
+      );
+    });
+
+    it('searches in description field', () => {
+      const result = performLocalSearch(
+        mockTools,
+        'email',
+        ['description'],
+        10
+      );
+
+      expect(result.tool_references.length).toBe(1);
+      expect(result.tool_references[0].tool_name).toBe('send_email');
+      expect(result.tool_references[0].matched_field).toBe('description');
+      expect(result.tool_references[0].match_score).toBe(0.7);
+    });
+
+    it('searches in parameter names', () => {
+      const result = performLocalSearch(mockTools, 'query', ['parameters'], 10);
+
+      expect(result.tool_references.length).toBe(1);
+      expect(result.tool_references[0].tool_name).toBe('run_database_query');
+      expect(result.tool_references[0].matched_field).toBe('parameters');
+      expect(result.tool_references[0].match_score).toBe(0.55);
+    });
+
+    it('prioritizes name matches over description matches', () => {
+      const result = performLocalSearch(
+        mockTools,
+        'weather',
+        ['name', 'description'],
+        10
+      );
+
+      const weatherTool = result.tool_references.find(
+        (r) => r.tool_name === 'get_weather'
+      );
+      const forecastTool = result.tool_references.find(
+        (r) => r.tool_name === 'get_forecast'
+      );
+
+      expect(weatherTool?.matched_field).toBe('name');
+      expect(forecastTool?.matched_field).toBe('description');
+      expect(weatherTool!.match_score).toBeGreaterThan(
+        forecastTool!.match_score
+      );
+    });
+
+    it('limits results to max_results', () => {
+      const result = performLocalSearch(mockTools, 'get', ['name'], 2);
+
+      expect(result.tool_references.length).toBe(2);
+      expect(result.total_tools_searched).toBe(mockTools.length);
+    });
+
+    it('returns empty array when no matches found', () => {
+      const result = performLocalSearch(
+        mockTools,
+        'nonexistent_xyz_123',
+        ['name', 'description'],
+        10
+      );
+
+      expect(result.tool_references.length).toBe(0);
+      expect(result.total_tools_searched).toBe(mockTools.length);
+    });
+
+    it('sorts results by score descending', () => {
+      const result = performLocalSearch(
+        mockTools,
+        'expense',
+        ['name', 'description'],
+        10
+      );
+
+      for (let i = 1; i < result.tool_references.length; i++) {
+        expect(
+          result.tool_references[i - 1].match_score
+        ).toBeGreaterThanOrEqual(result.tool_references[i].match_score);
+      }
+    });
+
+    it('handles empty tools array', () => {
+      const result = performLocalSearch([], 'test', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(0);
+      expect(result.total_tools_searched).toBe(0);
+    });
+
+    it('handles empty query gracefully', () => {
+      const result = performLocalSearch(mockTools, '', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(mockTools.length);
+    });
+
+    it('includes correct metadata in response', () => {
+      const result = performLocalSearch(mockTools, 'weather', ['name'], 10);
+
+      expect(result.total_tools_searched).toBe(mockTools.length);
+      expect(result.pattern_used).toBe('weather');
+    });
+
+    it('provides snippet in results', () => {
+      const result = performLocalSearch(
+        mockTools,
+        'database',
+        ['description'],
+        10
+      );
+
+      expect(result.tool_references[0].snippet).toBeTruthy();
+      expect(result.tool_references[0].snippet.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('extractMcpServerName', () => {
+    it('extracts server name from MCP tool name', () => {
+      expect(extractMcpServerName('get_weather_mcp_weather-server')).toBe(
+        'weather-server'
+      );
+      expect(extractMcpServerName('send_email_mcp_gmail')).toBe('gmail');
+      expect(extractMcpServerName('query_database_mcp_postgres-mcp')).toBe(
+        'postgres-mcp'
+      );
+    });
+
+    it('returns undefined for non-MCP tools', () => {
+      expect(extractMcpServerName('get_weather')).toBeUndefined();
+      expect(extractMcpServerName('send_email')).toBeUndefined();
+      expect(extractMcpServerName('regular_tool_name')).toBeUndefined();
+    });
+
+    it('handles edge cases', () => {
+      expect(extractMcpServerName('_mcp_server')).toBe('server');
+      expect(extractMcpServerName('tool_mcp_')).toBe('');
+    });
+  });
+
+  describe('getBaseToolName', () => {
+    it('extracts base name from MCP tool name', () => {
+      expect(getBaseToolName('get_weather_mcp_weather-server')).toBe(
+        'get_weather'
+      );
+      expect(getBaseToolName('send_email_mcp_gmail')).toBe('send_email');
+    });
+
+    it('returns full name for non-MCP tools', () => {
+      expect(getBaseToolName('get_weather')).toBe('get_weather');
+      expect(getBaseToolName('regular_tool')).toBe('regular_tool');
+    });
+  });
+
+  describe('isFromMcpServer', () => {
+    it('returns true for matching MCP server', () => {
+      expect(
+        isFromMcpServer('get_weather_mcp_weather-server', 'weather-server')
+      ).toBe(true);
+      expect(isFromMcpServer('send_email_mcp_gmail', 'gmail')).toBe(true);
+    });
+
+    it('returns false for non-matching MCP server', () => {
+      expect(
+        isFromMcpServer('get_weather_mcp_weather-server', 'other-server')
+      ).toBe(false);
+      expect(isFromMcpServer('send_email_mcp_gmail', 'outlook')).toBe(false);
+    });
+
+    it('returns false for non-MCP tools', () => {
+      expect(isFromMcpServer('get_weather', 'weather-server')).toBe(false);
+      expect(isFromMcpServer('regular_tool', 'any-server')).toBe(false);
+    });
+  });
+
+  describe('isFromAnyMcpServer', () => {
+    it('returns true if tool is from any of the specified servers', () => {
+      expect(
+        isFromAnyMcpServer('get_weather_mcp_weather-api', [
+          'weather-api',
+          'gmail',
+        ])
+      ).toBe(true);
+      expect(
+        isFromAnyMcpServer('send_email_mcp_gmail', ['weather-api', 'gmail'])
+      ).toBe(true);
+    });
+
+    it('returns false if tool is not from any specified server', () => {
+      expect(
+        isFromAnyMcpServer('get_weather_mcp_weather-api', ['gmail', 'slack'])
+      ).toBe(false);
+    });
+
+    it('returns false for non-MCP tools', () => {
+      expect(isFromAnyMcpServer('regular_tool', ['weather-api', 'gmail'])).toBe(
+        false
+      );
+    });
+
+    it('returns false for empty server list', () => {
+      expect(isFromAnyMcpServer('get_weather_mcp_weather-api', [])).toBe(false);
+    });
+  });
+
+  describe('normalizeServerFilter', () => {
+    it('converts string to single-element array', () => {
+      expect(normalizeServerFilter('gmail')).toEqual(['gmail']);
+    });
+
+    it('passes through arrays unchanged', () => {
+      expect(normalizeServerFilter(['gmail', 'slack'])).toEqual([
+        'gmail',
+        'slack',
+      ]);
+    });
+
+    it('returns empty array for undefined', () => {
+      expect(normalizeServerFilter(undefined)).toEqual([]);
+    });
+
+    it('returns empty array for empty string', () => {
+      expect(normalizeServerFilter('')).toEqual([]);
+    });
+
+    it('filters out empty strings from arrays', () => {
+      expect(normalizeServerFilter(['gmail', '', 'slack'])).toEqual([
+        'gmail',
+        'slack',
+      ]);
+    });
+  });
+
+  describe('performLocalSearch with MCP tools', () => {
+    const mcpTools: ToolMetadata[] = [
+      {
+        name: 'get_weather_mcp_weather-server',
+        description: 'Get weather from MCP server',
+        parameters: undefined,
+      },
+      {
+        name: 'get_forecast_mcp_weather-server',
+        description: 'Get forecast from MCP server',
+        parameters: undefined,
+      },
+      {
+        name: 'send_email_mcp_gmail',
+        description: 'Send email via Gmail MCP',
+        parameters: undefined,
+      },
+      {
+        name: 'read_inbox_mcp_gmail',
+        description: 'Read inbox via Gmail MCP',
+        parameters: undefined,
+      },
+      {
+        name: 'get_weather',
+        description: 'Regular weather tool (not MCP)',
+        parameters: undefined,
+      },
+    ];
+
+    it('searches across all tools including MCP tools', () => {
+      const result = performLocalSearch(
+        mcpTools,
+        'weather',
+        ['name', 'description'],
+        10
+      );
+
+      expect(result.tool_references.length).toBe(3);
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_weather_mcp_weather-server'
+      );
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'get_weather'
+      );
+    });
+
+    it('finds MCP tools by searching the full name including server suffix', () => {
+      const result = performLocalSearch(mcpTools, 'gmail', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(2);
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'send_email_mcp_gmail'
+      );
+      expect(result.tool_references.map((r) => r.tool_name)).toContain(
+        'read_inbox_mcp_gmail'
+      );
+    });
+
+    it('can search for tools by MCP delimiter', () => {
+      const result = performLocalSearch(mcpTools, '_mcp_', ['name'], 10);
+
+      expect(result.tool_references.length).toBe(4);
+      expect(result.tool_references.map((r) => r.tool_name)).not.toContain(
+        'get_weather'
+      );
+    });
+  });
+
+  describe('formatServerListing', () => {
+    const serverTools: ToolMetadata[] = [
+      {
+        name: 'get_weather_mcp_weather-api',
+        description: 'Get current weather conditions for a location',
+        parameters: undefined,
+      },
+      {
+        name: 'get_forecast_mcp_weather-api',
+        description: 'Get weather forecast for the next 7 days',
+        parameters: undefined,
+      },
+    ];
+
+    it('formats server listing with tool names and descriptions', () => {
+      const result = formatServerListing(serverTools, 'weather-api');
+
+      expect(result).toContain('Tools from MCP server: weather-api');
+      expect(result).toContain('2 tool(s)');
+      expect(result).toContain('get_weather');
+      expect(result).toContain('get_forecast');
+      expect(result).toContain('preview only');
+    });
+
+    it('includes hint to search for specific tool to load it', () => {
+      const result = formatServerListing(serverTools, 'weather-api');
+
+      expect(result).toContain('To use a tool, search for it by name');
+    });
+
+    it('uses base tool name (without MCP suffix) in display', () => {
+      const result = formatServerListing(serverTools, 'weather-api');
+
+      expect(result).toContain('**get_weather**');
+      expect(result).not.toContain('**get_weather_mcp_weather-api**');
+    });
+
+    it('handles empty tools array', () => {
+      const result = formatServerListing([], 'empty-server');
+
+      expect(result).toContain('No tools found');
+      expect(result).toContain('empty-server');
+    });
+
+    it('truncates long descriptions', () => {
+      const toolsWithLongDesc: ToolMetadata[] = [
+        {
+          name: 'long_tool_mcp_server',
+          description:
+            'This is a very long description that exceeds 80 characters and should be truncated to keep the listing compact and readable.',
+          parameters: undefined,
+        },
+      ];
+
+      const result = formatServerListing(toolsWithLongDesc, 'server');
+
+      expect(result).toContain('...');
+      expect(result.length).toBeLessThan(
+        toolsWithLongDesc[0].description.length + 200
+      );
+    });
+
+    it('handles multiple servers with grouped output', () => {
+      const multiServerTools: ToolMetadata[] = [
+        {
+          name: 'get_weather_mcp_weather-api',
+          description: 'Get weather',
+          parameters: undefined,
+        },
+        {
+          name: 'send_email_mcp_gmail',
+          description: 'Send email',
+          parameters: undefined,
+        },
+        {
+          name: 'read_inbox_mcp_gmail',
+          description: 'Read inbox',
+          parameters: undefined,
+        },
+      ];
+
+      const result = formatServerListing(multiServerTools, [
+        'weather-api',
+        'gmail',
+      ]);
+
+      expect(result).toContain('Tools from MCP servers: weather-api, gmail');
+      expect(result).toContain('3 tool(s)');
+      expect(result).toContain('### weather-api');
+      expect(result).toContain('### gmail');
+      expect(result).toContain('get_weather');
+      expect(result).toContain('send_email');
+      expect(result).toContain('read_inbox');
+    });
+
+    it('accepts single server as array', () => {
+      const result = formatServerListing(serverTools, ['weather-api']);
+
+      expect(result).toContain('Tools from MCP server: weather-api');
+      expect(result).not.toContain('###');
+    });
+  });
+});