legion-llm 0.6.29 → 0.6.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f61fe00ccd51184aa08b50f2169e510db99ac249bcd71c61310b2705dda1e8d4
-  data.tar.gz: 5fe4035e3d6ea242d52d681a7e44a11952ddd82b71aa009de628c18bae838965
+  metadata.gz: 0a2032854701a258fc788e3b3ef4cd495a2f031765c29775ed1486dd5eb8f35f
+  data.tar.gz: 62cd0ed1943b0730be9adb30c6c1b77308f10f9e223cfaea47f13d90b9794b6c
 SHA512:
-  metadata.gz: 7c91776441b4e6d943b4e33b2a1b6f69919215457889e88952b5ce79c3089dc783a5bfea24651c1ae844ec6b364c55b47889bf291035eedf388263bb59e364ee
-  data.tar.gz: 953104b4e691e18686f3aa8af3e981f47b1c7fb76b2923c59ca5fa966d4a5aab5ab8f85fe89f612f1896d3f6af0f3ad8f86e75f5d25b591b28a06e5d401322c8
+  metadata.gz: 5e7a3f1e28c2af1d5cc3489a4bbe2592e7e019511920ad0c7c82943a0f444f36500d9707f6cda52f342a9af79922178bb5df249b1f53b477b52a9920ed856e9d
+  data.tar.gz: 69d8dc01c5c43a4fa7acfde15e81986e757670127fae2140b22ca77c4d8938ff0d1fa91a61d4c6664269ae147b26416c066ef57ab4fecbc86b605d8541c047c2

data/CHANGELOG.md

@@ -2,8 +2,20 @@
 
 ## [Unreleased]
 
+## [0.6.31] - 2026-04-10
+
+### Fixed
+- `ConversationStore#db_append_message` — coerce multi-part content blocks (arrays of `{type:, text:}` hashes) to plain string before Sequel insert, preventing `PG::UndefinedColumn` errors
+- `ConversationStore#next_seq` — fall back to DB max seq when in-memory message list is empty, preventing seq collisions after eviction or restart
+
+## [0.6.30] - 2026-04-10
+
 ### Added
-- Broker soft consumer in Providers module — tries Identity::Broker before Settings for all provider credentials (Phase 8 Wave 2)
+- `Legion::LLM::Pipeline::Steps::TriggerMatch` — pipeline step that matches recent message words against `Legion::Tools::TriggerIndex` and populates `@triggered_tools`
+- `tool_trigger` settings defaults (`scan_depth: 2`, `tool_limit: 10`) in `Legion::LLM::Settings`
+- Trigger-matched tools are injected into the RubyLLM session in `inject_registry_tools` after always-loaded tools
+- `:trigger_match` step inserted between `:rag_context` and `:tool_discovery` in `STEPS` and `PRE_PROVIDER_STEPS`
+- `:trigger_match` added to all profile skip lists that skip `:tool_discovery` (`GAIA_SKIP`, `SYSTEM_SKIP`, `QUICK_REPLY_SKIP`, `SERVICE_SKIP`)
 
 ## [0.6.29] - 2026-04-09
 

data/lib/legion/llm/conversation_store.rb

@@ -182,6 +182,16 @@ module Legion
 
         def next_seq(conversation_id)
           msgs = conversations[conversation_id][:messages]
+          if msgs.empty? && db_available?
+            begin
+              max = Legion::Data.connection[:conversation_messages]
+                                .where(conversation_id: conversation_id)
+                                .max(:seq)
+              return (max || 0) + 1
+            rescue StandardError
+              # fall through to default
+            end
+          end
           msgs.empty? ? 1 : msgs.last[:seq] + 1
         end
 
@@ -373,13 +383,23 @@ module Legion
         end
 
         def db_append_message(conversation_id, msg)
-          content = msg[:content]
-          content = content.to_json unless content.is_a?(String) || content.nil?
+          # Coerce content to plain string — content may arrive as an array of
+          # multi-part blocks (e.g. [{type: "text", text: "..."}]) which Sequel
+          # would misinterpret as a filter expression, causing PG::UndefinedColumn.
+          raw_content = msg[:content]
+          coerced_content = if raw_content.is_a?(Array)
+                              raw_content.filter_map do |b|
+                                b.is_a?(Hash) ? (b[:text] || b['text']) : b.to_s
+                              end.join
+                            else
+                              raw_content.to_s
+                            end
+
           row = {
             conversation_id: conversation_id,
             seq:             msg[:seq],
             role:            msg[:role].to_s,
-            content:         content,
+            content:         coerced_content,
             provider:        msg[:provider]&.to_s,
             model:           msg[:model]&.to_s,
             input_tokens:    msg[:input_tokens],

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

@@ -19,6 +19,7 @@ module Legion
                     :escalation_chain
         attr_accessor :tool_event_handler
 
+        include Steps::TriggerMatch
         include Steps::ToolDiscovery
         include Steps::ToolCalls
         include Steps::KnowledgeCapture
@@ -29,14 +30,14 @@ module Legion
 
         STEPS = %i[
           tracing_init idempotency conversation_uuid context_load
-          rbac classification billing gaia_advisory tier_assignment rag_context tool_discovery
+          rbac classification billing gaia_advisory tier_assignment rag_context trigger_match tool_discovery
           routing request_normalization token_budget provider_call response_normalization
           debate confidence_scoring tool_calls context_store post_response knowledge_capture response_return
         ].freeze
 
         PRE_PROVIDER_STEPS = %i[
           tracing_init idempotency conversation_uuid context_load
-          rbac classification billing gaia_advisory tier_assignment rag_context tool_discovery
+          rbac classification billing gaia_advisory tier_assignment rag_context trigger_match tool_discovery
           routing request_normalization token_budget
         ].freeze
 
@@ -62,6 +63,7 @@ module Legion
           @raw_response = nil
           @exchange_id = nil
           @discovered_tools = []
+          @triggered_tools = []
           @resolved_provider = nil
           @resolved_model = nil
           @confidence_score = nil
@@ -102,6 +104,20 @@ module Legion
             handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_always_tool')
           end
 
+          # Trigger-matched tools — inject tools surfaced by trigger word matching
+          if @triggered_tools.any?
+            @triggered_tools.each do |tool_class|
+              adapter = ToolAdapter.new(tool_class)
+              next if injected_names.include?(adapter.name)
+
+              session.with_tool(adapter)
+              injected_names << adapter.name
+            rescue StandardError => e
+              @warnings << "Failed to inject triggered tool: #{e.message}"
+              handle_exception(e, level: :warn, operation: 'llm.pipeline.inject_triggered_tool')
+            end
+          end
+
           # Requested deferred tools — inject only if explicitly requested
           deferred = ::Legion::Tools::Registry.respond_to?(:deferred_tools) ? ::Legion::Tools::Registry.deferred_tools : []
           requested = requested_deferred_tool_names
@@ -121,6 +137,7 @@ module Legion
           log.info(
             "[llm][tools] inject request_id=#{@request.id} " \
             "always=#{::Legion::Tools::Registry.tools.size} " \
+            "triggered=#{@triggered_tools.size} " \
             "deferred_available=#{deferred.size} " \
             "requested_deferred=#{requested.size} " \
             "injected=#{injected_names.size} names=#{injected_names.first(25).join(',')}"

data/lib/legion/llm/pipeline/profile.rb

@@ -6,18 +6,18 @@ module Legion
       module Profile
         GAIA_SKIP = %i[
           idempotency conversation_uuid context_load rbac classification
-          billing gaia_advisory tool_discovery context_store post_response
+          billing gaia_advisory trigger_match tool_discovery context_store post_response
         ].freeze
 
         SYSTEM_SKIP = %i[
           idempotency conversation_uuid context_load rbac classification
-          billing gaia_advisory rag_context tool_discovery context_store
+          billing gaia_advisory rag_context trigger_match tool_discovery context_store
           post_response
         ].freeze
 
         QUICK_REPLY_SKIP = %i[
           idempotency conversation_uuid context_load classification
-          gaia_advisory rag_context tool_discovery confidence_scoring
+          gaia_advisory rag_context trigger_match tool_discovery confidence_scoring
           tool_calls context_store post_response knowledge_capture
         ].freeze
 
@@ -25,7 +25,7 @@ module Legion
 
         SERVICE_SKIP = %i[
           conversation_uuid context_load gaia_advisory
-          rag_context tool_discovery confidence_scoring
+          rag_context trigger_match tool_discovery confidence_scoring
           tool_calls context_store knowledge_capture
         ].freeze
 

data/lib/legion/llm/pipeline/steps/trigger_match.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+
+module Legion
+  module LLM
+    module Pipeline
+      module Steps
+        module TriggerMatch
+          include Legion::Logging::Helper
+
+          def step_trigger_match
+            start_time = nil
+            return unless defined?(::Legion::Tools::TriggerIndex)
+            return if ::Legion::Tools::TriggerIndex.empty?
+
+            start_time = ::Time.now
+
+            text = extract_recent_text
+            word_set = normalize_message_words(text)
+            return if word_set.empty?
+
+            matched, per_word = ::Legion::Tools::TriggerIndex.match(word_set)
+            subtract_always_loaded(matched)
+            return if matched.empty?
+
+            limit = trigger_tool_limit
+            @triggered_tools = if matched.size <= limit
+                                 matched.to_a
+                               else
+                                 rank_and_cap(matched, per_word, limit)
+                               end
+
+            if @triggered_tools.any?
+              names = @triggered_tools.map(&:tool_name)
+              @enrichments['tool:trigger_match'] = {
+                content:   "#{@triggered_tools.size} tools matched via trigger words",
+                data:      { tool_count: @triggered_tools.size, tool_names: names },
+                timestamp: ::Time.now
+              }
+            end
+
+            record_trigger_match_timeline(@triggered_tools.size, start_time)
+          rescue StandardError => e
+            @warnings << "Trigger match error: #{e.message}"
+            handle_exception(e, level: :warn, operation: 'llm.pipeline.steps.trigger_match')
+            record_trigger_match_timeline(0, start_time)
+          end
+
+          private
+
+          def extract_recent_text
+            depth = trigger_scan_depth
+            messages = @request.messages.last(depth)
+            messages.map do |msg|
+              if msg.is_a?(Hash)
+                msg[:content] || msg['content'] || msg.to_s
+              else
+                msg.to_s
+              end
+            end.join(' ')
+          end
+
+          def normalize_message_words(text)
+            return Set.new if text.nil? || text.empty?
+
+            text.downcase.gsub(/[^a-z ]/, ' ').split.to_set
+          end
+
+          def rank_and_cap(matched, per_word, limit)
+            scores = Hash.new(0)
+            per_word.each_value do |tools|
+              tools.each { |tool| scores[tool] += 1 }
+            end
+            matched.to_a
+                   .sort_by { |tool| [-scores[tool], tool.tool_name] }
+                   .first(limit)
+          end
+
+          def subtract_always_loaded(matched)
+            return unless defined?(::Legion::Tools::Registry) &&
+                          ::Legion::Tools::Registry.respond_to?(:always_loaded_names)
+
+            always = ::Legion::Tools::Registry.always_loaded_names
+            matched.reject! { |tool| always.include?(tool.tool_name) }
+          end
+
+          def trigger_scan_depth
+            Legion::Settings.dig(:llm, :tool_trigger, :scan_depth) || 2
+          end
+
+          def trigger_tool_limit
+            Legion::Settings.dig(:llm, :tool_trigger, :tool_limit) || 10
+          end
+
+          def record_trigger_match_timeline(count, start_time = nil)
+            return unless @timeline.respond_to?(:record)
+
+            duration = start_time ? ((::Time.now - start_time) * 1000).to_i : 0
+            @timeline.record(
+              category: :enrichment, key: 'tool:trigger_match',
+              direction: :inbound, detail: "#{count} tools matched via trigger words",
+              from: 'trigger_index', to: 'pipeline',
+              duration_ms: duration
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/pipeline/steps.rb

@@ -18,6 +18,7 @@ require_relative 'steps/gaia_advisory'
 require_relative 'steps/tier_assigner'
 require_relative 'steps/post_response'
 require_relative 'steps/tool_discovery'
+require_relative 'steps/trigger_match'
 require_relative 'steps/tool_calls'
 require_relative 'steps/rag_context'
 require_relative 'steps/rag_guard'

data/lib/legion/llm/settings.rb

@@ -33,7 +33,8 @@ module Legion
           telemetry:                 telemetry_defaults,
           context_curation:          context_curation_defaults,
           debate:                    debate_defaults,
-          provider_layer:            provider_layer_defaults
+          provider_layer:            provider_layer_defaults,
+          tool_trigger:              tool_trigger_defaults
         }
       end
 
@@ -226,6 +227,13 @@ module Legion
         }
       end
 
+      def self.tool_trigger_defaults
+        {
+          scan_depth: 2,
+          tool_limit: 10
+        }
+      end
+
       def self.debate_defaults
         {
           enabled:                  false,

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.6.29'
+    VERSION = '0.6.31'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.6.29
+  version: 0.6.31
 platform: ruby
 authors:
 - Esity
@@ -300,6 +300,7 @@ files:
 - lib/legion/llm/pipeline/steps/token_budget.rb
 - lib/legion/llm/pipeline/steps/tool_calls.rb
 - lib/legion/llm/pipeline/steps/tool_discovery.rb
+- lib/legion/llm/pipeline/steps/trigger_match.rb
 - lib/legion/llm/pipeline/timeline.rb
 - lib/legion/llm/pipeline/tool_adapter.rb
 - lib/legion/llm/pipeline/tool_dispatcher.rb