brute 0.1.7 → 0.1.9

data/lib/brute/middleware/otel/tool_calls.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Brute
+  module Middleware
+    module OTel
+      # Records tool calls the LLM requested as span events.
+      #
+      # Runs POST-call: after the LLM responds, inspects ctx.functions
+      # for any tool calls the model wants to make, and adds a span event
+      # for each one with the tool name, call ID, and arguments.
+      #
+      class ToolCalls < Base
+        def call(env)
+          response = @app.call(env)
+
+          span = env[:span]
+          if span
+            functions = env[:context].functions
+            if functions && !functions.empty?
+              span.set_attribute("brute.tool_calls.count", functions.size)
+
+              functions.each do |fn|
+                attrs = {
+                  "tool.name" => fn.name.to_s,
+                  "tool.id" => fn.id.to_s,
+                }
+                args = fn.arguments
+                attrs["tool.arguments"] = args.to_json if args
+                span.add_event("tool_call", attributes: attrs)
+              end
+            end
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/brute/middleware/otel/tool_results.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Brute
+  module Middleware
+    module OTel
+      # Records tool results being sent back to the LLM as span events.
+      #
+      # Runs PRE-call: when env[:tool_results] is present, the orchestrator
+      # is sending tool execution results back to the LLM. Each result gets
+      # a span event with the tool name and success/error status.
+      #
+      class ToolResults < Base
+        def call(env)
+          span = env[:span]
+
+          if span && (results = env[:tool_results])
+            span.set_attribute("brute.tool_results.count", results.size)
+
+            results.each do |name, value|
+              error = value.is_a?(Hash) && value[:error]
+              attrs = { "tool.name" => name.to_s }
+              if error
+                attrs["tool.status"] = "error"
+                attrs["tool.error"] = value[:error].to_s
+              else
+                attrs["tool.status"] = "ok"
+              end
+              span.add_event("tool_result", attributes: attrs)
+            end
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/brute/middleware/otel.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Brute
+  module Middleware
+    # OpenTelemetry instrumentation for the LLM pipeline.
+    #
+    # Each middleware is independent and communicates through env[:span].
+    # OTel::Span must be outermost — it creates the span. The rest
+    # decorate it with events and attributes from their position in the
+    # pipeline.
+    #
+    # All middlewares are no-ops when opentelemetry-sdk is not loaded.
+    #
+    # Usage in pipeline:
+    #
+    #   use Brute::Middleware::OTel::Span
+    #   use Brute::Middleware::OTel::ToolResults
+    #   use Brute::Middleware::OTel::ToolCalls
+    #   use Brute::Middleware::OTel::TokenUsage
+    #
+    module OTel
+    end
+  end
+end
+
+require_relative "otel/span"
+require_relative "otel/tool_results"
+require_relative "otel/tool_calls"
+require_relative "otel/token_usage"

data/lib/brute/middleware/tool_use_guard.rb

@@ -11,8 +11,16 @@ module Brute
     # blocks is lost. This causes "unexpected tool_use_id" on the next call
     # because tool_result references a tool_use that's missing from the buffer.
     #
-    # This middleware runs post-call and injects a synthetic assistant message
-    # when tool calls exist but no assistant message was recorded.
+    # This middleware runs post-call and ensures every pending tool_use ID
+    # is covered by an assistant message in the buffer. It handles three
+    # cases:
+    #
+    #   1. ctx.functions is non-empty and the assistant message exists → no-op
+    #   2. ctx.functions is non-empty but the assistant message is missing
+    #      (or has different IDs) → inject synthetic message
+    #   3. ctx.functions is empty (nil-choice bug) but the stream recorded
+    #      tool calls → inject synthetic message using stream metadata
+    #
     class ToolUseGuard
       def initialize(app)
         @app = app
@@ -22,32 +30,67 @@ module Brute
         response = @app.call(env)
 
         ctx = env[:context]
-        functions = ctx.functions
 
-        # If there are pending tool calls, ensure the buffer has an assistant
-        # message with tool_use blocks.
+        # Collect pending tool data from ctx.functions (primary) or the
+        # stream's recorded metadata (fallback for nil-choice bug).
+        tool_data = collect_tool_data(ctx, env)
+        return response if tool_data.empty?
+
+        # Find all tool_use IDs already covered by assistant messages.
+        covered_ids = covered_tool_ids(ctx)
+
+        # Inject a synthetic assistant message for any uncovered tool calls.
+        uncovered = tool_data.reject { |td| covered_ids.include?(td[:id]) }
+        inject_synthetic!(ctx, uncovered) unless uncovered.empty?
+
+        response
+      end
+
+      private
+
+      def collect_tool_data(ctx, env)
+        functions = ctx.functions
         if functions && !functions.empty?
-          messages = ctx.messages.to_a
-          last_assistant = messages.reverse.find { |m| m.role.to_s == "assistant" }
-
-          unless last_assistant&.tool_call?
-            # Build a synthetic assistant message with the tool_use data
-            tool_calls = functions.map do |fn|
-              LLM::Object.from(id: fn.id, name: fn.name, arguments: fn.arguments)
-            end
-            original_tool_calls = functions.map do |fn|
-              { "type" => "tool_use", "id" => fn.id, "name" => fn.name, "input" => fn.arguments || {} }
-            end
-
-            synthetic = LLM::Message.new(:assistant, "", {
-              tool_calls: tool_calls,
-              original_tool_calls: original_tool_calls,
-            })
-            ctx.messages.concat([synthetic])
+          functions.map { |fn| { id: fn.id, name: fn.name, arguments: fn.arguments } }
+        elsif env[:streaming]
+          stream = resolve_stream(ctx)
+          if stream
+            data = stream.pending_tool_calls.dup
+            stream.clear_pending_tool_calls!
+            data
+          else
+            []
           end
+        else
+          []
         end
+      end
 
-        response
+      def resolve_stream(ctx)
+        stream = ctx.instance_variable_get(:@params)&.dig(:stream)
+        stream if stream.respond_to?(:pending_tool_calls)
+      end
+
+      def covered_tool_ids(ctx)
+        ctx.messages.to_a
+          .select { |m| m.role.to_s == "assistant" && m.tool_call? }
+          .flat_map { |m| (m.extra.original_tool_calls || []).map { |tc| tc["id"] } }
+          .to_set
+      end
+
+      def inject_synthetic!(ctx, uncovered)
+        tool_calls = uncovered.map do |td|
+          LLM::Object.from(id: td[:id], name: td[:name], arguments: td[:arguments])
+        end
+        original_tool_calls = uncovered.map do |td|
+          { "type" => "tool_use", "id" => td[:id], "name" => td[:name], "input" => td[:arguments] || {} }
+        end
+
+        synthetic = LLM::Message.new(:assistant, "", {
+          tool_calls: tool_calls,
+          original_tool_calls: original_tool_calls,
+        })
+        ctx.messages.concat([synthetic])
       end
     end
   end

data/lib/brute/orchestrator.rb

@@ -20,31 +20,42 @@ module Brute
   class Orchestrator
     MAX_REQUESTS_PER_TURN = 100
 
-    attr_reader :context, :session, :pipeline, :env, :barrier
+    attr_reader :context, :session, :pipeline, :env, :barrier, :message_store
 
     def initialize(
       provider:,
+      model: nil,
       tools: Brute::TOOLS,
       cwd: Dir.pwd,
       session: nil,
       compactor_opts: {},
       reasoning: {},
+      agent_name: nil,
       on_content: nil,
       on_reasoning: nil,
       on_tool_call: nil,
       on_tool_result: nil,
+      on_question: nil,
       logger: nil
     )
       @provider = provider
+      @model = model
+      @agent_name = agent_name
       @tool_classes = tools
       @cwd = cwd
       @session = session || Session.new
       @logger = logger || Logger.new($stderr, level: Logger::INFO)
-
-      # Build system prompt
-      custom_rules = load_custom_rules
-      prompt_builder = SystemPrompt.new(cwd: @cwd, tools: @tool_classes, custom_rules: custom_rules)
-      @system_prompt = prompt_builder.build
+      @message_store = @session.message_store
+
+      # Build system prompt via deferred builder
+      @system_prompt_builder = SystemPrompt.default
+      @system_prompt = @system_prompt_builder.prepare(
+        provider_name: @provider&.name,
+        model_name: @model || @provider&.default_model,
+        cwd: @cwd,
+        custom_rules: load_custom_rules,
+        agent: @agent_name,
+      ).to_s
 
       # Initialize the LLM context (with streaming when callbacks provided)
       @stream = if on_content || on_reasoning
@@ -53,10 +64,13 @@ module Brute
           on_reasoning: on_reasoning,
           on_tool_call: on_tool_call,
           on_tool_result: on_tool_result,
+          on_question: on_question,
         )
       end
-      @context = LLM::Context.new(@provider, tools: @tool_classes,
-        **(@stream ? {stream: @stream} : {}))
+      ctx_opts = { tools: @tool_classes }
+      ctx_opts[:model]  = @model  if @model
+      ctx_opts[:stream] = @stream if @stream
+      @context = LLM::Context.new(@provider, **ctx_opts)
 
       # Build the middleware pipeline
       compactor = Compactor.new(provider, **compactor_opts)
@@ -65,6 +79,7 @@ module Brute
         session: @session,
         logger: @logger,
         reasoning: reasoning,
+        message_store: @message_store,
       )
 
       # The shared env hash — passed to every pipeline.call()
@@ -82,6 +97,7 @@ module Brute
           on_reasoning: on_reasoning,
           on_tool_call: on_tool_call,
           on_tool_result: on_tool_result,
+          on_question: on_question,
         },
       }
     end
@@ -115,7 +131,7 @@ module Brute
 
       # --- Agent loop ---
       loop do
-        break if @context.functions.empty?
+        break if @context.functions.empty? && (!@stream || @stream.queue.empty?)
 
         # Collect tool results.
         # Streaming: tools already spawned threads during the LLM response — just join them.
@@ -135,7 +151,7 @@ module Brute
         @request_count += 1
 
         # Check limits
-        break if @context.functions.empty?
+        break if @context.functions.empty? && (!@stream || @stream.queue.empty?)
         break if @request_count >= MAX_REQUESTS_PER_TURN
         break if @env[:metadata][:tool_error_limit_reached]
       end
@@ -149,28 +165,42 @@ module Brute
     # Pipeline construction
     # ------------------------------------------------------------------
 
-    def build_pipeline(compactor:, session:, logger:, reasoning:)
+    def build_pipeline(compactor:, session:, logger:, reasoning:, message_store:)
       sys_prompt = @system_prompt
       tools = @tool_classes
+      stream = @stream
 
       Pipeline.new do
-        # Outermost: timing and logging (sees total elapsed including retries)
+        # OTel span lifecycle (outermost — creates env[:span])
+        use Middleware::OTel::Span
+
+        # Timing and logging
         use Middleware::Tracing, logger: logger
 
+        # OTel: record tool results being sent back (pre-call)
+        use Middleware::OTel::ToolResults
+
         # Retry transient errors (wraps everything below)
         use Middleware::Retry
 
         # Save after each successful LLM call
         use Middleware::SessionPersistence, session: session
 
+        # Record structured messages in OpenCode {info, parts} format
+        use Middleware::MessageTracking, store: message_store
+
         # Track cumulative token usage
         use Middleware::TokenTracking
 
+        # OTel: record token usage from response (post-call)
+        use Middleware::OTel::TokenUsage
+
         # Check context size and compact if needed
         use Middleware::CompactionCheck,
           compactor: compactor,
           system_prompt: sys_prompt,
-          tools: tools
+          tools: tools,
+          stream: stream
 
         # Track per-tool errors
         use Middleware::ToolErrorTracking
@@ -184,6 +214,9 @@ module Brute
         # Guard against tool-only responses dropping the assistant message
         use Middleware::ToolUseGuard
 
+        # OTel: record tool calls the LLM requested (post-call, after ToolUseGuard)
+        use Middleware::OTel::ToolCalls
+
         # Innermost: the actual LLM call
         run Middleware::LLMCall.new
       end

data/lib/brute/prompts/autonomy.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module Autonomy
+      TEXT = <<~TXT
+        # Autonomy and persistence
+
+        Unless the user explicitly asks for a plan, asks a question about the code, is brainstorming potential solutions, or some other intent that makes it clear that code should not be written, assume the user wants you to make code changes or run tools to solve the user's problem. If you encounter challenges or blockers, you should attempt to resolve them yourself.
+
+        Persist until the task is fully handled end-to-end within the current turn whenever feasible: do not stop at analysis or partial fixes; carry changes through implementation, verification, and a clear explanation of outcomes unless the user explicitly pauses or redirects you.
+
+        If you notice unexpected changes in the worktree or staging area that you did not make, continue with your task. NEVER revert, undo, or modify changes you did not make unless the user explicitly asks you to. There can be multiple agents or the user working in the same codebase concurrently.
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    TEXT_DIR = File.expand_path("text", __dir__)
+
+    # Resolve a provider-specific text file.
+    # Looks for +section/provider_name.txt+, falls back to +section/default.txt+.
+    def self.read(section, provider_name)
+      provider = provider_name.to_s
+      path = File.join(TEXT_DIR, section, "#{provider}.txt")
+      path = File.join(TEXT_DIR, section, "default.txt") unless File.exist?(path)
+      return nil unless File.exist?(path)
+      File.read(path)
+    end
+
+    # Read a named agent prompt (e.g. "explore", "compaction").
+    def self.agent_prompt(name)
+      path = File.join(TEXT_DIR, "agents", "#{name}.txt")
+      File.exist?(path) ? File.read(path) : nil
+    end
+  end
+end

data/lib/brute/prompts/build_switch.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module BuildSwitch
+      TEXT = <<~TXT
+        <system-reminder>
+        Your operational mode has changed from plan to build.
+        You are no longer in read-only mode.
+        You are permitted to make file changes, run shell commands, and utilize your arsenal of tools as needed.
+        </system-reminder>
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/code_references.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module CodeReferences
+      TEXT = <<~'TXT'
+        # Code References
+        When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
+
+        <example>
+        user: Where are errors from the client handled?
+        assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.
+        </example>
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/code_style.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module CodeStyle
+      TEXT = <<~TXT
+        # Code style
+        - IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/conventions.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module Conventions
+      TEXT = <<~TXT
+        # Following conventions
+        When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+        - NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library.
+        - When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
+        - When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
+        - Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/doing_tasks.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module DoingTasks
+      def self.call(ctx)
+        Prompts.read("doing_tasks", ctx[:provider_name])
+      end
+    end
+  end
+end

data/lib/brute/prompts/editing_approach.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module EditingApproach
+      TEXT = <<~TXT
+        # Editing Approach
+
+        - The best changes are often the smallest correct changes.
+        - When you are weighing two correct approaches, prefer the more minimal one (less new names, helpers, tests, etc).
+        - Keep things in one function unless composable or reusable.
+        - Do not add backward-compatibility code unless there is a concrete need, such as persisted data, shipped behavior, external consumers, or an explicit user requirement; if unclear, ask one short question instead of guessing.
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/editing_constraints.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module EditingConstraints
+      TEXT = <<~TXT
+        # Editing constraints
+
+        - Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+        - Add succinct code comments that explain what is going on if code is not self-explanatory. Usage of these comments should be rare.
+        - Always use the patch tool for manual code edits. Do not use shell commands when creating or editing files.
+        - NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+        - You may be in a dirty git worktree.
+          * If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
+          * If the changes are in files you've touched recently, read carefully and understand how you can work with the changes rather than reverting them.
+          * If the changes are in unrelated files, just ignore them and don't revert them.
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/environment.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module Environment
+      def self.call(ctx)
+        cwd = ctx[:cwd] || Dir.pwd
+        model = ctx[:model_name].to_s
+        git = File.exist?(File.join(cwd, ".git"))
+
+        parts = []
+        parts << "You are powered by the model named #{model}." unless model.empty?
+        parts << ""
+        parts << "Here is some useful information about the environment you are running in:"
+        parts << "<env>"
+        parts << "  Working directory: #{cwd}"
+        parts << "  Is directory a git repo: #{git ? "yes" : "no"}"
+        parts << "  Platform: #{RUBY_PLATFORM}"
+        parts << "  Today's date: #{Time.now.strftime("%a %b %d %Y")}"
+        parts << "</env>"
+        parts.join("\n")
+      end
+    end
+  end
+end

data/lib/brute/prompts/frontend_tasks.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module FrontendTasks
+      TEXT = <<~TXT
+        # Frontend tasks
+
+        When doing frontend design tasks, avoid collapsing into bland, generic layouts.
+        - Ensure the page loads properly on both desktop and mobile.
+        - Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
+
+        Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/git_safety.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module GitSafety
+      TEXT = <<~TXT
+        # Git safety
+        - NEVER commit changes unless the user explicitly asks you to.
+        - NEVER use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested.
+        - Do not amend commits unless explicitly requested.
+        - Prefer non-interactive git commands. Avoid `git rebase -i` or `git add -i`.
+      TXT
+
+      def self.call(_ctx)
+        TEXT
+      end
+    end
+  end
+end

data/lib/brute/prompts/identity.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module Identity
+      def self.call(ctx)
+        Prompts.read("identity", ctx[:provider_name])
+      end
+    end
+  end
+end

data/lib/brute/prompts/instructions.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Brute
+  module Prompts
+    module Instructions
+      def self.call(ctx)
+        rules = ctx[:custom_rules]
+        return nil if rules.nil? || rules.strip.empty?
+
+        <<~TXT
+          # Project-Specific Rules
+
+          #{rules}
+        TXT
+      end
+    end
+  end
+end