mixdog 1.4.1 → 1.4.3

package/src/runtime/shared/idle-gc.mjs

@@ -73,7 +73,12 @@ export async function collectGarbageNow() {
  * @param {(message: string) => void} [options.log]
  * @param {string} [options.label] Log prefix.
  */
-export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {}) {
+export function createIdleGc({
+  isBusy,
+  log = () => {},
+  label = 'idle gc',
+  memoryUsage = () => process.memoryUsage(),
+} = {}) {
   const enabled = !DISABLED.test(String(process.env.MIXDOG_IDLE_GC || ''));
   // Long enough that the pause between two turns of one conversation never
   // triggers a sweep, short enough that a desktop left alone reclaims soon.
@@ -90,6 +95,11 @@ export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {})
   // between committed and used is itself a reason to sweep — the collection is
   // what lets V8 release those pages — so either signal alone arms the sweep.
   const minSlackBytes = envNumber('MIXDOG_IDLE_GC_MIN_SLACK_MB', 64) * MB;
+  // Buffers, ArrayBuffers and external strings live outside the JS heap, so a
+  // daemon can sit on gigabytes of dead attachment data behind a tiny heap
+  // (external 2.8GB beside heapTotal 7MB was measured) and never trip the heap
+  // floors above. Only a collection frees them.
+  const minExternalBytes = envNumber('MIXDOG_IDLE_GC_MIN_EXTERNAL_MB', 96) * MB;
   // Re-sweeping a process that has not allocated since the last sweep only
   // burns CPU; require real growth (or an announced release, see
   // noteMemoryRelease) before running again.
@@ -98,6 +108,7 @@ export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {})
   let timer = null;
   let lastBusyAt = Date.now();
   let lastSweptHeap = 0;
+  let lastSweptExternal = 0;
   let sweptReleaseSeq = releaseSeq;
   let appliedReleaseAt = lastReleaseAt;
   let sweeping = false;
@@ -123,12 +134,22 @@ export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {})
       lastBusyAt = Math.max(lastBusyAt, Math.min(lastReleaseAt, Date.now()));
     }
     if (Date.now() - lastBusyAt < idleMs) return 'settling';
-    const usageBefore = process.memoryUsage();
+    const usageBefore = memoryUsage();
     const before = usageBefore.heapUsed;
+    const externalBefore = usageBefore.external || 0;
     const slackBefore = Math.max(0, usageBefore.heapTotal - before);
-    if (before < minHeapBytes && slackBefore < minSlackBytes) return 'small';
+    if (before < minHeapBytes && slackBefore < minSlackBytes && externalBefore < minExternalBytes) {
+      return 'small';
+    }
     const released = releaseSeq !== sweptReleaseSeq;
-    if (lastSweptHeap && !released && before < lastSweptHeap + growthBytes) return 'unchanged';
+    if (
+      lastSweptHeap &&
+      !released &&
+      before < lastSweptHeap + growthBytes &&
+      externalBefore < lastSweptExternal + growthBytes
+    ) {
+      return 'unchanged';
+    }
 
     sweeping = true;
     const releaseSeqAtSweep = releaseSeq;
@@ -139,9 +160,10 @@ export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {})
         disarm();
         return 'unavailable';
       }
-      const usageAfter = process.memoryUsage();
+      const usageAfter = memoryUsage();
       const after = usageAfter.heapUsed;
       lastSweptHeap = after;
+      lastSweptExternal = usageAfter.external || 0;
       // Releases announced while this sweep ran still get their own.
       sweptReleaseSeq = releaseSeqAtSweep;
       const mb = (bytes) => (bytes / MB).toFixed(1);
@@ -150,7 +172,8 @@ export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {})
       log(
         `${label}: heapUsed ${mb(before)} -> ${mb(after)} MB` +
           ` (reclaimed ${mb(before - after)} MB) in ${Date.now() - startedAt}ms` +
-          `, committed ${mb(usageBefore.heapTotal)} -> ${mb(usageAfter.heapTotal)} MB`
+          `, committed ${mb(usageBefore.heapTotal)} -> ${mb(usageAfter.heapTotal)} MB` +
+          `, external ${mb(externalBefore)} -> ${mb(usageAfter.external || 0)} MB`
       );
       return 'swept';
     } catch (e) {
@@ -185,6 +208,6 @@ export function createIdleGc({ isBusy, log = () => {}, label = 'idle gc' } = {})
     },
     /** Drives one cycle synchronously for tests; returns the decision taken. */
     _tickForTest: tick,
-    _configForTest: { enabled, idleMs, checkMs, minHeapBytes, minSlackBytes, growthBytes },
+    _configForTest: { enabled, idleMs, checkMs, minHeapBytes, minSlackBytes, minExternalBytes, growthBytes },
   };
 }

package/src/runtime/shared/llm/cost.mjs

@@ -133,7 +133,12 @@ export function priceUsage(args) {
   // premium request needs the model's published Fast/Priority rates.
   const anthropicFast = premium && sentTier === 'fast' && supportsAnthropicFastMode(identity.pricingModel);
   const premiumPricing = sentTier === 'ultrafast' ? meta.ultrafastPricing : meta.fastPricing;
-  const rateMeta = premium && !anthropicFast ? premiumPricing || {} : meta;
+  // A request the server reports as served on Flex (Vertex Flex PayGo can be
+  // served by Provisioned Throughput first) bills the catalog's flex columns.
+  const flex = args.serviceTier === 'flex';
+  let rateMeta = meta;
+  if (flex) rateMeta = meta.flexPricing || {};
+  else if (premium && !anthropicFast) rateMeta = premiumPricing || {};
   if (args.historicalAggregate && rateMeta.pricingTiers?.some((tier) => promptTokens > tier.aboveInputTokens)) {
     // A daily sum cannot establish which individual requests crossed a
     // context boundary. Do not price the whole day as one huge prompt.

package/src/runtime/shared/llm/http-agent.mjs

@@ -20,6 +20,7 @@
  */
 
 import { createRequire } from 'node:module';
+import { BlockList, isIP } from 'node:net';
 
 const require = createRequire(import.meta.url);
 let _undici = null;
@@ -30,6 +31,8 @@ function undici() {
 
 let _agent = null;
 let _globalInstalled = false;
+/** The system-proxy router (adoptPrivateProxy), installed as the global dispatcher. */
+let _router = null;
 
 function envInt(name, fallback) {
   const raw = process.env[name];
@@ -57,10 +60,12 @@ function envInt(name, fallback) {
  */
 function proxyConfigured() {
   const env = process.env;
-  if (env.HTTP_PROXY || env.HTTPS_PROXY || env.http_proxy || env.https_proxy) return true;
+  if (PROXY_VARS.some((name) => env[name])) return true;
   if (env.NODE_USE_ENV_PROXY) return true;
   try {
     const g = undici().getGlobalDispatcher?.();
+    // Our own router sends its direct origins to the shared pool below.
+    if (_router && g === _router) return false;
     // Any non-default global dispatcher (constructor name other than the plain
     // `Agent` undici installs by default) is treated as custom — ProxyAgent,
     // EnvHttpProxyAgent, MockAgent, or a user subclass — and we step aside.
@@ -71,6 +76,305 @@ function proxyConfigured() {
   return false;
 }
 
+const PROXY_VARS = ['HTTPS_PROXY', 'https_proxy', 'HTTP_PROXY', 'http_proxy'];
+// Loopback, private (RFC 1918) and link-local IPv4.
+const LOCAL_V4_RANGES = [
+  ['127.0.0.0', '127.255.255.255'],
+  ['10.0.0.0', '10.255.255.255'],
+  ['172.16.0.0', '172.31.255.255'],
+  ['192.168.0.0', '192.168.255.255'],
+  ['169.254.0.0', '169.254.255.255'],
+];
+// Loopback, unique-local and link-local IPv6.
+const LOCAL_V6_SUBNETS = [
+  ['::1', 128],
+  ['fc00::', 7],
+  ['fe80::', 10],
+];
+
+/**
+ * NO_PROXY for processes that follow the proxy variables natively (children,
+ * Node's http module). NO_PROXY matching is by name, suffix or exact address;
+ * fetch has no address ranges at all and Node's http module takes `a-b`
+ * ranges, so this list is a fallback: in-process, isLocalHost decides.
+ */
+export const LOCAL_NO_PROXY = [
+  'localhost',
+  '127.0.0.1',
+  '::1',
+  '.local',
+  ...LOCAL_V4_RANGES.map(([start, end]) => `${start}-${end}`),
+].join(',');
+
+let _localAddresses = null;
+function localAddresses() {
+  if (!_localAddresses) {
+    _localAddresses = new BlockList();
+    for (const [start, end] of LOCAL_V4_RANGES) _localAddresses.addRange(start, end, 'ipv4');
+    for (const [network, prefix] of LOCAL_V6_SUBNETS) _localAddresses.addSubnet(network, prefix, 'ipv6');
+  }
+  return _localAddresses;
+}
+
+export function normalizeHost(hostname) {
+  return String(hostname)
+    .replace(/^\[(.*)\]$/, '$1')
+    .replace(/\.$/, '')
+    .toLowerCase();
+}
+
+/**
+ * A host that never goes through the proxy: a loopback, private or
+ * link-local address, a dotless name (`localhost`, a LAN machine) or a
+ * `.local` / `.localhost` name — local providers and LAN services.
+ */
+export function isLocalHost(hostname) {
+  const host = normalizeHost(hostname);
+  const family = isIP(host);
+  if (family) return localAddresses().check(host, family === 4 ? 'ipv4' : 'ipv6');
+  return !host.includes('.') || host.endsWith('.local') || host.endsWith('.localhost');
+}
+
+/**
+ * `env` plus what Node needs to honour its proxy variables: NODE_USE_ENV_PROXY
+ * (Node ignores HTTPS_PROXY without it) and a local NO_PROXY. Unchanged when
+ * no proxy variable is set or the user set NODE_USE_ENV_PROXY / NO_PROXY.
+ */
+export function withEnvProxy(env) {
+  if (env.NODE_USE_ENV_PROXY !== undefined || !PROXY_VARS.some((name) => env[name])) return env;
+  const noProxy = env.NO_PROXY || env.no_proxy ? {} : { NO_PROXY: LOCAL_NO_PROXY };
+  return { ...env, NODE_USE_ENV_PROXY: '1', ...noProxy };
+}
+
+/**
+ * The global dispatcher under a proxy: local and LAN hosts (isLocalHost, which
+ * includes every dotless name) connect directly, every other host follows the
+ * proxy variables and NO_PROXY. `direct` and `proxied` replace the two inner
+ * dispatchers (tests).
+ */
+export function createProxyDispatcher({ direct = null, proxied = null } = {}) {
+  const { Agent, Dispatcher, EnvHttpProxyAgent } = undici();
+  class LocalBypassProxyAgent extends Dispatcher {
+    #direct = direct ?? new Agent();
+    #proxied = proxied ?? new EnvHttpProxyAgent();
+
+    dispatch(opts, handler) {
+      const { hostname } = new URL(opts.origin);
+      return (isLocalHost(hostname) ? this.#direct : this.#proxied).dispatch(opts, handler);
+    }
+
+    async close() {
+      await Promise.all([this.#direct.close(), this.#proxied.close()]);
+    }
+
+    async destroy(error) {
+      await Promise.all([this.#direct.destroy(error), this.#proxied.destroy(error)]);
+    }
+  }
+  return new LocalBypassProxyAgent();
+}
+
+let _envProxyAdopted = false;
+
+/**
+ * Honour proxy variables in this already-running process (createProxyDispatcher
+ * as the global dispatcher) and, through the inherited env, in every child it
+ * spawns. No-op without a proxy variable, when the user set NODE_USE_ENV_PROXY
+ * to anything but 1, or once adopted.
+ */
+export function adoptEnvProxy(env = process.env) {
+  const next = withEnvProxy(env);
+  if (_envProxyAdopted || next.NODE_USE_ENV_PROXY !== '1' || !PROXY_VARS.some((name) => next[name])) return false;
+  env.NODE_USE_ENV_PROXY = '1';
+  if (next.NO_PROXY !== undefined) env.NO_PROXY = next.NO_PROXY;
+  undici().setGlobalDispatcher(createProxyDispatcher());
+  _envProxyAdopted = true;
+  return true;
+}
+
+/** A request the router could not hand to a leg fails through its handler. */
+function failDispatch(handler, error) {
+  if (typeof handler.onResponseError === 'function') handler.onResponseError(null, error);
+  else handler.onError?.(error);
+}
+
+const RESPONSE_CALLBACKS = [
+  'onRequestUpgrade',
+  'onResponseStart',
+  'onResponseData',
+  'onResponseEnd',
+  'onResponseError',
+];
+
+/**
+ * Start a request whose leg is not known yet: its handler gets a controller at
+ * once, so an abort while the route is looked up settles it right away instead
+ * of when the lookup answers. Returns the handler to give the leg (which binds
+ * the controller to the real request), or null once aborted. Legacy handlers
+ * (no onRequestStart) start with the leg as before.
+ */
+function startDeferred(handler) {
+  if (typeof handler.onRequestStart !== 'function') return () => handler;
+  let inner = null;
+  let reason = null;
+  const controller = {
+    get aborted() {
+      return inner ? inner.aborted : reason !== null;
+    },
+    get paused() {
+      return inner?.paused ?? false;
+    },
+    get reason() {
+      return inner ? inner.reason : reason;
+    },
+    get rawHeaders() {
+      return inner?.rawHeaders;
+    },
+    get rawTrailers() {
+      return inner?.rawTrailers;
+    },
+    abort(cause) {
+      if (inner) return inner.abort(cause);
+      if (reason !== null) return;
+      reason = cause ?? new (undici().errors.RequestAbortedError)();
+      handler.onResponseError?.(controller, reason);
+    },
+    pause() {
+      inner?.pause();
+    },
+    resume() {
+      inner?.resume();
+    },
+  };
+  handler.onRequestStart(controller, {});
+  const forwarded = {
+    onRequestStart(real) {
+      inner = real;
+    },
+  };
+  for (const name of RESPONSE_CALLBACKS) {
+    if (typeof handler[name] === 'function') forwarded[name] = (...args) => handler[name](...args);
+  }
+  return () => (reason === null ? forwarded : null);
+}
+
+/**
+ * A dispatcher that routes each origin on its own: local and LAN hosts connect
+ * directly without asking, every other origin by `route(origin)` — `{ proxy }`
+ * (a proxy URL, or null for direct), or a promise of one, which the request
+ * waits for. A request aborted meanwhile settles at once and is never sent.
+ * `direct()` gives the direct leg (read per request: the pool can be replaced),
+ * `proxied(uri)` builds the leg of one proxy, kept for reuse.
+ */
+export function createRoutedProxyDispatcher({
+  route,
+  direct = null,
+  proxied = (uri) => new (undici().ProxyAgent)({ uri }),
+}) {
+  const { Agent, Dispatcher } = undici();
+  let ownDirect = null;
+  const directLeg = direct ?? (() => (ownDirect ??= new Agent()));
+  class SystemProxyRouter extends Dispatcher {
+    #proxied = new Map();
+
+    #leg(decision) {
+      const uri = decision?.proxy;
+      if (!uri) return directLeg();
+      let leg = this.#proxied.get(uri);
+      if (!leg) {
+        leg = proxied(uri);
+        this.#proxied.set(uri, leg);
+      }
+      return leg;
+    }
+
+    dispatch(opts, handler) {
+      const url = new URL(opts.origin);
+      const decided = isLocalHost(url.hostname) ? null : route(url.origin);
+      if (typeof decided?.then !== 'function') return this.#leg(decided).dispatch(opts, handler);
+      const started = startDeferred(handler);
+      decided
+        .then(
+          (decision) => decision,
+          () => null
+        )
+        .then((decision) => {
+          const legHandler = started();
+          if (!legHandler) return;
+          try {
+            this.#leg(decision).dispatch(opts, legHandler);
+          } catch (error) {
+            failDispatch(legHandler, error);
+          }
+        });
+      return true;
+    }
+
+    async close() {
+      await Promise.all([directLeg().close(), ...[...this.#proxied.values()].map((leg) => leg.close())]);
+    }
+
+    async destroy(error) {
+      await Promise.all([directLeg().destroy(error), ...[...this.#proxied.values()].map((leg) => leg.destroy(error))]);
+    }
+  }
+  return new SystemProxyRouter();
+}
+
+/**
+ * Route this process's fetch per origin by a proxy decision that came from the
+ * OS rather than from the user's environment (system-proxy.mjs): `route` as in
+ * createRoutedProxyDispatcher. It lives in the dispatcher only: no proxy
+ * variable is written, so shells, tools and other CLIs this process spawns see
+ * none. Direct origins use the shared LLM pool and every proxy leg its
+ * settings. No-op once a proxy is adopted.
+ */
+export function adoptPrivateProxy(route) {
+  if (_envProxyAdopted) return false;
+  const router = createRoutedProxyDispatcher({
+    route,
+    direct: llmAgent,
+    proxied: (uri) => new (undici().ProxyAgent)({ ...llmAgentOptions(), uri }),
+  });
+  undici().setGlobalDispatcher(router);
+  _router = router;
+  _envProxyAdopted = true;
+  return true;
+}
+
+function llmAgentOptions() {
+  return {
+    keepAliveTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MS', 60_000),
+    keepAliveMaxTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MAX_MS', 90_000),
+    // No per-origin socket cap by default: each streaming (SSE) response
+    // holds its HTTP/1.1 socket for the whole generation, so a cap of N
+    // queued the (N+1)th concurrent agent until another finished. Rate
+    // limiting is the server's call (429 → admission cooldown).
+    connections: envInt('MIXDOG_LLM_CONNECTIONS', null),
+    // undici defaults both of these to 300s, which beheaded the Anthropic
+    // NON-STREAMING stall fallback (2026-08-03 regex-chess probe:
+    // UND_ERR_HEADERS_TIMEOUT at exactly 300s) — a non-streaming completion
+    // sends NO response headers until generation finishes, so a long silent
+    // generation legitimately exceeds 300s of header wait. Raise both to
+    // 600s: first-byte/idle protection is owned by the app-level watchdogs
+    // (provider first-byte + semantic idle + agent stall abort), which all
+    // fire below this transport ceiling; this layer is only the last-resort
+    // dead-socket bound.
+    headersTimeout: envInt('MIXDOG_LLM_HEADERS_TIMEOUT_MS', 600_000),
+    bodyTimeout: envInt('MIXDOG_LLM_BODY_TIMEOUT_MS', 600_000),
+  };
+}
+
+/** The shared LLM pool, created again once closed or destroyed. */
+function llmAgent() {
+  if (_agent?.destroyed || _agent?.closed) {
+    _agent = null;
+    _globalInstalled = false;
+  }
+  _agent ??= new (undici().Agent)(llmAgentOptions());
+  return _agent;
+}
+
 /**
  * The shared singleton dispatcher for LLM API requests. Created on first use.
  *
@@ -81,36 +385,12 @@ function proxyConfigured() {
  * Returns `undefined` when a proxy / any custom (non-default) global dispatcher
  * is configured, so `fetch({ dispatcher: undefined })` falls back to that
  * global dispatcher instead of bypassing it. `dispatcher: undefined` is a
- * harmless fetch option, so call sites need no change.
+ * harmless fetch option, so call sites need no change. Under the system-proxy
+ * router (the global dispatcher) the pool is its direct leg.
  */
 export function getLlmDispatcher() {
-  if (proxyConfigured()) return undefined;
-  if (_agent?.destroyed || _agent?.closed) {
-    _agent = null;
-    _globalInstalled = false;
-  }
-  if (!_agent) {
-    _agent = new (undici().Agent)({
-      keepAliveTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MS', 60_000),
-      keepAliveMaxTimeout: envInt('MIXDOG_LLM_KEEPALIVE_MAX_MS', 90_000),
-      // No per-origin socket cap by default: each streaming (SSE) response
-      // holds its HTTP/1.1 socket for the whole generation, so a cap of N
-      // queued the (N+1)th concurrent agent until another finished. Rate
-      // limiting is the server's call (429 → admission cooldown).
-      connections: envInt('MIXDOG_LLM_CONNECTIONS', null),
-      // undici defaults both of these to 300s, which beheaded the Anthropic
-      // NON-STREAMING stall fallback (2026-08-03 regex-chess probe:
-      // UND_ERR_HEADERS_TIMEOUT at exactly 300s) — a non-streaming completion
-      // sends NO response headers until generation finishes, so a long silent
-      // generation legitimately exceeds 300s of header wait. Raise both to
-      // 600s: first-byte/idle protection is owned by the app-level watchdogs
-      // (provider first-byte + semantic idle + agent stall abort), which all
-      // fire below this transport ceiling; this layer is only the last-resort
-      // dead-socket bound.
-      headersTimeout: envInt('MIXDOG_LLM_HEADERS_TIMEOUT_MS', 600_000),
-      bodyTimeout: envInt('MIXDOG_LLM_BODY_TIMEOUT_MS', 600_000),
-    });
-  }
+  if (proxyConfigured() || _router) return undefined;
+  llmAgent();
   // mixdog standalone: separate undici instance from Node's fetch undici, so
   // a per-request dispatcher throws UND_ERR_INVALID_ARG. Install globally once
   // and omit the per-request dispatcher. See port-plan D7.
@@ -138,6 +418,13 @@ export function recycleLlmDispatcher() {
   _agent = null;
   _globalInstalled = false;
   _preconnectedAt.clear();
+  // The router asks for the pool per request, so the next one gets a new pool.
+  if (_router) {
+    try {
+      old.close().catch(() => {});
+    } catch {}
+    return true;
+  }
   getLlmDispatcher();
   if (undici().getGlobalDispatcher() !== _agent) {
     const unused = _agent;

package/src/runtime/shared/llm/model-catalog-projection.mjs

@@ -155,10 +155,11 @@ function projectLitellmRow(row) {
   // litellmPricing), not just the base price.
   for (const [field, value] of Object.entries(row)) {
     if (
-      (/^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority|_ultrafast)?$/.test(
+      (/^(?:input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)(?:_above_\d+k_tokens)?(?:_priority|_ultrafast|_flex)?$/.test(
         field
       ) ||
-        /^output_cost_per_second_\w+$/.test(field)) &&
+        /^output_cost_per_second_\w+$/.test(field) ||
+        field === 'regional_endpoint_uplift_multiplier') &&
       typeof value === 'number' &&
       Number.isFinite(value)
     )

package/src/runtime/shared/llm/model-catalog.mjs

@@ -105,6 +105,7 @@ const _CATALOG_SIMPLE_PREFIXES = [
   'deepseek/',
   'openrouter/anthropic/',
   'openrouter/openai/',
+  'vertex_ai/',
 ];
 // Bedrock-style variants: catalog key = <prefix><id>-v1:0
 const _CATALOG_BEDROCK_PREFIXES = ['anthropic.', 'bedrock/anthropic.'];
@@ -123,6 +124,7 @@ const _PROVIDER_CATALOG_PREFIXES = {
   xai: ['xai/'],
   deepseek: ['deepseek/'],
   azure: ['azure_ai/'],
+  'google-vertex': ['vertex_ai/'],
 };
 function _prefixesForProvider(mappedProvider, allPrefixes) {
   if (!mappedProvider) return allPrefixes;
@@ -438,6 +440,26 @@ const PRICED_VARIANTS = Object.freeze({
   }),
 });
 
+// Vertex AI bills Claude and generally available Gemini 3+ models on regional
+// and multi-region endpoints 10% above the global list price (Standard and
+// Priority alike); the provider marks those requests' SKU `<id>@regional`.
+// https://docs.anthropic.com/en/docs/about-claude/pricing (verified 2026-10-27)
+// https://cloud.google.com/gemini-enterprise-agent-platform/generative-ai/pricing (verified 2026-10-28)
+const VERTEX_REGIONAL_SUFFIX = '@regional';
+function pricedVariant(provider, id) {
+  const listed = PRICED_VARIANTS[provider]?.[id];
+  if (listed) return listed;
+  if (provider === 'vertex-ai' && id.endsWith(VERTEX_REGIONAL_SUFFIX)) {
+    // The base row's own uplift wins; the documented 10% applies where the row has none.
+    return { base: id.slice(0, -VERTEX_REGIONAL_SUFFIX.length), rateMultiplier: 1.1, rowMultiplier: 'regionalUplift' };
+  }
+  // A pinned Vertex version (claude-sonnet-4-5@20250929, @default) bills as its
+  // model when no row prices the version itself.
+  const version = provider === 'vertex-ai' ? id.indexOf('@') : -1;
+  if (version > 0) return { base: id.slice(0, version), rateMultiplier: 1 };
+  return null;
+}
+
 // Cursor-billed rates no catalog publishes: Cursor's first-party SKUs and Fast
 // rates Cursor sells beyond the vendor's own catalog. `fast` is the rate of a
 // request Cursor ran in Fast mode. Other Cursor Fast requests bill at the
@@ -486,6 +508,7 @@ const PRICING_FIELDS = Object.freeze([
   'pricingTiers',
   'fastPricing',
   'ultrafastPricing',
+  'flexPricing',
   'offPeakMultiplier',
   'outputImageCostPerM',
   'outputVideoCostPerM',
@@ -649,17 +672,27 @@ function lookupModelMetadata(originalId, provider, catalog, modelsDevCatalog, li
   if (source?.relay && !hasRates(meta) && hasRates(guess)) {
     meta = meta ? { ...meta, ...pricingFields(guess) } : pricingOnly(guess);
   }
-  const variant = PRICED_VARIANTS[source?.provider || '']?.[id];
+  const variant = pricedVariant(source?.provider || '', id);
   if (variant && !hasRates(meta)) {
     const base = lookupModelMetadata(variant.base, provider, catalog, modelsDevCatalog);
     if (base && PRICING_RATE_KEYS.some((key) => base[key] != null)) {
-      meta = {
-        ...meta,
-        ...scaledRates(base, variant.rateMultiplier),
-        pricingTiers: (base.pricingTiers || []).map((tier) => ({
+      const factor = (variant.rowMultiplier && base[variant.rowMultiplier]) || variant.rateMultiplier;
+      const scaled = (rateSet) => ({
+        ...scaledRates(rateSet, factor),
+        pricingTiers: (rateSet.pricingTiers || []).map((tier) => ({
           ...tier,
-          ...scaledRates(tier, variant.rateMultiplier),
+          ...scaledRates(tier, factor),
         })),
+      });
+      meta = {
+        ...meta,
+        ...scaled(base),
+        // The variant's premium applies to every service tier the base publishes.
+        ...Object.fromEntries(
+          ['fastPricing', 'ultrafastPricing', 'flexPricing']
+            .filter((key) => base[key])
+            .map((key) => [key, scaled(base[key])])
+        ),
         pricingSource: base.pricingSource,
         supportsPromptCaching: base.supportsPromptCaching,
       };
@@ -740,6 +773,8 @@ function _normalize(entry) {
   // OpenAI's Priority processing (since renamed Fast mode) columns.
   const fastPricing = litellmPricing(entry, '_priority');
   const ultrafastPricing = litellmPricing(entry, '_ultrafast');
+  // Flex processing (Vertex Flex PayGo, OpenAI flex) columns.
+  const flexPricing = litellmPricing(entry, '_flex');
   return {
     contextWindow: entry.max_input_tokens || entry.max_tokens || null,
     outputTokens: entry.max_output_tokens || null,
@@ -747,7 +782,12 @@ function _normalize(entry) {
     ...litellmMediaPricing(entry),
     ...(PRICING_RATE_KEYS.some((key) => fastPricing[key] != null) ? { fastPricing } : {}),
     ...(PRICING_RATE_KEYS.some((key) => ultrafastPricing[key] != null) ? { ultrafastPricing } : {}),
+    ...(PRICING_RATE_KEYS.some((key) => flexPricing[key] != null) ? { flexPricing } : {}),
     ...(entry.off_peak_multiplier ? { offPeakMultiplier: entry.off_peak_multiplier } : {}),
+    // Vertex AI regional / multi-region endpoint premium over the global rate.
+    ...(entry.regional_endpoint_uplift_multiplier > 0
+      ? { regionalUplift: entry.regional_endpoint_uplift_multiplier }
+      : {}),
     // Tri-state: true/false as declared, undefined when the row is silent.
     supportsVision: capabilityFlag(entry.supports_vision),
     supportsFunctionCalling: capabilityFlag(entry.supports_function_calling),

package/src/runtime/shared/llm/provider-catalog-registry.mjs

@@ -58,6 +58,9 @@ const PROVIDER_CATALOGS = Object.freeze({
   anthropic: { modelsDev: 'anthropic', sameEndpoint: true, rosterFiles: ['anthropic-oauth-models.json'] },
   // generativelanguage.googleapis.com — the endpoint models.dev `google` describes.
   gemini: { modelsDev: 'google', sameEndpoint: true, rosterFiles: ['gemini-models.json'] },
+  // *aiplatform.googleapis.com: Gemini and Claude publisher models, priced by
+  // the LiteLLM `vertex_ai/` rows (model-catalog.mjs prefix table).
+  'vertex-ai': { modelsDev: 'google-vertex', sameEndpoint: true },
   // cli-chat-proxy.grok.com, not api.x.ai.
   'grok-oauth': {
     modelsDev: 'xai',