activeagent 1.0.0.rc1 → 1.0.1

data/lib/active_agent/providers/anthropic/request.rb

@@ -1,107 +1,186 @@
 # frozen_string_literal: true
 
-require "active_agent/providers/common/model"
-require_relative "_types"
+require "delegate"
+require "json"
+require_relative "transforms"
 
 module ActiveAgent
   module Providers
     module Anthropic
-      class Request < Common::BaseModel
-        # Required parameters
-        attribute :model,      :string
-        attribute :messages,   Requests::Messages::MessagesType.new
-        attribute :max_tokens, :integer, fallback: 4096
-
-        # Optional parameters - Prompting
-        attribute :system,         Requests::Messages::SystemType.new
-        attribute :temperature,    :float
-        attribute :top_k,          :integer
-        attribute :top_p,          :float
-        attribute :stop_sequences, default: -> { [] } # Array of strings
-
-        # Optional parameters - Tools
-        attribute :tools       # Array of tool definitions
-        attribute :tool_choice, Requests::ToolChoice::ToolChoiceType.new
-
-        # Optional parameters - Thinking
-        attribute :thinking, Requests::ThinkingConfig::ThinkingConfigType.new
-
-        # Optional parameters - Streaming
-        attribute :stream, :boolean, default: false
-
-        # Optional parameters - Metadata
-        attribute :metadata, Requests::MetadataType.new
-
-        # Optional parameters - Context Management
-        attribute :context_management, Requests::ContextManagementConfigType.new
-
-        # Optional parameters - Container
-        attribute :container, Requests::ContainerParamsType.new
-
-        # Optional parameters - Service tier
-        attribute :service_tier, :string
+      # Request wrapper that delegates to Anthropic gem model.
+      #
+      # Uses SimpleDelegator to wrap ::Anthropic::Models::MessageCreateParams,
+      # eliminating the need to maintain duplicate attribute definitions while
+      # providing convenience transformations and custom fields.
+      #
+      # All standard Anthropic API fields are automatically available via delegation:
+      # - model, messages, max_tokens
+      # - system, temperature, top_k, top_p, stop_sequences
+      # - tools, tool_choice, thinking
+      # - stream, metadata, context_management, container, service_tier, mcp_servers
+      #
+      # Custom fields managed separately:
+      # - response_format (simulated JSON mode feature)
+      #
+      # @example Basic usage
+      #   request = Request.new(
+      #     model: "claude-3-5-haiku-latest",
+      #     messages: [{role: "user", content: "Hello"}]
+      #   )
+      #   request.model      #=> "claude-3-5-haiku-latest"
+      #   request.max_tokens #=> 4096 (default)
+      #
+      # @example With transformations
+      #   # String content is automatically normalized
+      #   request = Request.new(
+      #     model: "...",
+      #     messages: [{role: "user", content: "Hi"}]
+      #   )
+      #   # Internally becomes: [{type: "text", text: "Hi"}]
+      #
+      # @example Custom field
+      #   request = Request.new(
+      #     model: "...",
+      #     messages: [...],
+      #     response_format: {type: "json_object"}
+      #   )
+      #   request.response_format #=> {type: "json_object"}
+      class Request < SimpleDelegator
+        # Default max_tokens value when not specified
+        DEFAULT_MAX_TOKENS = 4096
+
+        # Default values for optional parameters
+        DEFAULTS = {
+          max_tokens: DEFAULT_MAX_TOKENS,
+          stop_sequences: [],
+          mcp_servers: []
+        }.freeze
+
+        # @return [Hash, nil] simulated JSON response format configuration
+        attr_reader :response_format
+
+        # @return [Boolean, nil] whether to stream the response
+        attr_reader :stream
+
+        # @param params [Hash]
+        # @option params [String] :model required
+        # @option params [Array<Hash>] :messages required
+        # @option params [Integer] :max_tokens (4096)
+        # @option params [Hash] :response_format custom field for JSON mode simulation
+        # @option params [String] :anthropic_beta beta version for features like MCP
+        # @raise [ArgumentError] when gem model validation fails
+        def initialize(**params)
+          # Step 1: Extract custom fields that gem doesn't support
+          @response_format = params.delete(:response_format)
+          @stream = params.delete(:stream)
+          anthropic_beta = params.delete(:anthropic_beta)
+
+          # Step 2: Map common format 'instructions' to Anthropic's 'system'
+          if params.key?(:instructions)
+            params[:system] = params.delete(:instructions)
+          end
 
-        # Optional parameters - MCP Servers
-        attribute :mcp_servers, default: -> { [] } # Array of MCP server definitions
+          # Step 3: Apply defaults
+          params = apply_defaults(params)
 
-        # Common Format Compatibility
-        attribute :response_format, Requests::ResponseFormatType.new
+          # Step 4: Transform params for gem compatibility
+          transformed = Transforms.normalize_params(params)
 
-        # Validations for required fields
-        validates :model, :messages, :max_tokens, presence: true
+          # Step 5: Determine if we need beta params (for MCP or other beta features)
+          use_beta = anthropic_beta.present? || transformed[:mcp_servers]&.any?
 
-        # Validations for numeric parameters
-        validates :max_tokens,  numericality: { greater_than_or_equal_to: 1 },                          allow_nil: true
-        validates :temperature, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }, allow_nil: true
-        validates :top_k,       numericality: { greater_than_or_equal_to: 0 },                           allow_nil: true
-        validates :top_p,       numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 1 }, allow_nil: true
+          # Step 6: Add betas parameter if using beta API
+          if use_beta
+            # Default to MCP beta version if not specified
+            beta_version = anthropic_beta || "mcp-client-2025-04-04"
+            transformed[:betas] = [ beta_version ]
+          end
 
-        # Validations for specific values
-        validates :service_tier, inclusion: { in: %w[auto standard_only] }, allow_nil: true
+          # Step 7: Create gem model - use Beta version if needed
+          gem_model = if use_beta
+            ::Anthropic::Models::Beta::MessageCreateParams.new(**transformed)
+          else
+            ::Anthropic::Models::MessageCreateParams.new(**transformed)
+          end
 
-        # Custom validations
-        validate :validate_stop_sequences
-        validate :validate_tools_format
-        validate :validate_mcp_servers_format
+          # Step 8: Delegate all method calls to gem model
+          super(gem_model)
+        rescue ArgumentError => e
+          # Re-raise with more context
+          raise ArgumentError, "Invalid Anthropic request parameters: #{e.message}"
+        end
 
-        # Common Format Compatibility
-        alias_attribute :instructions, :system
+        # Serializes request for API call.
+        #
+        # Uses gem's JSON serialization and delegates cleanup to Transforms module.
+        #
+        # @return [Hash]
+        def serialize
+          # Use gem's JSON serialization (handles all nested objects)
+          hash = Anthropic::Transforms.gem_to_hash(__getobj__)
+
+          # Delegate cleanup to transforms module
+          Transforms.cleanup_serialized_request(hash, DEFAULTS, __getobj__)
+        end
 
-        # Handle merging in the common format
-        def message=(value)
-          self.messages ||= []
-          self.messages << Requests::Messages::MessageType.new.cast(value)
+        # Accessor for system instructions.
+        #
+        # Must override SimpleDelegator's method_missing because Ruby's Kernel.system
+        # conflicts with delegation. The gem stores data in @data instance variable.
+        #
+        # @return [String, Array, nil]
+        def system
+          __getobj__.instance_variable_get(:@data)[:system]
         end
 
-        private
+        # @param value [String, Array]
+        def system=(value)
+          __getobj__.instance_variable_get(:@data)[:system] = value
+        end
 
-        def validate_stop_sequences
-          return if stop_sequences.nil? || stop_sequences.empty?
+        # Alias for system (common format compatibility).
+        #
+        # @return [String, Array, nil]
+        def instructions
+          system
+        end
 
-          unless stop_sequences.is_a?(Array)
-            errors.add(:stop_sequences, "must be an array")
-          end
+        # @param value [String, Array]
+        def instructions=(value)
+          self.system = value
         end
 
-        def validate_tools_format
-          return if tools.nil?
+        # Accessor for MCP servers.
+        #
+        # Safely returns MCP servers array, defaulting to empty array if not set.
+        #
+        # @return [Array]
+        def mcp_servers
+          __getobj__.instance_variable_get(:@data)[:mcp_servers] || []
+        end
 
-          unless tools.is_a?(Array)
-            errors.add(:tools, "must be an array")
-          end
+        # Removes the last message from the messages array.
+        #
+        # Used for JSON format simulation to remove the lead-in assistant message.
+        #
+        # @return [void]
+        def pop_message!
+          new_messages = messages.dup
+          new_messages.pop
+          self.messages = new_messages
         end
 
-        def validate_mcp_servers_format
-          return if mcp_servers.nil? || mcp_servers.empty?
+        private
 
-          unless mcp_servers.is_a?(Array)
-            errors.add(:mcp_servers, "must be an array")
-            return
+        # @param params [Hash]
+        # @return [Hash]
+        def apply_defaults(params)
+          # Only apply defaults for keys that aren't present
+          DEFAULTS.each do |key, value|
+            params[key] = value unless params.key?(key)
           end
 
-          if mcp_servers.length > 20
-            errors.add(:mcp_servers, "can have at most 20 servers")
-          end
+          params
         end
       end
     end