rixie 0.1.0

data/lib/rixie/llm/client.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "client/resolver"
+
+module Rixie
+  module LLM
+    class Client
+      attr_reader :model, :provider
+
+      def initialize(model: nil, provider: nil, adapter: nil, stream: false, request_timeout: nil, max_tokens: nil, temperature: nil, parallel_tool_calls: nil)
+        @model = model
+        @provider = provider
+        @stream = stream
+        @adapter = adapter || Client::Resolver.resolve(
+          model: model,
+          provider: provider,
+          request_timeout: request_timeout,
+          max_tokens: max_tokens,
+          temperature: temperature,
+          parallel_tool_calls: parallel_tool_calls
+        )
+      end
+
+      def call(messages, tools:, &block)
+        if @stream
+          @adapter.stream(messages, tools: tools, &block)
+        else
+          @adapter.chat(messages, tools: tools)
+        end
+      end
+    end
+  end
+end

data/lib/rixie/llm/response.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rixie
+  module LLM
+    Response = Data.define(:content, :tool_calls, :finish_reason) do
+      def self.from_openai_wire(raw)
+        choices = raw["choices"] || []
+        choice = choices.first || {}
+        message = choice["message"] || {}
+        tool_calls = (message["tool_calls"] || []).map { |tc| LLM::ToolCall.from_openai_wire(tc) }
+        new(content: message["content"], tool_calls: tool_calls, finish_reason: choice["finish_reason"])
+      end
+
+      def has_tool_calls?
+        tool_calls.any?
+      end
+    end
+  end
+end

data/lib/rixie/llm/tool_call.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Rixie
+  module LLM
+    class ToolCall
+      attr_reader :id, :name, :arguments
+
+      def initialize(id:, name:, arguments:)
+        @id = id
+        @name = name
+        @arguments = arguments
+      end
+
+      def self.from_openai_wire(raw)
+        new(
+          id: raw["id"],
+          name: raw["function"]["name"],
+          arguments: JSON.parse(raw["function"]["arguments"])
+        )
+      end
+
+      def to_openai_wire
+        {
+          "id" => @id,
+          "type" => "function",
+          "function" => {
+            "name" => @name,
+            "arguments" => JSON.generate(@arguments)
+          }
+        }
+      end
+    end
+  end
+end

data/lib/rixie/mcp/http/client.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module Rixie
+  module MCP
+    module Http
+      class Client
+        MCP_PROTOCOL_VERSION = "2024-11-05"
+
+        def initialize(url:, headers: {}, client_info: nil, http_client: nil)
+          uri = URI.parse(url)
+          @url = url
+          @path = uri.path.empty? ? "/" : uri.path
+          @http_client = Rixie::Http::Client.new(
+            headers: {
+              "Content-Type" => "application/json",
+              "Accept" => "application/json, text/event-stream"
+            }.merge(headers),
+            http_client: http_client,
+            allow_private: true
+          )
+          @client_info = client_info || {name: "rixie", version: Rixie::VERSION}
+          @request_id = 0
+          @session_initialized = false
+        end
+
+        def tools
+          list_tools.map do |tool_def|
+            name = tool_def["name"]
+            Rixie::Tool.new(
+              name: name,
+              description: tool_def["description"],
+              input_schema: tool_def["inputSchema"],
+              call: ->(args) { call_tool(name, args) }
+            )
+          end
+        end
+
+        def list_tools
+          initialize_session
+          result = request("tools/list", {})
+          result.dig("result", "tools") || []
+        end
+
+        def call_tool(name, arguments = {})
+          initialize_session
+          result = request("tools/call", {name: name, arguments: arguments})
+          result.dig("result", "content").map { |c| c["text"] }.join
+        end
+
+        private
+
+        def initialize_session
+          return if @session_initialized
+
+          request("initialize", {
+            protocolVersion: MCP_PROTOCOL_VERSION,
+            capabilities: {},
+            clientInfo: @client_info
+          })
+          @session_initialized = true
+        end
+
+        def request(method, params)
+          @request_id += 1
+          body = JSON.generate({jsonrpc: "2.0", id: @request_id, method: method, params: params})
+
+          response = @http_client.post(@url, body: body)
+          parsed = JSON.parse(response[:body])
+
+          if parsed["error"]
+            raise Rixie::MCP::ProtocolError, parsed.dig("error", "message")
+          end
+
+          parsed
+        rescue Rixie::Http::TimeoutError => e
+          raise Rixie::MCP::TimeoutError, e.message
+        rescue Rixie::Http::Error => e
+          raise Rixie::MCP::RequestError, e.message
+        end
+      end
+    end
+  end
+end

data/lib/rixie/mcp/http.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "rixie/mcp/http/client"

data/lib/rixie/mcp.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "rixie/mcp/http"

data/lib/rixie/message.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Message
+    System = Data.define(:content)
+    User = Data.define(:content)
+    Assistant = Data.define(:content, :tool_calls)
+    Tool = Data.define(:tool_call_id, :content)
+  end
+end

data/lib/rixie/prompt_builder.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rixie
+  class PromptBuilder
+    def build(user_input:, instructions:, context:)
+      messages = []
+      messages << Message::System.new(content: instructions)
+      messages.concat(context.flat_map(&:to_message))
+      messages << Message::User.new(content: user_input)
+      messages
+    end
+  end
+end

data/lib/rixie/run.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Rixie
+  class Run
+    attr_reader :id, :user_input, :agent, :context, :thoughts, :steps, :status, :output
+
+    def initialize(user_input:, agent:, context:)
+      @id = SecureRandom.uuid
+      @user_input = user_input
+      @agent = agent
+      @context = context
+      @thoughts = []
+      @steps = []
+      @status = "running"
+      @output = nil
+    end
+
+    def execute(listener:)
+      listener.run_id = @id
+      listener.emit(Event::RunStart.new(user_input: user_input))
+      messages = PromptBuilder.new.build(
+        user_input: user_input,
+        instructions: agent.instructions,
+        context: context
+      )
+
+      result = agent.think(messages:, listener:)
+      @output = result.content
+      @thoughts = result.thoughts
+      @status = "completed"
+      listener.emit(Event::RunEnd.new(output: @output, status: @status))
+    rescue
+      @status = "failed"
+      listener.emit(Event::RunEnd.new(output: nil, status: @status))
+      raise
+    end
+
+    def add_step(tool_calls:, tool_results:)
+      @steps << {tool_calls: tool_calls, tool_results: tool_results}
+    end
+
+    def completed?
+      @status == "completed"
+    end
+
+    def failed?
+      @status == "failed"
+    end
+
+    def find_tool_call(name)
+      thoughts.select(&:tool_call?).flat_map(&:tool_calls).find { it.name == name }
+    end
+
+    def to_history
+      Context::History.new(input: user_input, thoughts: thoughts, output: output)
+    end
+  end
+end

data/lib/rixie/search/base.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Search
+    # Interface for search providers.
+    # Implementations must return Array<Hash> with keys: title, snippet, url.
+    class Base
+      def search(query, max_results:)
+        raise Rixie::NotImplementedError, "#{self.class}#search not implemented"
+      end
+    end
+  end
+end

data/lib/rixie/search/duck_duck_go.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Rixie
+  module Search
+    class DuckDuckGo < Base
+      SEARCH_URL = "https://lite.duckduckgo.com/lite/"
+      DEFAULT_MAX_RESULTS = 5
+
+      def initialize(http_client: nil)
+        @http_client = Rixie::Http::Client.new(
+          headers: {
+            "Accept" => "text/html",
+            "Accept-Language" => "en-US,en;q=0.9"
+          },
+          http_client: http_client
+        )
+      end
+
+      def search(query, max_results: DEFAULT_MAX_RESULTS)
+        begin
+          require "nokogiri"
+        rescue LoadError
+          raise Rixie::ConfigurationError, "nokogiri gem is required for Search::DuckDuckGo. Add `gem 'nokogiri'` to your Gemfile."
+        end
+
+        url = "#{SEARCH_URL}?q=#{URI.encode_www_form_component(query)}"
+        response = @http_client.get(url)
+        doc = Nokogiri::HTML(response[:body])
+        parse_results(doc, max_results)
+      end
+
+      private
+
+      def parse_results(doc, max_results)
+        results = []
+        doc.css("a.result-link").each do |a|
+          url = extract_url(a["href"].to_s)
+          next unless url
+
+          title = a.text.strip
+          next if title.empty?
+
+          snippet_td = a.ancestors("tr").first&.next_element&.css("td.result-snippet")&.first
+          snippet = snippet_td&.text&.strip.to_s
+
+          results << {title: title, url: url, snippet: snippet}
+          break if results.size >= max_results
+        end
+        results
+      rescue
+        []
+      end
+
+      def extract_url(href)
+        return nil unless href.to_s.start_with?("//")
+
+        uddg = URI.decode_www_form(URI.parse("https:#{href}").query.to_s).to_h["uddg"]
+        uddg if uddg&.match?(/\Ahttps?:\/\//)
+      rescue URI::InvalidURIError
+        nil
+      end
+    end
+  end
+end

data/lib/rixie/search/wikipedia.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module Rixie
+  module Search
+    class Wikipedia < Base
+      DEFAULT_MAX_RESULTS = 5
+      DEFAULT_LANGUAGE = "en"
+
+      def initialize(language: DEFAULT_LANGUAGE, http_client: nil)
+        @language = language
+        @http_client = Rixie::Http::Client.new(
+          headers: {"Accept" => "application/json"},
+          http_client: http_client
+        )
+      end
+
+      def search(query, max_results: DEFAULT_MAX_RESULTS)
+        response = @http_client.get(build_url(query, max_results))
+        data = JSON.parse(response[:body].to_s)
+        Array(data.dig("query", "search")).map { |hit| format_result(hit) }
+      rescue JSON::ParserError
+        []
+      end
+
+      private
+
+      def build_url(query, max_results)
+        params = URI.encode_www_form(
+          action: "query",
+          list: "search",
+          srsearch: query,
+          srlimit: max_results,
+          format: "json",
+          formatversion: 2
+        )
+        "https://#{@language}.wikipedia.org/w/api.php?#{params}"
+      end
+
+      def format_result(hit)
+        title = hit["title"].to_s
+        {
+          title: title,
+          snippet: strip_html(hit["snippet"].to_s),
+          url: "https://#{@language}.wikipedia.org/wiki/#{URI.encode_www_form_component(title.tr(" ", "_"))}"
+        }
+      end
+
+      ENTITIES = {"&quot;" => '"', "&amp;" => "&", "&lt;" => "<", "&gt;" => ">", "&#39;" => "'", "&nbsp;" => " "}.freeze
+      private_constant :ENTITIES
+
+      def strip_html(text)
+        text.gsub(/<[^>]+>/, "").gsub(/&\w+;|&#\d+;/) { |e| ENTITIES[e] || e }.strip
+      end
+    end
+  end
+end

data/lib/rixie/session.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Rixie
+  class Session
+    attr_reader :agent, :tasks, :session_id, :stream_client
+
+    def initialize(agent: nil, stream_client: nil, instructions: nil, tools: [], model: nil, provider: nil, max_steps: nil, llm_client: nil, store: nil, initial_context: [], request_timeout: nil, max_tokens: nil, temperature: nil, token_counter: nil, parallel_tool_calls: false, subscribers: [])
+      resolved_provider = provider || Rixie.config.default_provider
+      resolved_model = model || Rixie.config.default_model
+      resolved_timeout = request_timeout || Rixie.config.request_timeout
+
+      resolved_max_tokens = max_tokens || Rixie.config.default_max_tokens
+      resolved_temperature = temperature || Rixie.config.default_temperature
+
+      @agent = agent || Agent.new(
+        instructions: instructions,
+        tools: tools,
+        max_steps: max_steps || Rixie.config.default_max_steps,
+        parallel_tool_calls: parallel_tool_calls,
+        llm_client: llm_client || LLM::Client.new(
+          model: resolved_model,
+          provider: resolved_provider,
+          request_timeout: resolved_timeout,
+          max_tokens: resolved_max_tokens,
+          temperature: resolved_temperature,
+          parallel_tool_calls: parallel_tool_calls
+        )
+      )
+
+      @stream_client = if agent.nil?
+        stream_client || (resolved_provider ? LLM::Client.new(
+          model: resolved_model,
+          provider: resolved_provider,
+          stream: true,
+          request_timeout: resolved_timeout,
+          max_tokens: resolved_max_tokens,
+          temperature: resolved_temperature,
+          parallel_tool_calls: parallel_tool_calls
+        ) : nil)
+      else
+        stream_client
+      end
+
+      default_subs = Rixie.config.default_subscribers || [default_log_subscriber]
+      @subscribers = default_subs + subscribers
+      @store = store || Rixie.config.store || Store::Memory.new
+      @token_counter = token_counter || TokenCounter::DEFAULT
+      @initial_context = initial_context
+      @session_id = SecureRandom.uuid
+      @tasks = []
+      @summary = nil
+    end
+
+    def chat(user_input, strategy: Strategy::Simple.new)
+      task = Task.new(user_input: user_input, agent: agent, context: context, strategy: strategy, subscribers: @subscribers, session_id: @session_id)
+      task.execute
+      @tasks << task
+      @store.save(@session_id, context)
+      task.output
+    end
+
+    def live(user_input, strategy: Strategy::Simple.new)
+      Enumerator.new do |yielder|
+        stream_agent = @agent.with_llm_client(@stream_client)
+        stream_sub = build_stream_subscriber(yielder)
+
+        task = Task.new(
+          user_input: user_input,
+          agent: stream_agent,
+          context: context,
+          strategy: strategy,
+          subscribers: @subscribers + [stream_sub],
+          session_id: @session_id
+        )
+        task.execute
+        @tasks << task
+        @store.save(@session_id, context)
+      end
+    end
+
+    def compress!(keep_recent: 0, compressor: nil)
+      return if context.empty?
+
+      recent = context.last(keep_recent)
+      to_compress = context.first(context.size - recent.size)
+
+      return if to_compress.empty?
+
+      summary_input = to_compress.flat_map(&:to_message).map { |msg|
+        case msg
+        when Message::System then "[system] #{msg.content}"
+        when Message::User then "[user] #{msg.content}"
+        when Message::Assistant then "[assistant] #{msg.content}"
+        when Message::Tool then "[tool_result id=#{msg.tool_call_id}] #{msg.content}"
+        end
+      }.join("\n\n")
+
+      listener = EventListener.new(session_id: @session_id)
+      @subscribers.each { |s| s.subscribe(listener) }
+      listener.emit(Event::CompressionStart.new(entry_count: to_compress.size, keep_recent: keep_recent))
+
+      task = Task.new(
+        user_input: summary_input,
+        agent: compressor || Agent::Compressor.new(base_agent: @agent),
+        context: [],
+        strategy: Strategy::Simple.new
+      )
+      task.execute
+
+      @summary = Context::Summary.new(content: task.output)
+      @tasks = []
+      @initial_context = recent
+      @store.save(@session_id, context)
+      listener.emit(Event::CompressionEnd.new(status: "completed", entry_count: context.size))
+    rescue
+      listener&.emit(Event::CompressionEnd.new(status: "failed", entry_count: nil))
+      raise
+    end
+
+    def context_size
+      @token_counter.call(context.flat_map(&:to_message))
+    end
+
+    def context
+      base = @summary ? [@summary] : []
+      base + @initial_context + @tasks.select(&:completed?).flat_map(&:to_history)
+    end
+
+    private
+
+    def default_log_subscriber
+      case Rixie.config.log_format
+      when :json then Rixie::Subscribers::JsonLogger.new(logger: Rixie.config.logger)
+      else Rixie::Subscribers::Logger.new(logger: Rixie.config.logger)
+      end
+    end
+
+    def build_stream_subscriber(yielder)
+      sub = Object.new
+      sub.define_singleton_method(:subscribe) do |listener|
+        listener.on(Event::Token) { |envelope| yielder << envelope }
+        listener.on(Event::ThoughtCompleted) { |envelope| yielder << envelope }
+        listener.on(Event::Finished) { |envelope| yielder << envelope }
+        listener.on(Event::ToolCallStart) { |envelope| yielder << envelope }
+        listener.on(Event::ToolCallEnd) { |envelope| yielder << envelope }
+        listener.on(Event::ToolCallsCompleted) { |envelope| yielder << envelope }
+      end
+      sub
+    end
+  end
+end

data/lib/rixie/store/base.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Store
+    # Interface definition for storage adapters.
+    # Subclasses must implement #save and #load.
+    class Base
+      # Persists context for the given session_id.
+      # @param session_id [String]
+      # @param context [Array]
+      def save(session_id, context)
+        raise Rixie::NotImplementedError, "#{self.class}#save is not implemented"
+      end
+
+      # Retrieves context for the given session_id.
+      # @param session_id [String]
+      # @return [Array]
+      def load(session_id)
+        raise Rixie::NotImplementedError, "#{self.class}#load is not implemented"
+      end
+
+      # Serializes context for storage.
+      # @param context [Array<Context::History, Context::Summary>]
+      # @return [Array<Hash>]
+      def serialize(context)
+        raise Rixie::NotImplementedError, "#{self.class}#serialize is not implemented"
+      end
+
+      # Deserializes a single stored entry.
+      # @param entry [Hash] with a "type" key ("summary" or "history")
+      # @return [Context::History, Context::Summary]
+      def self.deserialize(entry)
+        raise Rixie::NotImplementedError, "#{self}.deserialize is not implemented"
+      end
+    end
+  end
+end

data/lib/rixie/store/memory.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Store
+    class Memory < Base
+      def initialize
+        @data = {}
+      end
+
+      def save(session_id, context)
+        @data[session_id] = context.map(&:to_store)
+      end
+
+      def load(session_id)
+        entries = @data.fetch(session_id, nil)
+        return [] if entries.nil?
+
+        entries.map { |entry| self.class.deserialize(entry) }
+      end
+
+      def self.deserialize(entry)
+        case entry["type"]
+        when "summary" then Context::Summary.from_store(entry)
+        when "history" then Context::History.from_store(entry)
+        else raise Rixie::Error, "Unknown context entry type: #{entry["type"]}"
+        end
+      end
+    end
+  end
+end

data/lib/rixie/store/null.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Store
+    class Null < Base
+      def save(session_id, context)
+        # no-op
+      end
+
+      def load(session_id)
+        []
+      end
+
+      def self.deserialize(entry)
+        []
+      end
+    end
+  end
+end