llm.rb 15.0.3 → 15.2.0

data/lib/llm/{repl → console}/window.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-class LLM::Repl
+class LLM::Console
   ##
-  # The {LLM::Repl::Window LLM::Repl::Window} class draws the
+  # The {LLM::Console::Window LLM::Console::Window} class draws the
   # curses screen for the REPL.
   # @api private
   class Window
@@ -12,21 +12,21 @@ class LLM::Repl
     TOP_ROWS = 1
 
     ##
-    # @return [LLM::Repl::Status]
+    # @return [LLM::Console::Status]
     attr_reader :status
 
     ##
-    # @return [LLM::Repl::Buffer]
+    # @return [LLM::Console::Buffer]
     attr_reader :buffer
 
     ##
-    # @return [LLM::Repl::Input]
+    # @return [LLM::Console::Input]
     attr_reader :input
 
     ##
-    # @param [LLM::Repl] repl
+    # @param [LLM::Console] console
     #  A read-eval-print loop.
-    # @return [LLM::Repl::Window]
+    # @return [LLM::Console::Window]
     def initialize(repl)
       @repl   = repl
       @status = repl.status
@@ -140,11 +140,11 @@ class LLM::Repl
           remaining = buffer.width - width
           break if remaining <= 0
           text, attrs = chunk.text.to_s, chunk.attrs
-          clipped = text[0, remaining]
+          clipped = Node.slice(text, remaining)
           Curses.attron(attrs) if attrs
           Curses.addstr(clipped)
           Curses.attroff(attrs) if attrs
-          width += clipped.length
+          width += Node.width(clipped)
         end
       end
       last_drawn = offset + rows.size
@@ -163,10 +163,10 @@ class LLM::Repl
       Curses.clrtoeol
       status.nodes.each { addnode(_1) }
       context = status.context_bar
-      Curses.setpos(y, [(columns - context.length) / 2, 0].max)
+      Curses.setpos(y, [(columns - Node.width(context)) / 2, 0].max)
       Curses.addstr(context)
       cost = status.cost.to_s
-      Curses.setpos(y, [columns - cost.length, 0].max)
+      Curses.setpos(y, [columns - Node.width(cost), 0].max)
       Curses.addstr(cost)
     end
 
@@ -178,9 +178,9 @@ class LLM::Repl
     def draw_meta(offset:)
       y = Curses.lines - offset
       fill_row(y) do
-        addnode(status.cwd, status.cwd.text[0, columns])
-        Curses.setpos(y, [columns - status.model.text.size, 0].max)
-        addnode(status.model, status.model.text[0, columns])
+        addnode(status.cwd, Node.slice(status.cwd.text, columns))
+        Curses.setpos(y, [columns - status.model.size, 0].max)
+        addnode(status.model, Node.slice(status.model.text, columns))
       end
     end
 
@@ -239,15 +239,15 @@ class LLM::Repl
 
     ##
     # 20% offset that occupies the left margin and
-    # helps center {LLM::Repl::Buffer LLM::Repl::Buffer}.
+    # helps center {LLM::Console::Buffer LLM::Console::Buffer}.
     # @return [Integer]
     def gutter
       (columns * 0.2).floor
     end
 
     ##
-    # Adds a {LLM::Repl::Node} to the Curses window.
-    # @param [LLM::Repl::Node] node
+    # Adds a {LLM::Console::Node} to the Curses window.
+    # @param [LLM::Console::Node] node
     # @param [String] text
     # @return [void]
     def addnode(node, text = node.text)

data/lib/llm/{repl.rb → console.rb}

@@ -2,8 +2,8 @@
 
 module LLM
   ##
-  # The {LLM::Repl LLM::Repl} class provides a small
-  # read-eval-print loop around an instance of
+  # The {LLM::Console LLM::Console} class provides a small
+  # interactive console around an instance of
   # {LLM::Agent LLM::Agent}.
   #
   # It can be used to keep talking to an agent after it
@@ -11,21 +11,22 @@ module LLM
   # useful when you want to confirm the agent handled the
   # task correctly, or for it to correct course after a
   # mistake was made.
-  class Repl
+  class Console
     LLM.require "curses", "~> 1.6"
     LLM.require "kramdown", "~> 2.5"
+    LLM.require "unicode/display_width", "~> 3.2"
 
-    require_relative "repl/color"
-    require_relative "repl/window"
-    require_relative "repl/status"
-    require_relative "repl/buffer"
-    require_relative "repl/input"
-    require_relative "repl/bar"
-    require_relative "repl/stream"
-    require_relative "repl/node"
-    require_relative "repl/markdown"
-    require_relative "repl/command"
-    require_relative "repl/walker"
+    require_relative "console/color"
+    require_relative "console/window"
+    require_relative "console/status"
+    require_relative "console/buffer"
+    require_relative "console/input"
+    require_relative "console/bar"
+    require_relative "console/stream"
+    require_relative "console/node"
+    require_relative "console/markdown"
+    require_relative "console/command"
+    require_relative "console/walker"
 
     attr_reader :agent, :provider, :stream,
                 :status, :buffer, :input,
@@ -42,7 +43,7 @@ module LLM
     #  Zero or more tools
     # @param [Array<String>] skills
     #  Zero or more skills
-    # @return [LLM::Repl]
+    # @return [LLM::Console]
     def initialize(agent:, name: nil, tools: [], skills: [], path: nil)
       @path = path
       @name = name || "agent"
@@ -114,7 +115,7 @@ module LLM
     # @param [String] chars
     # @return [Array<Node>]
     def markdown(chars)
-      LLM::Repl::Markdown.new(chars, buffer.width).ast
+      LLM::Console::Markdown.new(chars, buffer.width).ast
     end
 
     ##
@@ -216,9 +217,15 @@ module LLM
         write_message(sender, markdown(text))
         @thread = Thread.new do
           @queue << [:start]
-          agent.talk(text, model:, tools:, stream:)
-          agent.save(path:) if save?
-          @queue << [:done]
+          res = agent.talk(text, model:, tools:, stream:)
+          @queue << [:done, res.content]
+          ##
+          # When LLM::Interrupt is raised
+          # on this thread enqueue the raise
+          # so that the file write is protected
+          # from an immediate cancel.
+          int = {LLM::Interrupt => :never}
+          Thread.handle_interrupt(int) { agent.save(path:) if save? }
         rescue LLM::Interrupt => e
           @queue << [:cancel, e]
         rescue => e
@@ -264,6 +271,7 @@ module LLM
     # to by a subclass of {LLM::Stream LLM::Stream}.
     # @api private
     def read!
+      burst, max_burst = 0, 4
       loop do
         type, value = @queue.pop(true)
         case type
@@ -271,12 +279,20 @@ module LLM
           buffer.open
           stream.clear
         when :stream
+          ##
+          # A fast model can push many small chunks faster than the
+          # UI can repaint. Cap the stream chunks drained per call so
+          # read! gives control back to the key loop: leftover chunks
+          # stay queued and are drained by the next read!.
           status.text = think_text if stream.tools.empty?
           write_message name, markdown(value), method: :replace
+          burst += 1
+          break if burst >= max_burst
         when :status
           self.status = value
         when :done
           status.text = "idle"
+          write_message name, markdown(value), method: :replace
           buffer.close
           @thread = nil
         when :cancel
@@ -312,4 +328,8 @@ module LLM
     File = ::File
     private_constant :File
   end
+
+  ##
+  # Alias: LLM::Repl
+  Repl = Console
 end

data/lib/llm/context/deserializer.rb

@@ -40,7 +40,8 @@ class LLM::Context
       usage = payload["usage"]
       reasoning_content = payload["reasoning_content"]
       compaction = payload["compaction"]
-      extra = {tool_calls:, original_tool_calls:, tools: @params[:tools], usage:, reasoning_content:, compaction:}.compact
+      created_at = payload["created_at"]
+      extra = {tool_calls:, original_tool_calls:, tools: @params[:tools], usage:, reasoning_content:, compaction:, created_at:}.compact
       content = returns.nil? ? deserialize_content(payload["content"]) : returns
       LLM::Message.new(payload["role"], content, extra)
     end

data/lib/llm/context.rb

@@ -39,6 +39,15 @@ module LLM
     include Serializer
     include Deserializer
 
+    TRY_ERRORS = [
+      "LLM::InsufficientQuotaError",
+      "LLM::RateLimitError",
+      "Net::ReadTimeout",
+      "Net::WriteTimeout",
+      "Net::OpenTimeout"
+    ]
+    private_constant :TRY_ERRORS
+
     ##
     # Returns the set of runtime parameters that
     # configure this context and must never be forwarded
@@ -476,7 +485,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 +568,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/async/reactor.rb

@@ -25,24 +25,43 @@ module LLM::Function::Async
 
     ##
     # Stop the reactor and wait for the thread to finish.
+    # @return [nil]
     def stop
       @inbox << :stop
       @thread.join(5)
       @thread.kill if @thread.alive?
+      nil
     end
 
     private
 
+    ##
+    # Run the loop until a `:stop`, then tear down. Stopping
+    # cancels running children, running their ensure blocks,
+    # so #run returns promptly.
+    #
+    # Detach the scheduler before this thread exits. Left
+    # attached, Ruby calls scheduler_close on thread death,
+    # and its cancel path sends a non-Exception cause: through
+    # io-event's C #raise (not keyword-aware) into
+    # rb_fiber_raise, which on Ruby 4.0 raises TypeError
+    # (upstream async/io-event bug, not ours).
+    # @return [nil]
     def run
       reactor = ::Async::Reactor.new
       reactor.async do
         loop do
           work = @inbox.pop
-          break if work == :stop
+          if work == :stop
+            reactor.stop
+            break
+          end
           reactor.async { work.call }
         end
       end
       reactor.run
+    ensure
+      ::Fiber.set_scheduler(nil)
     end
   end
 end

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/function.rb

@@ -273,7 +273,7 @@ class LLM::Function
     when :fiber
       Fiber::Task.new(self, options)
     when :fork
-      LLM.require "xchan", "~> 0.22" unless defined?(::Chan::UNIXSocket)
+      LLM.require "xchan", "~> 0.23" unless defined?(::Chan::UNIXSocket)
       Fork::Task.new(self, options.merge(tracer: @tracer))
     when :ractor
       raise LLM::RactorError, "Ractor concurrency only supports class-based tools" unless Class === @runner

data/lib/llm/json_adapter.rb

@@ -26,6 +26,44 @@ module LLM
     # @return [Exception]
     #  Returns the error raised when parsing fails
     def self.parser_error = [StandardError]
+
+    ##
+    # JSON must be UTF-8 per spec, so a compliant adapter
+    # scrubs the strings it serializes. Walks +obj+ and
+    # encodes every string found into a valid UTF-8 string,
+    # replacing any invalid bytes. Adapters should call this
+    # from their +dump+ before handing the object to the
+    # underlying library.
+    # @param [Object] obj
+    # @return [Object]
+    #  The object with every string normalized to valid UTF-8
+    def self.normalize(obj)
+      case obj
+      when String then normalize_string(obj)
+      when Array then obj.map { normalize(_1) }
+      when Hash then obj.map { [_1, normalize(_2)] }.to_h
+      when LLM::Object then obj.map { [_1, normalize(_2)] }.to_h
+      else obj
+      end
+    end
+    private_class_method :normalize
+
+    ##
+    # Normalizes a single string as a valid UTF-8 string that is
+    # compatible with the JSON spec. BINARY-encoded strings are
+    # read as UTF-8 and scrubbed when invalid; every other encoding
+    # is transcoded to UTF-8, replacing invalid or undefined bytes.
+    # @param [String] str
+    # @return [String]
+    def self.normalize_string(str)
+      if str.encoding == Encoding::BINARY
+        str = (+str).force_encoding("UTF-8")
+        str.valid_encoding? ? str : str.scrub
+      else
+        str.encode("UTF-8", invalid: :replace, undef: :replace)
+      end
+    end
+    private_class_method :normalize_string
   end
 
   ##
@@ -59,32 +97,6 @@ module LLM
       require "json" unless defined?(::JSON)
       [::JSON::ParserError]
     end
-
-    ##
-    # JSON 3.0 compat
-    # Walks `obj` and encodes every string that is
-    # found into a UTF-8 compatible string.
-    def self.normalize(obj)
-      case obj
-      when String then normalize_string(obj)
-      when Array then obj.map { normalize(_1) }
-      when Hash then obj.map { [_1, normalize(_2)] }.to_h
-      when LLM::Object then obj.map { [_1, normalize(_2)] }.to_h
-      else obj
-      end
-    end
-    private_class_method :normalize
-
-    ##
-    # JSON 3.0 compat
-    # Normalizes a string as a UTF-8 encoded string
-    # that's compatible with the JSON spec.
-    def self.normalize_string(str)
-      return str if str.encoding == Encoding::UTF_8
-      str = (+str).force_encoding("UTF-8")
-      str.valid_encoding? ? str : str.scrub
-    end
-    private_class_method :normalize_string
   end
 
   ##
@@ -95,7 +107,7 @@ module LLM
     # @return (see JSONAdapter#dump)
     def self.dump(obj, options = {})
       require "oj" unless defined?(::Oj)
-      ::Oj.dump(obj, options.merge(mode: :compat))
+      ::Oj.dump(normalize(obj), options.merge(mode: :compat))
     end
 
     ##
@@ -121,7 +133,7 @@ module LLM
     # @return (see JSONAdapter#dump)
     def self.dump(obj, ...)
       require "yajl" unless defined?(::Yajl)
-      ::Yajl::Encoder.encode(obj, ...)
+      ::Yajl::Encoder.encode(normalize(obj), ...)
     end
 
     ##

data/lib/llm/message.rb

@@ -17,6 +17,11 @@ module LLM
     # @return [Hash]
     attr_reader :extra
 
+    ##
+    # Returns the time the message was created
+    # @return [Time]
+    attr_reader :created_at
+
     ##
     # Returns a new message
     # @param [Symbol] role
@@ -27,6 +32,7 @@ module LLM
       @role = role.to_s
       @content = content
       @extra = LLM::Object.from(extra)
+      @created_at = extra[:created_at] ? Time.iso8601(extra[:created_at].to_s) : Time.now.utc
     end
 
     ##
@@ -37,6 +43,7 @@ module LLM
         role:,
         content:,
         reasoning_content:,
+        created_at: created_at.utc.iso8601,
         compaction: extra.compaction,
         tools: extra.tool_calls&.map { LLM::Object === _1 ? _1.to_h : _1 },
         usage:,

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
@@ -337,7 +358,7 @@ class LLM::Provider
   # whenever no scoped override is active.
   # @example
   #   llm = LLM.openai(key: ENV["KEY"])
-  #   llm.tracer = LLM::Tracer::Logger.new(llm, path: "/path/to/log.txt")
+  #   llm.tracer = LLM::Tracer.logger(llm, path: "/path/to/log.txt")
   # @param [LLM::Tracer] tracer
   #  A tracer
   # @return [void]
@@ -350,7 +371,7 @@ class LLM::Provider
   # This is useful when you want per-request or per-turn tracing without
   # replacing the provider's default tracer.
   # @example
-  #   llm.with_tracer(LLM::Tracer::Logger.new(llm, io: $stdout)) do
+  #   llm.with_tracer(LLM::Tracer.logger(llm, io: $stdout)) do
   #     llm.complete("hello", model: "gpt-5.4-mini")
   #   end
   # @param [LLM::Tracer] tracer
@@ -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/alibaba.rb

@@ -11,7 +11,7 @@ module LLM
   #
   # The default host is the pay-as-you-go DashScope
   # international endpoint (`dashscope-intl.aliyuncs.com`). Configure
-  # a different host either globally through the `ALIBABA_API_HOST`
+  # a different host either globally through the `DASHSCOPE_API_HOST`
   # environment variable, or per instance through
   # `LLM.alibaba(host: "token-plan.ap-southeast-1.maas.aliyuncs.com")`
   # (for example Alibaba's Token Plan).

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