@youdotcom-oss/mcp 1.3.5-next.5 → 1.3.6

package/src/express/tests/express.utils.spec.ts

@@ -0,0 +1,244 @@
+import { describe, expect, setDefaultTimeout, test } from 'bun:test';
+import type { ExpressAgentMcpResponse } from '../express.schemas.ts';
+import { callExpressAgent, formatExpressAgentResponse } from '../express.utils.ts';
+
+const getUserAgent = () => 'MCP/test (You.com; test-client)';
+
+setDefaultTimeout(20_000);
+
+describe('callExpressAgent', () => {
+  test('returns answer only (WITHOUT web_search tools)', async () => {
+    const result = await callExpressAgent({
+      agentInput: { input: 'What is machine learning?' },
+      getUserAgent,
+    });
+
+    // Verify MCP response structure
+    expect(result).toHaveProperty('answer');
+    expect(typeof result.answer).toBe('string');
+    expect(result.answer.length).toBeGreaterThan(0);
+
+    // Should NOT have results when web_search is not used
+    expect(result.results).toBeUndefined();
+
+    expect(result.agent).toBe('express');
+  });
+
+  test('returns answer and search results (WITH web_search tools)', async () => {
+    const result = await callExpressAgent({
+      agentInput: {
+        input: 'Latest developments in quantum computing',
+        tools: [{ type: 'web_search' }],
+      },
+      getUserAgent,
+    });
+
+    // Verify MCP response has both answer and results
+    expect(result).toHaveProperty('answer');
+    expect(typeof result.answer).toBe('string');
+    expect(result.answer.length).toBeGreaterThan(0);
+
+    expect(result).toHaveProperty('results');
+    expect(result.results).toHaveProperty('web');
+    expect(Array.isArray(result.results?.web)).toBe(true);
+    expect(result.results?.web.length).toBeGreaterThan(0);
+
+    // Verify each search result has required fields
+    const firstResult = result.results?.web[0];
+    expect(firstResult).toHaveProperty('url');
+    expect(firstResult).toHaveProperty('title');
+    expect(firstResult).toHaveProperty('snippet');
+    expect(typeof firstResult?.url).toBe('string');
+    expect(typeof firstResult?.title).toBe('string');
+    expect(typeof firstResult?.snippet).toBe('string');
+    expect(firstResult?.url.length).toBeGreaterThan(0);
+    expect(firstResult?.title.length).toBeGreaterThan(0);
+
+    expect(result.agent).toBe('express');
+  }, 30000);
+
+  test('works without optional parameters', async () => {
+    const result = await callExpressAgent({
+      agentInput: { input: 'What is the capital of France?' },
+      getUserAgent,
+      // No progressToken or sendProgress provided
+    });
+
+    // Should work normally without progress tracking
+    expect(result).toHaveProperty('answer');
+    expect(result.answer.length).toBeGreaterThan(0);
+    expect(result.agent).toBe('express');
+  });
+});
+
+describe('formatExpressAgentResponse', () => {
+  test('formats response with answer only (no search results)', () => {
+    const mockResponse: ExpressAgentMcpResponse = {
+      answer: 'The capital of France is Paris.',
+      agent: 'express',
+    };
+
+    const result = formatExpressAgentResponse(mockResponse);
+
+    // Verify content array has 1 item (answer only)
+    expect(result).toHaveProperty('content');
+    expect(Array.isArray(result.content)).toBe(true);
+    expect(result.content.length).toBe(1);
+
+    // Verify answer content
+    expect(result.content[0]).toHaveProperty('type', 'text');
+    expect(result.content[0]).toHaveProperty('text');
+    expect(result.content[0]?.text).toContain('Express Agent Answer');
+    expect(result.content[0]?.text).toContain('The capital of France is Paris.');
+
+    // Verify structuredContent is minimal (not full response)
+    expect(result).toHaveProperty('structuredContent');
+    expect(result).toHaveProperty('fullResponse');
+    expect(result.structuredContent).toHaveProperty('answer');
+    expect(result.structuredContent).toHaveProperty('hasResults');
+    expect(result.structuredContent).toHaveProperty('resultCount');
+    expect(result.structuredContent).toHaveProperty('agent');
+    expect(result.structuredContent.answer).toBe(mockResponse.answer);
+    expect(result.structuredContent.hasResults).toBe(false);
+    expect(result.structuredContent.resultCount).toBe(0);
+    // No results, so results field should be undefined
+    expect(result.structuredContent.results).toBeUndefined();
+    expect(result.fullResponse).toEqual(mockResponse);
+  });
+
+  test('formats response with answer and search results', () => {
+    const mockResponse: ExpressAgentMcpResponse = {
+      answer: 'Quantum computing is advancing rapidly with recent breakthroughs in error correction.',
+      results: {
+        web: [
+          {
+            url: 'https://example.com/quantum1',
+            title: 'Quantum Computing Breakthrough',
+            snippet: 'Scientists achieve quantum error correction milestone.',
+          },
+          {
+            url: 'https://example.com/quantum2',
+            title: 'Latest in Quantum Research',
+            snippet: 'New quantum processor demonstrates superiority.',
+          },
+        ],
+      },
+      agent: 'express',
+    };
+
+    const result = formatExpressAgentResponse(mockResponse);
+
+    // Verify content array has 2 items (answer + search results)
+    expect(result.content.length).toBe(2);
+
+    // Verify answer comes FIRST
+    expect(result.content[0]?.type).toBe('text');
+    expect(result.content[0]?.text).toContain('Express Agent Answer');
+    expect(result.content[0]?.text).toContain('Quantum computing is advancing rapidly');
+
+    // Verify search results come SECOND (without URLs in text)
+    expect(result.content[1]?.type).toBe('text');
+    expect(result.content[1]?.text).toContain('Search Results');
+    expect(result.content[1]?.text).toContain('Quantum Computing Breakthrough');
+    expect(result.content[1]?.text).toContain('Latest in Quantum Research');
+    // URLs should NOT be in text content
+    expect(result.content[1]?.text).not.toContain('https://example.com/quantum1');
+    expect(result.content[1]?.text).not.toContain('https://example.com/quantum2');
+
+    // Verify structuredContent is minimal with counts
+    expect(result.structuredContent).toHaveProperty('answer');
+    expect(result.structuredContent).toHaveProperty('hasResults');
+    expect(result.structuredContent).toHaveProperty('resultCount');
+    expect(result.structuredContent.answer).toBe(mockResponse.answer);
+    expect(result.structuredContent.hasResults).toBe(true);
+    expect(result.structuredContent.resultCount).toBe(2);
+
+    // URLs should be in structuredContent.results
+    expect(result.structuredContent).toHaveProperty('results');
+    expect(result.structuredContent.results?.web).toBeDefined();
+    expect(result.structuredContent.results?.web?.length).toBe(2);
+    expect(result.structuredContent.results?.web?.[0]).toEqual({
+      url: 'https://example.com/quantum1',
+      title: 'Quantum Computing Breakthrough',
+    });
+    expect(result.structuredContent.results?.web?.[1]).toEqual({
+      url: 'https://example.com/quantum2',
+      title: 'Latest in Quantum Research',
+    });
+
+    // Verify fullResponse has complete data
+    expect(result.fullResponse).toEqual(mockResponse);
+    expect(result.fullResponse.results?.web).toHaveLength(2);
+  });
+
+  test('structuredContent validation for answer only', () => {
+    const mockResponse: ExpressAgentMcpResponse = {
+      answer: 'Neural networks are computational models inspired by biological neurons.',
+      agent: 'express',
+    };
+
+    const result = formatExpressAgentResponse(mockResponse);
+
+    // Verify structure matches minimal schema
+    expect(result.structuredContent).toMatchObject({
+      answer: expect.any(String),
+      hasResults: false,
+      resultCount: 0,
+      agent: 'express',
+    });
+
+    // Verify fullResponse has complete data
+    expect(result.fullResponse.results).toBeUndefined();
+  });
+
+  test('structuredContent validation for answer with results', () => {
+    const mockResponse: ExpressAgentMcpResponse = {
+      answer: 'Recent AI breakthroughs include advances in language models and computer vision.',
+      results: {
+        web: [
+          {
+            url: 'https://example.com/ai-breakthrough',
+            title: 'AI Breakthrough 2025',
+            snippet: 'Major advances in artificial intelligence.',
+          },
+        ],
+      },
+      agent: 'express',
+    };
+
+    const result = formatExpressAgentResponse(mockResponse);
+
+    // Verify structuredContent is minimal with counts
+    expect(result.structuredContent).toHaveProperty('answer');
+    expect(result.structuredContent).toHaveProperty('hasResults');
+    expect(result.structuredContent).toHaveProperty('resultCount');
+    expect(result.structuredContent).toHaveProperty('agent');
+    expect(result.structuredContent.answer).toBe(
+      'Recent AI breakthroughs include advances in language models and computer vision.',
+    );
+    expect(result.structuredContent.agent).toBe('express');
+    expect(result.structuredContent.hasResults).toBe(true);
+    expect(result.structuredContent.resultCount).toBe(1);
+
+    // URLs should be in structuredContent.results
+    expect(result.structuredContent).toHaveProperty('results');
+    expect(result.structuredContent.results?.web).toBeDefined();
+    expect(result.structuredContent.results?.web?.length).toBe(1);
+    expect(result.structuredContent.results?.web?.[0]).toEqual({
+      url: 'https://example.com/ai-breakthrough',
+      title: 'AI Breakthrough 2025',
+    });
+
+    // Verify fullResponse has complete search results
+    expect(result.fullResponse).toEqual(mockResponse);
+    expect(result.fullResponse.results).toBeDefined();
+    expect(Array.isArray(result.fullResponse.results?.web)).toBe(true);
+    expect(result.fullResponse.results?.web.length).toBe(1);
+
+    // Verify search result fields in fullResponse
+    const searchResult = result.fullResponse.results?.web[0];
+    expect(searchResult?.url).toBe('https://example.com/ai-breakthrough');
+    expect(searchResult?.title).toBe('AI Breakthrough 2025');
+    expect(searchResult?.snippet).toBe('Major advances in artificial intelligence.');
+  });
+});

package/src/get-mcp-server.ts

@@ -0,0 +1,17 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import packageJson from '../package.json' with { type: 'json' };
+
+export const getMCpServer = () =>
+  new McpServer(
+    {
+      name: 'You.com',
+      version: packageJson.version,
+    },
+    {
+      capabilities: {
+        logging: {},
+        tools: { listChanged: true },
+      },
+      instructions: `Use this server to search the web, get AI-powered answers with web context, and extract content from web pages using You.com. The you-contents tool extracts page content and returns it in markdown or HTML format. Use HTML format for layout preservation, interactive content, and visual fidelity; use markdown for text extraction and simpler consumption.`,
+    },
+  );

package/src/http.ts

@@ -0,0 +1,72 @@
+import { StreamableHTTPTransport } from '@hono/mcp';
+import { type Context, Hono } from 'hono';
+import { trimTrailingSlash } from 'hono/trailing-slash';
+import packageJson from '../package.json' with { type: 'json' };
+import { registerContentsTool } from './contents/register-contents-tool.ts';
+import { registerExpressTool } from './express/register-express-tool.ts';
+import { getMCpServer } from './get-mcp-server.ts';
+import { registerSearchTool } from './search/register-search-tool.ts';
+import { useGetClientVersion } from './shared/use-client-version.ts';
+
+const extractBearerToken = (authHeader: string | null): string | null => {
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    return null;
+  }
+  return authHeader.slice(7);
+};
+
+const handleMcpRequest = async (c: Context) => {
+  const authHeader = c.req.header('Authorization');
+
+  if (!authHeader) {
+    c.status(401);
+    c.header('Content-Type', 'text/plain');
+    return c.text('Unauthorized: Authorization header required');
+  }
+
+  const YDC_API_KEY = extractBearerToken(authHeader);
+
+  if (!YDC_API_KEY) {
+    c.status(401);
+    c.header('Content-Type', 'text/plain');
+    return c.text('Unauthorized: Bearer token required');
+  }
+  const mcp = getMCpServer();
+  const getUserAgent = useGetClientVersion(mcp);
+
+  registerSearchTool({
+    mcp,
+    YDC_API_KEY,
+    getUserAgent,
+  });
+  registerExpressTool({ mcp, YDC_API_KEY, getUserAgent });
+  registerContentsTool({ mcp, YDC_API_KEY, getUserAgent });
+
+  const transport = new StreamableHTTPTransport();
+  await mcp.connect(transport);
+  const response = await transport.handleRequest(c);
+
+  // Explicitly set Content-Encoding to 'identity' to prevent httpx auto-decompression issues
+  // httpx by default sends Accept-Encoding and attempts decompression, but MCP SSE streams
+  // are not compressed. Setting 'identity' tells clients the response is uncompressed.
+  response?.headers.set('Content-Encoding', 'identity');
+
+  return response;
+};
+
+const app = new Hono();
+app.use(trimTrailingSlash());
+
+app.get('/mcp-health', async (c) => {
+  return c.json({
+    status: 'healthy',
+    timestamp: new Date().toISOString(),
+    version: packageJson.version,
+    service: 'youdotcom-mcp-server',
+  });
+});
+
+app.all('/mcp', handleMcpRequest);
+app.all('/mcp/', handleMcpRequest);
+
+export default app;

package/src/search/register-search-tool.ts

@@ -0,0 +1,87 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { generateErrorReportLink } from '../shared/generate-error-report-link.ts';
+import { getLogger } from '../shared/get-logger.ts';
+import { SearchQuerySchema, SearchStructuredContentSchema } from './search.schemas.ts';
+import { fetchSearchResults, formatSearchResults } from './search.utils.ts';
+
+export const registerSearchTool = ({
+  mcp,
+  YDC_API_KEY,
+  getUserAgent,
+}: {
+  mcp: McpServer;
+  YDC_API_KEY?: string;
+  getUserAgent: () => string;
+}) => {
+  mcp.registerTool(
+    'you-search',
+    {
+      title: 'Web Search',
+      description: 'Web and news search via You.com',
+      inputSchema: SearchQuerySchema.shape,
+      outputSchema: SearchStructuredContentSchema.shape,
+    },
+    async (searchQuery) => {
+      const logger = getLogger(mcp);
+      try {
+        const response = await fetchSearchResults({
+          searchQuery,
+          YDC_API_KEY,
+          getUserAgent,
+        });
+
+        const webCount = response.results.web?.length ?? 0;
+        const newsCount = response.results.news?.length ?? 0;
+
+        if (!webCount && !newsCount) {
+          await logger({
+            level: 'info',
+            data: `No results found for query: "${searchQuery.query}"`,
+          });
+
+          return {
+            content: [{ type: 'text' as const, text: 'No results found.' }],
+            structuredContent: {
+              resultCounts: {
+                web: 0,
+                news: 0,
+                total: 0,
+              },
+            },
+          };
+        }
+
+        await logger({
+          level: 'info',
+          data: `Search successful for query: "${searchQuery.query}" - ${webCount} web results, ${newsCount} news results (${webCount + newsCount} total)`,
+        });
+
+        const { content, structuredContent } = formatSearchResults(response);
+        return { content, structuredContent };
+      } catch (err: unknown) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const reportLink = generateErrorReportLink({
+          errorMessage,
+          tool: 'you-search',
+          clientInfo: getUserAgent(),
+        });
+
+        await logger({
+          level: 'error',
+          data: `Search API call failed: ${errorMessage}\n\nReport this issue: ${reportLink}`,
+        });
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: `Error: ${errorMessage}`,
+            },
+          ],
+          structuredContent: undefined,
+          isError: true,
+        };
+      }
+    },
+  );
+};

package/src/search/tests/search.utils.spec.ts

@@ -0,0 +1,217 @@
+import { describe, expect, test } from 'bun:test';
+import type { SearchResponse } from '../search.schemas.ts';
+import { fetchSearchResults, formatSearchResults } from '../search.utils.ts';
+
+const getUserAgent = () => 'MCP/test (You.com; test-client)';
+
+describe('fetchSearchResults', () => {
+  test('returns valid response structure for basic query', async () => {
+    const result = await fetchSearchResults({
+      searchQuery: { query: 'latest stock news' },
+      getUserAgent,
+    });
+
+    expect(result).toHaveProperty('results');
+    expect(result).toHaveProperty('metadata');
+    expect(result.results).toHaveProperty('web');
+    expect(result.results).toHaveProperty('news');
+    expect(Array.isArray(result.results.web)).toBe(true);
+    expect(Array.isArray(result.results.news)).toBe(true);
+
+    // Assert required metadata fields
+    expect(typeof result.metadata?.query).toBe('string');
+
+    // Optional fields: only assert type if present
+    if (result.metadata?.request_uuid !== undefined) {
+      expect(typeof result.metadata.request_uuid).toBe('string');
+    }
+  });
+
+  test('handles search with filters', async () => {
+    const result = await fetchSearchResults({
+      searchQuery: {
+        query: 'javascript tutorial',
+        count: 3,
+        freshness: 'week',
+        country: 'US',
+      },
+      getUserAgent,
+    });
+
+    expect(result.results.web?.length).toBeLessThanOrEqual(3);
+    expect(result.metadata?.query).toContain('javascript tutorial');
+  });
+
+  test('validates response schema', async () => {
+    const result = await fetchSearchResults({
+      searchQuery: { query: 'latest technology news' },
+      getUserAgent,
+    });
+
+    // Test that web results have required properties
+    // biome-ignore lint/style/noNonNullAssertion: Test
+    const webResult = result.results.web![0];
+
+    expect(webResult).toHaveProperty('url');
+    expect(webResult).toHaveProperty('title');
+    expect(webResult).toHaveProperty('description');
+    expect(webResult).toHaveProperty('snippets');
+    expect(Array.isArray(webResult?.snippets)).toBe(true);
+
+    // Test that news results have required properties
+    // biome-ignore lint/style/noNonNullAssertion: Test
+    const newsResult = result.results.news![0];
+    expect(newsResult).toHaveProperty('url');
+    expect(newsResult).toHaveProperty('title');
+    expect(newsResult).toHaveProperty('description');
+    expect(newsResult).toHaveProperty('page_age');
+  });
+});
+
+describe('formatSearchResults', () => {
+  test('formats web results correctly', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [
+          {
+            url: 'https://example.com',
+            title: 'Test Title',
+            description: 'Test description',
+            snippets: ['snippet 1', 'snippet 2'],
+            page_age: '2023-01-01T00:00:00',
+            authors: ['Author Name'],
+          },
+        ],
+        news: [],
+      },
+      metadata: {
+        request_uuid: 'test-uuid',
+        query: 'test query',
+        latency: 0.1,
+      },
+    };
+
+    const result = formatSearchResults(mockResponse);
+
+    expect(result).toHaveProperty('content');
+    expect(result).toHaveProperty('structuredContent');
+    expect(result).toHaveProperty('fullResponse');
+    expect(Array.isArray(result.content)).toBe(true);
+    expect(result.content[0]).toHaveProperty('type', 'text');
+    expect(result.content[0]).toHaveProperty('text');
+    expect(result.content[0]?.text).toContain('WEB RESULTS:');
+    expect(result.content[0]?.text).toContain('Test Title');
+    // URLs should NOT be in text content
+    expect(result.content[0]?.text).not.toContain('https://example.com');
+    expect(result.structuredContent).toHaveProperty('resultCounts');
+    expect(result.structuredContent.resultCounts).toHaveProperty('web', 1);
+    expect(result.structuredContent.resultCounts).toHaveProperty('news', 0);
+    expect(result.structuredContent.resultCounts).toHaveProperty('total', 1);
+    // URLs should be in structuredContent.results
+    expect(result.structuredContent).toHaveProperty('results');
+    expect(result.structuredContent.results?.web).toBeDefined();
+    expect(result.structuredContent.results?.web?.length).toBe(1);
+    expect(result.structuredContent.results?.web?.[0]).toEqual({
+      url: 'https://example.com',
+      title: 'Test Title',
+    });
+    expect(result.fullResponse).toBe(mockResponse);
+  });
+
+  test('formats news results correctly', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [],
+        news: [
+          {
+            title: 'News Title',
+            description: 'News description',
+            page_age: '2023-01-01T00:00:00',
+            url: 'https://news.com/article',
+          },
+        ],
+      },
+      metadata: {
+        request_uuid: 'test-uuid',
+        query: 'test query',
+        latency: 0.1,
+      },
+    };
+
+    const result = formatSearchResults(mockResponse);
+
+    expect(result.content[0]?.text).toContain('NEWS RESULTS:');
+    expect(result.content[0]?.text).toContain('News Title');
+    expect(result.content[0]?.text).toContain('Published: 2023-01-01T00:00:00');
+    // URLs should NOT be in text content
+    expect(result.content[0]?.text).not.toContain('https://news.com/article');
+    expect(result.structuredContent).toHaveProperty('resultCounts');
+    expect(result.structuredContent.resultCounts).toHaveProperty('web', 0);
+    expect(result.structuredContent.resultCounts).toHaveProperty('news', 1);
+    expect(result.structuredContent.resultCounts).toHaveProperty('total', 1);
+    // URLs should be in structuredContent.results
+    expect(result.structuredContent).toHaveProperty('results');
+    expect(result.structuredContent.results?.news).toBeDefined();
+    expect(result.structuredContent.results?.news?.length).toBe(1);
+    expect(result.structuredContent.results?.news?.[0]).toEqual({
+      url: 'https://news.com/article',
+      title: 'News Title',
+    });
+  });
+
+  test('formats both web and news results', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [
+          {
+            url: 'https://web.com',
+            title: 'Web Title',
+            description: 'Web description',
+            snippets: ['web snippet'],
+            page_age: '2023-01-01T00:00:00',
+            authors: ['Web Author'],
+          },
+        ],
+        news: [
+          {
+            title: 'News Title',
+            description: 'News description',
+            page_age: '2023-01-01T00:00:00',
+            url: 'https://news.com/article',
+          },
+        ],
+      },
+      metadata: {
+        request_uuid: 'test-uuid',
+        query: 'test query',
+        latency: 0.1,
+      },
+    };
+
+    const result = formatSearchResults(mockResponse);
+
+    expect(result.content[0]?.text).toContain('WEB RESULTS:');
+    expect(result.content[0]?.text).toContain('NEWS RESULTS:');
+    expect(result.content[0]?.text).toContain(`=${'='.repeat(49)}`);
+    // URLs should NOT be in text content
+    expect(result.content[0]?.text).not.toContain('https://web.com');
+    expect(result.content[0]?.text).not.toContain('https://news.com/article');
+    expect(result.structuredContent.resultCounts).toHaveProperty('web', 1);
+    expect(result.structuredContent.resultCounts).toHaveProperty('news', 1);
+    expect(result.structuredContent.resultCounts).toHaveProperty('total', 2);
+    // URLs should be in structuredContent.results
+    expect(result.structuredContent).toHaveProperty('results');
+    expect(result.structuredContent.results?.web).toBeDefined();
+    expect(result.structuredContent.results?.news).toBeDefined();
+    expect(result.structuredContent.results?.web?.length).toBe(1);
+    expect(result.structuredContent.results?.news?.length).toBe(1);
+    expect(result.structuredContent.results?.web?.[0]).toEqual({
+      url: 'https://web.com',
+      title: 'Web Title',
+    });
+    expect(result.structuredContent.results?.news?.[0]).toEqual({
+      url: 'https://news.com/article',
+      title: 'News Title',
+    });
+  });
+});

package/src/shared/generate-error-report-link.ts

@@ -0,0 +1,37 @@
+import packageJson from '../../package.json' with { type: 'json' };
+/**
+ * Generates a mailto link for error reporting with pre-filled context
+ * Used by tool error handlers to provide easy error reporting
+ */
+export const generateErrorReportLink = ({
+  errorMessage,
+  tool,
+  clientInfo,
+}: {
+  errorMessage: string;
+  tool: string;
+  clientInfo: string;
+}): string => {
+  const subject = `MCP Server Issue v${packageJson.version}`;
+  const body = `Server Version: v${packageJson.version}
+Client: ${clientInfo}
+Tool: ${tool}
+
+Error Message:
+${errorMessage}
+
+Steps to Reproduce:
+1.
+2.
+3.
+
+Additional Context:
+`;
+
+  const params = new URLSearchParams({
+    subject,
+    body,
+  });
+
+  return `mailto:support@you.com?${params.toString()}`;
+};

package/src/shared/get-logger.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { LoggingMessageNotification } from '@modelcontextprotocol/sdk/types.js';
+
+/**
+ * Creates a logger function that sends messages through MCP server
+ * Used by tool registration files
+ */
+export const getLogger = (mcp: McpServer) => async (params: LoggingMessageNotification['params']) => {
+  await mcp.server.sendLoggingMessage(params);
+};