lex-llm-vertex 0.2.10 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25083d8e7cc928d57127feab13406395a6600421913559042fecfe7e2a376267
-  data.tar.gz: '028cb717f3299a2683bdd0ed10cc59f91a75f3de5f773d730ec75e2374762170'
+  metadata.gz: b1b2e665277fea3299658b992eac2b441a363e3c81dbf87d69e86c7328c6c99c
+  data.tar.gz: d81b38ce8e5e797a074d30a670a5e6fa9bcb92762c5dcd066ed86ad8196d5340
 SHA512:
-  metadata.gz: 69f44a1e8ac1d5d0da6b9e4ca5b5d5f7f0fba37b49021e5a512db86884958a89abd20323c336b9292c1973fb47e303d37b715322aaf37da75ab1f3d5da33a48f
-  data.tar.gz: 53cb2cfeb3039b78ca84722943e220178b6a7c1a060972ca329aacd4acb742bac4e4a581d9df819fa1902f315ca73858d9401d29ec08318c7ce0290899b11fc7
+  metadata.gz: 97009f1dd75f9f053ec06dfba726627f7c6202f92bb56a0185e9250d7579ff73de1c7c410b3ae6a82b4ad308032384362a0dd5c12ed2eeddc30e3c690d381753
+  data.tar.gz: 2f36d16c24610e1355ee50cdeb26e99818e8a1b7cc6441b9ef88f7e0d17130bd8691bba88e8db3c71bc3becd33a1abe5962ee65802a957abdcc6dec7bc4f839d

data/CHANGELOG.md

@@ -1,5 +1,37 @@
 # Changelog
 
+## [0.2.15] - 2026-06-20
+
+### Changed
+- Align Vertex offerings to the current `lex-llm` contract: shared `discover_offerings` now rebuilds
+  resource-name offerings from discovered models, preserves provider health on offerings, and keeps the
+  shared capability-override path intact.
+- Fix the provider tail introduced during the contract refactor so the provider file closes cleanly again.
+
+## [0.2.14] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
+## 0.2.13 - 2026-06-16
+
+- Dependency updates and code quality improvements.
+
+## 0.2.12 - 2026-06-15
+
+- **CapabilityPolicy integration** — Model-family heuristics tagged as `:provider_catalog`; Vertex features as `:model_metadata`. Settings overrides at provider/instance/model level supported.
+
+## 0.2.11 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **Dependency bump** — Require `lex-llm >= 0.5.0` for canonical types support.
+- **Canonical tool support** — Use `ToolSchema.extract` and add `:tools` capability.
+- **Bug fix** — Handle Array tool_calls in `tool_call_parts`.
+- 29 examples, 0 failures; 13 files, 0 rubocop offenses.
+
 ## 0.2.10 - 2026-06-02
 
 - Add per-provider scoped discovery refresh actor

data/Gemfile

@@ -2,13 +2,6 @@
 
 source 'https://rubygems.org'
 
-group :test do
-  llm_base_path = ENV.fetch('LEX_LLM_PATH', File.expand_path('../lex-llm', __dir__))
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-  gem 'lex-llm', path: llm_base_path if File.directory?(llm_base_path)
-end
-
 gemspec
 
 group :development do

data/lex-llm-vertex.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.4.3'
+  spec.add_dependency 'lex-llm', '>= 0.6.0'
 end

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

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
   warn(e.message) if $VERBOSE
 end
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 return unless defined?(Legion::Extensions::Actors::Every)
 
 module Legion
@@ -16,7 +24,11 @@ module Legion
           class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
             include Legion::Logging::Helper
 
-            REFRESH_INTERVAL = 1800
+            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            end
+
+            def self.every_seconds = 3600
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -26,16 +38,106 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
 
-              Legion::Settings.dig(:extensions, :llm, :vertex, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :vertex, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
-              log.debug('[vertex][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def scope_key
+              { provider: :vertex }
+            end
+
+            def compute_lanes_for_scope(**)
+              return [] unless defined?(Legion::LLM::Call::Registry)
+
+              settings      = Legion::Settings.dig(:extensions, :llm, :vertex) || {}
+              fleet_enabled = settings.dig(:fleet, :dispatch, :enabled)
+              instances     = Legion::LLM::Call::Registry.all_instances.select do |e|
+                (e[:provider] || '').to_sym == :vertex
+              end
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :vertex)
+              instances.flat_map do |entry|
+                lanes_for_instance(entry, fleet_enabled: fleet_enabled)
+              end
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'vertex.actor.compute_lanes_for_scope')
+              []
+            end
+
+            private
+
+            def lanes_for_instance(entry, fleet_enabled: false)
+              adapter     = entry[:adapter]
+              instance_id = entry[:instance] || entry[:instance_id] || entry[:id]
+              lanes       = []
+              Array(adapter.discover_offerings(live: false)).each do |raw_offering|
+                offering = offering_to_hash(raw_offering)
+                next unless offering
+
+                lane = build_lane(offering, instance_id)
+                lanes << lane
+                lanes << fleet_lane(lane, instance_id, offering) if fleet_enabled && lane[:type] == :inference
+              end
+              lanes
+            end
+
+            def offering_to_hash(offering)
+              return nil if offering.nil?
+              return offering if offering.is_a?(Hash)
+
+              hash = offering.to_h
+              hash[:type] ||= hash[:usage_type]
+              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
+              hash
+            end
+
+            def build_lane(offering, instance_id)
+              type  = offering_type(offering)
+              tier  = offering[:tier]&.to_sym || :cloud
+              caps  = normalize_capabilities(offering[:capabilities])
+              flds  = { tier: tier, provider_family: :vertex, instance_id: instance_id,
+                        type: type, model: offering[:model] }
+              {
+                id: Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(flds),
+                tier: tier,
+                provider_family: :vertex,
+                instance_id: instance_id,
+                model: offering[:model],
+                canonical_model_alias: offering[:canonical_model_alias],
+                type: type,
+                capabilities: caps,
+                limits: offering[:limits] || {},
+                enabled: offering.fetch(:enabled, true),
+                cost: offering[:cost] || {}
+              }
+            end
+
+            def fleet_lane(lane, instance_id, offering)
+              flds = { tier: :fleet, provider_family: :vertex, instance_id: instance_id,
+                       type: lane[:type], model: offering[:model] }
+              lane.merge(id: Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(flds), tier: :fleet)
+            end
+
+            def offering_type(offering)
+              %i[embed embedding].include?(offering[:type]&.to_sym) ? :embedding : :inference
+            end
+
+            def normalize_capabilities(caps)
+              return [] unless defined?(Legion::Extensions::Llm::Inventory::Capabilities) &&
+                               Legion::Extensions::Llm::Inventory::Capabilities.respond_to?(:normalize)
+
+              Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+            end
+
+            public
+
+            def credential_hash(**)
+              settings = Legion::Settings.dig(:extensions, :llm, :vertex) || {}
+              ::Digest::SHA256.hexdigest(settings[:api_key].to_s + settings[:instances].to_s)[0, 16]
+            end
+
+            def manual
+              tick if respond_to?(:tick)
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'vertex.actor.discovery_refresh')
             end

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

@@ -116,7 +116,7 @@ module Legion
             "#{publisher_model_path(model)}:#{suffix}"
           end
 
-          def list_models(**)
+          def list_models(**_filters)
             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" }
@@ -125,22 +125,13 @@ module Legion
           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'] || []
-            offerings = models.filter_map do |model|
-              offering = offering_from_live_model(model)
-              model_id = offering.respond_to?(:model) ? offering.model : (offering[:model] || offering[:id])
-              next unless model_allowed?(model_id.to_s)
-
-              offering
+            unless live
+              return static_offerings(**filters).select do |offering|
+                model_allowed?(short_model_id(offering.model))
+              end
             end
-            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
+
+            super
           end
 
           def offering_for(model:, model_family: nil, instance_id: :default, **metadata)
@@ -325,8 +316,50 @@ module Legion
             offering_for(model: id, publisher:, metadata: model)
           end
 
+          def offering_from_model(model_info, health: {})
+            metadata = model_info.respond_to?(:metadata) ? model_info.metadata.to_h : {}
+            raw_model = model_info.respond_to?(:id) ? model_info.id : model_info
+            publisher = metadata[:publisher] || metadata['publisher'] || publisher_for(raw_model)
+            api = metadata[:api] || metadata['api'] || api_for(raw_model)
+            alias_name = model_info.respond_to?(:name) ? model_info.name : nil
+            alias_name = nil if alias_name.to_s.empty? || alias_name.to_s == raw_model.to_s
+
+            build_offering(
+              model: resource_name(raw_model, publisher: publisher),
+              alias_name: alias_name,
+              model_family: if model_info.respond_to?(:family) && model_info.family
+                              model_info.family.to_sym
+                            else
+                              model_family_for(
+                                raw_model, publisher
+                              )
+                            end,
+              instance_id: if model_info.respond_to?(:instance)
+                             model_info.instance || provider_instance_id
+                           else
+                             provider_instance_id
+                           end,
+              publisher: publisher,
+              usage_type: if model_info.respond_to?(:embedding?) && model_info.embedding?
+                            :embedding
+                          else
+                            usage_type_for(raw_model)
+                          end,
+              api: api,
+              health: health,
+              metadata: metadata.merge(
+                limits: {
+                  context_window: model_info.respond_to?(:context_length) ? model_info.context_length : nil,
+                  max_output_tokens: model_info.respond_to?(:max_output_tokens) ? model_info.max_output_tokens : nil
+                }.compact
+              )
+            )
+          end
+
           def build_offering(model:, model_family:, usage_type:, publisher:, api:, instance_id: :default,
-                             alias_name: nil, metadata: {})
+                             alias_name: nil, health: {}, metadata: {})
+            policy = resolve_capability_policy(model, api:, metadata:, instance_id:)
+
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :vertex,
               instance_id: instance_id,
@@ -334,8 +367,10 @@ module Legion
               tier: offering_tier,
               model: model,
               usage_type: usage_type,
-              capabilities: default_capabilities(model, api:),
+              capabilities: base_capabilities(model, api:) + policy[:capabilities],
+              capability_sources: policy[:sources],
               limits: metadata.delete(:limits) || {},
+              health: health,
               metadata: metadata.merge(
                 model_family: model_family,
                 alias: alias_name,
@@ -478,7 +513,9 @@ module Legion
           end
 
           def tool_call_parts(message)
-            message.tool_calls.values.map do |tool_call|
+            # Array is canonical (name-keyed hashes dropped parallel same-name calls)
+            calls = message.tool_calls.is_a?(Hash) ? message.tool_calls.values : Array(message.tool_calls)
+            calls.map do |tool_call|
               { functionCall: { name: tool_call.name, args: tool_call.arguments } }
             end
           end
@@ -497,9 +534,11 @@ module Legion
 
             [{
               functionDeclarations: tools.values.map do |tool|
-                declaration = { name: tool.name, description: tool.description }
-                declaration[:parameters] = tool.params_schema if tool.respond_to?(:params_schema) && tool.params_schema
-                declaration
+                {
+                  name: Legion::Extensions::Llm::Canonical::ToolSchema.tool_name(tool),
+                  description: Legion::Extensions::Llm::Canonical::ToolSchema.tool_description(tool),
+                  parameters: Legion::Extensions::Llm::Canonical::ToolSchema.extract(tool)
+                }
               end
             }]
           end
@@ -623,15 +662,109 @@ module Legion
           end
 
           def default_capabilities(model, api:)
+            base_capabilities(model, api:) + policy_optional_capabilities(model, api:)
+          end
+
+          def base_capabilities(model, api:)
             return %i[embedding] if Capabilities.embeddings?(model)
 
             capabilities = %i[chat]
             capabilities << :streaming if %i[generate_content raw_predict].include?(api)
-            capabilities << :vision if Capabilities.vision?(model)
-            capabilities << :functions if generate_content_model?(model)
             capabilities
           end
 
+          def policy_optional_capabilities(model, api:)
+            return [] if Capabilities.embeddings?(model)
+
+            caps = []
+            caps << :vision if Capabilities.vision?(model)
+            caps << :tools if generate_content_model?(model) && api == :generate_content
+            caps
+          end
+
+          def resolve_capability_policy(model, api:, metadata:, instance_id:)
+            provider_catalog = capability_catalog_for(model, api:)
+            real_caps = capability_real_for(metadata)
+            provider_cfg = vertex_provider_config
+            instance_cfg = vertex_instance_config(instance_id)
+            model_cfg = vertex_model_config(model)
+
+            Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: real_caps,
+              provider_catalog: provider_catalog,
+              probe: {},
+              provider_envelope: {},
+              provider_config: provider_cfg,
+              instance_config: instance_cfg,
+              model_config: model_cfg
+            )
+          end
+
+          def capability_catalog_for(model, api:)
+            return {} if Capabilities.embeddings?(model)
+
+            catalog = {}
+            catalog[:vision] = Capabilities.vision?(model)
+            catalog[:tools] = api == :generate_content
+            catalog[:streaming] = %i[generate_content raw_predict].include?(api)
+            catalog
+          end
+
+          def capability_real_for(metadata)
+            return {} unless metadata.is_a?(Hash)
+
+            features = metadata[:supportedFeatures] || metadata['supportedFeatures']
+            return {} unless features.is_a?(Hash)
+
+            real = {}
+            real[:tools] = features['functionCalling'] if features.key?('functionCalling')
+            real[:vision] = features['multimodalInput'] if features.key?('multimodalInput')
+            real[:thinking] = features['thinking'] if features.key?('thinking')
+            real
+          end
+
+          def vertex_provider_config
+            cfg = CredentialSources.setting(:extensions, :llm, :vertex)
+            return {} unless cfg.is_a?(Hash)
+
+            cfg.except(:instances, 'instances')
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'vertex.provider.capability_policy_config')
+            {}
+          end
+
+          def vertex_instance_config(instance_id)
+            cfg = CredentialSources.setting(:extensions, :llm, :vertex)
+            return {} unless cfg.is_a?(Hash)
+
+            instances = cfg[:instances] || cfg['instances']
+            return {} unless instances.is_a?(Hash)
+
+            (instances[instance_id] || instances[instance_id.to_s] || {}).to_h
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'vertex.provider.instance_config')
+            {}
+          end
+
+          def vertex_model_config(model)
+            cfg = CredentialSources.setting(:extensions, :llm, :vertex)
+            return {} unless cfg.is_a?(Hash)
+
+            models = cfg[:models] || cfg['models']
+            return {} unless models.is_a?(Hash)
+
+            id = short_model_id(model)
+            (models[id.to_sym] || models[id.to_s] || {}).to_h
+          rescue StandardError => e
+            handle_exception(e, level: :warn, handled: true, operation: 'vertex.provider.model_config')
+            {}
+          end
+
+          def short_model_id(model)
+            id = model_id(model)
+            id.include?('/') ? id.split('/').last : id
+          end
+
           def bearer_token
             token = config.vertex_access_token
             token ? "Bearer #{token}" : nil

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Vertex
-        VERSION = '0.2.10'
+        VERSION = '0.2.15'
       end
     end
   end

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

@@ -3,6 +3,7 @@
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/vertex/provider'
 require 'legion/extensions/llm/vertex/version'
+require_relative 'vertex/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -39,10 +40,7 @@ module Legion
               fleet: {
                 enabled: false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat embed],
-                lanes: [],
-                concurrency: 4,
-                queue_suffix: nil
+                capabilities: %i[chat stream_chat embed tools]
               }
             }
           )
@@ -103,12 +101,7 @@ module Legion
         end
 
         def self.register_provider_options
-          configuration = Legion::Extensions::Llm::Configuration
-          if configuration.respond_to?(:register_provider_options)
-            configuration.register_provider_options(Provider.configuration_options)
-          elsif configuration.respond_to?(:option, true)
-            Provider.configuration_options.each { |key| configuration.send(:option, key) }
-          end
+          Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)
         end
 
         private_class_method :discover_default_instance, :discover_named_instances, :vertex_credentials_present?,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-vertex
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.15
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.6.0
 description: Google Cloud Vertex AI provider integration for the LegionIO LLM routing
   framework.
 email: