brute 3.0.0 → 3.0.1

data/lib/brute/middleware/002_session_log.rb

@@ -42,7 +42,7 @@ module Brute
           loaded = []
           File.foreach(@path) do |line|
             line = line.strip
-            loaded << ::RubyLLM::Message.new(**JSON.parse(line, symbolize_names: true)) unless line.empty?
+            loaded << Brute::Message.new(**JSON.parse(line, symbolize_names: true)) unless line.empty?
           end
           messages.unshift(*loaded)
         end

data/lib/brute/middleware/004_summarize.rb

@@ -36,7 +36,7 @@ module Brute
         saved_tools = env[:tools]
         env[:tools] = []
         env[:current_iteration] = 1
-        env[:messages] << RubyLLM::Message.new(role: :user, content: @prompt)
+        env[:messages] << Brute::Message.new(role: :user, content: @prompt)
         @app.call(env)
         env[:tools] = saved_tools
 
@@ -59,9 +59,9 @@ describe "brute/middleware/004_summarize" do
     inner = ->(env) do
       call_count += 1
       if call_count == 1
-        env[:messages] << RubyLLM::Message.new(role: :tool, content: "some result", tool_call_id: "tc1")
+        env[:messages] << Brute::Message.new(role: :tool, content: "some result", tool_call_id: "tc1")
       else
-        env[:messages] << RubyLLM::Message.new(role: :assistant, content: "Here is my complete summary.")
+        env[:messages] << Brute::Message.new(role: :assistant, content: "Here is my complete summary.")
       end
     end
 
@@ -77,7 +77,7 @@ describe "brute/middleware/004_summarize" do
 
   it "restores tools after summary call" do
     inner = ->(env) {
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "done")
+      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
     }
 
     mw = Brute::Middleware::Summarize.new(inner)
@@ -93,7 +93,7 @@ describe "brute/middleware/004_summarize" do
     captured_iteration = nil
     inner = ->(env) {
       captured_iteration = env[:current_iteration]
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "done")
+      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
     }
 
     mw = Brute::Middleware::Summarize.new(inner)
@@ -111,7 +111,7 @@ describe "brute/middleware/004_summarize" do
     inner = ->(env) {
       call_count += 1
       messages_at_second_call = env[:messages].map(&:content) if call_count == 2
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "done")
+      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
     }
 
     mw = Brute::Middleware::Summarize.new(inner)
@@ -128,7 +128,7 @@ describe "brute/middleware/004_summarize" do
     inner = ->(env) {
       call_count += 1
       messages_at_second_call = env[:messages].map(&:content) if call_count == 2
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "done")
+      env[:messages] << Brute::Message.new(role: :assistant, content: "done")
     }
 
     mw = Brute::Middleware::Summarize.new(inner, prompt: "Give me the TL;DR.")

data/lib/brute/middleware/006_loop.rb

@@ -108,9 +108,9 @@ describe "brute/middleware/006_loop" do
     inner = ->(env) do
       call_count += 1
       if call_count == 1
-        env[:messages] << RubyLLM::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
+        env[:messages] << Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
       else
-        env[:messages] << RubyLLM::Message.new(role: :assistant, content: "done")
+        env[:messages] << Brute::Message.new(role: :assistant, content: "done")
       end
     end
 
@@ -128,7 +128,7 @@ describe "brute/middleware/006_loop" do
     call_count = 0
     inner = ->(env) do
       call_count += 1
-      env[:messages] << RubyLLM::Message.new(role: :tool, content: "result", tool_call_id: "tc#{call_count}")
+      env[:messages] << Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc#{call_count}")
       env[:should_exit] = { reason: "max" } if call_count >= 2
     end
 
@@ -144,7 +144,7 @@ describe "brute/middleware/006_loop" do
     call_count = 0
     inner = ->(env) do
       call_count += 1
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "hello")
+      env[:messages] << Brute::Message.new(role: :assistant, content: "hello")
     end
 
     mw = Brute::Middleware::Loop::ToolResult.new(inner)

data/lib/brute/middleware/010_max_iterations.rb

@@ -22,7 +22,7 @@ module Brute
 
       def call(env)
         if max_iterations_reached?(env)
-          env[:messages] << RubyLLM::Message.new(
+          env[:messages] << Brute::Message.new(
             role: :user,
             content: "Maximum iterations reached.",
           )

data/lib/brute/middleware/020_system_prompt.rb

@@ -37,7 +37,7 @@ module Brute
           result = @system_prompt.prepare(ctx)
           unless result.empty?
             env[:messages].unshift(
-              RubyLLM::Message.new(role: :system, content: result.to_s)
+              Brute::Message.new(role: :system, content: result.to_s)
             )
           end
         end

data/lib/brute/middleware/040_compaction_check.rb

@@ -39,8 +39,8 @@ module Brute
         #    }
         #    # Replace the message history with the summary
         #    env[:messages] = [
-        #      RubyLLM::Message.new(role: :system, content: @system_prompt),
-        #      RubyLLM::Message.new(role: :user, content: "[Previous conversation summary]\n\n#{summary_text}"),
+        #      Brute::Message.new(role: :system, content: @system_prompt),
+        #      Brute::Message.new(role: :user, content: "[Previous conversation summary]\n\n#{summary_text}"),
         #    ]
         #  end
         #end

data/lib/brute/middleware/070_tool_pipeline.rb

@@ -81,13 +81,13 @@ module Brute
           Sync do
             barrier = Async::Barrier.new
 
-            tools_to_run.each do |id, tool_call|
+            tools_to_run.each do |tool_call|
               barrier.async do
                 tool = available_tools[tool_call.name.to_sym]
                 result = tool.call(tool_call.arguments)
 
-                # Coerce to String so RubyLLM::Message doesn't treat Hash results
-                # (e.g. Shell's {stdout:, stderr:, exit_code:}) as attachments.
+                # Coerce to String so Hash results (e.g. Shell's
+                # {stdout:, stderr:, exit_code:}) serialize predictably.
                 content = result.is_a?(String) ? result : result.to_s
 
                 # Universal truncation safety net — skip if already truncated
@@ -95,13 +95,13 @@ module Brute
                   content = Brute::Truncation.truncate(content)
                 end
 
-                results << [id, tool_call, content]
+                results << [tool_call, content]
               rescue => e
                 # Capture the error as a tool result so the LLM can see it
                 # and reason about the failure, rather than crashing the
                 # entire middleware chain.
                 env[:events] << { type: :error, data: { error: e, message: e.message } }
-                results << [id, tool_call, "Error: #{e.class}: #{e.message}"]
+                results << [tool_call, "Error: #{e.class}: #{e.message}"]
               end
             end
 
@@ -112,12 +112,11 @@ module Brute
 
           # Append events and messages in the original tool_call order so the
           # LLM sees a deterministic sequence regardless of completion order.
-          order = tools_to_run.keys
-          results.sort_by! { |id, _, _| order.index(id) }
+          results.sort_by! { |tool_call, _| tools_to_run.index(tool_call) }
 
-          results.each do |_id, tool_call, content|
+          results.each do |tool_call, content|
             env[:events] << { type: :tool_result, data: { name: tool_call.name, content: content } }
-            env[:messages] << RubyLLM::Message.new(role: :tool, content: content, tool_call_id: tool_call.id)
+            env[:messages] << Brute::Message.new(role: :tool, content: content, tool_call_id: tool_call.id)
           end
         end
 
@@ -126,8 +125,14 @@ module Brute
 
       private
 
+        # The last message's pending tool calls as a flat list. Duck-typed:
+        # tool_calls may be an Array (Brute::ToolCall) or an id-keyed Hash
+        # (some libraries' native shape); each entry needs #id, #name and
+        # #arguments.
         def pending_tool_calls(message)
-          message.tool_calls.to_h.reject { |_id, tc| tc.name == "question" }
+          calls = message.respond_to?(:tool_calls) ? message.tool_calls : nil
+          calls = calls.values if calls.respond_to?(:values)
+          Array(calls).reject { |tc| tc.name == "question" }
         end
 
         def resolve_tools(tools)
@@ -137,7 +142,7 @@ module Brute
         def on_tool_call_start_event(pending_tools)
           {
             type: :tool_call_start,
-            data: pending_tools.map { |_id, tc|
+            data: pending_tools.map { |tc|
               {
                 name: tc.name,
                 call_id: tc.id,
@@ -158,7 +163,7 @@ describe "brute/middleware/070_tool_pipeline" do
 
   it "passes through when no tool calls pending" do
     inner = ->(env) {
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "hi")
+      env[:messages] << Brute::Message.new(role: :assistant, content: "hi")
     }
     mw = Brute::Middleware::ToolPipeline.new(inner, tools: [])
     env = {
@@ -185,7 +190,7 @@ describe "brute/middleware/070_tool_pipeline" do
 
   it "truncates large tool results via Truncation" do
     # A fake tool that returns a huge string
-    big_tool = Class.new(RubyLLM::Tool) do
+    big_tool = Class.new(Brute::Tool) do
       description "test tool"
       param :input, type: "string", desc: "input"
       def name; "big_tool"; end
@@ -194,17 +199,16 @@ describe "brute/middleware/070_tool_pipeline" do
       end
     end
 
-    call_id = "tc_1"
-    tool_calls = {
-      call_id => RubyLLM::ToolCall.new(
-        id: call_id,
+    tool_calls = [
+      Brute::ToolCall.new(
+        id: "tc_1",
         name: "big_tool",
         arguments: { "input" => "go" },
       )
-    }
+    ]
 
     inner = ->(env) {
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "", tool_calls: tool_calls)
+      env[:messages] << Brute::Message.new(role: :assistant, content: "", tool_calls: tool_calls)
     }
     mw = Brute::Middleware::ToolPipeline.new(inner, tools: [big_tool])
     env = {
@@ -223,7 +227,7 @@ describe "brute/middleware/070_tool_pipeline" do
 
   it "does not double-truncate already-truncated output" do
     # A fake tool that returns output already containing the truncation marker
-    pre_truncated_tool = Class.new(RubyLLM::Tool) do
+    pre_truncated_tool = Class.new(Brute::Tool) do
       description "test tool"
       param :input, type: "string", desc: "input"
       def name; "pre_truncated_tool"; end
@@ -232,17 +236,16 @@ describe "brute/middleware/070_tool_pipeline" do
       end
     end
 
-    call_id = "tc_2"
-    tool_calls = {
-      call_id => RubyLLM::ToolCall.new(
-        id: call_id,
+    tool_calls = [
+      Brute::ToolCall.new(
+        id: "tc_2",
         name: "pre_truncated_tool",
         arguments: { "input" => "go" },
       )
-    }
+    ]
 
     inner = ->(env) {
-      env[:messages] << RubyLLM::Message.new(role: :assistant, content: "", tool_calls: tool_calls)
+      env[:messages] << Brute::Message.new(role: :assistant, content: "", tool_calls: tool_calls)
     }
     mw = Brute::Middleware::ToolPipeline.new(inner, tools: [pre_truncated_tool])
     env = {

data/lib/brute/tool.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  # Base class for Brute's built-in tools — a tiny, framework-agnostic tool
+  # DSL. It intentionally mirrors the common tool-library shape (description +
+  # params) so tools read the same as they would in any LLM library, without
+  # depending on one:
+  #
+  #   class Shell < Brute::Tool
+  #     description "Execute a shell command"
+  #     param :command, type: 'string', desc: "The command", required: true
+  #
+  #     def name; "shell"; end
+  #
+  #     def execute(command:)
+  #       ...
+  #     end
+  #   end
+  #
+  # For tools whose arguments don't fit the flat param list, pass a raw JSON
+  # schema instead:
+  #
+  #   params({ type: 'object', properties: { ... }, required: [...] })
+  #
+  # Instances expose the neutral interface Brute::Tools::Adapter understands:
+  # #name, #description, #params, #params_schema, #call.
+  class Tool
+    class << self
+      def description(text = nil)
+        return @description unless text
+
+        @description = text
+      end
+
+      # Declare one parameter: param :key, type:, desc:, required:
+      def param(name, type: "string", desc: nil, required: true, **opts)
+        param_definitions[name.to_sym] = { type: type, desc: desc, required: required, **opts }.compact
+      end
+
+      def param_definitions
+        @param_definitions ||= {}
+      end
+
+      # Raw JSON-schema override for complex argument shapes.
+      def params(schema = nil)
+        return @params_schema unless schema
+
+        @params_schema = schema.deep_symbolize_keys
+      end
+    end
+
+    # Tool name; subclasses usually override with an explicit short name.
+    def name
+      self.class.name.demodulize.underscore
+    end
+
+    def description
+      self.class.description.to_s
+    end
+
+    # { key => { type:, desc:, required: } }
+    def params
+      self.class.param_definitions
+    end
+
+    # The raw JSON schema, when declared via params({...}).
+    def params_schema
+      self.class.params
+    end
+
+    # Execute with a string- or symbol-keyed argument hash, as delivered
+    # by LLM providers.
+    def call(arguments = {})
+      execute(**arguments.to_h.transform_keys(&:to_sym))
+    end
+
+    def execute(**)
+      raise NotImplementedError, "#{self.class} must implement #execute"
+    end
+  end
+end
+
+__END__
+
+describe "brute/tool" do
+  it "exposes description and params from the DSL" do
+    klass = Class.new(Brute::Tool) do
+      description "test tool"
+      param :input, type: "string", desc: "the input"
+      def name; "t"; end
+      def execute(input:); "got #{input}"; end
+    end
+
+    tool = klass.new
+    tool.description.should == "test tool"
+    tool.params[:input][:type].should == "string"
+    tool.params[:input][:required].should.be.true
+  end
+
+  it "calls execute with symbolized keys" do
+    klass = Class.new(Brute::Tool) do
+      description "echo"
+      param :msg, type: "string"
+      def name; "echo"; end
+      def execute(msg:); msg; end
+    end
+
+    klass.new.call("msg" => "hi").should == "hi"
+  end
+
+  it "accepts a raw JSON schema via params({...})" do
+    klass = Class.new(Brute::Tool) do
+      description "schema tool"
+      params({ type: "object", properties: { a: { type: "string" } }, required: %w[a] })
+      def name; "s"; end
+      def execute(a:); a; end
+    end
+
+    klass.new.params_schema[:properties][:a][:type].should == "string"
+  end
+end

data/lib/brute/tools/adapter.rb

@@ -12,10 +12,9 @@ module Brute
     # This solves three problems:
     #
     # 1. Using any tools library — anything that quacks like a tool
-    #    (RubyLLM::Tool today, others via their own adapters) is wrapped
-    #    into the same interface.
-    # 2. Avoiding tool libraries entirely — Brute::Turn::ToolPipeline and
-    #    Tools::SubAgent work without inheriting from a library class.
+    #    (#name plus #call or #execute) is wrapped into the same interface.
+    # 2. Avoiding tool libraries entirely — Brute::Tool, Brute::Turn::ToolPipeline
+    #    and Tools::SubAgent work without inheriting from a library class.
     # 3. Quickly adding tools — a plain Hash with a proc is enough:
     #
     #      Brute::Tools::Adapter.wrap(
@@ -32,8 +31,8 @@ module Brute
     #   adapter.params      # { key => { type:, desc:, required: } }
     #   adapter.call(args)  # execute with a (string- or symbol-keyed) Hash
     #
-    # Completion middlewares convert adapters into whatever their LLM
-    # library expects (e.g. #to_ruby_llm); ToolPipeline executes them via #call.
+    # The inline `run` proc converts adapters (via #to_h) into whatever its
+    # LLM library expects; ToolPipeline executes them via #call.
     #
     class Adapter
       attr_reader :name, :description, :params
@@ -46,7 +45,7 @@ module Brute
 
         case tool
         when Hash                then from_hash(tool)
-        when ::RubyLLM::Tool     then from_ruby_llm(tool)
+        when ::Brute::Tool       then from_brute_tool(tool)
         when Brute::Tools::SubAgent then new(
           name:        tool.name,
           description: tool.description,
@@ -90,29 +89,21 @@ module Brute
         )
       end
 
-      # A RubyLLM::Tool instance (the library's own arg normalization and
-      # validation stays in play via tool.call). Tools declared with the
-      # params(...) schema DSL keep their full JSON schema.
-      def self.from_ruby_llm(tool)
-        params = tool.parameters.each_with_object({}) do |(key, param), hash|
-          hash[key.to_sym] = { type: param.type, desc: param.description, required: param.required }.compact
-        end
-
+      # A Brute::Tool instance. Tools declared with the params({...}) schema
+      # DSL keep their full JSON schema.
+      def self.from_brute_tool(tool)
         new(
           name:        tool.name.to_s,
           description: tool.description,
-          params:      params,
-          schema:      (tool.params_schema if tool.respond_to?(:params_schema)),
+          params:      tool.params,
+          schema:      tool.params_schema,
           handler:     ->(**args) { tool.call(args) },
           original:    tool,
         )
       end
 
-      # Anything tool-shaped: needs #name and #call or #execute. Honors
-      # #to_ruby_llm for backward compatibility with existing adapters.
+      # Anything tool-shaped: needs #name and #call or #execute.
       def self.from_duck_type(tool)
-        return from_ruby_llm(tool.to_ruby_llm) if tool.respond_to?(:to_ruby_llm)
-
         unless tool.respond_to?(:name) && (tool.respond_to?(:call) || tool.respond_to?(:execute))
           raise ArgumentError, "don't know how to adapt #{tool.inspect} into a tool"
         end
@@ -136,7 +127,7 @@ module Brute
         @original    = original
       end
 
-      # The tool object this adapter wraps (RubyLLM::Tool, Brute::Turn::ToolPipeline,
+      # The tool object this adapter wraps (Brute::Tool, Brute::Turn::ToolPipeline,
       # SubAgent, Hash definition, ...).
       attr_reader :original
 
@@ -147,23 +138,8 @@ module Brute
         @handler.call(**args)
       end
 
-      # Convert to a RubyLLM::Tool so ruby_llm-backed completion can hand
-      # the tool to its providers. Returns the wrapped tool untouched when
-      # it already is one.
-      def to_ruby_llm
-        return @original if @original.is_a?(::RubyLLM::Tool)
-
-        adapter = self
-        Class.new(::RubyLLM::Tool) do
-          description adapter.description
-          adapter.params.each { |key, opts| param key, **opts.slice(:type, :desc, :required) }
-          define_method(:name) { adapter.name }
-          define_method(:execute) { |**args| adapter.call(args) }
-        end.new
-      end
-
-      # Library-neutral tool definition (JSON-Schema-ish), for completion
-      # middlewares that talk to an HTTP API directly.
+      # Library-neutral tool definition (JSON-Schema-ish). The inline `run`
+      # proc reshapes this into whatever its LLM library expects.
       def to_h
         return { name: @name, description: @description, parameters: @schema.deep_symbolize_keys } if @schema
 
@@ -194,16 +170,16 @@ end
 __END__
 
 describe "brute/tools/adapter" do
-  it "wraps a RubyLLM::Tool class" do
-    klass = Class.new(::RubyLLM::Tool) do
+  it "wraps a Brute::Tool class" do
+    klass = Class.new(::Brute::Tool) do
       description "test tool"
       param :input, type: "string", desc: "the input"
-      def name; "rl_tool"; end
+      def name; "brute_tool"; end
       def execute(input:); "got #{input}"; end
     end
 
     adapter = Brute::Tools::Adapter.wrap(klass)
-    adapter.name.should == "rl_tool"
+    adapter.name.should == "brute_tool"
     adapter.description.should == "test tool"
     adapter.params[:input][:type].should == "string"
     adapter.call("input" => "x").should == "got x"
@@ -255,29 +231,15 @@ describe "brute/tools/adapter" do
     tools[:a].should.be.kind_of?(Brute::Tools::Adapter)
   end
 
-  it "converts to a RubyLLM::Tool" do
-    adapter = Brute::Tools::Adapter.wrap(
-      name:        "echo",
-      description: "Echo",
-      params:      { msg: { type: "string", desc: "message", required: true } },
-      execute:     ->(msg:) { msg },
-    )
-
-    rl = adapter.to_ruby_llm
-    rl.should.be.kind_of?(::RubyLLM::Tool)
-    rl.name.should == "echo"
-    rl.call("msg" => "hello").should == "hello"
-  end
-
-  it "returns the original when it already is a RubyLLM::Tool" do
-    klass = Class.new(::RubyLLM::Tool) do
+  it "exposes the wrapped original" do
+    klass = Class.new(::Brute::Tool) do
       description "test tool"
       def name; "original"; end
       def execute; "ok"; end
     end
     instance = klass.new
 
-    Brute::Tools::Adapter.wrap(instance).to_ruby_llm.should == instance
+    Brute::Tools::Adapter.wrap(instance).original.should == instance
   end
 
   it "produces a neutral JSON-schema-ish definition" do

data/lib/brute/tools/fs_patch.rb

@@ -6,7 +6,7 @@ require "brute/tools"
 
 module Brute
   module Tools
-    class FSPatch < RubyLLM::Tool
+    class FSPatch < Brute::Tool
       description 'Replace a specific string in a file. The old_string must match exactly ' \
                   '(including whitespace and indentation). Always read a file before patching it.'
 

data/lib/brute/tools/fs_read.rb

@@ -28,7 +28,7 @@ module Brute
     # 8. Return a plain string instead of a Hash — avoids the .to_s repr
     #    bloat when ToolPipeline coerces the result for the LLM message.
     #
-    class FSRead < RubyLLM::Tool
+    class FSRead < Brute::Tool
       description "Read the contents of a file. Returns file content with line numbers. " \
                   "Use start_line/end_line for partial reads of large files."
 

data/lib/brute/tools/fs_remove.rb

@@ -7,7 +7,7 @@ require "fileutils"
 
 module Brute
   module Tools
-    class FSRemove < RubyLLM::Tool
+    class FSRemove < Brute::Tool
       description "Remove a file or empty directory."
 
       param :path, type: 'string', desc: "Path to the file or directory to remove", required: true

data/lib/brute/tools/fs_search.rb

@@ -21,7 +21,7 @@ module Brute
     # 5. Return a plain string instead of a Hash.
     # 6. Align output cap with universal truncation (2000 lines / 50 KB).
     #
-    class FSSearch < RubyLLM::Tool
+    class FSSearch < Brute::Tool
       description "Search file contents using ripgrep (regex), or find files by glob pattern. " \
                   "Returns matching lines with file paths and line numbers."
 

data/lib/brute/tools/fs_undo.rb

@@ -6,7 +6,7 @@ require "brute/tools"
 
 module Brute
   module Tools
-    class FSUndo < RubyLLM::Tool
+    class FSUndo < Brute::Tool
       description "Undo the last write or patch operation on a file, restoring it to " \
                   "its previous state."
 

data/lib/brute/tools/fs_write.rb

@@ -7,7 +7,7 @@ require 'fileutils'
 
 module Brute
   module Tools
-    class FSWrite < RubyLLM::Tool
+    class FSWrite < Brute::Tool
       description "Write content to a file. Creates parent directories if they don't exist. " \
                   'Use this for creating new files or completely replacing file contents.'
 

data/lib/brute/tools/net_fetch.rb

@@ -9,7 +9,7 @@ require "uri"
 
 module Brute
   module Tools
-    class NetFetch < RubyLLM::Tool
+    class NetFetch < Brute::Tool
       description "Fetch content from a URL. Returns the response body as text."
 
       param :url, type: 'string', desc: "The URL to fetch", required: true

data/lib/brute/tools/question.rb

@@ -6,7 +6,7 @@ require "brute/tools"
 
 module Brute
   module Tools
-    class Question < RubyLLM::Tool
+    class Question < Brute::Tool
       description "Ask the user questions during execution. Use this to gather preferences, " \
                   "clarify ambiguous instructions, get decisions on implementation choices, or " \
                   "offer choices about direction. Users can always select \"Other\" to provide " \

data/lib/brute/tools/shell.rb

@@ -22,7 +22,7 @@ module Brute
     #    the LLM (defaults to 5 minutes).
     # 5. Return a plain string instead of a Hash.
     #
-    class Shell < RubyLLM::Tool
+    class Shell < Brute::Tool
       description "Execute a shell command and return stdout, stderr, and exit code. " \
                   "Use for git operations, running tests, installing packages, etc."
 

data/lib/brute/tools/skill_load.rb

@@ -28,7 +28,7 @@ module Brute
     # tool with the matching cwd: Brute::Tools::SkillLoad.new(cwd: __dir__).
     #
     # Reference: opencode's tool/skill.ts.
-    class SkillLoad < RubyLLM::Tool
+    class SkillLoad < Brute::Tool
       description "Load a specialized skill when the task at hand matches one of the " \
                   "available skills listed in the system context. This injects the skill's " \
                   "full instructions into the conversation, plus the skill's base directory " \