openai 4.53.2 → 4.55.0

package/src/lib/ChatCompletionStreamingRunner.ts

@@ -1,5 +1,4 @@
 import {
-  Completions,
   type ChatCompletionChunk,
   type ChatCompletionCreateParamsStreaming,
 } from "../resources/chat/completions";
@@ -7,6 +6,8 @@ import { RunnerOptions, type AbstractChatCompletionRunnerEvents } from './Abstra
 import { type ReadableStream } from "../_shims/index";
 import { RunnableTools, type BaseFunctionsArgs, type RunnableFunctions } from './RunnableFunction';
 import { ChatCompletionSnapshot, ChatCompletionStream } from './ChatCompletionStream';
+import OpenAI from "../index";
+import { AutoParseableTool } from "./parser";
 
 export interface ChatCompletionStreamEvents extends AbstractChatCompletionRunnerEvents {
   content: (contentDelta: string, contentSnapshot: string) => void;
@@ -24,45 +25,48 @@ export type ChatCompletionStreamingToolRunnerParams<FunctionsArgs extends BaseFu
   ChatCompletionCreateParamsStreaming,
   'tools'
 > & {
-  tools: RunnableTools<FunctionsArgs>;
+  tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
 };
 
-export class ChatCompletionStreamingRunner
-  extends ChatCompletionStream
+export class ChatCompletionStreamingRunner<ParsedT = null>
+  extends ChatCompletionStream<ParsedT>
   implements AsyncIterable<ChatCompletionChunk>
 {
-  static override fromReadableStream(stream: ReadableStream): ChatCompletionStreamingRunner {
-    const runner = new ChatCompletionStreamingRunner();
+  static override fromReadableStream(stream: ReadableStream): ChatCompletionStreamingRunner<null> {
+    const runner = new ChatCompletionStreamingRunner(null);
     runner._run(() => runner._fromReadableStream(stream));
     return runner;
   }
 
   /** @deprecated - please use `runTools` instead. */
   static runFunctions<T extends (string | object)[]>(
-    completions: Completions,
+    client: OpenAI,
     params: ChatCompletionStreamingFunctionRunnerParams<T>,
     options?: RunnerOptions,
-  ): ChatCompletionStreamingRunner {
-    const runner = new ChatCompletionStreamingRunner();
+  ): ChatCompletionStreamingRunner<null> {
+    const runner = new ChatCompletionStreamingRunner(null);
     const opts = {
       ...options,
       headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runFunctions' },
     };
-    runner._run(() => runner._runFunctions(completions, params, opts));
+    runner._run(() => runner._runFunctions(client, params, opts));
     return runner;
   }
 
-  static runTools<T extends (string | object)[]>(
-    completions: Completions,
+  static runTools<T extends (string | object)[], ParsedT = null>(
+    client: OpenAI,
     params: ChatCompletionStreamingToolRunnerParams<T>,
     options?: RunnerOptions,
-  ): ChatCompletionStreamingRunner {
-    const runner = new ChatCompletionStreamingRunner();
+  ): ChatCompletionStreamingRunner<ParsedT> {
+    const runner = new ChatCompletionStreamingRunner<ParsedT>(
+      // @ts-expect-error TODO these types are incompatible
+      params,
+    );
     const opts = {
       ...options,
       headers: { ...options?.headers, 'X-Stainless-Helper-Method': 'runTools' },
     };
-    runner._run(() => runner._runTools(completions, params, opts));
+    runner._run(() => runner._runTools(client, params, opts));
     return runner;
   }
 }

package/src/lib/{AbstractAssistantStreamRunner.ts → EventStream.ts}

@@ -1,12 +1,6 @@
-import * as Core from "../core";
 import { APIUserAbortError, OpenAIError } from "../error";
-import { Run, RunSubmitToolOutputsParamsBase } from "../resources/beta/threads/runs/runs";
-import { RunCreateParamsBase, Runs } from "../resources/beta/threads/runs/runs";
-import { ThreadCreateAndRunParamsBase, Threads } from "../resources/beta/threads/threads";
 
-export abstract class AbstractAssistantStreamRunner<
-  Events extends CustomEvents<any> = AbstractAssistantRunnerEvents,
-> {
+export class EventStream<EventTypes extends BaseEvents> {
   controller: AbortController = new AbortController();
 
   #connectedPromise: Promise<void>;
@@ -17,7 +11,9 @@ export abstract class AbstractAssistantStreamRunner<
   #resolveEndPromise: () => void = () => {};
   #rejectEndPromise: (error: OpenAIError) => void = () => {};
 
-  #listeners: { [Event in keyof Events]?: ListenersForEvent<Events, Event> } = {};
+  #listeners: {
+    [Event in keyof EventTypes]?: EventListeners<EventTypes, Event>;
+  } = {};
 
   #ended = false;
   #errored = false;
@@ -43,22 +39,18 @@ export abstract class AbstractAssistantStreamRunner<
     this.#endPromise.catch(() => {});
   }
 
-  protected _run(executor: () => Promise<any>) {
+  protected _run(this: EventStream<EventTypes>, executor: () => Promise<any>) {
     // Unfortunately if we call `executor()` immediately we get runtime errors about
     // references to `this` before the `super()` constructor call returns.
     setTimeout(() => {
       executor().then(() => {
-        // this._emitFinal();
+        this._emitFinal();
         this._emit('end');
-      }, this.#handleError);
+      }, this.#handleError.bind(this));
     }, 0);
   }
 
-  protected _addRun(run: Run): Run {
-    return run;
-  }
-
-  protected _connected() {
+  protected _connected(this: EventStream<EventTypes>) {
     if (this.ended) return;
     this.#resolveConnectedPromise();
     this._emit('connect');
@@ -87,8 +79,8 @@ export abstract class AbstractAssistantStreamRunner<
    * called, multiple times.
    * @returns this ChatCompletionStream, so that calls can be chained
    */
-  on<Event extends keyof Events>(event: Event, listener: ListenerForEvent<Events, Event>): this {
-    const listeners: ListenersForEvent<Events, Event> =
+  on<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners: EventListeners<EventTypes, Event> =
       this.#listeners[event] || (this.#listeners[event] = []);
     listeners.push({ listener });
     return this;
@@ -101,7 +93,7 @@ export abstract class AbstractAssistantStreamRunner<
    * off() must be called multiple times to remove each instance.
    * @returns this ChatCompletionStream, so that calls can be chained
    */
-  off<Event extends keyof Events>(event: Event, listener: ListenerForEvent<Events, Event>): this {
+  off<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
     const listeners = this.#listeners[event];
     if (!listeners) return this;
     const index = listeners.findIndex((l) => l.listener === listener);
@@ -114,8 +106,8 @@ export abstract class AbstractAssistantStreamRunner<
    * this listener is removed and then invoked.
    * @returns this ChatCompletionStream, so that calls can be chained
    */
-  once<Event extends keyof Events>(event: Event, listener: ListenerForEvent<Events, Event>): this {
-    const listeners: ListenersForEvent<Events, Event> =
+  once<Event extends keyof EventTypes>(event: Event, listener: EventListener<EventTypes, Event>): this {
+    const listeners: EventListeners<EventTypes, Event> =
       this.#listeners[event] || (this.#listeners[event] = []);
     listeners.push({ listener, once: true });
     return this;
@@ -132,12 +124,12 @@ export abstract class AbstractAssistantStreamRunner<
    *
    *   const message = await stream.emitted('message') // rejects if the stream errors
    */
-  emitted<Event extends keyof Events>(
+  emitted<Event extends keyof EventTypes>(
     event: Event,
   ): Promise<
-    EventParameters<Events, Event> extends [infer Param] ? Param
-    : EventParameters<Events, Event> extends [] ? void
-    : EventParameters<Events, Event>
+    EventParameters<EventTypes, Event> extends [infer Param] ? Param
+    : EventParameters<EventTypes, Event> extends [] ? void
+    : EventParameters<EventTypes, Event>
   > {
     return new Promise((resolve, reject) => {
       this.#catchingPromiseCreated = true;
@@ -151,7 +143,7 @@ export abstract class AbstractAssistantStreamRunner<
     await this.#endPromise;
   }
 
-  #handleError = (error: unknown) => {
+  #handleError(this: EventStream<EventTypes>, error: unknown) {
     this.#errored = true;
     if (error instanceof Error && error.name === 'AbortError') {
       error = new APIUserAbortError();
@@ -170,9 +162,15 @@ export abstract class AbstractAssistantStreamRunner<
       return this._emit('error', openAIError);
     }
     return this._emit('error', new OpenAIError(String(error)));
-  };
+  }
 
-  protected _emit<Event extends keyof Events>(event: Event, ...args: EventParameters<Events, Event>) {
+  _emit<Event extends keyof BaseEvents>(event: Event, ...args: EventParameters<BaseEvents, Event>): void;
+  _emit<Event extends keyof EventTypes>(event: Event, ...args: EventParameters<EventTypes, Event>): void;
+  _emit<Event extends keyof EventTypes>(
+    this: EventStream<EventTypes>,
+    event: Event,
+    ...args: EventParameters<EventTypes, Event>
+  ) {
     // make sure we don't emit any events after end
     if (this.#ended) {
       return;
@@ -183,10 +181,10 @@ export abstract class AbstractAssistantStreamRunner<
       this.#resolveEndPromise();
     }
 
-    const listeners: ListenersForEvent<Events, Event> | undefined = this.#listeners[event];
+    const listeners: EventListeners<EventTypes, Event> | undefined = this.#listeners[event];
     if (listeners) {
       this.#listeners[event] = listeners.filter((l) => !l.once) as any;
-      listeners.forEach(({ listener }: any) => listener(...args));
+      listeners.forEach(({ listener }: any) => listener(...(args as any)));
     }
 
     if (event === 'abort') {
@@ -219,121 +217,22 @@ export abstract class AbstractAssistantStreamRunner<
     }
   }
 
-  protected async _threadAssistantStream(
-    body: ThreadCreateAndRunParamsBase,
-    thread: Threads,
-    options?: Core.RequestOptions,
-  ): Promise<Run> {
-    return await this._createThreadAssistantStream(thread, body, options);
-  }
-
-  protected async _runAssistantStream(
-    threadId: string,
-    runs: Runs,
-    params: RunCreateParamsBase,
-    options?: Core.RequestOptions,
-  ): Promise<Run> {
-    return await this._createAssistantStream(runs, threadId, params, options);
-  }
-
-  protected async _runToolAssistantStream(
-    threadId: string,
-    runId: string,
-    runs: Runs,
-    params: RunSubmitToolOutputsParamsBase,
-    options?: Core.RequestOptions,
-  ): Promise<Run> {
-    return await this._createToolAssistantStream(runs, threadId, runId, params, options);
-  }
-
-  protected async _createThreadAssistantStream(
-    thread: Threads,
-    body: ThreadCreateAndRunParamsBase,
-    options?: Core.RequestOptions,
-  ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
-    // this.#validateParams(params);
-
-    const runResult = await thread.createAndRun(
-      { ...body, stream: false },
-      { ...options, signal: this.controller.signal },
-    );
-    this._connected();
-    return this._addRun(runResult as Run);
-  }
-
-  protected async _createToolAssistantStream(
-    run: Runs,
-    threadId: string,
-    runId: string,
-    params: RunSubmitToolOutputsParamsBase,
-    options?: Core.RequestOptions,
-  ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
-
-    const runResult = await run.submitToolOutputs(
-      threadId,
-      runId,
-      { ...params, stream: false },
-      { ...options, signal: this.controller.signal },
-    );
-    this._connected();
-    return this._addRun(runResult as Run);
-  }
-
-  protected async _createAssistantStream(
-    run: Runs,
-    threadId: string,
-    params: RunCreateParamsBase,
-    options?: Core.RequestOptions,
-  ): Promise<Run> {
-    const signal = options?.signal;
-    if (signal) {
-      if (signal.aborted) this.controller.abort();
-      signal.addEventListener('abort', () => this.controller.abort());
-    }
-    // this.#validateParams(params);
-
-    const runResult = await run.create(
-      threadId,
-      { ...params, stream: false },
-      { ...options, signal: this.controller.signal },
-    );
-    this._connected();
-    return this._addRun(runResult as Run);
-  }
+  protected _emitFinal(): void {}
 }
 
-type CustomEvents<Event extends string> = {
-  [k in Event]: k extends keyof AbstractAssistantRunnerEvents ? AbstractAssistantRunnerEvents[k]
-  : (...args: any[]) => void;
-};
+type EventListener<Events, EventType extends keyof Events> = Events[EventType];
 
-type ListenerForEvent<Events extends CustomEvents<any>, Event extends keyof Events> = Event extends (
-  keyof AbstractAssistantRunnerEvents
-) ?
-  AbstractAssistantRunnerEvents[Event]
-: Events[Event];
-
-type ListenersForEvent<Events extends CustomEvents<any>, Event extends keyof Events> = Array<{
-  listener: ListenerForEvent<Events, Event>;
+type EventListeners<Events, EventType extends keyof Events> = Array<{
+  listener: EventListener<Events, EventType>;
   once?: boolean;
 }>;
-type EventParameters<Events extends CustomEvents<any>, Event extends keyof Events> = Parameters<
-  ListenerForEvent<Events, Event>
->;
 
-export interface AbstractAssistantRunnerEvents {
+export type EventParameters<Events, EventType extends keyof Events> = {
+  [Event in EventType]: EventListener<Events, EventType> extends (...args: infer P) => any ? P : never;
+}[EventType];
+
+export interface BaseEvents {
   connect: () => void;
-  run: (run: Run) => void;
   error: (error: OpenAIError) => void;
   abort: (error: APIUserAbortError) => void;
   end: () => void;

package/src/lib/RunnableFunction.ts

@@ -12,7 +12,7 @@ export type RunnableFunctionWithParse<Args extends object> = {
    */
   function: (
     args: Args,
-    runner: ChatCompletionRunner | ChatCompletionStreamingRunner,
+    runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
   ) => PromiseOrValue<unknown>;
   /**
    * @param input the raw args from the OpenAI function call.
@@ -31,6 +31,7 @@ export type RunnableFunctionWithParse<Args extends object> = {
    * The name of the function to be called. Will default to function.name if omitted.
    */
   name?: string | undefined;
+  strict?: boolean | undefined;
 };
 
 export type RunnableFunctionWithoutParse = {
@@ -40,7 +41,7 @@ export type RunnableFunctionWithoutParse = {
    */
   function: (
     args: string,
-    runner: ChatCompletionRunner | ChatCompletionStreamingRunner,
+    runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
   ) => PromiseOrValue<unknown>;
   /**
    * The parameters the function accepts, describes as a JSON Schema object.
@@ -54,6 +55,7 @@ export type RunnableFunctionWithoutParse = {
    * The name of the function to be called. Will default to function.name if omitted.
    */
   name?: string | undefined;
+  strict?: boolean | undefined;
 };
 
 export type RunnableFunction<Args extends object | string> =

package/src/lib/parser.ts

@@ -0,0 +1,235 @@
+import {
+  ChatCompletion,
+  ChatCompletionCreateParams,
+  ChatCompletionMessageToolCall,
+  ChatCompletionTool,
+} from '../resources/chat/completions';
+import {
+  ChatCompletionStreamingToolRunnerParams,
+  ChatCompletionStreamParams,
+  ChatCompletionToolRunnerParams,
+  ParsedChatCompletion,
+  ParsedChoice,
+  ParsedFunctionToolCall,
+} from '../resources/beta/chat/completions';
+import { ResponseFormatJSONSchema } from '../resources/shared';
+import { ContentFilterFinishReasonError, LengthFinishReasonError, OpenAIError } from "../error";
+
+type AnyChatCompletionCreateParams =
+  | ChatCompletionCreateParams
+  | ChatCompletionToolRunnerParams<any>
+  | ChatCompletionStreamingToolRunnerParams<any>
+  | ChatCompletionStreamParams;
+
+export type ExtractParsedContentFromParams<Params extends AnyChatCompletionCreateParams> =
+  Params['response_format'] extends AutoParseableResponseFormat<infer P> ? P : null;
+
+export type AutoParseableResponseFormat<ParsedT> = ResponseFormatJSONSchema & {
+  __output: ParsedT; // type-level only
+
+  $brand: 'auto-parseable-response-format';
+  $parseRaw(content: string): ParsedT;
+};
+
+export function makeParseableResponseFormat<ParsedT>(
+  response_format: ResponseFormatJSONSchema,
+  parser: (content: string) => ParsedT,
+): AutoParseableResponseFormat<ParsedT> {
+  const obj = { ...response_format };
+
+  Object.defineProperties(obj, {
+    $brand: {
+      value: 'auto-parseable-response-format',
+      enumerable: false,
+    },
+    $parseRaw: {
+      value: parser,
+      enumerable: false,
+    },
+  });
+
+  return obj as AutoParseableResponseFormat<ParsedT>;
+}
+
+export function isAutoParsableResponseFormat<ParsedT>(
+  response_format: any,
+): response_format is AutoParseableResponseFormat<ParsedT> {
+  return response_format?.['$brand'] === 'auto-parseable-response-format';
+}
+
+type ToolOptions = {
+  name: string;
+  arguments: any;
+  function?: ((args: any) => any) | undefined;
+};
+
+export type AutoParseableTool<
+  OptionsT extends ToolOptions,
+  HasFunction = OptionsT['function'] extends Function ? true : false,
+> = ChatCompletionTool & {
+  __arguments: OptionsT['arguments']; // type-level only
+  __name: OptionsT['name']; // type-level only
+  __hasFunction: HasFunction; // type-level only
+
+  $brand: 'auto-parseable-tool';
+  $callback: ((args: OptionsT['arguments']) => any) | undefined;
+  $parseRaw(args: string): OptionsT['arguments'];
+};
+
+export function makeParseableTool<OptionsT extends ToolOptions>(
+  tool: ChatCompletionTool,
+  {
+    parser,
+    callback,
+  }: {
+    parser: (content: string) => OptionsT['arguments'];
+    callback: ((args: any) => any) | undefined;
+  },
+): AutoParseableTool<OptionsT['arguments']> {
+  const obj = { ...tool };
+
+  Object.defineProperties(obj, {
+    $brand: {
+      value: 'auto-parseable-tool',
+      enumerable: false,
+    },
+    $parseRaw: {
+      value: parser,
+      enumerable: false,
+    },
+    $callback: {
+      value: callback,
+      enumerable: false,
+    },
+  });
+
+  return obj as AutoParseableTool<OptionsT['arguments']>;
+}
+
+export function isAutoParsableTool(tool: any): tool is AutoParseableTool<any> {
+  return tool?.['$brand'] === 'auto-parseable-tool';
+}
+
+export function maybeParseChatCompletion<
+  Params extends ChatCompletionCreateParams | null,
+  ParsedT = Params extends null ? null : ExtractParsedContentFromParams<NonNullable<Params>>,
+>(completion: ChatCompletion, params: Params): ParsedChatCompletion<ParsedT> {
+  if (!params || !hasAutoParseableInput(params)) {
+    return {
+      ...completion,
+      choices: completion.choices.map((choice) => ({
+        ...choice,
+        message: { ...choice.message, parsed: null, tool_calls: choice.message.tool_calls ?? [] },
+      })),
+    };
+  }
+
+  return parseChatCompletion(completion, params);
+}
+
+export function parseChatCompletion<
+  Params extends ChatCompletionCreateParams,
+  ParsedT = ExtractParsedContentFromParams<Params>,
+>(completion: ChatCompletion, params: Params): ParsedChatCompletion<ParsedT> {
+  const choices: Array<ParsedChoice<ParsedT>> = completion.choices.map((choice): ParsedChoice<ParsedT> => {
+    if (choice.finish_reason === 'length') {
+      throw new LengthFinishReasonError();
+    }
+
+    if (choice.finish_reason === 'content_filter') {
+      throw new ContentFilterFinishReasonError();
+    }
+
+    return {
+      ...choice,
+      message: {
+        ...choice.message,
+        tool_calls: choice.message.tool_calls?.map((toolCall) => parseToolCall(params, toolCall)) ?? [],
+        parsed:
+          choice.message.content && !choice.message.refusal ?
+            parseResponseFormat(params, choice.message.content)
+          : null,
+      },
+    };
+  });
+
+  return { ...completion, choices };
+}
+
+function parseResponseFormat<
+  Params extends ChatCompletionCreateParams,
+  ParsedT = ExtractParsedContentFromParams<Params>,
+>(params: Params, content: string): ParsedT | null {
+  if (params.response_format?.type !== 'json_schema') {
+    return null;
+  }
+
+  if (params.response_format?.type === 'json_schema') {
+    if ('$parseRaw' in params.response_format) {
+      const response_format = params.response_format as AutoParseableResponseFormat<ParsedT>;
+
+      return response_format.$parseRaw(content);
+    }
+
+    return JSON.parse(content);
+  }
+
+  return null;
+}
+
+function parseToolCall<Params extends ChatCompletionCreateParams>(
+  params: Params,
+  toolCall: ChatCompletionMessageToolCall,
+): ParsedFunctionToolCall {
+  const inputTool = params.tools?.find((inputTool) => inputTool.function?.name === toolCall.function.name);
+  return {
+    ...toolCall,
+    function: {
+      ...toolCall.function,
+      parsed_arguments:
+        isAutoParsableTool(inputTool) ? inputTool.$parseRaw(toolCall.function.arguments)
+        : inputTool?.function.strict ? JSON.parse(toolCall.function.arguments)
+        : null,
+    },
+  };
+}
+
+export function shouldParseToolCall(
+  params: ChatCompletionCreateParams | null | undefined,
+  toolCall: ChatCompletionMessageToolCall,
+): boolean {
+  if (!params) {
+    return false;
+  }
+
+  const inputTool = params.tools?.find((inputTool) => inputTool.function?.name === toolCall.function.name);
+  return isAutoParsableTool(inputTool) || inputTool?.function.strict || false;
+}
+
+export function hasAutoParseableInput(params: AnyChatCompletionCreateParams): boolean {
+  if (isAutoParsableResponseFormat(params.response_format)) {
+    return true;
+  }
+
+  return (
+    params.tools?.some(
+      (t) => isAutoParsableTool(t) || (t.type === 'function' && t.function.strict === true),
+    ) ?? false
+  );
+}
+
+export function validateInputTools(tools: ChatCompletionTool[] | undefined) {
+  for (const tool of tools ?? []) {
+    if (tool.type !== 'function') {
+      throw new OpenAIError(
+        `Currently only \`function\` tool types support auto-parsing; Received \`${tool.type}\``,
+      );
+    }
+
+    if (tool.function.strict !== true) {
+      throw new OpenAIError(
+        `The \`${tool.function.name}\` tool is not marked with \`strict: true\`. Only strict function tools can be auto-parsed`,
+      );
+    }
+  }
+}

package/src/resources/audio/audio.ts

@@ -1,6 +1,7 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 import { APIResource } from '../../resource';
+import * as AudioAPI from './audio';
 import * as SpeechAPI from './speech';
 import * as TranscriptionsAPI from './transcriptions';
 import * as TranslationsAPI from './translations';
@@ -11,7 +12,10 @@ export class Audio extends APIResource {
   speech: SpeechAPI.Speech = new SpeechAPI.Speech(this._client);
 }
 
+export type AudioModel = 'whisper-1';
+
 export namespace Audio {
+  export import AudioModel = AudioAPI.AudioModel;
   export import Transcriptions = TranscriptionsAPI.Transcriptions;
   export import Transcription = TranscriptionsAPI.Transcription;
   export import TranscriptionCreateParams = TranscriptionsAPI.TranscriptionCreateParams;
@@ -19,5 +23,6 @@ export namespace Audio {
   export import Translation = TranslationsAPI.Translation;
   export import TranslationCreateParams = TranslationsAPI.TranslationCreateParams;
   export import Speech = SpeechAPI.Speech;
+  export import SpeechModel = SpeechAPI.SpeechModel;
   export import SpeechCreateParams = SpeechAPI.SpeechCreateParams;
 }

package/src/resources/audio/index.ts

@@ -1,6 +1,6 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-export { Audio } from './audio';
-export { SpeechCreateParams, Speech } from './speech';
+export { AudioModel, Audio } from './audio';
+export { SpeechModel, SpeechCreateParams, Speech } from './speech';
 export { Transcription, TranscriptionCreateParams, Transcriptions } from './transcriptions';
 export { Translation, TranslationCreateParams, Translations } from './translations';

package/src/resources/audio/speech.ts

@@ -14,6 +14,8 @@ export class Speech extends APIResource {
   }
 }
 
+export type SpeechModel = 'tts-1' | 'tts-1-hd';
+
 export interface SpeechCreateParams {
   /**
    * The text to generate audio for. The maximum length is 4096 characters.
@@ -24,7 +26,7 @@ export interface SpeechCreateParams {
    * One of the available [TTS models](https://platform.openai.com/docs/models/tts):
    * `tts-1` or `tts-1-hd`
    */
-  model: (string & {}) | 'tts-1' | 'tts-1-hd';
+  model: (string & {}) | SpeechModel;
 
   /**
    * The voice to use when generating the audio. Supported voices are `alloy`,
@@ -48,5 +50,6 @@ export interface SpeechCreateParams {
 }
 
 export namespace Speech {
+  export import SpeechModel = SpeechAPI.SpeechModel;
   export import SpeechCreateParams = SpeechAPI.SpeechCreateParams;
 }