ai-functions 2.1.3 → 2.4.0

package/test/core-functions.test.ts

@@ -2,113 +2,49 @@
  * Tests for core AI functions
  *
  * These tests verify the API contracts for each function.
- * Tests marked with .skipIf(!hasGateway) require actual AI calls.
+ * Tests require actual AI calls via the Cloudflare AI Gateway.
  */
 
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { stringify as yamlStringify } from 'yaml'
+import { describe, it, expect } from 'vitest'
+import { generateText, generateObject } from '../src/generate.js'
+import { z } from 'zod'
 
 // Skip tests if no gateway configured
-const hasGateway = !!process.env.AI_GATEWAY_URL || !!process.env.ANTHROPIC_API_KEY
-
-// ============================================================================
-// Mock implementations for unit tests
-// ============================================================================
-
-// Mock generate function that all others should call
-const mockGenerate = vi.fn()
+const hasGateway = !!process.env.AI_GATEWAY_URL
 
 // ============================================================================
 // ai() - Direct text generation
 // ============================================================================
 
-describe('ai()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue('Generated text')
-  })
-
-  it('should accept a string prompt', async () => {
-    const ai = createMockAi()
-    const result = await ai('Write a haiku')
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'text',
-      'Write a haiku',
-      expect.any(Object)
-    )
-    expect(result).toBe('Generated text')
-  })
-
-  it('should accept tagged template literal', async () => {
-    const ai = createMockAi()
-    const topic = 'TypeScript'
-    const result = await ai`Write about ${topic}`
+describe.skipIf(!hasGateway)('ai()', () => {
+  it('should generate text from a string prompt', async () => {
+    const result = await generateText({
+      model: 'haiku',
+      prompt: 'Say "hello world" and nothing else.',
+    })
 
-    expect(mockGenerate).toHaveBeenCalled()
-    const [, prompt] = mockGenerate.mock.calls[0]
-    expect(prompt).toContain('TypeScript')
-    expect(result).toBe('Generated text')
+    expect(result.text).toBeDefined()
+    expect(typeof result.text).toBe('string')
+    expect(result.text.toLowerCase()).toContain('hello')
   })
 
-  it('should accept options parameter', async () => {
-    const ai = createMockAi()
-    await ai`test`({ model: 'claude-opus-4-5' })
+  it('should respect model parameter', async () => {
+    const result = await generateText({
+      model: 'haiku',
+      prompt: 'Respond with just the word "yes".',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'text',
-      'test',
-      expect.objectContaining({ model: 'claude-opus-4-5' })
-    )
+    expect(result.text).toBeDefined()
+    expect(result.text.toLowerCase()).toContain('yes')
   })
 
   it('should return string type', async () => {
-    const ai = createMockAi()
-    const result = await ai('test')
-    expect(typeof result).toBe('string')
-  })
-})
-
-// ============================================================================
-// summarize() - Condense text
-// ============================================================================
-
-describe('summarize()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue('Summary of content')
-  })
-
-  it('should accept text to summarize', async () => {
-    const summarize = createMockSummarize()
-    const result = await summarize`${longArticle}`
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'summary',
-      expect.stringContaining('article'),
-      expect.any(Object)
-    )
-    expect(result).toBe('Summary of content')
-  })
-
-  it('should support length option', async () => {
-    const summarize = createMockSummarize()
-    await summarize`${longArticle}`({ length: 'short' })
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'summary',
-      expect.any(String),
-      expect.objectContaining({ length: 'short' })
-    )
-  })
-
-  it('should support audience option', async () => {
-    const summarize = createMockSummarize()
-    await summarize`${technicalReport}${{ audience: 'executives', focus: 'business impact' }}`
+    const result = await generateText({
+      model: 'haiku',
+      prompt: 'Say "test".',
+    })
 
-    const [, prompt] = mockGenerate.mock.calls[0]
-    expect(prompt).toContain('executives')
-    expect(prompt).toContain('business impact')
+    expect(typeof result.text).toBe('string')
   })
 })
 
@@ -116,51 +52,41 @@ describe('summarize()', () => {
 // is() - Boolean classification
 // ============================================================================
 
-describe('is()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-  })
-
-  it('should return boolean true', async () => {
-    mockGenerate.mockResolvedValue(true)
-    const is = createMockIs()
-
-    const result = await is`${'hello@example.com'} a valid email?`
-    expect(result).toBe(true)
-  })
-
-  it('should return boolean false', async () => {
-    mockGenerate.mockResolvedValue(false)
-    const is = createMockIs()
+describe.skipIf(!hasGateway)('is()', () => {
+  it('should return boolean true for valid classification', async () => {
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        isValid: z.boolean().describe('Is this a valid email address?'),
+      }),
+      prompt: 'Is "hello@example.com" a valid email address?',
+    })
 
-    const result = await is`${'not-an-email'} a valid email?`
-    expect(result).toBe(false)
+    expect(result.object.isValid).toBe(true)
   })
 
-  it('should accept natural question format', async () => {
-    mockGenerate.mockResolvedValue(true)
-    const is = createMockIs()
-
-    await is`${'The product is amazing!'} positive sentiment?`
+  it('should return boolean false for invalid classification', async () => {
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        isValid: z.boolean().describe('Is this a valid email address?'),
+      }),
+      prompt: 'Is "not-an-email" a valid email address?',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'boolean',
-      expect.stringContaining('positive sentiment'),
-      expect.any(Object)
-    )
+    expect(result.object.isValid).toBe(false)
   })
 
-  it('should support model option for complex classifications', async () => {
-    mockGenerate.mockResolvedValue(true)
-    const is = createMockIs()
-
-    await is`${claim} factually accurate?`({ model: 'claude-opus-4-5' })
+  it('should handle sentiment classification', async () => {
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        isPositive: z.boolean().describe('Is this positive sentiment?'),
+      }),
+      prompt: 'Is "I love this product, it\'s amazing!" positive sentiment?',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'boolean',
-      expect.any(String),
-      expect.objectContaining({ model: 'claude-opus-4-5' })
-    )
+    expect(result.object.isPositive).toBe(true)
   })
 })
 
@@ -168,41 +94,31 @@ describe('is()', () => {
 // list() - Generate a list
 // ============================================================================
 
-describe('list()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue(['Item 1', 'Item 2', 'Item 3'])
-  })
-
+describe.skipIf(!hasGateway)('list()', () => {
   it('should return an array of strings', async () => {
-    const list = createMockList()
-    const result = await list`startup ideas for ${industry}`
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        items: z.array(z.string()).describe('List of 3 colors'),
+      }),
+      prompt: 'List exactly 3 colors.',
+    })
 
-    expect(Array.isArray(result)).toBe(true)
-    expect(result).toHaveLength(3)
-    expect(result.every((item: unknown) => typeof item === 'string')).toBe(true)
+    expect(Array.isArray(result.object.items)).toBe(true)
+    expect(result.object.items.length).toBeGreaterThanOrEqual(1)
+    expect(result.object.items.every((item: unknown) => typeof item === 'string')).toBe(true)
   })
 
   it('should respect count in prompt', async () => {
-    const list = createMockList()
-    await list`10 blog post titles for ${topic}`
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'list',
-      expect.stringContaining('10'),
-      expect.any(Object)
-    )
-  })
-
-  it('should support count option', async () => {
-    const list = createMockList()
-    await list('startup ideas', { count: 10 })
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        items: z.array(z.string()).describe('List of items'),
+      }),
+      prompt: 'List exactly 5 fruits.',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'list',
-      'startup ideas',
-      expect.objectContaining({ count: 10 })
-    )
+    expect(result.object.items.length).toBe(5)
   })
 })
 
@@ -210,40 +126,21 @@ describe('list()', () => {
 // lists() - Generate multiple named lists
 // ============================================================================
 
-describe('lists()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue({
-      pros: ['Pro 1', 'Pro 2'],
-      cons: ['Con 1', 'Con 2'],
-    })
-  })
-
+describe.skipIf(!hasGateway)('lists()', () => {
   it('should return named lists object', async () => {
-    const lists = createMockLists()
-    const result = await lists`pros and cons of ${topic}`
-
-    expect(result).toHaveProperty('pros')
-    expect(result).toHaveProperty('cons')
-    expect(Array.isArray(result.pros)).toBe(true)
-    expect(Array.isArray(result.cons)).toBe(true)
-  })
-
-  it('should support SWOT analysis format', async () => {
-    mockGenerate.mockResolvedValue({
-      strengths: ['S1'],
-      weaknesses: ['W1'],
-      opportunities: ['O1'],
-      threats: ['T1'],
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        pros: z.array(z.string()).describe('List of pros/advantages'),
+        cons: z.array(z.string()).describe('List of cons/disadvantages'),
+      }),
+      prompt: 'List 2 pros and 2 cons of working remotely.',
     })
 
-    const lists = createMockLists()
-    const result = await lists`SWOT analysis for ${{ company, market }}`
-
-    expect(result).toHaveProperty('strengths')
-    expect(result).toHaveProperty('weaknesses')
-    expect(result).toHaveProperty('opportunities')
-    expect(result).toHaveProperty('threats')
+    expect(result.object).toHaveProperty('pros')
+    expect(result.object).toHaveProperty('cons')
+    expect(Array.isArray(result.object.pros)).toBe(true)
+    expect(Array.isArray(result.object.cons)).toBe(true)
   })
 })
 
@@ -251,37 +148,39 @@ describe('lists()', () => {
 // extract() - Extract from text
 // ============================================================================
 
-describe('extract()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue(['John Smith', 'Jane Doe'])
-  })
-
+describe.skipIf(!hasGateway)('extract()', () => {
   it('should extract items from text', async () => {
-    const extract = createMockExtract()
-    const result = await extract`person names from ${article}`
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        names: z.array(z.string()).describe('Person names mentioned in the text'),
+      }),
+      prompt:
+        'Extract all person names from: "John Smith met with Jane Doe yesterday. Bob was also there."',
+    })
 
-    expect(Array.isArray(result)).toBe(true)
-    expect(result).toContain('John Smith')
-    expect(result).toContain('Jane Doe')
+    expect(Array.isArray(result.object.names)).toBe(true)
+    expect(result.object.names.length).toBeGreaterThanOrEqual(2)
   })
 
   it('should support schema for structured extraction', async () => {
-    mockGenerate.mockResolvedValue([
-      { name: 'Acme Corp', role: 'competitor' },
-      { name: 'Beta Inc', role: 'partner' },
-    ])
-
-    const extract = createMockExtract()
-    const result = await extract`companies from ${text}${{
-      schema: {
-        name: 'Company name',
-        role: 'mentioned as: competitor | partner | customer',
-      },
-    }}`
-
-    expect(result[0]).toHaveProperty('name')
-    expect(result[0]).toHaveProperty('role')
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        companies: z.array(
+          z.object({
+            name: z.string().describe('Company name'),
+            role: z.enum(['competitor', 'partner', 'customer']).describe('Role mentioned'),
+          })
+        ),
+      }),
+      prompt:
+        'Extract companies from: "Our competitor Acme Corp launched a new product. Our partner Beta Inc helped with distribution."',
+    })
+
+    expect(result.object.companies.length).toBeGreaterThanOrEqual(2)
+    expect(result.object.companies[0]).toHaveProperty('name')
+    expect(result.object.companies[0]).toHaveProperty('role')
   })
 })
 
@@ -289,40 +188,26 @@ describe('extract()', () => {
 // write() - Generate text content
 // ============================================================================
 
-describe('write()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue('Generated content here...')
-  })
-
+describe.skipIf(!hasGateway)('write()', () => {
   it('should generate text content', async () => {
-    const write = createMockWrite()
-    const result = await write`professional email to ${recipient} about ${subject}`
-
-    expect(typeof result).toBe('string')
-    expect(result.length).toBeGreaterThan(0)
-  })
-
-  it('should support tone option', async () => {
-    const write = createMockWrite()
-    await write('blog post', { tone: 'casual', topic: 'TypeScript' })
+    const result = await generateText({
+      model: 'haiku',
+      prompt: 'Write a short greeting message (1-2 sentences).',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'text',
-      'blog post',
-      expect.objectContaining({ tone: 'casual' })
-    )
+    expect(typeof result.text).toBe('string')
+    expect(result.text.length).toBeGreaterThan(0)
   })
 
-  it('should support length option', async () => {
-    const write = createMockWrite()
-    await write('article', { length: 'long' })
+  it('should support system prompt for tone', async () => {
+    const result = await generateText({
+      model: 'haiku',
+      system: 'You write in a casual, friendly tone.',
+      prompt: 'Write a one-sentence welcome message.',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'text',
-      'article',
-      expect.objectContaining({ length: 'long' })
-    )
+    expect(typeof result.text).toBe('string')
+    expect(result.text.length).toBeGreaterThan(0)
   })
 })
 
@@ -330,45 +215,28 @@ describe('write()', () => {
 // code() - Generate code
 // ============================================================================
 
-describe('code()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue('function validate(email) { return email.includes("@"); }')
-  })
-
+describe.skipIf(!hasGateway)('code()', () => {
   it('should generate code', async () => {
-    const code = createMockCode()
-    const result = await code`email validation function`
-
-    expect(typeof result).toBe('string')
-    expect(result).toContain('function')
-  })
-
-  it('should support language option', async () => {
-    const code = createMockCode()
-    await code('REST API endpoints', { language: 'typescript' })
+    const result = await generateText({
+      model: 'haiku',
+      system: 'You are a code generator. Output only code, no explanations.',
+      prompt: 'Write a JavaScript function called isEven that returns true if a number is even.',
+    })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'code',
-      'REST API endpoints',
-      expect.objectContaining({ language: 'typescript' })
-    )
+    expect(typeof result.text).toBe('string')
+    expect(result.text).toContain('function')
   })
 
-  it('should handle complex requirements via object interpolation', async () => {
-    const code = createMockCode()
-    const requirements = {
-      pages: ['home', 'about', 'pricing'],
-      features: ['dark mode', 'animations'],
-      stack: 'Next.js + Tailwind',
-    }
-
-    await code`marketing website${{ requirements }}`
+  it('should generate TypeScript code', async () => {
+    const result = await generateText({
+      model: 'haiku',
+      system: 'You are a TypeScript code generator. Output only code, no explanations.',
+      prompt:
+        'Write a TypeScript function called add that takes two numbers and returns their sum. Include type annotations.',
+    })
 
-    const [, prompt] = mockGenerate.mock.calls[0]
-    expect(prompt).toContain('pages:')
-    expect(prompt).toContain('- home')
-    expect(prompt).toContain('features:')
+    expect(typeof result.text).toBe('string')
+    expect(result.text).toContain('number')
   })
 })
 
@@ -376,319 +244,55 @@ describe('code()', () => {
 // diagram() - Generate diagrams
 // ============================================================================
 
-describe('diagram()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue('graph TD\n  A --> B\n  B --> C')
-  })
-
+describe.skipIf(!hasGateway)('diagram()', () => {
   it('should generate mermaid diagrams', async () => {
-    const diagram = createMockDiagram()
-    const result = await diagram`user authentication flow`
-
-    expect(typeof result).toBe('string')
-    expect(result).toContain('graph')
-  })
-
-  it('should support format option', async () => {
-    const diagram = createMockDiagram()
-    await diagram('database schema', { format: 'mermaid', type: 'erd' })
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'diagram',
-      'database schema',
-      expect.objectContaining({ format: 'mermaid', type: 'erd' })
-    )
-  })
-})
-
-// ============================================================================
-// slides() - Generate presentations
-// ============================================================================
-
-describe('slides()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue('---\ntheme: default\n---\n\n# Slide 1\n\nContent here')
-  })
-
-  it('should generate slidev-format markdown', async () => {
-    const slides = createMockSlides()
-    const result = await slides`${topic}`
-
-    expect(typeof result).toBe('string')
-    expect(result).toContain('---')
-  })
-
-  it('should support format option', async () => {
-    const slides = createMockSlides()
-    await slides('quarterly review', { format: 'marp', slides: 12 })
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'slides',
-      'quarterly review',
-      expect.objectContaining({ format: 'marp', slides: 12 })
-    )
-  })
-
-  it('should support speaker notes', async () => {
-    const slides = createMockSlides()
-    await slides('workshop', { includeNotes: true, duration: '2 hours' })
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'slides',
-      'workshop',
-      expect.objectContaining({ includeNotes: true })
-    )
-  })
-})
-
-// ============================================================================
-// image() - Generate images
-// ============================================================================
-
-describe('image()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue(Buffer.from('fake-image-data'))
-  })
-
-  it('should generate image buffer', async () => {
-    const image = createMockImage()
-    const result = await image`minimalist logo for ${companyName}`
-
-    expect(Buffer.isBuffer(result)).toBe(true)
-  })
-
-  it('should support size option', async () => {
-    const image = createMockImage()
-    await image('robot reading a book', { size: '1024x1024', style: 'cartoon' })
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'image',
-      'robot reading a book',
-      expect.objectContaining({ size: '1024x1024', style: 'cartoon' })
-    )
-  })
-})
-
-// ============================================================================
-// video() - Generate videos
-// ============================================================================
-
-describe('video()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue(Buffer.from('fake-video-data'))
-  })
-
-  it('should generate video buffer', async () => {
-    const video = createMockVideo()
-    const result = await video`product demo for ${productName}`
-
-    expect(Buffer.isBuffer(result)).toBe(true)
-  })
-
-  it('should support duration and aspect options', async () => {
-    const video = createMockVideo()
-    await video('promotional video', { duration: 30, aspect: '16:9', style: 'motion graphics' })
-
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'video',
-      'promotional video',
-      expect.objectContaining({ duration: 30, aspect: '16:9' })
-    )
-  })
-})
-
-// ============================================================================
-// research() - Agentic research
-// ============================================================================
-
-describe('research()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue({
-      summary: 'Key findings...',
-      sources: [{ url: 'https://example.com', title: 'Source 1' }],
-      findings: ['Finding 1', 'Finding 2'],
-      confidence: 0.85,
+    const result = await generateText({
+      model: 'haiku',
+      system:
+        'You generate Mermaid diagram code. Output only the mermaid code, no explanations or markdown fences.',
+      prompt: 'Create a simple flowchart with Start -> Process -> End.',
     })
-  })
-
-  it('should return structured research results', async () => {
-    const research = createMockResearch()
-    const result = await research`${topic}`
-
-    expect(result).toHaveProperty('summary')
-    expect(result).toHaveProperty('sources')
-    expect(result).toHaveProperty('findings')
-    expect(result).toHaveProperty('confidence')
-  })
-
-  it('should support depth option', async () => {
-    const research = createMockResearch()
-    await research`market size for AI tools`({ depth: 'thorough' })
 
-    expect(mockGenerate).toHaveBeenCalledWith(
-      'research',
-      expect.any(String),
-      expect.objectContaining({ depth: 'thorough' })
-    )
+    expect(typeof result.text).toBe('string')
+    // Mermaid flowcharts use arrows like --> or ->
+    expect(result.text).toMatch(/(-->|->)/)
   })
 })
 
 // ============================================================================
-// do() - Single-pass task with tools
+// Structured object generation
 // ============================================================================
 
-describe('do()', () => {
-  beforeEach(() => {
-    mockGenerate.mockReset()
-    mockGenerate.mockResolvedValue({ summary: 'Done', result: 'Task completed' })
-  })
-
-  it('should execute a task', async () => {
-    const doFn = createMockDo()
-    const result = await doFn`translate ${text} to Spanish`
-
-    expect(result).toBeDefined()
-  })
-
-  it('should handle complex multi-function tasks', async () => {
-    mockGenerate.mockResolvedValue({
-      summary: 'Article summary',
-      people: ['John', 'Jane'],
-      actionItems: ['Review', 'Follow up'],
+describe.skipIf(!hasGateway)('generateObject()', () => {
+  it('should generate a structured recipe', async () => {
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        name: z.string().describe('Recipe name'),
+        servings: z.number().describe('Number of servings'),
+        ingredients: z.array(z.string()).describe('List of ingredients'),
+      }),
+      prompt: 'Generate a simple 2-ingredient recipe.',
     })
 
-    const doFn = createMockDo()
-    const result = await doFn`
-      analyze this article and give me a summary,
-      key people mentioned, and action items
-      ${article}
-    `
-
-    expect(result).toHaveProperty('summary')
-  })
-
-  it('is single-pass, not agentic loop', async () => {
-    const doFn = createMockDo()
-    await doFn`analyze ${data}`
+    expect(result.object).toHaveProperty('name')
+    expect(result.object).toHaveProperty('servings')
+    expect(result.object).toHaveProperty('ingredients')
+    expect(typeof result.object.name).toBe('string')
+    expect(typeof result.object.servings).toBe('number')
+    expect(Array.isArray(result.object.ingredients)).toBe(true)
+  })
+
+  it('should respect enum constraints', async () => {
+    const result = await generateObject({
+      model: 'haiku',
+      schema: z.object({
+        sentiment: z.enum(['positive', 'negative', 'neutral']).describe('Sentiment of the text'),
+      }),
+      prompt: 'Analyze the sentiment of: "I had a wonderful day today!"',
+    })
 
-    // Should only call generate once (single pass)
-    expect(mockGenerate).toHaveBeenCalledTimes(1)
+    expect(['positive', 'negative', 'neutral']).toContain(result.object.sentiment)
+    expect(result.object.sentiment).toBe('positive')
   })
 })
-
-// ============================================================================
-// Helper functions to create mock implementations
-// ============================================================================
-
-function createMockAi() {
-  return createMockFunction('text')
-}
-
-function createMockSummarize() {
-  return createMockFunction('summary')
-}
-
-function createMockIs() {
-  return createMockFunction('boolean')
-}
-
-function createMockList() {
-  return createMockFunction('list')
-}
-
-function createMockLists() {
-  return createMockFunction('lists')
-}
-
-function createMockExtract() {
-  return createMockFunction('extract')
-}
-
-function createMockWrite() {
-  return createMockFunction('text')
-}
-
-function createMockCode() {
-  return createMockFunction('code')
-}
-
-function createMockDiagram() {
-  return createMockFunction('diagram')
-}
-
-function createMockSlides() {
-  return createMockFunction('slides')
-}
-
-function createMockImage() {
-  return createMockFunction('image')
-}
-
-function createMockVideo() {
-  return createMockFunction('video')
-}
-
-function createMockResearch() {
-  return createMockFunction('research')
-}
-
-function createMockDo() {
-  return createMockFunction('do')
-}
-
-function createMockFunction(type: string) {
-  return function (promptOrStrings: string | TemplateStringsArray, ...args: unknown[]) {
-    let prompt: string
-
-    if (Array.isArray(promptOrStrings) && 'raw' in promptOrStrings) {
-      // Tagged template
-      prompt = (promptOrStrings as TemplateStringsArray).reduce((acc, str, i) => {
-        const value = args[i]
-        if (value === undefined) return acc + str
-        if (typeof value === 'object' && value !== null) {
-          // Convert objects to YAML for readability (matches real implementation)
-          return acc + str + '\n' + yamlStringify(value).trim()
-        }
-        return acc + str + String(value)
-      }, '')
-
-      // Return chainable for options - properly make it thenable
-      const basePromise = mockGenerate(type, prompt, {})
-      const chainable = (options?: Record<string, unknown>) => mockGenerate(type, prompt, options || {})
-
-      // Add then/catch to make it awaitable
-      ;(chainable as unknown as Promise<unknown>).then = basePromise.then.bind(basePromise)
-      ;(chainable as unknown as Promise<unknown>).catch = basePromise.catch.bind(basePromise)
-
-      return chainable
-    }
-
-    // Regular call
-    prompt = promptOrStrings as string
-    return mockGenerate(type, prompt, args[0] || {})
-  }
-}
-
-// ============================================================================
-// Test fixtures
-// ============================================================================
-
-const longArticle = 'This is a long article about technology and innovation...'
-const technicalReport = 'Technical analysis of system performance metrics...'
-const industry = 'fintech'
-const topic = 'TypeScript'
-const claim = 'The Earth is round'
-const article = 'Article mentioning John Smith and Jane Doe...'
-const text = 'Some text content'
-const company = 'Acme Corp'
-const market = 'SaaS'
-const recipient = 'John'
-const subject = 'Project Update'
-const companyName = 'TechCorp'
-const productName = 'ProductX'
-const data = { key: 'value' }