@undefineds.co/xpod 0.4.11 → 0.4.13

package/node_modules/@undefineds.co/ai-connections-core/dist/credential-storage.js

@@ -0,0 +1,131 @@
+import { aiProviderResource } from '@undefineds.co/models';
+import { AI_CONNECTIONS_PROVIDERS } from './client/types.js';
+/**
+ * Storage-shape rules for AI credential rows: the secret envelope, the provider
+ * relation a credential declares, and the provider resource key.
+ *
+ * They live in the capability package, not in the Pod adapter that happens to
+ * use them: `@undefineds.co/ai-connections` owns what a credential row looks
+ * like, and `ui/src/extensions/XpodAiConnectionsPodStore.ts` is one adapter over
+ * it. Keeping one copy is what lets the collection layer write the same rows the
+ * adapter reads - a second copy would drift on the first format change.
+ */
+/** Base64 of the UTF-8 JSON, so the envelope stays a single string literal. */
+function encodeBase64Json(value) {
+    const bytes = new TextEncoder().encode(JSON.stringify(value));
+    let binary = '';
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function decodeBase64Json(value) {
+    const binary = atob(value);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    return JSON.parse(new TextDecoder().decode(bytes));
+}
+/**
+ * The `encryptedSecret` payload for a credential row.
+ *
+ * `PLAINTEXT` means "not encrypted at rest yet", not "no envelope": the read
+ * side verifies the envelope's owner (`webId`), provider and credential IRI
+ * before handing the secret to a provider request, so a row copied between
+ * credentials (or between accounts) never yields a usable secret.
+ */
+export function credentialSecretEnvelope(input) {
+    return JSON.stringify({
+        algorithm: 'PLAINTEXT',
+        encoding: 'base64',
+        ciphertext: encodeBase64Json(input.secret),
+        webId: input.webId,
+        credentialIri: input.credentialIri,
+        provider: input.provider,
+    });
+}
+/** `undefined` unless the envelope belongs to this account, provider and credential. */
+export function decodeCredentialSecret(input) {
+    if (typeof input.envelope !== 'string' || !input.envelope.trim())
+        return undefined;
+    try {
+        const envelope = JSON.parse(input.envelope);
+        if (envelope.algorithm !== 'PLAINTEXT'
+            || envelope.webId !== input.webId
+            || envelope.provider !== input.provider
+            || envelope.credentialIri !== input.credentialIri) {
+            return undefined;
+        }
+        const secret = envelope.encoding === 'base64'
+            ? decodeBase64Json(String(envelope.ciphertext))
+            : JSON.parse(String(envelope.ciphertext));
+        return typeof secret === 'object' && secret !== null && !Array.isArray(secret)
+            ? secret
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The provider relation a catalog credential declares (`provider`):
+ * `providers/openai.ttl` in resource terms, `openai.ttl` as the stored value.
+ *
+ * A custom instance owns its own provider document, so there the relation is
+ * derived from the credential's own id.
+ */
+export function credentialProviderRelation(provider) {
+    return aiProviderResource.buildId({ id: provider });
+}
+export function customCredentialProviderRelation(credentialId) {
+    return aiProviderResource.buildId({ id: `custom-instance-${encodeURIComponent(credentialId)}.ttl#this` });
+}
+/**
+ * The row key of a new credential: the `{id}` slot of the descriptor's
+ * `resourceIdPattern`, which is the credential's identity (never a display
+ * name).
+ *
+ * Two writers create credential rows - `XpodAiConnectionsPodStore` for a plain
+ * page, and the collection layer when a live collection creates the row
+ * optimistically - and a row key that differed between them would produce two
+ * credentials where the user asked for one, so the shape is declared once here.
+ */
+export function credentialRowKeyFor(provider, authMode) {
+    const suffix = crypto.randomUUID();
+    return authMode === 'local' ? `${provider}-local-${suffix}` : `${provider}-${suffix}`;
+}
+/**
+ * The provider a credential row key declares, for rows whose `provider` relation
+ * is missing: a credential is keyed `<provider>-<uuid>` (see
+ * {@link credentialRowKeyFor}), and a custom instance is keyed `custom-…`.
+ *
+ * A key reaches us in either of two shapes - the bare `resourceIdPattern` slot
+ * (`openai-<uuid>`) or a full resource id (`custom-instance-abc.ttl#this`). The
+ * provider lives in the document segment in both, never in the fragment, so the
+ * fragment must not be the part that gets inspected.
+ */
+export function providerOfCredentialKey(key) {
+    const document = (key.split('#', 1)[0] ?? key).split('/').filter(Boolean).at(-1) ?? '';
+    const name = document.endsWith('.ttl') ? document.slice(0, -'.ttl'.length) : document;
+    if (!name)
+        return undefined;
+    if (name.startsWith('custom-') || name === 'custom')
+        return 'custom';
+    return AI_CONNECTIONS_PROVIDERS.find((provider) => name === provider || name.startsWith(`${provider}-`));
+}
+/** `providers/openai.ttl#this` → `openai.ttl#this` (document-relative reference). */
+export function providerResourceReference(value) {
+    if (!value)
+        return undefined;
+    const withoutFragment = value.split('#', 1)[0] ?? value;
+    const fileName = withoutFragment.split('/').filter(Boolean).at(-1) ?? withoutFragment;
+    if (!fileName)
+        return undefined;
+    const document = fileName.endsWith('.ttl') ? fileName : `${fileName}.ttl`;
+    const fragmentIndex = value.indexOf('#');
+    return fragmentIndex < 0 ? document : `${document}${value.slice(fragmentIndex)}`;
+}
+/** `providers/openai.ttl#this` → `openai` (the document name minus `.ttl`). */
+export function providerResourceKey(value) {
+    const reference = providerResourceReference(value);
+    if (!reference)
+        return undefined;
+    return (reference.split('#', 1)[0] ?? reference).replace(/\.ttl$/u, '');
+}

package/node_modules/@undefineds.co/ai-connections-core/dist/endpoint-urls.d.ts

@@ -0,0 +1,15 @@
+/**
+ * The endpoint shape rules every consumer shares: the coding-client adapters
+ * (`client-config/base-adapter.ts`) and the UI both point clients at the same
+ * Xpod base URL, so the `/v1` rule lives here once and nowhere else.
+ *
+ * This module must stay dependency-free: it is bundled into the Web applet and
+ * imported by the Node-side configuration service.
+ */
+/** OpenAI-compatible base: the client appends `/chat/completions` or `/responses` itself. */
+export declare function normalizeV1Endpoint(endpoint: string): string;
+/**
+ * Anthropic base: `ANTHROPIC_BASE_URL` is the host; the client appends
+ * `/v1/messages`, so a trailing `/v1` has to come off rather than stay on.
+ */
+export declare function normalizeMessagesEndpoint(endpoint: string): string;

package/node_modules/@undefineds.co/ai-connections-core/dist/endpoint-urls.js

@@ -0,0 +1,20 @@
+/**
+ * The endpoint shape rules every consumer shares: the coding-client adapters
+ * (`client-config/base-adapter.ts`) and the UI both point clients at the same
+ * Xpod base URL, so the `/v1` rule lives here once and nowhere else.
+ *
+ * This module must stay dependency-free: it is bundled into the Web applet and
+ * imported by the Node-side configuration service.
+ */
+/** OpenAI-compatible base: the client appends `/chat/completions` or `/responses` itself. */
+export function normalizeV1Endpoint(endpoint) {
+    const normalized = endpoint.trim().replace(/\/+$/, '');
+    return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`;
+}
+/**
+ * Anthropic base: `ANTHROPIC_BASE_URL` is the host; the client appends
+ * `/v1/messages`, so a trailing `/v1` has to come off rather than stay on.
+ */
+export function normalizeMessagesEndpoint(endpoint) {
+    return endpoint.trim().replace(/\/+$/, '').replace(/\/v1$/, '');
+}

package/node_modules/@undefineds.co/ai-connections-core/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Root entry of the shared core.
+ *
+ * The client protocol is what most consumers want, and it is the same surface
+ * `@undefineds.co/ai-connections-core/client` publishes. The catalog and the
+ * client-configuration adapters stay on their own subpaths because they are
+ * larger and only some consumers need them.
+ */
+export * from './ai-connections-client';

package/node_modules/@undefineds.co/ai-connections-core/dist/index.js

@@ -0,0 +1,9 @@
+/**
+ * Root entry of the shared core.
+ *
+ * The client protocol is what most consumers want, and it is the same surface
+ * `@undefineds.co/ai-connections-core/client` publishes. The catalog and the
+ * client-configuration adapters stay on their own subpaths because they are
+ * larger and only some consumers need them.
+ */
+export * from './ai-connections-client.js';

package/node_modules/@undefineds.co/{ai-connections → ai-connections-core}/dist/provider-catalog.cjs

@@ -39,19 +39,49 @@ var __export = (target, all) => {
 // src/provider-catalog.ts
 var exports_provider_catalog = {};
 __export(exports_provider_catalog, {
+  storedOfferingIdFor: () => storedOfferingIdFor,
   providerOfferings: () => providerOfferings,
-  providerName: () => providerName,
   offeringBaseUrl: () => offeringBaseUrl,
   defaultOfferingFor: () => defaultOfferingFor,
   customCompatibilityValue: () => customCompatibilityValue,
+  credentialOfferingMetadata: () => credentialOfferingMetadata,
   PROVIDER_OFFERINGS: () => PROVIDER_OFFERINGS,
   DEFAULT_PROVIDER_OFFERINGS: () => DEFAULT_PROVIDER_OFFERINGS,
-  CUSTOM_DEFAULT_OFFERINGS: () => CUSTOM_DEFAULT_OFFERINGS
+  CUSTOM_DEFAULT_OFFERINGS: () => CUSTOM_DEFAULT_OFFERINGS,
+  BROWSER_LOGIN_METHOD: () => BROWSER_LOGIN_METHOD,
+  API_KEY_METHOD: () => API_KEY_METHOD,
+  AI_CONNECTIONS_PROVIDER_DOCUMENT_IDS: () => AI_CONNECTIONS_PROVIDER_DOCUMENT_IDS
 });
 module.exports = __toCommonJS(exports_provider_catalog);
+
+// src/client/types.ts
+var AI_CONNECTIONS_PROVIDERS = [
+  "openai",
+  "anthropic",
+  "kimi",
+  "bailian",
+  "deepseek",
+  "zhipu",
+  "ollama",
+  "custom"
+];
+
+// src/provider-catalog.ts
 var DEFAULT_PROVIDER_OFFERINGS = [
   { id: "api-platform", label: "API Platform", kind: "api-platform", lifecycle: "active", authModes: ["apiKey"] }
 ];
+var API_KEY_METHOD = {
+  id: "api-key",
+  authMode: "apiKey",
+  lifecycle: "active"
+};
+var BROWSER_LOGIN_METHOD = {
+  id: "browser-login",
+  authMode: "apiKey",
+  connectMode: "browserAssistedApiKey",
+  lifecycle: "active"
+};
+var API_KEY_METHODS = [API_KEY_METHOD, BROWSER_LOGIN_METHOD];
 var CUSTOM_DEFAULT_OFFERINGS = [
   {
     id: "openai-compatible",
@@ -119,6 +149,7 @@ var PROVIDER_OFFERINGS = {
       kind: "api-platform",
       lifecycle: "active",
       authModes: ["apiKey"],
+      authorizationMethods: API_KEY_METHODS,
       productLabel: "OpenAI",
       runtimeProviderIds: ["openai"],
       credentialPrefixHints: ["sk-"],
@@ -158,6 +189,7 @@ var PROVIDER_OFFERINGS = {
       kind: "api-platform",
       lifecycle: "active",
       authModes: ["apiKey"],
+      authorizationMethods: API_KEY_METHODS,
       productLabel: "Anthropic",
       runtimeProviderIds: ["anthropic"],
       credentialPrefixHints: ["sk-ant-"],
@@ -255,6 +287,7 @@ var PROVIDER_OFFERINGS = {
       kind: "api-platform",
       lifecycle: "active",
       authModes: ["apiKey"],
+      authorizationMethods: API_KEY_METHODS,
       productLabel: "智谱 AI",
       runtimeProviderIds: ["zhipu"],
       credentialPrefixHints: ["id."],
@@ -272,6 +305,7 @@ var PROVIDER_OFFERINGS = {
       kind: "token-plan",
       lifecycle: "active",
       authModes: ["apiKey"],
+      authorizationMethods: API_KEY_METHODS,
       productLabel: "智谱 AI",
       runtimeProviderIds: ["zhipu"],
       credentialPrefixHints: ["id."],
@@ -292,6 +326,7 @@ function kimiOffering(input) {
     kind: input.kind,
     lifecycle: "active",
     authModes: input.authModes,
+    authorizationMethods: API_KEY_METHODS,
     productLabel: input.productLabel,
     runtimeProviderIds: input.runtimeProviderIds,
     credentialPrefixHints: input.credentialPrefixHints,
@@ -312,6 +347,7 @@ function bailianOffering(input) {
     productLabel: "Alibaba Bailian",
     kind: input.kind,
     authModes: ["apiKey"],
+    authorizationMethods: API_KEY_METHODS,
     runtimeProviderIds: input.runtimeProviderIds,
     credentialPrefixHints: input.credentialPrefixHints,
     consoleUrl: input.consoleUrl,
@@ -342,39 +378,28 @@ function providerOfferings(provider, openAiSubscriptionImportAvailable = false)
         lifecycle: "active",
         authModes: Array.from(new Set([...offering.authModes ?? [], "local"])),
         authorizationMethods: [
-          { id: "device-code", authMode: "deviceCode", connectMode: "deviceCodeOAuth", label: "设备码登录", lifecycle: "active" },
-          { id: "local-session-import", authMode: "local", label: "已有登录态", lifecycle: "active" }
+          { id: "device-code", authMode: "deviceCode", connectMode: "deviceCodeOAuth", lifecycle: "active" },
+          { id: "local-session-import", authMode: "local", lifecycle: "active" }
         ]
       };
     }
     return { ...offering };
   });
 }
+var AI_CONNECTIONS_PROVIDER_DOCUMENT_IDS = AI_CONNECTIONS_PROVIDERS.flatMap((provider) => [
+  provider,
+  ...builtinOfferings(provider).map((offering) => `${provider}-${offering.id}`)
+]);
+function builtinOfferings(provider) {
+  if (provider === "custom")
+    return CUSTOM_DEFAULT_OFFERINGS;
+  return PROVIDER_OFFERINGS[provider] ?? DEFAULT_PROVIDER_OFFERINGS;
+}
 function customCompatibilityValue(value, offeringId) {
   if (value === "anthropic" || offeringId === "anthropic-compatible")
     return "anthropic";
   return "openai";
 }
-function providerName(provider) {
-  switch (provider) {
-    case "openai":
-      return "OpenAI";
-    case "anthropic":
-      return "Anthropic";
-    case "kimi":
-      return "Kimi";
-    case "bailian":
-      return "百炼";
-    case "deepseek":
-      return "DeepSeek";
-    case "zhipu":
-      return "智谱 AI";
-    case "ollama":
-      return "Ollama";
-    case "custom":
-      return "Custom";
-  }
-}
 function defaultOfferingFor(provider, authMode) {
   if (provider === "openai" && (authMode === "local" || authMode === "oauth" || authMode === "deviceCode")) {
     return "official-subscription";
@@ -397,3 +422,22 @@ function offeringBaseUrl(provider, offeringId) {
   const discoveryProtocol = offering.modelDiscovery?.endpointProtocol;
   return offering.endpoints?.find((endpoint) => endpoint.protocol === discoveryProtocol)?.baseUrl ?? offering.endpoints?.[0]?.baseUrl;
 }
+function storedOfferingIdFor(provider, offeringId) {
+  const normalized = offeringId.trim().toLowerCase();
+  if (provider === "bailian") {
+    if (normalized === "token-plan-personal")
+      return "token-plan";
+    if (normalized === "coding-plan-pro")
+      return "coding-plan";
+  }
+  return normalized;
+}
+function credentialOfferingMetadata(input) {
+  return {
+    offeringId: input.offeringId,
+    priority: input.priority ?? 100,
+    enabled: input.enabled ?? true,
+    health: input.health ?? "unknown",
+    ...input.baseUrl ? { baseUrl: input.baseUrl } : {}
+  };
+}

package/node_modules/@undefineds.co/ai-connections-core/dist/provider-catalog.d.ts

@@ -0,0 +1,84 @@
+import type { AiConnectionsProvider, AiProviderAuthorizationMethod, AiProviderCredentialSummary, AiProviderOffering } from './ai-connections-client';
+export declare const DEFAULT_PROVIDER_OFFERINGS: AiProviderOffering[];
+/**
+ * How an offering accepts a key: typed into Xpod's own form (this entry) or
+ * minted in the provider's console (the browser-assisted entry below). An
+ * offering that declares its actions declares this one too - the catalog names
+ * the action by id and the server only decides whether the entry is usable in a
+ * given deployment. The wording a user reads is the applet's
+ * (`display-wording.ts`), so the same action cannot be named three ways.
+ */
+export declare const API_KEY_METHOD: AiProviderAuthorizationMethod;
+/**
+ * The connect entry that opens the provider's own console so the user signs in
+ * there and mints a key. Which ways in exist is offering data, so the entry is
+ * declared on the offerings that accept a key (`authModes` keeps the mechanical
+ * truth, `apiKey`) instead of on a provider-level label, and it points at the
+ * `consoleUrl` the offering already carries.
+ *
+ * Providers without one say something real by not declaring it: DeepSeek has no
+ * account console to sign into, Ollama is a local service, and `custom` is
+ * configured inside Xpod rather than at a provider.
+ *
+ * The id names the action the way its siblings do (browser-login / device-code /
+ * local-session-import); the wording follows from the id in the applet, and the
+ * legacy 「登录」 was retired because it named the provider rather than the
+ * action - which is what let a provider-level string claim a capability no
+ * offering declared.
+ */
+export declare const BROWSER_LOGIN_METHOD: AiProviderAuthorizationMethod;
+export declare const CUSTOM_DEFAULT_OFFERINGS: AiProviderOffering[];
+export declare const PROVIDER_OFFERINGS: Partial<Record<AiConnectionsProvider, AiProviderOffering[]>>;
+export declare function providerOfferings(provider: AiConnectionsProvider, openAiSubscriptionImportAvailable?: boolean): AiProviderOffering[];
+/**
+ * Provider documents the AI Connection service is granted access to: the
+ * provider container document plus one document per built-in offering, named
+ * `<provider>-<offeringId>` by the Pod layout.
+ *
+ * This is the single program-side authority for that list. The Gateway's
+ * service-access descriptor and this package's descriptor validator both read
+ * it, so the granted surface and the validator cannot drift from the catalogue
+ * or from each other. Adding an offering to the catalogue adds its document
+ * here, which is exactly the program capability the service is allowed to
+ * reach.
+ */
+export declare const AI_CONNECTIONS_PROVIDER_DOCUMENT_IDS: readonly string[];
+export declare function customCompatibilityValue(value: unknown, offeringId?: string): 'openai' | 'anthropic';
+export declare function defaultOfferingFor(provider: AiConnectionsProvider, authMode: AiProviderCredentialSummary['authMode']): string;
+export declare function offeringBaseUrl(provider: AiConnectionsProvider, offeringId?: string): string | undefined;
+/**
+ * The offering id a credential records.
+ *
+ * An offering id is catalog content, so this stores the catalog's own id
+ * (`token-plan`, `coding-plan`, `pay-as-you-go`, …) lower-cased. The bootstrap
+ * naming turned two Bailian ids into document-name variants; those are folded
+ * back so the attribute never carries a storage-layout artefact.
+ *
+ * It lives in the capability package rather than in the Pod adapter that first
+ * needed it: the adapter, the collection runtime and the read emulation in tests
+ * all have to agree on this column, and a second copy would drift on the first
+ * catalog change (AGENTS.md: 目录内容跟能力走, 不得保留第二份副本).
+ */
+export declare function storedOfferingIdFor(provider: AiConnectionsProvider, offeringId: string): string;
+/**
+ * The offering-derived part of a credential row's `metadata`.
+ *
+ * MIGRATION WINDOW: the offering is written both as the credential's
+ * `udfs:offeringId` attribute and inside the `metadata` JSON.
+ * `@undefineds.co/models` releases before the one that declares `offeringId`
+ * persist neither (drizzle-solid drops values whose key is not a declared
+ * column), so a bundle built against such a release would lose it. Drop the
+ * `metadata` copy once every consumer is built against the declaring release and
+ * no reader needs the fallback in `credentialOfferingIdFromRow`.
+ *
+ * Shared for the same reason as {@link storedOfferingIdFor}: a credential's row
+ * has exactly one shape, and the collection would read its own confirmation as a
+ * change if the writer and the projection disagreed on it.
+ */
+export declare function credentialOfferingMetadata(input: {
+    offeringId: string;
+    baseUrl?: string;
+    priority?: number;
+    enabled?: boolean;
+    health?: string;
+}): Record<string, unknown>;

package/node_modules/@undefineds.co/{ai-connections → ai-connections-core}/dist/provider-catalog.js

@@ -1,9 +1,48 @@
+import { AI_CONNECTIONS_PROVIDERS } from './client/types.js';
 // Built-in provider and offering catalog. This is the single place that names a
 // provider or an offering; display layers project from it instead of keeping a
 // second copy, which is how the same offering used to appear under two names.
 export const DEFAULT_PROVIDER_OFFERINGS = [
     { id: 'api-platform', label: 'API Platform', kind: 'api-platform', lifecycle: 'active', authModes: ['apiKey'] },
 ];
+/**
+ * How an offering accepts a key: typed into Xpod's own form (this entry) or
+ * minted in the provider's console (the browser-assisted entry below). An
+ * offering that declares its actions declares this one too - the catalog names
+ * the action by id and the server only decides whether the entry is usable in a
+ * given deployment. The wording a user reads is the applet's
+ * (`display-wording.ts`), so the same action cannot be named three ways.
+ */
+export const API_KEY_METHOD = {
+    id: 'api-key',
+    authMode: 'apiKey',
+    lifecycle: 'active',
+};
+/**
+ * The connect entry that opens the provider's own console so the user signs in
+ * there and mints a key. Which ways in exist is offering data, so the entry is
+ * declared on the offerings that accept a key (`authModes` keeps the mechanical
+ * truth, `apiKey`) instead of on a provider-level label, and it points at the
+ * `consoleUrl` the offering already carries.
+ *
+ * Providers without one say something real by not declaring it: DeepSeek has no
+ * account console to sign into, Ollama is a local service, and `custom` is
+ * configured inside Xpod rather than at a provider.
+ *
+ * The id names the action the way its siblings do (browser-login / device-code /
+ * local-session-import); the wording follows from the id in the applet, and the
+ * legacy 「登录」 was retired because it named the provider rather than the
+ * action - which is what let a provider-level string claim a capability no
+ * offering declared.
+ */
+export const BROWSER_LOGIN_METHOD = {
+    id: 'browser-login',
+    authMode: 'apiKey',
+    connectMode: 'browserAssistedApiKey',
+    lifecycle: 'active',
+};
+/** Both ways a key arrives, for an offering whose provider has a console. */
+const API_KEY_METHODS = [API_KEY_METHOD, BROWSER_LOGIN_METHOD];
 export const CUSTOM_DEFAULT_OFFERINGS = [
     {
         id: 'openai-compatible',
@@ -79,6 +118,7 @@ export const PROVIDER_OFFERINGS = {
             kind: 'api-platform',
             lifecycle: 'active',
             authModes: ['apiKey'],
+            authorizationMethods: API_KEY_METHODS,
             productLabel: 'OpenAI',
             runtimeProviderIds: ['openai'],
             credentialPrefixHints: ['sk-'],
@@ -118,6 +158,7 @@ export const PROVIDER_OFFERINGS = {
             kind: 'api-platform',
             lifecycle: 'active',
             authModes: ['apiKey'],
+            authorizationMethods: API_KEY_METHODS,
             productLabel: 'Anthropic',
             runtimeProviderIds: ['anthropic'],
             credentialPrefixHints: ['sk-ant-'],
@@ -217,6 +258,7 @@ export const PROVIDER_OFFERINGS = {
             kind: 'api-platform',
             lifecycle: 'active',
             authModes: ['apiKey'],
+            authorizationMethods: API_KEY_METHODS,
             productLabel: '智谱 AI',
             runtimeProviderIds: ['zhipu'],
             credentialPrefixHints: ['id.'],
@@ -234,6 +276,7 @@ export const PROVIDER_OFFERINGS = {
             kind: 'token-plan',
             lifecycle: 'active',
             authModes: ['apiKey'],
+            authorizationMethods: API_KEY_METHODS,
             productLabel: '智谱 AI',
             runtimeProviderIds: ['zhipu'],
             credentialPrefixHints: ['id.'],
@@ -254,6 +297,7 @@ function kimiOffering(input) {
         kind: input.kind,
         lifecycle: 'active',
         authModes: input.authModes,
+        authorizationMethods: API_KEY_METHODS,
         productLabel: input.productLabel,
         runtimeProviderIds: input.runtimeProviderIds,
         credentialPrefixHints: input.credentialPrefixHints,
@@ -274,6 +318,7 @@ function bailianOffering(input) {
         productLabel: 'Alibaba Bailian',
         kind: input.kind,
         authModes: ['apiKey'],
+        authorizationMethods: API_KEY_METHODS,
         runtimeProviderIds: input.runtimeProviderIds,
         credentialPrefixHints: input.credentialPrefixHints,
         consoleUrl: input.consoleUrl,
@@ -306,39 +351,46 @@ export function providerOfferings(provider, openAiSubscriptionImportAvailable =
                 lifecycle: 'active',
                 authModes: Array.from(new Set([...(offering.authModes ?? []), 'local'])),
                 authorizationMethods: [
-                    { id: 'device-code', authMode: 'deviceCode', connectMode: 'deviceCodeOAuth', label: '设备码登录', lifecycle: 'active' },
-                    { id: 'local-session-import', authMode: 'local', label: '已有登录态', lifecycle: 'active' },
+                    { id: 'device-code', authMode: 'deviceCode', connectMode: 'deviceCodeOAuth', lifecycle: 'active' },
+                    { id: 'local-session-import', authMode: 'local', lifecycle: 'active' },
                 ],
             };
         }
         return { ...offering };
     });
 }
+/**
+ * Provider documents the AI Connection service is granted access to: the
+ * provider container document plus one document per built-in offering, named
+ * `<provider>-<offeringId>` by the Pod layout.
+ *
+ * This is the single program-side authority for that list. The Gateway's
+ * service-access descriptor and this package's descriptor validator both read
+ * it, so the granted surface and the validator cannot drift from the catalogue
+ * or from each other. Adding an offering to the catalogue adds its document
+ * here, which is exactly the program capability the service is allowed to
+ * reach.
+ */
+export const AI_CONNECTIONS_PROVIDER_DOCUMENT_IDS = AI_CONNECTIONS_PROVIDERS.flatMap((provider) => [
+    provider,
+    ...builtinOfferings(provider).map((offering) => `${provider}-${offering.id}`),
+]);
+/**
+ * Built-in offerings of one provider as the catalogue declares them. `custom`
+ * keeps its placeholder offerings in their own table because its endpoints are
+ * intentionally invalid; every other provider declares its own list above.
+ * This mirrors the Gateway's `ProviderRegistry.offeringsForProduct`.
+ */
+function builtinOfferings(provider) {
+    if (provider === 'custom')
+        return CUSTOM_DEFAULT_OFFERINGS;
+    return PROVIDER_OFFERINGS[provider] ?? DEFAULT_PROVIDER_OFFERINGS;
+}
 export function customCompatibilityValue(value, offeringId) {
     if (value === 'anthropic' || offeringId === 'anthropic-compatible')
         return 'anthropic';
     return 'openai';
 }
-export function providerName(provider) {
-    switch (provider) {
-        case 'openai':
-            return 'OpenAI';
-        case 'anthropic':
-            return 'Anthropic';
-        case 'kimi':
-            return 'Kimi';
-        case 'bailian':
-            return '百炼';
-        case 'deepseek':
-            return 'DeepSeek';
-        case 'zhipu':
-            return '智谱 AI';
-        case 'ollama':
-            return 'Ollama';
-        case 'custom':
-            return 'Custom';
-    }
-}
 export function defaultOfferingFor(provider, authMode) {
     if (provider === 'openai' && (authMode === 'local' || authMode === 'oauth' || authMode === 'deviceCode')) {
         return 'official-subscription';
@@ -362,3 +414,50 @@ export function offeringBaseUrl(provider, offeringId) {
     return offering.endpoints?.find((endpoint) => endpoint.protocol === discoveryProtocol)?.baseUrl
         ?? offering.endpoints?.[0]?.baseUrl;
 }
+/**
+ * The offering id a credential records.
+ *
+ * An offering id is catalog content, so this stores the catalog's own id
+ * (`token-plan`, `coding-plan`, `pay-as-you-go`, …) lower-cased. The bootstrap
+ * naming turned two Bailian ids into document-name variants; those are folded
+ * back so the attribute never carries a storage-layout artefact.
+ *
+ * It lives in the capability package rather than in the Pod adapter that first
+ * needed it: the adapter, the collection runtime and the read emulation in tests
+ * all have to agree on this column, and a second copy would drift on the first
+ * catalog change (AGENTS.md: 目录内容跟能力走, 不得保留第二份副本).
+ */
+export function storedOfferingIdFor(provider, offeringId) {
+    const normalized = offeringId.trim().toLowerCase();
+    if (provider === 'bailian') {
+        if (normalized === 'token-plan-personal')
+            return 'token-plan';
+        if (normalized === 'coding-plan-pro')
+            return 'coding-plan';
+    }
+    return normalized;
+}
+/**
+ * The offering-derived part of a credential row's `metadata`.
+ *
+ * MIGRATION WINDOW: the offering is written both as the credential's
+ * `udfs:offeringId` attribute and inside the `metadata` JSON.
+ * `@undefineds.co/models` releases before the one that declares `offeringId`
+ * persist neither (drizzle-solid drops values whose key is not a declared
+ * column), so a bundle built against such a release would lose it. Drop the
+ * `metadata` copy once every consumer is built against the declaring release and
+ * no reader needs the fallback in `credentialOfferingIdFromRow`.
+ *
+ * Shared for the same reason as {@link storedOfferingIdFor}: a credential's row
+ * has exactly one shape, and the collection would read its own confirmation as a
+ * change if the writer and the projection disagreed on it.
+ */
+export function credentialOfferingMetadata(input) {
+    return {
+        offeringId: input.offeringId,
+        priority: input.priority ?? 100,
+        enabled: input.enabled ?? true,
+        health: input.health ?? 'unknown',
+        ...(input.baseUrl ? { baseUrl: input.baseUrl } : {}),
+    };
+}