llm.rb 15.0.2 → 15.1.0

data/data/xai.json

@@ -74,22 +74,6 @@
         "context": 500000,
         "output": 500000
       },
-      "experimental": {
-        "modes": {
-          "fast": {
-            "cost": {
-              "input": 4,
-              "output": 12,
-              "cache_read": 1
-            },
-            "provider": {
-              "body": {
-                "service_tier": "priority"
-              }
-            }
-          }
-        }
-      },
       "cost": {
         "input": 2,
         "output": 6,
@@ -386,6 +370,34 @@
         }
       }
     },
+    "grok-imagine-image-2.0": {
+      "id": "grok-imagine-image-2.0",
+      "name": "Grok Imagine Image 2.0",
+      "description": "Image model for prompt-driven generation, editing, and visual design workflows",
+      "family": "grok",
+      "attachment": true,
+      "reasoning": false,
+      "tool_call": false,
+      "temperature": false,
+      "release_date": "2026-08-07",
+      "last_updated": "2026-08-07",
+      "modalities": {
+        "input": [
+          "text",
+          "image",
+          "pdf"
+        ],
+        "output": [
+          "image",
+          "pdf"
+        ]
+      },
+      "open_weights": false,
+      "limit": {
+        "context": 8000,
+        "output": 0
+      }
+    },
     "grok-imagine-image": {
       "id": "grok-imagine-image",
       "name": "Grok Imagine Image",

data/docs/deepdive/advanced/context.md

@@ -74,12 +74,14 @@ with `store: false`, so no conversation state is kept server-side.
 Pass `mode: :completions` to use the legacy Chat Completions API
 instead. Every other provider defaults to `mode: :completions`.
 
-A raw context disables rate-limit retries by default (`retry_budget: 0`).
-Pass `retry_budget:` to retry a rate-limited request up to that many
-times. Each retry sleeps a growing interval (2s, 4s, 6s, ...) and
-notifies the stream through
-[`LLM::Stream#on_rate_limit`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_rate_limit-instance_method)
-before trying again. An `LLM::Agent` enables a budget of 3 by
+A raw context disables retries by default (`retry_budget: 0`).
+Pass `retry_budget:` to retry a request that was rate limited
+(`LLM::RateLimitError`) or timed out (`Timeout::Error`, covering
+`Net::OpenTimeout` and `Net::ReadTimeout`), up to that many times.
+Each retry sleeps a growing interval (2s, 4s, 6s, ...) and notifies
+the stream through
+[`LLM::Stream#on_retry`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_retry-instance_method)
+before trying again. An `LLM::Agent` enables a budget of 5 by
 default, so most users never touch this directly.
 
 ### Manual loop

data/docs/deepdive/fundamentals/agents.md

@@ -206,22 +206,22 @@ longer used.
 #### Overview
 
 [`LLM::Agent.retry_budget`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#retry_budget-class_method)
-is the maximum number of times an agent retries a rate-limited
-request before giving up. It is enabled by default at three
-retries, so most agents survive a transient 429 without any
-configuration. Only a raw
+is the maximum number of times an agent retries a failed request
+before giving up. It is enabled by default at five retries, so
+most agents survive a transient 429 or a dropped connection without
+any configuration. Only a raw
 [`LLM::Context`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
 disables it by default.
 
 #### How it works
 
-When you want to control how many times a rate-limited request is
+When you want to control how many times a failed request is
 retried, set the budget with
 [`LLM::Agent.set`](https://r.uby.dev/api-docs/llm.rb/LLM/Agent.html#set-class_method)
 or per-instance with the `retry_budget:` keyword argument. Each
-retry notifies your stream through `on_rate_limit` and sleeps a
+retry notifies your stream through `on_retry` and sleeps a
 growing interval (2s, 4s, 6s, ...). Once the budget is spent, the
-agent re-raises the rate-limit error instead of blocking forever:
+agent re-raises the error instead of blocking forever:
 
 ```ruby
 class Chat < LLM::Agent
@@ -244,9 +244,10 @@ of hanging.
 
 #### Notes
 
-The retry budget applies to rate-limited requests only, other
-errors are never retried. The budget defaults to five for agents,
-while a raw
+The retry budget applies to rate-limited requests
+(`LLM::RateLimitError`) and timeouts (`Timeout::Error`, covering
+`Net::OpenTimeout` and `Net::ReadTimeout`), other errors are never
+retried. The budget defaults to five for agents, while a raw
 [`LLM::Context`](https://r.uby.dev/api-docs/llm.rb/LLM/Context.html)
 defaults to zero (`retry_budget: 0`). A 429 is refused before any
 content streams, so retrying the same request loses nothing. Pass

data/docs/deepdive/fundamentals/stream.md

@@ -67,8 +67,8 @@ receives tokens as they arrive.
 fires when the model requests a tool.
 [`LLM::Stream#on_tool_return`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_tool_return)
 fires when the tool completes.
-[`LLM::Stream#on_rate_limit`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_rate_limit)
-fires each time a rate-limited request is retried. Compaction hooks
+[`LLM::Stream#on_retry`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_retry)
+fires each time a failed request is retried. Compaction hooks
 let you show progress or log what was trimmed. Skill hooks bracket a
 skill's subagent execution:
 [`LLM::Stream#on_skill_call`](https://r.uby.dev/api-docs/llm.rb/LLM/Stream.html#on_skill_call)
@@ -120,8 +120,8 @@ class MyStream < LLM::Stream
   def on_skill_return(agent, skill, result)
   end
 
-  # A request was rate limited and will be retried.
-  def on_rate_limit(error)
+  # A request was rate limited or timed out and will be retried.
+  def on_retry(error, attempt)
   end
 end
 

data/lib/llm/active_record.rb

@@ -39,7 +39,7 @@ module LLM::ActiveRecord
     def self.serialize_context(ctx, format)
       case format
       when :string then ctx.to_json
-      when :json, :jsonb then ctx.to_h
+      when :json, :jsonb then LLM.json.load(ctx.to_json)
       else raise ArgumentError, "Unknown format: #{format.inspect}"
       end
     end

data/lib/llm/agent.rb

@@ -486,6 +486,12 @@ module LLM
       @ctx.messages
     end
 
+    ##
+    # @return [Integer]
+    def retry_budget
+      @ctx.retry_budget
+    end
+
     ##
     # @return [Array<LLM::Function>]
     def pending_functions

data/lib/llm/context.rb

@@ -39,6 +39,14 @@ module LLM
     include Serializer
     include Deserializer
 
+    TRY_ERRORS = [
+      "LLM::InsufficientQuotaError",
+      "LLM::RateLimitError",
+      "Net::ReadTimeout",
+      "Net::OpenTimeout"
+    ]
+    private_constant :TRY_ERRORS
+
     ##
     # Returns the set of runtime parameters that
     # configure this context and must never be forwarded
@@ -476,7 +484,7 @@ module LLM
     # Returns the model a Context is actively using
     # @return [String]
     def model
-      messages.find(&:assistant?)&.model || @params[:model]
+      messages.find(&:assistant?)&.model || @params[:model] || @llm.default_model
     end
 
     ##
@@ -559,23 +567,30 @@ module LLM
 
     ##
     ##
-    # Runs a network call, retrying it on {LLM::RateLimitError} up to the
-    # retry budget. Each retry notifies the stream and sleeps a growing
-    # interval (2s, 4s, 6s, ...) rather than the server's `retry_after`.
-    # A 429 is refused before any content streams, so retrying the same
-    # request loses nothing. The bare `retry` below re-runs the method
-    # body while `attempts ||= 0` keeps the count across attempts.
+    # Runs a network call, retrying it when the request is rate limited
+    # ({LLM::RateLimitError}) or times out (`Timeout::Error`, which covers
+    # `Net::OpenTimeout` and `Net::ReadTimeout`), up to the retry budget.
+    # Each retry notifies the stream and sleeps a growing interval
+    # (2s, 4s, 6s, ...) rather than the server's `retry_after`. A 429 is
+    # refused before any content streams, so retrying the same request
+    # loses nothing. The bare `retry` below re-runs the method body while
+    # `attempts ||= 0` keeps the count across attempts.
     # @api private
     # @return [Object]
     def try
       attempts ||= 0
       yield
-    rescue LLM::RateLimitError => error
-      raise if attempts >= retry_budget
-      attempts += 1
-      stream.on_rate_limit(error)
-      sleep 2.0 * attempts
-      retry
+    rescue => ex
+      case ex.class.to_s
+      when *TRY_ERRORS
+        raise if attempts >= retry_budget
+        attempts += 1
+        stream.on_retry(ex, attempts)
+        sleep 2.0 * attempts
+        retry
+      else
+        raise(ex)
+      end
     end
 
     # Executes a turn through the Responses API.

data/lib/llm/cost.rb

@@ -6,6 +6,14 @@
 # output, input audio, output audio, input image, cache read, cache write,
 # and reasoning costs separately and can return the total.
 class LLM::Cost
+  ##
+  # Build a zero-valued cost breakdown. Every component
+  # is nil (treated as no cost), so the total is 0.
+  # @return [LLM::Cost]
+  def self.zero
+    new
+  end
+
   ##
   # Build a cost breakdown from token usage and model pricing.
   # @param [LLM::Context] ctx
@@ -13,6 +21,11 @@ class LLM::Cost
   # @return [LLM::Cost]
   def self.from(ctx)
     pricing = LLM.registry_for(ctx.llm).cost(model: ctx.model)
+    ##
+    # A model may have no known pricing (eg OpenRouter's
+    # `openrouter/auto` auto-router). Fall back to a zero
+    # cost rather than crashing on a nil pricing.
+    return zero if pricing.nil?
     usage = ctx.usage
     output = usage.output_tokens - usage.reasoning_tokens
     input = usage.input_tokens - usage.cache_read_tokens

data/lib/llm/function/fork/task.rb

@@ -32,13 +32,15 @@ class LLM::Function
       @pid = Kernel.fork do
         ##
         # The child inherits the parent's terminal. When
-        # the runtime runs under a curses REPL, the forked
-        # tool writing to the tty would clobber the parent's
-        # display (a blank screen). Redirect the child's
-        # stdout/stderr to null so it keeps off the user's
-        # terminal. A tool that genuinely needs the terminal
-        # can reopen it via /dev/tty; the tty fd stays
-        # available to the child.
+        # the runtime runs under a curses REPL, a forked
+        # tool reading or writing the tty would steal the
+        # user's input or clobber the parent's display.
+        # Point all three standard streams at null so the
+        # child keeps off the user's terminal entirely. A
+        # tool that genuinely needs the terminal can reopen
+        # it via /dev/tty; the tty fd stays available to
+        # the child.
+        $stdin.reopen(File::NULL)
         $stdout.reopen(File::NULL)
         $stderr.reopen(File::NULL)
         Fork::Job.new(@function, @ch).call
@@ -83,8 +85,10 @@ class LLM::Function
       @tracer&.on_tool_finish(result:, span: @span)
       result
     ensure
-      reap
-      [@ch.control, @ch.result].each { _1.close unless _1.closed? }
+      if @guarded.nil?
+        reap
+        [@ch.control, @ch.result].each { _1.close unless _1.closed? } if @ch
+      end
     end
     alias_method :value, :wait
 
@@ -97,7 +101,7 @@ class LLM::Function
     private
 
     def reap
-      return if @waited
+      return if @waited || @guarded || !@pid
       ::Process.waitpid(@pid)
       @waited = true
     rescue Errno::ECHILD

data/lib/llm/provider.rb

@@ -17,7 +17,12 @@ class LLM::Provider
   # @param [Integer] port
   #  The port number
   # @param [Integer] timeout
-  #  The number of seconds to wait for a response
+  #  The number of seconds to wait for a response. Also serves as the
+  #  default read timeout.
+  # @param [Integer, nil] read_timeout
+  #  The number of seconds to wait for a response. Defaults to `timeout`.
+  # @param [Integer] connect_timeout
+  #  The number of seconds to wait for a TCP connection to open.
   # @param [Boolean] ssl
   #  Whether to use SSL for the connection
   # @param [String] base_path
@@ -27,17 +32,27 @@ class LLM::Provider
   #  Requires the net-http-persistent gem.
   # @param [LLM::Transport, Class, nil] transport
   #  Optional override with any {LLM::Transport} instance or subclass.
-  def initialize(key:, host:, port: 443, timeout: 900, ssl: true, base_path: "", persistent: false, transport: nil)
+  def initialize(key:, host:, port: 443, timeout: 600, read_timeout: nil, connect_timeout: 5, ssl: true, base_path: "", persistent: false, transport: nil)
     @key = key
     @host = host
     @port = port
-    @timeout = timeout
+    @read_timeout = read_timeout || timeout
+    @timeout = @read_timeout
+    @connect_timeout = connect_timeout
     @ssl = ssl
     @base_path = LLM::Utils.normalize_base_path(base_path)
     @base_uri = URI("#{ssl ? "https" : "http"}://#{host}:#{port}/")
     @headers = {"User-Agent" => "llm.rb v#{LLM::VERSION}"}
-    @transport = LLM::Transport::Utils.resolve_transport(host:, port:, timeout:, ssl:, transport:, persistent:)
     @monitor = Monitor.new
+    @transport = LLM::Transport::Utils.resolve_transport(
+      host:,
+      port:,
+      timeout: @read_timeout,
+      connect_timeout: @connect_timeout,
+      ssl:,
+      transport:,
+      persistent:
+    )
   end
 
   ##
@@ -251,13 +266,19 @@ class LLM::Provider
   # Add one or more headers to all requests
   # @example
   #   llm = LLM.openai(key: ENV["KEY"])
-  #   llm.with(headers: {"OpenAI-Organization" => ENV["ORG"]})
-  #   llm.with(headers: {"OpenAI-Project" => ENV["PROJECT"]})
+  #   llm.with("OpenAI-Organization" => ENV["ORG"])
+  #   llm.with("OpenAI-Project" => ENV["PROJECT"])
   # @param [Hash<String,String>] headers
   #  One or more headers
+  # @note
+  #  For backwards compatibility, headers can be
+  #  provided via the `headers:` keyword argument,
+  #  or provided directly as a Hash without the
+  #  `headers:` key namespace.
   # @return [LLM::Provider]
   #  Returns self
-  def with(headers:)
+  def with(**headers)
+    headers = headers.merge(headers.delete(:headers) || {})
     lock do
       tap { @headers.merge!(headers) }
     end
@@ -412,7 +433,7 @@ class LLM::Provider
     "#{@base_path}#{suffix}"
   end
 
-  attr_reader :base_uri, :host, :port, :timeout, :ssl, :transport
+  attr_reader :base_uri, :host, :port, :timeout, :read_timeout, :connect_timeout, :ssl, :transport
 
   ##
   # The headers to include with a request

data/lib/llm/providers/anthropic.rb

@@ -159,7 +159,7 @@ module LLM
     end
 
     def normalize_complete_params(params)
-      params = {role: :user, model: default_model, max_tokens: 1024}.merge!(params)
+      params = {role: :user, model: params.delete(:model) || default_model, max_tokens: 1024}.merge!(params)
       tools = resolve_tools(params.delete(:tools))
       params = [params, adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), LLM::Stream.try(params.delete(:stream))

data/lib/llm/providers/bedrock/models.rb

@@ -51,7 +51,7 @@ class LLM::Bedrock
     # @param [String] host
     # @return [LLM::Transport]
     def build_transport(host)
-      transport.class.new(host:, port: 443, timeout:, ssl: true)
+      transport.class.new(host:, port: 443, timeout:, connect_timeout:, ssl: true)
     end
 
     ##
@@ -102,7 +102,7 @@ class LLM::Bedrock
       end
     end
 
-    [:timeout, :tracer, :transport].each do |m|
+    [:timeout, :connect_timeout, :tracer, :transport].each do |m|
       define_method(m) { @provider.send(m) }
     end
   end

data/lib/llm/providers/bedrock.rb

@@ -210,7 +210,7 @@ module LLM
     end
 
     def normalize_complete_params(params)
-      params = {role: :user, model: default_model, max_tokens: 2048}.merge!(params)
+      params = {role: :user, model: params.delete(:model) || default_model, max_tokens: 2048}.merge!(params)
       tools = resolve_tools(params.delete(:tools))
       params = [params, adapt_schema(params), adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), LLM::Stream.try(params.delete(:stream))

data/lib/llm/providers/google.rb

@@ -202,7 +202,7 @@ module LLM
 
     def normalize_complete_params(params)
       except = %i[role model messages stream]
-      params = {role: :user, model: default_model}.merge!(params)
+      params = {role: :user, model: params.delete(:model) || default_model}.merge!(params)
       tools  = resolve_tools(params.delete(:tools))
       config = adapt_generation_config(params.except(*except))
       params = [params.except(:schema), config, adapt_tools(tools)].inject({}, &:merge!).compact

data/lib/llm/providers/ollama.rb

@@ -129,7 +129,7 @@ module LLM
     end
 
     def normalize_complete_params(params)
-      params = {role: :user, model: default_model, stream: true}.merge!(params)
+      params = {role: :user, model: params.delete(:model) || default_model, stream: true}.merge!(params)
       tools  = resolve_tools(params.delete(:tools))
       params = [params, {format: params[:schema]}, adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), LLM::Stream.try(params.delete(:stream))

data/lib/llm/providers/openai/responses.rb

@@ -35,7 +35,8 @@ class LLM::OpenAI
     #  When given an object a provider does not understand
     # @return [LLM::Response]
     def create(prompt, params = {})
-      params = {role: :user, model: @provider.default_model}.merge!(params)
+      params = {}.merge!(params)
+      params = {role: :user, model: params.delete(:model) || @provider.default_model}.merge!(params)
       role, stream = params.delete(:role), LLM::Stream.try(params.delete(:stream))
       tools  = resolve_tools(params.delete(:tools))
       params = [

data/lib/llm/providers/openai.rb

@@ -219,7 +219,7 @@ module LLM
     end
 
     def normalize_complete_params(params)
-      params = {role: :user, model: default_model}.merge!(params)
+      params = {role: :user, model: params.delete(:model) || default_model}.merge!(params)
       tools = resolve_tools(params.delete(:tools))
       params = [params, adapt_schema(params), adapt_tools(tools)].inject({}, &:merge!).compact
       role, stream = params.delete(:role), LLM::Stream.try(params.delete(:stream))

data/lib/llm/providers/openrouter.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative "openai" unless defined?(LLM::OpenAI)
+
+module LLM
+  ##
+  # The OpenRouter class implements a provider for
+  # [OpenRouter](https://openrouter.ai) through its OpenAI-compatible API.
+  #
+  # @example
+  #   #!/usr/bin/env ruby
+  #   require "llm"
+  #
+  #   llm = LLM.openrouter(key: ENV["KEY"])
+  #   ctx = LLM::Context.new(llm)
+  #   ctx.talk "Hello"
+  class OpenRouter < OpenAI
+    HOST = "openrouter.ai"
+    BASE_PATH = "/api/v1"
+
+    ##
+    # @param key (see LLM::Provider#initialize)
+    # @param host (see LLM::Provider#initialize)
+    # @param base_path (see LLM::Provider#initialize)
+    # @return [LLM::OpenRouter]
+    def initialize(host: HOST, base_path: BASE_PATH, **)
+      super
+    end
+
+    ##
+    # @return [Symbol]
+    #  Returns the provider's name
+    def name
+      :openrouter
+    end
+
+    ##
+    # Provides an embedding.
+    # @see https://openrouter.ai/docs/api/api-reference/embeddings/create-embeddings OpenRouter docs
+    # @param input (see LLM::Provider#embed)
+    # @param model (see LLM::Provider#embed)
+    # @param params (see LLM::Provider#embed)
+    # @raise (see LLM::Provider#request)
+    # @return (see LLM::Provider#embed)
+    def embed(input, model: "openai/text-embedding-3-small", **params)
+      super
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def files
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def images
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def audio
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def moderations
+      raise NotImplementedError
+    end
+
+    ##
+    # @raise [NotImplementedError]
+    def vector_stores
+      raise NotImplementedError
+    end
+
+    ##
+    # Returns the default model for chat completions
+    # @see https://openrouter.ai/docs/guides/routing/routers/auto-router OpenRouter Auto Router
+    # @return [String]
+    def default_model
+      "openrouter/auto"
+    end
+  end
+end

data/lib/llm/repl/buffer.rb

@@ -147,15 +147,15 @@ class LLM::Repl
         if token == "\n"
           rows << []
         elsif token.match?(/\s/)
-          if sum(rows.last) + token.length <= width
+          if sum(rows.last) + Node.width(token) <= width
             rows.last << Node.new(token, attrs)
           end
-        elsif sum(rows.last) + token.length > width
+        elsif sum(rows.last) + Node.width(token) > width
           if sum(rows.last) == 0
             ##
             # A single word wider than the row: break it
-            # every width characters.
-            token.scan(/.{1,#{width}}/).each do |piece|
+            # every width columns.
+            slices(token, width).each do |piece|
               rows.last << Node.new(piece, attrs)
               if sum(rows.last) >= width
                 rows << []
@@ -190,7 +190,22 @@ class LLM::Repl
     ##
     # @api private
     def sum(row)
-      row.sum { _1[:text].to_s.length }
+      row.sum { _1.size }
+    end
+
+    ##
+    # Splits a single word into pieces that each fit within the
+    # buffer's width, measured in display columns.
+    # @api private
+    def slices(token, width)
+      pieces = []
+      remaining = token
+      until remaining.empty?
+        piece = Node.slice(remaining, width)
+        pieces << piece
+        remaining = remaining[piece.length..] || +""
+      end
+      pieces
     end
   end
 end

data/lib/llm/repl/input.rb

@@ -207,7 +207,8 @@ class LLM::Repl
     def cursor_pos
       scroll!
       row, col = @cursor
-      col += prompt.size if row.zero?
+      col = Node.width(@rows[row].chars[0...col].map(&:to_s).join)
+      col += Node.width(prompt) if row.zero?
       [row - @scroll, col]
     end
 
@@ -435,7 +436,7 @@ class LLM::Repl
       if char == "\n"
         @rows.insert(row + 1, Row.new(:newline))
         @cursor = [row + 1, 0]
-      elsif current_line.size >= Curses.cols
+      elsif Node.width(current_line) >= Curses.cols
         if char == " "
           @rows.insert(row + 1, Row.new(:space))
           @cursor = [row + 1, 0]
@@ -510,8 +511,8 @@ class LLM::Repl
       ##
       # Only the first row shares its columns with the prompt,
       # so it has fewer columns left for text.
-      width = Curses.cols - (row.equal?(@rows.first) ? prompt.size : 0)
-      if row.chars.any? and row.to_s.length + 1 > width
+      width = Curses.cols - (row.equal?(@rows.first) ? Node.width(prompt) : 0)
+      if row.chars.any? and Node.width(row.to_s) + 1 > width
         wrap(row)
       end
       @rows.last.chars << Char.new(char)

data/lib/llm/repl/markdown/table.rb

@@ -23,7 +23,10 @@ class LLM::Repl::Markdown
         emit("| ", attrs)
         row.each_with_index do |chunks, i|
           width = widths[i]
-          chunks.each { |c| emit(c[:text].ljust(width), c[:attrs]) }
+          chunks.each do |c|
+            text = c[:text].to_s
+            emit(text + (" " * (width - Node.width(text))), c[:attrs])
+          end
           emit(" | ", attrs) unless i == row.size - 1
         end
         emit(" |", attrs)
@@ -77,7 +80,7 @@ class LLM::Repl::Markdown
       return [] if rows.empty?
       cols = rows.first.size
       (0...cols).map do |i|
-        rows.map { |r| r[i].map { _1[:text] }.join.length }.max
+        rows.map { |r| Node.width(r[i].map { _1[:text] }.join) }.max
       end
     end
   end