lex-llm-vllm 0.1.5 → 0.1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09f2552a0f25448494068e45c5ae44d199b7311b3f1256893341c5e4fea6db45'
-  data.tar.gz: 4ca2f6e31f494983d97d67ab4d45c56e7c0e8a768c322fbfa313119789c96557
+  metadata.gz: 3b6bccbfd1d8e01fd38459107474d9ca3853f7d847ff3b5d71a8df3ff7a66c4b
+  data.tar.gz: f2bd935851929d113f078301a08119a425a68c35907094ee66d69d10af3e5f6f
 SHA512:
-  metadata.gz: 964bb4761e53e9141337266c38f470bc358d479f001dd3cb106ce21daeaf63fa3fe777b7f80f7200aeed3cbbcfcb121195614afbaecb26de4a13f618ae882146
-  data.tar.gz: 367efe9b428ca024db4d2de25ffef52e79207b17934a68b47eaa6a10d7b95f6e0dcc05a43d758b09d06fd7db27246b6e4acb9b901fc950fc9b636ec555822f34
+  metadata.gz: 837e7ea4d14a09dd44922cb6193e4650b92aea3c4eea8cd85ed7916d766c84b7f8887961b0fb72ab8a1578d4005742f61ed44435d181235bb4f26042aa6aecf8
+  data.tar.gz: 8c73bfdd7921d1f99d788d4a311be574fc7cb9f61c7ebb6a79bdf7ea4a68622f020ace60858134288eea85186beb3d4c32b97c5ac714515a124b8110f3253679

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.1.7 - 2026-04-30
+
+- Enable stream_usage_supported? for streaming token usage reporting
+- Add render_payload override with chat_template_kwargs for vLLM thinking mode
+- Add thinking_enabled? setting support from Legion::Settings
+
+## 0.1.6 - 2026-04-28
+
+- Publish best-effort `llm.registry` readiness and discovered-model availability events when transport is loaded.
+
 ## 0.1.5 - 2026-04-28
 
 - Require current shared Legion JSON, logging, settings, and LLM extension gems.

data/lib/legion/extensions/llm/vllm/provider.rb

@@ -12,11 +12,17 @@ module Legion
           include Legion::Extensions::Llm::Provider::OpenAICompatible
 
           class << self
+            attr_writer :registry_publisher
+
             def slug = 'vllm'
             def local? = true
             def configuration_options = %i[vllm_api_base vllm_api_key]
             def configuration_requirements = []
             def capabilities = Capabilities
+
+            def registry_publisher
+              @registry_publisher ||= RegistryPublisher.new
+            end
           end
 
           # Capability predicates for vLLM OpenAI-compatible model offerings.
@@ -39,6 +45,8 @@ module Legion
             end
           end
 
+          def stream_usage_supported? = true
+
           def api_base
             config.vllm_api_base || 'http://localhost:8000'
           end
@@ -61,6 +69,18 @@ module Legion
             connection.get(health_url).body
           end
 
+          def readiness(live: false)
+            super.tap do |metadata|
+              self.class.registry_publisher.publish_readiness_async(metadata) if live
+            end
+          end
+
+          def list_models
+            super.tap do |models|
+              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+            end
+          end
+
           def version
             connection.get(version_url).body
           end
@@ -84,6 +104,30 @@ module Legion
 
           private
 
+          def render_payload(messages, tools:, temperature:, model:, stream:, schema:, thinking:, tool_prefs:) # rubocop:disable Metrics/ParameterLists
+            payload = super
+            payload.delete(:reasoning_effort)
+            payload[:chat_template_kwargs] = { enable_thinking: true } if thinking_enabled?(thinking)
+            payload
+          end
+
+          def thinking_enabled?(thinking)
+            return true if thinking.is_a?(Hash) && (thinking[:enabled] != false)
+            return true if thinking.respond_to?(:enabled?) && thinking.enabled?
+            return vllm_thinking_setting unless thinking
+
+            false
+          end
+
+          def vllm_thinking_setting
+            return false unless defined?(Legion::Settings)
+
+            vllm = Legion::Settings.dig(:llm, :providers, :vllm)
+            vllm.is_a?(Hash) && (vllm[:enable_thinking] == true || vllm['enable_thinking'] == true)
+          rescue StandardError
+            false
+          end
+
           def with_query(path, positional = [], **params)
             pairs = positional + params.compact.map { |key, value| [key.to_s, value] }
             return path if pairs.empty?

data/lib/legion/extensions/llm/vllm/registry_event_builder.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Vllm
+        # Builds sanitized lex-llm registry envelopes for vLLM provider state.
+        class RegistryEventBuilder
+          def readiness(readiness)
+            registry_event_class.public_send(
+              readiness[:ready] ? :available : :unavailable,
+              provider_offering(readiness),
+              runtime: runtime_metadata,
+              health: readiness_health(readiness),
+              metadata: readiness_metadata(readiness)
+            )
+          end
+
+          def model_available(model, readiness:)
+            registry_event_class.available(
+              model_offering(model),
+              runtime: runtime_metadata,
+              health: model_health(readiness),
+              metadata: model_metadata(model)
+            )
+          end
+
+          private
+
+          def provider_offering(readiness)
+            {
+              provider_family: :vllm,
+              provider_instance: provider_instance,
+              transport: :http,
+              model: 'provider-readiness',
+              usage_type: :inference,
+              capabilities: [],
+              health: readiness_health(readiness),
+              metadata: { lex: :llm_vllm, provider_readiness: true }
+            }
+          end
+
+          def model_offering(model)
+            {
+              provider_family: :vllm,
+              provider_instance: provider_instance,
+              transport: :http,
+              model: model.id,
+              usage_type: usage_type_for(model),
+              capabilities: Array(model.capabilities).map(&:to_sym),
+              limits: model_limits(model),
+              metadata: { lex: :llm_vllm, model_name: model.name }.compact
+            }
+          end
+
+          def readiness_health(readiness)
+            health = {
+              ready: readiness[:ready] == true,
+              status: readiness[:ready] ? :available : :unavailable,
+              checked: readiness.dig(:health, :checked) != false
+            }
+            add_readiness_error(health, readiness[:health])
+          end
+
+          def add_readiness_error(health, source)
+            error = source.is_a?(Hash) ? source : {}
+            error_class = error[:error] || error['error']
+            error_message = error[:message] || error['message']
+            health[:error_class] = error_class if error_class
+            health[:error] = error_message if error_message
+            health
+          end
+
+          def model_health(readiness)
+            ready = readiness.fetch(:ready, true) == true
+            { ready:, status: ready ? :available : :degraded }
+          end
+
+          def readiness_metadata(readiness)
+            {
+              extension: :lex_llm_vllm,
+              provider: :vllm,
+              configured: readiness[:configured] == true,
+              live: readiness[:live] == true
+            }
+          end
+
+          def model_metadata(model)
+            { extension: :lex_llm_vllm, provider: :vllm, model_type: model.type }
+          end
+
+          def runtime_metadata
+            { node: provider_instance }
+          end
+
+          def model_limits(model)
+            {
+              context_window: model.context_window,
+              max_output_tokens: model.max_output_tokens
+            }.compact
+          end
+
+          def usage_type_for(model)
+            model.type == 'embedding' ? :embedding : :inference
+          end
+
+          def provider_instance
+            configured_node = (::Legion::Settings.dig(:node, :canonical_name) if defined?(::Legion::Settings))
+            value = configured_node.to_s.strip
+            value.empty? ? :vllm : value.to_sym
+          rescue StandardError
+            :vllm
+          end
+
+          def registry_event_class
+            ::Legion::Extensions::Llm::Routing::RegistryEvent
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/vllm/registry_publisher.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Vllm
+        # Best-effort publisher for vLLM provider availability events.
+        class RegistryPublisher
+          APP_ID = 'lex-llm-vllm'
+
+          def initialize(builder: RegistryEventBuilder.new)
+            @builder = builder
+          end
+
+          def publish_readiness_async(readiness)
+            schedule { publish_event(@builder.readiness(readiness)) }
+          end
+
+          def publish_models_async(models, readiness:)
+            schedule do
+              Array(models).each do |model|
+                publish_event(@builder.model_available(model, readiness:))
+              end
+            end
+          end
+
+          private
+
+          def schedule(&)
+            return false unless publishing_available?
+
+            Thread.new do
+              Thread.current.abort_on_exception = false
+              yield
+            rescue StandardError => e
+              log_publish_failure(e, level: :debug)
+            end
+          rescue StandardError => e
+            log_publish_failure(e, level: :debug)
+            false
+          end
+
+          def publish_event(event)
+            return false unless publishing_available?
+
+            message_class.new(event:, app_id: APP_ID).publish(spool: false)
+          rescue StandardError => e
+            log_publish_failure(e)
+            false
+          end
+
+          def publishing_available?
+            return false unless registry_event_available?
+            return false unless transport_message_available?
+            return true unless defined?(::Legion::Transport::Connection)
+            return true unless ::Legion::Transport::Connection.respond_to?(:session_open?)
+
+            ::Legion::Transport::Connection.session_open?
+          rescue StandardError
+            false
+          end
+
+          def registry_event_available?
+            defined?(::Legion::Extensions::Llm::Routing::RegistryEvent)
+          end
+
+          def transport_message_available?
+            return true if message_class_defined?
+            return false unless defined?(::Legion::Transport::Message) && defined?(::Legion::Transport::Exchange)
+
+            require 'legion/extensions/llm/vllm/transport/messages/registry_event'
+            message_class_defined?
+          rescue LoadError
+            false
+          end
+
+          def message_class_defined?
+            defined?(::Legion::Extensions::Llm::Vllm::Transport::Messages::RegistryEvent)
+          end
+
+          def message_class
+            ::Legion::Extensions::Llm::Vllm::Transport::Messages::RegistryEvent
+          end
+
+          def log_publish_failure(error, level: :warn)
+            message = "[lex-llm-vllm] llm.registry publish failed: #{error.class}: #{error.message}"
+            logger = ::Legion::Extensions::Llm.logger if defined?(::Legion::Extensions::Llm)
+            if logger.respond_to?(level)
+              logger.public_send(level, message)
+            elsif logger.respond_to?(:debug)
+              logger.debug(message)
+            end
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/vllm/transport/exchanges/llm_registry.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module Llm
+      module Vllm
+        module Transport
+          module Exchanges
+            # Topic exchange for vLLM provider availability events.
+            class LlmRegistry < ::Legion::Transport::Exchange
+              def exchange_name
+                'llm.registry'
+              end
+
+              def default_type
+                'topic'
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/llm/vllm/transport/messages/registry_event.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'legion/extensions/llm/vllm/transport/exchanges/llm_registry'
+
+module Legion
+  module Extensions
+    module Llm
+      module Vllm
+        module Transport
+          module Messages
+            # Publishes lex-llm RegistryEvent envelopes to the llm.registry exchange.
+            class RegistryEvent < ::Legion::Transport::Message
+              def initialize(event:, **options)
+                super(**event.to_h.merge(options))
+              end
+
+              def exchange
+                Transport::Exchanges::LlmRegistry
+              end
+
+              def routing_key
+                @options[:routing_key] || "llm.registry.#{@options.fetch(:event_type)}"
+              end
+
+              def type
+                'llm.registry.event'
+              end
+
+              def app_id
+                @options[:app_id] || RegistryPublisher::APP_ID
+              end
+
+              def persistent # rubocop:disable Naming/PredicateMethod
+                false
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Vllm
-        VERSION = '0.1.5'
+        VERSION = '0.1.7'
       end
     end
   end

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

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'legion/extensions/llm'
+require 'legion/extensions/llm/vllm/registry_event_builder'
 require 'legion/extensions/llm/vllm/provider'
+require 'legion/extensions/llm/vllm/registry_publisher'
 require 'legion/extensions/llm/vllm/version'
 
 module Legion

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-vllm
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.7
 platform: ruby
 authors:
 - LegionIO
@@ -84,6 +84,10 @@ files:
 - lex-llm-vllm.gemspec
 - lib/legion/extensions/llm/vllm.rb
 - lib/legion/extensions/llm/vllm/provider.rb
+- lib/legion/extensions/llm/vllm/registry_event_builder.rb
+- lib/legion/extensions/llm/vllm/registry_publisher.rb
+- lib/legion/extensions/llm/vllm/transport/exchanges/llm_registry.rb
+- lib/legion/extensions/llm/vllm/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/vllm/version.rb
 homepage: https://github.com/LegionIO/lex-llm-vllm
 licenses: