lex-llm 0.6.14 → 0.6.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b28d2162e2284642dcbb0e39384957962b8b609aa982c2dc1c085f84f560243f
-  data.tar.gz: a68c5e7d429b6ba04c2f431a4140d44c93542993430fe5b36e921347b1d9a728
+  metadata.gz: 3ba576c21739b35e60594706468f7a05769871b25e5acd466ae01cbc451eec70
+  data.tar.gz: e0ac7077fdc03270059abe385f202b681928e62d667f0cefad10a0a7d1b79760
 SHA512:
-  metadata.gz: 4a76155cd1c0b1ac8952647afff1ed38728bdb130a241ec4b416b752fd19c07074db18cf787c9dca6f2e4ffe1afe3be144800093837add92311e68a63219593b
-  data.tar.gz: 9eeadc0a087bb111ccaaea7feffc55aae57b44a0f60f331b3f7e0b7a43ed75737b70338319b6d1b8aa62de668a41b04b605444a9989e7776b2d315debd59ca38
+  metadata.gz: 997f024896ce8d0eb54d8574615312c0280efea81ecae75859b3bd702b8dd65aae0fbd5f615801e3e43b9d50cf6079ce4638d9a39488edb7e3a86887ee94a977
+  data.tar.gz: 3a33857e99d99a8f3358e781d46903560cb6932026d6889be2a922e23b865f3c2dacef4e38bd6a34e52af35474eab7f7e935d4c68360a8c56e2758836648d589

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.6.16 - 2026-08-04
+
+### Fixed
+- **Interleaved streaming tool-call fragments are correlated by provider index.** `ToolCall` now carries the provider wire index, and `StreamAccumulator` maps continuation fragments back to the call opened at that index. Parallel calls no longer send every id-less fragment to the most recently opened call, which previously lost one call's arguments and contaminated another's.
+
+## 0.6.15 - 2026-07-31
+
+### Fixed
+- **Remove dead `find_tool_call` method from StreamAccumulator.** Zero callers anywhere in lex-llm (confirmed via grep). The method referenced an undefined ivar `@latest_tool_call` (the actual ivar is `@latest_tool_call_id`) — it was broken dead code that could only ever return nil.
+- **StreamAccumulator no longer drops tool_call opening fragments that arrive with `id: nil`.** When a tool_call chunk has no `id` but carries a `name` (indicating it's an opening fragment, not a continuation), the accumulator now generates a UUID and starts the call instead of silently dropping it via `append_tool_call_fragment`. This is defensive hardening — normal OpenAI-compatible streaming always assigns an id to the opening fragment, but non-conforming backends or edge cases could produce id-less openers. Existing id-based correlation is unchanged.
+
+### Added
+- **Contract specs asserting streaming `stop_reason` propagates through the StreamAccumulator.** Three regression specs encoding the accumulator's stop_reason behavior: single stop_reason captured from a chunk and propagated to the assembled Message, last-wins semantics when multiple chunks carry non-nil stop_reason, and nil-when-absent (no chunks carry stop_reason). This is the lex-llm half of the cross-gem streaming finish_reason fix — paired with lex-llm-vllm v0.3.15 (#16) which wires `stop_reason: canonical.stop_reason` through `to_legacy_chunk`.
+
 ## 0.6.14 - 2026-07-31
 
 ### Added

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

@@ -26,6 +26,7 @@ module Legion
           @untagged_preamble_pending = true
           @untagged_preamble_buffer = +''
           @latest_tool_call_id = nil
+          @index_to_id = {}
         end
 
         def add(chunk)
@@ -149,6 +150,8 @@ module Legion
           new_tool_calls.each_value do |tool_call|
             if tool_call.id
               start_tool_call(tool_call)
+            elsif tool_call.name && @latest_tool_call_id.nil?
+              start_tool_call_without_id(tool_call)
             else
               append_tool_call_fragment(tool_call)
             end
@@ -156,13 +159,15 @@ module Legion
         end
 
         def start_tool_call(tool_call)
-          @tool_calls[tool_call.id] = ToolCall.new(
-            id: tool_call.id.empty? ? SecureRandom.uuid : tool_call.id,
+          resolved_id = tool_call.id.empty? ? SecureRandom.uuid : tool_call.id
+          @tool_calls[resolved_id] = ToolCall.new(
+            id: resolved_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
+          @latest_tool_call_id = resolved_id
+          @index_to_id[tool_call.index] = resolved_id unless tool_call.index.nil?
         end
 
         def mutable_tool_arguments(arguments)
@@ -175,8 +180,29 @@ module Legion
           end
         end
 
+        def start_tool_call_without_id(tool_call)
+          generated_id = SecureRandom.uuid
+          @tool_calls[generated_id] = ToolCall.new(
+            id: generated_id,
+            name: tool_call.name,
+            arguments: mutable_tool_arguments(tool_call.arguments),
+            thought_signature: tool_call.thought_signature
+          )
+          @latest_tool_call_id = generated_id
+          @index_to_id[tool_call.index] = generated_id unless tool_call.index.nil?
+        end
+
+        # Correlate a continuation fragment (id=nil, name=nil) to its call by the
+        # provider's authoritative wire index. Interleaved parallel calls
+        # (opener0, opener1, frag0, frag1, ...) only reassemble correctly when
+        # each fragment lands on the call at ITS index; recency (@latest_tool_call_id)
+        # sends every fragment to the last-opened call, losing one call's arguments
+        # and contaminating the other. Recency is retained only as the fallback for
+        # providers that emit no index.
         def append_tool_call_fragment(tool_call)
-          existing = @tool_calls[@latest_tool_call_id]
+          target_id = @index_to_id[tool_call.index] if tool_call.index
+          target_id ||= @latest_tool_call_id
+          existing = @tool_calls[target_id]
           return unless existing
 
           existing.arguments << tool_call.arguments.to_s
@@ -185,15 +211,6 @@ module Legion
           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]
-          else
-            @latest_tool_call_id = tool_call_id
-            @tool_calls[tool_call_id]
-          end
-        end
-
         def count_tokens(chunk)
           @input_tokens = chunk.input_tokens if chunk.input_tokens
           @output_tokens = chunk.output_tokens if chunk.output_tokens

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

@@ -5,14 +5,19 @@ module Legion
     module Llm
       # Represents a function call from an AI model to a Tool.
       class ToolCall
-        attr_reader :id, :name, :arguments
+        attr_reader :id, :name, :arguments, :index
         attr_accessor :thought_signature
 
-        def initialize(id:, name:, arguments: {}, thought_signature: nil)
+        # index carries the provider's authoritative wire position
+        # (delta.tool_calls[N].index) so the StreamAccumulator can correlate
+        # interleaved argument fragments to the right parallel call by index
+        # rather than by recency. nil for non-streaming/single-call paths.
+        def initialize(id:, name:, arguments: {}, thought_signature: nil, index: nil)
           @id = id
           @name = name
           @arguments = arguments
           @thought_signature = thought_signature
+          @index = index
         end
 
         def to_h

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.6.14'
+      VERSION = '0.6.16'
     end
   end
 end

data/spec/legion/extensions/llm/stream_accumulator_spec.rb

@@ -99,6 +99,62 @@ RSpec.describe Legion::Extensions::Llm::StreamAccumulator do
       expect(message.content).to eq(expected)
       expect(message.thinking).to be_nil
     end
+
+    it 'captures stop_reason from a chunk and propagates it to the assembled Message' do
+      accumulator = described_class.new
+      chunk = Legion::Extensions::Llm::Chunk.new(
+        role: :assistant, content: 'partial', model_id: 'm', stop_reason: :max_tokens
+      )
+
+      accumulator.add(chunk)
+      expect(accumulator.stop_reason).to eq(:max_tokens)
+
+      message = accumulator.to_message(nil)
+      expect(message.stop_reason).to eq(:max_tokens)
+    end
+
+    it 'uses the last non-nil stop_reason when multiple chunks carry one' do
+      accumulator = described_class.new
+      accumulator.add(Legion::Extensions::Llm::Chunk.new(
+                        role: :assistant, content: 'hello', model_id: 'm', stop_reason: :end_turn
+                      ))
+      accumulator.add(Legion::Extensions::Llm::Chunk.new(
+                        role: :assistant, content: nil, model_id: 'm', stop_reason: :max_tokens
+                      ))
+
+      expect(accumulator.stop_reason).to eq(:max_tokens)
+      expect(accumulator.to_message(nil).stop_reason).to eq(:max_tokens)
+    end
+
+    it 'leaves stop_reason nil when no chunk carries one' do
+      accumulator = described_class.new
+      accumulator.add(Legion::Extensions::Llm::Chunk.new(role: :assistant, content: 'hi', model_id: 'm'))
+
+      expect(accumulator.stop_reason).to be_nil
+      expect(accumulator.to_message(nil).stop_reason).to be_nil
+    end
+
+    it 'starts a tool call from an opening fragment with id nil but name present' do
+      accumulator = described_class.new
+      tool_call = Legion::Extensions::Llm::ToolCall.new(id: nil, name: 'weather', arguments: '')
+      chunk = Legion::Extensions::Llm::Chunk.new(
+        role: :assistant, content: nil, tool_calls: { weather: tool_call }
+      )
+
+      accumulator.add(chunk)
+
+      frag_call = Legion::Extensions::Llm::ToolCall.new(id: nil, name: nil, arguments: '{"city":"SF"}')
+      frag_chunk = Legion::Extensions::Llm::Chunk.new(
+        role: :assistant, content: nil, tool_calls: { fragment: frag_call }
+      )
+      accumulator.add(frag_chunk)
+
+      message = accumulator.to_message(nil)
+      expect(message.tool_calls.size).to eq(1)
+      tc = message.tool_calls.values.first
+      expect(tc.name).to eq('weather')
+      expect(tc.arguments).to eq({ 'city' => 'SF' })
+    end
   end
 
   describe '#filtered_chunk' do

metadata

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