@youdotcom-oss/mcp 2.1.0 → 3.1.0

package/src/tests/tool.spec.ts

@@ -1,649 +0,0 @@
-import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
-import { Client } from '@modelcontextprotocol/sdk/client/index.js'
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
-import { $ } from 'bun'
-import type { ContentsStructuredContent } from '../contents/contents.schemas.ts'
-import type { ResearchStructuredContent } from '../research/research.schemas.ts'
-import type { SearchStructuredContent } from '../search/search.schema.ts'
-
-let client: Client
-
-beforeAll(async () => {
-  await $`bun run build`
-  const transport = new StdioClientTransport({
-    command: 'npx',
-    args: [Bun.resolveSync('../../bin/stdio', import.meta.dir)],
-    env: {
-      YDC_API_KEY: process.env.YDC_API_KEY ?? '',
-    },
-  })
-
-  client = new Client({
-    name: 'test-client',
-    version: '0.0.1',
-  })
-
-  await client.connect(transport)
-}, 30_000)
-
-afterAll(async () => {
-  await client.close()
-})
-
-describe('registerSearchTool', () => {
-  test('tool is registered and available', async () => {
-    const tools = await client.listTools()
-
-    const searchTool = tools.tools.find((t) => t.name === 'you-search')
-
-    expect(searchTool).toBeDefined()
-    expect(searchTool?.title).toBe('Web Search')
-    expect(searchTool?.description).toContain('Web and news search')
-  })
-
-  test(
-    'performs basic search successfully',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'javascript tutorial',
-          count: 3,
-        },
-      })
-      const content = result.content as { type: string; text: string }[]
-      expect(result).toHaveProperty('content')
-      expect(Array.isArray(content)).toBe(true)
-      expect(content[0]).toHaveProperty('type', 'text')
-      expect(content[0]).toHaveProperty('text')
-
-      const text = content[0]?.text
-      expect(text).toContain('Search Results for')
-      expect(text).toContain('javascript tutorial')
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      // Should have structured content with minimal format
-      expect(result).toHaveProperty('structuredContent')
-      expect(structuredContent).toHaveProperty('resultCounts')
-      expect(structuredContent.resultCounts).toHaveProperty('web')
-      expect(structuredContent.resultCounts).toHaveProperty('news')
-      expect(structuredContent.resultCounts).toHaveProperty('total')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles search with web results formatting',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'react components',
-          count: 2,
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      const text = content[0]?.text
-      expect(text).toContain('WEB RESULTS:')
-      expect(text).toContain('Title:')
-      // URL should be in text content
-      expect(text).toContain('URL:')
-      expect(text).toContain('Description:')
-      expect(text).toContain('Snippets:')
-
-      // Verify structured data has result counts
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      expect(structuredContent.resultCounts.web).toBeGreaterThan(0)
-      expect(structuredContent.resultCounts.total).toBeGreaterThan(0)
-
-      // URLs should be in structuredContent.results
-      expect(structuredContent.results).toBeDefined()
-      expect(structuredContent.results?.web).toBeDefined()
-      expect(structuredContent.results?.web?.length).toBeGreaterThan(0)
-      expect(structuredContent.results?.web?.[0]).toHaveProperty('url')
-      expect(structuredContent.results?.web?.[0]).toHaveProperty('title')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles search with news results',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'technology news',
-          count: 2,
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      const text = content[0]?.text
-
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      // Check if news results are included
-      if (structuredContent.resultCounts.news > 0) {
-        expect(text).toContain('NEWS RESULTS:')
-        expect(text).toContain('Published:')
-        expect(structuredContent.resultCounts.news).toBeGreaterThan(0)
-      }
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles mixed web and news results with proper separation',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'artificial intelligence',
-          count: 3,
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      const text = content[0]?.text
-
-      // Should have web results
-      expect(text).toContain('WEB RESULTS:')
-
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      // If both web and news results exist, check for separator
-      if (structuredContent.resultCounts.news > 0) {
-        expect(text).toContain('NEWS RESULTS:')
-        expect(text).toContain('='.repeat(50))
-      }
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles freshness parameter',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'recent news',
-          freshness: 'week',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]).toHaveProperty('text')
-      expect(content[0]?.text).toContain('recent news')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles country parameter',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'local news',
-          country: 'US',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]).toHaveProperty('text')
-      expect(content[0]?.text).toContain('local news')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles safesearch parameter',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'educational content',
-          safesearch: 'strict',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]).toHaveProperty('text')
-      expect(content[0]?.text).toContain('educational content')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles site: operator in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'react components site:github.com',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]?.text).toContain('react components')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles filetype: operator in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'documentation filetype:pdf',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]?.text).toContain('documentation')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles lang: operator in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'tutorial lang:es',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]?.text).toContain('tutorial')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles + operator for required terms in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'programming +javascript +typescript',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]?.text).toContain('programming')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles - operator for excluded terms in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'tutorial -beginner -basic',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]?.text).toContain('tutorial')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles complex search with multiple operators in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'machine learning tutorial site:github.com filetype:md lang:en',
-          count: 5,
-          offset: 1,
-          freshness: 'month',
-          country: 'US',
-          safesearch: 'moderate',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]).toHaveProperty('text')
-      // Test should pass even if no results (very specific query might have no results)
-
-      // Verify results are limited by count if there are results
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      if (structuredContent.resultCounts.web > 0) {
-        expect(structuredContent.resultCounts.web).toBeLessThanOrEqual(5)
-      }
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles special characters in query',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: 'C++ programming "hello world"',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      expect(content[0]).toHaveProperty('text')
-      expect(content[0]?.text).toContain('C++')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles empty search results gracefully',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: '_',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-
-      // Should still have content even if no results
-      expect(content[0]).toHaveProperty('text')
-
-      const text = content[0]?.text
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      expect(structuredContent.resultCounts.web).toBe(0)
-      expect(structuredContent.resultCounts.news).toBe(0)
-      expect(structuredContent.resultCounts.total).toBe(0)
-      expect(text).toContain('No results found')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'validates structured response format',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: `what's the latest tech news`,
-          count: 2,
-        },
-      })
-
-      const structuredContent = result.structuredContent as SearchStructuredContent
-      // Validate minimal structured content schema
-      expect(structuredContent).toHaveProperty('resultCounts')
-
-      // Check result counts structure
-      const resultCounts = structuredContent.resultCounts
-      expect(resultCounts).toHaveProperty('web')
-      expect(resultCounts).toHaveProperty('news')
-      expect(resultCounts).toHaveProperty('total')
-      expect(typeof resultCounts.web).toBe('number')
-      expect(typeof resultCounts.news).toBe('number')
-      expect(typeof resultCounts.total).toBe('number')
-      expect(resultCounts.total).toBe(resultCounts.web + resultCounts.news)
-    },
-    { retry: 2 },
-  )
-
-  test('handles API errors gracefully', async () => {
-    try {
-      await client.callTool({
-        name: 'you-search',
-        arguments: {
-          query: undefined,
-        },
-      })
-    } catch (error) {
-      // If it errors, that's also acceptable behavior
-      expect(error).toBeDefined()
-    }
-  })
-})
-
-// NOTE: The following tests require a You.com API key with access to the Contents API
-// Using example.com and Wikipedia URLs that work with the Contents API
-describe('registerContentsTool', () => {
-  test('tool is registered and available', async () => {
-    const tools = await client.listTools()
-
-    const contentsTool = tools.tools.find((t) => t.name === 'you-contents')
-
-    expect(contentsTool).toBeDefined()
-    expect(contentsTool?.title).toBe('Extract Web Page Contents')
-    expect(contentsTool?.description).toContain('Extract page content')
-  })
-
-  test(
-    'extracts content from a single URL',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-contents',
-        arguments: {
-          urls: ['https://documentation.you.com/developer-resources/mcp-server'],
-          format: 'markdown',
-        },
-      })
-
-      expect(result).toHaveProperty('content')
-      expect(result).toHaveProperty('structuredContent')
-
-      const content = result.content as { type: string; text: string }[]
-      expect(Array.isArray(content)).toBe(true)
-      expect(content[0]).toHaveProperty('type', 'text')
-      expect(content[0]).toHaveProperty('text')
-
-      const text = content[0]?.text
-      expect(text).toContain('Successfully extracted content')
-      expect(text).toContain('https://documentation.you.com/developer-resources/mcp-server')
-      expect(text).toContain('Formats: markdown')
-
-      const structuredContent = result.structuredContent as ContentsStructuredContent
-      expect(structuredContent).toHaveProperty('count', 1)
-      expect(structuredContent).toHaveProperty('formats')
-      expect(structuredContent.formats).toEqual(['markdown'])
-      expect(structuredContent).toHaveProperty('items')
-      expect(structuredContent.items).toHaveLength(1)
-
-      const item = structuredContent.items[0]
-      expect(item).toBeDefined()
-
-      expect(item).toHaveProperty('url', 'https://documentation.you.com/developer-resources/mcp-server')
-      expect(item).toHaveProperty('markdown')
-      expect(typeof item?.markdown).toBe('string')
-      expect(item?.markdown?.length).toBeGreaterThan(0)
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'extracts content from multiple URLs',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-contents',
-        arguments: {
-          urls: [
-            'https://documentation.you.com/developer-resources/mcp-server',
-            'https://documentation.you.com/developer-resources/python-sdk',
-          ],
-          format: 'markdown',
-        },
-      })
-
-      const structuredContent = result.structuredContent as ContentsStructuredContent
-      expect(structuredContent.count).toBe(2)
-      expect(structuredContent.items).toHaveLength(2)
-
-      const content = result.content as { type: string; text: string }[]
-      const text = content[0]?.text
-      expect(text).toContain('Successfully extracted content from 2 URL(s)')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles html format',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-contents',
-        arguments: {
-          urls: ['https://documentation.you.com/developer-resources/mcp-server'],
-          format: 'html',
-        },
-      })
-
-      const structuredContent = result.structuredContent as ContentsStructuredContent
-      expect(structuredContent.formats).toEqual(['html'])
-
-      const content = result.content as { type: string; text: string }[]
-      const text = content[0]?.text
-      expect(text).toContain('Formats: html')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'defaults to markdown format when not specified',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-contents',
-        arguments: {
-          urls: ['https://documentation.you.com/developer-resources/mcp-server'],
-        },
-      })
-
-      const structuredContent = result.structuredContent as ContentsStructuredContent
-      expect(structuredContent.formats).toEqual(['markdown'])
-    },
-    { retry: 2 },
-  )
-})
-
-describe('registerResearchTool', () => {
-  test('tool is registered and available', async () => {
-    const tools = await client.listTools()
-
-    const researchTool = tools.tools.find((t) => t.name === 'you-research')
-
-    expect(researchTool).toBeDefined()
-    expect(researchTool?.title).toBe('Research')
-    expect(researchTool?.description).toContain('Research a topic')
-  })
-
-  test(
-    'performs basic research successfully',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-research',
-        arguments: {
-          input: 'What is TypeScript?',
-          research_effort: 'lite',
-        },
-      })
-
-      expect(result).toHaveProperty('content')
-      expect(result).toHaveProperty('structuredContent')
-
-      const content = result.content as { type: string; text: string }[]
-      expect(Array.isArray(content)).toBe(true)
-      expect(content[0]).toHaveProperty('type', 'text')
-      expect(content[0]).toHaveProperty('text')
-
-      const text = content[0]?.text
-      expect(typeof text).toBe('string')
-      expect(text?.length).toBeGreaterThan(0)
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'returns structured content with source information',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-research',
-        arguments: {
-          input: 'What are the benefits of REST APIs?',
-          research_effort: 'lite',
-        },
-      })
-
-      const structuredContent = result.structuredContent as ResearchStructuredContent
-      expect(structuredContent).toHaveProperty('content_type', 'text')
-      expect(structuredContent).toHaveProperty('sourceCount')
-      expect(typeof structuredContent.sourceCount).toBe('number')
-      expect(structuredContent.sourceCount).toBeGreaterThan(0)
-
-      expect(structuredContent).toHaveProperty('sources')
-      expect(Array.isArray(structuredContent.sources)).toBe(true)
-      expect(structuredContent.sources.length).toBeGreaterThan(0)
-
-      const source = structuredContent.sources[0]
-      expect(source).toBeDefined()
-      expect(source).toHaveProperty('url')
-      expect(typeof source?.url).toBe('string')
-      expect(source).toHaveProperty('snippetCount')
-      expect(typeof source?.snippetCount).toBe('number')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'text content contains markdown with answer and sources',
-    async () => {
-      const result = await client.callTool({
-        name: 'you-research',
-        arguments: {
-          input: 'What is JWT authentication?',
-          research_effort: 'lite',
-        },
-      })
-
-      const content = result.content as { type: string; text: string }[]
-      const text = content[0]?.text
-      expect(text).toContain('# Answer')
-      expect(text).toContain('## Sources')
-    },
-    { retry: 2 },
-  )
-
-  test(
-    'handles research_effort parameter',
-    async () => {
-      const transport = new StdioClientTransport({
-        command: 'npx',
-        args: [Bun.resolveSync('../../bin/stdio', import.meta.dir)],
-        env: {
-          YDC_API_KEY: process.env.YDC_API_KEY ?? '',
-        },
-      })
-
-      const dedicatedClient = new Client({
-        name: 'test-client-research',
-        version: '0.0.1',
-      })
-
-      await dedicatedClient.connect(transport)
-
-      try {
-        const result = await dedicatedClient.callTool({
-          name: 'you-research',
-          arguments: {
-            input: 'Explain microservices architecture',
-            research_effort: 'standard',
-          },
-        })
-
-        const content = result.content as { type: string; text: string }[]
-        expect(content[0]).toHaveProperty('text')
-        expect(content[0]?.text?.length).toBeGreaterThan(0)
-      } finally {
-        await dedicatedClient.close()
-      }
-    },
-    { retry: 2, timeout: 120_000 },
-  )
-})