legion-llm 0.9.34 → 0.9.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca7cfa8bdb01bbb162989ba4ce84f8735eb46e34f36cfea29d4504357d6eaa38
-  data.tar.gz: 2b8866db7f799f242a070fa590c18f64cbee278c7fc2e827a9fe604cab6ce7d1
+  metadata.gz: 0f260c2a456cc265c9ae615a84021ad73c8a82dd8bc7969e0c0d6afdab6c18e6
+  data.tar.gz: 38c4fac7b3fdb5ca97857317f17beda3fc202542aac0aed954d2959bb12c4beb
 SHA512:
-  metadata.gz: 2b3ba4cb577aa0a44b166ef7ee1299db98b5dbfa3759f76fb158ffa5e2c4eca7999198f47d87e70d8ebf79f21e1395137e75f26b033f609b939f70b2faa0b1f6
-  data.tar.gz: c77913f743c3075977419811d8c20fe7d7c1b48b77cc234b1bdcd4e1c1642734c9f203c60f3d8ec0c021f9cffe9fc79fd18a0abc14f452bdd152175d8a7fe820
+  metadata.gz: 37ccea0f649857ee3492c4df9fb9c6c58667d5899bcba2fac5eb2daef119c2bf361c1ae58fe37815a952625ecb8d8722d760ca5860ec99644f04d423da47c6f0
+  data.tar.gz: 48c4845b82db666058aea36a4d98e20108c6754ba52cd15598c9e18f7b5a7921a9c37f34b81d8b3ece8f9e733f42dc0bf965c4c8120ecf40212e4b75692baa1a

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Legion LLM Changelog
 
+## [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/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.34'
+    VERSION = '0.9.35'
   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.35
 platform: ruby
 authors:
 - Esity