ai-functions 2.1.3 → 2.4.0

package/test/embedding-cache-middleware.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Tests for embeddingCacheMiddleware — embedding-side analogue of
+ * cacheMiddleware for `wrapEmbeddingModel`.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { wrapEmbeddingModel } from 'ai'
+import { MockEmbeddingModelV3 } from 'ai/test'
+import { embeddingCacheMiddleware } from '../src/index.js'
+
+describe('embeddingCacheMiddleware', () => {
+  const originalGate = process.env['V3_EVAL_CACHE']
+
+  beforeEach(() => {
+    process.env['V3_EVAL_CACHE'] = '1'
+  })
+
+  afterEach(() => {
+    if (originalGate === undefined) {
+      delete process.env['V3_EVAL_CACHE']
+    } else {
+      process.env['V3_EVAL_CACHE'] = originalGate
+    }
+  })
+
+  it('returns cached embeddings on second call with same values', async () => {
+    let callCount = 0
+    const upstream = new MockEmbeddingModelV3({
+      modelId: 'test-embed',
+      doEmbed: async () => {
+        callCount++
+        return {
+          embeddings: [
+            [0.1, 0.2, 0.3],
+            [0.4, 0.5, 0.6],
+          ],
+        }
+      },
+    })
+
+    const wrapped = wrapEmbeddingModel({
+      model: upstream,
+      middleware: embeddingCacheMiddleware({ enabled: true }),
+    })
+
+    const r1 = await wrapped.doEmbed({ values: ['a', 'b'] })
+    expect(r1.embeddings).toEqual([
+      [0.1, 0.2, 0.3],
+      [0.4, 0.5, 0.6],
+    ])
+    expect(callCount).toBe(1)
+
+    const r2 = await wrapped.doEmbed({ values: ['a', 'b'] })
+    expect(r2.embeddings).toEqual([
+      [0.1, 0.2, 0.3],
+      [0.4, 0.5, 0.6],
+    ])
+    expect(callCount).toBe(1) // cache hit — no second upstream call
+  })
+
+  it('treats different value batches as separate keys', async () => {
+    let callCount = 0
+    const upstream = new MockEmbeddingModelV3({
+      modelId: 'test-embed',
+      doEmbed: async ({ values }) => {
+        callCount++
+        return {
+          embeddings: values.map((_, i) => [i, i + 1]),
+        }
+      },
+    })
+    const wrapped = wrapEmbeddingModel({
+      model: upstream,
+      middleware: embeddingCacheMiddleware({ enabled: true }),
+    })
+
+    await wrapped.doEmbed({ values: ['a'] })
+    await wrapped.doEmbed({ values: ['b'] })
+    expect(callCount).toBe(2)
+  })
+
+  it('falls through to upstream when env gate is unset', async () => {
+    delete process.env['V3_EVAL_CACHE']
+    let callCount = 0
+    const upstream = new MockEmbeddingModelV3({
+      modelId: 'test-embed',
+      doEmbed: async () => {
+        callCount++
+        return { embeddings: [[1, 2, 3]] }
+      },
+    })
+    const wrapped = wrapEmbeddingModel({
+      model: upstream,
+      middleware: embeddingCacheMiddleware(),
+    })
+
+    await wrapped.doEmbed({ values: ['x'] })
+    await wrapped.doEmbed({ values: ['x'] })
+    expect(callCount).toBe(2) // no caching when gate is off
+  })
+
+  it('respects explicit enabled: false override', async () => {
+    let callCount = 0
+    const upstream = new MockEmbeddingModelV3({
+      modelId: 'test-embed',
+      doEmbed: async () => {
+        callCount++
+        return { embeddings: [[1, 2, 3]] }
+      },
+    })
+    const wrapped = wrapEmbeddingModel({
+      model: upstream,
+      middleware: embeddingCacheMiddleware({ enabled: false }),
+    })
+
+    await wrapped.doEmbed({ values: ['x'] })
+    await wrapped.doEmbed({ values: ['x'] })
+    expect(callCount).toBe(2)
+  })
+
+  it('evicts entries past TTL and re-fetches', async () => {
+    let callCount = 0
+    const upstream = new MockEmbeddingModelV3({
+      modelId: 'test-embed',
+      doEmbed: async () => {
+        callCount++
+        return { embeddings: [[callCount]] }
+      },
+    })
+    const wrapped = wrapEmbeddingModel({
+      model: upstream,
+      middleware: embeddingCacheMiddleware({ enabled: true, ttlMs: -1 }),
+      // TTL = -1 → every entry is "older than -1 ms" → always evicted on access
+    })
+
+    await wrapped.doEmbed({ values: ['x'] })
+    await wrapped.doEmbed({ values: ['x'] })
+    expect(callCount).toBe(2) // TTL expired, re-fetch
+  })
+})

package/test/fill-template.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Tests for fillTemplate in function-registry.ts
+ *
+ * fillTemplate replaces {{key}} placeholders in a template string with values
+ * from an args record. Non-primitive values (objects/arrays) must serialize
+ * via JSON.stringify, not String(), to avoid "[object Object]" corruption.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { fillTemplate } from '../src/function-registry.js'
+
+describe('fillTemplate', () => {
+  describe('primitive values', () => {
+    it('interpolates a string value', () => {
+      expect(fillTemplate('Hello {{name}}!', { name: 'world' })).toBe('Hello world!')
+    })
+
+    it('interpolates a number value', () => {
+      expect(fillTemplate('Count: {{n}}', { n: 42 })).toBe('Count: 42')
+    })
+
+    it('interpolates a boolean value', () => {
+      expect(fillTemplate('Active: {{flag}}', { flag: true })).toBe('Active: true')
+    })
+
+    it('interpolates zero without stripping it', () => {
+      expect(fillTemplate('Value: {{v}}', { v: 0 })).toBe('Value: 0')
+    })
+
+    it('leaves placeholder empty when key is missing', () => {
+      expect(fillTemplate('{{missing}} value', {})).toBe(' value')
+    })
+
+    it('replaces multiple distinct placeholders', () => {
+      expect(fillTemplate('{{a}} + {{b}} = {{c}}', { a: 1, b: 2, c: 3 })).toBe('1 + 2 = 3')
+    })
+  })
+
+  describe('object and array values — must NOT produce [object Object]', () => {
+    it('serializes a plain object via JSON.stringify', () => {
+      const result = fillTemplate('Data: {{obj}}', { obj: { foo: 'bar', n: 1 } })
+      expect(result).not.toContain('[object Object]')
+      expect(result).toBe('Data: {"foo":"bar","n":1}')
+    })
+
+    it('serializes an array via JSON.stringify', () => {
+      const result = fillTemplate('Items: {{list}}', { list: ['a', 'b', 'c'] })
+      expect(result).not.toContain('[object Object]')
+      expect(result).toBe('Items: ["a","b","c"]')
+    })
+
+    it('serializes a nested object', () => {
+      const payload = { subject: 'AI', stats: { count: 5, tags: ['fast', 'smart'] } }
+      const result = fillTemplate('Payload: {{payload}}', { payload })
+      expect(result).not.toContain('[object Object]')
+      const parsed = JSON.parse(result.replace('Payload: ', ''))
+      expect(parsed.subject).toBe('AI')
+      expect(parsed.stats.count).toBe(5)
+    })
+
+    it('serializes an array of objects (upstream cascade step output pattern)', () => {
+      const steps = [{ id: 1, label: 'Subject' }, { id: 2, label: 'Problem' }]
+      const result = fillTemplate('Steps: {{steps}}', { steps })
+      expect(result).not.toContain('[object Object]')
+      const parsed = JSON.parse(result.replace('Steps: ', ''))
+      expect(parsed).toHaveLength(2)
+      expect(parsed[0].label).toBe('Subject')
+    })
+  })
+
+  describe('edge cases', () => {
+    it('keeps null as empty string (null coalesces to empty via ?? fallback)', () => {
+      // null ?? '' → '' → String('') → ''
+      expect(fillTemplate('{{v}}', { v: null as unknown as string })).toBe('')
+    })
+
+    it('keeps undefined key as empty string', () => {
+      expect(fillTemplate('{{v}}', {})).toBe('')
+    })
+
+    it('handles template with no placeholders', () => {
+      expect(fillTemplate('no placeholders here', { x: 1 })).toBe('no placeholders here')
+    })
+
+    it('handles empty template', () => {
+      expect(fillTemplate('', { x: 1 })).toBe('')
+    })
+  })
+})