llm_logs 0.4.1 → 0.6.0

data/lib/llm_logs/instrumentation/ruby_llm_chat.rb

@@ -1,105 +1,213 @@
 module LlmLogs
   module Instrumentation
+    # Records RubyLLM 2.x chat activity as llm_logs spans by subscribing to the
+    # events RubyLLM emits for observability adapters (docs/_advanced/instrumentation.md):
+    #
+    #   chat.ruby_llm      -- one per model request (RubyLLM::Chat#generate_once): an "llm" span
+    #                         per provider round. Wraps every transport retry of that round, so a
+    #                         round that fails after its retries surfaces as :exception_object.
+    #                         With fallbacks, each model tried gets its own span.
+    #   tool_call.ruby_llm -- one per local tool execution (RubyLLM::Chat#execute_tool): a "tool" span.
+    #
+    # Rounds and tools are siblings under the current span/trace:
+    #   trace -> llm (round 1, asks for a tool) -> tool.x -> llm (round 2, final answer)
+    #
+    # The subscription is global (every RubyLLM::Chat, including acts_as_chat's to_llm and
+    # RubyLLM::Agent), but only fires while RubyLLM's instrumenter is ActiveSupport::Notifications,
+    # which RubyLLM's Railtie sets by default.
     module RubyLlmChat
-      def complete(&block)
-        return super unless LlmLogs.enabled?
-
-        span = LlmLogs::Tracer.start_span(
-          name: "chat.complete",
-          span_type: "llm",
-          model: @model&.id,
-          provider: @model&.provider,
-          input: messages.map { |m| { role: m.role, content: llm_logs_serialize_content(m.content) } }
-        )
-
-        messages_before = messages.size
-
-        begin
-          result = super(&block)
-          span.record_response(result)
-          span.cost = llm_logs_compute_cost(result)
-          result
-        rescue => e
-          span.record_error(e)
-          llm_logs_capture_partial_tokens(span, messages_before)
-          raise
-        ensure
-          span.finish
+      SPAN_KEY = :llm_logs_span
+      USAGE_START_KEY = :llm_logs_usage_start
+
+      class << self
+        def install!
+          return if installed?
+
+          RubyLLM.config.instrumenter ||= ActiveSupport::Notifications
+          @subscribers = [
+            ActiveSupport::Notifications.subscribe("chat.ruby_llm", ChatSubscriber.new),
+            ActiveSupport::Notifications.subscribe("tool_call.ruby_llm", ToolSubscriber.new)
+          ]
         end
-      end
 
-      private
+        def uninstall!
+          Array(@subscribers).each { |subscriber| ActiveSupport::Notifications.unsubscribe(subscriber) }
+          @subscribers = nil
+        end
 
-      def llm_logs_serialize_content(content)
-        content.is_a?(Hash) || content.is_a?(Array) ? content.to_json : content.to_s
-      end
+        def installed?
+          !@subscribers.nil?
+        end
 
-      def llm_logs_serialize_tool_result(result)
-        if result.is_a?(Hash)
-          result
-        elsif defined?(RubyLLM::Tool::Halt) && result.is_a?(RubyLLM::Tool::Halt)
-          { halted: result.message }
-        else
-          { result: result.to_s }
+        # Instrumentation must never break the LLM call it observes. ActiveSupport re-raises
+        # subscriber exceptions into the instrumented block, so every hook rescues.
+        def guard
+          yield
+        rescue StandardError => e
+          Rails.logger&.error("[llm_logs] instrumentation error: #{e.class}: #{e.message}")
+          nil
         end
       end
 
-      def llm_logs_capture_partial_tokens(span, messages_before)
-        assistant_msg = messages[messages_before..].find { |m| m.role == :assistant }
-        return unless assistant_msg&.input_tokens
+      # Serializers shared by both subscribers.
+      module Serialize
+        module_function
 
-        span.input_tokens = assistant_msg.input_tokens
-        span.output_tokens = assistant_msg.output_tokens
-        span.cached_tokens = assistant_msg.cached_tokens
-        span.cost = llm_logs_compute_cost(assistant_msg)
-      rescue StandardError
-        nil
-      end
+        def messages(list)
+          Array(list).map { |message| message_entry(message) }
+        end
+
+        def message_entry(message)
+          entry = {role: message.role, content: message.content}
+          calls = tool_calls(message.tool_calls)
+          entry[:tool_calls] = calls if calls
+          entry[:tool_call_id] = message.tool_call_id if message.tool_call_id
+          entry
+        end
+
+        def tool_calls(calls)
+          return nil if calls.nil? || calls.empty?
+
+          calls.values.map { |call| {id: call.id, name: call.name, arguments: call.arguments} }
+        end
 
-      def llm_logs_compute_cost(message)
-        model_info = llm_logs_resolve_pricing_model
-        return unless model_info
+        # Structured (schema) answers are JSON text in 2.x; store the parsed Hash so the
+        # UI renders nested fields instead of an escaped string.
+        def response(message, schema:)
+          content = message.content
+          content = parse_json(content) if schema && content.is_a?(String) && !content.empty?
+          output = {content: content}
+          calls = tool_calls(message.tool_calls)
+          output[:tool_calls] = calls if calls
+          output[:thinking] = message.thinking.text if message.thinking&.text.present?
+          output
+        end
 
-        input_price = model_info.input_price_per_million
-        output_price = model_info.output_price_per_million
-        return unless input_price && output_price
+        def parse_json(text)
+          JSON.parse(text)
+        rescue JSON::ParserError
+          text
+        end
 
-        (message.input_tokens.to_f * input_price + message.output_tokens.to_f * output_price) / 1_000_000
+        def tool_result(result)
+          case result
+          when Hash then result
+          when Array then {result: result}
+          else {result: result.to_s}
+          end
+        end
       end
 
-      def llm_logs_resolve_pricing_model
-        return @model if @model&.input_price_per_million
+      class ChatSubscriber
+        def start(_name, _id, payload)
+          RubyLlmChat.guard do
+            next unless LlmLogs.enabled?
+
+            chat = payload[:chat]
+            payload[USAGE_START_KEY] = chat.usage_entries.length if chat.respond_to?(:usage_entries)
+            payload[SPAN_KEY] = LlmLogs::Tracer.start_span(
+              name: "chat.complete",
+              span_type: "llm",
+              model: payload[:model],
+              provider: payload[:provider],
+              input: Serialize.messages(payload[:input_messages]),
+              metadata: request_metadata(payload)
+            )
+          end
+        end
 
-        RubyLLM.models.find(@model.id) if @model&.id
-      rescue StandardError
-        nil
+        def finish(_name, _id, payload)
+          span = payload.delete(SPAN_KEY)
+          return unless span
+
+          RubyLlmChat.guard do
+            if (error = payload[:exception_object])
+              span.record_error(error)
+            else
+              span.output = Serialize.response(payload[:response], schema: payload[:schema])
+              span.set_attribute("finish_reason", payload[:response].finish_reason&.to_s)
+              response_model = payload[:response_model]
+              span.set_attribute("response_model", response_model) if response_model && response_model != payload[:model]
+            end
+            record_usage(span, payload)
+          end
+        ensure
+          RubyLlmChat.guard { span&.finish }
+        end
+
+        private
+
+        def request_metadata(payload)
+          {
+            "streaming" => payload[:streaming],
+            "tools" => Array(payload[:tools]).map(&:to_s),
+            "temperature" => payload[:temperature],
+            "thinking" => thinking_metadata(payload[:thinking]),
+            "schema" => payload[:schema] && payload[:schema][:name]
+          }.compact
+        end
+
+        def thinking_metadata(thinking)
+          return nil unless thinking
+
+          {"effort" => thinking.effort&.to_s, "budget" => thinking.budget, "enabled" => thinking.enabled}.compact.presence
+        end
+
+        # Tokens and cost of every transport attempt this round made (retries included), read
+        # from the chat's usage ledger. Falls back to the event's tokens/cost when the ledger is
+        # unavailable. A failed attempt whose usage is unknown (e.g. a timeout that may have
+        # been billed) is left out of the cost and flagged with cost_complete: false.
+        def record_usage(span, payload)
+          entries = round_usage_entries(payload)
+          if entries
+            tokens = RubyLLM::Tokens.aggregate(entries.map(&:tokens))
+            cost = RubyLLM::Cost.aggregate(entries.map(&:cost))
+            span.set_attribute("attempts", entries.size) if entries.size > 1
+            span.set_attribute("cost_complete", false) unless entries.all?(&:cost_available?)
+          else
+            tokens = payload[:tokens]
+            cost = payload[:cost]
+          end
+          span.record_tokens(tokens)
+          span.cost = cost&.total
+        end
+
+        def round_usage_entries(payload)
+          start = payload[USAGE_START_KEY]
+          chat = payload[:chat]
+          return nil unless start && chat.respond_to?(:usage_entries)
+
+          chat.usage_entries.drop(start)
+        end
       end
 
-      public
-
-      def execute_tool(tool_call)
-        return super unless LlmLogs.enabled?
-
-        span = LlmLogs::Tracer.start_span(
-          name: "tool.#{tool_call.name}",
-          span_type: "tool",
-          input: tool_call.arguments,
-          metadata: { tool_name: tool_call.name }
-        )
-
-        begin
-          result = super
-          span.output = llm_logs_serialize_tool_result(result)
-          span.set_attribute("tool.halted", true) if defined?(RubyLLM::Tool::Halt) && result.is_a?(RubyLLM::Tool::Halt)
-          # Convert hash/array results to JSON so RubyLLM stores clean JSON
-          # in message content, not Ruby hash syntax from Hash#to_s
-          result = result.to_json if result.is_a?(Hash) || result.is_a?(Array)
-          result
-        rescue => e
-          span.record_error(e)
-          raise
+      class ToolSubscriber
+        def start(_name, _id, payload)
+          RubyLlmChat.guard do
+            next unless LlmLogs.enabled?
+
+            payload[SPAN_KEY] = LlmLogs::Tracer.start_span(
+              name: "tool.#{payload[:tool_name]}",
+              span_type: "tool",
+              input: payload[:tool_arguments],
+              metadata: {tool_name: payload[:tool_name].to_s, tool_call_id: payload[:tool_call_id]}.compact
+            )
+          end
+        end
+
+        def finish(_name, _id, payload)
+          span = payload.delete(SPAN_KEY)
+          return unless span
+
+          RubyLlmChat.guard do
+            if (error = payload[:exception_object])
+              span.record_error(error)
+            else
+              span.output = Serialize.tool_result(payload[:result])
+            end
+          end
         ensure
-          span.finish
+          RubyLlmChat.guard { span&.finish }
         end
       end
     end

data/lib/llm_logs/ruby_llm_patches/bedrock_sigv4.rb

@@ -0,0 +1,75 @@
+require "faraday"
+
+module LlmLogs
+  module RubyLLMPatches
+    # Signs every Bedrock attempt when it is sent.
+    # Backport of crmne/ruby_llm#1024 ("Sign each Bedrock attempt when it is sent").
+    #
+    # ruby_llm 2.0.0 signs inside the request block (Protocols::Converse#signed_post,
+    # Converse::Streaming#stream_response, InvokeModel, Mantle, Guardrails, Rerank, ...),
+    # i.e. once, before Faraday's retry middleware runs. A retry after a long timeout
+    # (request_timeout 300s vs SigV4's 5-minute window) then replays an expired
+    # X-Amz-Date/Authorization and AWS answers 403 "Signature expired", which is not retried.
+    #
+    # This adds a middleware innermost in every Bedrock Transport::Connection stack (after
+    # :retry and after the :json encoder), so each attempt is re-signed over the exact body
+    # bytes being sent, at send time. It only touches requests that already carry a SigV4
+    # Authorization header and keeps the signing service named in it (bedrock,
+    # bedrock-mantle, ...). Auth#signed_get/#signed_post (model listing, batch control
+    # endpoints) use Connection.basic, which has no retry, so they need no change.
+    module BedrockSigV4
+      class Middleware < Faraday::Middleware
+        CREDENTIAL = %r{\AAWS4-HMAC-SHA256 Credential=[^/]+/\d{8}/[^/]+/(?<service>[^/]+)/aws4_request}
+
+        def initialize(app, provider:)
+          super(app)
+          @provider = provider
+        end
+
+        def call(env)
+          resign(env)
+          @app.call(env)
+        end
+
+        private
+
+        def resign(env)
+          match = CREDENTIAL.match(env.request_headers["Authorization"].to_s)
+          return unless match
+
+          body = env.body.nil? ? "" : env.body
+          return unless body.is_a?(String) # multipart/IO bodies keep the original signature
+
+          url = env.url
+          path = url.query ? "#{url.path}?#{url.query}" : url.path
+          headers = @provider.sign_headers(
+            env.method.to_s.upcase, path, body,
+            base_url: "#{url.scheme}://#{url.host}", service: match[:service]
+          )
+          env.request_headers.delete("X-Amz-Security-Token") # credentials may have rotated
+          env.request_headers.merge!(headers.except("Content-Type"))
+        end
+      end
+
+      module ConnectionPatch
+        private
+
+        def setup_middleware(faraday)
+          super
+          faraday.use(Middleware, provider: @provider) if BedrockSigV4.bedrock?(@provider)
+        end
+      end
+
+      module_function
+
+      def bedrock?(provider)
+        defined?(RubyLLM::Providers::Bedrock) && provider.is_a?(RubyLLM::Providers::Bedrock) &&
+          provider.respond_to?(:sign_headers)
+      end
+
+      def install!
+        RubyLLMPatches.prepend_checked(RubyLLM::Transport::Connection, ConnectionPatch, %i[setup_middleware])
+      end
+    end
+  end
+end

data/lib/llm_logs/ruby_llm_patches/converse_claude_adaptive_thinking.rb

@@ -0,0 +1,70 @@
+module LlmLogs
+  module RubyLLMPatches
+    # Adaptive thinking for adaptive-only Claude models on Bedrock Converse.
+    # Backport of crmne/ruby_llm#1025 ("Think adaptively on adaptive-only Claude via Converse").
+    #
+    # ruby_llm 2.0.0 (Protocols::Converse::Chat#format_reasoning_fields) turns a Claude
+    # reasoning effort into a fixed budget, `additionalModelRequestFields: {reasoning_config:
+    # {type: "enabled", budget_tokens: N}}`, sized from the Converse budgetTokens schema.
+    # Claude models that only think adaptively (the registry advertises an effort option and
+    # no budget_tokens option: Sonnet 5, Opus 4.7/4.8/5, Fable 5) reject it with
+    # `"thinking.type.enabled" is not supported for this model. Use "thinking.type.adaptive"
+    # and "output_config.effort"`, and with_thinking(true) sends no thinking at all. They take
+    # `{thinking: {type: "adaptive"}, output_config: {effort: "low"}}`, the rule upstream's own
+    # Anthropic protocol already applies (Protocols::Anthropic::Chat#thinking_mode).
+    #
+    # For an adaptive-only Claude target with no budget set:
+    # - effort other than "none": adaptive thinking, effort in output_config (every advertised
+    #   tier, xhigh and max included);
+    # - no effort (with_thinking(true), or a display alone): adaptive thinking alone;
+    # - effort "none": nothing.
+    # No `display` is sent (Converse has no field for it). Everything else goes to super: any
+    # budget, thinking turned off (reasoning_config disabled), budget-style Claude (Haiku 4.5,
+    # Sonnet 4.6), GPT, Nova and other vendors.
+    #
+    # The target is Anthropic under any region prefix (ConverseForeignReasoning::ANTHROPIC).
+    # A model with no reasoning options of its own (an unregistered id, such as an "in."
+    # inference profile) takes them from a Bedrock registry entry for the same foundation model.
+    module ConverseClaudeAdaptiveThinking
+      ANTHROPIC = ConverseForeignReasoning::ANTHROPIC
+      REGION = /\A[a-z0-9-]+\.(?=anthropic\.)/
+
+      private
+
+      def format_reasoning_fields(thinking, model, max_output_tokens = nil)
+        return super unless thinking&.enabled? && thinking.enabled != false && thinking.budget.nil?
+        return super unless llm_logs_adaptive_only_claude?(model)
+
+        effort = thinking.effort.to_s
+        return nil if effort == "none"
+        return {thinking: {type: "adaptive"}} if effort.empty?
+
+        {thinking: {type: "adaptive"}, output_config: {effort: effort}}
+      end
+
+      def llm_logs_adaptive_only_claude?(model)
+        id = foundation_model_id(model&.id)
+        return false unless ANTHROPIC.match?(id)
+
+        options = llm_logs_reasoning_options(model, id.sub(REGION, ""))
+        options.any? { |o| o[:type] == "effort" } && options.none? { |o| o[:type] == "budget_tokens" }
+      end
+
+      def llm_logs_reasoning_options(model, bare_id)
+        return model.reasoning_options if model.reasoning_options.any?
+
+        sibling = RubyLLM.models.all.find do |candidate|
+          candidate.provider == "bedrock" && candidate.reasoning_options.any? &&
+            foundation_model_id(candidate.id).sub(REGION, "") == bare_id
+        end
+        sibling ? sibling.reasoning_options : []
+      end
+
+      def self.install!
+        RubyLLMPatches.prepend_checked(
+          RubyLLM::Protocols::Converse, self, %i[format_reasoning_fields foundation_model_id]
+        )
+      end
+    end
+  end
+end

data/lib/llm_logs/ruby_llm_patches/converse_foreign_reasoning.rb

@@ -0,0 +1,80 @@
+module LlmLogs
+  module RubyLLMPatches
+    # Bedrock Converse replays a message's reasoning only to a model of the same family.
+    # Backport of crmne/ruby_llm#1026, stricter than it on purpose (see below).
+    #
+    # ruby_llm 2.0.0 (Protocols::Converse::Chat#format_thinking_blocks) replays every assistant
+    # message's reasoning (raw_reasoning["converse"] blocks, else thinking text/signature) as
+    # reasoningContent whatever the target model. Upstream only strips thinking a *different
+    # provider* produced (Protocol#foreign_thinking?), and Claude and GPT are both "bedrock".
+    # So a chat Claude answered and GPT continues fails with 400 "This model doesn't support
+    # the reasoningContent.reasoningText.text field for assistant message", and a chat GPT
+    # answered and Claude continues hands Claude GPT's encrypted reasoning (redactedContent,
+    # or a reasoningText with an empty text and GPT's blob as signature for rows migrated from
+    # 1.16), which Claude cannot validate.
+    #
+    # The family of a model id is "anthropic", "openai", or the vendor segment of any other
+    # Bedrock id ("amazon", "meta", ...), whatever region prefix it carries. The producer is
+    # RubyLLM::Message#model (the reply's model, or for a restored row the model of its last
+    # successful ruby_llm_usages entry).
+    #
+    # - Producer known and of another family: no reasoning is replayed.
+    # - Anthropic target (same family or producer unknown): super, unchanged.
+    # - Other named-vendor target (same family or producer unknown): only the redactedContent
+    #   blocks in raw_reasoning["converse"] (how GPT keeps its own encrypted reasoning across
+    #   tool-call rounds); reasoningText and the thinking text/signature fallback are dropped.
+    # - Target whose id names no model (application-inference-profile ARN): super, unchanged.
+    #
+    # An application inference profile id is opaque, and AWS allows dots in it
+    # (".../application-inference-profile/team.prod"), so it names no family as producer or
+    # target (backport of crmne/ruby_llm#1026, "Give application inference profiles no vendor").
+    # The rest of this module is stricter than #1026 on purpose: for a non-Anthropic target
+    # whose producer is unknown or of the same family, upstream replays all the reasoning, while
+    # this keeps only redactedContent.
+    module ConverseForeignReasoning
+      ANTHROPIC = /(?:\A|\.)anthropic\./
+      OPENAI = /(?:\A|\.)openai\./
+      VENDOR = /\A[a-z0-9-]+(?=\.)/
+      APPLICATION_INFERENCE_PROFILE = ":application-inference-profile/"
+
+      private
+
+      def format_thinking_blocks(msg)
+        target = llm_logs_model_family(model&.id)
+        return super if target.nil?
+
+        producer = llm_logs_model_family(msg.model) if msg.respond_to?(:model)
+        return [] if producer && producer != target
+        return super if target == "anthropic"
+
+        blocks = msg.raw_reasoning["converse"] || msg.raw_reasoning[:converse] if msg.raw_reasoning.is_a?(Hash)
+        kept = Array(blocks).select { |block| llm_logs_redacted_only?(block) }
+        RubyLLM::Support::Utils.deep_dup(kept)
+      end
+
+      # "anthropic", "openai", another vendor segment, or nil when the id names no model.
+      def llm_logs_model_family(model_id)
+        return if model_id.to_s.include?(APPLICATION_INFERENCE_PROFILE)
+
+        id = foundation_model_id(model_id)
+        return "anthropic" if ANTHROPIC.match?(id)
+        return "openai" if OPENAI.match?(id)
+
+        id[VENDOR]
+      end
+
+      def llm_logs_redacted_only?(block)
+        content = block["reasoningContent"] || block[:reasoningContent] if block.is_a?(Hash)
+        return false unless content.is_a?(Hash)
+
+        content.keys.map(&:to_s) == ["redactedContent"]
+      end
+
+      def self.install!
+        RubyLLMPatches.prepend_checked(
+          RubyLLM::Protocols::Converse, self, %i[format_thinking_blocks foundation_model_id model]
+        )
+      end
+    end
+  end
+end

data/lib/llm_logs/ruby_llm_patches/converse_reasoning_config.rb

@@ -0,0 +1,78 @@
+require "json"
+
+module LlmLogs
+  module RubyLLMPatches
+    # Reasoning effort as the reasoning_config value on Bedrock Converse.
+    # Backport of crmne/ruby_llm#1025 ("Send reasoning_config to models that publish it").
+    #
+    # ruby_llm 2.0.0 (Protocols::Converse::Chat#format_reasoning_fields) sends the effort of a
+    # model without a reasoning-budget schema as `additionalModelRequestFields:
+    # {reasoning_effort: "low"}`, which Bedrock rejects for OpenAI GPT models (400
+    # unknown_parameter). Their Converse additionalRequestFieldsSchema publishes
+    # `{"reasoning_config": {"type": "enum", "enum": ["none", "low", ...]}}`, and they take the
+    # effort as that value: `{reasoning_config: "low"}` ("none" turns reasoning off).
+    #
+    # Upstream rule, applied as #1025 does: when the model's schema, or the schema of another
+    # Bedrock registry entry for the same foundation model, publishes that enum, an effort that
+    # would have become reasoning_effort becomes the reasoning_config value, "none" included.
+    # Thinking off (reasoning_config disabled), budgets (explicit, or from a budget schema),
+    # Nova (reasoningConfig) and an empty effort are unchanged.
+    #
+    # Fallback (not in #1025): OpenAI GPT ids with no published schema get the same shape. ruby_llm
+    # 2.0.0's packaged registry lacks GPT-6 Sol/Luna, and an app catalog that registers them
+    # without Converse metadata leaves them schema-less. The match is prefix-agnostic (upstream
+    # REGION_PREFIXES lacks "in." in 2.0.0) and skips gpt-oss, which publishes no such enum.
+    module ConverseReasoningConfig
+      OPENAI_GPT = /(?:\A|\.)openai\.gpt-(?!oss)/
+
+      private
+
+      def format_reasoning_fields(thinking, model, max_output_tokens = nil)
+        return super unless thinking&.enabled? && thinking.enabled != false
+        return super unless llm_logs_reasoning_config?(model)
+
+        effort = thinking.effort.to_s
+        return super if effort.empty? || nova_model?(model)
+        return super if reasoning_budget(thinking, effort, model, max_output_tokens)
+
+        {reasoning_config: effort}
+      end
+
+      def llm_logs_reasoning_config?(model)
+        return false unless model
+
+        llm_logs_reasoning_config_schema?(model) || OPENAI_GPT.match?(foundation_model_id(model.id))
+      end
+
+      # Bedrock publishes Converse metadata for only some regional entries of a model.
+      def llm_logs_reasoning_config_schema?(model)
+        return true if llm_logs_publishes_reasoning_config?(model)
+
+        foundation_id = foundation_model_id(model.id)
+        RubyLLM.models.all.any? do |candidate|
+          candidate.provider == "bedrock" && candidate.id != model.id &&
+            foundation_model_id(candidate.id) == foundation_id && llm_logs_publishes_reasoning_config?(candidate)
+        end
+      end
+
+      def llm_logs_publishes_reasoning_config?(model)
+        metadata = RubyLLM::Support::Utils.deep_symbolize_keys(model.metadata || {})
+        raw_schema = metadata.dig(:converse, :additionalRequestFieldsSchema)
+        return false unless raw_schema.is_a?(String)
+
+        schema = JSON.parse(raw_schema, symbolize_names: true)
+        config = schema.is_a?(Hash) ? schema[:reasoning_config] : nil
+        config.is_a?(Hash) && config[:type] == "enum"
+      rescue JSON::ParserError
+        false
+      end
+
+      def self.install!
+        RubyLLMPatches.prepend_checked(
+          RubyLLM::Protocols::Converse, self,
+          %i[format_reasoning_fields foundation_model_id nova_model? reasoning_budget]
+        )
+      end
+    end
+  end
+end

data/lib/llm_logs/ruby_llm_patches/retry_ssl_error.rb

@@ -0,0 +1,25 @@
+require "faraday"
+
+module LlmLogs
+  module RubyLLMPatches
+    # Backport of crmne/ruby_llm#1024 ("Retry requests that fail with a TLS error").
+    # Retries TLS handshake failures (Faraday::SSLError, e.g. "SSL_connect ... unexpected
+    # eof"). faraday-net_http wraps every OpenSSL::SSL::SSLError as Faraday::SSLError, including
+    # read errors after the request was written, so this is the same trade-off ruby_llm
+    # already accepts for read timeouts. ruby_llm's retry_if (transport/connection.rb) still
+    # refuses non-idempotent requests and streams that already delivered content.
+    # Faraday::SSLError is not a Faraday::ConnectionFailed, so 2.0.0's retry list misses it.
+    module RetrySSLError
+      private
+
+      def retry_exceptions
+        exceptions = super
+        exceptions.include?(Faraday::SSLError) ? exceptions : exceptions + [Faraday::SSLError]
+      end
+
+      def self.install!
+        RubyLLMPatches.prepend_checked(RubyLLM::Transport::Connection, self, %i[retry_exceptions])
+      end
+    end
+  end
+end