legion-llm 0.9.29 → 0.9.32

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 914f95fd880bbb73c043d16612bbf22fc22569455b721fe9052b5ee4c55e83b3
-  data.tar.gz: 0a2f12babcae95cab6c9f2e0ee8b5207c26d998aafcee464d457af7ebea4dc16
+  metadata.gz: 715bd8c0918939545eda0cf832d81aa23e69c807ed6055fdb4d95f4177c99449
+  data.tar.gz: 12e42d3d2fdc02c4ca7764a264af90631141952982d9726c02d0e9ea7de87a92
 SHA512:
-  metadata.gz: 52a9853e3c2337d19a0e4517d0472143e9aa809dd94363655db76a94ed924041b95b20a1038442053fc8b30f4c035782335a6edc0ad9634cb17e7f6c59c81f4b
-  data.tar.gz: bd2f8b50e52e0653cedcb44c0c18105c212151b64baab5dd62248a456e917bdae8e8347d83d7c8c4dd535da354f00795d938643e94e95ec03657c03d2bfa33a2
+  metadata.gz: 6f2fd1a0ea8b18ed222f2713adb4f4a48ce57e90d5a3ac2242f7ae648ed297b6375d1143c0e29777e4c5ade60e479e09997c2af04cf0e1d3b81225ef3a14276f
+  data.tar.gz: 41d0daa21a98518c4192881bd3231ca1e308b6231d06e22b6102531feee4f6aef1ced50d9e43b1f65b7e8f344e95406ebb682bf445d356011aafd6d4ce241a37

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # 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
+- Tools: API-submitted client tools are no longer advertised to providers unless callers explicitly opt into client-tool passthrough, preventing incomplete tool calls from ending streaming responses.
+
 ## [0.9.29] - 2026-05-16
 
 ### Added

data/lib/legion/llm/api/anthropic/messages.rb

@@ -149,7 +149,7 @@ module Legion
                   name:        tname,
                   description: tdesc,
                   parameters:  tschema,
-                  source:      { type: :client, executable: false }
+                  source:      { type: :client, executable: true }
                 )
               rescue StandardError => e
                 log.warn("[llm][api][anthropic][messages] build_tool_classes failed name=#{tname} error=#{e.message}")

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

@@ -28,6 +28,7 @@ module Legion
               conversation_id = body[:conversation_id]
               request_id      = body[:request_id] || SecureRandom.uuid
               include_thinking = body[:include_thinking] == true
+              client_tool_passthrough = body[:client_tool_passthrough] == true
 
               unless messages.is_a?(Array)
                 halt 400, { 'Content-Type' => 'application/json' },
@@ -103,6 +104,9 @@ module Legion
 
               extra = {}
               extra[:tier] = tier.to_sym if tier
+              metadata = { requested_tools: requested_tools }
+              metadata[:client_tool_passthrough] = true if client_tool_passthrough
+              metadata[:client_tool_request_count] = tools.size if tools.any?
 
               pipeline_request = Legion::LLM::Inference::Request.build(
                 id:              request_id,
@@ -112,7 +116,7 @@ module Legion
                 tools:           tool_declarations,
                 caller:          effective_caller,
                 conversation_id: conversation_id,
-                metadata:        { requested_tools: requested_tools },
+                metadata:        metadata,
                 stream:          streaming,
                 cache:           { strategy: :default, cacheable: true },
                 extra:           extra

data/lib/legion/llm/api/openai/chat_completions.rb

@@ -123,7 +123,7 @@ module Legion
                 name:        t[:name].to_s,
                 description: t[:description].to_s,
                 parameters:  t[:parameters] || {},
-                source:      { type: :client, executable: false }
+                source:      { type: :client, executable: true }
               )
             rescue StandardError => e
               tool_name = t.is_a?(Hash) ? t[:name] : nil

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,
@@ -939,6 +944,25 @@ module Legion
           !(@request.respond_to?(:suppress_tools) && @request.suppress_tools)
         end
 
+        def client_tool_passthrough_enabled?
+          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
+
+          Legion::LLM::Settings.value(:tool_trigger, :client_tool_passthrough) != false
+        end
+
+        def non_executable_client_tool?(definition)
+          source = definition.respond_to?(:source) ? definition.source : {}
+          return false unless source.is_a?(Hash)
+
+          source_type = source[:type] || source['type']
+          executable = source.key?(:executable) ? source[:executable] : source['executable']
+          source_type.respond_to?(:to_sym) && source_type.to_sym == :client && executable != true
+        end
+
         def add_pinned_special_tool_definitions(definitions)
           Tools::Special.pinned_definitions.each do |definition|
             next if definitions.any? { |existing| existing.name == definition.name }
@@ -957,6 +981,14 @@ module Legion
                        else
                          Types::ToolDefinition.from_tool_class(tool)
                        end
+          if non_executable_client_tool?(definition) && !client_tool_passthrough_enabled?
+            log.info(
+              "[llm][tools][inject] action=client_tool_skipped request_id=#{request_log_value(:id, 'unknown')} " \
+              "conversation_id=#{request_log_value(:conversation_id, 'none') || 'none'} name=#{definition.name} " \
+              'reason=client_passthrough_not_enabled'
+            )
+            return
+          end
           return if gaia_tool_suppressed?(definition.name)
           return if definitions.any? { |existing| existing.name == definition.name }
 
@@ -1401,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)
@@ -1617,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.29'
+    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.29
+  version: 0.9.32
 platform: ruby
 authors:
 - Esity