brute 0.4.1 → 1.0.0

data/lib/brute/middleware/doom_loop_detection.rb

@@ -1,34 +1,39 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
+require "bundler/setup"
+require "brute"
 
 module Brute
   module Middleware
     # Detects when the agent is stuck repeating tool call patterns and injects
-    # a corrective warning into the context before the next LLM call.
+    # a corrective warning into the message history before the next LLM call.
     #
     # Runs PRE-call: inspects the conversation history for repeating tool call
-    # patterns. If detected, talks a warning message into the context so the
-    # LLM sees it as input alongside the normal tool results.
+    # patterns. If detected, appends a warning message so the LLM sees it as
+    # input alongside the normal tool results.
     #
     class DoomLoopDetection < Base
       def initialize(app, threshold: 3)
         super(app)
-        @detector = Brute::DoomLoopDetector.new(threshold: threshold)
+        @detector = Brute::Loop::DoomLoopDetector.new(threshold: threshold)
       end
 
       def call(env)
-        ctx = env[:context]
-        messages = ctx.messages.to_a
+        messages = env[:messages]
 
         if (reps = @detector.detect(messages))
           warning = @detector.warning_message(reps)
           # Inject the warning as a user message so the LLM sees it
-          ctx.talk(warning)
+          env[:messages] << LLM::Message.new(:user, warning)
           env[:metadata][:doom_loop_detected] = reps
+
+          # Signal the agent loop to exit after this LLM call completes.
+          # First-writer-wins: don't overwrite if another middleware already set it.
+          env[:should_exit] ||= {
+            reason:  "doom_loop_detected",
+            message: "Agent is stuck repeating the same tool calls (#{reps} repetitions).",
+            source:  "DoomLoopDetection",
+          }
         end
 
         @app.call(env)
@@ -37,97 +42,95 @@ module Brute
   end
 end
 
-if __FILE__ == $0
-  require_relative "../../../spec/spec_helper"
-
-  RSpec.describe Brute::Middleware::DoomLoopDetection do
-    let(:response) { MockResponse.new(content: "loop check") }
-    let(:inner_app) { ->(_env) { response } }
-
-    # Build a fake assistant message whose .functions returns the given list.
-    def assistant_msg_with_functions(function_list)
-      msg = LLM::Message.new(:assistant, "tool msg", {})
-      allow(msg).to receive(:functions).and_return(function_list)
-      msg
-    end
-
-    def fake_function(name:, arguments:)
-      double("fn", name: name, arguments: arguments)
-    end
-
-    it "passes through when no doom loop is detected" do
-      middleware = described_class.new(inner_app, threshold: 3)
-      env = build_env
-
-      result = middleware.call(env)
-
-      expect(result).to eq(response)
-      expect(env[:metadata][:doom_loop_detected]).to be_nil
-    end
-
-    it "detects consecutive identical tool calls" do
-      provider = MockProvider.new
-      ctx = LLM::Context.new(provider, tools: [])
-
-      fn = fake_function(name: "fs_read", arguments: '{"path":"x.rb"}')
-      messages = 4.times.map { assistant_msg_with_functions([fn]) }
-
-      allow(ctx).to receive(:messages).and_return(double("buffer", to_a: messages))
-      allow(ctx).to receive(:talk)
-
-      middleware = described_class.new(inner_app, threshold: 3)
-      env = build_env(context: ctx, provider: provider)
-
-      middleware.call(env)
-
-      expect(env[:metadata][:doom_loop_detected]).not_to be_nil
-    end
-
-    it "detects repeating sequences [A,B,A,B,A,B]" do
-      provider = MockProvider.new
-      ctx = LLM::Context.new(provider, tools: [])
+test do
+  require_relative "../../../spec/support/mock_provider"
+  require_relative "../../../spec/support/mock_response"
 
-      fn_a = fake_function(name: "fs_read", arguments: '{"path":"a.rb"}')
-      fn_b = fake_function(name: "shell", arguments: '{"cmd":"ls"}')
-      messages = 3.times.flat_map do
-        [assistant_msg_with_functions([fn_a]), assistant_msg_with_functions([fn_b])]
-      end
-
-      allow(ctx).to receive(:messages).and_return(double("buffer", to_a: messages))
-      allow(ctx).to receive(:talk)
+  def build_env(**overrides)
+    { provider: MockProvider.new, model: nil, input: "test prompt", tools: [],
+      messages: [], stream: nil, params: {}, metadata: {}, callbacks: {},
+      tool_results: nil, streaming: false, should_exit: nil, pending_functions: [] }.merge(overrides)
+  end
 
-      middleware = described_class.new(inner_app, threshold: 3)
-      env = build_env(context: ctx, provider: provider)
+  FakeFunc = Struct.new(:name, :arguments, keyword_init: true)
 
-      middleware.call(env)
+  def assistant_msg_with_functions(function_list)
+    msg = LLM::Message.new(:assistant, "tool msg", {})
+    msg.define_singleton_method(:functions) { function_list }
+    msg
+  end
 
-      expect(env[:metadata][:doom_loop_detected]).not_to be_nil
-    end
+  it "passes through when no doom loop is detected" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    env = build_env
+    middleware.call(env)
+    env[:metadata][:doom_loop_detected].should.be.nil
+  end
 
-    it "does not trigger below the threshold" do
-      provider = MockProvider.new
-      ctx = LLM::Context.new(provider, tools: [])
+  it "detects consecutive identical tool calls" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    fn = FakeFunc.new(name: "fs_read", arguments: '{"path":"x.rb"}')
+    messages = 4.times.map { assistant_msg_with_functions([fn]) }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    env = build_env(messages: messages)
+    middleware.call(env)
+    env[:metadata][:doom_loop_detected].should.not.be.nil
+  end
 
-      fn = fake_function(name: "fs_read", arguments: '{"path":"x.rb"}')
-      messages = 2.times.map { assistant_msg_with_functions([fn]) }
+  it "does not trigger below the threshold" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    fn = FakeFunc.new(name: "fs_read", arguments: '{"path":"x.rb"}')
+    messages = 2.times.map { assistant_msg_with_functions([fn]) }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    env = build_env(messages: messages)
+    middleware.call(env)
+    env[:metadata][:doom_loop_detected].should.be.nil
+  end
 
-      allow(ctx).to receive(:messages).and_return(double("buffer", to_a: messages))
+  it "sets should_exit reason when doom loop detected" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    fn = FakeFunc.new(name: "fs_read", arguments: '{"path":"x.rb"}')
+    messages = 4.times.map { assistant_msg_with_functions([fn]) }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    env = build_env(messages: messages)
+    middleware.call(env)
+    env[:should_exit][:reason].should == "doom_loop_detected"
+  end
 
-      middleware = described_class.new(inner_app, threshold: 3)
-      env = build_env(context: ctx, provider: provider)
+  it "does not set should_exit when no loop detected" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    env = build_env
+    middleware.call(env)
+    env[:should_exit].should.be.nil
+  end
 
-      middleware.call(env)
+  it "does not overwrite should_exit if already set" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    fn = FakeFunc.new(name: "fs_read", arguments: '{"path":"x.rb"}')
+    messages = 4.times.map { assistant_msg_with_functions([fn]) }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    existing = { reason: "other", message: "earlier", source: "Other" }
+    env = build_env(messages: messages, should_exit: existing)
+    middleware.call(env)
+    env[:should_exit][:reason].should == "other"
+  end
 
-      expect(env[:metadata][:doom_loop_detected]).to be_nil
-    end
+  it "appends a warning message when loop detected" do
+    inner_app = ->(_env) { MockResponse.new(content: "loop check") }
+    fn = FakeFunc.new(name: "fs_read", arguments: '{"path":"x.rb"}')
+    messages = 4.times.map { assistant_msg_with_functions([fn]) }
+    middleware = Brute::Middleware::DoomLoopDetection.new(inner_app, threshold: 3)
+    env = build_env(messages: messages)
+    original_count = env[:messages].size
+    middleware.call(env)
+    env[:messages].size.should == original_count + 1
+  end
 
-    describe Brute::DoomLoopDetector do
-      it "generates a warning message with repetition count" do
-        detector = described_class.new(threshold: 3)
-        msg = detector.warning_message(5)
-        expect(msg).to include("Doom loop detected")
-        expect(msg).to include("5 times")
-      end
-    end
+  it "generates warning message with repetition count" do
+    detector = Brute::Loop::DoomLoopDetector.new(threshold: 3)
+    msg = detector.warning_message(5)
+    msg.should =~ /5 times/
   end
 end

data/lib/brute/middleware/llm_call.rb

@@ -1,17 +1,35 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
+require "brute"
+
 module Brute
   module Middleware
     # The terminal "app" in the pipeline — performs the actual LLM call.
     #
+    # Builds a fresh LLM::Context per call from env[:messages], makes the
+    # call, extracts new messages back into env[:messages], and stashes
+    # pending functions in env[:pending_functions].
+    #
     # When streaming, on_content fires incrementally via AgentStream.
     # When not streaming, fires on_content post-hoc with the full text.
     #
     class LLMCall
       def call(env)
-        ctx = env[:context]
+        ctx = build_context(env)
+
+        # Load existing conversation history into the ephemeral context
+        ctx.messages.concat(env[:messages])
+
         response = ctx.talk(env[:input])
 
+        # Extract new messages appended by talk() and store them
+        new_messages = ctx.messages.to_a.drop(env[:messages].size)
+        env[:messages].concat(new_messages)
+
+        # Stash pending functions for the agent loop
+        env[:pending_functions] = ctx.functions.to_a
+
         # Only fire on_content post-hoc when NOT streaming
         # (streaming delivers chunks incrementally via AgentStream)
         unless env[:streaming]
@@ -26,6 +44,14 @@ module Brute
 
       private
 
+      def build_context(env)
+        params = {}
+        params[:tools]  = env[:tools]   if env[:tools]&.any?
+        params[:stream] = env[:stream]  if env[:stream]
+        params[:model]  = env[:model]   if env[:model]
+        LLM::Context.new(env[:provider], **params)
+      end
+
       # Safely extract text content from an LLM response.
       # Returns nil when the response contains only tool calls (no assistant text),
       # which causes LLM::Contract::Completion#content to raise NoMethodError
@@ -40,91 +66,63 @@ module Brute
   end
 end
 
-if __FILE__ == $0
-  require_relative "../../../spec/spec_helper"
-
-  RSpec.describe Brute::Middleware::LLMCall do
-    let(:provider) { MockProvider.new }
-    let(:middleware) { described_class.new }
-
-    it "calls ctx.talk with env[:input] and returns the response" do
-      ctx = LLM::Context.new(provider, tools: [])
-      prompt = ctx.prompt { |p| p.system("sys"); p.user("hello") }
-      env = build_env(context: ctx, provider: provider, input: prompt, streaming: false)
-
-      response = middleware.call(env)
-
-      expect(response).not_to be_nil
-      expect(provider.calls.size).to eq(1)
-    end
-
-    context "when not streaming" do
-      it "fires on_content callback with the response text" do
-        received_content = nil
-        callback = ->(text) { received_content = text }
+test do
+  require_relative "../../../spec/support/mock_provider"
+  require_relative "../../../spec/support/mock_response"
 
-        response = MockResponse.new(content: "Hello world")
-        allow(provider).to receive(:complete).and_return(response)
-
-        ctx = LLM::Context.new(provider, tools: [])
-        prompt = ctx.prompt { |p| p.system("sys"); p.user("hi") }
-        env = build_env(
-          context: ctx,
-          provider: provider,
-          input: prompt,
-          streaming: false,
-          callbacks: { on_content: callback }
-        )
-
-        middleware.call(env)
+  def build_env(**overrides)
+    { provider: MockProvider.new, model: nil, input: "test prompt", tools: [],
+      messages: [], stream: nil, params: {}, metadata: {}, callbacks: {},
+      tool_results: nil, streaming: false, should_exit: nil, pending_functions: [] }.merge(overrides)
+  end
 
-        expect(received_content).to eq("Hello world")
-      end
-    end
+  it "calls the provider and returns a response" do
+    provider = MockProvider.new
+    middleware = Brute::Middleware::LLMCall.new
+    env = build_env(provider: provider, input: "hello", streaming: false)
+    response = middleware.call(env)
+    response.should.not.be.nil
+  end
 
-    context "when streaming" do
-      it "does not fire on_content callback" do
-        callback_called = false
-        callback = ->(_text) { callback_called = true }
+  it "records a call on the provider" do
+    provider = MockProvider.new
+    middleware = Brute::Middleware::LLMCall.new
+    env = build_env(provider: provider, input: "hello", streaming: false)
+    middleware.call(env)
+    provider.calls.size.should == 1
+  end
 
-        ctx = LLM::Context.new(provider, tools: [])
-        prompt = ctx.prompt { |p| p.system("sys"); p.user("hi") }
-        env = build_env(
-          context: ctx,
-          provider: provider,
-          input: prompt,
-          streaming: true,
-          callbacks: { on_content: callback }
-        )
+  it "appends new messages to env[:messages]" do
+    provider = MockProvider.new
+    middleware = Brute::Middleware::LLMCall.new
+    env = build_env(provider: provider, input: "hello", streaming: false)
+    middleware.call(env)
+    env[:messages].should.not.be.empty
+  end
 
-        middleware.call(env)
+  it "populates env[:pending_functions] as an Array" do
+    provider = MockProvider.new
+    middleware = Brute::Middleware::LLMCall.new
+    env = build_env(provider: provider, input: "hello", streaming: false)
+    middleware.call(env)
+    env[:pending_functions].should.be.kind_of(Array)
+  end
 
-        expect(callback_called).to be false
-      end
-    end
+  it "does not fire on_content callback when streaming" do
+    provider = MockProvider.new
+    middleware = Brute::Middleware::LLMCall.new
+    called = false
+    env = build_env(provider: provider, input: "hi", streaming: true, callbacks: { on_content: ->(_) { called = true } })
+    middleware.call(env)
+    called.should.be.false
+  end
 
-    context "when response content raises NoMethodError (tool-only response)" do
-      it "does not crash and does not fire on_content" do
-        received_content = :not_called
-        callback = ->(text) { received_content = text }
-
-        bad_response = MockResponse.new(content: "")
-        allow(bad_response).to receive(:content).and_raise(NoMethodError)
-        allow(provider).to receive(:complete).and_return(bad_response)
-
-        ctx = LLM::Context.new(provider, tools: [])
-        prompt = ctx.prompt { |p| p.system("sys"); p.user("hi") }
-        env = build_env(
-          context: ctx,
-          provider: provider,
-          input: prompt,
-          streaming: false,
-          callbacks: { on_content: callback }
-        )
-
-        expect { middleware.call(env) }.not_to raise_error
-        expect(received_content).to eq(:not_called)
-      end
-    end
+  it "preserves existing messages across calls" do
+    provider = MockProvider.new
+    middleware = Brute::Middleware::LLMCall.new
+    existing = LLM::Message.new(:user, "previous")
+    env = build_env(provider: provider, input: "hello", streaming: false, messages: [existing])
+    middleware.call(env)
+    env[:messages].first.should == existing
   end
 end