@depup/openai 6.31.0-depup.0

package/src/realtime/internal-base.ts

@@ -0,0 +1,98 @@
+import {
+  RealtimeClientEvent,
+  RealtimeServerEvent,
+  RealtimeErrorEvent,
+  RealtimeError,
+} from '../resources/realtime/realtime';
+import { EventEmitter } from '../lib/EventEmitter';
+import { OpenAIError } from '../error';
+import OpenAI, { AzureOpenAI } from '../index';
+
+export class OpenAIRealtimeError extends OpenAIError {
+  /**
+   * The error data that the API sent back in an `error` event.
+   */
+  error?: RealtimeError | undefined;
+
+  /**
+   * The unique ID of the server event.
+   */
+  event_id?: string | undefined;
+
+  constructor(message: string, event: RealtimeErrorEvent | null) {
+    super(message);
+
+    this.error = event?.error;
+    this.event_id = event?.event_id;
+  }
+}
+
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+type RealtimeEvents = Simplify<
+  {
+    event: (event: RealtimeServerEvent) => void;
+    error: (error: OpenAIRealtimeError) => void;
+  } & {
+    [EventType in Exclude<RealtimeServerEvent['type'], 'error'>]: (
+      event: Extract<RealtimeServerEvent, { type: EventType }>,
+    ) => unknown;
+  }
+>;
+
+export abstract class OpenAIRealtimeEmitter extends EventEmitter<RealtimeEvents> {
+  /**
+   * Send an event to the API.
+   */
+  abstract send(event: RealtimeClientEvent): void;
+
+  /**
+   * Close the websocket connection.
+   */
+  abstract close(props?: { code: number; reason: string }): void;
+
+  protected _onError(event: null, message: string, cause: any): void;
+  protected _onError(event: RealtimeErrorEvent, message?: string | undefined): void;
+  protected _onError(event: RealtimeErrorEvent | null, message?: string | undefined, cause?: any): void {
+    message =
+      event?.error ?
+        `${event.error.message} code=${event.error.code} param=${event.error.param} type=${event.error.type} event_id=${event.error.event_id}`
+      : message ?? 'unknown error';
+
+    if (!this._hasListener('error')) {
+      const error = new OpenAIRealtimeError(
+        message +
+          `\n\nTo resolve these unhandled rejection errors you should bind an \`error\` callback, e.g. \`rt.on('error', (error) => ...)\` `,
+        event,
+      );
+      // @ts-ignore
+      error.cause = cause;
+      Promise.reject(error);
+      return;
+    }
+
+    const error = new OpenAIRealtimeError(message, event);
+    // @ts-ignore
+    error.cause = cause;
+
+    this._emit('error', error);
+  }
+}
+
+export function isAzure(client: Pick<OpenAI, 'apiKey' | 'baseURL'>): client is AzureOpenAI {
+  return client instanceof AzureOpenAI;
+}
+
+export function buildRealtimeURL(client: Pick<OpenAI, 'apiKey' | 'baseURL'>, model: string): URL {
+  const path = '/realtime';
+  const baseURL = client.baseURL;
+  const url = new URL(baseURL + (baseURL.endsWith('/') ? path.slice(1) : path));
+  url.protocol = 'wss';
+  if (isAzure(client)) {
+    url.searchParams.set('api-version', client.apiVersion);
+    url.searchParams.set('deployment', model);
+  } else {
+    url.searchParams.set('model', model);
+  }
+  return url;
+}

package/src/realtime/websocket.ts

@@ -0,0 +1,157 @@
+import { AzureOpenAI, OpenAI } from '../index';
+import { OpenAIError } from '../error';
+import type { RealtimeClientEvent, RealtimeServerEvent } from '../resources/realtime/realtime';
+import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+import { isRunningInBrowser } from '../internal/detect-platform';
+
+interface MessageEvent {
+  data: string;
+}
+
+type _WebSocket =
+  typeof globalThis extends (
+    {
+      WebSocket: infer ws extends abstract new (...args: any) => any;
+    }
+  ) ?
+    // @ts-ignore
+    InstanceType<ws>
+  : any;
+
+export class OpenAIRealtimeWebSocket extends OpenAIRealtimeEmitter {
+  url: URL;
+  socket: _WebSocket;
+
+  constructor(
+    props: {
+      model: string;
+      dangerouslyAllowBrowser?: boolean;
+      /**
+       * Callback to mutate the URL, needed for Azure.
+       * @internal
+       */
+      onURL?: (url: URL) => void;
+      /** Indicates the token was resolved by the factory just before connecting. @internal */
+      __resolvedApiKey?: boolean;
+    },
+    client?: Pick<OpenAI, 'apiKey' | 'baseURL'>,
+  ) {
+    super();
+    const hasProvider = typeof (client as any)?._options?.apiKey === 'function';
+    const dangerouslyAllowBrowser =
+      props.dangerouslyAllowBrowser ??
+      (client as any)?._options?.dangerouslyAllowBrowser ??
+      (client?.apiKey?.startsWith('ek_') ? true : null);
+    if (!dangerouslyAllowBrowser && isRunningInBrowser()) {
+      throw new OpenAIError(
+        "It looks like you're running in a browser-like environment.\n\nThis is disabled by default, as it risks exposing your secret API credentials to attackers.\n\nYou can avoid this error by creating an ephemeral session token:\nhttps://platform.openai.com/docs/api-reference/realtime-sessions\n",
+      );
+    }
+
+    client ??= new OpenAI({ dangerouslyAllowBrowser });
+
+    if (hasProvider && !props?.__resolvedApiKey) {
+      throw new Error(
+        [
+          'Cannot open Realtime WebSocket with a function-based apiKey.',
+          'Use the .create() method so that the key is resolved before connecting:',
+          'await OpenAIRealtimeWebSocket.create(client, { model })',
+        ].join('\n'),
+      );
+    }
+
+    this.url = buildRealtimeURL(client, props.model);
+    props.onURL?.(this.url);
+
+    // @ts-ignore
+    this.socket = new WebSocket(this.url.toString(), [
+      'realtime',
+      ...(isAzure(client) ? [] : [`openai-insecure-api-key.${client.apiKey}`]),
+    ]);
+
+    this.socket.addEventListener('message', (websocketEvent: MessageEvent) => {
+      const event = (() => {
+        try {
+          return JSON.parse(websocketEvent.data.toString()) as RealtimeServerEvent;
+        } 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-expect-error TS isn't smart enough to get the relationship right here
+          this._emit(event.type, event);
+        }
+      }
+    });
+
+    this.socket.addEventListener('error', (event: any) => {
+      this._onError(null, event.message, null);
+    });
+
+    if (isAzure(client)) {
+      if (this.url.searchParams.get('Authorization') !== null) {
+        this.url.searchParams.set('Authorization', '<REDACTED>');
+      } else {
+        this.url.searchParams.set('api-key', '<REDACTED>');
+      }
+    }
+  }
+
+  static async create(
+    client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_callApiKey'>,
+    props: { model: string; dangerouslyAllowBrowser?: boolean },
+  ): Promise<OpenAIRealtimeWebSocket> {
+    return new OpenAIRealtimeWebSocket({ ...props, __resolvedApiKey: await client._callApiKey() }, client);
+  }
+
+  static async azure(
+    client: Pick<AzureOpenAI, '_callApiKey' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
+    options: { deploymentName?: string; dangerouslyAllowBrowser?: boolean } = {},
+  ): Promise<OpenAIRealtimeWebSocket> {
+    const isApiKeyProvider = await client._callApiKey();
+    function onURL(url: URL) {
+      if (isApiKeyProvider) {
+        url.searchParams.set('Authorization', `Bearer ${client.apiKey}`);
+      } else {
+        url.searchParams.set('api-key', client.apiKey);
+      }
+    }
+    const deploymentName = options.deploymentName ?? client.deploymentName;
+    if (!deploymentName) {
+      throw new Error('No deployment name provided');
+    }
+    const { dangerouslyAllowBrowser } = options;
+    return new OpenAIRealtimeWebSocket(
+      {
+        model: deploymentName,
+        onURL,
+        ...(dangerouslyAllowBrowser ? { dangerouslyAllowBrowser } : {}),
+        __resolvedApiKey: isApiKeyProvider,
+      },
+      client,
+    );
+  }
+
+  send(event: RealtimeClientEvent) {
+    try {
+      this.socket.send(JSON.stringify(event));
+    } catch (err) {
+      this._onError(null, 'could not send data', err);
+    }
+  }
+
+  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);
+    }
+  }
+}

package/src/realtime/ws.ts

@@ -0,0 +1,113 @@
+import * as WS from 'ws';
+import { AzureOpenAI, OpenAI } from '../index';
+import type { RealtimeClientEvent, RealtimeServerEvent } from '../resources/realtime/realtime';
+import { OpenAIRealtimeEmitter, buildRealtimeURL, isAzure } from './internal-base';
+
+export class OpenAIRealtimeWS extends OpenAIRealtimeEmitter {
+  url: URL;
+  socket: WS.WebSocket;
+
+  constructor(
+    props: {
+      model: string;
+      options?: WS.ClientOptions | undefined;
+      /** @internal */ __resolvedApiKey?: boolean;
+    },
+    client?: Pick<OpenAI, 'apiKey' | 'baseURL'>,
+  ) {
+    super();
+    client ??= new OpenAI();
+    const hasProvider = typeof (client as any)?._options?.apiKey === 'function';
+    if (hasProvider && !props.__resolvedApiKey) {
+      throw new Error(
+        [
+          'Cannot open Realtime WebSocket with a function-based apiKey.',
+          'Use the .create() method so that the key is resolved before connecting:',
+          'await OpenAIRealtimeWS.create(client, { model })',
+        ].join('\n'),
+      );
+    }
+    this.url = buildRealtimeURL(client, props.model);
+    this.socket = new WS.WebSocket(this.url, {
+      ...props.options,
+      headers: {
+        ...props.options?.headers,
+        ...(isAzure(client) && !props.__resolvedApiKey ? {} : { Authorization: `Bearer ${client.apiKey}` }),
+      },
+    });
+
+    this.socket.on('message', (wsEvent) => {
+      const event = (() => {
+        try {
+          return JSON.parse(wsEvent.toString()) as RealtimeServerEvent;
+        } 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-expect-error 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);
+    });
+  }
+
+  static async create(
+    client: Pick<OpenAI, 'apiKey' | 'baseURL' | '_callApiKey'>,
+    props: { model: string; options?: WS.ClientOptions | undefined },
+  ): Promise<OpenAIRealtimeWS> {
+    return new OpenAIRealtimeWS({ ...props, __resolvedApiKey: await client._callApiKey() }, client);
+  }
+
+  static async azure(
+    client: Pick<AzureOpenAI, '_callApiKey' | 'apiVersion' | 'apiKey' | 'baseURL' | 'deploymentName'>,
+    props: { deploymentName?: string; options?: WS.ClientOptions | undefined } = {},
+  ): Promise<OpenAIRealtimeWS> {
+    const isApiKeyProvider = await client._callApiKey();
+    const deploymentName = props.deploymentName ?? client.deploymentName;
+    if (!deploymentName) {
+      throw new Error('No deployment name provided');
+    }
+    return new OpenAIRealtimeWS(
+      {
+        model: deploymentName,
+        options: {
+          ...props.options,
+          headers: {
+            ...props.options?.headers,
+            ...(isApiKeyProvider ? {} : { 'api-key': client.apiKey }),
+          },
+        },
+        __resolvedApiKey: isApiKeyProvider,
+      },
+      client,
+    );
+  }
+
+  send(event: RealtimeClientEvent) {
+    try {
+      this.socket.send(JSON.stringify(event));
+    } catch (err) {
+      this._onError(null, 'could not send data', err);
+    }
+  }
+
+  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);
+    }
+  }
+}

package/src/resource.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/resource instead */
+export * from './core/resource';

package/src/resources/audio/audio.ts

@@ -0,0 +1,91 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../core/resource';
+import * as SpeechAPI from './speech';
+import { Speech, SpeechCreateParams, SpeechModel } from './speech';
+import * as TranscriptionsAPI from './transcriptions';
+import {
+  Transcription,
+  TranscriptionCreateParams,
+  TranscriptionCreateParamsNonStreaming,
+  TranscriptionCreateParamsStreaming,
+  TranscriptionCreateResponse,
+  TranscriptionDiarized,
+  TranscriptionDiarizedSegment,
+  TranscriptionInclude,
+  TranscriptionSegment,
+  TranscriptionStreamEvent,
+  TranscriptionTextDeltaEvent,
+  TranscriptionTextDoneEvent,
+  TranscriptionTextSegmentEvent,
+  TranscriptionVerbose,
+  TranscriptionWord,
+  Transcriptions,
+} from './transcriptions';
+import * as TranslationsAPI from './translations';
+import {
+  Translation,
+  TranslationCreateParams,
+  TranslationCreateResponse,
+  TranslationVerbose,
+  Translations,
+} from './translations';
+
+export class Audio extends APIResource {
+  transcriptions: TranscriptionsAPI.Transcriptions = new TranscriptionsAPI.Transcriptions(this._client);
+  translations: TranslationsAPI.Translations = new TranslationsAPI.Translations(this._client);
+  speech: SpeechAPI.Speech = new SpeechAPI.Speech(this._client);
+}
+
+export type AudioModel =
+  | 'whisper-1'
+  | 'gpt-4o-transcribe'
+  | 'gpt-4o-mini-transcribe'
+  | 'gpt-4o-mini-transcribe-2025-12-15'
+  | 'gpt-4o-transcribe-diarize';
+
+/**
+ * The format of the output, in one of these options: `json`, `text`, `srt`,
+ * `verbose_json`, `vtt`, or `diarized_json`. For `gpt-4o-transcribe` and
+ * `gpt-4o-mini-transcribe`, the only supported format is `json`. For
+ * `gpt-4o-transcribe-diarize`, the supported formats are `json`, `text`, and
+ * `diarized_json`, with `diarized_json` required to receive speaker annotations.
+ */
+export type AudioResponseFormat = 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt' | 'diarized_json';
+
+Audio.Transcriptions = Transcriptions;
+Audio.Translations = Translations;
+Audio.Speech = Speech;
+
+export declare namespace Audio {
+  export { type AudioModel as AudioModel, type AudioResponseFormat as AudioResponseFormat };
+
+  export {
+    Transcriptions as Transcriptions,
+    type Transcription as Transcription,
+    type TranscriptionDiarized as TranscriptionDiarized,
+    type TranscriptionDiarizedSegment as TranscriptionDiarizedSegment,
+    type TranscriptionInclude as TranscriptionInclude,
+    type TranscriptionSegment as TranscriptionSegment,
+    type TranscriptionStreamEvent as TranscriptionStreamEvent,
+    type TranscriptionTextDeltaEvent as TranscriptionTextDeltaEvent,
+    type TranscriptionTextDoneEvent as TranscriptionTextDoneEvent,
+    type TranscriptionTextSegmentEvent as TranscriptionTextSegmentEvent,
+    type TranscriptionVerbose as TranscriptionVerbose,
+    type TranscriptionWord as TranscriptionWord,
+    type TranscriptionCreateResponse as TranscriptionCreateResponse,
+    type TranscriptionCreateParams as TranscriptionCreateParams,
+    type TranscriptionCreateParamsNonStreaming as TranscriptionCreateParamsNonStreaming,
+    type TranscriptionCreateParamsStreaming as TranscriptionCreateParamsStreaming,
+  };
+
+  export {
+    Translations as Translations,
+    type Translation as Translation,
+    type TranslationVerbose as TranslationVerbose,
+    type TranslationCreateResponse as TranslationCreateResponse,
+    type TranslationCreateParams as TranslationCreateParams,
+  };
+
+  export { Speech as Speech, type SpeechModel as SpeechModel, type SpeechCreateParams as SpeechCreateParams };
+}

package/src/resources/audio/index.ts

@@ -0,0 +1,29 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { Audio, type AudioModel, type AudioResponseFormat } from './audio';
+export { Speech, type SpeechModel, type SpeechCreateParams } from './speech';
+export {
+  Transcriptions,
+  type Transcription,
+  type TranscriptionDiarized,
+  type TranscriptionDiarizedSegment,
+  type TranscriptionInclude,
+  type TranscriptionSegment,
+  type TranscriptionStreamEvent,
+  type TranscriptionTextDeltaEvent,
+  type TranscriptionTextDoneEvent,
+  type TranscriptionTextSegmentEvent,
+  type TranscriptionVerbose,
+  type TranscriptionWord,
+  type TranscriptionCreateResponse,
+  type TranscriptionCreateParams,
+  type TranscriptionCreateParamsNonStreaming,
+  type TranscriptionCreateParamsStreaming,
+} from './transcriptions';
+export {
+  Translations,
+  type Translation,
+  type TranslationVerbose,
+  type TranslationCreateResponse,
+  type TranslationCreateParams,
+} from './translations';

package/src/resources/audio/speech.ts

@@ -0,0 +1,114 @@
+// 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 { buildHeaders } from '../../internal/headers';
+import { RequestOptions } from '../../internal/request-options';
+
+/**
+ * Turn audio into text or text into audio.
+ */
+export class Speech extends APIResource {
+  /**
+   * Generates audio from the input text.
+   *
+   * Returns the audio file content, or a stream of audio events.
+   *
+   * @example
+   * ```ts
+   * const speech = await client.audio.speech.create({
+   *   input: 'input',
+   *   model: 'string',
+   *   voice: 'string',
+   * });
+   *
+   * const content = await speech.blob();
+   * console.log(content);
+   * ```
+   */
+  create(body: SpeechCreateParams, options?: RequestOptions): APIPromise<Response> {
+    return this._client.post('/audio/speech', {
+      body,
+      ...options,
+      headers: buildHeaders([{ Accept: 'application/octet-stream' }, options?.headers]),
+      __binaryResponse: true,
+    });
+  }
+}
+
+export type SpeechModel = 'tts-1' | 'tts-1-hd' | 'gpt-4o-mini-tts' | 'gpt-4o-mini-tts-2025-12-15';
+
+export interface SpeechCreateParams {
+  /**
+   * The text to generate audio for. The maximum length is 4096 characters.
+   */
+  input: string;
+
+  /**
+   * One of the available [TTS models](https://platform.openai.com/docs/models#tts):
+   * `tts-1`, `tts-1-hd`, `gpt-4o-mini-tts`, or `gpt-4o-mini-tts-2025-12-15`.
+   */
+  model: (string & {}) | SpeechModel;
+
+  /**
+   * The voice to use when generating the audio. Supported built-in voices are
+   * `alloy`, `ash`, `ballad`, `coral`, `echo`, `fable`, `onyx`, `nova`, `sage`,
+   * `shimmer`, `verse`, `marin`, and `cedar`. You may also provide a custom voice
+   * object with an `id`, for example `{ "id": "voice_1234" }`. Previews of the
+   * voices are available in the
+   * [Text to speech guide](https://platform.openai.com/docs/guides/text-to-speech#voice-options).
+   */
+  voice:
+    | string
+    | 'alloy'
+    | 'ash'
+    | 'ballad'
+    | 'coral'
+    | 'echo'
+    | 'sage'
+    | 'shimmer'
+    | 'verse'
+    | 'marin'
+    | 'cedar'
+    | SpeechCreateParams.ID;
+
+  /**
+   * Control the voice of your generated audio with additional instructions. Does not
+   * work with `tts-1` or `tts-1-hd`.
+   */
+  instructions?: string;
+
+  /**
+   * The format to audio in. Supported formats are `mp3`, `opus`, `aac`, `flac`,
+   * `wav`, and `pcm`.
+   */
+  response_format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm';
+
+  /**
+   * The speed of the generated audio. Select a value from `0.25` to `4.0`. `1.0` is
+   * the default.
+   */
+  speed?: number;
+
+  /**
+   * The format to stream the audio in. Supported formats are `sse` and `audio`.
+   * `sse` is not supported for `tts-1` or `tts-1-hd`.
+   */
+  stream_format?: 'sse' | 'audio';
+}
+
+export namespace SpeechCreateParams {
+  /**
+   * Custom voice reference.
+   */
+  export interface ID {
+    /**
+     * The custom voice ID, e.g. `voice_1234`.
+     */
+    id: string;
+  }
+}
+
+export declare namespace Speech {
+  export { type SpeechModel as SpeechModel, type SpeechCreateParams as SpeechCreateParams };
+}