openai 0.99.0 → 0.100.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7888217212b961954d41ed4bb25d807a08d7155598eac1c384819b35723ab529
-  data.tar.gz: ff4e8f985ffcd57f1aa276cead8dba172a1c686228afd15dd90f0dfa3f440078
+  metadata.gz: f48afd92b1ad4726998649830f3158bae15ba7b60dfdb6388453493ffffcec91
+  data.tar.gz: ad88a01ba827d00dad0f8f05e7d53165a70eae0bf8abdfdf043f0bbcf2ee45b5
 SHA512:
-  metadata.gz: 4d54994a5e2f72c57ffc898b6bf8ed1ba30745296900d4d6c0c41cde5d88c182f55d8295619140eed845e1741283b0d68704bf92fd4684c2b7a070b91d2c3ae8
-  data.tar.gz: c277185aabed1723fa217caa826ba9df358d40a3ab5018a8ed7a70ff7f13b9c1855543144a9ba8404c3ed95bbb4bdea095802a898878b8bfab6e49dd682939d7
+  metadata.gz: 7167c3f0f5586c6da077aad8f7203eb4d5b38b70674927750f61836f856d21553a999791bc0ceae1ea052228c7ce1e9fc49d495da3ee1f151fbb951bcd84465c
+  data.tar.gz: e141202139c857c8e071dfe9c0bb1cb7031fea50a58fda0a601c9b5980b8034babbc73382a573dce97c4ec71cd68cae9d867914d0b7edd97a184b27106d6d54f

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## [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.100.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

@@ -195,6 +195,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

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

data/lib/openai/models/admin/organization/usage_audio_speeches_response.rb

@@ -200,6 +200,21 @@ module OpenAI
                 #   @return [String, nil]
                 optional :api_key_id, String, nil?: true
 
+                # @!attribute api_source
+                #   When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                #   activity and `unlabeled` includes all records without published source
+                #   attribution, including historical and unknown origins. Unlabeled does not imply
+                #   direct API usage. Without source grouping, this field is null.
+                #
+                #   @return [Symbol, OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageCompletionsResult::APISource, nil]
+                optional(
+                  :api_source,
+                  enum: -> {
+                    OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageCompletionsResult::APISource
+                  },
+                  nil?: true
+                )
+
                 # @!attribute batch
                 #   When `group_by=batch`, this field tells whether the grouped usage result is
                 #   batch or not.
@@ -318,7 +333,7 @@ module OpenAI
                 #   @return [String, nil]
                 optional :user_id, String, nil?: true
 
-                # @!method initialize(input_tokens:, num_model_requests:, output_tokens:, api_key_id: nil, batch: nil, input_audio_tokens: nil, input_cache_write_12h_tokens: nil, input_cache_write_tokens: nil, input_cached_audio_tokens: nil, input_cached_image_tokens: nil, input_cached_text_tokens: nil, input_cached_tokens: nil, input_image_tokens: nil, input_text_tokens: nil, input_uncached_tokens: nil, model: nil, output_audio_tokens: nil, output_image_tokens: nil, output_text_tokens: nil, project_id: nil, service_tier: nil, user_id: nil, object: :"organization.usage.completions.result")
+                # @!method initialize(input_tokens:, num_model_requests:, output_tokens:, api_key_id: nil, api_source: nil, batch: nil, input_audio_tokens: nil, input_cache_write_12h_tokens: nil, input_cache_write_tokens: nil, input_cached_audio_tokens: nil, input_cached_image_tokens: nil, input_cached_text_tokens: nil, input_cached_tokens: nil, input_image_tokens: nil, input_text_tokens: nil, input_uncached_tokens: nil, model: nil, output_audio_tokens: nil, output_image_tokens: nil, output_text_tokens: nil, project_id: nil, service_tier: nil, user_id: nil, object: :"organization.usage.completions.result")
                 #   The aggregated completions usage details of the specific time bucket.
                 #
                 #   @param input_tokens [Integer]
@@ -338,6 +353,12 @@ module OpenAI
                 #     When `group_by=api_key_id`, this field provides the API key ID of the grouped
                 #     usage result.
                 #
+                #   @param api_source [Symbol, OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageCompletionsResult::APISource, nil]
+                #     When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                #     activity and `unlabeled` includes all records without published source
+                #     attribution, including historical and unknown origins. Unlabeled does not imply
+                #     direct API usage. Without source grouping, this field is null.
+                #
                 #   @param batch [Boolean, nil]
                 #     When `group_by=batch`, this field tells whether the grouped usage result is
                 #     batch or not.
@@ -403,6 +424,22 @@ module OpenAI
                 #     result.
                 #
                 #   @param object [Symbol, :"organization.usage.completions.result"]
+
+                # When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                # activity and `unlabeled` includes all records without published source
+                # attribution, including historical and unknown origins. Unlabeled does not imply
+                # direct API usage. Without source grouping, this field is null.
+                #
+                # @see OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageCompletionsResult#api_source
+                module APISource
+                  extend OpenAI::Internal::Type::Enum
+
+                  AGENTS_API = :agents_api
+                  UNLABELED = :unlabeled
+
+                  # @!method self.values
+                  #   @return [Array<Symbol>]
+                end
               end
 
               class OrganizationUsageEmbeddingsResult < OpenAI::Internal::Type::BaseModel
@@ -952,6 +989,21 @@ module OpenAI
                 #   @return [String, nil]
                 optional :api_key_id, String, nil?: true
 
+                # @!attribute api_source
+                #   When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                #   activity and `unlabeled` includes all records without published source
+                #   attribution, including historical and unknown origins. Unlabeled does not imply
+                #   direct API usage. Without source grouping, this field is null.
+                #
+                #   @return [Symbol, OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageWebSearchesResult::APISource, nil]
+                optional(
+                  :api_source,
+                  enum: -> {
+                    OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageWebSearchesResult::APISource
+                  },
+                  nil?: true
+                )
+
                 # @!attribute context_level
                 #   When `group_by=context_level`, this field provides the search context size of
                 #   the grouped usage result.
@@ -980,7 +1032,7 @@ module OpenAI
                 #   @return [String, nil]
                 optional :user_id, String, nil?: true
 
-                # @!method initialize(num_model_requests:, num_requests:, api_key_id: nil, context_level: nil, model: nil, project_id: nil, user_id: nil, object: :"organization.usage.web_searches.result")
+                # @!method initialize(num_model_requests:, num_requests:, api_key_id: nil, api_source: nil, context_level: nil, model: nil, project_id: nil, user_id: nil, object: :"organization.usage.web_searches.result")
                 #   The aggregated web search calls usage details of the specific time bucket.
                 #
                 #   @param num_model_requests [Integer]
@@ -993,6 +1045,12 @@ module OpenAI
                 #     When `group_by=api_key_id`, this field provides the API key ID of the grouped
                 #     usage result.
                 #
+                #   @param api_source [Symbol, OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageWebSearchesResult::APISource, nil]
+                #     When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                #     activity and `unlabeled` includes all records without published source
+                #     attribution, including historical and unknown origins. Unlabeled does not imply
+                #     direct API usage. Without source grouping, this field is null.
+                #
                 #   @param context_level [String, nil]
                 #     When `group_by=context_level`, this field provides the search context size of
                 #     the grouped usage result.
@@ -1010,6 +1068,22 @@ module OpenAI
                 #     result.
                 #
                 #   @param object [Symbol, :"organization.usage.web_searches.result"]
+
+                # When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                # activity and `unlabeled` includes all records without published source
+                # attribution, including historical and unknown origins. Unlabeled does not imply
+                # direct API usage. Without source grouping, this field is null.
+                #
+                # @see OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationUsageWebSearchesResult#api_source
+                module APISource
+                  extend OpenAI::Internal::Type::Enum
+
+                  AGENTS_API = :agents_api
+                  UNLABELED = :unlabeled
+
+                  # @!method self.values
+                  #   @return [Array<Symbol>]
+                end
               end
 
               class OrganizationCostsResult < OpenAI::Internal::Type::BaseModel
@@ -1036,6 +1110,21 @@ module OpenAI
                 #   @return [String, nil]
                 optional :api_key_id, String, nil?: true
 
+                # @!attribute api_source
+                #   When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                #   activity and `unlabeled` includes all records without published source
+                #   attribution, including historical and unknown origins. Unlabeled does not imply
+                #   direct API usage. Without source grouping, this field is null.
+                #
+                #   @return [Symbol, OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationCostsResult::APISource, nil]
+                optional(
+                  :api_source,
+                  enum: -> {
+                    OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationCostsResult::APISource
+                  },
+                  nil?: true
+                )
+
                 # @!attribute line_item
                 #   When `group_by=line_item`, this field provides the line item of the grouped
                 #   costs result.
@@ -1070,7 +1159,14 @@ module OpenAI
                   nil?: true
                 )
 
-                # @!method initialize(amount: nil, api_key_id: nil, line_item: nil, project_id: nil, quantity: nil, quantity_unit: nil, object: :"organization.costs.result")
+                # @!attribute user_id
+                #   When `group_by=user_id`, this field provides the user ID of the grouped costs
+                #   result.
+                #
+                #   @return [String, nil]
+                optional :user_id, String, nil?: true
+
+                # @!method initialize(amount: nil, api_key_id: nil, api_source: nil, line_item: nil, project_id: nil, quantity: nil, quantity_unit: nil, user_id: nil, object: :"organization.costs.result")
                 #   The aggregated costs details of the specific time bucket.
                 #
                 #   @param amount [OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationCostsResult::Amount]
@@ -1080,6 +1176,12 @@ module OpenAI
                 #     When `group_by=api_key_id`, this field provides the API Key ID of the grouped
                 #     costs result.
                 #
+                #   @param api_source [Symbol, OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationCostsResult::APISource, nil]
+                #     When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                #     activity and `unlabeled` includes all records without published source
+                #     attribution, including historical and unknown origins. Unlabeled does not imply
+                #     direct API usage. Without source grouping, this field is null.
+                #
                 #   @param line_item [String, nil]
                 #     When `group_by=line_item`, this field provides the line item of the grouped
                 #     costs result.
@@ -1096,6 +1198,10 @@ module OpenAI
                 #     The unit of the `quantity` value. If no single supported unit applies to the
                 #     result, this field is `null`.
                 #
+                #   @param user_id [String, nil]
+                #     When `group_by=user_id`, this field provides the user ID of the grouped costs
+                #     result.
+                #
                 #   @param object [Symbol, :"organization.costs.result"]
 
                 # @see OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationCostsResult#amount
@@ -1121,6 +1227,22 @@ module OpenAI
                   #   @param value [Float]
                   #     The numeric value of the cost.
                 end
+
+                # When grouped by `api_source`, `agents_api` identifies attributed Agents API
+                # activity and `unlabeled` includes all records without published source
+                # attribution, including historical and unknown origins. Unlabeled does not imply
+                # direct API usage. Without source grouping, this field is null.
+                #
+                # @see OpenAI::Models::Admin::Organization::UsageAudioSpeechesResponse::Data::Result::OrganizationCostsResult#api_source
+                module APISource
+                  extend OpenAI::Internal::Type::Enum
+
+                  AGENTS_API = :agents_api
+                  UNLABELED = :unlabeled
+
+                  # @!method self.values
+                  #   @return [Array<Symbol>]
+                end
               end
 
               # @!method self.variants