activeagent 0.6.3 → 1.0.0.rc1

data/lib/active_agent/providers/open_ai/embedding/request.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "_types"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Embedding
+        class Request < Common::BaseModel
+          # Input text to embed (required)
+          # Can be a string or array of strings or array of token arrays
+          # - Must not exceed max input tokens for the model (8192 for all embedding models)
+          # - Cannot be an empty string
+          # - Arrays must be 2048 dimensions or less
+          # - Maximum of 300,000 tokens summed across all inputs in a single request
+          attribute :input, Requests::InputType.new
+
+          # Model ID (required)
+          attribute :model, :string
+
+          # Number of dimensions for output embeddings (optional)
+          # Only supported in text-embedding-3 and later models
+          attribute :dimensions, :integer
+
+          # Format for returned embeddings (optional)
+          # Can be "float" or "base64"
+          attribute :encoding_format, :string, default: "float"
+
+          # Unique identifier for end-user (optional, deprecated)
+          # Can help OpenAI monitor and detect abuse
+          attribute :user, :string
+
+          # Validations
+          validates :input, :model,   presence: true
+          validates :encoding_format, inclusion: { in: %w[float base64] }, allow_nil: true
+          validates :dimensions,      numericality: { greater_than: 0 },   allow_nil: true
+
+          # Custom validations
+          validate :validate_input_format
+          validate :validate_input_not_empty
+
+          private
+
+          def validate_input_format
+            return if input.nil?
+
+            unless input.is_a?(Array)
+              errors.add(:input, "must be stored as an array internally")
+              return
+            end
+
+            # Validate array contents
+            input.each_with_index do |item, index|
+              case item
+              when String
+                if item.empty?
+                  errors.add(:input, "cannot contain empty strings at index #{index}")
+                end
+              when Array
+                # Token array validation
+                if item.length > 2048
+                  errors.add(:input, "token arrays must be 2048 dimensions or less at index #{index}")
+                end
+                if item.empty?
+                  errors.add(:input, "cannot contain empty token arrays at index #{index}")
+                end
+              else
+                errors.add(:input, "array elements must be strings or token arrays at index #{index}")
+              end
+            end
+          end
+
+          def validate_input_not_empty
+            return if input.nil?
+
+            if input.is_a?(Array) && input.empty?
+              errors.add(:input, "cannot be an empty array")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/embedding/requests/_types.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Embedding
+        module Requests
+          # Custom type for handling embedding input
+          # Can be a string, array of strings, or array of token arrays
+          # Always stores internally as an array for consistency
+          class InputType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when String
+                [ value.presence ].compact
+              when Array
+                value.compact
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Input (expected String or Array)"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Array
+                # Return single string if array has only one string element
+                if value in [ String => string ]
+                  string
+                else
+                  value
+                end
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/options.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      class Options < Common::BaseModel
+        attribute :api_key,         :string
+        attribute :organization,    :string # Organization ID
+        attribute :project,         :string # Project ID ,
+        attribute :webhook_secret,  :string
+        attribute :base_url,        :string
+
+        attribute :max_retries,         :integer, default: ::OpenAI::Client::DEFAULT_MAX_RETRIES
+        attribute :timeout,             :float,   default: ::OpenAI::Client::DEFAULT_TIMEOUT_IN_SECONDS
+        attribute :initial_retry_delay, :float,   default: ::OpenAI::Client::DEFAULT_INITIAL_RETRY_DELAY
+        attribute :max_retry_delay,     :float,   default: ::OpenAI::Client::DEFAULT_MAX_RETRY_DELAY
+
+        validates :api_key, presence: true
+
+        # Backwards Compatibility
+        alias_attribute :host,            :base_url
+        alias_attribute :uri_base,        :base_url
+        alias_attribute :organization_id, :organization
+        alias_attribute :project_id,      :project
+        alias_attribute :access_token,    :api_key
+        alias_attribute :request_timeout, :timeout
+
+        # Initialize from a hash (kwargs) with fallback to environment variables and OpenAI gem configuration
+        def initialize(kwargs = {})
+          kwargs = kwargs.deep_symbolize_keys if kwargs.respond_to?(:deep_symbolize_keys)
+
+          super(**deep_compact(kwargs.except(:default_url_options).merge(
+            api_key:         resolve_api_key(kwargs),
+            organization_id: resolve_organization_id(kwargs),
+            project_id:      resolve_project_id(kwargs),
+          )))
+        end
+
+        def extra_headers
+          {}
+        end
+
+        private
+
+        def resolve_api_key(kwargs)
+          kwargs[:api_key] ||
+            kwargs[:access_token] ||
+            ENV["OPENAI_API_KEY"] ||
+            ENV["OPEN_AI_API_KEY"] ||
+            ENV["OPENAI_ACCESS_TOKEN"] ||
+            ENV["OPEN_AI_ACCESS_TOKEN"]
+        end
+
+        def resolve_organization_id(kwargs)
+          kwargs[:organization] ||
+            kwargs[:organization_id] ||
+            ENV["OPENAI_ORG_ID"] ||
+            ENV["OPEN_AI_ORG_ID"] ||
+            ENV["OPENAI_ORGANIZATION_ID"] ||
+            ENV["OPEN_AI_ORGANIZATION_ID"]
+        end
+
+        def resolve_project_id(kwargs)
+          kwargs[:project] ||
+            kwargs[:project_id]
+            ENV["OPENAI_PROJECT_ID"] ||
+            ENV["OPEN_AI_PROJECT_ID"]
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/_types.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "request"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        # Type for Request model
+        class RequestType < ActiveModel::Type::Value
+          def cast(value)
+            case value
+            when Request
+              value
+            when Hash
+              Request.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to Request"
+            end
+          end
+
+          def serialize(value)
+            case value
+            when Request
+              hash = value.serialize
+
+              if hash[:input] in [ { role: "user", content: String } ]
+                hash[:input] = hash[:input][0][:content]
+              end
+
+              hash
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          def deserialize(value)
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "requests/_types"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        class Request < Common::BaseModel
+          # Background execution
+          attribute :background, :boolean, default: false
+
+          # Conversation
+          attribute :conversation, Requests::ConversationType.new
+
+          # Include additional output data
+          attribute :include, default: -> { [] } # Array of strings
+
+          # Input items (text, image, or file inputs)
+          attribute :input, Requests::Inputs::MessagesType.new
+
+          # Instructions (system/developer message)
+          attribute :instructions, :string
+
+          # Token limits
+          attribute :max_output_tokens, :integer
+          attribute :max_tool_calls, :integer
+
+          # Metadata
+          attribute :metadata # Hash of key-value pairs
+
+          # Model ID
+          attribute :model, :string
+
+          # Parallel tool calls
+          attribute :parallel_tool_calls, :boolean, default: true
+
+          # Previous response ID for multi-turn conversations
+          attribute :previous_response_id, :string
+
+          # Prompt template reference
+          attribute :prompt, Requests::PromptReferenceType.new
+
+          # Cache key for optimization
+          attribute :prompt_cache_key, :string
+
+          # Reasoning configuration (for o-series and gpt-5 models)
+          attribute :reasoning, Requests::ReasoningType.new
+
+          # Safety identifier for usage policy detection
+          attribute :safety_identifier, :string
+
+          # Service tier
+          attribute :service_tier, :string, default: "auto"
+
+          # Storage
+          attribute :store, :boolean, default: true
+
+          # Streaming
+          attribute :stream, :boolean, default: false
+          attribute :stream_options, Requests::StreamOptionsType.new
+
+          # Temperature sampling
+          attribute :temperature, :float, default: 1
+
+          # Text response configuration
+          attribute :text, Requests::TextType.new
+
+          # Tool choice
+          attribute :tool_choice, Requests::ToolChoiceType.new
+
+          # Tools array
+          attribute :tools, Requests::Tools::ToolsType.new
+
+          # Top logprobs
+          attribute :top_logprobs, :integer
+
+          # Top P sampling
+          attribute :top_p, :float, default: 1
+
+          # Truncation strategy
+          attribute :truncation, :string, default: "disabled"
+
+          # User identifier (deprecated, use safety_identifier or prompt_cache_key)
+          attribute :user, :string
+
+          # Validations
+          validates :max_output_tokens, numericality: { greater_than: 0 },                                        allow_nil: true
+          validates :max_tool_calls,    numericality: { greater_than: 0 },                                        allow_nil: true
+          validates :temperature,       numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 2 },  allow_nil: true
+          validates :top_p,             numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 },  allow_nil: true
+          validates :top_logprobs,      numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 20 }, allow_nil: true
+          validates :service_tier,      inclusion: { in: %w[auto default flex priority] },                        allow_nil: true
+          validates :truncation,        inclusion: { in: %w[auto disabled] },                                     allow_nil: true
+
+          validate :validate_conversation_exclusivity
+          validate :validate_metadata_format
+          validate :validate_include_values
+
+          # Common Format Mapping
+          alias_attribute :messages,        :input
+          alias_attribute :message,         :input
+          alias_attribute :response_format, :text
+
+          # Common Format Compatability
+          def instructions=(value)
+            super(value.is_a?(Array) ? value.join("\n") : value)
+          end
+
+          private
+
+          def validate_conversation_exclusivity
+            if conversation.present? && previous_response_id.present?
+              errors.add(:base, "Cannot use both conversation and previous_response_id")
+            end
+          end
+
+          def validate_metadata_format
+            return if metadata.nil?
+
+            unless metadata.is_a?(Hash)
+              errors.add(:metadata, "must be a hash")
+              return
+            end
+
+            metadata.each do |key, value|
+              if key.to_s.length > 64
+                errors.add(:metadata, "keys must be 64 characters or less")
+              end
+              if value.to_s.length > 512
+                errors.add(:metadata, "values must be 512 characters or less")
+              end
+            end
+
+            if metadata.size > 16
+              errors.add(:metadata, "must have 16 key-value pairs or less")
+            end
+          end
+
+          def validate_include_values
+            return if include.nil? || include.empty?
+
+            valid_include_values = [
+              "web_search_call.action.sources",
+              "code_interpreter_call.outputs",
+              "computer_call_output.output.image_url",
+              "file_search_call.results",
+              "message.input_image.image_url",
+              "message.output_text.logprobs",
+              "reasoning.encrypted_content"
+            ]
+
+            invalid_values = include - valid_include_values
+            if invalid_values.any?
+              errors.add(:include, "contains invalid values: #{invalid_values.join(', ')}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/_types.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require_relative "inputs/_types"
+require_relative "tools/_types"
+
+require_relative "conversation"
+require_relative "prompt_reference"
+require_relative "reasoning"
+require_relative "stream_options"
+require_relative "text"
+require_relative "tool_choice"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          class ConversationType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when Conversation
+                value
+              when Hash
+                Conversation.new(**value.symbolize_keys)
+              when String
+                value # Can be a conversation ID string
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Conversation"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Conversation
+                value.serialize
+              when Hash
+                value
+              when String
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          class PromptReferenceType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when PromptReference
+                value
+              when Hash
+                PromptReference.new(**value.symbolize_keys)
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to PromptReference"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when PromptReference
+                value.serialize
+              when Hash
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          class ReasoningType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when Reasoning
+                value
+              when Hash
+                Reasoning.new(**value.symbolize_keys)
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Reasoning"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Reasoning
+                value.serialize
+              when Hash
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          class StreamOptionsType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when StreamOptions
+                value
+              when Hash
+                StreamOptions.new(**value.symbolize_keys)
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to StreamOptions"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when StreamOptions
+                value.serialize
+              when Hash
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          class TextType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when Text
+                value
+              when Hash
+                if value.key?(:json_schema)
+                  Text.new(**value.symbolize_keys.except(:type)) # Prevent Losing the Schema on Format setting
+                else
+                  Text.new(**value.symbolize_keys)
+                end
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Text"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Text
+                value.serialize
+              when Hash
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          class ToolChoiceType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when ToolChoice
+                value
+              when Hash
+                ToolChoice.new(**value.symbolize_keys)
+              when String
+                ToolChoice.new(mode: value)
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to ToolChoice"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when ToolChoice
+                hash = value.serialize
+                # If it's just a mode string, return the string
+                if hash[:mode].present? && hash[:type].blank? && hash[:function].blank? && hash[:custom].blank?
+                  hash[:mode]
+                else
+                  hash
+                end
+              when Hash
+                value
+              when String
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/responses/requests/conversation.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Responses
+        module Requests
+          class Conversation < Common::BaseModel
+            # Conversation ID
+            attribute :id, :string
+
+            # Optional: Store conversation items
+            attribute :store, :boolean
+
+            validates :id, presence: true, if: -> { store.nil? }
+          end
+        end
+      end
+    end
+  end
+end