openai 6.45.0 → 6.47.0

package/src/resources/chat/completions/completions.ts

@@ -15,8 +15,15 @@ import { path } from '../../../internal/utils/path';
 import { ChatCompletionRunner } from '../../../lib/ChatCompletionRunner';
 import { ChatCompletionStreamingRunner } from '../../../lib/ChatCompletionStreamingRunner';
 import { RunnerOptions } from '../../../lib/AbstractChatCompletionRunner';
-import { ChatCompletionToolRunnerParams } from '../../../lib/ChatCompletionRunner';
-import { ChatCompletionStreamingToolRunnerParams } from '../../../lib/ChatCompletionStreamingRunner';
+import {
+  ChatCompletionToolRunnerParamsWithContext,
+  ChatCompletionToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionRunner';
+import {
+  ChatCompletionStreamingToolRunnerParamsWithContext,
+  ChatCompletionStreamingToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionStreamingRunner';
+import { type RunnableToolFunctionWithContext } from '../../../lib/RunnableFunction';
 import { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
 import { ExtractParsedContentFromParams, parseChatCompletion, validateInputTools } from '../../../lib/parser';
 
@@ -188,17 +195,55 @@ export class Completions extends APIResource {
    * [the docs](https://github.com/openai/openai-node#automated-function-calls)
    */
   runTools<
-    Params extends ChatCompletionToolRunnerParams<any>,
+    ToolContext,
+    Params extends Omit<
+      ChatCompletionToolRunnerParamsWithContext<any, ToolContext>,
+      'toolContext' | 'tools'
+    > = Omit<ChatCompletionToolRunnerParamsWithContext<any, ToolContext>, 'toolContext' | 'tools'>,
+    ParsedT = ExtractParsedContentFromParams<
+      Params & ChatCompletionToolRunnerParamsWithContext<any, ToolContext>
+    >,
+  >(
+    body: Params & {
+      toolContext: ToolContext;
+      tools: readonly RunnableToolFunctionWithContext<ToolContext>[];
+    },
+    options?: RunnerOptions,
+  ): ChatCompletionRunner<ParsedT>;
+
+  runTools<
+    ToolContext,
+    Params extends Omit<
+      ChatCompletionStreamingToolRunnerParamsWithContext<any, ToolContext>,
+      'toolContext' | 'tools'
+    > = Omit<ChatCompletionStreamingToolRunnerParamsWithContext<any, ToolContext>, 'toolContext' | 'tools'>,
+    ParsedT = ExtractParsedContentFromParams<
+      Params & ChatCompletionStreamingToolRunnerParamsWithContext<any, ToolContext>
+    >,
+  >(
+    body: Params & {
+      toolContext: ToolContext;
+      tools: readonly RunnableToolFunctionWithContext<ToolContext>[];
+    },
+    options?: RunnerOptions,
+  ): ChatCompletionStreamingRunner<ParsedT>;
+
+  runTools<
+    Params extends ChatCompletionToolRunnerParamsWithoutContext<any>,
     ParsedT = ExtractParsedContentFromParams<Params>,
   >(body: Params, options?: RunnerOptions): ChatCompletionRunner<ParsedT>;
 
   runTools<
-    Params extends ChatCompletionStreamingToolRunnerParams<any>,
+    Params extends ChatCompletionStreamingToolRunnerParamsWithoutContext<any>,
     ParsedT = ExtractParsedContentFromParams<Params>,
   >(body: Params, options?: RunnerOptions): ChatCompletionStreamingRunner<ParsedT>;
 
   runTools<
-    Params extends ChatCompletionToolRunnerParams<any> | ChatCompletionStreamingToolRunnerParams<any>,
+    Params extends
+      | ChatCompletionToolRunnerParamsWithoutContext<any>
+      | ChatCompletionToolRunnerParamsWithContext<any, any>
+      | ChatCompletionStreamingToolRunnerParamsWithoutContext<any>
+      | ChatCompletionStreamingToolRunnerParamsWithContext<any, any>,
     ParsedT = ExtractParsedContentFromParams<Params>,
   >(
     body: Params,
@@ -207,12 +252,16 @@ export class Completions extends APIResource {
     if (body.stream) {
       return ChatCompletionStreamingRunner.runTools(
         this._client,
-        body as ChatCompletionStreamingToolRunnerParams<any>,
+        body as ChatCompletionStreamingToolRunnerParamsWithContext<any, any>,
         options,
       );
     }
 
-    return ChatCompletionRunner.runTools(this._client, body as ChatCompletionToolRunnerParams<any>, options);
+    return ChatCompletionRunner.runTools(
+      this._client,
+      body as ChatCompletionToolRunnerParamsWithContext<any, any>,
+      options,
+    );
   }
 
   /**
@@ -255,8 +304,16 @@ export {
   type RunnableFunctionWithoutParse,
   ParsingToolFunction,
 } from '../../../lib/RunnableFunction';
-export { type ChatCompletionToolRunnerParams } from '../../../lib/ChatCompletionRunner';
-export { type ChatCompletionStreamingToolRunnerParams } from '../../../lib/ChatCompletionStreamingRunner';
+export {
+  type ChatCompletionToolRunnerParams,
+  type ChatCompletionToolRunnerParamsWithContext,
+  type ChatCompletionToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionRunner';
+export {
+  type ChatCompletionStreamingToolRunnerParams,
+  type ChatCompletionStreamingToolRunnerParamsWithContext,
+  type ChatCompletionStreamingToolRunnerParamsWithoutContext,
+} from '../../../lib/ChatCompletionStreamingRunner';
 export { ChatCompletionStream, type ChatCompletionStreamParams } from '../../../lib/ChatCompletionStream';
 export { ChatCompletionRunner } from '../../../lib/ChatCompletionRunner';
 
@@ -1129,6 +1186,13 @@ export namespace ChatCompletionContentPart {
      * The type of the content part. Always `file`.
      */
     type: 'file';
+
+    /**
+     * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+     * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+     * token block.
+     */
+    prompt_cache_breakpoint?: File.PromptCacheBreakpoint;
   }
 
   export namespace File {
@@ -1149,6 +1213,18 @@ export namespace ChatCompletionContentPart {
        */
       filename?: string;
     }
+
+    /**
+     * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+     * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+     * token block.
+     */
+    export interface PromptCacheBreakpoint {
+      /**
+       * The breakpoint mode. Always `explicit`.
+       */
+      mode: 'explicit';
+    }
   }
 }
 
@@ -1162,6 +1238,13 @@ export interface ChatCompletionContentPartImage {
    * The type of the content part.
    */
   type: 'image_url';
+
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  prompt_cache_breakpoint?: ChatCompletionContentPartImage.PromptCacheBreakpoint;
 }
 
 export namespace ChatCompletionContentPartImage {
@@ -1177,6 +1260,18 @@ export namespace ChatCompletionContentPartImage {
      */
     detail?: 'auto' | 'low' | 'high';
   }
+
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  export interface PromptCacheBreakpoint {
+    /**
+     * The breakpoint mode. Always `explicit`.
+     */
+    mode: 'explicit';
+  }
 }
 
 /**
@@ -1189,6 +1284,13 @@ export interface ChatCompletionContentPartInputAudio {
    * The type of the content part. Always `input_audio`.
    */
   type: 'input_audio';
+
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  prompt_cache_breakpoint?: ChatCompletionContentPartInputAudio.PromptCacheBreakpoint;
 }
 
 export namespace ChatCompletionContentPartInputAudio {
@@ -1203,6 +1305,18 @@ export namespace ChatCompletionContentPartInputAudio {
      */
     format: 'wav' | 'mp3';
   }
+
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  export interface PromptCacheBreakpoint {
+    /**
+     * The breakpoint mode. Always `explicit`.
+     */
+    mode: 'explicit';
+  }
 }
 
 export interface ChatCompletionContentPartRefusal {
@@ -1231,6 +1345,27 @@ export interface ChatCompletionContentPartText {
    * The type of the content part.
    */
   type: 'text';
+
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  prompt_cache_breakpoint?: ChatCompletionContentPartText.PromptCacheBreakpoint;
+}
+
+export namespace ChatCompletionContentPartText {
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  export interface PromptCacheBreakpoint {
+    /**
+     * The breakpoint mode. Always `explicit`.
+     */
+    mode: 'explicit';
+  }
 }
 
 /**
@@ -2046,11 +2181,29 @@ export interface ChatCompletionCreateParamsBase {
   prompt_cache_key?: string;
 
   /**
+   * Options for prompt caching. Supported for `gpt-5.6` and later models. By
+   * default, OpenAI automatically chooses one implicit cache breakpoint. You can add
+   * explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each
+   * request can write up to four breakpoints. For cache matching, OpenAI considers
+   * up to the latest 80 breakpoints in the conversation, without a content-block
+   * lookback limit. Set `mode` to `explicit` to disable the implicit breakpoint. The
+   * `ttl` defaults to `30m`, which is currently the only supported value. See the
+   * [prompt caching guide](https://platform.openai.com/docs/guides/prompt-caching)
+   * for current details.
+   */
+  prompt_cache_options?: ChatCompletionCreateParams.PromptCacheOptions;
+
+  /**
+   * @deprecated Deprecated. Use `prompt_cache_options.ttl` instead.
+   *
    * The retention policy for the prompt cache. Set to `24h` to enable extended
    * prompt caching, which keeps cached prefixes active for longer, up to a maximum
    * of 24 hours.
    * [Learn more](https://platform.openai.com/docs/guides/prompt-caching#prompt-cache-retention).
-   * For `gpt-5.5`, `gpt-5.5-pro`, and future models, only `24h` is supported.
+   * This field expresses a maximum retention policy, while
+   * `prompt_cache_options.ttl` expresses a minimum cache lifetime. The two fields
+   * are independent and do not interact. For `gpt-5.5`, `gpt-5.5-pro`, and future
+   * models, only `24h` is supported.
    *
    * For older models that support both `in_memory` and `24h`, the default depends on
    * your organization's data retention policy:
@@ -2062,19 +2215,12 @@ export interface ChatCompletionCreateParamsBase {
   prompt_cache_retention?: 'in_memory' | '24h' | 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;
 
@@ -2276,6 +2422,74 @@ export namespace ChatCompletionCreateParams {
      * 'omni-moderation-latest'.
      */
     model: string;
+
+    /**
+     * The policy to apply to moderated response input and output.
+     */
+    policy?: Moderation.Policy | null;
+  }
+
+  export namespace Moderation {
+    /**
+     * The policy to apply to moderated response input and output.
+     */
+    export interface Policy {
+      /**
+       * The moderation policy for the response input.
+       */
+      input?: Policy.Input | null;
+
+      /**
+       * The moderation policy for the response output.
+       */
+      output?: Policy.Output | null;
+    }
+
+    export namespace Policy {
+      /**
+       * The moderation policy for the response input.
+       */
+      export interface Input {
+        mode: 'score' | 'block';
+      }
+
+      /**
+       * The moderation policy for the response output.
+       */
+      export interface Output {
+        mode: 'score' | 'block';
+      }
+    }
+  }
+
+  /**
+   * Options for prompt caching. Supported for `gpt-5.6` and later models. By
+   * default, OpenAI automatically chooses one implicit cache breakpoint. You can add
+   * explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each
+   * request can write up to four breakpoints. For cache matching, OpenAI considers
+   * up to the latest 80 breakpoints in the conversation, without a content-block
+   * lookback limit. Set `mode` to `explicit` to disable the implicit breakpoint. The
+   * `ttl` defaults to `30m`, which is currently the only supported value. See the
+   * [prompt caching guide](https://platform.openai.com/docs/guides/prompt-caching)
+   * for current details.
+   */
+  export interface PromptCacheOptions {
+    /**
+     * Controls whether OpenAI automatically creates an implicit cache breakpoint.
+     * Defaults to `implicit`. With `implicit`, OpenAI creates one implicit breakpoint
+     * and writes up to the latest three explicit breakpoints in the request. With
+     * `explicit`, OpenAI does not create an implicit breakpoint and writes up to the
+     * latest four explicit breakpoints. If there are no explicit breakpoints, the
+     * request does not use prompt caching.
+     */
+    mode?: 'implicit' | 'explicit';
+
+    /**
+     * The minimum lifetime applied to every implicit and explicit cache breakpoint
+     * written by the request. Defaults to `30m`, which is currently the only supported
+     * value. The backend may retain cache entries for longer.
+     */
+    ttl?: '30m';
   }
 
   /**

package/src/resources/completions.ts

@@ -185,6 +185,11 @@ export namespace CompletionUsage {
      */
     audio_tokens?: number;
 
+    /**
+     * The unadjusted number of prompt tokens written to cache.
+     */
+    cache_write_tokens?: number;
+
     /**
      * Cached tokens present in the prompt.
      */

package/src/resources/conversations/conversations.ts

@@ -95,6 +95,27 @@ export interface ComputerScreenshotContent {
    * to `computer_screenshot`.
    */
   type: 'computer_screenshot';
+
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  prompt_cache_breakpoint?: ComputerScreenshotContent.PromptCacheBreakpoint;
+}
+
+export namespace ComputerScreenshotContent {
+  /**
+   * Marks the exact end of a reusable prompt prefix. The breakpoint inherits its TTL
+   * from the request's `prompt_cache_options.ttl`; the boundary is not rounded to a
+   * token block.
+   */
+  export interface PromptCacheBreakpoint {
+    /**
+     * The breakpoint mode. Always `explicit`.
+     */
+    mode: 'explicit';
+  }
 }
 
 export interface Conversation {

package/src/resources/conversations/items.ts

@@ -100,6 +100,8 @@ export type ConversationItem =
   | ResponsesAPI.ResponseToolSearchOutputItem
   | ConversationItem.AdditionalTools
   | ResponsesAPI.ResponseReasoningItem
+  | ConversationItem.Program
+  | ConversationItem.ProgramOutput
   | ResponsesAPI.ResponseCompactionItem
   | ResponsesAPI.ResponseCodeInterpreterToolCall
   | ConversationItem.LocalShellCall
@@ -163,6 +165,60 @@ export namespace ConversationItem {
     type: 'additional_tools';
   }
 
+  export interface Program {
+    /**
+     * The unique ID of the program item.
+     */
+    id: string;
+
+    /**
+     * The stable call ID of the program item.
+     */
+    call_id: string;
+
+    /**
+     * The JavaScript source executed by programmatic tool calling.
+     */
+    code: string;
+
+    /**
+     * Opaque program replay fingerprint that must be round-tripped.
+     */
+    fingerprint: string;
+
+    /**
+     * The type of the item. Always `program`.
+     */
+    type: 'program';
+  }
+
+  export interface ProgramOutput {
+    /**
+     * The unique ID of the program output item.
+     */
+    id: string;
+
+    /**
+     * The call ID of the program item.
+     */
+    call_id: string;
+
+    /**
+     * The result produced by the program item.
+     */
+    result: string;
+
+    /**
+     * The terminal status of the program output item.
+     */
+    status: 'completed' | 'incomplete';
+
+    /**
+     * The type of the item. Always `program_output`.
+     */
+    type: 'program_output';
+  }
+
   /**
    * A tool call to run a command on the local shell.
    */