brute 1.0.0 → 2.0.0

data/lib/brute/patches/anthropic_tool_role.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-# Monkey-patch: Fix Anthropic tool result message role.
-#
-# llm.rb stores tool results as messages with role="tool" (via @llm.tool_role).
-# Anthropic's API requires tool result messages to have role="user" with
-# tool_result content blocks. The Completion adapter already correctly formats
-# the content (Function::Return -> {type: "tool_result", ...}), but passes
-# through the "tool" role unchanged — which Anthropic rejects.
-#
-# This patch overrides adapt_message to set role="user" when the message
-# content contains tool returns.
-
-module Brute
-  module Patches
-    module AnthropicToolRole
-      private
-
-      def adapt_message
-        if message.respond_to?(:role) && message.role.to_s == "tool"
-          {role: "user", content: adapt_content(content)}
-        else
-          super
-        end
-      end
-
-      # Apply the patch lazily — LLM::Anthropic is autoloaded.
-      def self.apply!
-        return if @applied
-        @applied = true
-        LLM::Anthropic::RequestAdapter::Completion.prepend(self)
-      end
-    end
-  end
-end

data/lib/brute/patches/buffer_nil_guard.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
-
-# Monkey-patch: Guard LLM::Buffer against nil entries.
-#
-# llm.rb's Context#talk can sometimes concatenate nil into the message
-# buffer (e.g. when response parsing yields a nil choice). This causes
-# NoMethodError when the buffer is iterated (assistant?, tool_return?, etc).
-#
-# This patch overrides concat to filter out nils before they enter the buffer.
-
-module Brute
-  module Patches
-    module BufferNilGuard
-      def concat(messages)
-        super(Array(messages).compact)
-      end
-    end
-  end
-end
-
-LLM::Buffer.prepend(Brute::Patches::BufferNilGuard)

data/lib/brute/providers/models_dev.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "json"
-
-module Brute
-  module Providers
-    # Fetches and caches model metadata from the models.dev catalog.
-    #
-    # Quacks like llm.rb's provider.models so that the REPL's model
-    # picker can call:
-    #
-    #   provider.models.all.select(&:chat?)
-    #
-    # Models are fetched from https://models.dev/api.json and cached
-    # in-memory for the lifetime of the process (with a TTL).
-    #
-    class ModelsDev
-      CATALOG_URL = "https://models.dev/api.json"
-      CACHE_TTL = 3600 # 1 hour
-
-      ModelEntry = Struct.new(:id, :name, :chat?, :cost, :limit, :reasoning, :tool_call, keyword_init: true)
-
-      # @param provider [LLM::Provider] the provider instance (for delegating execute/headers)
-      # @param provider_id [String] the provider key in models.dev (e.g., "opencode", "opencode-go")
-      def initialize(provider:, provider_id: "opencode")
-        @provider = provider
-        @provider_id = provider_id
-      end
-
-      # Returns all models for this provider from the models.dev catalog.
-      # @return [Array<ModelEntry>]
-      def all
-        entries = fetch_provider_models
-        entries.map do |id, model|
-          ModelEntry.new(
-            id: id,
-            name: model["name"] || id,
-            chat?: true,
-            cost: model["cost"],
-            limit: model["limit"],
-            reasoning: model["reasoning"] || false,
-            tool_call: model["tool_call"] || false
-          )
-        end.sort_by(&:id)
-      end
-
-      private
-
-      def fetch_provider_models
-        catalog = self.class.fetch_catalog
-        provider_data = catalog[@provider_id]
-        return {} unless provider_data
-
-        provider_data["models"] || {}
-      end
-
-      class << self
-        # Fetch the models.dev catalog, with in-memory caching.
-        # Thread-safe via a simple mutex.
-        def fetch_catalog
-          @mutex ||= Mutex.new
-          @mutex.synchronize do
-            if @catalog && @fetched_at && (Time.now - @fetched_at < CACHE_TTL)
-              return @catalog
-            end
-
-            @catalog = download_catalog
-            @fetched_at = Time.now
-            @catalog
-          end
-        end
-
-        # Force a cache refresh on next access.
-        def invalidate_cache!
-          @mutex&.synchronize do
-            @catalog = nil
-            @fetched_at = nil
-          end
-        end
-
-        private
-
-        def download_catalog
-          uri = URI.parse(CATALOG_URL)
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.use_ssl = true
-          http.open_timeout = 10
-          http.read_timeout = 30
-
-          request = Net::HTTP::Get.new(uri.request_uri)
-          request["User-Agent"] = "brute/#{Brute::VERSION}"
-          request["Accept"] = "application/json"
-
-          response = http.request(request)
-
-          unless response.is_a?(Net::HTTPSuccess)
-            raise "Failed to fetch models.dev catalog: HTTP #{response.code}"
-          end
-
-          JSON.parse(response.body)
-        rescue => e
-          # Return empty catalog on failure so the provider still works
-          # with default_model, just without a model list.
-          warn "[brute] Warning: Could not fetch models.dev catalog: #{e.message}"
-          {}
-        end
-      end
-    end
-  end
-end

data/lib/brute/providers/ollama.rb

@@ -1,135 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/setup"
-require "brute"
-
-# Ensure the Ollama provider is loaded (llm.rb lazy-loads providers).
-unless defined?(LLM::Ollama)
-  require "llm/providers/ollama"
-end
-
-module Brute
-  module Providers
-    ##
-    # Brute-level wrapper around LLM::Ollama for local model inference.
-    #
-    # Adds environment-variable-based configuration so that all Brute
-    # examples and the CLI work out of the box with a local Ollama
-    # instance:
-    #
-    #   OLLAMA_HOST  — base URL (default: http://localhost:11434)
-    #   OLLAMA_MODEL — default model (default: llm.rb's default, currently qwen3:latest)
-    #
-    # @example Auto-detect via environment
-    #   export OLLAMA_HOST=http://localhost:11434
-    #   ruby examples/01_basic_agent.rb
-    #
-    # @example Remote Ollama server
-    #   export OLLAMA_HOST=http://192.168.1.50:11434
-    #   export OLLAMA_MODEL=llama3.1:8b
-    #   ruby examples/02_fix_a_bug.rb
-    #
-    class Ollama < LLM::Ollama
-      ##
-      # Parse OLLAMA_HOST into host, port, and ssl components.
-      # Accepts formats like:
-      #   http://localhost:11434
-      #   https://ollama.example.com
-      #   192.168.1.50:11434
-      #   localhost
-      #
-      # @param url [String, nil] raw OLLAMA_HOST value
-      # @return [Hash] with :host, :port, :ssl keys
-      def self.parse_host(url)
-        return { host: LLM::Ollama::HOST, port: 11434, ssl: false } if url.nil? || url.empty?
-
-        # Prepend scheme if missing so URI.parse works
-        url = "http://#{url}" unless url.match?(%r{\A\w+://})
-        uri = URI.parse(url)
-
-        {
-          host: uri.host || LLM::Ollama::HOST,
-          port: uri.port || 11434,
-          ssl: uri.scheme == "https",
-        }
-      end
-
-      ##
-      # @param key [String] ignored (Ollama needs no auth), kept for provider interface
-      def initialize(key: "none", **)
-        config = self.class.parse_host(ENV["OLLAMA_HOST"])
-        super(key: key, host: config[:host], port: config[:port], ssl: config[:ssl], **)
-      end
-
-      ##
-      # @return [Symbol]
-      def name
-        :ollama
-      end
-
-      ##
-      # Returns the default model, preferring OLLAMA_MODEL env var.
-      # @return [String]
-      def default_model
-        ENV["OLLAMA_MODEL"] || super
-      end
-    end
-  end
-end
-
-test do
-  parse = proc { |url| Brute::Providers::Ollama.parse_host(url) }
-
-  describe ".parse_host" do
-    it "returns defaults for nil" do
-      parse.(nil).should == { host: "localhost", port: 11434, ssl: false }
-    end
-
-    it "returns defaults for empty string" do
-      parse.("").should == { host: "localhost", port: 11434, ssl: false }
-    end
-
-    it "parses http URL with port" do
-      parse.("http://192.168.1.50:11434").should == { host: "192.168.1.50", port: 11434, ssl: false }
-    end
-
-    it "parses https URL" do
-      parse.("https://ollama.example.com").should == { host: "ollama.example.com", port: 443, ssl: true }
-    end
-
-    it "parses host:port without scheme" do
-      parse.("192.168.1.50:11434").should == { host: "192.168.1.50", port: 11434, ssl: false }
-    end
-
-    it "parses bare hostname" do
-      parse.("myhost").should == { host: "myhost", port: 80, ssl: false }
-    end
-  end
-
-  describe "#name" do
-    it "returns :ollama" do
-      provider = Brute::Providers::Ollama.new
-      provider.name.should == :ollama
-    end
-  end
-
-  describe "#default_model" do
-    it "falls back to llm.rb default when OLLAMA_MODEL is not set" do
-      original = ENV["OLLAMA_MODEL"]
-      ENV.delete("OLLAMA_MODEL")
-      provider = Brute::Providers::Ollama.new
-      provider.default_model.should == "qwen3:latest"
-    ensure
-      ENV["OLLAMA_MODEL"] = original if original
-    end
-
-    it "uses OLLAMA_MODEL env var when set" do
-      original = ENV["OLLAMA_MODEL"]
-      ENV["OLLAMA_MODEL"] = "llama3.1:8b"
-      provider = Brute::Providers::Ollama.new
-      provider.default_model.should == "llama3.1:8b"
-    ensure
-      ENV["OLLAMA_MODEL"] = original
-    end
-  end
-end

data/lib/brute/providers/opencode_go.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
-
-module LLM
-  ##
-  # OpenAI-compatible provider for the OpenCode Go API gateway.
-  #
-  # OpenCode Go is the low-cost subscription plan with a restricted
-  # (lite) model list. Same gateway as Zen, different endpoint path.
-  #
-  # @example
-  #   llm = LLM::OpencodeGo.new(key: ENV["OPENCODE_API_KEY"])
-  #   ctx = LLM::Context.new(llm)
-  #   ctx.talk "Hello from brute"
-  #
-  class OpencodeGo < OpencodeZen
-    ##
-    # @return [Symbol]
-    def name
-      :opencode_go
-    end
-
-    ##
-    # Returns models from the models.dev catalog.
-    # Note: The Go gateway only accepts lite-tier models, but models.dev
-    # doesn't distinguish between Zen and Go tiers. We show the full
-    # catalog; the gateway returns an error for unsupported models.
-    # @return [Brute::Providers::ModelsDev]
-    def models
-      Brute::Providers::ModelsDev.new(provider: self, provider_id: "opencode")
-    end
-
-    private
-
-    def completions_path
-      "/zen/go/v1/chat/completions"
-    end
-  end
-end

data/lib/brute/providers/opencode_zen.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-if __FILE__ == $0
-  require "bundler/setup"
-  require "brute"
-end
-
-# Ensure the OpenAI provider is loaded (llm.rb lazy-loads providers).
-unless defined?(LLM::OpenAI)
-  require "llm/providers/openai"
-end
-
-module LLM
-  ##
-  # OpenAI-compatible provider for the OpenCode Zen API gateway.
-  #
-  # OpenCode Zen is a curated model gateway at opencode.ai that proxies
-  # requests to upstream LLM providers (Anthropic, OpenAI, Google, etc.).
-  # All models are accessed via the OpenAI-compatible chat completions
-  # endpoint; the gateway handles format conversion internally.
-  #
-  # @example
-  #   llm = LLM::OpencodeZen.new(key: ENV["OPENCODE_API_KEY"])
-  #   ctx = LLM::Context.new(llm)
-  #   ctx.talk "Hello from brute"
-  #
-  # @example Anonymous access (free models only)
-  #   llm = LLM::OpencodeZen.new(key: "public")
-  #   ctx = LLM::Context.new(llm)
-  #   ctx.talk "Hello"
-  #
-  class OpencodeZen < OpenAI
-    HOST = "opencode.ai"
-
-    ##
-    # @param key [String] OpenCode API key, or "public" for anonymous access
-    # @param (see LLM::Provider#initialize)
-    def initialize(key: "public", **)
-      super(host: HOST, key: key, **)
-    end
-
-    ##
-    # @return [Symbol]
-    def name
-      :opencode_zen
-    end
-
-    ##
-    # Returns the default model.
-    # @return [String]
-    def default_model
-      "zen-bickpickle"
-    end
-
-    ##
-    # Returns models from the models.dev catalog for the opencode provider.
-    # @return [Brute::Providers::ModelsDev]
-    def models
-      Brute::Providers::ModelsDev.new(provider: self, provider_id: "opencode")
-    end
-
-    # -- Unsupported sub-APIs --
-
-    def responses    = raise(NotImplementedError, "Use chat completions via the Zen gateway")
-    def images       = raise(NotImplementedError, "Not supported via Zen gateway")
-    def audio        = raise(NotImplementedError, "Not supported via Zen gateway")
-    def files        = raise(NotImplementedError, "Not supported via Zen gateway")
-    def moderations  = raise(NotImplementedError, "Not supported via Zen gateway")
-    def vector_stores = raise(NotImplementedError, "Not supported via Zen gateway")
-
-    private
-
-    def completions_path
-      "/zen/v1/chat/completions"
-    end
-
-    def headers
-      lock do
-        (@headers || {}).merge(
-          "Content-Type" => "application/json",
-          "Authorization" => "Bearer #{@key}",
-          "x-opencode-client" => "brute"
-        )
-      end
-    end
-  end
-end

data/lib/brute/providers.rb

@@ -1,62 +0,0 @@
-require_relative 'providers/shell_response'
-require_relative 'providers/shell'
-require_relative 'providers/models_dev'
-require_relative 'providers/opencode_zen'
-require_relative 'providers/opencode_go'
-require_relative 'providers/ollama'
-
-module Brute
-  module Providers
-    ALL = {
-      'anthropic' => ->(key) { LLM.anthropic(key: key).tap { Patches::AnthropicToolRole.apply! } },
-      'openai' => ->(key) { LLM.openai(key: key) },
-      'google' => ->(key) { LLM.google(key: key) },
-      'deepseek' => ->(key) { LLM.deepseek(key: key) },
-      'ollama' => ->(_key) { Providers::Ollama.new },
-      'xai' => ->(key) { LLM.xai(key: key) },
-      'opencode_zen' => ->(key) { LLM::OpencodeZen.new(key: key) },
-      'opencode_go' => ->(key) { LLM::OpencodeGo.new(key: key) },
-      'shell' => ->(_key) { Providers::Shell.new },
-    }.freeze
-
-    # Resolve the LLM provider from environment variables.
-    #
-    # Checks in order:
-    #   1. LLM_API_KEY + LLM_PROVIDER (explicit)
-    #   2. OPENCODE_API_KEY (implicit: provider = opencode_zen)
-    #   3. ANTHROPIC_API_KEY (implicit: provider = anthropic)
-    #   4. OPENAI_API_KEY   (implicit: provider = openai)
-    #   5. GOOGLE_API_KEY   (implicit: provider = google)
-    #   6. OLLAMA_HOST      (implicit: provider = ollama, local inference)
-    #
-    # Returns nil if no key is found. Error is deferred to the caller.
-    def self.guess_from_env
-      if ENV['LLM_API_KEY']
-        key = ENV['LLM_API_KEY']
-        name = ENV.fetch('LLM_PROVIDER', 'opencode_zen').downcase
-      elsif ENV['OPENCODE_API_KEY']
-        key = ENV['OPENCODE_API_KEY']
-        name = 'opencode_zen'
-      elsif ENV['ANTHROPIC_API_KEY']
-        key = ENV['ANTHROPIC_API_KEY']
-        name = 'anthropic'
-      elsif ENV['OPENAI_API_KEY']
-        key = ENV['OPENAI_API_KEY']
-        name = 'openai'
-      elsif ENV['GOOGLE_API_KEY']
-        key = ENV['GOOGLE_API_KEY']
-        name = 'google'
-      elsif ENV['OLLAMA_HOST']
-        key = 'none'
-        name = 'ollama'
-      else
-        return nil
-      end
-
-      factory = Providers::ALL[name]
-      raise "Unknown LLM provider: #{name}. Available: #{Providers::ALL.keys.join(', ')}" unless factory
-
-      factory.call(key)
-    end
-  end
-end