lex-llm 0.4.5 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33dcc097174b40983896f2c6676ca20e055f262e9f85d27df6a4b1e6f27e9632
-  data.tar.gz: 0abfa31c8b8d3d034f0c0d87e865bc80c5d6f8d5d5232a94ce614da0403b6868
+  metadata.gz: b7b27c6f6a3d3166cdf483b997908532b2a511e57496fc13bd9c1d854d0daee7
+  data.tar.gz: b21fda8924c6e108905b46ab962f62e67095f2a801dda19e284b639c7152fdd2
 SHA512:
-  metadata.gz: 27dc2378bfb280e77267f15f2ef6945d2453f1ac74c0437815e5c474e1310c951f3b4d80167f182f4465003c1699d97e200f7f1a8f2d479defe94a90dce35ddd
-  data.tar.gz: edf02a16a1a1373ac3dc97807af981314bd6fefd4b175bd60b6418e2526b8701f3726b657a6c4b0fb80a64765c2629614601ffe7abef847a6015b1a04ef91275
+  metadata.gz: cd6836a39da034186d4987b91066ecb4506c7dab624bdcc54c623657a5fa3f76a3a8645f4541593f5e9b32de364677542960bdacf1c8140d4605db1b5e58d79f
+  data.tar.gz: 163cc40607ab68e5014460e426558e4b6be9a3ccf3cf25ab7b5414edeed430a5e293a8a9f9cd9cd0ac6d636e07d806223142881233836bb50343f47b64a12628

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.4.7 - 2026-05-08
+
+- Unpack legacy nested fleet `options` before provider dispatch so `system` and `tools` arrive as normal provider keyword arguments.
+
+## 0.4.6 - 2026-05-07
+
+- Render OpenAI-compatible embedding payloads with the canonical model id when callers pass `Model::Info` objects.
+- Preserve streamed OpenAI-compatible tool-call argument fragments until the accumulator can assemble and parse the full JSON payload.
+- Treat malformed accumulated streaming tool arguments as handled provider output and return empty arguments instead of raising.
+
 ## 0.4.5 - 2026-05-07
 
 - Add `ProviderSettings.infer_tier_from_endpoint(url)` shared utility: returns `:local` for localhost/loopback endpoints, `:direct` for all other hosts. Handles `URI::InvalidURIError` and nil safely.

data/lib/legion/extensions/llm/fleet/worker_execution.rb

@@ -64,6 +64,7 @@ module Legion
             provider = provider.call(envelope) if provider.respond_to?(:call) && !provider.respond_to?(:chat)
             operation = envelope_value(envelope, :operation).to_sym
             params = normalize_hash(envelope_value(envelope, :params) || {})
+            params = unpack_legacy_options(params)
             model = envelope_value(envelope, :model)
 
             case operation
@@ -80,6 +81,14 @@ module Legion
             end
           end
 
+          def unpack_legacy_options(params)
+            options = params.delete(:options)
+            return params unless options.is_a?(Hash)
+
+            normalize_hash(options).each { |key, value| params[key] = value unless params.key?(key) }
+            params
+          end
+
           def reset_idempotency_cache!
             @idempotency_keys = Concurrent::Map.new
             @idempotency_mutex = Mutex.new

data/lib/legion/extensions/llm/provider/open_ai_compatible.rb

@@ -176,7 +176,7 @@ module Legion
               role: :assistant,
               content: content,
               model_id: data['model'],
-              tool_calls: parse_tool_calls(delta['tool_calls']),
+              tool_calls: parse_streaming_tool_calls(delta['tool_calls']),
               thinking: thinking,
               input_tokens: usage['prompt_tokens'],
               output_tokens: usage['completion_tokens'],
@@ -184,6 +184,21 @@ module Legion
             )
           end
 
+          def parse_streaming_tool_calls(tool_calls)
+            return nil unless tool_calls&.any?
+
+            tool_calls.to_h do |call|
+              function = call.fetch('function', {})
+              name = function['name']
+              id = call['id']
+              key = (name || id || call['index']).to_s.to_sym
+              [
+                key,
+                Legion::Extensions::Llm::ToolCall.new(id: id, name: name, arguments: function['arguments'] || '')
+              ]
+            end
+          end
+
           def extract_thinking_from_chunk(delta)
             reasoning = delta['reasoning_content'] || delta['reasoning']
             content = delta['content']
@@ -273,7 +288,7 @@ module Legion
           end
 
           def render_embedding_payload(text, model:, dimensions:)
-            { model: model, input: text, dimensions: dimensions }.compact
+            { model: model.respond_to?(:id) ? model.id : model, input: text, dimensions: dimensions }.compact
           end
 
           def parse_embedding_response(response, model:, text:)

data/lib/legion/extensions/llm/stream_accumulator.rb

@@ -5,6 +5,8 @@ module Legion
     module Llm
       # Assembles streaming responses from LLMs into complete messages.
       class StreamAccumulator
+        include Legion::Logging::Helper
+
         attr_reader :content, :model_id, :tool_calls
 
         def initialize
@@ -77,13 +79,7 @@ module Legion
 
         def tool_calls_from_stream
           tool_calls.transform_values do |tc|
-            arguments = if tc.arguments.is_a?(String) && !tc.arguments.empty?
-                          Legion::JSON.parse(tc.arguments, symbolize_names: false)
-                        elsif tc.arguments.is_a?(String)
-                          {}
-                        else
-                          tc.arguments
-                        end
+            arguments = parse_accumulated_arguments(tc.arguments)
 
             ToolCall.new(
               id: tc.id,
@@ -94,38 +90,59 @@ module Legion
           end
         end
 
-        def accumulate_tool_calls(new_tool_calls) # rubocop:disable Metrics/PerceivedComplexity
+        def parse_accumulated_arguments(arguments)
+          return arguments unless arguments.is_a?(String)
+          return {} if arguments.empty?
+
+          Legion::JSON.parse(arguments, symbolize_names: false)
+        rescue Legion::JSON::ParseError => e
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.stream.parse_tool_arguments')
+          {}
+        end
+
+        def accumulate_tool_calls(new_tool_calls)
           if Legion::Extensions::Llm.config.log_stream_debug
             Legion::Extensions::Llm.logger.debug { "Accumulating tool calls: #{new_tool_calls}" }
           end
           new_tool_calls.each_value do |tool_call|
             if tool_call.id
-              tool_call_id = tool_call.id.empty? ? SecureRandom.uuid : tool_call.id
-              tool_call_arguments = tool_call.arguments
-              if tool_call_arguments.nil? || (tool_call_arguments.respond_to?(:empty?) && tool_call_arguments.empty?)
-                tool_call_arguments = +''
-              end
-              @tool_calls[tool_call.id] = ToolCall.new(
-                id: tool_call_id,
-                name: tool_call.name,
-                arguments: tool_call_arguments,
-                thought_signature: tool_call.thought_signature
-              )
-              @latest_tool_call_id = tool_call.id
+              start_tool_call(tool_call)
             else
-              existing = @tool_calls[@latest_tool_call_id]
-              if existing
-                fragment = tool_call.arguments
-                fragment = '' if fragment.nil?
-                existing.arguments << fragment
-                if tool_call.thought_signature && existing.thought_signature.nil?
-                  existing.thought_signature = tool_call.thought_signature
-                end
-              end
+              append_tool_call_fragment(tool_call)
             end
           end
         end
 
+        def start_tool_call(tool_call)
+          @tool_calls[tool_call.id] = ToolCall.new(
+            id: tool_call.id.empty? ? SecureRandom.uuid : tool_call.id,
+            name: tool_call.name,
+            arguments: mutable_tool_arguments(tool_call.arguments),
+            thought_signature: tool_call.thought_signature
+          )
+          @latest_tool_call_id = tool_call.id
+        end
+
+        def mutable_tool_arguments(arguments)
+          if arguments.nil? || (arguments.respond_to?(:empty?) && arguments.empty?)
+            +''
+          elsif arguments.is_a?(String)
+            +arguments
+          else
+            arguments
+          end
+        end
+
+        def append_tool_call_fragment(tool_call)
+          existing = @tool_calls[@latest_tool_call_id]
+          return unless existing
+
+          existing.arguments << tool_call.arguments.to_s
+          return unless tool_call.thought_signature && existing.thought_signature.nil?
+
+          existing.thought_signature = tool_call.thought_signature
+        end
+
         def find_tool_call(tool_call_id)
           if tool_call_id.nil?
             @tool_calls[@latest_tool_call]

data/lib/legion/extensions/llm/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.4.5'
+      VERSION = '0.4.7'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.7
 platform: ruby
 authors:
 - LegionIO