activeagent 0.6.3 → 1.0.0.rc1

data/lib/active_agent/providers/anthropic/requests/messages/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/messages/content/document.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "sources/_types"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Document content block
+          class Document < Base
+            attribute :type, :string, as: "document"
+            attribute :source, Sources::SourceType.new # Can be base64, text, url, or file
+            attribute :title, :string # Optional title
+            attribute :context, :string # Optional context
+            attribute :citations # Optional citations config
+            attribute :cache_control # Optional cache control
+
+            validates :source, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "sources/_types"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Image content block
+          class Image < Base
+            attribute :type, :string, as: "image"
+            attribute :source, Sources::SourceType.new # Can be base64, url, or file
+            attribute :cache_control # Optional cache control
+
+            validates :source, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Redacted thinking content block
+          class RedactedThinking < Base
+            attribute :type, :string, as: "redacted_thinking"
+            attribute :data, :string
+
+            validates :data, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Search result content block
+          class SearchResult < Base
+            attribute :type, :string, as: "search_result"
+            attribute :source, :string
+            attribute :title, :string
+            attribute :content # Array of text blocks
+            attribute :citations # Optional citations config
+            attribute :cache_control # Optional cache control
+
+            validates :source, presence: true
+            validates :title, presence: true
+            validates :content, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "document_base64"
+require_relative "document_file"
+require_relative "document_text"
+require_relative "document_url"
+require_relative "image_base64"
+require_relative "image_file"
+require_relative "image_url"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # Type for source objects (image/document sources)
+            class SourceType < ActiveModel::Type::Value
+              def cast(value)
+                case value
+                when Base
+                  # Already a Source object, return as-is
+                  value
+                when Hash
+                  hash = value.deep_symbolize_keys
+                  type = hash[:type]&.to_sym
+
+                  case type
+                  when :base64
+                    # Determine if it's image or document based on media_type or context
+                    media_type = hash[:media_type]&.to_s
+                    if media_type&.start_with?("image/")
+                      ImageBase64.new(**hash)
+                    else
+                      DocumentBase64.new(**hash)
+                    end
+                  when :url
+                    # Could be either - default to image for now
+                    # Callers can be more specific by passing the right class
+                    ImageURL.new(**hash)
+                  when :file
+                    # Could be either - default to image for now
+                    ImageFile.new(**hash)
+                  when :text
+                    DocumentText.new(**hash)
+                  when nil
+                    # No type specified - try to infer
+                    infer_source_from_hash(hash)
+                  else
+                    raise ArgumentError, "Unknown source type: #{type}"
+                  end
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot cast #{value.class} to Source"
+                end
+              end
+
+              def serialize(value)
+                case value
+                when Base
+                  value.serialize
+                when Hash
+                  value
+                when nil
+                  nil
+                else
+                  raise ArgumentError, "Cannot serialize #{value.class}"
+                end
+              end
+
+              def deserialize(value)
+                cast(value)
+              end
+
+              private
+
+              def infer_source_from_hash(hash)
+                if hash.key?(:image)
+                  # Handle image key - detect URI or base64 data URI
+                  cast_image_source(hash[:image], hash)
+                elsif hash.key?(:document)
+                  # Handle document key - detect URI or base64 data URI
+                  cast_document_source(hash[:document], hash)
+                elsif hash.key?(:data) && hash.key?(:media_type)
+                  media_type = hash[:media_type]&.to_s
+                  if media_type&.start_with?("image/")
+                    ImageBase64.new(**hash.merge(type: "base64"))
+                  else
+                    DocumentBase64.new(**hash.merge(type: "base64"))
+                  end
+                elsif hash.key?(:url)
+                  ImageURL.new(**hash.merge(type: "url"))
+                elsif hash.key?(:file_id)
+                  ImageFile.new(**hash.merge(type: "file"))
+                elsif hash.key?(:text)
+                  DocumentText.new(**hash.merge(type: "text"))
+                else
+                  raise ArgumentError, "Cannot cast hash without type to Source: #{hash.inspect}"
+                end
+              end
+
+              def cast_image_source(image_value, original_hash)
+                case image_value
+                when String
+                  if uri?(image_value)
+                    # It's a URI/URL
+                    ImageURL.new(type: "url", url: image_value)
+                  elsif data_uri?(image_value)
+                    # It's a data URI (e.g., data:image/jpeg;base64,...)
+                    media_type, data = parse_data_uri(image_value)
+                    ImageBase64.new(type: "base64", media_type: media_type, data: data)
+                  else
+                    raise ArgumentError, "Cannot determine source type for image value: #{image_value.inspect}"
+                  end
+                else
+                  raise ArgumentError, "Expected String for image key, got #{image_value.class}"
+                end
+              end
+
+              def cast_document_source(file_value, original_hash)
+                case file_value
+                when String
+                  if uri?(file_value)
+                    # It's a URI/URL
+                    DocumentURL.new(type: "url", url: file_value)
+                  elsif data_uri?(file_value)
+                    # It's a data URI (e.g., data:application/pdf;base64,...)
+                    media_type, data = parse_data_uri(file_value)
+                    DocumentBase64.new(type: "base64", media_type: media_type, data: data)
+                  else
+                    raise ArgumentError, "Cannot determine source type for file value: #{file_value.inspect}"
+                  end
+                else
+                  raise ArgumentError, "Expected String for file key, got #{file_value.class}"
+                end
+              end
+
+              def uri?(value)
+                # Check if it looks like a URI (http://, https://, etc.)
+                value.match?(%r{\A(https?)://}i)
+              end
+
+              def data_uri?(value)
+                # Check if it's a data URI (data:...)
+                value.match?(/\Adata:/i)
+              end
+
+              def parse_data_uri(data_uri)
+                # Parse data URI format: data:mime/type;base64,encoded_data
+                match = data_uri.match(/\Adata:([^;,]+)(;base64)?,(.+)\z/i)
+                raise ArgumentError, "Invalid data URI format: #{data_uri[0..50]}..." unless match
+
+                media_type = match[1]
+                is_base64 = !match[2].nil?
+                data = match[3]
+
+                unless is_base64
+                  raise ArgumentError, "Only base64-encoded data URIs are supported: #{data_uri[0..50]}..."
+                end
+
+                [ media_type, data ]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/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/messages/content/sources/document_base64.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # Base64-encoded document source
+            class DocumentBase64 < Base
+              attribute :type, :string, as: "base64"
+              attribute :media_type, :string
+              attribute :data, :string
+
+              validates :media_type, presence: true
+              validates :data, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/sources/document_file.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # File-based document source
+            class DocumentFile < Base
+              attribute :type, :string, as: "file"
+              attribute :file_id, :string
+
+              validates :file_id, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/sources/document_text.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # Text document source
+            class DocumentText < Base
+              attribute :type, :string, as: "text"
+              attribute :text, :string
+              attribute :media_type, :string
+
+              validates :text, presence: true
+              validates :media_type, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/sources/document_url.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # URL-based document source
+            class DocumentURL < Base
+              attribute :type, :string, as: "url"
+              attribute :url, :string
+
+              validates :url, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/sources/image_base64.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # Base64-encoded image source
+            class ImageBase64 < Base
+              attribute :type, :string, as: "base64"
+              attribute :media_type, :string
+              attribute :data, :string
+
+              validates :media_type, presence: true, inclusion: {
+                in: %w[image/jpeg image/png image/gif image/webp]
+              }
+              validates :data, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/sources/image_file.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # File-based image source
+            class ImageFile < Base
+              attribute :type, :string, as: "file"
+              attribute :file_id, :string
+
+              validates :file_id, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic/requests/messages/content/sources/image_url.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          module Sources
+            # URL-based image source
+            class ImageURL < Base
+              attribute :type, :string, as: "url"
+              attribute :url, :string
+
+              validates :url, presence: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Text content block
+          class Text < Base
+            attribute :type, :string, as: "text"
+            attribute :text, :string
+            attribute :cache_control # Optional cache control
+
+            validates :text, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Thinking content block
+          class Thinking < Base
+            attribute :type, :string, as: "thinking"
+            attribute :thinking, :string
+            attribute :signature, :string
+
+            validates :thinking, presence: true
+            validates :signature, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Tool result content block
+          class ToolResult < Base
+            attribute :type, :string, as: "tool_result"
+            attribute :tool_use_id, :string
+            attribute :content # String or array of content blocks
+            attribute :is_error, :boolean
+            attribute :cache_control # Optional cache control
+
+            validates :tool_use_id, presence: true, format: { with: /\A[a-zA-Z0-9_-]+\z/ }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Content
+          # Tool use content block
+          class ToolUse < Base
+            attribute :type, :string, as: "tool_use"
+            attribute :id, :string
+            attribute :name, :string
+            attribute :input # Object containing tool input
+            attribute :cache_control # Optional cache control
+
+            validates :id, presence: true, format: { with: /\A[a-zA-Z0-9_-]+\z/ }
+            validates :name, presence: true, length: { minimum: 1, maximum: 200 }
+            validates :input, presence: true
+
+            drop_attributes :json_buf
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        module Messages
+          # User message - messages sent by the user
+          class User < Base
+            attribute :role, :string, as: "user"
+
+            # Content can be:
+            # - A string (shorthand for single text block)
+            # - An array of content blocks (text, image, document, etc.)
+            validates :content, presence: true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        # Metadata about the request
+        class Metadata < Common::BaseModel
+          attribute :user_id, :string
+
+          validates :user_id, length: { maximum: 256 }, allow_nil: true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module Anthropic
+      module Requests
+        # Configures the response format for Anthropic API requests.
+        #
+        # Anthropic does not natively support response formats. This class emulates
+        # the feature using a lead-in assistant message and response parsing.
+        class ResponseFormat < Common::BaseModel
+          # @return [String] format type: "text" or "json_object"
+          attribute :type, :string, default: "text"
+
+          validates :type, inclusion: { in: %w[text json_object] }, allow_nil: true
+        end
+      end
+    end
+  end
+end