activeagent 1.0.1 → 1.0.3

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