rixie 0.1.0

data/lib/rixie/context/plan.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Context
+    class Plan
+      def initialize(steps:, current_step:)
+        @steps = steps
+        @current_step = current_step
+      end
+
+      def to_message
+        numbered = @steps.each_with_index.map { |s, i| "#{i + 1}. #{s[:title]}" }.join("\n")
+        content = <<~PROMPT
+          You are executing one step of a multi-step plan. Your output for this step will be combined with the outputs of other steps into a single response.
+
+          Full plan:
+          #{numbered}
+
+          Current step: #{@current_step[:title]}
+          #{@current_step[:description]}
+
+          Output instructions:
+          - Produce only the content for this step. Do not summarize other steps.
+          - Do not add closing remarks, transition sentences, or offers to elaborate (e.g. "Feel free to ask if you want more details").
+          - Write as if the reader will continue reading the next step's output immediately after.
+        PROMPT
+        [Message::System.new(content: content)]
+      end
+    end
+  end
+end

data/lib/rixie/context/summary.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Context
+    class Summary
+      attr_reader :content
+
+      def initialize(content:)
+        @content = content
+      end
+
+      def self.from_store(entry)
+        new(content: entry["content"])
+      end
+
+      def to_message
+        [Message::System.new(content: "Previous conversation summary:\n#{@content}")]
+      end
+
+      def to_store
+        {"type" => "summary", "content" => @content}
+      end
+    end
+  end
+end

data/lib/rixie/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Rixie
+  class Error < StandardError; end
+
+  class ConfigurationError < Error; end
+  class NoProviderError < ConfigurationError; end
+  class UnknownProviderError < ConfigurationError; end
+
+  class NotImplementedError < Error; end
+
+  class AgentError < Error; end
+  class MaxStepsExceededError < AgentError; end
+  class ToolNotFoundError < AgentError; end
+
+  module LLM
+    class Error < ::Rixie::Error; end
+    class ResponseTruncatedError < Error; end
+  end
+
+  module Http
+    class Error < ::Rixie::Error; end
+    class TimeoutError < Error; end
+    class ConnectionError < Error; end
+    class SSRFError < Error; end
+  end
+
+  module MCP
+    class Error < ::Rixie::Error; end
+    class TimeoutError < Error; end
+    class ProtocolError < Error; end
+    class RequestError < Error; end
+  end
+end

data/lib/rixie/event/compression_end.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    CompressionEnd = Data.define(:status, :entry_count)
+  end
+end

data/lib/rixie/event/compression_start.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    CompressionStart = Data.define(:entry_count, :keep_recent)
+  end
+end

data/lib/rixie/event/envelope.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    Envelope = Data.define(:event, :occurred_at, :session_id, :task_id, :run_id, :sequence_number, :event_id)
+  end
+end

data/lib/rixie/event/finished.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    Finished = Data.define(:content)
+  end
+end

data/lib/rixie/event/llm_call_start.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    LlmCallStart = Data.define(:step_count)
+  end
+end

data/lib/rixie/event/run_end.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    RunEnd = Data.define(:output, :status)
+  end
+end

data/lib/rixie/event/run_start.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    RunStart = Data.define(:user_input)
+  end
+end

data/lib/rixie/event/task_end.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    TaskEnd = Data.define(:output, :status)
+  end
+end

data/lib/rixie/event/task_start.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    TaskStart = Data.define(:user_input, :strategy)
+  end
+end

data/lib/rixie/event/thought_completed.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    ThoughtCompleted = Data.define(:thought)
+  end
+end

data/lib/rixie/event/token.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    Token = Data.define(:delta)
+  end
+end

data/lib/rixie/event/tool_call_end.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    ToolCallEnd = Data.define(:tool_call, :result)
+  end
+end

data/lib/rixie/event/tool_call_start.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    ToolCallStart = Data.define(:tool_call)
+  end
+end

data/lib/rixie/event/tool_calls_completed.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Rixie
+  module Event
+    ToolCallsCompleted = Data.define(:tool_calls, :tool_results)
+  end
+end

data/lib/rixie/event.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "rixie/event/envelope"
+require "rixie/event/token"
+require "rixie/event/thought_completed"
+require "rixie/event/finished"
+require "rixie/event/tool_call_start"
+require "rixie/event/tool_call_end"
+require "rixie/event/tool_calls_completed"
+require "rixie/event/llm_call_start"
+require "rixie/event/run_start"
+require "rixie/event/run_end"
+require "rixie/event/task_start"
+require "rixie/event/task_end"
+require "rixie/event/compression_start"
+require "rixie/event/compression_end"

data/lib/rixie/event_listener.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Rixie
+  class EventListener
+    def initialize(session_id: nil, task_id: nil)
+      @session_id = session_id
+      @task_id = task_id
+      @run_id = nil
+      @sequence_number = 0
+      @listeners = Hash.new { |h, k| h[k] = [] }
+    end
+
+    attr_writer :run_id
+
+    def on(event_class, &block)
+      @listeners[event_class] << block
+      self
+    end
+
+    def emit(event)
+      @sequence_number += 1
+      envelope = Event::Envelope.new(
+        event: event,
+        occurred_at: Time.now,
+        session_id: @session_id,
+        task_id: @task_id,
+        run_id: @run_id,
+        sequence_number: @sequence_number,
+        event_id: SecureRandom.uuid
+      )
+      @listeners[event.class].each { |block| block.call(envelope) }
+    end
+  end
+end

data/lib/rixie/http/client.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "zlib"
+require "stringio"
+require "openssl"
+require "socket"
+
+module Rixie
+  module Http
+    class Client
+      DEFAULT_TIMEOUT = 30
+      DEFAULT_HEADERS = {"User-Agent" => "Rixie/#{Rixie::VERSION}"}.freeze
+      CONNECTION_ERRORS = [
+        Errno::EHOSTUNREACH, Errno::ECONNRESET, Errno::ECONNREFUSED,
+        Errno::EADDRNOTAVAIL, Errno::ENETUNREACH,
+        SocketError, OpenSSL::SSL::SSLError
+      ].freeze
+      REDIRECT_CODES = [301, 302, 303, 307, 308].freeze
+
+      def initialize(timeout: DEFAULT_TIMEOUT, headers: {}, http_client: nil, allow_private: false)
+        @timeout = timeout
+        @default_headers = DEFAULT_HEADERS.merge(headers)
+        @http_client = http_client
+        @allow_private = allow_private
+      end
+
+      def get(url)
+        validate_url!(url)
+        execute_request(url) { |uri| Net::HTTP::Get.new(uri) }
+      end
+
+      def post(url, body: nil)
+        validate_url!(url)
+        execute_request(url) do |uri|
+          req = Net::HTTP::Post.new(uri)
+          req.body = body
+          req
+        end
+      end
+
+      private
+
+      def validate_url!(url)
+        uri = URI.parse(url)
+        raise Rixie::Http::SSRFError, "Blocked scheme: #{uri.scheme}" unless %w[http https].include?(uri.scheme)
+        return if @allow_private
+        host = uri.host.to_s
+        raise Rixie::Http::SSRFError, "Blocked host: #{host}" if blocked_host?(host)
+      end
+
+      def execute_request(url, redirect_count: 0, &build_request)
+        uri = URI.parse(url)
+        http = http_client_for(uri)
+        request = build_request.call(uri)
+        @default_headers.each { |k, v| request[k] = v }
+        response = http.request(request)
+
+        return follow_redirect(url, response, redirect_count) if REDIRECT_CODES.include?(response.code.to_i)
+
+        {status: response.code.to_i, headers: normalize_headers(response.to_hash), body: decode_body(response)}
+      rescue Net::OpenTimeout, Net::ReadTimeout => e
+        raise Rixie::Http::TimeoutError, e.message
+      rescue *CONNECTION_ERRORS => e
+        raise Rixie::Http::ConnectionError, e.message
+      rescue Rixie::Http::Error
+        raise
+      rescue => e
+        raise Rixie::Http::Error, e.message
+      end
+
+      MAX_REDIRECTS = 5
+      private_constant :MAX_REDIRECTS
+      def follow_redirect(original_url, response, redirect_count)
+        raise Rixie::Http::ConnectionError, "Too many redirects" if redirect_count >= MAX_REDIRECTS
+        location = response["location"]
+        raise Rixie::Http::ConnectionError, "Redirect missing Location header" unless location
+        location = URI.join(original_url, location).to_s
+        validate_url!(location)
+        execute_request(location, redirect_count: redirect_count + 1) { |u| Net::HTTP::Get.new(u) }
+      end
+
+      def http_client_for(uri)
+        return @http_client if @http_client
+
+        build_http_client(uri)
+      end
+
+      def build_http_client(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        unless @allow_private
+          addresses = Socket.getaddrinfo(uri.host, nil, nil, :STREAM).map { |a| a[3] }
+          addresses.each do |ip|
+            raise Rixie::Http::SSRFError, "Blocked host: #{ip}" if blocked_host?(ip)
+          end
+          http.ipaddr = addresses.first
+        end
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @timeout
+        http.read_timeout = @timeout
+        http
+      end
+
+      # NOTE: This regex is not exhaustive but covers common private IP ranges and localhost.
+      #       The http client also performs DNS resolution and checks resolved IPs against this pattern to mitigate SSRF risks.
+      BLOCKED_HOSTS = /\A(127\.|10\.|192\.168\.|172\.(1[6-9]|2\d|3[01])\.|localhost|0\.0\.0\.0)/
+      private_constant :BLOCKED_HOSTS
+      def blocked_host?(host)
+        return true if host.match?(BLOCKED_HOSTS)
+        lower = host.delete_prefix("[").delete_suffix("]").downcase
+        for_ipv6 = ->(host, lower) {
+          ipv6_host = host.include?(":")
+          loopback = lower == "::1"
+          private_host = lower.start_with?("fc", "fd", "fe80:", "::ffff:")
+          ipv6_host && (loopback || private_host)
+        }
+        for_ipv6.call(host, lower)
+      end
+
+      def normalize_headers(headers)
+        headers.transform_keys(&:downcase)
+      end
+
+      def decode_body(response)
+        encoding = response["content-encoding"]
+        return response.body unless encoding
+
+        case encoding.downcase
+        when "gzip"
+          Zlib::GzipReader.new(StringIO.new(response.body)).read
+        when "deflate"
+          Zlib::Inflate.inflate(response.body)
+        else
+          response.body
+        end
+      end
+    end
+  end
+end

data/lib/rixie/llm/adapter/dummy.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Rixie
+  module LLM
+    module Adapter
+      class Dummy
+        DEFAULT_RESPONSE = {
+          "choices" => [{
+            "finish_reason" => "stop",
+            "message" => {"role" => "assistant", "content" => "[mock llm generated content]"}
+          }]
+        }.freeze
+
+        def initialize(responses = nil, **_)
+          @responses = responses.is_a?(Array) ? responses.dup : nil
+        end
+
+        def chat(messages, tools:)
+          if @responses.nil?
+            return Rixie::LLM::Response.from_openai_wire(DEFAULT_RESPONSE)
+          end
+
+          raise "Rixie::LLM::Adapter::Dummy exhausted: no more responses enqueued" if @responses.empty?
+
+          Rixie::LLM::Response.from_openai_wire(@responses.shift)
+        end
+
+        def stream(messages, tools:, &block)
+          response = chat(messages, tools: tools)
+          if (content = response.content)
+            block.call(Rixie::Event::Token.new(delta: content))
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/rixie/llm/adapter/openai.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+begin
+  require "openai"
+rescue LoadError
+  raise Rixie::ConfigurationError, "openai gem is required. Add `gem 'openai'` to your Gemfile."
+end
+
+module Rixie
+  module LLM
+    module Adapter
+      class OpenAI
+        def initialize(model:, base_url:, api_key:, request_timeout: nil, max_tokens: nil, temperature: nil, parallel_tool_calls: true)
+          @model = model
+          @max_tokens = max_tokens
+          @temperature = temperature
+          @parallel_tool_calls = parallel_tool_calls
+          params = {api_key: api_key, base_url: base_url}
+          params[:timeout] = request_timeout if request_timeout
+          @client = ::OpenAI::Client.new(**params)
+        end
+
+        def chat(messages, tools:)
+          result = @client.chat.completions.create(**build_params(encode_messages(messages), tools))
+          Rixie::LLM::Response.from_openai_wire(normalize(result))
+        rescue ::OpenAI::Errors::Error => e
+          raise Rixie::LLM::Error, e.message
+        end
+
+        def stream(messages, tools:, &block)
+          params = build_params(encode_messages(messages), tools)
+
+          content = +""
+          accumulated_tool_calls = {}
+          finish_reason = nil
+
+          @client.chat.completions.stream_raw(**params).each do |chunk|
+            choice = chunk.choices&.first
+            next unless choice
+
+            finish_reason = choice.finish_reason if choice.finish_reason
+            delta = choice.delta
+            next unless delta
+
+            if (text = delta.content) && !text.empty?
+              block.call(Event::Token.new(delta: text))
+              content << text
+            end
+
+            delta.tool_calls&.each do |tc|
+              i = tc.index
+              accumulated_tool_calls[i] ||= {
+                "id" => +"",
+                "function" => {"name" => +"", "arguments" => +""}
+              }
+              accumulated_tool_calls[i]["id"] << tc.id.to_s
+              accumulated_tool_calls[i]["function"]["name"] << tc.function&.name.to_s
+              accumulated_tool_calls[i]["function"]["arguments"] << tc.function&.arguments.to_s
+            end
+          end
+
+          Rixie::LLM::Response.from_openai_wire(build_stream_raw(content, accumulated_tool_calls, finish_reason))
+        rescue ::OpenAI::Errors::Error => e
+          raise Rixie::LLM::Error, e.message
+        end
+
+        private
+
+        def encode_messages(messages)
+          messages.map { |msg| encode_message(msg) }
+        end
+
+        def encode_message(msg)
+          case msg
+          when Rixie::Message::System
+            {role: "system", content: msg.content}
+          when Rixie::Message::User
+            {role: "user", content: msg.content}
+          when Rixie::Message::Assistant
+            h = {role: "assistant", content: msg.content}
+            h[:tool_calls] = msg.tool_calls.map(&:to_openai_wire) unless msg.tool_calls.empty?
+            h
+          when Rixie::Message::Tool
+            {role: "tool", tool_call_id: msg.tool_call_id, content: msg.content}
+          end
+        end
+
+        def build_stream_raw(content, accumulated_tool_calls, finish_reason)
+          tool_calls_raw = accumulated_tool_calls.empty? ? nil : accumulated_tool_calls.values
+          {
+            "choices" => [{
+              "finish_reason" => finish_reason,
+              "message" => {
+                "content" => content.empty? ? nil : content,
+                "tool_calls" => tool_calls_raw
+              }
+            }]
+          }
+        end
+
+        def encode_tools(tools)
+          tools.map do |tool|
+            {
+              type: "function",
+              function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema
+              }
+            }
+          end
+        end
+
+        def build_params(messages, tools)
+          params = {model: @model, messages: messages}
+          unless tools.empty?
+            params[:tools] = encode_tools(tools)
+            params[:parallel_tool_calls] = @parallel_tool_calls
+          end
+          params[:max_tokens] = @max_tokens if @max_tokens
+          params[:temperature] = @temperature unless @temperature.nil?
+          params
+        end
+
+        def normalize(result)
+          {
+            "choices" => (result.choices || []).map do |choice|
+              message = choice.message
+              {
+                "finish_reason" => choice.finish_reason,
+                "message" => {
+                  "content" => message.content,
+                  "tool_calls" => message.tool_calls&.map do |tc|
+                    {
+                      "id" => tc.id,
+                      "function" => {"name" => tc.function.name, "arguments" => tc.function.arguments}
+                    }
+                  end
+                }
+              }
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rixie/llm/client/resolver.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rixie
+  module LLM
+    class Client
+      class Resolver
+        BUILTIN_PROVIDERS = {
+          "openai" => {
+            adapter: :openai,
+            base_url: "https://api.openai.com/v1",
+            api_key: -> { ENV["OPENAI_API_KEY"] }
+          },
+          "ollama" => {
+            adapter: :openai,
+            base_url: "http://localhost:11434/v1",
+            api_key: -> { "ollama" }
+          }
+        }.freeze
+
+        def self.resolve(model: nil, provider: nil, request_timeout: nil, max_tokens: nil, temperature: nil, parallel_tool_calls: nil)
+          raise Rixie::NoProviderError, "No provider configured. Pass `provider:` or set Rixie.config.default_provider." if provider.nil?
+
+          all_providers = BUILTIN_PROVIDERS.merge(Rixie.config.custom_providers)
+          config = all_providers[provider.to_s]
+          raise Rixie::UnknownProviderError, "Unknown provider: #{provider.inspect}" if config.nil?
+
+          api_key = config[:api_key]
+          api_key = api_key.call if api_key.respond_to?(:call)
+
+          adapter_class = adapter_class_for(config[:adapter])
+          params = {
+            model: model,
+            base_url: config[:base_url],
+            api_key: api_key,
+            request_timeout: request_timeout,
+            max_tokens: max_tokens,
+            temperature: temperature
+          }
+          params[:parallel_tool_calls] = parallel_tool_calls unless parallel_tool_calls.nil? || !(adapter_class <= Adapter::OpenAI)
+          adapter_class.new(**params)
+        end
+
+        def self.adapter_class_for(adapter)
+          case adapter
+          when :openai
+            require_relative "../adapter/openai"
+            Adapter::OpenAI
+          when Class
+            adapter
+          else
+            raise Rixie::ConfigurationError, "Unknown adapter: #{adapter.inspect}"
+          end
+        end
+        private_class_method :adapter_class_for
+      end
+    end
+  end
+end