activeagent 0.6.3 → 1.0.0.rc1

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

@@ -0,0 +1,123 @@
+# 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

@@ -0,0 +1,42 @@
+# 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

@@ -0,0 +1,78 @@
+# 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

@@ -0,0 +1,133 @@
+# 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

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "files/_types"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Chat
+        module Requests
+          module Messages
+            module Content
+              # File content part
+              class File < Base
+                attribute :type, :string, as: "file"
+                attribute :file, Files::DetailsType.new
+
+                validates :file, presence: true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "details"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Chat
+        module Requests
+          module Messages
+            module Content
+              module Files
+                # Type for the nested file object
+                class DetailsType < ActiveModel::Type::Value
+                  def cast(value)
+                    case value
+                    when Details
+                      value
+                    when Hash
+                      Details.new(**value.deep_symbolize_keys)
+                    when String
+                      if value.start_with?("data:")
+                        Details.new(file_data: value)
+                      elsif value.match?(%r{\Ahttps?://})
+                        raise ArgumentError, "HTTP/S URLs are not supported. Use a base64 data instead"
+                      else
+                        Details.new(file_data: value)
+                      end
+                    when nil
+                      nil
+                    else
+                      raise ArgumentError, "Cannot cast #{value.class} to File::Details"
+                    end
+                  end
+
+                  def serialize(value)
+                    case value
+                    when Details
+                      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
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Chat
+        module Requests
+          module Messages
+            module Content
+              module Files
+                # Represents the nested file object within File content part
+                class Details < Common::BaseModel
+                  # The base64 encoded file data, used when passing the file to the model as a string
+                  attribute :file_data, :string
+
+                  # The ID of an uploaded file to use as input
+                  attribute :file_id, :string
+
+                  # The name of the file, used when passing the file to the model as a string
+                  attribute :filename, :string
+
+                  # Override serialize to strip data URI prefix from file_data
+                  def file_data=(value)
+                    # Strip data URI prefix from file_data if present
+                    if value&.match?(/\Adata:[^;]+;base64,/)
+                      value = value.sub(/\Adata:[^;]+;base64,/, "")
+                    end
+
+                    super(value)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Chat
+        module Requests
+          module Messages
+            module Content
+              # Refusal content part (used in assistant messages)
+              class Refusal < Base
+                attribute :type, :string, as: "refusal"
+                attribute :refusal, :string
+
+                validates :refusal, presence: true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Chat
+        module Requests
+          module Messages
+            module Content
+              # Text content part
+              class Text < Base
+                attribute :type, :string, as: "text"
+                attribute :text, :string
+
+                validates :text, presence: true
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "content/_types"
+
+module ActiveAgent
+  module Providers
+    module OpenAI
+      module Chat
+        module Requests
+          module Messages
+            # Developer message - instructions that the model should follow (o1 models and newer)
+            class Developer < Base
+              attribute :role, :string, as: "developer"
+              attribute :content, Content::ContentsType.new # String or array of content parts
+              attribute :name, :string # Optional name for the participant
+
+              validates :content, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end