@ai-sdk/lmnt 2.0.7 → 2.0.9

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @ai-sdk/lmnt
 
+## 2.0.9
+
+### Patch Changes
+
+- 8dc54db: chore: add src folders to package bundle
+
+## 2.0.8
+
+### Patch Changes
+
+- Updated dependencies [5c090e7]
+  - @ai-sdk/provider@3.0.4
+  - @ai-sdk/provider-utils@4.0.8
+
 ## 2.0.7
 
 ### Patch Changes

package/dist/index.js

@@ -197,7 +197,7 @@ var LMNTSpeechModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/lmnt-provider.ts
 function createLMNT(options = {}) {

package/dist/index.mjs

@@ -177,7 +177,7 @@ var LMNTSpeechModel = class {
 };
 
 // src/version.ts
-var VERSION = true ? "2.0.7" : "0.0.0-test";
+var VERSION = true ? "2.0.9" : "0.0.0-test";
 
 // src/lmnt-provider.ts
 function createLMNT(options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-sdk/lmnt",
-  "version": "2.0.7",
+  "version": "2.0.9",
   "license": "Apache-2.0",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -8,6 +8,7 @@
   "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*",
+    "src",
     "CHANGELOG.md",
     "README.md"
   ],
@@ -20,15 +21,15 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "3.0.3",
-    "@ai-sdk/provider-utils": "4.0.7"
+    "@ai-sdk/provider": "3.0.4",
+    "@ai-sdk/provider-utils": "4.0.8"
   },
   "devDependencies": {
     "@types/node": "20.17.24",
     "tsup": "^8",
     "typescript": "5.6.3",
     "zod": "3.25.76",
-    "@ai-sdk/test-server": "1.0.1",
+    "@ai-sdk/test-server": "1.0.2",
     "@vercel/ai-tsconfig": "0.0.0"
   },
   "peerDependencies": {

package/src/index.ts

@@ -0,0 +1,3 @@
+export { createLMNT, lmnt } from './lmnt-provider';
+export type { LMNTProvider, LMNTProviderSettings } from './lmnt-provider';
+export { VERSION } from './version';

package/src/lmnt-api-types.ts

@@ -0,0 +1,39 @@
+export type LMNTSpeechAPITypes = {
+  /** The voice id of the voice to use; voice ids can be retrieved by calls to List voices or Voice info. */
+  voice: string;
+  /** The text to synthesize; max 5000 characters per request (including spaces) */
+  text: string;
+  /** The model to use for synthesis. One of aurora (default) or blizzard. */
+  model?: 'aurora' | 'blizzard';
+  /** The desired language. Two letter ISO 639-1 code. Does not work with professional clones. Not all languages work with all models. Defaults to auto language detection. */
+  language?:
+    | 'auto'
+    | 'en'
+    | 'es'
+    | 'pt'
+    | 'fr'
+    | 'de'
+    | 'zh'
+    | 'ko'
+    | 'hi'
+    | 'ja'
+    | 'ru'
+    | 'it'
+    | 'tr';
+  /** The file format of the audio output */
+  format?: 'aac' | 'mp3' | 'mulaw' | 'raw' | 'wav';
+  /** The desired output sample rate in Hz */
+  sample_rate?: 8000 | 16000 | 24000;
+  /** The talking speed of the generated speech, a floating point value between 0.25 (slow) and 2.0 (fast). */
+  speed?: number;
+  /** Seed used to specify a different take; defaults to random */
+  seed?: number;
+  /** Set this to true to generate conversational-style speech rather than reading-style speech. Does not work with the blizzard model. */
+  conversational?: boolean;
+  /** Produce speech of this length in seconds; maximum 300.0 (5 minutes). Does not work with the blizzard model. */
+  length?: number;
+  /** Controls the stability of the generated speech. A lower value (like 0.3) produces more consistent, reliable speech. A higher value (like 0.9) gives more flexibility in how words are spoken, but might occasionally produce unusual intonations or speech patterns. */
+  top_p?: number;
+  /** Influences how expressive and emotionally varied the speech becomes. Lower values (like 0.3) create more neutral, consistent speaking styles. Higher values (like 1.0) allow for more dynamic emotional range and speaking styles. */
+  temperature?: number;
+};

package/src/lmnt-config.ts

@@ -0,0 +1,9 @@
+import { FetchFunction } from '@ai-sdk/provider-utils';
+
+export type LMNTConfig = {
+  provider: string;
+  url: (options: { modelId: string; path: string }) => string;
+  headers: () => Record<string, string | undefined>;
+  fetch?: FetchFunction;
+  generateId?: () => string;
+};

package/src/lmnt-error.test.ts

@@ -0,0 +1,34 @@
+import { safeParseJSON } from '@ai-sdk/provider-utils';
+import { lmntErrorDataSchema } from './lmnt-error';
+import { describe, it, expect } from 'vitest';
+
+describe('lmntErrorDataSchema', () => {
+  it('should parse LMNT resource exhausted error', async () => {
+    const error = `
+{"error":{"message":"{\\n  \\"error\\": {\\n    \\"code\\": 429,\\n    \\"message\\": \\"Resource has been exhausted (e.g. check quota).\\",\\n    \\"status\\": \\"RESOURCE_EXHAUSTED\\"\\n  }\\n}\\n","code":429}}
+`;
+
+    const result = await safeParseJSON({
+      text: error,
+      schema: lmntErrorDataSchema,
+    });
+
+    expect(result).toStrictEqual({
+      success: true,
+      value: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+      rawValue: {
+        error: {
+          message:
+            '{\n  "error": {\n    "code": 429,\n    "message": "Resource has been exhausted (e.g. check quota).",\n    "status": "RESOURCE_EXHAUSTED"\n  }\n}\n',
+          code: 429,
+        },
+      },
+    });
+  });
+});

package/src/lmnt-error.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/v4';
+import { createJsonErrorResponseHandler } from '@ai-sdk/provider-utils';
+
+export const lmntErrorDataSchema = z.object({
+  error: z.object({
+    message: z.string(),
+    code: z.number(),
+  }),
+});
+
+export type LMNTErrorData = z.infer<typeof lmntErrorDataSchema>;
+
+export const lmntFailedResponseHandler = createJsonErrorResponseHandler({
+  errorSchema: lmntErrorDataSchema,
+  errorToMessage: data => data.error.message,
+});

package/src/lmnt-provider.ts

@@ -0,0 +1,83 @@
+import { SpeechModelV3, ProviderV3 } from '@ai-sdk/provider';
+import {
+  FetchFunction,
+  loadApiKey,
+  withUserAgentSuffix,
+} from '@ai-sdk/provider-utils';
+import { LMNTSpeechModel } from './lmnt-speech-model';
+import { LMNTSpeechModelId } from './lmnt-speech-options';
+import { VERSION } from './version';
+
+export interface LMNTProvider extends Pick<ProviderV3, 'speechModel'> {
+  (
+    modelId: 'aurora',
+    settings?: {},
+  ): {
+    speech: LMNTSpeechModel;
+  };
+
+  /**
+Creates a model for speech synthesis.
+   */
+  speech(modelId: LMNTSpeechModelId): SpeechModelV3;
+}
+
+export interface LMNTProviderSettings {
+  /**
+API key for authenticating requests.
+     */
+  apiKey?: string;
+
+  /**
+Custom headers to include in the requests.
+     */
+  headers?: Record<string, string>;
+
+  /**
+Custom fetch implementation. You can use it as a middleware to intercept requests,
+or to provide a custom fetch implementation for e.g. testing.
+    */
+  fetch?: FetchFunction;
+}
+
+/**
+Create an LMNT provider instance.
+ */
+export function createLMNT(options: LMNTProviderSettings = {}): LMNTProvider {
+  const getHeaders = () =>
+    withUserAgentSuffix(
+      {
+        'x-api-key': loadApiKey({
+          apiKey: options.apiKey,
+          environmentVariableName: 'LMNT_API_KEY',
+          description: 'LMNT',
+        }),
+        ...options.headers,
+      },
+      `ai-sdk/lmnt/${VERSION}`,
+    );
+
+  const createSpeechModel = (modelId: LMNTSpeechModelId) =>
+    new LMNTSpeechModel(modelId, {
+      provider: `lmnt.speech`,
+      url: ({ path }) => `https://api.lmnt.com${path}`,
+      headers: getHeaders,
+      fetch: options.fetch,
+    });
+
+  const provider = function (modelId: LMNTSpeechModelId) {
+    return {
+      speech: createSpeechModel(modelId),
+    };
+  };
+
+  provider.speech = createSpeechModel;
+  provider.speechModel = createSpeechModel;
+
+  return provider as LMNTProvider;
+}
+
+/**
+Default LMNT provider instance.
+ */
+export const lmnt = createLMNT();

package/src/lmnt-speech-model.test.ts

@@ -0,0 +1,197 @@
+import { createTestServer } from '@ai-sdk/test-server/with-vitest';
+import { LMNTSpeechModel } from './lmnt-speech-model';
+import { createLMNT } from './lmnt-provider';
+import { describe, it, expect, vi } from 'vitest';
+
+vi.mock('./version', () => ({
+  VERSION: '0.0.0-test',
+}));
+
+const provider = createLMNT({ apiKey: 'test-api-key' });
+const model = provider.speech('aurora');
+
+const server = createTestServer({
+  'https://api.lmnt.com/v1/ai/speech/bytes': {},
+});
+
+describe('doGenerate', () => {
+  function prepareAudioResponse({
+    headers,
+    format = 'mp3',
+  }: {
+    headers?: Record<string, string>;
+    format?: 'aac' | 'mp3' | 'mulaw' | 'raw' | 'wav';
+  } = {}) {
+    const audioBuffer = new Uint8Array(100); // Mock audio data
+    server.urls['https://api.lmnt.com/v1/ai/speech/bytes'].response = {
+      type: 'binary',
+      headers: {
+        'content-type': `audio/${format}`,
+        ...headers,
+      },
+      body: Buffer.from(audioBuffer),
+    };
+    return audioBuffer;
+  }
+
+  it('should pass the model and text', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello from the AI SDK!',
+    });
+
+    expect(await server.calls[0].requestBodyJson).toMatchObject({
+      model: 'aurora',
+      text: 'Hello from the AI SDK!',
+    });
+  });
+
+  it('should pass headers', async () => {
+    prepareAudioResponse();
+
+    const provider = createLMNT({
+      apiKey: 'test-api-key',
+      headers: {
+        'Custom-Provider-Header': 'provider-header-value',
+      },
+    });
+
+    await provider.speech('aurora').doGenerate({
+      text: 'Hello from the AI SDK!',
+      headers: {
+        'Custom-Request-Header': 'request-header-value',
+      },
+    });
+
+    expect(server.calls[0].requestHeaders).toMatchObject({
+      'x-api-key': 'test-api-key',
+      'content-type': 'application/json',
+      'custom-provider-header': 'provider-header-value',
+      'custom-request-header': 'request-header-value',
+    });
+    expect(server.calls[0].requestUserAgent).toContain(
+      `ai-sdk/lmnt/0.0.0-test`,
+    );
+  });
+
+  it('should pass options', async () => {
+    prepareAudioResponse();
+
+    await model.doGenerate({
+      text: 'Hello from the AI SDK!',
+      voice: 'nova',
+      outputFormat: 'mp3',
+      speed: 1.5,
+    });
+
+    expect(await server.calls[0].requestBodyJson).toMatchObject({
+      model: 'aurora',
+      text: 'Hello from the AI SDK!',
+      voice: 'nova',
+      speed: 1.5,
+      response_format: 'mp3',
+    });
+  });
+
+  it('should return audio data with correct content type', async () => {
+    const audio = new Uint8Array(100); // Mock audio data
+    prepareAudioResponse({
+      format: 'mp3',
+      headers: {
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+
+    const result = await model.doGenerate({
+      text: 'Hello from the AI SDK!',
+      outputFormat: 'mp3',
+    });
+
+    expect(result.audio).toStrictEqual(audio);
+  });
+
+  it('should include response data with timestamp, modelId and headers', async () => {
+    prepareAudioResponse({
+      headers: {
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+
+    const testDate = new Date(0);
+    const customModel = new LMNTSpeechModel('aurora', {
+      provider: 'test-provider',
+      url: () => 'https://api.lmnt.com/v1/ai/speech/bytes',
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      text: 'Hello from the AI SDK!',
+    });
+
+    expect(result.response).toMatchObject({
+      timestamp: testDate,
+      modelId: 'aurora',
+      headers: {
+        'content-type': 'audio/mp3',
+        'x-request-id': 'test-request-id',
+        'x-ratelimit-remaining': '123',
+      },
+    });
+  });
+
+  it('should use real date when no custom date provider is specified', async () => {
+    prepareAudioResponse();
+
+    const testDate = new Date(0);
+    const customModel = new LMNTSpeechModel('aurora', {
+      provider: 'test-provider',
+      url: () => 'https://api.lmnt.com/v1/ai/speech/bytes',
+      headers: () => ({}),
+      _internal: {
+        currentDate: () => testDate,
+      },
+    });
+
+    const result = await customModel.doGenerate({
+      text: 'Hello from the AI SDK!',
+    });
+
+    expect(result.response.timestamp.getTime()).toEqual(testDate.getTime());
+    expect(result.response.modelId).toBe('aurora');
+  });
+
+  it('should handle different audio formats', async () => {
+    const formats = ['aac', 'mp3', 'mulaw', 'raw', 'wav'] as const;
+
+    for (const format of formats) {
+      const audio = prepareAudioResponse({ format });
+
+      const result = await model.doGenerate({
+        text: 'Hello from the AI SDK!',
+        providerOptions: {
+          lmnt: {
+            format,
+          },
+        },
+      });
+
+      expect(result.audio).toStrictEqual(audio);
+    }
+  });
+
+  it('should include warnings if any are generated', async () => {
+    prepareAudioResponse();
+
+    const result = await model.doGenerate({
+      text: 'Hello from the AI SDK!',
+    });
+
+    expect(result.warnings).toEqual([]);
+  });
+});

package/src/lmnt-speech-model.ts

@@ -0,0 +1,206 @@
+import { SpeechModelV3, SharedV3Warning } from '@ai-sdk/provider';
+import {
+  combineHeaders,
+  createBinaryResponseHandler,
+  parseProviderOptions,
+  postJsonToApi,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { LMNTConfig } from './lmnt-config';
+import { lmntFailedResponseHandler } from './lmnt-error';
+import { LMNTSpeechModelId } from './lmnt-speech-options';
+import { LMNTSpeechAPITypes } from './lmnt-api-types';
+
+// https://docs.lmnt.com/api-reference/speech/synthesize-speech-bytes
+const lmntSpeechCallOptionsSchema = z.object({
+  /**
+   * The model to use for speech synthesis e.g. 'aurora' or 'blizzard'.
+   * @default 'aurora'
+   */
+  model: z
+    .union([z.enum(['aurora', 'blizzard']), z.string()])
+    .nullish()
+    .default('aurora'),
+
+  /**
+   * The audio format of the output.
+   * @default 'mp3'
+   */
+  format: z
+    .enum(['aac', 'mp3', 'mulaw', 'raw', 'wav'])
+    .nullish()
+    .default('mp3'),
+
+  /**
+   * The sample rate of the output audio in Hz.
+   * @default 24000
+   */
+  sampleRate: z
+    .union([z.literal(8000), z.literal(16000), z.literal(24000)])
+    .nullish()
+    .default(24000),
+
+  /**
+   * The speed of the speech. Range: 0.25 to 2.
+   * @default 1
+   */
+  speed: z.number().min(0.25).max(2).nullish().default(1),
+
+  /**
+   * A seed value for deterministic generation.
+   */
+  seed: z.number().int().nullish(),
+
+  /**
+   * Whether to use a conversational style.
+   * @default false
+   */
+  conversational: z.boolean().nullish().default(false),
+
+  /**
+   * Maximum length of the output in seconds (up to 300).
+   */
+  length: z.number().max(300).nullish(),
+
+  /**
+   * Top-p sampling parameter. Range: 0 to 1.
+   * @default 1
+   */
+  topP: z.number().min(0).max(1).nullish().default(1),
+
+  /**
+   * Temperature for sampling. Higher values increase randomness.
+   * @default 1
+   */
+  temperature: z.number().min(0).nullish().default(1),
+});
+
+export type LMNTSpeechCallOptions = z.infer<typeof lmntSpeechCallOptionsSchema>;
+
+interface LMNTSpeechModelConfig extends LMNTConfig {
+  _internal?: {
+    currentDate?: () => Date;
+  };
+}
+
+export class LMNTSpeechModel implements SpeechModelV3 {
+  readonly specificationVersion = 'v3';
+
+  get provider(): string {
+    return this.config.provider;
+  }
+
+  constructor(
+    readonly modelId: LMNTSpeechModelId,
+    private readonly config: LMNTSpeechModelConfig,
+  ) {}
+
+  private async getArgs({
+    text,
+    voice = 'ava',
+    outputFormat = 'mp3',
+    speed,
+    language,
+    providerOptions,
+  }: Parameters<SpeechModelV3['doGenerate']>[0]) {
+    const warnings: SharedV3Warning[] = [];
+
+    // Parse provider options
+    const lmntOptions = await parseProviderOptions({
+      provider: 'lmnt',
+      providerOptions,
+      schema: lmntSpeechCallOptionsSchema,
+    });
+
+    // Create request body
+    const requestBody: Record<string, unknown> = {
+      model: this.modelId,
+      text,
+      voice,
+      response_format: 'mp3',
+      speed,
+    };
+
+    if (outputFormat) {
+      if (['mp3', 'aac', 'mulaw', 'raw', 'wav'].includes(outputFormat)) {
+        requestBody.response_format = outputFormat;
+      } else {
+        warnings.push({
+          type: 'unsupported',
+          feature: 'outputFormat',
+          details: `Unsupported output format: ${outputFormat}. Using mp3 instead.`,
+        });
+      }
+    }
+
+    // Add provider-specific options
+    if (lmntOptions) {
+      const speechModelOptions: Omit<LMNTSpeechAPITypes, 'voice' | 'text'> = {
+        conversational: lmntOptions.conversational ?? undefined,
+        length: lmntOptions.length ?? undefined,
+        seed: lmntOptions.seed ?? undefined,
+        speed: lmntOptions.speed ?? undefined,
+        temperature: lmntOptions.temperature ?? undefined,
+        top_p: lmntOptions.topP ?? undefined,
+        sample_rate: lmntOptions.sampleRate ?? undefined,
+      };
+
+      for (const key in speechModelOptions) {
+        const value =
+          speechModelOptions[
+            key as keyof Omit<LMNTSpeechAPITypes, 'voice' | 'text'>
+          ];
+        if (value !== undefined) {
+          requestBody[key] = value;
+        }
+      }
+    }
+
+    if (language) {
+      requestBody.language = language;
+    }
+
+    return {
+      requestBody,
+      warnings,
+    };
+  }
+
+  async doGenerate(
+    options: Parameters<SpeechModelV3['doGenerate']>[0],
+  ): Promise<Awaited<ReturnType<SpeechModelV3['doGenerate']>>> {
+    const currentDate = this.config._internal?.currentDate?.() ?? new Date();
+    const { requestBody, warnings } = await this.getArgs(options);
+
+    const {
+      value: audio,
+      responseHeaders,
+      rawValue: rawResponse,
+    } = await postJsonToApi({
+      url: this.config.url({
+        path: '/v1/ai/speech/bytes',
+        modelId: this.modelId,
+      }),
+      headers: combineHeaders(this.config.headers(), options.headers),
+      body: requestBody,
+      failedResponseHandler: lmntFailedResponseHandler,
+      successfulResponseHandler: createBinaryResponseHandler(),
+      abortSignal: options.abortSignal,
+      fetch: this.config.fetch,
+    });
+
+    return {
+      audio,
+      warnings,
+      request: {
+        body: JSON.stringify(requestBody),
+      },
+      response: {
+        timestamp: currentDate,
+        modelId: this.modelId,
+        headers: responseHeaders,
+        body: rawResponse,
+      },
+    };
+  }
+}

package/src/lmnt-speech-options.ts

@@ -0,0 +1 @@
+export type LMNTSpeechModelId = 'aurora' | 'blizzard' | (string & {});

package/src/version.ts

@@ -0,0 +1,6 @@
+// Version string of this package injected at build time.
+declare const __PACKAGE_VERSION__: string | undefined;
+export const VERSION: string =
+  typeof __PACKAGE_VERSION__ !== 'undefined'
+    ? __PACKAGE_VERSION__
+    : '0.0.0-test';