telnyx 6.71.0 → 6.73.0

package/src/resources/speech-to-text/ws.ts

@@ -1,127 +1,42 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import * as WS from 'ws';
-import { SpeechToTextEmitter, buildURL } from './internal-base';
-import * as SpeechToTextAPI from './speech-to-text';
+import { NodeWebSocket } from '../../internal/ws-adapter-node';
+import { SpeechToTextWSBase, type SpeechToTextWSBaseOptions } from './ws-base';
 import { Telnyx } from '../../client';
 
-export class SpeechToTextWS extends SpeechToTextEmitter {
-  url: URL;
-  socket: WS.WebSocket;
-  private client: Telnyx;
+export type { SpeechToTextWSReconnectOptions } from './ws-base';
+
+export interface SpeechToTextWSClientOptions extends WS.ClientOptions, SpeechToTextWSBaseOptions {}
+
+export class SpeechToTextWS extends SpeechToTextWSBase<NodeWebSocket> {
+  private _wsOptions: WS.ClientOptions | null | undefined;
 
   constructor(
     client: Telnyx,
-    parameters: SpeechToTextAPI.SpeechToTextStreamParams,
-    options?: WS.ClientOptions | null | undefined,
+    parameters?: Record<string, unknown> | undefined,
+    options?: SpeechToTextWSClientOptions | null | undefined,
   ) {
-    super();
-    this.client = client;
-    this.url = buildURL(client, parameters);
-    this.socket = new WS.WebSocket(this.url, {
-      ...options,
-      headers: {
-        ...this.authHeaders(),
-        ...options?.headers,
-      },
-    });
-
-    this.socket.on('open', () => {
-      // Connection established, ready to send audio
-    });
-
-    this.socket.on('message', (wsEvent) => {
-      const event = (() => {
-        try {
-          return JSON.parse(wsEvent.toString()) as SpeechToTextAPI.SttServerEvent;
-        } catch (err) {
-          this._onError(null, 'could not parse websocket event', err);
-          return null;
-        }
-      })();
-
-      if (event) {
-        this._emit('event', event);
-
-        if (event.type === 'error') {
-          this._onError(event);
-        } else {
-          // @ts-ignore TS isn't smart enough to get the relationship right here
-          this._emit(event.type, event);
-        }
-      }
-    });
-
-    this.socket.on('error', (err) => {
-      this._onError(null, err.message, err);
-    });
-
-    this.socket.on('close', (code, reason) => {
-      // Connection closed
-    });
-  }
-
-  /**
-   * Send binary audio data to the server for transcription.
-   * @param data - Raw audio bytes (mp3 or wav format)
-   */
-  send(data: SpeechToTextAPI.SttClientEvent) {
-    try {
-      this.socket.send(data);
-    } catch (err) {
-      this._onError(null, 'could not send audio data', err);
+    if (!WS?.WebSocket) {
+      throw new Error(
+        'SpeechToTextWS from "telnyx/resources/speech-to-text/ws" requires the "ws" package but it could not be loaded.',
+      );
     }
-  }
 
-  /**
-   * Close the WebSocket connection.
-   */
-  close(props?: { code: number; reason: string }) {
-    try {
-      this.socket.close(props?.code ?? 1000, props?.reason ?? 'OK');
-    } catch (err) {
-      this._onError(null, 'could not close the connection', err);
-    }
+    const { reconnect, maxQueueSize, ...wsOptions } = options ?? {};
+    super(client, parameters, { reconnect, maxQueueSize });
+    this._wsOptions = wsOptions;
+    this._connectInitial();
   }
 
-  /**
-   * Check if the WebSocket is open and ready to send data.
-   */
-  get isOpen(): boolean {
-    return this.socket.readyState === WS.WebSocket.OPEN;
-  }
-
-  /**
-   * Wait for the connection to be established.
-   */
-  waitForOpen(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (this.socket.readyState === WS.WebSocket.OPEN) {
-        resolve();
-        return;
-      }
-
-      const onOpen = () => {
-        this.socket.off('open', onOpen);
-        this.socket.off('error', onError);
-        resolve();
-      };
-
-      const onError = (err: Error) => {
-        this.socket.off('open', onOpen);
-        this.socket.off('error', onError);
-        reject(err);
-      };
-
-      this.socket.on('open', onOpen);
-      this.socket.on('error', onError);
+  protected _createSocket(url: URL, authHeaders: Record<string, string>): NodeWebSocket {
+    const ws = new WS.WebSocket(url, {
+      ...this._wsOptions,
+      headers: {
+        ...authHeaders,
+        ...this._wsOptions?.headers,
+      },
     });
-  }
-
-  private authHeaders(): Record<string, string> {
-    if (this.client.apiKey) {
-      return { Authorization: `Bearer ${this.client.apiKey}` };
-    }
-    return {};
+    return new NodeWebSocket(ws);
   }
 }

package/src/resources/speech-to-text.ts

@@ -1,114 +1,3 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { APIResource } from '../core/resource';
-import { APIPromise } from '../core/api-promise';
-import { RequestOptions } from '../internal/request-options';
-
-/**
- * Discover available speech-to-text providers, models, and supported languages.
- */
-export class SpeechToText extends APIResource {
-  /**
-   * Retrieve the canonical list of supported speech-to-text providers, models,
-   * accepted language codes, and the service types each model supports.
-   *
-   * Service types:
-   *
-   * - `streaming` — standalone WebSocket transcription via
-   *   `/speech-to-text/transcription`.
-   * - `file_transcription` — file-based transcription via
-   *   `/ai/audio/transcriptions`.
-   * - `in_call_transcription` — live call transcription via Call Control
-   *   `transcription_start`.
-   *
-   * Use this endpoint to discover which (provider, model) combinations are available
-   * for the surface you need, and which language codes each accepts. `auto` in a
-   * `languages` array indicates the provider performs language detection.
-   */
-  listProviders(
-    query: SpeechToTextListProvidersParams | null | undefined = {},
-    options?: RequestOptions,
-  ): APIPromise<SpeechToTextListProvidersResponse> {
-    return this._client.get('/speech-to-text/providers', {
-      query,
-      defaultBaseURL: 'https://api.telnyx.com/v2',
-      ...options,
-    });
-  }
-}
-
-/**
- * List of supported STT providers and models.
- */
-export interface SpeechToTextListProvidersResponse {
-  data: Array<SpeechToTextListProvidersResponse.Data>;
-
-  meta: SpeechToTextListProvidersResponse.Meta;
-}
-
-export namespace SpeechToTextListProvidersResponse {
-  /**
-   * A (provider, model) tuple along with its supported service types and languages.
-   */
-  export interface Data {
-    /**
-     * Languages this (provider, model) accepts, in the provider's native code format.
-     * `auto` indicates the provider performs language detection.
-     */
-    languages: Array<string>;
-
-    /**
-     * Provider-scoped model name.
-     */
-    model: string;
-
-    /**
-     * STT provider name.
-     */
-    provider: string;
-
-    /**
-     * Service surfaces this (provider, model) supports.
-     */
-    service_types: Array<'streaming' | 'file_transcription' | 'in_call_transcription'>;
-  }
-
-  export interface Meta {
-    /**
-     * Total number of entries returned.
-     */
-    total: number;
-  }
-}
-
-export interface SpeechToTextListProvidersParams {
-  /**
-   * Filter to entries for a specific STT provider. The enum mirrors the providers
-   * advertised across the speech-to-text spec (including `google` and `telnyx`,
-   * which are accepted as WebSocket transcription engines). A provider that has no
-   * models currently registered for any service type will return an empty `data`
-   * array rather than an error.
-   */
-  provider?:
-    | 'deepgram'
-    | 'speechmatics'
-    | 'assemblyai'
-    | 'xai'
-    | 'soniox'
-    | 'azure'
-    | 'openai'
-    | 'google'
-    | 'telnyx';
-
-  /**
-   * Filter to entries that support the given service type.
-   */
-  service_type?: 'streaming' | 'file_transcription' | 'in_call_transcription';
-}
-
-export declare namespace SpeechToText {
-  export {
-    type SpeechToTextListProvidersResponse as SpeechToTextListProvidersResponse,
-    type SpeechToTextListProvidersParams as SpeechToTextListProvidersParams,
-  };
-}
+export * from './speech-to-text/index';