@youdotcom-oss/api 0.1.1 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdotcom-oss/api",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "description": "You.com API client with bundled CLI for agents supporting Agent Skills",
   "license": "MIT",
   "engines": {

package/src/cli.ts

@@ -4,7 +4,7 @@
  *
  * Commands:
  *   search <query>              - Search the web with You.com
- *   express <input>             - Get AI answers with web context
+ *   deep-search <query>         - Perform deep research with comprehensive answers
  *   contents <url> [url...]     - Extract content from URLs
  *
  * Options:
@@ -14,10 +14,17 @@
  *   --help, -h                  - Show help
  */
 import { parseArgs } from 'node:util'
+import type * as z from 'zod'
 import packageJson from '../package.json' with { type: 'json' }
-import { contentsCommand } from './commands/contents.ts'
-import { expressCommand } from './commands/express.ts'
-import { searchCommand } from './commands/search.ts'
+import { ContentsQuerySchema } from './contents/contents.schemas.ts'
+import { fetchContents } from './contents/contents.utils.ts'
+import { DeepSearchQuerySchema } from './deep-search/deep-search.schemas.ts'
+import { callDeepSearch } from './deep-search/deep-search.utils.ts'
+import { SearchQuerySchema } from './search/search.schemas.ts'
+import { fetchSearchResults } from './search/search.utils.ts'
+import type { GetUserAgent } from './shared/api.types.ts'
+import { type CommandConfig, runCommand } from './shared/command-runner.ts'
+import { buildContentsRequest, buildDeepSearchRequest, buildSearchRequest } from './shared/dry-run-utils.ts'
 import { generateErrorReportLink } from './shared/generate-error-report-link.ts'
 import { useGetUserAgent } from './shared/use-get-user-agents.ts'
 
@@ -35,7 +42,7 @@ Usage: ydc <command> --json <json> [options]
 
 Commands:
   search                      Search the web with You.com
-  express                     Get AI answers with web context
+  deep-search                 Perform deep research with comprehensive answers
   contents                    Extract content from URLs
 
 Global Options:
@@ -43,6 +50,7 @@ Global Options:
   --api-key <key>             You.com API key (overrides YDC_API_KEY)
   --client <name>             Client name for tracking and debugging
   --schema                    Output JSON schema for what can be passed to --json
+  --dry-run                   Show request details without making API call
   --help, -h                  Show this help
 
 Environment Variables:
@@ -55,9 +63,10 @@ Output Format:
 
 Examples:
   ydc search --json '{"query":"AI developments"}' --client Openclaw
-  ydc express --json '{"input":"What happened today?","tools":[{"type":"web_search"}]}' --client MyAgent
+  ydc deep-search --json '{"query":"What are the latest breakthroughs in AI?","search_effort":"high"}' --client MyAgent
   ydc contents --json '{"urls":["https://example.com"],"formats":["markdown"]}'
   ydc search --schema  # Get JSON schema for search --json input
+  ydc search --json '{"query":"AI"}' --dry-run  # Inspect request without API call
   ydc search --json '{"query":"AI"}' | jq '.data.results.web[0].title'
 
 More info: https://github.com/youdotcom-oss/dx-toolkit/tree/main/packages/api
@@ -65,22 +74,84 @@ More info: https://github.com/youdotcom-oss/dx-toolkit/tree/main/packages/api
   process.exit(command ? 0 : 2)
 }
 
+// Command configuration map
+const commands = {
+  search: {
+    schema: SearchQuerySchema,
+    handler: ({
+      input,
+      YDC_API_KEY,
+      getUserAgent,
+    }: {
+      input: z.infer<typeof SearchQuerySchema>
+      YDC_API_KEY: string
+      getUserAgent: GetUserAgent
+    }) => fetchSearchResults({ searchQuery: input, YDC_API_KEY, getUserAgent }),
+    dryRunHandler: ({
+      input,
+      YDC_API_KEY,
+      getUserAgent,
+    }: {
+      input: z.infer<typeof SearchQuerySchema>
+      YDC_API_KEY: string
+      getUserAgent: GetUserAgent
+    }) => buildSearchRequest({ searchQuery: input, YDC_API_KEY, getUserAgent }),
+  },
+  'deep-search': {
+    schema: DeepSearchQuerySchema,
+    handler: ({
+      input,
+      YDC_API_KEY,
+      getUserAgent,
+    }: {
+      input: z.infer<typeof DeepSearchQuerySchema>
+      YDC_API_KEY: string
+      getUserAgent: GetUserAgent
+    }) => callDeepSearch({ deepSearchQuery: input, YDC_API_KEY, getUserAgent }),
+    dryRunHandler: ({
+      input,
+      YDC_API_KEY,
+      getUserAgent,
+    }: {
+      input: z.infer<typeof DeepSearchQuerySchema>
+      YDC_API_KEY: string
+      getUserAgent: GetUserAgent
+    }) => buildDeepSearchRequest({ deepSearchQuery: input, YDC_API_KEY, getUserAgent }),
+  },
+  contents: {
+    schema: ContentsQuerySchema,
+    handler: ({
+      input,
+      YDC_API_KEY,
+      getUserAgent,
+    }: {
+      input: z.infer<typeof ContentsQuerySchema>
+      YDC_API_KEY: string
+      getUserAgent: GetUserAgent
+    }) => fetchContents({ contentsQuery: input, YDC_API_KEY, getUserAgent }),
+    dryRunHandler: ({
+      input,
+      YDC_API_KEY,
+      getUserAgent,
+    }: {
+      input: z.infer<typeof ContentsQuerySchema>
+      YDC_API_KEY: string
+      getUserAgent: GetUserAgent
+    }) => buildContentsRequest({ contentsQuery: input, YDC_API_KEY, getUserAgent }),
+  },
+}
+
+// Validate command
+if (!(command in commands)) {
+  console.error(`Unknown command: ${command}`)
+  console.error(`Run 'ydc --help' for usage`)
+  process.exit(2)
+}
+
+// Execute command
 try {
-  switch (command) {
-    case 'search':
-      await searchCommand(args)
-      break
-    case 'express':
-      await expressCommand(args)
-      break
-    case 'contents':
-      await contentsCommand(args)
-      break
-    default:
-      console.error(`Unknown command: ${command}`)
-      console.error(`Run 'ydc --help' for usage`)
-      process.exit(2)
-  }
+  // Type assertion is safe because we validated command exists above
+  await runCommand(args, commands[command as keyof typeof commands] as CommandConfig<unknown, unknown>)
   process.exit(0)
 } catch (error) {
   console.error(error)

package/src/contents/contents.schemas.ts

@@ -21,20 +21,21 @@ export type ContentsQuery = z.infer<typeof ContentsQuerySchema>
 
 /**
  * Schema for a single content item in the API response
+ * Based on OpenAPI spec: https://you.com/specs/openapi_contents.yaml
  */
 const ContentsItemSchema = z.object({
   url: z.string().describe('URL'),
-  title: z.string().optional().describe('Title'),
-  html: z.string().optional().describe('HTML content'),
-  markdown: z.string().optional().describe('Markdown content'),
+  title: z.string().optional().describe('Title (optional in actual API responses)'),
+  html: z.string().nullable().optional().describe('HTML content'),
+  markdown: z.string().nullable().optional().describe('Markdown content'),
   metadata: z
     .object({
-      jsonld: z.array(z.record(z.string(), z.unknown())).optional().describe('JSON-LD structured data (Schema.org)'),
-      opengraph: z.record(z.string(), z.string()).optional().describe('OpenGraph meta tags'),
-      twitter: z.record(z.string(), z.string()).optional().describe('Twitter Card metadata'),
+      site_name: z.string().nullable().optional().describe('OpenGraph site name'),
+      favicon_url: z.string().describe('Favicon URL'),
     })
+    .nullable()
     .optional()
-    .describe('Structured metadata when available'),
+    .describe('Page metadata (only when metadata format requested)'),
 })
 
 /**

package/src/contents/tests/contents.request.spec.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from 'bun:test'
+import { CONTENTS_API_URL } from '../../shared/api.constants.ts'
+import { buildContentsRequest } from '../../shared/dry-run-utils.ts'
+
+describe('buildContentsRequest', () => {
+  const getUserAgent = () => 'test-agent'
+  const YDC_API_KEY = 'test-key'
+
+  test('builds basic contents request with markdown format', () => {
+    const request = buildContentsRequest({
+      contentsQuery: { urls: ['https://example.com'] },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    expect(request.url).toBe(CONTENTS_API_URL)
+    expect(request.method).toBe('POST')
+    expect(request.headers['X-API-Key']).toBe('test-key')
+    expect(request.headers['Content-Type']).toBe('application/json')
+    expect(request.headers['User-Agent']).toBe('test-agent')
+
+    const body = JSON.parse(request.body!)
+    expect(body.urls).toEqual(['https://example.com'])
+    expect(body.formats).toEqual(['markdown'])
+  })
+
+  test('builds request with multiple URLs', () => {
+    const request = buildContentsRequest({
+      contentsQuery: {
+        urls: ['https://a.com', 'https://b.com', 'https://c.com'],
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.urls).toEqual(['https://a.com', 'https://b.com', 'https://c.com'])
+  })
+
+  test('builds request with multiple formats', () => {
+    const request = buildContentsRequest({
+      contentsQuery: {
+        urls: ['https://example.com'],
+        formats: ['html', 'markdown', 'metadata'],
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.formats).toEqual(['html', 'markdown', 'metadata'])
+  })
+
+  test('builds request with deprecated format parameter', () => {
+    const request = buildContentsRequest({
+      contentsQuery: {
+        urls: ['https://example.com'],
+        format: 'html',
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.formats).toEqual(['html'])
+  })
+
+  test('prefers formats array over deprecated format parameter', () => {
+    const request = buildContentsRequest({
+      contentsQuery: {
+        urls: ['https://example.com'],
+        formats: ['markdown', 'metadata'],
+        format: 'html',
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.formats).toEqual(['markdown', 'metadata'])
+  })
+
+  test('includes crawl_timeout when provided', () => {
+    const request = buildContentsRequest({
+      contentsQuery: {
+        urls: ['https://example.com'],
+        crawl_timeout: 30,
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.crawl_timeout).toBe(30)
+  })
+
+  test('omits crawl_timeout when not provided', () => {
+    const request = buildContentsRequest({
+      contentsQuery: {
+        urls: ['https://example.com'],
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.crawl_timeout).toBeUndefined()
+  })
+})

package/src/contents/tests/contents.schema-validation.spec.ts

@@ -0,0 +1,75 @@
+import { describe, expect, test } from 'bun:test'
+import { ContentsQuerySchema } from '../contents.schemas.ts'
+
+describe('ContentsQuerySchema OpenAPI validation', () => {
+  test('accepts valid contents queries', () => {
+    const validQueries = [
+      { urls: ['https://example.com'] },
+      { urls: ['https://example.com'], formats: ['markdown'] },
+      { urls: ['https://example.com'], formats: ['html', 'markdown'] },
+      { urls: ['https://example.com'], formats: ['markdown', 'metadata'] },
+      { urls: ['https://example.com'], formats: ['html', 'markdown', 'metadata'] },
+      { urls: ['https://example.com'], format: 'html' }, // Deprecated but still supported
+      { urls: ['https://example.com'], crawl_timeout: 30 },
+      { urls: ['https://a.com', 'https://b.com', 'https://c.com'], formats: ['markdown'] },
+    ]
+
+    for (const validQuery of validQueries) {
+      expect(() => ContentsQuerySchema.parse(validQuery)).not.toThrow()
+    }
+  })
+
+  test('rejects invalid contents queries', () => {
+    const invalidQueries = [
+      {}, // Missing urls
+      { urls: [] }, // Empty urls array
+      { urls: ['not-a-url'] }, // Invalid URL
+      { urls: ['https://example.com'], formats: ['invalid'] }, // Invalid format
+      { urls: ['https://example.com'], crawl_timeout: 0 }, // Timeout too low
+      { urls: ['https://example.com'], crawl_timeout: 61 }, // Timeout too high
+    ]
+
+    for (const invalidQuery of invalidQueries) {
+      expect(() => ContentsQuerySchema.parse(invalidQuery)).toThrow()
+    }
+  })
+
+  test('accepts metadata format', () => {
+    const query = {
+      urls: ['https://example.com'],
+      formats: ['metadata'],
+    }
+
+    expect(() => ContentsQuerySchema.parse(query)).not.toThrow()
+  })
+
+  test('accepts all format combinations', () => {
+    const formatCombinations = [
+      ['html'],
+      ['markdown'],
+      ['metadata'],
+      ['html', 'markdown'],
+      ['html', 'metadata'],
+      ['markdown', 'metadata'],
+      ['html', 'markdown', 'metadata'],
+    ]
+
+    for (const formats of formatCombinations) {
+      expect(() => ContentsQuerySchema.parse({ urls: ['https://example.com'], formats })).not.toThrow()
+    }
+  })
+
+  test('crawl_timeout validation', () => {
+    // Valid timeouts (1-60)
+    const validTimeouts = [1, 30, 60]
+    for (const timeout of validTimeouts) {
+      expect(() => ContentsQuerySchema.parse({ urls: ['https://example.com'], crawl_timeout: timeout })).not.toThrow()
+    }
+
+    // Invalid timeouts
+    const invalidTimeouts = [0, -1, 61, 100]
+    for (const timeout of invalidTimeouts) {
+      expect(() => ContentsQuerySchema.parse({ urls: ['https://example.com'], crawl_timeout: timeout })).toThrow()
+    }
+  })
+})

package/src/deep-search/deep-search.schemas.ts

@@ -0,0 +1,48 @@
+import * as z from 'zod'
+
+/**
+ * Search effort levels for deep-search API
+ * Controls computation budget and response time
+ */
+export const SearchEffortSchema = z.enum(['low', 'medium', 'high']).describe('Search effort level')
+
+/**
+ * Input schema for deep-search API
+ * Based on OpenAPI spec: https://docs.you.com/api-reference/deep-search/v1-deep_search
+ *
+ * @public
+ */
+export const DeepSearchQuerySchema = z.object({
+  query: z
+    .string()
+    .min(1, 'Query is required')
+    .describe('The research question or complex query requiring in-depth investigation and multi-step reasoning'),
+  search_effort: SearchEffortSchema.optional()
+    .default('medium')
+    .describe('Computation budget: low (<30s), medium (<60s, default), high (<300s)'),
+})
+
+export type DeepSearchQuery = z.infer<typeof DeepSearchQuerySchema>
+
+/**
+ * Schema for a single source in the deep-search response
+ *
+ * @public
+ */
+const DeepSearchSourceSchema = z.object({
+  url: z.string().describe('Source webpage URL'),
+  title: z.string().describe('Source webpage title'),
+  snippets: z.array(z.string()).describe('Relevant excerpts from the source page used in generating the answer'),
+})
+
+/**
+ * Response schema for deep-search API
+ *
+ * @public
+ */
+export const DeepSearchResponseSchema = z.object({
+  answer: z.string().describe('Comprehensive response with inline citations, formatted in Markdown'),
+  results: z.array(DeepSearchSourceSchema).describe('List of web sources used to generate the answer'),
+})
+
+export type DeepSearchResponse = z.infer<typeof DeepSearchResponseSchema>

package/src/deep-search/deep-search.utils.ts

@@ -0,0 +1,79 @@
+import type * as z from 'zod'
+import { DEEP_SEARCH_API_URL } from '../shared/api.constants.ts'
+import type { GetUserAgent } from '../shared/api.types.ts'
+import { checkResponseForErrors } from '../shared/check-response-for-errors.ts'
+import { type DeepSearchQuery, DeepSearchResponseSchema } from './deep-search.schemas.ts'
+
+/**
+ * Perform deep research using You.com Deep Search API
+ *
+ * @param params - Deep search query parameters
+ * @returns Deep search response with comprehensive answer and sources
+ *
+ * @public
+ */
+export const callDeepSearch = async ({
+  deepSearchQuery,
+  YDC_API_KEY = process.env.YDC_API_KEY,
+  getUserAgent,
+}: {
+  deepSearchQuery: DeepSearchQuery
+  YDC_API_KEY?: string
+  getUserAgent: GetUserAgent
+}) => {
+  if (!YDC_API_KEY) {
+    throw new Error('YDC_API_KEY is required for Deep Search API')
+  }
+
+  const response = await fetch(DEEP_SEARCH_API_URL, {
+    method: 'POST',
+    headers: new Headers({
+      'X-API-Key': YDC_API_KEY,
+      'Content-Type': 'application/json',
+      'User-Agent': getUserAgent(),
+    }),
+    body: JSON.stringify(deepSearchQuery),
+  })
+
+  await checkResponseForErrors(response)
+  const data = await response.json()
+
+  return DeepSearchResponseSchema.parse(data)
+}
+
+/**
+ * Format deep-search response for display
+ * Returns markdown-formatted text with answer and sources
+ *
+ * @param response - Deep search API response
+ * @returns Formatted markdown string
+ *
+ * @public
+ */
+export const formatDeepSearchResponse = (response: z.infer<typeof DeepSearchResponseSchema>): string => {
+  const parts: string[] = []
+
+  // Add the comprehensive answer
+  parts.push('# Answer\n')
+  parts.push(response.answer)
+  parts.push('\n')
+
+  // Add sources section
+  if (response.results && response.results.length > 0) {
+    parts.push('\n## Sources\n')
+
+    for (const [index, source] of response.results.entries()) {
+      parts.push(`\n### ${index + 1}. ${source.title}\n`)
+      parts.push(`**URL:** ${source.url}\n`)
+
+      if (source.snippets && source.snippets.length > 0) {
+        parts.push('\n**Key Excerpts:**\n')
+        for (const snippet of source.snippets) {
+          parts.push(`> ${snippet}\n`)
+        }
+      }
+    }
+  }
+
+  return parts.join('\n')
+}

package/src/deep-search/tests/deep-search.request.spec.ts

@@ -0,0 +1,109 @@
+import { describe, expect, test } from 'bun:test'
+import { DEEP_SEARCH_API_URL } from '../../shared/api.constants.ts'
+import { buildDeepSearchRequest } from '../../shared/dry-run-utils.ts'
+
+describe('buildDeepSearchRequest', () => {
+  const getUserAgent = () => 'test-agent'
+  const YDC_API_KEY = 'test-key'
+
+  test('builds basic deep-search request with query only', () => {
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: { query: 'What is AI?' },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    expect(request.url).toBe(DEEP_SEARCH_API_URL)
+    expect(request.method).toBe('POST')
+    expect(request.headers['X-API-Key']).toBe('test-key')
+    expect(request.headers['Content-Type']).toBe('application/json')
+    expect(request.headers['User-Agent']).toBe('test-agent')
+
+    const body = JSON.parse(request.body!)
+    expect(body.query).toBe('What is AI?')
+    // search_effort not in body when not provided (default applied by schema validation, not dry-run)
+    expect(body.search_effort).toBeUndefined()
+  })
+
+  test('builds request with explicit medium search effort', () => {
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: { query: 'What is AI?', search_effort: 'medium' },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.query).toBe('What is AI?')
+    expect(body.search_effort).toBe('medium')
+  })
+
+  test('builds request with low search effort', () => {
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: {
+        query: 'Quick explanation of JWT',
+        search_effort: 'low',
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.query).toBe('Quick explanation of JWT')
+    expect(body.search_effort).toBe('low')
+  })
+
+  test('builds request with high search effort', () => {
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: {
+        query: 'Comprehensive analysis of climate change impacts',
+        search_effort: 'high',
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.query).toBe('Comprehensive analysis of climate change impacts')
+    expect(body.search_effort).toBe('high')
+  })
+
+  test('builds request with complex research question', () => {
+    const complexQuery = `What are the key differences between microservices and monolithic architecture?
+Include pros and cons of each approach, best use cases, and migration strategies.`
+
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: {
+        query: complexQuery,
+        search_effort: 'high',
+      },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    const body = JSON.parse(request.body!)
+    expect(body.query).toBe(complexQuery)
+    expect(body.search_effort).toBe('high')
+  })
+
+  test('uses correct API URL', () => {
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: { query: 'test' },
+      YDC_API_KEY,
+      getUserAgent,
+    })
+
+    expect(request.url).toBe('https://api.you.com/v1/deep_search')
+  })
+
+  test('includes all required headers', () => {
+    const request = buildDeepSearchRequest({
+      deepSearchQuery: { query: 'test' },
+      YDC_API_KEY: 'my-api-key',
+      getUserAgent: () => 'CustomAgent/1.0',
+    })
+
+    expect(request.headers['X-API-Key']).toBe('my-api-key')
+    expect(request.headers['Content-Type']).toBe('application/json')
+    expect(request.headers['User-Agent']).toBe('CustomAgent/1.0')
+  })
+})

package/src/deep-search/tests/deep-search.schema-validation.spec.ts

@@ -0,0 +1,71 @@
+import { describe, expect, test } from 'bun:test'
+import { DeepSearchQuerySchema, SearchEffortSchema } from '../deep-search.schemas.ts'
+
+describe('DeepSearchQuerySchema OpenAPI validation', () => {
+  test('accepts valid query parameters', () => {
+    const validQueries = [
+      { query: 'What is quantum computing?' },
+      { query: 'Explain machine learning', search_effort: 'low' },
+      { query: 'Latest AI developments', search_effort: 'medium' },
+      { query: 'Comprehensive research on climate change', search_effort: 'high' },
+    ]
+
+    for (const validQuery of validQueries) {
+      expect(() => DeepSearchQuerySchema.parse(validQuery)).not.toThrow()
+    }
+  })
+
+  test('rejects invalid query parameters', () => {
+    const invalidQueries = [
+      {}, // Missing query
+      { query: '' }, // Empty query
+      { query: 'test', search_effort: 'invalid' }, // Invalid search_effort
+      { query: 'test', search_effort: 'extreme' }, // Invalid effort level
+    ]
+
+    for (const invalidQuery of invalidQueries) {
+      expect(() => DeepSearchQuerySchema.parse(invalidQuery)).toThrow()
+    }
+  })
+
+  test('defaults search_effort to medium when not provided', () => {
+    const result = DeepSearchQuerySchema.parse({ query: 'test query' })
+    expect(result.search_effort).toBe('medium')
+  })
+
+  test('SearchEffortSchema accepts all valid effort levels', () => {
+    const validEfforts = ['low', 'medium', 'high']
+
+    for (const effort of validEfforts) {
+      expect(() => SearchEffortSchema.parse(effort)).not.toThrow()
+    }
+  })
+
+  test('SearchEffortSchema rejects invalid effort levels', () => {
+    const invalidEfforts = ['none', 'extreme', 'ultra', 'minimal', '']
+
+    for (const effort of invalidEfforts) {
+      expect(() => SearchEffortSchema.parse(effort)).toThrow()
+    }
+  })
+
+  test('accepts complex research questions', () => {
+    const complexQueries = [
+      {
+        query: 'What are the key differences between REST and GraphQL APIs, and when should each be used?',
+        search_effort: 'high',
+      },
+      {
+        query: 'Compare the advantages and disadvantages of microservices architecture versus monolithic architecture',
+      },
+      {
+        query: 'What happened in AI research during 2024? Provide a comprehensive summary with key breakthroughs.',
+        search_effort: 'high',
+      },
+    ]
+
+    for (const query of complexQueries) {
+      expect(() => DeepSearchQuerySchema.parse(query)).not.toThrow()
+    }
+  })
+})