@undefineds.co/xpod 0.4.10 → 0.4.12

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

@@ -1,13 +1,49 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_PROVIDER_DESCRIPTORS = exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS = exports.ProviderRegistry = exports.OPENAI_SUBSCRIPTION_BASE_URL = void 0;
+exports.DEFAULT_PROVIDER_DESCRIPTORS = exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS = exports.ProviderRegistry = exports.XPOD_PROVIDER_TO_MODELS_DEV = exports.MANAGED_PROVIDER_ALIASES = exports.MANAGED_PROVIDER_VOCABULARY = exports.OPENAI_SUBSCRIPTION_BASE_URL = void 0;
+exports.discoveryProviderSlug = discoveryProviderSlug;
 exports.createDefaultProviderRegistry = createDefaultProviderRegistry;
 exports.providerProductsForDeployment = providerProductsForDeployment;
+exports.offeringDeclaresUpstreamCapability = offeringDeclaresUpstreamCapability;
 exports.normalizeProviderId = normalizeProviderId;
 const models_1 = require("@undefineds.co/models");
+const defaultEmbeddingProfile_1 = require("../../../ai/service/defaultEmbeddingProfile");
 const provider_catalog_1 = require("@undefineds.co/ai-connections/provider-catalog");
 const OfferingAuthorization_1 = require("./OfferingAuthorization");
 exports.OPENAI_SUBSCRIPTION_BASE_URL = 'https://chatgpt.com/backend-api/codex';
+exports.MANAGED_PROVIDER_VOCABULARY = [
+    { id: 'openai', runtimeIds: ['codex'], modelsDevId: 'openai' },
+    { id: 'anthropic', runtimeIds: ['claude'], modelsDevId: 'anthropic' },
+    { id: 'kimi', runtimeIds: ['moonshot', 'moonshotai'], discoverySlug: 'moonshot', modelsDevId: 'moonshotai' },
+    {
+        id: 'bailian',
+        runtimeIds: ['dashscope', 'dashscope-cn', 'dashscope-intl', 'qwen', 'alibaba'],
+        discoverySlug: 'qwen',
+        modelsDevId: 'alibaba-cn',
+    },
+    { id: 'deepseek', runtimeIds: [], modelsDevId: 'deepseek' },
+    { id: 'zhipu', runtimeIds: ['zhipuai', 'bigmodel', 'glm'], modelsDevId: 'zhipuai' },
+    { id: 'ollama', runtimeIds: [] },
+];
+/**
+ * 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.
+ */
+exports.MANAGED_PROVIDER_ALIASES = Object.fromEntries(exports.MANAGED_PROVIDER_VOCABULARY.flatMap((provider) => [provider.id, ...provider.runtimeIds].map((runtimeId) => [runtimeId, provider.id])));
+/** Discovery-catalog slug of a gateway catalog provider id (identity when undeclared). */
+function discoveryProviderSlug(providerId) {
+    return managedProviderVocabulary(providerId)?.discoverySlug ?? providerId;
+}
+/** models.dev provider ids keyed by gateway catalog provider id, derived from the vocabulary block. */
+exports.XPOD_PROVIDER_TO_MODELS_DEV = Object.fromEntries(exports.MANAGED_PROVIDER_VOCABULARY.flatMap((provider) => provider.modelsDevId ? [[provider.id, provider.modelsDevId]] : []));
+function managedProviderVocabulary(providerId) {
+    const canonical = exports.MANAGED_PROVIDER_ALIASES[normalizeProviderId(providerId)] ?? normalizeProviderId(providerId);
+    return exports.MANAGED_PROVIDER_VOCABULARY.find((provider) => provider.id === canonical);
+}
 const RESERVED_DISCOVERY_METADATA_KEYS = new Set([
     'baseUrl',
     'base_url',
@@ -77,6 +113,63 @@ class ProviderRegistry {
     listProviders() {
         return Array.from(this.providers.values());
     }
+    /**
+     * 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) {
+        const normalized = normalizeProviderId(provider);
+        if (!normalized) {
+            return undefined;
+        }
+        const canonical = exports.MANAGED_PROVIDER_ALIASES[normalized] ?? normalized;
+        return this.providers.has(canonical) ? canonical : 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, deployment) {
+        if (deployment !== 'cloud') {
+            return true;
+        }
+        const providerId = normalizeProviderId(provider);
+        if (!providerId || providerId === 'custom') {
+            return false;
+        }
+        if (!this.providers.has(providerId)) {
+            return false;
+        }
+        return this.products.get(providerId)?.offerings.some((offering) => offering.kind !== 'local') === true;
+    }
+    listProvidedProviders(deployment) {
+        return this.listProviders().filter((provider) => this.isProvidedInDeployment(provider.id, deployment));
+    }
+    /**
+     * 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) {
+        const providerId = this.resolveManagedProviderId(provider);
+        const descriptor = providerId ? this.providers.get(providerId) : undefined;
+        if (!descriptor) {
+            return [];
+        }
+        return descriptor.models.filter((model) => model.capabilities?.embedding === true);
+    }
+    isManagedEmbeddingModel(provider, modelId) {
+        const model = normalizeKey(modelId);
+        if (!model) {
+            return false;
+        }
+        return this.listManagedEmbeddingModels(provider).some((candidate) => normalizeKey(candidate.id) === model
+            || (candidate.aliases ?? []).some((alias) => normalizeKey(alias) === model));
+    }
     getProduct(product) {
         const normalized = normalizeProviderId(product);
         return this.products.get(normalized) ?? this.productByRuntimeProvider.get(normalized);
@@ -103,6 +196,24 @@ class ProviderRegistry {
     resolveAlias(model) {
         return this.aliases.get(normalizeKey(model));
     }
+    /**
+     * 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, modelId) {
+        const providerId = this.resolveManagedProviderId(provider);
+        const descriptor = providerId ? this.providers.get(providerId) : undefined;
+        const normalizedModel = normalizeKey(modelId);
+        if (!descriptor || !normalizedModel) {
+            return undefined;
+        }
+        return descriptor.models.find((candidate) => normalizeKey(candidate.id) === normalizedModel
+            || (candidate.aliases ?? []).some((alias) => normalizeKey(alias) === normalizedModel));
+    }
     findModel(model) {
         const normalizedModel = normalizeKey(model);
         const matches = [];
@@ -134,6 +245,27 @@ exports.ProviderRegistry = ProviderRegistry;
 function createDefaultProviderRegistry(options = {}) {
     return new ProviderRegistry(exports.DEFAULT_PROVIDER_DESCRIPTORS, options);
 }
+/**
+ * An offering's own connect entry, narrowed to the server's descriptor type.
+ * The catalog owns the declaration (id, mode, label); this deployment only says
+ * whether the offering it belongs to is usable at all, the same way the derived
+ * api-key entry does.
+ */
+function catalogAuthorizationMethod(method, offeringLifecycle) {
+    const connectMode = method.connectMode === 'browserAssistedApiKey'
+        || method.connectMode === 'deviceCodeOAuth'
+        || method.connectMode === 'authorizationCodeOAuth'
+        ? method.connectMode
+        : undefined;
+    return {
+        id: method.id,
+        authMode: method.authMode,
+        ...(connectMode ? { connectMode } : {}),
+        label: method.label,
+        lifecycle: offeringLifecycle === 'unavailable' ? 'unavailable' : method.lifecycle ?? 'active',
+        ...(method.reason ? { reason: method.reason } : {}),
+    };
+}
 function providerProductsForDeployment(deployment) {
     return exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS.map((product) => ({
         ...product,
@@ -141,10 +273,7 @@ function providerProductsForDeployment(deployment) {
             const binding = OfferingAuthorization_1.SUBSCRIPTION_AUTHORIZATION_BINDINGS.find((candidate) => candidate.provider === product.id && candidate.offeringId === offering.id);
             const authorizationMethods = [];
             if (offering.authModes.includes('apiKey')) {
-                authorizationMethods.push({
-                    id: 'api-key', authMode: 'apiKey', label: '添加 API Key',
-                    lifecycle: offering.lifecycle === 'unavailable' ? 'unavailable' : 'active',
-                });
+                authorizationMethods.push(catalogAuthorizationMethod(provider_catalog_1.API_KEY_METHOD, offering.lifecycle));
             }
             if (binding) {
                 authorizationMethods.push(...(0, OfferingAuthorization_1.subscriptionAuthorizationMethods)(deployment, binding));
@@ -155,11 +284,20 @@ function providerProductsForDeployment(deployment) {
                     lifecycle: offering.lifecycle === 'unavailable' ? 'unavailable' : 'active',
                 });
             }
-            else if (offering.authModes.some((mode) => mode === 'oauth' || mode === 'deviceCode')) {
-                authorizationMethods.push({
-                    id: 'device-code', authMode: 'deviceCode', connectMode: 'deviceCodeOAuth',
-                    label: '浏览器登录', lifecycle: 'unavailable', reason: '此授权方式尚未接入。',
-                });
+            // An oauth/deviceCode mode with no integration binding is a capability this
+            // build has not implemented, and it is omitted rather than published as a
+            // disabled entry: a button that cannot be pressed together with an internal
+            // reason is noise, and the offering's own lifecycle already says it is not
+            // available here. Entries that are merely unavailable in this deployment
+            // (cloud without a local callback, cloud without session import) come from
+            // the binding above and keep their place and their reason.
+            //
+            // The catalog's own connect entries, such as the browser-assisted console
+            // login, supplement the derived ones instead of replacing them.
+            for (const declared of offering.authorizationMethods ?? []) {
+                if (authorizationMethods.some((method) => method.id === declared.id))
+                    continue;
+                authorizationMethods.push(catalogAuthorizationMethod(declared, offering.lifecycle));
             }
             return {
                 ...offering,
@@ -181,7 +319,7 @@ function providerProductsForDeployment(deployment) {
         }),
     }));
 }
-function catalogOffering(productLabel, input) {
+function catalogOffering(productId, productLabel, input) {
     const consoleUrl = input.consoleUrl ?? input.subscriptionUrl;
     if (!consoleUrl)
         throw new Error(`Provider offering "${input.id}" requires a console URL`);
@@ -260,12 +398,20 @@ const PROVIDER_UPSTREAM_OVERRIDES = {
     openai: {
         'official-subscription': [
             { capability: 'models', protocol: 'codex-models' },
-            { capability: 'quota', protocol: 'rolling-quota-windows', options: { profile: 'codex' } },
+            {
+                capability: 'quota',
+                protocol: 'rolling-quota-windows',
+                options: { profile: 'codex', credentialAuthModes: ['deviceCodeOAuth'] },
+            },
         ],
     },
     anthropic: {
         'official-subscription': [
-            { capability: 'quota', protocol: 'rolling-quota-windows', options: { profile: 'claude-code' } },
+            {
+                capability: 'quota',
+                protocol: 'rolling-quota-windows',
+                options: { profile: 'claude-code', credentialAuthModes: ['deviceCodeOAuth'] },
+            },
         ],
     },
     kimi: {
@@ -273,7 +419,23 @@ const PROVIDER_UPSTREAM_OVERRIDES = {
             { capability: 'models', protocol: 'openai-models', options: { path: '/models', endpointProtocol: 'chatCompletions' } },
             { capability: 'inference', protocol: 'chatCompletions', options: { baseUrl: 'https://api.kimi.com/coding/v1' } },
             { capability: 'inference', protocol: 'anthropic', options: { baseUrl: 'https://api.kimi.com/coding/' } },
-            { capability: 'quota', protocol: 'rolling-quota-windows', options: { profile: 'kimi-code' } },
+            {
+                capability: 'quota',
+                protocol: 'rolling-quota-windows',
+                options: { profile: 'kimi-code', credentialAuthModes: ['apiKey', 'deviceCodeOAuth'] },
+            },
+        ],
+        // MIGRATION WINDOW: Kimi credentials written before the offering rename name
+        // the coding-plan quota by the generic subscription id, and only ever hold a
+        // device-code token. The declaration owns both facts so the quota handler
+        // never has to compare offering ids itself; delete this row once no stored
+        // credential carries the old id.
+        'official-subscription': [
+            {
+                capability: 'quota',
+                protocol: 'rolling-quota-windows',
+                options: { profile: 'kimi-code', credentialAuthModes: ['deviceCodeOAuth'] },
+            },
         ],
         'api-platform': [
             { capability: 'models', protocol: 'openai-models', options: { path: '/models', endpointProtocol: 'chatCompletions' } },
@@ -289,6 +451,40 @@ const PROVIDER_UPSTREAM_OVERRIDES = {
         ],
     },
 };
+/**
+ * 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.
+ */
+function offeringDeclaresUpstreamCapability(product, offeringId, capability, credentialAuthMode) {
+    if (!offeringId) {
+        return false;
+    }
+    const declared = PROVIDER_UPSTREAM_OVERRIDES[normalizeProviderId(product)]?.[offeringId];
+    return declared?.some((candidate) => {
+        if (candidate.protocol !== capability.protocol) {
+            return false;
+        }
+        if (capability.profile !== undefined && candidate.options?.profile !== capability.profile) {
+            return false;
+        }
+        const credentialAuthModes = candidate.options?.credentialAuthModes;
+        if (!Array.isArray(credentialAuthModes)) {
+            return true;
+        }
+        return credentialAuthMode !== undefined && credentialAuthModes.includes(credentialAuthMode);
+    }) ?? false;
+}
 function offeringsForProduct(provider) {
     if (provider === 'custom')
         return provider_catalog_1.CUSTOM_DEFAULT_OFFERINGS;
@@ -301,7 +497,7 @@ const LEGACY_PROVIDER_PRODUCT_DESCRIPTORS = Object.keys(PROVIDER_PRODUCT_LABELS)
     // The shared catalog is the source of the offering content; the server's
     // descriptor type narrows the same fields, so the projection converts at
     // this boundary rather than duplicating the values.
-    catalogOffering(PROVIDER_PRODUCT_LABELS[provider], {
+    catalogOffering(provider, PROVIDER_PRODUCT_LABELS[provider], {
         ...offering,
         endpoints: offering.endpoints ?? [],
         ...(PROVIDER_UPSTREAM_OVERRIDES[provider]?.[offering.id]
@@ -309,10 +505,6 @@ const LEGACY_PROVIDER_PRODUCT_DESCRIPTORS = Object.keys(PROVIDER_PRODUCT_LABELS)
             : {}),
     })),
 }));
-const CANONICAL_PROVIDER_SLUGS = {
-    kimi: 'moonshot',
-    bailian: 'qwen',
-};
 /**
  * The provider/offering catalog belongs to `@undefineds.co/ai-connections`: it
  * is content rather than schema, and it carries endpoints, console links and
@@ -324,7 +516,7 @@ exports.DEFAULT_PROVIDER_PRODUCT_DESCRIPTORS = canonicalProviderProducts(LEGACY_
     .map(normalizeOpenAiSubscriptionProduct);
 function canonicalProviderProducts(legacy) {
     return legacy.map((fallback) => {
-        const canonicalSlug = CANONICAL_PROVIDER_SLUGS[fallback.id] ?? fallback.id;
+        const canonicalSlug = discoveryProviderSlug(fallback.id);
         const provider = (0, models_1.getBuiltinProvider)(canonicalSlug);
         if (!provider?.offerings?.length)
             return fallback;
@@ -398,6 +590,9 @@ function canonicalOfferingDescriptor(provider, offering, fallback) {
         productLabel: offering.productLabel ?? provider.displayName,
         kind: offering.kind,
         authModes: offering.authModes,
+        // The canonical source carries schema, not actions: which connect entries an
+        // offering declares stays with the catalog that declared them.
+        ...(fallback?.authorizationMethods ? { authorizationMethods: fallback.authorizationMethods } : {}),
         auth: fallback?.auth ?? defaultAuthCapabilities(offering.kind, offering.authModes),
         upstream: fallback?.upstream ?? defaultUpstreamCapabilities(endpoints, modelDiscovery, quota),
         endpoints,
@@ -444,6 +639,8 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
         models: [
             { id: 'gpt-5', contextWindow: 400_000, capabilities: { toolCalls: true, reasoningEffort: true, imageInput: true } },
             { id: 'gpt-4.1', capabilities: { toolCalls: true, imageInput: true } },
+            embeddingModel('text-embedding-3-small', 1536),
+            embeddingModel('text-embedding-3-large', 3072),
         ],
     },
     {
@@ -525,6 +722,8 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
         models: [
             { id: 'qwen-max', capabilities: { toolCalls: true, imageInput: true } },
             { id: 'qwen-coder-plus', capabilities: { toolCalls: true } },
+            // The DashScope-compatible endpoint the default embedding profile uses.
+            embeddingModel(defaultEmbeddingProfile_1.DEFAULT_EMBEDDING_MODEL_ID, 1024),
         ],
     },
     {
@@ -550,6 +749,15 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
             { id: 'deepseek-chat', capabilities: { toolCalls: true } },
             { id: 'deepseek-reasoner', capabilities: { toolCalls: true, reasoningEffort: true } },
             { id: 'deepseek-flash', capabilities: { toolCalls: true, reasoningEffort: true } },
+            // models.dev lists this model under the third-party aggregators that serve
+            // it, not under the first-party DeepSeek entry, so the catalog seeds it
+            // here. `fast` is a curated tier claim, not a measurement.
+            {
+                id: 'deepseek-v4.1-flash',
+                contextWindow: 1_048_576,
+                inputModalities: ['text', 'image'],
+                capabilities: { toolCalls: true, reasoningEffort: true, imageInput: true, fast: true },
+            },
             { id: 'deepseek-v4-flash', capabilities: { toolCalls: true, reasoningEffort: true } },
             { id: 'deepseek-v4-pro', capabilities: { toolCalls: true, reasoningEffort: true } },
         ],
@@ -580,6 +788,7 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
         models: [
             { id: 'glm-4.5', capabilities: { toolCalls: true, reasoningEffort: true } },
             { id: 'glm-4.5-air', capabilities: { toolCalls: true, reasoningEffort: true } },
+            embeddingModel('embedding-2', 1024),
         ],
     },
     {
@@ -599,7 +808,9 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
         capabilities: {
             toolCalls: true,
         },
-        models: [],
+        models: [
+            embeddingModel('nomic-embed-text', 768),
+        ],
     },
     {
         id: 'custom',
@@ -623,6 +834,18 @@ exports.DEFAULT_PROVIDER_DESCRIPTORS = [
         models: [],
     },
 ];
+/**
+ * Registers an embedding model in the provided catalog. Embedding models exist
+ * here (not in the chat lists) so that provider/model capability and the
+ * deployment embedding policy read from one source.
+ */
+function embeddingModel(id, dimension) {
+    return {
+        id,
+        capabilities: { embedding: true },
+        metadata: { modelType: 'embedding', dimension },
+    };
+}
 function mergeModelDescriptor(existing, discovered, provider) {
     return {
         ...existing,

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

@@ -4,6 +4,11 @@ import type { ProviderRuntimeAdapter } from './ProviderRuntimeAdapter';
 export interface ProviderRuntimeRegistryOptions {
     registry?: ProviderRegistry;
     transport?: ProviderHttpTransport;
+    /**
+     * Whether a credential may supply its own base URL. Only a Local deployment
+     * may; Cloud resolves every provider against the catalog endpoint.
+     */
+    allowCredentialBaseUrl?: boolean;
 }
 export declare class ProviderRuntimeRegistry {
     private readonly adapters;

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

@@ -60,7 +60,11 @@ class ProviderRuntimeRegistry {
             allowToolChoiceRequired: true,
         }));
         const custom = registry.requireProvider('custom');
-        this.adapters.set('custom', new CustomRuntimeAdapter_1.CustomRuntimeAdapter({ transport, descriptor: custom }));
+        this.adapters.set('custom', new CustomRuntimeAdapter_1.CustomRuntimeAdapter({
+            transport,
+            descriptor: custom,
+            allowCredentialBaseUrl: options.allowCredentialBaseUrl,
+        }));
     }
     get(provider) {
         const adapter = this.adapters.get((0, ProviderRegistry_1.normalizeProviderId)(provider));

package/dist/api/ai-gateway/quota/SubscriptionQuotaAdapters.d.ts

@@ -6,10 +6,21 @@ interface SubscriptionQuotaAdapterOptions {
 }
 declare abstract class SubscriptionQuotaAdapter implements ProviderQuotaAdapter {
     abstract readonly provider: string;
+    abstract readonly capability: {
+        protocol: string;
+        profile?: string;
+    };
     protected readonly fetchFn: typeof fetch;
     protected readonly transport?: ProviderHttpTransport;
     constructor(options?: SubscriptionQuotaAdapterOptions);
-    abstract supports(credential: QuotaCredentialRecord): boolean;
+    /**
+     * Whether the credential's Offering is one the runtime declaration assigns
+     * this handler's quota capability to, under the credential kind it holds. The
+     * declaration is the axis's single authority for offering→capability, so the
+     * handler asks it instead of re-typing the offering ids and auth modes it was
+     * bound to.
+     */
+    supports(credential: QuotaCredentialRecord): boolean;
     abstract fetch(input: ProviderQuotaFetchInput): Promise<NormalizedQuotaSnapshot>;
     protected snapshot(input: ProviderQuotaFetchInput, source: string, windows: QuotaWindow[]): NormalizedQuotaSnapshot;
     protected error(input: ProviderQuotaFetchInput, source: string, status?: number, retryAfter?: string | null): NormalizedQuotaSnapshot;
@@ -20,7 +31,6 @@ export declare class CodexSubscriptionQuotaAdapter extends SubscriptionQuotaAdap
         readonly protocol: "rolling-quota-windows";
         readonly profile: "codex";
     };
-    supports(credential: QuotaCredentialRecord): boolean;
     fetch(input: ProviderQuotaFetchInput): Promise<NormalizedQuotaSnapshot>;
 }
 export declare class ClaudeSubscriptionQuotaAdapter extends SubscriptionQuotaAdapter {
@@ -29,7 +39,6 @@ export declare class ClaudeSubscriptionQuotaAdapter extends SubscriptionQuotaAda
         readonly protocol: "rolling-quota-windows";
         readonly profile: "claude-code";
     };
-    supports(credential: QuotaCredentialRecord): boolean;
     fetch(input: ProviderQuotaFetchInput): Promise<NormalizedQuotaSnapshot>;
 }
 export declare class KimiCodeSubscriptionQuotaAdapter extends SubscriptionQuotaAdapter {
@@ -38,7 +47,6 @@ export declare class KimiCodeSubscriptionQuotaAdapter extends SubscriptionQuotaA
         readonly protocol: "rolling-quota-windows";
         readonly profile: "kimi-code";
     };
-    supports(credential: QuotaCredentialRecord): boolean;
     fetch(input: ProviderQuotaFetchInput): Promise<NormalizedQuotaSnapshot>;
 }
 export {};

package/dist/api/ai-gateway/quota/SubscriptionQuotaAdapters.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.KimiCodeSubscriptionQuotaAdapter = exports.ClaudeSubscriptionQuotaAdapter = exports.CodexSubscriptionQuotaAdapter = void 0;
+const ProviderRegistry_1 = require("../providers/ProviderRegistry");
 const ProviderQuotaAdapter_1 = require("./ProviderQuotaAdapter");
 const CODEX_USAGE_URL = 'https://chatgpt.com/backend-api/wham/usage';
 const CLAUDE_USAGE_URL = 'https://api.anthropic.com/api/oauth/usage';
@@ -11,6 +12,16 @@ class SubscriptionQuotaAdapter {
         this.fetchFn = options.fetch ?? fetch;
         this.transport = options.transport;
     }
+    /**
+     * Whether the credential's Offering is one the runtime declaration assigns
+     * this handler's quota capability to, under the credential kind it holds. The
+     * declaration is the axis's single authority for offering→capability, so the
+     * handler asks it instead of re-typing the offering ids and auth modes it was
+     * bound to.
+     */
+    supports(credential) {
+        return (0, ProviderRegistry_1.offeringDeclaresUpstreamCapability)(credential.provider, credential.offeringId, this.capability, credential.authMode);
+    }
     snapshot(input, source, windows) {
         return {
             credential: input.credential.credentialIri,
@@ -38,9 +49,6 @@ class CodexSubscriptionQuotaAdapter extends SubscriptionQuotaAdapter {
         this.provider = 'openai';
         this.capability = { protocol: 'rolling-quota-windows', profile: 'codex' };
     }
-    supports(credential) {
-        return credential.offeringId === 'official-subscription' && credential.authMode === 'deviceCodeOAuth';
-    }
     async fetch(input) {
         const token = bearerFromSecret(input.secret);
         if (!token)
@@ -62,9 +70,6 @@ class ClaudeSubscriptionQuotaAdapter extends SubscriptionQuotaAdapter {
         this.provider = 'anthropic';
         this.capability = { protocol: 'rolling-quota-windows', profile: 'claude-code' };
     }
-    supports(credential) {
-        return credential.offeringId === 'official-subscription' && credential.authMode === 'deviceCodeOAuth';
-    }
     async fetch(input) {
         const token = bearerFromSecret(input.secret);
         if (!token)
@@ -86,11 +91,6 @@ class KimiCodeSubscriptionQuotaAdapter extends SubscriptionQuotaAdapter {
         this.provider = 'kimi';
         this.capability = { protocol: 'rolling-quota-windows', profile: 'kimi-code' };
     }
-    supports(credential) {
-        return (credential.offeringId === 'official-subscription' && credential.authMode === 'deviceCodeOAuth')
-            || (credential.offeringId === 'subscription-key'
-                && (credential.authMode === 'apiKey' || credential.authMode === 'deviceCodeOAuth'));
-    }
     async fetch(input) {
         const token = bearerFromSecret(input.secret);
         if (!token)

package/dist/api/ai-gateway/routing/ModelRouter.d.ts

@@ -3,6 +3,7 @@ import { type ProviderAuthMode, type ProviderCapabilities, type ProviderDescript
 import { type SessionAffinityStore } from './SessionAffinityStore';
 import type { AuthContext } from '../../auth/AuthContext';
 import type { GatewayProtocol } from '../types';
+import { EmbeddingModelPolicy } from '../../../ai/service/EmbeddingModelPolicy';
 export type GatewayCredentialHealth = 'healthy' | 'reauthRequired' | 'disabled' | 'error' | 'invalid' | 'unknown';
 export type GatewayQuotaStatus = 'available' | 'unsupported' | 'exhausted' | 'error';
 export type ModelRouteSource = 'alias' | 'explicit-provider' | 'exact-model' | 'default-provider' | 'default-model';
@@ -14,6 +15,8 @@ export interface GatewayCredentialCandidate {
     enabled: boolean;
     priority?: number;
     models?: string[];
+    /** Display names the Pod recorded for `models`, keyed by model id. */
+    modelNames?: Record<string, string>;
     customModels?: CustomProviderModel[];
     defaultModel?: string;
     health?: GatewayCredentialHealth;
@@ -35,6 +38,8 @@ export interface ModelRouterOptions {
     selectionRepository?: GatewayModelSelectionRepository;
     defaultProvider?: string;
     defaultModel?: string;
+    /** Deployment policy for embedding models; defaults to allow-all (Local). */
+    embeddingModelPolicy?: EmbeddingModelPolicy;
     now?: () => Date;
 }
 export interface GatewayModelSelection {
@@ -43,6 +48,7 @@ export interface GatewayModelSelection {
         id: string;
         modelType?: string;
         status?: 'active' | 'inactive';
+        displayName?: string;
     }>;
     version?: string;
     defaultModel?: string;
@@ -102,6 +108,7 @@ export declare class ModelRouter {
     private readonly selectionRepository?;
     private readonly defaultProvider?;
     private readonly defaultModel?;
+    private readonly embeddingModelPolicy;
     private readonly now;
     constructor(options: ModelRouterOptions);
     route(input: ModelRouteInput, excludeCredentialIds?: ReadonlySet<string>): Promise<ModelRouteResult>;
@@ -133,4 +140,11 @@ export declare class ModelRouter {
     private routeProviderIdForCredential;
     private credentialVisibleModels;
     private isCredentialModelVisible;
+    /**
+     * A Pod can declare any capability on a custom model. Embedding is the one
+     * capability a deployment gates through its own catalog, so never advertise an
+     * embedding model the catalog does not provide. Other declared capabilities
+     * keep their existing behavior.
+     */
+    private visibleCustomCapabilities;
 }