ai-props 2.1.1 → 2.3.0

package/test/cascade.test.ts

@@ -0,0 +1,338 @@
+/**
+ * Tests for Cascade Executor
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  CascadeExecutor,
+  createCascadeStep,
+  TIER_ORDER,
+  DEFAULT_TIER_TIMEOUTS,
+  AllTiersFailedError,
+  CascadeTimeoutError,
+  type CascadeConfig,
+  type TierContext,
+  type FiveWHEvent,
+} from '../src/cascade.js'
+
+describe('CascadeExecutor', () => {
+  describe('basic execution', () => {
+    it('should execute code tier successfully', async () => {
+      const executor = new CascadeExecutor<{ value: number }, { result: number }>({
+        tiers: {
+          code: {
+            name: 'test-code',
+            execute: async (input) => ({ result: input.value * 2 }),
+          },
+        },
+      })
+
+      const result = await executor.execute({ value: 5 })
+
+      expect(result.value).toEqual({ result: 10 })
+      expect(result.tier).toBe('code')
+      expect(result.history).toHaveLength(1)
+      expect(result.history[0]!.success).toBe(true)
+    })
+
+    it('should escalate to next tier on failure', async () => {
+      const executor = new CascadeExecutor<{ value: number }, { result: number }>({
+        tiers: {
+          code: {
+            name: 'test-code',
+            execute: async () => {
+              throw new Error('Code tier failed')
+            },
+          },
+          generative: {
+            name: 'test-generative',
+            execute: async (input) => ({ result: input.value * 3 }),
+          },
+        },
+      })
+
+      const result = await executor.execute({ value: 5 })
+
+      expect(result.value).toEqual({ result: 15 })
+      expect(result.tier).toBe('generative')
+      expect(result.history).toHaveLength(2)
+      expect(result.history[0]!.success).toBe(false)
+      expect(result.history[1]!.success).toBe(true)
+    })
+
+    it('should throw AllTiersFailedError when all tiers fail', async () => {
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'test-code',
+            execute: async () => {
+              throw new Error('Code failed')
+            },
+          },
+          generative: {
+            name: 'test-generative',
+            execute: async () => {
+              throw new Error('Generative failed')
+            },
+          },
+        },
+      })
+
+      await expect(executor.execute({ value: 5 })).rejects.toThrow(AllTiersFailedError)
+    })
+
+    it('should skip unconfigured tiers', async () => {
+      const executor = new CascadeExecutor<{ value: number }, { result: number }>({
+        tiers: {
+          generative: {
+            name: 'test-generative',
+            execute: async (input) => ({ result: input.value }),
+          },
+        },
+      })
+
+      const result = await executor.execute({ value: 10 })
+
+      expect(result.tier).toBe('generative')
+      expect(result.skippedTiers).toContain('code')
+    })
+  })
+
+  describe('timeouts', () => {
+    it('should use default timeouts when configured', async () => {
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'test-code',
+            execute: async () => ({ success: true }),
+          },
+        },
+        useDefaultTimeouts: true,
+      })
+
+      // Default code timeout is 5000ms
+      expect(DEFAULT_TIER_TIMEOUTS.code).toBe(5000)
+
+      const result = await executor.execute({})
+      expect(result.tier).toBe('code')
+    })
+
+    it('should throw CascadeTimeoutError on total timeout', async () => {
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'slow-code',
+            execute: async () => {
+              await new Promise((resolve) => setTimeout(resolve, 100))
+              return { success: true }
+            },
+          },
+        },
+        totalTimeout: 10,
+      })
+
+      await expect(executor.execute({})).rejects.toThrow(CascadeTimeoutError)
+    })
+  })
+
+  describe('5W+H events', () => {
+    it('should emit start and complete events', async () => {
+      const events: FiveWHEvent[] = []
+
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'test-code',
+            execute: async () => ({ success: true }),
+          },
+        },
+        cascadeName: 'test-cascade',
+        actor: 'test-user',
+        onEvent: (event) => events.push(event),
+      })
+
+      await executor.execute({})
+
+      expect(events.length).toBeGreaterThanOrEqual(2)
+      expect(events[0]!.what).toBe('cascade-start')
+      expect(events[0]!.who).toBe('test-user')
+      expect(events[0]!.where).toBe('test-cascade')
+
+      const completeEvent = events.find((e) => e.what === 'cascade-complete')
+      expect(completeEvent).toBeDefined()
+      expect(completeEvent!.how?.status).toBe('completed')
+    })
+
+    it('should emit escalation events on tier failure', async () => {
+      const events: FiveWHEvent[] = []
+
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'test-code',
+            execute: async () => {
+              throw new Error('Code failed')
+            },
+          },
+          generative: {
+            name: 'test-generative',
+            execute: async () => ({ success: true }),
+          },
+        },
+        onEvent: (event) => events.push(event),
+      })
+
+      await executor.execute({})
+
+      const escalationEvent = events.find((e) => e.what === 'escalate-to-generative')
+      expect(escalationEvent).toBeDefined()
+      expect(escalationEvent!.why).toBe('Code failed')
+    })
+  })
+
+  describe('retry configuration', () => {
+    it('should retry tier on failure', async () => {
+      let attempts = 0
+
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'retry-code',
+            execute: async () => {
+              attempts++
+              if (attempts < 3) {
+                throw new Error('Not yet')
+              }
+              return { success: true }
+            },
+          },
+        },
+        retryConfig: {
+          code: {
+            maxRetries: 3,
+            baseDelay: 10,
+          },
+        },
+      })
+
+      const result = await executor.execute({})
+
+      expect(result.tier).toBe('code')
+      expect(result.history[0]!.attempts).toBe(3)
+      expect(attempts).toBe(3)
+    })
+  })
+
+  describe('skip conditions', () => {
+    it('should skip tier when condition returns true', async () => {
+      const executor = new CascadeExecutor<{ skipCode?: boolean }, { result: string }>({
+        tiers: {
+          code: {
+            name: 'skippable-code',
+            execute: async () => ({ result: 'code' }),
+          },
+          generative: {
+            name: 'test-generative',
+            execute: async () => ({ result: 'generative' }),
+          },
+        },
+        skipConditions: {
+          code: (input) => !!input.skipCode,
+        },
+      })
+
+      const result = await executor.execute({ skipCode: true })
+
+      expect(result.tier).toBe('generative')
+      expect(result.skippedTiers).toContain('code')
+    })
+  })
+
+  describe('context propagation', () => {
+    it('should pass previous errors to tier context', async () => {
+      let receivedPreviousErrors: Array<{ tier: string; error: string }> | undefined
+
+      const executor = new CascadeExecutor({
+        tiers: {
+          code: {
+            name: 'failing-code',
+            execute: async () => {
+              throw new Error('Code error')
+            },
+          },
+          generative: {
+            name: 'test-generative',
+            execute: async (_, ctx) => {
+              receivedPreviousErrors = ctx.previousErrors
+              return { success: true }
+            },
+          },
+        },
+      })
+
+      await executor.execute({})
+
+      expect(receivedPreviousErrors).toBeDefined()
+      expect(receivedPreviousErrors).toHaveLength(1)
+      expect(receivedPreviousErrors![0]!.tier).toBe('code')
+      expect(receivedPreviousErrors![0]!.error).toBe('Code error')
+    })
+  })
+})
+
+describe('createCascadeStep', () => {
+  it('should create executor with configured tiers', async () => {
+    const cascade = createCascadeStep({
+      name: 'test-cascade',
+      code: async (input: { value: number }) => ({ result: input.value }),
+      generative: async (input: { value: number }) => ({ result: input.value * 2 }),
+    })
+
+    const result = await cascade.execute({ value: 5 })
+
+    expect(result.value).toEqual({ result: 5 })
+    expect(result.tier).toBe('code')
+  })
+
+  it('should use default timeouts', async () => {
+    const cascade = createCascadeStep({
+      name: 'test-cascade',
+      code: async () => ({ success: true }),
+    })
+
+    // The cascade should have default timeouts enabled
+    const result = await cascade.execute({})
+    expect(result.tier).toBe('code')
+  })
+
+  it('should accept custom timeouts', async () => {
+    const cascade = createCascadeStep({
+      name: 'test-cascade',
+      code: async () => {
+        await new Promise((resolve) => setTimeout(resolve, 50))
+        return { success: true }
+      },
+      timeouts: {
+        code: 10,
+      },
+    })
+
+    // Should timeout since execution takes longer than 10ms
+    await expect(cascade.execute({})).rejects.toThrow()
+  })
+})
+
+describe('Constants', () => {
+  it('should have correct tier order', () => {
+    expect(TIER_ORDER).toEqual(['code', 'generative', 'agentic', 'human'])
+  })
+
+  it('should have correct default timeouts', () => {
+    expect(DEFAULT_TIER_TIMEOUTS).toEqual({
+      code: 5000,
+      generative: 30000,
+      agentic: 300000,
+      human: 86400000,
+    })
+  })
+})

package/test/durable-cascade.test.ts

@@ -0,0 +1,319 @@
+/**
+ * Tests for DurableCascadeExecutor
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  DurableCascadeExecutor,
+  createDurableCascadeStep,
+  createAIGatewayConfig,
+  type WorkflowStep,
+  type DurableCascadeTierContext,
+  type FiveWHEvent,
+} from '../src/durable-cascade.js'
+import { AllTiersFailedError, CascadeTimeoutError } from '../src/cascade.js'
+
+/**
+ * Create a mock workflow step for testing
+ */
+function createMockWorkflowStep(): WorkflowStep {
+  return {
+    do: vi.fn(
+      async (name: string, configOrCallback: unknown, maybeCallback?: () => Promise<unknown>) => {
+        const callback = typeof configOrCallback === 'function' ? configOrCallback : maybeCallback
+        return callback?.()
+      }
+    ),
+    sleep: vi.fn(async () => {}),
+    sleepUntil: vi.fn(async () => {}),
+  }
+}
+
+describe('DurableCascadeExecutor', () => {
+  describe('basic execution', () => {
+    it('should execute code tier successfully', async () => {
+      const step = createMockWorkflowStep()
+      const executor = new DurableCascadeExecutor<{ value: number }, { result: number }>('test', {
+        code: async (input) => ({ result: input.value * 2 }),
+      })
+
+      const result = await executor.run(step, { value: 5 })
+
+      expect(result.value).toEqual({ result: 10 })
+      expect(result.tier).toBe('code')
+      expect(step.do).toHaveBeenCalled()
+    })
+
+    it('should escalate to generative tier on code failure', async () => {
+      const step = createMockWorkflowStep()
+      const executor = new DurableCascadeExecutor<{ value: number }, { result: number }>('test', {
+        code: async () => {
+          throw new Error('Code failed')
+        },
+        generative: async (input) => ({ result: input.value * 3 }),
+      })
+
+      const result = await executor.run(step, { value: 5 })
+
+      expect(result.value).toEqual({ result: 15 })
+      expect(result.tier).toBe('generative')
+      expect(result.history).toHaveLength(2)
+    })
+
+    it('should throw AllTiersFailedError when all tiers fail', async () => {
+      const step = createMockWorkflowStep()
+      const executor = new DurableCascadeExecutor('test', {
+        code: async () => {
+          throw new Error('Code failed')
+        },
+        generative: async () => {
+          throw new Error('Generative failed')
+        },
+      })
+
+      await expect(executor.run(step, {})).rejects.toThrow(AllTiersFailedError)
+    })
+  })
+
+  describe('AI binding', () => {
+    it('should pass AI binding to generative tier', async () => {
+      const step = createMockWorkflowStep()
+      const mockAi = {
+        run: vi.fn(async () => ({ response: 'AI generated content' })),
+      }
+
+      const executor = new DurableCascadeExecutor<{ prompt: string }, { content: string }>('test', {
+        generative: async (input, ctx) => {
+          const result = await ctx.ai.run('@cf/meta/llama-3-8b-instruct', {
+            messages: [{ role: 'user', content: input.prompt }],
+          })
+          return { content: result.response ?? '' }
+        },
+      })
+
+      const result = await executor.run(step, { prompt: 'Hello' }, { ai: mockAi })
+
+      expect(result.value.content).toBe('AI generated content')
+      expect(mockAi.run).toHaveBeenCalled()
+    })
+
+    it('should use setAi method', async () => {
+      const step = createMockWorkflowStep()
+      const mockAi = {
+        run: vi.fn(async () => ({ response: 'Configured AI response' })),
+      }
+
+      const executor = new DurableCascadeExecutor<{ prompt: string }, { content: string }>('test', {
+        generative: async (input, ctx) => {
+          const result = await ctx.ai.run('@cf/meta/llama-3-8b-instruct', {
+            messages: [{ role: 'user', content: input.prompt }],
+          })
+          return { content: result.response ?? '' }
+        },
+      }).setAi(mockAi)
+
+      const result = await executor.run(step, { prompt: 'Test' })
+
+      expect(result.value.content).toBe('Configured AI response')
+    })
+  })
+
+  describe('human review', () => {
+    it('should handle human review requests', async () => {
+      const step = createMockWorkflowStep()
+      const mockHumanReviewHandler = vi.fn(async () => ({
+        reviewId: 'review-123',
+        status: 'approved',
+      }))
+
+      const executor = new DurableCascadeExecutor<{ data: string }, { approved: boolean }>('test', {
+        human: async (input, ctx) => {
+          const review = await ctx.requestHumanReview({
+            type: 'approval',
+            data: input.data,
+          })
+          return { approved: review.status === 'approved' }
+        },
+      })
+
+      const result = await executor.run(
+        step,
+        { data: 'test' },
+        { humanReviewHandler: mockHumanReviewHandler }
+      )
+
+      expect(result.value.approved).toBe(true)
+      expect(mockHumanReviewHandler).toHaveBeenCalledWith({
+        type: 'approval',
+        data: 'test',
+      })
+    })
+  })
+
+  describe('5W+H events', () => {
+    it('should emit cascade events', async () => {
+      const step = createMockWorkflowStep()
+      const events: FiveWHEvent[] = []
+
+      const executor = new DurableCascadeExecutor('test-cascade', {
+        code: async () => ({ success: true }),
+        actor: 'test-user',
+        onEvent: (event) => events.push(event),
+      })
+
+      await executor.run(step, {})
+
+      expect(events.length).toBeGreaterThanOrEqual(2)
+
+      const startEvent = events.find((e) => e.what === 'cascade-start')
+      expect(startEvent).toBeDefined()
+      expect(startEvent!.who).toBe('test-user')
+
+      const completeEvent = events.find((e) => e.what === 'cascade-complete')
+      expect(completeEvent).toBeDefined()
+    })
+  })
+
+  describe('tier configuration', () => {
+    it('should apply custom success condition', async () => {
+      const step = createMockWorkflowStep()
+      const executor = new DurableCascadeExecutor<unknown, { valid: boolean }>('test', {
+        code: async () => ({ valid: false }),
+        generative: async () => ({ valid: true }),
+        tierConfig: {
+          code: {
+            successCondition: (result) => (result as { valid: boolean }).valid,
+          },
+        },
+      })
+
+      const result = await executor.run(step, {})
+
+      // Code tier returned { valid: false }, which fails successCondition
+      // So it should escalate to generative
+      expect(result.tier).toBe('generative')
+      expect(result.value.valid).toBe(true)
+    })
+
+    it('should call onError handler on tier failure', async () => {
+      const step = createMockWorkflowStep()
+      const onError = vi.fn()
+
+      const executor = new DurableCascadeExecutor('test', {
+        code: async () => {
+          throw new Error('Test error')
+        },
+        generative: async () => ({ success: true }),
+        tierConfig: {
+          code: {
+            onError,
+          },
+        },
+      })
+
+      await executor.run(step, {})
+
+      expect(onError).toHaveBeenCalledWith(expect.any(Error), 'code')
+    })
+  })
+})
+
+describe('createDurableCascadeStep', () => {
+  it('should create executor with configured handlers', async () => {
+    const step = createMockWorkflowStep()
+    const cascade = createDurableCascadeStep({
+      name: 'test-cascade',
+      code: async (input: { value: number }) => ({ result: input.value }),
+    })
+
+    const result = await cascade.run(step, { value: 10 })
+
+    expect(result.value).toEqual({ result: 10 })
+    expect(result.tier).toBe('code')
+  })
+
+  it('should support all tier types', async () => {
+    const step = createMockWorkflowStep()
+    const mockAi = {
+      run: vi.fn(async () => ({ response: 'agentic' })),
+    }
+
+    const cascade = createDurableCascadeStep({
+      name: 'full-cascade',
+      code: async () => {
+        throw new Error('Skip')
+      },
+      generative: async () => {
+        throw new Error('Skip')
+      },
+      agentic: async (_, ctx) => {
+        const result = await ctx.ai.run('model', { messages: [] })
+        return { tier: result.response }
+      },
+    })
+
+    const result = await cascade.run(step, {}, { ai: mockAi })
+
+    expect(result.tier).toBe('agentic')
+    expect(result.value).toEqual({ tier: 'agentic' })
+  })
+})
+
+describe('createAIGatewayConfig', () => {
+  it('should create gateway configuration', () => {
+    const config = createAIGatewayConfig({
+      gatewayId: 'my-gateway',
+      accountId: 'account-123',
+      cacheTtl: 3600,
+    })
+
+    expect(config.config.gatewayId).toBe('my-gateway')
+    expect(config.config.accountId).toBe('account-123')
+    expect(config.config.cacheTtl).toBe(3600)
+  })
+
+  it('should generate request options', () => {
+    const config = createAIGatewayConfig({
+      gatewayId: 'my-gateway',
+      accountId: 'account-123',
+      cacheTtl: 3600,
+      skipCache: false,
+      metadata: { key: 'value' },
+    })
+
+    const options = config.toRequestOptions()
+
+    expect(options).toEqual({
+      gateway: {
+        id: 'my-gateway',
+        skipCache: false,
+        cacheTtl: 3600,
+        metadata: { key: 'value' },
+      },
+    })
+  })
+
+  it('should generate cache key', () => {
+    const config = createAIGatewayConfig({
+      gatewayId: 'my-gateway',
+      accountId: 'account-123',
+    })
+
+    const key = config.getCacheKey({ prompt: 'test' })
+
+    expect(key).toContain('my-gateway:')
+    expect(key).toContain('prompt')
+  })
+
+  it('should use default values', () => {
+    const config = createAIGatewayConfig({
+      gatewayId: 'gateway',
+      accountId: 'account',
+    })
+
+    const options = config.toRequestOptions()
+
+    expect((options.gateway as { cacheTtl: number }).cacheTtl).toBe(0)
+    expect((options.gateway as { skipCache: boolean }).skipCache).toBe(false)
+  })
+})