activeagent 1.0.0 → 1.0.2

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

@@ -148,6 +148,26 @@ module ActiveAgent
           self.messages = instructions_messages + current_messages
         end
 
+        # Gets tool_choice bypassing gem validation
+        #
+        # OpenRouter supports "any" which isn't valid in OpenAI gem types.
+        #
+        # @return [String, Hash, nil]
+        def tool_choice
+          __getobj__.instance_variable_get(:@data)[:tool_choice]
+        end
+
+        # Sets tool_choice bypassing gem validation
+        #
+        # OpenRouter supports "any" which isn't valid in OpenAI gem types,
+        # so we bypass the gem's type validation by setting @data directly.
+        #
+        # @param value [String, Hash, nil]
+        # @return [void]
+        def tool_choice=(value)
+          __getobj__.instance_variable_get(:@data)[:tool_choice] = value
+        end
+
         # Accessor for OpenRouter-specific provider preferences
         #
         # @return [Hash, nil]

data/lib/active_agent/providers/open_router/transforms.rb

@@ -62,9 +62,39 @@ module ActiveAgent
             # Use OpenAI transforms for the base parameters
             openai_params = OpenAI::Chat::Transforms.normalize_params(params)
 
+            # Override tool_choice normalization for OpenRouter's "any" vs "required" difference
+            if openai_params[:tool_choice]
+              openai_params[:tool_choice] = normalize_tool_choice(openai_params[:tool_choice])
+            end
+
             [ openai_params, openrouter_params ]
           end
 
+          # Normalizes tools using OpenAI transforms
+          #
+          # @param tools [Array<Hash>]
+          # @return [Array<Hash>]
+          def normalize_tools(tools)
+            OpenAI::Chat::Transforms.normalize_tools(tools)
+          end
+
+          # Normalizes tool_choice for OpenRouter API differences
+          #
+          # OpenRouter uses "any" instead of OpenAI's "required" for forcing tool use.
+          # Converts common format to OpenRouter-specific format:
+          # - "required" (common) → "any" (OpenRouter)
+          # - Everything else delegates to OpenAI transforms
+          #
+          # @param tool_choice [String, Hash, Symbol]
+          # @return [String, Hash, Symbol]
+          def normalize_tool_choice(tool_choice)
+            # Convert "required" to OpenRouter's "any"
+            return "any" if tool_choice.to_s == "required"
+
+            # For everything else, use OpenAI transforms
+            OpenAI::Chat::Transforms.normalize_tool_choice(tool_choice)
+          end
+
           # Normalizes messages using OpenAI transforms
           #
           # @param messages [Array, String, Hash, nil]

data/lib/active_agent/providers/open_router_provider.rb

@@ -33,6 +33,20 @@ module ActiveAgent
 
       protected
 
+      # @see BaseProvider#prepare_prompt_request
+      # @return [Request]
+      def prepare_prompt_request
+        prepare_prompt_request_tools
+        super
+      end
+
+      # Returns true if tool_choice == "any" (OpenRouter's equivalent of "required").
+      #
+      # @return [Boolean]
+      def tool_choice_forces_required?
+        request.tool_choice == "any"
+      end
+
       # Merges streaming delta into the message with role cleanup.
       #
       # Overrides parent to handle OpenRouter's role copying behavior which duplicates

data/lib/active_agent/providers/ruby_llm/_types.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative "options"
+require_relative "request"
+require_relative "embedding_request"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Type for Request model
+      class RequestType < ActiveModel::Type::Value
+        def cast(value)
+          case value
+          when Request
+            value
+          when Hash
+            Request.new(**value.deep_symbolize_keys)
+          when nil
+            nil
+          else
+            raise ArgumentError, "Cannot cast #{value.class} to Request"
+          end
+        end
+
+        def serialize(value)
+          case value
+          when Request
+            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 embedding requests
+      class EmbeddingRequestType < ActiveModel::Type::Value
+        def cast(value)
+          case value
+          when RubyLLM::EmbeddingRequest
+            value
+          when Hash
+            RubyLLM::EmbeddingRequest.new(**value.deep_symbolize_keys)
+          when nil
+            nil
+          else
+            raise ArgumentError, "Cannot cast #{value.class} to EmbeddingRequest"
+          end
+        end
+
+        def serialize(value)
+          case value
+          when RubyLLM::EmbeddingRequest
+            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

data/lib/active_agent/providers/ruby_llm/embedding_request.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Embedding request model for RubyLLM provider.
+      class EmbeddingRequest < Common::BaseModel
+        attribute :model, :string
+        attribute :input
+        attribute :dimensions, :integer
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/messages/_types.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Load all message classes
+require_relative "base"
+require_relative "system"
+require_relative "user"
+require_relative "assistant"
+require_relative "tool"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      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)
+              when :system
+                System.new(**hash)
+              when :tool
+                Tool.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
+              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

data/lib/active_agent/providers/ruby_llm/messages/assistant.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      module Messages
+        # Assistant message for RubyLLM provider.
+        #
+        # Drops extra fields that are part of the API response but not
+        # part of the message structure.
+        class Assistant < Base
+          attribute :role, :string, as: "assistant"
+          attribute :content
+          attribute :tool_calls
+
+          validates :content, presence: true, unless: :tool_calls
+
+          # Drop API response fields that aren't part of the message
+          drop_attributes :usage, :id, :model, :stop_reason, :stop_sequence, :type,
+                          :input_tokens, :output_tokens
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/messages/base.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      module Messages
+        # Base class for RubyLLM messages.
+        class Base < Common::BaseModel
+          attribute :role, :string
+          attribute :content
+
+          validates :role, presence: true
+
+          # 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 the content structure.
+          #
+          # @return [String] extracted text content
+          def extract_text_content
+            case content
+            when String
+              content
+            when Array
+              content.select { |block| block.is_a?(Hash) && block[:type] == "text" }
+                     .map { |block| block[:text] }
+                     .join("\n")
+            else
+              content.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/messages/system.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      module Messages
+        # System message for RubyLLM provider.
+        class System < Base
+          attribute :role, :string, as: "system"
+
+          validates :content, presence: true
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/messages/tool.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      module Messages
+        # Tool result message for RubyLLM provider.
+        class Tool < Base
+          attribute :role, :string, as: "tool"
+          attribute :content
+          attribute :tool_call_id, :string
+
+          def to_common
+            common = super
+            common[:tool_call_id] = tool_call_id if tool_call_id
+            common
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/messages/user.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      module Messages
+        # User message for RubyLLM provider.
+        class User < Base
+          attribute :role, :string, as: "user"
+
+          validates :content, presence: true
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/options.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Configuration options for the RubyLLM provider.
+      #
+      # RubyLLM manages its own API keys via RubyLLM.configure, so no
+      # provider-specific API key attributes are needed here.
+      class Options < Common::BaseModel
+        attribute :model, :string
+        attribute :temperature, :float
+        attribute :max_tokens, :integer
+
+        def initialize(kwargs = {})
+          kwargs = kwargs.deep_symbolize_keys if kwargs.respond_to?(:deep_symbolize_keys)
+          super(**deep_compact(kwargs))
+        end
+
+        def extra_headers
+          {}
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "active_agent/providers/common/model"
+
+require_relative "messages/_types"
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Request model for RubyLLM provider.
+      class Request < Common::BaseModel
+        attribute :model, :string
+        attribute :messages, Messages::MessagesType.new
+        attribute :instructions
+        attribute :tools
+        attribute :tool_choice
+        attribute :temperature, :float
+        attribute :max_tokens, :integer
+        attribute :stream, :boolean, default: false
+        attribute :response_format
+
+        # Common Format Compatibility
+        def message=(value)
+          self.messages ||= []
+          self.messages << value
+        end
+      end
+    end
+  end
+end

data/lib/active_agent/providers/ruby_llm/tool_proxy.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Providers
+    module RubyLLM
+      # Bridges ActiveAgent tool definitions to RubyLLM's expected tool interface.
+      # RubyLLM expects tools as { "name" => tool } where each tool responds to
+      # #name, #description, #parameters, #params_schema, and #provider_params.
+      class ToolProxy
+        attr_reader :name, :description, :parameters
+
+        def initialize(name:, description:, parameters:)
+          @name = name
+          @description = description
+          @parameters = parameters
+        end
+
+        # RubyLLM checks this first; returns the JSON Schema directly so
+        # RubyLLM doesn't try to interpret our parameters as Parameter objects.
+        # Deep-stringifies keys to match RubyLLM's internal schema format.
+        def params_schema
+          deep_stringify(@parameters) if @parameters.is_a?(Hash) && @parameters.any?
+        end
+
+        # RubyLLM merges this into the tool definition
+        def provider_params
+          {}
+        end
+
+        private
+
+        def deep_stringify(obj)
+          case obj
+          when Hash
+            obj.each_with_object({}) { |(k, v), h| h[k.to_s] = deep_stringify(v) }
+          when Array
+            obj.map { |v| deep_stringify(v) }
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end