lex-llm 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d7d400d2739542ca417b189fba9d20f468d32ca6b4c1d4864fcd884a21d31577
-  data.tar.gz: 1c0ffee1ed602d77d2a295d2f4e7904abcef1ac284754553c3c5f883a78fa023
+  metadata.gz: d41cf2984b04621d4e0c2a7fa84a7236361a561570b9944358631a76e6699ac9
+  data.tar.gz: c84f98866b4f313d240f964d691b6c170d8635f6275ca8c0150b54d6e2d286cf
 SHA512:
-  metadata.gz: 07ea1df46e8469e493b89855d983ef1416d38e6907404eae1502340f37f271a43c2de442825b48dbca538907042e520d85f95316803f8a87b08633edf849685a
-  data.tar.gz: 8ee001e548224a71f050c3224d140d33e652603a9308d6301e539a8f984d8aed922e7c8f8ff3313df4a42b5a693acd2dc896914a71c23e47c42eae90f4a62c9d
+  metadata.gz: a4516de1ebcab041beeabaf718ea11ed3445a943a3c4bbe388936622690001dec8606a8c26d5850f123950ac1d4a09361c4513a8387615e86cc5ef99af133860
+  data.tar.gz: 3d10adbbb6684df81ac7090a4a7c0ebd179803069e74b80e13a626b1cd93d67e9ab955bb5259a2ab638373aaf786217b738536478893fe8983366a2f29ee6e99

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 0.1.8 - 2026-04-30
+
+- Audit all rescue blocks for handle_exception compliance
+- Add Legion::Logging::Helper to Provider, Chat, and Models for structured exception reporting
+- Replace ad-hoc logger.debug/warn calls in rescue blocks with handle_exception across streaming, chat, models, and provider modules
+- Add require for legion/logging in the main entrypoint
+
+## 0.1.7 - 2026-04-30
+
+- Add thinking extraction from OpenAI-compatible streaming chunks (reasoning_content, reasoning, think tags)
+- Add stream_usage_supported? opt-in for streaming token usage reporting
+- Add filtered_chunk method to StreamAccumulator for clean thinking/content separation
+- Wrap streaming callback through accumulator filter for proper SSE event routing
+
 ## 0.1.6 - 2026-04-28
 
 - Add provider-neutral registry event envelopes for future `llm.registry` offering availability, unavailability, degraded, and heartbeat publishing without persistence.

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

@@ -6,6 +6,7 @@ module Legion
       # Represents a conversation with an AI model
       class Chat
         include Enumerable
+        include Legion::Logging::Helper
 
         attr_reader :model, :messages, :tools, :tool_prefs, :params, :headers, :schema
 
@@ -157,8 +158,8 @@ module Legion
           if @schema && response.content.is_a?(String) && !response.tool_call?
             begin
               response.content = Legion::JSON.parse(response.content, symbolize_names: false)
-            rescue Legion::JSON::ParseError
-              # If parsing fails, keep content as string
+            rescue Legion::JSON::ParseError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'llm.chat.complete')
             end
           end
 

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

@@ -35,6 +35,8 @@ module Legion
         ].freeze
 
         class << self
+          include Legion::Logging::Helper
+
           def instance
             @instance ||= new
           end
@@ -51,7 +53,8 @@ module Legion
             data = File.exist?(file) ? File.read(file) : '[]'
             models = Legion::JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
             filter_models(models)
-          rescue Legion::JSON::ParseError
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'llm.models.read_from_json')
             []
           end
 
@@ -92,6 +95,8 @@ module Legion
                 result[:models].concat(provider_class.new(config).list_models)
                 result[:fetched_providers] << provider_class.slug
               rescue StandardError => e
+                handle_exception(e, level: :warn, handled: true,
+                                    operation: 'llm.models.fetch_provider_models')
                 result[:failed] << { name: provider_class.name, slug: provider_class.slug, error: e }
               end
             end
@@ -170,9 +175,7 @@ module Legion
             end
             { models: models.reject { |model| model.provider.nil? || model.id.nil? }, fetched: true }
           rescue StandardError => e
-            Legion::Extensions::Llm.logger.warn(
-              "Failed to fetch models.dev (#{e.class}: #{e.message}). Keeping existing."
-            )
+            handle_exception(e, level: :warn, handled: true, operation: 'llm.models.fetch_models_dev')
             {
               models: existing_models.select { |model| model.metadata[:source] == 'models.dev' },
               fetched: false

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

@@ -6,6 +6,7 @@ module Legion
       class Provider
         # Shared OpenAI-compatible HTTP payload and response adapter.
         module OpenAICompatible
+          def stream_usage_supported? = false
           def completion_url = '/v1/chat/completions'
           def stream_url = completion_url
           def models_url = '/v1/models'
@@ -20,7 +21,7 @@ module Legion
           private
 
           def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists
-            {
+            payload = {
               model: model.id,
               messages: format_openai_messages(messages),
               temperature: temperature,
@@ -30,6 +31,8 @@ module Legion
               response_format: openai_response_format(schema),
               reasoning_effort: openai_reasoning_effort(thinking)
             }.compact
+            payload[:stream_options] = { include_usage: true } if stream && stream_usage_supported?
+            payload
           end
 
           def format_openai_messages(messages)
@@ -116,12 +119,14 @@ module Legion
             choice = Array(body['choices']).first || {}
             message = choice['message'] || {}
             usage = body['usage'] || {}
+            content, thinking = extract_thinking_from_completion(message)
 
             Legion::Extensions::Llm::Message.new(
               role: :assistant,
-              content: message['content'],
+              content: content,
               model_id: body['model'],
               tool_calls: parse_tool_calls(message['tool_calls']),
+              thinking: thinking,
               input_tokens: usage['prompt_tokens'],
               output_tokens: usage['completion_tokens'],
               reasoning_tokens: usage.dig('completion_tokens_details', 'reasoning_tokens'),
@@ -129,22 +134,68 @@ module Legion
             )
           end
 
+          def extract_thinking_from_completion(message)
+            reasoning = message['reasoning_content'] || message['reasoning']
+            content = message['content']
+
+            if reasoning
+              [content, Thinking.build(text: reasoning)]
+            elsif content.is_a?(String) && content.include?('<think>')
+              think_text = content[%r{<think>(.*?)</think>}m, 1]
+              clean = content.gsub(%r{<think>.*?</think>}m, '').strip
+              [clean, Thinking.build(text: think_text)]
+            else
+              [content, nil]
+            end
+          end
+
           def build_chunk(data)
             choice = Array(data['choices']).first || {}
             delta = choice['delta'] || {}
             usage = data['usage'] || {}
+            content, thinking = extract_thinking_from_chunk(delta)
 
             Legion::Extensions::Llm::Chunk.new(
               role: :assistant,
-              content: delta['content'],
+              content: content,
               model_id: data['model'],
               tool_calls: parse_tool_calls(delta['tool_calls']),
+              thinking: thinking,
               input_tokens: usage['prompt_tokens'],
               output_tokens: usage['completion_tokens'],
               raw: data
             )
           end
 
+          def extract_thinking_from_chunk(delta)
+            reasoning = delta['reasoning_content'] || delta['reasoning']
+            content = delta['content']
+
+            if reasoning
+              [content, Thinking.build(text: reasoning)]
+            elsif content.is_a?(String) && content.include?('<think>')
+              clean, think_text = split_think_tags(content)
+              [clean, Thinking.build(text: think_text)]
+            else
+              [content, nil]
+            end
+          end
+
+          def split_think_tags(text) # rubocop:disable Metrics/PerceivedComplexity
+            if text.match?(%r{<think>.*</think>}m)
+              thinking = text[%r{<think>(.*?)</think>}m, 1]
+              clean = text.gsub(%r{<think>.*?</think>}m, '').strip
+              [clean.empty? ? nil : clean, thinking]
+            elsif text.start_with?('<think>')
+              [nil, text.delete_prefix('<think>')]
+            elsif text.include?('</think>')
+              parts = text.split('</think>', 2)
+              [parts[1]&.strip.then { |s| s&.empty? ? nil : s }, parts[0]]
+            else
+              [text, nil]
+            end
+          end
+
           def parse_tool_calls(tool_calls)
             return nil unless tool_calls&.any?
 
@@ -167,7 +218,8 @@ module Legion
             return arguments if arguments.is_a?(Hash)
 
             Legion::JSON.parse(arguments, symbolize_names: false)
-          rescue Legion::JSON::ParseError
+          rescue Legion::JSON::ParseError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'llm.provider.parse_tool_arguments')
             {}
           end
 

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

@@ -6,6 +6,7 @@ module Legion
       # Base class for LLM providers.
       class Provider
         include Streaming
+        include Legion::Logging::Helper
 
         attr_reader :config, :connection
 
@@ -131,6 +132,7 @@ module Legion
           response = @connection.get(metadata[:endpoints][:health])
           metadata.merge(ready: configured? && health_ready?(response.body), health: response.body)
         rescue StandardError => e
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.provider.readiness')
           metadata.merge(ready: false, health: { error: e.class.name, message: e.message })
         end
 

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

@@ -26,12 +26,32 @@ module Legion
           Legion::Extensions::Llm.logger.debug { chunk.inspect } if Legion::Extensions::Llm.config.log_stream_debug
           @model_id ||= chunk.model_id
 
+          @last_content_delta = +''
+          @last_thinking_delta = +''
           handle_chunk_content(chunk)
           append_thinking_from_chunk(chunk)
           count_tokens chunk
           Legion::Extensions::Llm.logger.debug { inspect } if Legion::Extensions::Llm.config.log_stream_debug
         end
 
+        def filtered_chunk(chunk) # rubocop:disable Metrics/PerceivedComplexity
+          has_content = !@last_content_delta.empty?
+          has_thinking = !@last_thinking_delta.empty?
+          has_tokens = chunk.input_tokens&.positive? || chunk.output_tokens&.positive?
+          return nil unless has_content || has_thinking || chunk.tool_call? || has_tokens
+
+          Chunk.new(
+            role: :assistant,
+            content: has_content ? @last_content_delta : nil,
+            thinking: has_thinking ? Thinking.build(text: @last_thinking_delta) : chunk.thinking,
+            model_id: chunk.model_id,
+            tool_calls: chunk.tool_calls,
+            input_tokens: chunk.input_tokens,
+            output_tokens: chunk.output_tokens,
+            raw: chunk.raw
+          )
+        end
+
         def to_message(response)
           Message.new(
             role: :assistant,
@@ -137,14 +157,21 @@ module Legion
         def append_text_with_thinking(text)
           content_chunk, thinking_chunk = extract_think_tags(text)
           @content << content_chunk
-          @thinking_text << thinking_chunk if thinking_chunk
+          @last_content_delta << content_chunk
+          return unless thinking_chunk
+
+          @thinking_text << thinking_chunk
+          @last_thinking_delta << thinking_chunk
         end
 
         def append_thinking_from_chunk(chunk)
           thinking = chunk.thinking
           return unless thinking
 
-          @thinking_text << thinking.text.to_s if thinking.text
+          if thinking.text
+            @thinking_text << thinking.text.to_s
+            @last_thinking_delta << thinking.text.to_s
+          end
           @thinking_signature ||= thinking.signature # rubocop:disable Naming/MemoizedInstanceVariableName
         end
 

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

@@ -12,16 +12,11 @@ module Legion
 
           response = connection.post stream_url, payload do |req|
             req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
+            on_chunk = build_stream_callback(accumulator, block)
             if faraday_1?
-              req.options[:on_data] = handle_stream do |chunk|
-                accumulator.add chunk
-                block.call chunk
-              end
+              req.options[:on_data] = handle_stream(&on_chunk)
             else
-              req.options.on_data = handle_stream do |chunk|
-                accumulator.add chunk
-                block.call chunk
-              end
+              req.options.on_data = handle_stream(&on_chunk)
             end
           end
 
@@ -30,6 +25,14 @@ module Legion
           message
         end
 
+        def build_stream_callback(accumulator, block)
+          proc do |chunk|
+            accumulator.add chunk
+            filtered = accumulator.filtered_chunk(chunk)
+            block.call(filtered) if filtered
+          end
+        end
+
         def handle_stream(&block)
           build_on_data_handler do |data|
             block.call(build_chunk(data)) if data.is_a?(Hash)
@@ -88,8 +91,8 @@ module Legion
           buffer << chunk
           error_data = Legion::JSON.parse(buffer, symbolize_names: false)
           handle_parsed_error(error_data, env)
-        rescue Legion::JSON::ParseError
-          Legion::Extensions::Llm.logger.debug { "Accumulating error chunk: #{chunk}" }
+        rescue Legion::JSON::ParseError => e
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.streaming.handle_failed_response')
         end
 
         def handle_sse(chunk, parser, env, &)
@@ -109,7 +112,7 @@ module Legion
 
           handle_parsed_error(parsed, env)
         rescue Legion::JSON::ParseError => e
-          Legion::Extensions::Llm.logger.debug { "Failed to parse data chunk: #{e.message}" }
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.streaming.handle_data')
         end
 
         def handle_error_event(data, env)
@@ -120,7 +123,7 @@ module Legion
           error_data = Legion::JSON.parse(data, symbolize_names: false)
           [500, error_data['message'] || 'Unknown streaming error']
         rescue Legion::JSON::ParseError => e
-          Legion::Extensions::Llm.logger.debug { "Failed to parse streaming error: #{e.message}" }
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.streaming.parse_streaming_error')
           [500, "Failed to parse error: #{data}"]
         end
 
@@ -130,11 +133,11 @@ module Legion
           ErrorMiddleware.parse_error(provider: self, response: error_response)
         end
 
-        def parse_error_from_json(data, env, error_message)
+        def parse_error_from_json(data, env, _error_message)
           parsed_data = Legion::JSON.parse(data, symbolize_names: false)
           handle_parsed_error(parsed_data, env)
         rescue Legion::JSON::ParseError => e
-          Legion::Extensions::Llm.logger.debug { "#{error_message}: #{e.message}" }
+          handle_exception(e, level: :warn, handled: true, operation: 'llm.streaming.parse_error_from_json')
         end
 
         def build_stream_error_response(parsed_data, env, status)

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

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module Llm
-      VERSION = '0.1.6'
+      VERSION = '0.1.8'
     end
   end
 end

data/lib/legion/extensions/llm.rb

@@ -8,6 +8,7 @@ require 'faraday'
 require 'faraday/multipart'
 require 'faraday/retry'
 require 'legion/json'
+require 'legion/logging'
 require 'logger'
 require 'marcel'
 require 'ruby_llm/schema'

metadata

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