openai 0.68.0 → 0.69.0

data/rbi/openai/models/responses/response_apply_patch_tool_call.rbi

@@ -42,6 +42,16 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The execution context that produced this tool call.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Variants
+            )
+          )
+        end
+        attr_accessor :caller_
+
         # The ID of the entity that created this tool call.
         sig { returns(T.nilable(String)) }
         attr_reader :created_by
@@ -62,6 +72,13 @@ module OpenAI
               ),
             status:
               OpenAI::Responses::ResponseApplyPatchToolCall::Status::OrSymbol,
+            caller_:
+              T.nilable(
+                T.any(
+                  OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Direct::OrHash,
+                  OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Program::OrHash
+                )
+              ),
             created_by: String,
             type: Symbol
           ).returns(T.attached_class)
@@ -77,6 +94,8 @@ module OpenAI
           operation:,
           # The status of the apply patch tool call. One of `in_progress` or `completed`.
           status:,
+          # The execution context that produced this tool call.
+          caller_: nil,
           # The ID of the entity that created this tool call.
           created_by: nil,
           # The type of the item. Always `apply_patch_call`.
@@ -94,6 +113,10 @@ module OpenAI
               status:
                 OpenAI::Responses::ResponseApplyPatchToolCall::Status::TaggedSymbol,
               type: Symbol,
+              caller_:
+                T.nilable(
+                  OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Variants
+                ),
               created_by: String
             }
           )
@@ -280,6 +303,81 @@ module OpenAI
           def self.values
           end
         end
+
+        # The execution context that produced this tool call.
+        module Caller
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Direct,
+                OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Program
+              )
+            end
+
+          class Direct < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Direct,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig { params(type: Symbol).returns(T.attached_class) }
+            def self.new(type: :direct)
+            end
+
+            sig { override.returns({ type: Symbol }) }
+            def to_hash
+            end
+          end
+
+          class Program < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Program,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The call ID of the program item that produced this tool call.
+            sig { returns(String) }
+            attr_accessor :caller_id
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig do
+              params(caller_id: String, type: Symbol).returns(T.attached_class)
+            end
+            def self.new(
+              # The call ID of the program item that produced this tool call.
+              caller_id:,
+              type: :program
+            )
+            end
+
+            sig { override.returns({ caller_id: String, type: Symbol }) }
+            def to_hash
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::ResponseApplyPatchToolCall::Caller::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
       end
     end
   end

data/rbi/openai/models/responses/response_apply_patch_tool_call_output.rbi

@@ -33,6 +33,16 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The execution context that produced this tool call.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Variants
+            )
+          )
+        end
+        attr_accessor :caller_
+
         # The ID of the entity that created this tool call output.
         sig { returns(T.nilable(String)) }
         attr_reader :created_by
@@ -51,6 +61,13 @@ module OpenAI
             call_id: String,
             status:
               OpenAI::Responses::ResponseApplyPatchToolCallOutput::Status::OrSymbol,
+            caller_:
+              T.nilable(
+                T.any(
+                  OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Direct::OrHash,
+                  OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Program::OrHash
+                )
+              ),
             created_by: String,
             output: T.nilable(String),
             type: Symbol
@@ -64,6 +81,8 @@ module OpenAI
           call_id:,
           # The status of the apply patch tool call output. One of `completed` or `failed`.
           status:,
+          # The execution context that produced this tool call.
+          caller_: nil,
           # The ID of the entity that created this tool call output.
           created_by: nil,
           # Optional textual output returned by the apply patch tool.
@@ -81,6 +100,10 @@ module OpenAI
               status:
                 OpenAI::Responses::ResponseApplyPatchToolCallOutput::Status::TaggedSymbol,
               type: Symbol,
+              caller_:
+                T.nilable(
+                  OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Variants
+                ),
               created_by: String,
               output: T.nilable(String)
             }
@@ -123,6 +146,81 @@ module OpenAI
           def self.values
           end
         end
+
+        # The execution context that produced this tool call.
+        module Caller
+          extend OpenAI::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Direct,
+                OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Program
+              )
+            end
+
+          class Direct < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Direct,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig { params(type: Symbol).returns(T.attached_class) }
+            def self.new(type: :direct)
+            end
+
+            sig { override.returns({ type: Symbol }) }
+            def to_hash
+            end
+          end
+
+          class Program < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Program,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The call ID of the program item that produced this tool call.
+            sig { returns(String) }
+            attr_accessor :caller_id
+
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig do
+              params(caller_id: String, type: Symbol).returns(T.attached_class)
+            end
+            def self.new(
+              # The call ID of the program item that produced this tool call.
+              caller_id:,
+              type: :program
+            )
+            end
+
+            sig { override.returns({ caller_id: String, type: Symbol }) }
+            def to_hash
+            end
+          end
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::ResponseApplyPatchToolCallOutput::Caller::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
       end
     end
   end

data/rbi/openai/models/responses/response_compact_params.rbi

@@ -58,6 +58,34 @@ module OpenAI
         sig { returns(T.nilable(String)) }
         attr_accessor :prompt_cache_key
 
+        # 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.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Responses::ResponseCompactParams::PromptCacheOptions
+            )
+          )
+        end
+        attr_reader :prompt_cache_options
+
+        sig do
+          params(
+            prompt_cache_options:
+              T.nilable(
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::OrHash
+              )
+          ).void
+        end
+        attr_writer :prompt_cache_options
+
         # How long to retain a prompt cache entry created by this request.
         sig do
           returns(
@@ -94,6 +122,10 @@ module OpenAI
             instructions: T.nilable(String),
             previous_response_id: T.nilable(String),
             prompt_cache_key: T.nilable(String),
+            prompt_cache_options:
+              T.nilable(
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::OrHash
+              ),
             prompt_cache_retention:
               T.nilable(
                 OpenAI::Responses::ResponseCompactParams::PromptCacheRetention::OrSymbol
@@ -126,6 +158,16 @@ module OpenAI
           previous_response_id: nil,
           # A key to use when reading from or writing to the prompt cache.
           prompt_cache_key: nil,
+          # 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: nil,
           # How long to retain a prompt cache entry created by this request.
           prompt_cache_retention: nil,
           # The service tier to use for this request.
@@ -151,6 +193,10 @@ module OpenAI
               instructions: T.nilable(String),
               previous_response_id: T.nilable(String),
               prompt_cache_key: T.nilable(String),
+              prompt_cache_options:
+                T.nilable(
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions
+                ),
               prompt_cache_retention:
                 T.nilable(
                   OpenAI::Responses::ResponseCompactParams::PromptCacheRetention::OrSymbol
@@ -198,6 +244,21 @@ module OpenAI
             end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
+          GPT_5_6_SOL =
+            T.let(
+              :"gpt-5.6-sol",
+              OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol
+            )
+          GPT_5_6_TERRA =
+            T.let(
+              :"gpt-5.6-terra",
+              OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol
+            )
+          GPT_5_6_LUNA =
+            T.let(
+              :"gpt-5.6-luna",
+              OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol
+            )
           GPT_5_4 =
             T.let(
               :"gpt-5.4",
@@ -691,6 +752,176 @@ module OpenAI
             )
         end
 
+        class PromptCacheOptions < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # 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.
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::OrSymbol
+              )
+            )
+          end
+          attr_reader :mode
+
+          sig do
+            params(
+              mode:
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::OrSymbol
+            ).void
+          end
+          attr_writer :mode
+
+          # 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.
+          sig do
+            returns(
+              T.nilable(
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl::OrSymbol
+              )
+            )
+          end
+          attr_reader :ttl
+
+          sig do
+            params(
+              ttl:
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl::OrSymbol
+            ).void
+          end
+          attr_writer :ttl
+
+          # 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.
+          sig do
+            params(
+              mode:
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::OrSymbol,
+              ttl:
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl::OrSymbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # 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: nil,
+            # 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: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                mode:
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::OrSymbol,
+                ttl:
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl::OrSymbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # 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.
+          module Mode
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            IMPLICIT =
+              T.let(
+                :implicit,
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::TaggedSymbol
+              )
+            EXPLICIT =
+              T.let(
+                :explicit,
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Mode::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
+          # 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.
+          module Ttl
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            TTL_30M =
+              T.let(
+                :"30m",
+                OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::ResponseCompactParams::PromptCacheOptions::Ttl::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
         # How long to retain a prompt cache entry created by this request.
         module PromptCacheRetention
           extend OpenAI::Internal::Type::Enum