lex-llm-ledger 0.3.1 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a69d4ccf5975f45c795e6e54ab6ed59272a269855394bbef4d1149a48bd338e7
-  data.tar.gz: 60bfc3f268526d0cf427ccfa90f2e230f9e0491fd88584ff685604c93faf63c4
+  metadata.gz: bfcca825db5b0e313cbeafc6c9f396b3f964dd4debd911854c89affe3bcb79ef
+  data.tar.gz: 1a4ea16c0c4ca34cc1ae4e3d0efa19cab3948c932162d9072c21127dae1ea375
 SHA512:
-  metadata.gz: e166ea0dc31b758dd45d5c1595f6a72c78629b7dfd69d09d9928a699ce14f475658d9bf77f08018608bc98f394532f4c19b5887c3b2649bb1761aecbe2b4b5c8
-  data.tar.gz: 226be9d0592d67fcca0ff956fe0c62db56a311cc3f6bde5a16523f21801d43079d976a6d6582e2a0f1022396089555495df37ccf81ccfd56ddfd3f2344f9d27f
+  metadata.gz: 362b96b3b385cfcca6c2edbe3fa9c6e30a23fbaa80bd5136fa1f95cc35af8ea5aa93ea89cd7cf1415999ac82ce881311aeea084ee44ba19cffadcbef0858a71b
+  data.tar.gz: 89c63b437c02355a9cc39182d42ac0a1971b7dcdf80473d7ef237d92bbb39cef96c13dd0ea3b34f13d6ed1f662cb6bb30aa473658dde119739b641bbf7b92dac

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## [0.3.3] - 2026-05-17
+
+### Fixed
+- Extract inline `<think>` / `<thinking>` tags from string responses into `response_thinking_json` at write time instead of leaving them in `response_json`.
+- Fall back to `ThinkingExtractor` when `response_thinking` is absent from the audit payload (covers Ollama, vLLM, and OpenAI-compatible gateways that pass thinking inline).
+- Guard `finish_reason` and `thinking_response` against `String#dig` TypeError when `body[:response]` is a plain string.
+
+## [0.3.2] - 2026-05-13
+
+### Fixed
+- Keep metering-only writes from creating placeholder conversation messages so later prompt audits can attach the real user and assistant messages without sequence collisions.
+- Use the request reference as the default inference metric idempotency key so metering and prompt audit events enrich the same metric row.
+- Suppress duplicate insert warnings for unique races handled by the official ledger writer while retaining debug-level collision messages.
+
 ## [0.3.1] - 2026-05-13
 
 ### Fixed

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

@@ -184,7 +184,7 @@ module Legion
             end
 
             def official_metric_uuid(payload)
-              ref = payload[:message_id] || "metric:#{Writers::OfficialRecordWriter.request_ref(payload)}"
+              ref = payload[:metric_id] || payload[:metric_ref] || "metric:#{Writers::OfficialRecordWriter.request_ref(payload)}"
               Writers::OfficialRecordWriter.stable_uuid(ref)
             end
 

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

@@ -19,13 +19,15 @@ module Legion
 
             module_function
 
-            def insert_row(db, table, attributes, operation:)
+            def insert_row(db, table, attributes, operation:, warn_on_unique: true)
               row_id = db[table].insert(attributes)
               log.info(log_message('inserted', table, operation, row_id, attributes))
               row_id
             rescue Sequel::UniqueConstraintViolation => e
-              log.warn(log_message('insert_failed', table, operation, nil, attributes,
-                                   error_class: e.class, error: e.message))
+              if warn_on_unique
+                log.warn(log_message('insert_failed', table, operation, nil, attributes,
+                                     error_class: e.class, error: e.message))
+              end
               raise
             rescue StandardError => e
               log.error(log_message('insert_failed', table, operation, nil, attributes,

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

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'legion/extensions/llm/responses/thinking_extractor'
 require_relative '../helpers/caller_identity'
 require_relative '../helpers/json'
 
@@ -96,7 +97,30 @@ module Legion
             end
 
             def response_thinking(body)
-              body[:response_thinking] || body[:thinking] || body.dig(:response, :thinking) || {}
+              thinking = body[:response_thinking] || body[:thinking]
+              thinking ||= body.dig(:response, :thinking) if body[:response].is_a?(Hash)
+              if thinking
+                thinking.is_a?(Hash) ? thinking : { content: thinking }
+              else
+                extract_thinking_from_content(body)
+              end
+            end
+
+            def extract_thinking_from_content(body)
+              content_str = body[:response_content] || body[:response] || body[:content]
+              return {} unless content_str.is_a?(String)
+
+              _clean, extracted = extract_inline_thinking(content_str)
+              extracted ? { content: extracted } : {}
+            end
+
+            def extract_inline_thinking(text)
+              if defined?(::Legion::Extensions::Llm::Responses::ThinkingExtractor)
+                extraction = ::Legion::Extensions::Llm::Responses::ThinkingExtractor.extract(text)
+                [extraction.content, extraction.thinking]
+              else
+                [text, nil]
+              end
             end
 
             def official_prompt_payload(body, ctx, props, headers, expires_at)

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Ledger
-        VERSION = '0.3.1'
+        VERSION = '0.3.3'
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require 'digest'
 require 'securerandom'
 require 'legion/logging'
+require 'legion/extensions/llm/responses/thinking_extractor'
 require_relative '../helpers/json'
 require_relative '../helpers/persistence_logging'
 
@@ -42,8 +43,7 @@ module Legion
 
               db.transaction do
                 conversation = find_or_create_conversation(db, body)
-                user_message = find_or_create_user_message(db, conversation, body)
-                request = find_or_create_request(db, conversation, user_message, body)
+                request = find_or_create_request(db, conversation, nil, body)
                 response = find_or_create_response(db, request, nil, body)
                 metric = find_or_create_metric(db, request, response, body)
                 result = { result: :ok, request_id: request[:id], response_id: response[:id], metric_id: metric[:id] }
@@ -109,17 +109,14 @@ module Legion
             def find_or_create_request(db, conversation, latest_message, body)
               request_id = request_ref(body)
               existing = db[:llm_message_inference_requests].where(request_ref: request_id).first
-              if existing
-                enrich_request!(db, existing, body)
-                return existing
-              end
+              return enrich_request!(db, existing, body, latest_message) if existing
 
               operation = operation(body)
               caller_refs = caller_identity_refs(db, body)
               id = insert_with_savepoint(db, :llm_message_inference_requests, {
                                            uuid:                  stable_uuid(request_id),
                                            conversation_id:       conversation[:id],
-                                           latest_message_id:     latest_message[:id],
+                                           latest_message_id:     latest_message&.dig(:id),
                                            caller_principal_id:   caller_refs[:principal_id],
                                            caller_identity_id:    caller_refs[:identity_id],
                                            runtime_caller_type:   caller_type(body),
@@ -144,10 +141,7 @@ module Legion
             rescue Sequel::UniqueConstraintViolation => e
               log.debug("[ledger] request collision resolved request_ref=#{request_id} error=#{e.class}")
               existing = db[:llm_message_inference_requests].where(request_ref: request_id).first
-              if existing
-                enrich_request!(db, existing, body)
-                return existing
-              end
+              return enrich_request!(db, existing, body, latest_message) if existing
 
               raise
             end
@@ -252,7 +246,7 @@ module Legion
             end
 
             def find_or_create_metric(db, request, response, body)
-              metric_uuid = stable_uuid(reference(body, :message_id) || "metric:#{request_ref(body)}")
+              metric_uuid = stable_uuid(reference(body, :metric_id, :metric_ref) || "metric:#{request_ref(body)}")
               existing = db[:llm_message_inference_metrics].where(uuid: metric_uuid).first
               return existing if existing
 
@@ -287,7 +281,7 @@ module Legion
             end
 
             def insert_row(db, table, attributes, operation:)
-              Helpers::PersistenceLogging.insert_row(db, table, attributes, operation: operation)
+              Helpers::PersistenceLogging.insert_row(db, table, attributes, operation: operation, warn_on_unique: false)
             end
 
             def insert_with_savepoint(db, table, attributes, operation:)
@@ -309,8 +303,9 @@ module Legion
               db[:llm_messages].where(id: response_message[:id]).update(message_inference_response_id: response[:id])
             end
 
-            def enrich_request!(db, existing, body)
+            def enrich_request!(db, existing, body, latest_message = nil)
               updates = {}
+              update_if_missing(updates, existing, :latest_message_id, latest_message&.dig(:id))
               caller_refs = caller_identity_refs(db, body)
               updates[:caller_identity_id] = caller_refs[:identity_id] if existing[:caller_identity_id].nil? && caller_refs[:identity_id]
               updates[:caller_principal_id] = caller_refs[:principal_id] if existing[:caller_principal_id].nil? && caller_refs[:principal_id]
@@ -322,10 +317,11 @@ module Legion
               msg_count = Array(body.dig(:request, :messages) || body[:messages]).size
               updates[:context_message_count] = msg_count if existing[:context_message_count].to_i.zero? && msg_count.positive?
 
-              return if updates.empty?
+              return existing if updates.empty?
 
               db[:llm_message_inference_requests].where(id: existing[:id]).update(updates)
               log.info("[ledger] enriched request id=#{existing[:id]} fields=#{updates.keys.join(',')}")
+              existing.merge(updates)
             end
 
             def caller_identity(body)
@@ -585,18 +581,38 @@ module Legion
 
             def visible_response(body)
               response = body[:response] || body[:response_content] || body[:content] || {}
-              return { content: response } if response.is_a?(String)
+              if response.is_a?(String)
+                clean, _thinking = extract_inline_thinking(response)
+                return { content: clean }
+              end
               return { content: response[:content] } if response.is_a?(Hash) && response.key?(:content)
 
               response.is_a?(Hash) ? response.except(:thinking) : { content: response.to_s }
             end
 
             def thinking_response(body)
-              thinking = body[:response_thinking] || body[:thinking] || body.dig(:response, :thinking)
-              return {} if thinking.nil?
-              return { content: thinking } if thinking.is_a?(String)
+              thinking = body[:response_thinking] || body[:thinking]
+              thinking ||= body.dig(:response, :thinking) if body[:response].is_a?(Hash)
+              if thinking
+                return { content: thinking } if thinking.is_a?(String)
+
+                return thinking
+              end
 
-              thinking
+              content_str = body[:response_content] || body[:response] || body[:content]
+              return {} unless content_str.is_a?(String)
+
+              _clean, extracted = extract_inline_thinking(content_str)
+              extracted ? { content: extracted } : {}
+            end
+
+            def extract_inline_thinking(text)
+              if defined?(::Legion::Extensions::Llm::Responses::ThinkingExtractor)
+                extraction = ::Legion::Extensions::Llm::Responses::ThinkingExtractor.extract(text)
+                [extraction.content, extraction.thinking]
+              else
+                [text, nil]
+              end
             end
 
             def response_content(body)
@@ -604,7 +620,10 @@ module Legion
             end
 
             def finish_reason(body)
-              body[:finish_reason] || body.dig(:response, :finish_reason) || body.dig(:response, :stop, :reason)
+              return body[:finish_reason] if body[:finish_reason]
+              return nil unless body[:response].is_a?(Hash)
+
+              body.dig(:response, :finish_reason) || body.dig(:response, :stop, :reason)
             end
 
             def classification_level(body)

metadata

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