brute 5.0.4 → 5.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 46c27c1fb3c90344f693d63e91d7d0ccd8cf0b33c44c51d9d1cced16b3728b9e
-  data.tar.gz: d6016cef2788aa4dfb5551816538ca9ea6ff1fe80f4ce6b6d5e5dfabae1cc5f3
+  metadata.gz: 146d42f66c911ce3ce45384eaeadd96bb877befe2740a417f405fb693c73acc2
+  data.tar.gz: 439445efa583943587f1d70d03c626a6d34e58d40509f03d3d3ce33c9edf03c9
 SHA512:
-  metadata.gz: e2b383c66662c7f3fdd0c9ce6c8f9a1f98d4f6cddbfd8192f4bfc5c46ec335787146e143035e489491220c8ac9e2bedac16a1538caf7be9350dc86fe37a6c4e9
-  data.tar.gz: 383c89c05e8c85368aec9107769ec0e540b823f89a0e17eaf691840cea1cd0c07d1a496f3f42b81ff5517262a78cbee8f32f51ba9fa00d27255e23ef3b6c4aae
+  metadata.gz: 36ed02483e9838d2d71272bf471f5ffa025cf980b56b54c576873c011c85085c89320f513a00002acb814fc01c333f8882c796af2a900828b5532b26aea5c800
+  data.tar.gz: 925cc550884beadf57fbc631f7b796afc5484af8fea604e6b2cad19459159c2a664eff45a7429b0c385bc894320867ad0d12946ed26ccd42b7086b9c93b66926

data/lib/brute/middleware/001_slash_commands.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+
+module Brute
+  module Middleware
+    # The head of every agent chain, put there by the builder itself rather
+    # than by a `use` anyone writes. It switches on what was just said: the
+    # newest message, and only when it is a user message, is offered to each
+    # of env[:commands]'s checks in turn -- the commands registered with
+    # `AgentPipeline#map`, which `start` puts there. The first check that
+    # passes has its block run here, before the rest of the stack.
+    #
+    #   Brute.agent
+    #     .map("/compact") { |env| ... }
+    #     .run(->(env) { ... })
+    #
+    # A command's block is a middleware, so what it leaves in env is what
+    # the rest of the chain works on.
+    class SlashCommands < Brute::Middleware::Base
+      def call(env)
+        matched(env)&.call(env)
+        @app.call(env)
+      end
+
+      private
+
+        # The block of the first command whose check passes on what was just
+        # said -- and nothing at all unless the room said it, so not the
+        # assistant and not an empty log.
+        def matched(env)
+          message = Array(env[:messages]).last
+
+          if message.respond_to?(:role) && message.role == :user
+            _check, block = Array(env[:commands]).find { |check, _block| check.call(message.content.to_s) }
+            block
+          end
+        end
+    end
+  end
+end
+
+__END__
+
+describe "brute/middleware/001_slash_commands" do
+  require "brute/messages"
+
+  it "runs the first of env[:commands] whose check matches what was just said" do
+    ran = []
+    commands = [
+      [->(said) { said.start_with?("/compact") }, ->(env) { ran << [:compact, env[:messages].last.content] }],
+      [->(said) { said.length > 20 }, ->(_env) { ran << :long }],
+    ]
+
+    reached = []
+    inner = ->(env) { reached << env[:messages].last&.content; env }
+    middleware = Brute::Middleware::SlashCommands.new(inner)
+
+    def turn(commands, said, role = :user)
+      { commands: commands, messages: Brute.log.tap { |log| log << Brute::Message.new(role: role, content: said) } }
+    end
+
+    # The matching command runs before the stack below it.
+    middleware.call(turn(commands, "/compact keep the notes"))
+    ran.should == [[:compact, "/compact keep the notes"]]
+    reached.should == ["/compact keep the notes"]
+
+    # Checks are tried in order, and only the first to pass runs.
+    ran.clear
+    middleware.call(turn(commands, "something else, at some length"))
+    ran.should == [:long]
+
+    # Nothing matches, nothing runs -- and the turn carries on regardless.
+    ran.clear
+    reached.clear
+    middleware.call(turn(commands, "short"))
+    middleware.call(turn(commands, "/compact", :assistant))
+    middleware.call({ commands: commands, messages: Brute.log })
+    ran.should.be.empty
+    reached.should == ["short", "/compact", nil]
+
+    # A turn carrying no commands at all still runs, and does nothing.
+    ran.clear
+    middleware.call({ messages: Brute.log.tap { |log| log.user("/compact") } })
+    ran.should.be.empty
+  end
+end

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/version.rb

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

data/lib/brute.rb

@@ -116,6 +116,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"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 5.0.4
+  version: 5.0.5
 platform: ruby
 authors:
 - Brute Contributors
@@ -302,6 +302,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