feat: replace VercelProvider with Runner protocol implementation (AIC-2388) (#1339)

Author: jsonbailey

packages/ai-providers/server-ai-vercel/__tests__/VercelHelper.test.ts

@@ -0,0 +1,96 @@
+import {
+  convertMessagesToVercel,
+  getAIMetricsFromResponse,
+  getAIMetricsFromStream,
+  mapProviderName,
+  mapUsageDataToLDTokenUsage,
+} from '../src/VercelHelper';
+
+describe('convertMessagesToVercel', () => {
+  it('passes role and content through unchanged', () => {
+    expect(
+      convertMessagesToVercel([
+        { role: 'system', content: 'sys' },
+        { role: 'user', content: 'u' },
+        { role: 'assistant', content: 'a' },
+      ]),
+    ).toEqual([
+      { role: 'system', content: 'sys' },
+      { role: 'user', content: 'u' },
+      { role: 'assistant', content: 'a' },
+    ]);
+  });
+});
+
+describe('mapProviderName', () => {
+  it('maps gemini to google (case-insensitive)', () => {
+    expect(mapProviderName('gemini')).toBe('google');
+    expect(mapProviderName('Gemini')).toBe('google');
+  });
+
+  it('returns the provider unchanged when no mapping exists', () => {
+    expect(mapProviderName('openai')).toBe('openai');
+    expect(mapProviderName('anthropic')).toBe('anthropic');
+  });
+});
+
+describe('mapUsageDataToLDTokenUsage', () => {
+  it('prefers v5 field names (inputTokens / outputTokens) over v4', () => {
+    const usage = mapUsageDataToLDTokenUsage({
+      totalTokens: 100,
+      inputTokens: 40,
+      outputTokens: 60,
+      promptTokens: 1,
+      completionTokens: 2,
+    });
+    expect(usage).toEqual({ total: 100, input: 40, output: 60 });
+  });
+
+  it('falls back to v4 field names when v5 is absent', () => {
+    const usage = mapUsageDataToLDTokenUsage({
+      totalTokens: 50,
+      promptTokens: 20,
+      completionTokens: 30,
+    });
+    expect(usage).toEqual({ total: 50, input: 20, output: 30 });
+  });
+});
+
+describe('getAIMetricsFromResponse', () => {
+  it('treats missing finishReason as success', () => {
+    expect(
+      getAIMetricsFromResponse({
+        usage: { totalTokens: 5, promptTokens: 2, completionTokens: 3 },
+      }),
+    ).toEqual({ success: true, usage: { total: 5, input: 2, output: 3 } });
+  });
+
+  it('marks success=false when finishReason is "error"', () => {
+    expect(
+      getAIMetricsFromResponse({
+        finishReason: 'error',
+        usage: { totalTokens: 10, promptTokens: 4, completionTokens: 6 },
+      }).success,
+    ).toBe(false);
+  });
+});
+
+describe('getAIMetricsFromStream', () => {
+  it('extracts usage from a successful stream', async () => {
+    const result = await getAIMetricsFromStream({
+      finishReason: Promise.resolve('stop'),
+      usage: Promise.resolve({ totalTokens: 100, promptTokens: 49, completionTokens: 51 }),
+    });
+    expect(result).toEqual({
+      success: true,
+      usage: { total: 100, input: 49, output: 51 },
+    });
+  });
+
+  it('marks success=false on error finishReason', async () => {
+    const result = await getAIMetricsFromStream({
+      finishReason: Promise.resolve('error'),
+    });
+    expect(result.success).toBe(false);
+  });
+});

packages/ai-providers/server-ai-vercel/__tests__/VercelModelRunner.test.ts

@@ -0,0 +1,172 @@
+import { generateObject, generateText, jsonSchema } from 'ai';
+
+import type { LDAICompletionConfig } from '@launchdarkly/server-sdk-ai';
+
+import { VercelModelRunner } from '../src/VercelModelRunner';
+
+jest.mock('ai', () => ({
+  generateText: jest.fn(),
+  generateObject: jest.fn(),
+  jsonSchema: jest.fn((schema) => schema),
+}));
+
+const mockLogger = {
+  warn: jest.fn(),
+  info: jest.fn(),
+  error: jest.fn(),
+  debug: jest.fn(),
+};
+
+const baseConfig: LDAICompletionConfig = {
+  key: 'completion',
+  enabled: true,
+  model: { name: 'mock' },
+};
+
+describe('VercelModelRunner', () => {
+  const fakeModel = { name: 'mock' };
+  let runner: VercelModelRunner;
+
+  beforeEach(() => {
+    runner = new VercelModelRunner(fakeModel as any, baseConfig, {}, mockLogger);
+    jest.clearAllMocks();
+  });
+
+  describe('run (chat completion)', () => {
+    it('returns a successful RunnerResult with content, metrics, and raw response', async () => {
+      const result = {
+        text: 'Hi!',
+        usage: { totalTokens: 12, promptTokens: 7, completionTokens: 5 },
+      };
+      (generateText as jest.Mock).mockResolvedValue(result);
+
+      const out = await runner.run('hello');
+
+      expect(generateText).toHaveBeenCalledWith({
+        model: fakeModel,
+        messages: [{ role: 'user', content: 'hello' }],
+        experimental_telemetry: { isEnabled: true },
+      });
+      expect(out.content).toBe('Hi!');
+      expect(out.metrics).toEqual({
+        success: true,
+        usage: { total: 12, input: 7, output: 5 },
+      });
+      expect(out.raw).toBe(result);
+    });
+
+    it('prepends config messages before the user prompt', async () => {
+      (generateText as jest.Mock).mockResolvedValue({
+        text: 'reply',
+        usage: { totalTokens: 1, promptTokens: 1, completionTokens: 0 },
+      });
+
+      const configWithMessages: LDAICompletionConfig = {
+        ...baseConfig,
+        messages: [{ role: 'system', content: 'You are X' }],
+      };
+      const r = new VercelModelRunner(fakeModel as any, configWithMessages, {}, mockLogger);
+      await r.run('hi');
+
+      expect(generateText).toHaveBeenCalledWith({
+        model: fakeModel,
+        messages: [
+          { role: 'system', content: 'You are X' },
+          { role: 'user', content: 'hi' },
+        ],
+        experimental_telemetry: { isEnabled: true },
+      });
+    });
+
+    it('preserves v5 token field handling via getAIMetricsFromResponse', async () => {
+      (generateText as jest.Mock).mockResolvedValue({
+        text: 'ok',
+        usage: { totalTokens: 100, inputTokens: 40, outputTokens: 60 },
+      });
+
+      const out = await runner.run('hello');
+
+      expect(out.metrics.usage).toEqual({ total: 100, input: 40, output: 60 });
+    });
+
+    it('uses a LDMessage[] directly without prepending config messages', async () => {
+      (generateText as jest.Mock).mockResolvedValue({
+        text: 'direct',
+        usage: { totalTokens: 5, promptTokens: 2, completionTokens: 3 },
+      });
+
+      const configWithMessages: LDAICompletionConfig = {
+        ...baseConfig,
+        messages: [{ role: 'system', content: 'Should not appear' }],
+      };
+      const r = new VercelModelRunner(fakeModel as any, configWithMessages, {}, mockLogger);
+      const prebuilt = [
+        { role: 'system' as const, content: 'Custom system' },
+        { role: 'user' as const, content: 'Direct input' },
+      ];
+      await r.run(prebuilt);
+
+      expect(generateText).toHaveBeenCalledWith({
+        model: fakeModel,
+        messages: prebuilt,
+        experimental_telemetry: { isEnabled: true },
+      });
+    });
+
+    it('returns success=false when generateText throws', async () => {
+      const err = new Error('boom');
+      (generateText as jest.Mock).mockRejectedValue(err);
+
+      const out = await runner.run('hello');
+
+      expect(out.content).toBe('');
+      expect(out.metrics.success).toBe(false);
+      expect(mockLogger.warn).toHaveBeenCalledWith('Vercel AI model invocation failed:', err);
+    });
+  });
+
+  describe('run (structured output)', () => {
+    it('exposes parsed structured output via parsed', async () => {
+      const obj = { name: 'Ada', age: 36 };
+      (generateObject as jest.Mock).mockResolvedValue({
+        object: obj,
+        usage: { totalTokens: 30, promptTokens: 10, completionTokens: 20 },
+      });
+
+      const schema = { type: 'object' };
+      const out = await runner.run('tell', schema);
+
+      expect(jsonSchema).toHaveBeenCalledWith(schema);
+      expect(generateObject).toHaveBeenCalledWith({
+        model: fakeModel,
+        messages: [{ role: 'user', content: 'tell' }],
+        schema,
+        experimental_telemetry: { isEnabled: true },
+      });
+      expect(out.parsed).toEqual(obj);
+      expect(out.content).toBe(JSON.stringify(obj));
+      expect(out.metrics.success).toBe(true);
+    });
+
+    it('returns success=false when generateObject throws', async () => {
+      const err = new Error('struct boom');
+      (generateObject as jest.Mock).mockRejectedValue(err);
+
+      const out = await runner.run('tell', { type: 'object' });
+
+      expect(out.content).toBe('');
+      expect(out.parsed).toBeUndefined();
+      expect(out.metrics.success).toBe(false);
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        'Vercel AI structured model invocation failed:',
+        err,
+      );
+    });
+  });
+
+  describe('getModel', () => {
+    it('returns the underlying Vercel AI model', () => {
+      expect(runner.getModel()).toBe(fakeModel);
+    });
+  });
+});