lex-llm-ledger 0.4.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d96639d6f6bf123c338c0df58c4e25d1375d0102873318197f6297eeda70a80
-  data.tar.gz: 1ebcbc88558e3783595e3c07c13eb0f9d0f3fbb82a2c096cb52752592c469d2a
+  metadata.gz: 70deb6cfb3814da49ebbc893a2025e06ddcf96ee7789a65f794fa66910502f41
+  data.tar.gz: e0837642064bf0c1ee6bf480704d297f961144f5f6cfb0814b88d8de438bf0f6
 SHA512:
-  metadata.gz: 670f7c45555f557aae91ba858831f1ce40e74eaf92a5390a965e2d5e6487a6b6deb9700527a6098bd8454b2085fbe1de567195d4a7f54b8f910921d6dde9535f
-  data.tar.gz: a72b7dac0f47bf49ca637f060698899d8eb2fc1d7436e2271afbddb8ef5684a00e5b75ae264ac6d635bc9ac58b9e79fab84070b4b51878324615d939942a9ef7
+  metadata.gz: '024169e420f778950b01bd074b03b1e63ccc642cb6c0148a14046dc91a74426c8a4d202a70fb33b6a669fbe3248fba62940e72a3a63ba1d776cef0044e0b9e36'
+  data.tar.gz: 207e66a936b63bf8c52437d2dc1d92931afdcb12caea03976b4e293bf8e67d43f963e62e9ba336c1e80789b3d60ad960b56eb6b85081f3146509f84c760aaf6f

data/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## [0.6.0] - 2026-05-31
+
+### Added
+- **Skills audit actor** — new queue `llm.audit.skills`, actor, and runner consuming `audit.skill.#` events from the `llm.audit` exchange. Creates `llm_skill_events` records.
+- **Escalation audit actor** — new exchange `llm.escalation` binding, queue `llm.audit.escalations`, actor, and runner. Creates `llm_escalation_events` records.
+- **Retention purge actor** — actively deletes expired records (hourly, batched). Enforces `session_only` and PHI TTL retention policies that were previously passive.
+- **Reconciliation actor** — links orphaned tool calls (null `response_id`) and metering requests (null `latest_message_id`) within a 5-minute lookback window every 2 minutes.
+- **Migration 013** — `parent_request_id` FK on requests, `schema_version` on all official tables, `pii_types_json` and `jurisdictions_json` on conversations.
+- **Migration 014** — creates `llm_skill_events` and `llm_escalation_events` tables.
+- **PHI field-level encryption** — `request_json`, `response_json`, `response_thinking_json` encrypted at rest via `Legion::Crypt` when `contains_phi: true`.
+
+### Fixed
+- **LEDGER-01**: `session_only` retention maps to 0 days (immediate expiry) instead of `nil`, distinguishing it from `permanent`.
+- **IDENTITY-05**: `CallerIdentity.normalize` recognizes transport identity headers (`x-legion-identity-canonical-name`, `x-legion-identity-kind`, `x-legion-identity-db-*`).
+- **IDENTITY-06**: `OfficialRecordWriter.caller_identity_refs` falls back to pre-resolved AMQP header IDs.
+- **GAP-06**: `ProviderStats#health_report` uses `recorded_at` instead of `inserted_at` for 24h window.
+- **GAP-10**: Backfill `metering_payload` maps `provider_instance` from correct column.
+- **GAP-11**: Backfill `registry_reason` extracts from metadata JSON instead of storing raw blob.
+- Dead `Retention.resolve` call removed from tools runner.
+
+### Changed
+- **Jurisdictions** stored as JSON array instead of comma-joined string.
+- **Classification level** validated against controlled vocabulary (`public`/`internal`/`confidential`/`restricted`), defaults to `internal`.
+- **Schema version** written to all official table inserts (constant `SCHEMA_VERSION = 13`).
+- All CallerIdentity-resolved payloads now pass `__header_principal_id`/`__header_identity_id` for direct FK resolution.
+
+### Requires
+- legion-data >= 1.8.9 (migrations 013-014)
+
+## [0.5.0] - 2026-05-26
+
+### Changed
+- Tool audit writes no longer dead-letter when the parent response row is missing. The runner retries up to 3 times (1s delay each, configurable via `tool_write` settings), then inserts with a NULL `message_inference_response_id` instead of raising `UnrecoverableMessageError`.
+- Removed `ResponseNotReady` exception class — tool calls are always persisted now.
+- Populate `conversation_id` FK on `llm_tool_calls` from the message payload/headers, providing conversation-level traceability even when the response FK is NULL.
+- Retry configuration moved to `default_settings[:tool_write]` (`response_retry_attempts`, `response_retry_delay`) — tunable at runtime without code changes.
+
+### Requires
+- legion-data >= 1.8.9 (migrations 116-117)
+
+## [0.4.3] - 2026-05-22
+
+### Fixed
+- Persist `llm.registry.availability` publisher identity from current transport headers into `llm_registry_availability_records`, including best-effort `identity_principal_id` and `identity_id` from DB id headers.
+- Preserve legacy identity header and body fallbacks for registry availability records when current transport identity headers are absent.
+
 ## [0.4.2] - 2026-05-22
 
 ### Fixed

data/lib/legion/extensions/llm/ledger/actors/escalations.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+require_relative '../helpers/subscription_actor'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class Escalations < Legion::Extensions::Actors::Subscription
+            include Helpers::SubscriptionActor
+
+            prefetch 1
+
+            def runner_class = Legion::Extensions::Llm::Ledger::Runners::Escalations
+
+            def runner_function
+              'write_escalation_record'
+            end
+
+            def use_runner?
+              false
+            end
+
+            def queue
+              Legion::Extensions::Llm::Ledger::Transport::Queues::AuditEscalations
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/actors/reconciliation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class Reconciliation < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+            def runner_class
+              'Legion::Extensions::Llm::Ledger::Runners::Reconciliation'
+            end
+
+            def runner_function
+              'link_orphaned_tool_calls'
+            end
+
+            def time
+              120
+            end
+
+            def run
+              Runners::Reconciliation.link_orphaned_tool_calls
+              Runners::Reconciliation.link_metering_messages
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'reconciliation')
+            end
+
+            def run_now?
+              false
+            end
+
+            def use_runner?
+              false
+            end
+
+            def check_subtask?
+              false
+            end
+
+            def generate_task?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/actors/retention_purge.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class RetentionPurge < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
+            def runner_class
+              'Legion::Extensions::Llm::Ledger::Runners::RetentionPurge'
+            end
+
+            def runner_function
+              'purge_expired'
+            end
+
+            def time
+              3600
+            end
+
+            def run
+              Runners::RetentionPurge.purge_expired
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'retention_purge')
+            end
+
+            def run_now?
+              false
+            end
+
+            def use_runner?
+              false
+            end
+
+            def check_subtask?
+              false
+            end
+
+            def generate_task?
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/actors/skills.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/actors/subscription'
+require_relative '../helpers/subscription_actor'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Actor
+          class Skills < Legion::Extensions::Actors::Subscription
+            include Helpers::SubscriptionActor
+
+            prefetch 1
+
+            def runner_class = Legion::Extensions::Llm::Ledger::Runners::Skills
+
+            def runner_function
+              'write_skill_record'
+            end
+
+            def use_runner?
+              false
+            end
+
+            def queue
+              Legion::Extensions::Llm::Ledger::Transport::Queues::AuditSkills
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/backfill/legacy_llm_records.rb

@@ -110,7 +110,8 @@ module Legion
                 exchange_id:       row[:exchange_id],
                 operation:         row[:request_type],
                 provider:          row[:provider],
-                provider_instance: row[:worker_id],
+                provider_instance: row[:provider_instance],
+                worker_id:         row[:worker_id],
                 model_id:          row[:model_id],
                 tier:              row[:tier],
                 input_tokens:      row[:input_tokens],
@@ -161,7 +162,7 @@ module Legion
                            model_key:   row[:model_id],
                            event_type:  row[:event_type],
                            status:      registry_status(row),
-                           reason:      row[:metadata_json],
+                           reason:      registry_reason(row),
                            recorded_at: row[:occurred_at],
                            inserted_at: Time.now.utc
                          }, operation: 'legacy_llm_backfill.registry_event')
@@ -197,6 +198,11 @@ module Legion
               health[:status] || health['status'] || row[:event_type] || 'unknown'
             end
 
+            def registry_reason(row)
+              metadata = json_load(row[:metadata_json])
+              metadata[:reason] || metadata['reason'] || metadata[:message] || metadata['message'] || row[:event_type]
+            end
+
             def table_present?(table)
               db.table_exists?(table)
             end

data/lib/legion/extensions/llm/ledger/helpers/caller_identity.rb

@@ -18,12 +18,16 @@ module Legion
               extension = hash_value(caller_hash, :extension)
               type = first_present(
                 hash_value(identity_hash, :type),
+                hash_value(identity_hash, :kind),
+                header_value(headers, 'x-legion-identity-kind'),
                 header_value(headers, 'x-legion-caller-type'),
                 hash_value(caller, :type),
+                hash_value(caller, :kind),
                 extension && 'extension'
               )
 
               raw_identity = first_present(
+                header_value(headers, 'x-legion-identity-canonical-name'),
                 hash_value(identity_hash, :id),
                 hash_value(identity_hash, :canonical_name),
                 hash_value(identity_hash, :identity),
@@ -38,8 +42,10 @@ module Legion
               )
 
               {
-                identity: normalize_identity_value(raw_identity, type),
-                type:     type
+                identity:     normalize_identity_value(raw_identity, type),
+                type:         type,
+                principal_id: integer_header(headers, 'x-legion-identity-db-principal-id'),
+                identity_id:  integer_header(headers, 'x-legion-identity-db-identity-id')
               }.compact
             end
 
@@ -71,6 +77,14 @@ module Legion
               headers[key] || headers[key.to_sym]
             end
 
+            def integer_header(headers, key)
+              raw = header_value(headers, key)
+              return nil if raw.nil?
+
+              int = raw.to_i
+              int.positive? ? int : nil
+            end
+
             def present?(value)
               !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
             end

data/lib/legion/extensions/llm/ledger/helpers/retention.rb

@@ -13,7 +13,7 @@ module Legion
             PHI_TTL_DEFAULT_DAYS = 30
 
             RETENTION_MAP = {
-              'session_only' => nil,
+              'session_only' => 0,
               'days_30'      => 30,
               'days_90'      => 90,
               'permanent'    => nil

data/lib/legion/extensions/llm/ledger/runners/escalations.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+require_relative '../helpers/caller_identity'
+require_relative '../helpers/json'
+require_relative '../helpers/persistence_logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Runners
+          module Escalations
+            extend self
+
+            def write_escalation_record(payload = nil, metadata = {}, **message)
+              payload, metadata = normalize_runner_args(payload, metadata, message)
+              headers = Helpers::SubscriptionMessage.extract_headers(payload, metadata)
+              props   = metadata[:properties] || {}
+
+              body = payload.is_a?(Hash) ? payload : Helpers::Decryption.decrypt_if_needed(payload, metadata)
+
+              db = ::Legion::Data.connection
+              record = build_escalation_record(db, body, props, headers)
+
+              Helpers::PersistenceLogging.insert_row(
+                db, :llm_escalation_events, record,
+                operation: 'write_escalation_record'
+              )
+              { result: :ok }
+            rescue Sequel::UniqueConstraintViolation => e
+              log.warn("write_escalation_record duplicate insert ignored: #{e.message}")
+              { result: :duplicate }
+            rescue Helpers::DecryptionUnavailable => e
+              handle_exception(e, level: :warn, handled: true, operation: 'write_escalation_record.decrypt')
+              raise
+            rescue Helpers::DecryptionFailed => e
+              handle_exception(e, level: :error, handled: true, operation: 'write_escalation_record.decrypt')
+              raise
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'write_escalation_record')
+              { result: :error, error: e.message }
+            end
+
+            private
+
+            def normalize_runner_args(payload, metadata, message)
+              Helpers::SubscriptionMessage.runner_args(payload, metadata, message)
+            end
+
+            def build_escalation_record(db, body, props, headers) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+              history = Array(body[:history])
+              identity = Helpers::CallerIdentity.normalize(
+                caller_raw: body[:caller], identity: body[:identity], headers: headers
+              )
+
+              first_attempt = history.first || {}
+              last_attempt = history.last || {}
+
+              {
+                uuid:                    stable_uuid(props[:message_id] || body[:event_id] || SecureRandom.uuid),
+                conversation_id:         resolve_conversation_id(db, body, headers),
+                request_ref:             body[:request_id] || props[:correlation_id],
+                from_provider:           first_attempt[:provider] || body[:from_provider],
+                from_instance:           first_attempt[:instance] || body[:from_instance],
+                from_model:              first_attempt[:model] || body[:from_model],
+                to_provider:             last_attempt[:provider] || body[:to_provider],
+                to_instance:             last_attempt[:instance] || body[:to_instance],
+                to_model:                last_attempt[:model] || body[:to_model],
+                reason:                  body[:reason] || (first_attempt[:outcome] == 'failure' ? 'provider_failover' : nil),
+                error_category:          body[:error_category] || extract_error_category(first_attempt),
+                attempt_no:              history.size || (body[:attempt_no] || 1),
+                latency_ms:              history.sum { |a| (a[:duration_ms] || 0).to_i } || body[:latency_ms].to_i,
+                identity_canonical_name: identity[:identity],
+                identity_principal_id:   identity[:principal_id],
+                identity_id:             identity[:identity_id],
+                history_json:            history.any? ? Helpers::Json.dump(history) : nil,
+                outcome:                 body[:outcome]&.to_s,
+                total_attempts:          body[:attempts] ? body[:attempts].to_i : history.size,
+                recorded_at:             body[:recorded_at] || body[:timestamp] || Time.now.utc,
+                inserted_at:             Time.now.utc
+              }.compact
+            end
+
+            def resolve_conversation_id(db, body, headers)
+              conv_ref = body[:conversation_id] || headers['x-legion-llm-conversation-id']
+              return nil unless conv_ref # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              conv = db[:llm_conversations].where(uuid: stable_uuid(conv_ref)).first ||
+                     db[:llm_conversations].where(uuid: conv_ref).first
+              conv&.[](:id)
+            end
+
+            def extract_error_category(attempt)
+              failures = Array(attempt[:failures])
+              failures.first.is_a?(Hash) ? failures.first[:category].to_s : nil
+            end
+
+            def stable_uuid(value)
+              raw = value.to_s
+              return raw if raw.length <= 36 # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              hex = Digest::SHA256.hexdigest(raw)[0, 32]
+              "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
+            end
+
+            include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
+                                                        Legion::Extensions::Helpers.const_defined?(:Lex, false)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/ledger/runners/metering.rb

@@ -92,18 +92,20 @@ module Legion
                 caller_raw: payload[:caller], identity: payload[:identity], headers: headers
               )
               payload.merge(
-                message_id:        props[:message_id] || payload[:message_id] || ctx[:message_id],
-                correlation_id:    props[:correlation_id] || payload[:correlation_id],
-                conversation_id:   ctx[:conversation_id] || payload[:conversation_id],
-                request_id:        ctx[:request_id] || payload[:request_id],
-                exchange_id:       ctx[:exchange_id] || payload[:exchange_id],
-                operation:         payload[:operation] || payload[:request_type] || headers['x-legion-llm-request-type'],
-                provider:          payload[:provider] || headers['x-legion-llm-provider'],
-                provider_instance: payload[:provider_instance] || payload[:instance],
-                model_id:          payload[:model_id] || headers['x-legion-llm-model'],
-                tier:              payload[:tier] || headers['x-legion-llm-tier'],
-                caller_identity:   identity[:identity],
-                caller_type:       identity[:type]
+                message_id:            props[:message_id] || payload[:message_id] || ctx[:message_id],
+                correlation_id:        props[:correlation_id] || payload[:correlation_id],
+                conversation_id:       ctx[:conversation_id] || payload[:conversation_id],
+                request_id:            ctx[:request_id] || payload[:request_id],
+                exchange_id:           ctx[:exchange_id] || payload[:exchange_id],
+                operation:             payload[:operation] || payload[:request_type] || headers['x-legion-llm-request-type'],
+                provider:              payload[:provider] || headers['x-legion-llm-provider'],
+                provider_instance:     payload[:provider_instance] || payload[:instance],
+                model_id:              payload[:model_id] || headers['x-legion-llm-model'],
+                tier:                  payload[:tier] || headers['x-legion-llm-tier'],
+                caller_identity:       identity[:identity],
+                caller_type:           identity[:type],
+                __header_principal_id: identity[:principal_id],
+                __header_identity_id:  identity[:identity_id]
               )
             end
 

data/lib/legion/extensions/llm/ledger/runners/prompts.rb

@@ -10,6 +10,8 @@ module Legion
       module Ledger
         module Runners
           module Prompts
+            ALLOWED_CLASSIFICATION_LEVELS = %w[public internal confidential restricted].freeze
+
             extend self
 
             def write_prompt_record(payload = nil, metadata = {}, **message)
@@ -137,8 +139,10 @@ module Legion
                 caller_raw: body[:caller], identity: body[:identity], headers: headers
               )
               {
-                caller_identity: identity[:identity],
-                caller_type:     identity[:type]
+                caller_identity:       identity[:identity],
+                caller_type:           identity[:type],
+                __header_principal_id: identity[:principal_id],
+                __header_identity_id:  identity[:identity_id]
               }.compact
             end
 
@@ -165,14 +169,25 @@ module Legion
             end
 
             def official_compliance_payload(body, headers, expires_at)
+              cls = body[:classification] || {}
               {
                 retention_policy:     headers['x-legion-retention'] || body[:retention_policy],
                 expires_at:           expires_at,
-                contains_phi:         headers['x-legion-contains-phi'] == 'true' || body.dig(:classification, :contains_phi),
-                classification_level: body.dig(:classification, :level) || headers['x-legion-classification']
+                contains_phi:         headers['x-legion-contains-phi'] == 'true' || cls[:contains_phi],
+                contains_pii:         cls[:contains_pii] ? true : false,
+                pii_types_json:       Helpers::Json.dump(Array(cls[:pii_types])),
+                classification_level: normalize_classification(cls[:level] || headers['x-legion-classification']),
+                jurisdictions:        Helpers::Json.dump(Array(cls[:jurisdictions]))
               }
             end
 
+            def normalize_classification(level)
+              return 'internal' if level.nil? || level.to_s.empty? # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              normalized = level.to_s.downcase
+              ALLOWED_CLASSIFICATION_LEVELS.include?(normalized) ? normalized : 'internal'
+            end
+
             include Legion::Extensions::Helpers::Lex if Legion::Extensions.const_defined?(:Helpers, false) &&
                                                         Legion::Extensions::Helpers.const_defined?(:Lex, false)
           end

data/lib/legion/extensions/llm/ledger/runners/provider_stats.rb

@@ -10,7 +10,7 @@ module Legion
 
             def health_report
               ds = official_metrics
-                   .where { Sequel[:llm_message_inference_metrics][:inserted_at] >= Time.now.utc - 86_400 }
+                   .where { Sequel[:llm_message_inference_metrics][:recorded_at] >= Time.now.utc - 86_400 }
                    .select_group(
                      Sequel[:llm_message_inference_metrics][:provider],
                      Sequel[:llm_message_inference_responses][:provider_instance],

data/lib/legion/extensions/llm/ledger/runners/reconciliation.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'legion/logging'
+
+module Legion
+  module Extensions
+    module Llm
+      module Ledger
+        module Runners
+          module Reconciliation
+            extend self
+            extend Legion::Logging::Helper
+
+            BATCH_SIZE = 200
+            LOOKBACK_SECONDS = 300
+
+            def link_orphaned_tool_calls
+              db = ::Legion::Data.connection
+              linked = 0
+
+              orphans = db[:llm_tool_calls]
+                        .where(message_inference_response_id: nil)
+                        .where { inserted_at >= Time.now.utc - LOOKBACK_SECONDS }
+                        .limit(BATCH_SIZE)
+                        .all
+
+              orphans.each do |tool_call|
+                response = find_response_for_tool_call(db, tool_call)
+                next unless response
+
+                db[:llm_tool_calls].where(id: tool_call[:id]).update(
+                  message_inference_response_id: response[:id]
+                )
+                linked += 1
+              end
+
+              log.info("[ledger] reconciliation: linked #{linked} orphaned tool calls") if linked.positive?
+              { result: :ok, linked: linked }
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'reconciliation.tool_calls')
+              { result: :error, error: e.message }
+            end
+
+            def link_metering_messages
+              db = ::Legion::Data.connection
+              linked = 0
+
+              requests_without_messages = db[:llm_message_inference_requests]
+                                          .where(latest_message_id: nil)
+                                          .where { inserted_at >= Time.now.utc - LOOKBACK_SECONDS }
+                                          .limit(BATCH_SIZE)
+                                          .all
+
+              requests_without_messages.each do |request|
+                next unless request[:conversation_id]
+
+                message = db[:llm_messages]
+                          .where(conversation_id: request[:conversation_id])
+                          .order(Sequel.desc(:seq))
+                          .first
+                next unless message
+
+                db[:llm_message_inference_requests]
+                  .where(id: request[:id])
+                  .update(latest_message_id: message[:id])
+                linked += 1
+              end
+
+              log.info("[ledger] reconciliation: linked #{linked} metering requests to messages") if linked.positive?
+              { result: :ok, linked: linked }
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'reconciliation.metering_messages')
+              { result: :error, error: e.message }
+            end
+
+            private
+
+            def find_response_for_tool_call(db, tool_call)
+              return nil unless tool_call[:conversation_id] # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              request = db[:llm_message_inference_requests]
+                        .where(conversation_id: tool_call[:conversation_id])
+                        .order(Sequel.desc(:inserted_at))
+                        .first
+              return nil unless request # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              db[:llm_message_inference_responses]
+                .where(message_inference_request_id: request[:id])
+                .first
+            end
+          end
+        end
+      end
+    end
+  end
+end