rubyrana 0.1.0

data/examples/quick_start.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+require "rubyrana"
+
+Rubyrana.configure do |config|
+  config.debug = true
+  config.default_provider = Rubyrana::Providers::Anthropic.new(
+    api_key: ENV.fetch("ANTHROPIC_API_KEY"),
+    model: ENV.fetch("ANTHROPIC_MODEL", "claude-3-haiku-20240307")
+  )
+end
+
+word_count = Rubyrana::Tool.new("word_count") do |text:|
+  text.split.size
+end
+
+built_in_tools = [
+  Rubyrana::Tools.code_interpreter
+]
+
+agent = Rubyrana::Agent.new(tools: [word_count] + built_in_tools)
+puts agent.call("How many words are in this sentence?")

data/examples/streaming.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+require "rubyrana"
+
+Rubyrana.configure do |config|
+  config.default_provider = Rubyrana::Providers::Anthropic.new(
+    api_key: ENV.fetch("ANTHROPIC_API_KEY"),
+    model: ENV.fetch("ANTHROPIC_MODEL", "claude-3-haiku-20240307")
+  )
+end
+
+agent = Rubyrana::Agent.new
+
+agent.stream("Give me a one-line summary of Ruby.") do |chunk|
+  print chunk
+end
+
+puts

data/examples/tools_loader.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "dotenv/load"
+require "rubyrana"
+
+# Define tools in a separate folder using Rubyrana.tool
+# Example file: ./tools/hello_tool.rb
+# Rubyrana.tool("hello") { |name:| "Hello, #{name}!" }
+
+Rubyrana.configure do |config|
+  config.default_provider = Rubyrana::Providers::Anthropic.new(
+    api_key: ENV.fetch("ANTHROPIC_API_KEY"),
+    model: ENV.fetch("ANTHROPIC_MODEL", "claude-3-haiku-20240307")
+  )
+end
+
+agent = Rubyrana::Agent.new(load_tools_from: "./tools")
+puts agent.call("Use the hello tool to greet Ajay")

data/lib/rubyrana/agent.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  class Agent
+    def initialize(model: nil, tools: [], load_tools_from: nil, memory: true, history: [], safety_filters: [], store: nil, session_id: nil)
+      @model = model || Rubyrana.config.default_provider
+      raise ConfigurationError, "No provider configured" unless @model
+
+      @tool_registry = ToolRegistry.new(tools)
+      @load_tools_from = load_tools_from
+      @memory = memory
+      @safety_filters = safety_filters
+      @store = store
+      @session_id = session_id
+      @messages = history.dup
+      load_tools_from_directory
+      load_persisted_messages
+    end
+
+    def call(prompt, **opts)
+      apply_safety_filters(prompt)
+      messages = @memory ? @messages.dup : []
+      messages << { role: "user", content: prompt }
+      max_iterations = opts.delete(:max_iterations) || 5
+
+      max_iterations.times do
+        response = @model.complete(messages: messages, tools: @tool_registry.definitions, **opts)
+        text = response[:text] || response["text"] || ""
+        tool_calls = response[:tool_calls] || response["tool_calls"] || []
+        assistant_content = response[:assistant_content] || response["assistant_content"]
+        @last_usage = response[:usage] || response["usage"]
+
+        if tool_calls.any?
+          log_debug("Tool calls requested", tool_calls: tool_calls)
+          if assistant_content
+            messages << { role: "assistant", content: assistant_content }
+          elsif !text.to_s.empty?
+            messages << { role: "assistant", content: text }
+          end
+
+          tool_calls.each do |call|
+            tool_name = call[:name] || call["name"]
+            tool_call_id = call[:id] || call["id"]
+            arguments = call[:arguments] || call["arguments"] || {}
+            tool = @tool_registry.fetch(tool_name)
+            raise ToolError, "Unknown tool: #{tool_name}" unless tool
+
+            log_debug("Running tool", tool: tool_name, arguments: arguments)
+            result = tool.call(**symbolize_keys(arguments))
+            tool_message = { role: "tool", name: tool.name, content: result.to_s }
+            tool_message[:tool_call_id] = tool_call_id if tool_call_id
+            messages << tool_message
+          end
+
+          next
+        end
+
+        apply_safety_filters(text.to_s)
+        messages << { role: "assistant", content: text.to_s }
+        @messages = messages if @memory
+        persist_messages
+        return text.to_s
+      end
+
+      raise ToolError, "Tool loop exceeded max iterations"
+    end
+
+    def stream(prompt, **opts, &block)
+      apply_safety_filters(prompt)
+      messages = @memory ? @messages.dup : []
+      messages << { role: "user", content: prompt }
+
+      output = String.new
+      stream_proc = lambda do |chunk|
+        output << chunk.to_s
+        block.call(chunk) if block
+      end
+
+      if block
+        @model.stream(messages: messages, tools: @tool_registry.definitions, **opts, &stream_proc)
+        apply_safety_filters(output)
+        messages << { role: "assistant", content: output }
+        @messages = messages if @memory
+        persist_messages
+        return
+      end
+
+      Enumerator.new do |yielder|
+        @model.stream(messages: messages, tools: @tool_registry.definitions, **opts) do |chunk|
+          output << chunk.to_s
+          yielder << chunk.to_s
+        end
+
+        apply_safety_filters(output)
+        messages << { role: "assistant", content: output }
+        @messages = messages if @memory
+        persist_messages
+      end
+    end
+
+    def messages
+      @messages.dup
+    end
+
+    def last_usage
+      @last_usage
+    end
+
+    def reset!
+      @messages.clear
+      persist_messages
+    end
+
+    private
+
+    def symbolize_keys(hash)
+      hash.each_with_object({}) do |(key, value), acc|
+        acc[key.to_sym] = value
+      end
+    end
+
+    def log_debug(message, **data)
+      return unless Rubyrana.config.debug
+
+      Rubyrana.config.logger.debug({ message: message, **data })
+    end
+
+    def apply_safety_filters(text)
+      value = text.to_s
+      @safety_filters.each { |filter| filter.enforce!(value) }
+    end
+
+    def load_persisted_messages
+      return unless @store && @session_id
+
+      @messages = @store.load(@session_id)
+    end
+
+    def load_tools_from_directory
+      return unless @load_tools_from
+
+      loader = Rubyrana::Tools::Loader.new(@load_tools_from)
+      loaded = loader.load
+      loaded.each { |tool| @tool_registry.register(tool) }
+    end
+
+    def persist_messages
+      return unless @store && @session_id
+
+      @store.save(@session_id, @messages)
+    end
+  end
+end

data/lib/rubyrana/config.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module Rubyrana
+  class Config
+    attr_accessor :logger, :default_provider, :debug
+
+    def initialize
+      @logger = Logger.new($stdout)
+      @default_provider = nil
+      @debug = false
+    end
+  end
+end

data/lib/rubyrana/errors.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ProviderError < Error; end
+  class ToolError < Error; end
+  class SafetyError < Error; end
+  class PersistenceError < Error; end
+  class RoutingError < Error; end
+end

data/lib/rubyrana/mcp/client.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+
+module Rubyrana
+  module MCP
+    class Client
+      def initialize(command: nil, args: [], io: nil)
+        @command = command
+        @args = args
+        @io = io
+        @id = 0
+      end
+
+      def with_session
+        if @io
+          use_io(@io)
+          initialize_session
+          tools = list_tools.map { |tool_def| tool_from_mcp(tool_def) }
+          return yield tools
+        end
+
+        raise Rubyrana::ConfigurationError, "MCP command is required" unless @command
+
+        Open3.popen3(@command, *@args) do |stdin, stdout, stderr, wait_thr|
+          use_io({ stdin: stdin, stdout: stdout, stderr: stderr, wait_thr: wait_thr })
+
+          initialize_session
+          tools = list_tools.map { |tool_def| tool_from_mcp(tool_def) }
+          yield tools
+        ensure
+          cleanup
+        end
+      end
+
+      private
+
+      def initialize_session
+        send_request("initialize", {
+          protocolVersion: "2024-11-05",
+          capabilities: {},
+          clientInfo: { name: "rubyrana", version: Rubyrana::VERSION }
+        })
+      end
+
+      def list_tools
+        response = send_request("tools/list", {})
+        response.fetch("tools", [])
+      end
+
+      def call_tool(name, arguments)
+        response = send_request("tools/call", {
+          name: name,
+          arguments: arguments
+        })
+
+        response
+      end
+
+      def tool_from_mcp(defn)
+        Rubyrana::Tool.new(
+          defn.fetch("name"),
+          description: defn["description"],
+          schema: defn["inputSchema"]
+        ) do |**args|
+          call_tool(defn.fetch("name"), args)
+        end
+      end
+
+      def send_request(method, params)
+        @id += 1
+        request = {
+          jsonrpc: "2.0",
+          id: @id,
+          method: method,
+          params: params
+        }
+
+        @stdin.write(JSON.dump(request))
+        @stdin.write("\n")
+        @stdin.flush
+
+        read_response(@id)
+      end
+
+      def read_response(request_id)
+        loop do
+          line = @stdout.gets
+          raise Rubyrana::ProviderError, "MCP server closed" unless line
+
+          response = JSON.parse(line)
+          next unless response["id"] == request_id
+
+          if response["error"]
+            raise Rubyrana::ProviderError, response["error"].to_s
+          end
+
+          return response.fetch("result", {})
+        end
+      rescue JSON::ParserError
+        raise Rubyrana::ProviderError, "Invalid MCP response"
+      end
+
+      def cleanup
+        return unless @stdin
+
+        @stdin.close unless @stdin.closed?
+        @stdout.close unless @stdout.closed?
+        @stderr.close unless @stderr.closed?
+        @wait_thr.value if @wait_thr
+      rescue StandardError
+        # Ignore cleanup errors
+      end
+
+      def use_io(io)
+        @stdin = io.fetch(:stdin)
+        @stdout = io.fetch(:stdout)
+        @stderr = io.fetch(:stderr)
+        @wait_thr = io.fetch(:wait_thr, nil)
+      end
+    end
+  end
+end

data/lib/rubyrana/multi_agent.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  class MultiAgent
+    def initialize(agents:, router: nil)
+      @agents = agents
+      @router = router
+    end
+
+    def call(prompt, **opts)
+      agent = @router ? @router.route(prompt, agents: @agents) : @agents.first
+      raise Rubyrana::RoutingError, "No agents configured" unless agent
+
+      agent.call(prompt, **opts)
+    end
+
+    def broadcast(prompt, **opts)
+      @agents.map { |agent| agent.call(prompt, **opts) }
+    end
+  end
+end

data/lib/rubyrana/persistence/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Persistence
+    class Base
+      def load(_session_id)
+        []
+      end
+
+      def save(_session_id, _messages)
+        true
+      end
+    end
+  end
+end

data/lib/rubyrana/persistence/file_store.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Rubyrana
+  module Persistence
+    class FileStore < Base
+      def initialize(directory: ".rubyrana")
+        @directory = directory
+        FileUtils.mkdir_p(@directory)
+      end
+
+      def load(session_id)
+        path = file_path(session_id)
+        return [] unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue StandardError => e
+        raise Rubyrana::PersistenceError, e.message
+      end
+
+      def save(session_id, messages)
+        path = file_path(session_id)
+        File.write(path, JSON.pretty_generate(messages))
+        true
+      rescue StandardError => e
+        raise Rubyrana::PersistenceError, e.message
+      end
+
+      private
+
+      def file_path(session_id)
+        File.join(@directory, "#{session_id}.json")
+      end
+    end
+  end
+end

data/lib/rubyrana/persistence/redis_store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rubyrana
+  module Persistence
+    class RedisStore < Base
+      def initialize(redis:, namespace: "rubyrana")
+        @redis = redis
+        @namespace = namespace
+      end
+
+      def load(session_id)
+        raw = @redis.get(key(session_id))
+        return [] unless raw
+
+        JSON.parse(raw)
+      rescue StandardError => e
+        raise Rubyrana::PersistenceError, e.message
+      end
+
+      def save(session_id, messages)
+        @redis.set(key(session_id), JSON.dump(messages))
+        true
+      rescue StandardError => e
+        raise Rubyrana::PersistenceError, e.message
+      end
+
+      private
+
+      def key(session_id)
+        "#{@namespace}:#{session_id}"
+      end
+    end
+  end
+end

data/lib/rubyrana/providers/anthropic.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Rubyrana
+  module Providers
+    class Anthropic < Base
+      def initialize(api_key:, model:, client: nil)
+        @api_key = api_key
+        @model = model
+        @client = client
+      end
+
+      def complete(prompt: nil, messages: nil, tools: [], **_opts)
+        resolved_messages = format_messages(messages || [{ role: "user", content: prompt }])
+        payload = {
+          model: @model,
+          max_tokens: 1024,
+          messages: resolved_messages
+        }
+
+        if tools.any?
+          payload[:tools] = tools.map do |tool|
+            entry = {
+              name: tool[:name],
+              input_schema: tool[:input_schema] || { type: "object", properties: {}, required: [] }
+            }
+            entry[:description] = tool[:description] if tool[:description]
+            entry
+          end
+        end
+
+        response = request_with_retries do
+          client.post("/v1/messages") do |req|
+            req.headers["x-api-key"] = @api_key
+            req.headers["anthropic-version"] = "2023-06-01"
+            req.headers["Content-Type"] = "application/json"
+            req.body = JSON.dump(payload)
+          end
+        end
+
+        parse_response(response)
+      end
+
+      def stream(prompt: nil, messages: nil, tools: [], **_opts, &block)
+        return super unless block_given?
+
+        resolved_messages = format_messages(messages || [{ role: "user", content: prompt }])
+        payload = {
+          model: @model,
+          max_tokens: 1024,
+          messages: resolved_messages,
+          stream: true
+        }
+
+        if tools.any?
+          payload[:tools] = tools.map do |tool|
+            entry = {
+              name: tool[:name],
+              input_schema: tool[:input_schema] || { type: "object", properties: {}, required: [] }
+            }
+            entry[:description] = tool[:description] if tool[:description]
+            entry
+          end
+        end
+
+        stream_request("/v1/messages", payload, &block)
+      end
+
+      private
+
+      def client
+        @client ||= Faraday.new(url: "https://api.anthropic.com")
+      end
+
+      def parse_response(response)
+        unless response.success?
+          raise ProviderError, "Anthropic request failed (status #{response.status}): #{response.body}"
+        end
+
+        body = JSON.parse(response.body)
+        assistant_content = body["content"] || []
+        text = assistant_content.select { |item| item["type"] == "text" }.map { |item| item["text"] }.join
+        tool_calls = assistant_content.select { |item| item["type"] == "tool_use" }.map do |item|
+          {
+            id: item["id"],
+            name: item["name"],
+            arguments: item["input"] || {}
+          }
+        end
+
+        {
+          text: text,
+          tool_calls: tool_calls,
+          usage: body["usage"],
+          assistant_content: assistant_content
+        }
+      rescue JSON::ParserError
+        raise ProviderError, "Invalid response from Anthropic"
+      end
+
+      def stream_request(path, payload, &block)
+        buffer = String.new
+
+        request_with_retries do
+          client.post(path) do |req|
+            req.headers["x-api-key"] = @api_key
+            req.headers["anthropic-version"] = "2023-06-01"
+            req.headers["Content-Type"] = "application/json"
+            req.options.on_data = proc do |chunk, _|
+              buffer << chunk
+              while (line = buffer.slice!(/.*\n/))
+                line = line.strip
+                next unless line.start_with?("data:")
+
+                data = line.delete_prefix("data:").strip
+                next if data == "[DONE]"
+
+                begin
+                  event = JSON.parse(data)
+                  delta = extract_stream_delta(event)
+                  block.call(delta) if delta && !delta.empty?
+                rescue JSON::ParserError
+                  next
+                end
+              end
+            end
+            req.body = JSON.dump(payload)
+          end
+        end
+      end
+
+      def extract_stream_delta(event)
+        return event.dig("delta", "text") if event["type"] == "content_block_delta"
+        return event.dig("content_block", "text") if event["type"] == "content_block_start"
+
+        nil
+      end
+
+      def format_messages(messages)
+        messages.map do |message|
+          role = message[:role] || message["role"]
+          content = message[:content] || message["content"]
+
+          if role == "tool"
+            tool_use_id = message[:tool_call_id] || message["tool_call_id"]
+            {
+              role: "user",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: tool_use_id,
+                  content: content.to_s
+                }
+              ]
+            }
+          else
+            { role: role, content: content }
+          end
+        end
+      end
+
+      def request_with_retries(max_retries: 2)
+        attempts = 0
+        begin
+          attempts += 1
+          yield
+        rescue Faraday::Error => e
+          retry if attempts <= max_retries
+          raise ProviderError, e.message
+        end
+      end
+    end
+  end
+end

data/lib/rubyrana/providers/base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Providers
+    class Base
+      def complete(prompt: nil, messages: nil, tools: [], **_opts)
+        raise NotImplementedError, "Provider must implement #complete"
+      end
+
+      def stream(prompt: nil, messages: nil, tools: [], **_opts, &block)
+        result = complete(prompt: prompt, messages: messages, tools: tools, **_opts)
+        text = result.is_a?(Hash) ? (result[:text] || result["text"]) : result
+
+        if block_given?
+          yield text.to_s
+          return
+        end
+
+        Enumerator.new do |yielder|
+          yielder << text.to_s
+        end
+      end
+    end
+  end
+end

data/lib/rubyrana/providers/bedrock.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Providers
+    class Bedrock < Base
+      def initialize(*_args, **_kwargs)
+        raise ConfigurationError, "Bedrock provider is not included in this release"
+      end
+    end
+  end
+end