lex-llm-ledger 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d96639d6f6bf123c338c0df58c4e25d1375d0102873318197f6297eeda70a80
-  data.tar.gz: 1ebcbc88558e3783595e3c07c13eb0f9d0f3fbb82a2c096cb52752592c469d2a
+  metadata.gz: d7432d720f451a54b2826adc2eb2fa6335efb0d05cf993d2b84d29c4048090d4
+  data.tar.gz: a77af8bd22c3e4438b5a2c1e5ba684eb042b9612aff691fcc7085a5078ee752a
 SHA512:
-  metadata.gz: 670f7c45555f557aae91ba858831f1ce40e74eaf92a5390a965e2d5e6487a6b6deb9700527a6098bd8454b2085fbe1de567195d4a7f54b8f910921d6dde9535f
-  data.tar.gz: a72b7dac0f47bf49ca637f060698899d8eb2fc1d7436e2271afbddb8ef5684a00e5b75ae264ac6d635bc9ac58b9e79fab84070b4b51878324615d939942a9ef7
+  metadata.gz: 0b03a48cfd7912f193ce78263d44cc1ca996f5d8289f971f836a9e8231b2630bd61d4ece62d1489c8fdc92414174e4e6275df088585d0a2763496e7ff673cff5
+  data.tar.gz: 287814a7495a4f10ba0a95f4b2f2206fadbc13bd3b6143173477dccf276ae2d15658b88e273e94abed67d0734eb9d91fee085c7b088bf7a8705e09b9e4b8e03e

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # 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

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

@@ -10,8 +10,6 @@ module Legion
   module Extensions
     module Llm
       module Ledger
-        class ResponseNotReady < StandardError; end
-
         module Runners
           module Tools
             extend self
@@ -31,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
@@ -53,9 +53,6 @@ module Legion
             rescue Helpers::DecryptionFailed => e
               handle_exception(e, level: :error, handled: true, operation: 'write_tool_record.decrypt')
               raise
-            rescue ResponseNotReady => e
-              log.warn("[ledger] write_tool_record: parent response not yet written, dead-lettering message (#{e.message})")
-              raise unrecoverable_message_error(e)
             rescue StandardError => e
               handle_exception(e, level: :error, handled: true, operation: 'write_tool_record')
               { result: :error, error: e.message }
@@ -67,16 +64,26 @@ module Legion
               Helpers::SubscriptionMessage.runner_args(payload, metadata, message)
             end
 
-            def unrecoverable_message_error(error)
-              if defined?(Legion::Extensions::Actors::UnrecoverableMessageError)
-                Legion::Extensions::Actors::UnrecoverableMessageError.new(error.message)
-              else
-                error
+            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
 
-            # 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(db, body, ctx, props, headers)
               request_ref = ctx[:request_id] || body[:request_id] ||
                             props[:correlation_id] || headers['x-legion-llm-request-id']
@@ -89,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'
@@ -108,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'],
@@ -128,34 +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
-
-              raise ResponseNotReady, "no response row found for tool call uuid=#{tool_uuid}"
-            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
 
@@ -265,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.2'
+        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.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Esity