legionio 1.7.29 → 1.7.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5af5e876210c79ae9fcc876fad3b8086a605f3a841c450793b4759711c5b0101
-  data.tar.gz: 43d1c51c4a52121654e1a1e426f5bbe9e6e1771a5a95a095eb12e87474632eec
+  metadata.gz: 962639f3a96de99418ba1cb7feb2ba06b488776df2c2c3a1ec7dfd0d353e6759
+  data.tar.gz: 87f2e206fab455fac86e36efdc497ff67d4614bb0699be00eb146c764ef43797
 SHA512:
-  metadata.gz: af956fad95ae9de341f700fa1e03997bed9b889983dc69b96322ba72cb7871f584224b4d00112e17b2e580a9f37e1afff3fa96e9b5bb5e83a38cf487fad26b77
-  data.tar.gz: 6545603e7df04444096ae7763fcfde3ee4b970603554388ab04be50a088bd36ac1f77c0fc5ce02f04eeaf5396bb5620d38fc6416f5125b900225a3f79ecc773a
+  metadata.gz: ef4a6788ec894fe2107c834c470fc469d866d36e445618bee17d6149738e2b31ce49c708619f0aaff12d140e799a92562e5383e9515f6d88e1ce15bbaeb9834c
+  data.tar.gz: 3a8a85d88ba670d683c196de7e60c32f37650e3ce420869a5e7b781f0741dcadce758f6c42b6cdb71b61c32ca68ac23d05d1571b00f2b974423da8779d975b82

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Legion Changelog
 
+## [1.7.31] - 2026-04-08
+
+### Added
+- Phase 7 RBAC enrichment: `Identity::Request` gains `roles:` constructor kwarg, `#roles` reader, `#id` alias for `principal_id`, and `roles:` in `identity_hash`
+- `Identity::Middleware#build_request` now separates `claims[:groups]` (group OIDs/names) from `claims[:roles]` (Entra app roles), fixing the pre-existing conflation via `||`
+- Worker token principal_id now correctly uses `claims[:worker_id]` when present, preventing worker tokens owned by a human from sharing the human's RBAC identity
+- `Identity::Middleware` enriches resolved roles via `Legion::Rbac::GroupRoleMapper` when legion-rbac is loaded and enabled (including audit mode)
+- `Identity::Middleware` builds `env['legion.rbac_principal']` (a `Legion::Rbac::Principal`) after setting `env['legion.principal']`, bridging identity to RBAC
+- Middleware mount order fix: `Legion::Rbac::Middleware` removed from class-level `use` in `api.rb`; both `Identity::Middleware` and `Rbac::Middleware` now registered in `service.rb#setup_api` in the correct order (Identity first, then RBAC)
+
+### Changed
+- `Legion::Identity::Request.from_auth_context` now reads `claims[:resolved_roles]` to populate `roles`
+
+## [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/api.rb

@@ -221,7 +221,6 @@ module Legion
     register Routes::GraphQL if defined?(Routes::GraphQL)
 
     use Legion::API::Middleware::RequestLogger
-    use Legion::Rbac::Middleware if defined?(Legion::Rbac::Middleware)
     use ElasticAPM::Middleware if defined?(ElasticAPM::Middleware) &&
                                   Legion::Settings.dig(:api, :elastic_apm, :enabled)
   end

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/identity/middleware.rb

@@ -18,17 +18,39 @@ module Legion
         auth_claims  = env['legion.auth']
         auth_method  = env['legion.auth_method']
 
-        env['legion.principal'] = if auth_claims
-                                    build_request(auth_claims, auth_method)
-                                  elsif @require_auth
-                                    # Auth middleware already handled 401 for protected paths;
-                                    # this is a safety net for any path that slipped through.
-                                    nil
-                                  else
-                                    # No auth required (loopback bind, lite mode, etc.).
-                                    # Set a system-level principal so audit trails always have an identity.
-                                    system_principal
-                                  end
+        request = if auth_claims
+                    build_request(auth_claims, auth_method)
+                  elsif @require_auth
+                    # Auth middleware already handled 401 for protected paths;
+                    # this is a safety net for any path that slipped through.
+                    nil
+                  else
+                    # No auth required (loopback bind, lite mode, etc.).
+                    # Set a system-level principal so audit trails always have an identity.
+                    system_principal
+                  end
+
+        env['legion.principal'] = request
+
+        # Bridge to RBAC principal if legion-rbac is loaded.
+        # This is a data bridge — set regardless of enforce/audit mode so
+        # the RBAC middleware always has a typed principal to evaluate.
+        # Guard: require Legion::Rbac.enabled? to confirm the real gem is loaded
+        # (not a minimal test stub), and rescue construction errors defensively.
+        if request && defined?(Legion::Rbac::Principal) &&
+           defined?(Legion::Rbac) && Legion::Rbac.respond_to?(:enabled?) &&
+           Legion::Rbac.enabled?
+          begin
+            env['legion.rbac_principal'] = Legion::Rbac::Principal.new(
+              id:    request.principal_id,
+              type:  request.kind == :service ? :worker : request.kind,
+              roles: request.roles,
+              team:  request.metadata&.dig(:team)
+            )
+          rescue StandardError
+            # Best-effort bridge: leave legion.rbac_principal unset on construction errors.
+          end
+        end
 
         @app.call(env)
       end
@@ -49,12 +71,39 @@ module Legion
       end
 
       def build_request(claims, method)
+        # Use worker_id as principal_id when present — worker tokens encode both
+        # worker_id and sub=owner_msid, and we want the worker's identity, not the owner's.
+        principal_id = claims[:worker_id] || claims[:sub] || claims[:owner_msid]
+
+        # For worker tokens (scope: 'worker' or worker_id present), derive canonical_name
+        # from the worker's own identity. Production worker JWTs omit :name and carry
+        # sub=owner_msid, so falling back to claims[:sub] would inherit the owner's identity.
+        worker_token = claims[:scope] == 'worker' || claims[:worker_id]
+        display_name = claims[:name] || (worker_token ? principal_id : claims[:sub])
+
+        # Separate group OIDs/names from Entra app roles — they are NOT equivalent.
+        # claims[:groups] = group OIDs/names (for GroupRoleMapper)
+        # claims[:roles]  = Entra app roles (pre-assigned at token-exchange time)
+        groups = Array(claims[:groups])
+        roles  = Array(claims[:roles])
+
+        # Enrich with group-derived RBAC roles when legion-rbac is loaded (including audit mode).
+        resolved_roles = if defined?(Legion::Rbac::GroupRoleMapper) &&
+                            Legion::Rbac.respond_to?(:enabled?) &&
+                            Legion::Rbac.enabled?
+                           group_roles = Legion::Rbac::GroupRoleMapper.resolve_roles(groups: groups)
+                           (roles + group_roles).uniq
+                         else
+                           roles
+                         end
+
         Identity::Request.from_auth_context({
-                                              sub:    claims[:sub] || claims[:worker_id] || claims[:owner_msid],
-                                              name:   claims[:name] || claims[:sub],
-                                              kind:   determine_kind(claims, method),
-                                              groups: Array(claims[:roles] || claims[:groups]),
-                                              source: method&.to_sym
+                                              sub:            principal_id,
+                                              name:           display_name,
+                                              kind:           determine_kind(claims, method),
+                                              groups:         groups,
+                                              resolved_roles: resolved_roles,
+                                              source:         method&.to_sym
                                             })
       end
 

data/lib/legion/identity/request.rb

@@ -16,13 +16,16 @@ module Legion
         system:   :system
       }.freeze
 
-      attr_reader :principal_id, :canonical_name, :kind, :groups, :source, :metadata
+      attr_reader :principal_id, :canonical_name, :kind, :groups, :roles, :source, :metadata
 
-      def initialize(principal_id:, canonical_name:, kind:, groups: [], source: nil, metadata: {}) # rubocop:disable Metrics/ParameterLists
+      alias id principal_id
+
+      def initialize(principal_id:, canonical_name:, kind:, groups: [], roles: [], source: nil, metadata: {}) # rubocop:disable Metrics/ParameterLists
         @principal_id   = principal_id
         @canonical_name = canonical_name
         @kind           = kind
         @groups         = groups.freeze
+        @roles          = roles.freeze
         @source         = SOURCE_NORMALIZATION.fetch(source&.to_sym, source)
         @metadata       = metadata.freeze
         freeze
@@ -35,7 +38,9 @@ module Legion
       end
 
       # Builds a Request from a parsed auth claims hash with symbol keys:
-      #   { sub:, name:, preferred_username:, kind:, groups:, source: }
+      #   { sub:, name:, preferred_username:, kind:, groups:, resolved_roles:, source: }
+      # resolved_roles is the final merged set of Entra app roles + group-derived RBAC
+      # roles (populated by Identity::Middleware before calling this method).
       # The source value is normalized via SOURCE_NORMALIZATION at construction time.
       def self.from_auth_context(claims_hash)
         raw_name = claims_hash[:name] || claims_hash[:preferred_username] || ''
@@ -48,6 +53,7 @@ module Legion
           canonical_name: canonical,
           kind:           claims_hash[:kind] || :human,
           groups:         claims_hash[:groups] || [],
+          roles:          Array(claims_hash[:resolved_roles]),
           source:         normalized_source
         )
       end
@@ -58,6 +64,7 @@ module Legion
           canonical_name: canonical_name,
           kind:           kind,
           groups:         groups,
+          roles:          roles,
           source:         source
         }
       end

data/lib/legion/service.rb

@@ -356,7 +356,7 @@ module Legion
       handle_exception(e, level: :warn, operation: 'service.shutdown_apm')
     end
 
-    def setup_api # rubocop:disable Metrics/MethodLength
+    def setup_api # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       if @api_thread&.alive?
         log.warn 'API already running, skipping duplicate setup_api call'
         return
@@ -394,12 +394,25 @@ module Legion
         log.info "Starting Legion API on #{bind}:#{port}"
       end
 
-      # Mount identity middleware — bridges legion.auth to legion.principal
+      # Mount identity middleware — bridges legion.auth to legion.principal.
+      # Identity MUST be mounted before RBAC so env['legion.rbac_principal'] is
+      # populated before the RBAC middleware reads it.
       if defined?(Legion::Identity::Middleware)
         require_auth = Legion::Identity::Middleware.require_auth?(bind: bind, mode: Legion::Mode.current)
         Legion::API.use Legion::Identity::Middleware, require_auth: require_auth
       end
 
+      # Mount RBAC middleware after Identity — reads env['legion.rbac_principal']
+      # set by Identity::Middleware above. Only mount when a compatible RBAC
+      # integration is present and enabled to avoid mixed-version request
+      # failures.
+      if defined?(Legion::Rbac::Middleware) &&
+         defined?(Legion::Rbac::Principal) &&
+         Legion::Rbac.respond_to?(:enabled?) &&
+         Legion::Rbac.enabled?
+        Legion::API.use Legion::Rbac::Middleware
+      end
+
       @api_thread = Thread.new do
         retries = 0
         max_retries = api_settings[:bind_retries]

data/lib/legion/version.rb

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

metadata

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