openai 6.44.0 → 6.46.0

package/src/resources/beta/responses/index.ts

@@ -0,0 +1,169 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export { InputItems, type BetaResponseItemList, type InputItemListParams } from './input-items';
+export { InputTokens, type InputTokenCountResponse, type InputTokenCountParams } from './input-tokens';
+export {
+  Responses,
+  type BetaApplyPatchTool,
+  type BetaCompactedResponse,
+  type BetaComputerAction,
+  type BetaComputerActionList,
+  type BetaComputerTool,
+  type BetaComputerUsePreviewTool,
+  type BetaContainerAuto,
+  type BetaContainerNetworkPolicyAllowlist,
+  type BetaContainerNetworkPolicyDisabled,
+  type BetaContainerNetworkPolicyDomainSecret,
+  type BetaContainerReference,
+  type BetaCustomTool,
+  type BetaEasyInputMessage,
+  type BetaFileSearchTool,
+  type BetaFunctionShellTool,
+  type BetaFunctionTool,
+  type BetaInlineSkill,
+  type BetaInlineSkillSource,
+  type BetaLocalEnvironment,
+  type BetaLocalSkill,
+  type BetaNamespaceTool,
+  type BetaResponse,
+  type BetaResponseApplyPatchToolCall,
+  type BetaResponseApplyPatchToolCallOutput,
+  type BetaResponseAudioDeltaEvent,
+  type BetaResponseAudioDoneEvent,
+  type BetaResponseAudioTranscriptDeltaEvent,
+  type BetaResponseAudioTranscriptDoneEvent,
+  type BetaResponseCodeInterpreterCallCodeDeltaEvent,
+  type BetaResponseCodeInterpreterCallCodeDoneEvent,
+  type BetaResponseCodeInterpreterCallCompletedEvent,
+  type BetaResponseCodeInterpreterCallInProgressEvent,
+  type BetaResponseCodeInterpreterCallInterpretingEvent,
+  type BetaResponseCodeInterpreterToolCall,
+  type BetaResponseCompactionItem,
+  type BetaResponseCompactionItemParam,
+  type BetaResponseCompletedEvent,
+  type BetaResponseComputerToolCall,
+  type BetaResponseComputerToolCallOutputItem,
+  type BetaResponseComputerToolCallOutputScreenshot,
+  type BetaResponseContainerReference,
+  type BetaResponseContent,
+  type BetaResponseContentPartAddedEvent,
+  type BetaResponseContentPartDoneEvent,
+  type BetaResponseConversationParam,
+  type BetaResponseCreatedEvent,
+  type BetaResponseCustomToolCall,
+  type BetaResponseCustomToolCallInputDeltaEvent,
+  type BetaResponseCustomToolCallInputDoneEvent,
+  type BetaResponseCustomToolCallItem,
+  type BetaResponseCustomToolCallOutput,
+  type BetaResponseCustomToolCallOutputItem,
+  type BetaResponseError,
+  type BetaResponseErrorEvent,
+  type BetaResponseFailedEvent,
+  type BetaResponseFileSearchCallCompletedEvent,
+  type BetaResponseFileSearchCallInProgressEvent,
+  type BetaResponseFileSearchCallSearchingEvent,
+  type BetaResponseFileSearchToolCall,
+  type BetaResponseFormatTextConfig,
+  type BetaResponseFormatTextJSONSchemaConfig,
+  type BetaResponseFunctionCallArgumentsDeltaEvent,
+  type BetaResponseFunctionCallArgumentsDoneEvent,
+  type BetaResponseFunctionCallOutputItem,
+  type BetaResponseFunctionCallOutputItemList,
+  type BetaResponseFunctionShellCallOutputContent,
+  type BetaResponseFunctionShellToolCall,
+  type BetaResponseFunctionShellToolCallOutput,
+  type BetaResponseFunctionToolCall,
+  type BetaResponseFunctionToolCallItem,
+  type BetaResponseFunctionToolCallOutputItem,
+  type BetaResponseFunctionWebSearch,
+  type BetaResponseImageGenCallCompletedEvent,
+  type BetaResponseImageGenCallGeneratingEvent,
+  type BetaResponseImageGenCallInProgressEvent,
+  type BetaResponseImageGenCallPartialImageEvent,
+  type BetaResponseInProgressEvent,
+  type BetaResponseIncludable,
+  type BetaResponseIncompleteEvent,
+  type BetaResponseInjectCreatedEvent,
+  type BetaResponseInjectEvent,
+  type BetaResponseInjectFailedEvent,
+  type BetaResponseInput,
+  type BetaResponseInputAudio,
+  type BetaResponseInputContent,
+  type BetaResponseInputFile,
+  type BetaResponseInputFileContent,
+  type BetaResponseInputImage,
+  type BetaResponseInputImageContent,
+  type BetaResponseInputItem,
+  type BetaResponseInputMessageContentList,
+  type BetaResponseInputMessageItem,
+  type BetaResponseInputText,
+  type BetaResponseInputTextContent,
+  type BetaResponseItem,
+  type BetaResponseLocalEnvironment,
+  type BetaResponseMcpCallArgumentsDeltaEvent,
+  type BetaResponseMcpCallArgumentsDoneEvent,
+  type BetaResponseMcpCallCompletedEvent,
+  type BetaResponseMcpCallFailedEvent,
+  type BetaResponseMcpCallInProgressEvent,
+  type BetaResponseMcpListToolsCompletedEvent,
+  type BetaResponseMcpListToolsFailedEvent,
+  type BetaResponseMcpListToolsInProgressEvent,
+  type BetaResponseOutputAudio,
+  type BetaResponseOutputItem,
+  type BetaResponseOutputItemAddedEvent,
+  type BetaResponseOutputItemDoneEvent,
+  type BetaResponseOutputMessage,
+  type BetaResponseOutputRefusal,
+  type BetaResponseOutputText,
+  type BetaResponseOutputTextAnnotationAddedEvent,
+  type BetaResponsePrompt,
+  type BetaResponseQueuedEvent,
+  type BetaResponseReasoningItem,
+  type BetaResponseReasoningSummaryPartAddedEvent,
+  type BetaResponseReasoningSummaryPartDoneEvent,
+  type BetaResponseReasoningSummaryTextDeltaEvent,
+  type BetaResponseReasoningSummaryTextDoneEvent,
+  type BetaResponseReasoningTextDeltaEvent,
+  type BetaResponseReasoningTextDoneEvent,
+  type BetaResponseRefusalDeltaEvent,
+  type BetaResponseRefusalDoneEvent,
+  type BetaResponseStatus,
+  type BetaResponseStreamEvent,
+  type BetaResponseTextConfig,
+  type BetaResponseTextDeltaEvent,
+  type BetaResponseTextDoneEvent,
+  type BetaResponseToolSearchCall,
+  type BetaResponseToolSearchOutputItem,
+  type BetaResponseToolSearchOutputItemParam,
+  type BetaResponseUsage,
+  type BetaResponseWebSearchCallCompletedEvent,
+  type BetaResponseWebSearchCallInProgressEvent,
+  type BetaResponseWebSearchCallSearchingEvent,
+  type BetaResponsesClientEvent,
+  type BetaResponsesServerEvent,
+  type BetaSkillReference,
+  type BetaTool,
+  type BetaToolChoiceAllowed,
+  type BetaToolChoiceApplyPatch,
+  type BetaToolChoiceCustom,
+  type BetaToolChoiceFunction,
+  type BetaToolChoiceMcp,
+  type BetaToolChoiceOptions,
+  type BetaToolChoiceShell,
+  type BetaToolChoiceTypes,
+  type BetaToolSearchTool,
+  type BetaWebSearchPreviewTool,
+  type BetaWebSearchTool,
+  type ResponseCreateParams,
+  type ResponseCreateParamsNonStreaming,
+  type ResponseCreateParamsStreaming,
+  type ResponseRetrieveParams,
+  type ResponseRetrieveParamsNonStreaming,
+  type ResponseRetrieveParamsStreaming,
+  type ResponseDeleteParams,
+  type ResponseCancelParams,
+  type ResponseCompactParams,
+  type BetaResponseItemsPage,
+} from './responses';
+export { type ResponsesWSClientOptions } from './ws';
+export { type ResponsesWSReconnectOptions } from './ws-base';

package/src/resources/beta/responses/input-items.ts

@@ -0,0 +1,105 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as ResponsesAPI from './responses';
+import { BetaResponseItemsPage } from './responses';
+import { CursorPage, type CursorPageParams, PagePromise } from '../../../core/pagination';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+import { path } from '../../../internal/utils/path';
+
+export class InputItems extends APIResource {
+  /**
+   * Returns a list of input items for a given response.
+   *
+   * @example
+   * ```ts
+   * // Automatically fetches more pages as needed.
+   * for await (const betaResponseItem of client.beta.responses.inputItems.list(
+   *   'response_id',
+   * )) {
+   *   // ...
+   * }
+   * ```
+   */
+  list(
+    responseID: string,
+    params: InputItemListParams | null | undefined = {},
+    options?: RequestOptions,
+  ): PagePromise<BetaResponseItemsPage, ResponsesAPI.BetaResponseItem> {
+    const { betas, ...query } = params ?? {};
+    return this._client.getAPIList(
+      path`/responses/${responseID}/input_items?beta=true`,
+      CursorPage<ResponsesAPI.BetaResponseItem>,
+      {
+        query,
+        ...options,
+        headers: buildHeaders([
+          { ...(betas?.toString() != null ? { 'openai-beta': betas?.toString() } : undefined) },
+          options?.headers,
+        ]),
+        __security: { bearerAuth: true },
+      },
+    );
+  }
+}
+
+/**
+ * A list of Response items.
+ */
+export interface BetaResponseItemList {
+  /**
+   * A list of items used to generate this response.
+   */
+  data: Array<ResponsesAPI.BetaResponseItem>;
+
+  /**
+   * The ID of the first item in the list.
+   */
+  first_id: string;
+
+  /**
+   * Whether there are more items available.
+   */
+  has_more: boolean;
+
+  /**
+   * The ID of the last item in the list.
+   */
+  last_id: string;
+
+  /**
+   * The type of object returned, must be `list`.
+   */
+  object: 'list';
+}
+
+export interface InputItemListParams extends CursorPageParams {
+  /**
+   * Query param: Additional fields to include in the response. See the `include`
+   * parameter for Response creation above for more information.
+   */
+  include?: Array<ResponsesAPI.BetaResponseIncludable>;
+
+  /**
+   * Query param: The order to return the input items in. Default is `desc`.
+   *
+   * - `asc`: Return the input items in ascending order.
+   * - `desc`: Return the input items in descending order.
+   */
+  order?: 'asc' | 'desc';
+
+  /**
+   * Header param: Optional beta features to enable for this request.
+   */
+  betas?: Array<'responses_multi_agent=v1'>;
+}
+
+export declare namespace InputItems {
+  export {
+    type BetaResponseItemList as BetaResponseItemList,
+    type InputItemListParams as InputItemListParams,
+  };
+}
+
+export { type BetaResponseItemsPage };

package/src/resources/beta/responses/input-tokens.ts

@@ -0,0 +1,245 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../../../core/resource';
+import * as ResponsesAPI from './responses';
+import { APIPromise } from '../../../core/api-promise';
+import { buildHeaders } from '../../../internal/headers';
+import { RequestOptions } from '../../../internal/request-options';
+
+export class InputTokens extends APIResource {
+  /**
+   * Returns input token counts of the request.
+   *
+   * Returns an object with `object` set to `response.input_tokens` and an
+   * `input_tokens` count.
+   *
+   * @example
+   * ```ts
+   * const response =
+   *   await client.beta.responses.inputTokens.count();
+   * ```
+   */
+  count(
+    params: InputTokenCountParams | null | undefined = {},
+    options?: RequestOptions,
+  ): APIPromise<InputTokenCountResponse> {
+    const { betas, ...body } = params ?? {};
+    return this._client.post('/responses/input_tokens?beta=true', {
+      body,
+      ...options,
+      headers: buildHeaders([
+        { ...(betas?.toString() != null ? { 'openai-beta': betas?.toString() } : undefined) },
+        options?.headers,
+      ]),
+      __security: { bearerAuth: true },
+    });
+  }
+}
+
+export interface InputTokenCountResponse {
+  input_tokens: number;
+
+  object: 'response.input_tokens';
+}
+
+export interface InputTokenCountParams {
+  /**
+   * Body param: The conversation that this response belongs to. Items from this
+   * conversation are prepended to `input_items` for this response request. Input
+   * items and output items from this response are automatically added to this
+   * conversation after this response completes.
+   */
+  conversation?: string | ResponsesAPI.BetaResponseConversationParam | null;
+
+  /**
+   * Body param: Text, image, or file inputs to the model, used to generate a
+   * response
+   */
+  input?: string | Array<ResponsesAPI.BetaResponseInputItem> | null;
+
+  /**
+   * Body param: A system (or developer) message inserted into the model's context.
+   * When used along with `previous_response_id`, the instructions from a previous
+   * response will not be carried over to the next response. This makes it simple to
+   * swap out system (or developer) messages in new responses.
+   */
+  instructions?: string | null;
+
+  /**
+   * Body param: Model ID used to generate the response, like `gpt-4o` or `o3`.
+   * OpenAI offers a wide range of models with different capabilities, performance
+   * characteristics, and price points. Refer to the
+   * [model guide](https://platform.openai.com/docs/models) to browse and compare
+   * available models.
+   */
+  model?: string | null;
+
+  /**
+   * Body param: Whether to allow the model to run tool calls in parallel.
+   */
+  parallel_tool_calls?: boolean | null;
+
+  /**
+   * Body param: A model-owned style preset to apply to this request. Omit this
+   * parameter to use the model's default style. Supported values may expand over
+   * time. Values must be at most 64 characters.
+   */
+  personality?: (string & {}) | 'friendly' | 'pragmatic';
+
+  /**
+   * Body param: The unique ID of the previous response to the model. Use this to
+   * create multi-turn conversations. Learn more about
+   * [conversation state](https://platform.openai.com/docs/guides/conversation-state).
+   * Cannot be used in conjunction with `conversation`.
+   */
+  previous_response_id?: string | null;
+
+  /**
+   * Body param: **gpt-5 and o-series models only** Configuration options for
+   * [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+   */
+  reasoning?: InputTokenCountParams.Reasoning | null;
+
+  /**
+   * Body param: Configuration options for a text response from the model. Can be
+   * plain text or structured JSON data. Learn more:
+   *
+   * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+   * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+   */
+  text?: InputTokenCountParams.Text | null;
+
+  /**
+   * Body param: Controls which tool the model should use, if any.
+   */
+  tool_choice?:
+    | ResponsesAPI.BetaToolChoiceOptions
+    | ResponsesAPI.BetaToolChoiceAllowed
+    | ResponsesAPI.BetaToolChoiceTypes
+    | ResponsesAPI.BetaToolChoiceFunction
+    | ResponsesAPI.BetaToolChoiceMcp
+    | ResponsesAPI.BetaToolChoiceCustom
+    | InputTokenCountParams.BetaSpecificProgrammaticToolCallingParam
+    | ResponsesAPI.BetaToolChoiceApplyPatch
+    | ResponsesAPI.BetaToolChoiceShell
+    | null;
+
+  /**
+   * Body param: An array of tools the model may call while generating a response.
+   * You can specify which tool to use by setting the `tool_choice` parameter.
+   */
+  tools?: Array<ResponsesAPI.BetaTool> | null;
+
+  /**
+   * @deprecated Body param: The truncation strategy to use for the model response. -
+   * `auto`: If the input to this Response exceeds the model's context window size,
+   * the model will truncate the response to fit the context window by dropping items
+   * from the beginning of the conversation. - `disabled` (default): If the input
+   * size will exceed the context window size for a model, the request will fail with
+   * a 400 error.
+   */
+  truncation?: 'auto' | 'disabled';
+
+  /**
+   * Header param: Optional beta features to enable for this request.
+   */
+  betas?: Array<'responses_multi_agent=v1'>;
+}
+
+export namespace InputTokenCountParams {
+  /**
+   * **gpt-5 and o-series models only** Configuration options for
+   * [reasoning models](https://platform.openai.com/docs/guides/reasoning).
+   */
+  export interface Reasoning {
+    /**
+     * Controls which reasoning items are rendered back to the model on later turns.
+     * When returned on a response, this is the effective reasoning context mode used
+     * for the response.
+     */
+    context?: 'auto' | 'current_turn' | 'all_turns' | null;
+
+    /**
+     * 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.
+     */
+    effort?: 'none' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max' | null;
+
+    /**
+     * @deprecated **Deprecated:** use `summary` instead.
+     *
+     * A summary of the reasoning performed by the model. This can be useful for
+     * debugging and understanding the model's reasoning process. One of `auto`,
+     * `concise`, or `detailed`.
+     */
+    generate_summary?: 'auto' | 'concise' | 'detailed' | null;
+
+    /**
+     * Controls the reasoning execution mode for the request.
+     *
+     * When returned on a response, this is the effective execution mode.
+     */
+    mode?: (string & {}) | 'standard' | 'pro';
+
+    /**
+     * A summary of the reasoning performed by the model. This can be useful for
+     * debugging and understanding the model's reasoning process. One of `auto`,
+     * `concise`, or `detailed`.
+     *
+     * `concise` is supported for `computer-use-preview` models and all reasoning
+     * models after `gpt-5`.
+     */
+    summary?: 'auto' | 'concise' | 'detailed' | null;
+  }
+
+  /**
+   * Configuration options for a text response from the model. Can be plain text or
+   * structured JSON data. Learn more:
+   *
+   * - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+   * - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+   */
+  export interface Text {
+    /**
+     * An object specifying the format that the model must output.
+     *
+     * Configuring `{ "type": "json_schema" }` enables Structured Outputs, which
+     * ensures the model will match your supplied JSON schema. Learn more in the
+     * [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
+     *
+     * The default format is `{ "type": "text" }` with no additional options.
+     *
+     * **Not recommended for gpt-4o and newer models:**
+     *
+     * Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+     * ensures the message the model generates is valid JSON. Using `json_schema` is
+     * preferred for models that support it.
+     */
+    format?: ResponsesAPI.BetaResponseFormatTextConfig;
+
+    /**
+     * Constrains the verbosity of the model's response. Lower values will result in
+     * more concise responses, while higher values will result in more verbose
+     * responses. Currently supported values are `low`, `medium`, and `high`.
+     */
+    verbosity?: 'low' | 'medium' | 'high' | null;
+  }
+
+  export interface BetaSpecificProgrammaticToolCallingParam {
+    /**
+     * The tool to call. Always `programmatic_tool_calling`.
+     */
+    type: 'programmatic_tool_calling';
+  }
+}
+
+export declare namespace InputTokens {
+  export {
+    type InputTokenCountResponse as InputTokenCountResponse,
+    type InputTokenCountParams as InputTokenCountParams,
+  };
+}

package/src/resources/beta/responses/internal-base.ts

@@ -0,0 +1,117 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import * as ResponsesAPI from './responses';
+import { OpenAI } from '../../../client';
+import { EventEmitter } from '../../../core/EventEmitter';
+import { OpenAIError } from '../../../core/error';
+
+import type { RawWebSocketData, ReconnectingEvent, UnsentMessage } from '../../../internal/ws';
+
+export type ResponsesStreamMessage =
+  | { type: 'connecting' | 'open' | 'closing' }
+  | {
+      type: 'close';
+      code: number;
+      reason: string;
+      unsent: UnsentMessage<ResponsesAPI.BetaResponsesClientEvent>[];
+    }
+  | { type: 'reconnecting'; reconnect: ReconnectingEvent }
+  | { type: 'reconnected' }
+  | { type: 'message'; message: ResponsesAPI.BetaResponsesServerEvent }
+  | { type: 'raw'; data: RawWebSocketData }
+  | { type: 'error'; error: WebSocketError };
+
+export class WebSocketError extends OpenAIError {
+  /**
+   * The error data that the API sent back in an error event.
+   */
+  error?: ResponsesAPI.BetaResponseErrorEvent | undefined;
+
+  constructor(message: string, event: ResponsesAPI.BetaResponseErrorEvent | null) {
+    super(message);
+
+    this.error = event ?? undefined;
+  }
+}
+
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+
+type WebSocketEvents = Simplify<
+  {
+    event: (event: ResponsesAPI.BetaResponsesServerEvent) => void;
+    raw: (data: RawWebSocketData) => void;
+    error: (error: WebSocketError) => void;
+    close: (
+      code: number,
+      reason: string,
+      unsent: UnsentMessage<ResponsesAPI.BetaResponsesClientEvent>[],
+    ) => void;
+    reconnecting: (event: ReconnectingEvent) => void;
+    reconnected: () => void;
+  } & {
+    [EventType in Exclude<NonNullable<ResponsesAPI.BetaResponsesServerEvent['type']>, 'error'>]: (
+      event: Extract<ResponsesAPI.BetaResponsesServerEvent, { type?: EventType }>,
+    ) => unknown;
+  }
+>;
+
+export abstract class ResponsesEmitter extends EventEmitter<WebSocketEvents> {
+  /**
+   * Send an event to the API.
+   */
+  abstract send(event: ResponsesAPI.BetaResponsesClientEvent): void;
+
+  /**
+   * Send raw data over the WebSocket without JSON serialization.
+   */
+  abstract sendRaw(data: RawWebSocketData): 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: ResponsesAPI.BetaResponseErrorEvent, message?: string | undefined): void;
+  protected _onError(
+    event: ResponsesAPI.BetaResponseErrorEvent | null,
+    message?: string | undefined,
+    cause?: any,
+  ): void {
+    message = message ?? safeJSONStringify(event) ?? 'unknown error';
+
+    if (!this._hasListener('error')) {
+      const error = new WebSocketError(
+        message +
+          `\n\nTo resolve these unhandled rejection errors you should bind an \`error\` callback, e.g. \`ws.on('error', (error) => ...)\` `,
+        event,
+      );
+      // @ts-ignore
+      error.cause = cause;
+      Promise.reject(error);
+      return;
+    }
+
+    const error = new WebSocketError(message, event);
+    // @ts-ignore
+    error.cause = cause;
+
+    this._emit('error', error);
+  }
+}
+
+export function buildURL(client: OpenAI, parameters: Record<string, unknown>): URL {
+  const { ...query } = parameters;
+  const endpoint = '/responses';
+  const url = new URL(client.buildURL(endpoint, query, undefined));
+  url.protocol = url.protocol === 'http:' || url.protocol === 'ws:' ? 'ws:' : 'wss:';
+  return url;
+}
+
+function safeJSONStringify(value: unknown): string | null {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return null;
+  }
+}