legion-llm 0.8.23 → 0.8.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bea0deb0330e257b0a513675970bd988c5b157170e1bf46569482e9203578681
-  data.tar.gz: 9af8c0c5e9d6911f95f738bfd840c3dd1989e2503da7042357332e1c394fe930
+  metadata.gz: 6b37f926f357a862c036b2e3d4676b579ae505ba6f76b7b7da332ba3aeeed8ac
+  data.tar.gz: 59ab5db376ac8be2a45cda642dec1d22c8eda3e76782b9f2cd5689233bcc2063
 SHA512:
-  metadata.gz: ff80717d479fb79c9c2ea60123828b50c218ce549d90c7d6a9605885c8791c1a078c48a232d4b5437213c904206c326d7b832348eabf694caef8e7cb30abdfcd
-  data.tar.gz: d81969d08b0dd13e6447a662aaeb4c4a0c43fe07cfe3e4a2af328bd30ab9d09df0e817a6ffaa8b296e44ebdb00d4a4f2b70f55a3f86c59e1f8b18c0207fb4da2
+  metadata.gz: 6994e774e6a0551c720ef0a2c7a5aa4681f324c9e8c09a624ca2e227565cd87ca26f1457ed108967ae3e17593e6a5ee8df7fdf20515aa0ccdd277f2eb16db827
+  data.tar.gz: 815d14a99f379c2d655341776507e96be1625582b4fd4989597c4c299a1086be394dbad785b4b33e2d1423419a37ea37392ee617fa75fbb88208dac6d6864bce

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Legion LLM Changelog
 
+## [0.8.25] - 2026-04-24
+
+### Fixed
+- `StructuredOutput.generate`, `handle_parse_error`, and `retry_with_instruction` used hash-style access (`result[:content]`, `result[:model]`) on the return value of `chat_single`, but `chat_single` returns a `RubyLLM::Message` object which only supports method access (`.content`, `.model_id`). All four access sites now use `respond_to?` duck-typing so both hash and Message objects work. Visible as `undefined method '[]' for an instance of RubyLLM::Message` in Apollo's `llm_detects_conflict?` and any structured output caller using non-schema-capable models (e.g. ollama/qwen).
+- `Call::Embeddings.generate` crashed with `NoMethodError` on `.size` when `response.vectors` was a flat array (`[0.007, ...]`) instead of nested (`[[0.007, ...]]`). RubyLLM's OpenAI provider unwraps single-input embedding responses. Added `normalize_vectors_first` to detect and handle both flat and nested vector formats before dimension enforcement.
+
+## [0.8.24] - 2026-04-23
+
+### Fixed
+- All AMQP transport messages (audit, metering, tool, escalation) now include identity headers (`x-legion-identity`, `x-legion-credential`, `x-legion-hostname`) extracted from the `caller` field. Previously only prompt audit events carried identity in the body — tool audit and metering messages had no identity at all.
+- Embedding metering events now include `caller` context.
+- Non-pipeline `chat_single` metering events now include `caller` context from kwargs.
+
 ## [0.8.23] - 2026-04-23
 
 ### Fixed

data/lib/legion/llm/call/embeddings.rb

@@ -27,7 +27,8 @@ module Legion
 
             response = RubyLLM.embed(text, **build_opts(model, provider, dimensions))
             emit_embedding_metering(provider: provider, model: model, tokens: response.input_tokens)
-            vector = apply_dimension_enforcement(response.vectors.first, provider)
+            vector = normalize_vectors_first(response.vectors)
+            vector = apply_dimension_enforcement(vector, provider)
             return dimension_error(model, provider, vector) if vector.is_a?(String)
 
             { vector: vector, model: model, provider: provider, dimensions: vector&.size || 0, tokens: response.input_tokens }
@@ -101,6 +102,16 @@ module Legion
             opts
           end
 
+          def normalize_vectors_first(vectors)
+            return nil if vectors.nil? || (vectors.is_a?(Array) && vectors.empty?)
+
+            first = vectors.first
+            return first if first.is_a?(Array)
+            return vectors if vectors.is_a?(Array) && vectors.first.is_a?(Numeric)
+
+            first
+          end
+
           def apply_dimension_enforcement(vector, provider)
             return vector unless enforce_dimension? && vector.is_a?(Array)
 
@@ -462,9 +473,16 @@ module Legion
           end
 
           def emit_embedding_metering(provider:, model:, tokens:)
+            caller = begin
+              Legion::LLM.settings[:caller]
+            rescue StandardError => e
+              handle_exception(e, level: :debug, operation: 'llm.embeddings.metering.caller')
+              nil
+            end
             Legion::LLM::Metering.emit(
               provider: provider, model_id: model, request_type: 'embed',
-              tier: 'cloud', input_tokens: tokens.to_i, output_tokens: 0, total_tokens: tokens.to_i
+              tier: 'cloud', input_tokens: tokens.to_i, output_tokens: 0, total_tokens: tokens.to_i,
+              caller: caller
             )
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'llm.embeddings.metering')

data/lib/legion/llm/call/structured_output.rb

@@ -15,8 +15,11 @@ module Legion
             result = call_with_schema(messages, schema, model, provider: provider, **)
             log.info "[llm][structured_output] model=#{model} provider=#{provider} valid=true"
 
-            parsed = Legion::JSON.load(result[:content])
-            { data: parsed, raw: result[:content], model: result[:model], valid: true }
+            content = result.respond_to?(:content) ? result.content : result[:content]
+            raw_model = result.respond_to?(:model_id) ? result.model_id : result[:model]
+
+            parsed = Legion::JSON.load(content)
+            { data: parsed, raw: content, model: raw_model, valid: true }
           rescue ::JSON::ParserError => e
             log.warn "[llm][structured_output] model=#{model} provider=#{provider} parse_error=#{e.message}"
             handle_parse_error(e, messages, schema, model, provider, result, **)
@@ -49,7 +52,8 @@ module Legion
             if retry_enabled? && attempt < max_retries
               retry_with_instruction(messages, schema, model, provider: provider, attempt: attempt + 1, **opts)
             else
-              { data: nil, error: "JSON parse failed: #{error.message}", raw: result&.dig(:content), valid: false }
+              raw = result.respond_to?(:content) ? result&.content : result&.dig(:content)
+              { data: nil, error: "JSON parse failed: #{error.message}", raw: raw, valid: false }
             end
           end
 
@@ -60,8 +64,11 @@ module Legion
                                                  model: model, provider: provider, intent: nil, tier: nil,
                                                  message: user_content, **opts.except(:attempt))
 
-            parsed = Legion::JSON.load(result[:content])
-            { data: parsed, raw: result[:content], model: result[:model], valid: true, retried: true }
+            retry_content = result.respond_to?(:content) ? result.content : result[:content]
+            retry_model = result.respond_to?(:model_id) ? result.model_id : result[:model]
+
+            parsed = Legion::JSON.load(retry_content)
+            { data: parsed, raw: retry_content, model: retry_model, valid: true, retried: true }
           rescue StandardError => e
             handle_exception(e, level: :warn)
             { data: nil, error: e.message, valid: false }

data/lib/legion/llm/inference.rb

@@ -514,7 +514,7 @@ module Legion
         log.debug '[llm][inference] chat_single asking session'
         response = block ? session.ask(message, &block) : session.ask(message)
         log.debug "[llm][inference] chat_single response_class=#{response.class} response_nil=#{response.nil?}"
-        emit_non_pipeline_metering(response, model: opts[:model], provider: opts[:provider])
+        emit_non_pipeline_metering(response, model: opts[:model], provider: opts[:provider], caller: kwargs[:caller])
 
         if response && !block && defined?(Quality::ShadowEval) && Quality::ShadowEval.enabled?
           msgs = session.respond_to?(:messages) ? session.messages : nil
@@ -712,14 +712,15 @@ module Legion
         esc.fetch(:quality_threshold, 50)
       end
 
-      def emit_non_pipeline_metering(response, model:, provider:)
+      def emit_non_pipeline_metering(response, model:, provider:, caller: nil)
         return unless response
 
         input  = response.respond_to?(:input_tokens)  ? response.input_tokens.to_i  : 0
         output = response.respond_to?(:output_tokens) ? response.output_tokens.to_i : 0
         Legion::LLM::Metering.emit(
           provider: provider, model_id: model, request_type: 'chat',
-          tier: 'direct', input_tokens: input, output_tokens: output, total_tokens: input + output
+          tier: 'direct', input_tokens: input, output_tokens: output, total_tokens: input + output,
+          caller: caller
         )
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.inference.non_pipeline_metering')

data/lib/legion/llm/transport/message.rb

@@ -65,6 +65,19 @@ module Legion
           h['x-legion-llm-model']          = model_val.to_s                     if model_val
           h['x-legion-llm-request-type']   = @options[:request_type].to_s       if @options[:request_type]
           h['x-legion-llm-schema-version'] = '1.0.0'
+          h.merge(identity_headers)
+        end
+
+        def identity_headers
+          caller = @options[:caller]
+          return {} unless caller.is_a?(Hash)
+
+          rb = caller[:requested_by] || caller['requested_by'] || {}
+          h = {}
+          identity = rb[:identity] || rb['identity'] || rb[:username] || rb['username']
+          h['x-legion-identity']   = identity.to_s   if identity
+          h['x-legion-credential'] = (rb[:credential] || rb['credential']).to_s if rb[:credential] || rb['credential']
+          h['x-legion-hostname']   = (rb[:hostname] || rb['hostname']).to_s     if rb[:hostname] || rb['hostname']
           h
         end
 

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.8.23'
+    VERSION = '0.8.25'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.8.23
+  version: 0.8.25
 platform: ruby
 authors:
 - Esity