ai-functions 2.1.3 → 2.3.0

package/test/implicit-batch.test.ts

@@ -16,7 +16,7 @@
  * ```
  */
 
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
 import {
   configure,
   resetContext,
@@ -29,54 +29,14 @@ import {
   getFlexThreshold,
   getBatchThreshold,
   isFlexAvailable,
-} from '../src/context.js'
-import { list, write, ai, is } from '../src/primitives.js'
-import {
   createBatchMap,
   BatchMapPromise,
-  captureOperation,
-  isInRecordingMode,
-} from '../src/batch-map.js'
+} from '../src/index.js'
+import { captureOperation } from '../src/batch-map.js'
 
-// Import memory adapter to register it
-import '../src/batch/memory.js'
-import { configureMemoryAdapter, clearBatches } from '../src/batch/memory.js'
-
-// ============================================================================
-// Mock Setup
-// ============================================================================
-
-vi.mock('../src/generate.js', () => ({
-  generateObject: vi.fn().mockImplementation(async ({ prompt, schema }) => {
-    // Simulate list generation
-    if (schema?.items) {
-      return {
-        object: {
-          items: [
-            'Building AI-First Startups in 2026',
-            'The Future of Remote Work',
-            'Sustainable Tech Growth',
-            'From Idea to MVP in 30 Days',
-            'Community-Led Product Development',
-          ],
-        },
-      }
-    }
-    // Simulate boolean
-    if (schema?.answer) {
-      return {
-        object: { answer: 'true' },
-      }
-    }
-    // Default object
-    return { object: { result: 'Generated content' } }
-  }),
-  generateText: vi.fn().mockImplementation(async ({ prompt }) => {
-    return {
-      text: `Generated blog post for: ${prompt.slice(0, 50)}...`,
-    }
-  }),
-}))
+// Memory adapter for testing - simulates batch processing locally
+// Import from .ts file for proper vite resolution
+import { configureMemoryAdapter, clearBatches } from '../src/batch/memory.ts'
 
 // ============================================================================
 // Tests
@@ -84,7 +44,6 @@ vi.mock('../src/generate.js', () => ({
 
 describe('Implicit Batch Processing', () => {
   beforeEach(() => {
-    vi.clearAllMocks()
     resetContext()
     clearBatches()
     configureMemoryAdapter({})
@@ -145,7 +104,7 @@ describe('Implicit Batch Processing', () => {
     })
   })
 
-  describe('Three-Tier Execution (immediate → flex → batch)', () => {
+  describe('Three-Tier Execution (immediate -> flex -> batch)', () => {
     it('getExecutionTier returns immediate for < flexThreshold items', () => {
       configure({ batchMode: 'auto', flexThreshold: 5, batchThreshold: 500 })
 
@@ -267,8 +226,7 @@ describe('Implicit Batch Processing', () => {
 
       // Create batch map - this enters recording mode for each item
       const batchMap = createBatchMap(items, (item) => {
-        // When we call write` here, it should capture the operation
-        // Since we mocked generateText, we need to manually capture
+        // Capture operation for each item
         captureOperation(`Write about: ${item}`, 'text', undefined, undefined)
         recordedCount++
         return `result_${item}`
@@ -306,7 +264,7 @@ describe('Implicit Batch Processing', () => {
       })
     })
 
-    it('supports async iteration', async () => {
+    it('supports iteration over results', async () => {
       configure({ batchMode: 'immediate' })
 
       const items = ['X', 'Y']
@@ -334,20 +292,15 @@ describe('Implicit Batch Processing', () => {
   })
 
   describe('Full Workflow', () => {
-    it('list → map → batch flow works end-to-end', async () => {
+    it('list -> map -> batch flow works end-to-end', async () => {
       // Configure for immediate execution (for testing)
       configure({ batchMode: 'immediate', provider: 'openai', model: 'gpt-4o' })
 
-      // Step 1: Get titles (this executes immediately)
-      // Note: The mock returns { object: { items: [...] } }
-      // so we access .items from the result
-      const result = await list`5 blog post titles about startups`
-      const titles = (result as any).items || result
-      expect(titles).toHaveLength(5)
+      // Step 1: Simulate getting titles (in production this would be AI-generated)
+      const titles = ['Title 1', 'Title 2', 'Title 3', 'Title 4', 'Title 5']
 
       // Step 2: Map to blog posts
       // In the real implementation, this would capture operations
-      // For this test, we simulate the batch map behavior
       const batchMap = createBatchMap(titles, (title: string) => {
         // Capture the write operation
         captureOperation(`Write a blog post about: ${title}`, 'text')
@@ -384,12 +337,16 @@ describe('Implicit Batch Processing', () => {
       const items = ['Test']
       const batchMap = new BatchMapPromise<string>(
         items,
-        [[{
-          id: 'op_1',
-          prompt: 'Test prompt',
-          itemPlaceholder: 'Test',
-          type: 'text' as const,
-        }]],
+        [
+          [
+            {
+              id: 'op_1',
+              prompt: 'Test prompt',
+              itemPlaceholder: 'Test',
+              type: 'text' as const,
+            },
+          ],
+        ],
         { deferred: true }
       )
 

package/test/retry-policy-integration.test.ts

@@ -0,0 +1,117 @@
+/**
+ * Integration tests: retry/CB/fallback machinery reads policy data from
+ * `language-models`. Validates that the per-model `ModelPolicy` flows through
+ * the resilience classes correctly.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { RetryPolicy, CircuitBreaker, FallbackChain } from '../src/retry.js'
+import { tiersForModel, modelSupportsTier, modelPolicyFor } from '../src/index.js'
+
+describe('RetryPolicy.forModel', () => {
+  it('uses frontier-provider settings for sonnet', async () => {
+    const policy = RetryPolicy.forModel('sonnet')
+    let attempts = 0
+    const op = vi.fn(async () => {
+      attempts++
+      if (attempts < 2) {
+        const err = new Error('rate limit')
+        ;(err as Error & { status?: number }).status = 429
+        throw err
+      }
+      return 'ok'
+    })
+    const result = await policy.execute(() => op())
+    expect(result).toBe('ok')
+    expect(attempts).toBe(2)
+  })
+
+  it('forModel respects per-call overrides', async () => {
+    const policy = RetryPolicy.forModel('sonnet', { maxRetries: 0 })
+    let attempts = 0
+    const op = async () => {
+      attempts++
+      const err = new Error('rate limit')
+      ;(err as Error & { status?: number }).status = 429
+      throw err
+    }
+    await expect(policy.execute(() => op())).rejects.toThrow()
+    expect(attempts).toBe(1) // No retries
+  })
+})
+
+describe('CircuitBreaker.forModel', () => {
+  it('uses frontier-provider failure threshold for sonnet', async () => {
+    const breaker = CircuitBreaker.forModel('sonnet')
+    // Frontier threshold is 8 — eight failures should still report state
+    // before opening on the 8th.
+    for (let i = 0; i < 7; i++) {
+      try {
+        await breaker.execute(async () => {
+          throw new Error('fail')
+        })
+      } catch {
+        // expected
+      }
+    }
+    // Still closed (threshold is 8)
+    expect(breaker.state).toBe('closed')
+  })
+
+  it('forModel respects per-call overrides', async () => {
+    const breaker = CircuitBreaker.forModel('sonnet', { failureThreshold: 1 })
+    try {
+      await breaker.execute(async () => {
+        throw new Error('fail')
+      })
+    } catch {
+      // expected
+    }
+    expect(breaker.state).toBe('open')
+  })
+})
+
+describe('FallbackChain.forModel', () => {
+  it('builds a chain from policy.fallbackChain plus the primary model id', async () => {
+    const seen: string[] = []
+    const chain = FallbackChain.forModel<string, void>('sonnet', async (modelId) => {
+      seen.push(modelId)
+      throw new Error('fail')
+    })
+    await expect(chain.execute()).rejects.toThrow('All fallback models failed')
+    // First call is the primary alias, rest are fallbacks
+    expect(seen[0]).toBe('anthropic/claude-sonnet-4.5')
+    expect(seen.length).toBeGreaterThan(1)
+  })
+
+  it('returns first successful model result', async () => {
+    let calls = 0
+    const chain = FallbackChain.forModel<string, void>('sonnet', async (modelId) => {
+      calls++
+      if (calls === 1) throw new Error('first fails')
+      return modelId
+    })
+    const result = await chain.execute()
+    expect(calls).toBe(2)
+    expect(result).toBeTruthy()
+  })
+})
+
+describe('tier helpers', () => {
+  it('tiersForModel returns expected tiers', () => {
+    expect(tiersForModel('sonnet')).toContain('immediate')
+    expect(tiersForModel('sonnet')).toContain('batch')
+    expect(tiersForModel('gpt-4o')).toContain('flex')
+  })
+
+  it('modelSupportsTier checks eligibility', () => {
+    expect(modelSupportsTier('gpt-4o', 'flex')).toBe(true)
+    expect(modelSupportsTier('sonnet', 'flex')).toBe(false)
+    expect(modelSupportsTier('sonnet', 'immediate')).toBe(true)
+  })
+
+  it('modelPolicyFor is re-exported', () => {
+    const p = modelPolicyFor('sonnet')
+    expect(p.$type).toBe('ModelPolicy')
+  })
+})

package/test/schema.test.ts

@@ -2,6 +2,7 @@
  * Tests for schema conversion
  *
  * These are pure unit tests - no AI calls needed.
+ * Uses type-safe instanceof checks instead of accessing internal _def property.
  */
 
 import { describe, it, expect } from 'vitest'
@@ -12,54 +13,67 @@ describe('schema', () => {
   describe('string types', () => {
     it('converts simple string description to z.string()', () => {
       const result = schema('User name')
-      expect(result._def.typeName).toBe('ZodString')
-      expect(result._def.description).toBe('User name')
+      expect(result instanceof z.ZodString).toBe(true)
+      expect(result.description).toBe('User name')
     })
 
     it('converts (number) hint to z.number()', () => {
       const result = schema('User age (number)')
-      expect(result._def.typeName).toBe('ZodNumber')
-      expect(result._def.description).toBe('User age')
+      expect(result instanceof z.ZodNumber).toBe(true)
+      expect(result.description).toBe('User age')
     })
 
     it('converts (boolean) hint to z.boolean()', () => {
       const result = schema('Is active (boolean)')
-      expect(result._def.typeName).toBe('ZodBoolean')
-      expect(result._def.description).toBe('Is active')
+      expect(result instanceof z.ZodBoolean).toBe(true)
+      expect(result.description).toBe('Is active')
     })
 
     it('converts (integer) hint to z.number().int()', () => {
       const result = schema('Item count (integer)')
-      expect(result._def.typeName).toBe('ZodNumber')
-      expect(result._def.checks?.some((c: { kind: string }) => c.kind === 'int')).toBe(true)
+      expect(result instanceof z.ZodNumber).toBe(true)
+      // Verify it's an integer by testing validation behavior
+      expect(result.safeParse(5).success).toBe(true)
+      expect(result.safeParse(5.5).success).toBe(false)
     })
 
     it('converts (date) hint to z.string().datetime()', () => {
       const result = schema('Created at (date)')
-      expect(result._def.typeName).toBe('ZodString')
-      expect(result._def.checks?.some((c: { kind: string }) => c.kind === 'datetime')).toBe(true)
+      expect(result instanceof z.ZodString).toBe(true)
+      // Verify it validates datetime format
+      expect(result.safeParse('2024-01-15T10:30:00Z').success).toBe(true)
+      expect(result.safeParse('not-a-date').success).toBe(false)
     })
   })
 
   describe('enum types', () => {
     it('converts pipe-separated values to z.enum()', () => {
       const result = schema('pending | done | cancelled')
-      expect(result._def.typeName).toBe('ZodEnum')
-      expect(result._def.values).toEqual(['pending', 'done', 'cancelled'])
+      expect(result instanceof z.ZodEnum).toBe(true)
+      // Verify enum values through validation
+      expect(result.safeParse('pending').success).toBe(true)
+      expect(result.safeParse('done').success).toBe(true)
+      expect(result.safeParse('cancelled').success).toBe(true)
+      expect(result.safeParse('invalid').success).toBe(false)
     })
 
     it('handles spaces around pipe', () => {
       const result = schema('yes | no | maybe')
-      expect(result._def.values).toEqual(['yes', 'no', 'maybe'])
+      expect(result instanceof z.ZodEnum).toBe(true)
+      expect(result.safeParse('yes').success).toBe(true)
+      expect(result.safeParse('no').success).toBe(true)
+      expect(result.safeParse('maybe').success).toBe(true)
     })
   })
 
   describe('array types', () => {
     it('converts [string] to z.array(z.string())', () => {
       const result = schema(['List of items'])
-      expect(result._def.typeName).toBe('ZodArray')
-      expect(result._def.type._def.typeName).toBe('ZodString')
-      expect(result._def.description).toBe('List of items')
+      expect(result instanceof z.ZodArray).toBe(true)
+      expect(result.description).toBe('List of items')
+      // Verify array of strings validation
+      expect(result.safeParse(['a', 'b', 'c']).success).toBe(true)
+      expect(result.safeParse([1, 2, 3]).success).toBe(false)
     })
   })
 
@@ -69,7 +83,10 @@ describe('schema', () => {
         name: 'User name',
         age: 'Age (number)',
       })
-      expect(result._def.typeName).toBe('ZodObject')
+      expect(result instanceof z.ZodObject).toBe(true)
+      // Verify object validation
+      expect(result.safeParse({ name: 'John', age: 30 }).success).toBe(true)
+      expect(result.safeParse({ name: 'John', age: 'thirty' }).success).toBe(false)
     })
 
     it('handles nested objects', () => {
@@ -81,7 +98,16 @@ describe('schema', () => {
           },
         },
       })
-      expect(result._def.typeName).toBe('ZodObject')
+      expect(result instanceof z.ZodObject).toBe(true)
+      // Verify nested object validation
+      expect(
+        result.safeParse({
+          user: {
+            name: 'John',
+            profile: { bio: 'A developer' },
+          },
+        }).success
+      ).toBe(true)
     })
 
     it('handles mixed types in object', () => {
@@ -92,7 +118,17 @@ describe('schema', () => {
         status: 'pending | done',
         tags: ['Tags'],
       })
-      expect(result._def.typeName).toBe('ZodObject')
+      expect(result instanceof z.ZodObject).toBe(true)
+      // Verify mixed type validation
+      expect(
+        result.safeParse({
+          name: 'Test',
+          count: 5,
+          active: true,
+          status: 'pending',
+          tags: ['tag1', 'tag2'],
+        }).success
+      ).toBe(true)
     })
   })