legion-llm 0.9.34 → 0.9.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca7cfa8bdb01bbb162989ba4ce84f8735eb46e34f36cfea29d4504357d6eaa38
-  data.tar.gz: 2b8866db7f799f242a070fa590c18f64cbee278c7fc2e827a9fe604cab6ce7d1
+  metadata.gz: 93611da95712602a9f99e00c4b34523c23838a99d34c3c441ea6bef642231e3f
+  data.tar.gz: 6ced6ad0b6091c5a3d53702b867eea5f04d35199892338023aebb6bb452ed867
 SHA512:
-  metadata.gz: 2b3ba4cb577aa0a44b166ef7ee1299db98b5dbfa3759f76fb158ffa5e2c4eca7999198f47d87e70d8ebf79f21e1395137e75f26b033f609b939f70b2faa0b1f6
-  data.tar.gz: c77913f743c3075977419811d8c20fe7d7c1b48b77cc234b1bdcd4e1c1642734c9f203c60f3d8ec0c021f9cffe9fc79fd18a0abc14f452bdd152175d8a7fe820
+  metadata.gz: aa99ed858c6bef1fc214a45d4d59e51f1e9f0262f75dcdbd0f60645d59296edf6fa57e47dfa706dd0b06ec7c7f6dbf572f3832235d0d7125cd9992ec65aa6eee
+  data.tar.gz: dfe7e2db5cf883de39a5ac47438408a858372a52dd82230baa4a624e33e17b0558eb50359237345afa5b8a1df432b164149c3fce540304ac56ffbad888110c33

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Legion LLM Changelog
 
+## [0.9.36] - 2026-05-22
+
+### Fixed
+- Providers: `LexLLMAdapter` now preserves streamed token usage from the upstream `llm-gateway.uhg.com` Responses API payload added in LegionIO/legion-llm#130, including gateway-shaped `usage`, `raw[:data]`, and `raw[:response][:usage]` token fields, so LegionIO `response.completed.usage.input_tokens` no longer collapses to `0`
+
+## [0.9.35] - 2026-05-22
+
+### Fixed
+- API: OpenAI Responses streaming now emits the full gateway-compatible SSE envelope format (`{ type:, response:, sequence_number: }` for lifecycle events, `{ type:, item_id:, ... }` for content events), matching `llm-gateway.uhg.com` wire format exactly so Codex CLI accepts the stream
+- API: `response.completed` now correctly includes `usage.input_tokens` from `pipeline_response.tokens` via `build_usage` helper; token aliases (`:input`/`:input_tokens`, `:output`/`:output_tokens`) resolved across hash and object-backed payloads
+- API: Added missing `response.in_progress` and `response.content_part.*` SSE events to streaming sequence
+
 ## [0.9.34] - 2026-05-22
 
 ### Fixed

data/lib/legion/llm/api/openai/responses.rb

@@ -168,30 +168,53 @@ module Legion
               status:  'completed'
             }
 
-            input_tokens = extract_token(tokens, :input)
-            output_tokens = extract_token(tokens, :output)
-
             {
               id:         request_id,
               object:     'response',
               created_at: Time.now.to_i,
               model:      resolved_model,
               output:     output,
-              usage:      {
-                input_tokens:  input_tokens,
-                output_tokens: output_tokens,
-                total_tokens:  input_tokens.to_i + output_tokens.to_i
-              },
+              usage:      build_usage(tokens),
               status:     'completed'
             }
           end
 
-          def self.stream_response(out, executor, request_id:, model:)
-            out << "event: response.created\ndata: #{Legion::JSON.dump({ id: request_id, object: 'response', status: 'in_progress' })}\n\n"
+          def self.stream_response(out, executor, request_id:, model:) # rubocop:disable Metrics/MethodLength
+            created_at = Time.now.to_i
+            seq = 0
+            in_progress_response = { id: request_id, object: 'response', created_at: created_at,
+                                     status: 'in_progress', model: model, output: [], usage: nil }
+
+            # response.created — envelope matches gateway format: { type:, response:, sequence_number: }
+            out << sse_event('response.created', {
+                               type:            'response.created',
+                               sequence_number: seq += 1,
+                               response:        in_progress_response
+                             })
+
+            out << sse_event('response.in_progress', {
+                               type:            'response.in_progress',
+                               sequence_number: seq += 1,
+                               response:        in_progress_response
+                             })
 
             msg_id = "msg_#{SecureRandom.hex(12)}"
-            item_event = { type: 'message', id: msg_id, role: 'assistant', content: [], status: 'in_progress' }
-            out << "event: response.output_item.added\ndata: #{Legion::JSON.dump({ output_index: 0, item: item_event })}\n\n"
+            out << sse_event('response.output_item.added', {
+                               type:            'response.output_item.added',
+                               sequence_number: seq += 1,
+                               output_index:    0,
+                               item:            { id: msg_id, type: 'message', role: 'assistant',
+                                 content: [], status: 'in_progress' }
+                             })
+
+            out << sse_event('response.content_part.added', {
+                               type:            'response.content_part.added',
+                               sequence_number: seq += 1,
+                               output_index:    0,
+                               content_index:   0,
+                               item_id:         msg_id,
+                               part:            { type: 'output_text', text: '', annotations: [] }
+                             })
 
             full_text = +''
 
@@ -200,40 +223,69 @@ module Legion
               next if text.empty?
 
               full_text << text
-              delta_event = { content_index: 0, delta: text }
-              out << "event: response.output_text.delta\ndata: #{Legion::JSON.dump(delta_event)}\n\n"
+              out << sse_event('response.output_text.delta', {
+                                 type:            'response.output_text.delta',
+                                 sequence_number: seq += 1,
+                                 output_index:    0,
+                                 content_index:   0,
+                                 item_id:         msg_id,
+                                 delta:           text
+                               })
             end
 
             routing = pipeline_response.routing || {}
-            tokens = pipeline_response.tokens || {}
+            tokens  = pipeline_response.tokens || {}
             resolved_model = (routing[:model] || routing['model'] || model).to_s
-            input_tokens = extract_token(tokens, :input)
-            output_tokens = extract_token(tokens, :output)
-
-            out << "event: response.output_text.done\ndata: #{Legion::JSON.dump({ content_index: 0, text: full_text })}\n\n"
-            done_item = {
-              output_index: 0,
-              item:         { type: 'message', id: msg_id, role: 'assistant',
-                              content: [{ type: 'output_text', text: full_text }], status: 'completed' }
-            }
-            out << "event: response.output_item.done\ndata: #{Legion::JSON.dump(done_item)}\n\n"
-
-            done_data = {
-              id:     request_id,
-              object: 'response',
-              model:  resolved_model,
-              status: 'completed',
-              usage:  {
-                input_tokens:  input_tokens,
-                output_tokens: output_tokens,
-                total_tokens:  input_tokens.to_i + output_tokens.to_i
-              }
-            }
-            out << "event: response.completed\ndata: #{Legion::JSON.dump(done_data)}\n\n"
+            usage = build_usage(tokens)
+
+            out << sse_event('response.output_text.done', {
+                               type:            'response.output_text.done',
+                               sequence_number: seq += 1,
+                               output_index:    0,
+                               content_index:   0,
+                               item_id:         msg_id,
+                               text:            full_text
+                             })
+
+            out << sse_event('response.content_part.done', {
+                               type:            'response.content_part.done',
+                               sequence_number: seq += 1,
+                               output_index:    0,
+                               content_index:   0,
+                               item_id:         msg_id,
+                               part:            { type: 'output_text', text: full_text, annotations: [] }
+                             })
+
+            completed_item = { id: msg_id, type: 'message', role: 'assistant', status: 'completed',
+                               content: [{ type: 'output_text', text: full_text, annotations: [] }] }
+            out << sse_event('response.output_item.done', {
+                               type:            'response.output_item.done',
+                               sequence_number: seq += 1,
+                               output_index:    0,
+                               item:            completed_item
+                             })
+
+            out << sse_event('response.completed', {
+                               type:            'response.completed',
+                               sequence_number: seq + 1,
+                               response:        {
+                                 id:         request_id,
+                                 object:     'response',
+                                 created_at: created_at,
+                                 status:     'completed',
+                                 model:      resolved_model,
+                                 output:     [completed_item],
+                                 usage:      usage
+                               }
+                             })
 
             log.info("[llm][api][openai][responses] action=stream_complete request_id=#{request_id} model=#{resolved_model}")
           end
 
+          def self.sse_event(name, payload)
+            "event: #{name}\ndata: #{Legion::JSON.dump(payload)}\n\n"
+          end
+
           def self.build_output_tool_calls(pipeline_response)
             tools_data = pipeline_response.respond_to?(:tools) ? pipeline_response.tools : nil
             return [] unless tools_data.is_a?(Array) && !tools_data.empty?
@@ -258,17 +310,56 @@ module Legion
           def self.extract_token(tokens, key)
             return 0 if tokens.nil?
 
-            method_name = { input: :input_tokens, output: :output_tokens }[key]
+            aliases = token_aliases(key)
 
             if tokens.is_a?(Hash)
-              return (tokens[method_name] || tokens[method_name.to_s] ||
-                      tokens[key] || tokens[key.to_s] || 0).to_i
+              aliases.each do |candidate|
+                value = tokens[candidate]
+                value = tokens[candidate.to_s] if value.nil?
+                return value.to_i unless value.nil?
+              end
+
+              return 0
             end
 
-            return tokens.public_send(method_name).to_i if method_name && tokens.respond_to?(method_name)
+            aliases.each do |candidate|
+              method_name = token_method(candidate)
+              return tokens.public_send(method_name).to_i if method_name && tokens.respond_to?(method_name)
+            end
 
             0
           end
+
+          def self.build_usage(tokens)
+            input_tokens = extract_token(tokens, :input_tokens)
+            output_tokens = extract_token(tokens, :output_tokens)
+
+            {
+              input_tokens:  input_tokens,
+              output_tokens: output_tokens,
+              total_tokens:  input_tokens + output_tokens
+            }
+          end
+
+          def self.token_aliases(key)
+            case key.to_sym
+            when :input, :input_tokens
+              %i[input_tokens input]
+            when :output, :output_tokens
+              %i[output_tokens output]
+            else
+              [key.to_sym]
+            end
+          end
+
+          def self.token_method(key)
+            {
+              input:         :input_tokens,
+              input_tokens:  :input_tokens,
+              output:        :output_tokens,
+              output_tokens: :output_tokens
+            }[key.to_sym]
+          end
         end
       end
     end

data/lib/legion/llm/call/lex_llm_adapter.rb

@@ -336,10 +336,11 @@ module Legion
         end
 
         def accumulate_stream_usage(accumulator, chunk)
-          return unless chunk.respond_to?(:input_tokens)
+          usage = usage_hash(chunk)
+          return unless token_usage_signal?(chunk, usage)
 
           accumulator[:model] = chunk.model_id if chunk.respond_to?(:model_id)
-          accumulator[:usage] = usage_hash(chunk)
+          accumulator[:usage] = merge_usage_hash(accumulator[:usage], usage)
           accumulator[:raw] = chunk.raw if chunk.respond_to?(:raw)
         end
 
@@ -392,13 +393,89 @@ module Legion
 
         def usage_hash(response)
           {
-            input_tokens:       response.input_tokens.to_i,
-            output_tokens:      response.output_tokens.to_i,
-            cache_read_tokens:  response.cached_tokens.to_i,
-            cache_write_tokens: response.cache_creation_tokens.to_i
+            input_tokens:       extract_token_metric(response, :input_tokens, :prompt_tokens),
+            output_tokens:      extract_token_metric(response, :output_tokens, :completion_tokens),
+            cache_read_tokens:  extract_token_metric(response, :cache_read_tokens, :cached_tokens),
+            cache_write_tokens: extract_token_metric(response, :cache_write_tokens, :cache_creation_tokens)
           }
         end
 
+        def token_usage_signal?(response, usage)
+          usage.values.any?(&:positive?) ||
+            response.respond_to?(:usage) ||
+            response.respond_to?(:raw) ||
+            response.respond_to?(:input_tokens) ||
+            response.respond_to?(:output_tokens)
+        end
+
+        def merge_usage_hash(existing, incoming)
+          current = existing.is_a?(Hash) ? existing : {}
+          latest = incoming.is_a?(Hash) ? incoming : {}
+
+          {
+            input_tokens:       [current[:input_tokens].to_i, latest[:input_tokens].to_i].max,
+            output_tokens:      [current[:output_tokens].to_i, latest[:output_tokens].to_i].max,
+            cache_read_tokens:  [current[:cache_read_tokens].to_i, latest[:cache_read_tokens].to_i].max,
+            cache_write_tokens: [current[:cache_write_tokens].to_i, latest[:cache_write_tokens].to_i].max
+          }
+        end
+
+        def extract_token_metric(response, canonical_key, legacy_key = nil)
+          values = token_metric_candidates(response, canonical_key, legacy_key)
+          positive = values.find(&:positive?)
+          positive || values.first || 0
+        end
+
+        def token_metric_candidates(response, canonical_key, legacy_key = nil)
+          keys = [canonical_key, legacy_key].compact
+          token_metric_sources(response).flat_map do |source|
+            keys.filter_map { |key| extract_metric_value(source, key) }
+          end
+        end
+
+        def token_metric_sources(response)
+          sources = [response]
+          sources << response.usage if response.respond_to?(:usage)
+          sources << response.raw if response.respond_to?(:raw)
+
+          sources.compact.flat_map { |source| expand_token_metric_source(source) }.compact.uniq
+        end
+
+        def expand_token_metric_source(source, depth = 0)
+          return [] if source.nil?
+          return [source] unless source.respond_to?(:key?) && depth < 3
+
+          nested = [source]
+          nested << hash_value(source, :usage)
+          nested << hash_value(source, :data)
+          nested << hash_value(source, :response)
+          nested.compact.flat_map { |entry| [entry, *expand_token_metric_source(entry, depth + 1)] }
+        end
+
+        def extract_metric_value(source, key)
+          if source.respond_to?(key)
+            value = source.public_send(key)
+            return value.to_i unless value.nil?
+          end
+
+          return nil unless source.respond_to?(:key?)
+
+          value = hash_value(source, key)
+          value&.to_i
+        rescue StandardError => e
+          log.debug "[llm][adapter] action=extract_metric_value key=#{key} class=#{source.class} error=#{e.class}: #{e.message}"
+          nil
+        end
+
+        def hash_value(hash, key)
+          return hash[key] if hash.key?(key)
+
+          string_key = key.to_s
+          return hash[string_key] if hash.key?(string_key)
+
+          nil
+        end
+
         def stream_thinking_hash(accumulator)
           thinking_text = accumulator[:thinking_text]
           return nil if thinking_text.empty?

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.34'
+    VERSION = '0.9.36'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.9.34
+  version: 0.9.36
 platform: ruby
 authors:
 - Esity