openai 6.45.0 → 6.47.0

package/src/resources/responses/responses.ts

@@ -43,6 +43,8 @@ export type ParsedResponseOutputItem<ParsedT> =
   | ResponseFunctionWebSearch
   | ResponseComputerToolCall
   | ResponseComputerToolCallOutputItem
+  | ResponseOutputItem.Program
+  | ResponseOutputItem.ProgramOutput
   | ResponseToolSearchCall
   | ResponseToolSearchOutputItem
   | ResponseOutputItem.AdditionalTools
@@ -235,7 +237,7 @@ export class Responses extends APIResource {
    * @example
    * ```ts
    * const compactedResponse = await client.responses.compact({
-   *   model: 'gpt-5.4',
+   *   model: 'gpt-5.6-sol',
    * });
    * ```
    */
@@ -254,6 +256,11 @@ export interface ApplyPatchTool {
    * The type of the tool. Always `apply_patch`.
    */
   type: 'apply_patch';
+
+  /**
+   * The tool invocation context(s).
+   */
+  allowed_callers?: Array<'direct' | 'programmatic'> | null;
 }
 
 export interface CompactedResponse {
@@ -659,6 +666,11 @@ export interface CustomTool {
    */
   type: 'custom';
 
+  /**
+   * The tool invocation context(s).
+   */
+  allowed_callers?: Array<'direct' | 'programmatic'> | null;
+
   /**
    * Whether this tool should be deferred and discovered via tool search.
    */
@@ -794,6 +806,11 @@ export interface FunctionShellTool {
    */
   type: 'shell';
 
+  /**
+   * The tool invocation context(s).
+   */
+  allowed_callers?: Array<'direct' | 'programmatic'> | null;
+
   environment?: ContainerAuto | LocalEnvironment | ContainerReference | null;
 }
 
@@ -814,7 +831,7 @@ export interface FunctionTool {
   parameters: { [key: string]: unknown } | null;
 
   /**
-   * Whether to enforce strict parameter validation. Default `true`.
+   * Whether strict parameter validation is enforced for this function tool.
    */
   strict: boolean | null;
 
@@ -823,6 +840,11 @@ export interface FunctionTool {
    */
   type: 'function';
 
+  /**
+   * The tool invocation context(s).
+   */
+  allowed_callers?: Array<'direct' | 'programmatic'> | null;
+
   /**
    * Whether this function is deferred and loaded via tool search.
    */
@@ -833,6 +855,12 @@ export interface FunctionTool {
    * call the function.
    */
   description?: string | null;
+
+  /**
+   * A JSON schema object describing the JSON value encoded in string outputs for
+   * this function.
+   */
+  output_schema?: { [key: string]: unknown } | null;
 }
 
 export interface InlineSkill {
@@ -937,6 +965,11 @@ export namespace NamespaceTool {
 
     type: 'function';
 
+    /**
+     * The tool invocation context(s).
+     */
+    allowed_callers?: Array<'direct' | 'programmatic'> | null;
+
     /**
      * Whether this function should be deferred and discovered via tool search.
      */
@@ -944,8 +977,19 @@ export namespace NamespaceTool {
 
     description?: string | null;
 
+    /**
+     * A JSON Schema describing the JSON value encoded in string outputs for this
+     * function tool. This does not describe content-array outputs.
+     */
+    output_schema?: { [key: string]: unknown } | null;
+
     parameters?: unknown | null;
 
+    /**
+     * Whether to enforce strict parameter validation. If omitted, Responses attempts
+     * to use strict validation when the schema is compatible, and falls back to
+     * non-strict validation otherwise.
+     */
     strict?: boolean | null;
   }
 }
@@ -1042,6 +1086,7 @@ export interface Response {
     | ToolChoiceFunction
     | ToolChoiceMcp
     | ToolChoiceCustom
+    | Response.SpecificProgrammaticToolCallingParam
     | ToolChoiceApplyPatch
     | ToolChoiceShell;
 
@@ -1130,11 +1175,22 @@ export interface Response {
   prompt_cache_key?: string;
 
   /**
+   * The prompt-caching options that were applied to the response. Supported for
+   * `gpt-5.6` and later models.
+   */
+  prompt_cache_options?: Response.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:
@@ -1243,6 +1299,13 @@ export namespace Response {
     reason?: 'max_output_tokens' | 'content_filter';
   }
 
+  export interface SpecificProgrammaticToolCallingParam {
+    /**
+     * The tool to call. Always `programmatic_tool_calling`.
+     */
+    type: 'programmatic_tool_calling';
+  }
+
   /**
    * The conversation that this response belonged to. Input items and output items
    * from this response were automatically added to this conversation.
@@ -1385,6 +1448,22 @@ export namespace Response {
       type: 'error';
     }
   }
+
+  /**
+   * The prompt-caching options that were applied to the response. Supported for
+   * `gpt-5.6` and later models.
+   */
+  export interface PromptCacheOptions {
+    /**
+     * Whether implicit prompt-cache breakpoints were enabled.
+     */
+    mode: 'implicit' | 'explicit';
+
+    /**
+     * The minimum lifetime applied to each cache breakpoint.
+     */
+    ttl: '30m';
+  }
 }
 
 /**
@@ -1421,6 +1500,11 @@ export interface ResponseApplyPatchToolCall {
    */
   type: 'apply_patch_call';
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseApplyPatchToolCall.Direct | ResponseApplyPatchToolCall.Program | null;
+
   /**
    * The ID of the entity that created this tool call.
    */
@@ -1482,6 +1566,19 @@ export namespace ResponseApplyPatchToolCall {
      */
     type: 'update_file';
   }
+
+  export interface Direct {
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    type: 'program';
+  }
 }
 
 /**
@@ -1509,6 +1606,11 @@ export interface ResponseApplyPatchToolCallOutput {
    */
   type: 'apply_patch_call_output';
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseApplyPatchToolCallOutput.Direct | ResponseApplyPatchToolCallOutput.Program | null;
+
   /**
    * The ID of the entity that created this tool call output.
    */
@@ -1520,6 +1622,21 @@ export interface ResponseApplyPatchToolCallOutput {
   output?: string | null;
 }
 
+export namespace ResponseApplyPatchToolCallOutput {
+  export interface Direct {
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    type: 'program';
+  }
+}
+
 /**
  * Emitted when there is a partial audio response.
  */
@@ -2445,12 +2562,32 @@ export interface ResponseCustomToolCall {
    */
   id?: string;
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseCustomToolCall.Direct | ResponseCustomToolCall.Program | null;
+
   /**
    * The namespace of the custom tool being called.
    */
   namespace?: string;
 }
 
+export namespace ResponseCustomToolCall {
+  export interface Direct {
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    type: 'program';
+  }
+}
+
 /**
  * Event representing a delta (partial update) to the input of a custom tool call.
  */
@@ -2556,6 +2693,32 @@ export interface ResponseCustomToolCallOutput {
    * The unique ID of the custom tool call output in the OpenAI platform.
    */
   id?: string;
+
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseCustomToolCallOutput.Direct | ResponseCustomToolCallOutput.Program | null;
+}
+
+export namespace ResponseCustomToolCallOutput {
+  export interface Direct {
+    /**
+     * The caller type. Always `direct`.
+     */
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    /**
+     * The caller type. Always `program`.
+     */
+    type: 'program';
+  }
 }
 
 /**
@@ -2590,6 +2753,7 @@ export interface ResponseError {
     | 'server_error'
     | 'rate_limit_exceeded'
     | 'invalid_prompt'
+    | 'bio_policy'
     | 'vector_store_timeout'
     | 'invalid_image'
     | 'invalid_image_format'
@@ -3020,6 +3184,11 @@ export interface ResponseFunctionShellToolCall {
    */
   type: 'shell_call';
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseFunctionShellToolCall.Direct | ResponseFunctionShellToolCall.Program | null;
+
   /**
    * The ID of the entity that created this tool call.
    */
@@ -3043,6 +3212,19 @@ export namespace ResponseFunctionShellToolCall {
      */
     timeout_ms: number | null;
   }
+
+  export interface Direct {
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    type: 'program';
+  }
 }
 
 /**
@@ -3082,6 +3264,11 @@ export interface ResponseFunctionShellToolCallOutput {
    */
   type: 'shell_call_output';
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseFunctionShellToolCallOutput.Direct | ResponseFunctionShellToolCallOutput.Program | null;
+
   /**
    * The identifier of the actor that created the item.
    */
@@ -3141,6 +3328,19 @@ export namespace ResponseFunctionShellToolCallOutput {
       type: 'exit';
     }
   }
+
+  export interface Direct {
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    type: 'program';
+  }
 }
 
 /**
@@ -3174,6 +3374,11 @@ export interface ResponseFunctionToolCall {
    */
   id?: string;
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseFunctionToolCall.Direct | ResponseFunctionToolCall.Program | null;
+
   /**
    * The namespace of the function to run.
    */
@@ -3186,6 +3391,21 @@ export interface ResponseFunctionToolCall {
   status?: 'in_progress' | 'completed' | 'incomplete';
 }
 
+export namespace ResponseFunctionToolCall {
+  export interface Direct {
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    type: 'program';
+  }
+}
+
 /**
  * A tool call to run a function. See the
  * [function calling guide](https://platform.openai.com/docs/guides/function-calling)
@@ -3237,12 +3457,38 @@ export interface ResponseFunctionToolCallOutputItem {
    */
   type: 'function_call_output';
 
+  /**
+   * The execution context that produced this tool call.
+   */
+  caller?: ResponseFunctionToolCallOutputItem.Direct | ResponseFunctionToolCallOutputItem.Program | null;
+
   /**
    * The identifier of the actor that created the item.
    */
   created_by?: string;
 }
 
+export namespace ResponseFunctionToolCallOutputItem {
+  export interface Direct {
+    /**
+     * The caller type. Always `direct`.
+     */
+    type: 'direct';
+  }
+
+  export interface Program {
+    /**
+     * The call ID of the program item that produced this tool call.
+     */
+    caller_id: string;
+
+    /**
+     * The caller type. Always `program`.
+     */
+    type: 'program';
+  }
+}
+
 /**
  * The results of a web search tool call. See the
  * [web search guide](https://platform.openai.com/docs/guides/tools-web-search) for
@@ -3588,11 +3834,13 @@ export interface ResponseInputFile {
   type: 'input_file';
 
   /**
-   * The detail level of the file to be sent to the model. Use `low` for the default
-   * rendering behavior, or `high` to render the file at higher quality. Defaults to
-   * `low`.
+   * The detail level of the file to be sent to the model. Use `auto` to let the
+   * system select the detail level; for GPT-5.6 and later models, `auto` uses
+   * high-quality rendering, which may increase input token usage. Use `low` for
+   * lower-cost rendering, or `high` to render the file at higher quality. Defaults
+   * to `auto`.
    */
-  detail?: 'low' | 'high';
+  detail?: 'auto' | 'low' | 'high';
 
   /**
    * The content of the file to be sent to the model.
@@ -3613,6 +3861,27 @@ export interface ResponseInputFile {
    * The name of the file to be sent to the model.
    */
   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.
+   */
+  prompt_cache_breakpoint?: ResponseInputFile.PromptCacheBreakpoint;
+}
+
+export namespace ResponseInputFile {
+  /**
+   * 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';
+  }
 }
 
 /**
@@ -3625,11 +3894,13 @@ export interface ResponseInputFileContent {
   type: 'input_file';
 
   /**
-   * The detail level of the file to be sent to the model. Use `low` for the default
-   * rendering behavior, or `high` to render the file at higher quality. Defaults to
-   * `low`.
+   * The detail level of the file to be sent to the model. Use `auto` to let the
+   * system select the detail level; for GPT-5.6 and later models, `auto` uses
+   * high-quality rendering, which may increase input token usage. Use `low` for
+   * lower-cost rendering, or `high` to render the file at higher quality. Defaults
+   * to `auto`.
    */
-  detail?: 'low' | 'high';
+  detail?: 'auto' | 'low' | 'high';
 
   /**
    * The base64-encoded data of the file to be sent to the model.
@@ -3650,6 +3921,27 @@ export interface ResponseInputFileContent {
    * The name of the file to be sent to the model.
    */
   filename?: string | null;
+
+  /**
+   * 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?: ResponseInputFileContent.PromptCacheBreakpoint | null;
+}
+
+export namespace ResponseInputFileContent {
+  /**
+   * 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';
+  }
 }
 
 /**
@@ -3678,6 +3970,27 @@ export interface ResponseInputImage {
    * encoded image in a data URL.
    */
   image_url?: string | null;
+
+  /**
+   * 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?: ResponseInputImage.PromptCacheBreakpoint;
+}
+
+export namespace ResponseInputImage {
+  /**
+   * 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';
+  }
 }
 
 /**
@@ -3706,6 +4019,27 @@ export interface ResponseInputImageContent {
    * encoded image in a data URL.
    */
   image_url?: string | null;
+
+  /**
+   * 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?: ResponseInputImageContent.PromptCacheBreakpoint | null;
+}
+
+export namespace ResponseInputImageContent {
+  /**
+   * 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';
+  }
 }
 
 /**
@@ -3745,7 +4079,9 @@ export type ResponseInputItem =
   | ResponseCustomToolCallOutput
   | ResponseCustomToolCall
   | ResponseInputItem.CompactionTrigger
-  | ResponseInputItem.ItemReference;
+  | ResponseInputItem.ItemReference
+  | ResponseInputItem.Program
+  | ResponseInputItem.ProgramOutput;
 
 export namespace ResponseInputItem {
   /**
@@ -3861,6 +4197,11 @@ export namespace ResponseInputItem {
      */
     id?: string | null;
 
+    /**
+     * The execution context that produced this tool call.
+     */
+    caller?: FunctionCallOutput.Direct | FunctionCallOutput.Program | null;
+
     /**
      * The status of the item. One of `in_progress`, `completed`, or `incomplete`.
      * Populated when items are returned via API.
@@ -3868,6 +4209,27 @@ export namespace ResponseInputItem {
     status?: 'in_progress' | 'completed' | 'incomplete' | null;
   }
 
+  export namespace FunctionCallOutput {
+    export interface Direct {
+      /**
+       * The caller type. Always `direct`.
+       */
+      type: 'direct';
+    }
+
+    export interface Program {
+      /**
+       * The call ID of the program item that produced this tool call.
+       */
+      caller_id: string;
+
+      /**
+       * The caller type. Always `program`.
+       */
+      type: 'program';
+    }
+  }
+
   export interface ToolSearchCall {
     /**
      * The arguments supplied to the tool search call.
@@ -4064,6 +4426,11 @@ export namespace ResponseInputItem {
      */
     id?: string | null;
 
+    /**
+     * The execution context that produced this tool call.
+     */
+    caller?: ShellCall.Direct | ShellCall.Program | null;
+
     /**
      * The environment to execute the shell commands in.
      */
@@ -4097,6 +4464,25 @@ export namespace ResponseInputItem {
        */
       timeout_ms?: number | null;
     }
+
+    export interface Direct {
+      /**
+       * The caller type. Always `direct`.
+       */
+      type: 'direct';
+    }
+
+    export interface Program {
+      /**
+       * The call ID of the program item that produced this tool call.
+       */
+      caller_id: string;
+
+      /**
+       * The caller type. Always `program`.
+       */
+      type: 'program';
+    }
   }
 
   /**
@@ -4125,6 +4511,11 @@ export namespace ResponseInputItem {
      */
     id?: string | null;
 
+    /**
+     * The execution context that produced this tool call.
+     */
+    caller?: ShellCallOutput.Direct | ShellCallOutput.Program | null;
+
     /**
      * The maximum number of UTF-8 characters captured for this shell call's combined
      * output.
@@ -4137,6 +4528,27 @@ export namespace ResponseInputItem {
     status?: 'in_progress' | 'completed' | 'incomplete' | null;
   }
 
+  export namespace ShellCallOutput {
+    export interface Direct {
+      /**
+       * The caller type. Always `direct`.
+       */
+      type: 'direct';
+    }
+
+    export interface Program {
+      /**
+       * The call ID of the program item that produced this tool call.
+       */
+      caller_id: string;
+
+      /**
+       * The caller type. Always `program`.
+       */
+      type: 'program';
+    }
+  }
+
   /**
    * A tool call representing a request to create, delete, or update files using diff
    * patches.
@@ -4168,6 +4580,11 @@ export namespace ResponseInputItem {
      * via API.
      */
     id?: string | null;
+
+    /**
+     * The execution context that produced this tool call.
+     */
+    caller?: ApplyPatchCall.Direct | ApplyPatchCall.Program | null;
   }
 
   export namespace ApplyPatchCall {
@@ -4225,6 +4642,25 @@ export namespace ResponseInputItem {
        */
       type: 'update_file';
     }
+
+    export interface Direct {
+      /**
+       * The caller type. Always `direct`.
+       */
+      type: 'direct';
+    }
+
+    export interface Program {
+      /**
+       * The call ID of the program item that produced this tool call.
+       */
+      caller_id: string;
+
+      /**
+       * The caller type. Always `program`.
+       */
+      type: 'program';
+    }
   }
 
   /**
@@ -4252,6 +4688,11 @@ export namespace ResponseInputItem {
      */
     id?: string | null;
 
+    /**
+     * The execution context that produced this tool call.
+     */
+    caller?: ApplyPatchCallOutput.Direct | ApplyPatchCallOutput.Program | null;
+
     /**
      * Optional human-readable log text from the apply patch tool (e.g., patch results
      * or errors).
@@ -4259,6 +4700,27 @@ export namespace ResponseInputItem {
     output?: string | null;
   }
 
+  export namespace ApplyPatchCallOutput {
+    export interface Direct {
+      /**
+       * The caller type. Always `direct`.
+       */
+      type: 'direct';
+    }
+
+    export interface Program {
+      /**
+       * The call ID of the program item that produced this tool call.
+       */
+      caller_id: string;
+
+      /**
+       * The caller type. Always `program`.
+       */
+      type: 'program';
+    }
+  }
+
   /**
    * A list of tools available on an MCP server.
    */
@@ -4453,6 +4915,60 @@ export namespace ResponseInputItem {
      */
     type?: 'item_reference' | null;
   }
+
+  export interface Program {
+    /**
+     * The unique ID of this 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 item type. Always `program`.
+     */
+    type: 'program';
+  }
+
+  export interface ProgramOutput {
+    /**
+     * The unique ID of this 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.
+     */
+    status: 'completed' | 'incomplete';
+
+    /**
+     * The item type. Always `program_output`.
+     */
+    type: 'program_output';
+  }
 }
 
 /**
@@ -4503,6 +5019,27 @@ export interface ResponseInputText {
    * The type of the input item. Always `input_text`.
    */
   type: 'input_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?: ResponseInputText.PromptCacheBreakpoint;
+}
+
+export namespace ResponseInputText {
+  /**
+   * 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';
+  }
 }
 
 /**
@@ -4518,6 +5055,27 @@ export interface ResponseInputTextContent {
    * The type of the input item. Always `input_text`.
    */
   type: 'input_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?: ResponseInputTextContent.PromptCacheBreakpoint | null;
+}
+
+export namespace ResponseInputTextContent {
+  /**
+   * 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';
+  }
 }
 
 /**
@@ -4536,6 +5094,8 @@ export type ResponseItem =
   | ResponseToolSearchOutputItem
   | ResponseItem.AdditionalTools
   | ResponseReasoningItem
+  | ResponseItem.Program
+  | ResponseItem.ProgramOutput
   | ResponseCompactionItem
   | ResponseItem.ImageGenerationCall
   | ResponseCodeInterpreterToolCall
@@ -4575,6 +5135,60 @@ export namespace ResponseItem {
     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';
+  }
+
   /**
    * An image generation request made by the model.
    */
@@ -5118,6 +5732,8 @@ export type ResponseOutputItem =
   | ResponseComputerToolCall
   | ResponseComputerToolCallOutputItem
   | ResponseReasoningItem
+  | ResponseOutputItem.Program
+  | ResponseOutputItem.ProgramOutput
   | ResponseToolSearchCall
   | ResponseToolSearchOutputItem
   | ResponseOutputItem.AdditionalTools
@@ -5138,6 +5754,60 @@ export type ResponseOutputItem =
   | ResponseCustomToolCallOutputItem;
 
 export namespace ResponseOutputItem {
+  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';
+  }
+
   export interface AdditionalTools {
     /**
      * The unique ID of the additional tools item.
@@ -5828,8 +6498,9 @@ export interface ResponseReasoningItem {
   content?: Array<ResponseReasoningItem.Content>;
 
   /**
-   * The encrypted content of the reasoning item - populated when a response is
-   * generated with `reasoning.encrypted_content` in the `include` parameter.
+   * The encrypted content of the reasoning item. This is populated by default for
+   * reasoning items returned by `POST /v1/responses` and WebSocket `response.create`
+   * requests.
    */
   encrypted_content?: string | null;
 
@@ -5957,6 +6628,12 @@ export interface ResponseReasoningSummaryPartDoneEvent {
    * The type of the event. Always `response.reasoning_summary_part.done`.
    */
   type: 'response.reasoning_summary_part.done';
+
+  /**
+   * The completion status of the summary part. Omitted when the part completed
+   * normally and set to `incomplete` when generation was interrupted.
+   */
+  status?: 'incomplete';
 }
 
 export namespace ResponseReasoningSummaryPartDoneEvent {
@@ -6581,6 +7258,11 @@ export namespace ResponseUsage {
    * A detailed breakdown of the input tokens.
    */
   export interface InputTokensDetails {
+    /**
+     * The number of input tokens that were written to the cache.
+     */
+    cache_write_tokens: number;
+
     /**
      * The number of tokens that were retrieved from the cache.
      * [More on prompt caching](https://platform.openai.com/docs/guides/prompt-caching).
@@ -6809,11 +7491,29 @@ export interface ResponsesClientEvent {
   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?: ResponsesClientEvent.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:
@@ -6911,6 +7611,7 @@ export interface ResponsesClientEvent {
     | ToolChoiceFunction
     | ToolChoiceMcp
     | ToolChoiceCustom
+    | ResponsesClientEvent.SpecificProgrammaticToolCallingParam
     | ToolChoiceApplyPatch
     | ToolChoiceShell;
 
@@ -6997,6 +7698,74 @@ export namespace ResponsesClientEvent {
      * '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';
   }
 
   /**
@@ -7013,6 +7782,13 @@ export namespace ResponsesClientEvent {
      */
     include_obfuscation?: boolean;
   }
+
+  export interface SpecificProgrammaticToolCallingParam {
+    /**
+     * The tool to call. Always `programmatic_tool_calling`.
+     */
+    type: 'programmatic_tool_calling';
+  }
 }
 
 /**
@@ -7101,6 +7877,7 @@ export type Tool =
   | WebSearchTool
   | Tool.Mcp
   | Tool.CodeInterpreter
+  | Tool.ProgrammaticToolCalling
   | Tool.ImageGeneration
   | Tool.LocalShell
   | FunctionShellTool
@@ -7127,6 +7904,11 @@ export namespace Tool {
      */
     type: 'mcp';
 
+    /**
+     * The tool invocation context(s).
+     */
+    allowed_callers?: Array<'direct' | 'programmatic'> | null;
+
     /**
      * List of allowed tool names or a filter object.
      */
@@ -7289,6 +8071,11 @@ export namespace Tool {
      * The type of the code interpreter tool. Always `code_interpreter`.
      */
     type: 'code_interpreter';
+
+    /**
+     * The tool invocation context(s).
+     */
+    allowed_callers?: Array<'direct' | 'programmatic'> | null;
   }
 
   export namespace CodeInterpreter {
@@ -7321,6 +8108,13 @@ export namespace Tool {
     }
   }
 
+  export interface ProgrammaticToolCalling {
+    /**
+     * The type of the tool. Always `programmatic_tool_calling`.
+     */
+    type: 'programmatic_tool_calling';
+  }
+
   /**
    * A tool that generates images using the GPT image models.
    */
@@ -7886,11 +8680,29 @@ export interface ResponseCreateParamsBase {
   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?: ResponseCreateParams.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:
@@ -7987,6 +8799,7 @@ export interface ResponseCreateParamsBase {
     | ToolChoiceFunction
     | ToolChoiceMcp
     | ToolChoiceCustom
+    | ResponseCreateParams.SpecificProgrammaticToolCallingParam
     | ToolChoiceApplyPatch
     | ToolChoiceShell;
 
@@ -8073,6 +8886,74 @@ export namespace ResponseCreateParams {
      * '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';
   }
 
   /**
@@ -8090,6 +8971,13 @@ export namespace ResponseCreateParams {
     include_obfuscation?: boolean;
   }
 
+  export interface SpecificProgrammaticToolCallingParam {
+    /**
+     * The tool to call. Always `programmatic_tool_calling`.
+     */
+    type: 'programmatic_tool_calling';
+  }
+
   export type ResponseCreateParamsNonStreaming = ResponsesAPI.ResponseCreateParamsNonStreaming;
   export type ResponseCreateParamsStreaming = ResponsesAPI.ResponseCreateParamsStreaming;
 }
@@ -8191,6 +9079,9 @@ export interface ResponseCompactParams {
    * available models.
    */
   model:
+    | 'gpt-5.6-sol'
+    | 'gpt-5.6-terra'
+    | 'gpt-5.6-luna'
     | 'gpt-5.4'
     | 'gpt-5.4-mini'
     | 'gpt-5.4-nano'
@@ -8313,7 +9204,20 @@ export interface ResponseCompactParams {
   prompt_cache_key?: string | null;
 
   /**
-   * How long to retain a prompt cache entry created by this request.
+   * 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?: ResponseCompactParams.PromptCacheOptions | null;
+
+  /**
+   * @deprecated How long to retain a prompt cache entry created by this request.
    */
   prompt_cache_retention?: 'in_memory' | '24h' | null;
 
@@ -8323,6 +9227,38 @@ export interface ResponseCompactParams {
   service_tier?: 'auto' | 'default' | 'flex' | 'priority' | null;
 }
 
+export namespace ResponseCompactParams {
+  /**
+   * 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';
+  }
+}
+
 Responses.InputItems = InputItems;
 Responses.InputTokens = InputTokens;