activeagent 1.0.1 → 1.0.2

data/lib/active_agent/providers/gemini_provider.rb

@@ -0,0 +1,94 @@
+require_relative "_base_provider"
+
+require_gem!(:openai, __FILE__)
+
+require_relative "open_ai_provider"
+require_relative "gemini/_types"
+
+module ActiveAgent
+  module Providers
+    # Provides access to Google's Gemini API via OpenAI-compatible endpoint.
+    #
+    # Extends OpenAI provider to work with Gemini's OpenAI-compatible API,
+    # enabling access to Gemini models through a familiar interface.
+    #
+    # @see OpenAI::ChatProvider
+    # @see https://ai.google.dev/gemini-api/docs/openai
+    class GeminiProvider < OpenAI::ChatProvider
+      # @return [String]
+      def self.service_name
+        "Gemini"
+      end
+
+      # @return [Class]
+      def self.options_klass
+        namespace::Options
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.prompt_request_type
+        namespace::RequestType.new
+      end
+
+      # @return [ActiveModel::Type::Value]
+      def self.embed_request_type
+        namespace::Embedding::RequestType.new
+      end
+
+      protected
+
+      # Executes chat completion request with Gemini-specific error handling.
+      #
+      # @see OpenAI::ChatProvider#api_prompt_execute
+      # @param parameters [Hash]
+      # @return [Object, nil] response object or nil for streaming
+      # @raise [OpenAI::Errors::APIConnectionError] when Gemini API unreachable
+      def api_prompt_execute(parameters)
+        super
+
+      rescue ::OpenAI::Errors::APIConnectionError => exception
+        log_connection_error(exception)
+        raise exception
+      end
+
+      # Executes embedding request with Gemini-specific error handling.
+      #
+      # @param parameters [Hash]
+      # @return [Hash] symbolized API response
+      # @raise [OpenAI::Errors::APIConnectionError] when Gemini API unreachable
+      def api_embed_execute(parameters)
+        client.embeddings.create(**parameters).as_json.deep_symbolize_keys
+      rescue ::OpenAI::Errors::APIConnectionError => exception
+        log_connection_error(exception)
+        raise exception
+      end
+
+      # Merges streaming delta into the message with role cleanup.
+      #
+      # Overrides parent to handle Gemini's role copying behavior which duplicates
+      # the role field in every streaming chunk, requiring manual cleanup to prevent
+      # message corruption.
+      #
+      # @see OpenAI::ChatProvider#message_merge_delta
+      # @param message [Hash]
+      # @param delta [Hash]
+      # @return [Hash]
+      def message_merge_delta(message, delta)
+        message[:role] = delta.delete(:role) if delta[:role]
+
+        hash_merge_delta(message, delta)
+      end
+
+      # Logs connection failures with Gemini API details for debugging.
+      #
+      # @param error [Exception]
+      # @return [void]
+      def log_connection_error(error)
+        instrument("connection_error.provider.active_agent",
+                  uri_base: options.base_url,
+                  exception: error.class,
+                  message: error.message)
+      end
+    end
+  end
+end

data/lib/active_agent/providers/open_ai/chat/transforms.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/hash/keys"
+require "uri"
 
 module ActiveAgent
   module Providers
@@ -124,10 +125,19 @@ module ActiveAgent
                     { type: "text", text: msg_hash[:text] },
                     { type: "image_url", image_url: { url: msg_hash[:image] } }
                   ]
+                elsif msg_hash.key?(:text) && msg_hash.key?(:document)
+                  # Shorthand with both text and document: { text: "...", document: "url" }
+                  [
+                    { type: "text", text: msg_hash[:text] },
+                    build_file_content(msg_hash[:document])
+                  ]
                 elsif msg_hash.key?(:image)
                   # Shorthand with only image: { image: "url" }
                   # Text comes from adjacent prompt arguments
                   [ { type: "image_url", image_url: { url: msg_hash[:image] } } ]
+                elsif msg_hash.key?(:document)
+                  # Shorthand with only document: { document: "url" }
+                  [ build_file_content(msg_hash[:document]) ]
                 elsif msg_hash.key?(:text)
                   # Shorthand: { text: "..." } or { role: "...", text: "..." }
                   msg_hash[:text]
@@ -137,13 +147,39 @@ module ActiveAgent
                 end
 
                 # Create appropriate message param based on role and content
-                extra_params = msg_hash.except(:role, :content, :text, :image)
+                extra_params = msg_hash.except(:role, :content, :text, :image, :document)
                 create_message_param(role, content, extra_params)
               else
                 raise ArgumentError, "Cannot normalize #{message.class} to message"
               end
             end
 
+            # Builds a file content block for the Chat API file type
+            #
+            # Handles both URL and data URI formats:
+            # - URL: "http://example.com/document.pdf" → { type: "file", file: { filename: "...", url: "..." } }
+            # - Data URI: "data:application/pdf;base64,..." → { type: "file", file: { filename: "...", file_data: "..." } }
+            #
+            # @param document [String] URL or data URI
+            # @return [Hash] file content block
+            def build_file_content(document)
+              if document.start_with?("data:")
+                # Data URI - extract or infer filename from media type
+                media_type = document.match(%r{\Adata:([^;,]+)})&.[](1) || "application/octet-stream"
+                extension = media_type.split("/").last&.gsub(/[^a-zA-Z0-9]/, "_") || "bin"
+                filename = "document.#{extension}"
+                { type: "file", file: { filename: filename, file_data: document } }
+              else
+                # Regular URL
+                filename = File.basename(URI.parse(document).path.to_s)
+                filename = "document.pdf" if filename.empty?
+                { type: "file", file: { filename: filename, url: document } }
+              end
+            rescue URI::Error
+              # Fallback for invalid URLs
+              { type: "file", file: { filename: "document.pdf", url: document } }
+            end
+
             # Creates the appropriate gem message param class for the given role
             #
             # @param role [String] message role (developer, system, user, assistant, tool, function)

data/lib/active_agent/providers/open_ai/chat_provider.rb

@@ -95,6 +95,8 @@ module ActiveAgent
         def process_stream_chunk(api_response_event)
           instrument("stream_chunk.active_agent")
 
+          broadcast_stream_open
+
           # Called Multiple Times: [Chunk<T>, T]<Content, ToolsCall>
           case api_response_event.type
           when :chunk

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