brute 3.1.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fe7f1994a944255146721ea3030261622735e33d412f07ba6fd118287b76517
-  data.tar.gz: 0b36c9d8c38afb152c16f0bc26c305145ed94f1c53e84316399d4f32b7f8752a
+  metadata.gz: 724fd8c44f58e700e455bf463899e0f3151303dab3a7eeda9b21c184f7aed9ce
+  data.tar.gz: 22f47575d1c60e617c1ce6cc7ddc554145d3685e64b59d3d9fc48661427515b2
 SHA512:
-  metadata.gz: 92f1aaba43df5f7fc0dad527c2b52a47e5336d4efabd95a6211cd9cdff97ae1a583d29ab94364d48b56760c5d7126fd3f9fe8f6e51b16518a250178daac30ee5
-  data.tar.gz: fce06871143bd87726637ece09887261b87aec3042470c0bb38ace70db42546541ef6a12f0310a3f72433a6ab65ade8f8c894a70a2f865ba21d752e94145f235
+  metadata.gz: b1a1b7588db4a3c3de695a8ce57047ef5875fb14b6fe6efb445f81a1f1cb98013af048a8e47ce39395be66e5b82ae8a08bcc491042afc1ba1ea3df0747b9d1de
+  data.tar.gz: 27494840079f7c6eb695dca807ff525854c2f28d9b6b3968f3308e670a217a6ee8e644b5981b1ee2a226d08399c0bac56f9dd6e64270d728620b5c6a270eecd4

data/lib/brute/message_transport/open_router.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "brute"
+require "brute/message_transport"
+
+module Brute
+  class MessageTransport
+    class OpenRouter < MessageTransport
+      def self.dump(message)
+        message.to_h
+      end
+
+      private
+
+        def wrap(message)
+          # Coerce string keys to symbol keys if necessary
+          hash = message.to_h.transform_keys(&:to_sym)
+        
+          case hash
+          in { role: (:system | :user | :assistant | :tool) }
+            # Message#initialize handles converting tool_calls & symbolising role!
+            Brute::Message.new(**hash)
+          else
+            raise "Unrecognised message format #{message.inspect}"
+          end
+        end
+    end
+  end
+end

data/lib/brute/message_transport/ruby_llm.rb

@@ -6,47 +6,44 @@ require "brute/message_transport"
 
 module Brute
   class MessageTransport
-    # MessageTransport for the ruby_llm gem (https://rubyllm.com).
-    # Brute does not require ruby_llm — you do:
-    #
-    #   require "ruby_llm"
-    #
-    #   response = provider.complete(
-    #     Brute::MessageTransport::RubyLLM.dump_all(env[:messages]),
-    #     tools: ..., model: model,
-    #   )
-    #   Brute::MessageTransport::RubyLLM.wrap_each(response) { |m| env[:messages] << m }
     class RubyLLM < MessageTransport
-      # Brute::Message -> RubyLLM::Message (tool calls as ruby_llm's
-      # id-keyed hash).
+
+      # Brute::Message -> RubyLLM::Message (tool calls as ruby_llm's id-keyed hash).
       def self.dump(message)
-        tool_calls = message.tool_calls&.each_with_object({}) do |tc, hash|
-          hash[tc.id] = ::RubyLLM::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments)
+        tool_calls = message.tool_calls&.to_h do |tc|
+          [tc.id, ::RubyLLM::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments)]
         end
 
         ::RubyLLM::Message.new(
           role:         message.role,
           content:      message.content,
           tool_calls:   tool_calls,
-          tool_call_id: message.tool_call_id,
+          tool_call_id: message.tool_call_id
         )
       end
 
       private
 
-        # RubyLLM::Message -> Brute::Message.
-        def wrap(message)
-          tool_calls = message.tool_calls&.values&.map do |tc|
-            Brute::ToolCall.new(id: tc.id, name: tc.name, arguments: tc.arguments)
-          end
+      # RubyLLM::Message -> Brute::Message.
+      def wrap(message)
+        raw_calls = message.tool_calls
+        calls_list = raw_calls.respond_to?(:values) ? raw_calls.values : raw_calls
 
-          Brute::Message.new(
-            role:         message.role,
-            content:      message.content.to_s,
-            tool_calls:   tool_calls,
-            tool_call_id: message.tool_call_id,
+        tool_calls = calls_list&.map do |tc|
+          Brute::ToolCall.new(
+            id:        tc.id,
+            name:      tc.name,
+            arguments: tc.arguments
           )
         end
+
+        Brute::Message.new(
+          role:         message.role,
+          content:      message.content&.to_s, # Preserves nil safely
+          tool_calls:   tool_calls,
+          tool_call_id: message.tool_call_id
+        )
+      end
     end
   end
 end

data/lib/brute/message_transport/ruby_open_ai.rb

@@ -0,0 +1,83 @@
+module Brute
+  class MessageTransport
+    class RubyOpenAI < MessageTransport
+
+      # Brute::Message -> ruby-openai Hash payload
+      def self.dump(message)
+        payload = {
+          role: message.role.to_s
+        }
+
+        # Include content if present
+        payload[:content] = message.content if message.content
+
+        # Include tool call ID for tool outputs
+        payload[:tool_call_id] = message.tool_call_id if message.tool_call_id
+
+        # Convert Brute::ToolCall objects to ruby-openai nested tool call hashes
+        if message.tool_call?
+          payload[:tool_calls] = message.tool_calls.map do |tc|
+            {
+              id: tc.id,
+              type: "function",
+              function: {
+                name: tc.name,
+                arguments: tc.arguments.is_a?(String) ? tc.arguments : tc.arguments.to_json
+              }
+            }
+          end
+        end
+
+        payload
+      end
+
+      private
+
+      # ruby-openai Hash (or API response choice message) -> Brute::Message
+      def wrap(message)
+        # Normalize keys to symbols for pattern matching
+        hash = message.to_h.transform_keys(&:to_sym)
+
+        case hash
+        # Branch 1: System, User, or Tool responses with text content
+        in { role: ("system" | "user" | "tool") => role }
+          Brute::Message.new(
+            role: role,
+            content: hash[:content],
+            tool_call_id: hash[:tool_call_id]
+          )
+
+        # Branch 2: Assistant tool calls request
+        in { role: "assistant", tool_calls: Array => raw_calls }
+          tool_calls = raw_calls.map do |tc|
+            # Handle both string and symbol keys within nested tool_call hashes
+            tc_hash = tc.to_h.transform_keys(&:to_sym)
+            fn_hash = (tc_hash[:function] || {}).transform_keys(&:to_sym)
+
+            Brute::ToolCall.new(
+              id: tc_hash[:id],
+              name: fn_hash[:name],
+              arguments: fn_hash[:arguments]
+            )
+          end
+
+          Brute::Message.new(
+            role: :assistant,
+            content: hash[:content],
+            tool_calls: tool_calls
+          )
+
+        # Branch 3: Standard Assistant text message
+        in { role: "assistant" }
+          Brute::Message.new(
+            role: :assistant,
+            content: hash[:content]
+          )
+
+        else
+          raise "Unrecognised message format for ruby-openai: #{message.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/brute/message_transport.rb

@@ -4,38 +4,14 @@ require "bundler/setup"
 require "brute"
 
 module Brute
-  # Transports messages between an LLM library's format and Brute's format
-  # (Brute::Message). This is the seam that keeps Brute framework-agnostic:
-  # calling an LLM is trivial with any library, so Brute has no "completion
-  # middleware" — the terminal `run` proc of an agent pipeline makes the LLM
-  # call itself, and a MessageTransport translates at the boundary.
-  #
-  # Inbound (library response -> Brute), the transport wraps whatever the
-  # proc got back and yields each message as a Brute::Message; the proc
-  # appends:
-  #
-  #   response = client.complete(...)
-  #   Brute::MessageTransport::RubyLLM.new(response).wrap_each do |message|
-  #     env[:messages] << message
-  #   end
-  #
-  # Outbound (Brute -> library), `dump_all` converts env[:messages] into the
-  # shape the library's completion call expects:
-  #
-  #   client.complete(Brute::MessageTransport::RubyLLM.dump_all(env[:messages]), ...)
-  #
-  # This base class is the identity transport: it flattens the result into a
-  # list of messages and yields them untouched. Library-specific subclasses
-  # (see message_transport/*.rb) override #wrap and .dump. They reference
-  # their library lazily, so requiring the library is your job — Brute
-  # depends on none of them.
   class MessageTransport
+
     # Convenience: Brute::MessageTransport.wrap_each(result) { |m| ... }
     def self.wrap_each(result, &block)
       new(result).wrap_each(&block)
     end
 
-    # Outbound: one Brute::Message in the library's format. Identity here.
+    #  Outbound: one Brute::Message in the library's format. Identity here.
     def self.dump(message)
       message
     end
@@ -49,22 +25,27 @@ module Brute
       @result = result
     end
 
-    # Yield each result message as a Brute::Message. Without a block, returns
-    # an Enumerator. The caller decides what to do with each (typically
-    # append to env[:messages]).
     def wrap_each
-      return enum_for(:wrap_each) unless block_given?
-
-      messages.each { |message| yield wrap(message) }
+      if block_given?
+        messages.each { |message| yield wrap(message) }
+      else
+        # https://docs.ruby-lang.org/en/4.0/Object.html#method-i-enum_for
+        enum_for(:wrap_each)
+      end
     end
 
     # The result normalized to a flat list of the library's messages. A
     # single message, an array, or anything transcript-shaped (responds to
     # #messages).
     def messages
-      case @result
-      when Array then @result.compact
-      else @result.respond_to?(:messages) ? @result.messages : [@result].compact
+      if @result.is_a?(Array)
+        @result.compact
+      else
+        if @result.respond_to?(:messages)
+          @result.messages
+        else
+          [@result].compact
+        end
       end
     end
 

data/lib/brute/messages.rb

@@ -24,21 +24,26 @@ module Brute
   #   Brute::Message.new(role: :tool, content: "result", tool_call_id: "tc1")
   Message = Data.define(:role, :content, :tool_calls, :tool_call_id) do
     def initialize(role:, content: nil, tool_calls: nil, tool_call_id: nil)
-      tool_calls = tool_calls&.map do |tc|
+      formatted_calls = tool_calls&.map do |tc|
         tc.is_a?(ToolCall) ? tc : ToolCall.new(**tc.to_h.transform_keys(&:to_sym))
       end
-      super(role: role.to_sym, content: content, tool_calls: tool_calls, tool_call_id: tool_call_id)
+  
+      super(
+        role: role.to_sym,
+        content: content,
+        tool_calls: formatted_calls,
+        tool_call_id: tool_call_id
+      )
     end
-
-    def tool_call?
-      !tool_calls.nil? && !tool_calls.empty?
-    end
-
-    # Plain, JSON-ready view (nils dropped, tool calls as hashes).
-    def to_h
-      h = super
-      h[:tool_calls] = tool_calls.map(&:to_h) if tool_calls
-      h.compact
+  
+    def tool_call? = !tool_calls.nil? && !tool_calls.empty?
+    alias_method :has_tool_calls?, :tool_call?
+  
+    # Clean, JSON-ready hash export dropping nil values
+    def to_h(...)
+      hash = super
+      hash[:tool_calls] = tool_calls.map(&:to_h) if tool_calls
+      hash.compact
     end
   end
 

data/lib/brute/middleware/006_loop.rb

@@ -25,6 +25,7 @@ module Brute
       def initialize(app, condition = nil, &block)
         @app       = app
         @condition = condition || block
+
         unless @condition.respond_to?(:call)
           raise ArgumentError, "Brute::Middleware::Loop requires a proc or block condition"
         end
@@ -33,8 +34,12 @@ module Brute
       def call(env)
         loop do
           @app.call(env)
-          break unless @condition.call(env)
+
+          unless @condition.call(env)
+            break
+          end
         end
+
         env
       end
 
@@ -49,10 +54,16 @@ module Brute
       #
       class ToolResult < Loop
         CONDITION = lambda do |env|
-          next false if env[:should_exit]
-          next false unless env[:messages].last&.role == :tool
+          if env[:should_exit]
+            next false
+          end
+
+          unless env[:messages].last&.role == :tool
+            next false
+          end
 
           env[:current_iteration] += 1
+
           true
         end
 

data/lib/brute/middleware/070_tool_pipeline.rb

@@ -8,94 +8,63 @@ require "async/barrier"
 
 module Brute
   module Middleware
-    # Executes pending tool calls from the LLM response.
-    #
-    # Existing features (ref: opencode tool.ts wrap / truncate.ts):
-    #
-    # 1. Universal output truncation — after every tool.call(), pass the
-    #    result string through Brute::Truncation.truncate() which enforces
-    #    a 2000-line / 50 KB cap. This is a safety net so no single tool
-    #    result can blow up the context window, regardless of whether the
-    #    tool itself has internal limits.
-    # 2. Overflow to disk — when truncating, the full output is saved to
-    #    a temp file under the truncation directory. The path is included
-    #    in the truncated result with a hint.
-    # 3. Configurable limits — MAX_LINES / MAX_BYTES default to 2000 / 50 KB.
-    # 4. Skip truncation when tool already truncated — if the tool result
-    #    already contains the truncation marker (e.g. Shell or FSSearch
-    #    truncated internally), don't double-truncate.
-    #
-    # == Concurrency model (Async)
-    #
-    # Tool calls are executed concurrently using the `async` gem's fiber-based
-    # scheduler. Each tool call is dispatched as an Async::Task inside an
-    # Async::Barrier, so all tools run in parallel and we wait for every task
-    # to complete before moving on.
-    #
-    # Key design decisions:
-    #
-    # - Sync {} (not Async{}.wait) — reuses an existing event loop if one is
-    #   already running, or creates one on demand. Blocks the caller until all
-    #   inner work completes, which is what the middleware stack requires.
-    #
-    # - Async::Barrier — the idiomatic fan-out / join primitive. Each tool call
-    #   becomes a child task via barrier.async; barrier.wait blocks until every
-    #   task finishes. This is preferable to Async::Queue for a fixed batch of
-    #   work with no producer/consumer relationship.
-    #
-    # - Deterministic result ordering — tool results are collected into an array
-    #   during concurrent execution, then sorted back into the original
-    #   tools_to_run key order before appending to env[:messages]. This ensures
-    #   the LLM always sees results in a stable order regardless of which tool
-    #   finishes first.
-    #
-    # - Fiber-safe shared state — appending to the results array from multiple
-    #   fibers is safe because Async fibers are cooperatively scheduled (only
-    #   one fiber runs at a time within a Sync block). No mutex needed.
-    #
-    # - FileMutationQueue compatibility — tools that mutate files use
-    #   Brute::Tools::FS::FileMutationQueue.serialize, which uses Ruby 3.4's
-    #   fiber-scheduler-aware Mutex. Operations on the same file are serialized;
-    #   operations on different files proceed in parallel.
-    #
     class ToolPipeline
       def initialize(app, tools: [])
         @app   = app
         @tools = tools
       end
 
-      # in  -> advertise the tools to the turn (env[:tools], which the LLM-call
-      #        proc reads to tell the model what it can call)
-      # out <- execute the tool calls the model made and append :tool results
       def call(env)
         env[:tools] = @tools
         @app.call(env)
 
-        tools_to_run = pending_tool_calls(env[:messages].last)
-        if tools_to_run.any?
-          available_tools = resolve_tools(env[:tools])
+        response = env[:messages].last
+
+        if response.respond_to?(:tool_calls) && response.tool_calls.present?
+          tools_to_run = response.tool_calls
+
+          # tool_to_run may be an Array (Brute::ToolCall) or an id-keyed Hash (some libraries' native shape)
+          if tools_to_run.respond_to?(:values)
+            tools_to_run = tools_to_run.values
+          end
+
+          # No idea why we use Array() here... probably in case it's a hash or something...
+          # because reject would work on the hash...
+          tools_to_run = Array(tools_to_run).reject { |tc| tc.name == "question" }
+
+          available_tools = Brute::Tools::Adapter.wrap_all(env[:tools])
           env[:events] << on_tool_call_start_event(tools_to_run)
 
           results = []
 
+          # Async::Barrier blocks until all tasks are complete.
+          # Tasks run in parrallel.
+          #
           Sync do
             barrier = Async::Barrier.new
 
             tools_to_run.each do |tool_call|
-              barrier.async do
-                tool = available_tools[tool_call.name.to_sym]
-                result = tool.call(tool_call.arguments)
-
-                # Coerce to String so Hash results (e.g. Shell's
-                # {stdout:, stderr:, exit_code:}) serialize predictably.
-                content = result.is_a?(String) ? result : result.to_s
-
-                # Universal truncation safety net — skip if already truncated
-                unless Brute::Truncation.already_truncated?(content)
-                  content = Brute::Truncation.truncate(content)
+              barrier.async do 
+                name = tool_call.name.to_sym
+                args = tool_call.arguments
+
+                available_tools[name].call(args).then do |result|
+
+                  # Coerce to String so Hash results (e.g. Shell's
+                  # {stdout:, stderr:, exit_code:}) serialize predictably.
+                  if result.is_a?(String)
+                    content = result
+                  else
+                    content = result.to_s
+                  end
+
+                  # Universal truncation safety net — skip if already truncated
+                  unless Brute::Truncation.already_truncated?(content)
+                    content = Brute::Truncation.truncate(content)
+                  end
+
+                  results << [tool_call, content]
                 end
-
-                results << [tool_call, content]
               rescue => e
                 # Capture the error as a tool result so the LLM can see it
                 # and reason about the failure, rather than crashing the
@@ -120,25 +89,11 @@ module Brute
           end
         end
 
-        return env
+        env
       end
 
       private
 
-        # The last message's pending tool calls as a flat list. Duck-typed:
-        # tool_calls may be an Array (Brute::ToolCall) or an id-keyed Hash
-        # (some libraries' native shape); each entry needs #id, #name and
-        # #arguments.
-        def pending_tool_calls(message)
-          calls = message.respond_to?(:tool_calls) ? message.tool_calls : nil
-          calls = calls.values if calls.respond_to?(:values)
-          Array(calls).reject { |tc| tc.name == "question" }
-        end
-
-        def resolve_tools(tools)
-          Brute::Tools::Adapter.wrap_all(tools)
-        end
-
         def on_tool_call_start_event(pending_tools)
           {
             type: :tool_call_start,

data/lib/brute/middleware/open_router.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Brute
+  module Middleware
+    module OpenRouter
+      class Completion
+        def initialize(app, config: {}, **options)
+          @app = app
+          @config = OpenRouter::Configuration.new(config)
+          @options = OpenRouter::CompletionOptions.new(options)
+        end
+
+        def call(env)
+          messages = Brute::MessageTransport::OpenRouter.dump_all(env[:messages])
+
+          OpenRouter::Client.new(@config).then do |client|
+            client.complete(messages, @options).then do |response|
+
+              # OpenRouter in fact only returns a single message...
+              # https://github.com/estiens/open_router_enhanced/blob/main/lib/open_router/response.rb#L66
+              Brute::MessageTransport::OpenRouter.wrap_each(response) do |message|
+                env[:messages] << message
+              end
+            end
+          end
+
+          env
+        end
+      end
+    end
+  end
+end

data/lib/brute/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Brute Contributors
@@ -176,8 +176,10 @@ files:
 - lib/brute/message_transport.rb
 - lib/brute/message_transport/anthropic.rb
 - lib/brute/message_transport/llm.rb
+- lib/brute/message_transport/open_router.rb
 - lib/brute/message_transport/openai.rb
 - lib/brute/message_transport/ruby_llm.rb
+- lib/brute/message_transport/ruby_open_ai.rb
 - lib/brute/messages.rb
 - lib/brute/middleware/001_otel_span.rb
 - lib/brute/middleware/002_session_log.rb
@@ -194,6 +196,7 @@ files:
 - lib/brute/middleware/073_otel_tool_call.rb
 - lib/brute/middleware/075_otel_tool_results.rb
 - lib/brute/middleware/event_handler.rb
+- lib/brute/middleware/open_router.rb
 - lib/brute/middleware/user_queue.rb
 - lib/brute/prompts.rb
 - lib/brute/prompts/autonomy.rb