@launchdarkly/server-sdk-ai 0.9.8 → 0.10.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [0.10.0](https://github.com/launchdarkly/js-core/compare/server-sdk-ai-v0.9.9...server-sdk-ai-v0.10.0) (2025-07-16)
+
+
+### Features
+
+* Adding Vercel AI SDK mapper ([#895](https://github.com/launchdarkly/js-core/issues/895)) ([0befee0](https://github.com/launchdarkly/js-core/commit/0befee0888d0af03b01c0cf6f46eacc80a3ce8e8))
+
+## [0.9.9](https://github.com/launchdarkly/js-core/compare/server-sdk-ai-v0.9.8...server-sdk-ai-v0.9.9) (2025-06-17)
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * devDependencies
+    * @launchdarkly/js-server-sdk-common bumped from 2.15.2 to 2.16.0
+  * peerDependencies
+    * @launchdarkly/js-server-sdk-common bumped from 2.x to 2.16.0
+
 ## [0.9.8](https://github.com/launchdarkly/js-core/compare/server-sdk-ai-v0.9.7...server-sdk-ai-v0.9.8) (2025-05-21)
 
 

package/__tests__/LDAIClientImpl.test.ts

@@ -57,6 +57,7 @@ it('returns config with interpolated messagess', async () => {
     ],
     tracker: expect.any(Object),
     enabled: true,
+    toVercelAISDK: expect.any(Function),
   });
 });
 
@@ -102,6 +103,7 @@ it('handles missing metadata in variation', async () => {
     messages: [{ role: 'system', content: 'Hello' }],
     tracker: expect.any(Object),
     enabled: false,
+    toVercelAISDK: expect.any(Function),
   });
 });
 
@@ -125,6 +127,7 @@ it('passes the default value to the underlying client', async () => {
     provider: defaultValue.provider,
     tracker: expect.any(Object),
     enabled: false,
+    toVercelAISDK: expect.any(Function),
   });
 
   expect(mockLdClient.variation).toHaveBeenCalledWith(key, testContext, defaultValue);

package/__tests__/LDAIConfigMapper.test.ts

@@ -0,0 +1,159 @@
+import { LDMessage, VercelAISDKMapOptions } from '../src/api/config';
+import { LDAIConfigMapper } from '../src/LDAIConfigMapper';
+
+describe('_findParameter', () => {
+  it('handles undefined model and messages', () => {
+    const mapper = new LDAIConfigMapper();
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('test-param')).toBeUndefined();
+  });
+
+  it('handles parameter not found', () => {
+    const mapper = new LDAIConfigMapper({
+      name: 'test-ai-model',
+      parameters: {
+        'test-param': 123,
+      },
+      custom: {
+        'test-param': 456,
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('other-param')).toBeUndefined();
+  });
+
+  it('finds parameter from single model parameter', () => {
+    const mapper = new LDAIConfigMapper({
+      name: 'test-ai-model',
+      parameters: {
+        'test-param': 123,
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('test-param')).toEqual(123);
+  });
+
+  it('finds parameter from multiple model parameters', () => {
+    const mapper = new LDAIConfigMapper({
+      name: 'test-ai-model',
+      parameters: {
+        testParam: 123,
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('test-param', 'testParam')).toEqual(123);
+  });
+
+  it('finds parameter from single model custom parameter', () => {
+    const mapper = new LDAIConfigMapper({
+      name: 'test-ai-model',
+      custom: {
+        'test-param': 123,
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('test-param')).toEqual(123);
+  });
+
+  it('finds parameter from multiple model custom parameters', () => {
+    const mapper = new LDAIConfigMapper({
+      name: 'test-ai-model',
+      custom: {
+        testParam: 123,
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('test-param', 'testParam')).toEqual(123);
+  });
+
+  it('gives precedence to model parameters over model custom parameters', () => {
+    const mapper = new LDAIConfigMapper({
+      name: 'test-ai-model',
+      parameters: {
+        'test-param': 123,
+      },
+      custom: {
+        'test-param': 456,
+      },
+    });
+    // eslint-disable-next-line @typescript-eslint/dot-notation
+    expect(mapper['_findParameter']<number>('test-param', 'testParam')).toEqual(123);
+  });
+});
+
+describe('toVercelAIAISDK', () => {
+  const mockModel = { name: 'mockModel' };
+  const mockMessages: LDMessage[] = [
+    { role: 'user', content: 'test prompt' },
+    { role: 'system', content: 'test instruction' },
+  ];
+  const mockOptions: VercelAISDKMapOptions = {
+    nonInterpolatedMessages: [{ role: 'assistant', content: 'test assistant instruction' }],
+  };
+  const mockProvider = jest.fn().mockReturnValue(mockModel);
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('handles undefined model and messages', () => {
+    const mapper = new LDAIConfigMapper();
+    const result = mapper.toVercelAISDK(mockProvider);
+
+    expect(mockProvider).toHaveBeenCalledWith('');
+    expect(result).toEqual(
+      expect.objectContaining({
+        model: mockModel,
+        messages: undefined,
+      }),
+    );
+  });
+
+  it('uses additional messages', () => {
+    const mapper = new LDAIConfigMapper({ name: 'test-ai-model' });
+    const result = mapper.toVercelAISDK(mockProvider, mockOptions);
+
+    expect(mockProvider).toHaveBeenCalledWith('test-ai-model');
+    expect(result).toEqual(
+      expect.objectContaining({
+        model: mockModel,
+        messages: mockOptions.nonInterpolatedMessages,
+      }),
+    );
+  });
+
+  it('combines config messages and additional messages', () => {
+    const mapper = new LDAIConfigMapper({ name: 'test-ai-model' }, undefined, mockMessages);
+    const result = mapper.toVercelAISDK(mockProvider, mockOptions);
+
+    expect(mockProvider).toHaveBeenCalledWith('test-ai-model');
+    expect(result).toEqual(
+      expect.objectContaining({
+        model: mockModel,
+        messages: [...mockMessages, ...(mockOptions.nonInterpolatedMessages ?? [])],
+      }),
+    );
+  });
+
+  it('requests parameters correctly', () => {
+    const mapper = new LDAIConfigMapper({ name: 'test-ai-model' }, undefined, mockMessages);
+    const findParameterMock = jest.spyOn(mapper as any, '_findParameter');
+    const result = mapper.toVercelAISDK(mockProvider);
+
+    expect(mockProvider).toHaveBeenCalledWith('test-ai-model');
+    expect(result).toEqual(
+      expect.objectContaining({
+        model: mockModel,
+        messages: mockMessages,
+      }),
+    );
+    expect(findParameterMock).toHaveBeenCalledWith('max_tokens', 'maxTokens');
+    expect(findParameterMock).toHaveBeenCalledWith('temperature');
+    expect(findParameterMock).toHaveBeenCalledWith('top_p', 'topP');
+    expect(findParameterMock).toHaveBeenCalledWith('top_k', 'topK');
+    expect(findParameterMock).toHaveBeenCalledWith('presence_penalty', 'presencePenalty');
+    expect(findParameterMock).toHaveBeenCalledWith('frequency_penalty', 'frequencyPenalty');
+    expect(findParameterMock).toHaveBeenCalledWith('stop', 'stop_sequences', 'stopSequences');
+    expect(findParameterMock).toHaveBeenCalledWith('seed');
+  });
+});

package/__tests__/LDAIConfigTrackerImpl.test.ts

@@ -129,6 +129,13 @@ it('tracks success', () => {
     { configKey, variationKey, version },
     1,
   );
+
+  expect(mockTrack).toHaveBeenCalledWith(
+    '$ld:ai:generation:success',
+    testContext,
+    { configKey, variationKey, version },
+    1,
+  );
 });
 
 it('tracks OpenAI usage', async () => {
@@ -167,6 +174,20 @@ it('tracks OpenAI usage', async () => {
     1,
   );
 
+  expect(mockTrack).toHaveBeenCalledWith(
+    '$ld:ai:generation:success',
+    testContext,
+    { configKey, variationKey, version },
+    1,
+  );
+
+  expect(mockTrack).not.toHaveBeenCalledWith(
+    '$ld:ai:generation:error',
+    expect.anything(),
+    expect.anything(),
+    expect.anything(),
+  );
+
   expect(mockTrack).toHaveBeenCalledWith(
     '$ld:ai:tokens:total',
     testContext,
@@ -226,6 +247,13 @@ it('tracks error when OpenAI metrics function throws', async () => {
     { configKey, variationKey, version },
     1,
   );
+
+  expect(mockTrack).not.toHaveBeenCalledWith(
+    expect.stringMatching(/^\$ld:ai:tokens:/),
+    expect.anything(),
+    expect.anything(),
+    expect.anything(),
+  );
 });
 
 it('tracks Bedrock conversation with successful response', () => {
@@ -260,6 +288,20 @@ it('tracks Bedrock conversation with successful response', () => {
     1,
   );
 
+  expect(mockTrack).toHaveBeenCalledWith(
+    '$ld:ai:generation:success',
+    testContext,
+    { configKey, variationKey, version },
+    1,
+  );
+
+  expect(mockTrack).not.toHaveBeenCalledWith(
+    '$ld:ai:generation:error',
+    expect.anything(),
+    expect.anything(),
+    expect.anything(),
+  );
+
   expect(mockTrack).toHaveBeenCalledWith(
     '$ld:ai:duration:total',
     testContext,
@@ -318,6 +360,409 @@ it('tracks Bedrock conversation with error response', () => {
     { configKey, variationKey, version },
     1,
   );
+
+  expect(mockTrack).not.toHaveBeenCalledWith(
+    expect.stringMatching(/^\$ld:ai:tokens:/),
+    expect.anything(),
+    expect.anything(),
+    expect.anything(),
+  );
+});
+
+describe('Vercel AI SDK generateText', () => {
+  it('tracks Vercel AI SDK usage', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    const TOTAL_TOKENS = 100;
+    const PROMPT_TOKENS = 49;
+    const COMPLETION_TOKENS = 51;
+
+    await tracker.trackVercelAISDKGenerateTextMetrics(async () => ({
+      usage: {
+        totalTokens: TOTAL_TOKENS,
+        promptTokens: PROMPT_TOKENS,
+        completionTokens: COMPLETION_TOKENS,
+      },
+    }));
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:success',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:tokens:total',
+      testContext,
+      { configKey, variationKey, version },
+      TOTAL_TOKENS,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:tokens:input',
+      testContext,
+      { configKey, variationKey, version },
+      PROMPT_TOKENS,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:tokens:output',
+      testContext,
+      { configKey, variationKey, version },
+      COMPLETION_TOKENS,
+    );
+  });
+
+  it('tracks error when Vercel AI SDK metrics function throws', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    const error = new Error('Vercel AI SDK API error');
+    await expect(
+      tracker.trackVercelAISDKGenerateTextMetrics(async () => {
+        throw error;
+      }),
+    ).rejects.toThrow(error);
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      expect.stringMatching(/^\$ld:ai:tokens:/),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+});
+
+describe('Vercel AI SDK streamText', () => {
+  it('tracks Vercel AI SDK usage', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    const TOTAL_TOKENS = 100;
+    const PROMPT_TOKENS = 49;
+    const COMPLETION_TOKENS = 51;
+
+    let resolveDone: ((value: boolean) => void) | undefined;
+    const donePromise = new Promise<boolean>((resolve) => {
+      resolveDone = resolve;
+    });
+
+    const finishReason = Promise.resolve('stop');
+    jest
+      .spyOn(finishReason, 'then')
+      .mockImplementationOnce((fn) => finishReason.then(fn).finally(() => resolveDone?.(true)));
+
+    tracker.trackVercelAISDKStreamTextMetrics(() => ({
+      finishReason,
+      usage: Promise.resolve({
+        totalTokens: TOTAL_TOKENS,
+        promptTokens: PROMPT_TOKENS,
+        completionTokens: COMPLETION_TOKENS,
+      }),
+    }));
+
+    await donePromise;
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:success',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:tokens:total',
+      testContext,
+      { configKey, variationKey, version },
+      TOTAL_TOKENS,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:tokens:input',
+      testContext,
+      { configKey, variationKey, version },
+      PROMPT_TOKENS,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:tokens:output',
+      testContext,
+      { configKey, variationKey, version },
+      COMPLETION_TOKENS,
+    );
+  });
+
+  it('tracks error when Vercel AI SDK metrics function throws', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    const error = new Error('Vercel AI SDK API error');
+    expect(() =>
+      tracker.trackVercelAISDKStreamTextMetrics(() => {
+        throw error;
+      }),
+    ).toThrow(error);
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      expect.stringMatching(/^\$ld:ai:tokens:/),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('tracks error when Vercel AI SDK finishes because of an error', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    tracker.trackVercelAISDKStreamTextMetrics(() => ({
+      finishReason: Promise.resolve('error'),
+    }));
+
+    await new Promise(process.nextTick);
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      expect.stringMatching(/^\$ld:ai:tokens:/),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('tracks error when Vercel AI SDK finishReason promise rejects', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    tracker.trackVercelAISDKStreamTextMetrics(() => ({
+      finishReason: Promise.reject(new Error('Vercel AI SDK API error')),
+    }));
+
+    await new Promise(process.nextTick);
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      expect.stringMatching(/^\$ld:ai:tokens:/),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
+
+  it('squashes error when Vercel AI SDK usage promise rejects', async () => {
+    const tracker = new LDAIConfigTrackerImpl(
+      mockLdClient,
+      configKey,
+      variationKey,
+      version,
+      testContext,
+    );
+    jest.spyOn(global.Date, 'now').mockReturnValueOnce(1000).mockReturnValueOnce(2000);
+
+    tracker.trackVercelAISDKStreamTextMetrics(() => ({
+      finishReason: Promise.resolve('stop'),
+      usage: Promise.reject(new Error('Vercel AI SDK API error')),
+    }));
+
+    await new Promise(process.nextTick);
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:duration:total',
+      testContext,
+      { configKey, variationKey, version },
+      1000,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).toHaveBeenCalledWith(
+      '$ld:ai:generation:success',
+      testContext,
+      { configKey, variationKey, version },
+      1,
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      '$ld:ai:generation:error',
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+
+    expect(mockTrack).not.toHaveBeenCalledWith(
+      expect.stringMatching(/^\$ld:ai:tokens:/),
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+    );
+  });
 });
 
 it('tracks tokens', () => {