rubino-agent 0.3.0

data/lib/rubino/llm/inline_think_filter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Rubino
+  module LLM
+    # Streaming filter that splits text into :content and :thinking events by
+    # recognising inline <think>...</think> sentinels emitted by MiniMax,
+    # DeepSeek-R1, Qwen, and similar reasoning models that don't expose a
+    # dedicated reasoning channel.
+    #
+    # Holds back up to TAG_MAX_LEN-1 chars across chunks so a tag split between
+    # chunks (e.g. "<thi" + "nk>") still gets matched. Call #flush at end of
+    # stream to drain any tail.
+    class InlineThinkFilter
+      OPEN_RE  = /<think>/i
+      CLOSE_RE = %r{</think>}i
+      TAG_MAX_LEN = "</think>".length
+
+      def initialize
+        @inside  = false
+        @pending = +""
+      end
+
+      def feed(chunk)
+        @pending << chunk
+        loop do
+          re, sentinel = @inside ? [CLOSE_RE, :thinking] : [OPEN_RE, :content]
+          match = @pending.match(re)
+
+          if match
+            idx     = match.begin(0)
+            tag_len = match[0].length
+            emit    = @pending.slice!(0, idx)
+            @pending.slice!(0, tag_len)
+            yield sentinel, emit unless emit.empty?
+            @inside = !@inside
+          else
+            # Hold back last (TAG_MAX_LEN-1) chars in case the next chunk
+            # completes a tag that began at the tail of @pending.
+            safe_len = @pending.length - (TAG_MAX_LEN - 1)
+            if safe_len.positive?
+              emit = @pending.slice!(0, safe_len)
+              yield sentinel, emit unless emit.empty?
+            end
+            break
+          end
+        end
+      end
+
+      def flush
+        return if @pending.empty?
+
+        sentinel = @inside ? :thinking : :content
+        yield sentinel, @pending
+        @pending = +""
+      end
+    end
+  end
+end

data/lib/rubino/llm/model_catalog.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Rubino
+  module LLM
+    # Enumerates the model ids the ruby_llm registry knows for a provider —
+    # the source behind `/model` (bare listing + dropdown completion). Custom
+    # backends (minimax/gateway/anthropic-compatible proxies) are not registry
+    # providers, so they enumerate to [] and `/model` degrades to the
+    # current-model + usage-hint view; no hardcoded global list is invented.
+    module ModelCatalog
+      # ProviderResolver speaks "google"; the ruby_llm registry files the same
+      # models under "gemini". Only mismatch between the two vocabularies.
+      REGISTRY_ALIASES = { "google" => "gemini" }.freeze
+
+      module_function
+
+      # Model ids for +provider+, [] when the registry can't enumerate it.
+      def ids_for(provider)
+        return [] if provider.to_s.empty?
+
+        require "ruby_llm"
+        registry_name = REGISTRY_ALIASES.fetch(provider.to_s, provider.to_s)
+        RubyLLM.models.by_provider(registry_name).map(&:id)
+      rescue StandardError
+        []
+      end
+    end
+  end
+end

data/lib/rubino/llm/provider_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Rubino
+  module LLM
+    # Resolves provider from model name or explicit configuration.
+    #
+    # Single place that interprets "auto": an explicit (non-"auto") provider is
+    # returned verbatim; nil/"auto" first honours the Bedrock-bearer override
+    # (Mantle short-term key → anthropic provider) and then falls back to
+    # pattern-matching the model id. AdapterFactory resolves once here and hands
+    # the concrete provider to RubyLLMAdapter, which no longer re-resolves.
+    class ProviderResolver
+      PROVIDER_PATTERNS = {
+        "fake" => /\Afake/i,
+        "openai" => /\A(openai|gpt|o1|o3|o4)/i,
+        "anthropic" => /\A(anthropic(?!\.)|claude)/i,
+        "google" => /\A(google|gemini)/i,
+        "bedrock" => /\A(anthropic\.|amazon\.|meta\.|mistral\.|cohere\.|ai21\.)/i,
+        "deepseek" => /\Adeepseek/i,
+        "mistral" => /\A(mistral|mixtral)/i,
+        "minimax" => /\A(minimax|abab)/i,
+        "qwen" => /\Aqwen/i
+      }.freeze
+
+      def self.resolve(model_id, explicit_provider: nil)
+        return explicit_provider if explicit_provider && explicit_provider != "auto"
+
+        # Bedrock bearer-token mode (Mantle short-term key: API key set, no
+        # secret) always routes through the Anthropic provider regardless of
+        # model id. Part of the "auto" interpretation, kept here so it lives in
+        # exactly one place (was duplicated in RubyLLMAdapter#resolve_provider).
+        return "anthropic" if bedrock_bearer_env?
+
+        PROVIDER_PATTERNS.each do |provider, pattern|
+          return provider if model_id.to_s.match?(pattern)
+        end
+
+        "openai" # Default fallback
+      end
+
+      # True when the environment carries a Bedrock bearer token (API key set,
+      # no secret key) — the Mantle short-term credential mode.
+      def self.bedrock_bearer_env?
+        !ENV["BEDROCK_API_KEY"].to_s.empty? && ENV["BEDROCK_SECRET_KEY"].to_s.empty?
+      end
+    end
+  end
+end

data/lib/rubino/llm/reasoning_manager.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Rubino
+  module LLM
+    # Renders the reasoning/thinking configuration to the Anthropic-compat wire
+    # params (manual mode). This is the Ruby port of the reference reasoning_config →
+    # `thinking` mapping: on the manual path
+    # (MiniMax /anthropic, older Anthropic, bedrock) thinking is enabled with a
+    # token budget, which FORCES temperature=1 and bumps max_tokens so the budget
+    # fits under it with text headroom to still answer.
+    #
+    # The numbers (budget 8000 "medium", text headroom 4096, 16384 ceiling) are
+    # sourced from config (model.thinking_budget / model.max_tokens_text_headroom
+    # / model.max_tokens) by the adapter and passed in — this object holds no
+    # magic numbers of its own; it only mirrors the reference combination rules.
+    #
+    # One source of truth: the adapter calls #render exactly once per chat build
+    # to derive the params, and applies them; the inline Slice 0(c) logic that
+    # used to live in RubyLLMAdapter#apply_generation_params now lives here.
+    class ReasoningManager
+      # The rendered wire params. +thinking+ is the Anthropic manual-mode block
+      # (nil when disabled), +temperature+ is forced to 1 with thinking on (else
+      # the configured value, possibly nil ⇒ provider default), +max_tokens+ is
+      # the ceiling grown to fit budget + headroom (nil ⇒ leave provider default).
+      Rendered = Struct.new(:thinking, :temperature, :max_tokens, keyword_init: true) do
+        def thinking_enabled?
+          !thinking.nil?
+        end
+      end
+
+      # Render the reasoning config to wire params.
+      #
+      # budget          : Integer — thinking token budget; 0/nil disables thinking
+      # temperature     : Float|nil — configured sampling temperature (ignored when
+      #                   thinking is enabled — Anthropic requires 1 then)
+      # max_tokens      : Integer|nil — configured output ceiling; nil ⇒ leave the
+      #                   provider default UNLESS thinking forces a floor
+      # text_headroom   : Integer — visible-output tokens reserved on top of budget
+      # apply_max_tokens: Bool — only the anthropic-family path raises the ceiling;
+      #                   openai/ollama/etc. leave token limits to the provider
+      #
+      # Mirrors anthropic_adapter.py:2238–2241:
+      #   kwargs["thinking"]    = {type: enabled, budget_tokens: budget}
+      #   kwargs["temperature"] = 1
+      #   kwargs["max_tokens"]  = max(effective_max_tokens, budget + headroom)
+      def render(budget:, temperature: nil, max_tokens: nil,
+                 text_headroom: 4096, apply_max_tokens: true)
+        budget = budget.to_i
+        enabled = budget.positive?
+
+        Rendered.new(
+          thinking: enabled ? { type: :enabled, budget_tokens: budget } : nil,
+          temperature: render_temperature(enabled, temperature),
+          max_tokens: apply_max_tokens ? render_max_tokens(enabled, budget, max_tokens, text_headroom) : nil
+        )
+      end
+
+      # Echo-back seam (reference reapply_reasoning_echo_for_provider): in the
+      # reference, prior-turn assistant
+      # reasoning_content is re-padded onto the api copy for providers that
+      # REQUIRE it back (DeepSeek/Kimi/MiMo thinking mode) or it 400s.
+      #
+      # DOCUMENTED NO-OP SEAM (per the boundary spike): the installed
+      # ruby_llm 1.15 RubyLLM::Message exposes +thinking+ as a read-only attr
+      # (no setter, only an initializer keyword) and our anthropic-compat target
+      # (MiniMax /anthropic) does NOT require reasoning echo-back — only the
+      # OpenAI-compat require-side providers do, which we do not yet target.
+      # So there is no transport to carry reasoning back through cleanly today;
+      # fabricating one would be wrong. This stays a no-op until a require-side
+      # provider lands (Slice 7 fallback may surface one) and ruby_llm offers a
+      # reachable reasoning field on replayed messages.
+      #
+      # Returns +history+ unchanged.
+      def carry(history)
+        # TODO(slice-7+): when a require-side provider (DeepSeek/Kimi/MiMo) is
+        # supported and ruby_llm exposes a settable reasoning field on replayed
+        # assistant messages, fold prior-turn reasoning back here.
+        history
+      end
+
+      private
+
+      def render_temperature(enabled, temperature)
+        return 1 if enabled
+
+        temperature
+      end
+
+      def render_max_tokens(enabled, budget, max_tokens, text_headroom)
+        ceiling = max_tokens
+        floor   = budget + text_headroom.to_i
+        ceiling = [ceiling.to_i, floor].max if enabled && ceiling
+        ceiling = floor if enabled && ceiling.nil?
+        return nil unless ceiling&.positive?
+
+        ceiling
+      end
+    end
+  end
+end

data/lib/rubino/llm/request.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Rubino
+  module LLM
+    # The single value object the conversation loop hands the LLM boundary on
+    # each model call. Pure data — it carries everything a provider needs to
+    # issue one request, so the loop never threads positional args through the
+    # adapter. Mirrors the reference per-call request shape feeding the
+    # normalize_response seam: build a request,
+    # call the boundary, read back a normalized response.
+    #
+    # Fields:
+    #   messages    : [{role:, content:, tool_calls?, tool_call_id?}] — api copy
+    #   tools       : [tool schema] — may be [] (e.g. max-iter toolless summary)
+    #   temperature : Float | nil — nil ⇒ provider default; forced to 1 w/ thinking
+    #   max_tokens  : Integer | nil — bumped on thinking + truncation continuation
+    #   thinking    : {enabled:, effort:|budget:} | nil — rendered to wire later
+    #   prefill     : String | nil — assistant-turn seed for prefill-to-continue
+    #   image_paths : [path] — native attachments, first call of a turn only
+    #   stream      : Bool — loop decides (interactive turn ⇒ false)
+    class Request
+      attr_reader :messages, :tools, :temperature, :max_tokens, :thinking,
+                  :prefill, :image_paths, :stream
+
+      def initialize(messages:, tools: nil, temperature: nil, max_tokens: nil,
+                     thinking: nil, prefill: nil, image_paths: nil, stream: false)
+        @messages    = messages || []
+        @tools       = tools || []
+        @temperature = temperature
+        @max_tokens  = max_tokens
+        @thinking    = thinking
+        @prefill     = prefill
+        @image_paths = image_paths || []
+        @stream      = stream ? true : false
+      end
+
+      # True when the loop asked the boundary to stream this call.
+      def stream?
+        @stream
+      end
+
+      def to_h
+        {
+          messages: @messages,
+          tools: @tools,
+          temperature: @temperature,
+          max_tokens: @max_tokens,
+          thinking: @thinking,
+          prefill: @prefill,
+          image_paths: @image_paths,
+          stream: @stream
+        }
+      end
+    end
+  end
+end