lex-llm-gateway 0.2.12 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23b44bc07cb28fc0e364b119984909f1d8becba720ea547b1255a8512188dec7
-  data.tar.gz: a4aae0ecf4e1b053405f74628af518156ae2ffc3d0678b4f920771a9e6a68ee6
+  metadata.gz: d3508dacc36a4c4fe57b9969cebd91aad39c5e3ab0edd67234bcb1a7b2094d84
+  data.tar.gz: 35eac64d3c2eadd149ad4c15dd87905ae83ea56a6b4b4a7ebbc1b7e0111b2605
 SHA512:
-  metadata.gz: 1cf5d4fe5d3f0728dee2dfa04019f62c7e2fd799527df6a79b069f9aabf4ef7cff44674fa0405406e200705faaa03eff282c60ab9b0ca3db25a5f93fa7bb6c1f
-  data.tar.gz: c01a0edb556ccf0346b111b6187f05e4083dde3c52ecbc43707fbb720c40a73501a76a98c85e37389512fb2db0184d631ba98edbecab77b456cd1af1401b882d
+  metadata.gz: 3910799509e5b020c223301493edae1bf5260d5544b5225448f2323740ce42139ea6fbc4a3350d61c01a66ebc0cfdf0c5fcb28a3c58d5e66796a209473e9b4e6
+  data.tar.gz: 104043cffae24348aed89a1183c1426be9205f45f9c882d92183f35759b10cd0c2d5a5958e2f2d64bf05c87163f57535b27c816eeec20d229c4b5ff7f6bffd15

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.2.13] - 2026-03-30
+
+### Changed
+- Add rubocop-legion 0.1.7 shared config via `inherit_gem`
+- Replace all `log.*` calls in `module_function` modules with `Legion::Logging.*` and inline disable comments
+- Replace `llm_chat`/`llm_embed`/`llm_structured` helper calls with `Legion::LLM.*` direct calls in `module_function` contexts
+- Update CI workflow: rename `lint` job to `excluded-files`, update workflow ref to `excluded-files.yml@main`
+
 ## [0.2.12] - 2026-03-24
 
 ### Fixed

data/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) 2026 Esity
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2021 Esity
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/lex-llm-gateway.gemspec

@@ -39,5 +39,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-legion'
   spec.add_development_dependency 'rubocop-rspec'
 end

data/lib/legion/extensions/llm/gateway/actors/spool_flush.rb

@@ -5,7 +5,7 @@ module Legion
     module LLM
       module Gateway
         module Actor
-          class SpoolFlush < Legion::Extensions::Actors::Every
+          class SpoolFlush < Legion::Extensions::Actors::Every # rubocop:disable Legion/Extension/EveryActorRequiresTime
             def runner_class
               'Legion::Extensions::LLM::Gateway::Runners::Metering'
             end

data/lib/legion/extensions/llm/gateway/helpers/auth.rb

@@ -12,7 +12,7 @@ module Legion
               return nil unless defined?(Legion::Crypt::JWT)
 
               Legion::Crypt::JWT.encode(payload: payload, ttl: 60)
-            rescue StandardError
+            rescue StandardError => _e
               nil
             end
 
@@ -20,7 +20,7 @@ module Legion
               return nil unless defined?(Legion::Crypt::JWT)
 
               Legion::Crypt::JWT.decode(token: token)
-            rescue StandardError
+            rescue StandardError => _e
               nil
             end
           end

data/lib/legion/extensions/llm/gateway/helpers/cost_estimator.rb

@@ -9,20 +9,20 @@ module Legion
             # Prices per 1M tokens [input, output] in USD
             # Source: published API pricing as of 2026-03
             PRICING = {
-              'claude-opus-4-6' => [15.0, 75.0],
+              'claude-opus-4-6'   => [15.0, 75.0],
               'claude-sonnet-4-6' => [3.0, 15.0],
-              'claude-haiku-4-5' => [0.80, 4.0],
+              'claude-haiku-4-5'  => [0.80, 4.0],
               'claude-3-5-sonnet' => [3.0, 15.0],
-              'claude-3-haiku' => [0.25, 1.25],
-              'gpt-4o' => [2.50,  10.0],
-              'gpt-4o-mini' => [0.15,  0.60],
-              'gpt-4-turbo' => [10.0,  30.0],
-              'o3' => [10.0, 40.0],
-              'o3-mini' => [1.10,  4.40],
-              'o4-mini' => [1.10,  4.40],
-              'gemini-2.5-pro' => [1.25, 10.0],
-              'gemini-2.5-flash' => [0.15,  0.60],
-              'gemini-2.0-flash' => [0.10,  0.40]
+              'claude-3-haiku'    => [0.25, 1.25],
+              'gpt-4o'            => [2.50,  10.0],
+              'gpt-4o-mini'       => [0.15,  0.60],
+              'gpt-4-turbo'       => [10.0,  30.0],
+              'o3'                => [10.0, 40.0],
+              'o3-mini'           => [1.10,  4.40],
+              'o4-mini'           => [1.10,  4.40],
+              'gemini-2.5-pro'    => [1.25, 10.0],
+              'gemini-2.5-flash'  => [0.15,  0.60],
+              'gemini-2.0-flash'  => [0.10,  0.40]
             }.freeze
 
             DEFAULT_PRICE = [1.0, 3.0].freeze

data/lib/legion/extensions/llm/gateway/helpers/reply_dispatcher.rb

@@ -16,13 +16,13 @@ module Legion
 
             def register(correlation_id)
               future = Concurrent::Promises.resolvable_future
-              @pending[correlation_id] = future
+              @pending[correlation_id] = future # rubocop:disable ThreadSafety/ClassInstanceVariable
               ensure_consumer
               future
             end
 
             def deregister(correlation_id)
-              @pending.delete(correlation_id)
+              @pending.delete(correlation_id) # rubocop:disable ThreadSafety/ClassInstanceVariable
             end
 
             def handle_delivery(raw_payload, properties = {})
@@ -30,16 +30,16 @@ module Legion
               cid = properties[:correlation_id] || payload[:correlation_id]
               return unless cid
 
-              future = @pending.delete(cid)
+              future = @pending.delete(cid) # rubocop:disable ThreadSafety/ClassInstanceVariable
               return unless future
 
               future.fulfill(payload.merge(success: true))
             rescue StandardError => e
-              log_warn("ReplyDispatcher: handle_delivery failed: #{e.message}")
+              Legion::Logging.warn("ReplyDispatcher: handle_delivery failed: #{e.message}") if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
             end
 
             def pending_count
-              @pending.size
+              @pending.size # rubocop:disable ThreadSafety/ClassInstanceVariable
             end
 
             def reset!
@@ -51,7 +51,7 @@ module Legion
 
             # private
 
-            def ensure_consumer # rubocop:disable Metrics/MethodLength
+            def ensure_consumer
               @mutex.synchronize do
                 return if @consumer
                 return unless transport_available?
@@ -67,18 +67,18 @@ module Legion
                 end
               end
             rescue StandardError => e
-              log_warn("ReplyDispatcher: consumer setup failed: #{e.message}")
+              Legion::Logging.warn("ReplyDispatcher: consumer setup failed: #{e.message}") if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
             end
 
             def cancel_consumer
-              @consumer&.cancel
-              @consumer = nil
+              @consumer&.cancel # rubocop:disable ThreadSafety/ClassInstanceVariable
+              @consumer = nil # rubocop:disable ThreadSafety/ClassInstanceVariable
             rescue StandardError => e
-              log_warn("ReplyDispatcher: cancel failed: #{e.message}")
+              Legion::Logging.warn("ReplyDispatcher: cancel failed: #{e.message}") if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
             end
 
             def transport_available?
-              defined?(Legion::Transport) &&
+              defined?(Legion::Transport) && # rubocop:disable Legion/HelperMigration/DefinedTransportGuard
                 Legion::Transport.respond_to?(:connection) &&
                 Legion::Transport.connection
             end
@@ -87,17 +87,17 @@ module Legion
               return raw if raw.is_a?(Hash)
 
               if defined?(Legion::JSON)
-                Legion::JSON.load(raw)
+                Legion::JSON.load(raw) # rubocop:disable Legion/HelperMigration/DirectJson
               else
                 require 'json'
-                JSON.parse(raw, symbolize_names: true)
+                ::JSON.parse(raw, symbolize_names: true)
               end
-            rescue StandardError
+            rescue StandardError => _e
               {}
             end
 
             def log_warn(msg)
-              Legion::Logging.warn(msg) if defined?(Legion::Logging)
+              Legion::Logging.warn(msg) if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
             end
           end
         end

data/lib/legion/extensions/llm/gateway/helpers/rpc.rb

@@ -15,16 +15,14 @@ module Legion
             end
 
             def agent_queue_name
-              if defined?(Legion::Transport) && Legion::Transport.respond_to?(:agent_queue_name)
-                return Legion::Transport.agent_queue_name
-              end
+              return Legion::Transport.agent_queue_name if defined?(Legion::Transport) && Legion::Transport.respond_to?(:agent_queue_name) # rubocop:disable Legion/HelperMigration/DefinedTransportGuard
 
               nil
             end
 
             def build_reply_headers(correlation_id:)
               {
-                reply_to: agent_queue_name,
+                reply_to:       agent_queue_name,
                 correlation_id: correlation_id
               }
             end

data/lib/legion/extensions/llm/gateway/helpers/usage_queries.rb

@@ -20,8 +20,8 @@ module Legion
               {
                 total_requests: dataset.count,
                 total_cost_usd: dataset.sum(:cost_usd).to_f.round(4),
-                total_input: dataset.sum(:input_tokens).to_i,
-                total_output: dataset.sum(:output_tokens).to_i
+                total_input:    dataset.sum(:input_tokens).to_i,
+                total_output:   dataset.sum(:output_tokens).to_i
               }
             end
 

data/lib/legion/extensions/llm/gateway/runners/fleet.rb

@@ -30,7 +30,7 @@ module Legion
             end
 
             def transport_ready?
-              !!(defined?(Legion::Transport) &&
+              !!(defined?(Legion::Transport) && # rubocop:disable Legion/HelperMigration/DefinedTransportGuard
                  Legion::Transport.respond_to?(:connected?) &&
                  Legion::Transport.connected?)
             end
@@ -80,7 +80,7 @@ module Legion
               future = Helpers::ReplyDispatcher.register(correlation_id)
               result = future.value!(timeout)
               result || timeout_result(correlation_id, timeout)
-            rescue Concurrent::CancelledOperationError
+            rescue Concurrent::CancelledOperationError => _e
               timeout_result(correlation_id, timeout)
             ensure
               Helpers::ReplyDispatcher.deregister(correlation_id)

data/lib/legion/extensions/llm/gateway/runners/fleet_handler.rb

@@ -48,65 +48,63 @@ module Legion
             def call_chat(payload)
               messages = payload[:messages]
               if messages.is_a?(Array) && messages.size > 1
-                Legion::LLM.chat(model: payload[:model], messages: messages,
+                Legion::LLM.chat(model: payload[:model], messages: messages, # rubocop:disable Legion/HelperMigration/DirectLlm
                                  caller: { extension: 'lex-llm-gateway', operation: 'fleet' })
               else
-                Legion::LLM.chat(model: payload[:model], message: messages&.dig(0, :content),
+                Legion::LLM.chat(model: payload[:model], message: messages&.dig(0, :content), # rubocop:disable Legion/HelperMigration/DirectLlm
                                  caller: { extension: 'lex-llm-gateway', operation: 'fleet' })
               end
             end
 
             def call_structured(payload)
-              Legion::LLM.structured(
-                model: payload[:model],
-                messages: payload[:messages],
-                schema: payload[:schema],
-                caller: { extension: 'lex-llm-gateway', operation: 'fleet' }
-              )
+              Legion::LLM.structured(model:    payload[:model], # rubocop:disable Legion/HelperMigration/DirectLlm
+                                     messages: payload[:messages],
+                                     schema:   payload[:schema],
+                                     caller:   { extension: 'lex-llm-gateway', operation: 'fleet' })
             end
 
             def call_embed(payload)
               text = payload[:text] || payload.dig(:messages, 0, :content)
-              Legion::LLM.embed(model: payload[:model], text: text,
+              Legion::LLM.embed(model: payload[:model], text: text, # rubocop:disable Legion/HelperMigration/DirectLlm
                                 caller: { extension: 'lex-llm-gateway', operation: 'fleet' })
             end
 
             def build_response(correlation_id, response)
               {
-                correlation_id: correlation_id,
-                response: response,
-                input_tokens: extract_token(response, :input_tokens),
-                output_tokens: extract_token(response, :output_tokens),
+                correlation_id:  correlation_id,
+                response:        response,
+                input_tokens:    extract_token(response, :input_tokens),
+                output_tokens:   extract_token(response, :output_tokens),
                 thinking_tokens: extract_token(response, :thinking_tokens),
-                provider: extract_field(response, :provider),
-                model_id: extract_field(response, :model)
+                provider:        extract_field(response, :provider),
+                model_id:        extract_field(response, :model)
               }
             end
 
-            def publish_reply(reply_to, correlation_id, response_hash) # rubocop:disable Metrics/MethodLength
-              return unless defined?(Legion::Transport)
+            def publish_reply(reply_to, correlation_id, response_hash)
+              return unless defined?(Legion::Transport) # rubocop:disable Legion/HelperMigration/DefinedTransportGuard
 
               payload = if defined?(Legion::JSON)
-                          Legion::JSON.dump(response_hash)
+                          Legion::JSON.dump(response_hash) # rubocop:disable Legion/HelperMigration/DirectJson
                         else
                           require 'json'
-                          JSON.generate(response_hash)
+                          ::JSON.generate(response_hash)
                         end
 
               channel = Legion::Transport.connection.create_channel
               channel.default_exchange.publish(
                 payload,
-                routing_key: reply_to,
+                routing_key:    reply_to,
                 correlation_id: correlation_id,
-                content_type: 'application/json'
+                content_type:   'application/json'
               )
               channel.close
             rescue StandardError => e
-              log_warn("FleetHandler: publish_reply failed: #{e.message}")
+              Legion::Logging.warn("FleetHandler: publish_reply failed: #{e.message}") if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
             end
 
             def log_warn(msg)
-              Legion::Logging.warn(msg) if defined?(Legion::Logging)
+              Legion::Logging.warn(msg) if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
             end
 
             def extract_token(response, field)

data/lib/legion/extensions/llm/gateway/runners/inference.rb

@@ -5,13 +5,13 @@ module Legion
     module LLM
       module Gateway
         module Runners
-          module Inference # rubocop:disable Metrics/ModuleLength
+          module Inference
             module_function
 
-            def chat(model: nil, provider: nil, **opts) # rubocop:disable Metrics/MethodLength
+            def chat(model: nil, provider: nil, **opts)
               if pipeline_available?
                 log_deprecation(:chat)
-                return Legion::LLM.chat(model: model, provider: provider,
+                return Legion::LLM.chat(model: model, provider: provider, # rubocop:disable Legion/HelperMigration/DirectLlm
                                         caller: { extension: 'lex-llm-gateway', operation: 'inference' }, **opts)
               end
 
@@ -23,11 +23,11 @@ module Legion
               response
             end
 
-            def embed(text: nil, model: nil, provider: nil, **) # rubocop:disable Metrics/MethodLength
+            def embed(text: nil, model: nil, provider: nil, **)
               if pipeline_available?
                 log_deprecation(:embed)
-                return Legion::LLM.embed(text, model: model, provider: provider,
-                                               caller: { extension: 'lex-llm-gateway', operation: 'inference' }, **)
+                return Legion::LLM.embed(text, model: model, provider: provider, # rubocop:disable Legion/HelperMigration/DirectLlm
+                                         caller: { extension: 'lex-llm-gateway', operation: 'inference' }, **)
               end
 
               start_ms = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
@@ -38,10 +38,10 @@ module Legion
               response
             end
 
-            def structured(messages: nil, schema: nil, model: nil, provider: nil, **) # rubocop:disable Metrics/MethodLength
+            def structured(messages: nil, schema: nil, model: nil, provider: nil, **)
               if pipeline_available?
                 log_deprecation(:structured)
-                return Legion::LLM.structured(messages: messages, schema: schema, model: model,
+                return Legion::LLM.structured(messages: messages, schema: schema, model: model, # rubocop:disable Legion/HelperMigration/DirectLlm
                                               provider: provider,
                                               caller: { extension: 'lex-llm-gateway', operation: 'inference' }, **)
               end
@@ -63,16 +63,14 @@ module Legion
             end
 
             def log_deprecation(method)
-              return unless defined?(Legion::Logging)
+              return unless defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/LoggingGuard
 
-              Legion::Logging.warn(
-                "lex-llm-gateway is deprecated for #{method}, use Legion::LLM.#{method} directly"
-              )
+              Legion::Logging.warn("lex-llm-gateway is deprecated for #{method}, use Legion::LLM.#{method} directly") # rubocop:disable Legion/HelperMigration/DirectLogging
             end
 
             def dispatch_chat(message: nil, messages: nil, model: nil, provider: nil, **opts)
               tier = opts[:tier]
-              Legion::Logging.debug "[Gateway::Inference] dispatch_chat tier=#{tier}" if defined?(Legion::Logging)
+              Legion::Logging.debug("[Gateway::Inference] dispatch_chat tier=#{tier}") if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
               if tier == 'fleet' && fleet_available?
                 fleet_messages = messages || [{ role: 'user', content: message }]
                 Fleet.dispatch(model: model, messages: fleet_messages, intent: opts[:intent])
@@ -108,7 +106,7 @@ module Legion
 
             def call_llm(method_name, **)
               unless defined?(Legion::LLM)
-                Legion::Logging.warn '[Gateway::Inference] Legion::LLM not defined' if defined?(Legion::Logging)
+                Legion::Logging.warn('[Gateway::Inference] Legion::LLM not defined') if defined?(Legion::Logging) # rubocop:disable Legion/HelperMigration/DirectLogging, Legion/HelperMigration/LoggingGuard
                 return { error: 'llm_not_available' }
               end
 
@@ -127,19 +125,19 @@ module Legion
 
             def base_meter_fields(response, opts)
               {
-                request_type: opts[:request_type],
-                provider: extract_provider(response, opts[:provider]),
-                model_id: extract_model(response, opts[:model_id]),
-                latency_ms: opts[:latency_ms],
-                tier: opts[:tier],
+                request_type:   opts[:request_type],
+                provider:       extract_provider(response, opts[:provider]),
+                model_id:       extract_model(response, opts[:model_id]),
+                latency_ms:     opts[:latency_ms],
+                tier:           opts[:tier],
                 routing_reason: opts[:intent]
               }
             end
 
             def token_fields(response)
               {
-                input_tokens: extract_tokens(response, :input_tokens),
-                output_tokens: extract_tokens(response, :output_tokens),
+                input_tokens:    extract_tokens(response, :input_tokens),
+                output_tokens:   extract_tokens(response, :output_tokens),
                 thinking_tokens: extract_tokens(response, :thinking_tokens)
               }
             end

data/lib/legion/extensions/llm/gateway/runners/metering.rb

@@ -14,13 +14,13 @@ module Legion
 
             def identity_fields(opts)
               {
-                node_id: opts[:node_id],
-                worker_id: opts[:worker_id],
-                agent_id: opts[:agent_id],
+                node_id:      opts[:node_id],
+                worker_id:    opts[:worker_id],
+                agent_id:     opts[:agent_id],
                 request_type: opts[:request_type],
-                tier: opts[:tier],
-                provider: opts[:provider],
-                model_id: opts[:model_id]
+                tier:         opts[:tier],
+                provider:     opts[:provider],
+                model_id:     opts[:model_id]
               }
             end
 
@@ -34,10 +34,10 @@ module Legion
 
             def timing_and_context(opts)
               {
-                latency_ms: opts.fetch(:latency_ms, 0),
-                wall_clock_ms: opts.fetch(:wall_clock_ms, 0),
+                latency_ms:     opts.fetch(:latency_ms, 0),
+                wall_clock_ms:  opts.fetch(:wall_clock_ms, 0),
                 routing_reason: opts[:routing_reason],
-                recorded_at: Time.now.utc.iso8601
+                recorded_at:    Time.now.utc.iso8601
               }
             end
 
@@ -61,7 +61,7 @@ module Legion
             end
 
             def transport_connected?
-              !!(defined?(Legion::Transport) &&
+              !!(defined?(Legion::Transport) && # rubocop:disable Legion/HelperMigration/DefinedTransportGuard
                 Legion::Transport.respond_to?(:connected?) &&
                 Legion::Transport.connected?)
             end

data/lib/legion/extensions/llm/gateway/runners/metering_writer.rb

@@ -33,39 +33,39 @@ module Legion
 
             def identity_fields(payload)
               {
-                worker_id: payload[:worker_id],
-                task_id: payload[:task_id],
-                provider: payload[:provider],
-                model_id: payload[:model_id],
+                worker_id:      payload[:worker_id],
+                task_id:        payload[:task_id],
+                provider:       payload[:provider],
+                model_id:       payload[:model_id],
                 routing_reason: payload[:routing_reason],
-                recorded_at: payload[:recorded_at] || Time.now.utc
+                recorded_at:    payload[:recorded_at] || Time.now.utc
               }
             end
 
             def trace_fields(payload)
               {
-                status: payload[:status],
-                event_type: payload[:event_type],
-                extension: payload[:extension],
+                status:          payload[:status],
+                event_type:      payload[:event_type],
+                extension:       payload[:extension],
                 runner_function: payload[:runner_function]
               }
             end
 
             def metric_fields(payload)
               {
-                input_tokens: payload[:input_tokens].to_i,
-                output_tokens: payload[:output_tokens].to_i,
+                input_tokens:    payload[:input_tokens].to_i,
+                output_tokens:   payload[:output_tokens].to_i,
                 thinking_tokens: payload[:thinking_tokens].to_i,
-                total_tokens: payload[:total_tokens].to_i,
-                latency_ms: payload[:latency_ms].to_i,
-                wall_clock_ms: payload[:wall_clock_ms].to_i
+                total_tokens:    payload[:total_tokens].to_i,
+                latency_ms:      payload[:latency_ms].to_i,
+                wall_clock_ms:   payload[:wall_clock_ms].to_i
               }
             end
 
             def cost_field(payload)
               cost = payload[:cost_usd] || Helpers::CostEstimator.estimate(
-                model_id: payload[:model_id],
-                input_tokens: payload[:input_tokens].to_i,
+                model_id:      payload[:model_id],
+                input_tokens:  payload[:input_tokens].to_i,
                 output_tokens: payload[:output_tokens].to_i
               )
               { cost_usd: cost.to_f }

data/lib/legion/extensions/llm/gateway/runners/provider_stats.rb

@@ -28,9 +28,9 @@ module Legion
               tracker = health_tracker
               providers = known_providers
               {
-                total: providers.size,
-                closed: providers.count { |p| tracker.circuit_state(p) == :closed },
-                open: providers.count { |p| tracker.circuit_state(p) == :open },
+                total:     providers.size,
+                closed:    providers.count { |p| tracker.circuit_state(p) == :closed },
+                open:      providers.count { |p| tracker.circuit_state(p) == :open },
                 half_open: providers.count { |p| tracker.circuit_state(p) == :half_open }
               }
             end
@@ -54,16 +54,16 @@ module Legion
               providers.select { |_, cfg| cfg.is_a?(Hash) && cfg[:enabled] }
                        .keys
                        .map(&:to_sym)
-            rescue StandardError
+            rescue StandardError => _e
               []
             end
 
             def provider_entry(name, tracker)
               {
-                provider: name.to_s,
-                circuit: tracker.circuit_state(name).to_s,
+                provider:   name.to_s,
+                circuit:    tracker.circuit_state(name).to_s,
                 adjustment: tracker.adjustment(name),
-                healthy: tracker.circuit_state(name) != :open
+                healthy:    tracker.circuit_state(name) != :open
               }
             end
 

data/lib/legion/extensions/llm/gateway/runners/usage_reporter.rb

@@ -55,31 +55,31 @@ module Legion
 
             def build_summary(dataset, period, since)
               queries.aggregate_totals(dataset).merge(
-                period: period.to_s,
-                since: since.iso8601,
+                period:      period.to_s,
+                since:       since.iso8601,
                 by_provider: queries.grouped_rows(dataset, :provider),
-                by_model: queries.grouped_rows(dataset, :model_id)
+                by_model:    queries.grouped_rows(dataset, :model_id)
               )
             end
 
             def build_worker_summary(dataset, worker_id, period, since)
               queries.aggregate_totals(dataset).merge(
                 worker_id: worker_id,
-                period: period.to_s,
-                since: since.iso8601,
-                by_model: queries.grouped_rows(dataset, :model_id)
+                period:    period.to_s,
+                since:     since.iso8601,
+                by_model:  queries.grouped_rows(dataset, :model_id)
               )
             end
 
             def build_budget_result(budget, spent, alert_at, period)
               ratio = budget.positive? ? (spent / budget) : 0.0
               {
-                period: period.to_s,
-                budget: budget.round(2),
-                spent: spent.round(4),
+                period:    period.to_s,
+                budget:    budget.round(2),
+                spent:     spent.round(4),
                 remaining: [(budget - spent), 0.0].max.round(4),
-                ratio: ratio.round(4),
-                status: budget_status(ratio, alert_at)
+                ratio:     ratio.round(4),
+                status:    budget_status(ratio, alert_at)
               }
             end
 

data/lib/legion/extensions/llm/gateway/transport/messages/inference_response.rb

@@ -28,10 +28,10 @@ module Legion
               def message
                 token_fields.merge(
                   correlation_id: @options[:correlation_id],
-                  response: @options[:response],
-                  provider: @options[:provider],
-                  model_id: @options[:model_id],
-                  error: @options[:error]
+                  response:       @options[:response],
+                  provider:       @options[:provider],
+                  model_id:       @options[:model_id],
+                  error:          @options[:error]
                 )
               end
 
@@ -39,10 +39,10 @@ module Legion
 
               def token_fields
                 {
-                  input_tokens: @options[:input_tokens] || 0,
-                  output_tokens: @options[:output_tokens] || 0,
+                  input_tokens:    @options[:input_tokens] || 0,
+                  output_tokens:   @options[:output_tokens] || 0,
                   thinking_tokens: @options[:thinking_tokens] || 0,
-                  latency_ms: @options[:latency_ms] || 0
+                  latency_ms:      @options[:latency_ms] || 0
                 }
               end
             end

data/lib/legion/extensions/llm/gateway/transport/messages/metering_event.rb

@@ -34,35 +34,35 @@ module Legion
 
               def identity_fields
                 {
-                  node_id: @options[:node_id],
-                  worker_id: @options[:worker_id],
-                  agent_id: @options[:agent_id],
+                  node_id:      @options[:node_id],
+                  worker_id:    @options[:worker_id],
+                  agent_id:     @options[:agent_id],
                   request_type: @options[:request_type],
-                  tier: @options[:tier],
-                  provider: @options[:provider],
-                  model_id: @options[:model_id]
+                  tier:         @options[:tier],
+                  provider:     @options[:provider],
+                  model_id:     @options[:model_id]
                 }
               end
 
               def context_fields
                 {
                   routing_reason: @options[:routing_reason],
-                  recorded_at: @options[:recorded_at] || Time.now.utc.iso8601
+                  recorded_at:    @options[:recorded_at] || Time.now.utc.iso8601
                 }
               end
 
               def token_fields
                 {
-                  input_tokens: @options[:input_tokens] || 0,
-                  output_tokens: @options[:output_tokens] || 0,
+                  input_tokens:    @options[:input_tokens] || 0,
+                  output_tokens:   @options[:output_tokens] || 0,
                   thinking_tokens: @options[:thinking_tokens] || 0,
-                  total_tokens: @options[:total_tokens] || 0
+                  total_tokens:    @options[:total_tokens] || 0
                 }
               end
 
               def timing_fields
                 {
-                  latency_ms: @options[:latency_ms] || 0,
+                  latency_ms:    @options[:latency_ms] || 0,
                   wall_clock_ms: @options[:wall_clock_ms] || 0
                 }
               end

data/lib/legion/extensions/llm/gateway/transport/queues/inference_process.rb

@@ -13,7 +13,7 @@ module Legion
 
               def queue_options
                 {
-                  durable: true,
+                  durable:     true,
                   auto_delete: false
                 }
               end

data/lib/legion/extensions/llm/gateway/transport/queues/metering_write.rb

@@ -13,7 +13,7 @@ module Legion
 
               def queue_options
                 {
-                  durable: true,
+                  durable:     true,
                   auto_delete: false
                 }
               end

data/lib/legion/extensions/llm/gateway/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module LLM
       module Gateway
-        VERSION = '0.2.12'
+        VERSION = '0.2.13'
       end
     end
   end

data/lib/legion/extensions/llm/gateway.rb

@@ -6,7 +6,7 @@ module Legion
   module Extensions
     module LLM
       module Gateway
-        extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core)
+        extend Legion::Extensions::Core if Legion::Extensions.const_defined?(:Core, false)
       end
     end
     remove_const(:Llm) if const_defined?(:Llm, false)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-gateway
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.13
 platform: ruby
 authors:
 - Esity
@@ -149,6 +149,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-legion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement