llm_logs 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a687cddb64dc51d51cdf1bfa833833523b54194054ae32fe631354f187c9f256
-  data.tar.gz: ec0375795a8d27afa1266c1a8ebacd0984395fd8d41753c6ebd4c2658cfef026
+  metadata.gz: c131b25cf1499cbebd755808d206f17e7c4dc4199fe18a7d282cabef947b349f
+  data.tar.gz: fadedd362588224fad8fc191dc6f9a3ee4d65746ed1d86f239b37e228b448606
 SHA512:
-  metadata.gz: fe87b0ed824568ba3c1104e600fdc670a43919c5b061159a7e1e94bffe59257272b74914fd83256633236fd02da3b1ae99efd240ea8a6e645c93880e07d3a7af
-  data.tar.gz: 81986848eec310e3c2360ceecfbe894a58fc5836adc1a5a6832c90a2c60abbc72898521c6a7b44cf9a1aa118c0837aea861d2e919aeb4fd33b5d83c251e6b22d
+  metadata.gz: d94d3962f820cce448da3171f364eeaea2995a707a8fd79e863fae6b9889db321e0ccf6bcead6f12ac48aa50709178e5c8dc2de858db6e111aa4be8ba7bc5cce
+  data.tar.gz: 8237d89556f129e2010ee04229d85f2ebe03d3bd11ad7799e1150a3d7c88134c1b4c63fe54e8555f9a3e53b1119e604332b184bb787c9586d87559db26453343

data/README.md

@@ -209,16 +209,7 @@ Running the task creates missing prompts, updates metadata, and creates a new pr
 
 Send latency-insensitive requests through a provider's Batch API for roughly half the cost. LlmLogs persists each request, groups pending requests into a provider batch, reconciles results, and records a trace per request — so batched work shows up in the dashboard alongside synchronous calls.
 
-Two batch backends are supported, selected **per model**:
-
-- **[OpenAI Responses Batch API](https://platform.openai.com/docs/guides/batch)** via [`ruby_llm-responses_api`](https://rubygems.org/gems/ruby_llm-responses_api) — the default for OpenAI models.
-- **[AWS Bedrock Batch API](#aws-bedrock-batches)** (`CreateModelInvocationJob`) for Anthropic Claude models.
-
-Add the OpenAI provider to your app's Gemfile:
-
-```ruby
-gem "ruby_llm-responses_api"
-```
+Batching runs on the **[AWS Bedrock Batch API](#aws-bedrock-batches)** (`CreateModelInvocationJob`) for Anthropic Claude models. Models Bedrock does not serve are not batchable; run them synchronously.
 
 ### Enqueue a Request
 
@@ -227,10 +218,10 @@ Requests are persisted immediately and grouped by `purpose` + `model` when submi
 ```ruby
 LlmLogs::Batch.enqueue(
   purpose: "chat_summary",
-  model: "gpt-4.1-mini",
+  model: "anthropic.claude-haiku-4-5-20251001-v1:0",
   instructions: "Summarize the conversation in two sentences.",
   input: conversation_text,
-  schema: SummarySchema,          # optional RubyLLM::Schema for structured output
+  schema: SUMMARY_SCHEMA,          # optional JSON schema Hash for structured output
   routing: { conversation_id: 42 }, # your keys, echoed into the trace metadata
   temperature: 0.2                  # optional
 )
@@ -247,7 +238,8 @@ Register one handler per `purpose`. The gem owns the batch lifecycle; your app o
 LlmLogs.register_batch_handler("chat_summary", ChatSummaryHandler.new)
 
 class ChatSummaryHandler
-  # Called once a request succeeds. `message` is the RubyLLM::Message.
+  # Called once a request succeeds. `message` is a `LlmLogs::Batch::Adapters::Bedrock::Result`
+  # (content, input_tokens, output_tokens, model_id).
   def call(request, message)
     Conversation.find(request.routing["conversation_id"])
       .update!(summary: message.content)
@@ -302,7 +294,7 @@ LlmLogs.configuration.bedrock_batch = LlmLogs::Configuration::BedrockBatch.new(
 LlmLogs.register_batch_adapter(:bedrock, LlmLogs::Batch::Adapters::Bedrock.new)
 ```
 
-Provider selection is per model: `LlmLogs::Batch.batch_provider_for(model)` returns `:bedrock` when the adapter is registered and `model_matcher` matches, otherwise the OpenAI backend when the model resolves there, otherwise `nil` (not batchable — run it synchronously). Bedrock enforces a **minimum records per job**, so check `LlmLogs::Batch.min_records_for(model)` and fall back to a synchronous call when a batch would be under the floor.
+Provider selection is per model: `LlmLogs::Batch.batch_provider_for(model)` returns `:bedrock` when the adapter is registered and `model_matcher` matches, otherwise `nil` (not batchable — run it synchronously). Bedrock enforces a **minimum records per job**, so check `LlmLogs::Batch.min_records_for(model)` and fall back to a synchronous call when a batch would be under the floor.
 
 The adapter builds its AWS clients from the ambient credential chain by default; inject your own to authenticate explicitly:
 
@@ -330,16 +322,37 @@ Browse traces and manage prompts at `/llm_logs`.
 ```ruby
 LlmLogs.setup do |config|
   config.enabled = true                                      # master switch for logging
-  config.auto_instrument = true                              # auto-prepend on RubyLLM::Chat
+  config.auto_instrument = true                              # subscribe to ruby_llm notifications (needs RubyLLM.config.instrumenter = ActiveSupport::Notifications)
   config.retention_days = 30                                 # for future cleanup job
   config.prompts_source_path = Rails.root.join("db/data/prompts")
   config.prompt_subfolders = %w[skills fragments templates]
   config.batch_enabled = true                                # enable the batch API integration
-  config.batch_provider = :openai_responses                  # default (OpenAI) backend; Bedrock is registered separately (see Batches)
   config.page_size = 50                                      # rows per page on all index pages
 end
 ```
 
+## ruby_llm 2.0 integration
+
+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
+
+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.
+
+| 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.
+
 ## Requirements
 
 - Rails 8.0+

data/app/models/llm_logs/batch/submitter.rb

@@ -1,12 +1,13 @@
 module LlmLogs
   class Batch
-    # Groups pending BatchRequests of one purpose+model into a single OpenAI batch via
-    # ruby_llm-responses_api. To prevent two concurrent FlushJobs from double-submitting
-    # the same requests, it first CLAIMS the pending rows in a `FOR UPDATE SKIP LOCKED`
-    # transaction (assigning them to a placeholder Batch with no openai_batch_id, which
-    # flips them out of the `pending` scope and which PollJob ignores). It then submits to
-    # OpenAI and records the batch id. If submission fails, the claim is released (requests
-    # return to `pending`) and the placeholder batch is dropped, so the work retries next flush.
+    # Groups pending BatchRequests of one purpose+model into a single provider batch (Bedrock).
+    # To keep two concurrent FlushJobs from double-submitting the same requests, it first
+    # CLAIMS the pending rows in a `FOR UPDATE SKIP LOCKED` transaction, assigning them to a
+    # placeholder Batch with no provider batch id (stored in the legacy `openai_batch_id`
+    # column), which flips them out of the `pending` scope and which PollJob ignores. It then
+    # submits the batch and records its id. If submission fails, the claim is released
+    # (requests return to `pending`) and the placeholder batch is dropped, so the work retries
+    # on the next flush.
     class Submitter
       def initialize(purpose:, model:, metadata: {})
         @purpose = purpose

data/app/models/llm_logs/batch/trace_recorder.rb

@@ -27,23 +27,35 @@ module LlmLogs
             output: { "content" => span.serialize_content(message.content) },
             input_tokens: message.input_tokens,
             output_tokens: message.output_tokens,
-            cost: compute_cost(message)
+            cost: compute_cost(message, request: request, provider: provider)
           )
           span.finish
         end
         trace
       end
 
-      def compute_cost(message)
-        model_info = RubyLLM.models.find(message.model_id)
-        return nil unless model_info&.input_price_per_million && model_info&.output_price_per_million
+      # Prices the request at the submitted model's standard rates for this provider (the
+      # Bedrock id, e.g. us.anthropic.claude-haiku-4-5-...), falling back to the id the result
+      # reports (a native Anthropic id resolves to the anthropic provider's rates). nil when
+      # neither is in the registry or the registry has no price for the tokens used.
+      def compute_cost(message, request:, provider:)
+        model = pricing_model(request.model, provider) || pricing_model(message.model_id, nil)
+        return nil unless model
 
-        raw = (message.input_tokens.to_f * model_info.input_price_per_million +
-               message.output_tokens.to_f * model_info.output_price_per_million) / 1_000_000
-        (raw * BATCH_COST_MULTIPLIER).round(6)
+        tokens = RubyLLM::Tokens.new(input: message.input_tokens.to_i, output: message.output_tokens.to_i)
+        total = model.cost_for(tokens).total
+        total && (total * BATCH_COST_MULTIPLIER).round(6)
       rescue StandardError
         nil
       end
+
+      def pricing_model(model_id, provider)
+        return nil if model_id.blank?
+
+        provider.present? ? RubyLLM.models.find(model_id, provider: provider) : RubyLLM.models.find(model_id)
+      rescue RubyLLM::ModelNotFoundError
+        nil
+      end
     end
   end
 end

data/app/models/llm_logs/batch.rb

@@ -66,14 +66,10 @@ module LlmLogs
       !batch_provider_for(model).nil?
     end
 
-    # Which batch provider (if any) serves this model. Bedrock wins for Claude models when
-    # the Bedrock adapter is configured; otherwise fall back to the OpenAI provider when the
-    # model resolves there; otherwise nil (run synchronously).
+    # Which batch provider (if any) serves this model: :bedrock when the Bedrock adapter is
+    # registered and its model_matcher matches, otherwise nil (run synchronously).
     def self.batch_provider_for(model)
-      return :bedrock if bedrock_serves?(model)
-      return :openai_responses if openai_serves?(model)
-
-      nil
+      bedrock_serves?(model) ? :bedrock : nil
     end
 
     # The Bedrock minimum records-per-job floor for this model (0 when Bedrock does not serve it).
@@ -89,25 +85,5 @@ module LlmLogs
       matcher = config.model_matcher
       matcher.respond_to?(:call) ? matcher.call(model.to_s) : matcher.match?(model.to_s)
     end
-
-    def self.openai_serves?(model)
-      return false unless defined?(RubyLLM::Providers::OpenAIResponses)
-
-      servable_by_batch_provider?(model)
-    end
-
-    # The batch path submits via RubyLLM.batch(provider: batch_provider). A model is
-    # only batchable if that provider can actually serve it -- i.e. the model resolves
-    # under batch_provider. Models that belong to a different provider (e.g. Bedrock /
-    # Anthropic) don't resolve there, so they return false and the caller runs them
-    # synchronously instead of enqueueing work that would fail at submit time.
-    def self.servable_by_batch_provider?(model)
-      RubyLLM::Models.resolve(
-        model, provider: LlmLogs.batch_provider, assume_exists: false, config: RubyLLM.config
-      )
-      true
-    rescue RubyLLM::ModelNotFoundError
-      false
-    end
   end
 end

data/app/models/llm_logs/span.rb

@@ -19,11 +19,23 @@ module LlmLogs
       LlmLogs::Tracer.current_span = parent_span
     end
 
+    # +message+ is a RubyLLM 2.x Message (or anything with +content+ and +tokens+).
     def record_response(message)
       self.output = { content: serialize_content(message.content) }
-      self.input_tokens = message.input_tokens
-      self.output_tokens = message.output_tokens
-      self.cached_tokens = message.cached_tokens
+      record_tokens(message.tokens)
+    end
+
+    # Copies a RubyLLM::Tokens onto the span. +input+ is non-cached input (RubyLLM 2.x no
+    # longer subtracts cache buckets from it); cache writes and thinking have no column and
+    # go to metadata.
+    def record_tokens(tokens)
+      return unless tokens
+
+      self.input_tokens = tokens.input
+      self.output_tokens = tokens.output
+      self.cached_tokens = tokens.cache_read
+      set_attribute("cache_write_tokens", tokens.cache_write) unless tokens.cache_write.nil?
+      set_attribute("thinking_tokens", tokens.thinking) unless tokens.thinking.nil?
     end
 
     # Structured (schema) responses arrive as a Hash/Array; keep them as-is so the

data/lib/llm_logs/configuration.rb

@@ -3,7 +3,7 @@ module LlmLogs
     BedrockBatch = Struct.new(:role_arn, :s3_bucket, :s3_prefix, :min_records, :model_matcher, :region, keyword_init: true)
 
     attr_accessor :enabled, :auto_instrument, :retention_days, :prompts_source_path, :prompt_subfolders,
-                  :batch_enabled, :batch_provider, :page_size, :bedrock_batch, :reasoning_effort_options
+                  :batch_enabled, :page_size, :bedrock_batch, :reasoning_effort_options
 
     def initialize
       @enabled             = true
@@ -12,7 +12,6 @@ module LlmLogs
       @prompts_source_path = nil
       @prompt_subfolders   = %w[skills fragments templates]
       @batch_enabled       = true
-      @batch_provider      = :openai_responses
       @page_size           = 50
       @bedrock_batch       = nil
       # Effort tiers offered in the prompt form. Union of what current providers

data/lib/llm_logs/engine.rb

@@ -6,11 +6,20 @@ module LlmLogs
       ActiveSupport.on_load(:active_record) do
         if LlmLogs.auto_instrument && defined?(RubyLLM::Chat)
           require "llm_logs/instrumentation/ruby_llm_chat"
-          RubyLLM::Chat.prepend(LlmLogs::Instrumentation::RubyLlmChat)
+          LlmLogs::Instrumentation::RubyLlmChat.install!
         end
       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/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

data/lib/llm_logs/ruby_llm_patches.rb

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

data/lib/llm_logs/version.rb

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

data/lib/llm_logs.rb

@@ -54,10 +54,6 @@ module LlmLogs
     configuration.batch_enabled
   end
 
-  def self.batch_provider
-    configuration.batch_provider
-  end
-
   def self.bedrock_batch
     configuration.bedrock_batch
   end
@@ -71,7 +67,7 @@ module LlmLogs
   end
 
   def self.batch_adapters
-    @batch_adapters ||= {openai_responses: LlmLogs::Batch::Adapters::OpenaiResponses.new}
+    @batch_adapters ||= {}
   end
 
   def self.register_batch_adapter(provider, adapter)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_logs
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Anton
@@ -97,30 +97,36 @@ dependencies:
   name: ruby_llm
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: ruby_llm-responses_api
+  name: aws-eventstream
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -186,10 +192,8 @@ files:
 - app/models/llm_logs/application_record.rb
 - app/models/llm_logs/batch.rb
 - app/models/llm_logs/batch/adapters/bedrock.rb
-- app/models/llm_logs/batch/adapters/openai_responses.rb
 - app/models/llm_logs/batch/handler_registry.rb
 - app/models/llm_logs/batch/reconciler.rb
-- app/models/llm_logs/batch/schema_format.rb
 - app/models/llm_logs/batch/submitter.rb
 - app/models/llm_logs/batch/trace_recorder.rb
 - app/models/llm_logs/batch_request.rb
@@ -237,6 +241,12 @@ 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
@@ -261,7 +271,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.20
+rubygems_version: 3.7.2
 specification_version: 4
 summary: Rails engine for LLM logging and prompt management
 test_files: []

data/app/models/llm_logs/batch/adapters/openai_responses.rb

@@ -1,63 +0,0 @@
-module LlmLogs
-  class Batch
-    module Adapters
-      # Wraps ruby_llm-responses_api's OpenAI Batch API. Contains the remote-API logic
-      # previously inline in Submitter/Reconciler; the DB/claim lifecycle stays in those.
-      class OpenaiResponses
-        PROVIDER = :openai_responses
-
-        def submit(_batch, requests)
-          rubyllm_batch = RubyLLM.batch(model: requests.first.model, provider: PROVIDER)
-          requests.each do |request|
-            payload = request.payload
-            rubyllm_batch.add(
-              payload["input"],
-              id: request.custom_id,
-              instructions: payload["instructions"],
-              temperature: payload["temperature"],
-              **reasoning_extra(payload["reasoning_effort"]),
-              **schema_extra(payload["schema"])
-            )
-          end
-          rubyllm_batch.create!
-          {provider_batch_id: rubyllm_batch.id, openai_batch_id: rubyllm_batch.id, provider_metadata: {}}
-        end
-
-        def terminal_status(batch)
-          resume(batch).status
-        end
-
-        def results(batch)
-          resume(batch).results
-        end
-
-        def error_ids(batch)
-          resume(batch).errors.filter_map { |e| e["custom_id"] }
-        end
-
-        private
-
-        # The Responses API nests effort under `reasoning:`; `reasoning_effort` is the
-        # Chat Completions spelling and is silently ignored here.
-        def reasoning_extra(effort)
-          return {} if effort.blank?
-
-          {reasoning: {effort: effort}}
-        end
-
-        # No memoization: LlmLogs.batch_adapters holds one shared instance of this adapter
-        # for the life of the process, so caching the resumed handle here would go stale
-        # for a long-running PollJob worker (in-progress batches would never re-fetch a
-        # later terminal status) and would grow unbounded. Build a fresh handle every call.
-        def resume(batch)
-          RubyLLM.batch(id: batch.provider_batch_id, provider: PROVIDER)
-        end
-
-        def schema_extra(schema)
-          format = SchemaFormat.call(schema)
-          format ? {text: format} : {}
-        end
-      end
-    end
-  end
-end

data/app/models/llm_logs/batch/schema_format.rb

@@ -1,25 +0,0 @@
-module LlmLogs
-  class Batch
-    # Translates a {name:, schema:, strict:} schema (the shape RubyLLM::Chat#with_schema
-    # produces) into the OpenAI Responses API `text.format` block. The batch path builds
-    # request bodies directly via RubyLLM.batch#add(**extra), bypassing with_schema, so
-    # we must hand the json_schema block in ourselves.
-    module SchemaFormat
-      module_function
-
-      def call(schema)
-        return nil if schema.nil?
-
-        schema = schema.symbolize_keys if schema.respond_to?(:symbolize_keys)
-        {
-          format: {
-            type: "json_schema",
-            name: schema[:name] || "response",
-            schema: schema[:schema] || schema,
-            strict: schema.key?(:strict) ? schema[:strict] : true
-          }
-        }
-      end
-    end
-  end
-end