jrubyagents 0.2.1

data/lib/rubyagents/memory.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+module Rubyagents
+  ActionStep = Data.define(:step_number, :thought, :code, :tool_calls, :observation, :error, :duration, :token_usage) do
+    def initialize(step_number:, thought:, code: nil, tool_calls: nil, observation: nil, error: nil,
+                   duration: 0.0, token_usage: nil)
+      super
+    end
+
+    def to_h
+      h = { type: "action", step_number: step_number, thought: thought, duration: duration }
+      h[:code] = code if code
+      h[:tool_calls] = tool_calls.map(&:to_h) if tool_calls
+      h[:observation] = observation if observation
+      h[:error] = error if error
+      h[:token_usage] = token_usage.to_h if token_usage
+      h
+    end
+  end
+
+  PlanningStep = Data.define(:plan, :duration, :token_usage) do
+    def to_h
+      h = { type: "planning", plan: plan, duration: duration }
+      h[:token_usage] = token_usage.to_h if token_usage
+      h
+    end
+  end
+
+  UserMessage = Data.define(:content) do
+    def to_h
+      { type: "user_message", content: content }
+    end
+  end
+
+  class Memory
+    attr_reader :system_prompt, :task, :steps, :total_tokens, :total_duration
+
+    def initialize(system_prompt:, task:)
+      @system_prompt = system_prompt
+      @task = task
+      @steps = []
+      @total_tokens = TokenUsage.new(input_tokens: 0, output_tokens: 0)
+      @total_duration = 0.0
+    end
+
+    def add_step(thought:, code: nil, tool_calls: nil, observation: nil, error: nil,
+                 duration: 0.0, token_usage: nil)
+      step = ActionStep.new(
+        step_number: action_steps.size + 1,
+        thought: thought,
+        code: code,
+        tool_calls: tool_calls,
+        observation: observation,
+        error: error,
+        duration: duration,
+        token_usage: token_usage
+      )
+      record_step(step, duration, token_usage)
+    end
+
+    def add_plan(plan:, duration: 0.0, token_usage: nil)
+      step = PlanningStep.new(plan: plan, duration: duration, token_usage: token_usage)
+      record_step(step, duration, token_usage)
+    end
+
+    def add_user_message(message)
+      @steps << UserMessage.new(content: message)
+    end
+
+    def action_steps
+      @steps.select { |s| s.is_a?(ActionStep) }
+    end
+
+    def progress_summary
+      completed = action_steps
+      return "No steps completed yet." if completed.empty?
+
+      lines = ["Steps completed so far:"]
+      completed.each do |step|
+        status = step.error ? "failed" : "done"
+        summary = step.thought || step.observation || "no details"
+        lines << "  #{step.step_number}. [#{status}] #{summary.to_s[0, 100]}"
+      end
+      lines.join("\n")
+    end
+
+    def to_messages
+      messages = [
+        { role: "system", content: system_prompt },
+        { role: "user", content: task }
+      ]
+
+      steps.each do |step|
+        case step
+        when UserMessage
+          messages << { role: "user", content: step.content }
+        when PlanningStep
+          messages << { role: "assistant", content: "Plan:\n#{step.plan}" }
+          messages << { role: "user", content: "Now proceed and carry out this plan." }
+        when ActionStep
+          assistant_msg = build_assistant_message(step)
+          messages << assistant_msg if assistant_msg
+
+          if step.observation
+            messages << { role: "user", content: "Observation: #{step.observation}" }
+          elsif step.error
+            messages << {
+              role: "user",
+              content: "Error: #{step.error}\nNow let's retry: take care not to repeat previous errors! " \
+                       "If you have retried several times, try a completely different approach."
+            }
+          end
+        end
+      end
+
+      messages.each { |m| m[:content] = sanitize_utf8(m[:content]) if m[:content] }
+    end
+
+    def last_step
+      @steps.last
+    end
+
+    def return_full_code
+      action_steps.filter_map(&:code).join("\n\n")
+    end
+
+    def to_h
+      {
+        system_prompt: system_prompt,
+        task: task,
+        steps: steps.map(&:to_h),
+        total_tokens: total_tokens.to_h,
+        total_duration: total_duration
+      }
+    end
+
+    def to_json(*args)
+      require "json"
+      to_h.to_json(*args)
+    end
+
+    def replay(io: $stdout)
+      io.puts UI::Styles.final_answer.render("Task: ") + task.to_s
+      io.puts
+
+      steps.each do |step|
+        case step
+        when ActionStep
+          replay_action_step(step, io)
+        when PlanningStep
+          io.puts UI::Styles.plan_label.render(" Plan ")
+          io.puts UI::Styles.plan_box.render(step.plan)
+          replay_metrics(step, io)
+        when UserMessage
+          io.puts UI::Styles.label.render("User: ") + step.content.to_s
+          io.puts
+        end
+      end
+
+      parts = ["#{action_steps.size} steps", format("%.1fs total", total_duration)]
+      parts << total_tokens.to_s if total_tokens.total_tokens > 0
+      io.puts UI::Styles.dim.render(parts.join(" | "))
+    end
+
+    private
+
+    def replay_action_step(step, io)
+      if step.thought
+        io.puts UI::Styles.label.render("Thought: ") + step.thought
+      end
+
+      if step.code
+        io.puts
+        highlighted = rouge_formatter.format(rouge_lexer.lex(step.code))
+        highlighted.each_line { |line| io.puts "  #{line.rstrip}" }
+        io.puts
+      end
+
+      if step.tool_calls
+        step.tool_calls.each do |tc|
+          args = tc.function.arguments.map { |k, v| "#{k}: #{v.inspect}" }.join(", ")
+          io.puts UI::Styles.label.render("Tool: ") + "#{tc.function.name}(#{args})"
+        end
+      end
+
+      if step.observation
+        io.puts UI::Styles.label.render("Result: ") + step.observation.to_s[0, 200]
+      end
+
+      if step.error
+        io.puts UI::Styles.error.render("Error: ") + step.error
+      end
+
+      replay_metrics(step, io)
+    end
+
+    def replay_metrics(step, io)
+      parts = []
+      parts << format("%.1fs", step.duration) if step.duration > 0
+      parts << step.token_usage.to_s if step.token_usage
+      io.puts UI::Styles.dim.render(parts.join(" | ")) unless parts.empty?
+      io.puts
+    end
+
+    def rouge_lexer
+      @rouge_lexer ||= Rouge::Lexers::Ruby.new
+    end
+
+    def rouge_formatter
+      @rouge_formatter ||= Rouge::Formatters::Terminal256.new(Rouge::Themes::Monokai.new)
+    end
+
+    def build_assistant_message(step)
+      if step.tool_calls
+        # For tool calling agents: include content and tool_calls in message
+        msg = { role: "assistant" }
+        msg[:content] = step.thought if step.thought
+        msg[:tool_calls] = step.tool_calls
+        msg
+      elsif step.thought || step.code
+        assistant_content = +""
+        assistant_content << "Thought: #{step.thought}\n" if step.thought
+        assistant_content << "Code:\n```ruby\n#{step.code}\n```\n" if step.code
+        { role: "assistant", content: assistant_content } unless assistant_content.empty?
+      end
+    end
+
+    def record_step(step, duration, token_usage)
+      @steps << step
+      @total_duration += duration if duration
+      @total_tokens = @total_tokens + token_usage if token_usage
+      step
+    end
+
+    def sanitize_utf8(str)
+      return str unless str.is_a?(String)
+      str.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+    end
+  end
+end

data/lib/rubyagents/model.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Rubyagents
+  TokenUsage = Data.define(:input_tokens, :output_tokens) do
+    def total_tokens = input_tokens + output_tokens
+
+    def +(other)
+      TokenUsage.new(
+        input_tokens: input_tokens + other.input_tokens,
+        output_tokens: output_tokens + other.output_tokens
+      )
+    end
+
+    def to_s
+      "#{total_tokens} tokens (#{input_tokens} in / #{output_tokens} out)"
+    end
+
+    def to_h
+      { input_tokens: input_tokens, output_tokens: output_tokens }
+    end
+  end
+
+  ToolCallFunction = Data.define(:name, :arguments) do
+    def to_h
+      { name: name, arguments: arguments }
+    end
+  end
+
+  ToolCall = Data.define(:id, :function) do
+    def to_h
+      { id: id, function: function.to_h }
+    end
+  end
+
+  ChatMessage = Data.define(:role, :content, :token_usage, :tool_calls) do
+    def initialize(role:, content:, token_usage: nil, tool_calls: nil)
+      super
+    end
+  end
+
+  RunResult = Data.define(:output, :state, :steps, :token_usage, :timing) do
+    def initialize(output:, state:, steps: [], token_usage: nil, timing: nil)
+      super
+    end
+
+    def success? = state == "success"
+
+    def to_h
+      {
+        output: output,
+        state: state,
+        steps: steps.map(&:to_h),
+        token_usage: token_usage&.to_h,
+        timing: timing
+      }
+    end
+
+    def to_json(*args)
+      require "json"
+      to_h.to_json(*args)
+    end
+  end
+
+  class Model
+    @registry = {}
+
+    class << self
+      attr_reader :registry
+
+      def register(prefix, klass)
+        @registry[prefix] = klass
+      end
+
+      def for(model_id)
+        if model_id.include?("/")
+          prefix, model_name = model_id.split("/", 2)
+          adapter_class = @registry[prefix]
+          if adapter_class
+            adapter_class.new(model_name)
+          else
+            Models::RubyLLMAdapter.new(model_name, provider: prefix)
+          end
+        else
+          Models::RubyLLMAdapter.new(model_id)
+        end
+      end
+    end
+
+    attr_reader :model_name
+
+    def initialize(model_name)
+      @model_name = model_name
+    end
+
+    def generate(messages, tools: nil, &on_stream)
+      raise NotImplementedError, "#{self.class} must implement #generate"
+    end
+  end
+end

data/lib/rubyagents/models/ruby_llm_adapter.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Rubyagents
+  module Models
+    class RubyLLMAdapter < Model
+      attr_reader :provider
+
+      def initialize(model_name, provider: nil)
+        super(model_name)
+        @provider = provider&.to_sym
+      end
+
+      def generate(messages, tools: nil, &on_stream)
+        require "ruby_llm"
+        self.class.configure_ruby_llm
+
+        chat = build_chat
+        load_messages(chat, messages)
+        load_tools(chat, tools) if tools&.any?
+
+        response = if on_stream
+          chat.complete { |chunk| on_stream.call(chunk.content) if chunk.content }
+        else
+          chat.complete
+        end
+
+        extract_response(chat, response)
+      rescue RubyLLM::ConfigurationError => e
+        raise Error, "Model configuration error: #{e.message}. Set the appropriate API key env var."
+      rescue RubyLLM::ModelNotFoundError => e
+        raise Error, "Unknown model '#{model_name}'. Check the model name or set a provider prefix (e.g. 'openai/#{model_name}')."
+      rescue RubyLLM::UnauthorizedError => e
+        raise Error, "API authentication failed: #{e.message}. Check your API key."
+      rescue RubyLLM::Error => e
+        raise Error, "LLM API error: #{e.message}"
+      end
+
+      def self.configure_ruby_llm
+        return if @configured
+
+        RubyLLM.configure do |config|
+          config.openai_api_key = ENV["OPENAI_API_KEY"] if ENV["OPENAI_API_KEY"]
+          config.anthropic_api_key = ENV["ANTHROPIC_API_KEY"] if ENV["ANTHROPIC_API_KEY"]
+          config.gemini_api_key = ENV["GEMINI_API_KEY"] if ENV["GEMINI_API_KEY"]
+          config.deepseek_api_key = ENV["DEEPSEEK_API_KEY"] if ENV["DEEPSEEK_API_KEY"]
+          config.openrouter_api_key = ENV["OPENROUTER_API_KEY"] if ENV["OPENROUTER_API_KEY"]
+          config.ollama_api_base = ENV["OLLAMA_HOST"] if ENV["OLLAMA_HOST"]
+        end
+
+        @configured = true
+      end
+
+      private
+
+      def build_chat
+        RubyLLM::Chat.new(model: model_name, provider: @provider)
+      end
+
+      def load_messages(chat, messages)
+        messages.each do |msg|
+          role = msg[:role]
+          content = msg[:content]
+
+          case role
+          when "system"
+            chat.with_instructions(content)
+          when "assistant"
+            attrs = { role: :assistant, content: content }
+            if msg[:tool_calls]
+              attrs[:tool_calls] = convert_tool_calls_to_ruby_llm(msg[:tool_calls])
+            end
+            chat.add_message(attrs)
+          else
+            chat.add_message(role: role.to_sym, content: content || "")
+          end
+        end
+      end
+
+      def load_tools(chat, tool_schemas)
+        tool_schemas.each { |schema| chat.with_tool(build_stub_tool(schema)) }
+      end
+
+      def build_stub_tool(schema)
+        tool_name = schema[:name]
+        tool_desc = schema[:description]
+        params = schema[:parameters] || {}
+        properties = params[:properties] || params["properties"] || {}
+        required_list = (params[:required] || params["required"] || []).map(&:to_s)
+
+        klass = Class.new(RubyLLM::Tool) do
+          description tool_desc
+
+          properties.each do |pname, pschema|
+            ptype = (pschema[:type] || pschema["type"] || "string").to_s
+            pdesc = pschema[:description] || pschema["description"]
+            is_req = required_list.include?(pname.to_s)
+            param pname.to_sym, type: ptype, desc: pdesc, required: is_req
+          end
+
+          define_method(:execute) { |**_kwargs| halt("tool_called") }
+        end
+
+        instance = klass.new
+        instance.define_singleton_method(:name) { tool_name }
+        instance
+      end
+
+      def extract_response(chat, response)
+        if defined?(RubyLLM::Tool::Halt) && response.is_a?(RubyLLM::Tool::Halt)
+          # Tool calls halted the loop; find the assistant message with tool_calls
+          message = chat.messages.reverse.find { |m| m.role == :assistant && m.tool_call? }
+          build_chat_message(message)
+        else
+          build_chat_message(response)
+        end
+      end
+
+      def build_chat_message(message)
+        ChatMessage.new(
+          role: "assistant",
+          content: message.content,
+          token_usage: extract_token_usage(message),
+          tool_calls: extract_tool_calls(message)
+        )
+      end
+
+      def extract_token_usage(message)
+        input = message.input_tokens
+        output = message.output_tokens
+        return nil unless input || output
+        TokenUsage.new(input_tokens: input || 0, output_tokens: output || 0)
+      end
+
+      def extract_tool_calls(message)
+        return nil unless message.tool_call?
+
+        message.tool_calls.map do |_id, tc|
+          ToolCall.new(
+            id: tc.id,
+            function: ToolCallFunction.new(name: tc.name, arguments: tc.arguments || {})
+          )
+        end
+      end
+
+      def convert_tool_calls_to_ruby_llm(tool_calls)
+        return nil unless tool_calls&.any?
+
+        tool_calls.each_with_object({}) do |tc, hash|
+          hash[tc.id] = RubyLLM::ToolCall.new(
+            id: tc.id,
+            name: tc.function.name,
+            arguments: tc.function.arguments || {}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubyagents/prompt.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Rubyagents
+  PromptTemplates = Data.define(:system_prompt, :planning_initial, :planning_update) do
+    def initialize(system_prompt: nil, planning_initial: nil, planning_update: nil) = super
+  end
+
+  module Prompt
+    CODE_AGENT_SYSTEM = <<~'PROMPT'
+      You are an expert Ruby programmer and problem solver. You solve tasks by writing and executing Ruby code.
+
+      On each step, you will write a short Thought, then write Ruby code to make progress on the task.
+
+      ## Rules
+      - Always provide your reasoning in "Thought:" before writing code
+      - Write Ruby code inside a ```ruby code block
+      - Your code has access to these tools as methods: {{tool_descriptions}}
+      - Variables persist between steps - you can build on previous results
+      - Use puts to print intermediate values for debugging
+      - Keep code simple and direct
+
+      ## Available Ruby libraries
+      Your code runs in a full Ruby environment. You can `require` and use:
+      - Ruby standard library: net/http, uri, json, csv, fileutils, open-uri, date, time, set, etc.
+      - Any gems installed in the current environment (use the list_gems tool to see them)
+      Use these freely -- e.g. `require "net/http"` to fetch URLs, `require "json"` to parse JSON, etc.
+
+      ## CRITICAL: final_answer rules
+      - Call final_answer(answer: "...") ONLY when you have the actual, complete answer
+      - NEVER call final_answer in the same step where you gather data with tools
+      - First step: gather information. Next step: process it. Final step: call final_answer with the result.
+      - If a tool returns data you haven't read yet, do NOT call final_answer - wait for the next step
+
+      ## Response format
+
+      Thought: <your reasoning about what to do next>
+      Code:
+      ```ruby
+      <your Ruby code here>
+      ```
+
+      ## Example
+
+      Task: What is the 10th Fibonacci number?
+
+      Thought: I'll write a simple iterative Fibonacci computation.
+      Code:
+      ```ruby
+      a, b = 0, 1
+      8.times { a, b = b, a + b }
+      final_answer(answer: "The 10th Fibonacci number is #{b}")
+      ```
+
+      Now solve the following task. Think step by step and write Ruby code to find the answer.
+    PROMPT
+
+    TOOL_CALLING_AGENT_SYSTEM = <<~'PROMPT'
+      You are an expert problem solver. You solve tasks by calling the available tools.
+
+      On each step, think about what to do next, then call one or more tools to make progress.
+
+      ## Rules
+      - Think step by step about the problem
+      - Use the available tools to gather information and solve the task
+      - Variables do NOT persist between steps - each tool call is independent
+      - When you have the final answer, call the final_answer tool with your result
+
+      ## CRITICAL: final_answer rules
+      - Call the final_answer tool ONLY when you have the actual, complete answer
+      - NEVER call final_answer in the same step where you gather data with other tools
+      - First step: gather information. Next step: process it. Final step: call final_answer with the result.
+
+      ## Available tools
+      {{tool_descriptions}}
+
+      Now solve the following task. Think step by step and use tools to find the answer.
+    PROMPT
+
+    INITIAL_PLAN = <<~'PROMPT'
+      You are a planning assistant. Based on the task, create a step-by-step plan.
+
+      Write a concise numbered plan (3-7 steps) for how to complete the task.
+      Focus on what needs to be done to solve the problem.
+
+      Respond with just the plan, no code.
+    PROMPT
+
+    UPDATE_PLAN = <<~'PROMPT'
+      You are a planning assistant. Based on the task and the work done so far, update the plan.
+
+      ## Progress so far
+      {{progress_summary}}
+
+      Write a concise numbered plan (3-7 steps) for how to complete the remaining work.
+      Focus on what still needs to be done, not what's already been accomplished.
+
+      Respond with just the plan, no code.
+    PROMPT
+
+    def self.code_agent_system(tools:)
+      tool_descriptions = tools.map { |t| t.class.to_prompt }.join("\n\n")
+      CODE_AGENT_SYSTEM.gsub("{{tool_descriptions}}", tool_descriptions)
+    end
+
+    def self.tool_calling_agent_system(tools:)
+      tool_descriptions = tools.map { |t| t.class.to_prompt }.join("\n\n")
+      TOOL_CALLING_AGENT_SYSTEM.gsub("{{tool_descriptions}}", tool_descriptions)
+    end
+
+    def self.initial_plan
+      INITIAL_PLAN
+    end
+
+    def self.update_plan(progress_summary:)
+      UPDATE_PLAN.gsub("{{progress_summary}}", progress_summary)
+    end
+
+    # Backward compatibility
+    def self.planning
+      INITIAL_PLAN
+    end
+  end
+end