lex-llm-vertex 0.2.10 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 25083d8e7cc928d57127feab13406395a6600421913559042fecfe7e2a376267
-  data.tar.gz: '028cb717f3299a2683bdd0ed10cc59f91a75f3de5f773d730ec75e2374762170'
+  metadata.gz: 31112ce3580ae2a99c27285cbc5385d742faf52f4aaa854212802254c423112a
+  data.tar.gz: 64ba36b8b97732e2d2b63605e2f7edb33f82b42065f5f79d8c2328d0dd3e3b35
 SHA512:
-  metadata.gz: 69f44a1e8ac1d5d0da6b9e4ca5b5d5f7f0fba37b49021e5a512db86884958a89abd20323c336b9292c1973fb47e303d37b715322aaf37da75ab1f3d5da33a48f
-  data.tar.gz: 53cb2cfeb3039b78ca84722943e220178b6a7c1a060972ca329aacd4acb742bac4e4a581d9df819fa1902f315ca73858d9401d29ec08318c7ce0290899b11fc7
+  metadata.gz: 924fe07b104555a416524b8d7e9994e0a09e6051e307034161d485d285cad2bd44c7cc26653420cfee4d629e757b6cdbd02088d2c375e032c437eb660fd7a28d
+  data.tar.gz: a1467f3de89eba4f4cc7e852e49f33153fe8caa79878a2da1b57e147a95a50a8122a1b1c60ab018cbb90e12c6b2a7c0b774dc9962f0288815b7e871fae6fdcc6

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 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.5.0'
 end

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

@@ -36,6 +36,13 @@ module Legion
               return unless defined?(Legion::LLM::Discovery)
 
               Legion::LLM::Discovery.refresh_discovered_models!(provider: :vertex)
+
+              if defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:populate_auto_rules)
+                Legion::LLM::Router.populate_auto_rules(Legion::LLM::Discovery.discovered_instances)
+              end
+              if defined?(Legion::LLM::Inventory) && Legion::LLM::Inventory.respond_to?(:invalidate_offerings_cache!)
+                Legion::LLM::Inventory.invalidate_offerings_cache!
+              end
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'vertex.actor.discovery_refresh')
             end

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

@@ -327,6 +327,8 @@ module Legion
 
           def build_offering(model:, model_family:, usage_type:, publisher:, api:, instance_id: :default,
                              alias_name: nil, metadata: {})
+            policy = resolve_capability_policy(model, api:, metadata:, instance_id:)
+
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :vertex,
               instance_id: instance_id,
@@ -334,7 +336,8 @@ 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) || {},
               metadata: metadata.merge(
                 model_family: model_family,
@@ -478,7 +481,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 +502,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 +630,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: :debug, 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: :debug, 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: :debug, 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.13'
       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.13
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.4.3
+        version: 0.5.0
 description: Google Cloud Vertex AI provider integration for the LegionIO LLM routing
   framework.
 email: