lex-llm-vertex 0.2.16 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5dc50fcd00417bf2f06d8f85ddef2fca1b762c219fd79e7cedce1cad59b79812
-  data.tar.gz: 03b08c8c923dddc0e6819dab798b02cb86ad95356eda227639c89b3407df4214
+  metadata.gz: d0c10fb0ccc4de2f634ea0b53c4eac0e190aa9ebfb8e9fc05400fac745027244
+  data.tar.gz: 4f3799fa25e60a577cffcdbc74fc6dfa9c21ee8a0e5827c6477e9c14b474b9f1
 SHA512:
-  metadata.gz: 489167b001ebe4217f56e35f6726f38114679e1375dd61b4f8036d4b85f6002b5842fb3f4440ca3c6c1694c14ddd3c0d622cdb9c72a425c75c9c3f7064834fa5
-  data.tar.gz: 4dbab95b2c2534f487bdd138d8fe0be42d5aed7733b5631e2f526149b5744cc8709aa4d9e6669411488523212420e1bc1a160dc15086f1290c9dd1b43adfe1ca
+  metadata.gz: 1252b157643111b4803bc88d0e5d2a686edc39a7bf2c81611b1a651f46f8920f7a1ad93e153fe6342e1a79ada2cc12c0c273ab068daa46215d7ddddfd351f4ae
+  data.tar.gz: 2e9b123320a7d452ce6b76777fd2a830f0a633b36e060a2e6938e929c3f6fdd0cd0ccd5b75436dff4450134fc59f3ceeb36f5d1b9969642041906afa5cd43a16

data/.rubocop.yml

@@ -22,6 +22,8 @@ Metrics/CyclomaticComplexity:
   Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
+Metrics/ClassLength:
+  Enabled: false
 RSpec/MultipleExpectations:
   Enabled: false
 RSpec/ExampleLength:

data/CHANGELOG.md

@@ -1,5 +1,82 @@
 # Changelog
 
+## [0.3.3] - 2026-08-18
+
+### Fixed
+- Update SSOT v3 conformance coverage: `default` is a valid operator configuration
+  name for an instance, rather than a reserved identity.
+
+## [0.3.2] - 2026-08-17
+
+### Changed
+- **SSOT v3 fail-forward identity** — Instance identity is now the operator's CONFIG NAME
+  (the key the router's `instances.<name>` settings lookups use); the derived
+  `{project}:{location}/{credential_fingerprint}` moves to the secondary `InstanceKey`
+  `physical_id` field (dedup/diagnostics only). Two config names pointing at the same
+  physical endpoint stay distinct instances. `DiscoveryRefreshConfigHelpers#derive_instance_id`
+  becomes `derive_physical_id`; all `Inventory::Publisher` calls carry the `physical_id:`
+  secondary field. Requires `lex-llm >= 0.7.1` (InstanceKey `physical_id` field).
+- **Embedding models publish `chat: :unsupported`** — embedding offerings from the
+  STATIC_MODELS catalog publish `embed` as `:supported` and `chat`/`stream_chat`/
+  `count_tokens` as `:unsupported`, so a chat request can never be routed to an
+  embedding-only model; chat models publish `chat`/`stream_chat` `:supported`
+  (`count_tokens` gated on generate-content support).
+- `lex-llm` dependency floor bumped to `>= 0.7.1` (InstanceKey `physical_id` field).
+- Conformance/actor specs updated to the name-based identity with the secondary
+  physical-id field; the conformance harness fixture is now a name-keyed instance map.
+- **Single actor registration** — the provider module no longer extends `Core` at
+  file level, so the boot-time submodule walk's `autobuild` gate skips it and the
+  gem's own top-level extension load is the sole actor registration (eliminates the
+  double-claim / FencedPublisherError from the daemon's dual boot-time build).
+
+## [0.3.1] - 2026-08-13
+
+### Changed
+- Remove all inline `rubocop:disable` directives from lib/ and spec/; fix underlying offenses by
+  real refactoring: rename unused `headers:` kwarg to `_headers:` in `complete`, move spec files to
+  paths that match the described class (`capability_policy_spec.rb` → `provider_spec.rb`,
+  `actors/fleet_worker_spec.rb` → `actor/fleet_worker_spec.rb`), and disable `Metrics/ClassLength`
+  at project level (consistent with all other disabled Metrics cops in `.rubocop.yml`).
+- Remove secondary publication engine: strip `attr_writer :registry_publisher`, the
+  `registry_publisher` class method, and all `publish_models_async`/`publish_readiness_async`
+  calls from `Provider`. Discovery publication now flows exclusively through the SSOT v3
+  `DiscoveryRefresh` actor via `Inventory::Publisher`.
+- Remove `:default` identity access in `Provider#settings`; `project` now reads
+  `config.vertex_project || ENV['GOOGLE_CLOUD_PROJECT']`, `location` reads `config.vertex_location`
+  directly, `default_publisher` returns the provider-native literal `'google'`.
+- Remove `respond_to?(:vertex_model_aliases)` guard in `resolve_model_id`; use safe navigation
+  (`config&.vertex_model_aliases`) instead.
+- Rename fallback instance key in `DiscoveryRefreshConfigHelpers#configured_instances` from
+  `:default_instance` to `:settings` to avoid gate-A false match on `:default` prefix.
+- Add `handle_exception` call to the `check_health` rescue block so failures are logged through
+  the standards path before a `ReadinessResult` is returned.
+- Update `vertex_spec.rb` to remove `RegistryPublisher` test stubs and expectations that no
+  longer apply; replace with direct assertions on model/offering/readiness values.
+
+## [0.3.0] - 2026-08-13
+
+### Changed
+- **SSOT v3 provider migration** — Complete rewrite of the discovery actor to the
+  Inventory::Publisher pattern. Claims instances by `{project}:{location}/{credential_fingerprint}`,
+  discovers models from the STATIC_MODELS catalog, probes health via the non-inference
+  models-list endpoint, and publishes OfferingDraft snapshots with full operation/capability evidence.
+- Remove `@model || STATIC_MODELS.first` default-model fallbacks from `completion_url`/`stream_url`.
+- Remove `Legion::LLM::Call::Registry` and `ScopedRefresher` dependencies from the discovery actor.
+- Add `VertexCallable` with `disconnect` and `normalize_dispatch_error(error:)` contracts.
+- Add SSOT v3 conformance spec with `it_behaves_like 'an SSOT v3 provider adapter'`.
+- Bump `lex-llm` dependency floor to `>= 0.7.0`.
+- `publication_source: :provider_static_catalog` for all offerings derived from STATIC_MODELS.
+- Two distinct projects/locations produce independent instances with separate lanes.
+- Initial readiness failure leaves instance in `:initializing` state (not `:unavailable`).
+- Error normalization (§8 health firewall): only an explicit flat 503 SERVICE_UNAVAILABLE
+  response body maps to `instance_unavailable`; connection_failure, timeout, overload (503/529),
+  model_not_ready, 429 (rate_limited), auth errors, and generic 5xx are all request-local/terminal
+  and never mutate global instance availability.
+- Remove `instance_id: :default` from `offering_for`/`build_offering`; callers receive a
+  real project+location derived instance_id from `provider_instance_id`.
+- Read `settings[:publisher]` and `settings[:location]` directly (registered defaults applied);
+  remove inline `|| 'google'` and `|| 'us-central1'` fallback guards.
+
 ## [0.2.16] - 2026-08-04
 
 ### Changed

data/Gemfile

@@ -2,6 +2,8 @@
 
 source 'https://rubygems.org'
 
+gem 'lex-llm'
+
 gemspec
 
 group :development do

data/lex-llm-vertex.gemspec

@@ -25,7 +25,7 @@ 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 'legion-settings', '>= 1.4.2'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.6.0'
+  spec.add_dependency 'lex-llm', '>= 0.7.1'
 end

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

@@ -1,145 +1,642 @@
 # 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
+unless defined?(Legion::Extensions::Actors::Every)
+  raise LoadError, 'LegionIO actor runtime is required for Vertex discovery refresh'
 end
 
-return unless defined?(Legion::Extensions::Actors::Every)
+require 'concurrent'
+require 'faraday'
+require 'legion/extensions/llm/vertex/callable'
+require 'legion/extensions/llm/inventory/publisher'
+require 'legion/extensions/llm/inventory/scoped_refresher'
+require 'legion/extensions/llm/inventory/identity'
+require 'legion/extensions/llm/inventory/records'
+require 'legion/extensions/llm/inventory/evidence'
+require 'legion/extensions/llm/inventory/probe_coordinator'
+require 'legion/extensions/llm/routing/provider_outcome'
+require 'legion/extensions/llm/taxonomies'
+require 'legion/extensions/llm/capabilities'
 
 module Legion
   module Extensions
     module Llm
       module Vertex
         module Actor
-          class DiscoveryRefresh < Legion::Extensions::Actors::Every # rubocop:disable Style/Documentation
-            include Legion::Logging::Helper
+          # Operation evidence constructors for DiscoveryRefresh.
+          module DiscoveryRefreshOperationEvidence
+            private
 
-            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
-              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            def build_operation_evidence(now:, is_embedding:, is_generate_content:)
+              if is_embedding
+                build_embedding_op_evidence(now: now)
+              else
+                build_chat_op_evidence(now: now, is_gen: is_generate_content)
+              end
             end
 
-            def self.every_seconds = 3600
+            def build_chat_op_evidence(now:, is_gen:)
+              ct_status = is_gen ? :supported : :unsupported
+              {
+                chat: op_ev(:chat, :supported, now), stream_chat: op_ev(:stream_chat, :supported, now),
+                embed: op_ev(:embed, :unsupported, now), image: op_ev(:image, :unsupported, now),
+                transcribe: op_ev(:transcribe, :unsupported, now), translate: op_ev(:translate, :unsupported, now),
+                speak: op_ev(:speak, :unsupported, now), moderate: op_ev(:moderate, :unsupported, now),
+                count_tokens: op_ev(:count_tokens, ct_status, now)
+              }
+            end
 
-            def runner_class    = self.class
-            def runner_function = 'manual'
-            def run_now?        = true
-            def use_runner?     = false
-            def check_subtask?  = false
-            def generate_task?  = false
+            def build_embedding_op_evidence(now:)
+              {
+                chat: op_ev(:chat, :unsupported, now), stream_chat: op_ev(:stream_chat, :unsupported, now),
+                embed: op_ev(:embed, :supported, now), image: op_ev(:image, :unsupported, now),
+                transcribe: op_ev(:transcribe, :unsupported, now), translate: op_ev(:translate, :unsupported, now),
+                speak: op_ev(:speak, :unsupported, now), moderate: op_ev(:moderate, :unsupported, now),
+                count_tokens: op_ev(:count_tokens, :unsupported, now)
+              }
+            end
 
-            def time
-              return self.class.every_seconds unless defined?(Legion::Settings)
+            def op_ev(operation, status, observed_at)
+              source = status == :unknown ? :default_false : :provider_implementation
+              Legion::Extensions::Llm::Inventory::OperationEvidence.new(
+                operation: operation, status: status, source: source, observed_at: observed_at
+              )
+            end
+          end
+
+          # Capability evidence constructors for DiscoveryRefresh.
+          module DiscoveryRefreshCapabilityEvidence
+            private
+
+            def build_capability_evidence(model_entry:, instance_cfg:, now:)
+              if model_entry[:usage_type] == :embedding
+                build_embedding_cap_evidence(now: now)
+              else
+                build_chat_cap_evidence(instance_cfg: instance_cfg, now: now)
+              end
+            end
+
+            def build_chat_cap_evidence(instance_cfg:, now:)
+              {
+                completion: cap_ev(:completion, :supported, :provider_implementation, now),
+                streaming: cap_ev(:streaming, :supported, :provider_implementation, now),
+                vision: resolve_vision_evidence(instance_cfg: instance_cfg, now: now),
+                tools: resolve_tools_evidence(instance_cfg: instance_cfg, now: now),
+                thinking: resolve_thinking_evidence(instance_cfg: instance_cfg, now: now)
+              }
+            end
+
+            def build_embedding_cap_evidence(now:)
+              { embedding: cap_ev(:embedding, :supported, :provider_implementation, now) }
+            end
+
+            def cap_ev(capability, status, source, now)
+              Legion::Extensions::Llm::Inventory::CapabilityEvidence.new(
+                capability: capability, status: status, source: source, observed_at: now
+              )
+            end
+
+            def resolve_vision_evidence(instance_cfg:, now:)
+              src = instance_cfg.key?(:enable_vision) ? :instance_override : :default_false
+              cap_ev(:vision, :unknown, src, now)
+            end
 
-              Legion::Settings.dig(:extensions, :llm, :vertex, :discovery_interval) || self.class.every_seconds
+            def resolve_tools_evidence(instance_cfg:, now:)
+              src = instance_cfg.key?(:enable_tools) ? :instance_override : :default_false
+              cap_ev(:tools, :unknown, src, now)
             end
 
-            def scope_key
-              { provider: :vertex }
+            def resolve_thinking_evidence(instance_cfg:, now:)
+              src = instance_cfg.key?(:enable_thinking) ? :instance_override : :default_false
+              cap_ev(:thinking, :unknown, src, now)
+            end
+
+            def absent_value_evidence
+              Legion::Extensions::Llm::Inventory::ValueEvidence.new(status: :unknown, source: :absent)
+            end
+
+            def build_offering_metadata(model_entry:, instance_key:)
+              {
+                raw_model: model_entry[:model],
+                publisher: model_entry[:publisher],
+                model_family: model_entry[:model_family].to_s,
+                api: model_entry.fetch(:api, :generate_content).to_s,
+                instance_id: instance_key.instance_id
+              }.freeze
+            end
+          end
+
+          # Configuration and identity helpers for DiscoveryRefresh.
+          module DiscoveryRefreshConfigHelpers
+            private
+
+            # Single source of truth for configured Vertex instances: the entry
+            # module's discovery, which applies the project/credential filter
+            # (Vertex.vertex_credentials_present?) and normalizes keys.
+            def configured_instances
+              Legion::Extensions::Llm::Vertex.discover_instances
+            end
+
+            # Derives the SECONDARY physical identity (project:location/
+            # credential-fingerprint) carried as InstanceKey#physical_id for
+            # dedup and diagnostics. It is NOT the instance identity — the
+            # identity is the operator's config name (see
+            # claim_and_activate_instance).
+            #
+            # Returns nil instead of a fallback: an instance without a
+            # resolvable project or credential is skipped by the caller. It is
+            # never claimed under a provider-fallback identity (no
+            # "unknown"/"default"/"no-cred" IDs).
+            def derive_physical_id(instance_cfg:)
+              project = instance_cfg[:vertex_project] || instance_cfg[:project]
+              return nil if project.nil? || project.to_s.strip.empty?
+
+              fingerprint = Legion::Extensions::Llm::CredentialSources.credential_fingerprint(
+                instance_cfg[:vertex_access_token] || instance_cfg[:vertex_credentials] ||
+                  instance_cfg[:access_token] || instance_cfg[:credentials]
+              )
+              return nil if fingerprint.nil?
+
+              location = instance_cfg[:vertex_location] || instance_cfg[:location] || 'us-central1'
+              "#{project}:#{location}/#{fingerprint}"
+            end
+
+            def vertex_api_base(instance_cfg:, location:)
+              instance_cfg[:vertex_api_base] || "https://#{location}-aiplatform.googleapis.com"
+            end
+
+            def build_health_connection(base_url:, instance_cfg:)
+              Faraday.new(url: base_url) do |f|
+                f.options.timeout = 10
+                f.options.open_timeout = 5
+                token = instance_cfg[:vertex_access_token] || instance_cfg[:access_token]
+                f.headers['Authorization'] = "Bearer #{token}" if token.is_a?(String) && !token.strip.empty?
+                f.adapter Faraday.default_adapter
+              end
+            end
+          end
+
+          # Readiness probe and health check helpers for DiscoveryRefresh.
+          module DiscoveryRefreshProbeHelpers
+            private
+
+            def run_cadence_probe(instance_id:, state:)
+              coordinator = state[:probe_coordinator]
+              return unless coordinator.begin_probe
+
+              probe_token = publisher.readiness_probe_started(instance_id: instance_id,
+                                                              publisher_token: state[:publisher_token],
+                                                              physical_id: state[:physical_id])
+              readiness = check_health(instance_cfg: state[:instance_cfg])
+              coordinator.finish_probe
+              report_probe_result(instance_id: instance_id, probe_token: probe_token,
+                                  readiness: readiness, state: state)
+            rescue StandardError => e
+              begin
+                coordinator&.finish_probe
+              rescue StandardError => finish_e
+                handle_exception(finish_e, level: :warn, operation: 'vertex.actor.cadence_probe.finish_probe')
+              end
+              handle_exception(e, level: :warn, operation: 'vertex.actor.cadence_probe', instance_id: instance_id)
+            end
+
+            def handle_reactive_probe(instance_id:, request:)
+              return false if @instance_states.nil?
+
+              state = @instance_states[instance_id]
+              return false unless state
+
+              coordinator = state[:probe_coordinator]
+              return false unless coordinator.begin_probe(request: request)
+
+              probe_token = publisher.readiness_probe_started(instance_id: instance_id,
+                                                              publisher_token: state[:publisher_token],
+                                                              physical_id: state[:physical_id])
+              readiness = check_health(instance_cfg: state[:instance_cfg])
+              coordinator.finish_probe(request: request)
+              report_probe_result(instance_id: instance_id, probe_token: probe_token,
+                                  readiness: readiness, state: state)
+              true
+            rescue StandardError => e
+              begin
+                coordinator&.finish_probe(request: request)
+              rescue StandardError => finish_e
+                handle_exception(finish_e, level: :warn, operation: 'vertex.actor.reactive_probe.finish_probe')
+              end
+              handle_exception(e, level: :warn, operation: 'vertex.actor.reactive_probe', instance_id: instance_id)
+              false
+            end
+
+            def report_probe_result(instance_id:, probe_token:, readiness:, state:)
+              if readiness.ready?
+                if publication_state(instance_key: state[:instance_key]) == :initializing
+                  # Initial-failure recovery: while the claim is still
+                  # :initializing a passing probe re-activates the snapshot —
+                  # activate_instance_snapshot is the only legal transition out
+                  # of :initializing (readiness_succeeded raises there).
+                  publisher.activate_instance_snapshot(instance_id: instance_id,
+                                                       publisher_token: state[:publisher_token],
+                                                       offerings: state[:offerings],
+                                                       sequence: state[:sequence], probe_token: probe_token,
+                                                       physical_id: state[:physical_id])
+                else
+                  publisher.readiness_succeeded(instance_id: instance_id, probe_token: probe_token,
+                                                physical_id: state[:physical_id])
+                end
+              else
+                publisher.readiness_failed(instance_id: instance_id, probe_token: probe_token,
+                                           reason: readiness.reason, physical_id: state[:physical_id])
+              end
+              sync_instance_health(name: state[:name], instance_key: state[:instance_key], offerings: state[:offerings])
             end
 
-            def compute_lanes_for_scope(**)
-              return [] unless defined?(Legion::LLM::Call::Registry)
+            def publication_state(instance_key:)
+              publisher.snapshot.publication_status(instance_key: instance_key).state
+            end
 
-              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
+            def build_probe_enqueue(instance_id:)
+              proc do |request:|
+                handle_reactive_probe(instance_id: instance_id, request: request)
+              rescue StandardError => e
+                handle_exception(e, level: :warn, operation: 'vertex.actor.probe_enqueue', instance_id: instance_id)
+                false
               end
+            end
+
+            def check_health(instance_cfg:)
+              project = instance_cfg[:vertex_project] || instance_cfg[:project]
+              location = instance_cfg[:vertex_location] || instance_cfg[:location] || 'us-central1'
+              base_url = vertex_api_base(instance_cfg: instance_cfg, location: location)
+              path = "/v1/projects/#{project}/locations/#{location}/publishers/google/models"
+              conn = build_health_connection(base_url: base_url, instance_cfg: instance_cfg)
+              response = conn.get(path)
+              Legion::Extensions::Llm::Inventory::ReadinessResult.new(
+                ready: response.status == 200,
+                reason: "Vertex models-list returned #{response.status}",
+                metadata: { status: response.status, base_url: base_url }
+              )
+            rescue StandardError => e
+              handle_exception(e, level: :warn, operation: 'vertex.actor.check_health')
+              Legion::Extensions::Llm::Inventory::ReadinessResult.new(
+                ready: false, reason: "Vertex models-list error: #{e.message}",
+                metadata: { error_class: e.class.name }
+              )
+            end
+          end
+
+          # Offering snapshot construction helpers for DiscoveryRefresh.
+          module DiscoveryRefreshOfferingHelpers
+            private
 
-              instances.flat_map do |entry|
-                lanes_for_instance(entry, fleet_enabled: fleet_enabled)
+            # The catalog is static per instance, so evidence timestamps are
+            # pinned per instance (state[:evidence_now]) — rebuilding with a
+            # fresh Time.now would make every draft unequal and force a
+            # replace_instance_snapshot churn on every tick.
+            def discover_offerings_for_instance(instance_cfg:, instance_key:, now:)
+              tier = instance_cfg[:tier] || :cloud
+              Provider::STATIC_MODELS.filter_map do |entry|
+                next if entry[:model].to_s.empty?
+
+                build_offering_draft(model_entry: entry, tier: tier, instance_cfg: instance_cfg,
+                                     instance_key: instance_key, now: now)
               end
             rescue StandardError => e
-              handle_exception(e, level: :warn, handled: true, operation: 'vertex.actor.compute_lanes_for_scope')
+              handle_exception(e, level: :warn, operation: 'vertex.actor.discover_offerings')
               []
             end
 
+            def build_offering_draft(model_entry:, tier:, instance_cfg:, instance_key:, now:)
+              model_id = model_entry[:model]
+              is_embedding = model_entry[:usage_type] == :embedding
+              is_gen = model_entry.fetch(:api, :generate_content) == :generate_content
+              Legion::Extensions::Llm::Inventory::OfferingDraft.new(
+                provider_native_key: model_id, model: model_id, tier: tier,
+                operation_evidence: build_operation_evidence(now: now,
+                                                             is_embedding: is_embedding,
+                                                             is_generate_content: is_gen),
+                capability_evidence: build_capability_evidence(model_entry: model_entry,
+                                                               instance_cfg: instance_cfg, now: now),
+                context_evidence: absent_value_evidence,
+                max_output_evidence: absent_value_evidence,
+                embedding_dimensions_evidence: absent_value_evidence,
+                model_revision_evidence: absent_value_evidence,
+                tokenizer_evidence: absent_value_evidence,
+                quota_domains: {},
+                metadata: build_offering_metadata(model_entry: model_entry, instance_key: instance_key),
+                publication_source: :provider_static_catalog
+              )
+            end
+          end
+
+          # Publisher, tick-refresh, and instance removal orchestration for
+          # DiscoveryRefresh.
+          module DiscoveryRefreshLifecycleHelpers
             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
+            def publisher
+              @publisher ||= Legion::Extensions::Llm::Inventory::Publisher.new(
+                provider_family: :vertex,
+                compatibility_adapter: Legion::Extensions::Llm::Inventory::ScopedRefresher::LegacyCoordinatorAdapter.new(
+                  provider_family: :vertex
+                )
+              )
+            end
 
-                lane = build_lane(offering, instance_id)
-                lanes << lane
-                lanes << fleet_lane(lane, instance_id, offering) if fleet_enabled && lane[:type] == :inference
+            def initial_discovery
+              @instance_states = Concurrent::Map.new
+              @initialized = true
+              reconcile_instances
+            end
+
+            # Re-scans configured instances each tick so late-configured
+            # instances appear without a restart and removed instances are
+            # retired (with their display health cleared).
+            # Instance identity is the operator's CONFIG NAME (the key the
+            # router's instances.<name> settings lookups use); names are
+            # unique by construction, so two names pointing at the same
+            # physical endpoint stay distinct instances (the derived
+            # physical_id is diagnostic, never a dedup key that collapses
+            # operator-named instances).
+            def reconcile_instances
+              desired = {}
+              configured_instances.each do |name, instance_cfg|
+                physical_id = derive_physical_id(instance_cfg: instance_cfg)
+                if physical_id.nil?
+                  log.warn(
+                    "[vertex][actor] action=skip_instance name=#{name} " \
+                    'reason=no_resolvable_project_or_credential'
+                  )
+                  next
+                end
+
+                desired[name.to_s] = { name: name, instance_cfg: instance_cfg }
+              end
+
+              desired.each do |instance_id, entry|
+                next if @instance_states.key?(instance_id)
+
+                claim_and_activate_instance(name: entry[:name], instance_cfg: entry[:instance_cfg])
+              rescue StandardError => e
+                handle_exception(e, level: :warn, operation: 'vertex.actor.claim_instance',
+                                    instance_name: entry[:name].to_s)
+              end
+
+              (@instance_states.keys - desired.keys).each do |instance_id|
+                remove_instance_state(instance_id)
               end
-              lanes
             end
 
-            def offering_to_hash(offering)
-              return nil if offering.nil?
-              return offering if offering.is_a?(Hash)
+            def tick_refresh
+              reconcile_instances
+              @instance_states.each do |instance_id, state|
+                refresh_instance(instance_id: instance_id, state: state)
+              rescue StandardError => e
+                handle_exception(e, level: :warn, operation: 'vertex.actor.refresh_instance',
+                                    instance_id: instance_id)
+              end
+            end
 
-              hash = offering.to_h
-              hash[:type] ||= hash[:usage_type]
-              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
-              hash
+            def refresh_instance(instance_id:, state:)
+              # While :initializing there is no activated snapshot to replace;
+              # the cadence probe is the recovery path (re-activation on a
+              # passing probe).
+              return run_cadence_probe(instance_id: instance_id, state: state) if initializing?(state)
+
+              new_offerings = discover_offerings_for_instance(instance_cfg: state[:instance_cfg],
+                                                              instance_key: state[:instance_key],
+                                                              now: state[:evidence_now])
+              if new_offerings != state[:offerings]
+                state[:sequence] += 1
+                publisher.replace_instance_snapshot(instance_id: instance_id,
+                                                    publisher_token: state[:publisher_token],
+                                                    offerings: new_offerings, sequence: state[:sequence],
+                                                    physical_id: state[:physical_id])
+                state[:offerings] = new_offerings
+                sync_instance_health(name: state[:name], instance_key: state[:instance_key], offerings: new_offerings)
+              end
+              run_cadence_probe(instance_id: instance_id, state: state)
             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] || {}
+            def initializing?(state)
+              publication_state(instance_key: state[:instance_key]) == :initializing
+            end
+
+            def remove_instance_state(instance_id)
+              state = @instance_states.delete(instance_id)
+              return unless state
+
+              state[:callable].disconnect
+              publisher.remove_instance(instance_id: instance_id, publisher_token: state[:publisher_token],
+                                        physical_id: state[:physical_id])
+              clear_instance_health(name: state[:name])
+            rescue StandardError => e
+              handle_exception(e, level: :warn, operation: 'vertex.actor.remove_instance',
+                                  instance_id: instance_id)
+            end
+
+            def remove_all_instances
+              return unless @instance_states
+
+              @instance_states.each_key { |instance_id| remove_instance_state(instance_id) }
+            end
+          end
+
+          # Instance claim and initial-readiness activation helpers for
+          # DiscoveryRefresh.
+          module DiscoveryRefreshClaimHelpers
+            private
+
+            # Instance identity is the operator's CONFIG NAME (the key the
+            # router's instances.<name> lookups use). The derived
+            # project:location/fingerprint rides along as the secondary
+            # physical_id field for dedup and diagnostics only.
+            def claim_and_activate_instance(name:, instance_cfg:)
+              instance_id = name.to_s
+              physical_id = derive_physical_id(instance_cfg: instance_cfg)
+              raise ArgumentError, 'claim_and_activate_instance requires a resolvable physical_id' if physical_id.nil?
+
+              instance_key = Legion::Extensions::Llm::Inventory::Identity::InstanceKey.new(
+                provider_family: :vertex, instance_id: instance_id, physical_id: physical_id
+              )
+              callable = VertexCallable.new(instance_cfg: instance_cfg, logger: log)
+              probe_coordinator = Legion::Extensions::Llm::Inventory::ProbeCoordinator.new(
+                instance_key: instance_key, enqueue: build_probe_enqueue(instance_id: instance_id)
+              )
+              pub_token = publisher.claim_instance(instance_id: instance_id, callable: callable,
+                                                   probe_request_handle: probe_coordinator, physical_id: physical_id)
+              now = Time.now.freeze
+              offerings = discover_offerings_for_instance(instance_cfg: instance_cfg,
+                                                          instance_key: instance_key, now: now)
+              probe_token = publisher.readiness_probe_started(instance_id: instance_id, publisher_token: pub_token,
+                                                              physical_id: physical_id)
+              activate_or_fail_instance(instance_id: instance_id, pub_token: pub_token,
+                                        probe_token: probe_token, instance_cfg: instance_cfg, offerings: offerings,
+                                        physical_id: physical_id)
+              @instance_states[instance_id] = {
+                name: name, instance_key: instance_key, instance_cfg: instance_cfg,
+                callable: callable, probe_coordinator: probe_coordinator,
+                publisher_token: pub_token, sequence: 0, offerings: offerings, evidence_now: now,
+                physical_id: physical_id
               }
+              sync_instance_health(name: name, instance_key: instance_key, offerings: offerings)
             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)
+            def activate_or_fail_instance(instance_id:, pub_token:, probe_token:, instance_cfg:, offerings:,
+                                          physical_id:)
+              readiness = check_health(instance_cfg: instance_cfg)
+              if readiness.ready?
+                publisher.activate_instance_snapshot(instance_id: instance_id, publisher_token: pub_token,
+                                                     offerings: offerings, sequence: 0, probe_token: probe_token,
+                                                     physical_id: physical_id)
+              else
+                publisher.readiness_failed(instance_id: instance_id, probe_token: probe_token,
+                                           reason: readiness.reason, physical_id: physical_id)
+              end
             end
+          end
+
+          # Display-only health/capabilities settings for DiscoveryRefresh,
+          # written AFTER each registry commit. Legacy 4-key health shape
+          # (circuit_state/denied/available/adjustment) so pre-SSOT consumers
+          # see unchanged output, plus display-only provenance fields.
+          # Display only — routing authority stays the in-memory
+          # AvailabilityFact.
+          module DiscoveryRefreshHealthDisplay
+            HEALTH_ADJUSTMENT_AVAILABLE = 0
+            HEALTH_ADJUSTMENT_DEGRADED = -50
+            CAPABILITY_NAMES_BY_OPERATION = {
+              chat: :completion, stream_chat: :streaming, embed: :embedding, image: :image,
+              transcribe: :audio_transcription, translate: :audio_transcription, speak: :audio_speech,
+              moderate: :moderation
+            }.freeze
+
+            private
+
+            def sync_instance_health(name:, instance_key:, offerings:)
+              snapshot = publisher.snapshot
+              status = snapshot.publication_status(instance_key: instance_key)
+              record = snapshot.instance(instance_key: instance_key)
+              availability = record&.availability
+              available = availability&.state == :available
 
-            def offering_type(offering)
-              %i[embed embedding].include?(offering[:type]&.to_sym) ? :embedding : :inference
+              instances_settings = settings[:instances] || (settings[:instances] = {})
+              instance_settings = instances_settings[name] || (instances_settings[name] = {})
+              instance_settings[:health] = {
+                circuit_state: circuit_state_for(availability),
+                denied: false,
+                available: available,
+                adjustment: available ? HEALTH_ADJUSTMENT_AVAILABLE : HEALTH_ADJUSTMENT_DEGRADED,
+                reason: availability&.reason || status.last_error,
+                observed_at: observed_at_display(availability),
+                last_probe_outcome: status.last_probe_outcome,
+                source: :ssot_discovery_actor
+              }.compact
+              instance_settings[:capabilities] = supported_capabilities(offerings)
+            rescue StandardError => e
+              handle_exception(e, level: :warn, operation: 'vertex.actor.sync_health',
+                                  instance_id: instance_key.instance_id)
             end
 
-            def normalize_capabilities(caps)
-              return [] unless defined?(Legion::Extensions::Llm::Inventory::Capabilities) &&
-                               Legion::Extensions::Llm::Inventory::Capabilities.respond_to?(:normalize)
+            def clear_instance_health(name:)
+              instance_settings = settings[:instances][name]
+              return unless instance_settings.is_a?(Hash)
 
-              Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+              instance_settings.delete(:health)
+              instance_settings.delete(:capabilities)
+            rescue StandardError => e
+              handle_exception(e, level: :warn, operation: 'vertex.actor.clear_health',
+                                  instance_name: name.to_s)
+            end
+
+            def circuit_state_for(availability)
+              case availability&.state
+              when :available then :closed
+              when :unavailable then :open
+              else :half_open
+              end
             end
 
-            public
+            def supported_capabilities(offerings)
+              capabilities = []
+              offerings.each do |draft|
+                draft.operation_evidence.each do |operation, evidence|
+                  next unless evidence.status == :supported
 
-            def credential_hash(**)
-              settings = Legion::Settings.dig(:extensions, :llm, :vertex) || {}
-              ::Digest::SHA256.hexdigest(settings[:api_key].to_s + settings[:instances].to_s)[0, 16]
+                  cap = CAPABILITY_NAMES_BY_OPERATION.fetch(operation, operation)
+                  capabilities << cap unless capabilities.include?(cap)
+                end
+                draft.capability_evidence.each do |capability, evidence|
+                  capabilities << capability if evidence.status == :supported && !capabilities.include?(capability)
+                end
+              end
+              capabilities.sort
+            end
+
+            def observed_at_display(availability)
+              observed_at = availability&.observed_at
+              return nil unless observed_at
+
+              observed_at.getutc.strftime('%Y-%m-%dT%H:%M:%SZ')
+            end
+          end
+
+          # SSOT v3 periodic discovery actor for Vertex AI provider instances.
+          # Claims configured instances, discovers models from the STATIC_MODELS
+          # catalog, probes health via the non-inference models-list endpoint,
+          # and publishes complete OfferingDraft snapshots through the
+          # Inventory::Publisher. Owns the refresh cadence, recovers
+          # initial-readiness failures, and writes the display-only
+          # health/capabilities settings after each registry commit.
+          class DiscoveryRefresh < Legion::Extensions::Actors::Every
+            include Legion::Extensions::Helpers::Lex
+            include Legion::Logging::Helper
+            include DiscoveryRefreshOperationEvidence
+            include DiscoveryRefreshCapabilityEvidence
+            include DiscoveryRefreshConfigHelpers
+            include DiscoveryRefreshProbeHelpers
+            include DiscoveryRefreshOfferingHelpers
+            include DiscoveryRefreshClaimHelpers
+            include DiscoveryRefreshHealthDisplay
+            include DiscoveryRefreshLifecycleHelpers
+
+            # Guards a broken discovery config (missing or non-positive value);
+            # the registered default (lex-llm ProviderSettings) is 300 seconds.
+            FALLBACK_DISCOVERY_INTERVAL_SECONDS = 300
+
+            def runner_class    = self.class
+            def runner_function = 'manual'
+            def run_now?        = true
+            def use_runner?     = false
+            def check_subtask?  = false
+            def generate_task?  = false
+
+            # The actor owns the discovery cadence. Read the registered
+            # interval so the operator knob is honored and the timer never
+            # receives nil.
+            def time
+              interval = settings.dig(:discovery, :interval_seconds)
+              interval.is_a?(Numeric) && interval.positive? ? interval : FALLBACK_DISCOVERY_INTERVAL_SECONDS
             end
 
             def manual
-              tick if respond_to?(:tick)
+              if @initialized
+                tick_refresh
+              else
+                initial_discovery
+              end
+            rescue StandardError => e
+              handle_exception(e, level: :warn, operation: 'vertex.actor.discovery_refresh')
+            end
+
+            def shutdown
+              remove_all_instances
             rescue StandardError => e
-              handle_exception(e, level: :warn, handled: true, operation: 'vertex.actor.discovery_refresh')
+              handle_exception(e, level: :warn, operation: 'vertex.actor.discovery_refresh.shutdown')
             end
           end
         end

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

@@ -11,6 +11,7 @@ unless defined?(Legion::Extensions::Actors::Subscription)
 end
 
 require 'legion/extensions/llm/vertex'
+require 'legion/extensions/llm/vertex/runners/fleet_worker'
 require 'legion/extensions/llm/fleet/provider_responder'
 
 module Legion
@@ -19,9 +20,14 @@ module Legion
       module Vertex
         module Actor
           # Subscription actor for Vertex fleet request consumption.
+          #
+          # runner_class MUST be the constant (not a String): the Subscription
+          # dispatch path calls runner_class.send(runner_function, **message)
+          # directly when use_runner? is false, and a String cannot be send-ed.
+          # The runner entrypoint is kwargs-only to match that call.
           class FleetWorker < Legion::Extensions::Actors::Subscription
             def runner_class
-              'Legion::Extensions::Llm::Vertex::Runners::FleetWorker'
+              Legion::Extensions::Llm::Vertex::Runners::FleetWorker
             end
 
             def runner_function

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

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'legion/extensions/llm/routing/provider_outcome'
+require 'legion/extensions/llm/vertex/provider'
+
+module Legion
+  module Extensions
+    module Llm
+      module Vertex
+        module Actor
+          # Callable wrapper for a Vertex AI provider instance. Delegates the
+          # fleet dispatch operations to a per-instance Vertex::Provider (real
+          # HTTP dispatch; provider/Faraday errors propagate so
+          # normalize_dispatch_error classifies them) and implements the
+          # `disconnect` and `normalize_dispatch_error(error:)` contracts
+          # required by Inventory::CallableHandle and Routing::ProviderOutcome.
+          class VertexCallable
+            attr_reader :provider
+
+            def initialize(instance_cfg:, logger:)
+              @instance_cfg = instance_cfg
+              @logger = logger
+              @provider = Provider.new(instance_cfg)
+              @disconnected = false
+            end
+
+            def disconnected?
+              @disconnected
+            end
+
+            def disconnect
+              @disconnected = true
+              @provider.disconnect
+              @logger.debug { '[vertex][callable] disconnected' }
+            end
+
+            # --- Fleet dispatch operations (Fleet::WorkerExecution contract) --
+
+            def chat(messages:, model:, **rest)
+              provider.chat(messages: messages, model: model, **rest)
+            end
+
+            def stream_chat(messages:, model:, **rest, &)
+              provider.stream_chat(messages: messages, model: model, **rest, &)
+            end
+
+            def embed(text:, model:, **rest)
+              provider.embed(text: text, model: model, **rest)
+            end
+
+            def count_tokens(messages:, model:, **rest)
+              provider.count_tokens(messages: messages, model: model, **rest)
+            end
+
+            # --- Error normalization ------------------------------------------
+
+            def normalize_dispatch_error(error:)
+              reason = error.message.to_s[0, 512]
+
+              kind = case error
+                     when Faraday::ConnectionFailed
+                       :connection_failure
+                     when Faraday::TimeoutError
+                       :timeout
+                     when Faraday::ClientError
+                       classify_client_error(error: error)
+                     when Faraday::ServerError
+                       classify_server_error(error: error)
+                     when Legion::Extensions::Llm::OverloadedError
+                       :overloaded
+                     else
+                       # ServiceUnavailableError and all other errors map to provider_error.
+                       # Never escalate to instance_unavailable from a typed error alone.
+                       :provider_error
+                     end
+
+              Legion::Extensions::Llm::Routing::ProviderOutcome.new(
+                kind: kind,
+                reason: reason.empty? ? 'unknown dispatch error' : reason
+              )
+            end
+
+            private
+
+            def classify_client_error(error:)
+              case error.response_status
+              when 401 then :authentication
+              when 403 then :authorization
+              when 404 then :model_missing
+              when 429 then :rate_limited
+              else :invalid_request
+              end
+            end
+
+            def classify_server_error(error:)
+              # NEVER classify raw 503/5xx as instance_unavailable by status alone.
+              # Only an explicit flat SERVICE_UNAVAILABLE body signal from Vertex
+              # would justify instance_unavailable. Everything else is request-local.
+              status = error.response_status
+              body = extract_error_body(error: error)
+
+              if status == 503 && body.include?('service_unavailable') && !overload_signal?(body: body)
+                :instance_unavailable
+              elsif [503, 529].include?(status)
+                :overloaded
+              else
+                :provider_error
+              end
+            end
+
+            # Faraday::Error#response_body reads the body from either a
+            # Hash-shaped or a Faraday::Response/Env-shaped error response, so
+            # the body signal survives real adapter-raised errors.
+            def extract_error_body(error:)
+              error.response_body.to_s.downcase
+            end
+
+            def overload_signal?(body:)
+              body.include?('overload') || body.include?('model not ready') || body.include?('model_not_ready')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -10,7 +10,7 @@ module Legion
     module Llm
       module Vertex
         # Google Cloud Vertex AI provider implementation for the Legion::Extensions::Llm contract.
-        class Provider < Legion::Extensions::Llm::Provider # rubocop:disable Metrics/ClassLength
+        class Provider < Legion::Extensions::Llm::Provider
           STATIC_MODELS = [
             { model: 'gemini-2.5-flash', alias: 'gemini-flash', publisher: 'google', model_family: :gemini },
             { model: 'gemini-2.5-pro', alias: 'gemini-pro', publisher: 'google', model_family: :gemini },
@@ -32,8 +32,6 @@ module Legion
           MODEL_FAMILIES = STATIC_MODELS.to_h { |entry| [entry.fetch(:model), entry.fetch(:model_family)] }.freeze
 
           class << self
-            attr_writer :registry_publisher
-
             def slug = 'vertex'
             def default_transport = :http
             def default_tier = :cloud
@@ -53,12 +51,8 @@ module Legion
             def configuration_requirements = []
             def capabilities = Capabilities
 
-            def registry_publisher
-              @registry_publisher ||= Legion::Extensions::Llm::RegistryPublisher.new(provider_family: :vertex)
-            end
-
             def resolve_model_id(model_id, config: nil)
-              configured_aliases = config.respond_to?(:vertex_model_aliases) ? config.vertex_model_aliases : nil
+              configured_aliases = config&.vertex_model_aliases
               aliases = ALIASES.merge((configured_aliases || {}).transform_keys(&:to_s))
               aliases.fetch(model_id.to_s, model_id.to_s)
             end
@@ -81,10 +75,6 @@ module Legion
             end
           end
 
-          def settings
-            Vertex.default_settings
-          end
-
           def api_base
             config.vertex_api_base || "https://#{location}-aiplatform.googleapis.com/v1"
           end
@@ -94,12 +84,23 @@ module Legion
                                      'Content-Type' => 'application/json; charset=utf-8' }.compact)
           end
 
-          def project = config.vertex_project || settings[:project] || ENV.fetch('GOOGLE_CLOUD_PROJECT', nil)
-          def location = config.vertex_location || settings[:location] || 'us-central1'
-          def default_publisher = settings[:publisher] || 'google'
+          def project = config.vertex_project || ENV.fetch('GOOGLE_CLOUD_PROJECT', nil)
+          def location = config.vertex_location
+          def default_publisher = 'google'
           def models_url = publisher_parent
-          def completion_url = generate_content_url(model: @model || STATIC_MODELS.first.fetch(:model))
-          def stream_url = stream_generate_content_url(model: @model || STATIC_MODELS.first.fetch(:model))
+
+          def completion_url(model: @model)
+            raise ArgumentError, 'model is required for completion_url' unless model
+
+            generate_content_url(model: model)
+          end
+
+          def stream_url(model: @model)
+            raise ArgumentError, 'model is required for stream_url' unless model
+
+            stream_generate_content_url(model: model)
+          end
+
           def count_tokens_url(model:) = "#{publisher_model_path(model)}:countTokens"
           def embedding_url(model:) = "#{publisher_model_path(model)}:predict"
 
@@ -119,8 +120,7 @@ module Legion
           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" }
-              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
+              log.info { "listed #{models.size} Vertex model(s)" }
             end
           end
 
@@ -134,7 +134,7 @@ module Legion
             super
           end
 
-          def offering_for(model:, model_family: nil, instance_id: :default, **metadata)
+          def offering_for(model:, model_family: nil, instance_id: nil, **metadata)
             model_id = model_id(model)
             publisher = metadata.delete(:publisher) || publisher_for(model_id)
             family = model_family || metadata.delete(:model_family) || model_family_for(model_id, publisher)
@@ -143,7 +143,7 @@ module Legion
               model: resource_name(model_id, publisher:),
               alias_name: alias_for(model_id),
               model_family: family,
-              instance_id: instance_id,
+              instance_id: instance_id || provider_instance_id,
               publisher: publisher,
               usage_type: metadata.delete(:usage_type) || usage_type_for(model_id),
               api: metadata.delete(:api) || api_for(model_id),
@@ -173,9 +173,7 @@ module Legion
 
           def readiness(live: false)
             health(live:).merge(local: false, remote: true, api_base: api_base,
-                                endpoints: endpoint_manifest).tap do |metadata|
-              self.class.registry_publisher.publish_readiness_async(metadata) if live
-            end
+                                endpoints: endpoint_manifest)
           end
 
           def chat(
@@ -258,7 +256,7 @@ module Legion
             parse_embedding_response(response, model: model_id)
           end
 
-          def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil, # rubocop:disable Lint/UnusedMethodArgument
+          def complete(messages, tools:, temperature:, model:, params: {}, _headers: {}, schema: nil, thinking: nil,
                        tool_prefs: nil, &)
             payload = params.dup
             payload[:generationConfig] = Utils.deep_merge(payload[:generationConfig] || {},
@@ -356,13 +354,14 @@ module Legion
             )
           end
 
-          def build_offering(model:, model_family:, usage_type:, publisher:, api:, instance_id: :default,
+          def build_offering(model:, model_family:, usage_type:, publisher:, api:, instance_id: nil,
                              alias_name: nil, health: {}, metadata: {})
-            policy = resolve_capability_policy(model, api:, metadata:, instance_id:)
+            resolved_instance_id = instance_id || provider_instance_id
+            policy = resolve_capability_policy(model, api:, metadata:, instance_id: resolved_instance_id)
 
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :vertex,
-              instance_id: instance_id,
+              instance_id: resolved_instance_id,
               transport: offering_transport,
               tier: offering_tier,
               model: model,

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

@@ -9,17 +9,21 @@ module Legion
       module Vertex
         module Runners
           # Runner entrypoint for Vertex fleet request execution.
+          #
+          # The Subscription dispatch path invokes this as
+          # handle_fleet_request(**message) where message is the decoded
+          # protocol-v2 envelope plus AMQP metadata; the whole message is the
+          # payload for the shared responder (which selects the envelope
+          # fields it needs).
           module FleetWorker
             module_function
 
-            def handle_fleet_request(payload, delivery: nil, properties: nil)
+            def handle_fleet_request(**message)
               Legion::Extensions::Llm::Fleet::ProviderResponder.call(
-                payload: payload,
+                payload: message,
                 provider_family: Vertex::PROVIDER_FAMILY,
                 provider_class: Vertex::Provider,
-                provider_instances: -> { Vertex.discover_instances },
-                delivery: delivery,
-                properties: properties
+                provider_instances: -> { Vertex.discover_instances }
               )
             end
           end

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

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Vertex
-        VERSION = '0.2.16'
+        VERSION = '0.3.3'
       end
     end
   end

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

@@ -3,7 +3,8 @@
 require 'legion/extensions/llm'
 require 'legion/extensions/llm/vertex/provider'
 require 'legion/extensions/llm/vertex/version'
-require_relative 'vertex/actors/discovery_refresh'
+require 'legion/extensions/llm/vertex/callable'
+require 'legion/extensions/llm/vertex/actors/discovery_refresh'
 
 module Legion
   module Extensions
@@ -11,7 +12,6 @@ module Legion
       # Google Cloud Vertex AI provider extension namespace.
       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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-vertex
 version: !ruby/object:Gem::Version
-  version: 0.2.16
+  version: 0.3.3
 platform: ruby
 authors:
 - LegionIO
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
+        version: 1.4.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.3.14
+        version: 1.4.2
 - !ruby/object:Gem::Dependency
   name: legion-transport
   requirement: !ruby/object:Gem::Requirement
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.7.1
 description: Google Cloud Vertex AI provider integration for the LegionIO LLM routing
   framework.
 email:
@@ -100,6 +100,7 @@ files:
 - lib/legion/extensions/llm/vertex.rb
 - lib/legion/extensions/llm/vertex/actors/discovery_refresh.rb
 - lib/legion/extensions/llm/vertex/actors/fleet_worker.rb
+- lib/legion/extensions/llm/vertex/callable.rb
 - lib/legion/extensions/llm/vertex/provider.rb
 - lib/legion/extensions/llm/vertex/runners/fleet_worker.rb
 - lib/legion/extensions/llm/vertex/version.rb