legionio 1.7.29 → 1.7.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5af5e876210c79ae9fcc876fad3b8086a605f3a841c450793b4759711c5b0101
-  data.tar.gz: 43d1c51c4a52121654e1a1e426f5bbe9e6e1771a5a95a095eb12e87474632eec
+  metadata.gz: 537bbc9c431e5e8b9fdaf96145ea124a0c4b8e84b4094673cbc4f6b07d4edb21
+  data.tar.gz: da76364c12123a27f644f4fdef175c14796b2542800a93b054b26cb5f27a5e79
 SHA512:
-  metadata.gz: af956fad95ae9de341f700fa1e03997bed9b889983dc69b96322ba72cb7871f584224b4d00112e17b2e580a9f37e1afff3fa96e9b5bb5e83a38cf487fad26b77
-  data.tar.gz: 6545603e7df04444096ae7763fcfde3ee4b970603554388ab04be50a088bd36ac1f77c0fc5ce02f04eeaf5396bb5620d38fc6416f5125b900225a3f79ecc773a
+  metadata.gz: bee0c19f368dffa21a46fc964a43ae7448356912cbc5f0ac6884c9bcd4e00660821bc66c37e2b8d2cc2e05c77ec0fbce17d2f5a6c70b5b2bfb0d5eb4c3c278a6
+  data.tar.gz: 60f48041416adb178c7aae384647c7fb15860aa2a25dde1418500ef947ac323ebf36340ab242e9abcdd2893e717e3bdef94bd62aea43955e927c26acf377aecf

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Legion Changelog
 
+## [1.7.30] - 2026-04-08
+
+### Added
+- SSE streaming inference now emits real-time `tool-call`, `tool-result`, `tool-error`, and `model-fallback` events via `executor.tool_event_handler` as tools execute (with wall-clock `startedAt`/`finishedAt`/`durationMs` timing)
+- `event: done` payload extended with `conversation_id`, `stop_reason`, `cache_read_tokens`, and `cache_write_tokens` fields (nil values compacted out)
+- Post-hoc `model-fallback` events emitted from `pipeline_response.warnings` for non-streaming tool paths
+- `admin purge-topology` CLI command to remove stale v2.0 `legion.*` AMQP exchanges that have `lex.*` counterparts
+- Parallel tool execution in `CLI::Chat::DaemonChat`: all tools in a response now run concurrently via `Thread.new`, preserving original order for message replay
+- `build_tool_result_object` now carries `tool_call_id`/`id` so the Interlink frontend can match results to tool calls by ID rather than name (fixes parallel same-type tool matching)
+
+### Changed
+- SSE tool-call events now use camelCase keys (`toolCallId`, `toolName`, `args`) matching the Interlink wire protocol
+
 ## [1.7.29] - 2026-04-07
 
 ### Changed

data/lib/legion/api/llm.rb

@@ -306,6 +306,51 @@ module Legion
                       'X-Accel-Buffering' => 'no'
 
               stream do |out|
+                # Wire up real-time tool-call / tool-result / tool-error / model-fallback SSE events.
+                # The executor fires tool_event_handler for each event as it happens,
+                # including accurate wall-clock startedAt/finishedAt/durationMs timing.
+                emitted_tool_call_ids = Set.new
+                executor.tool_event_handler = lambda do |event|
+                  case event[:type]
+                  when :tool_call
+                    emitted_tool_call_ids << event[:tool_call_id] if event[:tool_call_id]
+                    out << "event: tool-call\ndata: #{Legion::JSON.dump({
+                                                                          toolCallId: event[:tool_call_id],
+                                                                          toolName:   event[:tool_name],
+                                                                          args:       event[:arguments] || {},
+                                                                          startedAt:  event[:started_at]&.iso8601(3),
+                                                                          timestamp:  event[:started_at]&.iso8601(3) || Time.now.iso8601(3)
+                                                                        })}\n\n"
+                  when :tool_result
+                    out << "event: tool-result\ndata: #{Legion::JSON.dump({
+                                                                            toolCallId: event[:tool_call_id],
+                                                                            toolName:   event[:tool_name],
+                                                                            result:     event[:result],
+                                                                            startedAt:  event[:started_at]&.iso8601(3),
+                                                                            finishedAt: event[:finished_at]&.iso8601(3) || Time.now.iso8601(3),
+                                                                            durationMs: event[:duration_ms],
+                                                                            timestamp:  event[:finished_at]&.iso8601(3) || Time.now.iso8601(3)
+                                                                          })}\n\n"
+                  when :tool_error
+                    out << "event: tool-error\ndata: #{Legion::JSON.dump({
+                                                                           toolCallId: event[:tool_call_id],
+                                                                           toolName:   event[:tool_name],
+                                                                           error:      (event[:error] || event[:result]).to_s,
+                                                                           startedAt:  event[:started_at]&.iso8601(3),
+                                                                           finishedAt: Time.now.iso8601(3),
+                                                                           timestamp:  Time.now.iso8601(3)
+                                                                         })}\n\n"
+                  when :model_fallback
+                    out << "event: model-fallback\ndata: #{Legion::JSON.dump({
+                                                                               fromModel:  event[:from_model],
+                                                                               toModel:    event[:to_model],
+                                                                               toModelKey: event[:to_model],
+                                                                               error:      event[:error] || 'Provider unavailable',
+                                                                               reason:     event[:reason] || 'provider_fallback'
+                                                                             })}\n\n"
+                  end
+                end
+
                 full_text = +''
                 pipeline_response = executor.call_stream do |chunk|
                   text = chunk.respond_to?(:content) ? chunk.content.to_s : chunk.to_s
@@ -315,26 +360,53 @@ module Legion
                   out << "event: text-delta\ndata: #{Legion::JSON.dump({ delta: text })}\n\n"
                 end
 
+                # Post-hoc safety net: emit any tool-calls that weren't fired in real-time
+                # (e.g. non-streaming tool paths). Skip IDs already sent via tool_event_handler.
                 if pipeline_response.tools.is_a?(Array) && !pipeline_response.tools.empty?
                   pipeline_response.tools.each do |tc|
+                    tc_id = tc.respond_to?(:id) ? tc.id : nil
+                    next if tc_id && emitted_tool_call_ids.include?(tc_id)
+
                     out << "event: tool-call\ndata: #{Legion::JSON.dump({
-                                                                          id:        tc.respond_to?(:id) ? tc.id : nil,
-                                                                          name:      tc.respond_to?(:name) ? tc.name : tc.to_s,
-                                                                          arguments: tc.respond_to?(:arguments) ? tc.arguments : {}
+                                                                          toolCallId: tc_id,
+                                                                          toolName:   tc.respond_to?(:name) ? tc.name : tc.to_s,
+                                                                          args:       tc.respond_to?(:arguments) ? tc.arguments : {}
                                                                         })}\n\n"
                   end
                 end
 
+                # Emit any model-fallback warnings collected post-hoc
+                Array(pipeline_response.warnings).each do |w|
+                  next unless w.is_a?(Hash) && w[:type] == :provider_fallback
+
+                  fallback = w[:fallback].to_s
+                  provider, model = fallback.split(':', 2)
+                  resolved_model = (model || provider).to_s.strip
+                  next if resolved_model.empty?
+
+                  out << "event: model-fallback\ndata: #{Legion::JSON.dump({
+                                                                             fromModel:  pipeline_response.routing&.dig(:model),
+                                                                             toModel:    resolved_model,
+                                                                             toModelKey: resolved_model,
+                                                                             error:      w[:original_error] || 'Provider unavailable',
+                                                                             reason:     'provider_fallback'
+                                                                           })}\n\n"
+                end
+
                 enrichments = pipeline_response.enrichments
                 out << "event: enrichment\ndata: #{Legion::JSON.dump(enrichments)}\n\n" if enrichments.is_a?(Hash) && !enrichments.empty?
 
                 tokens = pipeline_response.tokens
                 out << "event: done\ndata: #{Legion::JSON.dump({
-                                                                 content:       full_text,
-                                                                 model:         pipeline_response.routing&.dig(:model),
-                                                                 input_tokens:  tokens.respond_to?(:input_tokens) ? tokens.input_tokens : nil,
-                                                                 output_tokens: tokens.respond_to?(:output_tokens) ? tokens.output_tokens : nil
-                                                               })}\n\n"
+                  content:            full_text,
+                  model:              pipeline_response.routing&.dig(:model),
+                  conversation_id:    pipeline_response.conversation_id,
+                  stop_reason:        pipeline_response.stop&.dig(:reason)&.to_s,
+                  input_tokens:       tokens.respond_to?(:input_tokens)        ? tokens.input_tokens        : nil,
+                  output_tokens:      tokens.respond_to?(:output_tokens)       ? tokens.output_tokens       : nil,
+                  cache_read_tokens:  tokens.respond_to?(:cache_read_tokens)   ? tokens.cache_read_tokens   : nil,
+                  cache_write_tokens: tokens.respond_to?(:cache_write_tokens)  ? tokens.cache_write_tokens  : nil
+                }.compact)}\n\n"
               rescue StandardError => e
                 Legion::Logging.log_exception(e, payload_summary: 'api/llm/inference stream failed', component_type: :api)
                 out << "event: error\ndata: #{Legion::JSON.dump({ code: 'stream_error', message: e.message })}\n\n"

data/lib/legion/cli/admin_command.rb

@@ -9,13 +9,15 @@ module Legion
       namespace :admin
 
       desc 'purge-topology', 'Remove old v2.0 AMQP exchanges (legion.* that have lex.* counterparts)'
-      method_option :dry_run,  type: :boolean, default: true,        desc: 'List without deleting'
-      method_option :execute,  type: :boolean, default: false,       desc: 'Actually delete exchanges'
-      method_option :host,     type: :string,  default: 'localhost', desc: 'RabbitMQ management host'
-      method_option :port,     type: :numeric, default: 15_672,      desc: 'RabbitMQ management port'
-      method_option :user,     type: :string,  default: 'guest',     desc: 'RabbitMQ management user'
-      method_option :password, type: :string,  default: 'guest',     desc: 'RabbitMQ management password'
-      method_option :vhost,    type: :string,  default: '/',         desc: 'RabbitMQ vhost'
+      method_option :dry_run,      type: :boolean, default: true,        desc: 'List without deleting'
+      method_option :execute,      type: :boolean, default: false,       desc: 'Actually delete exchanges'
+      method_option :host,         type: :string,  default: 'localhost', desc: 'RabbitMQ management host'
+      method_option :port,         type: :numeric, default: 15_672,      desc: 'RabbitMQ management port'
+      method_option :user,         type: :string,  default: 'guest',     desc: 'RabbitMQ management user'
+      method_option :password,     type: :string,  default: 'guest',     desc: 'RabbitMQ management password'
+      method_option :vhost,        type: :string,  default: '/',         desc: 'RabbitMQ vhost'
+      method_option :open_timeout, type: :numeric, default: 5,           desc: 'HTTP open timeout in seconds'
+      method_option :read_timeout, type: :numeric, default: 30,          desc: 'HTTP read timeout in seconds'
       def purge_topology
         exchanges  = fetch_exchanges
         candidates = self.class.detect_old_exchanges(exchanges)
@@ -76,7 +78,9 @@ module Legion
       end
 
       def management_request(uri, method_class)
-        Net::HTTP.start(uri.host, uri.port) do |http|
+        Net::HTTP.start(uri.host, uri.port,
+                        open_timeout: options[:open_timeout],
+                        read_timeout: options[:read_timeout]) do |http|
           req = method_class.new(uri)
           req.basic_auth(options[:user], options[:password])
           http.request(req)

data/lib/legion/cli/chat/daemon_chat.rb

@@ -32,6 +32,10 @@ module Legion
           end
         end
 
+        # Single shared struct class for tool result objects; avoids allocating
+        # an anonymous Struct class on every build_tool_result_object call.
+        ToolResult = Struct.new(:content, :tool_call_id, :id)
+
         attr_reader :model, :conversation_id, :caller_context
 
         def initialize(model: nil, provider: nil)
@@ -168,15 +172,24 @@ module Legion
           # Record the assistant turn with tool_calls before appending results.
           @messages << { role: 'assistant', content: assistant_content, tool_calls: tool_calls }
 
-          tool_calls.each do |tc|
-            tc = tc.transform_keys(&:to_sym) if tc.respond_to?(:transform_keys)
-            tc_obj = build_tool_call_object(tc)
+          # Normalize all tool calls upfront so threads don't mutate shared state
+          normalized = tool_calls.map do |tc|
+            tc.respond_to?(:transform_keys) ? tc.transform_keys(&:to_sym) : tc
+          end
 
-            @on_tool_call&.call(tc_obj)
+          # Fire on_tool_call callbacks immediately (serial — fast, just event emission)
+          normalized.each do |tc|
+            @on_tool_call&.call(build_tool_call_object(tc))
+          end
 
-            result_text = run_tool(tc)
+          # Execute all tools in parallel, preserving original order for message replay
+          results = normalized.map do |tc|
+            Thread.new { [tc, run_tool(tc)] }
+          end.map(&:value)
 
-            result_obj = build_tool_result_object(result_text)
+          # Collect results serially: fire callbacks and append messages in order
+          results.each do |tc, result_text|
+            result_obj = build_tool_result_object(result_text, tc[:id] || tc[:tool_call_id])
             @on_tool_result&.call(result_obj)
 
             @messages << {
@@ -195,8 +208,13 @@ module Legion
           )
         end
 
-        def build_tool_result_object(text)
-          Struct.new(:content).new(content: text.to_s)
+        # Carries both the result content AND the originating tool_call_id so the
+        # daemon-bridge-script serializer can include it in the tool-result event,
+        # allowing the Interlink frontend to match results back to the correct
+        # tool call by ID (rather than falling back to name-based matching which
+        # breaks when multiple tools of the same type run in parallel).
+        def build_tool_result_object(text, tool_call_id = nil)
+          ToolResult.new(text.to_s, tool_call_id, tool_call_id)
         end
 
         def run_tool(tool_call)

data/lib/legion/cli/groups/admin_group.rb

@@ -23,6 +23,20 @@ module Legion
 
         desc 'team SUBCOMMAND', 'Team and multi-user management'
         subcommand 'team', Legion::CLI::Team
+
+        desc 'purge-topology', 'Remove old v2.0 AMQP exchanges (legion.* that have lex.* counterparts)'
+        method_option :dry_run,      type: :boolean, default: true,        desc: 'List without deleting'
+        method_option :execute,      type: :boolean, default: false,       desc: 'Actually delete exchanges'
+        method_option :host,         type: :string,  default: 'localhost', desc: 'RabbitMQ management host'
+        method_option :port,         type: :numeric, default: 15_672,      desc: 'RabbitMQ management port'
+        method_option :user,         type: :string,  default: 'guest',     desc: 'RabbitMQ management user'
+        method_option :password,     type: :string,  default: 'guest',     desc: 'RabbitMQ management password'
+        method_option :vhost,        type: :string,  default: '/',         desc: 'RabbitMQ vhost'
+        method_option :open_timeout, type: :numeric, default: 5,           desc: 'HTTP open timeout in seconds'
+        method_option :read_timeout, type: :numeric, default: 30,          desc: 'HTTP read timeout in seconds'
+        def purge_topology
+          Legion::CLI::AdminCommand.new([], options).purge_topology
+        end
       end
     end
   end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.7.29'
+  VERSION = '1.7.30'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.7.29
+  version: 1.7.30
 platform: ruby
 authors:
 - Esity