lex-llm-vertex 0.1.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a7dc0a783d3cb0961f7881a4ef0412d1842730852518f1f7ac859ad2cbb944d
-  data.tar.gz: fabd6084238f3473c1b3a75e53e1f19de820f6ce12231316c38b39a33a2a506f
+  metadata.gz: 35a2ffd46ca20c21c1c0d280688794b6702285b996d0f1386c37de565a409b57
+  data.tar.gz: 5ae360df40fe27bd2c43d37cd15ee36449303422df3a65550e596fc51f22ae3e
 SHA512:
-  metadata.gz: 403c6201955ec9d77611f0ade5a338b58d4164f9567bab09b927c73427a06a2214e6828dff3f3fe82ac435ed33932195454a426f1c78bbac2f74c0743db26c27
-  data.tar.gz: 91592103291579ba34d8bd61dd1e066111b7a68449585bd96d8d5ca7f38b141dfc0c9d37db532c73721eb3de88d9bdca302510366088464678156c1e978132e8
+  metadata.gz: ac9e04f6a5ffdf57bd83392cbb039220871eac5d006256bf90c0a095bae241722a2aa8a05216ab663751bc0d5f144eec95ffcf6f6b5921f2135309938bd3de77
+  data.tar.gz: 928812748673dd57855e0ad4e718d2de1fa0f331d2d60df190d96b072de49cd4b317f4eb905c59a9eccaaf38a85c5ea2b87879bcaab00d5a7c4446db6295258d

data/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.0 - 2026-05-01
+
+- Add auto-discovery via CredentialSources and AutoRegistration from lex-llm 0.3.0
+- Self-register discovered instances into Call::Registry at require-time
+- Require lex-llm >= 0.3.0
+
+
 ## [0.1.5] - 2026-04-30
 
 - Add `Legion::Logging::Helper` to all modules and classes for structured logging

data/lex-llm-vertex.gemspec

@@ -26,5 +26,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-json', '>= 1.2.1'
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
-  spec.add_dependency 'lex-llm', '>= 0.1.5'
+  spec.add_dependency 'lex-llm', '>= 0.3.0'
 end

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

@@ -56,7 +56,7 @@ module Legion
             def capabilities = Capabilities
 
             def registry_publisher
-              @registry_publisher ||= RegistryPublisher.new
+              @registry_publisher ||= Legion::Extensions::Llm::RegistryPublisher.new(provider_family: :vertex)
             end
 
             def resolve_model_id(model_id, config: nil)
@@ -112,16 +112,25 @@ module Legion
             "#{publisher_model_path(model)}:#{suffix}"
           end
 
+          def list_models
+            log.info { 'listing available Vertex models from static catalog' }
+            STATIC_MODELS.map { |entry| model_info_from_static(entry) }.tap do |models|
+              log.info { "discovered #{models.size} Vertex model(s); publishing to registry" }
+              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+            end
+          end
+
           def discover_offerings(live: false, **filters)
             log.info { "discovering offerings live=#{live} project=#{project} location=#{location}" }
             return static_offerings(**filters) unless live
 
             response = connection.get(models_url)
             models = response.body['publisherModels'] || response.body['models'] || []
-            models.map { |model| offering_from_live_model(model) }.tap do |offerings|
-              log.info { "discovered #{offerings.size} live offering(s) from Vertex" }
-              self.class.registry_publisher.publish_offerings_async(offerings, readiness: readiness(live: false))
-            end
+            offerings = models.map { |model| offering_from_live_model(model) }
+            log.info { "discovered #{offerings.size} live offering(s) from Vertex" }
+            model_infos = offerings.map { |o| model_info_from_offering(o) }
+            self.class.registry_publisher.publish_models_async(model_infos, readiness: readiness(live: false))
+            offerings
           end
 
           def offering_for(model:, model_family: nil, instance_id: :default, **metadata)
@@ -235,6 +244,34 @@ module Legion
 
           private
 
+          def model_info_from_static(entry)
+            caps = default_capabilities(entry[:model], api: entry.fetch(:api, :generate_content))
+            Legion::Extensions::Llm::Model::Info.new(
+              id: entry[:model],
+              name: entry[:alias] || entry[:model],
+              provider: :vertex,
+              family: entry[:model_family].to_s,
+              capabilities: caps.map(&:to_s),
+              metadata: {
+                publisher: entry[:publisher],
+                project: project,
+                location: location,
+                api: entry.fetch(:api, :generate_content)
+              }.compact
+            )
+          end
+
+          def model_info_from_offering(offering)
+            Legion::Extensions::Llm::Model::Info.new(
+              id: offering.model,
+              name: offering.metadata[:alias] || offering.model,
+              provider: :vertex,
+              family: offering.metadata[:model_family].to_s,
+              capabilities: offering.capabilities.map(&:to_s),
+              metadata: offering.metadata
+            )
+          end
+
           def static_offerings(**filters)
             STATIC_MODELS.filter_map do |entry|
               next if filters[:model_family] && entry.fetch(:model_family) != filters[:model_family].to_sym

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Vertex
-        VERSION = '0.1.5'
+        VERSION = '0.2.0'
       end
     end
   end

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

@@ -2,8 +2,6 @@
 
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/vertex/provider'
-require 'legion/extensions/llm/vertex/registry_event_builder'
-require 'legion/extensions/llm/vertex/registry_publisher'
 require 'legion/extensions/llm/vertex/version'
 
 module Legion
@@ -13,37 +11,73 @@ module Legion
       module Vertex
         extend Legion::Logging::Helper
         extend ::Legion::Extensions::Core if ::Legion::Extensions.const_defined?(:Core, false)
+        extend Legion::Extensions::Llm::AutoRegistration
 
         PROVIDER_FAMILY = :vertex
 
         def self.default_settings
-          ::Legion::Extensions::Llm.provider_settings(
-            family: PROVIDER_FAMILY,
-            discovery: { enabled: true, live: false, locations: %w[us-central1 us-east5 europe-west4] },
-            instance: {
-              endpoint: 'https://us-central1-aiplatform.googleapis.com/v1',
-              project: 'env://GOOGLE_CLOUD_PROJECT',
-              location: 'us-central1',
-              tier: :frontier,
-              transport: :http,
-              credentials: {
-                provider: 'google-application-default-credentials',
-                access_token: 'env://VERTEX_ACCESS_TOKEN',
-                credentials_file: 'env://GOOGLE_APPLICATION_CREDENTIALS'
-              },
-              usage: { inference: true, embedding: true, token_counting: true },
-              limits: { concurrency: 4 }
-            }
-          )
+          {
+            enabled: false,
+            default_model: nil,
+            project: nil,
+            location: 'us-central1',
+            model_whitelist: [],
+            model_blacklist: [],
+            model_cache_ttl: 3600,
+            tls: { enabled: false, verify: :peer },
+            instances: {}
+          }
         end
 
         def self.provider_class
           Provider
         end
+
+        def self.discover_instances
+          instances = {}
+          discover_default_instance(instances)
+          discover_named_instances(instances)
+          instances
+        end
+
+        def self.discover_default_instance(instances)
+          cfg = CredentialSources.setting(:extensions, :llm, :vertex)
+          return unless cfg.is_a?(Hash) && vertex_credentials_present?(cfg)
+
+          instances[:settings] = cfg.except(:instances, 'instances').merge(tier: :cloud)
+        end
+
+        def self.discover_named_instances(instances)
+          cfg = CredentialSources.setting(:extensions, :llm, :vertex)
+          return unless cfg.is_a?(Hash)
+
+          named = cfg[:instances] || cfg['instances']
+          return unless named.is_a?(Hash)
+
+          named.each do |name, config|
+            next unless config.is_a?(Hash) && vertex_credentials_present?(config)
+
+            instances[name.to_sym] = config.merge(tier: :cloud)
+          end
+        end
+
+        def self.vertex_credentials_present?(cfg)
+          project = cfg[:project] || cfg['project']
+          return false if project.nil? || project.to_s.strip.empty?
+
+          token = cfg[:access_token] || cfg['access_token']
+          creds = cfg[:credentials] || cfg['credentials']
+          !(token.nil? && creds.nil?)
+        end
+
+        private_class_method :discover_default_instance, :discover_named_instances, :vertex_credentials_present?
       end
     end
   end
 end
 
-Legion::Extensions::Llm::Provider.register(Legion::Extensions::Llm::Vertex::PROVIDER_FAMILY,
-                                           Legion::Extensions::Llm::Vertex::Provider)
+Legion::Extensions::Llm::Configuration.register_provider_options(
+  Legion::Extensions::Llm::Vertex::Provider.configuration_options
+)
+
+Legion::Extensions::Llm::Vertex.register_discovered_instances

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-vertex
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - LegionIO
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.3.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.1.5
+        version: 0.3.0
 description: Google Cloud Vertex AI provider integration for the LegionIO LLM routing
   framework.
 email:
@@ -85,10 +85,6 @@ files:
 - lex-llm-vertex.gemspec
 - lib/legion/extensions/llm/vertex.rb
 - lib/legion/extensions/llm/vertex/provider.rb
-- lib/legion/extensions/llm/vertex/registry_event_builder.rb
-- lib/legion/extensions/llm/vertex/registry_publisher.rb
-- lib/legion/extensions/llm/vertex/transport/exchanges/llm_registry.rb
-- lib/legion/extensions/llm/vertex/transport/messages/registry_event.rb
 - lib/legion/extensions/llm/vertex/version.rb
 homepage: https://github.com/LegionIO/lex-llm-vertex
 licenses:

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

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Vertex
-        # Builds sanitized lex-llm registry envelopes for Vertex provider state.
-        class RegistryEventBuilder
-          include Legion::Logging::Helper
-
-          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 offering_available(offering, readiness:)
-            registry_event_class.available(
-              offering,
-              runtime: runtime_metadata,
-              health: offering_health(readiness),
-              metadata: offering_metadata
-            )
-          end
-
-          private
-
-          def provider_offering(readiness)
-            {
-              provider_family: :vertex,
-              provider_instance: provider_instance,
-              transport: :http,
-              model: 'provider-readiness',
-              usage_type: :inference,
-              capabilities: [],
-              health: readiness_health(readiness),
-              metadata: { lex: :llm_vertex, provider_readiness: true }
-            }
-          end
-
-          def readiness_health(readiness)
-            health = {
-              ready: readiness[:ready] == true,
-              status: readiness[:ready] ? :available : :unavailable,
-              checked: readiness[:checked] != false
-            }
-            add_readiness_error(health, readiness)
-          end
-
-          def add_readiness_error(health, source)
-            error_class = source[:error] || source['error']
-            error_message = source[:message] || source['message']
-            health[:error_class] = error_class if error_class
-            health[:error] = error_message if error_message
-            health
-          end
-
-          def offering_health(readiness)
-            ready = readiness.fetch(:ready, true) == true
-            { ready:, status: ready ? :available : :degraded, checked: readiness[:checked] != false }
-          end
-
-          def readiness_metadata(readiness)
-            {
-              extension: :lex_llm_vertex,
-              provider: :vertex,
-              configured: readiness[:configured] == true,
-              live: readiness[:live] == true
-            }
-          end
-
-          def offering_metadata
-            { extension: :lex_llm_vertex, provider: :vertex }
-          end
-
-          def runtime_metadata
-            { node: provider_instance }
-          end
-
-          def provider_instance
-            :vertex
-          end
-
-          def registry_event_class
-            ::Legion::Extensions::Llm::Routing::RegistryEvent
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Legion
-  module Extensions
-    module Llm
-      module Vertex
-        # Best-effort publisher for Vertex provider availability events.
-        class RegistryPublisher
-          include Legion::Logging::Helper
-
-          APP_ID = 'lex-llm-vertex'
-
-          def initialize(builder: RegistryEventBuilder.new)
-            @builder = builder
-          end
-
-          def publish_readiness_async(readiness)
-            log.info { 'publishing readiness event to llm.registry' }
-            schedule { publish_event(@builder.readiness(readiness)) }
-          end
-
-          def publish_offerings_async(offerings, readiness:)
-            log.info { "publishing #{Array(offerings).size} offering event(s) to llm.registry" }
-            schedule do
-              Array(offerings).each do |offering|
-                publish_event(@builder.offering_available(offering, 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
-              handle_exception(e, level: :debug, handled: true, operation: 'vertex.registry.schedule_thread')
-            end
-          rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'vertex.registry.schedule')
-            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
-            handle_exception(e, level: :warn, handled: true, operation: 'vertex.registry.publish_event')
-            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 => e
-            handle_exception(e, level: :debug, handled: true, operation: 'vertex.registry.publishing_available?')
-            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/vertex/transport/messages/registry_event'
-            message_class_defined?
-          rescue LoadError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'vertex.registry.transport_load')
-            false
-          end
-
-          def message_class_defined?
-            defined?(::Legion::Extensions::Llm::Vertex::Transport::Messages::RegistryEvent)
-          end
-
-          def message_class
-            ::Legion::Extensions::Llm::Vertex::Transport::Messages::RegistryEvent
-          end
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require 'legion/extensions/llm/vertex/transport/exchanges/llm_registry'
-
-module Legion
-  module Extensions
-    module Llm
-      module Vertex
-        module Transport
-          module Messages
-            # Publishes lex-llm RegistryEvent envelopes to the llm.registry exchange.
-            class RegistryEvent < ::Legion::Transport::Message
-              include Legion::Logging::Helper
-
-              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