brute 3.0.0 → 3.0.1

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.0.1"
 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.0.1
 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,6 +173,11 @@ 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
@@ -234,6 +239,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 +266,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 +287,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: []

data/lib/ruby_llm/message_transport.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "brute"
-
-module RubyLLM
-  # Transports the result of an LLM call into Brute's message format.
-  #
-  # Calling an LLM is trivial — `RubyLLM.chat.ask "..."` — so Brute has no
-  # "completion middleware". The terminal `run` of an agent pipeline is an
-  # inline proc that makes the LLM call itself. The only wrinkle: RubyLLM hands
-  # back its own objects (a Message, an array, a whole Chat transcript), while
-  # the rest of the stack — the turn manager, event handlers, tool loop and
-  # SessionLog persistence — works off `env[:messages]` (a plain message log;
-  # see Brute.log).
-  #
-  # This makes NO LLM call and does NO appending. It just wraps what the proc
-  # got back and yields each message in Brute's format; the proc appends:
-  #
-  #   response = provider.complete(env[:messages], ...)          # one Message
-  #   RubyLLM::MessageTransport.new(response).wrap_each do |message|
-  #     env[:messages] << message
-  #   end
-  #
-  #   before = chat.messages.length                              # a Chat loop
-  #   chat.complete
-  #   RubyLLM::MessageTransport.new(chat.messages[before..]).wrap_each do |message|
-  #     env[:messages] << message
-  #   end
-  class MessageTransport
-    # Convenience: RubyLLM::MessageTransport.wrap_each(result) { |m| ... }
-    def self.wrap_each(result, &block)
-      new(result).wrap_each(&block)
-    end
-
-    def initialize(result)
-      @result = result
-    end
-
-    # Yield each result message in Brute's format. Without a block, returns an
-    # Enumerator. The caller decides what to do with each (typically append to
-    # env[:messages]).
-    def wrap_each
-      return enum_for(:wrap_each) unless block_given?
-
-      messages.each { |message| yield wrap(message) }
-    end
-
-    # The result normalized to a flat list of messages. A single Message, an
-    # array, or anything transcript-shaped (a Chat responds to #messages).
-    def messages
-      case @result
-      when ::RubyLLM::Message then [@result]
-      when Array              then @result.compact
-      else @result.respond_to?(:messages) ? @result.messages : Array(@result)
-      end
-    end
-
-    private
-
-      # The Brute-format view of a single message. RubyLLM::Message already IS
-      # Brute's message format, so this is the identity seam — the place to
-      # normalize if the two formats ever diverge.
-      def wrap(message)
-        message
-      end
-  end
-end
-
-__END__
-
-describe "ruby_llm/message_transport" do
-  require "brute/messages"
-
-  it "wraps a single message" do
-    message = RubyLLM::Message.new(role: :assistant, content: "hi")
-    RubyLLM::MessageTransport.new(message).wrap_each.to_a.should == [message]
-  end
-
-  it "wraps an array of messages" do
-    a = RubyLLM::Message.new(role: :assistant, content: "one")
-    b = RubyLLM::Message.new(role: :tool, content: "two", tool_call_id: "tc1")
-    RubyLLM::MessageTransport.new([a, b]).wrap_each.to_a.should == [a, b]
-  end
-
-  it "wraps a transcript-shaped object (a Chat)" do
-    fake_chat = Class.new do
-      attr_reader :messages
-      def initialize(messages); @messages = messages; end
-    end
-    msgs = [RubyLLM::Message.new(role: :user, content: "hi"),
-            RubyLLM::Message.new(role: :assistant, content: "hello")]
-
-    RubyLLM::MessageTransport.new(fake_chat.new(msgs)).wrap_each.to_a.map(&:role).should == [:user, :assistant]
-  end
-
-  it "yields each message to the block for the caller to append" do
-    session = Brute.log
-    session.user("hello")
-    response = RubyLLM::Message.new(role: :assistant, content: "hi there")
-
-    RubyLLM::MessageTransport.new(response).wrap_each { |message| session << message }
-
-    session.last.role.should == :assistant
-    session.last.content.should == "hi there"
-  end
-
-  it "exposes a class-level wrap_each convenience" do
-    session = Brute.log
-    a = RubyLLM::Message.new(role: :assistant, content: "a")
-    b = RubyLLM::Message.new(role: :assistant, content: "b")
-
-    RubyLLM::MessageTransport.wrap_each([a, b]) { |message| session << message }
-
-    session.map(&:content).should == ["a", "b"]
-  end
-end