brute 5.0.1 → 5.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e01ccfbca88337e90f041dc548bb2ced64a83bcffc1f76e302bd8fa4825b902
-  data.tar.gz: 6bd8054dacdf68ac5d3f773d53fd6a4093be59985350ba51cc78c10227fe38ef
+  metadata.gz: 8b1c034900a1b4cd0fca86749632d4bba871872a01a530e545fc5eeae62290ed
+  data.tar.gz: 157222f25f8afd4f3f44dcdd6589b4dd29a9f26349851360a4a6dadc158ab9fe
 SHA512:
-  metadata.gz: 4eae8566ab16b8f48ab62db551efe0878569727a4a5a5069e8a7c8de533858a84707538dd6015f4651f2ef276b9c17fc9b6ef615535e76301a425039fbf8deb0
-  data.tar.gz: fb6bf08902d2917ec98089403a64f1424216ac8f2d81374a426b372ff24e2a90e32adf4c52571d24cce166ddcbd2f1f13c34180c1fee01302f9cc69753c38c87
+  metadata.gz: 59a96300b0a9db1d5d9348e6155e8f2977da15fcaf3834aa357cc663ff37cff011ec2ac1e11e32eb4a2de65baf08159cff0d9ad95895936c3f22be80e5b90e50
+  data.tar.gz: 073a72fd94f1af3eaf590794634610f856b34b30bb76508fb5574e418d275020cdd4dc3f2bb0ae4524488fd1d794947ae6e95b117ac34f5a0c1ef8117f2ab2f7

data/lib/brute/completion/lang_chain.rb

@@ -35,8 +35,6 @@ module Brute
           raise LoadError, "#{self.class} needs the 'langchainrb' gem — add `gem \"langchainrb\"` to your Gemfile."
         end
 
-        Brute::Completion.async_faraday!
-
         @llm = llm || client or
           raise ArgumentError, "#{self.class} needs an llm: option, e.g. Langchain::LLM::OpenAI.new(api_key: ...)"
 
@@ -157,6 +155,23 @@ describe "brute/completion/lang_chain" do
     llm.calls.first[:temperature].should == 0.7
     llm.calls.first[:messages].first[:role].should == "user"
 
+    # env[:tools] — what the ToolPipeline put there — is advertised as-is.
+    tooled = FakeLangChainLLM.new(FakeLangChainResponse.new("ok", []))
+    tool = {
+      name:        "echo",
+      description: "Echo the input back",
+      params:      { msg: { type: "string", desc: "what to echo", required: true } },
+      execute:     ->(msg:) { msg },
+    }
+    tools_env = { messages: Brute.log, tools: [tool], events: [] }
+    tools_env[:messages].user("hi")
+    Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::LangChain.new(llm: tooled) }.call(tools_env)
+
+    advertised = tooled.calls.first[:tools]
+    advertised.first[:type].should == "function"
+    advertised.first[:function][:name].should == "echo"
+    advertised.first[:function][:parameters][:required].should == ["msg"]
+
     # A tool call comes back in the OpenAI shape and lands as a ToolCall.
     calling = FakeLangChainLLM.new(FakeLangChainResponse.new(nil, [
       { "id" => "tc1", "type" => "function", "function" => { "name" => "echo", "arguments" => { "text" => "hi" } } },

data/lib/brute/completion/llmrb.rb

@@ -168,6 +168,23 @@ describe "brute/completion/llmrb" do
     call[:params][:temperature].should == 0.1
     call[:params][:model].should == "env-model" # falls back to env
 
+    # env[:tools] — what the ToolPipeline put there — becomes llm.rb functions.
+    tooled = FakeLLMrbClient.new
+    tool = {
+      name:        "echo",
+      description: "Echo the input back",
+      params:      { msg: { type: "string", desc: "what to echo", required: true } },
+      execute:     ->(msg:) { msg },
+    }
+    tools_env = { messages: Brute.log, provider: :stub, model: "m", tools: [tool], events: [] }
+    tools_env[:messages].user("hi")
+    Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::LLMrb.new(client: tooled) }.call(tools_env)
+
+    functions = tooled.calls.first[:params][:tools]
+    functions.size.should == 1
+    functions.first.name.should == "echo"
+    functions.first.description.should == "Echo the input back"
+
     # Without a client, a provider is required to build one.
     no_provider = Brute::Turn::Pipeline.new
     no_provider.run Brute::Completion::LLMrb.new

data/lib/brute/completion/open_router.rb

@@ -15,6 +15,12 @@ module Brute
     class OpenRouter
       include Brute::Hooks
 
+      # Anything not given here falls back to the turn env, the way the other
+      # completions do it: tools from env[:tools] — the list the ToolPipeline
+      # middleware puts there and executes, so a pipeline declares its tools
+      # once — and the model from env[:model], which lets a middleware route a
+      # turn to a different one. Options given at point of use always win.
+      #
       # config:   keyword arguments for OpenRouter::Client.new
       #           (access_token:, request_timeout:, uri_base:, extra_headers:).
       #           Defaults to OpenRouter.configuration's global settings.
@@ -29,9 +35,10 @@ module Brute
           raise LoadError, "#{self.class} needs the 'open_router_enhanced' gem — add `gem \"open_router_enhanced\"` to your Gemfile."
         end
 
-        Brute::Completion.async_faraday!
-
         @config = config
+        # CompletionOptions defaults the model to "openrouter/auto", so what
+        # was actually asked for is remembered before that default hides it.
+        @model_given = options.key?(:model)
         @options = ::OpenRouter::CompletionOptions.new(**options)
       end
 
@@ -42,7 +49,7 @@ module Brute
 
         ::OpenRouter::Client.new(**@config).then do |client|
           response = nil
-          emit(LLM_DURATION_EVENT, env) { response = client.complete(messages, @options) }
+          emit(LLM_DURATION_EVENT, env) { response = client.complete(messages, options(env)) }
 
           response.then do |response|
 
@@ -84,6 +91,32 @@ module Brute
 
         env
       end
+
+      private
+
+        # Point-of-use options win; the rest fall back to the env.
+        def options(env)
+          overrides = {}
+
+          unless @options.tools?
+            tools = tool_definitions(env)
+            overrides[:tools] = tools if tools.any?
+          end
+
+          if !@model_given && (model = env[:model])
+            overrides[:model] = model
+          end
+
+          overrides.any? ? @options.merge(**overrides) : @options
+        end
+
+        # open_router_enhanced serializes an OpenRouter::Tool or a plain Hash;
+        # Adapter#to_h is already the function half of that shape.
+        def tool_definitions(env)
+          Brute::Tools::Adapter.wrap_all(env[:tools] || []).values.map do |adapter|
+            { type: "function", function: adapter.to_h }
+          end
+        end
     end
   end
 end
@@ -141,6 +174,84 @@ describe "brute/completion/open_router" do
     env.key?(:metadata).should.be.false
   end
 
+  it "advertises env[:tools] to the provider, and lets a tools: option win" do
+    captured = []
+    fake_client = Object.new
+    fake_client.define_singleton_method(:complete) { |_messages, options| captured << options; FakeUsageResponse.new(nil) }
+    original = OpenRouter::Client.method(:new)
+    OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
+
+    tool = {
+      name:        "echo",
+      description: "Echo the input back",
+      params:      { msg: { type: "string", desc: "what to echo", required: true } },
+      execute:     ->(msg:) { msg },
+    }
+
+    begin
+      # The ToolPipeline puts its tools in env[:tools]; the completion
+      # advertises them without being told twice.
+      env = { messages: Brute.log, tools: [tool] }
+      env[:messages].user("hi")
+      Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::OpenRouter.new }.call(env)
+
+      advertised = captured.last.tools
+      advertised.size.should == 1
+      advertised.first[:type].should == "function"
+      advertised.first[:function][:name].should == "echo"
+      advertised.first[:function][:parameters][:required].should == ["msg"]
+
+      # An empty (or absent) env[:tools] advertises nothing.
+      bare = { messages: Brute.log, tools: [] }
+      bare[:messages].user("hi")
+      Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::OpenRouter.new }.call(bare)
+      captured.last.tools?.should.be.false
+
+      # Tools given at point of use win over env[:tools].
+      explicit = { type: "function", function: { name: "explicit", description: "d", parameters: { type: "object" } } }
+      env2 = { messages: Brute.log, tools: [tool] }
+      env2[:messages].user("hi")
+      Brute::Turn::Pipeline.new.tap { |p|
+        p.run Brute::Completion::OpenRouter.new(tools: [explicit])
+      }.call(env2)
+      captured.last.tools.should == [explicit]
+    ensure
+      OpenRouter::Client.define_singleton_method(:new, original)
+    end
+  end
+
+  it "takes the model from env[:model], and lets a model: option win" do
+    captured = []
+    fake_client = Object.new
+    fake_client.define_singleton_method(:complete) { |_messages, options| captured << options; FakeUsageResponse.new(nil) }
+    original = OpenRouter::Client.method(:new)
+    OpenRouter::Client.define_singleton_method(:new) { |**_config| fake_client }
+
+    begin
+      # A middleware that routes a turn elsewhere sets env[:model].
+      env = { messages: Brute.log, model: "anthropic/claude-sonnet-4" }
+      env[:messages].user("hi")
+      Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::OpenRouter.new }.call(env)
+      captured.last.model.should == "anthropic/claude-sonnet-4"
+
+      # Given at point of use, it wins.
+      env2 = { messages: Brute.log, model: "from/env" }
+      env2[:messages].user("hi")
+      Brute::Turn::Pipeline.new.tap { |p|
+        p.run Brute::Completion::OpenRouter.new(model: "use/this")
+      }.call(env2)
+      captured.last.model.should == "use/this"
+
+      # With neither, the gem's own default stands.
+      bare = { messages: Brute.log }
+      bare[:messages].user("hi")
+      Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::OpenRouter.new }.call(bare)
+      captured.last.model.should == "openrouter/auto"
+    ensure
+      OpenRouter::Client.define_singleton_method(:new, original)
+    end
+  end
+
   it "reports a failed provider call through the hooks instead of raising" do
     seen = []
 

data/lib/brute/completion/ruby_llm.rb

@@ -27,6 +27,25 @@ module Brute
 
       DEFAULT_TEMPERATURE = 0.7
 
+      # A Brute tool adapter wearing the interface ruby_llm's providers read
+      # off a RubyLLM::Tool: name, description, and a params_schema (they fall
+      # back to #parameters only when that is nil), plus #provider_params to
+      # deep-merge into the declaration. Brute's own ToolPipeline runs the
+      # tool, so this mostly has to describe it — #call is here for a caller
+      # that hands the same list to ruby_llm's dispatch.
+      class Tool
+        def initialize(adapter)
+          @adapter = adapter
+        end
+
+        def name            = @adapter.name
+        def description     = @adapter.description
+        def params_schema   = @adapter.to_h[:parameters]
+        def parameters      = {}
+        def provider_params = {}
+        def call(args)      = @adapter.call(args)
+      end
+
       def initialize(**options)
         # Brute depends on no LLM library: the provider gem is required here,
         # at point of use, and only for this completion.
@@ -36,8 +55,6 @@ module Brute
           raise LoadError, "#{self.class} needs the 'ruby_llm' gem — add `gem \"ruby_llm\"` to your Gemfile."
         end
 
-        Brute::Completion.async_faraday!
-
         @options = options
       end
 
@@ -81,7 +98,7 @@ module Brute
         def complete(env, messages)
           kwargs = {
             model:       resolve_model(option(env, :model), option(env, :provider)),
-            tools:       tool_adapters(env).transform_values(&:to_ruby_llm),
+            tools:       ruby_llm_tools(env),
             temperature: temperature(env),
           }
 
@@ -127,6 +144,15 @@ module Brute
 
         def tool_adapters(env) = Brute::Tools::Adapter.wrap_all(option(env, :tools) || [])
 
+        # ruby_llm wants { name => tool }, which is the shape wrap_all already
+        # returns; only the values need presenting as ruby_llm tools. A tool
+        # written against ruby_llm goes through untouched.
+        def ruby_llm_tools(env)
+          tool_adapters(env).transform_values do |adapter|
+            adapter.original.is_a?(::RubyLLM::Tool) ? adapter.original : Tool.new(adapter)
+          end
+        end
+
         def streaming?(env) = options.fetch(:streaming) { env[:streaming] } == true
     end
   end
@@ -156,6 +182,31 @@ describe "brute/completion/ruby_llm" do
     Brute::Turn::Pipeline.new.tap { |pipeline| pipeline.run completion }
   end
 
+  it "advertises env[:tools] as ruby_llm tools" do
+    client = FakeRubyLLMClient.new
+    tool = {
+      name:        "echo",
+      description: "Echo the input back",
+      params:      { msg: { type: "string", desc: "what to echo", required: true } },
+      execute:     ->(msg:) { msg },
+    }
+
+    env = { messages: Brute.log, provider: :stub, model: "m", tools: [tool], events: [] }
+    env[:messages].user("hi")
+    Brute::Turn::Pipeline.new.tap { |p| p.run Brute::Completion::RubyLLM.new(client: client) }.call(env)
+
+    tools = client.calls.first[:kwargs][:tools]
+    tools.keys.should == [:echo]
+
+    advertised = tools[:echo]
+    advertised.name.should == "echo"
+    advertised.description.should == "Echo the input back"
+    advertised.params_schema[:properties][:msg][:type].should == "string"
+    advertised.params_schema[:required].should == ["msg"]
+    advertised.provider_params.should == {}
+    advertised.call(msg: "back").should == "back"
+  end
+
   it "completes a turn, prefers point-of-use options over env, and reports failure through the hooks" do
     client = FakeRubyLLMClient.new("hello there")
     env = { messages: Brute.log, provider: :stub, model: "env-model", tools: [], events: [] }

data/lib/brute/version.rb

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

data/lib/brute.rb

@@ -94,7 +94,6 @@ require_relative "brute/version"
 require_relative "brute/hooks"
 require_relative "brute/messages"
 require_relative "brute/middleware/000_base"
-require_relative "brute/completion/async_faraday"
 require_relative "brute/completion/open_router"
 require_relative "brute/completion/lang_chain"
 require_relative "brute/completion/llmrb"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brute
 version: !ruby/object:Gem::Version
-  version: 5.0.1
+  version: 5.0.3
 platform: ruby
 authors:
 - Brute Contributors
@@ -107,20 +107,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: async-http-faraday
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: json_schemer
   requirement: !ruby/object:Gem::Requirement
@@ -282,7 +268,6 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/brute.rb
-- lib/brute/completion/async_faraday.rb
 - lib/brute/completion/lang_chain.rb
 - lib/brute/completion/llmrb.rb
 - lib/brute/completion/open_router.rb

data/lib/brute/completion/async_faraday.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "brute"
-
-module Brute
-  module Completion
-    # Faraday's own default adapter is Net::HTTP, which works under Async but
-    # opens a fresh connection for every request. Provider gems build their
-    # own Faraday connections and give no seam to configure them, so the
-    # adapter is swapped at the only place it can be: Faraday's default.
-    #
-    # Called by each completion whose provider gem rides on Faraday, after
-    # that gem is required — so it only fires when Faraday is genuinely in
-    # play, and an app that uses a completion which doesn't (llm.rb speaks
-    # Net::HTTP directly) never loads any of it.
-    def self.async_faraday!
-      return false unless defined?(::Faraday)
-
-      require "async/http/faraday/default"
-      true
-    end
-  end
-end
-
-__END__
-
-describe "brute/completion/async_faraday" do
-  it "points Faraday's default adapter at async-http, and does nothing without Faraday" do
-    require "faraday"
-    Brute::Completion.async_faraday!.should.be.true
-    ::Faraday.default_adapter.should == :async_http
-
-    # Idempotent: a second completion constructing does not undo the first.
-    Brute::Completion.async_faraday!.should.be.true
-    ::Faraday.default_adapter.should == :async_http
-  end
-end