legion-llm 0.9.30 → 0.9.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 221d8482faa90a3fa8e4bbefe90999838a56b96bc34d6506956f6b8ac90ab290
-  data.tar.gz: a3c3ce4cde046e8cd1af18874e04da1698d4527549fc70df274d14c0830f3803
+  metadata.gz: 715bd8c0918939545eda0cf832d81aa23e69c807ed6055fdb4d95f4177c99449
+  data.tar.gz: 12e42d3d2fdc02c4ca7764a264af90631141952982d9726c02d0e9ea7de87a92
 SHA512:
-  metadata.gz: fd2fdd7bce06cd6efa9a8b583072b947f14ffdaa5a1898b65f2027da8693c79bdd56b3553d04f6f6329f2f3a9d71c0699947f371aa5715708fd538a144819363
-  data.tar.gz: 7c3c36ca8b7db0075b18ea656e3c13c9235d873362d8febbe663c96eb07a1fa562a16d754f1bfed42d909698b466c303d7395e79caa0093ad1d1008c64389f69
+  metadata.gz: 6f2fd1a0ea8b18ed222f2713adb4f4a48ce57e90d5a3ac2242f7ae648ed297b6375d1143c0e29777e4c5ade60e479e09997c2af04cf0e1d3b81225ef3a14276f
+  data.tar.gz: 41d0daa21a98518c4192881bd3231ca1e308b6231d06e22b6102531feee4f6aef1ced50d9e43b1f65b7e8f344e95406ebb682bf445d356011aafd6d4ce241a37

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Legion LLM Changelog
 
+## [0.9.31] - 2026-05-18
+
+### Added
+- Tools: `legion_list_all_tools` pinned special tool for full extension tool discovery with extension/deferred filters
+- RAG: debug logging for per-result confidence scores and content_type distribution
+- RAG: `exclude_source_agents` setting to filter noisy bulk-ingest sources from context injection
+- Settings: `client_tool_passthrough` configurable via `Legion::Settings[:llm][:tool_trigger][:client_tool_passthrough]`
+
+### Changed
+- RAG: `min_confidence` default raised from 0.5 to 0.85 (reduces irrelevant context)
+- RAG: default exclusion list: teams-api-ingest, unknown, teams-entity-extractor, legion-interlink
+
+### Fixed
+- Executor: enrichment injection (system prompt + RAG) cached on first tool loop pass; subsequent rounds reuse cache
+- Client tool passthrough: per-request explicit false now correctly disables (was broken by || on false values)
+- Tool audit publishing deferred to post-metering flush (async, non-blocking)
+
+
 ## [0.9.30] - 2026-05-16
 
 ### Fixed

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

@@ -176,13 +176,13 @@ module Legion
             )
             log.info("[llm][reflection] published via=transport model=#{model} type=#{entry[:type]}")
           elsif apollo_direct?
-            Legion::Extensions::Apollo::Runners::Ingest.ingest(
+            Legion::Extensions::Apollo::Runners::Request.ingest(
               content:          entry[:content],
               content_type:     entry[:type].to_s,
               knowledge_domain: 'reflection',
               confidence:       entry[:confidence],
               source_agent:     "llm:#{model}",
-              metadata:         { submitted_by: Legion::LLM::PublisherIdentity.requested_by }
+              source_channel:   'reflection_hook'
             )
             log.info("[llm][reflection] published via=direct model=#{model} type=#{entry[:type]}")
           end
@@ -236,7 +236,7 @@ module Legion
         private_class_method :apollo_transport?
 
         def apollo_direct?
-          defined?(Legion::Extensions::Apollo::Runners::Ingest)
+          defined?(Legion::Extensions::Apollo::Runners::Request)
         end
         private_class_method :apollo_direct?
       end

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

@@ -102,6 +102,7 @@ module Legion
           @sticky_turn_snapshot = nil
           @pending_tool_history = Concurrent::Array.new
           @pending_tool_history_mutex = Mutex.new
+          @deferred_tool_audits = []
           @injected_tool_map = {}
           @native_tool_source_map = {}
           @freshly_triggered_keys = []
@@ -889,10 +890,14 @@ module Legion
         end
 
         def native_dispatch_options
-          injected_system = EnrichmentInjector.inject(
-            system:      @request.system,
-            enrichments: @enrichments
-          )
+          injected_system = if @native_tool_loop_round.to_i.positive?
+                              @cached_injected_system
+                            else
+                              @cached_injected_system = EnrichmentInjector.inject(
+                                system:      @request.system,
+                                enrichments: @enrichments
+                              )
+                            end
 
           options = {
             system:            injected_system,
@@ -940,11 +945,13 @@ module Legion
         end
 
         def client_tool_passthrough_enabled?
-          return false unless @request.respond_to?(:metadata)
+          if @request.respond_to?(:metadata)
+            metadata = @request.metadata || {}
+            value = metadata.key?(:client_tool_passthrough) ? metadata[:client_tool_passthrough] : metadata['client_tool_passthrough']
+            return value if [true, false].include?(value)
+          end
 
-          metadata = @request.metadata || {}
-          value = metadata[:client_tool_passthrough] || metadata['client_tool_passthrough']
-          value == true
+          Legion::LLM::Settings.value(:tool_trigger, :client_tool_passthrough) != false
         end
 
         def non_executable_client_tool?(definition)
@@ -1426,28 +1433,52 @@ module Legion
         end
 
         def publish_tool_audit(tc_id, tc_name, result_str, is_error, duration_ms, started_at, finished_at)
-          Legion::LLM::Audit.emit_tools(
-            request_id:      @request.id,
-            conversation_id: @request.conversation_id,
-            exchange_id:     @exchange_id,
-            tool_name:       tc_name,
-            tool_call:       {
-              id:          tc_id,
-              name:        tc_name,
-              status:      is_error ? :error : :success,
-              duration_ms: duration_ms,
-              started_at:  started_at,
-              finished_at: finished_at
-            },
-            result:          result_str[0, 4096],
-            caller:          @request.caller,
-            classification:  @request.classification,
-            tracing:         @tracing,
-            timestamp:       finished_at,
-            request_type:    'tool'
-          )
-        rescue StandardError => e
-          handle_exception(e, level: :warn, operation: 'llm.pipeline.publish_tool_audit', tool_name: tc_name)
+          @deferred_tool_audits << {
+            tc_id: tc_id, tc_name: tc_name, result_str: result_str,
+            is_error: is_error, duration_ms: duration_ms,
+            started_at: started_at, finished_at: finished_at
+          }
+        end
+
+        def flush_deferred_tool_audits
+          return if @deferred_tool_audits.empty?
+
+          audits = @deferred_tool_audits.dup
+          @deferred_tool_audits.clear
+
+          request_id      = @request.id
+          conversation_id = @request.conversation_id
+          exchange_id     = @exchange_id
+          caller_data     = @request.caller
+          classification  = @request.classification
+          tracing         = @tracing
+
+          Concurrent::Promises.future do
+            audits.each do |audit|
+              Legion::LLM::Audit.emit_tools(
+                request_id:      request_id,
+                conversation_id: conversation_id,
+                exchange_id:     exchange_id,
+                tool_name:       audit[:tc_name],
+                tool_call:       {
+                  id:          audit[:tc_id],
+                  name:        audit[:tc_name],
+                  status:      audit[:is_error] ? :error : :success,
+                  duration_ms: audit[:duration_ms],
+                  started_at:  audit[:started_at],
+                  finished_at: audit[:finished_at]
+                },
+                result:          audit[:result_str][0, 4096],
+                caller:          caller_data,
+                classification:  classification,
+                tracing:         tracing,
+                timestamp:       audit[:finished_at],
+                request_type:    'tool'
+              )
+            rescue StandardError => e
+              Legion::Logging.log.warn("[llm][pipeline] publish_tool_audit failed tool=#{audit[:tc_name]}: #{e.message}")
+            end
+          end
         end
 
         def tool_call_field(tool_call, field)
@@ -1642,6 +1673,7 @@ module Legion
             routing_reason:    @audit.dig(:'routing:provider_selection', :data, :reason)
           )
           Steps::Metering.publish_or_spool(event)
+          flush_deferred_tool_audits
         rescue StandardError => e
           @warnings << "metering error: #{e.message}"
           handle_exception(e, level: :warn, operation: 'llm.pipeline.step_metering')

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

@@ -89,6 +89,13 @@ module Legion
               return
             end
 
+            scores = entries.filter_map { |e| e[:confidence] || e[:distance] }.map { |s| s.is_a?(Numeric) ? s.round(3) : s }
+            log.debug(
+              "[llm][steps][rag_context] action=results_scored request_id=#{@request&.id || 'unknown'} " \
+              "strategy=#{strategy} count=#{entries.size} scores=#{scores.inspect} " \
+              "types=#{entries.map { |e| e[:content_type] }.compact.tally.inspect}"
+            )
+
             @enrichments['rag:context_retrieval'] = {
               content:   "#{Legion::LLM::Settings.config_value(result, :count)} entries retrieved via #{strategy}",
               data:      { entries: entries, strategy: strategy, count: Legion::LLM::Settings.config_value(result, :count) },
@@ -160,14 +167,30 @@ module Legion
           def apollo_retrieve(query:, strategy:)
             full_limit    = rag_setting(:full_limit, 10)
             compact_limit = rag_setting(:compact_limit, 5)
-            confidence    = rag_setting(:min_confidence, 0.5)
+            confidence    = rag_setting(:min_confidence, 0.85)
             limit = apply_gaia_context_limit(strategy == :rag_compact ? compact_limit : full_limit,
                                              strategy: strategy)
             log_step_debug(:rag_context, :apollo_query, strategy: strategy, limit: limit, min_confidence: confidence)
 
             general = apollo_retrieve_general(query: query, limit: limit, confidence: confidence)
             history = apollo_retrieve_conversation_history(query: query, limit: limit, confidence: confidence)
-            merge_apollo_results(general, history)
+            result = merge_apollo_results(general, history)
+            filter_excluded_source_agents(result)
+          end
+
+          def filter_excluded_source_agents(result)
+            excluded = Array(rag_setting(:exclude_source_agents, []))
+            return result if excluded.empty?
+
+            entries = Array(result[:entries])
+            filtered = entries.reject { |e| excluded.include?(e[:source_agent].to_s) }
+            if filtered.size < entries.size
+              log.debug(
+                "[llm][steps][rag_context] action=source_agent_filter excluded=#{entries.size - filtered.size} " \
+                "remaining=#{filtered.size} agents=#{excluded.inspect}"
+              )
+            end
+            result.merge(entries: filtered, count: filtered.size)
           end
 
           def apollo_retrieve_general(query:, limit:, confidence:)

data/lib/legion/llm/settings.rb

@@ -377,12 +377,13 @@ module Legion
           enabled:                       true,
           full_limit:                    10,
           compact_limit:                 5,
-          min_confidence:                0.5,
+          min_confidence:                0.85,
           utilization_compact_threshold: 0.7,
           utilization_skip_threshold:    0.9,
           conversation_history_enabled:  false,
           trivial_max_chars:             20,
-          trivial_patterns:              %w[hello hi hey ping pong test ok okay yes no thanks thank]
+          trivial_patterns:              %w[hello hi hey ping pong test ok okay yes no thanks thank],
+          exclude_source_agents:         %w[teams-api-ingest unknown teams-entity-extractor legion-interlink]
         }
       end
 
@@ -481,9 +482,10 @@ module Legion
 
       def self.tool_trigger_defaults
         {
-          scan_depth:       10,
-          tool_limit:       25,
-          local_tool_limit: 100
+          scan_depth:              10,
+          tool_limit:              25,
+          local_tool_limit:        100,
+          client_tool_passthrough: false
         }
       end
 

data/lib/legion/llm/tools/special.rb

@@ -16,6 +16,7 @@ module Legion
         extend Legion::Logging::Helper
 
         LIST_SPECIAL_TOOLS_NAME = 'legion_list_special_tools'
+        LIST_ALL_TOOLS_NAME = 'legion_list_all_tools'
         DEFAULT_TIMEOUT_MS = 120_000
         MAX_TIMEOUT_MS = 600_000
         PYTHON_PACKAGES = %w[
@@ -34,7 +35,7 @@ module Legion
         module_function
 
         def pinned_definitions
-          definitions = [special_tools_definition, ruby_definition]
+          definitions = [special_tools_definition, all_tools_definition, ruby_definition]
           definitions.concat(python_definitions) if python_available?
           definitions
         end
@@ -43,6 +44,8 @@ module Legion
           case normalize_tool_name(tool_name)
           when LIST_SPECIAL_TOOLS_NAME
             { status: :success, result: Legion::JSON.dump(inventory) }
+          when LIST_ALL_TOOLS_NAME
+            { status: :success, result: Legion::JSON.dump(all_tools_inventory(**args)) }
           when 'ruby'
             dispatch_runtime('ruby', ruby_path, **args)
           when 'python', 'python3'
@@ -65,6 +68,32 @@ module Legion
           }
         end
 
+        def all_tools_inventory(**args)
+          tools = settings_extensions_tools
+          extension_filter = args[:extension] || args['extension']
+          deferred_filter = args.key?(:deferred) ? args[:deferred] : args['deferred']
+
+          if extension_filter
+            normalized_filter = extension_filter.to_s.tr('-', '_').delete_prefix('lex_')
+            tools = tools.select { |t| t[:extension].to_s.tr('-', '_').delete_prefix('lex_').include?(normalized_filter) }
+          end
+
+          tools = tools.select { |t| t[:deferred] == deferred_filter } unless deferred_filter.nil?
+
+          grouped = tools.group_by { |t| t[:extension] || 'unknown' }
+          {
+            total:      tools.size,
+            extensions: grouped.transform_values do |ext_tools|
+              ext_tools.group_by { |t| t[:runner] || 'default' }.transform_values do |runner_tools|
+                runner_tools.map { |t| { name: t[:name], description: t[:description], deferred: t[:deferred] } }
+              end
+            end
+          }
+        rescue StandardError => e
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.tools.special.all_tools_inventory')
+          { total: 0, extensions: {}, error: e.message }
+        end
+
         def python_available?
           !python_path.to_s.empty?
         end
@@ -115,6 +144,22 @@ module Legion
           )
         end
 
+        def all_tools_definition
+          Types::ToolDefinition.build(
+            name:        LIST_ALL_TOOLS_NAME,
+            description: 'List ALL registered Legion tools from all loaded extensions, grouped by extension and runner. ' \
+                         'Use this to discover what tools are available for a specific domain (e.g. Teams, Apollo, identity).',
+            parameters:  {
+              type:       'object',
+              properties: {
+                extension: { type: 'string', description: 'Filter by extension name (e.g. "microsoft_teams", "apollo"). Omit for all.' },
+                deferred:  { type: 'boolean', description: 'Filter by deferred status. Omit for all.' }
+              }
+            },
+            source:      { type: :special, handler: :all_tools_inventory, pinned: true }
+          )
+        end
+
         def ruby_definition
           Types::ToolDefinition.build(
             name:        'ruby',

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.30'
+    VERSION = '0.9.32'
   end
 end

metadata

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