lex-llm-ledger 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b4fb5492195845786b98e664192f84716d049c4144e81e28c5627799cf169b99
-  data.tar.gz: fc6b2b70fbfda9e98c6e7a6e942c81f65193e5c65f46856a50b4fa64ec681972
+  metadata.gz: d7432d720f451a54b2826adc2eb2fa6335efb0d05cf993d2b84d29c4048090d4
+  data.tar.gz: a77af8bd22c3e4438b5a2c1e5ba684eb042b9612aff691fcc7085a5078ee752a
 SHA512:
-  metadata.gz: e85919d09a173cca54608528ceb4c50a0350912a52c81a5948fff7cf483f9a428e078cbf948b7f90237191335e0e1165ff103d22864df6ffc794c2b922394b9a
-  data.tar.gz: 6de04faae342441c24754f9b186fa92e49b6ab971ad8e4935175ad7206a58da5e288fef33791e97ed785c01f2ca0198606f82b064812a085e69530cf578dfe8d
+  metadata.gz: 0b03a48cfd7912f193ce78263d44cc1ca996f5d8289f971f836a9e8231b2630bd61d4ece62d1489c8fdc92414174e4e6275df088585d0a2763496e7ff673cff5
+  data.tar.gz: 287814a7495a4f10ba0a95f4b2f2206fadbc13bd3b6143173477dccf276ae2d15658b88e273e94abed67d0734eb9d91fee085c7b088bf7a8705e09b9e4b8e03e

data/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## [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
+- Dead-letter tool audit messages with missing parent response rows via `UnrecoverableMessageError` so the subscription rejects the RabbitMQ delivery with `requeue: false` instead of acknowledging, republishing, or blocking inside a runner-local sleep/retry loop.
+- Set the `llm.registry.availability` subscription actor prefetch to 4 so registry availability events can drain with modest concurrency.
+
+## [0.4.1] - 2026-05-18
+
+### Fixed
+- Tool write retries once after 1s when parent response row is not yet committed (race between async metering publish and tool audit AMQP delivery)
+- Raises `ResponseNotReady` instead of silently returning nil when response row is missing
+
+
 ## [0.4.0] - 2026-05-17
 
 ### Changed

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

@@ -11,6 +11,8 @@ module Legion
           class RegistryAvailability < Legion::Extensions::Actors::Subscription
             include Helpers::SubscriptionActor
 
+            prefetch 4
+
             def runner_class = Legion::Extensions::Llm::Ledger::Runners::RegistryAvailability
 
             def runner_function

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

@@ -29,11 +29,13 @@ module Legion
               )
 
               db = ::Legion::Data.connection
+              response = find_or_resolve_response_with_retry(db, body, ctx, props, headers)
               write_result = [:ok]
               db.transaction do
-                response                     = find_or_resolve_response(db, body, ctx, props, headers)
                 identity_attrs               = extract_identity_attrs(body, headers, db)
-                tool_call_row, new_tool_call = find_or_create_tool_call(db, response, body, ctx, tool, headers, identity_attrs)
+                conversation_id              = resolve_conversation_id(db, body, ctx, headers)
+                tool_call_row, new_tool_call = find_or_create_tool_call(db, response, body, ctx, tool, headers,
+                                                                        identity_attrs, conversation_id)
                 if tool_call_row && !new_tool_call
                   write_result[0] = :duplicate
                 elsif new_tool_call
@@ -62,8 +64,26 @@ module Legion
               Helpers::SubscriptionMessage.runner_args(payload, metadata, message)
             end
 
-            # Resolve the llm_message_inference_responses row this tool call belongs to.
-            # Returns nil if we cannot link at all.
+            def find_or_resolve_response_with_retry(db, body, ctx, props, headers)
+              response = find_or_resolve_response(db, body, ctx, props, headers)
+              return response if response # rubocop:disable Legion/Extension/RunnerReturnHash
+
+              retry_attempts = tool_write_setting(:response_retry_attempts, 3)
+              retry_delay    = tool_write_setting(:response_retry_delay, 1)
+
+              retry_attempts.times do |attempt|
+                sleep retry_delay
+                response = find_or_resolve_response(db, body, ctx, props, headers)
+                if response
+                  log.debug("[ledger] write_tool_record: response found on retry #{attempt + 1}")
+                  return response # rubocop:disable Legion/Extension/RunnerReturnHash
+                end
+              end
+
+              log.info('[ledger] write_tool_record: response not available after retries, proceeding with null response_id')
+              nil
+            end
+
             def find_or_resolve_response(db, body, ctx, props, headers)
               request_ref = ctx[:request_id] || body[:request_id] ||
                             props[:correlation_id] || headers['x-legion-llm-request-id']
@@ -76,17 +96,30 @@ module Legion
                 .where(message_inference_request_id: request[:id]).first
             end
 
-            def find_or_create_tool_call(db, response, body, ctx, tool, headers, identity_attrs)
+            def resolve_conversation_id(db, body, ctx, headers)
+              conv_ref = ctx[:conversation_id] || 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 find_or_create_tool_call(db, response, body, ctx, tool, headers, identity_attrs, conversation_id)
               tool_uuid = derive_tool_call_uuid(body, ctx, tool, headers)
               existing  = db[:llm_tool_calls].where(uuid: tool_uuid).first
               return [existing, false] if existing # rubocop:disable Legion/Extension/RunnerReturnHash
 
-              response_id = resolve_response_id(db, response, body, ctx, headers, tool_uuid)
-              return [nil, false] unless response_id # rubocop:disable Legion/Extension/RunnerReturnHash
+              response_id = response&.[](:id)
 
-              next_index = db[:llm_tool_calls]
-                           .where(message_inference_response_id: response_id)
-                           .max(:tool_call_index).to_i + 1
+              next_index = if response_id
+                             db[:llm_tool_calls]
+                               .where(message_inference_response_id: response_id)
+                               .max(:tool_call_index).to_i + 1
+                           else
+                             0
+                           end
 
               src    = tool[:source] || {}
               status = tool[:status] || headers['x-legion-tool-status'] || 'success'
@@ -95,6 +128,7 @@ module Legion
               id = insert_with_savepoint(db, :llm_tool_calls, {
                                            uuid:                          tool_uuid,
                                            message_inference_response_id: response_id,
+                                           conversation_id:               conversation_id,
                                            tool_call_index:               next_index,
                                            provider_tool_call_ref:        tool[:id],
                                            tool_name:                     tool[:name] || headers['x-legion-tool-name'],
@@ -115,35 +149,6 @@ module Legion
               [row, false]
             end
 
-            # Extract or fall back to find a response_id for linking the tool call.
-            def resolve_response_id(db, response, body, ctx, headers, tool_uuid)
-              return response[:id] if response # rubocop:disable Legion/Extension/RunnerReturnHash
-
-              fallback = fallback_response_for_conversation(db, body, ctx, headers)
-              return fallback[:id] if fallback # rubocop:disable Legion/Extension/RunnerReturnHash
-
-              log.warn("[ledger] write_tool_record: no response row found for tool call uuid=#{tool_uuid}, skipping")
-              nil
-            end
-
-            def fallback_response_for_conversation(db, body, ctx, headers)
-              conv_id = ctx[:conversation_id] || body[:conversation_id] ||
-                        headers['x-legion-llm-conversation-id']
-              return nil unless conv_id # rubocop:disable Legion/Extension/RunnerReturnHash
-
-              conv = db[:llm_conversations].where(uuid: stable_uuid(conv_id)).first ||
-                     db[:llm_conversations].where(uuid: conv_id).first
-              return nil unless conv # rubocop:disable Legion/Extension/RunnerReturnHash
-
-              db[:llm_message_inference_responses]
-                .join(:llm_message_inference_requests,
-                      id: :message_inference_request_id)
-                .where(Sequel[:llm_message_inference_requests][:conversation_id] => conv[:id])
-                .order(Sequel.desc(Sequel[:llm_message_inference_responses][:id]))
-                .select_all(:llm_message_inference_responses)
-                .first
-            end
-
             def find_or_create_tool_call_attempt(db, tool_call_row, tool, body, props, headers, identity_attrs) # rubocop:disable Metrics/CyclomaticComplexity
               return nil unless tool_call_row # rubocop:disable Legion/Extension/RunnerReturnHash
 
@@ -253,6 +258,12 @@ module Legion
               "#{hex[0, 8]}-#{hex[8, 4]}-#{hex[12, 4]}-#{hex[16, 4]}-#{hex[20, 12]}"
             end
 
+            def tool_write_setting(key, default)
+              ledger = Legion::Settings.dig(:extensions, :llm, :ledger) || {}
+              tool_write = ledger[:tool_write] || {}
+              (tool_write[key] || default).to_i
+            end
+
             def insert_with_savepoint(db, table, attributes, operation:)
               db.transaction(savepoint: true) do
                 Helpers::PersistenceLogging.insert_row(db, table, attributes,

data/lib/legion/extensions/llm/ledger/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ledger
-        VERSION = '0.4.0'
+        VERSION = '0.5.0'
       end
     end
   end

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

@@ -51,9 +51,13 @@ module Legion
 
         def self.default_settings
           {
-            retention: {
+            retention:  {
               default_days: 90,
               phi_ttl_days: 30
+            },
+            tool_write: {
+              response_retry_attempts: 3,
+              response_retry_delay:    1
             }
           }
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-ledger
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Esity