ai-functions 2.1.3 → 2.3.0

package/test/define.test.ts

@@ -5,14 +5,14 @@
  */
 
 import { describe, it, expect, beforeEach } from 'vitest'
-import { define, defineFunction, functions } from '../src/index.js'
+import { define, defineFunction, functions, createFunctionRegistry, resetGlobalRegistry } from '../src/index.js'
 
 // Skip tests if no gateway configured
 const hasGateway = !!process.env.AI_GATEWAY_URL || !!process.env.ANTHROPIC_API_KEY
 
 describe('functions registry', () => {
   beforeEach(() => {
-    functions.clear()
+    resetGlobalRegistry()
   })
 
   it('starts empty', () => {
@@ -75,14 +75,152 @@ describe('functions registry', () => {
     functions.set('func1', fn1)
     functions.set('func2', fn2)
 
-    functions.clear()
+    resetGlobalRegistry()
+    expect(functions.list()).toEqual([])
+  })
+})
+
+describe('createFunctionRegistry', () => {
+  beforeEach(() => {
+    resetGlobalRegistry()
+  })
+
+  it('creates an isolated registry instance', () => {
+    const registry = createFunctionRegistry()
+    expect(registry.list()).toEqual([])
+  })
+
+  it('registry operations do not affect global registry', () => {
+    // Add function to global registry
+    const globalFn = defineFunction({
+      type: 'generative',
+      name: 'globalFunc',
+      args: { input: 'Test input' },
+      output: 'string',
+    })
+    functions.set('globalFunc', globalFn)
+
+    // Create isolated registry and add different function
+    const registry = createFunctionRegistry()
+    const isolatedFn = defineFunction({
+      type: 'generative',
+      name: 'isolatedFunc',
+      args: { data: 'Test data' },
+      output: 'string',
+    })
+    registry.set('isolatedFunc', isolatedFn)
+
+    // Verify isolation
+    expect(functions.has('globalFunc')).toBe(true)
+    expect(functions.has('isolatedFunc')).toBe(false)
+    expect(registry.has('isolatedFunc')).toBe(true)
+    expect(registry.has('globalFunc')).toBe(false)
+  })
+
+  it('multiple registries are independent of each other', () => {
+    const registry1 = createFunctionRegistry()
+    const registry2 = createFunctionRegistry()
+
+    const fn1 = defineFunction({
+      type: 'generative',
+      name: 'func1',
+      args: {},
+      output: 'string',
+    })
+    const fn2 = defineFunction({
+      type: 'generative',
+      name: 'func2',
+      args: {},
+      output: 'string',
+    })
+
+    registry1.set('func1', fn1)
+    registry2.set('func2', fn2)
+
+    expect(registry1.has('func1')).toBe(true)
+    expect(registry1.has('func2')).toBe(false)
+    expect(registry2.has('func1')).toBe(false)
+    expect(registry2.has('func2')).toBe(true)
+  })
+
+  it('isolated registry supports all operations', () => {
+    const registry = createFunctionRegistry()
+
+    const fn = defineFunction({
+      type: 'generative',
+      name: 'testFunc',
+      args: { x: 'number' },
+      output: 'string',
+    })
+
+    // set and get
+    registry.set('testFunc', fn)
+    expect(registry.get('testFunc')).toBe(fn)
+
+    // has
+    expect(registry.has('testFunc')).toBe(true)
+
+    // list
+    expect(registry.list()).toEqual(['testFunc'])
+
+    // delete
+    expect(registry.delete('testFunc')).toBe(true)
+    expect(registry.has('testFunc')).toBe(false)
+
+    // clear
+    registry.set('a', fn)
+    registry.set('b', fn)
+    registry.clear()
+    expect(registry.list()).toEqual([])
+  })
+})
+
+describe('resetGlobalRegistry', () => {
+  it('clears all functions from global registry', () => {
+    const fn = defineFunction({
+      type: 'generative',
+      name: 'testFunc',
+      args: {},
+      output: 'string',
+    })
+    functions.set('testFunc', fn)
+    expect(functions.has('testFunc')).toBe(true)
+
+    resetGlobalRegistry()
+    expect(functions.has('testFunc')).toBe(false)
+    expect(functions.list()).toEqual([])
+  })
+
+  it('does not affect isolated registries', () => {
+    const isolatedRegistry = createFunctionRegistry()
+    const fn = defineFunction({
+      type: 'generative',
+      name: 'isolatedFunc',
+      args: {},
+      output: 'string',
+    })
+    isolatedRegistry.set('isolatedFunc', fn)
+
+    // Add to global and reset
+    functions.set('globalFunc', fn)
+    resetGlobalRegistry()
+
+    // Global should be empty, isolated should still have function
+    expect(functions.list()).toEqual([])
+    expect(isolatedRegistry.has('isolatedFunc')).toBe(true)
+  })
+
+  it('can be called multiple times safely', () => {
+    resetGlobalRegistry()
+    resetGlobalRegistry()
+    resetGlobalRegistry()
     expect(functions.list()).toEqual([])
   })
 })
 
 describe('defineFunction', () => {
   beforeEach(() => {
-    functions.clear()
+    resetGlobalRegistry()
   })
 
   it('creates a generative function definition', () => {
@@ -132,6 +270,7 @@ describe('defineFunction', () => {
       name: 'implement',
       args: { spec: 'Function specification' },
       language: 'typescript',
+      handler: () => 'ok',
     })
 
     expect(fn.definition.type).toBe('code')
@@ -163,7 +302,7 @@ describe('defineFunction', () => {
 
 describe('define helpers', () => {
   beforeEach(() => {
-    functions.clear()
+    resetGlobalRegistry()
   })
 
   it('define.generative registers function', () => {
@@ -204,7 +343,8 @@ describe('define helpers', () => {
     const fn = define.code({
       name: 'generate',
       args: { prompt: 'Code generation prompt' },
-      language: 'python',
+      language: 'typescript',
+      handler: () => 'ok',
     })
 
     expect(functions.has('generate')).toBe(true)
@@ -212,9 +352,72 @@ describe('define helpers', () => {
   })
 })
 
+// Code is the DETERMINISTIC kind — no gateway required. These tests assert the
+// post-split contract: `type: 'code'` runs a handler (or inline body), never a
+// model, at call time. (Code-authoring moved to generateCode().)
+describe('code function execution (deterministic)', () => {
+  beforeEach(() => {
+    resetGlobalRegistry()
+  })
+
+  it('runs the supplied handler with no LLM call', async () => {
+    const calculateTax = defineFunction<number, { amount: number; rate: number }>({
+      type: 'code',
+      name: 'calculateTax',
+      args: { amount: 'Amount (number)', rate: 'Rate (number)' },
+      handler: ({ amount, rate }) => amount * rate,
+    })
+
+    const result = await calculateTax.call({ amount: 100, rate: 0.2 })
+    expect(result).toBe(20)
+    // Determinism: same input → same output, every time
+    expect(await calculateTax.call({ amount: 100, rate: 0.2 })).toBe(20)
+  })
+
+  it('awaits an async handler', async () => {
+    const fn = defineFunction<string, { name: string }>({
+      type: 'code',
+      name: 'greetAsync',
+      args: { name: 'Name' },
+      handler: async ({ name }) => `hi ${name}`,
+    })
+    expect(await fn.call({ name: 'world' })).toBe('hi world')
+  })
+
+  it('evaluates an inline code body deterministically', async () => {
+    const fn = defineFunction<number, { items: number[] }>({
+      type: 'code',
+      name: 'sum',
+      args: { items: ['Numbers'] },
+      language: 'typescript',
+      code: 'return args.items.reduce((a, b) => a + b, 0)',
+    })
+    expect(await fn.call({ items: [1, 2, 3, 4] })).toBe(10)
+  })
+
+  it('throws (does not call a model) when no handler or code is provided', async () => {
+    const fn = defineFunction({
+      type: 'code',
+      name: 'noImpl',
+      args: { spec: 'spec' },
+      language: 'typescript',
+    })
+    await expect(fn.call({ spec: 'x' })).rejects.toThrow(/no handler or inline code/i)
+  })
+
+  it('define.code runs the handler', async () => {
+    const fn = define.code<number, { a: number; b: number }>({
+      name: 'add',
+      args: { a: 'a (number)', b: 'b (number)' },
+      handler: ({ a, b }) => a + b,
+    })
+    expect(await fn.call({ a: 2, b: 3 })).toBe(5)
+  })
+})
+
 describe.skipIf(!hasGateway)('generative function execution', () => {
   beforeEach(() => {
-    functions.clear()
+    resetGlobalRegistry()
   })
 
   it('executes a generative string function', async () => {
@@ -251,7 +454,7 @@ describe.skipIf(!hasGateway)('generative function execution', () => {
 
 describe.skipIf(!hasGateway)('auto-define', () => {
   beforeEach(() => {
-    functions.clear()
+    resetGlobalRegistry()
   })
 
   it('auto-defines a function from name and args', async () => {