lex-llm 0.6.12 → 0.6.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fcdfa125fb151f6cac7d0468881476c99b8145738282c20e52d630a7b739702
-  data.tar.gz: 57c2ded197c24f6d05c0227d3bbdd9d8ea843e04df69c5fa4fa1b33b934ad0d7
+  metadata.gz: b28d2162e2284642dcbb0e39384957962b8b609aa982c2dc1c085f84f560243f
+  data.tar.gz: a68c5e7d429b6ba04c2f431a4140d44c93542993430fe5b36e921347b1d9a728
 SHA512:
-  metadata.gz: cf38e525d5124d5e17a063ff88e7a14d083830f326b90ce9212e8558d8106e934afd456bba8d37a34c3f822f66f7ad772f34300706006d909619063f36a13199
-  data.tar.gz: a98036763e921140f0a1e32e66640826de90b3c211ec7e2fc19aa5bbd2496015996eac6c29798fa2ef073ff9f276ec58bc5b581c4edf019aa8402f75e5c6273a
+  metadata.gz: 4a76155cd1c0b1ac8952647afff1ed38728bdb130a241ec4b416b752fd19c07074db18cf787c9dca6f2e4ffe1afe3be144800093837add92311e68a63219593b
+  data.tar.gz: 9eeadc0a087bb111ccaaea7feffc55aae57b44a0f60f331b3f7e0b7a43ed75737b70338319b6d1b8aa62de668a41b04b605444a9989e7776b2d315debd59ca38

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 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
+- **StreamAccumulator now captures `stop_reason` from provider done chunks.** Previously, the real `finish_reason` from the provider was silently discarded — the accumulator had no field for it, and the legacy `Message` class couldn't carry it. Downstream code always synthesized `:end_turn` regardless of what the provider actually said. Now `stop_reason` propagates through accumulator → Message → `normalize_response`.
+- **Canonical::Chunk factory methods accept `stop_reason:` and `usage:` kwargs.** `text_delta`, `thinking_delta`, and `tool_call_delta` factories now pass through stop_reason and usage when present on the SSE event, enabling translators to propagate finish_reason on non-empty chunks without buffering.
+- **Streaming handler iterates array results from `build_chunk`.** When a translator returns multiple chunks from a single SSE event (e.g. both thinking and content on the same delta), the handler now yields each one to the accumulator instead of expecting a single chunk. Prevents content loss at thinking/content boundaries.
+
 ## 0.6.12 - 2026-07-15
 
 ### Fixed

data/lib/legion/extensions/llm/canonical/chunk.rb

@@ -16,39 +16,42 @@ module Legion
         ) do
           # Build a text delta chunk.
           def self.text_delta(delta:, request_id:, conversation_id: nil, exchange_id: nil,
-                              index: 0, block_index: nil, item_id: nil)
+                              index: 0, block_index: nil, item_id: nil,
+                              stop_reason: nil, usage: nil)
             new(
               type: :text_delta, delta: delta, index: index,
               request_id: request_id, conversation_id: conversation_id,
               exchange_id: exchange_id, block_index: block_index,
               item_id: item_id, tool_call: nil, signature: nil,
-              usage: nil, stop_reason: nil, metadata: {},
+              usage: usage, stop_reason: stop_reason, metadata: {},
               timestamp: ::Time.now
             )
           end
 
           # Build a thinking delta chunk.
           def self.thinking_delta(delta:, request_id:, conversation_id: nil, exchange_id: nil,
-                                  index: 0, block_index: nil, item_id: nil, signature: nil)
+                                  index: 0, block_index: nil, item_id: nil, signature: nil,
+                                  stop_reason: nil, usage: nil)
             new(
               type: :thinking_delta, delta: delta, index: index,
               request_id: request_id, conversation_id: conversation_id,
               exchange_id: exchange_id, block_index: block_index,
               item_id: item_id, tool_call: nil, signature: signature,
-              usage: nil, stop_reason: nil, metadata: {},
+              usage: usage, stop_reason: stop_reason, metadata: {},
               timestamp: ::Time.now
             )
           end
 
           # Build a tool_call_delta chunk (supports multiple in-flight tool calls via tool_call.id).
           def self.tool_call_delta(tool_call:, request_id:, conversation_id: nil, exchange_id: nil,
-                                   index: 0, block_index: nil, item_id: nil)
+                                   index: 0, block_index: nil, item_id: nil,
+                                   stop_reason: nil, usage: nil)
             new(
               type: :tool_call_delta, index: index,
               request_id: request_id, conversation_id: conversation_id,
               exchange_id: exchange_id, block_index: block_index,
               item_id: item_id, delta: nil, tool_call: tool_call, signature: nil,
-              usage: nil, stop_reason: nil, metadata: {},
+              usage: usage, stop_reason: stop_reason, metadata: {},
               timestamp: ::Time.now
             )
           end

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

@@ -7,7 +7,7 @@ module Legion
       class Message
         ROLES = %i[system user assistant tool].freeze
 
-        attr_reader :role, :model_id, :tool_calls, :tool_call_id, :raw, :thinking, :tokens
+        attr_reader :role, :model_id, :tool_calls, :tool_call_id, :raw, :thinking, :tokens, :stop_reason
         attr_writer :content
 
         def initialize(options = {})
@@ -26,6 +26,7 @@ module Legion
           )
           @raw = options[:raw]
           @thinking = options[:thinking]
+          @stop_reason = options[:stop_reason]
 
           ensure_valid_role
         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

@@ -7,13 +7,14 @@ module Legion
       class StreamAccumulator
         include Legion::Logging::Helper
 
-        attr_reader :content, :model_id, :tool_calls
+        attr_reader :content, :model_id, :tool_calls, :stop_reason
 
         def initialize
           @content = +''
           @thinking_text = +''
           @thinking_signature = nil
           @tool_calls = {}
+          @stop_reason = nil
           @input_tokens = nil
           @output_tokens = nil
           @cached_tokens = nil
@@ -36,6 +37,7 @@ module Legion
           handle_chunk_content(chunk)
           append_thinking_from_chunk(chunk)
           count_tokens chunk
+          @stop_reason = chunk.stop_reason if chunk.respond_to?(:stop_reason) && chunk.stop_reason
           log.debug { inspect } if Legion::Extensions::Llm.config.log_stream_debug
         end
 
@@ -81,6 +83,21 @@ module Legion
         def to_message(response)
           flush_pending_untagged_preamble
 
+          if content.length < 50
+            log.debug '[llm][stream_accumulator] action=short_content_debug ' \
+                      "content=#{content.inspect} thinking_chars=#{@thinking_text.length} " \
+                      "tool_calls=#{tool_calls.size} " \
+                      "inside_think_tag=#{@inside_think_tag} " \
+                      "pending_think_tag=#{@pending_think_tag.inspect} " \
+                      "untagged_preamble_pending=#{@untagged_preamble_pending} " \
+                      "thinking_start=#{@thinking_text[0, 200].inspect} " \
+                      "thinking_end=#{@thinking_text[-200..].inspect}"
+            if content.length < 5 && @thinking_text.length > 100 && tool_calls.empty?
+              log.debug '[llm][stream_accumulator] action=POSSIBLE_CONTENT_EATEN ' \
+                        "full_thinking=#{@thinking_text.inspect}"
+            end
+          end
+
           Message.new(
             role: :assistant,
             content: content.empty? ? nil : content,
@@ -97,6 +114,7 @@ module Legion
             ),
             model_id: model_id,
             tool_calls: tool_calls_from_stream,
+            stop_reason: @stop_reason,
             raw: response
           )
         end
@@ -197,10 +215,21 @@ module Legion
 
         def append_text_with_thinking(text)
           content_chunk, thinking_chunk = extract_think_tags(text)
+          if @content.empty? && !content_chunk.empty?
+            log.debug '[llm][stream_accumulator] action=first_content_after_extract ' \
+                      "content_chunk_start=#{content_chunk[0, 50].inspect} " \
+                      "thinking_chunk_present=#{!thinking_chunk.nil?} " \
+                      "thinking_text_so_far=#{@thinking_text.length} " \
+                      "raw_text_start=#{text[0, 50].inspect}"
+          end
           content_chunk, untagged_thinking = extract_untagged_preamble(content_chunk)
           @content << content_chunk
           @last_content_delta << content_chunk
           if untagged_thinking
+            log.debug '[llm][stream_accumulator] action=untagged_thinking_from_chunk ' \
+                      "content_kept=#{content_chunk[0, 50].inspect} " \
+                      "untagged_thinking=#{untagged_thinking[0, 100].inspect} " \
+                      "inside_think_tag=#{@inside_think_tag}"
             @thinking_text << untagged_thinking
             @last_thinking_delta << untagged_thinking
           end
@@ -245,6 +274,9 @@ module Legion
 
           content, thinking = Responses::ThinkingExtractor.extract_untagged_preamble(@untagged_preamble_buffer)
           if thinking
+            log.debug '[llm][stream_accumulator] action=untagged_preamble_classified_as_thinking ' \
+                      "buffer=#{@untagged_preamble_buffer[0, 100].inspect} " \
+                      "content_kept=#{content[0, 50].inspect} thinking_extracted=#{thinking[0, 100].inspect}"
             @content << content
             @thinking_text << thinking
           else
@@ -290,6 +322,13 @@ module Legion
           output = +''
           thinking = +''
 
+          if @inside_think_tag && text.length > 10
+            log.debug '[llm][stream_accumulator] action=chunk_arrives_inside_think ' \
+                      "text_length=#{text.length} text=#{text[0, 200].inspect} " \
+                      "active_close_tag=#{@active_think_close_tag.inspect} " \
+                      "content_so_far=#{@content.length} thinking_so_far=#{@thinking_text.length}"
+          end
+
           until remaining.empty?
             remaining = if @inside_think_tag
                           consume_think_content(remaining, @active_think_close_tag, thinking)
@@ -309,6 +348,13 @@ module Legion
             @active_think_close_tag = nil
             remaining.slice((end_index + end_tag.length)..) || +''
           else
+            consumed = remaining.slice(0, remaining.length - longest_suffix_prefix(remaining, [end_tag]))
+            if @content.length.positive? && consumed.length > 20
+              log.debug '[llm][stream_accumulator] action=think_consuming_without_close ' \
+                        "end_tag=#{end_tag.inspect} consumed_chars=#{consumed.length} " \
+                        "consumed_start=#{consumed[0, 80].inspect} " \
+                        "total_thinking=#{thinking.length + consumed.length}"
+            end
             suffix_len = longest_suffix_prefix(remaining, [end_tag])
             thinking << remaining.slice(0, remaining.length - suffix_len)
             @pending_think_tag = remaining.slice(-suffix_len, suffix_len)
@@ -322,6 +368,12 @@ module Legion
           if unmatched_close && (start_match.nil? || unmatched_close[:index] < start_match[:index])
             consume_unmatched_think_close(remaining, unmatched_close)
           elsif start_match
+            if @content.length > 10 || output.length > 10
+              log.debug '[llm][stream_accumulator] action=think_tag_opened_mid_content ' \
+                        "tag=#{start_match[:tag].inspect} " \
+                        "content_before_tag=#{remaining.slice(0, start_match[:index])[0, 50].inspect} " \
+                        "content_accumulated=#{@content.length} output_accumulated=#{output.length}"
+            end
             output << remaining.slice(0, start_match[:index])
             @inside_think_tag = true
             @active_think_close_tag = start_match[:close_tag]
@@ -336,6 +388,14 @@ module Legion
 
         def consume_unmatched_think_close(remaining, close_match)
           thinking = remaining.slice(0, close_match[:index])
+          if thinking.length > 5
+            log.debug '[llm][stream_accumulator] action=unmatched_close_eating_content ' \
+                      "close_tag=#{close_match[:tag].inspect} " \
+                      "eaten_chars=#{thinking.length} " \
+                      "eaten_start=#{thinking[0, 80].inspect} " \
+                      "inside_think_tag=#{@inside_think_tag} " \
+                      "content_so_far=#{@content.length}"
+          end
           @thinking_text << thinking
           @last_thinking_delta << thinking
           remaining.slice((close_match[:index] + close_match[:tag].length)..).to_s.sub(/\A[[:space:]]+/, '')

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

@@ -48,8 +48,14 @@ module Legion
           build_on_data_handler do |data|
             next unless data.is_a?(Hash)
 
-            chunk = build_chunk(data)
-            block.call(chunk) if chunk
+            result = build_chunk(data)
+            next unless result
+
+            if result.is_a?(Array)
+              result.each { |chunk| block.call(chunk) if chunk }
+            else
+              block.call(result)
+            end
           end
         end
 

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.6.12'
+      VERSION = '0.6.14'
     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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm
 version: !ruby/object:Gem::Version
-  version: 0.6.12
+  version: 0.6.14
 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