@youdotcom-oss/mcp 3.2.2 → 3.3.0

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

@@ -27,31 +27,13 @@ describe('formatSearchResults', () => {
 
     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')
-    // URL and page_age should be in text content
-    expect(result.content[0]?.text).toContain('URL: https://example.com')
-    expect(result.content[0]?.text).toContain('Published: 2023-01-01T00:00:00')
-    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)
-    // All fields 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]).toMatchObject({
-      url: 'https://example.com',
-      title: 'Test Title',
-      page_age: '2023-01-01T00:00:00',
-    })
-    expect(result.fullResponse).toBe(mockResponse)
+    expect(Array.isArray(result)).toBe(true)
+    expect(result[0]).toHaveProperty('type', 'text')
+    expect(result[0]).toHaveProperty('text')
+    expect(result[0]?.text).toContain('WEB RESULTS:')
+    expect(result[0]?.text).toContain('Test Title')
+    expect(result[0]?.text).toContain('URL: https://example.com')
+    expect(result[0]?.text).toContain('Published: 2023-01-01T00:00:00')
   })
 
   test('formats news results correctly', () => {
@@ -76,24 +58,11 @@ describe('formatSearchResults', () => {
 
     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')
-    // URL should be in text content
-    expect(result.content[0]?.text).toContain('URL: 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)
-    // All fields 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]).toMatchObject({
-      url: 'https://news.com/article',
-      title: 'News Title',
-      page_age: '2023-01-01T00:00:00',
-    })
+    expect(result[0]?.text).toContain('NEWS RESULTS:')
+    expect(result[0]?.text).toContain('News Title')
+    expect(result[0]?.text).toContain('Published: 2023-01-01T00:00:00')
+    expect(result[0]?.text).toContain('URL: https://news.com/article')
+    expect(result[0]?.text).toContain('Description: News description')
   })
 
   test('formats both web and news results', () => {
@@ -127,30 +96,97 @@ describe('formatSearchResults', () => {
 
     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 be in text content
-    expect(result.content[0]?.text).toContain('URL: https://web.com')
-    expect(result.content[0]?.text).toContain('URL: 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)
-    // All fields 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]).toMatchObject({
-      url: 'https://web.com',
-      title: 'Web Title',
-      page_age: '2023-01-01T00:00:00',
-    })
-    expect(result.structuredContent.results?.news?.[0]).toMatchObject({
-      url: 'https://news.com/article',
-      title: 'News Title',
-      page_age: '2023-01-01T00:00:00',
-    })
+    expect(result[0]?.text).toContain('WEB RESULTS:')
+    expect(result[0]?.text).toContain('NEWS RESULTS:')
+    expect(result[0]?.text).toContain(`=${'='.repeat(49)}`)
+    expect(result[0]?.text).toContain('URL: https://web.com')
+    expect(result[0]?.text).toContain('URL: https://news.com/article')
+  })
+
+  test('includes page content indicator when livecrawl returns contents', () => {
+    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)
+
+    expect(result[0]?.text).toContain('Page content available:')
+    expect(result[0]?.text).toContain('chars (markdown)')
+    expect(result[0]?.text).toContain('chars (html)')
+  })
+
+  test('omits content indicator when livecrawl contents absent', () => {
+    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[0]?.text).not.toContain('Page content available:')
+  })
+
+  test('includes content 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)
+
+    expect(result[0]?.text).toContain('Page content available:')
+    expect(result[0]?.text).toContain('chars (markdown)')
   })
 })

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:')
+  })
+})

package/src/contents/contents.schemas.ts

@@ -1,30 +0,0 @@
-import * as z from 'zod'
-
-/**
- * Structured content schema for MCP response
- * Includes full content and metadata for each URL
- */
-export const ContentsStructuredContentSchema = z.object({
-  count: z.number().describe('URLs processed'),
-  formats: z.array(z.string()).describe('Content formats requested'),
-  items: z
-    .array(
-      z.object({
-        url: z.string().describe('URL'),
-        title: z.string().optional().describe('Title'),
-        markdown: z.string().optional().describe('Markdown content'),
-        html: z.string().optional().describe('HTML content'),
-        metadata: z
-          .object({
-            favicon_url: z.string().describe('Favicon URL'),
-            site_name: z.string().optional().nullable().describe('Site name'),
-          })
-          .optional()
-          .nullable()
-          .describe('Page metadata'),
-      }),
-    )
-    .describe('Extracted items'),
-})
-
-export type ContentsStructuredContent = z.infer<typeof ContentsStructuredContentSchema>

package/src/research/research.schemas.ts

@@ -1,19 +0,0 @@
-import * as z from 'zod'
-
-// Minimal schema for structuredContent (reduces payload duplication)
-// Full research content is in the text content field
-export const ResearchStructuredContentSchema = z.object({
-  contentType: z.string().describe('Format of the content field'),
-  sourceCount: z.number().describe('Number of sources used'),
-  sources: z
-    .array(
-      z.object({
-        url: z.string().describe('Source URL'),
-        title: z.string().optional().describe('Source title'),
-        snippetCount: z.number().describe('Number of excerpts from this source'),
-      }),
-    )
-    .describe('Sources used in the research answer'),
-})
-
-export type ResearchStructuredContent = z.infer<typeof ResearchStructuredContentSchema>

package/src/search/search.schemas.ts

@@ -1,38 +0,0 @@
-import * as z from 'zod'
-
-// Minimal schema for structuredContent (reduces payload duplication)
-// Excludes metadata (query, search_uuid, latency) as these are not actionable by LLM
-export const SearchStructuredContentSchema = z.object({
-  resultCounts: z.object({
-    web: z.number().describe('Web results'),
-    news: z.number().describe('News results'),
-    total: z.number().describe('Total results'),
-  }),
-  results: z
-    .object({
-      web: z
-        .array(
-          z.object({
-            url: z.string().describe('URL'),
-            title: z.string().describe('Title'),
-            page_age: z.string().optional().describe('Publication timestamp'),
-          }),
-        )
-        .optional()
-        .describe('Web results'),
-      news: z
-        .array(
-          z.object({
-            url: z.string().describe('URL'),
-            title: z.string().describe('Title'),
-            page_age: z.string().describe('Publication timestamp'),
-          }),
-        )
-        .optional()
-        .describe('News results'),
-    })
-    .optional()
-    .describe('Search results'),
-})
-
-export type SearchStructuredContent = z.infer<typeof SearchStructuredContentSchema>