llm_logs 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c131b25cf1499cbebd755808d206f17e7c4dc4199fe18a7d282cabef947b349f
-  data.tar.gz: fadedd362588224fad8fc191dc6f9a3ee4d65746ed1d86f239b37e228b448606
+  metadata.gz: 5d03f4e8b8e5607855655d0d756f0c906395e42e808d3bfe255ced558a639d5e
+  data.tar.gz: bb172cb33c5d864ec6dde523cfe64e14c9fe4783a0a4b9c3e856dc58717b0cb3
 SHA512:
-  metadata.gz: d94d3962f820cce448da3171f364eeaea2995a707a8fd79e863fae6b9889db321e0ccf6bcead6f12ac48aa50709178e5c8dc2de858db6e111aa4be8ba7bc5cce
-  data.tar.gz: 8237d89556f129e2010ee04229d85f2ebe03d3bd11ad7799e1150a3d7c88134c1b4c63fe54e8555f9a3e53b1119e604332b184bb787c9586d87559db26453343
+  metadata.gz: 904aefd977972ab4bb67534972656d9abd55b3d4120c2ed99f961b661b5dfc9c1d2f7861d1afe9b74b8b6f175d86d9a5315ac2a468488ae58f23e737ef8d7c4c
+  data.tar.gz: 3e8e0f902575f2e2cbaf656965267343bf2124f781de41c036fe426d1bb6382551bbaede74f5f794ab52cdcaedba858c8adc6452554728ffbcf28786ccd0f53a

data/README.md

@@ -335,28 +335,18 @@ end
 
 With `auto_instrument` on, LlmLogs subscribes to ruby_llm's `chat.ruby_llm` and `tool_call.ruby_llm` notifications: one `llm` span per provider round and one tool span per tool call, all siblings under the trace. Tokens and cost come from each round's usage entries. This requires `RubyLLM.config.instrumenter` to be `ActiveSupport::Notifications`; the Railtie sets that default, and `LlmLogs::Instrumentation::RubyLlmChat.install!` sets it when unset.
 
-### Patches for ruby_llm 2.0.x
+### Bedrock fixes in ruby_llm
 
-The engine prepends five fixes (`LlmLogs::RubyLLMPatches`) that ruby_llm 2.0.0 lacks. Each one backports an upstream pull request, so dropping it once a ruby_llm release includes that PR changes no behaviour (exceptions are noted). They install only on ruby_llm >= 2.0.0, and log a warning on 2.1 or later so you re-check them.
+llm_logs no longer patches ruby_llm. The Bedrock bugs it used to patch are fixed in ruby_llm 2.1: [crmne/ruby_llm#1024](https://github.com/crmne/ruby_llm/pull/1024) (re-sign each attempt, retry TLS errors), [#1025](https://github.com/crmne/ruby_llm/pull/1025) (`reasoning_config` for GPT, adaptive thinking for adaptive-only Claude) and [ab4a4f06](https://github.com/crmne/ruby_llm/commit/ab4a4f060fc4760053105b92500c042c52c3d968) (reasoning replays only to the model that produced it). llm_logs 0.7.0 requires ruby_llm 2.1 or later. Two behaviours differ from the old patches:
 
-| Patch | Upstream PR |
-|---|---|
-| BedrockSigV4, RetrySSLError | [crmne/ruby_llm#1024](https://github.com/crmne/ruby_llm/pull/1024) |
-| ConverseReasoningConfig, ConverseClaudeAdaptiveThinking | [crmne/ruby_llm#1025](https://github.com/crmne/ruby_llm/pull/1025) |
-| ConverseForeignReasoning | [crmne/ruby_llm#1026](https://github.com/crmne/ruby_llm/pull/1026) |
-
-- **BedrockSigV4** ([#1024](https://github.com/crmne/ruby_llm/pull/1024), "Sign each Bedrock attempt when it is sent") re-signs every Bedrock attempt at send time, over the body being sent, and removes an `X-Amz-Security-Token` the new signature no longer carries. Upstream 2.0.0 signs once before the retry middleware, so a retry after a long timeout replays an expired signature (403 "Signature expired"). Drop when a ruby_llm release includes #1024.
-- **RetrySSLError** ([#1024](https://github.com/crmne/ruby_llm/pull/1024), "Retry requests that fail with a TLS error") adds `Faraday::SSLError` (for example "SSL_connect ... unexpected eof") to the retried exceptions. This is the same trade-off ruby_llm already accepts for read timeouts: a request that reached the server may be sent twice. ruby_llm's `retry_if` still refuses to retry requests marked non-idempotent and streams that already delivered content. Drop when a ruby_llm release includes #1024.
-- **ConverseReasoningConfig** ([#1025](https://github.com/crmne/ruby_llm/pull/1025), "Send reasoning_config to models that publish it") sends a reasoning effort on Bedrock Converse as `additionalModelRequestFields: {reasoning_config: "<effort>"}` (including `none`, which is also what `with_thinking(false)` resolves to for these models) when the model's Converse `additionalRequestFieldsSchema`, or that of another registry entry for the same foundation model, publishes a `reasoning_config` enum (OpenAI GPT 5.6/6 Astra, xAI Grok 4.6, ...). Upstream 2.0.0 sends `reasoning_effort`, which Bedrock rejects for GPT (400 unknown_parameter). Thinking turned off, budgets, Claude, Nova, and gpt-oss are unchanged. Beyond #1025, OpenAI GPT ids with no published schema (ruby_llm 2.0.0's registry lacks GPT-6 Sol/Luna) get the same shape, under any region prefix. Drop when a ruby_llm release includes #1025; that fallback goes with it, so first check that the registry you run publishes the schema for every GPT id you use (or add `metadata.converse.additionalRequestFieldsSchema` to your catalog entry), or those ids go back to `reasoning_effort`.
-- **ConverseClaudeAdaptiveThinking** ([#1025](https://github.com/crmne/ruby_llm/pull/1025), "Think adaptively on adaptive-only Claude via Converse") sends adaptive thinking to adaptive-only Claude models on Bedrock Converse (the registry advertises an `effort` option and no `budget_tokens` option: Sonnet 5, Opus 4.7/4.8/5, Fable 5) as `additionalModelRequestFields: {thinking: {type: "adaptive"}, output_config: {effort: ...}}` (every advertised tier, `xhigh` and `max` included; `{thinking: {type: "adaptive"}}` alone when no effort is set, as for `with_thinking(true)` or a `display` alone; nothing for `none`; no `display` is sent). Upstream 2.0.0 sends a fixed `reasoning_config` budget, which these models reject ("thinking.type.enabled" is not supported for this model). Any budget, thinking turned off, budget-style Claude (Haiku 4.5, Sonnet 4.6), and other vendors are unchanged. An unregistered id takes its reasoning options from a registry entry for the same foundation model. Drop when a ruby_llm release includes #1025.
-- **ConverseForeignReasoning** ([#1026](https://github.com/crmne/ruby_llm/pull/1026), "Drop Bedrock reasoning another model family produced" and "Give application inference profiles no vendor") replays a message's reasoning only to a model of the same family on Bedrock Converse. Upstream 2.0.0 replays every assistant message's reasoning to whatever model is next, and Claude and GPT are both the `bedrock` provider: a chat Claude answered and GPT continues fails with "This model doesn't support the reasoningContent.reasoningText.text field", and a chat GPT answered and Claude continues hands Claude GPT's encrypted reasoning. A model's family is `anthropic`, `openai`, or the vendor segment of any other Bedrock id (`amazon`, `meta`, ...), whatever its region prefix; an application inference profile ARN names no family, even with a dot in its id (`.../application-inference-profile/team.prod`). The producer is `RubyLLM::Message#model` (for a persisted message, the model of its last successful usage entry). Reasoning from another family is dropped. Anthropic targets otherwise get upstream's replay unchanged, and so does a target that names no family. **This patch is stricter than #1026 on purpose:** a non-Anthropic target whose producer is unknown or of the same family gets only the `redactedContent` blocks stored in `raw_reasoning["converse"]` (GPT's own encrypted reasoning across tool-call rounds), never `reasoningText` or the thinking text/signature fallback, where #1026 replays them all. Drop when a ruby_llm release includes #1026, accepting that looser replay (or keep the stricter rule as a patch of its own).
-
-Not backported: #1025's first commit ("Recognise the in. Bedrock inference profile prefix"), which adds `in` to `Converse::REGION_PREFIXES` and also changes region rewriting and Mantle routing. The patches here match ids under any region prefix instead.
+- GPT effort goes out as `reasoning_config` only when the model's registry entry publishes that schema. ruby_llm's registry does for the GPT-6 and GPT-5.6 ids; a catalog entry of your own for a GPT id needs `metadata.converse.additionalRequestFieldsSchema`, or the effort goes out as `reasoning_effort`, which Bedrock rejects.
+- Reasoning replays only to the exact model that produced it, not to any model of the same family.
 
 ## Requirements
 
 - Rails 8.0+
 - Ruby 3.3+
+- ruby_llm 2.1+
 - PostgreSQL
 
 ## License

data/lib/llm_logs/engine.rb

@@ -11,15 +11,6 @@ module LlmLogs
       end
     end
 
-    # Bedrock fixes missing from upstream ruby_llm 2.0.0. Installed whether or not
-    # auto-instrumentation is on: they change request behaviour, not logging.
-    initializer "llm_logs.ruby_llm_patches" do
-      if defined?(RubyLLM::VERSION)
-        require "llm_logs/ruby_llm_patches"
-        LlmLogs::RubyLLMPatches.install!
-      end
-    end
-
     rake_tasks do
       load File.expand_path("../tasks/llm_logs.rake", __dir__)
     end

data/lib/llm_logs/version.rb

@@ -1,3 +1,3 @@
 module LlmLogs
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_logs
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Anton
@@ -99,7 +99,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
@@ -109,7 +109,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '2.1'
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
@@ -241,12 +241,6 @@ files:
 - lib/llm_logs/engine.rb
 - lib/llm_logs/instrumentation/ruby_llm_chat.rb
 - lib/llm_logs/prompt_renderer.rb
-- lib/llm_logs/ruby_llm_patches.rb
-- lib/llm_logs/ruby_llm_patches/bedrock_sigv4.rb
-- lib/llm_logs/ruby_llm_patches/converse_claude_adaptive_thinking.rb
-- lib/llm_logs/ruby_llm_patches/converse_foreign_reasoning.rb
-- lib/llm_logs/ruby_llm_patches/converse_reasoning_config.rb
-- lib/llm_logs/ruby_llm_patches/retry_ssl_error.rb
 - lib/llm_logs/tracer.rb
 - lib/llm_logs/version.rb
 - lib/tasks/llm_logs.rake

data/lib/llm_logs/ruby_llm_patches/bedrock_sigv4.rb

@@ -1,75 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

data/lib/llm_logs/ruby_llm_patches.rb

@@ -1,54 +0,0 @@
-require "llm_logs/ruby_llm_patches/bedrock_sigv4"
-require "llm_logs/ruby_llm_patches/converse_reasoning_config"
-require "llm_logs/ruby_llm_patches/converse_foreign_reasoning"
-require "llm_logs/ruby_llm_patches/converse_claude_adaptive_thinking"
-require "llm_logs/ruby_llm_patches/retry_ssl_error"
-
-module LlmLogs
-  # Bedrock fixes that upstream ruby_llm 2.0.0 lacks, applied with Module#prepend. Each
-  # backports an open upstream PR (crmne/ruby_llm#1024, #1025, #1026; see the README), so it
-  # can be dropped once a ruby_llm release includes that PR.
-  # Each was verified against 2.0.x only: on 1.x they are skipped (different internals),
-  # on a newer ruby_llm they still install but log a warning so we re-check whether
-  # upstream fixed the bug (then drop the patch) or moved the method (then the patch
-  # skips itself and logs why).
-  module RubyLLMPatches
-    PATCHES = [
-      BedrockSigV4, ConverseReasoningConfig, ConverseForeignReasoning, ConverseClaudeAdaptiveThinking, RetrySSLError
-    ].freeze
-    MINIMUM = Gem::Version.new("2.0.0")
-    VERIFIED = Gem::Requirement.new(">= 2.0.0", "< 2.1")
-
-    module_function
-
-    def install!
-      version = Gem::Version.new(RubyLLM::VERSION)
-      return [] if version < MINIMUM
-
-      unless VERIFIED.satisfied_by?(version)
-        warn_log("verified against ruby_llm #{VERIFIED}, running #{version}: check whether upstream " \
-                 "now fixes #{PATCHES.map(&:name).join(', ')} and drop the patches it does")
-      end
-      PATCHES.select(&:install!)
-    end
-
-    def warn_log(message)
-      logger = defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
-      logger ? logger.warn("[llm_logs] #{message}") : Kernel.warn("[llm_logs] #{message}")
-    end
-
-    # Prepends +patch+ to +target+ when +target+ still defines every method in +methods+.
-    def prepend_checked(target, patch, methods)
-      return true if target <= patch
-
-      missing = methods.reject { |name| target.method_defined?(name) || target.private_method_defined?(name) }
-      if missing.any?
-        warn_log("#{patch.name} not installed: #{target} no longer defines #{missing.join(', ')}")
-        return false
-      end
-
-      target.prepend(patch)
-      true
-    end
-  end
-end