@undefineds.co/xpod 0.4.11 → 0.4.12

package/dist/api/ai-gateway/models/ProviderModelSelectionService.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderModelSelectionService = void 0;
 const PlaintextCredentialPayload_1 = require("../credentials/PlaintextCredentialPayload");
 const errors_1 = require("../errors");
+const EmbeddingModelPolicy_1 = require("../../../ai/service/EmbeddingModelPolicy");
 const ProviderRegistry_1 = require("../providers/ProviderRegistry");
 const ProviderModelDiscoveryAdapters_1 = require("./ProviderModelDiscoveryAdapters");
+const ProviderModelType_1 = require("./ProviderModelType");
 const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
 /**
  * Coordinates short-lived provider discovery with durable Pod selections.
@@ -32,11 +34,13 @@ class ProviderModelSelectionService {
         this.baseUrlForProvider = options.baseUrlForProvider;
         this.modelsService = options.modelsService;
         this.credentialVault = options.credentialVault;
+        this.embeddingModelPolicy = options.embeddingModelPolicy ?? EmbeddingModelPolicy_1.EmbeddingModelPolicy.allowAll();
         this.now = options.now ?? (() => new Date());
         this.cacheTtlMs = normalizeCacheTtl(options.cacheTtlMs);
     }
     async discover(input) {
         const normalizedProvider = normalizeProvider(input.provider);
+        this.requireProvidedProvider(normalizedProvider, input.deployment);
         const credential = await this.resolveCredential(input, normalizedProvider);
         const context = this.discoveryContext(normalizedProvider, credential);
         const key = cacheKey(input.webId, normalizedProvider, input.deployment, context);
@@ -82,6 +86,7 @@ class ProviderModelSelectionService {
     }
     async replaceSelection(input) {
         const normalizedProvider = normalizeProvider(input.provider);
+        this.requireProvidedProvider(normalizedProvider, input.deployment);
         const credential = await this.resolveOptionalCredential(input, normalizedProvider);
         const context = credential ? this.discoveryContext(normalizedProvider, credential) : undefined;
         const key = cacheKey(input.webId, normalizedProvider, input.deployment, context);
@@ -115,6 +120,12 @@ class ProviderModelSelectionService {
         if (input.defaultModel !== undefined && !availableById.has(modelIdentity(input.defaultModel))) {
             throw modelNotInCatalogError(normalizedProvider, input.defaultModel);
         }
+        assertEmbeddingSelectionAllowed({
+            provider: normalizedProvider,
+            modelIds: input.modelIds,
+            availableById,
+            policy: this.embeddingModelPolicy,
+        });
         const next = await this.selectionRepository.replaceSelection({
             webId: input.webId,
             provider: normalizedProvider,
@@ -122,7 +133,7 @@ class ProviderModelSelectionService {
                 const discovered = availableById.get(modelIdentity(modelId));
                 return {
                     id: modelId,
-                    modelType: discovered?.modelType ?? 'other',
+                    modelType: discovered?.modelType ?? 'chat',
                     status: 'active',
                     ...(discovered?.displayName ? { displayName: discovered.displayName } : {}),
                 };
@@ -219,13 +230,13 @@ class ProviderModelSelectionService {
             return result.models.map((model) => ({
                 id: model.id,
                 ...(model.displayName ? { displayName: model.displayName } : {}),
-                modelType: model.modelType ?? inferModelType(model.id),
+                modelType: model.modelType ?? (0, ProviderModelType_1.inferProviderModelType)({}, model.id),
             }));
         }
         if (offering?.modelDiscovery.strategy === 'unsupported') {
             return this.providerRegistry.requireProvider(input.input.provider).models.map((model) => ({
                 id: model.id,
-                modelType: inferModelType(model.id),
+                modelType: (0, ProviderModelType_1.inferProviderModelType)({}, model.id),
             }));
         }
         const adapter = this.discoveryRegistry.get(input.input.provider);
@@ -242,6 +253,16 @@ class ProviderModelSelectionService {
         };
         return adapter.discover(adapterInput);
     }
+    /** Cloud settings only manage providers this deployment provides. */
+    requireProvidedProvider(provider, deployment) {
+        if (deployment && !this.providerRegistry.isProvidedInDeployment(provider, deployment)) {
+            throw new errors_1.GatewayProtocolError('provider_not_available_in_deployment', {
+                code: 'invalid_request',
+                status: 403,
+                details: { provider },
+            });
+        }
+    }
     async resolveCredential(input, provider) {
         const credential = input.credentialId && this.credentialRepository.getCredentialById
             ? await this.credentialRepository.getCredentialById({
@@ -345,20 +366,6 @@ function stringValue(value) {
 function normalizeCompatibility(value) {
     return value === 'auto' || value === 'openai' || value === 'anthropic' ? value : undefined;
 }
-function inferModelType(id) {
-    const normalized = id.toLowerCase();
-    if (/(?:embedding|embed)/u.test(normalized))
-        return 'embedding';
-    if (/(?:dall[-_ ]?e|stable[-_ ]?diffusion|flux|imagen|midjourney|image[-_ ]?(?:generation|gen))/u.test(normalized)) {
-        return 'image';
-    }
-    if (/(?:whisper|tts|speech|musicgen|audio[-_ ]?(?:generation|gen))/u.test(normalized))
-        return 'audio';
-    if (/(?:chat|completion|conversation|text[-_ ]?generation|instruct|reason|coder|gpt|claude|kimi|qwen|deepseek|llama|mistral|gemini)/u.test(normalized)) {
-        return 'chat';
-    }
-    return 'other';
-}
 function normalizeCacheTtl(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0
         ? value
@@ -461,10 +468,14 @@ function cloneCatalog(catalog) {
         models: catalog.models.map((model) => ({ ...model })),
     };
 }
+/**
+ * A catalog type is one of the two classes the Pod can store.
+ *
+ * Anything else - an older row, a provider's own vocabulary - reads as a chat
+ * model rather than as a value the AI config write would reject.
+ */
 function normalizeCatalogModelType(value) {
-    return value === 'chat' || value === 'embedding' || value === 'image' || value === 'audio' || value === 'other'
-        ? value
-        : 'other';
+    return value === 'embedding' ? 'embedding' : 'chat';
 }
 function activeCredentialRequiredError(provider) {
     return new errors_1.GatewayProtocolError('active_credential_required', {
@@ -480,6 +491,32 @@ function modelNotInCatalogError(provider, modelId) {
         details: { provider, modelId },
     });
 }
+/**
+ * Discovery reports whatever a BYOK endpoint advertises, so a selected embedding
+ * model still has to be provided by the gateway catalog. Selecting one that is
+ * not would otherwise advertise an arbitrary embedding model in Cloud.
+ */
+function assertEmbeddingSelectionAllowed(input) {
+    if (!input.policy.isEnforced()) {
+        return;
+    }
+    for (const modelId of input.modelIds) {
+        const identity = modelIdentity(modelId);
+        const discovered = input.availableById.get(identity);
+        const embedding = discovered?.modelType === 'embedding'
+            || (0, ProviderModelType_1.inferProviderModelType)({}, identity) === 'embedding';
+        if (!embedding) {
+            continue;
+        }
+        if (!input.policy.isAllowed({ provider: input.provider, model: identity })) {
+            throw new errors_1.GatewayProtocolError('embedding_model_not_allowed', {
+                code: 'embedding_model_not_allowed',
+                status: 400,
+                details: { provider: input.provider, modelId: identity },
+            });
+        }
+    }
+}
 function modelSelectionDefaultNotPickedError(provider, defaultModel) {
     return new errors_1.GatewayProtocolError('model_selection_default_not_picked', {
         code: 'invalid_request',

package/dist/api/ai-gateway/models/ProviderModelType.d.ts

@@ -0,0 +1,28 @@
+/**
+ * What kind of model an upstream `/models` entry is, as Xpod records it.
+ *
+ * Discovery answers exactly one question the product acts on: is this an
+ * embedding model, or is it a chat model? Embedding is the value the embedding
+ * allowlist filters on and the one the settings list marks with a glyph, and the
+ * Pod stores such a row as `EmbeddingModel`; everything else is a chat model.
+ *
+ * The vocabulary is deliberately this short. A Pod row's class has to be one the
+ * shared schema knows (`toAIModelClassUri` in `@undefineds.co/models`); a third
+ * value invented here - `other`, `audio` - makes the AI config write throw
+ * `Unsupported AI model class`, so a synced list would stop being writable. Any
+ * finer distinction belongs to a model's capabilities, not to this column.
+ *
+ * Both discovery paths read the same provider payloads - the adapters behind
+ * `POST …/models/refresh` (同步模型) and the per-provider discovery adapters
+ * behind the selection service - so the rule lives here once and both import it.
+ */
+export type DiscoveredProviderModelType = 'chat' | 'embedding';
+/**
+ * Model type for one upstream entry.
+ *
+ * An explicit field the provider sends wins; otherwise the id is the only
+ * evidence available, and embeddings are the one kind that must never be missed:
+ * the embedding allowlist filters on this value, so a missed embedding model
+ * disappears from model management.
+ */
+export declare function inferProviderModelType(record: Record<string, unknown>, id: string): DiscoveredProviderModelType;

package/dist/api/ai-gateway/models/ProviderModelType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferProviderModelType = inferProviderModelType;
+/**
+ * Model type for one upstream entry.
+ *
+ * An explicit field the provider sends wins; otherwise the id is the only
+ * evidence available, and embeddings are the one kind that must never be missed:
+ * the embedding allowlist filters on this value, so a missed embedding model
+ * disappears from model management.
+ */
+function inferProviderModelType(record, id) {
+    if (explicitProviderModelType(record) === 'embedding') {
+        return 'embedding';
+    }
+    return /(?:embedding|embed)/u.test(id.toLowerCase()) ? 'embedding' : 'chat';
+}
+/** The kind the provider payload itself declares, when it declares one. */
+function explicitProviderModelType(record) {
+    for (const value of [record.modelType, record.model_type, record.type, record.object, record.category]) {
+        if (typeof value !== 'string') {
+            continue;
+        }
+        const normalized = value.trim().toLowerCase();
+        if (!normalized || normalized === 'model') {
+            continue;
+        }
+        if (/(?:embedding|embed)/u.test(normalized)) {
+            return 'embedding';
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=ProviderModelType.js.map

package/dist/api/ai-gateway/models/ProviderModelsAdapter.d.ts

@@ -2,10 +2,20 @@ import type { ConnectCredentialRecord } from '../connect';
 import type { ProviderSecret } from '../credentials/CredentialVault';
 import { ProviderHttpTransport } from '../../service/provider-http-transport';
 import type { ProviderProductDescriptor, ProviderRegistry } from '../providers/ProviderRegistry';
+import { type DiscoveredProviderModelType } from './ProviderModelType';
 export interface DiscoveredProviderModel {
     id: string;
     displayName?: string;
     capabilities?: string[];
+    /**
+     * What the model is for, inferred from the provider payload.
+     *
+     * Discovery keeps embedding models in the list, and every consumer of this
+     * shape - the Pod row written on sync, the settings model list, the embedding
+     * allowlist - reads the type from here. Dropping it stores an embedding model
+     * as an ordinary one, which is how it disappears from model management.
+     */
+    modelType?: DiscoveredProviderModelType;
     availability?: 'available' | 'unavailable';
     metadata?: {
         sources?: ProviderModelDiscoverySource[];

package/dist/api/ai-gateway/models/ProviderModelsAdapter.js

@@ -5,6 +5,7 @@ exports.resolveSafeModelsBaseUrl = resolveSafeModelsBaseUrl;
 exports.normalizeDiscoveredModels = normalizeDiscoveredModels;
 const ProviderQuotaAdapter_1 = require("../quota/ProviderQuotaAdapter");
 const provider_http_transport_1 = require("../../service/provider-http-transport");
+const ProviderModelType_1 = require("./ProviderModelType");
 class ProviderModelsFetchError extends Error {
     constructor(providerStatus, retryAfter, providerMessage) {
         super(`provider_models_fetch_failed:${providerStatus}`);
@@ -340,7 +341,7 @@ function normalizeDiscoveredModels(payload) {
         }
         const record = item;
         const id = String(record.id ?? record.name ?? record.model ?? record.slug ?? record.uid ?? '').trim();
-        if (!id || seen.has(id) || isEmbeddingModel(id)) {
+        if (!id || seen.has(id)) {
             continue;
         }
         seen.add(id);
@@ -350,6 +351,7 @@ function normalizeDiscoveredModels(payload) {
             id,
             ...(displayName && displayName !== id ? { displayName } : {}),
             ...(capabilities.length > 0 ? { capabilities } : {}),
+            modelType: (0, ProviderModelType_1.inferProviderModelType)(record, id),
         });
     }
     return models;
@@ -406,9 +408,6 @@ function extractModelList(payload) {
     }
     return [];
 }
-function isEmbeddingModel(id) {
-    return /embed/i.test(id);
-}
 function stringValue(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }

package/dist/api/ai-gateway/models/index.d.ts

@@ -1,4 +1,5 @@
 export { AnthropicModelsAdapter, CodexSubscriptionModelsAdapter, OpenAiCompatibleModelsAdapter, ProviderModelsFetchError, ProviderModelsResponseError, normalizeDiscoveredModels, type DiscoveredProviderModel, type ModelsCredentialRecord, type ProviderModelsAdapter, type ProviderModelsFetchInput, } from './ProviderModelsAdapter';
 export { ProviderModelsService, type ProviderModelDiscovery, type ProviderModelsServiceOptions, } from './ProviderModelsService';
 export { ProviderCustomModelsService, type ProviderCustomModelsServiceOptions, } from './ProviderCustomModelsService';
+export { createGatewayEmbeddingModelCatalog } from './GatewayEmbeddingModelCatalog';
 export type { CustomProviderModel } from '../connect';

package/dist/api/ai-gateway/models/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProviderCustomModelsService = exports.ProviderModelsService = exports.normalizeDiscoveredModels = exports.ProviderModelsResponseError = exports.ProviderModelsFetchError = exports.OpenAiCompatibleModelsAdapter = exports.CodexSubscriptionModelsAdapter = exports.AnthropicModelsAdapter = void 0;
+exports.createGatewayEmbeddingModelCatalog = exports.ProviderCustomModelsService = exports.ProviderModelsService = exports.normalizeDiscoveredModels = exports.ProviderModelsResponseError = exports.ProviderModelsFetchError = exports.OpenAiCompatibleModelsAdapter = exports.CodexSubscriptionModelsAdapter = exports.AnthropicModelsAdapter = void 0;
 var ProviderModelsAdapter_1 = require("./ProviderModelsAdapter");
 Object.defineProperty(exports, "AnthropicModelsAdapter", { enumerable: true, get: function () { return ProviderModelsAdapter_1.AnthropicModelsAdapter; } });
 Object.defineProperty(exports, "CodexSubscriptionModelsAdapter", { enumerable: true, get: function () { return ProviderModelsAdapter_1.CodexSubscriptionModelsAdapter; } });
@@ -12,4 +12,6 @@ var ProviderModelsService_1 = require("./ProviderModelsService");
 Object.defineProperty(exports, "ProviderModelsService", { enumerable: true, get: function () { return ProviderModelsService_1.ProviderModelsService; } });
 var ProviderCustomModelsService_1 = require("./ProviderCustomModelsService");
 Object.defineProperty(exports, "ProviderCustomModelsService", { enumerable: true, get: function () { return ProviderCustomModelsService_1.ProviderCustomModelsService; } });
+var GatewayEmbeddingModelCatalog_1 = require("./GatewayEmbeddingModelCatalog");
+Object.defineProperty(exports, "createGatewayEmbeddingModelCatalog", { enumerable: true, get: function () { return GatewayEmbeddingModelCatalog_1.createGatewayEmbeddingModelCatalog; } });
 //# sourceMappingURL=index.js.map

package/dist/api/ai-gateway/providers/CustomRuntimeAdapter.d.ts

@@ -6,9 +6,16 @@ export declare class CustomRuntimeAdapter implements ProviderRuntimeAdapter {
     readonly provider = "custom";
     private readonly openai;
     private readonly anthropic;
+    /**
+     * A user-owned endpoint is a Local capability: the operator cannot vouch for
+     * it, so Cloud never sends a provider key to a Pod-supplied base URL. Cloud
+     * therefore resolves `custom` against the catalog's placeholder endpoint and
+     * rejects the request instead of following the Pod.
+     */
     constructor(input: {
         transport: ProviderHttpTransport;
         descriptor: ProviderDescriptor;
+        allowCredentialBaseUrl?: boolean;
     });
     execute(input: ProviderRuntimeExecuteInput): AsyncIterable<GatewayEvent>;
 }

package/dist/api/ai-gateway/providers/CustomRuntimeAdapter.js

@@ -5,15 +5,22 @@ const errors_1 = require("../errors");
 const AnthropicRuntimeAdapter_1 = require("./AnthropicRuntimeAdapter");
 const ProviderRuntimeAdapter_1 = require("./ProviderRuntimeAdapter");
 class CustomRuntimeAdapter {
+    /**
+     * A user-owned endpoint is a Local capability: the operator cannot vouch for
+     * it, so Cloud never sends a provider key to a Pod-supplied base URL. Cloud
+     * therefore resolves `custom` against the catalog's placeholder endpoint and
+     * rejects the request instead of following the Pod.
+     */
     constructor(input) {
         this.provider = 'custom';
+        const options = { allowCredentialBaseUrl: input.allowCredentialBaseUrl ?? true };
         this.openai = new ProviderRuntimeAdapter_1.OpenAiCompatibleRuntimeAdapter({
             transport: input.transport,
             provider: 'custom',
             descriptor: input.descriptor,
             defaultBaseUrl: input.descriptor.defaultBaseUrl,
             safeBaseUrls: input.descriptor.safeBaseUrls,
-            allowCredentialBaseUrl: true,
+            allowCredentialBaseUrl: options.allowCredentialBaseUrl,
             supportsImages: input.descriptor.capabilities.imageInput,
             supportsDeveloperMessages: true,
             allowToolChoiceRequired: true,
@@ -23,7 +30,7 @@ class CustomRuntimeAdapter {
             provider: 'custom',
             defaultBaseUrl: input.descriptor.defaultBaseUrl,
             safeBaseUrls: input.descriptor.safeBaseUrls,
-            allowCredentialBaseUrl: true,
+            allowCredentialBaseUrl: options.allowCredentialBaseUrl,
         });
     }
     async *execute(input) {

package/dist/api/ai-gateway/providers/ModelsDevCatalog.d.ts

@@ -1,6 +1,12 @@
+import { XPOD_PROVIDER_TO_MODELS_DEV } from './ProviderRegistry';
 import type { ProviderModelDescriptor, ProviderRegistry } from './ProviderRegistry';
 export declare const MODELS_DEV_API_URL = "https://models.dev/api.json";
-export declare const XPOD_PROVIDER_TO_MODELS_DEV: Record<string, string>;
+/**
+ * models.dev provider id per gateway catalog provider id. The mapping is a
+ * projection of `MANAGED_PROVIDER_VOCABULARY`, the single provider-vocabulary
+ * block: this module does not keep its own translation table.
+ */
+export { XPOD_PROVIDER_TO_MODELS_DEV };
 export interface ModelsDevModel {
     id: string;
     name?: string;

package/dist/api/ai-gateway/providers/ModelsDevCatalog.js

@@ -8,17 +8,11 @@ exports.lookupModelsDevModelDescriptor = lookupModelsDevModelDescriptor;
 exports.syncProviderRegistryWithModelsDev = syncProviderRegistryWithModelsDev;
 exports.syncProviderRegistryFromModelsDev = syncProviderRegistryFromModelsDev;
 const global_logger_factory_1 = require("global-logger-factory");
+const ProviderRegistry_1 = require("./ProviderRegistry");
+Object.defineProperty(exports, "XPOD_PROVIDER_TO_MODELS_DEV", { enumerable: true, get: function () { return ProviderRegistry_1.XPOD_PROVIDER_TO_MODELS_DEV; } });
 exports.MODELS_DEV_API_URL = 'https://models.dev/api.json';
 const DEFAULT_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_TIMEOUT_MS = 10_000;
-exports.XPOD_PROVIDER_TO_MODELS_DEV = {
-    openai: 'openai',
-    anthropic: 'anthropic',
-    kimi: 'moonshotai',
-    bailian: 'alibaba-cn',
-    deepseek: 'deepseek',
-    zhipu: 'zhipuai',
-};
 let catalogCache;
 function resetModelsDevCatalogCache() {
     catalogCache = undefined;
@@ -85,7 +79,7 @@ function modelsDevModelDescriptors(provider) {
  * Used to enrich gateway projections for models that are absent from the static registry
  * (e.g. newly released models discovered via the provider's live /models endpoint).
  */
-function lookupModelsDevModelDescriptor(providerId, modelId, mapping = exports.XPOD_PROVIDER_TO_MODELS_DEV) {
+function lookupModelsDevModelDescriptor(providerId, modelId, mapping = ProviderRegistry_1.XPOD_PROVIDER_TO_MODELS_DEV) {
     const modelsDevId = mapping[providerId];
     const models = modelsDevId ? catalogCache?.catalog[modelsDevId]?.models : undefined;
     if (!models) {
@@ -98,7 +92,7 @@ function lookupModelsDevModelDescriptor(providerId, modelId, mapping = exports.X
     }
     return modelsDevModelDescriptors({ id: modelsDevId, models: { [model.id]: model } })[0];
 }
-function syncProviderRegistryWithModelsDev(registry, catalog, mapping = exports.XPOD_PROVIDER_TO_MODELS_DEV) {
+function syncProviderRegistryWithModelsDev(registry, catalog, mapping = ProviderRegistry_1.XPOD_PROVIDER_TO_MODELS_DEV) {
     const synced = [];
     for (const [providerId, modelsDevId] of Object.entries(mapping)) {
         const entry = catalog[modelsDevId];

package/dist/api/ai-gateway/providers/ProviderRegistry.d.ts

@@ -78,7 +78,64 @@ export interface ProviderCapabilities {
     reasoningEffort?: boolean;
     imageInput?: boolean;
     promptCaching?: boolean;
+    /**
+     * Catalog marker for embedding models. This provider catalog is the single
+     * authority for the embedding models a deployment provides, so a model only
+     * becomes embeddable by being registered here (or merged from models.dev with
+     * this capability already set). User-declared custom models cannot add it.
+     */
+    embedding?: boolean;
+    /**
+     * Curated fast-tier marker.
+     *
+     * Neither this catalog nor models.dev carries latency data, so "fast" is a
+     * published judgement about a model's tier rather than a measurement. It is
+     * surfaced to clients as the `fast` capability token.
+     */
+    fast?: boolean;
 }
+/**
+ * One row per managed provider: every vocabulary that names it.
+ *
+ * Pod AI config, credentials and the default embedding profile name providers in
+ * their own vocabulary (`dashscope`, `qwen`, `moonshot`, ...), while the gateway
+ * catalog names the product (`bailian`, `kimi`, ...), and the catalogs we
+ * project from name it again (`qwen`, `alibaba-cn`, `moonshotai`, `zhipuai`).
+ * Keeping all of that in one block means every model-policy check compares
+ * against one provider identity instead of each caller inventing its own
+ * aliases, and adding a provider cannot leave one of the parallel translations
+ * behind.
+ */
+export interface ManagedProviderVocabulary {
+    /** Canonical gateway catalog provider id. */
+    readonly id: string;
+    /**
+     * Runtime vocabularies that resolve to `id`. The id itself is always an
+     * accepted spelling and does not need to be repeated here.
+     */
+    readonly runtimeIds: readonly string[];
+    /**
+     * Slug of the same provider in the bundled `@undefineds.co/models` discovery
+     * catalog. Defaults to `id` when the two agree.
+     */
+    readonly discoverySlug?: string;
+    /** Provider id in models.dev. Absent when models.dev does not carry the provider. */
+    readonly modelsDevId?: string;
+}
+export declare const MANAGED_PROVIDER_VOCABULARY: readonly ManagedProviderVocabulary[];
+/**
+ * Runtime vocabulary to canonical provider id, derived from
+ * `MANAGED_PROVIDER_VOCABULARY`.
+ *
+ * `ProviderRegistry.resolveManagedProviderId` is the translation entry point:
+ * it validates the canonical id against the registered catalog, which a raw
+ * table lookup cannot do.
+ */
+export declare const MANAGED_PROVIDER_ALIASES: Record<string, string>;
+/** Discovery-catalog slug of a gateway catalog provider id (identity when undeclared). */
+export declare function discoveryProviderSlug(providerId: string): string;
+/** models.dev provider ids keyed by gateway catalog provider id, derived from the vocabulary block. */
+export declare const XPOD_PROVIDER_TO_MODELS_DEV: Record<string, string>;
 export interface ProviderModelDescriptor {
     id: string;
     aliases?: string[];
@@ -118,12 +175,43 @@ export declare class ProviderRegistry {
     getProvider(provider: string): ProviderDescriptor | undefined;
     requireProvider(provider: string): ProviderDescriptor;
     listProviders(): ProviderDescriptor[];
+    /**
+     * Resolve a runtime provider vocabulary entry to the catalog provider that
+     * owns it. Unknown providers stay unresolved so a deployment can never treat
+     * a Pod-invented provider id as a catalog provider.
+     */
+    resolveManagedProviderId(provider: string): string | undefined;
+    /**
+     * Whether this deployment offers the provider at all.
+     *
+     * Cloud only offers the operator-designated providers with the endpoints the
+     * catalog names: a self-hosted `custom` endpoint or a local-daemon provider
+     * such as Ollama is a Local-only capability, because there the user owns the
+     * endpoint.
+     */
+    isProvidedInDeployment(provider: string, deployment: string): boolean;
+    listProvidedProviders(deployment: string): ProviderDescriptor[];
+    /**
+     * Embedding models this catalog provides for a provider. This is the authority
+     * for embedding model policy; anything absent is not provided by the gateway.
+     */
+    listManagedEmbeddingModels(provider: string): ProviderModelDescriptor[];
+    isManagedEmbeddingModel(provider: string, modelId: string): boolean;
     getProduct(product: string): ProviderProductDescriptor | undefined;
     requireProduct(product: string): ProviderProductDescriptor;
     listProducts(): ProviderProductDescriptor[];
     getOffering(product: string, offeringId: string): ProviderOfferingDescriptor | undefined;
     requireOffering(product: string, offeringId: string): ProviderOfferingDescriptor;
     resolveAlias(model: string): ModelAliasTarget | undefined;
+    /**
+     * Catalog descriptor for one model of one provider, matched by id or alias.
+     *
+     * Provider vocabularies differ between the Pod configuration and the catalog,
+     * so the runtime id is resolved through the same alias table the model-policy
+     * checks use. An unknown provider stays unresolved rather than falling back to
+     * another provider's catalog entry.
+     */
+    getModelDescriptor(provider: string, modelId: string): ProviderModelDescriptor | undefined;
     findModel(model: string): Array<{
         provider: ProviderDescriptor;
         model: ProviderModelDescriptor;
@@ -132,6 +220,25 @@ export declare class ProviderRegistry {
 }
 export declare function createDefaultProviderRegistry(options?: ProviderRegistryOptions): ProviderRegistry;
 export declare function providerProductsForDeployment(deployment: 'local' | 'cloud'): ProviderProductDescriptor[];
+/**
+ * Whether one declared upstream capability assigns a protocol+profile to a
+ * product offering under the credential kind that would use it.
+ *
+ * `PROVIDER_UPSTREAM_OVERRIDES` is the axis's single authority for the
+ * offering→capability mapping and `QuotaCapabilityRegistry` dispatches handlers
+ * from the protocol+profile declared here. A handler that needs to know whether
+ * an offering is its own asks the declaration instead of comparing offering id
+ * literals in `supports()`, which would be a second copy of this table.
+ *
+ * A capability may narrow itself to the credential auth modes it serves
+ * (`options.credentialAuthModes`); without that option every credential kind the
+ * Offering publishes is served. When the declaration narrows the kinds and the
+ * caller does not know the credential kind, the offering cannot be claimed.
+ */
+export declare function offeringDeclaresUpstreamCapability(product: string, offeringId: string | undefined, capability: {
+    protocol: string;
+    profile?: string;
+}, credentialAuthMode?: string): boolean;
 /**
  * The provider/offering catalog belongs to `@undefineds.co/ai-connections`: it
  * is content rather than schema, and it carries endpoints, console links and