lex-llm 0.4.3 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b266813f29f9a144b2a57408f39fe98bc27b7a53e59b13871ca22c0dc8cf6127
-  data.tar.gz: 80cb7a8866d4cd2b9c150dd4567f99aa09d12208f8acfa38df3dd578c7c93831
+  metadata.gz: b7b27c6f6a3d3166cdf483b997908532b2a511e57496fc13bd9c1d854d0daee7
+  data.tar.gz: b21fda8924c6e108905b46ab962f62e67095f2a801dda19e284b639c7152fdd2
 SHA512:
-  metadata.gz: d43d28ab982b938f012a66000f73ee7cb4b9cae34ae31cbb6c11794d87845280ae919e2b91b81b594f76f6e11b95e9c57ff796c46d1ce595a74962b6d4a91800
-  data.tar.gz: 1976f2adfd60d698e547e92b00f7d779ab28b5c75c975a7245bc58ecc94dbb0d81b767c76552b3d1cee24a53fdd8d2bb98d1e3cb204816e27963491326daee50
+  metadata.gz: cd6836a39da034186d4987b91066ecb4506c7dab624bdcc54c623657a5fa3f76a3a8645f4541593f5e9b32de364677542960bdacf1c8140d4605db1b5e58d79f
+  data.tar.gz: 163cc40607ab68e5014460e426558e4b6be9a3ccf3cf25ab7b5414edeed430a5e293a8a9f9cd9cd0ac6d636e07d806223142881233836bb50343f47b64a12628

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # 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.
+
+## 0.4.4 - 2026-05-07
+
+- Fix `confirm_publish` to call `wait_for_confirms` with no arguments, matching bunny 3.1.0 API which removed the timeout parameter.
+- Fix `prepare_publisher_confirms` to pass `confirm_timeout:` to `confirm_select` when `publish_confirm_timeout_ms` is set.
+
 ## 0.4.3 - 2026-05-06
 
 - Move provider-owned fleet responder execution into `lex-llm` so provider gems no longer depend on `legion-llm`.

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

@@ -57,7 +57,14 @@ module Legion
             return unless options[:publisher_confirm] == true
 
             confirm_channel = publish_channel(exchange_dest)
-            confirm_channel.confirm_select if confirm_channel.respond_to?(:confirm_select)
+            return unless confirm_channel.respond_to?(:confirm_select)
+
+            timeout_ms = options[:publish_confirm_timeout_ms]
+            if timeout_ms
+              confirm_channel.confirm_select(confirm_timeout: timeout_ms.to_i)
+            else
+              confirm_channel.confirm_select
+            end
           end
 
           def publish_result(exchange_dest, options, return_state)
@@ -93,12 +100,7 @@ module Legion
             confirm_channel = publish_channel(exchange_dest)
             return :accepted unless confirm_channel.respond_to?(:wait_for_confirms)
 
-            timeout = options[:publish_confirm_timeout_ms]
-            confirmed = if timeout
-                          confirm_channel.wait_for_confirms(timeout.to_f / 1000.0)
-                        else
-                          confirm_channel.wait_for_confirms
-                        end
+            confirmed = confirm_channel.wait_for_confirms
             confirmed == false ? :nacked : :accepted
           rescue Timeout::Error => e
             handle_exception(e, level: :warn, handled: true, operation: 'llm.fleet.publish.confirm')

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/provider_settings.rb

@@ -60,6 +60,16 @@ module Legion
             left_value.is_a?(Hash) && right_value.is_a?(Hash) ? deep_merge(left_value, right_value) : right_value
           end
         end
+
+        def infer_tier_from_endpoint(url)
+          return :direct if url.nil? || url.to_s.empty?
+
+          require 'uri'
+          host = URI.parse(url.to_s).host.to_s.downcase
+          %w[localhost 127.0.0.1 ::1 [::1]].include?(host) ? :local : :direct
+        rescue URI::InvalidURIError
+          :direct
+        end
       end
     end
   end

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.3'
+      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.3
+  version: 0.4.7
 platform: ruby
 authors:
 - LegionIO