@undefineds.co/xpod 0.4.11 → 0.4.13

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

@@ -1,24 +1,42 @@
-import type { WebExtensionHost } from '@undefineds.co/extension-sdk/web';
-import { type AiConnectionsClient, type AiConnectionsMode, type AiConnectionsProvider, type AiProviderConnectionSummary, type AiProviderSummary } from './ai-connections-client';
+import type { SolidLiveUpdateState, WebExtensionHost } from '@undefineds.co/extension-sdk/web';
+import { type AiConnectionsClient, type AiConnectionsProvider, type AiProviderConnectionSummary, type AiProviderSummary } from '@undefineds.co/ai-connections-core/client';
 import type { AiClientConfigurationBridge } from './AiClientConfigurationSection';
+import { type CredentialRow } from './collections';
+import type { PodCollection } from '@undefineds.co/pod-collections';
 export interface AiProviderDefinition {
     id: AiConnectionsProvider;
     name: string;
-    browserMode: AiConnectionsMode;
-    browserLabel: string;
     description: string;
     homeUrl: string;
     apiKeyUrl?: string;
     apiKeyPlaceholder?: string;
     defaultBaseUrl?: string;
 }
+/**
+ * Provider pages explain themselves through the header's ⓘ tooltip, so each
+ * description is one line of the same shape — where the models come from and how
+ * this deployment can be authorized — instead of a restatement of the name.
+ *
+ * Connect actions are deliberately absent here: which ways in exist is offering
+ * data (`authorizationMethods`), derived by the server per offering, and a
+ * provider-level label is exactly how a page could offer a 「登录」 no offering
+ * declares.
+ */
 export declare const PROVIDERS: AiProviderDefinition[];
 export type ProviderProductState = 'loading' | 'unconfigured' | 'configured' | 'connected' | 'attention';
 export declare const AI_CONNECTIONS_PINNED_SECTIONS: readonly [{
     readonly id: "keys";
-    readonly label: "API Keys";
+    readonly label: "Xpod";
     readonly title: "API KEYS";
 }];
+/**
+ * Coalescing window for Pod change signals.
+ *
+ * A notification only says "this document changed", so a burst of writes must
+ * cost one re-read, not one per write; the first signal arms a fixed window and
+ * everything arriving inside it is absorbed.
+ */
+export declare const TABLE_CHANGE_COALESCE_MS = 75;
 export type AiConnectionsPinnedSection = typeof AI_CONNECTIONS_PINNED_SECTIONS[number]['id'];
 export type AiConnectionsWorkspaceSection = AiConnectionsPinnedSection | 'provider';
 export interface AiConnectionsController {
@@ -32,12 +50,47 @@ export interface AiConnectionsController {
     readonly providerStates: Partial<Record<AiConnectionsProvider, ProviderProductState>>;
     readonly providerSummaries: Partial<Record<AiConnectionsProvider, AiProviderSummary>>;
     readonly providerLoadError?: string;
+    /**
+     * Whether the Pod table documents this page renders are pushing changes.
+     *
+     * `unavailable` also covers a host that offers no live-update capability at
+     * all; either way the page keeps working from explicit reads.
+     */
+    readonly liveUpdates: SolidLiveUpdateState;
+    /**
+     * The live credentials table (`settings/credentials.ttl`), when the host
+     * exposes `podCollections` and the lazily loaded collection layer has landed.
+     * The page renders its rows; the controller's own live-revision refresh does
+     * not watch that document while this is present.
+     */
+    readonly credentialsCollection?: PodCollection<CredentialRow>;
+    /**
+     * The collection's rows as its own change feed reports them, or `undefined`
+     * while the layer is still loading, when the host offers no collection, or
+     * after a failed first read. This is what the credentials list renders (and
+     * what makes every credential write optimistic).
+     */
+    readonly credentialRows?: readonly CredentialRow[];
+    /**
+     * Advances once per coalesced burst of changes to those documents. Pages
+     * re-read through the loaders they already have when it changes.
+     */
+    readonly liveRevision: number;
     selectSection(section: AiConnectionsPinnedSection): void;
     selectProvider(provider: AiConnectionsProvider, credentialId?: string): void;
     selectFirstUnconfiguredProvider(): void;
     setSearchQuery(value: string): void;
     setProviderState(provider: AiConnectionsProvider, state: ProviderProductState): void;
     loadProviders(): Promise<void>;
+    /**
+     * Watches the table documents the open page renders: the credentials table
+     * plus the open provider's document.
+     *
+     * Re-entrant and idempotent, so React StrictMode's setup/cleanup/setup cycle
+     * stays harmless; releasing the last hold leaves no channel and no socket
+     * behind for this page.
+     */
+    watchPageTables(): () => void;
     cancelProviderLoads(): void;
     subscribe(listener: () => void): () => void;
 }
@@ -48,5 +101,18 @@ export declare function useSelectedCredentialId(controller: AiConnectionsControl
 export declare function useProviderSearch(controller: AiConnectionsController): string;
 export declare function useProviderStates(controller: AiConnectionsController): Partial<Record<AiConnectionsProvider, ProviderProductState>>;
 export declare function useProviderSummaries(controller: AiConnectionsController): Partial<Record<AiConnectionsProvider, AiProviderConnectionSummary>>;
+/**
+ * Providers this deployment offers, as reported by the server.
+ *
+ * Cloud answers with the operator-designated providers only (no self-hosted
+ * `custom`, no local daemon), so the settings surface cannot offer a provider the
+ * deployment does not provide. Before the first successful load this is
+ * `undefined`, which keeps every provider visible (Local behavior).
+ */
+export declare function useAvailableProviders(controller: AiConnectionsController): AiConnectionsProvider[] | undefined;
 export declare function useProviderProducts(controller: AiConnectionsController): Partial<Record<AiConnectionsProvider, AiProviderSummary>>;
 export declare function useProviderLoadError(controller: AiConnectionsController): string | undefined;
+/** Whether live Pod updates are on, for a status affordance that stays small. */
+export declare function useLiveUpdates(controller: AiConnectionsController): SolidLiveUpdateState;
+/** Advances once per coalesced burst of Pod changes; drives page re-reads. */
+export declare function useLiveRevision(controller: AiConnectionsController): number;

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

@@ -1,18 +1,38 @@
 import { useSyncExternalStore } from 'react';
-import { AI_CONNECTIONS_PROVIDERS, AiConnectionsRequestError, createAiConnectionsClient, normalizeAiConnectionsThrownError, } from './ai-connections-client.js';
+import { AI_CONNECTIONS_PROVIDERS, AiConnectionsRequestError, createAiConnectionsClient, } from '@undefineds.co/ai-connections-core/client';
+import { aiConnectionsErrorMessage } from './error-wording.js';
+import { credentialCollectionRuntime, } from './collections.js';
+/**
+ * Provider pages explain themselves through the header's ⓘ tooltip, so each
+ * description is one line of the same shape — where the models come from and how
+ * this deployment can be authorized — instead of a restatement of the name.
+ *
+ * Connect actions are deliberately absent here: which ways in exist is offering
+ * data (`authorizationMethods`), derived by the server per offering, and a
+ * provider-level label is exactly how a page could offer a 「登录」 no offering
+ * declares.
+ */
 export const PROVIDERS = [
-    { id: 'openai', name: 'OpenAI', browserMode: 'browserAssistedApiKey', browserLabel: '登录', description: 'OpenAI 模型与编码能力', homeUrl: 'https://openai.com', apiKeyUrl: 'https://platform.openai.com/api-keys', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://api.openai.com/v1' },
-    { id: 'anthropic', name: 'Anthropic', browserMode: 'browserAssistedApiKey', browserLabel: '登录', description: 'Claude 模型与编码能力', homeUrl: 'https://www.anthropic.com', apiKeyUrl: 'https://console.anthropic.com/settings/keys', apiKeyPlaceholder: 'sk-ant-...', defaultBaseUrl: 'https://api.anthropic.com' },
-    { id: 'kimi', name: 'Kimi', browserMode: 'browserAssistedApiKey', browserLabel: '登录', description: 'Moonshot AI 模型服务', homeUrl: 'https://www.moonshot.cn', apiKeyUrl: 'https://platform.moonshot.cn/console/api-keys', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://api.moonshot.cn/v1' },
-    { id: 'bailian', name: '百炼', browserMode: 'browserAssistedApiKey', browserLabel: '登录', description: '阿里云百炼模型服务', homeUrl: 'https://www.aliyun.com/product/bailian', apiKeyUrl: 'https://bailian.console.aliyun.com/#/api-key', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1' },
-    { id: 'deepseek', name: 'DeepSeek', browserMode: 'connectUnsupported', browserLabel: '不支持登录', description: 'DeepSeek 模型服务', homeUrl: 'https://www.deepseek.com', apiKeyUrl: 'https://platform.deepseek.com/api_keys', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://api.deepseek.com/v1' },
-    { id: 'zhipu', name: '智谱 AI', browserMode: 'browserAssistedApiKey', browserLabel: '登录', description: '智谱 AI / GLM 模型服务', homeUrl: 'https://open.bigmodel.cn', apiKeyUrl: 'https://open.bigmodel.cn/usercenter/apikeys', apiKeyPlaceholder: 'id.secret-...', defaultBaseUrl: 'https://open.bigmodel.cn/api/paas/v4' },
-    { id: 'ollama', name: 'Ollama', browserMode: 'connectUnsupported', browserLabel: '本地服务', description: '本地 Ollama 模型服务', homeUrl: 'https://ollama.com', defaultBaseUrl: 'http://localhost:11434/v1' },
-    { id: 'custom', name: 'Custom', browserMode: 'browserAssistedApiKey', browserLabel: '配置', description: 'OpenAI / Anthropic 兼容的自定义模型服务', homeUrl: 'https://undefineds.co', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://example.com/v1' },
+    { id: 'openai', name: 'OpenAI', description: 'OpenAI 官方 GPT 与推理模型，支持 API Key 与订阅导入。', homeUrl: 'https://openai.com', apiKeyUrl: 'https://platform.openai.com/api-keys', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://api.openai.com/v1' },
+    { id: 'anthropic', name: 'Anthropic', description: 'Anthropic 官方 Claude 模型，支持 API Key 与订阅导入。', homeUrl: 'https://www.anthropic.com', apiKeyUrl: 'https://console.anthropic.com/settings/keys', apiKeyPlaceholder: 'sk-ant-...', defaultBaseUrl: 'https://api.anthropic.com' },
+    { id: 'kimi', name: 'Kimi', description: '月之暗面 Kimi 模型，支持账号订阅、编码套餐与开放平台。', homeUrl: 'https://www.moonshot.cn', apiKeyUrl: 'https://platform.moonshot.cn/console/api-keys', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://api.moonshot.cn/v1' },
+    { id: 'bailian', name: '百炼', description: '阿里云百炼的通义千问等模型，提供按量与多种套餐。', homeUrl: 'https://www.aliyun.com/product/bailian', apiKeyUrl: 'https://bailian.console.aliyun.com/#/api-key', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://dashscope.aliyuncs.com/compatible-mode/v1' },
+    { id: 'deepseek', name: 'DeepSeek', description: 'DeepSeek 官方模型，API Key 接入，接口兼容 OpenAI。', homeUrl: 'https://www.deepseek.com', apiKeyUrl: 'https://platform.deepseek.com/api_keys', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://api.deepseek.com/v1' },
+    { id: 'zhipu', name: '智谱 AI', description: '智谱 GLM 系列模型，支持 API Key 与 GLM 编码套餐。', homeUrl: 'https://open.bigmodel.cn', apiKeyUrl: 'https://open.bigmodel.cn/usercenter/apikeys', apiKeyPlaceholder: 'id.secret-...', defaultBaseUrl: 'https://open.bigmodel.cn/api/paas/v4' },
+    { id: 'ollama', name: 'Ollama', description: '运行在本机的 Ollama 模型，无需 API Key，仅本机可达。', homeUrl: 'https://ollama.com', defaultBaseUrl: 'http://localhost:11434/v1' },
+    { id: 'custom', name: 'Custom', description: '任意 OpenAI 或 Anthropic 兼容服务，自填地址与 API Key。', homeUrl: 'https://undefineds.co', apiKeyPlaceholder: 'sk-...', defaultBaseUrl: 'https://example.com/v1' },
 ];
 export const AI_CONNECTIONS_PINNED_SECTIONS = [
-    { id: 'keys', label: 'API Keys', title: 'API KEYS' },
+    { id: 'keys', label: 'Xpod', title: 'API KEYS' },
 ];
+/**
+ * Coalescing window for Pod change signals.
+ *
+ * A notification only says "this document changed", so a burst of writes must
+ * cost one re-read, not one per write; the first signal arms a fixed window and
+ * everything arriving inside it is absorbed.
+ */
+export const TABLE_CHANGE_COALESCE_MS = 75;
 if (PROVIDERS.map((provider) => provider.id).join(',') !== AI_CONNECTIONS_PROVIDERS.join(',')) {
     throw new Error('AI Connection provider UI is out of sync with the client catalog');
 }
@@ -24,6 +44,28 @@ export function createAiConnectionsController(host) {
     const readyPod = pod?.status === 'ready' ? pod : undefined;
     const authenticated = sessionSnapshot.status === 'authenticated'
         && readyPod !== undefined;
+    /**
+     * The live credentials table, when the host offers one.
+     *
+     * Declaring it here (and not in a page) is what keeps one table to one
+     * collection: the page reads the same instance the client writes through.
+     *
+     * It is declared *asynchronously* and lands in `credentials` (+ `credentialRows`
+     * and `credentialMutations`): the collection layer is loaded on demand through
+     * `collections.credentialCollectionRuntime()` - the table declaration, the row
+     * read and the credential writes all live in that chunk - so the applet renders
+     * from the store first and upgrades to live rows when the collection's first
+     * read is back. When the host offers no `podCollections` capability at all the
+     * collection never lands and the controller behaves exactly as before
+     * (`docs/pod-collections.md` §8.9).
+     */
+    let credentials;
+    let credentialRows;
+    let credentialMutations;
+    const liveCredentials = {
+        collection: () => credentials,
+        mutations: () => credentialMutations,
+    };
     let providerLoadGeneration = 0;
     let providerLoadPromise;
     let providerLoadOperation;
@@ -81,7 +123,7 @@ export function createAiConnectionsController(host) {
             webId: sessionSnapshot.webId,
             podBaseUrl: readyPod.current.podUrl,
             authenticatedFetch: host.solid.session.fetch,
-        }), host.capabilities.aiClientCredentials), host.capabilities.aiConnectionsPodStore, beginProviderLoad)
+        }), host.capabilities.aiClientCredentials), host.capabilities.aiConnectionsPodStore, liveCredentials, beginProviderLoad)
         : null;
     let selectedSection = 'keys';
     let selectedProvider = 'openai';
@@ -92,10 +134,164 @@ export function createAiConnectionsController(host) {
     let providerLoadError;
     const listeners = new Set();
     const notify = () => listeners.forEach((listener) => listener());
+    const notifications = host.capabilities.solidNotifications;
+    const podStore = host.capabilities.aiConnectionsPodStore;
+    /** Release function per watched topic document; one entry per document. */
+    const tableSubscriptions = new Map();
+    let pageTableHolds = 0;
+    let liveUpdates = currentLiveUpdates();
+    let liveRevision = 0;
+    let coalesceTimer;
+    function scheduleLiveRefresh() {
+        if (coalesceTimer !== undefined)
+            return;
+        coalesceTimer = setTimeout(() => {
+            coalesceTimer = undefined;
+            liveRevision += 1;
+            notify();
+        }, TABLE_CHANGE_COALESCE_MS);
+    }
+    /**
+     * The documents the open page renders *and* this controller refreshes; a table
+     * is one document, never a row.
+     *
+     * One table has exactly one refresh path. The credentials table is owned by
+     * the collection when the host exposes one - the collection subscribes to the
+     * same notification primitive with the same document - so it is left out here;
+     * without a collection it stays on this path, exactly as before. The open
+     * provider's document is always this path's (P4 moves it).
+     */
+    function pageTableDocuments() {
+        if (!podStore)
+            return [];
+        const documents = new Set();
+        const credentialsDocument = credentials ? undefined : podStore.credentialsTableDocument?.();
+        if (credentialsDocument)
+            documents.add(credentialsDocument);
+        if (selectedSection === 'provider') {
+            const provider = podStore.providerTableDocument?.(selectedProvider, selectedCredentialId);
+            if (provider)
+                documents.add(provider);
+        }
+        return [...documents];
+    }
+    function releaseTableSubscriptions() {
+        for (const [document, release] of tableSubscriptions) {
+            tableSubscriptions.delete(document);
+            release();
+        }
+    }
+    function syncTableSubscriptions() {
+        if (!notifications || pageTableHolds === 0)
+            return;
+        const wanted = new Set(pageTableDocuments());
+        for (const [document, release] of tableSubscriptions) {
+            if (wanted.has(document))
+                continue;
+            tableSubscriptions.delete(document);
+            release();
+        }
+        for (const document of wanted) {
+            if (tableSubscriptions.has(document))
+                continue;
+            tableSubscriptions.set(document, notifications.watch(document, scheduleLiveRefresh));
+        }
+    }
+    /**
+     * The availability signal the page shows.
+     *
+     * With a live collection the page's truth is the *collection's* sync state,
+     * not the transport's global state: `live` only when the table's own feed is
+     * established and the transport is actually pushing. Without one, this is the
+     * transport's state, exactly as before.
+     */
+    function currentLiveUpdates() {
+        const transport = notifications ? notifications.getState() : 'unavailable';
+        if (!credentials || !host.capabilities.podCollections)
+            return transport;
+        const sync = host.capabilities.podCollections.syncState(credentials.collection);
+        if (sync === 'unavailable' || sync === 'degraded' || transport === 'unavailable') {
+            return 'unavailable';
+        }
+        return sync === 'live' && transport === 'live' ? 'live' : 'idle';
+    }
+    notifications?.subscribeState(() => {
+        const next = currentLiveUpdates();
+        if (next === liveUpdates)
+            return;
+        liveUpdates = next;
+        notify();
+    });
+    host.capabilities.podCollections?.subscribeSyncState(() => {
+        const next = currentLiveUpdates();
+        if (next === liveUpdates)
+            return;
+        liveUpdates = next;
+        notify();
+    });
+    /**
+     * The page's live rows: re-read from the collection when it changes, and
+     * `undefined` until its first read lands (or forever, when there is no
+     * collection). One snapshot object per change keeps `useSyncExternalStore`
+     * stable between reads.
+     */
+    function publishCredentialRows() {
+        const collection = credentials?.collection;
+        const next = collection?.isReady()
+            ? collection.toArray
+            : undefined;
+        if (next === credentialRows)
+            return;
+        credentialRows = next;
+        notify();
+    }
+    /**
+     * Adopt the host's credentials collection once the lazy layer has it.
+     *
+     * Three things change at once, and they have to change together: the rows the
+     * page renders (from the collection's own change feed and status), the
+     * credential mutations (the client dispatches to them from now on), and the
+     * fallback table watch - the credentials document leaves the controller's
+     * `liveRevision` path because the collection now owns that table, which has to
+     * happen by releasing the subscription the controller opened before the
+     * collection arrived.
+     */
+    function adoptCredentials(loaded, mutations) {
+        credentials = loaded;
+        credentialMutations = mutations;
+        const collection = loaded.collection;
+        // The collection is owned by the host capability and lives as long as the
+        // session; these two subscriptions live with it rather than with the page.
+        collection.subscribeChanges(() => publishCredentialRows());
+        collection.on('status:change', () => publishCredentialRows());
+        publishCredentialRows();
+        syncTableSubscriptions();
+        notify();
+    }
+    // A host that offers no collection never fetches the layer: the capability is
+    // checked before the dynamic import, not inside it.
+    if (authenticated && sessionSnapshot.webId && host.capabilities.podCollections) {
+        void credentialCollectionRuntime()
+            .then(async (runtime) => {
+            const loaded = await runtime.openCredentialCollection(host);
+            if (!loaded || !podStore)
+                return;
+            adoptCredentials(loaded, runtime.collectionCredentialMutations(loaded, podStore));
+        })
+            // No collection layer (chunk unavailable, layout underivable, table
+            // undefined): the page keeps the store's own reads, as before.
+            .catch(() => undefined);
+    }
     const controller = {
         client,
         openExternal: host.navigation.openExternal,
         clientConfigurationBridge: host.capabilities.aiClientConfiguration,
+        get credentialsCollection() {
+            return credentials?.collection;
+        },
+        get credentialRows() {
+            return credentialRows;
+        },
         get selectedSection() {
             return selectedSection;
         },
@@ -117,10 +313,32 @@ export function createAiConnectionsController(host) {
         get providerLoadError() {
             return providerLoadError;
         },
+        get liveUpdates() {
+            return liveUpdates;
+        },
+        get liveRevision() {
+            return liveRevision;
+        },
+        watchPageTables() {
+            pageTableHolds += 1;
+            syncTableSubscriptions();
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                pageTableHolds -= 1;
+                if (pageTableHolds > 0)
+                    return;
+                pageTableHolds = 0;
+                releaseTableSubscriptions();
+            };
+        },
         selectSection(section) {
             if (selectedSection === section)
                 return;
             selectedSection = section;
+            syncTableSubscriptions();
             notify();
         },
         selectProvider(provider, credentialId) {
@@ -132,6 +350,7 @@ export function createAiConnectionsController(host) {
             selectedSection = 'provider';
             selectedProvider = provider;
             selectedCredentialId = nextCredentialId;
+            syncTableSubscriptions();
             notify();
         },
         selectFirstUnconfiguredProvider() {
@@ -255,7 +474,7 @@ function withAccountClientCredentials(client, credentials) {
         },
     };
 }
-function createInteractiveAiConnectionsClient(operationsClient, podStore, beginProviderLoad) {
+function createInteractiveAiConnectionsClient(operationsClient, podStore, live, beginProviderLoad) {
     const listProviders = async () => {
         const guard = beginProviderLoad();
         try {
@@ -327,7 +546,7 @@ function createInteractiveAiConnectionsClient(operationsClient, podStore, beginP
         }
         return { credential, secret, didRefresh };
     };
-    return {
+    const storeClient = {
         ...operationsClient,
         listProviders,
         listModels: podStore.listModels
@@ -556,6 +775,35 @@ function createInteractiveAiConnectionsClient(operationsClient, podStore, beginP
             ? async (provider, modelIds, credentialId) => podStore.saveModelSelection(provider, modelIds, credentialId)
             : operationsClient.saveModelSelection,
     };
+    /**
+     * With a live credentials collection, credential writes go through it: the
+     * page sees them immediately, they roll back on rejection, and the document's
+     * own echo reconciles instead of overwriting.
+     *
+     * The collection may not be there yet (the layer loads lazily) and may never
+     * be (a host without the capability), so this dispatches per call: until the
+     * table lands, every write is the store's own, exactly as before.
+     *
+     * Reads of credentials stay in `listProviders` for now (it also carries
+     * providers and models); the page renders the credential lists from the
+     * collection's rows, and the store's summary of the same row is only the
+     * enrichment for attributes the descriptor cannot project.
+     */
+    const credentialStore = {
+        createApiKeyCredential: (provider, input) => live.mutations()?.createApiKeyCredential(provider, input)
+            ?? storeClient.createApiKeyCredential(provider, input),
+        // Two local-connection flows are account/Gateway operations, not Pod rows.
+        createLocalCredential: (provider, input) => (input.authorizationMethodId === 'local-session-import'
+            || (!input.authorizationMethodId && input.offeringId === 'official-subscription')
+            ? storeClient.createLocalCredential(provider, input)
+            : live.mutations()?.createLocalCredential(provider, input)
+                ?? storeClient.createLocalCredential(provider, input)),
+        updateProviderCredential: (provider, credentialId, input) => live.mutations()?.updateProviderCredential(provider, credentialId, input)
+            ?? storeClient.updateProviderCredential(provider, credentialId, input),
+        deleteProviderCredential: (provider, credentialId) => live.mutations()?.deleteProviderCredential(provider, credentialId)
+            ?? storeClient.deleteProviderCredential(provider, credentialId),
+    };
+    return { ...storeClient, ...credentialStore };
 }
 export function useSelectedSection(controller) {
     return useSyncExternalStore(controller.subscribe, () => controller.selectedSection ?? 'provider', () => controller.selectedSection ?? 'provider');
@@ -575,12 +823,33 @@ export function useProviderStates(controller) {
 export function useProviderSummaries(controller) {
     return useSyncExternalStore(controller.subscribe, () => legacySummariesFor(controller.providerSummaries), () => legacySummariesFor(controller.providerSummaries));
 }
+/**
+ * Providers this deployment offers, as reported by the server.
+ *
+ * Cloud answers with the operator-designated providers only (no self-hosted
+ * `custom`, no local daemon), so the settings surface cannot offer a provider the
+ * deployment does not provide. Before the first successful load this is
+ * `undefined`, which keeps every provider visible (Local behavior).
+ */
+export function useAvailableProviders(controller) {
+    const summaries = useProviderSummaries(controller);
+    const ids = Object.keys(summaries);
+    return ids.length > 0 ? ids : undefined;
+}
 export function useProviderProducts(controller) {
     return useSyncExternalStore(controller.subscribe, () => controller.providerSummaries, () => controller.providerSummaries);
 }
 export function useProviderLoadError(controller) {
     return useSyncExternalStore(controller.subscribe, () => controller.providerLoadError, () => controller.providerLoadError);
 }
+/** Whether live Pod updates are on, for a status affordance that stays small. */
+export function useLiveUpdates(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.liveUpdates, () => controller.liveUpdates);
+}
+/** Advances once per coalesced burst of Pod changes; drives page re-reads. */
+export function useLiveRevision(controller) {
+    return useSyncExternalStore(controller.subscribe, () => controller.liveRevision, () => controller.liveRevision);
+}
 function productStateFromProvider(product) {
     if (!product || product.status === 'unconfigured' || product.status === 'unavailable') {
         return 'unconfigured';
@@ -660,14 +929,15 @@ function mergeAuthorizationMethodsIntoProviders(providers, methods) {
             const capability = methodsByOffering.get(`${provider.id}:${offering.id}`);
             if (!capability)
                 return offering;
+            // The server's list is authoritative, an empty one included: it omits a
+            // connect entry this build has not implemented, and that omission has to
+            // survive the merge rather than fall back to deriving one from `authModes`.
             const authorizationMethods = capability.authorizationMethods;
             return {
                 ...offering,
                 ...(capability.endpoints ? { endpoints: capability.endpoints } : {}),
-                ...(authorizationMethods.length ? {
-                    authorizationMethods,
-                    authModes: mergeAuthModes(offering.authModes, authorizationMethods.map((method) => method.authMode)),
-                } : {}),
+                authorizationMethods,
+                authModes: mergeAuthModes(offering.authModes, authorizationMethods.map((method) => method.authMode)),
             };
         }),
     }));
@@ -745,7 +1015,7 @@ function isDefined(value) {
     return value !== undefined;
 }
 function errorMessage(error) {
-    return normalizeAiConnectionsThrownError(error);
+    return aiConnectionsErrorMessage(error);
 }
 /** The wrapper carries the OIDC client id; parsing it needs no stored secret. */
 function clientIdFromApiKey(apiKey) {

package/node_modules/@undefineds.co/ai-connections/dist/credential-labels.d.ts

@@ -1,10 +1,15 @@
-import type { AiProviderCredentialSummary } from './ai-connections-client';
+import type { AiProviderCredentialSummary } from '@undefineds.co/ai-connections-core/client';
 /** Highest priority first: a new credential joins the end of the pool. */
 export declare function nextCredentialPriority(credentials: AiProviderCredentialSummary[]): number;
 export declare function credentialDisplayLabel(credential: AiProviderCredentialSummary): string;
 /** Account names are shown inside a pool; only the domain stays readable. */
 export declare function maskAccountLabel(value: string): string;
 export declare function healthLabel(health: AiProviderCredentialSummary['health']): string;
+/**
+ * Tone of one credential row: the tint the row carries and the colour of its
+ * health dot. The row's border and dividers belong to the list container now, so
+ * the tone is a background rather than a box.
+ */
 export declare function healthTone(health: AiProviderCredentialSummary['health']): {
     row: string;
     dot: string;

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

@@ -36,12 +36,17 @@ export function healthLabel(health) {
         return '已过期';
     return '错误';
 }
+/**
+ * Tone of one credential row: the tint the row carries and the colour of its
+ * health dot. The row's border and dividers belong to the list container now, so
+ * the tone is a background rather than a box.
+ */
 export function healthTone(health) {
     if (health === 'healthy') {
-        return { row: 'border-emerald-500/40 bg-emerald-500/5', dot: 'bg-emerald-500' };
+        return { row: 'bg-emerald-500/5', dot: 'bg-emerald-500' };
     }
     if (health === 'unknown') {
-        return { row: 'border-border/50 bg-background', dot: 'bg-muted-foreground/50' };
+        return { row: 'bg-background', dot: 'bg-muted-foreground/50' };
     }
-    return { row: 'border-destructive/40 bg-destructive/5', dot: 'bg-destructive' };
+    return { row: 'bg-destructive/5', dot: 'bg-destructive' };
 }

package/node_modules/@undefineds.co/ai-connections/dist/display-wording.d.ts

@@ -0,0 +1,20 @@
+import type { AiConnectionsProvider, AiProviderAuthorizationMethod } from '@undefineds.co/ai-connections-core/client';
+/**
+ * Wording for one connect entry.
+ *
+ * A payload that declares its own wording keeps it: the entry's own name is the
+ * more specific statement, and it is how a provider the user configured names
+ * its entry, and how one offering renames a shared action for its context. The
+ * table only fills the gap the shared core deliberately leaves - it names the
+ * action by `id` and no longer writes the button.
+ */
+export declare function authorizationMethodLabel(method: AiProviderAuthorizationMethod): string | undefined;
+/** Fills in the wording of every entry that has one. */
+export declare function withAuthorizationMethodLabels(methods: readonly AiProviderAuthorizationMethod[]): AiProviderAuthorizationMethod[];
+/**
+ * The name this applet shows for a provider. English for the providers whose
+ * product name is English, Chinese where the product is known by its Chinese
+ * name - a display decision, so it lives with the display layer instead of
+ * travelling in every payload.
+ */
+export declare function providerDisplayName(provider: AiConnectionsProvider): string;

package/node_modules/@undefineds.co/ai-connections/dist/display-wording.js

@@ -0,0 +1,73 @@
+/**
+ * The wording this applet shows, in one place.
+ *
+ * The shared core carries what a provider *is* and how to talk to it - ids,
+ * auth modes, connect modes, endpoints - and deliberately carries no user-facing
+ * wording. A connect entry's wording is a property of the entry's id, so it
+ * belongs here, where it is rendered, rather than in the catalog, in the
+ * payload the server sends, and in this applet's own fallback derivation, which
+ * is where the same button used to be named three different ways.
+ *
+ * An id this table does not know keeps whatever wording its payload declared:
+ * a provider the user configured themselves can still name its own entry, and an
+ * entry that names nothing stays unrendered, which is how "the offering did not
+ * ask for this button" has always been expressed.
+ *
+ * The table lists only the ids the shared core stopped naming - the four connect
+ * actions plus the browser authorization-code entry. A declared wording always
+ * wins (see `authorizationMethodLabel`); this is the fallback that keeps a
+ * payload naming nothing renderable under the action's own name.
+ */
+const AUTHORIZATION_METHOD_LABEL_BY_ID = {
+    'api-key': '添加 API Key',
+    'browser-login': '浏览器登录',
+    'browser-oauth': '浏览器登录',
+    'device-code': '设备码登录',
+    'local-session-import': '已有登录态',
+    'local-service': '本地服务',
+};
+/**
+ * Wording for one connect entry.
+ *
+ * A payload that declares its own wording keeps it: the entry's own name is the
+ * more specific statement, and it is how a provider the user configured names
+ * its entry, and how one offering renames a shared action for its context. The
+ * table only fills the gap the shared core deliberately leaves - it names the
+ * action by `id` and no longer writes the button.
+ */
+export function authorizationMethodLabel(method) {
+    return method.label ?? AUTHORIZATION_METHOD_LABEL_BY_ID[method.id];
+}
+/** Fills in the wording of every entry that has one. */
+export function withAuthorizationMethodLabels(methods) {
+    return methods.map((method) => {
+        const label = authorizationMethodLabel(method);
+        return label === method.label ? method : { ...method, label };
+    });
+}
+/**
+ * The name this applet shows for a provider. English for the providers whose
+ * product name is English, Chinese where the product is known by its Chinese
+ * name - a display decision, so it lives with the display layer instead of
+ * travelling in every payload.
+ */
+export function providerDisplayName(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';
+    }
+}