legion-llm 0.9.10 → 0.9.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3155d38fd745698ea1445e6d1d8b1824c4ce57c001f107ab2fc0036ee88c48a
-  data.tar.gz: 0baebdd6be604ae292502adda2168e5eb599cf4fa00e30e5f82b414ad271d016
+  metadata.gz: cc06bf006614fbb7a1052b368912ef58744e5b6509680c163c1b7ce0009e87d8
+  data.tar.gz: 91c96c5fee56c7fb4804ea3d58eb908cec12539a75eba11348e842be26509343
 SHA512:
-  metadata.gz: 7e3112d5a47dddcfe969867afe3e2cccc2d45029628a6b64c3098b7d8be2ba35908823bd9decd062eface61b2b9fded8e29710f8fcca094b00c19311a82eb211
-  data.tar.gz: 59f1a067e96bb527f46ed5b68f5e03c50aceeb8141ff91c06e89fdedfb17496359a6d50898a6fb2a8c9fd268b596ea23db858f4ee64f7e86ce22e04aefa0c56d
+  metadata.gz: fc3d9e91c66c0128bde4ffc434c19e6e75a21cb14a74cafe206235750ef402380a250c928358dfc7702f11f7259ffc46e5976a2abcf360c508bf8ceb7dca6033
+  data.tar.gz: 5d1a42619cc8e0d6e086b82245356b69790df2f7601313046e5d09e301ada70483f83ab53b4f6e592f5294c94f631904c7d46847131981542db173950e8e408c

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Legion LLM Changelog
 
+## [0.9.14] - 2026-05-08
+
+### Fixed
+- Guard discovery-first provider inference when the lightweight discovery namespace is loaded before the full discovery cache API.
+- Clean up publisher-identity review follow-up by making request identity fallback explicit and removing unused caller identity requires.
+
+## [0.9.13] - 2026-05-08
+
+### Fixed
+- Allow trigger-matched registry tools to reach native provider dispatch even when `Settings::Extensions` has no always-loaded tools registered.
+- Pass native dispatch options as top-level fleet request parameters so fleet providers receive `system`, `tools`, and offering metadata consistently with direct dispatch.
+
+## [0.9.12] - 2026-05-07
+
+### Fixed
+- Route LLM AMQP publisher identity, API fallback caller identity, prompt audit attribution, and metering attribution through the local `Legion::Identity::Process` identity instead of trusting request-supplied caller hashes.
+- Preserve request caller context separately from publisher identity headers, including prompt audit request caller type, skill events, escalation events, fleet envelopes, reflection ingest metadata, and privacy-blocked audit events.
+
+## [0.9.11] - 2026-05-07
+
+### Fixed
+- `infer_provider_for_model` now consults `Discovery.cached_discovered_models` before falling back to static regex patterns, so models reported by registered lex-llm-* providers route correctly regardless of naming convention.
+- Add Bedrock vendor prefix detection (`anthropic.`, `meta.`, `mistral.`, etc.) before the Ollama catch-all pattern to prevent Bedrock model IDs like `anthropic.claude-opus-4-5-20251101-v1:0` from being misrouted to Ollama due to the `:` in the version suffix.
+- `inferred_provider_tier` now checks `Call::Registry` metadata for the provider's tier before falling back to the static `PROVIDER_TIER` hash.
+- Restore `thinking` option in `native_dispatch_chat_options` where provider dispatch expects it.
+
 ## [0.9.10] - 2026-05-07
 
 ### Fixed

data/lib/legion/llm/api/native/helpers.rb

@@ -5,6 +5,7 @@ require 'open3'
 require 'time'
 require 'legion/cache/helper'
 require 'legion/logging/helper'
+require 'legion/llm/publisher_identity'
 require 'legion/llm/types'
 
 begin
@@ -390,8 +391,18 @@ module Legion
 
               define_method(:identity_canonical_name) do |rack_env|
                 request_identity = identity_request_from_env(rack_env)
-                name = request_identity&.canonical_name if request_identity.respond_to?(:canonical_name)
-                return name if name && name.to_s != ''
+                if request_identity.respond_to?(:to_caller_hash)
+                  caller_hash = request_identity.to_caller_hash
+                  requested_by = nil
+                  requested_by = caller_hash[:requested_by] || caller_hash['requested_by'] if caller_hash.is_a?(Hash)
+                  unless Legion::LLM::PublisherIdentity.generic_requested_by?(requested_by)
+                    name = requested_by[:identity] || requested_by['identity'] if requested_by.respond_to?(:key?)
+                    return name if name && name.to_s != ''
+                  end
+                end
+
+                publisher_identity = Legion::LLM::PublisherIdentity.requested_by[:identity]
+                return publisher_identity if publisher_identity && publisher_identity.to_s != ''
 
                 if defined?(Legion::Identity::Process) && Legion::Identity::Process.respond_to?(:canonical_name)
                   process_name = Legion::Identity::Process.canonical_name
@@ -408,16 +419,12 @@ module Legion
                   caller_hash = request_identity.to_caller_hash
                   if caller_hash.is_a?(Hash)
                     requested_by = caller_hash[:requested_by] || caller_hash['requested_by']
-                    return { requested_by: requested_by } if requested_by
+                    return { requested_by: requested_by } if requested_by && !Legion::LLM::PublisherIdentity.generic_requested_by?(requested_by)
                   end
                 end
 
                 {
-                  requested_by: {
-                    identity:   identity_canonical_name(rack_env),
-                    type:       :process,
-                    credential: :system
-                  }
+                  requested_by: Legion::LLM::PublisherIdentity.requested_by
                 }
               end
 

data/lib/legion/llm/audit.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
+require_relative 'publisher_identity'
 
 module Legion
   module LLM
@@ -19,6 +20,7 @@ module Legion
       module_function
 
       def emit_prompt(event)
+        event = attributed_event(event)
         if transport_connected? && defined?(Legion::LLM::Transport::Messages::PromptEvent)
           Legion::LLM::Transport::Messages::PromptEvent.new(**event).publish
           log.info('[llm][audit] published prompt audit')
@@ -33,6 +35,7 @@ module Legion
       end
 
       def emit_tools(event)
+        event = attributed_event(event)
         if transport_connected? && defined?(Legion::LLM::Transport::Messages::ToolEvent)
           Legion::LLM::Transport::Messages::ToolEvent.new(**event).publish
           log.info('[llm][audit] published tool audit')
@@ -47,6 +50,7 @@ module Legion
       end
 
       def emit_skill(**event)
+        event = attributed_event(event)
         if transport_connected? && defined?(Legion::LLM::Transport::Messages::SkillEvent)
           Legion::LLM::Transport::Messages::SkillEvent.new(**event).publish
           log.info('[llm][audit] published skill audit')
@@ -64,6 +68,13 @@ module Legion
         Legion::LLM::Settings.transport_connected?
       end
 
+      def attributed_event(event)
+        source = event.is_a?(Hash) ? event.dup : {}
+        source[:identity] = Legion::LLM::PublisherIdentity.current
+        source[:caller] ||= Legion::LLM::PublisherIdentity.caller_hash
+        source
+      end
+
       # Backward-compat: resolve old Legion::LLM::Audit::Exchange, ::PromptEvent, etc.
       def self.const_missing(name)
         case name

data/lib/legion/llm/fleet/dispatcher.rb

@@ -6,6 +6,7 @@ require 'time'
 require 'legion/extensions/llm/fleet/protocol'
 require 'legion/logging/helper'
 
+require_relative '../publisher_identity'
 require_relative 'token_issuer'
 
 module Legion
@@ -15,7 +16,7 @@ module Legion
         extend Legion::Logging::Helper
 
         ENVELOPE_KEYS = %i[
-          app_id caller correlation_id expires_at idempotency_key message_context operation
+          app_id caller correlation_id expires_at idempotency_key identity message_context operation
           model priority protocol_version provider provider_instance reply_to request_id routing_key
           signed_token timeout timeout_seconds trace_context ttl
         ].freeze
@@ -89,6 +90,7 @@ module Legion
             reply_to:          reply_to,
             message_context:   message_context || {},
             caller:            fetch_option(request_opts, :caller) || default_caller,
+            identity:          Legion::LLM::PublisherIdentity.current,
             trace_context:     fetch_option(request_opts, :trace_context) || {},
             timeout_seconds:   timeout,
             expires_at:        (Time.now.utc + timeout).iso8601,
@@ -293,7 +295,11 @@ module Legion
         end
 
         def default_caller
-          { source: 'legion-llm', component: 'fleet_dispatcher' }
+          {
+            source:       'legion-llm',
+            component:    'fleet_dispatcher',
+            requested_by: Legion::LLM::PublisherIdentity.requested_by
+          }
         end
       end
     end

data/lib/legion/llm/fleet/handler.rb

@@ -4,6 +4,7 @@ require 'legion/extensions/llm/fleet/protocol'
 require 'legion/logging/helper'
 
 require_relative '../call/registry'
+require_relative '../publisher_identity'
 require_relative 'worker_execution'
 
 module Legion
@@ -73,6 +74,8 @@ module Legion
             reply_to:          envelope[:reply_to],
             message_context:   envelope[:message_context] || {},
             trace_context:     envelope[:trace_context] || {},
+            caller:            envelope[:caller],
+            identity:          Legion::LLM::PublisherIdentity.current,
             content:           response_content(response),
             tool_calls:        response_tool_calls(response),
             usage:             response_usage(response),
@@ -96,12 +99,14 @@ module Legion
             reply_to:          envelope[:reply_to],
             message_context:   envelope[:message_context] || {},
             trace_context:     envelope[:trace_context] || {},
+            caller:            envelope[:caller],
+            identity:          Legion::LLM::PublisherIdentity.current,
             message:           error.message,
             error_class:       error.class.name
           }.compact
         end
 
-        def publish_response(_envelope, result)
+        def publish_response(envelope, result)
           require 'legion/extensions/llm/transport/messages/fleet_response'
           publish_result = ::Legion::Extensions::Llm::Transport::Messages::FleetResponse.new(
             protocol_version:  result[:protocol_version],
@@ -115,6 +120,8 @@ module Legion
             reply_to:          result[:reply_to],
             message_context:   result[:message_context],
             trace_context:     result[:trace_context],
+            caller:            envelope[:caller],
+            identity:          Legion::LLM::PublisherIdentity.current,
             content:           result[:content],
             tool_calls:        result[:tool_calls],
             usage:             result[:usage],
@@ -127,7 +134,7 @@ module Legion
           handle_exception(e, level: :warn, operation: 'llm.fleet.handler.publish_response')
         end
 
-        def publish_error(_envelope, result)
+        def publish_error(envelope, result)
           require 'legion/extensions/llm/transport/messages/fleet_error'
           publish_result = ::Legion::Extensions::Llm::Transport::Messages::FleetError.new(
             protocol_version:  result[:protocol_version],
@@ -141,6 +148,8 @@ module Legion
             reply_to:          result[:reply_to],
             message_context:   result[:message_context],
             trace_context:     result[:trace_context],
+            caller:            envelope[:caller],
+            identity:          Legion::LLM::PublisherIdentity.current,
             code:              result[:error],
             message:           result[:message],
             error_class:       result[:error_class],

data/lib/legion/llm/hooks/reflection.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
+require_relative '../publisher_identity'
 module Legion
   module LLM
     module Hooks
@@ -166,7 +167,11 @@ module Legion
                                   knowledge_domain: 'reflection',
                                   confidence:       entry[:confidence],
                                   source_agent:     "llm:#{model}",
-                                  metadata:         { context: entry[:context], source: 'reflection_hook' }
+                                  metadata:         {
+                                    context:      entry[:context],
+                                    source:       'reflection_hook',
+                                    submitted_by: Legion::LLM::PublisherIdentity.requested_by
+                                  }
                                 })
             )
             log.info("[llm][reflection] published via=transport model=#{model} type=#{entry[:type]}")
@@ -176,7 +181,8 @@ module Legion
               content_type:     entry[:type].to_s,
               knowledge_domain: 'reflection',
               confidence:       entry[:confidence],
-              source_agent:     "llm:#{model}"
+              source_agent:     "llm:#{model}",
+              metadata:         { submitted_by: Legion::LLM::PublisherIdentity.requested_by }
             )
             log.info("[llm][reflection] published via=direct model=#{model} type=#{entry[:type]}")
           end

data/lib/legion/llm/inference/audit_publisher.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
-require_relative '../caller_identity'
+require_relative '../publisher_identity'
 module Legion
   module LLM
     module Inference
@@ -65,8 +65,8 @@ module Legion
           nil
         end
 
-        def extract_identity(caller)
-          Legion::LLM::CallerIdentity.normalize(caller: caller)
+        def extract_identity(_caller)
+          Legion::LLM::PublisherIdentity.current
         end
 
         def serialize_tokens(tokens)

data/lib/legion/llm/inference/executor.rb

@@ -3,7 +3,7 @@
 require 'concurrent'
 require 'faraday'
 
-require_relative '../caller_identity'
+require_relative '../publisher_identity'
 require_relative 'route_attempts'
 
 module Legion
@@ -142,6 +142,9 @@ module Legion
 
         def inferred_provider_tier(provider)
           return nil unless provider
+
+          meta = Call::Registry.metadata_for(provider, @resolved_instance || :default)
+          return meta[:tier].to_sym if meta.is_a?(Hash) && meta[:tier]
           return Router.provider_tier(provider) if defined?(Router) && Router.respond_to?(:provider_tier)
 
           Router::PROVIDER_TIER.fetch(provider.to_sym, :cloud) if defined?(Router::PROVIDER_TIER)
@@ -650,10 +653,7 @@ module Legion
         end
 
         def native_dispatch_chat_options
-          opts = {
-            model:    @resolved_model,
-            provider: @resolved_provider
-          }
+          opts = { model: @resolved_model, provider: @resolved_provider }
           opts[:instance] = @resolved_instance if @resolved_instance
           opts[:thinking] = @request.thinking if @request.thinking
           opts.compact
@@ -729,8 +729,8 @@ module Legion
 
         def add_registry_tool_definitions(definitions)
           return unless Legion::Settings::Extensions.respond_to?(:tools) &&
-                        Legion::Settings::Extensions.respond_to?(:filter_tools) &&
-                        Array(Legion::Settings::Extensions.tools).any?
+                        Legion::Settings::Extensions.respond_to?(:filter_tools)
+          return unless Array(Legion::Settings::Extensions.tools).any? || @triggered_tools.any?
 
           add_settings_extensions_tool_definitions(definitions)
         rescue StandardError => e
@@ -1418,8 +1418,7 @@ module Legion
         end
 
         def metering_identity
-          top_id = @request.respond_to?(:metadata) ? @request.metadata[:identity] || @request.metadata['identity'] : nil
-          Legion::LLM::CallerIdentity.normalize(caller: @request.caller, identity: top_id)
+          Legion::LLM::PublisherIdentity.current
         end
 
         def step_context_store

data/lib/legion/llm/inference/route_attempts.rb

@@ -96,11 +96,10 @@ module Legion
             model:             @resolved_model,
             idempotency_key:   idempotency_key,
             messages:          messages,
-            options:           native_dispatch_options,
             caller:            @request.caller,
             trace_context:     @tracing || {},
             timeout:           @request.ttl
-          }.compact
+          }.merge(native_dispatch_options).compact
         end
 
         def normalize_fleet_result(result)

data/lib/legion/llm/inference.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'legion/logging/helper'
+require_relative 'publisher_identity'
 require_relative 'metering/usage'
 require_relative 'inference/request'
 require_relative 'inference/response'
@@ -589,7 +590,7 @@ module Legion
           return response if response
         end
 
-        publish_escalation_event(history, :exhausted) if history.size > 1
+        publish_escalation_event(history, :exhausted, caller: kwargs[:caller]) if history.size > 1
         message = "All #{history.size} escalation attempts failed"
         if last_error
           providers = history.filter_map { |attempt| attempt[:provider] }.uniq.join(', ')
@@ -608,7 +609,8 @@ module Legion
         duration_ms = ((Time.now - start_time) * 1000).round
         result = Quality::Checker.check(response, quality_threshold: threshold, quality_check: quality_check)
 
-        return [response, nil] if escalation_attempt_passed?(response, result, resolution, duration_ms, history, chain)
+        return [response, nil] if escalation_attempt_passed?(response, result, resolution, duration_ms, history, chain,
+                                                             caller: kwargs[:caller])
 
         report_health(:quality_failure, resolution, duration_ms, failures: result.failures)
         history << build_attempt(resolution, :quality_failure, result.failures, duration_ms)
@@ -630,13 +632,13 @@ module Legion
                            **opts.except(:model, :provider))
       end
 
-      def escalation_attempt_passed?(response, result, resolution, duration_ms, history, chain)
+      def escalation_attempt_passed?(response, result, resolution, duration_ms, history, chain, caller: nil)
         return false unless result.passed
 
         report_health(:success, resolution, duration_ms)
         history << build_attempt(resolution, :success, [], duration_ms)
         attach_escalation_history(response, history, resolution, chain)
-        publish_escalation_event(history, :success) if history.size > 1
+        publish_escalation_event(history, :success, caller: caller) if history.size > 1
         log.debug "[llm][inference] chat_with_escalation success attempts=#{history.size}"
         true
       end
@@ -683,11 +685,12 @@ module Legion
                                      signal: :latency, value: duration_ms, metadata: {})
       end
 
-      def publish_escalation_event(history, final_outcome)
+      def publish_escalation_event(history, final_outcome, caller: nil)
         payload = {
           outcome:   final_outcome,
           attempts:  history.size,
           history:   history,
+          caller:    caller || Legion::LLM::PublisherIdentity.caller_hash,
           timestamp: Time.now.utc.iso8601
         }
 
@@ -775,7 +778,7 @@ module Legion
 
       def emit_privacy_blocked_audit
         Legion::LLM::Audit.emit_prompt(
-          request_id: nil, conversation_id: nil, caller: nil,
+          request_id: nil, conversation_id: nil, caller: Legion::LLM::PublisherIdentity.caller_hash,
           routing: {}, tokens: {}, status: 'privacy_blocked',
           error: { class: 'PrivacyModeError', message: 'External tiers blocked by enterprise privacy' },
           timestamp: Time.now, request_type: 'chat'

data/lib/legion/llm/metering.rb

@@ -5,6 +5,7 @@ require_relative 'metering/estimator'
 require_relative 'metering/tracker'
 require_relative 'metering/tokens'
 require_relative 'metering/usage'
+require_relative 'publisher_identity'
 
 module Legion
   module LLM
@@ -24,6 +25,7 @@ module Legion
       module_function
 
       def emit(event)
+        event = attributed_event(event)
         event_class = metering_event_class if transport_connected?
 
         if event_class
@@ -47,6 +49,13 @@ module Legion
         :dropped
       end
 
+      def attributed_event(event)
+        source = event.is_a?(Hash) ? event.dup : {}
+        source[:identity] = Legion::LLM::PublisherIdentity.current
+        source[:caller] ||= Legion::LLM::PublisherIdentity.caller_hash
+        source
+      end
+
       def flush_spool
         return 0 unless spool_available? && transport_connected?
 
@@ -64,7 +73,7 @@ module Legion
       end
 
       def install_hook
-        Legion::LLM::Hooks.after_chat do |response:, model:, **|
+        Legion::LLM::Hooks.after_chat do |response:, model:, caller: nil, **|
           usage = extract_usage(response)
           next if usage[:input_tokens].zero? && usage[:output_tokens].zero?
 
@@ -83,6 +92,7 @@ module Legion
             model_id:      resolved_model,
             input_tokens:  usage[:input_tokens],
             output_tokens: usage[:output_tokens],
+            caller:        caller,
             event_type:    'llm_completion',
             status:        response.is_a?(Hash) && response[:error] ? 'failure' : 'success'
           )

data/lib/legion/llm/publisher_identity.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'caller_identity'
+
+module Legion
+  module LLM
+    module PublisherIdentity
+      GENERIC_PUBLISHER_IDENTITIES = %w[
+        anonymous process:anonymous service:system system system:system unknown:anonymous
+      ].freeze
+
+      module_function
+
+      def current
+        process = process_identity_module
+        identity = process_identity(process)
+        return identity if present_identity?(identity)
+
+        env_identity
+      end
+
+      def caller_hash
+        identity = current
+        {
+          requested_by: {
+            identity:   identity[:identity],
+            type:       identity[:type],
+            credential: identity[:credential],
+            hostname:   identity[:hostname]
+          }.compact
+        }
+      end
+
+      def requested_by
+        caller_hash[:requested_by]
+      end
+
+      def generic_requested_by?(value)
+        requested = value.is_a?(Hash) ? value : {}
+        raw_id = hash_value(requested, :id).to_s
+        return true if raw_id == 'system:system'
+
+        identity = CallerIdentity.normalize(caller: { requested_by: requested })
+        normalized = identity[:identity].to_s
+        GENERIC_PUBLISHER_IDENTITIES.include?(normalized)
+      end
+
+      def process_identity_module
+        return Legion::Identity::Process if defined?(Legion::Identity::Process)
+
+        begin
+          require 'legion/identity/process'
+        rescue LoadError
+          nil
+        end
+
+        defined?(Legion::Identity::Process) ? Legion::Identity::Process : nil
+      end
+
+      def process_identity(process)
+        return nil unless process
+
+        canonical = process_value(process, :canonical_name)
+        return nil unless present?(canonical)
+
+        CallerIdentity.normalize(
+          caller: {
+            requested_by: {
+              identity:   canonical,
+              type:       process_value(process, :kind) || :process,
+              credential: process_value(process, :source) || :system,
+              hostname:   process_value(process, :hostname)
+            }.compact
+          }
+        )
+      end
+
+      def env_identity
+        raw = ENV.fetch('USER', nil) || ENV.fetch('LOGNAME', nil)
+        return CallerIdentity::DEFAULT_IDENTITY.dup unless present?(raw)
+
+        CallerIdentity.normalize(
+          caller: {
+            requested_by: {
+              identity:   raw.to_s,
+              type:       :human,
+              credential: :system
+            }
+          }
+        )
+      end
+
+      def process_value(process, method_name)
+        return nil unless process.respond_to?(method_name)
+
+        process.public_send(method_name)
+      rescue StandardError
+        nil
+      end
+
+      def hash_value(hash, key)
+        return nil unless hash.respond_to?(:key?)
+        return hash[key] if hash.key?(key)
+
+        string_key = key.to_s
+        hash[string_key] if hash.key?(string_key)
+      end
+
+      def present_identity?(identity)
+        identity.is_a?(Hash) && present?(identity[:identity])
+      end
+
+      def present?(value)
+        !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+      end
+    end
+  end
+end

data/lib/legion/llm/router.rb

@@ -28,8 +28,12 @@ module Legion
         def infer_provider_for_model(model)
           return nil if model.nil? || model.to_s.empty?
 
+          discovered = discover_provider_for_model(model)
+          return discovered if discovered
+
           model_s = model.to_s
           return :bedrock if model_s.start_with?('us.')
+          return :bedrock if model_s.match?(/\A(anthropic|meta|mistral|cohere|amazon|ai21)\./i)
           return :openai if model_s.match?(/\Agpt-|\Ao[134]-/)
           return :anthropic if model_s.start_with?('claude-')
           return :gemini if model_s.start_with?('gemini-')
@@ -38,6 +42,17 @@ module Legion
           nil
         end
 
+        def discover_provider_for_model(model)
+          return nil unless defined?(Discovery) && Discovery.respond_to?(:cached_discovered_models)
+
+          model_s = model.to_s
+          entry = Array(Discovery.cached_discovered_models).find do |m|
+            dn = m[:model].to_s
+            dn == model_s || dn.start_with?("#{model_s}:")
+          end
+          entry&.dig(:provider)
+        end
+
         # Resolve an LLM routing intent to a tier/provider/model decision.
         #
         # @param intent   [Hash, nil] routing intent (capability, privacy, etc.)

data/lib/legion/llm/skills/base.rb

@@ -132,7 +132,7 @@ module Legion
             total_duration += duration_ms
             inject_parts << result.inject if result.inject
 
-            emit_step_success(conv_id, method_name, step_idx, duration_ms, result, classification)
+            emit_step_success(conv_id, method_name, step_idx, duration_ms, result, classification, context)
 
             next unless result.gate
 
@@ -154,14 +154,21 @@ module Legion
 
         private
 
+        def context_caller(context)
+          return nil unless context.is_a?(Hash)
+
+          context[:caller] || context['caller']
+        end
+
         def execute_step(method_name, step_idx, context, conv_id, classification)
           t0 = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+          caller = context_caller(context)
           emit_event(conv_id, 'skill.step.started',
                      step_name: method_name, step_index: step_idx)
           Legion::LLM::Metering.emit(
             request_type: 'skill.step.start', skill_name: self.class.skill_name,
             namespace: self.class.namespace, step_name: method_name,
-            step_index: step_idx, tier: 'local'
+            step_index: step_idx, tier: 'local', caller: caller
           )
           result = public_send(method_name, context: context)
           unless result.respond_to?(:inject) && result.respond_to?(:metadata) && result.respond_to?(:gate)
@@ -175,10 +182,11 @@ module Legion
           [result, duration_ms]
         rescue StandardError => e
           duration_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - t0) * 1000).round
-          handle_step_error(e, method_name, step_idx, conv_id, duration_ms, classification)
+          handle_step_error(e, method_name, step_idx, conv_id, duration_ms, classification, context)
         end
 
-        def handle_step_error(err, method_name, step_idx, conv_id, duration_ms, classification)
+        def handle_step_error(err, method_name, step_idx, conv_id, duration_ms, classification, context)
+          caller = context_caller(context)
           Legion::LLM::Inference::Conversation.clear_skill_state(conv_id) if conv_id
           emit_event(conv_id, 'skill.step.failed',
                      step_name: method_name, error: err.message)
@@ -186,19 +194,20 @@ module Legion
             skill_name: self.class.skill_name, namespace: self.class.namespace,
             step_name: method_name, gate: nil, status: :failed,
             duration_ms: duration_ms, metadata: { error: err.message },
-            classification: classification
+            classification: classification, caller: caller
           )
           Legion::LLM::Metering.emit(
             request_type: 'skill.step', skill_name: self.class.skill_name,
             namespace: self.class.namespace, step_name: method_name,
-            step_index: step_idx, duration_ms: duration_ms, gate: nil, tier: 'local'
+            step_index: step_idx, duration_ms: duration_ms, gate: nil, tier: 'local', caller: caller
           )
           raise Legion::LLM::Skills::StepError.new(
             "#{self.class.skill_name}##{method_name} failed: #{err.message}", cause: err
           )
         end
 
-        def emit_step_success(conv_id, method_name, step_idx, duration_ms, result, classification)
+        def emit_step_success(conv_id, method_name, step_idx, duration_ms, result, classification, context)
+          caller = context_caller(context)
           emit_event(conv_id, 'skill.step.completed',
                      step_name: method_name, duration_ms: duration_ms,
                      metadata: result.metadata)
@@ -206,13 +215,13 @@ module Legion
             skill_name: self.class.skill_name, namespace: self.class.namespace,
             step_name: method_name, gate: result.gate,
             status: :completed, duration_ms: duration_ms,
-            metadata: result.metadata, classification: classification
+            metadata: result.metadata, classification: classification, caller: caller
           )
           Legion::LLM::Metering.emit(
             request_type: 'skill.step', skill_name: self.class.skill_name,
             namespace: self.class.namespace, step_name: method_name,
             step_index: step_idx, duration_ms: duration_ms,
-            gate: result.gate&.to_s, tier: 'local'
+            gate: result.gate&.to_s, tier: 'local', caller: caller
           )
         end
 

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

@@ -3,7 +3,7 @@
 require 'securerandom'
 require 'uri'
 require 'legion/logging/helper'
-require_relative '../caller_identity'
+require_relative '../publisher_identity'
 
 module Legion
   module LLM
@@ -209,7 +209,7 @@ module Legion
         end
 
         def identity_headers
-          identity = Legion::LLM::CallerIdentity.normalize(caller: @options[:caller], identity: @options[:identity])
+          identity = Legion::LLM::PublisherIdentity.current
           return {} unless identity
 
           h = {}

data/lib/legion/llm/transport/messages/prompt_event.rb

@@ -43,7 +43,7 @@ module Legion
             type        = caller_info[:type] || caller_info['type'] || top_id[:type] || top_id['type'] ||
                           (extension && 'extension')
             h = {}
-            h['x-legion-caller-type'] = type.to_s if type
+            h['x-legion-request-caller-type'] = type.to_s if type
             h
           end
 

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.10'
+    VERSION = '0.9.14'
   end
 end

data/lib/legion/llm.rb

@@ -9,6 +9,7 @@ require_relative 'llm/version'
 require_relative 'llm/errors'
 require_relative 'llm/settings'
 require_relative 'llm/caller_identity'
+require_relative 'llm/publisher_identity'
 require_relative 'llm/call/providers'
 require_relative 'llm/call/registry'
 require_relative 'llm/call/lex_llm_adapter'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.9.10
+  version: 0.9.14
 platform: ruby
 authors:
 - Esity
@@ -294,6 +294,7 @@ files:
 - lib/legion/llm/metering/tokens.rb
 - lib/legion/llm/metering/tracker.rb
 - lib/legion/llm/metering/usage.rb
+- lib/legion/llm/publisher_identity.rb
 - lib/legion/llm/quality.rb
 - lib/legion/llm/quality/checker.rb
 - lib/legion/llm/quality/confidence/score.rb