openai 0.99.0 → 0.101.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7888217212b961954d41ed4bb25d807a08d7155598eac1c384819b35723ab529
-  data.tar.gz: ff4e8f985ffcd57f1aa276cead8dba172a1c686228afd15dd90f0dfa3f440078
+  metadata.gz: 7c9c92914efc09920f412b87f40bd0401a68b41f69fa4ffcaee090cf8ee93959
+  data.tar.gz: af39812b8849fa3bdb1f0f04dd5da8368c45b244ec24c52cfe901e5e22445690
 SHA512:
-  metadata.gz: 4d54994a5e2f72c57ffc898b6bf8ed1ba30745296900d4d6c0c41cde5d88c182f55d8295619140eed845e1741283b0d68704bf92fd4684c2b7a070b91d2c3ae8
-  data.tar.gz: c277185aabed1723fa217caa826ba9df358d40a3ab5018a8ed7a70ff7f13b9c1855543144a9ba8404c3ed95bbb4bdea095802a898878b8bfab6e49dd682939d7
+  metadata.gz: 49f421e6b6fca640e3abbee1028b7df1935c9cc7c79ddecebc6fb50b01e920ca5fc0cbed0b652cc065730b5e6696f0de18367d51e0f4fa0ceec8caee92ccdcf5
+  data.tar.gz: ae6558f4994712ecb02afe85d5961c26657bc48001ad4c8dde460f408b256434cf741a71f60bb17432e3c35d2dca4180d81a8b77ceafdc6831a8117ff7971116

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## [0.101.0](https://github.com/openai/openai-ruby/compare/v0.100.0...v0.101.0) (2026-10-06)
+
+
+### Features
+
+* **api:** add standalone Decisions support ([#811](https://github.com/openai/openai-ruby/issues/811)) ([ab10fa3](https://github.com/openai/openai-ruby/commit/ab10fa3742cde6fe968d13099917c2c6282bd76d))
+
+## [0.100.0](https://github.com/openai/openai-ruby/compare/v0.99.0...v0.100.0) (2026-10-06)
+
+
+### Features
+
+* **agents:** handle local tools during streaming creation ([#805](https://github.com/openai/openai-ruby/issues/805)) ([a961bd6](https://github.com/openai/openai-ruby/commit/a961bd6aea012b8c1d47c84ac6b950142fd45470))
+* **agents:** support tool search (defer_loading=true) in typed function tools ([#809](https://github.com/openai/openai-ruby/issues/809)) ([389fd0b](https://github.com/openai/openai-ruby/commit/389fd0b67186c625fd19a324412ae3166db5a1c6))
+* **api:** add agent turn items and usage source grouping ([#810](https://github.com/openai/openai-ruby/issues/810)) ([606902b](https://github.com/openai/openai-ruby/commit/606902b255cd095fe3530fbe620edfe4b7210ab3))
+
+
+### Bug Fixes
+
+* select the Mantle inference path for GPT-6.1 Sol ([#808](https://github.com/openai/openai-ruby/issues/808)) ([133bea0](https://github.com/openai/openai-ruby/commit/133bea01973fd3e6d195392891e732b2c07cdfd3))
+
+
+### Chores
+
+* **deps-dev:** bump sorbet-runtime from 0.6.13506 to 0.6.13508 in the development-dependencies group ([#804](https://github.com/openai/openai-ruby/issues/804)) ([5bd0b99](https://github.com/openai/openai-ruby/commit/5bd0b99725e29d2646dcfdb5d41b9efba0955f99))
+
 ## [0.99.0](https://github.com/openai/openai-ruby/compare/v0.98.0...v0.99.0) (2026-10-02)
 
 

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.99.0"
+gem "openai", "~> 0.101.0"
 ```
 
 <!-- x-release-please-end -->

data/bedrock.md

@@ -17,7 +17,23 @@ response = client.responses.create(
 puts(response.output_text)
 ```
 
-The provider uses `https://bedrock-mantle.<region>.api.aws/v1` by default and exposes the normal SDK resources. AWS controls which endpoints and features are supported; unsupported calls surface as normal API errors.
+The provider uses `https://bedrock-mantle.<region>.api.aws/v1` by default. AWS documents this route for [GPT OSS](https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-openai-gpt-oss-120b.html), including Responses and Chat Completions, and for model discovery.
+
+When no base URL override is configured, Responses and Chat Completions creation requests whose final structured request body specifies exactly `model: "openai.gpt-6.1-sol"` use `/openai/v1/responses` and `/openai/v1/chat/completions`, respectively, as required by the [GPT-6.1 Sol model card](https://docs.aws.amazon.com/bedrock/latest/userguide/model-card-openai-gpt-6-1-sol.html). **Sol on Mantle requires `region: "us-east-1"`; it is not available in the `us-west-2` region used in the general example above.** String and Ruby symbol model IDs are supported. This selection happens before bearer authentication or SigV4 signing. It does not change the client's base URL or infer routes for other model names.
+
+Calls without a structured model field, including pre-encoded/streaming request bodies and retrieving or deleting a response, use the configured base URL. For Sol response follow-ups, use a client explicitly configured with the Sol API root:
+
+```ruby
+sol_client = OpenAI::Client.new(
+  provider: OpenAI::Providers.bedrock(
+    region: "us-east-1",
+    base_url: "https://bedrock-mantle.us-east-1.api.aws/openai/v1"
+  )
+)
+response = sol_client.responses.retrieve("resp_example")
+```
+
+Explicit `base_url` and `AWS_BEDROCK_BASE_URL` overrides are used as configured for every model. AWS controls which endpoints and features are supported; unsupported calls surface as normal API errors.
 
 ## Bedrock Runtime
 

data/lib/openai/client.rb

@@ -40,6 +40,9 @@ module OpenAI
     # @api private
     attr_reader :workload_identity_auth
 
+    # @return [OpenAI::Resources::Decisions]
+    attr_reader :decisions
+
     # Given a prompt, the model will return one or more predicted completions, and can
     # also return the probabilities of alternative tokens at each position.
     # @return [OpenAI::Resources::Completions]
@@ -195,6 +198,15 @@ module OpenAI
 
     # @api private
     private def build_request(request, options)
+      if @provider_runtime
+        built = super
+        body = built[:body]
+        # Capture only the final model; provider hooks run after body encoding.
+        model = body.reverse_each.find { |key, _| key == :model || key == "model" }&.last if body.is_a?(Hash)
+        model = model.to_s if model.is_a?(Symbol)
+        return built.merge(provider_request_model: model)
+      end
+
       unless @workload_identity_auth && x509_transport?(@requester)
         return super
       end
@@ -803,6 +815,7 @@ module OpenAI
         on_retry: self.on_retry()
       )
 
+      @decisions = OpenAI::Resources::Decisions.new(client: self)
       @completions = OpenAI::Resources::Completions.new(client: self)
       @chat = OpenAI::Resources::Chat.new(client: self)
       @embeddings = OpenAI::Resources::Embeddings.new(client: self)

data/lib/openai/helpers/agents/session_stream.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "tools"
+require_relative "../beta/agents/tool_dispatcher"
 require_relative "../beta/agents/result"
 
 module OpenAI
@@ -19,6 +19,7 @@ module OpenAI
           session_id:,
           input:,
           tool_handlers: {},
+          on_tool_error: nil,
           idempotency_key: nil,
           output_type: nil,
           request_options: {}
@@ -46,7 +47,13 @@ module OpenAI
 
           @options[:extra_headers] = headers
           @recent_events = {}
-          @handled_calls = {}
+          @dispatcher = OpenAI::Helpers::Beta::Agents::ToolDispatcher.new(
+            sessions: sessions,
+            session_id: session_id,
+            tool_handlers: @handlers,
+            on_tool_error: on_tool_error,
+            request_options: @options
+          )
           @closed = false
           session = @sessions.retrieve(@session_id, request_options: @options)
           unless session.status == :idle
@@ -154,12 +161,12 @@ module OpenAI
 
                 terminal = event.type == :"agent.session.failed" ||
                   (event.type == :"agent.session.idle" && @turn_ended)
-                invocation = prepare_call(event) unless terminal
+                invocation = @dispatcher.prepare_call(event) unless terminal
                 close if terminal
                 yielder << event
                 break if terminal || @closed
 
-                dispatch(invocation.call) if invocation
+                @dispatcher.dispatch(invocation.call) if invocation
               end
 
               raise RuntimeError, "Session event stream ended before the turn reached idle or failed" unless @closed
@@ -187,38 +194,6 @@ module OpenAI
           true
         end
 
-        def prepare_call(event)
-          unless event.type == :"agent.session.turn.item.added" &&
-              event.item.is_a?(OpenAI::Models::Beta::AgentFunctionCallItem)
-            return
-          end
-
-          call = event.item
-          key = [call.turn_id.dup, call.call_id.dup]
-          return if @handled_calls.key?(key)
-
-          @handled_calls[key] = true
-          handler = @handlers[call.name]
-          return unless handler
-
-          Tools.prepare(call, handler)
-        end
-
-        def dispatch(result)
-          idempotency_key = SecureRandom.uuid
-          delays = [0.1, 0.3, 0.6]
-          begin
-            @sessions
-              .events
-              .create(@session_id, events: [result], idempotency_key: idempotency_key, request_options: @options)
-          rescue OpenAI::Errors::BadRequestError => error
-            delay = delays.shift
-            raise unless delay && Tools.pending_call_race?(error, result[:call_id])
-
-            sleep(delay)
-            retry
-          end
-        end
       end
     end
   end

data/lib/openai/helpers/agents/tools.rb

@@ -1,25 +1,39 @@
 # frozen_string_literal: true
 
+require_relative "../beta/agents/tool_error"
+
 module OpenAI
   module Helpers
     module Agents
       # @api private
       module Tools
+        # @api private
+        module TypedHandler
+        end
+
         # Capture routing and detached arguments before caller code sees the event,
         # but defer the application callback until iteration resumes after yielding it.
-        def self.prepare(call, handler)
+        def self.prepare(call, handler, session_id:, on_tool_error: nil)
           base = {type: :"agent.session.input.tool_result", turn_id: call.turn_id.dup, call_id: call.call_id.dup}
+          tool_name = call.name.dup
+          arguments_error = nil
           arguments = begin
             JSON.parse(call.arguments.is_a?(String) ? call.arguments : JSON.generate(call.arguments))
-          rescue StandardError
+          rescue StandardError => error
+            arguments_error = error
             nil
           end
 
           lambda do
+            stage = :arguments
             begin
+              raise arguments_error if arguments_error
               raise ArgumentError, "Function arguments must be a JSON object" unless arguments.is_a?(Hash)
 
-              output = handler.call(arguments)
+              stage = :execution
+              report_stage = -> (value) { stage = value } if on_tool_error && handler.is_a?(TypedHandler)
+              output = handler.call(arguments, &report_stage)
+              stage = :output
               output = JSON.generate(output) if output.is_a?(Hash)
               unless output.nil? || output.is_a?(String) || output.is_a?(Array)
                 raise ArgumentError, "Tool output must be a string, object, content array, or nil"
@@ -31,7 +45,23 @@ module OpenAI
               end
 
               base.merge(success: true, output: output)
-            rescue StandardError
+            rescue StandardError => error
+              if on_tool_error
+                failure = OpenAI::Helpers::Beta::Agents::ToolError.new(
+                  error: error,
+                  tool_name: tool_name,
+                  session_id: session_id,
+                  turn_id: base[:turn_id],
+                  call_id: base[:call_id],
+                  stage: stage
+                )
+                begin
+                  on_tool_error.call(failure)
+                rescue StandardError
+                  # Diagnostics must not prevent submission of the original failure.
+                end
+              end
+
               base.merge(success: false, error: "Tool handler failed.")
             end
           end

data/lib/openai/helpers/beta/agents/creation_stream.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "result"
+require_relative "tool_dispatcher"
 
 module OpenAI
   module Helpers
@@ -46,6 +47,22 @@ module OpenAI
             self
           end
 
+          # @api private
+          def configure_tool_handlers(sessions:, tool_handlers:, request_options:)
+            @dispatcher = ToolDispatcher.new(
+              sessions: sessions,
+              tool_handlers: tool_handlers,
+              request_options: request_options
+            )
+            @collector = ResultCollector.new(handler_names: @dispatcher.handler_names)
+            self
+          end
+
+          def close
+            @closed = true
+            super
+          end
+
           private
 
           def iterator
@@ -53,8 +70,17 @@ module OpenAI
             source = super
             @iterator = OpenAI::Internal::Util.chain_fused(source) do |yielder|
               source.each do |event|
+                invocation = nil
+                if @dispatcher && event.is_a?(OpenAI::Internal::Type::BaseModel)
+                  @dispatcher.observe(event)
+                  invocation = @dispatcher.prepare_call(event)
+                end
+
                 @collector.observe(event)
                 yielder << event
+                break if @closed
+
+                @dispatcher.dispatch(invocation.call) if invocation
               end
 
             rescue StandardError => error

data/lib/openai/helpers/beta/agents/function_tool.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "model_adapter"
+require_relative "../../agents/tools"
 
 module OpenAI
   module Helpers
@@ -14,8 +15,9 @@ module OpenAI
           # @param name [String]
           # @param arguments [Class<OpenAI::BaseModel>]
           # @param description [String]
+          # @param defer_loading [Boolean, nil] Load this tool through hosted tool search; nil leaves the setting omitted.
           # @yieldparam arguments [OpenAI::BaseModel]
-          def initialize(name:, arguments:, description: "", &handler)
+          def initialize(name:, arguments:, description: "", defer_loading: nil, &handler)
             ModelAdapter.validate!(arguments, parameter: "arguments")
 
             raise ArgumentError, "a callback is required" unless handler
@@ -29,7 +31,8 @@ module OpenAI
                 type: :function,
                 name: @name,
                 parameters: arguments.to_json_schema,
-                description: description
+                description: description,
+                **(defer_loading.nil? ? {} : {defer_loading: defer_loading})
               )
               .freeze
           end
@@ -40,7 +43,9 @@ module OpenAI
 
           # Pass these local bindings to sessions.stream(tool_handlers: ...).
           # @return [Hash{String=>Proc}]
-          def handlers = {name => method(:call).to_proc}
+          def handlers
+            {name => method(:call).to_proc.extend(OpenAI::Helpers::Agents::Tools::TypedHandler)}
+          end
 
           # Parse using the SDK's BaseModel conventions, then invoke the callback.
           # This is not JSON Schema validation; validate application constraints
@@ -48,6 +53,8 @@ module OpenAI
           # @param arguments [Hash{String=>Object}, String]
           # @return [Object]
           def call(arguments)
+            # The dispatcher supplies this internal stage reporter only when observing errors.
+            yield :arguments if block_given?
             values = JSON.parse(arguments.is_a?(String) ? arguments : JSON.generate(arguments), symbolize_names: true)
             raise ArgumentError, "Tool arguments must be a JSON object" unless values.is_a?(Hash)
             parsed = ModelAdapter.coerce(@arguments, values)
@@ -55,9 +62,9 @@ module OpenAI
               raise ArgumentError, "Tool arguments cannot be parsed into the argument model"
             end
 
+            yield :execution if block_given?
             @handler.call(parsed)
           end
-
         end
       end
     end

data/lib/openai/helpers/beta/agents/tool_dispatcher.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "../../agents/tools"
+
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        # @api private
+        # Shared callback preparation, deduplication, and tool-result submission.
+        class ToolDispatcher
+          def initialize(sessions:, tool_handlers:, request_options:, session_id: nil, on_tool_error: nil)
+            @sessions = sessions
+            @session_id = session_id
+            @handlers = tool_handlers.to_h.dup
+            @on_tool_error = on_tool_error
+            @handled_calls = {}
+            @options = request_options.to_h.dup
+            @options.delete(:idempotency_key)
+            headers = {"OpenAI-Beta" => "agents=v1"}.merge(@options[:extra_headers].to_h)
+            @options[:extra_headers] = headers.reject do |key, _|
+              key.to_s.casecmp?("idempotency-key")
+            end
+          end
+
+          def handler_names = @handlers.keys
+
+          def observe(event)
+            @session_id ||= event.session.id.dup if event.type == :"agent.session.created"
+          end
+
+          def prepare_call(event)
+            unless event.type == :"agent.session.turn.item.added" &&
+                event.item.is_a?(OpenAI::Models::Beta::AgentFunctionCallItem)
+              return
+            end
+
+            call = event.item
+            key = [call.turn_id.dup, call.call_id.dup]
+            return if @handled_calls.key?(key)
+
+            @handled_calls[key] = true
+            handler = @handlers[call.name]
+            return unless handler
+            raise RuntimeError, "Creation stream did not identify a session" unless @session_id
+
+            OpenAI::Helpers::Agents::Tools.prepare(
+              call,
+              handler,
+              session_id: @session_id,
+              on_tool_error: @on_tool_error
+            )
+          end
+
+          def dispatch(result)
+            idempotency_key = SecureRandom.uuid
+            delays = [0.1, 0.3, 0.6]
+            begin
+              @sessions
+                .events
+                .create(@session_id, events: [result], idempotency_key: idempotency_key, request_options: @options)
+            rescue OpenAI::Errors::BadRequestError => error
+              delay = delays.shift
+              raise unless delay && OpenAI::Helpers::Agents::Tools.pending_call_race?(error, result[:call_id])
+
+              sleep(delay)
+              retry
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/openai/helpers/beta/agents/tool_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Helpers
+    module Beta
+      module Agents
+        # Beta, local-only diagnostic delivered to sessions.stream(on_tool_error:).
+        # Use alongside tool_handlers for logging or monitoring argument parsing,
+        # handler execution, and output conversion failures, not API/transport errors.
+        # The original exception may contain sensitive application data.
+        class ToolError
+          attr_reader :error, :tool_name, :session_id, :turn_id, :call_id, :stage
+
+          # @api private
+          def initialize(error:, tool_name:, session_id:, turn_id:, call_id:, stage:)
+            @error = error
+            @tool_name = tool_name.dup.freeze
+            @session_id = session_id.dup.freeze
+            @turn_id = turn_id.dup.freeze
+            @call_id = call_id.dup.freeze
+            @stage = stage
+            freeze
+          end
+        end
+      end
+    end
+  end
+end