[WIP] Boil the Ocean - OpenAI Stabilized (Native Format)

Author: sirwolfgang

lib/active_agent/providers/common/_base_model.rb

@@ -68,7 +68,11 @@ def self.attribute(name, type = nil, **options)
             required_attributes << name.to_s
 
             define_method("#{name}=") do |value|
-              next if value == default_value
+              normalized_value   = value.is_a?(String)         ? value.to_sym         : value
+              normalized_default = default_value.is_a?(String) ? default_value.to_sym : default_value
+
+              next if normalized_value == normalized_default
+
               raise ArgumentError, "Cannot set '#{name}' attribute (read-only with default value)"
             end
           else
@@ -112,16 +116,15 @@ def self.keys
         #
         # Settings can be provided as a hash or keyword arguments. Hash keys are
         # sorted to prioritize nested objects during initialization for backwards compatibility.
-        #
-        # @param hash [Hash, nil] attribute hash
-        # @param kwargs [Hash] attribute keyword arguments
-        def initialize(hash = nil, **kwargs)
-          settings = hash || kwargs
+        def initialize(kwargs = {})
+          # To allow us to get a list of attribute defaults without initialized overrides
+          return super(nil) if kwargs.key?(:'__default_values')
+
           # Backwards Compatibility: This sorts object construction to the top to protect the assignment
           #   of backward compatibility assignments.
-          settings = settings.sort_by { |k, v| v.is_a?(Hash) ? 0 : 1 }.to_h if settings.is_a?(Hash)
+          kwargs = kwargs.sort_by { |k, v| v.is_a?(Hash) ? 0 : 1 }.to_h if kwargs.is_a?(Hash)
 
-          super(settings)
+          super(kwargs)
         end
 
         # Merges the given attributes into the current instance.
@@ -131,8 +134,8 @@ def initialize(hash = nil, **kwargs)
         # @param hash [Hash, nil] attribute hash to merge
         # @param kwargs [Hash] attribute keyword arguments to merge
         # @return [BaseModel] self for method chaining
-        def merge!(hash = nil, **kwargs)
-          (hash || kwargs).deep_symbolize_keys.each do |key, value|
+        def merge!(kwargs = {})
+          kwargs.deep_symbolize_keys.each do |key, value|
             public_send("#{key}=", value) if respond_to?("#{key}=")
           end
 
@@ -213,7 +216,7 @@ def to_hash
         #   message.to_hash_compressed
         #   #=> { role: "user" }  # content omitted (matches default), role included (required)
         def to_hash_compressed
-          default_values = self.class.new.attributes
+          default_values = self.class.new(__default_values: true).attributes
           required_attrs = self.class.required_attributes
 
           deep_compact(attribute_names.each_with_object({}) do |name, hash|

lib/active_agent/providers/open_ai/_base_provider.rb

@@ -8,11 +8,14 @@ module ActiveAgent
   module Providers
     module OpenAI
       class BaseProvider < ActiveAgent::Providers::BaseProvider
-        attr_internal :stream_callback, :function_callback
+        attr_internal :request, :message_stack,
+                      :stream_callback, :stream_finished,
+                      :function_callback
 
         def initialize(kwargs = {})
           self.stream_callback   = kwargs.delete(:stream_callback)
           self.function_callback = kwargs.delete(:function_callback)
+          self.message_stack     = []
 
           super(kwargs)
         end
@@ -36,11 +39,42 @@ def service_name = "OpenAI"
         # @return [Class] The Options class for the specific provider, e.g., Anthropic::Options
         def options_type = OpenAI::Options
 
+        # @return response [ActiveAgent::Providers::Response]
+        def resolve_prompt
+          # Apply Tool/Function Messages and Reset Processing Buffer
+          self.request.messages = [ *request.messages, *message_stack ]
+          self.message_stack    = []
+          # @todo Validate Request
+
+          ## Prepare Executation Environment
+          parameters = request.to_hc
+          if request.stream
+            parameters[:stream]  = process_stream
+            self.stream_finished = false
+          end
+
+          ## Execute
+          api_response = client_request_create(parameters:)
+          process_finished(api_response.presence&.deep_symbolize_keys)
+        end
+
+        def client_request_create(parameters:)
+          fail(NotImplementedError)
+        end
+
         def process_stream
           proc do |api_response_chunk|
             process_stream_chunk(api_response_chunk.deep_symbolize_keys)
           end
         end
+
+        # @return result [Unknown]
+        def process_tool_call_function(api_function_call)
+          name   = api_function_call[:name]
+          kwargs = JSON.parse(api_function_call[:arguments], symbolize_names: true) if api_function_call[:arguments]
+
+          function_callback.call(name, **kwargs)
+        end
       end
     end
   end

lib/active_agent/providers/open_ai/chat_provider.rb

@@ -5,34 +5,16 @@ module ActiveAgent
   module Providers
     module OpenAI
       class ChatProvider < BaseProvider
-        attr_internal :request, :message_stack, :stream_finished
-
         def initialize(...)
           super
 
-          self.request       = Chat::Request.new(context)
-          self.message_stack = []
+          self.request = Chat::Request.new(context)
         end
 
         protected
 
-        # @return response [ActiveAgent::Providers::Response]
-        def resolve_prompt
-          # Apply Tool/Function Messages
-          request.messages = message_stack unless message_stack.empty?
-          # @todo Validate Request
-
-          ## Prepare Executation Environment
-          parameters = request.to_hc
-          if request.stream
-            parameters[:stream]  = process_stream
-            self.stream_finished = false
-          end
-          message_stack.replace(parameters[:messages])
-
-          ## Execute
-          api_response = client.chat(parameters:)
-          process_finished(api_response.presence&.deep_symbolize_keys)
+        def client_request_create(parameters:)
+          client.chat(parameters:)
         end
 
         # @return void
@@ -72,19 +54,15 @@ def process_tool_calls(api_tool_calls)
               fail "Unexpected Tool Call Type: #{api_tool_call[:type]}"
             end
 
-            message = Chat::Requests::Messages::Tool.new(tool_call_id: api_tool_call[:id], content: content.to_json)
+            message = Chat::Requests::Messages::Tool.new(
+              tool_call_id: api_tool_call[:id],
+              content: content.to_json
+            )
+
             message_stack.push(message.to_hc)
           end
         end
 
-        # @return result [Unknown]
-        def process_tool_call_function(api_function_call)
-          name   = api_function_call[:name]
-          kwargs = JSON.parse(api_function_call[:arguments], symbolize_names: true) if api_function_call[:arguments]
-
-          function_callback.call(name, **kwargs)
-        end
-
         # @return response [ActiveAgent::Providers::Response]
         def process_finished(api_response = nil)
           if (api_message = api_response&.dig(:choices, 0, :message))
@@ -104,16 +82,6 @@ def process_finished(api_response = nil)
           end
         end
 
-        # ActiveAgent::ActionPrompt::Message.new(
-        #     generation_id:     api_message[:id] || api_response[:id],
-        #     content:           api_message[:content],
-        #     role:              api_message[:role].intern,
-        #     action_requested:  api_message[:finish_reason] == "tool_calls",
-        #     raw_actions:       api_message[:tool_calls] || [],
-        #     requested_actions: handle_actions(api_message[:tool_calls]),
-        #     content_type:      context[:output_schema].present? ? "application/json" : "text/plain"
-        # )
-
         # def embeddings_response(response, request_params = nil)
         #   message = ActiveAgent::ActionPrompt::Message.new(content: response.dig("data", 0, "embedding"), role: "assistant")
 

lib/active_agent/providers/open_ai/responses/request.rb

@@ -143,40 +143,21 @@ def input=(value)
           def input
             value = super
 
-            if value && value.one? && value.first.is_a?(Requests::Inputs::UserMessage)
+            if value && value.one? && value.first.is_a?(Requests::Inputs::UserMessage) && value.first.content.is_a?(String)
               value.first.content
             else
               value
             end
           end
 
+
           # For the message stack
-          def input_list
+          def messages
             attributes["input"]&.map { |it| it.to_h }
           end
 
-          # To handle Common Message [input] format
-          def message=(value)
-            case value.try(:role) || value[:role]
-            when :system
-              self.instructions = value.try(:content) || value[:content]
-            when :user
-              self.input        = value.try(:content) || value[:content]
-            end
-
-            # self.input = [
-            #   {
-            #     role:    value.role,
-            #     content: message_content(value.content)
-            #   }
-            # ]
-          end
-
-          # To handle Common Messages [input] format
-          def messages=(value)
-            value.each do |message|
-              self.message = message
-            end
+          def messages=(values)
+            self.input = values
           end
 
           private

lib/active_agent/providers/open_ai/responses/requests/input.rb

@@ -3,8 +3,12 @@
 require_relative "inputs/base"
 require_relative "inputs/user_message"
 require_relative "inputs/system_message"
+require_relative "inputs/developer_message"
 require_relative "inputs/assistant_message"
 require_relative "inputs/tool_message"
+require_relative "inputs/function_call_output"
+require_relative "inputs/reasoning"
+require_relative "inputs/item_reference"
 require_relative "inputs/content_parts/base"
 require_relative "inputs/content_parts/input_text"
 require_relative "inputs/content_parts/input_image"

lib/active_agent/providers/open_ai/responses/requests/inputs/base.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../../../../common/_base_model"
+require_relative "../types"
 
 module ActiveAgent
   module Providers
@@ -11,12 +12,20 @@ module Inputs
             # Base class for input items in Responses API
             class Base < Common::BaseModel
               attribute :role, :string
-              attribute :content # Can be string or array of content parts
+              attribute :content, Types::ContentType.new
 
               validates :role, inclusion: {
-                in: %w[system user assistant tool],
+                in: %w[system user assistant developer tool],
                 allow_nil: true
               }
+
+              def to_hc
+                super.tap do |hash|
+                  if content.is_a?(Array) && content.one? && content.first.type == "input_text"
+                    hash[:content] = content.first.text
+                  end
+                end
+              end
             end
           end
         end

lib/active_agent/providers/open_ai/responses/requests/inputs/content_parts/input_audio.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            module ContentParts
+              # Audio content part
+              class InputAudio < Base
+                attribute :type, :string, as: "input_audio"
+                attribute :input_audio # Object containing audio properties
+
+                validates :type, presence: true
+                validates :input_audio, presence: true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/active_agent/providers/open_ai/responses/requests/inputs/content_parts/input_file.rb

@@ -12,11 +12,12 @@ module ContentParts
               # File content part
               class InputFile < Base
                 attribute :type, :string, as: "input_file"
-                attribute :filename, :string
-                attribute :file_data, :string # Base64 encoded file data
+                attribute :file_data, :string # Optional: content of file to send
+                attribute :file_id, :string # Optional: ID of file to send
+                attribute :file_url, :string # Optional: URL of file to send
+                attribute :filename, :string # Optional: name of file
 
-                validates :filename, presence: true
-                validates :file_data, presence: true
+                validates :type, presence: true
               end
             end
           end

lib/active_agent/providers/open_ai/responses/requests/inputs/content_parts/input_image.rb

@@ -12,9 +12,12 @@ module ContentParts
               # Image content part
               class InputImage < Base
                 attribute :type, :string, as: "input_image"
-                attribute :image_url # Can be string (URL or data URI) or object with url and detail
+                attribute :detail, :string, default: "auto" # One of: high, low, auto
+                attribute :file_id, :string # Optional: ID of file to send
+                attribute :image_url, :string # Optional: URL or base64 data URL
 
-                validates :image_url, presence: true
+                validates :type, presence: true
+                validates :detail, presence: true
               end
             end
           end

lib/active_agent/providers/open_ai/responses/requests/inputs/developer_message.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          module Inputs
+            # Developer message input (higher priority than system)
+            class DeveloperMessage < Base
+              attribute :role, :string, as: "developer"
+            end
+          end
+        end
+      end
+    end
+  end
+end