@livekit/agents 1.1.0-dev.0 → 1.2.0

package/src/index.ts

@@ -9,33 +9,31 @@
  * @see {@link https://docs.livekit.io/agents/overview | LiveKit Agents documentation}
  * @packageDocumentation
  */
-import * as beta from './beta/index.js';
-import * as cli from './cli.js';
-import * as inference from './inference/index.js';
-import * as ipc from './ipc/index.js';
-import * as llm from './llm/index.js';
-import * as metrics from './metrics/index.js';
-import * as stream from './stream/index.js';
-import * as stt from './stt/index.js';
-import * as telemetry from './telemetry/index.js';
-import * as tokenize from './tokenize/index.js';
-import * as tts from './tts/index.js';
-import * as voice from './voice/index.js';
-
 export * from './_exceptions.js';
 export * from './audio.js';
+export * as beta from './beta/index.js';
+export * as cli from './cli.js';
 export * from './connection_pool.js';
 export * from './generator.js';
+export * as inference from './inference/index.js';
 export * from './inference_runner.js';
+export * as ipc from './ipc/index.js';
 export * from './job.js';
+export * from './language.js';
+export * as llm from './llm/index.js';
 export * from './log.js';
+export * as metrics from './metrics/index.js';
 export * from './plugin.js';
+export * as stream from './stream/index.js';
+export * as stt from './stt/index.js';
+export * as telemetry from './telemetry/index.js';
+export * as tokenize from './tokenize/index.js';
 export * from './transcription.js';
+export * as tts from './tts/index.js';
 export * from './types.js';
 export * from './utils.js';
 export * from './vad.js';
 export * from './version.js';
+export * as voice from './voice/index.js';
 export { createTimedString, isTimedString, type TimedString } from './voice/io.js';
 export * from './worker.js';
-
-export { beta, cli, inference, ipc, llm, metrics, stream, stt, telemetry, tokenize, tts, voice };

package/src/inference/interruption/defaults.ts

@@ -9,7 +9,7 @@ export const THRESHOLD = 0.5;
 export const MAX_AUDIO_DURATION_IN_S = 3.0;
 export const AUDIO_PREFIX_DURATION_IN_S = 0.5;
 export const DETECTION_INTERVAL_IN_S = 0.1;
-export const REMOTE_INFERENCE_TIMEOUT_IN_S = 1.0;
+export const REMOTE_INFERENCE_TIMEOUT_IN_S = 0.7;
 export const SAMPLE_RATE = 16000;
 export const FRAMES_PER_SECOND = 40;
 export const FRAME_DURATION_IN_S = 0.025; // 25ms per frame

package/src/inference/interruption/http_transport.ts

@@ -1,12 +1,12 @@
 // SPDX-FileCopyrightText: 2026 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { ofetch } from 'ofetch';
+import { FetchError, ofetch } from 'ofetch';
 import { TransformStream } from 'stream/web';
 import { z } from 'zod';
+import { APIConnectionError, APIError, APIStatusError, isAPIError } from '../../_exceptions.js';
 import { log } from '../../log.js';
 import { createAccessToken } from '../utils.js';
-import { intervalForRetry } from './defaults.js';
 import { InterruptionCacheEntry } from './interruption_cache_entry.js';
 import type { OverlappingSpeechEvent } from './types.js';
 import type { BoundedCache } from './utils.js';
@@ -50,31 +50,50 @@ export async function predictHTTP(
   url.searchParams.append('min_frames', predictOptions.minFrames.toFixed());
   url.searchParams.append('created_at', createdAt.toFixed());
 
-  let retryCount = 0;
-  const response = await ofetch(url.toString(), {
-    retry: options.maxRetries ?? 3,
-    retryDelay: () => {
-      const delay = intervalForRetry(retryCount);
-      retryCount++;
-      return delay;
-    },
-    headers: {
-      'Content-Type': 'application/octet-stream',
-      Authorization: `Bearer ${options.token}`,
-    },
-    signal: options.signal,
-    timeout: options.timeout,
-    method: 'POST',
-    body: data,
-  });
-  const { created_at, is_bargein, probabilities } = predictEndpointResponseSchema.parse(response);
-
-  return {
-    createdAt: created_at,
-    isBargein: is_bargein,
-    probabilities,
-    predictionDurationInS: (performance.now() - createdAt) / 1000,
-  };
+  try {
+    const response = await ofetch(url.toString(), {
+      retry: 0,
+      headers: {
+        'Content-Type': 'application/octet-stream',
+        Authorization: `Bearer ${options.token}`,
+      },
+      signal: options.signal,
+      timeout: options.timeout,
+      method: 'POST',
+      body: data,
+    });
+    const { created_at, is_bargein, probabilities } = predictEndpointResponseSchema.parse(response);
+
+    return {
+      createdAt: created_at,
+      isBargein: is_bargein,
+      probabilities,
+      predictionDurationInS: (performance.now() - createdAt) / 1000,
+    };
+  } catch (err) {
+    if (isAPIError(err)) throw err;
+    if (err instanceof FetchError) {
+      if (err.statusCode) {
+        throw new APIStatusError({
+          message: `error during interruption prediction: ${err.message}`,
+          options: { statusCode: err.statusCode, body: err.data },
+        });
+      }
+      if (
+        err.cause instanceof Error &&
+        (err.cause.name === 'TimeoutError' || err.cause.name === 'AbortError')
+      ) {
+        throw new APIStatusError({
+          message: `interruption inference timeout: ${err.message}`,
+          options: { statusCode: 408, retryable: false },
+        });
+      }
+      throw new APIConnectionError({
+        message: `interruption inference connection error: ${err.message}`,
+      });
+    }
+    throw new APIError(`error during interruption prediction: ${err}`);
+  }
 }
 
 export interface HttpTransportOptions {
@@ -154,8 +173,8 @@ export function createHttpTransport(
               updateUserSpeakingSpan(entry);
             }
             const event: OverlappingSpeechEvent = {
-              type: 'user_overlapping_speech',
-              timestamp: Date.now(),
+              type: 'overlapping_speech',
+              detectedAt: Date.now(),
               overlapStartedAt: overlapSpeechStartedAt,
               isInterruption: entry.isInterruption,
               speechInput: entry.speechInput,
@@ -177,7 +196,7 @@ export function createHttpTransport(
             controller.enqueue(event);
           }
         } catch (err) {
-          logger.error({ err }, 'Failed to send audio data over HTTP');
+          controller.error(err);
         }
       },
     },

package/src/inference/interruption/interruption_detector.ts

@@ -7,12 +7,12 @@ import { log } from '../../log.js';
 import type { InterruptionMetrics } from '../../metrics/base.js';
 import { DEFAULT_INFERENCE_URL, STAGING_INFERENCE_URL, getDefaultInferenceUrl } from '../utils.js';
 import { FRAMES_PER_SECOND, SAMPLE_RATE, interruptionOptionDefaults } from './defaults.js';
-import type { InterruptionDetectionError } from './errors.js';
+import { InterruptionDetectionError } from './errors.js';
 import { InterruptionStreamBase } from './interruption_stream.js';
 import type { InterruptionOptions, OverlappingSpeechEvent } from './types.js';
 
 type InterruptionCallbacks = {
-  user_overlapping_speech: (event: OverlappingSpeechEvent) => void;
+  overlapping_speech: (event: OverlappingSpeechEvent) => void;
   metrics_collected: (metrics: InterruptionMetrics) => void;
   error: (error: InterruptionDetectionError) => void;
 };
@@ -76,6 +76,15 @@ export class AdaptiveInterruptionDetector extends (EventEmitter as new () => Typ
     } else {
       useProxy = false;
     }
+    const transport = useProxy ? 'websocket' : 'http';
+    this.logger.debug(
+      {
+        baseUrl: lkBaseUrl,
+        useProxy,
+        transport,
+      },
+      '=== Resolved interruption detector transport configuration',
+    );
 
     this.options = {
       sampleRate: SAMPLE_RATE,
@@ -104,8 +113,9 @@ export class AdaptiveInterruptionDetector extends (EventEmitter as new () => Typ
         threshold: this.options.threshold,
         inferenceTimeout: this.options.inferenceTimeout,
         useProxy: this.options.useProxy,
+        transport,
       },
-      'adaptive interruption detector initialized',
+      '=== Adaptive interruption detector initialized',
     );
   }
 
@@ -150,9 +160,15 @@ export class AdaptiveInterruptionDetector extends (EventEmitter as new () => Typ
    * Use this when you need direct access to the stream for pushing frames.
    */
   createStream(): InterruptionStreamBase {
-    const streamBase = new InterruptionStreamBase(this, {});
-    this.streams.add(streamBase);
-    return streamBase;
+    try {
+      const streamBase = new InterruptionStreamBase(this, {});
+      this.streams.add(streamBase);
+      return streamBase;
+    } catch (e) {
+      const cause = e instanceof Error ? e : new Error(String(e));
+      this.emitError(new InterruptionDetectionError(cause.message, Date.now(), this._label, false));
+      throw e;
+    }
   }
 
   /**

package/src/inference/interruption/interruption_stream.ts

@@ -281,8 +281,8 @@ export class InterruptionStreamBase {
               }
               const e = latestEntry ?? InterruptionCacheEntry.default();
               const event: OverlappingSpeechEvent = {
-                type: 'user_overlapping_speech',
-                timestamp: chunk.endedAt,
+                type: 'overlapping_speech',
+                detectedAt: chunk.endedAt,
                 isInterruption: false,
                 overlapStartedAt: this.overlapSpeechStartedAt,
                 speechInput: e.speechInput,
@@ -334,11 +334,11 @@ export class InterruptionStreamBase {
 
     const eventEmitter = new TransformStream<OverlappingSpeechEvent, OverlappingSpeechEvent>({
       transform: (chunk, controller) => {
-        this.model.emit('user_overlapping_speech', chunk);
+        this.model.emit('overlapping_speech', chunk);
 
         const metrics: InterruptionMetrics = {
           type: 'interruption_metrics',
-          timestamp: chunk.timestamp,
+          timestamp: chunk.detectedAt,
           totalDuration: chunk.totalDurationInS * 1000,
           predictionDuration: chunk.predictionDurationInS * 1000,
           detectionDelay: chunk.detectionDelayInS * 1000,

package/src/inference/interruption/types.ts

@@ -4,8 +4,8 @@
 import type { Span } from '@opentelemetry/api';
 
 export interface OverlappingSpeechEvent {
-  type: 'user_overlapping_speech';
-  timestamp: number;
+  type: 'overlapping_speech';
+  detectedAt: number;
   isInterruption: boolean;
   totalDurationInS: number;
   predictionDurationInS: number;

package/src/inference/interruption/ws_transport.ts

@@ -4,9 +4,9 @@
 import { TransformStream } from 'stream/web';
 import WebSocket from 'ws';
 import { z } from 'zod';
+import { APIConnectionError, APIStatusError, APITimeoutError } from '../../_exceptions.js';
 import { log } from '../../log.js';
 import { createAccessToken } from '../utils.js';
-import { intervalForRetry } from './defaults.js';
 import { InterruptionCacheEntry } from './interruption_cache_entry.js';
 import type { OverlappingSpeechEvent } from './types.js';
 import type { BoundedCache } from './utils.js';
@@ -82,16 +82,32 @@ async function connectWebSocket(options: WsTransportOptions): Promise<WebSocket>
   await new Promise<void>((resolve, reject) => {
     const timeout = setTimeout(() => {
       ws.terminate();
-      reject(new Error('WebSocket connection timeout'));
+      reject(
+        new APITimeoutError({
+          message: 'WebSocket connection timeout',
+          options: { retryable: false },
+        }),
+      );
     }, options.timeout);
     ws.once('open', () => {
       clearTimeout(timeout);
       resolve();
     });
+    ws.once('unexpected-response', (_req, res) => {
+      clearTimeout(timeout);
+      ws.terminate();
+      const statusCode = res.statusCode ?? -1;
+      reject(
+        new APIStatusError({
+          message: `WebSocket connection rejected with status ${statusCode}`,
+          options: { statusCode, retryable: false },
+        }),
+      );
+    });
     ws.once('error', (err: Error) => {
       clearTimeout(timeout);
       ws.terminate();
-      reject(err);
+      reject(new APIConnectionError({ message: `WebSocket connection error: ${err.message}` }));
     });
   });
 
@@ -133,7 +149,9 @@ export function createWsTransport(
     });
 
     socket.on('error', (err: Error) => {
-      logger.error({ err }, 'WebSocket error');
+      outputController?.error(
+        new APIConnectionError({ message: `WebSocket error: ${err.message}` }),
+      );
     });
 
     socket.on('close', (code: number, reason: Buffer) => {
@@ -144,41 +162,20 @@ export function createWsTransport(
   async function ensureConnection(): Promise<void> {
     if (ws && ws.readyState === WebSocket.OPEN) return;
 
-    const maxRetries = options.maxRetries ?? 3;
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        ws = await connectWebSocket(options);
-        setupMessageHandler(ws);
-
-        // Send session.create message
-        const sessionCreateMsg = JSON.stringify({
-          type: MSG_SESSION_CREATE,
-          settings: {
-            sample_rate: options.sampleRate,
-            num_channels: 1,
-            threshold: options.threshold,
-            min_frames: options.minFrames,
-            encoding: 's16le',
-          },
-        });
-        ws.send(sessionCreateMsg);
-        return;
-      } catch (err) {
-        lastError = err instanceof Error ? err : new Error(String(err));
-        if (attempt < maxRetries) {
-          const delay = intervalForRetry(attempt);
-          logger.debug(
-            { attempt, delay, err: lastError.message },
-            'WebSocket connection failed, retrying',
-          );
-          await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-      }
-    }
-
-    throw lastError ?? new Error('Failed to connect to WebSocket after retries');
+    ws = await connectWebSocket(options);
+    setupMessageHandler(ws);
+
+    const sessionCreateMsg = JSON.stringify({
+      type: MSG_SESSION_CREATE,
+      settings: {
+        sample_rate: options.sampleRate,
+        num_channels: 1,
+        threshold: options.threshold,
+        min_frames: options.minFrames,
+        encoding: 's16le',
+      },
+    });
+    ws.send(sessionCreateMsg);
   }
 
   function handleMessage(message: WsMessage): void {
@@ -229,8 +226,8 @@ export function createWsTransport(
           );
 
           const event: OverlappingSpeechEvent = {
-            type: 'user_overlapping_speech',
-            timestamp: Date.now(),
+            type: 'overlapping_speech',
+            detectedAt: Date.now(),
             isInterruption: true,
             totalDurationInS: entry.totalDurationInS,
             predictionDurationInS: entry.predictionDurationInS,
@@ -288,11 +285,10 @@ export function createWsTransport(
 
       case MSG_ERROR:
         outputController?.error(
-          new Error(
-            `LiveKit Adaptive Interruption error${
-              message.code !== undefined ? ` (${message.code})` : ''
-            }: ${message.message}`,
-          ),
+          new APIStatusError({
+            message: `LiveKit Adaptive Interruption error: ${message.message}`,
+            options: { statusCode: message.code ?? -1 },
+          }),
         );
         break;
     }
@@ -300,15 +296,12 @@ export function createWsTransport(
 
   function sendAudioData(audioSlice: Int16Array): void {
     if (!ws || ws.readyState !== WebSocket.OPEN) {
-      throw new Error('WebSocket not connected');
+      throw new APIConnectionError({ message: 'WebSocket not connected' });
     }
 
     const state = getState();
-    // Use truncated timestamp consistently for both cache key and header
-    // This ensures the server's response created_at matches our cache key
     const createdAt = Math.floor(performance.now());
 
-    // Store the audio data in cache with truncated timestamp
     state.cache.set(
       createdAt,
       new InterruptionCacheEntry({
@@ -318,13 +311,11 @@ export function createWsTransport(
       }),
     );
 
-    // Create header: 8-byte little-endian uint64 timestamp (milliseconds as integer)
     const header = new ArrayBuffer(8);
     const view = new DataView(header);
     view.setUint32(0, createdAt >>> 0, true);
     view.setUint32(4, Math.floor(createdAt / 0x100000000) >>> 0, true);
 
-    // Combine header and audio data
     const audioBytes = new Uint8Array(
       audioSlice.buffer,
       audioSlice.byteOffset,
@@ -334,12 +325,8 @@ export function createWsTransport(
     combined.set(new Uint8Array(header), 0);
     combined.set(audioBytes, 8);
 
-    try {
-      ws.send(combined);
-      onRequestSent?.();
-    } catch (e: unknown) {
-      logger.error(e, `failed to send audio via websocket`);
-    }
+    ws.send(combined);
+    onRequestSent?.();
   }
 
   function close(): void {
@@ -383,10 +370,27 @@ export function createWsTransport(
         const state = getState();
         if (!state.overlapSpeechStartedAt || !state.overlapSpeechStarted) return;
 
+        if (options.timeout > 0) {
+          const now = performance.now();
+          for (const [, entry] of state.cache.entries()) {
+            if (entry.totalDurationInS !== 0) continue;
+            if (now - entry.createdAt > options.timeout) {
+              controller.error(
+                new APIStatusError({
+                  message: `interruption inference timed out after ${((now - entry.createdAt) / 1000).toFixed(1)}s (ws)`,
+                  options: { statusCode: 408, retryable: false },
+                }),
+              );
+              return;
+            }
+            break;
+          }
+        }
+
         try {
           sendAudioData(chunk);
         } catch (err) {
-          logger.error({ err }, 'Failed to send audio data over WebSocket');
+          controller.error(err);
         }
       },
 

package/src/inference/llm.ts

@@ -4,12 +4,14 @@
 import OpenAI from 'openai';
 import { APIConnectionError, APIStatusError, APITimeoutError } from '../_exceptions.js';
 import * as llm from '../llm/index.js';
-import { DEFAULT_API_CONNECT_OPTIONS } from '../types.js';
 import type { APIConnectOptions } from '../types.js';
+import { DEFAULT_API_CONNECT_OPTIONS } from '../types.js';
 import { type Expand, toError } from '../utils.js';
 import { type AnyString, createAccessToken, getDefaultInferenceUrl } from './utils.js';
 
 export type OpenAIModels =
+  | 'openai/gpt-5.4'
+  | 'openai/gpt-5.3-chat-latest'
   | 'openai/gpt-5.2'
   | 'openai/gpt-5.2-chat-latest'
   | 'openai/gpt-5.1'

package/src/inference/stt.test.ts

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { beforeAll, describe, expect, it } from 'vitest';
+import { normalizeLanguage } from '../language.js';
 import { initializeLogger } from '../log.js';
 import { type APIConnectOptions, DEFAULT_API_CONNECT_OPTIONS } from '../types.js';
 import { STT, type STTFallbackModel, normalizeSTTFallback, parseSTTModelString } from './stt.js';
@@ -34,6 +35,12 @@ describe('parseSTTModelString', () => {
     expect(language).toBe('en');
   });
 
+  it('normalizes language suffixes', () => {
+    const [model, language] = parseSTTModelString('deepgram:english');
+    expect(model).toBe('deepgram');
+    expect(language).toBe('en');
+  });
+
   it('provider/model format without language', () => {
     const [model, language] = parseSTTModelString('deepgram/nova-3');
     expect(model).toBe('deepgram/nova-3');
@@ -151,6 +158,16 @@ describe('normalizeSTTFallback', () => {
 });
 
 describe('STT constructor fallback and connOptions', () => {
+  it('normalizes language in constructor and model string', () => {
+    const stt = makeStt({ model: 'deepgram/nova-3:english' });
+    expect(stt['opts'].language).toBe('en');
+  });
+
+  it('prefers explicit normalized language over model suffix', () => {
+    const stt = makeStt({ model: 'deepgram/nova-3:english', language: 'en_US' });
+    expect(stt['opts'].language).toBe(normalizeLanguage('en_US'));
+  });
+
   it('fallback not given defaults to undefined', () => {
     const stt = makeStt();
     expect(stt['opts'].fallback).toBeUndefined();

package/src/inference/stt.ts

@@ -5,6 +5,7 @@ import { type AudioFrame } from '@livekit/rtc-node';
 import type { WebSocket } from 'ws';
 import { APIError, APIStatusError } from '../_exceptions.js';
 import { AudioByteStream } from '../audio.js';
+import { type LanguageCode, areLanguagesEquivalent, normalizeLanguage } from '../language.js';
 import { log } from '../log.js';
 import { createStreamChannel } from '../stream/stream_channel.js';
 import {
@@ -121,10 +122,10 @@ export interface STTFallbackModel {
 export type STTFallbackModelType = STTFallbackModel | string;
 
 /** Parse a model string into [model, language]. Language is undefined if not specified. */
-export function parseSTTModelString(model: string): [string, string | undefined] {
+export function parseSTTModelString(model: string): [string, LanguageCode | undefined] {
   const idx = model.lastIndexOf(':');
   if (idx !== -1) {
-    return [model.slice(0, idx), model.slice(idx + 1)];
+    return [model.slice(0, idx), normalizeLanguage(model.slice(idx + 1))];
   }
   return [model, undefined];
 }
@@ -155,7 +156,7 @@ const DEFAULT_CANCEL_TIMEOUT = 5000;
 
 export interface InferenceSTTOptions<TModel extends STTModels> {
   model?: TModel;
-  language?: STTLanguages;
+  language?: LanguageCode;
   encoding: STTEncoding;
   sampleRate: number;
   baseURL: string;
@@ -218,25 +219,24 @@ export class STT<TModel extends STTModels> extends BaseSTT {
     let nextModel = model;
     let nextLanguage = language;
     if (typeof nextModel === 'string') {
-      const idx = nextModel.lastIndexOf(':');
-      if (idx !== -1) {
-        const languageFromModel = nextModel.slice(idx + 1) as STTLanguages;
-        if (nextLanguage && nextLanguage !== languageFromModel) {
+      const [parsedModel, parsedLanguage] = parseSTTModelString(nextModel);
+      if (parsedLanguage !== undefined) {
+        if (nextLanguage && !areLanguagesEquivalent(nextLanguage, parsedLanguage)) {
           this.#logger.warn(
             '`language` is provided via both argument and model, using the one from the argument',
             { language: nextLanguage, model: nextModel },
           );
         } else {
-          nextLanguage = languageFromModel;
+          nextLanguage = parsedLanguage as STTLanguages;
         }
-        nextModel = nextModel.slice(0, idx) as TModel;
+        nextModel = parsedModel as TModel;
       }
     }
     const normalizedFallback = fallback ? normalizeSTTFallback(fallback) : undefined;
 
     this.opts = {
       model: nextModel as TModel,
-      language: nextLanguage,
+      language: nextLanguage ? normalizeLanguage(nextLanguage) : undefined,
       encoding,
       sampleRate,
       baseURL: lkBaseURL,
@@ -270,7 +270,11 @@ export class STT<TModel extends STTModels> extends BaseSTT {
   }
 
   updateOptions(opts: Partial<Pick<InferenceSTTOptions<TModel>, 'model' | 'language'>>): void {
-    this.opts = { ...this.opts, ...opts };
+    this.opts = {
+      ...this.opts,
+      ...opts,
+      language: opts.language !== undefined ? normalizeLanguage(opts.language) : this.opts.language,
+    };
 
     for (const stream of this.streams) {
       stream.updateOptions(opts);
@@ -285,7 +289,7 @@ export class STT<TModel extends STTModels> extends BaseSTT {
       options || {};
     const streamOpts = {
       ...this.opts,
-      language: language ?? this.opts.language,
+      language: language !== undefined ? normalizeLanguage(language) : this.opts.language,
     } as InferenceSTTOptions<TModel>;
 
     const stream = new SpeechStream(this, streamOpts, connOptions);
@@ -371,7 +375,11 @@ export class SpeechStream<TModel extends STTModels> extends BaseSpeechStream {
   }
 
   updateOptions(opts: Partial<Pick<InferenceSTTOptions<TModel>, 'model' | 'language'>>): void {
-    this.opts = { ...this.opts, ...opts };
+    this.opts = {
+      ...this.opts,
+      ...opts,
+      language: opts.language !== undefined ? normalizeLanguage(opts.language) : this.opts.language,
+    };
     this.reconnectEvent.set();
   }
 
@@ -576,7 +584,7 @@ export class SpeechStream<TModel extends STTModels> extends BaseSpeechStream {
 
     const requestId = data.session_id || this.requestId;
     const text = data.transcript;
-    const language = data.language || this.opts.language || 'en';
+    const language = normalizeLanguage(data.language || this.opts.language || 'en');
 
     if (!text && !isFinal) return;
 

package/src/inference/tts.test.ts

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 import { beforeAll, describe, expect, it } from 'vitest';
+import { normalizeLanguage } from '../language.js';
 import { initializeLogger } from '../log.js';
 import { type APIConnectOptions, DEFAULT_API_CONNECT_OPTIONS } from '../types.js';
 import { TTS, type TTSFallbackModel, normalizeTTSFallback, parseTTSModelString } from './tts.js';
@@ -165,6 +166,17 @@ describe('normalizeTTSFallback', () => {
 });
 
 describe('TTS constructor fallback and connOptions', () => {
+  it('normalizes language in constructor', () => {
+    const tts = makeTts({ language: 'english' });
+    expect(tts['opts'].language).toBe('en');
+  });
+
+  it('normalizes updated language values', () => {
+    const tts = makeTts();
+    tts.updateOptions({ language: 'en_US' });
+    expect(tts['opts'].language).toBe(normalizeLanguage('en_US'));
+  });
+
   it('fallback not given defaults to undefined', () => {
     const tts = makeTts();
     expect(tts['opts'].fallback).toBeUndefined();