legion-llm 0.9.19 → 0.9.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4743dd41922fbca3818f72bb48d353314ed2895ce0981e779ac29315c8ffea3b
-  data.tar.gz: a235df9596b11ddfd94ef5f075a9785f4bce0ae9c849db8b0b5845bde83af4ac
+  metadata.gz: 428a14e141f5cbbb278e05f49fd198ef13f6e789727037c90154a855b76a8b34
+  data.tar.gz: 8dc2aea0cd776675aad1c8ff198b35f0eba573e4a37c6e2bcdc0b6dfbbb7210b
 SHA512:
-  metadata.gz: 1c02e4859ef4bd824e854275fcbb1eadfe243b13477c9af9a9f2f3c484579eefa10bc70d0b1735c85b433b476ca9a8dd69b5fa788cdeafc651dcc370f71cfc40
-  data.tar.gz: 9f3ae0f1adba6bbe56653f0afce38c0eaa0dd4121b02279f5d9053be84682774f07401e346a855320c1bc006929d8ca184c88896098cd52697869c9b8d9f4630
+  metadata.gz: 3b9f1b9fae5371eefcbfbc89262bfa422e23df0e2e52d56735c5f3af9912b7245883ae4864568b6d8828e2dfdc3ab8c3d9fd4f125f662d6f8ae51602976d9952
+  data.tar.gz: dcdbf11006d26b929779bdb0e2ae8a541225b3a62c820dd027ef6801198a5056eb1d9a93e7cd504846b11b2196c187d7a415e263592864c3eae5ace4153b31ee

data/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Legion LLM Changelog
 
+## [0.9.22] - 2026-05-12
+
+### Added
+- Pin `legion_list_special_tools` before client and registry tools so models can inspect Legion special tools and the current `Legion::Settings::Extensions` inventory.
+- Surface special Ruby runtime execution with current process/PATH environment metadata, and add Legion-managed Python and pip tools when `legionio setup python` is available.
+
+### Changed
+- Route Python command interception through the same Legion Python runtime detection used by special tool injection.
+- Replace ad hoc `/api/llm/inference` tool-payload debug prints with structured debug logging.
+
+### Fixed
+- Chunk Ollama embedding requests according to configured model context limits and aggregate chunk vectors so large Apollo knowledge-capture documents do not exceed provider context windows.
+
+## [0.9.21] - 2026-05-12
+
+### Fixed
+- Route metering strictly through `legion-transport`, dropping events when transport is unavailable instead of writing metric events to `Legion::Data::Spool`.
+- Keep override confidence database access read-only by removing `Legion::Data::Local` upserts from `legion-llm`.
+- Stop conversation history and sticky state from writing directly to `Legion::Data` tables.
+
+## [0.9.20] - 2026-05-12
+
+### Added
+- Added `llm.gaia.advisory_enabled`, defaulting to `true`, so GAIA pre-request advisory shaping can be disabled without code changes.
+
+### Fixed
+- Preserve accumulated streamed native tool-call arguments from lex-llm provider responses instead of rebuilding final responses from partial stream chunks.
+- Symbolize extension tool arguments before invoking runner keyword methods so JSON string keys such as `chat_id` satisfy Ruby keyword parameters.
+- Match tool triggers from `Legion::Settings::Extensions` registry entries and keep registry tools injectable alongside client tools with better diagnostics.
+- Skip trigger matching cleanly when `Legion::Settings::Extensions` is not loaded instead of warning through a rescued `NameError`.
+- Accumulate only stream fallback state in the lex-llm adapter instead of retaining every streamed chunk when providers return final messages.
+- Apply explicit vLLM tool-name forcing only on the first native tool-loop round, allowing follow-up automatic tool calls after the requested tool returns.
+- Ignore absent GAIA advisory context-window limits when sizing RAG retrieval instead of routing nil through debug exception handling.
+
 ## [0.9.19] - 2026-05-11
 
 ### Added

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

@@ -43,6 +43,11 @@ module Legion
 
               tools = raw_tools || []
               validate_tools!(tools) unless tools.empty?
+              raw_tool_count = raw_tools.is_a?(Array) ? raw_tools.size : 0
+              log.debug(
+                "[llm][api][tools] action=request_tools_received request_id=#{request_id} " \
+                "has_tools=#{body.key?(:tools)} raw_tools_class=#{raw_tools&.class} raw_tools_count=#{raw_tool_count}"
+              )
 
               caller_identity = identity_canonical_name(env)
               last_user = messages.select { |m| (m[:role] || m['role']).to_s == 'user' }.last

data/lib/legion/llm/call/dispatch.rb

@@ -250,6 +250,14 @@ module Legion
           ext = Registry.for(provider, instance: instance)
           return ext if ext
 
+          if instance && instance.to_s != 'default'
+            ext = Registry.for(provider, instance: :default)
+            if ext
+              log.warn("[llm][native] instance_fallback provider=#{provider} requested=#{instance} using=default")
+              return ext
+            end
+          end
+
           instance_suffix = instance ? "/#{instance}" : ''
           log.error("[llm][native] provider_not_registered provider=#{provider}#{instance_suffix}")
           raise Legion::LLM::ProviderError,
@@ -296,7 +304,6 @@ module Legion
 
           tool_calls = normalize_tool_calls(raw[:tool_calls] || raw['tool_calls'] || raw[:tools] || raw['tools'] || result)
           stop_reason = raw[:stop_reason] || raw['stop_reason'] || (tool_calls.any? ? :tool_use : nil)
-
           {
             result:      result,
             model:       raw[:model] || raw['model'],

data/lib/legion/llm/call/embeddings.rb

@@ -24,11 +24,13 @@ module Legion
             return unavailable_result(model, provider) unless provider
 
             model ||= resolve_model
-            text_length = text.to_s.length
-            text = apply_prefix(coerce_text(text), model: model, task: task)
+            text = coerce_text(text)
+            text_length = text.length
+            prepared_texts = prepare_embedding_texts(text, provider: provider, model: model, task: task)
+            dispatch_text = prepared_texts.one? ? prepared_texts.first : prepared_texts
 
             log.info("[llm][embed] action=generate provider=#{provider} instance=#{instance || 'default'} " \
-                     "model=#{model} task=#{task} text_chars=#{text_length}")
+                     "model=#{model} task=#{task} text_chars=#{text_length} chunks=#{prepared_texts.size}")
 
             started_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             response = Dispatch.call(
@@ -36,24 +38,29 @@ module Legion
               instance:   instance,
               capability: :embed,
               model:      model,
-              text:       text,
+              text:       dispatch_text,
               dimensions: dimensions
             )
             elapsed = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - started_at) * 1000).round(1)
 
-            vector = normalize_vector(response[:result])
+            vector = if prepared_texts.size > 1
+                       aggregate_vectors(response[:result], weights: prepared_texts.map(&:length), model: model, provider: provider)
+                     else
+                       normalize_vector(response[:result])
+                     end
             vector = enforce_dimensions(vector) if enforce_dimension?
             tokens = extract_tokens(response)
 
             log.info("[llm][embed] action=generate.complete provider=#{provider} instance=#{instance || 'default'} " \
-                     "model=#{model} dimensions=#{vector&.size || 0} tokens=#{tokens} duration_ms=#{elapsed}")
+                     "model=#{model} dimensions=#{vector&.size || 0} tokens=#{tokens} chunks=#{prepared_texts.size} duration_ms=#{elapsed}")
 
             {
               vector:     vector,
               model:      model,
               provider:   provider,
               dimensions: vector&.size || 0,
-              tokens:     tokens
+              tokens:     tokens,
+              chunks:     prepared_texts.size
             }
           rescue StandardError => e
             handle_exception(e, level: :warn, operation: 'llm.embeddings.generate')
@@ -70,7 +77,20 @@ module Legion
             log.info("[llm][embed] action=generate_batch provider=#{provider} instance=#{instance || 'default'} " \
                      "model=#{model} count=#{texts.size} task=#{task}")
 
-            texts = texts.map { |t| apply_prefix(coerce_text(t), model: model, task: task) }
+            raw_texts = texts.map { |t| coerce_text(t) }
+            prepared_texts = raw_texts.map { |t| prepare_embedding_texts(t, provider: provider, model: model, task: task) }
+            if prepared_texts.any? { |chunks| chunks.size > 1 }
+              return generate_chunked_batch(
+                raw_texts,
+                model:      model,
+                provider:   provider,
+                instance:   instance,
+                dimensions: dimensions,
+                task:       task
+              )
+            end
+
+            texts = prepared_texts.map(&:first)
 
             started_at = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
             response = Dispatch.call(
@@ -122,11 +142,71 @@ module Legion
           end
 
           def apply_prefix(text, model:, task:)
-            base = model.to_s.split(':').first
-            prefix = PREFIX_REGISTRY.dig(base, task)
+            prefix = prefix_for(model, task)
             prefix ? "#{prefix}#{text}" : text
           end
 
+          def prepare_embedding_texts(text, provider:, model:, task:)
+            prefix = prefix_for(model, task).to_s
+            chunks = chunk_text(text, embedding_chunk_chars(provider: provider, model: model, prefix: prefix))
+            chunks.map { |chunk| prefix.empty? ? chunk : "#{prefix}#{chunk}" }
+          end
+
+          def prefix_for(model, task)
+            registry = Legion::LLM::Settings.value(:embedding, :prefix_registry, default: PREFIX_REGISTRY)
+            model_prefixes = Legion::LLM::Settings.config_value(registry, model_base(model), {})
+            Legion::LLM::Settings.config_value(model_prefixes, task)
+          end
+
+          def embedding_chunk_chars(provider:, model:, prefix:)
+            return nil unless provider.to_s == 'ollama'
+
+            embedding = Legion::LLM::Settings.value(:embedding, default: {})
+            context_chars = Legion::LLM::Settings.config_value(embedding, :ollama_context_chars, {})
+            limit = Legion::LLM::Settings.config_value(context_chars, model.to_s) ||
+                    Legion::LLM::Settings.config_value(context_chars, model_base(model)) ||
+                    Legion::LLM::Settings.config_value(embedding, :ollama_default_context_chars)
+            limit = limit.to_i
+            return nil unless limit.positive?
+
+            [limit - prefix.length, 1].max
+          end
+
+          def chunk_text(text, max_chars)
+            return [text] unless max_chars.to_i.positive?
+            return [text] if text.length <= max_chars
+
+            chunks = []
+            remaining = text.dup
+            until remaining.empty?
+              chunk, remaining = next_text_chunk(remaining, max_chars)
+              chunks << chunk unless chunk.empty?
+            end
+            chunks
+          end
+
+          def next_text_chunk(text, max_chars)
+            return [text, ''] if text.length <= max_chars
+
+            slice = text[0, max_chars]
+            boundary = chunk_boundary(slice, max_chars)
+            chunk = text[0, boundary].strip
+            remaining = text[boundary..].to_s.strip
+            [chunk.empty? ? text[0, max_chars] : chunk, remaining]
+          end
+
+          def chunk_boundary(slice, max_chars)
+            candidates = [slice.rindex("\n\n"), slice.rindex("\n"), slice.rindex('. '), slice.rindex(' ')]
+            boundary = candidates.compact.max
+            return max_chars unless boundary && boundary >= (max_chars * 0.5)
+
+            boundary + 1
+          end
+
+          def model_base(model)
+            model.to_s.split(':').first
+          end
+
           def normalize_vector(result)
             return nil if result.nil?
             return result if result.is_a?(Array) && result.first.is_a?(Numeric)
@@ -145,6 +225,39 @@ module Legion
             end
           end
 
+          def aggregate_vectors(result, weights:, model:, provider:)
+            vectors = normalize_batch(result, model, provider).map { |entry| entry[:vector] }
+            usable = vectors.each_with_index.filter_map do |vector, index|
+              next unless vector.is_a?(Array) && vector.first.is_a?(Numeric)
+
+              [vector, [weights[index].to_i, 1].max]
+            end
+            return nil if usable.empty?
+
+            dimensions = usable.first.first.size
+            usable.select! { |vector, _weight| vector.size == dimensions }
+            total_weight = usable.sum { |_vector, weight| weight }.to_f
+            Array.new(dimensions) do |index|
+              usable.sum { |vector, weight| vector[index].to_f * weight } / total_weight
+            end
+          end
+
+          def generate_chunked_batch(texts, model:, provider:, instance:, dimensions:, task:)
+            log.info("[llm][embed] action=generate_batch.chunked provider=#{provider} instance=#{instance || 'default'} " \
+                     "model=#{model} count=#{texts.size}")
+
+            texts.each_with_index.map do |text, index|
+              generate(
+                text:       text,
+                model:      model,
+                provider:   provider,
+                instance:   instance,
+                dimensions: dimensions,
+                task:       task
+              ).merge(index: index)
+            end
+          end
+
           def enforce_dimension?
             Legion::LLM::Settings.value(:embedding, :enforce_dimension) != false
           end

data/lib/legion/llm/call/lex_llm_adapter.rb

@@ -35,8 +35,8 @@ module Legion
         end
 
         def stream(model:, messages:, **opts, &block)
-          chunks = []
-          provider.stream_chat(
+          accumulator = build_stream_accumulator
+          response = provider.stream_chat(
             messages:    normalize_messages(messages, system: opts[:system]),
             tools:       normalize_tools(opts[:tools]),
             temperature: opts[:temperature],
@@ -47,11 +47,15 @@ module Legion
             tool_prefs:  opts[:tool_prefs],
             model:       model_info(model, offering_metadata: opts[:offering_metadata])
           ) do |chunk|
-            chunks << chunk
+            accumulate_stream_chunk(accumulator, chunk)
             block&.call(chunk)
           end
 
-          chunk_response(chunks, offering_metadata: opts[:offering_metadata])
+          if response
+            message_response(response, offering_metadata: opts[:offering_metadata])
+          else
+            chunk_response(accumulator, offering_metadata: opts[:offering_metadata])
+          end
         end
 
         def embed(model:, text:, dimensions: nil, **opts)
@@ -158,8 +162,8 @@ module Legion
             message_hash = normalize_hash(message)
             message_class.new(
               role:         message_hash[:role] || :user,
-              content:      message_hash[:content].to_s,
-              tool_calls:   message_hash[:tool_calls],
+              content:      normalize_message_content(message_hash[:content]),
+              tool_calls:   normalize_message_tool_calls(message_hash[:tool_calls]),
               tool_call_id: message_hash[:tool_call_id]
             )
           end
@@ -222,6 +226,47 @@ module Legion
           { role: :user, content: value }
         end
 
+        def normalize_message_content(content)
+          return content if content.nil? || content.is_a?(String)
+          return content if content.respond_to?(:attachments)
+
+          if content.is_a?(Array)
+            text_parts = content.filter_map { |part| text_part_content(part) }
+            return text_parts.join("\n\n") unless text_parts.empty?
+          end
+
+          text_part_content(content) || content.to_s
+        end
+
+        def text_part_content(part)
+          return unless part.respond_to?(:transform_keys)
+
+          normalized = part.transform_keys { |key| key.respond_to?(:to_sym) ? key.to_sym : key }
+          return unless normalized[:type].to_s == 'text'
+
+          normalized[:text].to_s
+        end
+
+        def normalize_message_tool_calls(tool_calls)
+          return tool_calls unless tool_calls.is_a?(Array)
+
+          tool_calls.filter_map do |tool_call|
+            normalized = normalize_hash(tool_call)
+            name = normalized[:name]
+            next if name.to_s.empty?
+
+            arguments = normalized[:arguments] || {}
+            [
+              name.to_sym,
+              lex_llm_namespace::ToolCall.new(
+                id:        normalized[:id],
+                name:      name.to_s,
+                arguments: arguments
+              )
+            ]
+          end.to_h
+        end
+
         def message_response(response, offering_metadata: nil)
           {
             result:      response.content,
@@ -234,19 +279,52 @@ module Legion
           }.compact
         end
 
-        def chunk_response(chunks, offering_metadata: nil)
-          last = chunks.reverse.find { |chunk| chunk.respond_to?(:input_tokens) }
-          tool_calls = chunks.filter_map { |chunk| chunk.tool_calls if chunk.respond_to?(:tool_calls) }.reduce({}) do |memo, calls|
-            memo.merge(calls || {})
-          end
+        def build_stream_accumulator
           {
-            result:      chunks.filter_map(&:content).join,
-            model:       last&.model_id,
+            content:            +'',
+            model:              nil,
+            usage:              {},
+            raw:                nil,
+            tool_calls:         {},
+            thinking_text:      +'',
+            thinking_signature: nil
+          }
+        end
+
+        def accumulate_stream_chunk(accumulator, chunk)
+          accumulator[:content] << chunk.content.to_s if chunk.respond_to?(:content) && !chunk.content.nil?
+          accumulate_stream_usage(accumulator, chunk)
+          accumulator[:tool_calls].merge!(chunk.tool_calls || {}) if chunk.respond_to?(:tool_calls)
+          accumulate_stream_thinking(accumulator, chunk)
+        end
+
+        def accumulate_stream_usage(accumulator, chunk)
+          return unless chunk.respond_to?(:input_tokens)
+
+          accumulator[:model] = chunk.model_id if chunk.respond_to?(:model_id)
+          accumulator[:usage] = usage_hash(chunk)
+          accumulator[:raw] = chunk.raw if chunk.respond_to?(:raw)
+        end
+
+        def accumulate_stream_thinking(accumulator, chunk)
+          return unless chunk.respond_to?(:thinking)
+
+          thinking = normalize_thinking_value(chunk.thinking)
+          content = thinking[:content]
+          accumulator[:thinking_text] << content.to_s unless content.nil?
+          accumulator[:thinking_signature] ||= thinking[:signature]
+        end
+
+        def chunk_response(accumulator, offering_metadata: nil)
+          tool_calls = accumulator[:tool_calls]
+          {
+            result:      accumulator[:content],
+            model:       accumulator[:model],
             tool_calls:  tool_calls.empty? ? nil : tool_calls,
             stop_reason: tool_calls.empty? ? nil : :tool_use,
-            thinking:    stream_thinking_hash(chunks),
-            usage:       last ? usage_hash(last) : {},
-            metadata:    response_metadata(last, offering_metadata: offering_metadata)
+            thinking:    stream_thinking_hash(accumulator),
+            usage:       accumulator[:usage],
+            metadata:    response_metadata(accumulator[:raw], offering_metadata: offering_metadata)
           }.compact
         end
 
@@ -284,15 +362,11 @@ module Legion
           }
         end
 
-        def stream_thinking_hash(chunks)
-          thinking_parts = chunks.filter_map do |chunk|
-            normalize_thinking_value(chunk.thinking) if chunk.respond_to?(:thinking)
-          end
-          thinking_text = thinking_parts.filter_map { |part| part[:content] }.join
-          signature = thinking_parts.find { |part| part[:signature] }&.dig(:signature)
+        def stream_thinking_hash(accumulator)
+          thinking_text = accumulator[:thinking_text]
           return nil if thinking_text.empty?
 
-          { content: thinking_text, signature: signature, enabled: true }.compact
+          { content: thinking_text, signature: accumulator[:thinking_signature], enabled: true }.compact
         end
 
         def thinking_hash(response)
@@ -325,7 +399,8 @@ module Legion
 
         def response_metadata(response = nil, offering_metadata: nil)
           metadata = normalize_offering_metadata(offering_metadata)
-          raw = response.respond_to?(:raw) ? response.raw : nil
+          raw = response.is_a?(Hash) ? response : nil
+          raw ||= response.raw if response.respond_to?(:raw)
           metadata[:raw_model] = raw['model'] if raw.is_a?(Hash) && raw['model']
           metadata.empty? ? {} : { offering: metadata }
         end