active_agent_rails 0.1.0

data/lib/active_agent/memory/base.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Memory
+    class Base
+      attr_reader :conversation_id
+
+      def initialize(conversation_id:)
+        @conversation_id = conversation_id
+      end
+
+      # Returns array of message hashes:
+      # [ { role: 'user', content: 'hello' }, ... ]
+      def messages
+        raise NotImplementedError
+      end
+
+      # Adds a message to memory
+      def add_message(role:, content:, **options)
+        raise NotImplementedError
+      end
+
+      # Clears the memory for this conversation
+      def clear
+        raise NotImplementedError
+      end
+    end
+
+    def self.for(store_name, conversation_id)
+      case store_name.to_sym
+      when :in_memory
+        require_relative "in_memory"
+        InMemory.new(conversation_id: conversation_id)
+      when :active_record
+        require_relative "active_record"
+        ActiveRecord.new(conversation_id: conversation_id)
+      else
+        raise ArgumentError, "Unknown memory store: #{store_name}"
+      end
+    end
+  end
+end

data/lib/active_agent/memory/in_memory.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module ActiveAgent
+  module Memory
+    class InMemory < Base
+      @store = Hash.new { |h, k| h[k] = [] }
+
+      class << self
+        attr_reader :store
+      end
+
+      def messages
+        self.class.store[conversation_id]
+      end
+
+      def add_message(role:, content:, **options)
+        message = { role: role, content: content }.merge(options)
+        self.class.store[conversation_id] << message
+        message
+      end
+
+      def clear
+        self.class.store[conversation_id] = []
+      end
+    end
+  end
+end

data/lib/active_agent/provider.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module ActiveAgent
+  module Provider
+    class Base
+      attr_reader :api_key, :model
+
+      def initialize(api_key:, model:)
+        provider_name = self.class.name.split("::").last
+        if api_key.to_s.strip.empty?
+          raise "ActiveAgent Error: API key for #{provider_name} is not configured. Please set it in config/initializers/active_agent.rb or via environment variables."
+        end
+        @api_key = api_key
+        @model = model
+      end
+
+      # Abstract methods to be implemented by adapters
+      def chat(messages, tools: [], &block)
+        raise NotImplementedError, "#{self.class} must implement #chat"
+      end
+
+      def format_tools(tools)
+        raise NotImplementedError, "#{self.class} must implement #format_tools"
+      end
+
+      private
+
+      # Helper for making HTTP requests
+      def post_request(url, headers, body, &block)
+        require "net/http"
+        require "uri"
+        require "json"
+
+        uri = URI.parse(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.read_timeout = 60 # Allow time for tool calling and generation
+
+        request = Net::HTTP::Post.new(uri.request_uri, headers)
+        request.body = body.to_json
+
+        if block_given?
+          http.request(request) do |response|
+            unless response.is_a?(Net::HTTPSuccess)
+              ActiveAgent.logger.error("ActiveAgent API Error: #{response.code} #{response.body}")
+              raise "API Error: #{response.code}"
+            end
+
+            buffer = ""
+            response.read_body do |chunk|
+              buffer += chunk
+              while (line_index = buffer.index("\n"))
+                line = buffer[0...line_index].strip
+                buffer = buffer[(line_index + 1)..-1]
+                next if line.empty?
+                yield(line)
+              end
+            end
+          end
+          nil # return nil when streaming
+        else
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            ActiveAgent.logger.error("ActiveAgent API Error: #{response.code} #{response.body}")
+            raise "API Error: #{response.code} - #{response.body}"
+          end
+
+          JSON.parse(response.body)
+        end
+      end
+    end
+
+    def self.for(provider_name, model)
+      case provider_name.to_sym
+      when :gemini
+        require_relative "providers/gemini"
+        Gemini.new(api_key: ActiveAgent.configuration.gemini_api_key, model: model)
+      when :openai
+        require_relative "providers/openai"
+        OpenAI.new(api_key: ActiveAgent.configuration.openai_api_key, model: model)
+      when :anthropic
+        require_relative "providers/anthropic"
+        Anthropic.new(api_key: ActiveAgent.configuration.anthropic_api_key, model: model)
+      else
+        raise ArgumentError, "Unknown provider: #{provider_name}"
+      end
+    end
+  end
+end

data/lib/active_agent/providers/anthropic.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+
+module ActiveAgent
+  module Provider
+    class Anthropic < Base
+      def chat(messages, tools: [], &block)
+        api_model = model || "claude-3-5-sonnet-latest"
+        url = "https://api.anthropic.com/v1/messages"
+
+        system_message = messages.find { |m| m[:role].to_s == "system" }
+        history_messages = messages.reject { |m| m[:role].to_s == "system" }
+
+        body = {
+          model: api_model,
+          max_tokens: 4096,
+          messages: format_messages(history_messages)
+        }
+
+        if system_message && !system_message[:content].to_s.empty?
+          body[:system] = system_message[:content]
+        end
+
+        if tools.any?
+          body[:tools] = format_tools(tools)
+        end
+
+        headers = {
+          "Content-Type" => "application/json",
+          "x-api-key" => api_key,
+          "anthropic-version" => "2023-06-01"
+        }
+
+        if block_given?
+          body[:stream] = true
+          text_accumulator = ""
+          tool_calls_accumulator = {}
+
+          post_request(url, headers, body) do |line|
+            next unless line.start_with?("data:")
+            json_str = line.sub("data:", "").strip
+            next if json_str.empty?
+
+            begin
+              event_data = JSON.parse(json_str)
+              case event_data["type"]
+              when "content_block_start"
+                index = event_data["index"]
+                block_info = event_data["content_block"]
+                if block_info["type"] == "tool_use"
+                  tool_calls_accumulator[index] = {
+                    id: block_info["id"],
+                    name: block_info["name"],
+                    partial_json: ""
+                  }
+                end
+              when "content_block_delta"
+                index = event_data["index"]
+                delta = event_data["delta"]
+                
+                if delta["type"] == "text_delta"
+                  text_accumulator += delta["text"]
+                  yield(delta["text"])
+                elsif delta["type"] == "input_json_delta"
+                  tool_calls_accumulator[index][:partial_json] += delta["partial_json"] if tool_calls_accumulator[index]
+                end
+              end
+            rescue JSON::ParserError
+              # Ignore json parse errors for incomplete lines
+            end
+          end
+
+          tool_calls = tool_calls_accumulator.values.map do |tc|
+            args = {}
+            begin
+              args = JSON.parse(tc[:partial_json], symbolize_names: true) unless tc[:partial_json].empty?
+            rescue JSON::ParserError
+              ActiveAgent.logger.warn("Anthropic could not parse streaming tool input JSON: #{tc[:partial_json]}")
+            end
+
+            {
+              id: tc[:id],
+              name: tc[:name],
+              args: args
+            }
+          end
+
+          result = { role: "assistant" }
+          result[:content] = text_accumulator unless text_accumulator.empty?
+          result[:tool_calls] = tool_calls if tool_calls.any?
+          result
+        else
+          response_json = post_request(url, headers, body)
+          parse_response(response_json)
+        end
+      end
+
+      def format_tools(tools)
+        tools.map do |tool|
+          properties = {}
+          tool.parameters.each do |name, info|
+            properties[name] = {
+              type: Tool.map_type(info[:type], uppercase: false),
+              description: info[:description]
+            }
+          end
+
+          {
+            name: tool.name,
+            description: tool.description,
+            input_schema: {
+              type: "object",
+              properties: properties,
+              required: tool.required_parameters
+            }
+          }
+        end
+      end
+
+      private
+
+      # Translates generic messages into alternating user/assistant messages for Anthropic
+      def format_messages(messages)
+        formatted_list = []
+
+        messages.each do |msg|
+          role = msg[:role].to_s
+
+          if role == "tool"
+            # Anthropic expects tool results as 'user' role with a 'tool_result' block.
+            block = {
+              type: "tool_result",
+              tool_use_id: msg[:tool_call_id] || msg[:name],
+              content: msg[:content].to_s
+            }
+
+            # If the last message is already user, merge this tool result block into it
+            if formatted_list.last && formatted_list.last[:role] == "user"
+              # Ensure the content is an array
+              last_content = formatted_list.last[:content]
+              if last_content.is_a?(String)
+                formatted_list.last[:content] = [{ type: "text", text: last_content }, block]
+              else
+                formatted_list.last[:content] << block
+              end
+            else
+              formatted_list << { role: "user", content: [block] }
+            end
+
+          elsif role == "assistant"
+            content_blocks = []
+            content_blocks << { type: "text", text: msg[:content] } if msg[:content]
+
+            if msg[:tool_calls]&.any?
+              msg[:tool_calls].each do |tc|
+                content_blocks << {
+                  type: "tool_use",
+                  id: tc[:id] || tc[:name],
+                  name: tc[:name],
+                  input: tc[:args]
+                }
+              end
+            end
+
+            formatted_list << { role: "assistant", content: content_blocks }
+
+          elsif role == "user"
+            # Standard user message
+            formatted_list << { role: "user", content: msg[:content].to_s }
+          end
+        end
+
+        formatted_list
+      end
+
+      def parse_response(response)
+        result = { role: "assistant" }
+        content_blocks = response["content"] || []
+
+        text = ""
+        tool_calls = []
+
+        content_blocks.each do |block|
+          case block["type"]
+          when "text"
+            text += block["text"]
+          when "tool_use"
+            # Convert input keys to symbols
+            args = {}
+            if block["input"]
+              block["input"].each { |k, v| args[k.to_sym] = v }
+            end
+            tool_calls << {
+              id: block["id"],
+              name: block["name"],
+              args: args
+            }
+          end
+        end
+
+        result[:content] = text unless text.empty?
+        result[:tool_calls] = tool_calls if tool_calls.any?
+        result
+      end
+    end
+  end
+end

data/lib/active_agent/providers/gemini.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require_relative "../provider"
+
+module ActiveAgent
+  module Provider
+    class Gemini < Base
+      def chat(messages, tools: [], &block)
+        api_model = model || "gemini-2.5-flash"
+        headers = { "Content-Type" => "application/json" }
+
+        system_message = messages.find { |m| m[:role].to_s == "system" }
+        history_messages = messages.reject { |m| m[:role].to_s == "system" }
+
+        body = {
+          contents: format_messages(history_messages)
+        }
+
+        if system_message && !system_message[:content].to_s.empty?
+          body[:systemInstruction] = {
+            parts: [{ text: system_message[:content] }]
+          }
+        end
+
+        if tools.any?
+          body[:tools] = [{ functionDeclarations: format_tools(tools) }]
+        end
+
+        if block_given?
+          url = "https://generativelanguage.googleapis.com/v1beta/models/#{api_model}:streamGenerateContent?key=#{api_key}&alt=sse"
+          text_accumulator = ""
+          tool_calls = []
+
+          post_request(url, headers, body) do |line|
+            next unless line.start_with?("data:")
+            json_str = line.sub("data:", "").strip
+            next if json_str.empty?
+
+            begin
+              chunk = JSON.parse(json_str)
+              candidate = chunk.dig("candidates", 0)
+              next unless candidate
+
+              parts = candidate.dig("content", "parts") || []
+              parts.each do |part|
+                if part["text"]
+                  text_accumulator += part["text"]
+                  yield(part["text"])
+                elsif part["functionCall"]
+                  fc = part["functionCall"]
+                  args = {}
+                  if fc["args"]
+                    fc["args"].each { |k, v| args[k.to_sym] = v }
+                  end
+                  tool_calls << {
+                    id: fc["name"],
+                    name: fc["name"],
+                    args: args
+                  }
+                end
+              end
+            rescue JSON::ParserError
+              # Ignore json parse errors for incomplete lines
+            end
+          end
+
+          result = { role: "assistant" }
+          result[:content] = text_accumulator unless text_accumulator.empty?
+          result[:tool_calls] = tool_calls if tool_calls.any?
+          result
+        else
+          url = "https://generativelanguage.googleapis.com/v1beta/models/#{api_model}:generateContent?key=#{api_key}"
+          response_json = post_request(url, headers, body)
+          parse_response(response_json)
+        end
+      end
+
+      def format_tools(tools)
+        tools.map do |tool|
+          properties = {}
+          tool.parameters.each do |name, info|
+            properties[name] = {
+              type: Tool.map_type(info[:type], uppercase: true),
+              description: info[:description]
+            }
+          end
+
+          {
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+              type: "OBJECT",
+              properties: properties,
+              required: tool.required_parameters
+            }
+          }
+        end
+      end
+
+      private
+
+      def format_messages(messages)
+        messages.map do |msg|
+          role = case msg[:role].to_s
+                 when "user" then "user"
+                 when "assistant" then "model"
+                 when "tool" then "tool"
+                 else "user"
+                 end
+
+          parts = []
+          if msg[:tool_calls]&.any?
+            msg[:tool_calls].each do |tc|
+              parts << {
+                functionCall: {
+                  name: tc[:name],
+                  args: tc[:args]
+                }
+              }
+            end
+          elsif role == "tool"
+            parts << {
+              functionResponse: {
+                name: msg[:name],
+                response: { result: msg[:content] }
+              }
+            }
+          else
+            parts << { text: msg[:content].to_s }
+          end
+
+          { role: role, parts: parts }
+        end
+      end
+
+      def parse_response(response)
+        candidate = response.dig("candidates", 0)
+        return { role: "assistant", content: "Error: No response from model." } unless candidate
+
+        parts = candidate.dig("content", "parts") || []
+        text = nil
+        tool_calls = []
+
+        parts.each do |part|
+          if part["text"]
+            text = part["text"]
+          elsif part["functionCall"]
+            fc = part["functionCall"]
+            # Convert args keys to symbols
+            args = {}
+            if fc["args"]
+              fc["args"].each { |k, v| args[k.to_sym] = v }
+            end
+            tool_calls << {
+              id: fc["name"], # Gemini doesn't have tool call IDs, use name
+              name: fc["name"],
+              args: args
+            }
+          end
+        end
+
+        result = { role: "assistant" }
+        result[:content] = text if text
+        result[:tool_calls] = tool_calls if tool_calls.any?
+        result
+      end
+    end
+  end
+end