activeagent 1.0.0.rc1 → 1.0.0

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

@@ -1,229 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "messages/_types"
-require_relative "tools/_types"
-
-require_relative "audio"
-require_relative "prediction"
-require_relative "response_format"
-require_relative "stream_options"
-require_relative "tool_choice"
-require_relative "web_search_options"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          # Type for Audio
-          class AudioType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Audio
-                value
-              when Hash
-                Audio.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to Audio"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Audio
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          # Type for Prediction
-          class PredictionType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when Prediction
-                value
-              when Hash
-                Prediction.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to Prediction"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when Prediction
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          # Type for ResponseFormat
-          class ResponseFormatType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when ResponseFormat
-                value
-              when Hash
-                ResponseFormat.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to ResponseFormat"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when ResponseFormat
-                value.serialize
-              when Hash
-                value
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot serialize #{value.class}"
-              end
-            end
-
-            def deserialize(value)
-              cast(value)
-            end
-          end
-
-          # Type for StreamOptions
-          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
-
-          # Type for ToolChoice
-          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[:allowed_tools].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
-
-          # Type for WebSearchOptions
-          class WebSearchOptionsType < ActiveModel::Type::Value
-            def cast(value)
-              case value
-              when WebSearchOptions
-                value
-              when Hash
-                WebSearchOptions.new(**value.symbolize_keys)
-              when nil
-                nil
-              else
-                raise ArgumentError, "Cannot cast #{value.class} to WebSearchOptions"
-              end
-            end
-
-            def serialize(value)
-              case value
-              when WebSearchOptions
-                value.serialize
-              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
-end

data/lib/active_agent/providers/open_ai/chat/requests/audio.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "active_agent/providers/common/model"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          class Audio < Common::BaseModel
-            # Voice to use for audio output
-            attribute :voice, :string
-
-            # Audio format
-            attribute :format, :string
-
-            validates :voice, inclusion: { in: %w[alloy ash ballad coral echo fable nova onyx sage shimmer] }, allow_nil: true
-            validates :format, inclusion: { in: %w[wav mp3 flac opus pcm16] }, allow_nil: true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/open_ai/chat/requests/messages/_types.rb

@@ -1,123 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "content/_types"
-
-# Load all message classes
-require_relative "base"
-require_relative "developer"
-require_relative "system"
-require_relative "user"
-require_relative "assistant"
-require_relative "tool"
-require_relative "function"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          module Messages
-            # Type for Messages array
-            class MessagesType < ActiveModel::Type::Value
-              def initialize
-                super
-                @message_type = MessageType.new
-              end
-
-              def cast(value)
-                case value
-                when Array
-                  value.map { |v| @message_type.cast(v) }
-                when nil
-                  nil
-                else
-                  raise ArgumentError, "Cannot cast #{value.class} to Messages array"
-                end
-              end
-
-              def serialize(value)
-                case value
-                when Array
-                  grouped = []
-
-                  value.each do |message|
-                    if grouped.empty? || grouped.last.role != message.role
-                      grouped << message.deep_dup
-                    else
-                      grouped.last.content += message.content.deep_dup
-                    end
-                  end
-
-                  grouped.map { |v| @message_type.serialize(v) }
-                when nil
-                  nil
-                else
-                  raise ArgumentError, "Cannot serialize #{value.class}"
-                end
-              end
-
-              def deserialize(value)
-                cast(value)
-              end
-            end
-
-            # Type for individual Message
-            class MessageType < ActiveModel::Type::Value
-              def cast(value)
-                case value
-                when ::OpenAI::Models::Chat::ChatCompletionMessage
-                  cast(value.to_h)
-                when Base
-                  value
-                when String
-                  User.new(content: value)
-                when Hash
-                  hash = value.deep_symbolize_keys
-                  role = hash[:role]&.to_sym
-
-                  case role
-                  when :developer
-                    Developer.new(**hash)
-                  when :system
-                    System.new(**hash)
-                  when :user, nil
-                    User.new(**hash)
-                  when :assistant
-                    Assistant.new(**hash)
-                  when :tool
-                    Tool.new(**hash)
-                  when :function
-                    Function.new(**hash)
-                  else
-                    raise ArgumentError, "Unknown message role: #{role.inspect}"
-                  end
-                when nil
-                  nil
-                else
-                  raise ArgumentError, "Cannot cast #{value.class} to Message (expected Base, String, Hash, or nil)"
-                end
-              end
-
-              def serialize(value)
-                case value
-                when Base
-                  value.serialize
-                when Hash
-                  value
-                when nil
-                  nil
-                else
-                  raise ArgumentError, "Cannot serialize #{value.class} as Message"
-                end
-              end
-
-              def deserialize(value)
-                cast(value)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/open_ai/chat/requests/messages/assistant.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "content/_types"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          module Messages
-            # Assistant message - messages sent by the model
-            class Assistant < Base
-              attribute :role, :string, as: "assistant"
-              attribute :content # String, null, or array of content parts
-              attribute :name, :string # Optional name for the participant
-              attribute :audio # Audio response from the model
-              attribute :refusal, :string # Refusal message if the model refused to respond
-              attribute :tool_calls # Array of tool calls the model wants to make
-              attribute :function_call # Deprecated: function call (use tool_calls instead)
-
-              # Assistant messages need content, tool_calls, function_call, or refusal
-              validate :validate_has_response_content
-
-              drop_attributes :annotations, :index
-
-              alias_attribute :text, :content
-
-              private
-
-              def validate_has_response_content
-                if content.nil? && tool_calls.nil? && function_call.nil? && refusal.nil?
-                  errors.add(:base, "must have content, tool_calls, function_call, or refusal")
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/open_ai/chat/requests/messages/base.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require "active_agent/providers/common/model"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          module Messages
-            # Base class for all OpenAI message types.
-            #
-            # Provides common message structure and conversion utilities for
-            # OpenAI's message format, including role mapping and content extraction.
-            class Base < Common::BaseModel
-              attribute :role, :string
-
-              validates :role, presence: true
-
-              # Converts to common format.
-              #
-              # @return [Hash] message in canonical format
-              def to_common
-                {
-                  role: map_role_to_common,
-                  content: extract_text_content,
-                  name: respond_to?(:name) ? name : nil,
-                  tool_call_id: respond_to?(:tool_call_id) ? tool_call_id : nil
-                }.compact
-              end
-
-              private
-
-              # Maps OpenAI roles to canonical roles.
-              #
-              # @return [String] canonical role name
-              def map_role_to_common
-                case role
-                when "developer", "system"
-                  "system"
-                when "user"
-                  "user"
-                when "assistant"
-                  "assistant"
-                when "tool", "function"
-                  "tool"
-                else
-                  role
-                end
-              end
-
-              # Extracts text content from OpenAI's content structure.
-              #
-              # @return [String, nil] extracted text content
-              def extract_text_content
-                return nil unless respond_to?(:content)
-
-                case content
-                when String
-                  content
-                when Array
-                  # Join all text parts
-                  content.select { |part| part.is_a?(Hash) && part["type"] == "text" }
-                         .map { |part| part["text"] }
-                         .join("\n")
-                when nil
-                  nil
-                else
-                  content.to_s
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/open_ai/chat/requests/messages/content/_types.rb

@@ -1,133 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "text"
-require_relative "image"
-require_relative "audio"
-require_relative "file"
-require_relative "refusal"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          module Messages
-            module Content
-              # Type for handling content (string or array of content parts)
-              class ContentsType < ActiveModel::Type::Value
-                def initialize
-                  super
-                  @content_type = ContentType.new
-                end
-
-                def cast(value)
-                  case value
-                  when String
-                    # Plain text string - convert to array with single text content
-                    [ Text.new(text: value) ]
-                  when Array
-                    # Array of content parts - cast each part
-                    value.map { |part| @content_type.cast(part) }
-                  when nil
-                    nil
-                  else
-                    raise ArgumentError, "Cannot cast #{value.class} to Contents (expected String, Array, or nil)"
-                  end
-                end
-
-                def serialize(value)
-                  case value
-                  when String
-                    value
-                  when Array
-                    array = value.map { |part| @content_type.serialize(part) }
-
-                    if array in [ { type: "text", text: String } ]
-                      array.first[:text]
-                    else
-                      array
-                    end
-                  when nil
-                    nil
-                  else
-                    raise ArgumentError, "Cannot serialize #{value.class} as Contents"
-                  end
-                end
-
-                def deserialize(value)
-                  cast(value)
-                end
-              end
-
-              # Type for individual content items
-              class ContentType < ActiveModel::Type::Value
-                def cast(value)
-                  case value
-                  when Base
-                    value
-                  when Hash
-                    hash = value.deep_symbolize_keys
-                    type = hash[:type]&.to_sym
-
-                    case type
-                    when :text
-                      Text.new(**hash)
-                    when :image_url
-                      Image.new(**hash)
-                    when :input_audio
-                      Audio.new(**hash)
-                    when :file
-                      File.new(**hash)
-                    when :refusal
-                      Refusal.new(**hash)
-                    when nil
-                      # When type is nil, check for specific content keys to infer type
-                      if hash.key?(:text)
-                        Text.new(**hash)
-                      elsif hash.key?(:image)
-                        Image.new(**hash.merge(image_url: hash.delete(:image)))
-                      elsif hash.key?(:document)
-                        File.new(**hash.merge(file: hash.delete(:document)))
-                      else
-                        raise ArgumentError, "Cannot determine content type from hash keys: #{hash.keys.inspect}"
-                      end
-                    else
-                      raise ArgumentError, "Unknown content type: #{type.inspect}"
-                    end
-                  when String
-                    # Plain text string becomes text content
-                    Text.new(text: value)
-                  when nil
-                    nil
-                  else
-                    raise ArgumentError, "Cannot cast #{value.class} to Content (expected Base, Hash, String, or nil)"
-                  end
-                end
-
-                def serialize(value)
-                  case value
-                  when Base
-                    value.serialize
-                  when Hash
-                    value
-                  when String
-                    { type: "text", text: value }
-                  when nil
-                    nil
-                  else
-                    raise ArgumentError, "Cannot serialize #{value.class} as Content"
-                  end
-                end
-
-                def deserialize(value)
-                  cast(value)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/open_ai/chat/requests/messages/content/audio.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          module Messages
-            module Content
-              # Audio content part
-              class Audio < Base
-                attribute :type, :string, as: "input_audio"
-                attribute :input_audio, default: -> { {} }
-
-                validates :input_audio, presence: true
-
-                # Nested input_audio object
-                def input_audio=(value)
-                  case value
-                  when Hash
-                    super(value.symbolize_keys)
-                  else
-                    super(value)
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/active_agent/providers/open_ai/chat/requests/messages/content/base.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require "active_agent/providers/common/model"
-
-module ActiveAgent
-  module Providers
-    module OpenAI
-      module Chat
-        module Requests
-          module Messages
-            module Content
-              # Base class for content parts
-              class Base < Common::BaseModel
-                attribute :type, :string
-
-                validates :type, presence: true
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end