activeagent 0.6.3 → 1.0.0.rc1

data/lib/active_agent/providers/anthropic/requests/_types.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require_relative "messages/_types"
+require_relative "thinking_config/_types"
+require_relative "tool_choice/_types"
+require_relative "tool_choice/_types"
+
+require_relative "container_params"
+require_relative "context_management_config"
+require_relative "metadata"
+require_relative "response_format"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        # ActiveModel type for casting and serializing ContainerParams objects.
+        #
+        # Supports string shortcut for container ID: `"container_id"` casts to `{ id: "container_id" }`.
+        class ContainerParamsType < ActiveModel::Type::Value
+          # @param value [ContainerParams, Hash, String, nil]
+          # @return [ContainerParams, nil]
+          # @raise [ArgumentError] when value cannot be cast
+          def cast(value)
+            case value
+            when ContainerParams
+              value
+            when Hash
+              ContainerParams.new(**value.deep_symbolize_keys)
+            when String
+              # Allow string as container ID shortcut
+              ContainerParams.new(id: value)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to ContainerParams"
+            end
+          end
+
+          # @param value [ContainerParams, Hash, nil]
+          # @return [Hash, nil]
+          # @raise [ArgumentError] when value cannot be serialized
+          def serialize(value)
+            case value
+            when ContainerParams
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          # @param value [Object]
+          # @return [ContainerParams, nil]
+          def deserialize(value)
+            cast(value)
+          end
+        end
+
+        # ActiveModel type for casting and serializing ContextManagementConfig objects.
+        class ContextManagementConfigType < ActiveModel::Type::Value
+          # @param value [ContextManagementConfig, Hash, nil]
+          # @return [ContextManagementConfig, nil]
+          # @raise [ArgumentError] when value cannot be cast
+          def cast(value)
+            case value
+            when ContextManagementConfig
+              value
+            when Hash
+              ContextManagementConfig.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to ContextManagementConfig"
+            end
+          end
+
+          # @param value [ContextManagementConfig, Hash, nil]
+          # @return [Hash, nil]
+          # @raise [ArgumentError] when value cannot be serialized
+          def serialize(value)
+            case value
+            when ContextManagementConfig
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          # @param value [Object]
+          # @return [ContextManagementConfig, nil]
+          def deserialize(value)
+            cast(value)
+          end
+        end
+
+        # ActiveModel type for casting and serializing Metadata objects.
+        class MetadataType < ActiveModel::Type::Value
+          # @param value [Metadata, Hash, nil]
+          # @return [Metadata, nil]
+          # @raise [ArgumentError] when value cannot be cast
+          def cast(value)
+            case value
+            when Metadata
+              value
+            when Hash
+              Metadata.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to Metadata"
+            end
+          end
+
+          # @param value [Metadata, Hash, nil]
+          # @return [Hash, nil]
+          # @raise [ArgumentError] when value cannot be serialized
+          def serialize(value)
+            case value
+            when Metadata
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          # @param value [Object]
+          # @return [Metadata, nil]
+          def deserialize(value)
+            cast(value)
+          end
+        end
+
+        # ActiveModel type for casting and serializing ResponseFormat objects.
+        #
+        # @see ResponseFormat
+        class ResponseFormatType < ActiveModel::Type::Value
+          # @param value [ResponseFormat, Hash, nil]
+          # @return [ResponseFormat, nil]
+          # @raise [ArgumentError] when value cannot be cast
+          def cast(value)
+            case value
+            when ResponseFormat
+              value
+            when Hash
+              ResponseFormat.new(**value.deep_symbolize_keys)
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot cast #{value.class} to ResponseFormat"
+            end
+          end
+
+          # @param value [ResponseFormat, Hash, nil]
+          # @return [Hash, nil]
+          # @raise [ArgumentError] when value cannot be serialized
+          def serialize(value)
+            case value
+            when ResponseFormat
+              value.serialize
+            when Hash
+              value
+            when nil
+              nil
+            else
+              raise ArgumentError, "Cannot serialize #{value.class}"
+            end
+          end
+
+          # @param value [Object]
+          # @return [ResponseFormat, nil]
+          def deserialize(value)
+            cast(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/container_params.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        # Container parameters for code execution and skills
+        class ContainerParams < Common::BaseModel
+          attribute :id,     :string
+          attribute :skills, default: -> { [] } # Array of skill specifications
+
+          validates :skills, length: { maximum: 8 }, allow_nil: true
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/content/base.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "sources/_types"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Base class for all content items
+          class Base < Common::BaseModel
+            attribute :type, :string
+
+            validates :type, presence: true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/content/sources/base.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # Base class for all content sources
+            class Base < Common::BaseModel
+              attribute :type, :string
+
+              validates :type, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/context_management_config.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        # Context management configuration
+        class ContextManagementConfig < Common::BaseModel
+          attribute :edits, default: -> { [] } # Array of edit configurations
+
+          validates :edits, presence: true
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/_types.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+# Load required dependencies
+require_relative "base"
+require_relative "user"
+require_relative "assistant"
+require_relative "content/_types"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      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 Base
+                value
+              when String
+                User.new(content: value)
+              when Hash
+                hash = value.deep_symbolize_keys
+                role = hash[:role]&.to_sym
+
+                case role
+                when :user, nil
+                  User.new(**hash)
+                when :assistant
+                  Assistant.new(**hash)
+                else
+                  raise ArgumentError, "Unknown message role: #{role}"
+                end
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Message"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Base
+                hash = value.serialize
+                # Compress single text content to string
+                if hash[:content].is_a?(Array) && hash[:content].one? && hash[:content].first.is_a?(Hash) && hash[:content].first[:type] == "text"
+                  hash[:content] = hash[:content].first[:text]
+                end
+                hash
+              when Hash
+                value
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+          end
+
+          # Type for System content - converts strings to arrays of text blocks
+          class SystemType < ActiveModel::Type::Value
+            def cast(value)
+              case value
+              when Array
+                # Already an array - validate and return
+                value.map { |block| cast_system_block(block) }
+              when String
+                # Convert string to array of text blocks
+                [
+                  {
+                    type: "text",
+                    text: value
+                  }
+                ]
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to System content"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Array
+                serialized = value.map { |block| serialize_system_block(block) }
+                # Compress single text block to string
+                if serialized.one? && serialized.first.is_a?(Hash) && serialized.first[:type] == "text"
+                  serialized.first[:text]
+                else
+                  serialized
+                end
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+
+            def deserialize(value)
+              cast(value)
+            end
+
+            private
+
+            def cast_system_block(value)
+              case value
+              when Content::Base
+                value
+              when String
+                Content::Text.new(text: value)
+              when Hash
+                hash = value.deep_symbolize_keys
+                type = hash[:type]&.to_sym
+
+                case type
+                when :text
+                  Content::Text.new(**hash)
+                else
+                  raise ArgumentError, "Unknown system block type: #{type}"
+                end
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to system block"
+              end
+            end
+
+            def serialize_system_block(value)
+              case value
+              when Content::Base
+                value.serialize
+              when Hash
+                value
+              else
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/assistant.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Messages
+          # Assistant message - messages sent by the model
+          class Assistant < Base
+            attribute :role, :string, as: "assistant"
+
+            # Content can be:
+            # - A string (shorthand for single text block)
+            # - An array of content blocks (text, thinking, tool_use, etc.)
+            validates :content, presence: true
+
+            drop_attributes :usage, :id, :model, :stop_reason, :stop_sequence, :type
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/base.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+require_relative "content/_types"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Messages
+          # Base class for Anthropic messages.
+          #
+          # Provides common message structure and conversion utilities for
+          # Anthropic's message format, including content extraction.
+          class Base < Common::BaseModel
+            attribute :role, :string
+            attribute :content, Content::ContentsType.new
+
+            validates :role, presence: true, inclusion: { in: %w[user assistant] }
+
+            # Define content setter methods for different content types
+            %i[text image document].each do |content_type|
+              define_method(:"#{content_type}=") do |value|
+                self.content ||= []
+                self.content += [ { content_type => value } ]
+              end
+            end
+
+            # Converts to common format.
+            #
+            # @return [Hash] message in canonical format with role and text content
+            def to_common
+              {
+                role: role,
+                content: extract_text_content,
+                name: nil
+              }
+            end
+
+            private
+
+            # Extracts text content from Anthropic's content structure.
+            #
+            # @return [String] extracted text content
+            def extract_text_content
+              case content
+              when String
+                content
+              when Array
+                # Join all text blocks
+                content.select { |block| block.type == "text" }
+                       .map(&:text)
+                       .join("\n")
+              else
+                content.to_s
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/_types.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "text"
+require_relative "image"
+require_relative "document"
+require_relative "tool_use"
+require_relative "tool_result"
+require_relative "thinking"
+require_relative "redacted_thinking"
+require_relative "search_result"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Type for contents array (always an array of content items)
+          class ContentsType < ActiveModel::Type::Value
+            def initialize
+              super
+              @content_type = ContentType.new
+            end
+
+            def cast(value)
+              case value
+              when String
+                # Convert string to array of text content
+                [ Text.new(text: value) ]
+              when Array
+                # Array of content items - cast each item
+                value.map { |item| @content_type.cast(item) }
+              when Hash
+                # Single hash becomes array with one content item
+                [ @content_type.cast(value) ]
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Contents array"
+              end
+            end
+
+            def serialize(value)
+              case value
+              when Array
+                serialized = value.map { |item| @content_type.serialize(item) }
+                # Compress single text item to string
+                if serialized.one? && serialized.first.is_a?(Hash) && serialized.first[:type] == "text"
+                  serialized.first[:text]
+                else
+                  serialized
+                end
+              when nil
+                nil
+              else
+                # Should not happen if cast is working correctly, but handle gracefully
+                raise ArgumentError, "Cannot serialize #{value.class}"
+              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
+                # Already a Content object, return as-is
+                value
+              when Hash
+                hash = value.deep_symbolize_keys
+                type = hash[:type]&.to_sym
+
+                case type
+                when :text
+                  Text.new(**hash)
+                when :image
+                  Image.new(**hash)
+                when :document
+                  Document.new(**hash)
+                when :tool_use
+                  ToolUse.new(**hash)
+                when :tool_result
+                  ToolResult.new(**hash)
+                when :thinking
+                  Thinking.new(**hash)
+                when :redacted_thinking
+                  RedactedThinking.new(**hash)
+                when :search_result
+                  SearchResult.new(**hash)
+                when nil
+                  # No type specified - infer from keys present
+                  if hash.key?(:text)
+                    Text.new(**hash)
+                  elsif hash.key?(:image)
+                    # Move image key under source
+                    Image.new(**hash.merge(source: hash.extract!(:image)))
+                  elsif hash.key?(:document)
+                    # Move document key under source
+                    Document.new(**hash.merge(source: hash.extract!(:document)))
+                  else
+                    raise ArgumentError, "Cannot cast hash without type to Content: #{hash.inspect}"
+                  end
+                else
+                  raise ArgumentError, "Unknown content type: #{type}"
+                end
+              when String
+                # Plain text string becomes text content item
+                Text.new(text: value)
+              when nil
+                nil
+              else
+                raise ArgumentError, "Cannot cast #{value.class} to Content"
+              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