ruby_llm-responses_api 0.6.1 → 1.0.0

data/lib/ruby_llm/providers/openai_responses/active_record_extension.rb

@@ -3,133 +3,36 @@
 module RubyLLM
   module Providers
     class OpenAIResponses
-      # Extends RubyLLM's ActiveRecord MessageMethods to support response_id persistence
-      # for stateful conversations with the OpenAI Responses API.
-      #
-      # This is automatically applied when Rails loads ActiveRecord.
-      # Just add a migration: add_column :messages, :response_id, :string
-      #
-
-      # Extension for the NEW MessageMethods (RubyLLM 2.0+)
+      # Keep native persistence for tools, usage, attachments and reasoning.
       module MessageMethodsExtension
         def to_llm
-          cached = has_attribute?(:cached_tokens) ? self[:cached_tokens] : nil
-          cache_creation = has_attribute?(:cache_creation_tokens) ? self[:cache_creation_tokens] : nil
-          resp_id = has_attribute?(:response_id) ? self[:response_id] : nil
-
-          RubyLLM::Message.new(
-            role: role.to_sym,
-            content: extract_content,
-            tool_calls: extract_tool_calls,
-            tool_call_id: extract_tool_call_id,
-            input_tokens: input_tokens,
-            output_tokens: output_tokens,
-            cached_tokens: cached,
-            cache_creation_tokens: cache_creation,
-            model_id: model_association&.model_id,
-            response_id: resp_id
-          )
+          message = super
+          message.response_id = self[:response_id] if has_attribute?(:response_id)
+          message
         end
       end
 
-      # Extension for the NEW ChatMethods (RubyLLM 2.0+)
       module ChatMethodsExtension
-        def persist_message_completion(message)
-          super
-          save_response_id(message)
-        end
-
         private
 
-        def save_response_id(message)
-          return unless message
-          return unless message.respond_to?(:response_id) && message.response_id
-          return unless @message.has_attribute?(:response_id)
-
-          @message.update_column(:response_id, message.response_id)
-        end
-      end
-
-      # Extension for LEGACY MessageLegacyMethods (RubyLLM 1.x)
-      module MessageLegacyMethodsExtension
-        def to_llm
-          resp_id = has_attribute?(:response_id) ? self[:response_id] : nil
-
-          RubyLLM::Message.new(
-            role: role.to_sym,
-            content: extract_content,
-            tool_calls: extract_tool_calls,
-            tool_call_id: extract_tool_call_id,
-            input_tokens: input_tokens,
-            output_tokens: output_tokens,
-            model_id: model_id,
-            response_id: resp_id
-          )
+        def message_attributes(message)
+          attributes = super
+          assign_supported_attribute(attributes, :response_id, message.response_id)
+          attributes
         end
       end
 
-      # Extension for LEGACY ChatLegacyMethods (RubyLLM 1.x)
-      module ChatLegacyMethodsExtension
-        def persist_message_completion(message)
-          super
-          save_response_id_legacy(message)
-        end
-
-        private
-
-        def save_response_id_legacy(message)
-          return unless message
-          return unless message.respond_to?(:response_id) && message.response_id
-          return unless @message.has_attribute?(:response_id)
-
-          @message.update_column(:response_id, message.response_id)
-        end
-      end
-
-      @active_record_extensions_applied = false
-
-      # Apply ActiveRecord extensions for response_id persistence.
-      # Called automatically when ActiveRecord loads, or can be called manually.
       def self.apply_active_record_extensions!
-        return if @active_record_extensions_applied
-
-        applied = false
-
-        # Try to apply to NEW modules (RubyLLM 2.0+)
-        begin
-          require 'ruby_llm/active_record/message_methods'
-          require 'ruby_llm/active_record/chat_methods'
-
-          RubyLLM::ActiveRecord::MessageMethods.prepend(MessageMethodsExtension)
-          RubyLLM::ActiveRecord::ChatMethods.prepend(ChatMethodsExtension)
-          applied = true
-        rescue LoadError, NameError
-          # New modules not available
-        end
-
-        # Try to apply to LEGACY modules (RubyLLM 1.x)
-        begin
-          require 'ruby_llm/active_record/acts_as_legacy'
-
-          if defined?(RubyLLM::ActiveRecord::MessageLegacyMethods)
-            RubyLLM::ActiveRecord::MessageLegacyMethods.prepend(MessageLegacyMethodsExtension)
-          end
-
-          if defined?(RubyLLM::ActiveRecord::ChatLegacyMethods)
-            RubyLLM::ActiveRecord::ChatLegacyMethods.prepend(ChatLegacyMethodsExtension)
-          end
-          applied = true
-        rescue LoadError, NameError
-          # Legacy modules not available
-        end
+        require 'ruby_llm/active_record/message_methods'
+        require 'ruby_llm/active_record/chat_methods'
 
-        @active_record_extensions_applied = applied
+        RubyLLM::ActiveRecord::MessageMethods.prepend(MessageMethodsExtension)
+        RubyLLM::ActiveRecord::ChatMethods.prepend(ChatMethodsExtension)
       end
     end
   end
 end
 
-# Auto-apply extensions when ActiveRecord is loaded in Rails
 if defined?(ActiveSupport.on_load)
   ActiveSupport.on_load(:active_record) do
     RubyLLM::Providers::OpenAIResponses.apply_active_record_extensions!

data/lib/ruby_llm/providers/openai_responses/base.rb

@@ -2,13 +2,8 @@
 
 module RubyLLM
   module Providers
-    # OpenAI Responses API provider for RubyLLM.
-    # Implements the new Responses API which provides built-in tools,
-    # stateful conversations, background mode, and MCP support.
-    #
-    # This base file defines the class structure before modules are loaded
-    # to avoid "superclass mismatch" errors.
-    class OpenAIResponses < Provider
+    # OpenAI's native provider with opt-in server-side conversation state.
+    class OpenAIResponses < OpenAI
     end
   end
 end

data/lib/ruby_llm/providers/openai_responses/batch.rb

@@ -10,7 +10,7 @@ module RubyLLM
       # behind a clean Ruby API that mirrors RubyLLM::Chat.
       #
       # @example
-      #   batch = RubyLLM.batch(model: 'gpt-4o', provider: :openai_responses)
+      #   batch = RubyLLM::ResponsesAPI.batch(model: 'gpt-4o', provider: :openai_responses)
       #   batch.add("What is Ruby?")
       #   batch.add("What is Python?", instructions: "Be brief")
       #   batch.create!
@@ -60,8 +60,8 @@ module RubyLLM
         # @param metadata [Hash, nil] Optional metadata for the batch
         # @return [self]
         def create!(metadata: nil)
-          raise Error.new(nil, 'No requests added') if @requests.empty?
-          raise Error.new(nil, 'Batch already created') if @id
+          raise Error, 'No requests added' if @requests.empty?
+          raise Error, 'Batch already created' if @id
 
           jsonl = Batches.build_jsonl(@requests)
           file_id = upload_file(jsonl)
@@ -82,7 +82,7 @@ module RubyLLM
         # Fetch the latest batch status from the API.
         # @return [self]
         def refresh!
-          raise Error.new(nil, 'Batch not yet created') unless @id
+          raise Error, 'Batch not yet created' unless @id
 
           response = @provider.instance_variable_get(:@connection).get(Batches.batch_url(@id))
           @data = response.body
@@ -149,7 +149,7 @@ module RubyLLM
             break if Batches.terminal?(status)
 
             if timeout && (Time.now - start_time) > timeout
-              raise Error.new(nil, "Batch polling timeout after #{timeout} seconds")
+              raise Error, "Batch polling timeout after #{timeout} seconds"
             end
 
             sleep interval
@@ -162,7 +162,7 @@ module RubyLLM
         # @return [Hash<String, Message>] Results keyed by custom_id
         def results
           output_file_id = @data['output_file_id']
-          raise Error.new(nil, 'No output file available yet') unless output_file_id
+          raise Error, 'No output file available yet' unless output_file_id
 
           jsonl = fetch_file_content(output_file_id)
           Batches.parse_results_to_messages(jsonl)
@@ -181,7 +181,7 @@ module RubyLLM
         # Cancel the batch.
         # @return [self]
         def cancel!
-          raise Error.new(nil, 'Batch not yet created') unless @id
+          raise Error, 'Batch not yet created' unless @id
 
           response = @provider.instance_variable_get(:@connection).post(Batches.cancel_batch_url(@id), {})
           @data = response.body
@@ -195,7 +195,7 @@ module RubyLLM
           when Symbol, String
             slug = provider.to_sym
             provider_class = RubyLLM::Provider.providers[slug]
-            raise Error.new(nil, "Unknown provider: #{slug}") unless provider_class
+            raise Error, "Unknown provider: #{slug}" unless provider_class
 
             provider_class.new(RubyLLM.config)
           else

data/lib/ruby_llm/providers/openai_responses/batches.rb

@@ -96,7 +96,7 @@ module RubyLLM
         end
 
         # Parse JSONL output into a Hash of { custom_id => Message }.
-        # Reuses Chat.extract_output_text and Chat.extract_tool_calls to avoid duplication.
+        # Uses the native Responses parser, including reasoning and server tools.
         def parse_results_to_messages(jsonl_string)
           results = parse_results(jsonl_string)
           results.each_with_object({}) do |result, hash|
@@ -104,19 +104,11 @@ module RubyLLM
             response_body = result.dig('response', 'body')
             next unless response_body
 
-            output = response_body['output'] || []
-            content = Chat.extract_output_text(output)
-            tool_calls = Chat.extract_tool_calls(output)
-            usage = response_body['usage'] || {}
-
-            hash[custom_id] = Message.new(
-              role: :assistant,
-              content: content,
-              tool_calls: tool_calls,
-              input_tokens: usage['input_tokens'],
-              output_tokens: usage['output_tokens'],
-              model_id: response_body['model']
-            )
+            next if result.dig('response', 'status_code').to_i >= 400
+
+            raw = Faraday::Response.new(status: result.dig('response', 'status_code') || 200, body: response_body)
+            provider = OpenAIResponses.new(RubyLLM.config)
+            hash[custom_id] = Protocol.new(provider).parse_completion_body(response_body, raw: raw)
           end
         end
 

data/lib/ruby_llm/providers/openai_responses/built_in_tools.rb

@@ -213,7 +213,7 @@ module RubyLLM
 
         # Build a list of {tool_call:, result:} events from the response output.
         # Used to surface server-side built-in tool activity through the standard
-        # on_tool_call / on_tool_result callbacks (issue #1).
+        # before_tool_call / after_tool_result callbacks (issue #1).
         def extract_events(output)
           return [] unless output.is_a?(Array)
 

data/lib/ruby_llm/providers/openai_responses/chat_extension.rb

@@ -3,7 +3,7 @@
 module RubyLLM
   module Providers
     class OpenAIResponses
-      # Extends RubyLLM::Chat to fire on_tool_call / on_tool_result for built-in
+      # Extends RubyLLM::Chat to fire before_tool_call / after_tool_result for built-in
       # server-side tools (web_search, code_interpreter, file_search, etc.)
       # carried on the assistant message. This lets users observe built-in tool
       # activity through the same callback API as locally executed function
@@ -25,19 +25,10 @@ module RubyLLM
 
         def dispatch_built_in_tool_events(message)
           message.built_in_tool_events.each do |event|
-            fire_callback(:before_tool_call, :tool_call, event[:tool_call])
-            fire_callback(:after_tool_result, :tool_result, event[:result])
+            run_callbacks(:before_tool_call, event[:tool_call])
+            run_callbacks(:after_tool_result, event[:result])
           end
         end
-
-        # Mirrors RubyLLM::Chat#run_callbacks (private since 1.13): dispatches
-        # through the new @callbacks array API if present, and always falls
-        # back to the legacy @on hash so older ruby_llm versions still work.
-        def fire_callback(new_name, legacy_name, *args)
-          callbacks = instance_variable_defined?(:@callbacks) ? @callbacks : nil
-          callbacks[new_name]&.each { |cb| cb.call(*args) } if callbacks
-          @on[legacy_name]&.call(*args)
-        end
       end
     end
   end

data/lib/ruby_llm/providers/openai_responses/compaction.rb

@@ -10,7 +10,7 @@ module RubyLLM
 
         # Build context_management parameter for compaction
         # @param compact_threshold [Integer] Token count threshold to trigger compaction (minimum 1000)
-        # @return [Hash] Parameters to merge into request payload via with_params
+        # @return [Hash] Parameters to merge into request payload via with_provider_options
         def compaction_params(compact_threshold: 200_000)
           {
             context_management: [

data/lib/ruby_llm/providers/openai_responses/message_extension.rb

@@ -3,33 +3,23 @@
 module RubyLLM
   module Providers
     class OpenAIResponses
-      # Extends RubyLLM::Message to support response_id for stateful conversations
-      # and built_in_tool_events for server-side tool calls (web_search,
-      # code_interpreter, etc.) that should fire on_tool_call/on_tool_result.
+      # Extra state carried by this provider; native Message fields are preserved.
       module MessageExtension
-        attr_accessor :response_id, :built_in_tool_events
+        attr_accessor :response_id, :built_in_tool_events, :responses_api_body
 
-        def self.included(base)
-          base.class_eval do
-            alias_method :original_initialize, :initialize
-
-            define_method(:initialize) do |options = {}|
-              original_initialize(options)
-              @response_id = options[:response_id]
-              @built_in_tool_events = options[:built_in_tool_events]
-            end
-
-            alias_method :original_to_h, :to_h
+        def initialize(options = {})
+          super
+          @response_id = options[:response_id]
+          @built_in_tool_events = options[:built_in_tool_events]
+          @responses_api_body = options[:responses_api_body]
+        end
 
-            define_method(:to_h) do
-              original_to_h.merge(response_id: response_id).compact
-            end
-          end
+        def to_h
+          response_id ? super.merge(response_id: response_id) : super
         end
       end
     end
   end
 end
 
-# Apply the extension to RubyLLM::Message
-RubyLLM::Message.include(RubyLLM::Providers::OpenAIResponses::MessageExtension)
+RubyLLM::Message.prepend(RubyLLM::Providers::OpenAIResponses::MessageExtension)

data/lib/ruby_llm/providers/openai_responses/model_registry.rb

@@ -3,273 +3,29 @@
 module RubyLLM
   module Providers
     class OpenAIResponses
-      # Registers OpenAI Responses API models with RubyLLM
-      # Models updated May 2026 based on OpenAI documentation
+      # Reuse the current OpenAI catalog rather than maintaining model snapshots.
       module ModelRegistry
-        MODELS = [
-          # ===================
-          # GPT-5.5 Series (Latest flagship - May 2026)
-          # ===================
-          {
-            id: 'gpt-5.5',
-            name: 'GPT-5.5',
-            provider: 'openai_responses',
-            family: 'gpt-5.5',
-            context_window: 1_050_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[
-              streaming function_calling structured_output vision reasoning
-              web_search file_search image_generation code_interpreter shell
-              apply_patch computer_use mcp
-            ]
-          },
+        def by_provider(provider)
+          own = super
+          return own unless provider.to_s == 'openai_responses'
 
-          # ===================
-          # GPT-5.2 Series (Latest flagship - December 2025)
-          # ===================
-          {
-            id: 'gpt-5.2',
-            name: 'GPT-5.2',
-            provider: 'openai_responses',
-            family: 'gpt-5.2',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-
-          # ===================
-          # GPT-5.1 Series (November 2025)
-          # ===================
-          {
-            id: 'gpt-5.1',
-            name: 'GPT-5.1',
-            provider: 'openai_responses',
-            family: 'gpt-5.1',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'gpt-5.1-codex-max',
-            name: 'GPT-5.1 Codex Max',
-            provider: 'openai_responses',
-            family: 'gpt-5.1',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output reasoning web_search]
-          },
-          {
-            id: 'gpt-5.1-codex',
-            name: 'GPT-5.1 Codex',
-            provider: 'openai_responses',
-            family: 'gpt-5.1',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output reasoning]
-          },
-          {
-            id: 'gpt-5.1-codex-mini',
-            name: 'GPT-5.1 Codex Mini',
-            provider: 'openai_responses',
-            family: 'gpt-5.1',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output reasoning]
-          },
-          {
-            id: 'gpt-5.1-chat',
-            name: 'GPT-5.1 Chat',
-            provider: 'openai_responses',
-            family: 'gpt-5.1',
-            context_window: 128_000,
-            max_output_tokens: 16_384,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision]
-          },
-
-          # ===================
-          # GPT-5 Series (August 2025)
-          # ===================
-          {
-            id: 'gpt-5',
-            name: 'GPT-5',
-            provider: 'openai_responses',
-            family: 'gpt-5',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'gpt-5-pro',
-            name: 'GPT-5 Pro',
-            provider: 'openai_responses',
-            family: 'gpt-5',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'gpt-5-mini',
-            name: 'GPT-5 Mini',
-            provider: 'openai_responses',
-            family: 'gpt-5',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'gpt-5-nano',
-            name: 'GPT-5 Nano',
-            provider: 'openai_responses',
-            family: 'gpt-5',
-            context_window: 400_000,
-            max_output_tokens: 128_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning]
-          },
-
-          # ===================
-          # O-Series Reasoning Models
-          # ===================
-          {
-            id: 'o4-mini',
-            name: 'O4 Mini',
-            provider: 'openai_responses',
-            family: 'o4',
-            context_window: 200_000,
-            max_output_tokens: 100_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'o3-pro',
-            name: 'O3 Pro',
-            provider: 'openai_responses',
-            family: 'o3',
-            context_window: 200_000,
-            max_output_tokens: 100_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'o3',
-            name: 'O3',
-            provider: 'openai_responses',
-            family: 'o3',
-            context_window: 200_000,
-            max_output_tokens: 100_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning web_search code_interpreter]
-          },
-          {
-            id: 'o3-mini',
-            name: 'O3 Mini',
-            provider: 'openai_responses',
-            family: 'o3',
-            context_window: 200_000,
-            max_output_tokens: 100_000,
-            modalities: { input: ['text'], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output reasoning]
-          },
-          {
-            id: 'o1',
-            name: 'O1',
-            provider: 'openai_responses',
-            family: 'o1',
-            context_window: 200_000,
-            max_output_tokens: 100_000,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision reasoning]
-          },
-          {
-            id: 'o1-mini',
-            name: 'O1 Mini',
-            provider: 'openai_responses',
-            family: 'o1',
-            context_window: 128_000,
-            max_output_tokens: 65_536,
-            modalities: { input: ['text'], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output reasoning]
-          },
-
-          # ===================
-          # GPT-4.1 Series (Legacy - still supported)
-          # ===================
-          {
-            id: 'gpt-4.1',
-            name: 'GPT-4.1',
-            provider: 'openai_responses',
-            family: 'gpt-4.1',
-            context_window: 1_000_000,
-            max_output_tokens: 32_768,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision web_search code_interpreter]
-          },
-          {
-            id: 'gpt-4.1-mini',
-            name: 'GPT-4.1 Mini',
-            provider: 'openai_responses',
-            family: 'gpt-4.1',
-            context_window: 1_000_000,
-            max_output_tokens: 32_768,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision web_search code_interpreter]
-          },
-          {
-            id: 'gpt-4.1-nano',
-            name: 'GPT-4.1 Nano',
-            provider: 'openai_responses',
-            family: 'gpt-4.1',
-            context_window: 1_000_000,
-            max_output_tokens: 32_768,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision web_search code_interpreter]
-          },
-
-          # ===================
-          # GPT-4o Series (Legacy - still widely used)
-          # ===================
-          {
-            id: 'gpt-4o',
-            name: 'GPT-4o',
-            provider: 'openai_responses',
-            family: 'gpt-4o',
-            context_window: 128_000,
-            max_output_tokens: 16_384,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision web_search code_interpreter]
-          },
-          {
-            id: 'gpt-4o-mini',
-            name: 'GPT-4o Mini',
-            provider: 'openai_responses',
-            family: 'gpt-4o',
-            context_window: 128_000,
-            max_output_tokens: 16_384,
-            modalities: { input: %w[text image], output: ['text'] },
-            capabilities: %w[streaming function_calling structured_output vision web_search code_interpreter]
-          }
-        ].freeze
+          native = super(:openai).all_including_unlisted.map do |source|
+            RubyLLM::Model.new(source.to_h.merge(provider: 'openai_responses'))
+          end
+          self.class.new((own.all_including_unlisted + native).uniq(&:id))
+        end
 
-        module_function
+        def find(model_id, provider: nil, config: nil)
+          super
+        rescue RubyLLM::ModelNotFoundError
+          raise unless provider.to_s == 'openai_responses'
 
-        def register_all!
-          MODELS.each do |model_data|
-            model = RubyLLM::Model::Info.new(model_data)
-            existing = RubyLLM::Models.instance.all.find { |m| m.id == model.id && m.provider == model.provider }
-            RubyLLM::Models.instance.all << model unless existing
-          end
+          source = super(model_id, provider: :openai, config: config)
+          RubyLLM::Model.new(source.to_h.merge(provider: 'openai_responses'))
         end
       end
     end
   end
 end
+
+RubyLLM::Models.prepend(RubyLLM::Providers::OpenAIResponses::ModelRegistry)