lex-llm 0.6.14 → 0.6.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b28d2162e2284642dcbb0e39384957962b8b609aa982c2dc1c085f84f560243f
-  data.tar.gz: a68c5e7d429b6ba04c2f431a4140d44c93542993430fe5b36e921347b1d9a728
+  metadata.gz: 07f6e605230a187e17667abdf947db738dab8b823783cde124766278159c49f1
+  data.tar.gz: e1858e04a213ed78175c8647c74f05a5c300db4a8a54caadaba523cb3a1e71ef
 SHA512:
-  metadata.gz: 4a76155cd1c0b1ac8952647afff1ed38728bdb130a241ec4b416b752fd19c07074db18cf787c9dca6f2e4ffe1afe3be144800093837add92311e68a63219593b
-  data.tar.gz: 9eeadc0a087bb111ccaaea7feffc55aae57b44a0f60f331b3f7e0b7a43ed75737b70338319b6d1b8aa62de668a41b04b605444a9989e7776b2d315debd59ca38
+  metadata.gz: 10216387247f307ee05fe4e06a199cbf6cc762f6869636b16043adb18e1fdae355127f99e433e67614580e3c85b3d18b9d6199291d2703167184ee93e8810745
+  data.tar.gz: f010c914eddd807fc13593692a6fc20353ea1c12487838eed859493088b908a64a6459ee1866d5ffaaa9e4b3924e521b8ed3e79fce9e94fe27364283fb7be62e

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 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

@@ -149,6 +149,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
@@ -175,6 +177,17 @@ 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
+        end
+
         def append_tool_call_fragment(tool_call)
           existing = @tool_calls[@latest_tool_call_id]
           return unless existing
@@ -185,15 +198,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/version.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.6.14'
+      VERSION = '0.6.15'
     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.15
 platform: ruby
 authors:
 - LegionIO