openai 0.99.0 → 0.101.0

data/lib/openai/models/responses/responses_server_event.rb

@@ -2258,6 +2258,13 @@ module OpenAI
                 union: -> { OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType }
               )
 
+              # @!attribute review_target
+              #   An opaque target for explicitly continuing this review, or null when
+              #   unavailable.
+              #
+              #   @return [String, nil]
+              optional :review_target, String, nil?: true
+
               # @!attribute steer
               #   An optional public continuation instruction.
               #
@@ -2267,13 +2274,17 @@ module OpenAI
                 -> { OpenAI::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::Steer }
               )
 
-              # @!method initialize(detailed_explanation: nil, error_type: nil, steer: nil)
+              # @!method initialize(detailed_explanation: nil, error_type: nil, review_target: nil, steer: nil)
               #   @param detailed_explanation [String]
               #     The public explanation for this block.
               #
               #   @param error_type [String, Symbol, OpenAI::Models::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::ErrorType]
               #     An optional classification; clients must accept additional values.
               #
+              #   @param review_target [String, nil]
+              #     An opaque target for explicitly continuing this review, or null when
+              #     unavailable.
+              #
               #   @param steer [OpenAI::Models::Responses::ResponsesServerEvent::ResponseWsError::Error::Misalignment::Steer]
               #     An optional public continuation instruction.
 

data/lib/openai/models/responses/tool.rb

@@ -634,9 +634,10 @@ module OpenAI
           optional :background, enum: -> { OpenAI::Responses::Tool::ImageGeneration::Background }
 
           # @!attribute input_fidelity
-          #   Controls fidelity to the original input image(s). This parameter is supported
-          #   for GPT image models that support input fidelity. `gpt-image-2` and
-          #   `gpt-image-2-2026-04-21` ignore this parameter.
+          #   Control how much effort the model will exert to match the style and features,
+          #   especially facial features, of input images. Supports `high` and `low` on
+          #   `gpt-image-1` and `gpt-image-1.5`; `gpt-image-1-mini` supports only `low`. For
+          #   `gpt-image-2`, omit this parameter. Defaults to `low` on supported models.
           #
           #   @return [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::InputFidelity, nil]
           optional(
@@ -732,9 +733,10 @@ module OpenAI
           #     set the output format to `png` or `webp`.
           #
           #   @param input_fidelity [Symbol, OpenAI::Models::Responses::Tool::ImageGeneration::InputFidelity, nil]
-          #     Controls fidelity to the original input image(s). This parameter is supported
-          #     for GPT image models that support input fidelity. `gpt-image-2` and
-          #     `gpt-image-2-2026-04-21` ignore this parameter.
+          #     Control how much effort the model will exert to match the style and features,
+          #     especially facial features, of input images. Supports `high` and `low` on
+          #     `gpt-image-1` and `gpt-image-1.5`; `gpt-image-1-mini` supports only `low`. For
+          #     `gpt-image-2`, omit this parameter. Defaults to `low` on supported models.
           #
           #   @param input_image_mask [OpenAI::Models::Responses::Tool::ImageGeneration::InputImageMask]
           #     Optional mask for inpainting. Contains `image_url` (string, optional) and
@@ -818,9 +820,10 @@ module OpenAI
             #   @return [Array<Symbol>]
           end
 
-          # Controls fidelity to the original input image(s). This parameter is supported
-          # for GPT image models that support input fidelity. `gpt-image-2` and
-          # `gpt-image-2-2026-04-21` ignore this parameter.
+          # Control how much effort the model will exert to match the style and features,
+          # especially facial features, of input images. Supports `high` and `low` on
+          # `gpt-image-1` and `gpt-image-1.5`; `gpt-image-1-mini` supports only `low`. For
+          # `gpt-image-2`, omit this parameter. Defaults to `low` on supported models.
           #
           # @see OpenAI::Models::Responses::Tool::ImageGeneration#input_fidelity
           module InputFidelity

data/lib/openai/models/responses/tool_search_output_namespace_tool.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      class ToolSearchOutputNamespaceTool < OpenAI::Internal::Type::BaseModel
+        # @!attribute description
+        #   A description of the namespace shown to the model.
+        #
+        #   @return [String]
+        required :description, String
+
+        # @!attribute name
+        #   The namespace name used in tool calls (for example, `crm`).
+        #
+        #   @return [String]
+        required :name, String
+
+        # @!attribute tools
+        #   The function/custom tools loaded inside this namespace.
+        #
+        #   @return [Array<OpenAI::Models::Responses::ToolSearchOutputNamespaceTool::Tool::Function, OpenAI::Models::Responses::CustomTool>]
+        required(
+          :tools,
+          -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Responses::ToolSearchOutputNamespaceTool::Tool] }
+        )
+
+        # @!attribute type
+        #   The type of the tool. Always `namespace`.
+        #
+        #   @return [Symbol, :namespace]
+        required :type, const: :namespace
+
+        # @!method initialize(description:, name:, tools:, type: :namespace)
+        #   Groups function/custom tools under a shared namespace.
+        #
+        #   @param description [String]
+        #     A description of the namespace shown to the model.
+        #
+        #   @param name [String]
+        #     The namespace name used in tool calls (for example, `crm`).
+        #
+        #   @param tools [Array<OpenAI::Models::Responses::ToolSearchOutputNamespaceTool::Tool::Function, OpenAI::Models::Responses::CustomTool>]
+        #     The function/custom tools loaded inside this namespace.
+        #
+        #   @param type [Symbol, :namespace]
+        #     The type of the tool. Always `namespace`.
+
+        # A function or custom tool loaded into a namespace by tool search.
+        module Tool
+          extend OpenAI::Internal::Type::Union
+
+          discriminator :type
+
+          variant :function, -> { OpenAI::Responses::ToolSearchOutputNamespaceTool::Tool::Function }
+
+          # A custom tool that processes input using a specified format. Learn more about   [custom tools](https://developers.openai.com/api/docs/guides/function-calling#custom-tools)
+          variant :custom, -> { OpenAI::Responses::CustomTool }
+
+          class Function < OpenAI::Internal::Type::BaseModel
+            # @!attribute name
+            #   The name of the loaded function tool.
+            #
+            #   @return [String]
+            required :name, String
+
+            # @!attribute type
+            #
+            #   @return [Symbol, :function]
+            required :type, const: :function
+
+            # @!attribute allowed_callers
+            #   The tool invocation context(s).
+            #
+            #   @return [Array<Symbol, OpenAI::Models::Responses::ToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller>, nil]
+            optional(
+              :allowed_callers,
+              -> {
+                OpenAI::Internal::Type::ArrayOf[
+                  enum: OpenAI::Responses::ToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller
+                ]
+              },
+              nil?: true
+            )
+
+            # @!attribute async
+            #   Whether the tool response can be returned asynchronously versus immediately
+            #   returned on next response creation.
+            #
+            #   @return [Boolean, nil]
+            optional :async, OpenAI::Internal::Type::Boolean
+
+            # @!attribute defer_loading
+            #   Whether this function should be deferred and discovered via tool search.
+            #
+            #   @return [Boolean, nil]
+            optional :defer_loading, OpenAI::Internal::Type::Boolean
+
+            # @!attribute description
+            #
+            #   @return [String, nil]
+            optional :description, String, nil?: true
+
+            # @!attribute output_schema
+            #   A JSON Schema describing the JSON value encoded in string outputs for this
+            #   function tool. This does not describe content-array outputs.
+            #
+            #   @return [Hash{Symbol=>Object}, nil]
+            optional(
+              :output_schema,
+              OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown],
+              nil?: true
+            )
+
+            # @!attribute parameters
+            #
+            #   @return [Object, nil]
+            optional :parameters, OpenAI::Internal::Type::Unknown, nil?: true
+
+            # @!attribute strict
+            #   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.
+            #
+            #   @return [Boolean, nil]
+            optional :strict, OpenAI::Internal::Type::Boolean, nil?: true
+
+            # @!method initialize(name:, allowed_callers: nil, async: nil, defer_loading: nil, description: nil, output_schema: nil, parameters: nil, strict: nil, type: :function)
+            #   @param name [String]
+            #     The name of the loaded function tool.
+            #
+            #   @param allowed_callers [Array<Symbol, OpenAI::Models::Responses::ToolSearchOutputNamespaceTool::Tool::Function::AllowedCaller>, nil]
+            #     The tool invocation context(s).
+            #
+            #   @param async [Boolean]
+            #     Whether the tool response can be returned asynchronously versus immediately
+            #     returned on next response creation.
+            #
+            #   @param defer_loading [Boolean]
+            #     Whether this function should be deferred and discovered via tool search.
+            #
+            #   @param description [String, nil]
+            #
+            #   @param output_schema [Hash{Symbol=>Object}, nil]
+            #     A JSON Schema describing the JSON value encoded in string outputs for this
+            #     function tool. This does not describe content-array outputs.
+            #
+            #   @param parameters [Object, nil]
+            #
+            #   @param strict [Boolean, nil]
+            #     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.
+            #
+            #   @param type [Symbol, :function]
+
+            module AllowedCaller
+              extend OpenAI::Internal::Type::Enum
+
+              DIRECT = :direct
+              PROGRAMMATIC = :programmatic
+
+              # @!method self.values
+              #   @return [Array<Symbol>]
+            end
+          end
+
+          # @!method self.variants
+          #   @return [Array(OpenAI::Models::Responses::ToolSearchOutputNamespaceTool::Tool::Function, OpenAI::Models::Responses::CustomTool)]
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/video_create_error.rb

@@ -56,19 +56,30 @@ module OpenAI
         #   @return [String, Symbol, OpenAI::Models::VideoCreateError::Misalignment::ErrorType, nil]
         optional :error_type, union: -> { OpenAI::VideoCreateError::Misalignment::ErrorType }
 
+        # @!attribute review_target
+        #   An opaque target for explicitly continuing this review, or null when
+        #   unavailable.
+        #
+        #   @return [String, nil]
+        optional :review_target, String, nil?: true
+
         # @!attribute steer
         #   An optional public continuation instruction.
         #
         #   @return [OpenAI::Models::VideoCreateError::Misalignment::Steer, nil]
         optional :steer, -> { OpenAI::VideoCreateError::Misalignment::Steer }
 
-        # @!method initialize(detailed_explanation: nil, error_type: nil, steer: nil)
+        # @!method initialize(detailed_explanation: nil, error_type: nil, review_target: nil, steer: nil)
         #   @param detailed_explanation [String]
         #     The public explanation for this block.
         #
         #   @param error_type [String, Symbol, OpenAI::Models::VideoCreateError::Misalignment::ErrorType]
         #     An optional classification; clients must accept additional values.
         #
+        #   @param review_target [String, nil]
+        #     An opaque target for explicitly continuing this review, or null when
+        #     unavailable.
+        #
         #   @param steer [OpenAI::Models::VideoCreateError::Misalignment::Steer]
         #     An optional public continuation instruction.
 

data/lib/openai/models.rb

@@ -113,6 +113,18 @@ module OpenAI
 
   CustomToolInputFormat = OpenAI::Models::CustomToolInputFormat
 
+  Decision = OpenAI::Models::Decision
+
+  DecisionCreateParams = OpenAI::Models::DecisionCreateParams
+
+  DecisionInputImage = OpenAI::Models::DecisionInputImage
+
+  DecisionInputMessage = OpenAI::Models::DecisionInputMessage
+
+  DecisionInputPart = OpenAI::Models::DecisionInputPart
+
+  DecisionInputText = OpenAI::Models::DecisionInputText
+
   DeletedSkill = OpenAI::Models::DeletedSkill
 
   Embedding = OpenAI::Models::Embedding

data/lib/openai/providers/bedrock.rb

@@ -90,10 +90,29 @@ module OpenAI
           OpenAI::Internal::Provider::Runtime.new(
             name: name,
             base_url: base_url,
-            prepare_request: auth.method(:prepare_request),
+            prepare_request: lambda do |request|
+              url = request.fetch(:url)
+              # AWS documents a separate inference path for this exact Mantle model.
+              if @base_url.nil? && @endpoint == :mantle && sol_inference_request?(request)
+                url = url.dup
+                url.path = "/openai#{url.path}"
+                request = request.merge(url: url)
+              end
+
+              auth.prepare_request(request)
+            end,
             authentication_headers: AUTH_HEADERS
           )
         end
+
+        private def sol_inference_request?(request)
+          unless request[:method] == :post &&
+              %w[/v1/responses /v1/chat/completions].include?(request.fetch(:url).path)
+            return false
+          end
+
+          request[:provider_request_model] == "openai.gpt-6.1-sol"
+        end
       end
 
       class BearerAuth

data/lib/openai/resources/admin/organization/usage.rb

@@ -196,8 +196,10 @@ module OpenAI
           #
           # @param group_by [Array<Symbol, OpenAI::Models::Admin::Organization::UsageCompletionsParams::GroupBy>]
           #   Group the usage data by the specified fields. Support fields include
-          #   `project_id`, `user_id`, `api_key_id`, `model`, `batch`, `service_tier` or any
-          #   combination of them.
+          #   `project_id`, `user_id`, `api_key_id`, `model`, `batch`, `service_tier`,
+          #   `api_source` or any combination of them. When grouped by `api_source`, results
+          #   use `agents_api` for attributed Agents API activity and `unlabeled` for all
+          #   other activity. Without source grouping, `api_source` is null.
           #
           # @param limit [Integer]
           #   Specifies the number of buckets to return.
@@ -255,8 +257,13 @@ module OpenAI
           #   End time (Unix seconds) of the query time range, exclusive.
           #
           # @param group_by [Array<Symbol, OpenAI::Models::Admin::Organization::UsageCostsParams::GroupBy>]
-          #   Group the costs by the specified fields. Support fields include `project_id`,
-          #   `line_item`, `api_key_id` and any combination of them.
+          #   Group the costs by the specified fields. Supported fields include `project_id`,
+          #   `user_id`, `line_item`, `api_key_id`, and `api_source`. Support for combining
+          #   `user_id` with `project_id` grouping or the `project_ids` filter depends on the
+          #   organization and requested time range. Unsupported combinations return HTTP 400.
+          #   When grouped by `api_source`, results use `agents_api` for attributed Agents API
+          #   activity and `unlabeled` for all other activity. Without source grouping,
+          #   `api_source` is null.
           #
           # @param limit [Integer]
           #   A limit on the number of buckets to be returned. Limit can range between 1 and
@@ -609,8 +616,10 @@ module OpenAI
           #
           # @param group_by [Array<Symbol, OpenAI::Models::Admin::Organization::UsageWebSearchCallsParams::GroupBy>]
           #   Group the usage data by the specified fields. Support fields include
-          #   `project_id`, `user_id`, `api_key_id`, `model`, `context_level` or any
-          #   combination of them.
+          #   `project_id`, `user_id`, `api_key_id`, `model`, `context_level`, `api_source` or
+          #   any combination of them. When grouped by `api_source`, results use `agents_api`
+          #   for attributed Agents API activity and `unlabeled` for all other activity.
+          #   Without source grouping, `api_source` is null.
           #
           # @param limit [Integer]
           #   Specifies the number of buckets to return.

data/lib/openai/resources/beta/agents/environments/templates.rb

@@ -30,8 +30,8 @@ module OpenAI
             #   An optional human-readable display name for the template.
             #
             # @param network [OpenAI::Models::Beta::Agents::Environments::TemplateCreateParams::Network, nil]
-            #   Network access policy for the environment. Defaults to disabled for GA requests
-            #   and enabled for beta requests.
+            #   Network access policy for the environment. If omitted, the API version
+            #   determines whether network access is enabled or disabled.
             #
             # @param packages [OpenAI::Models::Beta::Agents::Environments::TemplateCreateParams::Packages, nil]
             #   Packages to install in the environment. Defaults to empty package lists.
@@ -113,8 +113,7 @@ module OpenAI
             #
             # @param network [OpenAI::Models::Beta::Agents::Environments::TemplateUpdateParams::Network, nil]
             #   Network access available after setup completes. Omit to preserve the current
-            #   policy, or pass `null` to reset to disabled for GA requests or enabled for beta
-            #   requests.
+            #   policy, or pass `null` to reset to the default policy.
             #
             # @param packages [OpenAI::Models::Beta::Agents::Environments::TemplateUpdateParams::Packages, nil]
             #   Packages installed before the runtime network policy applies.

data/lib/openai/resources/beta/agents/sessions/turns/items.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Beta
+      class Agents
+        class Sessions
+          class Turns
+            class Items
+              # Lists items belonging to one root-agent turn, including its interactions with
+              # subagents. See
+              # [inspecting agent output](https://developers.openai.com/api/docs/guides/agents-api/observability).
+              #
+              # @overload list(turn_id, session_id:, after: nil, limit: nil, order: nil, request_options: {})
+              #
+              # @param turn_id [String]
+              #   Path param: The ID of the turn.
+              #
+              # @param session_id [String]
+              #   Path param: The ID of the session that owns the turn.
+              #
+              # @param after [String]
+              #   Query param: Return items after this cursor in the selected order. Pass the
+              #   previous response's last_id, which can differ from the last item's ID.
+              #
+              # @param limit [Integer]
+              #   Query param: The maximum number of resources to return, between 1 and 100.
+              #   Defaults to 20.
+              #
+              # @param order [Symbol, OpenAI::Models::Beta::Agents::Sessions::Turns::ItemListParams::Order]
+              #   Query param: The order in which resources are returned. Defaults to `desc`.
+              #
+              # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+              #
+              # @return [OpenAI::Internal::ConversationCursorPage<OpenAI::Models::Beta::AgentSessionMessage, OpenAI::Models::Beta::AgentReasoningItem, OpenAI::Models::Beta::AgentFunctionCallItem, OpenAI::Models::Beta::AgentSessionItem::FunctionCallOutput, OpenAI::Models::Beta::AgentSessionItem::AgentMessage, OpenAI::Models::Beta::AgentMcpCallItem, OpenAI::Models::Beta::AgentSessionItem::ComputerUseCall, OpenAI::Models::Beta::AgentSessionItem::ComputerUseApprovalRequest, OpenAI::Models::Beta::AgentSessionItem::ComputerUseApprovalRequestResult, OpenAI::Models::Beta::AgentWebSearchCallItem, OpenAI::Models::Beta::AgentCommandExecutionItem, OpenAI::Models::Beta::AgentCreateSubagentCallItem, OpenAI::Models::Beta::AgentSendSubagentInputCallItem, OpenAI::Models::Beta::AgentResumeSubagentCallItem, OpenAI::Models::Beta::AgentWaitForSubagentsCallItem, OpenAI::Models::Beta::AgentInterruptSubagentCallItem, OpenAI::Models::Beta::AgentCloseSubagentCallItem>]
+              #
+              # @see OpenAI::Models::Beta::Agents::Sessions::Turns::ItemListParams
+              def list(turn_id, params)
+                parsed, options = OpenAI::Beta::Agents::Sessions::Turns::ItemListParams.dump_request(params)
+                session_id = parsed.delete(:session_id) do
+                  raise ArgumentError.new("missing required path argument #{_1}")
+                end
+
+                query = OpenAI::Internal::Util.encode_query_params(parsed)
+                @client.request(
+                  method: :get,
+                  path: ["agents/sessions/%1$s/turns/%2$s/items", session_id, turn_id],
+                  query: query,
+                  page: OpenAI::Internal::ConversationCursorPage,
+                  model: OpenAI::Beta::AgentSessionItem,
+                  security: {bearer_auth: true},
+                  options: {extra_headers: {"OpenAI-Beta" => "agents=v1"}, **options}
+                )
+              end
+
+              # @api private
+              #
+              # @param client [OpenAI::Client]
+              def initialize(client:)
+                @client = client
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openai/resources/beta/agents/sessions/turns.rb

@@ -6,6 +6,9 @@ module OpenAI
       class Agents
         class Sessions
           class Turns
+            # @return [OpenAI::Resources::Beta::Agents::Sessions::Turns::Items]
+            attr_reader :items
+
             # Retrieves a turn's current status, timestamps, usage, and error. Returns 404 if
             # the turn does not belong to the session. See
             # [session turns](https://developers.openai.com/api/docs/guides/agents-api/sessions/manage#inspect-session-turns).
@@ -80,6 +83,7 @@ module OpenAI
             # @param client [OpenAI::Client]
             def initialize(client:)
               @client = client
+              @items = OpenAI::Resources::Beta::Agents::Sessions::Turns::Items.new(client: client)
             end
           end
         end

data/lib/openai/resources/beta/agents/sessions.rb

@@ -85,7 +85,7 @@ module OpenAI
           # the session or streams its events when stream is true. See
           # [running sessions](https://developers.openai.com/api/docs/guides/agents-api/sessions).
           #
-          # @overload create_streaming(environment:, agent: nil, agent_id: nil, input: nil, output_type: nil, metadata: nil, vault_ids: nil, request_options: {})
+          # @overload create_streaming(environment:, agent: nil, agent_id: nil, input: nil, output_type: nil, tool_handlers: {}, metadata: nil, vault_ids: nil, request_options: {})
           #
           # @param environment [OpenAI::Models::Beta::EnvironmentParam::None, OpenAI::Models::Beta::EnvironmentParam::OpenAIHosted, OpenAI::Models::Beta::EnvironmentParam::SelfHosted]
           #   An inline execution environment or a reference to an environment template.
@@ -112,6 +112,7 @@ module OpenAI
           #   The IDs of vaults made available to the session.
           #
           # @param output_type [Class<OpenAI::BaseModel>, nil] Beta: configure and parse a structured answer.
+          # @param tool_handlers [Hash{String=>Proc}] Local handlers for initial-turn function calls (not sent to the API).
           #
           # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
           #
@@ -121,6 +122,7 @@ module OpenAI
           def create_streaming(params)
             params = params.to_h.transform_keys { _1.is_a?(String) ? _1.to_sym : _1 }
             output_type = params.delete(:output_type)
+            tool_handlers = params.delete(:tool_handlers)
             parser = OpenAI::Helpers::Beta::Agents::OutputParser.new(output_type) unless output_type.nil?
             parsed, options = OpenAI::Beta::Agents::SessionCreateParams.dump_request(params)
             unless parsed.fetch(:stream, true)
@@ -140,6 +142,10 @@ module OpenAI
               security: {bearer_auth: true},
               options: {extra_headers: {"OpenAI-Beta" => "agents=v1"}, **options}
             )
+            if tool_handlers
+              stream.configure_tool_handlers(sessions: self, tool_handlers: tool_handlers, request_options: options)
+            end
+
             stream.configure_output_parser(parser)
           end
 
@@ -274,17 +280,31 @@ module OpenAI
           # @param session_id [String]
           # @param input [String, Array<OpenAI::Models::Beta::AgentSessionInputMessageParam>]
           # @param tool_handlers [Hash{String=>Proc}]
+          # @param on_tool_error [Proc, nil]
+          #   Beta: use with tool_handlers to log or monitor argument parsing, handler
+          #   execution, and output conversion failures locally. Receives ToolError;
+          #   API/transport errors still propagate normally. Ordinary observer errors
+          #   are ignored, and the submitted tool failure stays generic.
           # @param idempotency_key [String, nil] Applies only to the input submission.
           # @param output_type [Class<OpenAI::BaseModel>, nil] Beta: parse output without changing session configuration.
           # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
           # @yieldparam stream [OpenAI::Helpers::Agents::SessionStream]
           # @return [OpenAI::Helpers::Agents::SessionStream]
-          def stream(session_id, input:, tool_handlers: {}, idempotency_key: nil, output_type: nil, request_options: {})
+          def stream(
+            session_id,
+            input:,
+            tool_handlers: {},
+            on_tool_error: nil,
+            idempotency_key: nil,
+            output_type: nil,
+            request_options: {}
+          )
             stream = OpenAI::Helpers::Agents::SessionStream.new(
               sessions: self,
               session_id: session_id,
               input: input,
               tool_handlers: tool_handlers,
+              on_tool_error: on_tool_error,
               idempotency_key: idempotency_key,
               output_type: output_type,
               request_options: request_options

data/lib/openai/resources/decisions.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Decisions
+      # Evaluate ordered classification and scoring questions against shared input.
+      # Answers are returned in question order.
+      #
+      # Supply input as a string or user messages containing text and inline images.
+      # Only user messages with `input_text` and `input_image` parts are supported;
+      # non-user roles, function calls, files, audio, and item references are not
+      # supported. Images require a data URL, not an external URL or file ID. At most
+      # 128 images are allowed across the request.
+      #
+      # Each question can return a refusal instead of a scored answer. A refusal has
+      # type `refusal` and the corresponding question name, or null if unnamed.
+      #
+      # @overload create(input:, model:, questions:, safety_identifier: nil, request_options: {})
+      #
+      # @param input [String, Array<OpenAI::Models::DecisionInputMessage>]
+      #   Shared evidence, as a string or an array of user messages containing text and
+      #   inline images. Non-user roles, function calls, function-call outputs, files,
+      #   audio, and item references are not supported. At most 128 image parts are
+      #   allowed across all messages in one request.
+      #
+      # @param model [String]
+      #
+      # @param questions [Array<OpenAI::Models::DecisionCreateParams::Question::Predicate, OpenAI::Models::DecisionCreateParams::Question::Choice, OpenAI::Models::DecisionCreateParams::Question::Score>]
+      #
+      # @param safety_identifier [String, nil]
+      #   Opaque caller-provided end-user identifier, scoped by the verified org. Match
+      #   Responses' limit; this is never the authenticated user identity.
+      #
+      # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [OpenAI::Models::Decision]
+      #
+      # @see OpenAI::Models::DecisionCreateParams
+      def create(params)
+        parsed, options = OpenAI::DecisionCreateParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "decisions",
+          body: parsed,
+          model: OpenAI::Decision,
+          security: {bearer_auth: true},
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [OpenAI::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/openai/resources/fine_tuning/jobs.rb

@@ -141,8 +141,13 @@ module OpenAI
         #   Number of fine-tuning jobs to retrieve.
         #
         # @param metadata [Hash{Symbol=>String}, nil]
-        #   Optional metadata filter. To filter, use the syntax `metadata[k]=v`.
-        #   Alternatively, set `metadata=null` to indicate no metadata.
+        #   Optional metadata filter. To filter, use the syntax `metadata[k]=v`. Omitting
+        #   the parameter or passing an empty object applies no metadata filter. An empty
+        #   value, such as `metadata[k]=`, filters for that key with an empty string value.
+        #   To select jobs with null metadata, send the literal query string
+        #   `metadata=null`. Nullable caller types do not specify how a client serializes
+        #   null for a deep-object parameter. Use a raw query parameter if the client omits
+        #   null. Do not combine the two query forms.
         #
         # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
         #