legionio 1.7.36 → 1.7.37

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2c0a91d98736f789285e0e29fd43fd40d3ed5ceaf5e050a23049049ff2d579ca
-  data.tar.gz: 145442ec524abec8224134b81f5117f2da1eac532debb23bc9336cb127fd9d66
+  metadata.gz: 2bafa8899bbfa7e80970cec50a67e3989fc259cc426ebbbf7bc531194bd8b0d8
+  data.tar.gz: 4e768d2523b3a9b962f8d1119061fe25d71c8e101acb071cef793b40695ebb8c
 SHA512:
-  metadata.gz: caa367bf5972fe2370360eaa609c75819b8c43cbd0c0e204f9a4ae92feba428c869eedc95ddc68c29c42fb9402ccdba15fff356843db32a49a6253ef6d957e3a
-  data.tar.gz: e34c37f8dfd6dd65180d3505d8ac06c7edcc4ea0cda8beed92e65ef45a2518c454ecada439ef3f55228ec9169ebc5989e11a3b22380f0cbb8133ada9c71d2901
+  metadata.gz: c20eb127ef11c1f60ad06c42619354a91072a3c79ff103189454c6f8080e60fa1e1b5ad9bdcb77703ccfd3308079117aadad6c7f063f59c5255a01b635d2c3dc
+  data.tar.gz: 0bcaa14c6e8c8a3fd0c9b5f47d2cb64abba2cee271cb09eadf812a460f0bfe5069147bb497b205e910fffa71da98702c3889805ef8d18f09cd7d7d8714020c38

data/CHANGELOG.md

@@ -2,8 +2,12 @@
 
 ## [Unreleased]
 
+## [1.7.37] - 2026-04-09
+
 ### Added
-- register_credential_providers step in boot sequence for Phase 8 credential-only identity module registration with Broker
+- Trigger word tool injection: extensions and runners declare trigger words that auto-promote deferred tools when detected in LLM messages
+- `Legion::Tools::TriggerIndex` — Concurrent::Map-backed reverse index for O(1) trigger word lookup
+- `trigger_words` DSL on Extensions::Core, runner modules, and Tools::Base
 
 ## [1.7.36] - 2026-04-09
 

data/lib/legion/api/llm.rb

@@ -314,40 +314,40 @@ module Legion
                   case event[:type]
                   when :tool_call
                     emitted_tool_call_ids << event[:tool_call_id] if event[:tool_call_id]
-                    out << "event: tool-call\ndata: #{Legion::JSON.dump({
-                                                                          toolCallId: event[:tool_call_id],
-                                                                          toolName:   event[:tool_name],
-                                                                          args:       event[:arguments] || {},
-                                                                          startedAt:  event[:started_at]&.iso8601(3),
-                                                                          timestamp:  event[:started_at]&.iso8601(3) || Time.now.iso8601(3)
-                                                                        })}\n\n"
+                    out << "event: tool-call\ndata: #{Legion::JSON.generate({
+                                                                              toolCallId: event[:tool_call_id],
+                                                                              toolName:   event[:tool_name],
+                                                                              args:       event[:arguments] || {},
+                                                                              startedAt:  event[:started_at]&.iso8601(3),
+                                                                              timestamp:  event[:started_at]&.iso8601(3) || Time.now.iso8601(3)
+                                                                            })}\n\n"
                   when :tool_result
-                    out << "event: tool-result\ndata: #{Legion::JSON.dump({
-                                                                            toolCallId: event[:tool_call_id],
-                                                                            toolName:   event[:tool_name],
-                                                                            result:     event[:result],
-                                                                            startedAt:  event[:started_at]&.iso8601(3),
-                                                                            finishedAt: event[:finished_at]&.iso8601(3) || Time.now.iso8601(3),
-                                                                            durationMs: event[:duration_ms],
-                                                                            timestamp:  event[:finished_at]&.iso8601(3) || Time.now.iso8601(3)
-                                                                          })}\n\n"
+                    out << "event: tool-result\ndata: #{Legion::JSON.generate({
+                                                                                toolCallId: event[:tool_call_id],
+                                                                                toolName:   event[:tool_name],
+                                                                                result:     event[:result],
+                                                                                startedAt:  event[:started_at]&.iso8601(3),
+                                                                                finishedAt: event[:finished_at]&.iso8601(3) || Time.now.iso8601(3),
+                                                                                durationMs: event[:duration_ms],
+                                                                                timestamp:  event[:finished_at]&.iso8601(3) || Time.now.iso8601(3)
+                                                                              })}\n\n"
                   when :tool_error
-                    out << "event: tool-error\ndata: #{Legion::JSON.dump({
-                                                                           toolCallId: event[:tool_call_id],
-                                                                           toolName:   event[:tool_name],
-                                                                           error:      (event[:error] || event[:result]).to_s,
-                                                                           startedAt:  event[:started_at]&.iso8601(3),
-                                                                           finishedAt: Time.now.iso8601(3),
-                                                                           timestamp:  Time.now.iso8601(3)
-                                                                         })}\n\n"
-                  when :model_fallback
-                    out << "event: model-fallback\ndata: #{Legion::JSON.dump({
-                                                                               fromModel:  event[:from_model],
-                                                                               toModel:    event[:to_model],
-                                                                               toModelKey: event[:to_model],
-                                                                               error:      event[:error] || 'Provider unavailable',
-                                                                               reason:     event[:reason] || 'provider_fallback'
+                    out << "event: tool-error\ndata: #{Legion::JSON.generate({
+                                                                               toolCallId: event[:tool_call_id],
+                                                                               toolName:   event[:tool_name],
+                                                                               error:      (event[:error] || event[:result]).to_s,
+                                                                               startedAt:  event[:started_at]&.iso8601(3),
+                                                                               finishedAt: Time.now.iso8601(3),
+                                                                               timestamp:  Time.now.iso8601(3)
                                                                              })}\n\n"
+                  when :model_fallback
+                    out << "event: model-fallback\ndata: #{Legion::JSON.generate({
+                                                                                   fromModel:  event[:from_model],
+                                                                                   toModel:    event[:to_model],
+                                                                                   toModelKey: event[:to_model],
+                                                                                   error:      event[:error] || 'Provider unavailable',
+                                                                                   reason:     event[:reason] || 'provider_fallback'
+                                                                                 })}\n\n"
                   end
                 end
 
@@ -357,7 +357,7 @@ module Legion
                   next if text.empty?
 
                   full_text << text
-                  out << "event: text-delta\ndata: #{Legion::JSON.dump({ delta: text })}\n\n"
+                  out << "event: text-delta\ndata: #{Legion::JSON.generate({ delta: text })}\n\n"
                 end
 
                 # Post-hoc safety net: emit any tool-calls that weren't fired in real-time
@@ -367,11 +367,11 @@ module Legion
                     tc_id = tc.respond_to?(:id) ? tc.id : nil
                     next if tc_id && emitted_tool_call_ids.include?(tc_id)
 
-                    out << "event: tool-call\ndata: #{Legion::JSON.dump({
-                                                                          toolCallId: tc_id,
-                                                                          toolName:   tc.respond_to?(:name) ? tc.name : tc.to_s,
-                                                                          args:       tc.respond_to?(:arguments) ? tc.arguments : {}
-                                                                        })}\n\n"
+                    out << "event: tool-call\ndata: #{Legion::JSON.generate({
+                                                                              toolCallId: tc_id,
+                                                                              toolName:   tc.respond_to?(:name) ? tc.name : tc.to_s,
+                                                                              args:       tc.respond_to?(:arguments) ? tc.arguments : {}
+                                                                            })}\n\n"
                   end
                 end
 
@@ -384,20 +384,20 @@ module Legion
                   resolved_model = (model || provider).to_s.strip
                   next if resolved_model.empty?
 
-                  out << "event: model-fallback\ndata: #{Legion::JSON.dump({
-                                                                             fromModel:  pipeline_response.routing&.dig(:model),
-                                                                             toModel:    resolved_model,
-                                                                             toModelKey: resolved_model,
-                                                                             error:      w[:original_error] || 'Provider unavailable',
-                                                                             reason:     'provider_fallback'
-                                                                           })}\n\n"
+                  out << "event: model-fallback\ndata: #{Legion::JSON.generate({
+                                                                                 fromModel:  pipeline_response.routing&.dig(:model),
+                                                                                 toModel:    resolved_model,
+                                                                                 toModelKey: resolved_model,
+                                                                                 error:      w[:original_error] || 'Provider unavailable',
+                                                                                 reason:     'provider_fallback'
+                                                                               })}\n\n"
                 end
 
                 enrichments = pipeline_response.enrichments
-                out << "event: enrichment\ndata: #{Legion::JSON.dump(enrichments)}\n\n" if enrichments.is_a?(Hash) && !enrichments.empty?
+                out << "event: enrichment\ndata: #{Legion::JSON.generate(enrichments)}\n\n" if enrichments.is_a?(Hash) && !enrichments.empty?
 
                 tokens = pipeline_response.tokens
-                out << "event: done\ndata: #{Legion::JSON.dump({
+                out << "event: done\ndata: #{Legion::JSON.generate({
                   content:            full_text,
                   model:              pipeline_response.routing&.dig(:model),
                   conversation_id:    pipeline_response.conversation_id,
@@ -409,7 +409,7 @@ module Legion
                 }.compact)}\n\n"
               rescue StandardError => e
                 Legion::Logging.log_exception(e, payload_summary: 'api/llm/inference stream failed', component_type: :api)
-                out << "event: error\ndata: #{Legion::JSON.dump({ code: 'stream_error', message: e.message })}\n\n"
+                out << "event: error\ndata: #{Legion::JSON.generate({ code: 'stream_error', message: e.message })}\n\n"
               end
             else
               pipeline_response = executor.call

data/lib/legion/audit/siem_export.rb

@@ -26,7 +26,7 @@ module Legion
       end
 
       def to_ndjson(records)
-        export_batch(records).map { |r| Legion::JSON.dump(r) }.join("\n")
+        export_batch(records).map { |r| Legion::JSON.generate(r) }.join("\n")
       end
     end
   end

data/lib/legion/extensions/builders/runners.rb

@@ -21,41 +21,44 @@ module Legion
         def build_runner_list
           runner_files.each do |file|
             runner_name = file.split('/').last.sub('.rb', '')
-            runner_class =  "#{lex_class}::Runners::#{runner_name.split('_').collect(&:capitalize).join}"
+            runner_class = "#{lex_class}::Runners::#{runner_name.split('_').collect(&:capitalize).join}"
             loaded_runner = Kernel.const_get(runner_class)
             loaded_runner.extend(Legion::Extensions::Definitions) unless loaded_runner.respond_to?(:definition)
             Legion::Logging.debug "[Runners] registered: #{runner_class}" if defined?(Legion::Logging)
+            @runners[runner_name.to_sym] = build_runner_entry(runner_name, runner_class, loaded_runner, file)
+            populate_runner_methods(runner_name, loaded_runner)
+          end
+        end
 
-            @runners[runner_name.to_sym] = {
-              extension:       lex_class.to_s.downcase,
-              extension_name:  extension_name,
-              extension_class: lex_class,
-              runner_name:     runner_name,
-              runner_class:    runner_class,
-              runner_module:   loaded_runner,
-              runner_path:     file,
-              class_methods:   {}
-            }
-
-            @runners[runner_name.to_sym][:scheduled_tasks] = loaded_runner.scheduled_tasks if loaded_runner.method_defined? :scheduled_tasks
-
-            if settings.key?(:runners) && settings[:runners].key?(runner_name.to_sym)
-              @runners[runner_name.to_sym][:desc] = settings[:runners][runner_name.to_sym][:desc]
-            end
-
-            loaded_runner.public_instance_methods(false).each do |runner_method|
-              @runners[runner_name.to_sym][:class_methods][runner_method] = {
-                args: loaded_runner.instance_method(runner_method).parameters
-              }
-            end
+        def build_runner_entry(runner_name, runner_class, loaded_runner, file)
+          entry = {
+            extension:       lex_class.to_s.downcase,
+            extension_name:  extension_name,
+            extension_class: lex_class,
+            runner_name:     runner_name,
+            runner_class:    runner_class,
+            runner_module:   loaded_runner,
+            runner_path:     file,
+            class_methods:   {}
+          }
+          entry[:scheduled_tasks] = loaded_runner.scheduled_tasks if loaded_runner.method_defined?(:scheduled_tasks)
+          entry[:trigger_words] = loaded_runner.trigger_words if loaded_runner.respond_to?(:trigger_words)
+          entry[:desc] = settings[:runners][runner_name.to_sym][:desc] if settings.key?(:runners) && settings[:runners].key?(runner_name.to_sym)
+          entry
+        end
 
-            loaded_runner.methods(false).each do |runner_method|
-              next if %i[scheduled_tasks runner_description].include? runner_method
+        def populate_runner_methods(runner_name, loaded_runner)
+          loaded_runner.public_instance_methods(false).each do |runner_method|
+            @runners[runner_name.to_sym][:class_methods][runner_method] = {
+              args: loaded_runner.instance_method(runner_method).parameters
+            }
+          end
+          loaded_runner.methods(false).each do |runner_method|
+            next if %i[scheduled_tasks runner_description].include?(runner_method)
 
-              @runners[runner_name.to_sym][:class_methods][runner_method] = {
-                args: loaded_runner.method(runner_method).parameters
-              }
-            end
+            @runners[runner_name.to_sym][:class_methods][runner_method] = {
+              args: loaded_runner.method(runner_method).parameters
+            }
           end
         end
 

data/lib/legion/extensions/core.rb

@@ -120,6 +120,10 @@ module Legion
         true
       end
 
+      def trigger_words
+        []
+      end
+
       # Auto-generate AMQP message classes for each runner method that has a definition.
       # Explicit Messages::* classes in the transport directory take precedence.
       # Runs after build_runners so definitions are populated.

data/lib/legion/service.rb

@@ -935,6 +935,13 @@ module Legion
       require 'legion/tools'
       Legion::Tools.register_all
       Legion::Tools::Discovery.discover_and_register
+      future = Legion::Tools::TriggerIndex.build_async!
+      if future.respond_to?(:rescue)
+        @trigger_index_build_future = future.rescue do |e|
+          handle_exception(e, level: :warn, operation: 'service.register_core_tools.trigger_index_build')
+          nil
+        end
+      end
       Legion::Tools::EmbeddingCache.setup
 
       log.info(

data/lib/legion/tools/base.rb

@@ -69,6 +69,12 @@ module Legion
           @mcp_tier = val
         end
 
+        def trigger_words(val = nil)
+          return @trigger_words || [] if val.nil?
+
+          @trigger_words = val
+        end
+
         def call(**_args)
           raise NotImplementedError, "#{name} must implement .call"
         end

data/lib/legion/tools/discovery.rb

@@ -147,14 +147,15 @@ module Legion
           ext_name = derive_extension_name(ext)
           runner_snake = derive_runner_snake(runner_mod)
           {
-            tool_name:    defn&.dig(:mcp_prefix) || "legion-#{ext_name}-#{runner_snake}-#{func_name}",
-            description:  meta[:desc] || defn&.dig(:desc) || "#{ext_name}##{func_name}",
-            input_schema: normalize_schema(meta[:options]),
-            mcp_category: defn&.dig(:mcp_category),
-            mcp_tier:     defn&.dig(:mcp_tier),
-            deferred:     deferred,
-            ext_name:     ext_name,
-            runner_snake: runner_snake
+            tool_name:     defn&.dig(:mcp_prefix) || "legion-#{ext_name}-#{runner_snake}-#{func_name}",
+            description:   meta[:desc] || defn&.dig(:desc) || "#{ext_name}##{func_name}",
+            input_schema:  normalize_schema(meta[:options]),
+            mcp_category:  defn&.dig(:mcp_category),
+            mcp_tier:      defn&.dig(:mcp_tier),
+            deferred:      deferred,
+            ext_name:      ext_name,
+            runner_snake:  runner_snake,
+            trigger_words: merge_trigger_words(ext, runner_mod)
           }
         end
 
@@ -168,6 +169,7 @@ module Legion
             runner(attrs[:runner_snake])
             mcp_category(attrs[:mcp_category]) if attrs[:mcp_category]
             mcp_tier(attrs[:mcp_tier]) if attrs[:mcp_tier]
+            trigger_words(attrs[:trigger_words])
 
             define_singleton_method(:call) do |**params|
               if runner_ref.respond_to?(func_ref)
@@ -184,6 +186,12 @@ module Legion
           end
         end
 
+        def merge_trigger_words(ext, runner_mod)
+          ext_words = ext.respond_to?(:trigger_words) ? Array(ext.trigger_words) : []
+          runner_words = runner_mod.respond_to?(:trigger_words) ? Array(runner_mod.trigger_words) : []
+          (ext_words + runner_words).uniq
+        end
+
         def derive_runner_snake(runner_mod)
           mod_name = runner_mod.name
           return 'unknown' unless mod_name

data/lib/legion/tools/trigger_index.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Legion
+  module Tools
+    module TriggerIndex
+      @index = if defined?(Concurrent::Map)
+                 Concurrent::Map.new
+               else
+                 {}
+               end
+      @mutex = Mutex.new unless defined?(Concurrent::Map)
+
+      class << self
+        def build_from_registry
+          clear
+          Registry.all_tools.each do |tool_class|
+            words = Array(tool_class.trigger_words)
+            next if words.empty?
+
+            normalized = words.flat_map { |w| w.downcase.gsub(/[^a-z ]/, ' ').split }.uniq
+            normalized.each { |word| add_tool_for_word(word, tool_class) }
+          end
+        end
+
+        def build_async!
+          if defined?(Concurrent::Promises)
+            Concurrent::Promises.future { build_from_registry }
+          else
+            build_from_registry
+          end
+        end
+
+        def match(word_set)
+          matched = Set.new
+          per_word = {}
+          word_set.each do |word|
+            normalized = word.to_s.downcase.gsub(/[^a-z ]/, ' ').strip
+            next if normalized.empty?
+
+            tools = read_word(normalized)
+            next unless tools
+
+            per_word[normalized] = tools
+            matched.merge(tools)
+          end
+          [matched, per_word]
+        end
+
+        def empty?
+          if defined?(Concurrent::Map) && @index.is_a?(Concurrent::Map)
+            @index.each_pair.none?
+          else
+            @index.empty?
+          end
+        end
+
+        def size
+          if defined?(Concurrent::Map) && @index.is_a?(Concurrent::Map)
+            count = 0
+            @index.each_pair { count += 1 }
+            count
+          else
+            @index.size
+          end
+        end
+
+        def clear
+          if defined?(Concurrent::Map) && @index.is_a?(Concurrent::Map)
+            @index = Concurrent::Map.new
+          else
+            @mutex.synchronize { @index = {} }
+          end
+        end
+
+        private
+
+        def add_tool_for_word(word, tool_class)
+          if defined?(Concurrent::Map) && @index.is_a?(Concurrent::Map)
+            @index.compute(word) { |existing| ((existing || Set.new) + Set[tool_class]).freeze }
+          else
+            @mutex.synchronize do
+              @index[word] ||= Set.new
+              @index[word] = (@index[word] + Set[tool_class]).freeze
+            end
+          end
+        end
+
+        def read_word(word)
+          if defined?(Concurrent::Map) && @index.is_a?(Concurrent::Map)
+            @index[word]
+          else
+            @mutex&.synchronize { @index[word] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/tools.rb

@@ -29,7 +29,9 @@ require_relative 'tools/registry'
 require_relative 'tools/base'
 require_relative 'tools/discovery'
 require_relative 'tools/embedding_cache'
+require_relative 'tools/trigger_index'
 
 Dir[File.join(__dir__, 'tools', '*.rb')].each do |f|
-  require f unless f.end_with?('/base.rb', '/registry.rb', '/discovery.rb', '/embedding_cache.rb')
+  require f unless f.end_with?('/base.rb', '/registry.rb', '/discovery.rb', '/embedding_cache.rb',
+                               '/trigger_index.rb')
 end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.7.36'
+  VERSION = '1.7.37'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.36
+  version: 1.7.37
 platform: ruby
 authors:
 - Esity
@@ -901,6 +901,7 @@ files:
 - lib/legion/tools/embedding_cache/migrations/001_create_tool_embedding_cache.rb
 - lib/legion/tools/registry.rb
 - lib/legion/tools/status.rb
+- lib/legion/tools/trigger_index.rb
 - lib/legion/trace_search.rb
 - lib/legion/trigger.rb
 - lib/legion/trigger/envelope.rb