openai 0.95.0 → 0.97.0

data/rbi/openai/models/beta/persisted_agent_tool.rbi

@@ -15,7 +15,8 @@ module OpenAI
             OpenAI::Beta::PersistedAgentTool::ToolSearch,
             OpenAI::Beta::PersistedAgentTool::ProgrammaticToolCalling,
             OpenAI::Beta::PersistedAgentTool::Mcp,
-            OpenAI::Beta::PersistedAgentTool::WebSearch
+            OpenAI::Beta::PersistedAgentTool::WebSearch,
+            OpenAI::Beta::PersistedAgentTool::ComputerUse
           )
         end
 
@@ -495,6 +496,53 @@ module OpenAI
           end
         end
 
+        class ComputerUse < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::PersistedAgentTool::ComputerUse,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # Whether computer tool outputs include screenshots.
+          sig { returns(T::Boolean) }
+          attr_accessor :include_screenshots
+
+          # The type of the object. Always `computer_use`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Browser use in an OpenAI-hosted session.
+          sig do
+            params(
+
+              include_screenshots: T::Boolean,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Whether computer tool outputs include screenshots.
+            include_screenshots:,
+
+            # The type of the object. Always `computer_use`.
+
+            type: :computer_use
+          )
+          end
+
+          sig do
+            override.returns(
+              {include_screenshots: T::Boolean, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
         sig { override.returns(T::Array[OpenAI::Beta::PersistedAgentTool::Variants]) }
         def self.variants
         end

data/rbi/openai/models/beta/persisted_agent_tool_param.rbi

@@ -15,7 +15,8 @@ module OpenAI
             OpenAI::Beta::PersistedAgentToolParam::ToolSearch,
             OpenAI::Beta::PersistedAgentToolParam::ProgrammaticToolCalling,
             OpenAI::Beta::PersistedAgentToolParam::Mcp,
-            OpenAI::Beta::PersistedAgentToolParam::WebSearch
+            OpenAI::Beta::PersistedAgentToolParam::WebSearch,
+            OpenAI::Beta::PersistedAgentToolParam::ComputerUse
           )
         end
 
@@ -534,6 +535,56 @@ module OpenAI
           end
         end
 
+        class ComputerUse < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::PersistedAgentToolParam::ComputerUse,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The type of the object. Always `computer_use`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Whether computer tool outputs include screenshots. Defaults to `false`.
+          sig { returns(T.nilable(T::Boolean)) }
+          attr_reader :include_screenshots
+
+          sig { params(include_screenshots: T::Boolean).void }
+          attr_writer :include_screenshots
+
+          # Browser use in an OpenAI-hosted session.
+          sig do
+            params(
+
+              include_screenshots: T::Boolean,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # Whether computer tool outputs include screenshots. Defaults to `false`.
+            include_screenshots: nil,
+
+            # The type of the object. Always `computer_use`.
+
+            type: :computer_use
+          )
+          end
+
+          sig do
+            override.returns(
+              {type: Symbol, include_screenshots: T::Boolean}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
         sig { override.returns(T::Array[OpenAI::Beta::PersistedAgentToolParam::Variants]) }
         def self.variants
         end

data/rbi/openai/models/beta/response_compact_params.rbi

@@ -223,6 +223,7 @@ module OpenAI
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           GPT_6_ASTRA = T.let(:"gpt-6-astra", OpenAI::Beta::ResponseCompactParams::Model::TaggedSymbol)
+          GPT_6_1_SOL = T.let(:"gpt-6.1-sol", OpenAI::Beta::ResponseCompactParams::Model::TaggedSymbol)
           GPT_6_SOL = T.let(:"gpt-6-sol", OpenAI::Beta::ResponseCompactParams::Model::TaggedSymbol)
           GPT_6_LUNA = T.let(:"gpt-6-luna", OpenAI::Beta::ResponseCompactParams::Model::TaggedSymbol)
           GPT_5_6_SOL = T.let(:"gpt-5.6-sol", OpenAI::Beta::ResponseCompactParams::Model::TaggedSymbol)

data/rbi/openai/models/beta/response_create_params.rbi

@@ -17,6 +17,13 @@ module OpenAI
           )
         end
 
+        # Domain-specific access programs to use for this request.
+        sig { returns(T.nilable(OpenAI::Beta::ResponseCreateParams::AccessPrograms)) }
+        attr_reader :access_programs
+
+        sig { params(access_programs: OpenAI::Beta::ResponseCreateParams::AccessPrograms::OrHash).void }
+        attr_writer :access_programs
+
         # Whether to run the model response in the background.
         # [Learn more](https://developers.openai.com/api/docs/guides/background).
         sig { returns(T.nilable(T::Boolean)) }
@@ -421,6 +428,8 @@ module OpenAI
         sig do
           params(
 
+            access_programs: OpenAI::Beta::ResponseCreateParams::AccessPrograms::OrHash,
+
             background: T.nilable(T::Boolean),
 
             context_management: T.nilable(T::Array[OpenAI::Beta::ResponseCreateParams::ContextManagement::OrHash]),
@@ -520,6 +529,9 @@ module OpenAI
         end
         def self.new(
 
+          # Domain-specific access programs to use for this request.
+          access_programs: nil,
+
           # Whether to run the model response in the background.
           # [Learn more](https://developers.openai.com/api/docs/guides/background).
           background: nil,
@@ -777,6 +789,7 @@ module OpenAI
         sig do
           override.returns(
             {
+              access_programs: OpenAI::Beta::ResponseCreateParams::AccessPrograms,
               background: T.nilable(T::Boolean),
               context_management: T.nilable(T::Array[OpenAI::Beta::ResponseCreateParams::ContextManagement]),
               conversation: T.nilable(T.any(String, OpenAI::Beta::BetaResponseConversationParam)),
@@ -845,6 +858,92 @@ module OpenAI
         def to_hash
         end
 
+        class AccessPrograms < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Beta::ResponseCreateParams::AccessPrograms,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The Cyber access program to use for this request. Supported values are
+          # `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves
+          # the program from the model's Cyber tier and your organization and project
+          # access, subject to model-specific eligibility restrictions. By default, models
+          # without a Cyber tier use Standard. Blue-tier models use Daybreak Blue when
+          # authorized; otherwise they fall back to Standard unless the model requires
+          # Daybreak access. Red-tier models use Daybreak Red and require authorization.
+          # Requests that require unavailable Daybreak access return 403. An implicit
+          # Standard fallback is represented by null in the response's access_programs
+          # field, rather than an explicit Standard selection.
+          sig { returns(T.nilable(OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol)) }
+          attr_reader :cyber
+
+          sig { params(cyber: OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol).void }
+          attr_writer :cyber
+
+          # Domain-specific access programs to use for this request.
+          sig do
+            params(
+
+              cyber: OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The Cyber access program to use for this request. Supported values are
+            # `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves
+            # the program from the model's Cyber tier and your organization and project
+            # access, subject to model-specific eligibility restrictions. By default, models
+            # without a Cyber tier use Standard. Blue-tier models use Daybreak Blue when
+            # authorized; otherwise they fall back to Standard unless the model requires
+            # Daybreak access. Red-tier models use Daybreak Red and require authorization.
+            # Requests that require unavailable Daybreak access return 403. An implicit
+            # Standard fallback is represented by null in the response's access_programs
+            # field, rather than an explicit Standard selection.
+
+            cyber: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {cyber: OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol}
+            )
+          end
+          def to_hash
+          end
+
+          # The Cyber access program to use for this request. Supported values are
+          # `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves
+          # the program from the model's Cyber tier and your organization and project
+          # access, subject to model-specific eligibility restrictions. By default, models
+          # without a Cyber tier use Standard. Blue-tier models use Daybreak Blue when
+          # authorized; otherwise they fall back to Standard unless the model requires
+          # Daybreak access. Red-tier models use Daybreak Red and require authorization.
+          # Requests that require unavailable Daybreak access return 403. An implicit
+          # Standard fallback is represented by null in the response's access_programs
+          # field, rather than an explicit Standard selection.
+          module Cyber
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber) }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            STANDARD = T.let(:standard, OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol)
+            DAYBREAK_BLUE = T.let(
+              :daybreak_blue,
+              OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol
+            )
+            DAYBREAK_RED = T.let(:daybreak_red, OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol)
+
+            sig { override.returns(T::Array[OpenAI::Beta::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol]) }
+            def self.values
+            end
+          end
+        end
+
         class ContextManagement < OpenAI::Internal::Type::BaseModel
           OrHash = T.type_alias do
             T.any(
@@ -947,6 +1046,7 @@ module OpenAI
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           GPT_6_ASTRA = T.let(:"gpt-6-astra", OpenAI::Beta::ResponseCreateParams::Model::TaggedSymbol)
+          GPT_6_1_SOL = T.let(:"gpt-6.1-sol", OpenAI::Beta::ResponseCreateParams::Model::TaggedSymbol)
           GPT_6_SOL = T.let(:"gpt-6-sol", OpenAI::Beta::ResponseCreateParams::Model::TaggedSymbol)
           GPT_6_LUNA = T.let(:"gpt-6-luna", OpenAI::Beta::ResponseCreateParams::Model::TaggedSymbol)
           GPT_5_6_SOL = T.let(:"gpt-5.6-sol", OpenAI::Beta::ResponseCreateParams::Model::TaggedSymbol)

data/rbi/openai/models/beta/session_turn_error.rbi

@@ -82,6 +82,12 @@ module OpenAI
           # The request was rejected by a safety policy.
           CYBER_POLICY = T.let(:cyber_policy, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
 
+          # The request was blocked by the safety systems.
+          MISALIGNMENT_POLICY_VIOLATION = T.let(
+            :misalignment_policy_violation,
+            OpenAI::Beta::SessionTurnError::Code::TaggedSymbol
+          )
+
           # The request could not connect to the model service.
           CONNECTION_FAILED = T.let(:connection_failed, OpenAI::Beta::SessionTurnError::Code::TaggedSymbol)
 

data/rbi/openai/models/chat_model.rbi

@@ -10,6 +10,7 @@ module OpenAI
       OrSymbol = T.type_alias { T.any(Symbol, String) }
 
       GPT_6_ASTRA = T.let(:"gpt-6-astra", OpenAI::ChatModel::TaggedSymbol)
+      GPT_6_1_SOL = T.let(:"gpt-6.1-sol", OpenAI::ChatModel::TaggedSymbol)
       GPT_6_SOL = T.let(:"gpt-6-sol", OpenAI::ChatModel::TaggedSymbol)
       GPT_6_LUNA = T.let(:"gpt-6-luna", OpenAI::ChatModel::TaggedSymbol)
       GPT_5_6_SOL = T.let(:"gpt-5.6-sol", OpenAI::ChatModel::TaggedSymbol)

data/rbi/openai/models/responses/response.rbi

@@ -18,6 +18,12 @@ module OpenAI
         sig { returns(String) }
         attr_accessor :id
 
+        sig { returns(T.nilable(OpenAI::Responses::Response::AccessPrograms)) }
+        attr_reader :access_programs
+
+        sig { params(access_programs: T.nilable(OpenAI::Responses::Response::AccessPrograms::OrHash)).void }
+        attr_writer :access_programs
+
         # Unix timestamp (in seconds) of when this Response was created.
         sig { returns(Float) }
         attr_accessor :created_at
@@ -338,6 +344,8 @@ module OpenAI
 
             id: String,
 
+            access_programs: T.nilable(OpenAI::Responses::Response::AccessPrograms::OrHash),
+
             created_at: Float,
 
             error: T.nilable(OpenAI::Responses::ResponseError::OrHash),
@@ -478,6 +486,8 @@ module OpenAI
           # Unique identifier for this Response.
           id:,
 
+          access_programs:,
+
           # Unix timestamp (in seconds) of when this Response was created.
           created_at:,
 
@@ -715,6 +725,7 @@ module OpenAI
           override.returns(
             {
               id: String,
+              access_programs: T.nilable(OpenAI::Responses::Response::AccessPrograms),
               created_at: Float,
               error: T.nilable(OpenAI::Responses::ResponseError),
               incomplete_details: T.nilable(OpenAI::Responses::Response::IncompleteDetails),
@@ -755,6 +766,58 @@ module OpenAI
         def to_hash
         end
 
+        class AccessPrograms < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::Response::AccessPrograms,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The effective Cyber access program used for this response.
+          sig { returns(OpenAI::Responses::Response::AccessPrograms::Cyber::TaggedSymbol) }
+          attr_accessor :cyber
+
+          sig do
+            params(
+
+              cyber: OpenAI::Responses::Response::AccessPrograms::Cyber::OrSymbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The effective Cyber access program used for this response.
+
+            cyber:
+          )
+          end
+
+          sig do
+            override.returns(
+              {cyber: OpenAI::Responses::Response::AccessPrograms::Cyber::TaggedSymbol}
+            )
+          end
+          def to_hash
+          end
+
+          # The effective Cyber access program used for this response.
+          module Cyber
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Responses::Response::AccessPrograms::Cyber) }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            STANDARD = T.let(:standard, OpenAI::Responses::Response::AccessPrograms::Cyber::TaggedSymbol)
+            DAYBREAK_BLUE = T.let(:daybreak_blue, OpenAI::Responses::Response::AccessPrograms::Cyber::TaggedSymbol)
+            DAYBREAK_RED = T.let(:daybreak_red, OpenAI::Responses::Response::AccessPrograms::Cyber::TaggedSymbol)
+
+            sig { override.returns(T::Array[OpenAI::Responses::Response::AccessPrograms::Cyber::TaggedSymbol]) }
+            def self.values
+            end
+          end
+        end
+
         class IncompleteDetails < OpenAI::Internal::Type::BaseModel
           OrHash = T.type_alias do
             T.any(

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

@@ -215,6 +215,7 @@ module OpenAI
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           GPT_6_ASTRA = T.let(:"gpt-6-astra", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
+          GPT_6_1_SOL = T.let(:"gpt-6.1-sol", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
           GPT_6_SOL = T.let(:"gpt-6-sol", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
           GPT_6_LUNA = T.let(:"gpt-6-luna", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)
           GPT_5_6_SOL = T.let(:"gpt-5.6-sol", OpenAI::Responses::ResponseCompactParams::Model::TaggedSymbol)

data/rbi/openai/models/responses/response_create_params.rbi

@@ -17,6 +17,13 @@ module OpenAI
           )
         end
 
+        # Domain-specific access programs to use for this request.
+        sig { returns(T.nilable(OpenAI::Responses::ResponseCreateParams::AccessPrograms)) }
+        attr_reader :access_programs
+
+        sig { params(access_programs: OpenAI::Responses::ResponseCreateParams::AccessPrograms::OrHash).void }
+        attr_writer :access_programs
+
         # Whether to run the model response in the background.
         # [Learn more](https://developers.openai.com/api/docs/guides/background).
         sig { returns(T.nilable(T::Boolean)) }
@@ -426,6 +433,8 @@ module OpenAI
         sig do
           params(
 
+            access_programs: OpenAI::Responses::ResponseCreateParams::AccessPrograms::OrHash,
+
             background: T.nilable(T::Boolean),
 
             context_management: T.nilable(T::Array[OpenAI::Responses::ResponseCreateParams::ContextManagement::OrHash]),
@@ -521,6 +530,9 @@ module OpenAI
         end
         def self.new(
 
+          # Domain-specific access programs to use for this request.
+          access_programs: nil,
+
           # Whether to run the model response in the background.
           # [Learn more](https://developers.openai.com/api/docs/guides/background).
           background: nil,
@@ -773,6 +785,7 @@ module OpenAI
         sig do
           override.returns(
             {
+              access_programs: OpenAI::Responses::ResponseCreateParams::AccessPrograms,
               background: T.nilable(T::Boolean),
               context_management: T.nilable(T::Array[OpenAI::Responses::ResponseCreateParams::ContextManagement]),
               conversation: T.nilable(T.any(String, OpenAI::Responses::ResponseConversationParam)),
@@ -839,6 +852,99 @@ module OpenAI
         def to_hash
         end
 
+        class AccessPrograms < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseCreateParams::AccessPrograms,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The Cyber access program to use for this request. Supported values are
+          # `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves
+          # the program from the model's Cyber tier and your organization and project
+          # access, subject to model-specific eligibility restrictions. By default, models
+          # without a Cyber tier use Standard. Blue-tier models use Daybreak Blue when
+          # authorized; otherwise they fall back to Standard unless the model requires
+          # Daybreak access. Red-tier models use Daybreak Red and require authorization.
+          # Requests that require unavailable Daybreak access return 403. An implicit
+          # Standard fallback is represented by null in the response's access_programs
+          # field, rather than an explicit Standard selection.
+          sig { returns(T.nilable(OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol)) }
+          attr_reader :cyber
+
+          sig { params(cyber: OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol).void }
+          attr_writer :cyber
+
+          # Domain-specific access programs to use for this request.
+          sig do
+            params(
+
+              cyber: OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The Cyber access program to use for this request. Supported values are
+            # `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves
+            # the program from the model's Cyber tier and your organization and project
+            # access, subject to model-specific eligibility restrictions. By default, models
+            # without a Cyber tier use Standard. Blue-tier models use Daybreak Blue when
+            # authorized; otherwise they fall back to Standard unless the model requires
+            # Daybreak access. Red-tier models use Daybreak Red and require authorization.
+            # Requests that require unavailable Daybreak access return 403. An implicit
+            # Standard fallback is represented by null in the response's access_programs
+            # field, rather than an explicit Standard selection.
+
+            cyber: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {cyber: OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::OrSymbol}
+            )
+          end
+          def to_hash
+          end
+
+          # The Cyber access program to use for this request. Supported values are
+          # `standard`, `daybreak_blue`, and `daybreak_red`. If omitted, the API resolves
+          # the program from the model's Cyber tier and your organization and project
+          # access, subject to model-specific eligibility restrictions. By default, models
+          # without a Cyber tier use Standard. Blue-tier models use Daybreak Blue when
+          # authorized; otherwise they fall back to Standard unless the model requires
+          # Daybreak access. Red-tier models use Daybreak Red and require authorization.
+          # Requests that require unavailable Daybreak access return 403. An implicit
+          # Standard fallback is represented by null in the response's access_programs
+          # field, rather than an explicit Standard selection.
+          module Cyber
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber)
+            }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            STANDARD = T.let(:standard, OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol)
+            DAYBREAK_BLUE = T.let(
+              :daybreak_blue,
+              OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol
+            )
+            DAYBREAK_RED = T.let(
+              :daybreak_red,
+              OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol
+            )
+
+            sig {
+              override.returns(T::Array[OpenAI::Responses::ResponseCreateParams::AccessPrograms::Cyber::TaggedSymbol])
+            }
+            def self.values
+            end
+          end
+        end
+
         class ContextManagement < OpenAI::Internal::Type::BaseModel
           OrHash = T.type_alias do
             T.any(