brute 5.0.4 → 5.1.0

data/lib/brute/tools/sub_agent.rb

@@ -21,7 +21,7 @@ module Brute
     #     use Brute::Middleware::SystemPrompt
     #     use Brute::Middleware::Loop::ToolResult
     #     use Brute::Middleware::MaxIterations, max_iterations: 10
-    #     use Brute::Middleware::ToolPipeline, tools: [Brute::Tools::FSRead, Brute::Tools::FSSearch]
+    #     use Brute::Middleware::DefaultToolPipeline, tools: [Brute::Tools::FSRead, Brute::Tools::FSSearch]
     #     run ->(env) do
     #       # The LLM call, written with your library of choice. Convert
     #       # env[:messages] to its format, call it, and append the response
@@ -32,7 +32,7 @@ module Brute
     #
     #   # The SubAgent IS a tool — hand it to a parent agent's ToolPipeline:
     #   main_agent = Brute.agent do
-    #     use Brute::Middleware::ToolPipeline, tools: [Brute::Tools::FSRead, researcher]
+    #     use Brute::Middleware::DefaultToolPipeline, tools: [Brute::Tools::FSRead, researcher]
     #     run ->(env) { ... }
     #   end
     #   main_agent.start("delegate some research")

data/lib/brute/turn/agent_pipeline.rb

@@ -18,26 +18,37 @@ module Brute
 
       # Register a slash command:
       #
-      #   map "/weather", "Get the weather in the following location $ARGUMENTS"
-      #   map("/weather") { "Get the weather in the following location $ARGUMENTS" }
+      #   map("/compact") { |env| ... }
+      #   map(/\Aplease compact/i) { |env| ... }
+      #   map(->(said) { said.length > 10_000 }) { |env| ... }
       #
-      def map(command, template = nil, &block)
-        command = command.to_s
-        command = command.start_with?("/") ? command : "/#{command}"
-
-        (@map ||= {})[command] = block || proc { template }
+      # Whatever is given becomes a check: a function of what was said that
+      # answers true or false. A String is a slash command -- "/compact"
+      # becomes ^\/compact.*, the command and whatever rides after it -- and
+      # a Regexp is wrapped in a function that evaluates it, so by the time
+      # a command is registered there are only functions. Anything that
+      # already answers to #call is taken as the check itself.
+      #
+      # This is Rack::Builder's `map` overridden: an agent routes on what was
+      # said, not on a path, so there are no sub-builders and no URLMap.
+      #
+      # The block is a middleware. `start` puts the registry into the turn as
+      # env[:commands], and SlashCommands -- which the builder puts at the
+      # head of every chain -- runs the first command whose check passes on
+      # the newest message, only when it is a user message, before the rest
+      # of the stack.
+      def map(matcher, &block)
+        (@commands ||= []) << [check(matcher), block]
         self
       end
 
-      def generate_map(default_app, mapping)
-        super.tap do |routes|
-          routes.define_singleton_method(:call) do |prompt|
-            name, args = prompt.to_s.strip.split(/\s+/, 2)
-            prompt = mapping[name].call.to_s.gsub("$ARGUMENTS", args.to_s) if mapping[name]
-            default_app.call(prompt)
-          end
-        end
+      # Every chain starts with the commands, registry or no registry: the
+      # builder puts SlashCommands at its head rather than leaving it to a
+      # `use` someone has to remember.
+      def to_app
+        Brute::Middleware::SlashCommands.new(super)
       end
+      alias_method :build, :to_app
 
       def start(input = nil, events: NullSink.new)
         env = {
@@ -45,6 +56,7 @@ module Brute
           events:            events,
           metadata:          {},
           current_iteration: 1,
+          commands:          @commands || [],
         }
         hooks.emit(TURN_START_EVENT, env)
         begin
@@ -57,6 +69,28 @@ module Brute
 
       private
 
+        # A matcher becomes a function of what was said. A Regexp is
+        # evaluated; a String is a slash command first -- given without its
+        # slash, it grows one -- and then evaluated the same way.
+        def check(matcher)
+          if matcher.respond_to?(:call)
+            matcher
+          else
+            pattern = pattern_for(matcher)
+            ->(said) { pattern.match?(said) }
+          end
+        end
+
+        def pattern_for(matcher)
+          if matcher.is_a?(::Regexp)
+            matcher
+          else
+            name = matcher.to_s
+            name = name.start_with?("/") ? name : "/#{name}"
+            /^#{::Regexp.escape(name)}.*/
+          end
+        end
+
         def coerce_messages(input)
           case input
           when nil                 then Brute.log
@@ -176,35 +210,80 @@ describe "brute/turn/agent_pipeline" do
     agent.start("go")[:messages].last.content.should == "done"
   end
 
-  it "map chains and to_app taps generate_map to build a (retargeted) URLMap" do
+  it "runs a command's block as a middleware, before the rest of the stack" do
+    order = []
     agent = Brute.agent
-      .map("/weather", "Get the weather in the following location $ARGUMENTS")
-      .run(->(prompt) { prompt })
+      .use(AgentStubMW)
+      .map("/compact") { |env| order << [:compact, env[:messages].last.content] }
+      .map("deploy") { |_env| order << :deploy }                 # grows its slash
+      .map(/\Aplease compact\b/i) { |_env| order << :asked }     # a Regexp is evaluated
+      .map(->(said) { said.length > 20 }) { |_env| order << :long }   # so is a function
+      .run(->(env) { order << :app; env[:messages].assistant("done") })
+
+    # The command runs first; the stack below it still runs.
+    agent.start("/compact notes")
+    order.should == [[:compact, "/compact notes"], :app]
+
+    # A String matches the command and whatever rides after it.
+    order.clear
+    agent.start("/deploy now")
+    order.should == [:deploy, :app]
+
+    # Checks are tried in the order they were registered, and the first to
+    # pass is the one that runs.
+    order.clear
+    agent.start("Please compact this, it has gone on long enough")
+    order.should == [:asked, :app]
+
+    order.clear
+    agent.start("something else entirely, at some length")
+    order.should == [:long, :app]
+
+    # Conversation and unregistered commands reach the stack untouched.
+    order.clear
+    agent.start("just a question")
+    agent.start("/unregistered")
+    order.should == [:app, :app]
+
+    # Only a user message says anything a command answers to.
+    order.clear
+    agent.start(Brute::Message.new(role: :assistant, content: "/compact"))
+    order.should == [:app]
+
+    # The registry rides in env, so anything below can see what was mapped.
+    agent.start("hello")[:commands].size.should == 4
+  end
+
+  it "turns a matcher into a check that answers true or false" do
+    checks = Brute.agent
+      .map("/compact") { |_env| }
+      .map("deploy") { |_env| }
+      .map(/\Ahello/) { |_env| }
+      .instance_variable_get(:@commands)
+      .map(&:first)
 
-    agent.should.be.kind_of?(Brute::Turn::AgentPipeline)   # map returns self
-    agent.build.should.be.kind_of?(::Rack::URLMap)         # to_app tapped generate_map (super)
+    checks.each { |check| check.should.respond_to?(:call) }
+
+    checks[0].call("/compact keep the notes").should.be.true
+    checks[0].call("/compactor").should.be.true          # ^\/compact.* and no more
+    checks[0].call("nope").should.be.false
+
+    checks[1].call("/deploy now").should.be.true         # registered without the slash
+    checks[1].call("deploy now").should.be.false
+
+    checks[2].call("hello there").should.be.true
+    checks[2].call("well hello").should.be.false
   end
 
-  it "swaps a /command prompt for its template ($ARGUMENTS) and calls the app" do
-    got = nil
+  it "map chains, and every chain is built with the commands at its head" do
     agent = Brute.agent
-      .map("/weather", "Get the weather in the following location $ARGUMENTS")
-      .map("/echo") { "you said: $ARGUMENTS" }
-      .run(->(prompt) { got = prompt })
-
-    agent.call("/weather London")
-    got.should == "Get the weather in the following location London"
-    agent.call("/echo hi there")
-    got.should == "you said: hi there"
-  end
+      .map("/compact") { |_env| }
+      .run(->(env) { env })
 
-  it "passes non-commands through untouched (and normalizes the slash)" do
-    got = nil
-    agent = Brute.agent.map("weather", "W $ARGUMENTS").run(->(prompt) { got = prompt })
+    agent.should.be.kind_of?(Brute::Turn::AgentPipeline)              # map returns self
+    agent.build.should.be.kind_of?(Brute::Middleware::SlashCommands)  # and the head is the commands
 
-    agent.call("just a question")
-    got.should == "just a question"
-    agent.call("/weather NYC")   # registered as "weather", normalized to "/weather"
-    got.should == "W NYC"
+    # No commands, same head.
+    Brute.agent.run(->(env) { env }).build.should.be.kind_of?(Brute::Middleware::SlashCommands)
   end
 end

data/lib/brute/turn/compaction_pipeline.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require "brute/turn/pipeline"
+
+module Brute
+  module Turn
+    # A compactor built out of middleware.
+    #
+    # Like ToolPipeline it *composes* a Pipeline rather than inheriting: the
+    # definition block is instance_eval'd into the internal Pipeline, so `use`
+    # / `run` inside it are the builder's methods.
+    #
+    # The stack order is the policy. A layer that got the conversation under
+    # target does not call the next one, so the strategies that cost nothing
+    # sit at the top and the terminal app -- the summariser, the only thing
+    # here that spends money -- is reached only when they could not get there.
+    # That is `run` meaning what it means everywhere else in Brute: the model
+    # call, at the bottom, with the layers deciding what reaches it.
+    #
+    #   Brute::Turn::CompactionPipeline.new do
+    #     use Brute::Compaction::Middleware::ToolResults,   keep_steps: 1
+    #     use Brute::Compaction::Middleware::SlidingWindow, keep_steps: 2
+    #
+    #     run Brute::Compaction::Summarize.new(
+    #       Brute::Completion::OpenRouter.new(config: { access_token: key }),
+    #     )
+    #   end
+    #
+    # A pipeline that must never spend a call is the first two layers and
+    # `run ->(env) { env }` -- a policy said out loud rather than configured.
+    #
+    # The conversation being compacted rides on `env[:conversation]`, leaving
+    # `env[:messages]` to mean what it means to every other terminal app in
+    # Brute: the prompt going down, the reply coming back.
+    #
+    # It answers #compact, so what comes out drops into
+    # Brute::Middleware::DefaultCompactionPipeline as that turn's compactor.
+    class CompactionPipeline
+      def initialize(&block)
+        @pipeline = Pipeline.new
+        @pipeline.instance_eval(&block) if block
+      end
+
+      # Answer a smaller conversation, or nil when nothing was given up.
+      def compact(messages, target:, events: Pipeline::NullSink.new, token_counter: nil)
+        env = {
+          conversation:  messages,
+          target:        target,
+          token_counter: token_counter,
+          applied:       [],
+          messages:      Brute.log,
+          events:        events,
+          metadata:      {},
+        }
+        @pipeline.call(env)
+
+        unless env[:applied].empty?
+          env[:conversation]
+        end
+      end
+    end
+  end
+end
+
+__END__
+
+describe "brute/turn/compaction_pipeline" do
+  def said(content) = Brute::Message.new(role: :user, content: content)
+
+  def layer(name, &block)
+    Class.new(Brute::Compaction::Middleware::Strategy) do
+      define_method(:strategy) { name }
+      define_method(:rewrite) { |conversation, target:| block.call(conversation, target) }
+    end
+  end
+
+  it "composes strategies into one compactor, and only reaches run when they could not" do
+    reached = []
+    halves = layer("halves") { |c, _t| reached << "halves"; c.first(c.length / 2) }
+    never  = layer("never")  { |_c, _t| reached << "never"; nil }
+    # A terminal belongs to one pipeline: the builder binds an emit onto it
+    # and refuses to bind a second, so each pipeline gets its own.
+    terminal = lambda do
+      Object.new.tap { |it| it.define_singleton_method(:call) { |env| reached << "run"; env } }
+    end
+
+    four = [said("a" * 4_000), said("b" * 4_000), said("c" * 4_000), said("d" * 4_000)]
+
+    # Halving is enough, so the terminal -- the one that costs money -- is
+    # never reached. The stack order is the policy.
+    pipeline = Brute::Turn::CompactionPipeline.new do
+      use halves
+      run terminal.call
+    end
+    pipeline.compact(four, target: 3_000).map { |m| m.content[0, 1] }.should == ["a", "b"]
+    reached.should == ["halves"]
+
+    # A strategy that declines lets the turn fall through to it.
+    reached.clear
+    Brute::Turn::CompactionPipeline.new do
+      use never
+      run terminal.call
+    end.compact(four, target: 3_000).should.be.nil
+    reached.should == ["never", "run"]
+
+    # Nothing given up at all is nil, not the conversation it was handed --
+    # the caller applies whatever else comes back.
+    reached.clear
+    pipeline.compact(four, target: 500_000).should.be.nil
+    reached.should == []
+
+    # The conversation rides on :conversation, leaving :messages to mean what
+    # it means to every other terminal app -- the prompt down, the reply back.
+    seen = nil
+    Brute::Turn::CompactionPipeline.new do
+      run ->(env) { seen = [env[:conversation].length, env[:messages], env[:target]] }
+    end.compact(four, target: 10)
+    seen.should == [4, [], 10]
+  end
+end

data/lib/brute/version.rb

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

data/lib/brute.rb

@@ -42,7 +42,7 @@ module Brute
   #
   #   agent = Brute.agent
   #     .use(Brute::Middleware::SystemPrompt)
-  #     .use(Brute::Middleware::ToolPipeline, tools: Brute::Tools::ALL)
+  #     .use(Brute::Middleware::DefaultToolPipeline, tools: Brute::Tools::ALL)
   #     .run ->(env) { ... }      # the LLM-call proc (provider/model/creds here)
   #
   #   agent.start("what changed?")
@@ -93,7 +93,14 @@ end
 require_relative "brute/version"
 require_relative "brute/hooks"
 require_relative "brute/messages"
+require_relative "brute/env"
 require_relative "brute/middleware/000_base"
+require_relative "brute/compaction"
+require_relative "brute/compaction/transcript"
+require_relative "brute/compaction/middleware/strategy"
+require_relative "brute/compaction/middleware/tool_results"
+require_relative "brute/compaction/middleware/sliding_window"
+require_relative "brute/compaction/summarize"
 require_relative "brute/completion/open_router"
 require_relative "brute/completion/lang_chain"
 require_relative "brute/completion/llmrb"
@@ -116,6 +123,7 @@ require_relative "brute/message_transport/openai"
 require_relative "brute/message_transport/ruby_llm"
 require_relative "brute/message_transport/ruby_open_ai"
 require_relative "brute/message_transport/lang_chain"
+require_relative "brute/middleware/001_slash_commands"
 require_relative "brute/middleware/002_session_log"
 require_relative "brute/middleware/004_summarize"
 require_relative "brute/middleware/006_loop"
@@ -123,8 +131,10 @@ require_relative "brute/middleware/008_checkpoint"
 require_relative "brute/middleware/010_max_iterations"
 require_relative "brute/middleware/020_system_prompt"
 require_relative "brute/middleware/025_skills"
+require_relative "brute/middleware/040_default_compaction_pipeline"
 require_relative "brute/middleware/040_compaction_check"
 require_relative "brute/middleware/060_questions"
+require_relative "brute/middleware/070_default_tool_pipeline"
 require_relative "brute/middleware/070_tool_pipeline"
 require_relative "brute/middleware/event_handler"
 require_relative "brute/middleware/user_queue"
@@ -156,6 +166,9 @@ require_relative "brute/prompts/tool_usage"
 require_relative "brute/rack/adapter"
 require_relative "brute/skill"
 require_relative "brute/system_prompt"
+require_relative "brute/token_counter"
+require_relative "brute/token_counter/approximate"
+require_relative "brute/token_counter/tiktoken"
 require_relative "brute/tool"
 require_relative "brute/tools"
 require_relative "brute/tools/adapter"
@@ -178,7 +191,9 @@ require_relative "brute/tools/todo_write"
 require_relative "brute/truncation"
 require_relative "brute/turn/agent_pipeline"
 require_relative "brute/turn/pipeline"
+require_relative "brute/turn/compaction_pipeline"
 require_relative "brute/turn/tool_pipeline"
+require_relative "brute/eval"
 require_relative "brute/utils/diff"
 
 # gangsta g-dogg bruh...

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 5.0.4
+  version: 5.1.0
 platform: ruby
 authors:
 - Brute Contributors
@@ -282,12 +282,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/brute.rb
+- lib/brute/compaction.rb
+- lib/brute/compaction/middleware/sliding_window.rb
+- lib/brute/compaction/middleware/strategy.rb
+- lib/brute/compaction/middleware/tool_results.rb
+- lib/brute/compaction/summarize.rb
+- lib/brute/compaction/transcript.rb
 - lib/brute/completion/lang_chain.rb
 - lib/brute/completion/llmrb.rb
 - lib/brute/completion/open_router.rb
 - lib/brute/completion/ruby_llm.rb
 - lib/brute/contrib/log_file.rb
 - lib/brute/contrib/otel.rb
+- lib/brute/env.rb
+- lib/brute/eval.rb
+- lib/brute/eval/case.rb
+- lib/brute/eval/suite.rb
+- lib/brute/eval/transcript.rb
+- lib/brute/eval/world.rb
 - lib/brute/events/handler.rb
 - lib/brute/events/prefixed_terminal_output.rb
 - lib/brute/events/terminal_output_handler.rb
@@ -302,6 +314,7 @@ files:
 - lib/brute/message_transport/ruby_open_ai.rb
 - lib/brute/messages.rb
 - lib/brute/middleware/000_base.rb
+- lib/brute/middleware/001_slash_commands.rb
 - lib/brute/middleware/002_session_log.rb
 - lib/brute/middleware/004_summarize.rb
 - lib/brute/middleware/006_loop.rb
@@ -310,7 +323,9 @@ files:
 - lib/brute/middleware/020_system_prompt.rb
 - lib/brute/middleware/025_skills.rb
 - lib/brute/middleware/040_compaction_check.rb
+- lib/brute/middleware/040_default_compaction_pipeline.rb
 - lib/brute/middleware/060_questions.rb
+- lib/brute/middleware/070_default_tool_pipeline.rb
 - lib/brute/middleware/070_tool_pipeline.rb
 - lib/brute/middleware/event_handler.rb
 - lib/brute/middleware/user_queue.rb
@@ -361,6 +376,9 @@ files:
 - lib/brute/rack/adapter.rb
 - lib/brute/skill.rb
 - lib/brute/system_prompt.rb
+- lib/brute/token_counter.rb
+- lib/brute/token_counter/approximate.rb
+- lib/brute/token_counter/tiktoken.rb
 - lib/brute/tool.rb
 - lib/brute/tools.rb
 - lib/brute/tools/adapter.rb
@@ -382,6 +400,7 @@ files:
 - lib/brute/tools/todo_write.rb
 - lib/brute/truncation.rb
 - lib/brute/turn/agent_pipeline.rb
+- lib/brute/turn/compaction_pipeline.rb
 - lib/brute/turn/pipeline.rb
 - lib/brute/turn/tool_pipeline.rb
 - lib/brute/usage_detection/lang_chain.rb