@youdotcom-oss/mcp 3.2.2 → 3.2.3

package/bin/stdio.js

@@ -12572,7 +12572,7 @@ var ResearchQuerySchema = object({
 var ResearchSourceSchema = object({
   url: string2().describe("Source webpage URL"),
   title: string2().optional().describe("Source webpage title"),
-  snippets: array(string2()).describe("Relevant excerpts from the source page used in generating the answer")
+  snippets: array(string2()).optional().describe("Relevant excerpts from the source page used in generating the answer")
 });
 var ResearchOutputSchema = object({
   content: string2().describe("Comprehensive response with inline citations, formatted in Markdown"),
@@ -12634,7 +12634,7 @@ var formatResearchResponse = (response) => {
 `);
       parts.push(`**URL:** ${source.url}
 `);
-      if (source.snippets.length > 0) {
+      if (source.snippets?.length) {
         parts.push(`
 **Key Excerpts:**
 `);
@@ -12747,8 +12747,17 @@ var SearchQuerySchema = object({
   ]).optional().describe("Country code"),
   safesearch: _enum(["off", "moderate", "strict"]).optional().describe("Filter level"),
   livecrawl: _enum(["web", "news", "all"]).optional().describe("Live-crawl sections for full content"),
-  livecrawl_formats: _enum(["html", "markdown"]).optional().describe("Format for crawled content")
+  livecrawl_formats: array(_enum(["html", "markdown"])).optional().describe("Formats for crawled content"),
+  language: LanguageSchema.optional().describe("Language code (BCP 47 format)"),
+  include_domains: array(string2()).max(500).optional().describe("Domains to include in results (up to 500)"),
+  exclude_domains: array(string2()).max(500).optional().describe("Domains to exclude from results (up to 500)"),
+  crawl_timeout: number2().int().min(1).max(60).optional().describe("Crawl timeout in seconds (1-60)")
 });
+var validateSearchQuery = (searchQuery) => {
+  if (searchQuery.include_domains && searchQuery.exclude_domains) {
+    throw new Error("Cannot combine include_domains and exclude_domains");
+  }
+};
 var WebResultSchema = object({
   url: string2().describe("URL"),
   title: string2().describe("Title"),
@@ -12807,23 +12816,18 @@ var fetchSearchResults = async ({
   getUserAgent,
   customHeaders
 }) => {
-  const url = new URL(SEARCH_API_URL);
-  const searchParams = new URLSearchParams;
-  for (const [name, value] of Object.entries(searchQuery)) {
-    if (value !== undefined && value !== null) {
-      searchParams.append(name, `${value}`);
-    }
-  }
-  url.search = searchParams.toString();
+  validateSearchQuery(searchQuery);
   const options = {
-    method: "GET",
+    method: "POST",
     headers: new Headers({
       ...customHeaders,
       "X-API-Key": YDC_API_KEY || "",
+      "Content-Type": "application/json",
       "User-Agent": getUserAgent()
-    })
+    }),
+    body: JSON.stringify(searchQuery)
   };
-  const response = await fetch(url, options);
+  const response = await fetch(SEARCH_API_URL, options);
   if (!response.ok) {
     const errorCode = response.status;
     if (errorCode === 429) {
@@ -20460,7 +20464,7 @@ var EMPTY_COMPLETION_RESULT = {
 // package.json
 var package_default = {
   name: "@youdotcom-oss/mcp",
-  version: "3.2.2",
+  version: "3.2.3",
   description: "You.com MCP server — web search, AI research, and content extraction via You.com APIs",
   license: "MIT",
   engines: {
@@ -20513,7 +20517,7 @@ var package_default = {
   mcpName: "io.github.youdotcom-oss/mcp",
   dependencies: {
     "@modelcontextprotocol/sdk": "^1.28.0",
-    "@youdotcom-oss/api": "0.5.1",
+    "@youdotcom-oss/api": "0.5.2",
     zod: "^4.3.6"
   },
   devDependencies: {
@@ -20630,17 +20634,27 @@ var SearchStructuredContentSchema = object({
     web: array(object({
       url: string2().describe("URL"),
       title: string2().describe("Title"),
-      page_age: string2().optional().describe("Publication timestamp")
+      page_age: string2().optional().describe("Publication timestamp"),
+      snippets: array(string2()).optional().describe("Content snippets"),
+      contents: object({
+        html: string2().optional().describe("Full HTML content"),
+        markdown: string2().optional().describe("Full Markdown content")
+      }).optional().describe("Livecrawled page content")
     })).optional().describe("Web results"),
     news: array(object({
       url: string2().describe("URL"),
       title: string2().describe("Title"),
-      page_age: string2().describe("Publication timestamp")
+      page_age: string2().describe("Publication timestamp"),
+      contents: object({
+        html: string2().optional().describe("Full HTML content"),
+        markdown: string2().optional().describe("Full Markdown content")
+      }).optional().describe("Livecrawled page content")
     })).optional().describe("News results")
   }).optional().describe("Search results")
 });
 
 // src/shared/format-search-results-text.ts
+var formatCharCount = (count) => count.toLocaleString();
 var formatSearchResultsText = (results) => {
   return results.map((result) => {
     const parts = [`Title: ${result.title}`];
@@ -20658,6 +20672,18 @@ var formatSearchResultsText = (results) => {
     } else if (result.snippet) {
       parts.push(`Snippet: ${result.snippet}`);
     }
+    if (result.contents) {
+      const formats = [];
+      if (result.contents.markdown) {
+        formats.push(`${formatCharCount(result.contents.markdown.length)} chars (markdown)`);
+      }
+      if (result.contents.html) {
+        formats.push(`${formatCharCount(result.contents.html.length)} chars (html)`);
+      }
+      if (formats.length > 0) {
+        parts.push(`Page content available: ${formats.join(", ")}`);
+      }
+    }
     return parts.join(`
 `);
   }).join(`
@@ -20675,14 +20701,7 @@ var formatSearchResults = (response) => {
 ${webResults}`;
   }
   if (response.results.news?.length) {
-    const newsResults = response.results.news.map((article) => `Title: ${article.title}
-URL: ${article.url}
-Description: ${article.description}
-Published: ${article.page_age}`).join(`
-
----
-
-`);
+    const newsResults = formatSearchResultsText(response.results.news);
     if (formattedResults) {
       formattedResults += `
 
@@ -20703,15 +20722,24 @@ ${newsResults}`;
       };
       if (result.page_age)
         item.page_age = result.page_age;
+      if (result.snippets?.length)
+        item.snippets = result.snippets;
+      if (result.contents)
+        item.contents = result.contents ?? undefined;
       return item;
     });
   }
   if (response.results.news?.length) {
-    structuredResults.news = response.results.news.map((article) => ({
-      url: article.url,
-      title: article.title,
-      page_age: article.page_age
-    }));
+    structuredResults.news = response.results.news.map((article) => {
+      const item = {
+        url: article.url,
+        title: article.title,
+        page_age: article.page_age
+      };
+      if (article.contents)
+        item.contents = article.contents ?? undefined;
+      return item;
+    });
   }
   return {
     content: [
@@ -20742,7 +20770,7 @@ var registerSearchTool = ({
 }) => {
   mcp.registerTool("you-search", {
     title: "Web Search",
-    description: "Web and news search via You.com",
+    description: "Web and news search via You.com. Supports domain filtering, language selection, livecrawl for full page content, and date freshness controls.",
     inputSchema: SearchQuerySchema.shape,
     outputSchema: SearchStructuredContentSchema.shape
   }, async (searchQuery, { sendNotification }) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdotcom-oss/mcp",
-  "version": "3.2.2",
+  "version": "3.2.3",
   "description": "You.com MCP server — web search, AI research, and content extraction via You.com APIs",
   "license": "MIT",
   "engines": {
@@ -53,7 +53,7 @@
   "mcpName": "io.github.youdotcom-oss/mcp",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.28.0",
-    "@youdotcom-oss/api": "0.5.1",
+    "@youdotcom-oss/api": "0.5.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/server.json

@@ -39,7 +39,7 @@
           "description": "Remote MCP server URL (defaults to https://api.you.com/mcp)",
           "isRequired": false,
           "isSecret": false,
-          "format": "uri"
+          "format": "string"
         }
       ]
     }

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

@@ -96,6 +96,20 @@ describe('formatResearchResults', () => {
     expect(result.structuredContent.sources[0]?.snippetCount).toBe(0)
   })
 
+  test('handles source with undefined snippets', () => {
+    const mockResponse: ResearchResponse = {
+      output: {
+        content: 'Answer',
+        content_type: 'text',
+        sources: [{ url: 'https://example.com/no-snippets', title: 'No Snippets' }],
+      },
+    }
+
+    const result = formatResearchResults(mockResponse)
+
+    expect(result.structuredContent.sources[0]?.snippetCount).toBe(0)
+  })
+
   test('handles response with zero sources', () => {
     const mockResponse: ResearchResponse = {
       output: {

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

@@ -17,7 +17,8 @@ export const registerSearchTool = ({
     'you-search',
     {
       title: 'Web Search',
-      description: 'Web and news search via You.com',
+      description:
+        'Web and news search via You.com. Supports domain filtering, language selection, livecrawl for full page content, and date freshness controls.',
       inputSchema: SearchQuerySchema.shape,
       outputSchema: SearchStructuredContentSchema.shape,
     },

package/src/search/search.schemas.ts

@@ -16,6 +16,14 @@ export const SearchStructuredContentSchema = z.object({
             url: z.string().describe('URL'),
             title: z.string().describe('Title'),
             page_age: z.string().optional().describe('Publication timestamp'),
+            snippets: z.array(z.string()).optional().describe('Content snippets'),
+            contents: z
+              .object({
+                html: z.string().optional().describe('Full HTML content'),
+                markdown: z.string().optional().describe('Full Markdown content'),
+              })
+              .optional()
+              .describe('Livecrawled page content'),
           }),
         )
         .optional()
@@ -26,6 +34,13 @@ export const SearchStructuredContentSchema = z.object({
             url: z.string().describe('URL'),
             title: z.string().describe('Title'),
             page_age: z.string().describe('Publication timestamp'),
+            contents: z
+              .object({
+                html: z.string().optional().describe('Full HTML content'),
+                markdown: z.string().optional().describe('Full Markdown content'),
+              })
+              .optional()
+              .describe('Livecrawled page content'),
           }),
         )
         .optional()

package/src/search/search.utils.ts

@@ -1,4 +1,4 @@
-import type { NewsResult, SearchResponse } from '@youdotcom-oss/api'
+import type { SearchResponse } from '@youdotcom-oss/api'
 import { formatSearchResultsText } from '../shared/format-search-results-text.ts'
 
 export const formatSearchResults = (response: SearchResponse) => {
@@ -10,14 +10,9 @@ export const formatSearchResults = (response: SearchResponse) => {
     formattedResults += `WEB RESULTS:\n\n${webResults}`
   }
 
-  // Format news results
+  // Format news results using shared utility (consistent with web formatting)
   if (response.results.news?.length) {
-    const newsResults = response.results.news
-      .map(
-        (article: NewsResult) =>
-          `Title: ${article.title}\nURL: ${article.url}\nDescription: ${article.description}\nPublished: ${article.page_age}`,
-      )
-      .join('\n\n---\n\n')
+    const newsResults = formatSearchResultsText(response.results.news)
 
     if (formattedResults) {
       formattedResults += `\n\n${'='.repeat(50)}\n\n`
@@ -27,27 +22,45 @@ export const formatSearchResults = (response: SearchResponse) => {
 
   // Extract fields for structuredContent
   const structuredResults: {
-    web?: Array<{ url: string; title: string; page_age?: string }>
-    news?: Array<{ url: string; title: string; page_age: string }>
+    web?: Array<{
+      url: string
+      title: string
+      page_age?: string
+      snippets?: string[]
+      contents?: { html?: string; markdown?: string }
+    }>
+    news?: Array<{ url: string; title: string; page_age: string; contents?: { html?: string; markdown?: string } }>
   } = {}
 
   if (response.results.web?.length) {
     structuredResults.web = response.results.web.map((result) => {
-      const item: { url: string; title: string; page_age?: string } = {
+      const item: {
+        url: string
+        title: string
+        page_age?: string
+        snippets?: string[]
+        contents?: { html?: string; markdown?: string }
+      } = {
         url: result.url,
         title: result.title,
       }
       if (result.page_age) item.page_age = result.page_age
+      if (result.snippets?.length) item.snippets = result.snippets
+      if (result.contents) item.contents = result.contents ?? undefined
       return item
     })
   }
 
   if (response.results.news?.length) {
-    structuredResults.news = response.results.news.map((article) => ({
-      url: article.url,
-      title: article.title,
-      page_age: article.page_age,
-    }))
+    structuredResults.news = response.results.news.map((article) => {
+      const item: { url: string; title: string; page_age: string; contents?: { html?: string; markdown?: string } } = {
+        url: article.url,
+        title: article.title,
+        page_age: article.page_age,
+      }
+      if (article.contents) item.contents = article.contents ?? undefined
+      return item
+    })
   }
 
   return {

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

@@ -0,0 +1,123 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from 'bun:test'
+import { Client } from '@modelcontextprotocol/sdk/client/index.js'
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js'
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { SearchResponse } from '@youdotcom-oss/api'
+import * as api from '@youdotcom-oss/api'
+import { registerSearchTool } from '../register-search-tool.ts'
+
+const emptyResponse: SearchResponse = {
+  results: { web: [], news: [] },
+  metadata: { search_uuid: 'test', query: 'test', latency: 0 },
+}
+
+const oneResultResponse: SearchResponse = {
+  results: {
+    web: [
+      {
+        url: 'https://example.com',
+        title: 'Example',
+        description: 'A test result',
+        snippets: ['snippet'],
+        page_age: '2025-01-01T00:00:00',
+        authors: [],
+      },
+    ],
+    news: [],
+  },
+  metadata: { search_uuid: 'test', query: 'test', latency: 0.1 },
+}
+
+let mockFetchResponse: SearchResponse | Error = emptyResponse
+let fetchSearchResultsSpy: ReturnType<typeof spyOn<typeof api, 'fetchSearchResults'>> | undefined
+let generateErrorReportLinkSpy: ReturnType<typeof spyOn<typeof api, 'generateErrorReportLink'>> | undefined
+
+type Cleanup = () => Promise<void>
+
+const setupMcpClient = async (): Promise<{ client: Client; cleanup: Cleanup }> => {
+  const server = new McpServer({ name: 'test', version: '0.0.0' }, { capabilities: { logging: {}, tools: {} } })
+  registerSearchTool({
+    mcp: server,
+    YDC_API_KEY: 'test-key',
+    getUserAgent: () => 'test-agent',
+  })
+
+  const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair()
+  await server.connect(serverTransport)
+
+  const client = new Client({ name: 'test-client', version: '0.0.0' })
+  await client.connect(clientTransport)
+
+  const cleanup = async () => {
+    await client.close()
+    await server.close()
+  }
+
+  return { client, cleanup }
+}
+
+describe('registerSearchTool', () => {
+  let cleanup: Cleanup | undefined
+
+  beforeEach(() => {
+    mockFetchResponse = emptyResponse
+    fetchSearchResultsSpy = spyOn(api, 'fetchSearchResults').mockImplementation(async () => {
+      if (mockFetchResponse instanceof Error) throw mockFetchResponse
+      return mockFetchResponse
+    })
+    generateErrorReportLinkSpy = spyOn(api, 'generateErrorReportLink').mockImplementation(
+      () => 'https://example.com/report',
+    )
+  })
+
+  afterEach(async () => {
+    if (cleanup) {
+      await cleanup()
+      cleanup = undefined
+    }
+    fetchSearchResultsSpy?.mockRestore()
+    fetchSearchResultsSpy = undefined
+    generateErrorReportLinkSpy?.mockRestore()
+    generateErrorReportLinkSpy = undefined
+  })
+
+  test('handles empty search results gracefully', async () => {
+    const result = await setupMcpClient()
+    cleanup = result.cleanup
+
+    const toolResult = await result.client.callTool({ name: 'you-search', arguments: { query: 'nonexistent' } })
+
+    expect(toolResult.content).toEqual([{ type: 'text', text: 'No results found.' }])
+    expect(toolResult.structuredContent).toEqual({
+      resultCounts: { web: 0, news: 0, total: 0 },
+    })
+  })
+
+  test('returns formatted results for successful search', async () => {
+    mockFetchResponse = oneResultResponse
+    const result = await setupMcpClient()
+    cleanup = result.cleanup
+
+    const toolResult = await result.client.callTool({ name: 'you-search', arguments: { query: 'example' } })
+
+    const text = (toolResult.content as Array<{ type: string; text: string }>)[0]?.text
+    expect(text).toContain('Example')
+    expect(text).toContain('https://example.com')
+
+    const structured = toolResult.structuredContent as Record<string, unknown>
+    expect(structured).toHaveProperty('resultCounts')
+    expect((structured as { resultCounts: { total: number } }).resultCounts.total).toBe(1)
+  })
+
+  test('returns error when API call fails', async () => {
+    mockFetchResponse = new Error('API rate limit exceeded')
+    const result = await setupMcpClient()
+    cleanup = result.cleanup
+
+    const toolResult = await result.client.callTool({ name: 'you-search', arguments: { query: 'test' } })
+
+    expect(toolResult.isError).toBe(true)
+    const text = (toolResult.content as Array<{ type: string; text: string }>)[0]?.text
+    expect(text).toContain('API rate limit exceeded')
+  })
+})

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

@@ -50,6 +50,7 @@ describe('formatSearchResults', () => {
       url: 'https://example.com',
       title: 'Test Title',
       page_age: '2023-01-01T00:00:00',
+      snippets: ['snippet 1', 'snippet 2'],
     })
     expect(result.fullResponse).toBe(mockResponse)
   })
@@ -79,8 +80,9 @@ describe('formatSearchResults', () => {
     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')
-    // URL should be in text content
+    // URL and Description should be in text content (routed through formatSearchResultsText)
     expect(result.content[0]?.text).toContain('URL: https://news.com/article')
+    expect(result.content[0]?.text).toContain('Description: News description')
     expect(result.structuredContent).toHaveProperty('resultCounts')
     expect(result.structuredContent.resultCounts).toHaveProperty('web', 0)
     expect(result.structuredContent.resultCounts).toHaveProperty('news', 1)
@@ -146,6 +148,7 @@ describe('formatSearchResults', () => {
       url: 'https://web.com',
       title: 'Web Title',
       page_age: '2023-01-01T00:00:00',
+      snippets: ['web snippet'],
     })
     expect(result.structuredContent.results?.news?.[0]).toMatchObject({
       url: 'https://news.com/article',
@@ -153,4 +156,136 @@ describe('formatSearchResults', () => {
       page_age: '2023-01-01T00:00:00',
     })
   })
+
+  test('includes contents in structuredContent and text indicator when livecrawl returns page content', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [
+          {
+            url: 'https://example.com',
+            title: 'Livecrawl Title',
+            description: 'A page with content',
+            snippets: ['snippet'],
+            page_age: '2023-01-01T00:00:00',
+            authors: [],
+            contents: {
+              markdown: 'Full page content in markdown format.',
+              html: '<p>Full page content in HTML format.</p>',
+            },
+          },
+        ],
+        news: [],
+      },
+      metadata: {
+        search_uuid: 'test-uuid',
+        query: 'livecrawl test',
+        latency: 0.5,
+      },
+    }
+
+    const result = formatSearchResults(mockResponse)
+
+    // Text content should include the contents indicator
+    expect(result.content[0]?.text).toContain('Page content available:')
+    expect(result.content[0]?.text).toContain('chars (markdown)')
+    expect(result.content[0]?.text).toContain('chars (html)')
+
+    // structuredContent should include contents
+    expect(result.structuredContent.results?.web?.[0]).toMatchObject({
+      url: 'https://example.com',
+      title: 'Livecrawl Title',
+      contents: {
+        markdown: 'Full page content in markdown format.',
+        html: '<p>Full page content in HTML format.</p>',
+      },
+    })
+  })
+
+  test('omits contents when not present in response', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [
+          {
+            url: 'https://example.com',
+            title: 'No Content',
+            description: 'A page without livecrawl',
+            snippets: ['snippet'],
+          },
+        ],
+        news: [],
+      },
+      metadata: {
+        search_uuid: 'test-uuid',
+        query: 'test',
+        latency: 0.1,
+      },
+    }
+
+    const result = formatSearchResults(mockResponse)
+
+    expect(result.content[0]?.text).not.toContain('Page content available:')
+    expect(result.structuredContent.results?.web?.[0]?.contents).toBeUndefined()
+  })
+
+  test('includes contents indicator for news results with livecrawl', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [],
+        news: [
+          {
+            title: 'News with Content',
+            description: 'Breaking news',
+            page_age: '2023-01-01T00:00:00',
+            url: 'https://news.com/article',
+            contents: {
+              markdown: 'Full news article content in markdown.',
+            },
+          },
+        ],
+      },
+      metadata: {
+        search_uuid: 'test-uuid',
+        query: 'news livecrawl test',
+        latency: 0.4,
+      },
+    }
+
+    const result = formatSearchResults(mockResponse)
+
+    // Text content should include the contents indicator for news too
+    expect(result.content[0]?.text).toContain('Page content available:')
+    expect(result.content[0]?.text).toContain('chars (markdown)')
+
+    // structuredContent should include contents for news
+    expect(result.structuredContent.results?.news?.[0]).toMatchObject({
+      url: 'https://news.com/article',
+      title: 'News with Content',
+      contents: { markdown: 'Full news article content in markdown.' },
+    })
+  })
+
+  test('includes snippets in structuredContent for web results', () => {
+    const mockResponse: SearchResponse = {
+      results: {
+        web: [
+          {
+            url: 'https://example.com',
+            title: 'With Snippets',
+            description: 'Has snippets',
+            snippets: ['first snippet', 'second snippet'],
+          },
+        ],
+        news: [],
+      },
+      metadata: {
+        search_uuid: 'test-uuid',
+        query: 'test',
+        latency: 0.1,
+      },
+    }
+
+    const result = formatSearchResults(mockResponse)
+
+    expect(result.structuredContent.results?.web?.[0]?.snippets).toEqual(['first snippet', 'second snippet'])
+  })
 })

package/src/shared/format-search-results-text.ts

@@ -9,8 +9,14 @@ type GenericSearchResult = {
   snippet?: string
   snippets?: string[]
   page_age?: string
+  contents?: { html?: string; markdown?: string }
 }
 
+/**
+ * Format a character count with locale-aware number formatting
+ */
+const formatCharCount = (count: number): string => count.toLocaleString()
+
 /**
  * Format array of search results into display text
  * Used by search result formatting
@@ -43,6 +49,20 @@ export const formatSearchResultsText = (results: GenericSearchResult[]): string
         parts.push(`Snippet: ${result.snippet}`)
       }
 
+      // Add contents indicator if livecrawl returned page content
+      if (result.contents) {
+        const formats: string[] = []
+        if (result.contents.markdown) {
+          formats.push(`${formatCharCount(result.contents.markdown.length)} chars (markdown)`)
+        }
+        if (result.contents.html) {
+          formats.push(`${formatCharCount(result.contents.html.length)} chars (html)`)
+        }
+        if (formats.length > 0) {
+          parts.push(`Page content available: ${formats.join(', ')}`)
+        }
+      }
+
       return parts.join('\n')
     })
     .join('\n\n')

package/src/shared/tests/format-search-results-text.spec.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from 'bun:test'
+import { formatSearchResultsText } from '../format-search-results-text.ts'
+
+describe('formatSearchResultsText', () => {
+  test('formats basic search results with title and URL', () => {
+    const result = formatSearchResultsText([{ url: 'https://example.com', title: 'Test' }])
+
+    expect(result).toContain('Title: Test')
+    expect(result).toContain('URL: https://example.com')
+  })
+
+  test('includes page_age when present', () => {
+    const result = formatSearchResultsText([{ url: 'https://example.com', title: 'Test', page_age: '2023-01-01' }])
+
+    expect(result).toContain('Published: 2023-01-01')
+  })
+
+  test('includes description when present', () => {
+    const result = formatSearchResultsText([
+      { url: 'https://example.com', title: 'Test', description: 'A description' },
+    ])
+
+    expect(result).toContain('Description: A description')
+  })
+
+  test('includes snippets array when present', () => {
+    const result = formatSearchResultsText([{ url: 'https://example.com', title: 'Test', snippets: ['one', 'two'] }])
+
+    expect(result).toContain('Snippets:')
+    expect(result).toContain('- one')
+    expect(result).toContain('- two')
+  })
+
+  test('includes single snippet when present', () => {
+    const result = formatSearchResultsText([{ url: 'https://example.com', title: 'Test', snippet: 'a snippet' }])
+
+    expect(result).toContain('Snippet: a snippet')
+  })
+
+  test('formats multiple results with separator', () => {
+    const result = formatSearchResultsText([
+      { url: 'https://a.com', title: 'A' },
+      { url: 'https://b.com', title: 'B' },
+    ])
+
+    expect(result).toContain('Title: A')
+    expect(result).toContain('Title: B')
+    expect(result).toContain('\n\n')
+  })
+
+  test('handles empty results array', () => {
+    const result = formatSearchResultsText([])
+
+    expect(result).toBe('')
+  })
+
+  test('includes contents indicator when markdown content is present', () => {
+    const result = formatSearchResultsText([
+      {
+        url: 'https://example.com',
+        title: 'Test',
+        contents: { markdown: 'A'.repeat(4523) },
+      },
+    ])
+
+    expect(result).toContain('Page content available:')
+    expect(result).toContain('4,523 chars (markdown)')
+  })
+
+  test('includes contents indicator for both markdown and html', () => {
+    const result = formatSearchResultsText([
+      {
+        url: 'https://example.com',
+        title: 'Test',
+        contents: { markdown: 'markdown content', html: '<p>html content</p>' },
+      },
+    ])
+
+    expect(result).toContain('Page content available:')
+    expect(result).toContain('chars (markdown)')
+    expect(result).toContain('chars (html)')
+  })
+
+  test('omits contents indicator when contents object has no content', () => {
+    const result = formatSearchResultsText([{ url: 'https://example.com', title: 'Test', contents: {} }])
+
+    expect(result).not.toContain('Page content available:')
+  })
+
+  test('omits contents indicator when contents is not present', () => {
+    const result = formatSearchResultsText([{ url: 'https://example.com', title: 'Test' }])
+
+    expect(result).not.toContain('Page content available:')
+  })
+})