lex-llm 0.6.12 → 0.6.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fcdfa125fb151f6cac7d0468881476c99b8145738282c20e52d630a7b739702
-  data.tar.gz: 57c2ded197c24f6d05c0227d3bbdd9d8ea843e04df69c5fa4fa1b33b934ad0d7
+  metadata.gz: '0307598766a4f750febc8f0e72b2ebfa344291eb7feb3f134b2f7f1fffcb7620'
+  data.tar.gz: 713d7789cc022b01300ab4cc75811c43ea297ec817bb2780ce046426328155e9
 SHA512:
-  metadata.gz: cf38e525d5124d5e17a063ff88e7a14d083830f326b90ce9212e8558d8106e934afd456bba8d37a34c3f822f66f7ad772f34300706006d909619063f36a13199
-  data.tar.gz: a98036763e921140f0a1e32e66640826de90b3c211ec7e2fc19aa5bbd2496015996eac6c29798fa2ef073ff9f276ec58bc5b581c4edf019aa8402f75e5c6273a
+  metadata.gz: ef02b0c8ac4f2850a2823982d564ea6ca0a9f6e9c5fb23180231080ff2291f22b242848ad700b889fe7a721d555c2a8d10f55b9f057e11ea0f4c67f3348df6a4
+  data.tar.gz: cb4a22c7c6c8e4f151f09c7cb4f6b6b445a8faa085936344c747d7a90b648620f79673435731f9fe3f311e95b804e16c2af439b577aaa180ad2ae1d20b052721

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 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/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/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.13'
     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.13
 platform: ruby
 authors:
 - LegionIO