brute 3.0.0 → 3.1.0

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 " \

data/lib/brute/tools/sub_agent.rb

@@ -23,14 +23,10 @@ module Brute
     #     use Brute::Middleware::MaxIterations, max_iterations: 10
     #     use Brute::Middleware::ToolPipeline, tools: [Brute::Tools::FSRead, Brute::Tools::FSSearch]
     #     run ->(env) do
-    #       ctx = RubyLLM.context { |c| c.ollama_api_base = ENV["OLLAMA_API_BASE"] }
-    #       model, provider = RubyLLM::Models.resolve(
-    #         "llama3.2", provider: :ollama, assume_exists: true, config: ctx.config)
-    #       response = provider.complete(env[:messages],
-    #                                    tools:       Brute.rubyllm_tools(env[:tools]),
-    #                                    temperature: 0.7,
-    #                                    model:       model)
-    #       RubyLLM::MessageTransport.new(response).wrap_each { |m| env[:messages] << m }
+    #       # The LLM call, written with your library of choice. Convert
+    #       # env[:messages] to its format, call it, and append the response
+    #       # back as Brute::Message values (the MessageTransport pattern —
+    #       # see examples/ruby_llm.rb, examples/openai.rb, ...).
     #     end
     #   end
     #
@@ -63,20 +59,7 @@ module Brute
         extract_result(session)
       end
 
-      # Adapter so the parent agent's completion middleware (and ruby_llm)
-      # sees this as a regular tool. ToolPipeline middleware should call
-      # `to_ruby_llm` when building the tools hash if a tool responds to it.
-      def to_ruby_llm
-        sub = self
-        Class.new(::RubyLLM::Tool) do
-          description sub.description
-          sub.params.each { |k, opts| param k, **opts }
-          define_method(:name) { sub.sub_agent_name }
-          define_method(:execute) { |**args| sub.execute(args) }
-        end.new
-      end
-
-      # Lets ToolPipeline treat SubAgents the same as RubyLLM::Tool instances
+      # Lets ToolPipeline treat SubAgents the same as any other tool
       # without checking respond_to? everywhere.
       def name
         @sub_agent_name

data/lib/brute/tools/todo_read.rb

@@ -6,7 +6,7 @@ require "brute/tools"
 
 module Brute
   module Tools
-    class TodoRead < RubyLLM::Tool
+    class TodoRead < Brute::Tool
       description "Read the current todo list to check task status and progress."
       param :_placeholder, type: 'string', desc: "Unused, pass any value", required: false
 

data/lib/brute/tools/todo_write.rb

@@ -6,7 +6,7 @@ require "brute/tools"
 
 module Brute
   module Tools
-    class TodoWrite < RubyLLM::Tool
+    class TodoWrite < Brute::Tool
       description "Create or update the todo list. Send the complete list each time — " \
                   "this replaces the existing list entirely."
 

data/lib/brute/turn/agent_pipeline.rb

@@ -57,7 +57,8 @@ module Brute
           case input
           when nil                 then Brute.log
           when ::String            then Brute.log.tap { |log| log.user(input) }
-          when ::RubyLLM::Message  then Brute.log(input)
+          when ::Brute::Message    then Brute.log(input)
+          when ::Hash              then Brute.log(Brute::Message.new(**input.transform_keys(&:to_sym)))
           when ::Array             then input.extend(Brute::Messages)
           else Brute.log(input)
           end

data/lib/brute/turn/pipeline.rb

@@ -14,7 +14,7 @@ module Brute
         #     .use(MaxProfit)
         #     .use(DontTellMom)
         #     .run -> (env) {
-        #       RubyLLM.chat.ask("How to make money?")
+        #       your_llm_library.complete("How to make money?")
         #     }
         #
         def use(...) = tap { super }

data/lib/brute/turn/tool_pipeline.rb

@@ -13,8 +13,8 @@ module Brute
     # the work; middleware wraps it with concerns like file mutation queueing,
     # validation, logging.
     #
-    # Coexists with Brute::Tools::* (which inherit from RubyLLM::Tool). Use a
-    # ToolPipeline when you want middleware; use RubyLLM::Tool subclasses for
+    # Coexists with Brute::Tools::* (which inherit from Brute::Tool). Use a
+    # ToolPipeline when you want middleware; use Brute::Tool subclasses for
     # simple cases.
     #
     #   read = Brute::Turn::ToolPipeline.new(
@@ -53,16 +53,6 @@ module Brute
         env[:result]
       end
 
-      # Adapter so the LLM can call this tool through ruby_llm.
-      def to_ruby_llm
-        tool = self
-        Class.new(RubyLLM::Tool) do
-          description tool.description
-          tool.params.each { |k, opts| param k, **opts }
-          define_method(:name) { tool.name }
-          define_method(:execute) { |**args| tool.call(**args) }
-        end.new
-      end
     end
   end
 end

data/lib/brute/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Brute
-  VERSION = "3.0.0"
+  VERSION = "3.1.0"
 end

data/lib/brute.rb

@@ -2,7 +2,6 @@
 
 require "bundler/setup"
 
-require "ruby_llm"
 require "rack"
 require 'timeout'
 require 'logger'
@@ -22,16 +21,14 @@ module Brute
  `Y8bod8P' d888b     `V88V"V8P'   "888" `Y8bod8P' 
   LOGO
 
-  # NOTE: Brute owns no LLM configuration. Calling an LLM is just
-  # `RubyLLM.chat.ask "..."`, and all provider/model/credential config lives
-  # in the pipeline's terminal `run` proc — typically via `RubyLLM.context`:
-  #
-  #   run ->(env) do
-  #     context = RubyLLM.context { |c| c.ollama_api_base = ENV["OLLAMA_API_BASE"] }
-  #     ...
-  #   end
-  #
-  # See examples/agents/01_basic_agent.rb.
+  # NOTE: Brute owns no LLM configuration and no LLM library. All
+  # provider/model/credential config lives in the pipeline's terminal `run`
+  # proc, which the user writes with whatever LLM library they prefer
+  # (ruby_llm, llm.rb, openai, anthropic, raw HTTP, ...). The proc converts
+  # env[:messages] (Brute::Message values — see Brute.log) to the library's
+  # format, makes the call, and appends the response back as Brute::Message
+  # values — the MessageTransport pattern. See examples/ruby_llm.rb,
+  # examples/llm.rb, examples/openai.rb and examples/anthropic.rb.
 
   def self.provider
     @provider ||= :anthropic
@@ -60,19 +57,21 @@ module Brute
     Brute::Turn::AgentPipeline.new(&block)
   end
 
-  # Adapt any Brute tools (hashes, Brute::Turn::ToolPipeline, SubAgent, RubyLLM::Tool …)
-  # into a { name_sym => RubyLLM::Tool } hash — the shape an inline `run`
-  # proc hands to RubyLLM.chat.with_tools or a provider #complete call.
-  def self.rubyllm_tools(tools)
-    Brute::Tools::Adapter.wrap_all(tools || []).transform_values(&:to_ruby_llm)
+  # Adapt any Brute tools (hashes, Brute::Tool, Brute::Turn::ToolPipeline,
+  # SubAgent …) into a { name_sym => Brute::Tools::Adapter } hash. Each
+  # adapter exposes #to_h — a neutral JSON-Schema-ish definition the inline
+  # `run` proc converts to whatever its LLM library expects.
+  def self.tools(tools)
+    Brute::Tools::Adapter.wrap_all(tools || [])
   end
-  
+
+
   def self.provider=(p)
     @provider = p.to_sym
   end
 end
 
-Dir.glob("#{__dir__}/{brute,ruby_llm}/**/*.rb").sort.each do |path|
+Dir.glob("#{__dir__}/brute/**/*.rb").sort.each do |path|
   require path
 end
 

data/lib/brute_cli/providers/shell_response.rb

@@ -28,15 +28,15 @@ module BruteCLI
         return [empty_assistant] if @command.nil?
 
         call_id = "shell_#{SecureRandom.hex(8)}"
-        tool_calls = {
-          call_id => RubyLLM::ToolCall.new(
+        tool_calls = [
+          Brute::ToolCall.new(
             id: call_id,
             name: "shell",
             arguments: { "command" => @command },
           )
-        }
+        ]
 
-        [RubyLLM::Message.new(
+        [Brute::Message.new(
           role: :assistant,
           content: "",
           tool_calls: tool_calls,
@@ -78,17 +78,13 @@ module BruteCLI
       end
 
       def usage
-        RubyLLM::Tokens.new(
-          input: 0,
-          output: 0,
-          reasoning: 0,
-        )
+        { input: 0, output: 0, reasoning: 0 }
       end
 
       private
 
       def empty_assistant
-        RubyLLM::Message.new(role: :assistant, content: "")
+        Brute::Message.new(role: :assistant, content: "")
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Brute Contributors
@@ -37,20 +37,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.5'
-- !ruby/object:Gem::Dependency
-  name: ruby_llm
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -163,6 +149,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: lefthook
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
 description: Production-grade coding agent with tool execution, middleware pipeline,
   context compaction, session persistence, and multi-provider LLM support.
 executables: []
@@ -173,12 +173,18 @@ files:
 - lib/brute/events/handler.rb
 - lib/brute/events/prefixed_terminal_output.rb
 - lib/brute/events/terminal_output_handler.rb
+- lib/brute/message_transport.rb
+- lib/brute/message_transport/anthropic.rb
+- lib/brute/message_transport/llm.rb
+- lib/brute/message_transport/openai.rb
+- lib/brute/message_transport/ruby_llm.rb
 - lib/brute/messages.rb
 - lib/brute/middleware/001_otel_span.rb
 - lib/brute/middleware/002_session_log.rb
 - lib/brute/middleware/004_summarize.rb
 - lib/brute/middleware/005_tracing.rb
 - lib/brute/middleware/006_loop.rb
+- lib/brute/middleware/008_checkpoint.rb
 - lib/brute/middleware/010_max_iterations.rb
 - lib/brute/middleware/015_otel_token_usage.rb
 - lib/brute/middleware/020_system_prompt.rb
@@ -234,6 +240,7 @@ files:
 - lib/brute/rack/adapter.rb
 - lib/brute/skill.rb
 - lib/brute/system_prompt.rb
+- lib/brute/tool.rb
 - lib/brute/tools.rb
 - lib/brute/tools/adapter.rb
 - lib/brute/tools/fs/file_mutation_queue.rb
@@ -260,7 +267,6 @@ files:
 - lib/brute/version.rb
 - lib/brute_cli/providers/shell.rb
 - lib/brute_cli/providers/shell_response.rb
-- lib/ruby_llm/message_transport.rb
 homepage: https://github.com/general-intelligence-systems/brute
 licenses:
 - MIT
@@ -282,5 +288,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.7.2
 specification_version: 4
-summary: A coding agent built on ruby_llm
+summary: A framework-agnostic coding agent
 test_files: []