rubyrana 0.1.0

data/lib/rubyrana/providers/openai.rb

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

data/lib/rubyrana/routing/keyword_router.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Routing
+    class KeywordRouter
+      def initialize(routes: {}, default_index: 0)
+        @routes = routes
+        @default_index = default_index
+      end
+
+      def route(prompt, agents:)
+        match = @routes.find { |keyword, _| prompt.to_s.downcase.include?(keyword.to_s.downcase) }
+        index = match ? match[1] : @default_index
+        agents.fetch(index)
+      rescue IndexError
+        raise Rubyrana::RoutingError, "No agent found for route"
+      end
+    end
+  end
+end

data/lib/rubyrana/safety/filter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Safety
+    class Filter
+      def check(_text)
+        []
+      end
+
+      def enforce!(text)
+        violations = check(text)
+        return if violations.empty?
+
+        raise Rubyrana::SafetyError, "Safety filter triggered: #{violations.join(", ")}" if violations.any?
+      end
+    end
+
+    class BlocklistFilter < Filter
+      def initialize(patterns: [])
+        @patterns = patterns.map { |p| p.is_a?(Regexp) ? p : /#{Regexp.escape(p)}/i }
+      end
+
+      def check(text)
+        @patterns.select { |pattern| text.match?(pattern) }.map(&:source)
+      end
+    end
+  end
+end

data/lib/rubyrana/tool.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  class Tool
+    attr_reader :name, :description, :schema
+
+    def initialize(name, description: nil, schema: nil, &block)
+      raise ToolError, "Tool requires a block" unless block_given?
+
+      @name = name.to_s
+      @description = description
+      @schema = schema
+      @block = block
+    end
+
+    def call(**kwargs)
+      @block.call(**kwargs)
+    rescue StandardError => e
+      raise ToolError, e.message
+    end
+
+    def to_h
+      {
+        name: name,
+        description: description,
+        input_schema: schema || { type: "object", properties: {}, required: [] }
+      }
+    end
+  end
+end

data/lib/rubyrana/tool_registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  class ToolRegistry
+    def initialize(tools = [])
+      @tools = {}
+      tools.each { |tool| register(tool) }
+    end
+
+    def register(tool)
+      @tools[tool.name] = tool
+    end
+
+    def fetch(name)
+      @tools[name.to_s]
+    end
+
+    def all
+      @tools.values
+    end
+
+    def definitions
+      all.map(&:to_h)
+    end
+  end
+end

data/lib/rubyrana/tooling.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Tooling
+    @registry = Rubyrana::ToolRegistry.new
+
+    class << self
+      attr_reader :registry
+
+      def reset!
+        @registry = Rubyrana::ToolRegistry.new
+      end
+
+      def register(tool)
+        @registry.register(tool)
+        tool
+      end
+
+      def tools
+        @registry.all
+      end
+
+      def define(name, description: nil, schema: nil, &block)
+        tool = Rubyrana::Tool.new(name, description: description, schema: schema, &block)
+        register(tool)
+      end
+    end
+  end
+
+  def self.tool(name, description: nil, schema: nil, &block)
+    Tooling.define(name, description: description, schema: schema, &block)
+  end
+end

data/lib/rubyrana/tools/code_interpreter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "json"
+require "open3"
+require "tempfile"
+require "timeout"
+
+module Rubyrana
+  module Tools
+    class CodeInterpreter
+      DEFAULT_TIMEOUT = 5
+
+      def initialize(timeout_s: DEFAULT_TIMEOUT, ruby_bin: "ruby")
+        @timeout_s = timeout_s
+        @ruby_bin = ruby_bin
+      end
+
+      def tool
+        Rubyrana::Tool.new(
+          "code_interpreter",
+          description: "Run Ruby code in a temporary process and return stdout/stderr.",
+          schema: {
+            type: "object",
+            properties: {
+              code: { type: "string" },
+              timeout_s: { type: "number" }
+            },
+            required: ["code"]
+          }
+        ) do |code:, timeout_s: nil|
+          execute(code: code, timeout_s: timeout_s)
+        end
+      end
+
+      private
+
+      def execute(code:, timeout_s: nil)
+        timeout_value = (timeout_s || @timeout_s).to_f
+
+        Tempfile.create(["rubyrana", ".rb"]) do |file|
+          file.write(code)
+          file.flush
+
+          stdout, stderr, status = run_with_timeout(file.path, timeout_value)
+          {
+            stdout: stdout,
+            stderr: stderr,
+            exit_status: status&.exitstatus
+          }.to_json
+        end
+      rescue Timeout::Error
+        { stdout: "", stderr: "Execution timed out", exit_status: nil }.to_json
+      end
+
+      def run_with_timeout(path, timeout_value)
+        stdout = ""
+        stderr = ""
+        status = nil
+
+        Timeout.timeout(timeout_value) do
+          stdout, stderr, status = Open3.capture3(@ruby_bin, path)
+        end
+
+        [stdout, stderr, status]
+      end
+    end
+  end
+end

data/lib/rubyrana/tools/loader.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Tools
+    class Loader
+      def initialize(directory)
+        @directory = directory
+      end
+
+      def load
+        return [] unless Dir.exist?(@directory)
+
+        before = Rubyrana::Tooling.tools.dup
+        Dir[File.join(@directory, "**/*.rb")].sort.each { |file| require file }
+        after = Rubyrana::Tooling.tools
+        (after - before)
+      end
+    end
+  end
+end

data/lib/rubyrana/tools/mcp_web_search.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  module Tools
+    class MCPWebSearch
+      def initialize(command:, args: [], tool_name: "web_search")
+        @command = command
+        @args = args
+        @tool_name = tool_name
+      end
+
+      def tool
+        Rubyrana::Tool.new(
+          "web_search",
+          description: "Web search via MCP server tool.",
+          schema: {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+              limit: { type: "number" }
+            },
+            required: ["query"]
+          }
+        ) do |query:, limit: 5|
+          mcp = Rubyrana::MCP::Client.new(command: @command, args: @args)
+          mcp.with_session do |tools|
+            tool = tools.find { |t| t.name == @tool_name }
+            raise Rubyrana::ToolError, "MCP tool not found: #{@tool_name}" unless tool
+
+            tool.call(query: query, limit: limit)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubyrana/tools/web_search.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module Rubyrana
+  module Tools
+    class WebSearch
+      DEFAULT_PROVIDER = "serper"
+
+      def initialize(api_key: ENV["WEB_SEARCH_API_KEY"], provider: DEFAULT_PROVIDER, ssl_cert_file: ENV["SSL_CERT_FILE"])
+        @api_key = api_key
+        @provider = provider
+        @ssl_cert_file = ssl_cert_file
+      end
+
+      def tool
+        Rubyrana::Tool.new(
+          "web_search",
+          description: "Search the web and return top results.",
+          schema: {
+            type: "object",
+            properties: {
+              query: { type: "string" },
+              limit: { type: "number" }
+            },
+            required: ["query"]
+          }
+        ) do |query:, limit: 5|
+          search(query: query, limit: limit)
+        end
+      end
+
+      private
+
+      def search(query:, limit: 5)
+        raise Rubyrana::ConfigurationError, "WEB_SEARCH_API_KEY not set. Users must supply their own web search API key." unless @api_key
+
+        case @provider
+        when "serper"
+          serper_search(query: query, limit: limit)
+        else
+          raise Rubyrana::ConfigurationError, "Unsupported web search provider: #{@provider}"
+        end
+      end
+
+      def serper_search(query:, limit:)
+        uri = URI("https://google.serper.dev/search")
+        request = Net::HTTP::Post.new(uri)
+        request["X-API-KEY"] = @api_key
+        request["Content-Type"] = "application/json"
+        request.body = JSON.dump({ q: query, num: limit })
+
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.ca_file = @ssl_cert_file if @ssl_cert_file && !@ssl_cert_file.empty?
+          http.request(request)
+        end
+
+        raise Rubyrana::ProviderError, "Web search failed (status #{response.code})" unless response.is_a?(Net::HTTPSuccess)
+
+        body = JSON.parse(response.body)
+        results = (body["organic"] || []).first(limit).map do |item|
+          {
+            title: item["title"],
+            url: item["link"],
+            snippet: item["snippet"]
+          }
+        end
+
+        { results: results }.to_json
+      rescue JSON::ParserError
+        raise Rubyrana::ProviderError, "Invalid web search response"
+      end
+    end
+  end
+end

data/lib/rubyrana/tools.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "tools/code_interpreter"
+require_relative "tools/mcp_web_search"
+require_relative "tools/loader"
+require_relative "tools/web_search"
+
+module Rubyrana
+  module Tools
+    def self.code_interpreter(timeout_s: CodeInterpreter::DEFAULT_TIMEOUT)
+      CodeInterpreter.new(timeout_s: timeout_s).tool
+    end
+
+    def self.web_search(api_key: ENV["WEB_SEARCH_API_KEY"], provider: WebSearch::DEFAULT_PROVIDER)
+      WebSearch.new(api_key: api_key, provider: provider).tool
+    end
+
+    def self.web_search_mcp(command:, args: [], tool_name: "web_search")
+      MCPWebSearch.new(command: command, args: args, tool_name: tool_name).tool
+    end
+  end
+end

data/lib/rubyrana/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rubyrana
+  VERSION = "0.1.0"
+end

data/lib/rubyrana.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "rubyrana/version"
+require_relative "rubyrana/errors"
+require_relative "rubyrana/config"
+require_relative "rubyrana/tool"
+require_relative "rubyrana/tool_registry"
+require_relative "rubyrana/tooling"
+require_relative "rubyrana/agent"
+require_relative "rubyrana/tools"
+require_relative "rubyrana/multi_agent"
+require_relative "rubyrana/safety/filter"
+require_relative "rubyrana/persistence/base"
+require_relative "rubyrana/persistence/file_store"
+require_relative "rubyrana/persistence/redis_store"
+require_relative "rubyrana/routing/keyword_router"
+require_relative "rubyrana/mcp/client"
+require_relative "rubyrana/providers/base"
+require_relative "rubyrana/providers/openai"
+require_relative "rubyrana/providers/anthropic"
+require_relative "rubyrana/providers/bedrock"
+
+module Rubyrana
+  class << self
+    def configure
+      yield(config)
+    end
+
+    def config
+      @config ||= Rubyrana::Config.new
+    end
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: rubyrana
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rubyrana Contributors
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Rubyrana is a model-driven Ruby SDK for building AI agents.
+email:
+- hello@rubyrana.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- NOTICE
+- README.md
+- REPORT.md
+- docs/CHECKLIST.md
+- docs/RELEASE.md
+- docs/USAGE.md
+- examples/mcp.rb
+- examples/quick_start.rb
+- examples/streaming.rb
+- examples/tools_loader.rb
+- lib/rubyrana.rb
+- lib/rubyrana/agent.rb
+- lib/rubyrana/config.rb
+- lib/rubyrana/errors.rb
+- lib/rubyrana/mcp/client.rb
+- lib/rubyrana/multi_agent.rb
+- lib/rubyrana/persistence/base.rb
+- lib/rubyrana/persistence/file_store.rb
+- lib/rubyrana/persistence/redis_store.rb
+- lib/rubyrana/providers/anthropic.rb
+- lib/rubyrana/providers/base.rb
+- lib/rubyrana/providers/bedrock.rb
+- lib/rubyrana/providers/openai.rb
+- lib/rubyrana/routing/keyword_router.rb
+- lib/rubyrana/safety/filter.rb
+- lib/rubyrana/tool.rb
+- lib/rubyrana/tool_registry.rb
+- lib/rubyrana/tooling.rb
+- lib/rubyrana/tools.rb
+- lib/rubyrana/tools/code_interpreter.rb
+- lib/rubyrana/tools/loader.rb
+- lib/rubyrana/tools/mcp_web_search.rb
+- lib/rubyrana/tools/web_search.rb
+- lib/rubyrana/version.rb
+homepage: https://github.com/your-org/rubyrana
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.27
+signing_key:
+specification_version: 4
+summary: Build production-ready AI agents in Ruby
+test_files: []