legionio 1.7.26 → 1.7.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 010545b8c47b9d866f1f5da8597e82f2e94bcd7c2a065f8aa97a9383f34325df
-  data.tar.gz: 7e75584a9fdf08247ec2e8834584a25499f1150814d6888701adea1689a85c37
+  metadata.gz: 537bbc9c431e5e8b9fdaf96145ea124a0c4b8e84b4094673cbc4f6b07d4edb21
+  data.tar.gz: da76364c12123a27f644f4fdef175c14796b2542800a93b054b26cb5f27a5e79
 SHA512:
-  metadata.gz: 582fd272567d6bcca36b3d9fa8eff39b123f8c664f557a3a26d832bde3756e9c5d32d94693533d31d6231ff9d3f77201d067c3b8e26c9fd416888245993c0dc7
-  data.tar.gz: fc1f7f556c6f7cb5c4a24b8733fc23032a3cc54561ccb0d40fba8189190a424e58c84412824d5e195c870b05015ecc93f398fd74948f8fce837f842a63641e41
+  metadata.gz: bee0c19f368dffa21a46fc964a43ae7448356912cbc5f0ac6884c9bcd4e00660821bc66c37e2b8d2cc2e05c77ec0fbce17d2f5a6c70b5b2bfb0d5eb4c3c278a6
+  data.tar.gz: 60f48041416adb178c7aae384647c7fb15860aa2a25dde1418500ef947ac323ebf36340ab242e9abcdd2893e717e3bdef94bd62aea43955e927c26acf377aecf

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # 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
+- Skip secret resolution for all CLI commands that only need local settings: `config`, `mode`, `lex`, `doctor`, `auth`, `marketplace`, `debug`, `failover status` — eliminates noisy Vault/lease warnings on local-only operations
+
+## [1.7.28] - 2026-04-07
+
+### Fixed
+- `legionio setup` pack marker and packs.json writes now rescue `Errno::EPERM`/`EACCES`, fixing Homebrew post-install crash when sandbox blocks writes to `~/.legionio/`
+
+## [1.7.27] - 2026-04-07
+
+### Changed
+- `Connection.ensure_settings` accepts `resolve_secrets:` keyword (default `true`) to skip Vault/lease resolution for CLI commands that don't need infrastructure credentials
+- `legionio update` now skips secret resolution, eliminating noisy "Vault not connected" and "LeaseManager not available" warnings
+
 ## [1.7.26] - 2026-04-07
 
 ### Added

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/auth_command.rb

@@ -20,7 +20,7 @@ module Legion
       method_option :scopes,     type: :string, desc: 'OAuth scopes to request'
       def teams
         out = formatter
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         port = begin
           Legion::Settings.dig(:api, :port) || 4567

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/config_command.rb

@@ -18,7 +18,7 @@ module Legion
       def show
         out = formatter
         Connection.config_dir = options[:config_dir] if options[:config_dir]
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         settings = if Legion::Settings.respond_to?(:to_hash)
                      Legion::Settings.to_hash
@@ -110,7 +110,7 @@ module Legion
 
         # Check settings load
         begin
-          Connection.ensure_settings
+          Connection.ensure_settings(resolve_secrets: false)
           out.success('Settings loaded successfully') unless options[:json]
         rescue StandardError => e
           issues << "Settings failed to load: #{e.message}"

data/lib/legion/cli/connection.rb

@@ -23,7 +23,7 @@ module Legion
           @logging_ready = true
         end
 
-        def ensure_settings
+        def ensure_settings(resolve_secrets: true)
           return if @settings_ready
 
           ensure_logging
@@ -31,7 +31,7 @@ module Legion
 
           dir = resolve_config_dir
           Legion::Settings.load(config_dir: dir)
-          Legion::Settings.resolve_secrets! if Legion::Settings.respond_to?(:resolve_secrets!)
+          Legion::Settings.resolve_secrets! if resolve_secrets && Legion::Settings.respond_to?(:resolve_secrets!)
           @settings_ready = true
         end
 

data/lib/legion/cli/debug_command.rb

@@ -98,7 +98,7 @@ module Legion
         def load_settings
           Connection.config_dir = options[:config_dir] if options[:config_dir]
           Connection.log_level = 'error'
-          Connection.ensure_settings
+          Connection.ensure_settings(resolve_secrets: false)
         rescue StandardError
           nil
         end

data/lib/legion/cli/doctor_command.rb

@@ -70,7 +70,7 @@ module Legion
       def diagnose
         out = formatter
         begin
-          Connection.ensure_settings
+          Connection.ensure_settings(resolve_secrets: false)
         rescue StandardError => e
           Legion::Logging.debug("Doctor#diagnose settings load failed: #{e.message}") if defined?(Legion::Logging)
         end

data/lib/legion/cli/failover_command.rb

@@ -72,7 +72,7 @@ module Legion
         private
 
         def ensure_settings
-          Connection.ensure_settings
+          Connection.ensure_settings(resolve_secrets: false)
         end
 
         def run_dry_run(out, target)

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/cli/lex_command.rb

@@ -160,7 +160,7 @@ module Legion
       desc 'enable NAME', 'Enable an extension in settings'
       def enable(name)
         out = formatter
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         extensions = Legion::Settings[:extensions] || {}
         if extensions.key?(name.to_sym)
@@ -176,7 +176,7 @@ module Legion
       desc 'disable NAME', 'Disable an extension in settings'
       def disable(name)
         out = formatter
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         extensions = Legion::Settings[:extensions] || {}
         if extensions.key?(name.to_sym)
@@ -349,7 +349,7 @@ module Legion
 
           # Load settings to check enabled/disabled state
           begin
-            Connection.ensure_settings
+            Connection.ensure_settings(resolve_secrets: false)
             ext_settings = Legion::Settings[:extensions] || {}
           rescue StandardError => e
             Legion::Logging.warn("LexCommand#discover_all settings load failed: #{e.message}") if defined?(Legion::Logging)

data/lib/legion/cli/marketplace_command.rb

@@ -248,7 +248,7 @@ module Legion
         end
 
         begin
-          Connection.ensure_settings
+          Connection.ensure_settings(resolve_secrets: false)
           Legion::Extensions::GemSource.setup!
         rescue StandardError => e
           Legion::Logging.debug("marketplace install: settings not available: #{e.message}") if defined?(Legion::Logging)

data/lib/legion/cli/mode_command.rb

@@ -31,7 +31,7 @@ module Legion
       desc 'show', 'Show current process role and extension profile'
       def show
         out = formatter
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         process_role = Legion::ProcessRole.current
         profile = Legion::Settings.dig(:role, :profile)&.to_s || '(none — all extensions load)'
@@ -55,7 +55,7 @@ module Legion
       desc 'list', 'List available extension profiles and process roles'
       def list
         out = formatter
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         if options[:json]
           out.json({ profiles: PROFILE_DESCRIPTIONS, process_roles: Legion::ProcessRole::ROLES.keys })
@@ -95,7 +95,7 @@ module Legion
       option :reload,       type: :boolean, default: false, desc: 'Trigger daemon reload after writing config'
       def set(profile = nil)
         out = formatter
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
 
         validate_inputs!(out, profile)
 

data/lib/legion/cli/setup_command.rb

@@ -304,6 +304,8 @@ module Legion
           marker = File.join(marker_dir, pack_name.to_s)
           File.write(marker, '') unless File.exist?(marker)
           update_packs_setting(pack_name)
+        rescue Errno::EPERM, Errno::EACCES => e
+          Legion::Logging.warn("Could not write pack marker: #{e.message}") if defined?(Legion::Logging)
         end
 
         def update_packs_setting(pack_name)
@@ -318,6 +320,8 @@ module Legion
           data['packs'] = packs.sort
           FileUtils.mkdir_p(File.dirname(settings_file))
           File.write(settings_file, ::JSON.pretty_generate(data))
+        rescue Errno::EPERM, Errno::EACCES => e
+          Legion::Logging.warn("Could not update packs setting: #{e.message}") if defined?(Legion::Logging)
         rescue ::JSON::ParserError
           data = { 'packs' => [pack_name.to_s] }
           File.write(settings_file, ::JSON.pretty_generate(data))

data/lib/legion/cli/update_command.rb

@@ -31,7 +31,7 @@ module Legion
           raise SystemExit, 1
         end
 
-        Connection.ensure_settings
+        Connection.ensure_settings(resolve_secrets: false)
         Legion::Extensions::GemSource.setup!
 
         target_gems = discover_legion_gems

data/lib/legion/version.rb

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

metadata

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