lex-llm-vllm 0.3.11 → 0.3.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66c6939650ded871419a3833d9d0a89e5c31a104f3acccbb065af86af17709cb
-  data.tar.gz: e639e39a60ff4c03838100bd361048997fecfe38e92fdd9f1763809958a43f8e
+  metadata.gz: '0459c715b28893afc32019e6f2f831ee08824cd3a0224c17fa25164f5f14a9fc'
+  data.tar.gz: 72629182ec192e73316f29d1b491b471a1c8cfe6d87e348f2ce00a16f9df8a1b
 SHA512:
-  metadata.gz: cf346327446a5e3c7b8666c8ea04269d7fea32b7bbe89b9a0c11b7578fe3ca1a8f948cf4fc639265bfcfa6f0a65bca7007f24ce90146f6234f1589fcb6fe5c31
-  data.tar.gz: 1e324da7463bd1a63b14b5fde9b3f6030be0f8cdd933d802d350066beaf40fe8208998a298a848b00126bf5d1d68868b8384c2ed719fb863c825179aa8c92ced
+  metadata.gz: 60b334c314c6f29257ae7c9a073dfc034536f50f4c58e620137d49d88fb682d12f1abb5882ae792e7a99faffabd3cb01ba990f053f341d10b5478952f527e6bd
+  data.tar.gz: 3b602d7548c15a76068645d27da5a94619d7ca1954a2620c8291b2eb4af93384b2a4fe5f241b15487b3b8f7bb99a8294cd474ddac7f94ee1439d9e2d5f76ee08

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.3.14] - 2026-07-24
+
+### Fixed
+- **Translator passes `finish_reason` and `usage` through on all streaming chunk types.** vLLM sends `finish_reason` on the same chunk as the last content token. Previously the translator dropped it because the early-return pattern only emitted finish_reason when the delta was empty. Now `text_delta`, `tool_call_delta`, and `thinking_delta` chunks carry `stop_reason` and `usage` when present on the SSE event, enabling the accumulator to capture the real provider signal.
+- **Translator returns both thinking and content when vLLM sends both on the same SSE chunk.** vLLM emits `reasoning` and `content` simultaneously on the boundary between thinking and visible output. Previously the first-branch-wins pattern dropped content when reasoning was present, causing visible characters to disappear from responses (e.g. numbered list items losing their leading digit). `parse_chunk` now returns an array `[thinking_delta, text_delta]` when both fields are present, and the streaming handler iterates them.
+
+## [0.3.13] - 2026-07-14
+
+### Fixed
+- **Streaming dead stop on Qwen with thinking enabled.** `empty_delta?` only checked `delta['reasoning_content']`, missing vLLM's `delta['reasoning']` field. When the final chunk carried `finish_reason: "stop"` alongside a `reasoning` delta, the translator incorrectly treated it as an empty delta and fired the done chunk early — the content phase never started, producing an empty streaming response. Now checks both `reasoning_content` and `reasoning`. Also fixed `wire_metadata` to read from either field for sync responses.
+
+## [0.3.12] - 2026-07-05
+
+### Changed
+- Stop_reason mapping now uses the shared `Legion::Extensions::Llm::StopReasonMapping` mixin from lex-llm (>= 0.6.9) instead of a local `VLLM_STOP_REASON_MAP`. The local 3-entry map only recognized `tool_use` and silently fell back to `:end_turn` on the `tool_calls` finish_reason that OpenAI-compatible vLLM actually emits on tool turns — so vLLM tool completions were mis-reported as `end_turn`. The shared vocabulary maps both `tool_calls` and `tool_use` to `:tool_use` (plus `stop`/`end_turn`/`eos`, `length`/`max_tokens`, `stop_sequence`, `content_filter`), and is inherited by every provider so it no longer drifts per gem.
+
 ## [0.3.11] - 2026-06-20
 
 ### Fixed

data/lex-llm-vllm.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.6.0'
+  spec.add_dependency 'lex-llm', '>= 0.6.9'
 end

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

@@ -471,10 +471,14 @@ module Legion
 
           # Override: delegate SSE chunk parsing to the canonical translator.
           def build_chunk(data)
-            canonical_chunk = translator.parse_chunk(data)
-            return nil if canonical_chunk.nil?
+            result = translator.parse_chunk(data)
+            return nil if result.nil?
 
-            to_legacy_chunk(canonical_chunk, data)
+            if result.is_a?(Array)
+              result.map { |c| to_legacy_chunk(c, data) }
+            else
+              to_legacy_chunk(result, data)
+            end
           end
 
           def parse_list_models_response(response, provider, capabilities)

data/lib/legion/extensions/llm/vllm/translator.rb

@@ -2,6 +2,7 @@
 
 require 'legion/extensions/llm/canonical'
 require 'legion/extensions/llm/responses/thinking_extractor'
+require 'legion/extensions/llm/stop_reason_mapping'
 require 'legion/json'
 require 'legion/logging'
 
@@ -25,13 +26,10 @@ module Legion
         # rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- translator implementation
         class Translator
           include Legion::Logging::Helper
+          # Shared stop_reason vocabulary (tool_calls/tool_use/stop/length/...).
+          # vLLM is OpenAI-compatible and needs no additions; inherits the common map.
+          include Legion::Extensions::Llm::StopReasonMapping
 
-          # vLLM-specific stop_reason mapping (per conformance fixture stop_reason_matrix).
-          VLLM_STOP_REASON_MAP = {
-            'stop' => :end_turn,
-            'tool_use' => :tool_use,
-            'length' => :max_tokens
-          }.freeze
           FALLBACK_STOP_REASON = :end_turn
 
           # G18 parameter mapping: supported canonical params.
@@ -165,23 +163,43 @@ module Legion
               )
             end
 
+            chunk_stop_reason = finish_reason ? map_stop_reason(finish_reason) : nil
+            chunk_usage = finish_reason && data['usage'] ? Canonical::Usage.from_hash(data['usage']) : nil
+
             tool_calls = Array(delta['tool_calls'])
-            return build_tool_call_delta_chunk(tool_calls.first, request_id) unless tool_calls.empty?
+            unless tool_calls.empty?
+              if delta['content'] && !delta['content'].to_s.empty?
+                log.debug '[vllm][translator] action=content_dropped_with_tool_call ' \
+                          "content=#{delta['content'][0, 100].inspect} request_id=#{request_id}"
+              end
+              return build_tool_call_delta_chunk(tool_calls.first, request_id,
+                                                 stop_reason: chunk_stop_reason, usage: chunk_usage)
+            end
 
             # Thinking delta from reasoning_content
             reasoning_content = delta['reasoning_content'] || delta['reasoning']
+            content = delta['content']
             unless reasoning_content.to_s.empty?
-              return Canonical::Chunk.thinking_delta(
+              thinking_chunk = Canonical::Chunk.thinking_delta(
                 delta: reasoning_content,
                 request_id: request_id,
                 block_index: delta.dig('content_block', 'index'),
-                item_id: delta['content_block_start']&.dig('id')
+                item_id: delta['content_block_start']&.dig('id'),
+                stop_reason: content.to_s.empty? ? chunk_stop_reason : nil,
+                usage: content.to_s.empty? ? chunk_usage : nil
               )
+              return thinking_chunk if content.to_s.empty?
+
+              content_chunk = parse_text_delta_with_thinking(content, request_id, data,
+                                                             stop_reason: chunk_stop_reason, usage: chunk_usage)
+              return [thinking_chunk, content_chunk]
             end
 
             # Text delta — check for embedded think tags
-            content = delta['content']
-            return parse_text_delta_with_thinking(content, request_id, data) unless content.to_s.empty?
+            unless content.to_s.empty?
+              return parse_text_delta_with_thinking(content, request_id, data,
+                                                    stop_reason: chunk_stop_reason, usage: chunk_usage)
+            end
 
             nil
           rescue Legion::JSON::ParseError => e
@@ -200,7 +218,7 @@ module Legion
               tool_calls_as_text: true,
               forced_tool_choice: true,
               thinking_tags: %w[think thinking],
-              stop_reason_map: VLLM_STOP_REASON_MAP,
+              stop_reason_map: stop_reason_map,
               streaming_token_usage: true
             }.freeze
           end
@@ -613,7 +631,8 @@ module Legion
 
           def wire_metadata(wire, message, _thinking_meta)
             meta = {}
-            meta[:reasoning_content] = message['reasoning_content'] if message['reasoning_content']
+            reasoning = message['reasoning_content'] || message['reasoning']
+            meta[:reasoning_content] = reasoning if reasoning
             raw_usage = wire['usage']
             if raw_usage.is_a?(Hash) && raw_usage['completion_tokens_details']
               meta[:completion_tokens_details] = raw_usage['completion_tokens_details']
@@ -636,7 +655,7 @@ module Legion
           # fragments carry id: nil and a raw partial-JSON arguments string.
           # The StreamAccumulator keys off a nil id to append fragments to the
           # current tool call, so the id must NOT be synthesized here.
-          def build_tool_call_delta_chunk(first_call, request_id)
+          def build_tool_call_delta_chunk(first_call, request_id, stop_reason: nil, usage: nil)
             function = first_call.fetch('function', {})
 
             tc = Canonical::ToolCall.new(
@@ -650,14 +669,17 @@ module Legion
             Canonical::Chunk.tool_call_delta(
               tool_call: tc,
               request_id: request_id,
-              block_index: first_call['index']
+              block_index: first_call['index'],
+              stop_reason: stop_reason,
+              usage: usage
             )
           end
 
           def empty_delta?(delta)
             (delta['content'].nil? || delta['content'].to_s.empty?) &&
               (delta['tool_calls'].nil? || Array(delta['tool_calls']).empty?) &&
-              (delta['reasoning_content'].nil? || delta['reasoning_content'].to_s.empty?)
+              (delta['reasoning_content'].nil? || delta['reasoning_content'].to_s.empty?) &&
+              (delta['reasoning'].nil? || delta['reasoning'].to_s.empty?)
           end
 
           # Per-chunk think-tag extraction is structurally impossible while streaming:
@@ -667,11 +689,13 @@ module Legion
           # (Previously called ThinkingExtractor.extract_from_content, which is
           # private_class_method in lex-llm >= 0.5.0 and raised NoMethodError on
           # every streamed text delta, silently killing all vLLM streaming.)
-          def parse_text_delta_with_thinking(content, request_id, data)
+          def parse_text_delta_with_thinking(content, request_id, data, stop_reason: nil, usage: nil)
             Canonical::Chunk.text_delta(
               delta: content,
               request_id: request_id,
-              index: data['index']
+              index: data['index'],
+              stop_reason: stop_reason,
+              usage: usage
             )
           end
 
@@ -694,7 +718,7 @@ module Legion
           def map_stop_reason(raw)
             return FALLBACK_STOP_REASON if raw.nil? || raw.to_s.empty?
 
-            VLLM_STOP_REASON_MAP.fetch(raw.to_s, FALLBACK_STOP_REASON)
+            stop_reason_lookup(raw) || FALLBACK_STOP_REASON
           end
 
           # ── JSON helpers ──

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Vllm
-        VERSION = '0.3.11'
+        VERSION = '0.3.14'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-vllm
 version: !ruby/object:Gem::Version
-  version: 0.3.11
+  version: 0.3.14
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.9
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.9
 description: vLLM provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com