@undefineds.co/xpod 0.4.10 → 0.4.12

package/dist/ai/service/EmbeddingModelPolicy.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Deployment policy for embedding models and their endpoint.
+ *
+ * The ai-gateway provider catalog is the authority for which models a
+ * deployment provides. A Cloud deployment must not offer arbitrary embedding
+ * models — not even through a BYOK credential — and a Cloud user cannot supply an
+ * endpoint: the catalog names the provider and the endpoint, the user only brings
+ * an API key. A Local deployment may use any model and any endpoint the user
+ * configures. This module is the single decision point so the registration,
+ * configuration and runtime paths cannot drift apart.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingModelPolicy = exports.EmbeddingEndpointNotProvidedError = exports.EmbeddingModelNotAllowedError = exports.EmbeddingPolicyError = exports.EMBEDDING_ENDPOINT_NOT_PROVIDED = exports.EMBEDDING_MODEL_NOT_ALLOWED = void 0;
+exports.createEmbeddingModelPolicy = createEmbeddingModelPolicy;
+exports.isEmbeddingPolicyRejection = isEmbeddingPolicyRejection;
+exports.isEmbeddingModelNotAllowedError = isEmbeddingModelNotAllowedError;
+exports.parseEmbeddingModelRef = parseEmbeddingModelRef;
+exports.EMBEDDING_MODEL_NOT_ALLOWED = 'embedding_model_not_allowed';
+exports.EMBEDDING_ENDPOINT_NOT_PROVIDED = 'embedding_endpoint_not_provided';
+const POLICY_REJECTION_CODES = new Set([
+    exports.EMBEDDING_MODEL_NOT_ALLOWED,
+    exports.EMBEDDING_ENDPOINT_NOT_PROVIDED,
+]);
+class EmbeddingPolicyError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = new.target.name;
+    }
+}
+exports.EmbeddingPolicyError = EmbeddingPolicyError;
+class EmbeddingModelNotAllowedError extends EmbeddingPolicyError {
+    constructor(provider, model) {
+        super(exports.EMBEDDING_MODEL_NOT_ALLOWED, `Embedding model "${model}" is not provided for provider "${provider}" in this deployment`);
+    }
+}
+exports.EmbeddingModelNotAllowedError = EmbeddingModelNotAllowedError;
+class EmbeddingEndpointNotProvidedError extends EmbeddingPolicyError {
+    constructor(provider) {
+        super(exports.EMBEDDING_ENDPOINT_NOT_PROVIDED, `No embedding endpoint is provided for provider "${provider}" in this deployment`);
+    }
+}
+exports.EmbeddingEndpointNotProvidedError = EmbeddingEndpointNotProvidedError;
+class EmbeddingModelPolicy {
+    constructor(catalog) {
+        this.catalog = catalog;
+    }
+    /** Local deployments (and runtimes without a catalog) keep arbitrary BYOK models. */
+    static allowAll() {
+        return new EmbeddingModelPolicy(undefined);
+    }
+    static fromCatalog(catalog) {
+        return new EmbeddingModelPolicy(catalog);
+    }
+    isEnforced() {
+        return this.catalog !== undefined;
+    }
+    isAllowed(input) {
+        if (!this.catalog) {
+            return true;
+        }
+        const provider = input.provider.trim();
+        const model = input.model.trim();
+        if (!provider || !model) {
+            return false;
+        }
+        return this.catalog.isManagedEmbeddingModel(provider, model);
+    }
+    assertAllowed(input) {
+        if (!this.isAllowed(input)) {
+            throw new EmbeddingModelNotAllowedError(input.provider, input.model);
+        }
+    }
+    /**
+     * Resolve the endpoint an embedding call may use.
+     *
+     * Local (and catalog-less runtimes) keep whatever the Pod carries. A Cloud
+     * deployment replaces the Pod endpoint with the one its catalog provides and
+     * drops any Pod proxy, so a BYOK key can never redirect Cloud egress.
+     */
+    resolveEndpoint(input) {
+        if (!this.catalog) {
+            return { baseUrl: input.baseUrl, proxyUrl: input.proxyUrl, source: 'pod' };
+        }
+        const baseUrl = this.catalog.managedEmbeddingBaseUrl(input.provider);
+        if (!baseUrl) {
+            throw new EmbeddingEndpointNotProvidedError(input.provider);
+        }
+        return { baseUrl, proxyUrl: undefined, source: 'catalog' };
+    }
+}
+exports.EmbeddingModelPolicy = EmbeddingModelPolicy;
+function createEmbeddingModelPolicy(input) {
+    if (input.deployment !== 'cloud' || !input.catalog) {
+        return EmbeddingModelPolicy.allowAll();
+    }
+    return EmbeddingModelPolicy.fromCatalog(input.catalog);
+}
+/** True for every deployment rejection, so callers never retry a policy decision. */
+function isEmbeddingPolicyRejection(error) {
+    if (error instanceof EmbeddingPolicyError) {
+        return true;
+    }
+    const code = typeof error === 'object' && error !== null ? error.code : undefined;
+    return typeof code === 'string' && POLICY_REJECTION_CODES.has(code);
+}
+function isEmbeddingModelNotAllowedError(error) {
+    if (error instanceof EmbeddingModelNotAllowedError) {
+        return true;
+    }
+    const code = typeof error === 'object' && error !== null ? error.code : undefined;
+    return code === exports.EMBEDDING_MODEL_NOT_ALLOWED;
+}
+/**
+ * Parse an AI Config model assignment (`settings/providers/<provider>.ttl#<model>`
+ * or its absolute form) into the provider/model pair the policy checks. A ref
+ * that does not name both cannot be proven to be provided, so it resolves to
+ * `undefined` and an enforcing policy rejects it.
+ */
+function parseEmbeddingModelRef(ref) {
+    const trimmed = ref.trim();
+    const hashIndex = trimmed.lastIndexOf('#');
+    if (hashIndex < 0) {
+        return undefined;
+    }
+    const provider = /(?:^|\/)settings\/providers\/([^/]+)\.ttl$/u.exec(trimmed.slice(0, hashIndex))?.[1];
+    const model = trimmed.slice(hashIndex + 1).trim();
+    if (!provider || !model) {
+        return undefined;
+    }
+    return { provider: decodeURIComponent(provider), model: decodeURIComponent(model) };
+}
+//# sourceMappingURL=EmbeddingModelPolicy.js.map

package/dist/ai/service/EmbeddingProviderError.js

@@ -2,11 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.classifyEmbeddingProviderFailure = classifyEmbeddingProviderFailure;
 const ai_1 = require("ai");
+const EmbeddingModelPolicy_1 = require("./EmbeddingModelPolicy");
 /** Classify AI SDK failures without inspecting provider-specific message text. */
 function classifyEmbeddingProviderFailure(error) {
     if (ai_1.RetryError.isInstance(error) && error.lastError !== error) {
         return classifyEmbeddingProviderFailure(error.lastError);
     }
+    // A deployment rejecting the model or the endpoint is a permanent
+    // configuration problem: the same request must not be retried against the provider.
+    if ((0, EmbeddingModelPolicy_1.isEmbeddingPolicyRejection)(error)) {
+        return { retryable: false, category: 'embedding_model_invalid' };
+    }
     if (ai_1.NoSuchModelError.isInstance(error)) {
         return { retryable: false, category: 'embedding_model_invalid' };
     }

package/dist/ai/service/EmbeddingServiceImpl.d.ts

@@ -1,9 +1,21 @@
 import { EmbeddingService } from './EmbeddingService';
+import { EmbeddingModelPolicy } from './EmbeddingModelPolicy';
 import type { ProviderRegistry } from './ProviderRegistry';
 import type { AiCredential } from './types';
+export interface EmbeddingServiceImplOptions {
+    /**
+     * Deployment embedding policy. Every embedding call goes through this service,
+     * so this is the hard boundary: Cloud never reaches a provider with an
+     * embedding model — or an endpoint — its gateway catalog does not provide,
+     * regardless of what the user's Pod contains.
+     */
+    policy?: EmbeddingModelPolicy;
+}
 export declare class EmbeddingServiceImpl extends EmbeddingService {
+    protected readonly logger: import("global-logger-factory").Logger<unknown>;
     private providerRegistry;
-    constructor(providerRegistry: ProviderRegistry);
+    private readonly policy;
+    constructor(providerRegistry: ProviderRegistry, options?: EmbeddingServiceImplOptions);
     embed(text: string, credential: AiCredential, modelId: string): Promise<number[]>;
     embedBatch(texts: string[], credential: AiCredential, modelId: string): Promise<number[][]>;
     private createEmbeddingModel;

package/dist/ai/service/EmbeddingServiceImpl.js

@@ -26,13 +26,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EmbeddingServiceImpl = void 0;
 const openai_1 = require("@ai-sdk/openai");
 const ai_1 = require("ai");
+const global_logger_factory_1 = require("global-logger-factory");
 const EmbeddingService_1 = require("./EmbeddingService");
+const EmbeddingModelPolicy_1 = require("./EmbeddingModelPolicy");
 class EmbeddingServiceImpl extends EmbeddingService_1.EmbeddingService {
-    constructor(providerRegistry) {
+    constructor(providerRegistry, options = {}) {
         super();
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.providerRegistry = providerRegistry;
+        this.policy = options.policy ?? EmbeddingModelPolicy_1.EmbeddingModelPolicy.allowAll();
     }
     async embed(text, credential, modelId) {
+        this.policy.assertAllowed({ provider: credential.provider, model: modelId });
         const model = await this.createEmbeddingModel(credential, modelId);
         const result = await (0, ai_1.embed)({ model, value: text });
         return result.embedding;
@@ -40,6 +45,7 @@ class EmbeddingServiceImpl extends EmbeddingService_1.EmbeddingService {
     async embedBatch(texts, credential, modelId) {
         if (texts.length === 0)
             return [];
+        this.policy.assertAllowed({ provider: credential.provider, model: modelId });
         const model = await this.createEmbeddingModel(credential, modelId);
         const modelInfo = await this.providerRegistry.getEmbeddingModel(credential.provider, modelId);
         const maxBatchSize = modelInfo?.maxBatchSize;
@@ -57,17 +63,24 @@ class EmbeddingServiceImpl extends EmbeddingService_1.EmbeddingService {
     }
     async createEmbeddingModel(credential, modelName) {
         const provider = await this.providerRegistry.getProvider(credential.provider);
-        const baseUrl = credential.baseUrl || provider?.baseUrl;
-        const proxyUrl = credential.proxyUrl || provider?.proxyUrl;
+        const endpoint = this.policy.resolveEndpoint({
+            provider: credential.provider,
+            baseUrl: credential.baseUrl || provider?.baseUrl,
+            proxyUrl: credential.proxyUrl || provider?.proxyUrl,
+        });
+        const baseUrl = endpoint.baseUrl;
         if (!baseUrl) {
             throw new Error(`No baseUrl found for provider: ${credential.provider}`);
         }
+        if (endpoint.source === 'catalog' && credential.baseUrl && credential.baseUrl !== baseUrl) {
+            this.logger.info(`Ignoring Pod-provided embedding endpoint for ${credential.provider}; this deployment provides ${baseUrl}`);
+        }
         const clientConfig = {
             apiKey: credential.apiKey,
             baseURL: baseUrl,
         };
-        if (proxyUrl) {
-            clientConfig.fetch = await this.createProxyFetch(proxyUrl);
+        if (endpoint.proxyUrl) {
+            clientConfig.fetch = await this.createProxyFetch(endpoint.proxyUrl);
         }
         const client = (0, openai_1.createOpenAI)(clientConfig);
         return client.embedding(modelName);

package/dist/ai/service/EmbeddingServiceImpl.jsonld

@@ -15,13 +15,37 @@
         {
           "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl_providerRegistry",
           "range": "undefineds:dist/ai/service/ProviderRegistry.jsonld#ProviderRegistry"
+        },
+        {
+          "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl_options_policy",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              "undefineds:dist/ai/service/EmbeddingModelPolicy.jsonld#EmbeddingModelPolicy",
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "Deployment embedding policy. Every embedding call goes through this service, so this is the hard boundary: Cloud never reaches a provider with an embedding model — or an endpoint — its gateway catalog does not provide, regardless of what the user's Pod contains."
         }
       ],
       "memberFields": [
+        {
+          "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl__member_logger",
+          "memberFieldName": "logger",
+          "range": {
+            "@type": "ParameterRangeWildcard"
+          }
+        },
         {
           "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl__member_providerRegistry",
           "memberFieldName": "providerRegistry"
         },
+        {
+          "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl__member_policy",
+          "memberFieldName": "policy"
+        },
         {
           "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl__member_constructor",
           "memberFieldName": "constructor"
@@ -46,6 +70,17 @@
       "constructorArguments": [
         {
           "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl_providerRegistry"
+        },
+        {
+          "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl_options__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "policy",
+              "value": {
+                "@id": "undefineds:dist/ai/service/EmbeddingServiceImpl.jsonld#EmbeddingServiceImpl_options_policy"
+              }
+            }
+          ]
         }
       ]
     }

package/dist/ai/service/index.d.ts

@@ -4,6 +4,8 @@
 export * from './types';
 export * from './EmbeddingService';
 export * from './EmbeddingServiceImpl';
+export * from './EmbeddingModelPolicy';
+export * from './AiCredentialSecret';
 export * from './CredentialReader';
 export * from './CredentialReaderImpl';
 export * from './ProviderRegistry';

package/dist/ai/service/index.js

@@ -22,6 +22,8 @@ __exportStar(require("./types"), exports);
 // Services
 __exportStar(require("./EmbeddingService"), exports);
 __exportStar(require("./EmbeddingServiceImpl"), exports);
+__exportStar(require("./EmbeddingModelPolicy"), exports);
+__exportStar(require("./AiCredentialSecret"), exports);
 __exportStar(require("./CredentialReader"), exports);
 __exportStar(require("./CredentialReaderImpl"), exports);
 __exportStar(require("./ProviderRegistry"), exports);

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

@@ -2,7 +2,7 @@ import { aiModelResource, aiProviderResource, credentialResource } from '@undefi
 import type { EncryptedCredentialSecret } from '../credentials/KeyWrapper';
 import type { CredentialVault, ProviderSecret } from '../credentials/CredentialVault';
 import type { GatewayDeployment } from '../auth/InvocationTokenCodec';
-import { type ProviderOfferingEndpointDescriptor, type ProviderRegistry } from '../providers/ProviderRegistry';
+import { type ProviderOfferingEndpointDescriptor, type ProviderCapabilities, type ProviderRegistry } from '../providers/ProviderRegistry';
 import type { OfferingAuthorizationMethod } from '../providers/OfferingAuthorization';
 import type { AuthContext } from '../../auth/AuthContext';
 import type { InternalPodAccessTokenProvider } from '../pod/HostedPodDataAccess';
@@ -269,6 +269,8 @@ export declare class PodConnectedCredentialRepository implements PodCredentialRe
         accountLabel?: string;
         priority?: number;
         models?: string[];
+        /** Display names the Pod recorded for `models`, keyed by model id. */
+        modelNames?: Record<string, string>;
         customModels?: CustomProviderModel[];
         defaultModel?: string;
         health?: 'healthy' | 'reauthRequired' | 'disabled' | 'error' | 'invalid' | 'unknown';
@@ -548,7 +550,14 @@ export interface AiGatewayModelSummary {
     custom?: boolean;
     inputModalities?: string[];
     outputModalities?: string[];
-    capabilities?: string[];
+    /** Custom models declare their own tokens; catalog models carry the object flags. */
+    capabilities?: string[] | ProviderCapabilities;
+    /** Token list the client reads first, so custom declarations survive normalisation. */
+    custom_capabilities?: string[];
+    modalities?: {
+        input?: string[];
+        output?: string[];
+    };
 }
 export interface AiProviderPoolSummary {
     id: string;
@@ -608,6 +617,15 @@ export interface ProviderCredentialTestModelsService {
     }>;
 }
 export declare class ProviderConnectService {
+    /** Cloud settings only manage providers this deployment provides. */
+    private requireProvidedProvider;
+    /**
+     * 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.
+     */
+    private assertEndpointIsProvided;
+    private providedEndpoints;
     private static readonly localImportLocks;
     private readonly registry;
     private readonly credentialRepository?;