@undefineds.co/xpod 0.4.10 → 0.4.12

package/config/components-ignore.json

@@ -8,6 +8,7 @@
   "InvalidRelaySessionRequestError",
   "InvalidTunnelTokenError",
   "LEGACY_DERIVED_INDEX_CONSUMER_ID",
+  "LOG_FILE_PATTERN",
   "normalizeContext",
   "NodeRouteSourceNotFoundError",
   "Omit",
@@ -15,6 +16,8 @@
   "P2PSessionNotFoundError",
   "P2PSignalingRequestError",
   "registerDeviceNotificationRuntime",
+  "resolveCurrentLogFile",
+  "resolveLogFilePattern",
   "SearchApiError",
   "SolidFsConflictError",
   "SolidFsNotFoundError",
@@ -22,5 +25,6 @@
   "UnsupportedSparqlQueryError",
   "Uint8Array",
   "VectorApiError",
-  "WaitingRunnerError"
+  "WaitingRunnerError",
+  "ActivityEmitter"
 ]

package/config/notifications.json

@@ -0,0 +1,68 @@
+{
+  "@context": [
+    "https://linkedsoftwaredependencies.org/bundles/npm/@solid/community-server/^8.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/components/context.jsonld",
+    "https://linkedsoftwaredependencies.org/bundles/npm/asynchronous-handlers/^1.0.0/components/context.jsonld"
+  ],
+  "@graph": [
+    {
+      "comment": "订阅通道记录在 internal_kv 里的只读视图（键前缀与 css:config/http/notifications/base/storage.json 的 ContainerPathStorage 保持一致，清扫器靠它枚举通道）。",
+      "@id": "urn:undefineds:xpod:NotificationChannelIndexStorage",
+      "@type": "ContainerPathStorage",
+      "relativePath": "/notifications/",
+      "source": {
+        "@id": "urn:solid-server:default:KeyValueStorage"
+      }
+    },
+    {
+      "comment": "CSS 的 WebSocket2023Storer 只在 socket 关闭时把它从内存 map 移除，通道记录会一直留到 endAt 过期；这里等位替换，在某个通道的最后一个 socket 关闭或出错时删除该通道。",
+      "@type": "Override",
+      "overrideInstance": {
+        "@id": "urn:solid-server:default:WebSocket2023Storer"
+      },
+      "overrideParameters": {
+        "@type": "ReclaimingWebSocket2023Storer",
+        "storage": {
+          "@id": "urn:solid-server:default:SubscriptionStorage"
+        },
+        "socketMap": {
+          "@id": "urn:solid-server:default:WebSocketMap"
+        }
+      }
+    },
+    {
+      "comment": "启动时清扫一次（进程刚起来，内存 map 必为空，持久化的通道不可能还有活动 socket），之后每 5 分钟清扫一次：无 socket 的通道需要连续两次被判定为孤儿才删除，给“刚创建、socket 还在握手”的通道留出宽限期。只回收本实例 baseUrl 下的通道。",
+      "@id": "urn:undefineds:xpod:NotificationChannelSweeper",
+      "@type": "NotificationChannelSweeper",
+      "storage": {
+        "@id": "urn:solid-server:default:SubscriptionStorage"
+      },
+      "channelIndex": {
+        "@id": "urn:undefineds:xpod:NotificationChannelIndexStorage"
+      },
+      "socketMap": {
+        "@id": "urn:solid-server:default:WebSocketMap"
+      },
+      "baseUrl": {
+        "@id": "urn:solid-server:default:variable:baseUrl"
+      },
+      "intervalMinutes": 5
+    },
+    {
+      "comment": "把清扫器挂进 CSS 启动序列：与 css:config/http/notifications/base/listener.json 挂 ListeningActivityHandler 是同一机制（同一实例的 handlers 数组会追加）。",
+      "@id": "urn:solid-server:default:PrimaryParallelInitializer",
+      "@type": "ParallelHandler",
+      "handlers": [
+        {
+          "@id": "urn:undefineds:xpod:NotificationChannelSweeper"
+        }
+      ]
+    },
+    {
+      "comment": "寿命兜底：通道最长 12 小时（单位分钟，CSS 默认 20160 分钟即 2 周）。清扫生效时它只是第三道防线，同时保证长时间开着的页面最多被强制重新订阅一次。",
+      "@id": "urn:solid-server:default:WebSocket2023Subscriber",
+      "@type": "NotificationSubscriber",
+      "maxDuration": 720
+    }
+  ]
+}

package/config/xpod.base.json

@@ -16,7 +16,8 @@
   ],
   "import": [
     "./cli.json",
-    "./resolver.json"
+    "./resolver.json",
+    "./notifications.json"
   ],
   "@graph": [
     {
@@ -296,23 +297,17 @@
     {
       "comment": "Preserve exact WebID IRIs only in controlled CSS RDF templates; keep EJS and HTML escaping unchanged.",
       "@type": "Override",
-      "overrideInstance": {
-        "@id": "urn:solid-server:default:TemplateEngine"
-      },
+      "overrideInstance": { "@id": "urn:solid-server:default:TemplateEngine" },
       "overrideParameters": {
         "@type": "StatusWaterfallHandler",
         "handlers": [
           {
             "@type": "EjsTemplateEngine",
-            "baseUrl": {
-              "@id": "urn:solid-server:default:variable:baseUrl"
-            }
+            "baseUrl": { "@id": "urn:solid-server:default:variable:baseUrl" }
           },
           {
             "@type": "RdfHandlebarsTemplateEngine",
-            "rdfTemplateBaseUrl": {
-              "@id": "urn:solid-server:default:variable:baseUrl"
-            }
+            "rdfTemplateBaseUrl": { "@id": "urn:solid-server:default:variable:baseUrl" }
           }
         ]
       }
@@ -375,7 +370,7 @@
       }
     },
     {
-      "comment": "Serves subgraph-scoped SPARQL endpoints",
+      "comment": "Serves subgraph-scoped SPARQL endpoints. `emitter` is the activity emitter the notification stack listens to (css:config/http/notifications/base/listener.json subscribes to urn:solid-server:default:ResourceStore, i.e. the MonitoringStore), so /-/sparql writes notify like store writes.",
       "@type": "SubgraphSparqlHttpHandler",
       "@id": "urn:undefineds:xpod:SubgraphSparqlHttpHandler",
       "queryEngine": {
@@ -393,6 +388,9 @@
       "updateAuthority": {
         "@id": "urn:undefineds:xpod:MixDataAccessor"
       },
+      "emitter": {
+        "@id": "urn:solid-server:default:ResourceStore"
+      },
       "options_identityDbUrl": {
         "@id": "urn:solid-server:default:variable:identityDbUrl",
         "@type": "Variable"

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

@@ -0,0 +1,30 @@
+/**
+ * Reading a Pod AI credential's secret.
+ *
+ * AI Connections stores the provider secret as an `encryptedSecret` envelope
+ * (plaintext JSON envelope locally, a wrapped secret cell in Cloud), while some
+ * older rows carry a bare `apiKey` property. Every consumer that needs the key —
+ * the Gateway for chat, and the embedding/indexing paths — must read the secret
+ * the same way, otherwise a key entered through AI Connections works for chat but
+ * not for embeddings.
+ */
+export declare const PLAINTEXT_CREDENTIAL_ALGORITHM = "PLAINTEXT";
+export interface AiCredentialSecretContext {
+    webId: string;
+    /** Credential resource IRI, when the caller knows it (required by wrapped envelopes). */
+    credentialIri?: string;
+    /** Provider id, when the caller knows it (required by wrapped envelopes). */
+    provider?: string;
+}
+export type AiCredentialSecret = Record<string, unknown>;
+export type AiCredentialSecretDecoder = (row: Record<string, unknown>, context: AiCredentialSecretContext) => Promise<AiCredentialSecret | undefined> | AiCredentialSecret | undefined;
+/**
+ * Default decoder: bare `apiKey`, the `plaintext-v1` payload shape, and the
+ * `PLAINTEXT` envelope AI Connections writes locally. Wrapped envelopes return
+ * `undefined` so a caller with a credential vault can decode them.
+ */
+export declare const defaultAiCredentialSecretDecoder: AiCredentialSecretDecoder;
+export declare function decodePlaintextAiCredentialSecret(row: Record<string, unknown>): AiCredentialSecret | undefined;
+export declare function parseCredentialEnvelope(value: unknown): Record<string, unknown> | undefined;
+/** Token fields a decoded secret may carry instead of `apiKey`. */
+export declare function providerTokenFromSecret(secret: AiCredentialSecret | undefined): string | undefined;

package/dist/ai/service/AiCredentialSecret.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Reading a Pod AI credential's secret.
+ *
+ * AI Connections stores the provider secret as an `encryptedSecret` envelope
+ * (plaintext JSON envelope locally, a wrapped secret cell in Cloud), while some
+ * older rows carry a bare `apiKey` property. Every consumer that needs the key —
+ * the Gateway for chat, and the embedding/indexing paths — must read the secret
+ * the same way, otherwise a key entered through AI Connections works for chat but
+ * not for embeddings.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAiCredentialSecretDecoder = exports.PLAINTEXT_CREDENTIAL_ALGORITHM = void 0;
+exports.decodePlaintextAiCredentialSecret = decodePlaintextAiCredentialSecret;
+exports.parseCredentialEnvelope = parseCredentialEnvelope;
+exports.providerTokenFromSecret = providerTokenFromSecret;
+exports.PLAINTEXT_CREDENTIAL_ALGORITHM = 'PLAINTEXT';
+/**
+ * Default decoder: bare `apiKey`, the `plaintext-v1` payload shape, and the
+ * `PLAINTEXT` envelope AI Connections writes locally. Wrapped envelopes return
+ * `undefined` so a caller with a credential vault can decode them.
+ */
+const defaultAiCredentialSecretDecoder = (row) => decodePlaintextAiCredentialSecret(row);
+exports.defaultAiCredentialSecretDecoder = defaultAiCredentialSecretDecoder;
+function decodePlaintextAiCredentialSecret(row) {
+    const apiKey = stringValue(row.apiKey);
+    if (apiKey) {
+        return { ...apiKeySecret(row), apiKey };
+    }
+    const payload = decodePlaintextPayload(row);
+    if (payload) {
+        return payload;
+    }
+    return decodePlaintextEnvelope(row.encryptedSecret, row.secretPayload);
+}
+/** The `plaintext-v1` storage shape: a JSON `secretPayload` column. */
+function decodePlaintextPayload(row) {
+    const storageMode = stringValue(row.storageMode);
+    const secretPayload = stringValue(row.secretPayload);
+    if (storageMode !== 'plaintext-v1' || !secretPayload) {
+        return undefined;
+    }
+    return parseSecretObject(secretPayload);
+}
+/** The `encryptedSecret` envelope shape used by AI Connections. */
+function decodePlaintextEnvelope(encryptedSecret, secretPayload) {
+    const envelope = parseEnvelope(encryptedSecret) ?? parseEnvelope(secretPayload);
+    if (!envelope) {
+        return undefined;
+    }
+    const algorithm = stringValue(envelope.algorithm);
+    if (algorithm !== exports.PLAINTEXT_CREDENTIAL_ALGORITHM) {
+        return undefined;
+    }
+    const ciphertext = stringValue(envelope.ciphertext);
+    if (!ciphertext) {
+        return undefined;
+    }
+    if (stringValue(envelope.encoding) === 'base64') {
+        try {
+            return parseSecretObject(Buffer.from(ciphertext, 'base64').toString('utf8'));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return parseSecretObject(ciphertext);
+}
+function parseCredentialEnvelope(value) {
+    return parseEnvelope(value);
+}
+function parseEnvelope(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    const serialized = stringValue(value);
+    if (!serialized) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(serialized);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseSecretObject(serialized) {
+    if (!serialized.trim()) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(serialized);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Token fields a decoded secret may carry instead of `apiKey`. */
+function providerTokenFromSecret(secret) {
+    if (!secret) {
+        return undefined;
+    }
+    return stringValue(secret.apiKey)
+        ?? stringValue(secret.accessToken)
+        ?? stringValue(secret.token);
+}
+function apiKeySecret(row) {
+    const accessToken = stringValue(row.accessToken);
+    return accessToken ? { accessToken } : {};
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+//# sourceMappingURL=AiCredentialSecret.js.map

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

@@ -1,8 +1,26 @@
 import { CredentialReader } from './CredentialReader';
 import type { AiCredential } from './types';
+import { type AiCredentialSecretDecoder } from './AiCredentialSecret';
+export interface CredentialReaderImplOptions {
+    /**
+     * Reads the Pod credential secret. Defaults to the plaintext decoder, which
+     * covers bare `apiKey` rows, `plaintext-v1` payloads, and the `PLAINTEXT`
+     * envelope AI Connections writes; the container injects a vault-backed decoder
+     * so wrapped Cloud secrets resolve too.
+     */
+    secretDecoder?: AiCredentialSecretDecoder;
+}
 export declare class CredentialReaderImpl extends CredentialReader {
     protected readonly logger: import("global-logger-factory").Logger<unknown>;
+    private readonly secretDecoder;
+    constructor(options?: CredentialReaderImplOptions);
     getAiCredential(podBaseUrl: string, providerId: string, authenticatedFetch: typeof fetch, webId?: string, options?: {
         credentialId?: string;
     }): Promise<AiCredential | null>;
+    /**
+     * AI Connections stores the provider secret in `encryptedSecret`; the shared
+     * selector only understands a plain `apiKey`. Decode each row first so the
+     * extension runtime sees the same credentials the Gateway does.
+     */
+    private withDecodedSecrets;
 }

package/dist/ai/service/CredentialReaderImpl.js

@@ -5,6 +5,7 @@ const global_logger_factory_1 = require("global-logger-factory");
 const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
 const CredentialReader_1 = require("./CredentialReader");
+const AiCredentialSecret_1 = require("./AiCredentialSecret");
 const tables_1 = require("../../credential/schema/tables");
 const provider_1 = require("../schema/provider");
 const types_1 = require("../../credential/schema/types");
@@ -13,9 +14,10 @@ const schema = {
     provider: provider_1.Provider,
 };
 class CredentialReaderImpl extends CredentialReader_1.CredentialReader {
-    constructor() {
-        super(...arguments);
+    constructor(options = {}) {
+        super();
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.secretDecoder = options.secretDecoder ?? AiCredentialSecret_1.defaultAiCredentialSecretDecoder;
     }
     async getAiCredential(podBaseUrl, providerId, authenticatedFetch, webId, options = {}) {
         try {
@@ -28,10 +30,12 @@ class CredentialReaderImpl extends CredentialReader_1.CredentialReader {
                 where: (0, drizzle_solid_1.and)((0, drizzle_solid_1.eq)(tables_1.Credential.service, types_1.ServiceType.AI), (0, drizzle_solid_1.eq)(tables_1.Credential.status, types_1.CredentialStatus.ACTIVE)),
             });
             const providers = await db.query.provider.findMany();
+            const enabled = credentials.filter((credential) => credentialEnabled(credential));
             const credentialRows = options.credentialId
-                ? credentials.filter((credential) => matchesCredentialId(credential, options.credentialId))
-                : credentials;
-            const selection = (0, models_1.selectAIConfigCredential)(providerId, credentialRows, providers);
+                ? enabled.filter((credential) => matchesCredentialId(credential, options.credentialId))
+                : enabled;
+            const decrypted = await this.withDecodedSecrets(credentialRows, { podBaseUrl, webId });
+            const selection = (0, models_1.selectAIConfigCredential)(providerId, decrypted, providers);
             if (!selection) {
                 this.logger.debug(`No active credential found for provider: ${providerId}`);
                 return null;
@@ -49,8 +53,80 @@ class CredentialReaderImpl extends CredentialReader_1.CredentialReader {
             return null;
         }
     }
+    /**
+     * AI Connections stores the provider secret in `encryptedSecret`; the shared
+     * selector only understands a plain `apiKey`. Decode each row first so the
+     * extension runtime sees the same credentials the Gateway does.
+     */
+    async withDecodedSecrets(rows, context) {
+        return Promise.all(rows.map(async (row) => {
+            if (typeof row?.apiKey === 'string' && row.apiKey.trim()) {
+                return row;
+            }
+            try {
+                const secret = await this.secretDecoder(row, {
+                    webId: context.webId ?? '',
+                    credentialIri: credentialIriFor(row, context.podBaseUrl),
+                    provider: credentialProviderId(row),
+                });
+                const apiKey = (0, AiCredentialSecret_1.providerTokenFromSecret)(secret);
+                return apiKey ? { ...row, apiKey } : row;
+            }
+            catch (error) {
+                this.logger.debug(`Failed to decode credential secret ${String(row?.id)}: ${error}`);
+                return row;
+            }
+        }));
+    }
 }
 exports.CredentialReaderImpl = CredentialReaderImpl;
+function credentialEnabled(credential) {
+    const metadata = parseMetadata(credential?.metadata);
+    return metadata?.enabled !== false;
+}
+function parseMetadata(value) {
+    if (value && typeof value === 'object' && !Array.isArray(value)) {
+        return value;
+    }
+    if (typeof value !== 'string' || !value.trim()) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function credentialIriFor(row, podBaseUrl) {
+    const id = typeof row?.id === 'string' ? row.id : undefined;
+    const iri = typeof row?.['@id'] === 'string' ? row['@id'] : undefined;
+    if (iri) {
+        return iri;
+    }
+    if (!id) {
+        return undefined;
+    }
+    if (/^https?:\/\//.test(id)) {
+        return id;
+    }
+    const base = podBaseUrl?.replace(/\/+$/, '');
+    return base ? `${base}/settings/credentials.ttl#${id}` : undefined;
+}
+function credentialProviderId(row) {
+    const value = typeof row?.provider === 'string' ? row.provider : undefined;
+    if (!value) {
+        return undefined;
+    }
+    const fragment = value.lastIndexOf('#');
+    const withoutFragment = fragment >= 0 && fragment < value.length - 1 ? value.slice(fragment + 1) : value;
+    const clean = withoutFragment.replace(/\/+$/, '').replace(/\.ttl$/u, '');
+    const segment = clean.slice(clean.lastIndexOf('/') + 1);
+    return segment || undefined;
+}
 function matchesCredentialId(credential, requestedId) {
     if (!requestedId)
         return true;

package/dist/ai/service/CredentialReaderImpl.jsonld

@@ -11,7 +11,23 @@
       "extends": [
         "undefineds:dist/ai/service/CredentialReader.jsonld#CredentialReader"
       ],
-      "parameters": [],
+      "parameters": [
+        {
+          "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl_options_secretDecoder",
+          "range": {
+            "@type": "ParameterRangeUnion",
+            "parameterRangeElements": [
+              {
+                "@type": "ParameterRangeWildcard"
+              },
+              {
+                "@type": "ParameterRangeUndefined"
+              }
+            ]
+          },
+          "comment": "Reads the Pod credential secret. Defaults to the plaintext decoder, which covers bare `apiKey` rows, `plaintext-v1` payloads, and the `PLAINTEXT` envelope AI Connections writes; the container injects a vault-backed decoder so wrapped Cloud secrets resolve too."
+        }
+      ],
       "memberFields": [
         {
           "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl__member_logger",
@@ -20,12 +36,36 @@
             "@type": "ParameterRangeWildcard"
           }
         },
+        {
+          "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl__member_secretDecoder",
+          "memberFieldName": "secretDecoder"
+        },
+        {
+          "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl__member_constructor",
+          "memberFieldName": "constructor"
+        },
         {
           "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl__member_getAiCredential",
           "memberFieldName": "getAiCredential"
+        },
+        {
+          "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl__member_withDecodedSecrets",
+          "memberFieldName": "withDecodedSecrets"
         }
       ],
-      "constructorArguments": []
+      "constructorArguments": [
+        {
+          "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl_options__constructorArgument",
+          "fields": [
+            {
+              "keyRaw": "secretDecoder",
+              "value": {
+                "@id": "undefineds:dist/ai/service/CredentialReaderImpl.jsonld#CredentialReaderImpl_options_secretDecoder"
+              }
+            }
+          ]
+        }
+      ]
     }
   ]
 }

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

@@ -0,0 +1,79 @@
+/**
+ * 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.
+ */
+export declare const EMBEDDING_MODEL_NOT_ALLOWED = "embedding_model_not_allowed";
+export declare const EMBEDDING_ENDPOINT_NOT_PROVIDED = "embedding_endpoint_not_provided";
+/** Port over the ai-gateway provider catalog. */
+export interface EmbeddingModelCatalog {
+    /** True only for models this catalog provides as embedding models. */
+    isManagedEmbeddingModel(provider: string, modelId: string): boolean;
+    /** Endpoint this deployment provides for that provider, if it provides one. */
+    managedEmbeddingBaseUrl(provider: string): string | undefined;
+}
+export interface EmbeddingModelPolicyInput {
+    deployment: string;
+    catalog?: EmbeddingModelCatalog;
+}
+export interface EmbeddingModelRequest {
+    provider: string;
+    model: string;
+}
+/** Endpoint inputs a Pod may carry. A Cloud deployment ignores the Pod values. */
+export interface EmbeddingEndpointRequest {
+    provider: string;
+    baseUrl?: string;
+    proxyUrl?: string;
+}
+export interface EmbeddingEndpoint {
+    baseUrl?: string;
+    proxyUrl?: string;
+    /** Whether the endpoint came from the deployment catalog or from the Pod. */
+    source: 'catalog' | 'pod';
+}
+export declare class EmbeddingPolicyError extends Error {
+    readonly code: string;
+    protected constructor(code: string, message: string);
+}
+export declare class EmbeddingModelNotAllowedError extends EmbeddingPolicyError {
+    constructor(provider: string, model: string);
+}
+export declare class EmbeddingEndpointNotProvidedError extends EmbeddingPolicyError {
+    constructor(provider: string);
+}
+export declare class EmbeddingModelPolicy {
+    private readonly catalog?;
+    private constructor();
+    /** Local deployments (and runtimes without a catalog) keep arbitrary BYOK models. */
+    static allowAll(): EmbeddingModelPolicy;
+    static fromCatalog(catalog: EmbeddingModelCatalog): EmbeddingModelPolicy;
+    isEnforced(): boolean;
+    isAllowed(input: EmbeddingModelRequest): boolean;
+    assertAllowed(input: EmbeddingModelRequest): void;
+    /**
+     * 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: EmbeddingEndpointRequest): EmbeddingEndpoint;
+}
+export declare function createEmbeddingModelPolicy(input: EmbeddingModelPolicyInput): EmbeddingModelPolicy;
+/** True for every deployment rejection, so callers never retry a policy decision. */
+export declare function isEmbeddingPolicyRejection(error: unknown): boolean;
+export declare function isEmbeddingModelNotAllowedError(error: unknown): boolean;
+/**
+ * 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.
+ */
+export declare function parseEmbeddingModelRef(ref: string): EmbeddingModelRequest | undefined;