lex-llm 0.6.13 → 0.6.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0307598766a4f750febc8f0e72b2ebfa344291eb7feb3f134b2f7f1fffcb7620'
-  data.tar.gz: 713d7789cc022b01300ab4cc75811c43ea297ec817bb2780ce046426328155e9
+  metadata.gz: 07f6e605230a187e17667abdf947db738dab8b823783cde124766278159c49f1
+  data.tar.gz: e1858e04a213ed78175c8647c74f05a5c300db4a8a54caadaba523cb3a1e71ef
 SHA512:
-  metadata.gz: ef02b0c8ac4f2850a2823982d564ea6ca0a9f6e9c5fb23180231080ff2291f22b242848ad700b889fe7a721d555c2a8d10f55b9f057e11ea0f4c67f3348df6a4
-  data.tar.gz: cb4a22c7c6c8e4f151f09c7cb4f6b6b445a8faa085936344c747d7a90b648620f79673435731f9fe3f311e95b804e16c2af439b577aaa180ad2ae1d20b052721
+  metadata.gz: 10216387247f307ee05fe4e06a199cbf6cc762f6869636b16043adb18e1fdae355127f99e433e67614580e3c85b3d18b9d6199291d2703167184ee93e8810745
+  data.tar.gz: f010c914eddd807fc13593692a6fc20353ea1c12487838eed859493088b908a64a6459ee1866d5ffaaa9e4b3924e521b8ed3e79fce9e94fe27364283fb7be62e

data/CHANGELOG.md

@@ -1,5 +1,20 @@
 # 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
+- **Connection#close tears down the underlying Faraday connection.** Previously `Connection` had no lifecycle method — persistent HTTP connections were never explicitly closed, causing CLOSE_WAIT socket accumulation when provider peers sent FIN (e.g. during daemon shutdown or provider restarts)
+- **Provider#disconnect closes the connection and clears the reference.** Callers (legion-llm registry shutdown) can now explicitly tear down provider connections during graceful shutdown
+
 ## 0.6.13 - 2026-07-24
 
 ### Fixed

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

@@ -65,6 +65,13 @@ module Legion
           end
         end
 
+        def close
+          return unless @connection
+
+          @connection.close if @connection.respond_to?(:close)
+          @connection = nil
+        end
+
         def instance_variables
           super - %i[@config @connection]
         end

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

@@ -84,6 +84,11 @@ module Legion
           @connection = Connection.new(self, @config)
         end
 
+        def disconnect
+          @connection&.close
+          @connection = nil
+        end
+
         def api_base
           raise NotImplementedError
         end

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.13'
+      VERSION = '0.6.15'
     end
   end
 end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Legion::Extensions::Llm::Connection do
+  describe '#close' do
+    let(:provider) do
+      instance_double(
+        Legion::Extensions::Llm::Provider,
+        api_base: 'https://example.com',
+        configured?: true,
+        headers: {}
+      )
+    end
+
+    let(:config) do
+      instance_double(
+        Legion::Extensions::Llm::Configuration,
+        request_timeout: 300,
+        max_retries: 3,
+        retry_interval: 0.1,
+        retry_interval_randomness: 0.5,
+        retry_backoff_factor: 2,
+        http_proxy: nil,
+        log_regexp_timeout: nil
+      )
+    end
+
+    it 'nils out the underlying Faraday connection' do
+      conn = described_class.new(provider, config)
+      expect(conn.connection).not_to be_nil
+      conn.close
+      expect(conn.connection).to be_nil
+    end
+
+    it 'is safe to call multiple times' do
+      conn = described_class.new(provider, config)
+      conn.close
+      expect { conn.close }.not_to raise_error
+    end
+
+    it 'calls close on the Faraday connection when supported' do
+      conn = described_class.new(provider, config)
+      faraday = conn.connection
+      allow(faraday).to receive(:close)
+      conn.close
+      expect(faraday).to have_received(:close)
+    end
+  end
+end

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

@@ -717,4 +717,29 @@ RSpec.describe Legion::Extensions::Llm::Provider do
       expect(key_v3).to include('schema3')
     end
   end
+
+  describe '#disconnect' do
+    let(:provider_class) do
+      Class.new(described_class) do
+        def api_base = 'https://test.invalid'
+      end
+    end
+
+    let(:provider) do
+      provider_class.new({ request_timeout: 60, max_retries: 0,
+                           retry_interval: 0, retry_backoff_factor: 0,
+                           retry_interval_randomness: 0 })
+    end
+
+    it 'closes the connection and nils the reference' do
+      expect(provider.connection).not_to be_nil
+      provider.disconnect
+      expect(provider.connection).to be_nil
+    end
+
+    it 'is safe to call multiple times' do
+      provider.disconnect
+      expect { provider.disconnect }.not_to raise_error
+    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.13
+  version: 0.6.15
 platform: ruby
 authors:
 - LegionIO
@@ -395,6 +395,7 @@ files:
 - spec/legion/extensions/llm/conformance/fixtures/canonical_tools_request.json
 - spec/legion/extensions/llm/conformance/provider_tool_rendering_examples.rb
 - spec/legion/extensions/llm/conformance/provider_translator_examples.rb
+- spec/legion/extensions/llm/connection_close_spec.rb
 - spec/legion/extensions/llm/connection_logging_spec.rb
 - spec/legion/extensions/llm/connection_retry_spec.rb
 - spec/legion/extensions/llm/context_spec.rb