lex-llm-gateway 0.2.5 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 44562169a54b0e789ff4656a30599b2c43314c59fd5b5bb3056bf790da5a7a01
-  data.tar.gz: 399266aaa074b1eeb0c69044987bf36d13a11668defcda7066133f5c25ed5a93
+  metadata.gz: 6598c8eb88e900cf46910dcb33c93a51e9013e4a56795ea7a94d6aa892f8a550
+  data.tar.gz: 7267fd499d23a63afcd45bd8780080bac45a045f917f8b60ec04181d804e5e94
 SHA512:
-  metadata.gz: 9d122cadcffddfa7fa848a2d5cd992682e40a2e9cf84e5868af845d90572a7965f9fd462e6f23bc1d275410f48332ce7111a4d823dbbf17de3d16583903f407c
-  data.tar.gz: a188786600832ed973a988da109d053a87e05b7cdea82ee08914f1cad7931d4db2f8f4f1f2ea37fe442f9382d731f4980e6a099c6e6db84af1bca10b49b95512
+  metadata.gz: 0f35e042cd9c333fecae0ba9896bb79e131f9ece92af6a68e03920a6eaad652ee3a4fe1a38f1906d1378186290c66591125bf610f707896cc0c09b80ccb1dfaf
+  data.tar.gz: bb641bd9d3efcd68dfbe0c5d818a72935c6c3c89e76a68dee56c33dc8a5a2039270c0eed875245cadf93dbe1b1f1c39b6e366637c35b19f20dfe5a411e0aa1b6

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## [0.2.6] - 2026-03-23
+
+### Added
+- Fleet dispatch for structured and embed request types from Inference runner
+- Multi-message chat support in fleet dispatch (passes messages array directly)
+- InferenceRequest message now includes request_type, schema, and text fields
+
+### Changed
+- Fleet.dispatch uses `**opts` for extensible parameter forwarding
+- Fleet.publish_request uses anonymous keyword forwarding
+- Inference extract helpers compacted to single-line ternary style
+
 ## [0.2.5] - 2026-03-23
 
 ### Added

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

@@ -10,17 +10,19 @@ module Legion
 
             module_function
 
-            def dispatch(model:, messages:, intent: nil, timeout: nil)
+            def dispatch(model:, messages:, **opts)
               return error_result('fleet_unavailable') unless fleet_available?
 
+              intent = opts[:intent]
               token = Helpers::Auth.sign_request({ model: model, intent: intent })
               return error_result('fleet_auth_failed') if token.nil? && require_auth?
 
               correlation_id = Helpers::Rpc.generate_correlation_id
               publish_request(model: model, messages: messages, intent: intent,
-                              correlation_id: correlation_id, signed_token: token)
+                              correlation_id: correlation_id, signed_token: token,
+                              **opts.except(:intent, :timeout))
 
-              wait_for_response(correlation_id, timeout: resolve_timeout(timeout))
+              wait_for_response(correlation_id, timeout: resolve_timeout(opts[:timeout]))
             end
 
             def fleet_available?
@@ -68,12 +70,9 @@ module Legion
               settings.dig(:routing, :fleet, :timeout_seconds) || DEFAULT_TIMEOUT
             end
 
-            def publish_request(model:, messages:, intent:, correlation_id:, signed_token:)
-              reply_to = Helpers::Rpc.agent_queue_name
+            def publish_request(**)
               Transport::Messages::InferenceRequest.new(
-                model: model, messages: messages, intent: intent,
-                reply_to: reply_to, correlation_id: correlation_id,
-                signed_token: signed_token
+                reply_to: Helpers::Rpc.agent_queue_name, **
               ).publish
             end
 

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

@@ -19,7 +19,7 @@ module Legion
 
             def embed(text: nil, model: nil, provider: nil, **)
               start_ms = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
-              response = call_llm(:embed, text: text, model: model, provider: provider, **)
+              response = dispatch_embed(text: text, model: model, provider: provider, **)
               elapsed_ms = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond) - start_ms
               meter_response(response, request_type: 'embed', provider: provider, model_id: model,
                                        latency_ms: elapsed_ms)
@@ -28,22 +28,42 @@ module Legion
 
             def structured(messages: nil, schema: nil, model: nil, provider: nil, **)
               start_ms = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond)
-              response = call_llm(:structured, messages: messages, schema: schema, model: model,
-                                               provider: provider, **)
+              response = dispatch_structured(messages: messages, schema: schema, model: model,
+                                             provider: provider, **)
               elapsed_ms = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC, :millisecond) - start_ms
               meter_response(response, request_type: 'structured', provider: provider, model_id: model,
                                        latency_ms: elapsed_ms)
               response
             end
 
-            def dispatch_chat(message: nil, model: nil, provider: nil, **opts)
+            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)
               if tier == 'fleet' && fleet_available?
-                Fleet.dispatch(model: model, messages: [{ role: 'user', content: message }],
-                               intent: opts[:intent])
+                fleet_messages = messages || [{ role: 'user', content: message }]
+                Fleet.dispatch(model: model, messages: fleet_messages, intent: opts[:intent])
               else
-                call_llm(:chat, message: message, model: model, provider: provider, **opts)
+                call_llm(:chat, message: message, messages: messages, model: model,
+                                provider: provider, **opts)
+              end
+            end
+
+            def dispatch_embed(text: nil, model: nil, provider: nil, **opts)
+              if opts[:tier] == 'fleet' && fleet_available?
+                Fleet.dispatch(model: model, messages: [{ role: 'user', content: text }],
+                               intent: opts[:intent], request_type: 'embed', text: text)
+              else
+                call_llm(:embed, text: text, model: model, provider: provider, **opts)
+              end
+            end
+
+            def dispatch_structured(messages: nil, schema: nil, model: nil, provider: nil, **opts)
+              if opts[:tier] == 'fleet' && fleet_available?
+                Fleet.dispatch(model: model, messages: messages, intent: opts[:intent],
+                               request_type: 'structured', schema: schema)
+              else
+                call_llm(:structured, messages: messages, schema: schema, model: model,
+                                      provider: provider, **opts)
               end
             end
 
@@ -91,21 +111,15 @@ module Legion
             end
 
             def extract_tokens(response, field)
-              return 0 unless response.respond_to?(field)
-
-              response.public_send(field).to_i
+              response.respond_to?(field) ? response.public_send(field).to_i : 0
             end
 
             def extract_provider(response, fallback)
-              return response.provider if response.respond_to?(:provider)
-
-              fallback
+              response.respond_to?(:provider) ? response.provider : fallback
             end
 
             def extract_model(response, fallback)
-              return response.model if response.respond_to?(:model)
-
-              fallback
+              response.respond_to?(:model) ? response.model : fallback
             end
           end
         end

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

@@ -29,14 +29,12 @@ module Legion
 
               def message
                 {
-                  model: @options[:model],
-                  messages: @options[:messages] || [],
-                  intent: @options[:intent],
-                  reply_to: @options[:reply_to],
-                  correlation_id: @options[:correlation_id],
-                  signed_token: @options[:signed_token],
-                  provider: @options[:provider],
-                  tier: @options[:tier]
+                  model: @options[:model], messages: @options[:messages] || [],
+                  intent: @options[:intent], reply_to: @options[:reply_to],
+                  correlation_id: @options[:correlation_id], signed_token: @options[:signed_token],
+                  provider: @options[:provider], tier: @options[:tier],
+                  request_type: @options[:request_type], schema: @options[:schema],
+                  text: @options[:text]
                 }
               end
             end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module LLM
       module Gateway
-        VERSION = '0.2.5'
+        VERSION = '0.2.6'
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-gateway
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.6
 platform: ruby
 authors:
 - Esity