openai 6.45.0 → 6.47.0

package/src/lib/ChatCompletionStreamingRunner.ts

@@ -1,26 +1,63 @@
 import {
   type ChatCompletionChunk,
   type ChatCompletionCreateParamsStreaming,
+  type ChatCompletionMessageParam,
 } from '../resources/chat/completions';
 import { RunnerOptions, type AbstractChatCompletionRunnerEvents } from './AbstractChatCompletionRunner';
 import { type ReadableStream } from '../internal/shim-types';
 import { RunnableTools, type BaseFunctionsArgs } from './RunnableFunction';
-import { ChatCompletionSnapshot, ChatCompletionStream } from './ChatCompletionStream';
+import {
+  type ChatCompletionReadableStreamItem,
+  ChatCompletionSnapshot,
+  ChatCompletionStream,
+  makeChatCompletionReadableStreamMessageChunk,
+} from './ChatCompletionStream';
+import { OpenAIError } from '../error';
 import OpenAI from '../index';
 import { AutoParseableTool } from '../lib/parser';
+import { Stream } from '../streaming';
+import { isAssistantMessage, isToolMessage } from './chatCompletionUtils';
 
 export interface ChatCompletionStreamEvents extends AbstractChatCompletionRunnerEvents {
   content: (contentDelta: string, contentSnapshot: string) => void;
   chunk: (chunk: ChatCompletionChunk, snapshot: ChatCompletionSnapshot) => void;
 }
 
-export type ChatCompletionStreamingToolRunnerParams<FunctionsArgs extends BaseFunctionsArgs> = Omit<
-  ChatCompletionCreateParamsStreaming,
-  'tools'
-> & {
-  tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+type ChatCompletionStreamingToolRunnerParamsBase = Omit<ChatCompletionCreateParamsStreaming, 'tools'>;
+
+/**
+ * Parameters for tools that do not require a context value.
+ */
+export type ChatCompletionStreamingToolRunnerParamsWithoutContext<FunctionsArgs extends BaseFunctionsArgs> =
+  ChatCompletionStreamingToolRunnerParamsBase & {
+    tools: RunnableTools<FunctionsArgs> | AutoParseableTool<any, true>[];
+    toolContext?: never;
+  };
+
+/**
+ * Parameters for tools that require a context value.
+ */
+export type ChatCompletionStreamingToolRunnerParamsWithContext<
+  FunctionsArgs extends BaseFunctionsArgs,
+  ToolContext,
+> = ChatCompletionStreamingToolRunnerParamsBase & {
+  tools: RunnableTools<FunctionsArgs, ToolContext> | AutoParseableTool<any, true>[];
+  /**
+   * Context to pass to each tool callback during this run.
+   */
+  toolContext: ToolContext;
 };
 
+/**
+ * Parameters for running streaming tools. Supplying a context type makes
+ * `toolContext` required; omitting it preserves the existing no-context form.
+ */
+export type ChatCompletionStreamingToolRunnerParams<
+  FunctionsArgs extends BaseFunctionsArgs,
+  ToolContext = never,
+> = [ToolContext] extends [never] ? ChatCompletionStreamingToolRunnerParamsWithoutContext<FunctionsArgs>
+: ChatCompletionStreamingToolRunnerParamsWithContext<FunctionsArgs, ToolContext>;
+
 export class ChatCompletionStreamingRunner<ParsedT = null>
   extends ChatCompletionStream<ParsedT>
   implements AsyncIterable<ChatCompletionChunk>
@@ -31,9 +68,109 @@ export class ChatCompletionStreamingRunner<ParsedT = null>
     return runner;
   }
 
+  override toReadableStream(): ReadableStream {
+    const pushQueue: ChatCompletionReadableStreamItem[] = [];
+    const readQueue: {
+      resolve: (event: ChatCompletionReadableStreamItem | undefined) => void;
+      reject: (err: unknown) => void;
+    }[] = [];
+    let done = false;
+    let lastChunk: ChatCompletionChunk | undefined;
+    let toolCallIds: string[] | undefined;
+
+    const pushEvent = (event: ChatCompletionReadableStreamItem) => {
+      const reader = readQueue.shift();
+      if (reader) {
+        reader.resolve(event);
+      } else {
+        pushQueue.push(event);
+      }
+    };
+
+    this.on('chunk', (chunk) => {
+      lastChunk = chunk;
+      pushEvent(chunk);
+    });
+    this.on('message', (message: ChatCompletionMessageParam) => {
+      if (isAssistantMessage(message)) {
+        toolCallIds = message.tool_calls?.map((toolCall) => toolCall.id);
+        return;
+      }
+
+      if (isToolMessage(message)) {
+        if (!lastChunk) {
+          throw new OpenAIError('cannot serialize a tool message before receiving any chunks');
+        }
+        pushEvent(makeChatCompletionReadableStreamMessageChunk(lastChunk, message, toolCallIds));
+      }
+    });
+
+    this.on('end', () => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.resolve(undefined);
+      }
+      readQueue.length = 0;
+    });
+
+    this.on('abort', (err) => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.reject(err);
+      }
+      readQueue.length = 0;
+    });
+
+    this.on('error', (err) => {
+      done = true;
+      for (const reader of readQueue) {
+        reader.reject(err);
+      }
+      readQueue.length = 0;
+    });
+
+    const iterator = (): AsyncIterator<ChatCompletionReadableStreamItem> => ({
+      next: async (): Promise<IteratorResult<ChatCompletionReadableStreamItem>> => {
+        if (!pushQueue.length) {
+          if (done) {
+            return { value: undefined, done: true };
+          }
+          return new Promise<ChatCompletionReadableStreamItem | undefined>((resolve, reject) =>
+            readQueue.push({ resolve, reject }),
+          ).then((event) => (event ? { value: event, done: false } : { value: undefined, done: true }));
+        }
+        const event = pushQueue.shift();
+        if (!event) {
+          return { value: undefined, done: true };
+        }
+        return { value: event, done: false };
+      },
+      return: async () => {
+        this.abort();
+        return { value: undefined, done: true };
+      },
+    });
+
+    const stream = new Stream(iterator, this.controller);
+    return stream.toReadableStream();
+  }
+
+  static runTools<T extends (string | object)[], ParsedT = null, ToolContext = unknown>(
+    client: OpenAI,
+    params: ChatCompletionStreamingToolRunnerParamsWithContext<T, ToolContext>,
+    options?: RunnerOptions,
+  ): ChatCompletionStreamingRunner<ParsedT>;
+
   static runTools<T extends (string | object)[], ParsedT = null>(
     client: OpenAI,
-    params: ChatCompletionStreamingToolRunnerParams<T>,
+    params: ChatCompletionStreamingToolRunnerParamsWithoutContext<T>,
+    options?: RunnerOptions,
+  ): ChatCompletionStreamingRunner<ParsedT>;
+  static runTools<T extends (string | object)[], ParsedT = null, ToolContext = unknown>(
+    client: OpenAI,
+    params:
+      | ChatCompletionStreamingToolRunnerParamsWithContext<T, ToolContext>
+      | ChatCompletionStreamingToolRunnerParamsWithoutContext<T>,
     options?: RunnerOptions,
   ): ChatCompletionStreamingRunner<ParsedT> {
     const runner = new ChatCompletionStreamingRunner<ParsedT>(

package/src/lib/EventStream.ts

@@ -44,10 +44,17 @@ export class EventStream<EventTypes extends BaseEvents> {
     // 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._emit('end');
-      }, this.#handleError.bind(this));
+      Promise.resolve()
+        .then(executor)
+        .then(() => {
+          try {
+            this._emitFinal();
+          } catch (error) {
+            this.#handleError(error);
+            return;
+          }
+          this._emit('end');
+        }, this.#handleError.bind(this));
     }, 0);
   }
 
@@ -157,6 +164,109 @@ export class EventStream<EventTypes extends BaseEvents> {
     });
   }
 
+  /**
+   * Returns an async iterator that yields every time the event is triggered.
+   * The iterator ends when the stream ends and rejects if the stream errors
+   * or is aborted. If you request the 'error' or 'abort' event, the iterator
+   * yields that event instead of rejecting.
+   *
+   * Example:
+   *
+   *   for await (const [message] of stream.events('message')) {
+   *     await processMessage(message);
+   *   }
+   */
+  events<Event extends keyof EventTypes>(
+    event: Event,
+  ): AsyncIterableIterator<EventParameters<EventTypes, Event>> {
+    type Parameters = EventParameters<EventTypes, Event>;
+    type Result = IteratorResult<Parameters>;
+    type Reader = {
+      resolve: (result: Result) => void;
+      reject: (error: OpenAIError) => void;
+    };
+
+    const pushQueue: Parameters[] = [];
+    const readQueue: Reader[] = [];
+    let ended = this.ended;
+    let failure: OpenAIError | undefined;
+    let failureDelivered = false;
+
+    const doneResult = (): Result => ({ value: undefined as never, done: true });
+    const finishReaders = () => {
+      while (readQueue.length) {
+        readQueue.shift()!.resolve(doneResult());
+      }
+    };
+    const rejectReader = () => {
+      if (!failure || failureDelivered || !readQueue.length) return;
+      failureDelivered = true;
+      readQueue.shift()!.reject(failure);
+    };
+    const cleanup = () => {
+      this.off(event, onEvent as EventListener<EventTypes, Event>);
+      this.off('end', onEnd);
+      if (event !== 'error') this.off('error', onFailure);
+      if (event !== 'abort') this.off('abort', onFailure);
+    };
+    const onEvent = (...args: Parameters) => {
+      if (ended) return;
+      const reader = readQueue.shift();
+      if (reader) {
+        reader.resolve({ value: args, done: false });
+      } else {
+        pushQueue.push(args);
+      }
+    };
+    const onFailure = (error: OpenAIError) => {
+      failure = error;
+      if (!pushQueue.length) rejectReader();
+    };
+    const onEnd = () => {
+      ended = true;
+      cleanup();
+      if (!pushQueue.length) {
+        rejectReader();
+        finishReaders();
+      }
+    };
+
+    if (!ended) {
+      this.on(event, onEvent as EventListener<EventTypes, Event>);
+      this.on('end', onEnd);
+      if (event !== 'error') this.on('error', onFailure);
+      if (event !== 'abort') this.on('abort', onFailure);
+    }
+
+    return {
+      next: () => {
+        const value = pushQueue.shift();
+        if (value) return Promise.resolve({ value, done: false });
+
+        if (failure && !failureDelivered) {
+          failureDelivered = true;
+          return Promise.reject(failure);
+        }
+
+        if (ended) return Promise.resolve(doneResult());
+
+        return new Promise<Result>((resolve, reject) => {
+          readQueue.push({ resolve, reject });
+        });
+      },
+      return: () => {
+        ended = true;
+        pushQueue.length = 0;
+        cleanup();
+        finishReaders();
+        return Promise.resolve(doneResult());
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+    };
+  }
+
   async done(): Promise<void> {
     this.#catchingPromiseCreated = true;
     await this.#endPromise;

package/src/lib/RunnableFunction.ts

@@ -4,15 +4,17 @@ import { JSONSchema } from './jsonschema';
 
 type PromiseOrValue<T> = T | Promise<T>;
 
-export type RunnableFunctionWithParse<Args extends object> = {
+export type RunnableFunctionWithParse<Args extends object, ToolContext = unknown> = {
   /**
    * @param args the return value from `parse`.
    * @param runner the runner evaluating this callback.
+   * @param toolContext the context passed to `.runTools()`.
    * @returns a string to send back to OpenAI.
    */
   function: (
     args: Args,
     runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
+    toolContext: ToolContext,
   ) => PromiseOrValue<unknown>;
   /**
    * @param input the raw args from the OpenAI function call.
@@ -34,14 +36,17 @@ export type RunnableFunctionWithParse<Args extends object> = {
   strict?: boolean | undefined;
 };
 
-export type RunnableFunctionWithoutParse = {
+export type RunnableFunctionWithoutParse<ToolContext = unknown> = {
   /**
    * @param args the raw args from the OpenAI function call.
+   * @param runner the runner evaluating this callback.
+   * @param toolContext the context passed to `.runTools()`.
    * @returns a string to send back to OpenAI
    */
   function: (
     args: string,
     runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
+    toolContext: ToolContext,
   ) => PromiseOrValue<unknown>;
   /**
    * The parameters the function accepts, describes as a JSON Schema object.
@@ -58,56 +63,80 @@ export type RunnableFunctionWithoutParse = {
   strict?: boolean | undefined;
 };
 
-export type RunnableFunction<Args extends object | string> =
-  Args extends string ? RunnableFunctionWithoutParse
-  : Args extends object ? RunnableFunctionWithParse<Args>
-  : never;
+export type RunnableFunction<Args extends object | string, ToolContext = unknown> = Args extends string ?
+  RunnableFunctionWithoutParse<ToolContext>
+: Args extends object ? RunnableFunctionWithParse<Args, ToolContext>
+: never;
 
-export type RunnableToolFunction<Args extends object | string> =
-  Args extends string ? RunnableToolFunctionWithoutParse
-  : Args extends object ? RunnableToolFunctionWithParse<Args>
-  : never;
+export type RunnableToolFunction<Args extends object | string, ToolContext = unknown> = Args extends string ?
+  RunnableToolFunctionWithoutParse<ToolContext>
+: Args extends object ? RunnableToolFunctionWithParse<Args, ToolContext>
+: never;
 
-export type RunnableToolFunctionWithoutParse = {
+export type RunnableToolFunctionWithoutParse<ToolContext = unknown> = {
+  type: 'function';
+  function: RunnableFunctionWithoutParse<ToolContext>;
+};
+export type RunnableToolFunctionWithParse<Args extends object, ToolContext = unknown> = {
   type: 'function';
-  function: RunnableFunctionWithoutParse;
+  function: RunnableFunctionWithParse<Args, ToolContext>;
 };
-export type RunnableToolFunctionWithParse<Args extends object> = {
+
+/**
+ * A broad tool shape for contextually typing callbacks when the argument type is inferred.
+ */
+export type RunnableToolFunctionWithContext<ToolContext> = {
   type: 'function';
-  function: RunnableFunctionWithParse<Args>;
+  function: {
+    function: (
+      args: any,
+      runner: ChatCompletionRunner<unknown> | ChatCompletionStreamingRunner<unknown>,
+      toolContext: ToolContext,
+    ) => PromiseOrValue<unknown>;
+    parse?: (input: string) => PromiseOrValue<any>;
+    parameters: JSONSchema;
+    description: string;
+    name?: string | undefined;
+    strict?: boolean | undefined;
+  };
 };
 
-export function isRunnableFunctionWithParse<Args extends object>(
+export function isRunnableFunctionWithParse<Args extends object, ToolContext = unknown>(
   fn: any,
-): fn is RunnableFunctionWithParse<Args> {
+): fn is RunnableFunctionWithParse<Args, ToolContext> {
   return typeof (fn as any).parse === 'function';
 }
 
 export type BaseFunctionsArgs = readonly (object | string)[];
 
-export type RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs> =
-  [any[]] extends [FunctionsArgs] ? readonly RunnableFunction<any>[]
-  : {
-      [Index in keyof FunctionsArgs]: Index extends number ? RunnableFunction<FunctionsArgs[Index]>
-      : FunctionsArgs[Index];
-    };
+export type RunnableFunctions<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [
+  any[],
+] extends [FunctionsArgs] ?
+  readonly RunnableFunction<any, ToolContext>[]
+: {
+    [Index in keyof FunctionsArgs]: Index extends number ? RunnableFunction<FunctionsArgs[Index], ToolContext>
+    : FunctionsArgs[Index];
+  };
 
-export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs> =
-  [any[]] extends [FunctionsArgs] ? readonly RunnableToolFunction<any>[]
-  : {
-      [Index in keyof FunctionsArgs]: Index extends number ? RunnableToolFunction<FunctionsArgs[Index]>
-      : FunctionsArgs[Index];
-    };
+export type RunnableTools<FunctionsArgs extends BaseFunctionsArgs, ToolContext = unknown> = [any[]] extends (
+  [FunctionsArgs]
+) ?
+  readonly RunnableToolFunction<any, ToolContext>[]
+: {
+    [Index in keyof FunctionsArgs]: Index extends number ?
+      RunnableToolFunction<FunctionsArgs[Index], ToolContext>
+    : FunctionsArgs[Index];
+  };
 
 /**
  * This is helper class for passing a `function` and `parse` where the `function`
  * argument type matches the `parse` return type.
  */
-export class ParsingToolFunction<Args extends object> {
+export class ParsingToolFunction<Args extends object, ToolContext = unknown> {
   type: 'function';
-  function: RunnableFunctionWithParse<Args>;
+  function: RunnableFunctionWithParse<Args, ToolContext>;
 
-  constructor(input: RunnableFunctionWithParse<Args>) {
+  constructor(input: RunnableFunctionWithParse<Args, ToolContext>) {
     this.type = 'function';
     this.function = input;
   }

package/src/lib/parser.ts

@@ -7,8 +7,10 @@ import {
   ChatCompletionMessage,
   ChatCompletionMessageFunctionToolCall,
   ChatCompletionStreamingToolRunnerParams,
+  ChatCompletionStreamingToolRunnerParamsWithContext,
   ChatCompletionStreamParams,
   ChatCompletionToolRunnerParams,
+  ChatCompletionToolRunnerParamsWithContext,
   ParsedChatCompletion,
   ParsedChoice,
   ParsedFunctionToolCall,
@@ -19,7 +21,9 @@ import { ResponseFormatJSONSchema } from '../resources/shared';
 type AnyChatCompletionCreateParams =
   | ChatCompletionCreateParams
   | ChatCompletionToolRunnerParams<any>
+  | ChatCompletionToolRunnerParamsWithContext<any, any>
   | ChatCompletionStreamingToolRunnerParams<any>
+  | ChatCompletionStreamingToolRunnerParamsWithContext<any, any>
   | ChatCompletionStreamParams;
 
 type Unpacked<T> = T extends (infer U)[] ? U : T;

package/src/lib/responses/ResponseAccumulator.ts

@@ -6,6 +6,11 @@ import {
 import { OpenAIError } from '../../error';
 import { addOutputText } from '../ResponsesParser';
 
+type ResponseKeepAliveEvent = {
+  type: 'keepalive';
+  sequence_number: number;
+};
+
 /**
  * Applies a streaming event to a response snapshot.
  *
@@ -13,7 +18,10 @@ import { addOutputText } from '../ResponsesParser';
  * in place, while response lifecycle events return a detached replacement. Event
  * payloads are cloned, so retaining or replaying the raw events is safe.
  */
-export function accumulateResponse(event: ResponseStreamEvent, snapshot?: Response): Response {
+export function accumulateResponse(
+  event: ResponseStreamEvent | ResponseKeepAliveEvent,
+  snapshot?: Response,
+): Response {
   if (!snapshot) {
     if (event.type !== 'response.created') {
       throw new OpenAIError(
@@ -371,6 +379,7 @@ export function accumulateResponse(event: ResponseStreamEvent, snapshot?: Respon
     case 'response.mcp_list_tools.in_progress':
     case 'response.mcp_list_tools.completed':
     case 'response.mcp_list_tools.failed':
+    case 'keepalive':
     case 'error': {
       // These events do not contain state represented by the Response object.
       break;

package/src/lib/responses/ResponseInputItems.ts

@@ -96,6 +96,8 @@ export function toResponseInputItem(item: ResponseInputItemLike): ResponseInputI
     case 'mcp_call':
     case 'mcp_list_tools':
     case 'message':
+    case 'program':
+    case 'program_output':
     case 'reasoning':
     case 'shell_call':
     case 'tool_search_call':

package/src/lib/responses/ResponseStream.ts

@@ -7,6 +7,7 @@ import {
   type ResponseStreamEvent,
 } from '../../resources/responses/responses';
 import { RequestOptions } from '../../internal/request-options';
+import { type ReadableStream } from '../../internal/shim-types';
 import { APIUserAbortError, OpenAIError } from '../../error';
 import OpenAI from '../../index';
 import { type BaseEvents, EventStream } from '../EventStream';
@@ -27,7 +28,9 @@ export type ResponseStreamByIdParams = {
    */
   response_id: string;
   /**
-   * If provided, the stream will start after the event with the given sequence number.
+   * If provided, events with a sequence number less than or equal to this value
+   * will not be emitted. The helper still replays them internally to build a
+   * complete snapshot for later events and `finalResponse()`.
    */
   starting_after?: number;
   /**
@@ -90,6 +93,12 @@ export class ResponseStream<ParsedT = null>
     return runner;
   }
 
+  static fromReadableStream(stream: ReadableStream): ResponseStream<null> {
+    const runner = new ResponseStream(null);
+    runner._run(() => runner._fromReadableStream(stream));
+    return runner;
+  }
+
   #beginRequest() {
     if (this.ended) return;
     this.#currentResponseSnapshot = undefined;
@@ -175,6 +184,8 @@ export class ResponseStream<ParsedT = null>
     let stream: Stream<ResponseStreamEvent> | undefined;
     let starting_after: number | null = null;
     if ('response_id' in params) {
+      // Keep the full replay so that `accumulateResponse()` sees `response.created` and can build
+      // complete snapshots before locally filtering events at `starting_after`.
       stream = await client.responses.retrieve(
         params.response_id,
         { stream: true },
@@ -198,6 +209,23 @@ export class ResponseStream<ParsedT = null>
     return this.#endRequest();
   }
 
+  protected async _fromReadableStream(
+    readableStream: ReadableStream,
+    options?: RequestOptions,
+  ): Promise<ParsedResponse<ParsedT>> {
+    this._listenForAbort(options?.signal);
+    this.#beginRequest();
+    this._connected();
+    const stream = Stream.fromReadableStream<ResponseStreamEvent>(readableStream, this.controller);
+    for await (const event of stream) {
+      this.#addEvent(event, null);
+    }
+    if (stream.controller.signal?.aborted) {
+      throw new APIUserAbortError();
+    }
+    return this.#endRequest();
+  }
+
   [Symbol.asyncIterator](this: ResponseStream<ParsedT>): AsyncIterator<ResponseStreamEvent> {
     const pushQueue: ResponseStreamEvent[] = [];
     const readQueue: {

package/src/resources/admin/organization/projects/api-keys.ts

@@ -121,6 +121,11 @@ export interface ProjectAPIKey {
 
   owner: ProjectAPIKey.Owner;
 
+  /**
+   * Whether the API key's owner currently has effective access to the project.
+   */
+  owner_project_access: 'active' | 'inactive';
+
   /**
    * The redacted value of the API key
    */
@@ -218,7 +223,16 @@ export interface APIKeyRetrieveParams {
   project_id: string;
 }
 
-export interface APIKeyListParams extends ConversationCursorPageParams {}
+export interface APIKeyListParams extends ConversationCursorPageParams {
+  /**
+   * Filter API keys by whether the owner currently has effective access to the
+   * project. Use `active` for owners with access, `inactive` for owners without
+   * access, or `any` for all enabled project API keys. If omitted, the endpoint
+   * applies its existing membership-based visibility rules, which may exclude some
+   * enabled keys.
+   */
+  owner_project_access?: 'active' | 'inactive' | 'any';
+}
 
 export interface APIKeyDeleteParams {
   /**

package/src/resources/beta/assistants.ts

@@ -1141,19 +1141,12 @@ export interface AssistantCreateParams {
   name?: string | null;
 
   /**
-   * Constrains effort on reasoning for
-   * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-   * supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-   * Reducing reasoning effort can result in faster responses and fewer tokens used
-   * on reasoning in a response.
-   *
-   * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-   *   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-   *   calls are supported for all reasoning values in gpt-5.1.
-   * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-   *   support `none`.
-   * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-   * - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+   * Constrains effort on reasoning for reasoning models. Currently supported values
+   * are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+   * reasoning effort can result in faster responses and fewer tokens used on
+   * reasoning in a response. Not all reasoning models support every value. See the
+   * [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+   * model-specific support.
    */
   reasoning_effort?: Shared.ReasoningEffort | null;
 
@@ -1403,19 +1396,12 @@ export interface AssistantUpdateParams {
   name?: string | null;
 
   /**
-   * Constrains effort on reasoning for
-   * [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-   * supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-   * Reducing reasoning effort can result in faster responses and fewer tokens used
-   * on reasoning in a response.
-   *
-   * - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-   *   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-   *   calls are supported for all reasoning values in gpt-5.1.
-   * - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-   *   support `none`.
-   * - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-   * - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+   * Constrains effort on reasoning for reasoning models. Currently supported values
+   * are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+   * reasoning effort can result in faster responses and fewer tokens used on
+   * reasoning in a response. Not all reasoning models support every value. See the
+   * [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+   * model-specific support.
    */
   reasoning_effort?: Shared.ReasoningEffort | null;