legion-llm 0.9.10 → 0.9.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3155d38fd745698ea1445e6d1d8b1824c4ce57c001f107ab2fc0036ee88c48a
-  data.tar.gz: 0baebdd6be604ae292502adda2168e5eb599cf4fa00e30e5f82b414ad271d016
+  metadata.gz: 206afbe8609bb8ed7df111d216967aafba55b0d523d5939aad024f169e43f5ef
+  data.tar.gz: 283f42c3d5b9ba07aa7857aad3e6d1f30b7559f35282f4a1d00986ea4ab2c646
 SHA512:
-  metadata.gz: 7e3112d5a47dddcfe969867afe3e2cccc2d45029628a6b64c3098b7d8be2ba35908823bd9decd062eface61b2b9fded8e29710f8fcca094b00c19311a82eb211
-  data.tar.gz: 59f1a067e96bb527f46ed5b68f5e03c50aceeb8141ff91c06e89fdedfb17496359a6d50898a6fb2a8c9fd268b596ea23db858f4ee64f7e86ce22e04aefa0c56d
+  metadata.gz: 54b3e821013f9ba6f73019907821e85d1aaacc766e8942767f5e6a9630d66757c1d16a8e1b6643054895b1e5de229245e45ebf562f42bdec1cfac8f609024a5c
+  data.tar.gz: 45d349d01bef14e68527aa0c8108c4d08f71e05b63c87c331e377703bdacfcee431b903fe72dc2ad48b10c2f73a67523e9c67a0da1dd46b4b9cf3e041c290671

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Legion LLM Changelog
 
+## [0.9.15] - 2026-05-08
+
+### Fixed
+- Normalize structured user message content before RAG query handling, preventing multipart API messages from crashing trivial-query detection or reaching Apollo as arrays.
+- Normalize empty string tool-call arguments to `{}` and make sticky tool history tolerate non-hash argument payloads without dropping state writes.
+- Pass non-executable API client tool calls through to callers as streaming `tool-call` events instead of dispatching them server-side as failed tool executions.
+- Add runtime logging for client tool receipt, native tool injection summaries, registry-injection skips, and returned tool-call SSE emission.
+
+## [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
@@ -346,6 +347,56 @@ module Legion
                 stream << "event: #{event_name}\ndata: #{Legion::JSON.dump(payload)}\n\n"
               end
 
+              define_method(:emit_response_tool_call_events) do |stream, pipeline_response|
+                tool_calls = extract_tool_calls(pipeline_response)
+                return if tool_calls.empty?
+
+                timeline_tool_call_ids = Array(pipeline_response.timeline).filter_map do |event|
+                  key = event[:key].to_s
+                  next unless key.start_with?('tool:execute:')
+
+                  data = event[:data].is_a?(Hash) ? event[:data] : {}
+                  data[:tool_call_id] || data['tool_call_id']
+                end
+
+                emitted = 0
+                skipped_timeline = 0
+                request_id = pipeline_response.respond_to?(:request_id) ? pipeline_response.request_id : 'unknown'
+                conversation_id = pipeline_response.respond_to?(:conversation_id) ? pipeline_response.conversation_id : 'none'
+
+                tool_calls.each do |tool_call|
+                  tool_call_id = tool_call[:id] || tool_call['id']
+                  if tool_call_id && timeline_tool_call_ids.include?(tool_call_id)
+                    skipped_timeline += 1
+                    next
+                  end
+
+                  tool_name = tool_call[:name] || tool_call['name']
+                  next if tool_name.to_s.empty?
+
+                  log.info(
+                    "[llm][api][tools] action=returned_tool_call_sse request_id=#{request_id || 'unknown'} " \
+                    "conversation_id=#{conversation_id || 'none'} tool_call_id=#{tool_call_id || 'none'} name=#{tool_name} " \
+                    "args_class=#{(tool_call[:arguments] || tool_call['arguments'] || {}).class}"
+                  )
+                  emit_sse_event(stream, 'tool-call', {
+                                   toolCallId: tool_call_id,
+                                   toolName:   tool_name,
+                                   args:       tool_call[:arguments] || tool_call['arguments'] || {},
+                                   timestamp:  Time.now.utc.iso8601
+                                 })
+                  emitted += 1
+                end
+
+                names = tool_calls.map { |tool_call| tool_call[:name] || tool_call['name'] }.compact
+                names = names.first(30).join(',') + (names.size > 30 ? ",+#{names.size - 30}more" : '')
+                log.info(
+                  "[llm][api][tools] action=returned_tool_calls_complete request_id=#{request_id || 'unknown'} " \
+                  "conversation_id=#{conversation_id || 'none'} total=#{tool_calls.size} emitted=#{emitted} " \
+                  "skipped_timeline=#{skipped_timeline} names=#{names.empty? ? 'none' : names}"
+                )
+              end
+
               define_method(:emit_timeline_tool_events) do |stream, pipeline_response, skip_tool_results: false|
                 timeline = Array(pipeline_response.timeline)
                 log.debug("[llm][api][helpers] emit_timeline_tool_events count=#{timeline.size} skip_tool_results=#{skip_tool_results}")
@@ -390,8 +441,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 +469,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/api/native/inference.rb

@@ -72,7 +72,13 @@ module Legion
                 build_client_tool_class(ts[:name].to_s, ts[:description].to_s, ts[:parameters] || ts[:input_schema])
               end
 
-              log.debug("[llm][api][inference] action=tools_built client_tools=#{tool_declarations.size}")
+              client_tool_names = tool_declarations.map(&:name)
+              client_tool_summary = client_tool_names.empty? ? 'none' : client_tool_names.first(30).join(',')
+              client_tool_summary = "#{client_tool_summary},+#{client_tool_names.size - 30}more" if client_tool_names.size > 30
+              log.info(
+                "[llm][api][tools] action=client_tools_built request_id=#{request_id} " \
+                "conversation_id=#{conversation_id || 'none'} count=#{tool_declarations.size} names=#{client_tool_summary}"
+              )
 
               streaming = body[:stream] == true && request.preferred_type.to_s.include?('text/event-stream')
               effective_caller = build_server_caller(source: 'api', path: request.path, env: env,
@@ -155,6 +161,7 @@ module Legion
                     emit_sse_event(out, 'text-delta', { delta: text })
                   end
 
+                  emit_response_tool_call_events(out, pipeline_response)
                   emit_timeline_tool_events(out, pipeline_response, skip_tool_results: !executor.tool_event_handler.nil?)
 
                   enrichments = pipeline_response.enrichments

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/call/dispatch.rb

@@ -332,11 +332,13 @@ module Legion
 
         def parse_arguments(arguments)
           return arguments unless arguments.is_a?(String)
+          return {} if arguments.strip.empty?
 
-          Legion::JSON.parse(arguments)
+          parsed = Legion::JSON.parse(arguments)
+          parsed.is_a?(Hash) ? parsed : {}
         rescue StandardError => e
           handle_exception(e, level: :debug, handled: true, operation: 'llm.dispatch.parse_arguments')
-          arguments
+          {}
         end
       end
     end

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
@@ -674,6 +674,7 @@ module Legion
               log.debug "[llm][executor] action=native_tool_loop.complete rounds=#{round} reason=no_tool_calls"
               return result
             end
+            return client_passthrough_tool_loop_result(result, tool_calls, round) if tool_calls.any? { |tool_call| client_passthrough_tool_call?(tool_call) }
 
             round += 1
             tool_names = tool_calls.map { |tc| tc[:name] }.join(',')
@@ -697,6 +698,7 @@ module Legion
             Array(@request.tools).each { |tool| add_native_tool_definition(definitions, tool) }
             add_registry_tool_definitions(definitions) if registry_tool_injection_requested?
             log.debug "[llm][executor] action=native_tool_definitions.built count=#{definitions.size}"
+            log_native_tool_definitions(definitions)
             definitions
           end
         end
@@ -728,9 +730,7 @@ module Legion
         end
 
         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?
+          return unless registry_tool_sources_available?
 
           add_settings_extensions_tool_definitions(definitions)
         rescue StandardError => e
@@ -841,7 +841,7 @@ module Legion
                        else
                          {}
                        end
-          normalized[:arguments] ||= {}
+          normalized[:arguments] = normalize_tool_arguments(normalized[:arguments])
           normalized[:id] ||= "call_#{SecureRandom.hex(12)}"
           normalized
         end
@@ -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/steps/rag_context.rb

@@ -127,11 +127,12 @@ module Legion
           def estimate_utilization
             return 0.0 if @request.tokens[:max].nil? || @request.tokens[:max].zero?
 
-            message_tokens = @request.messages.sum { |m| (m[:content]&.length || 0) / 4 }
+            message_tokens = @request.messages.sum { |m| content_text(message_content(m)).length / 4 }
             message_tokens.to_f / @request.tokens[:max]
           end
 
           def trivial_query?(query)
+            query = content_text(query)
             max_chars = rag_setting(:trivial_max_chars, 20)
             patterns  = rag_setting(:trivial_patterns, [])
 
@@ -247,7 +248,34 @@ module Legion
 
           def extract_query
             @request.messages.select { |m| Legion::LLM::Settings.config_value(m, :role).to_s == 'user' }
-                             .then { |messages| Legion::LLM::Settings.config_value(messages.last, :content) }
+                             .then { |messages| content_text(message_content(messages.last)) }
+          end
+
+          def message_content(message)
+            Legion::LLM::Settings.config_value(message, :content)
+          end
+
+          def content_text(content)
+            case content
+            when nil
+              ''
+            when String
+              content
+            when Array
+              content.filter_map { |entry| content_text(entry) }.join
+            when Hash
+              type = content[:type] || content['type']
+              return '' unless type.nil? || type.to_s == 'text'
+
+              text = if content.key?(:text) || content.key?('text')
+                       content[:text] || content['text']
+                     else
+                       content[:content] || content['content']
+                     end
+              content_text(text)
+            else
+              content.respond_to?(:text) ? content.text.to_s : content.to_s
+            end
           end
 
           def apply_gaia_context_limit(limit, strategy:)

data/lib/legion/llm/inference/steps/sticky_persist.rb

@@ -17,7 +17,7 @@ module Legion
             access_token private_key secret_key auth_token credential
           ].freeze
 
-          def step_sticky_persist # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/PerceivedComplexity
+          def step_sticky_persist # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
             return unless sticky_persist_ready?
 
             conv_id        = @request.conversation_id
@@ -100,7 +100,7 @@ module Legion
                   tool:   entry[:tool_name],
                   runner: runner_key,
                   turn:   @sticky_turn_snapshot,
-                  args:   sanitize_args(truncate_args(entry[:args] || {})),
+                  args:   sanitize_args(truncate_args(normalize_history_args(entry[:args]))),
                   result: entry[:result].to_s[0, max_result_length],
                   error:  entry[:error] || false
                 }
@@ -162,6 +162,25 @@ module Legion
             end
           end
 
+          def normalize_history_args(args)
+            case args
+            when nil
+              {}
+            when Hash
+              args
+            when String
+              return {} if args.strip.empty?
+
+              parsed = Legion::JSON.parse(args)
+              parsed.is_a?(Hash) ? parsed : {}
+            else
+              args.respond_to?(:to_h) ? args.to_h : {}
+            end
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.step_sticky_persist.normalize_args')
+            {}
+          end
+
           def sanitize_args(args)
             args.each_with_object({}) do |(k, v), h|
               h[k] = SENSITIVE_PARAM_NAMES.include?(k.to_s.downcase) ? '[REDACTED]' : v

data/lib/legion/llm/inference/steps/tool_calls.rb

@@ -32,6 +32,20 @@ module Legion
               source = find_tool_source(tool_name)
               next unless source
 
+              if client_passthrough_source?(source)
+                log.info(
+                  "[llm][tools] client_passthrough request_id=#{@request.id} " \
+                  "tool_call_id=#{tool_call_id || 'none'} name=#{tool_name}"
+                )
+                log_step_debug(
+                  :tool_calls,
+                  :client_passthrough,
+                  tool_call_id: tool_call_id || 'none',
+                  tool_name:    tool_name
+                )
+                next
+              end
+
               # Skip builtin tools; native providers handle provider-owned tools.
               if source[:type] == :builtin
                 log.info(
@@ -123,6 +137,102 @@ module Legion
             { type: :builtin }
           end
 
+          def client_passthrough_source?(source)
+            source[:type] == :client && source[:executable] != true
+          end
+
+          def client_passthrough_tool_call?(tool_call)
+            client_passthrough_source?(find_tool_source(tool_call[:name]))
+          end
+
+          def client_passthrough_tool_loop_result(result, tool_calls, round)
+            result[:tool_calls] = tool_calls
+            log.debug "[llm][executor] action=native_tool_loop.complete rounds=#{round} reason=client_passthrough"
+            result
+          end
+
+          def normalize_tool_arguments(arguments)
+            case arguments
+            when nil
+              {}
+            when Hash
+              arguments
+            when String
+              return {} if arguments.strip.empty?
+
+              parsed = Legion::JSON.parse(arguments)
+              parsed.is_a?(Hash) ? parsed : {}
+            else
+              arguments.respond_to?(:to_h) ? arguments.to_h : {}
+            end
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.normalize_tool_arguments')
+            {}
+          end
+
+          def registry_tool_sources_available?
+            unless Legion::Settings::Extensions.respond_to?(:tools) &&
+                   Legion::Settings::Extensions.respond_to?(:filter_tools)
+              log_tool_injection_skip(:settings_extensions_unavailable)
+              return false
+            end
+
+            settings_tool_count = Array(Legion::Settings::Extensions.tools).size
+            if settings_tool_count.zero? && @triggered_tools.empty?
+              log_tool_injection_skip(:no_settings_or_triggered_tools, settings_tool_count: settings_tool_count)
+              return false
+            end
+
+            true
+          end
+
+          def log_tool_injection_skip(reason, settings_tool_count: nil)
+            log.info(
+              "[llm][tools][inject] action=registry_skipped request_id=#{request_log_value(:id, 'unknown')} " \
+              "conversation_id=#{request_log_value(:conversation_id, 'none') || 'none'} reason=#{reason} " \
+              "settings_tools=#{settings_tool_count || 'unknown'} triggered_tools=#{@triggered_tools.size} " \
+              "requested_tools=#{requested_deferred_tool_names.size}"
+            )
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.log_tool_injection_skip')
+          end
+
+          def log_native_tool_definitions(definitions)
+            log.info(
+              "[llm][tools][inject] action=native_tool_definitions request_id=#{request_log_value(:id, 'unknown')} " \
+              "conversation_id=#{request_log_value(:conversation_id, 'none') || 'none'} provider=#{@resolved_provider || 'unknown'} " \
+              "model=#{@resolved_model || 'unknown'} total=#{definitions.size} sources=#{format_tool_source_counts(definitions)} " \
+              "client_request_tools=#{Array(request_log_value(:tools, [])).size} triggered_tools=#{@triggered_tools.size} " \
+              "requested_tools=#{requested_deferred_tool_names.size} names=#{format_tool_names(definitions.map(&:name))}"
+            )
+          rescue StandardError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.log_native_tool_definitions')
+          end
+
+          def format_tool_source_counts(definitions)
+            counts = definitions.each_with_object(Hash.new(0)) do |definition, memo|
+              source = definition.respond_to?(:source) ? definition.source : {}
+              key = source.is_a?(Hash) ? (source[:type] || source['type'] || :unknown) : :unknown
+              memo[key] += 1
+            end
+            return 'none' if counts.empty?
+
+            counts.map { |key, count| "#{key}:#{count}" }.join(',')
+          end
+
+          def format_tool_names(names, limit = 30)
+            names = Array(names).map(&:to_s).reject(&:empty?)
+            return 'none' if names.empty?
+
+            visible = names.first(limit)
+            suffix = names.size > limit ? ",+#{names.size - limit}more" : ''
+            "#{visible.join(',')}#{suffix}"
+          end
+
+          def request_log_value(method_name, fallback)
+            @request.respond_to?(method_name) ? @request.public_send(method_name) : fallback
+          end
+
           def describe_tool_source(source)
             case source[:type]
             when :mcp

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.15'
   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.15
 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