@undefineds.co/xpod 0.4.10 → 0.4.12

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

@@ -72,6 +72,10 @@ class PodConnectedCredentialRepository {
                 enabled: record.enabled === false ? false : !record.reauthRequired,
                 accountLabel: record.accountLabel,
                 models: selectedModelIds ?? modelsFromMetadata(record.metadata),
+                // The Pod also stores the name discovery gave each picked model. The
+                // published model list renders the same name-over-id line as the
+                // settings pages, so carry the names instead of dropping them here.
+                modelNames: modelNamesFromSelectedModels(record.selectedModels),
                 customModels: customModelsFromMetadata(record.metadata),
                 defaultModel: defaultModelFromMetadata(record.metadata),
                 priority: record.priority ?? 100,
@@ -1449,6 +1453,42 @@ class DeepSeekConnectAdapter {
 }
 exports.DeepSeekConnectAdapter = DeepSeekConnectAdapter;
 class ProviderConnectService {
+    /** Cloud settings only manage providers this deployment provides. */
+    requireProvidedProvider(deployment, provider) {
+        if (!this.registry.isProvidedInDeployment(provider, deployment)) {
+            throw new Error('provider_not_available_in_deployment');
+        }
+    }
+    /**
+     * Cloud owns the endpoint: a caller may not point a provided provider at its
+     * own base URL or proxy. Supplying the provided endpoint verbatim (what the
+     * applet does when it fills the offering default) stays valid.
+     */
+    assertEndpointIsProvided(input) {
+        if (input.deployment !== 'cloud') {
+            return;
+        }
+        const proxyUrl = input.proxyUrl?.trim();
+        if (proxyUrl) {
+            throw new Error('provider_endpoint_not_configurable_in_cloud');
+        }
+        const baseUrl = input.baseUrl?.trim();
+        if (!baseUrl) {
+            return;
+        }
+        const provided = new Set(this.providedEndpoints(input.provider));
+        if (!provided.has(normalizeEndpoint(baseUrl))) {
+            throw new Error('provider_endpoint_not_configurable_in_cloud');
+        }
+    }
+    providedEndpoints(provider) {
+        const descriptor = this.registry.getProvider(normalizeProvider(provider));
+        const product = this.registry.getProduct(normalizeProvider(provider));
+        return [
+            descriptor?.defaultBaseUrl,
+            ...(product?.offerings.flatMap((offering) => offering.endpoints.map((endpoint) => endpoint.baseUrl)) ?? []),
+        ].filter((value) => Boolean(value));
+    }
     constructor(options) {
         this.adapters = new Map();
         this.localSessionImporters = new Map();
@@ -1482,6 +1522,7 @@ class ProviderConnectService {
                 message,
             });
         }
+        this.requireProvidedProvider(input.deployment, input.provider);
         return this.requireAdapter(input.provider, offeringId, input.requestedMode).begin({
             ...input,
             offeringId,
@@ -1508,7 +1549,10 @@ class ProviderConnectService {
         }));
     }
     async listProviders(input) {
-        return Promise.all(this.registry.listProviders().map(async (descriptor) => {
+        // Cloud settings only offer the providers this deployment provides, with the
+        // endpoints the catalog names; self-hosted and local-daemon providers are
+        // Local-only.
+        return Promise.all(this.registry.listProvidedProviders(input.deployment).map(async (descriptor) => {
             const credential = this.credentialRepository?.getCredential
                 ? await this.credentialRepository.getCredential({
                     ...input,
@@ -1549,8 +1593,10 @@ class ProviderConnectService {
         }));
     }
     async listProviderCredentialPools(input) {
+        const providedProducts = this.registry.listProducts()
+            .filter((product) => this.registry.isProvidedInDeployment(product.id, input.deployment));
         if (!this.credentialRepository) {
-            return this.registry.listProducts().map((product) => ({
+            return providedProducts.map((product) => ({
                 id: product.id,
                 name: product.label,
                 status: 'unconfigured',
@@ -1559,7 +1605,7 @@ class ProviderConnectService {
                 selectedModels: [],
             }));
         }
-        return Promise.all(this.registry.listProducts().map(async (product) => {
+        return Promise.all(providedProducts.map(async (product) => {
             const runtimeProviders = new Set(product.offerings.flatMap((offering) => offering.runtimeProviderIds));
             const credentials = (await Promise.all([...runtimeProviders].map((provider) => this.credentialRepository.listProviderCredentials({
                 ...input,
@@ -1572,7 +1618,7 @@ class ProviderConnectService {
                 status: aggregateProviderPoolStatus(publicCredentials),
                 offerings: product.offerings.map(publicOfferingSummary),
                 credentials: publicCredentials,
-                selectedModels: selectedModelsFromCredentials(credentials),
+                selectedModels: selectedModelsFromCredentials(credentials, this.registry),
             };
         }));
     }
@@ -1580,6 +1626,13 @@ class ProviderConnectService {
         if (!this.credentialRepository || !this.vault) {
             throw new Error('credential_pool_not_configured');
         }
+        this.requireProvidedProvider(input.deployment, input.provider);
+        this.assertEndpointIsProvided({
+            deployment: input.deployment,
+            provider: input.provider,
+            baseUrl: input.baseUrl,
+            proxyUrl: input.proxyUrl,
+        });
         const provider = normalizeProvider(input.provider);
         const offeringId = requireApiKeyOffering(provider, input.offeringId);
         const proxyUrl = (0, provider_http_transport_1.normalizeProviderProxyUrl)(input.proxyUrl);
@@ -1615,6 +1668,12 @@ class ProviderConnectService {
     async createLocalCredential(input) {
         if (!this.credentialRepository || !this.vault)
             throw new Error('credential_pool_not_configured');
+        this.requireProvidedProvider(input.deployment, input.provider);
+        this.assertEndpointIsProvided({
+            deployment: input.deployment,
+            provider: input.provider,
+            baseUrl: input.baseUrl,
+        });
         const key = JSON.stringify([input.webId, input.deployment, normalizeProvider(input.provider),
             this.requireLocalOffering(normalizeProvider(input.provider), input.offeringId)]);
         const previous = ProviderConnectService.localImportLocks.get(key) ?? Promise.resolve();
@@ -1775,6 +1834,13 @@ class ProviderConnectService {
         return { ...result, ...metadataWithoutUndefined({ ...kimiAccountIdentityHint(input.provider, result.accessToken) }) };
     }
     async updateCredential(input) {
+        this.requireProvidedProvider(input.deployment, input.provider);
+        this.assertEndpointIsProvided({
+            deployment: input.deployment,
+            provider: input.provider,
+            baseUrl: input.patch.baseUrl,
+            proxyUrl: input.patch.proxyUrl,
+        });
         if (!this.credentialRepository) {
             throw new Error('credential_pool_not_configured');
         }
@@ -1885,6 +1951,12 @@ class ProviderConnectService {
         return offering.id;
     }
     completeApiKey(input) {
+        this.requireProvidedProvider(input.deployment, input.provider);
+        this.assertEndpointIsProvided({
+            deployment: input.deployment,
+            provider: input.provider,
+            baseUrl: input.baseUrl,
+        });
         const adapter = this.requireAdapter(input.provider, input.offeringId, 'browserAssistedApiKey');
         if (!adapter.completeApiKey) {
             throw new Error('Provider does not support API key Connect completion');
@@ -2211,7 +2283,27 @@ function aggregateProviderPoolStatus(credentials) {
     }
     return 'configured';
 }
-function selectedModelsFromCredentials(credentials) {
+/**
+ * Display names of the models a credential picked, keyed by model id.
+ *
+ * A model may be listed once per credential, so the first name the Pod stored
+ * for an id wins; a model without a stored name is simply absent and the caller
+ * falls back to the catalog.
+ */
+function modelNamesFromSelectedModels(selectedModels) {
+    if (!selectedModels?.length) {
+        return undefined;
+    }
+    const names = {};
+    for (const model of selectedModels) {
+        const name = model.displayName?.trim();
+        if (name && names[model.id] === undefined) {
+            names[model.id] = name;
+        }
+    }
+    return Object.keys(names).length > 0 ? names : undefined;
+}
+function selectedModelsFromCredentials(credentials, registry) {
     const selected = new Map();
     for (const credential of credentials) {
         if (credential.status !== 'active') {
@@ -2219,8 +2311,9 @@ function selectedModelsFromCredentials(credentials) {
         }
         const metadata = metadataFromRowValue(credential.metadata);
         const provider = normalizeProvider(credential.provider);
-        const models = credential.selectedModels
-            ?? modelIdsFromMetadata(metadata).map((id) => ({ id, provider }));
+        const models = (credential.selectedModels
+            ?? modelIdsFromMetadata(metadata).map((id) => ({ id, provider })))
+            .map((model) => withCatalogCapabilities(model, provider, registry));
         for (const model of models) {
             const publicModel = { ...model, provider: productProviderId(provider) };
             selected.set(publicModel.resourceId
@@ -2234,12 +2327,38 @@ function selectedModelsFromCredentials(credentials) {
                 custom: true,
                 inputModalities: custom.inputModalities,
                 outputModalities: custom.outputModalities,
-                capabilities: custom.capabilities,
+                // The client reads `custom_capabilities` before the catalog flag object,
+                // so a custom model's own tokens survive normalisation.
+                custom_capabilities: custom.capabilities,
             }));
         }
     }
     return [...selected.values()];
 }
+/**
+ * Fill a selected model's capability evidence from the provider catalog.
+ *
+ * A credential stores only the model ids a user picked, so the summary carried
+ * no capabilities and the model list had nothing to render next to the names.
+ * Custom models are left alone: they declare their own capabilities, and the
+ * catalog has no authority over a user-defined id.
+ */
+function withCatalogCapabilities(model, provider, registry) {
+    const descriptor = registry.getModelDescriptor(provider, model.id);
+    if (!descriptor) {
+        return model;
+    }
+    const displayName = model.displayName
+        ?? (typeof descriptor.metadata?.name === 'string' ? descriptor.metadata.name : undefined);
+    return {
+        ...model,
+        ...(displayName ? { displayName } : {}),
+        ...(descriptor.capabilities ? { capabilities: descriptor.capabilities } : {}),
+        ...(descriptor.inputModalities
+            ? { modalities: { input: descriptor.inputModalities } }
+            : {}),
+    };
+}
 function localSessionImporterKey(provider, offeringId) {
     return `${normalizeProvider(provider)}:${normalizeProvider(offeringId)}`;
 }
@@ -2368,12 +2487,12 @@ function createDefaultConnectedCredentialDb(input) {
 function credentialRowFromRecord(record) {
     const metadata = metadataFromRowValue(record.metadata) ?? {};
     const normalizedProvider = normalizeProvider(record.provider);
-    if (record.offeringId === undefined) {
-        metadata.offeringId = metadata.offeringId ?? defaultOfferingFor(normalizedProvider, record.authMode);
-    }
-    else {
-        metadata.offeringId = record.offeringId;
-    }
+    const offeringId = record.offeringId ?? stringMetadata(metadata, 'offeringId')
+        ?? defaultOfferingFor(normalizedProvider, record.authMode);
+    // MIGRATION WINDOW: the offering is the credential's own `udfs:offeringId`
+    // attribute; the `metadata` copy stays for readers built before that column
+    // existed and goes away with the migration.
+    metadata.offeringId = offeringId;
     metadata.priority = record.priority ?? metadata.priority ?? 100;
     metadata.enabled = record.enabled ?? metadata.enabled ?? record.status === 'active';
     if (record.health !== undefined) {
@@ -2389,9 +2508,12 @@ function credentialRowFromRecord(record) {
     return {
         id: record.id,
         owner: record.webId,
-        provider: models_1.aiProviderResource.buildId({ id: normalizeProvider(record.provider) }),
+        // The provider relation names the provider, never the offering: every
+        // offering's rows live in `providers/<provider>.ttl`.
+        provider: models_1.aiProviderResource.buildId({ id: normalizedProvider }),
         service: 'ai',
         authMode: record.authMode,
+        offeringId,
         status: record.status,
         encryptedSecret: JSON.stringify(record.encryptedSecret),
         wrappedDataKey: record.encryptedSecret.wrappedDek,
@@ -2445,7 +2567,12 @@ function recordFromCredentialRow(row) {
         proxyUrl: (0, provider_http_transport_1.normalizeProviderProxyUrl)(stringFrom(row.proxyUrl) ?? stringMetadata(metadata, 'proxyUrl')),
         metadata,
         priority: rowPriorityFromMetadata(row) ?? 100,
-        offeringId: rowOfferingIdFromMetadata(row) ?? defaultOfferingFor(provider, authMode),
+        // The credential's own attribute wins. The metadata copy and the default
+        // only cover rows written before `udfs:offeringId` existed; the migration
+        // backfills them.
+        offeringId: stringMetadata(row, 'offeringId')
+            ?? rowOfferingIdFromMetadata(row)
+            ?? defaultOfferingFor(provider, authMode),
         enabled: rowEnabledFromMetadata(row) ?? status === 'active',
         health: rowHealthFromMetadata(row) ?? (reauthRequired ? 'reauthRequired' : 'healthy'),
     };
@@ -2802,6 +2929,15 @@ function productProviderId(provider) {
     return customProviderProductId(normalized)
         ?? normalizeProvider(providerProductFor(normalized)?.id ?? normalized);
 }
+/**
+ * MIGRATION WINDOW ONLY: the offering an old model reference encoded in its
+ * document name (`providers/openai-official-subscription.ttl#gpt-6-astra`).
+ *
+ * A model's document is its provider's, so a reference written now carries no
+ * offering and this returns `undefined`. It stays only until the migration has
+ * normalised the model rows and `hasModel` references already in Pods; a
+ * credential's offering is read from the credential itself.
+ */
 function offeringIdFromProviderReference(value, provider) {
     if (customProviderInstanceCredentialId(value)) {
         return undefined;
@@ -2825,6 +2961,16 @@ function defaultModelFromMetadata(metadata) {
     const value = metadata?.defaultModel;
     return typeof value === 'string' ? value : undefined;
 }
+function normalizeEndpoint(value) {
+    const trimmed = value.trim();
+    try {
+        const url = new URL(trimmed);
+        return `${url.origin}${url.pathname.replace(/\/+$/u, '')}`.toLowerCase();
+    }
+    catch {
+        return trimmed.replace(/\/+$/u, '').toLowerCase();
+    }
+}
 function runtimeCredentialFromMetadata(metadata) {
     const value = metadata?.runtimeCredential;
     const runtime = value && typeof value === 'object' && !Array.isArray(value)

package/dist/api/ai-gateway/credentials/AiCredentialSecretDecoder.d.ts

@@ -0,0 +1,12 @@
+import { type AiCredentialSecretDecoder } from '../../../ai/service/AiCredentialSecret';
+import type { CredentialVault } from './CredentialVault';
+export interface AiCredentialSecretDecoderOptions {
+    /** Decodes wrapped (secret-cell / Cloud KMS) envelopes the Pod stores. */
+    vault?: CredentialVault;
+}
+/**
+ * Reads a Pod credential secret the way the Gateway does: plaintext payloads
+ * first, then the configured credential vault. Embedding/indexing consumers use
+ * this so an AI Connections credential behaves the same on both surfaces.
+ */
+export declare function createAiCredentialSecretDecoder(options?: AiCredentialSecretDecoderOptions): AiCredentialSecretDecoder;

package/dist/api/ai-gateway/credentials/AiCredentialSecretDecoder.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAiCredentialSecretDecoder = createAiCredentialSecretDecoder;
+const AiCredentialSecret_1 = require("../../../ai/service/AiCredentialSecret");
+/**
+ * Reads a Pod credential secret the way the Gateway does: plaintext payloads
+ * first, then the configured credential vault. Embedding/indexing consumers use
+ * this so an AI Connections credential behaves the same on both surfaces.
+ */
+function createAiCredentialSecretDecoder(options = {}) {
+    return async (row, context) => {
+        const plaintext = (0, AiCredentialSecret_1.decodePlaintextAiCredentialSecret)(row);
+        if (plaintext) {
+            return plaintext;
+        }
+        const envelope = (0, AiCredentialSecret_1.parseCredentialEnvelope)(row.encryptedSecret);
+        if (!envelope || !options.vault) {
+            return undefined;
+        }
+        try {
+            return await options.vault.open({ webId: context.webId }, context.credentialIri ?? '', context.provider ?? '', envelope);
+        }
+        catch {
+            // A wrapped secret this runtime cannot open is treated as unavailable, the
+            // same as any other credential the deployment cannot use.
+            return undefined;
+        }
+    };
+}
+//# sourceMappingURL=AiCredentialSecretDecoder.js.map

package/dist/api/ai-gateway/errors.d.ts

@@ -1,4 +1,4 @@
-export type GatewayErrorCode = 'invalid_request' | 'invalid_tool_arguments' | 'unsupported_protocol_event' | 'service_access_missing' | 'credential_unavailable' | 'model_not_available' | 'no_model_available' | 'provider_error' | 'internal_error';
+export type GatewayErrorCode = 'invalid_request' | 'invalid_tool_arguments' | 'unsupported_protocol_event' | 'service_access_missing' | 'credential_unavailable' | 'model_not_available' | 'no_model_available' | 'embedding_model_not_allowed' | 'provider_error' | 'internal_error';
 export interface NormalizedGatewayError {
     error: {
         code: GatewayErrorCode;

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

@@ -0,0 +1,11 @@
+import type { EmbeddingModelCatalog } from '../../../ai/service/EmbeddingModelPolicy';
+import type { ProviderRegistry } from '../providers/ProviderRegistry';
+/**
+ * Adapts the ai-gateway provider catalog to the embedding policy.
+ *
+ * Cloud only provides providers that have a non-local offering: a local-daemon
+ * provider such as Ollama would otherwise pin Cloud embedding traffic to the
+ * Cloud node's own loopback. The endpoint always comes from the catalog
+ * descriptor, which the deployment may override at construction time.
+ */
+export declare function createGatewayEmbeddingModelCatalog(registry: ProviderRegistry, deployment: string): EmbeddingModelCatalog;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGatewayEmbeddingModelCatalog = createGatewayEmbeddingModelCatalog;
+/**
+ * Adapts the ai-gateway provider catalog to the embedding policy.
+ *
+ * Cloud only provides providers that have a non-local offering: a local-daemon
+ * provider such as Ollama would otherwise pin Cloud embedding traffic to the
+ * Cloud node's own loopback. The endpoint always comes from the catalog
+ * descriptor, which the deployment may override at construction time.
+ */
+function createGatewayEmbeddingModelCatalog(registry, deployment) {
+    const providedInDeployment = (providerId) => registry.isProvidedInDeployment(providerId, deployment);
+    return {
+        isManagedEmbeddingModel(provider, modelId) {
+            const providerId = registry.resolveManagedProviderId(provider);
+            if (!providerId || !providedInDeployment(providerId)) {
+                return false;
+            }
+            return registry.isManagedEmbeddingModel(providerId, modelId);
+        },
+        managedEmbeddingBaseUrl(provider) {
+            const providerId = registry.resolveManagedProviderId(provider);
+            if (!providerId || !providedInDeployment(providerId)) {
+                return undefined;
+            }
+            return registry.getProvider(providerId)?.defaultBaseUrl;
+        },
+    };
+}
+//# sourceMappingURL=GatewayEmbeddingModelCatalog.js.map

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

@@ -244,14 +244,14 @@ class PodModelSelectionRepository {
             if (!isMissingResourceError(error))
                 throw error;
         }
-        // A model uses a fragment IRI inside its offering document. Plain-LDP
+        // A model is a fragment IRI inside its provider document. Plain-LDP
         // findById can fetch that document yet fail to select the fragment subject,
         // so resolve it through the indexed isProvidedBy relation as a fallback.
         const document = modelResourceId.split('#', 1)[0];
-        const offeringIri = buildProviderResourceIri(webId, `${document}#this`);
+        const providerIri = buildProviderResourceIri(webId, `${document}#this`);
         const rows = await db.select()
             .from(models_1.aiModelResource)
-            .where((0, drizzle_solid_1.eq)(models_1.aiModelResource.isProvidedBy, offeringIri))
+            .where((0, drizzle_solid_1.eq)(models_1.aiModelResource.isProvidedBy, providerIri))
             .execute();
         return rows.find((row) => modelRowMatchesResourceId(row, modelResourceId, webId)) ?? null;
     }
@@ -556,6 +556,10 @@ function selectedModelResourceIdFromRelation(value, webId) {
 }
 function resourceBelongsToProvider(resourceId, providerId) {
     const document = resourceId.split('#', 1)[0];
+    // `startsWith` is a MIGRATION WINDOW allowance for `hasModel` entries written
+    // while the offering was encoded in the provider document name
+    // (`openai-official-subscription.ttl`); new selections only name
+    // `settings/providers/<provider>.ttl`.
     return document === `${providerId}.ttl` || document.startsWith(`${providerId}-`);
 }
 function modelProviderRelationMatches(value, modelResourceId, webId) {

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

@@ -1,11 +1,23 @@
 import type { GatewayDeployment } from '../auth/InvocationTokenCodec';
 import type { AuthContext } from '../../auth/AuthContext';
+import { EmbeddingModelPolicy } from '../../../ai/service/EmbeddingModelPolicy';
 import { type CustomProviderModel, type PodCredentialRepository } from '../connect';
+import { type ProviderRegistry } from '../providers/ProviderRegistry';
 export interface ProviderCustomModelsServiceOptions {
     credentialRepository: PodCredentialRepository;
+    /** Provider catalog; decides which providers this deployment offers at all. */
+    registry?: ProviderRegistry;
+    /**
+     * Deployment policy for embedding declarations. A cloud deployment only
+     * provides embedding models from the ai-gateway catalog, so a custom model may
+     * not claim embedding capability for a model the catalog does not provide.
+     */
+    embeddingModelPolicy?: EmbeddingModelPolicy;
 }
 export declare class ProviderCustomModelsService {
     private readonly credentialRepository;
+    private readonly embeddingModelPolicy;
+    private readonly registry;
     constructor(options: ProviderCustomModelsServiceOptions);
     upsert(input: {
         webId: string;
@@ -21,6 +33,12 @@ export declare class ProviderCustomModelsService {
         modelId: string;
         auth?: AuthContext;
     }): Promise<CustomProviderModel[]>;
+    /**
+     * A custom model may only declare embedding capability when the deployment
+     * provides that exact provider/model as an embedding model. Local deployments
+     * allow any declaration; cloud deployments do not.
+     */
+    private assertEmbeddingDeclarationAllowed;
     private requireCredential;
     private persistMetadata;
 }

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

@@ -1,16 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderCustomModelsService = void 0;
+const EmbeddingModelPolicy_1 = require("../../../ai/service/EmbeddingModelPolicy");
 const connect_1 = require("../connect");
 const ProviderQuotaAdapter_1 = require("../quota/ProviderQuotaAdapter");
+const ProviderRegistry_1 = require("../providers/ProviderRegistry");
 class ProviderCustomModelsService {
     constructor(options) {
         this.credentialRepository = options.credentialRepository;
+        this.embeddingModelPolicy = options.embeddingModelPolicy ?? EmbeddingModelPolicy_1.EmbeddingModelPolicy.allowAll();
+        this.registry = options.registry ?? (0, ProviderRegistry_1.createDefaultProviderRegistry)();
     }
     async upsert(input) {
         const credential = await this.requireCredential(input);
+        if (!this.registry.isProvidedInDeployment(input.provider, input.deployment)) {
+            throw new Error('provider_not_available_in_deployment');
+        }
         const customModels = (0, connect_1.customModelsFromMetadata)(credential.metadata);
         const entry = serializeCustomModel(input.model);
+        this.assertEmbeddingDeclarationAllowed(input.provider, entry);
         const index = customModels.findIndex((model) => model.id === entry.id);
         if (index === -1) {
             customModels.push(entry);
@@ -28,6 +36,21 @@ class ProviderCustomModelsService {
         await this.persistMetadata(input, credential, customModels);
         return customModels;
     }
+    /**
+     * A custom model may only declare embedding capability when the deployment
+     * provides that exact provider/model as an embedding model. Local deployments
+     * allow any declaration; cloud deployments do not.
+     */
+    assertEmbeddingDeclarationAllowed(provider, model) {
+        const declaresEmbedding = (model.capabilities ?? [])
+            .some((capability) => capability.trim().toLowerCase() === 'embedding');
+        if (!declaresEmbedding) {
+            return;
+        }
+        if (!this.embeddingModelPolicy.isAllowed({ provider, model: model.id })) {
+            throw new EmbeddingModelPolicy_1.EmbeddingModelNotAllowedError(provider, model.id);
+        }
+    }
     async requireCredential(input) {
         const credential = await this.credentialRepository.getCredential?.({
             webId: input.webId,

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

@@ -1,9 +1,11 @@
 import type { ProviderSecret } from '../credentials/CredentialVault';
 import { type ProviderDescriptor, type ProviderRegistry } from '../providers/ProviderRegistry';
+import { type DiscoveredProviderModelType } from './ProviderModelType';
+export type { DiscoveredProviderModelType } from './ProviderModelType';
 export type DiscoveredProviderModel = {
     id: string;
     displayName?: string;
-    modelType: 'chat' | 'embedding' | 'image' | 'audio' | 'other';
+    modelType: DiscoveredProviderModelType;
 };
 export interface ProviderModelDiscoveryAdapter {
     readonly provider: string;

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

@@ -4,6 +4,7 @@ exports.DeepSeekModelDiscoveryAdapter = exports.BailianModelDiscoveryAdapter = e
 exports.createProviderModelDiscoveryAdapters = createProviderModelDiscoveryAdapters;
 const errors_1 = require("../errors");
 const ProviderRegistry_1 = require("../providers/ProviderRegistry");
+const ProviderModelType_1 = require("./ProviderModelType");
 const ANTHROPIC_VERSION = '2023-06-01';
 const DEFAULT_MAX_PAGES = 20;
 /**
@@ -274,53 +275,9 @@ function normalizeModelRow(row) {
     return {
         id,
         ...(displayName ? { displayName } : {}),
-        modelType: inferModelType(record, id),
+        modelType: (0, ProviderModelType_1.inferProviderModelType)(record, id),
     };
 }
-function inferModelType(record, id) {
-    const explicit = explicitModelType(record);
-    if (explicit) {
-        return explicit;
-    }
-    const normalizedId = id.toLowerCase();
-    if (/(?:embedding|embed)/u.test(normalizedId)) {
-        return 'embedding';
-    }
-    if (/(?:dall[-_ ]?e|stable[-_ ]?diffusion|flux|imagen|midjourney|image[-_ ]?(?:generation|gen))/u.test(normalizedId)) {
-        return 'image';
-    }
-    if (/(?:whisper|tts|speech|musicgen|audio[-_ ]?(?:generation|gen))/u.test(normalizedId)) {
-        return 'audio';
-    }
-    if (/(?:chat|completion|conversation|text[-_ ]?generation|instruct|reason|coder|gpt|claude|kimi|qwen|deepseek|llama|mistral|gemini)/u.test(normalizedId)) {
-        return 'chat';
-    }
-    return 'other';
-}
-function explicitModelType(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';
-        }
-        if (/(?:image|dall[-_ ]?e|stable[-_ ]?diffusion|flux|imagen)/u.test(normalized)) {
-            return 'image';
-        }
-        if (/(?:audio|whisper|speech|tts)/u.test(normalized)) {
-            return 'audio';
-        }
-        if (/(?:chat|completion|conversation|text[-_ ]?generation|instruct|reason|coder)/u.test(normalized)) {
-            return 'chat';
-        }
-    }
-    return undefined;
-}
 function tokenFromSecret(secret) {
     return nonEmptySecretValue(secret.apiKey) ?? nonEmptySecretValue(secret.accessToken);
 }

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

@@ -2,6 +2,7 @@ import type { AuthContext } from '../../auth/AuthContext';
 import type { GatewayDeployment } from '../auth/InvocationTokenCodec';
 import type { ConnectCredentialRecord, PodCredentialRepository } from '../connect';
 import type { CredentialVault } from '../credentials/CredentialVault';
+import { EmbeddingModelPolicy } from '../../../ai/service/EmbeddingModelPolicy';
 import { type ProviderRegistry } from '../providers/ProviderRegistry';
 import { type DiscoveredProviderModel, type ProviderModelDiscoveryAdapter } from './ProviderModelDiscoveryAdapters';
 import type { PodModelSelection, PodSelectedModelInput, PodModelSelectionRepository } from './PodModelSelectionRepository';
@@ -101,6 +102,12 @@ export interface ProviderModelSelectionServiceOptions {
     baseUrlForProvider?: (provider: string) => string;
     /** Optional provider-model service for offering-aware caller-owned discovery. */
     modelsService?: ProviderModelDiscoveryServiceLike;
+    /**
+     * Deployment policy for embedding models. Discovery can surface any model a
+     * BYOK endpoint advertises; a cloud deployment may still only select embedding
+     * models its gateway catalog provides.
+     */
+    embeddingModelPolicy?: EmbeddingModelPolicy;
     /** Opens the selected caller credential when the Pod stores a secret cell. */
     credentialVault?: CredentialVault;
     now?: () => Date;
@@ -119,6 +126,7 @@ export declare class ProviderModelSelectionService {
     private readonly baseUrlForProvider?;
     private readonly modelsService?;
     private readonly credentialVault?;
+    private readonly embeddingModelPolicy;
     private readonly now;
     private readonly cacheTtlMs;
     private readonly cache;
@@ -131,6 +139,8 @@ export declare class ProviderModelSelectionService {
     private discoverAndCache;
     private openCredentialSecret;
     private discoverProviderModels;
+    /** Cloud settings only manage providers this deployment provides. */
+    private requireProvidedProvider;
     private resolveCredential;
     private resolveOptionalCredential;
     private discoveryContext;