brute 1.0.0 → 2.0.0

data/lib/brute/loop/agent_turn.rb

@@ -1,520 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "brute"
-
-module Brute
-  module Loop
-  # Factory + namespace for provider-specific agent turns.
-  #
-  # An agent turn sends a message to the LLM, iterates over tool calls
-  # until there are none left, and returns the response. Each turn has
-  # its own job queue for tool execution (ParallelQueue of ToolCallSteps).
-  #
-  # Usage:
-  #
-  #   step = AgentTurn.perform(agent:, session:, pipeline:, input:)
-  #
-  # AgentTurn.perform detects the provider from the agent and returns
-  # the appropriate provider-specific Step subclass, already executed.
-  # The returned step has .state, .result, .error, etc.
-  #
-  # Provider-specific subclasses live under AgentTurn:: and override
-  # supported_messages to filter the session's message history per
-  # provider capability.
-  #
-  module AgentTurn
-    # Build and return the right AgentTurn step for this agent's provider.
-    # Does NOT execute it — call step.call(task) yourself, or enqueue it.
-    def self.new(agent:, session:, pipeline:, input: nil, callbacks: {}, **rest)
-      klass = detect(agent.provider)
-      klass.new(agent: agent, session: session, pipeline: pipeline, input: input, callbacks: callbacks, **rest)
-    end
-
-    # Build, execute inside a Sync block, return the finished step.
-    def self.perform(agent:, session:, pipeline:, input: nil, callbacks: {}, **rest)
-      step = self.new(agent: agent, session: session, pipeline: pipeline, input: input, callbacks: callbacks, **rest)
-      Sync do
-        step.call(Async::Task.current)
-      end
-      step
-    end
-
-    # Detect the right subclass from the provider.
-    def self.detect(provider)
-      if provider
-        provider.class.name.to_s.downcase.then do |class_name|
-          if class_name.include?("anthropic")
-            Anthropic
-          elsif class_name.include?("openai")
-            OpenAI
-          elsif class_name.include?("google") || class_name.include?("gemini")
-            Google
-          else
-            Base
-          end
-        end
-      else
-        Base
-      end
-    end
-
-    # The default implementation. Works for any provider.
-    # Provider-specific subclasses override supported_messages
-    # and anything else that differs.
-    #
-    # LLM::Context is built fresh for each pipeline call by the LLMCall
-    # middleware. The agent turn owns the conversation state via
-    # env[:messages] (an Array<LLM::Message>).
-    #
-    # Supports two modes:
-    #
-    #   Non-streaming (default): text arrives after the LLM call completes,
-    #   on_content fires post-hoc via LLMCall middleware, tool calls come
-    #   from env[:pending_functions].
-    #
-    #   Streaming: enabled when on_content or on_reasoning callbacks are
-    #   present. Text/reasoning fire incrementally via AgentStream. Tool
-    #   calls are deferred during the stream and collected afterward from
-    #   the stream's pending_tools.
-    #
-    # Callbacks:
-    #
-    #   on_content:         ->(text) {}     # text chunk (streaming) or full text (non-streaming)
-    #   on_reasoning:       ->(text) {}     # reasoning/thinking chunk (streaming only)
-    #   on_tool_call_start: ->(batch) {}    # [{name:, arguments:}, ...] before tool execution
-    #   on_tool_result:     ->(name, r) {}  # per-tool, after each completes
-    #   on_question:        ->(questions, queue) {}  # interactive; push answers onto queue
-    #
-    class Base < Step
-      MAX_ITERATIONS = 100
-
-      attr_reader :agent, :session
-
-      def initialize(agent:, session:, pipeline:, input: nil, callbacks: {}, **rest)
-        super(**rest)
-        @agent     = agent
-        @session   = session
-        @pipeline  = pipeline
-        @input     = input
-        @callbacks = callbacks
-
-        # Create streaming bridge when content or reasoning callbacks are
-        # present. The stream is passed into env so LLMCall can wire it
-        # into each fresh LLM::Context.
-        if @callbacks[:on_content] || @callbacks[:on_reasoning]
-          @stream = AgentStream.new(
-            on_content:   @callbacks[:on_content],
-            on_reasoning: @callbacks[:on_reasoning],
-            on_question:  @callbacks[:on_question],
-          )
-        end
-      end
-
-      def perform(task)
-        env = build_env
-
-        # First LLM call
-        env[:input] = build_initial_input(@input)
-        env[:tool_results] = nil
-        response = @pipeline.call(env)
-
-        iterations = 0
-        while !env[:should_exit] &&
-          (pending = collect_pending_tools(env)).any? &&
-          iterations < MAX_ITERATIONS
-
-          # Fire on_tool_call_start with the full batch
-          @callbacks[:on_tool_call_start]&.call(
-            pending.map { |fn, _| { name: fn.name, arguments: fn.arguments } }
-          )
-
-          # Partition: question tools run sequentially on this fiber,
-          # all others run in parallel via the sub-queue.
-          questions, others = pending.partition { |fn, _| fn.name == "question" }
-
-          results = []
-
-          # Questions first — sequential, blocking, with on_question fiber-local
-          questions.each do |fn, err|
-            if err
-              @callbacks[:on_tool_result]&.call(err.name, result_value(err))
-              results << err
-            else
-              Thread.current[:on_question] = @callbacks[:on_question]
-              result = fn.call
-              @callbacks[:on_tool_result]&.call(fn.name, result_value(result))
-              results << result
-            end
-          end
-
-          # Others — into the parallel queue
-          if others.any?
-            errors, executable = others.partition { |_, err| err }
-
-            # Record pre-existing errors (from stream's on_tool_call)
-            errors.each do |_, err|
-              @callbacks[:on_tool_result]&.call(err.name, result_value(err))
-              results << err
-            end
-
-            if executable.any?
-              tool_steps = executable.map { |fn, _| ToolCallStep.new(function: fn) }
-              tool_steps.each { |s| jobs(type: Brute::Queue::ParallelQueue) << s }
-              jobs.drain
-
-              tool_steps.each do |s|
-                val = s.state == :completed ? s.result : s.error
-                @callbacks[:on_tool_result]&.call(s.function.name, result_value(val))
-                results << val
-              end
-            end
-          end
-
-          # Feed results back to LLM
-          env[:input] = results
-          env[:tool_results] = results.filter_map { |r|
-            name = r.respond_to?(:name) ? r.name : "unknown"
-            [name, result_value(r)]
-          }
-          response = @pipeline.call(env)
-
-          # Re-create sub-queue for next iteration's tool calls
-          @mutex.synchronize { @jobs = nil }
-          iterations += 1
-        end
-
-        response
-      end
-
-      # Override in subclasses to filter message types per provider.
-      # Default: all messages pass through.
-      def supported_messages(messages)
-        messages
-      end
-
-      private
-
-      def build_env
-        {
-          provider:          @agent.provider,
-          model:             @agent.model,
-          input:             nil,
-          tools:             @agent.tools,
-          messages:          [],
-          stream:            @stream,
-          params:            {},
-          metadata:          {},
-          tool_results:      nil,
-          streaming:         !!@stream,
-          callbacks:         @callbacks,
-          should_exit:       nil,
-          pending_functions: [],
-        }
-      end
-
-      def build_initial_input(user_message)
-        sys = @agent.system_prompt
-        LLM::Prompt.new(@agent.provider) do |p|
-          p.system(sys) if sys
-          p.user(user_message) if user_message
-        end
-      end
-
-      # Collect pending tool calls from the stream (streaming mode) or
-      # from env[:pending_functions] (set by LLMCall after each call).
-      #
-      # Returns [(function, error_or_nil), ...] pairs.
-      # Clears the stream's deferred state after consumption.
-      def collect_pending_tools(env)
-        if @stream&.pending_tools&.any?
-          @stream.pending_tools.dup.tap { @stream.clear_pending_tools! }
-        elsif env[:pending_functions]&.any?
-          env[:pending_functions].dup.tap { env[:pending_functions] = [] }.map { |fn| [fn, nil] }
-        else
-          []
-        end
-      end
-
-      def result_value(result)
-        result.respond_to?(:value) ? result.value : result
-      end
-    end
-
-    # Provider-specific subclasses. Override supported_messages
-    # or loop behavior as needed.
-
-    class Anthropic < Base
-    end
-
-    class OpenAI < Base
-    end
-
-    class Google < Base
-    end
-  end
-  end
-end
-
-test do
-  require_relative "../../../spec/support/mock_provider"
-  require_relative "../../../spec/support/mock_response"
-
-  class RecordingPipeline
-    attr_reader :calls
-    def initialize(responses: [])
-      @responses = responses
-      @calls = []
-      @index = 0
-    end
-
-    def call(env)
-      @calls << env[:input]
-      resp = @responses[@index] || @responses.last
-      @index += 1
-      resp
-    end
-  end
-
-  FakeResponse = Struct.new(:content)
-
-  def make_agent(provider: MockProvider.new, tools: [])
-    Brute::Agent.new(provider: provider, model: nil, tools: tools)
-  end
-
-  # -- factory detection --
-
-  it "detects Base for unknown providers" do
-    Brute::Loop::AgentTurn.detect(MockProvider.new).should == Brute::Loop::AgentTurn::Base
-  end
-
-  it "detects Anthropic from provider class name" do
-    provider = MockProvider.new
-    def provider.class; Class.new { def self.name; "LLM::Anthropic"; end }; end
-    Brute::Loop::AgentTurn.detect(provider).should == Brute::Loop::AgentTurn::Anthropic
-  end
-
-  it "detects OpenAI from provider class name" do
-    provider = MockProvider.new
-    def provider.class; Class.new { def self.name; "LLM::OpenAI"; end }; end
-    Brute::Loop::AgentTurn.detect(provider).should == Brute::Loop::AgentTurn::OpenAI
-  end
-
-  it "detects Google from provider class name" do
-    provider = MockProvider.new
-    def provider.class; Class.new { def self.name; "LLM::Google"; end }; end
-    Brute::Loop::AgentTurn.detect(provider).should == Brute::Loop::AgentTurn::Google
-  end
-
-  # -- AgentTurn.new returns the right subclass --
-
-  it "returns Base instance for unknown provider" do
-    step = Brute::Loop::AgentTurn.new(
-      agent: make_agent,
-      session: Brute::Store::Session.new,
-      pipeline: RecordingPipeline.new(responses: []),
-      input: "hi",
-    )
-    step.should.be.kind_of Brute::Loop::AgentTurn::Base
-  end
-
-  # -- basic turn execution --
-
-  it "calls the pipeline" do
-    Sync do
-      pipeline = RecordingPipeline.new(responses: [FakeResponse.new("hello")])
-      step = Brute::Loop::AgentTurn.new(
-        agent: make_agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-      pipeline.calls.size.should == 1
-    end
-  end
-
-  it "returns the LLM response as result" do
-    Sync do
-      pipeline = RecordingPipeline.new(responses: [FakeResponse.new("world")])
-      step = Brute::Loop::AgentTurn.new(
-        agent: make_agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-      step.result.content.should == "world"
-    end
-  end
-
-  it "transitions to completed" do
-    Sync do
-      pipeline = RecordingPipeline.new(responses: [FakeResponse.new("ok")])
-      step = Brute::Loop::AgentTurn.new(
-        agent: make_agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-      step.state.should == :completed
-    end
-  end
-
-  # -- AgentTurn.perform convenience --
-
-  it "perform returns a completed step" do
-    pipeline = RecordingPipeline.new(responses: [FakeResponse.new("done")])
-    step = Brute::Loop::AgentTurn.perform(
-      agent: make_agent,
-      session: Brute::Store::Session.new,
-      pipeline: pipeline,
-      input: "hi",
-    )
-    step.state.should == :completed
-  end
-
-  # -- cancellation --
-
-  it "is cancellable when pending" do
-    step = Brute::Loop::AgentTurn.new(
-      agent: Brute::Agent.new(provider: nil, model: nil, tools: []),
-      session: Brute::Store::Session.new,
-      pipeline: RecordingPipeline.new(responses: []),
-      input: "hi",
-    )
-    step.cancel
-    step.state.should == :cancelled
-  end
-
-  # -- system prompt from agent --
-
-  it "uses agent system_prompt" do
-    Sync do
-      agent = Brute::Agent.new(
-        provider: MockProvider.new,
-        model: nil,
-        tools: [],
-        system_prompt: "You are a test bot",
-      )
-      pipeline = RecordingPipeline.new(responses: [FakeResponse.new("ok")])
-      step = Brute::Loop::AgentTurn.new(
-        agent: agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-      step.state.should == :completed
-    end
-  end
-
-  # -- should_exit loop break --
-
-  # A mock function that satisfies ToolCallStep's interface.
-  LoopTestFunction = Struct.new(:id, :name, :arguments, keyword_init: true) do
-    def call; self; end
-    def value; "tool_result"; end
-  end
-
-  # Pipeline that injects pending_functions and optionally sets should_exit.
-  class ShouldExitPipeline
-    attr_reader :call_count
-
-    def initialize(exit_on_call: nil)
-      @exit_on_call = exit_on_call
-      @call_count = 0
-      @fn = LoopTestFunction.new(id: "call_1", name: "test_tool", arguments: "{}")
-    end
-
-    def call(env)
-      @call_count += 1
-
-      # Always give pending functions so the loop would continue.
-      env[:pending_functions] = [@fn]
-
-      if @exit_on_call && @call_count >= @exit_on_call
-        env[:should_exit] = {
-          reason:  "test_exit",
-          message: "forced exit for test",
-          source:  "ShouldExitPipeline",
-        }
-      end
-
-      FakeResponse.new("response #{@call_count}")
-    end
-  end
-
-  it "breaks the loop when should_exit is set on the initial call" do
-    Sync do
-      pipeline = ShouldExitPipeline.new(exit_on_call: 1)
-      step = Brute::Loop::AgentTurn.new(
-        agent: make_agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-
-      # Pipeline called once (initial call). The loop never entered
-      # because should_exit was set before the while guard.
-      pipeline.call_count.should == 1
-      step.state.should == :completed
-    end
-  end
-
-  it "breaks the loop mid-iteration when should_exit is set" do
-    Sync do
-      # exit_on_call: 2 means the first call returns tools (loop enters),
-      # the second call (inside the loop) sets should_exit.
-      pipeline = ShouldExitPipeline.new(exit_on_call: 2)
-      step = Brute::Loop::AgentTurn.new(
-        agent: make_agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-
-      # Two calls: initial + one loop iteration. The loop did not
-      # continue to a third call because should_exit was set.
-      pipeline.call_count.should == 2
-      step.state.should == :completed
-    end
-  end
-
-  it "loops normally when should_exit is not set" do
-    Sync do
-      call_count = 0
-      fn = LoopTestFunction.new(id: "call_1", name: "test_tool", arguments: "{}")
-
-      pipeline_obj = Object.new
-      pipeline_obj.define_singleton_method(:call_count) { call_count }
-      pipeline_obj.define_singleton_method(:call) do |env|
-        call_count += 1
-        if call_count <= 3
-          env[:pending_functions] = [fn]
-        else
-          env[:pending_functions] = []
-        end
-        FakeResponse.new("response #{call_count}")
-      end
-
-      step = Brute::Loop::AgentTurn.new(
-        agent: make_agent,
-        session: Brute::Store::Session.new,
-        pipeline: pipeline_obj,
-        input: "hi",
-      )
-      step.call(Async::Task.current)
-
-      # Call 1 (initial) → pending_functions has fn → loop enters
-      # Loop iter 1: execute tools, call pipeline (call 2) → still has fn → continues
-      # Loop iter 2: execute tools, call pipeline (call 3) → still has fn → continues
-      # Loop iter 3: execute tools, call pipeline (call 4) → empty → exits
-      call_count.should == 4
-      step.state.should == :completed
-    end
-  end
-end

data/lib/brute/loop/compactor.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module Brute
-  module Loop
-  # Context compaction service. When the conversation grows past configurable
-  # thresholds, older messages are summarized into a condensed form and the
-  # original messages are dropped, keeping the context window manageable.
-  #
-  # Modeled after forgecode's Compactor which uses an eviction window and
-  # retention window strategy.
-  class Compactor
-    DEFAULTS = {
-      token_threshold: 100_000,   # Compact when estimated tokens exceed this
-      message_threshold: 200,     # Compact when message count exceeds this
-      retention_window: 6,        # Minimum recent messages to always keep
-      summary_model: nil,         # Model for summarization (uses agent's model if nil)
-    }.freeze
-
-    attr_reader :config
-
-    def initialize(provider, **opts)
-      @provider = provider
-      @config = DEFAULTS.merge(opts)
-    end
-
-    # Check whether compaction should run based on current context state.
-    def should_compact?(messages, usage: nil)
-      return true if messages.size > @config[:message_threshold]
-      return true if usage && (usage.total_tokens || 0) > @config[:token_threshold]
-      false
-    end
-
-    # Compact the message history by summarizing older messages.
-    #
-    # Returns [summary_message, kept_messages] — the caller rebuilds
-    # the context from these.
-    def compact(messages)
-      total = messages.size
-      keep_count = [@config[:retention_window], total].min
-      return nil if total <= keep_count
-
-      old_messages = messages[0...(total - keep_count)]
-      recent_messages = messages[(total - keep_count)..]
-
-      summary_text = summarize(old_messages)
-
-      [summary_text, recent_messages]
-    end
-
-    private
-
-    def summarize(messages)
-      # Build a condensed representation of the conversation for the summarizer
-      conversation_text = messages.map { |m|
-        role = if m.respond_to?(:role)
-          m.role.to_s
-        else
-          "unknown"
-        end
-        content = if m.respond_to?(:content)
-          m.content.to_s[0..1000]
-        else
-          m.to_s[0..1000]
-        end
-
-        # Include tool call info for assistant messages
-        tool_info = ""
-        if m.respond_to?(:functions) && m.functions&.any?
-          calls = m.functions.map { |f| "#{f.name}(#{f.arguments.to_s[0..200]})" }
-          tool_info = " [tools: #{calls.join(", ")}]"
-        end
-
-        "#{role}:#{tool_info} #{content}"
-      }.join("\n---\n")
-
-      prompt = <<~PROMPT
-        Summarize this conversation history for context continuity. The summary will replace
-        these messages in the context window, so include everything the agent needs to continue
-        working effectively.
-
-        Structure your summary as:
-        ## Goal
-        What the user asked for.
-
-        ## Progress
-        - Files read, created, or modified (list paths)
-        - Commands executed and their outcomes
-        - Key decisions made
-
-        ## Current State
-        Where things stand right now — what's done and what remains.
-
-        ## Next Steps
-        What should happen next based on the conversation.
-
-        ---
-        CONVERSATION:
-        #{conversation_text}
-      PROMPT
-
-      model = @config[:summary_model] || "claude-sonnet-4-20250514"
-      res = @provider.complete(prompt, model: model)
-      res.content
-    end
-  end
-  end
-end

data/lib/brute/loop/doom_loop.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module Brute
-  module Loop
-  # Detects when the agent is stuck in a repeating pattern of tool calls.
-  #
-  # Two types of loops are detected:
-  #   1. Consecutive identical calls: [A, A, A] — same tool + same args
-  #   2. Repeating sequences: [A,B,C, A,B,C, A,B,C] — a pattern cycling
-  #
-  # When detected, a warning is injected into the context so the LLM
-  # can course-correct.
-  class DoomLoopDetector
-    DEFAULT_THRESHOLD = 3
-
-    attr_reader :threshold
-
-    def initialize(threshold: DEFAULT_THRESHOLD)
-      @threshold = threshold
-    end
-
-    # Extracts tool call signatures from the context's message buffer and
-    # checks for repeating patterns at the tail.
-    #
-    # Returns the repetition count if a loop is found, nil otherwise.
-    def detect(messages)
-      signatures = extract_signatures(messages)
-      return nil if signatures.size < @threshold
-
-      check_repeating_pattern(signatures)
-    end
-
-    # Build a human-readable warning message for the agent.
-    def warning_message(repetitions)
-      <<~MSG
-        SYSTEM NOTICE: Doom loop detected — the same tool call pattern has repeated #{repetitions} times.
-        You are stuck in a loop and not making progress. Stop and try a fundamentally different approach:
-        - Re-read the file to check your changes actually applied
-        - Try a different tool or strategy
-        - Break the problem into smaller steps
-        - If a command keeps failing, investigate why before retrying
-      MSG
-    end
-
-    private
-
-    # Extract [tool_name, arguments_json] pairs from assistant messages.
-    def extract_signatures(messages)
-      messages
-        .select { |m| m.respond_to?(:functions) && m.assistant? }
-        .flat_map { |m| m.functions.map { |f| [f.name.to_s, f.arguments.to_s] } }
-    end
-
-    # Check for repeating patterns of any length at the tail of the sequence.
-    # Returns the repetition count, or nil.
-    def check_repeating_pattern(sequence)
-      max_pattern_len = sequence.size / @threshold
-
-      (1..max_pattern_len).each do |pattern_len|
-        count = count_tail_repetitions(sequence, pattern_len)
-        return count if count >= @threshold
-      end
-
-      nil
-    end
-
-    # Count how many times a pattern of `length` repeats at the end of the sequence.
-    def count_tail_repetitions(sequence, length)
-      return 0 if sequence.size < length
-
-      pattern = sequence.last(length)
-      count = 1
-      pos = sequence.size - length
-
-      while pos >= length
-        candidate = sequence[(pos - length)...pos]
-        break unless candidate == pattern
-        count += 1
-        pos -= length
-      end
-
-      count
-    end
-  end
-  end
-end