@undefineds.co/xpod 0.4.19 → 0.4.25

package/dist/api/ApiServer.js

@@ -14,6 +14,11 @@ class ApiServer {
         this.upgradeHandlers = [];
         this.shutdownHandlers = [];
         this.responseHeaders = {};
+        this.activeHandlers = new Map();
+        this.openResponses = new Map();
+        this.upgradedSockets = new Set();
+        this.drainWaiters = new Set();
+        this.stopping = false;
         this.runtimeHost = options.runtimeHost ?? NodeRuntimeHost_1.nodeRuntimeHost;
         this.listenEndpoint = options.listenEndpoint ?? this.runtimeHost.createListenEndpoint({
             port: options.port,
@@ -62,9 +67,6 @@ class ApiServer {
     }
     addUpgradeHandler(handler) {
         this.upgradeHandlers.push(handler);
-        if (this.server) {
-            this.server.on('upgrade', handler);
-        }
     }
     addShutdownHandler(handler) {
         this.shutdownHandlers.push(handler);
@@ -78,6 +80,25 @@ class ApiServer {
     async start() {
         return new Promise((resolve, reject) => {
             this.server = (0, node_http_1.createServer)((req, res) => {
+                const requestPath = `${req.method ?? 'GET'} ${(req.url ?? '/').split('?', 1)[0]}`;
+                this.openResponses.set(res, requestPath);
+                const responseDone = () => {
+                    this.openResponses.delete(res);
+                    req.off('aborted', responseDone);
+                    req.socket.off('close', responseDone);
+                    this.notifyDrained();
+                };
+                res.once('finish', responseDone);
+                res.once('close', responseDone);
+                req.once('aborted', responseDone);
+                req.socket.once('close', responseDone);
+                if (this.stopping) {
+                    res.statusCode = 503;
+                    res.setHeader('Connection', 'close');
+                    res.end('Service is shutting down');
+                    return;
+                }
+                this.activeHandlers.set(req, requestPath);
                 this.handleRequest(req, res).catch((error) => {
                     this.logger.error(`Unhandled error: ${error}`);
                     if (!res.headersSent) {
@@ -85,11 +106,27 @@ class ApiServer {
                         res.setHeader('Content-Type', 'application/json');
                         res.end(JSON.stringify({ error: 'Internal Server Error' }));
                     }
+                }).finally(() => {
+                    // Bun can omit response finish/close after the peer disconnected.
+                    // The transport is gone, but its logical write still had to finish.
+                    if (req.aborted || req.socket.destroyed || res.destroyed) {
+                        responseDone();
+                    }
+                    this.activeHandlers.delete(req);
+                    this.notifyDrained();
                 });
             });
-            for (const handler of this.upgradeHandlers) {
-                this.server.on('upgrade', handler);
-            }
+            this.server.on('upgrade', (request, socket, head) => {
+                this.upgradedSockets.add(socket);
+                socket.once('close', () => { this.upgradedSockets.delete(socket); this.notifyDrained(); });
+                if (this.stopping) {
+                    socket.destroy();
+                    return;
+                }
+                for (const handler of this.upgradeHandlers) {
+                    handler(request, socket, head);
+                }
+            });
             this.runtimeHost.listen(this.server, this.listenEndpoint).then(() => {
                 this.logger.info(`API Server listening on ${this.runtimeHost.formatListenEndpoint(this.listenEndpoint)}`);
                 resolve();
@@ -100,16 +137,38 @@ class ApiServer {
      * Stop the server
      */
     async stop() {
-        return new Promise((resolve, reject) => {
-            if (!this.server) {
-                resolve();
-                return;
-            }
-            Promise.all(this.shutdownHandlers.map(async (handler) => handler())).then(() => this.runtimeHost.close(this.server, this.listenEndpoint)).then(() => {
-                this.logger.info('API Server stopped');
-                resolve();
-            }, reject);
-        });
+        if (this.stopPromise) {
+            return this.stopPromise;
+        }
+        this.stopping = true;
+        this.stopPromise = this.drainAndClose();
+        return this.stopPromise;
+    }
+    async drainAndClose() {
+        if (!this.server) {
+            return;
+        }
+        const endpoint = JSON.stringify(this.listenEndpoint);
+        this.logger.info(`Stopping API shutdown handlers at ${endpoint}`);
+        await Promise.all(this.shutdownHandlers.map(async (handler) => handler()));
+        // Upgraded channels no longer accept work. Wait for actual socket close,
+        // not just destroy() returning: Bun's native WebSocket cleanup is asynchronous.
+        // Shutdown handlers own the WebSocket close handshake; wait for its socket close.
+        this.logger.info(`Draining API HTTP server at ${endpoint}`);
+        this.logger.info(`API pending handlers at ${endpoint}: ${JSON.stringify([...this.activeHandlers.values()])}; responses: ${JSON.stringify([...this.openResponses.values()])}`);
+        await new Promise((resolve) => { this.drainWaiters.add(resolve); this.notifyDrained(); });
+        this.server.once('close', () => this.logger.info(`API HTTP close event at ${endpoint}`));
+        await this.runtimeHost.close(this.server, this.listenEndpoint, { connectionsDrained: true });
+        this.logger.info(`API Server stopped at ${endpoint}`);
+    }
+    notifyDrained() {
+        if (this.activeHandlers.size || this.openResponses.size || this.upgradedSockets.size) {
+            return;
+        }
+        for (const resolve of this.drainWaiters) {
+            resolve();
+        }
+        this.drainWaiters.clear();
     }
     /**
      * Get the underlying HTTP server (for WebSocket upgrade)

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

@@ -1,7 +1,8 @@
+import type { GatewayInvocationMetadata } from './InvocationMetadata';
 import type { AuthContext } from '../auth/AuthContext';
 import type { CredentialVault } from './credentials/CredentialVault';
 import type { EncryptedCredentialSecret } from './credentials/KeyWrapper';
-import type { ProviderRuntimeCredential } from './providers/ProviderRuntimeAdapter';
+import { type ProviderRuntimeCredential } from './providers/ProviderRuntimeAdapter';
 import type { ProviderRegistry } from './providers/ProviderRegistry';
 import type { ProviderRuntimeRegistry } from './providers/ProviderRuntimeRegistry';
 import { type CloudGatewayModelsClient } from './CloudGatewayModelsClient';
@@ -39,6 +40,11 @@ export interface GatewayCredentialHealthRecord {
     credentialIri: string;
     status?: number;
     errorCode?: string;
+    failureCode?: string;
+    occurredAt?: Date;
+    rateLimitResetAt?: Date;
+    expectedVersion?: number;
+    auth?: AuthContext;
 }
 export interface AiGatewayServiceOptions {
     deployment: string;
@@ -69,6 +75,7 @@ export interface GatewayExecutionInput {
     protocol: GatewayProtocol;
     body: unknown;
     signal?: AbortSignal;
+    invocationMetadata?: GatewayInvocationMetadata;
 }
 export interface GatewayExecution {
     protocol: GatewayProtocol;
@@ -91,6 +98,7 @@ export interface GatewayAcceptanceProvenance {
     generatedAt: string;
 }
 export declare class AiGatewayService {
+    private readonly logger;
     private readonly deployment;
     private readonly registry;
     private readonly router;

package/dist/api/ai-gateway/AiGatewayService.js

@@ -2,14 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AiGatewayService = void 0;
 const node_crypto_1 = require("node:crypto");
+const global_logger_factory_1 = require("global-logger-factory");
 const errors_1 = require("./errors");
 const AuthContext_1 = require("../auth/AuthContext");
 const PlaintextCredentialPayload_1 = require("./credentials/PlaintextCredentialPayload");
 const protocol_1 = require("./protocol");
+const ProviderRuntimeAdapter_1 = require("./providers/ProviderRuntimeAdapter");
 const ProviderRegistry_1 = require("./providers/ProviderRegistry");
 const CloudGatewayModelsClient_1 = require("./CloudGatewayModelsClient");
 class AiGatewayService {
     constructor(options) {
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.frontends = new Map();
         this.deployment = options.deployment;
         this.registry = options.registry;
@@ -70,6 +73,7 @@ class AiGatewayService {
                     protocol: input.protocol,
                     body: input.body,
                     signal: input.signal,
+                    invocationMetadata: input.invocationMetadata,
                 }),
             };
         }
@@ -86,6 +90,7 @@ class AiGatewayService {
                 request,
                 route,
                 signal: input.signal,
+                invocationMetadata: input.invocationMetadata,
             }),
         };
     }
@@ -115,6 +120,7 @@ class AiGatewayService {
                 protocol: input.protocol,
                 body: input.body,
                 signal: input.signal,
+                invocationMetadata: input.invocationMetadata,
             });
         }
         request.model = route.model;
@@ -126,6 +132,7 @@ class AiGatewayService {
             request,
             route,
             signal: input.signal,
+            invocationMetadata: input.invocationMetadata,
         })) {
             events.push(event);
         }
@@ -209,6 +216,7 @@ class AiGatewayService {
                     apiKey,
                     credential: this.runtimeCredentialFor(route, credential, input.protocol),
                     signal: input.signal,
+                    invocationMetadata: input.invocationMetadata,
                 });
                 for await (const event of upstream) {
                     if (event.type === 'usage') {
@@ -220,12 +228,14 @@ class AiGatewayService {
                     }
                     yield event;
                 }
-                await this.credentials.recordSuccess?.(healthRecord(input.principal.webId, this.deployment, route));
+                await this.credentials.recordSuccess?.({
+                    ...healthRecord(input.principal.webId, this.deployment, route), auth: input.auth, occurredAt: this.now(),
+                }).catch(() => this.logger.warn('Could not persist credential health after a successful request.'));
                 await this.recordUsage(input.principal.webId, input.auth, route, finalUsage);
                 return;
             }
             catch (error) {
-                await this.recordRouteFailure(input.principal.webId, route, error);
+                await this.recordRouteFailure(input.principal.webId, route, error, input.auth);
                 if (!firstClientEventEmitted && this.router.canFailOver(route) && isCredentialFailoverError(error)) {
                     const nextRoute = await this.findFailoverRoute(input.principal.webId, input.auth, input.request, route, attempted);
                     if (nextRoute) {
@@ -402,26 +412,30 @@ class AiGatewayService {
             ...(offering?.kind === 'token-plan' && !isLegacyCodingPlan ? { keyType: 'tokenPlan' } : {}),
         };
     }
-    async recordRouteFailure(webId, route, error) {
+    async recordRouteFailure(webId, route, error, auth) {
         const status = typeof error?.status === 'number'
             ? error.status
             : error instanceof errors_1.GatewayProtocolError
                 ? error.status
                 : undefined;
-        if (status === 429) {
+        const occurredAt = this.now();
+        const normalized = (0, errors_1.normalizeGatewayError)(error);
+        const failureCode = stringMetadata(normalized.error.details, 'classification') ?? (0, ProviderRuntimeAdapter_1.classifyProviderStatus)(status ?? 502);
+        const rateLimitResetAt = failureCode === 'rate_limited' ? new Date(occurredAt.getTime() + 60_000) : undefined;
+        if (rateLimitResetAt) {
             await this.router.recordCooldown({
                 webId,
                 deployment: this.deployment,
                 credentialId: route.credential.id,
-                until: new Date(this.now().getTime() + 60_000),
+                until: rateLimitResetAt,
             });
         }
-        const normalized = (0, errors_1.normalizeGatewayError)(error);
         await this.credentials.recordFailure?.({
             ...healthRecord(webId, this.deployment, route),
             status,
             errorCode: normalized.error.code,
-        });
+            failureCode, occurredAt, rateLimitResetAt, auth,
+        }).catch(() => this.logger.warn('Could not persist credential health after a failed request.'));
     }
     canForwardInferenceToCloud(error, auth, request) {
         if (!this.cloudModels) {
@@ -576,6 +590,7 @@ function healthRecord(webId, deployment, route) {
         provider: route.provider.id,
         credentialId: route.credential.id,
         credentialIri: route.credential.credentialIri,
+        expectedVersion: route.credential.version,
     };
 }
 function isCredentialFailoverError(error) {

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

@@ -1,3 +1,4 @@
+import { type GatewayInvocationMetadata } from './InvocationMetadata';
 import type { AuthContext } from '../auth/AuthContext';
 import type { GatewayEvent, GatewayProtocol } from './types';
 import type { GatewayModelProjection } from './routing/ModelRouter';
@@ -28,12 +29,14 @@ export declare class CloudGatewayModelsClient {
         protocol: GatewayProtocol;
         body: unknown;
         signal?: AbortSignal;
+        invocationMetadata?: GatewayInvocationMetadata;
     }): Promise<Record<string, unknown>>;
     executeStream(input: {
         auth: AuthContext;
         protocol: GatewayProtocol;
         body: unknown;
         signal?: AbortSignal;
+        invocationMetadata?: GatewayInvocationMetadata;
     }): AsyncIterable<GatewayEvent>;
     private inferenceResponse;
 }

package/dist/api/ai-gateway/CloudGatewayModelsClient.js

@@ -4,6 +4,7 @@ exports.CloudGatewayModelsClient = void 0;
 exports.resolveCloudModelsGatewayOrigin = resolveCloudModelsGatewayOrigin;
 exports.unionGatewayModelLists = unionGatewayModelLists;
 exports.callerIdentityAuthorization = callerIdentityAuthorization;
+const InvocationMetadata_1 = require("./InvocationMetadata");
 const global_logger_factory_1 = require("global-logger-factory");
 const errors_1 = require("./errors");
 const DEFAULT_TIMEOUT_MS = 3_000;
@@ -94,6 +95,7 @@ class CloudGatewayModelsClient {
             return await this.fetchImpl(url, {
                 method: 'POST',
                 headers: {
+                    ...(0, InvocationMetadata_1.gatewayInvocationHeaders)(input.invocationMetadata),
                     accept: input.accept,
                     authorization,
                     'content-type': 'application/json',

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

@@ -0,0 +1,9 @@
+import type { IncomingHttpHeaders } from 'node:http';
+/** Per-invocation client identity/routing hints, never Pod credentials or headers. */
+export interface GatewayInvocationMetadata {
+    sessionId?: string;
+    userAgent?: string;
+}
+export declare function readGatewayInvocationMetadata(headers: IncomingHttpHeaders, rawHeaders?: readonly string[]): GatewayInvocationMetadata;
+/** Rebuild only declared headers; runtime objects cannot smuggle auth or host. */
+export declare function gatewayInvocationHeaders(metadata?: GatewayInvocationMetadata): Record<string, string>;

package/dist/api/ai-gateway/InvocationMetadata.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGatewayInvocationMetadata = readGatewayInvocationMetadata;
+exports.gatewayInvocationHeaders = gatewayInvocationHeaders;
+const errors_1 = require("./errors");
+// The sole declaration of which client metadata may cross the Gateway boundary.
+const INVOCATION_HEADERS = [
+    { header: 'x-opencode-session', field: 'sessionId', maxLength: 256, pattern: /^[\x21-\x2b\x2d-\x7e]+$/u },
+    { header: 'user-agent', field: 'userAgent', maxLength: 512, pattern: /^[\x20-\x7e]+$/u },
+];
+function validateValue(value, rule) {
+    if (typeof value !== 'string' || !value.trim() || value.length > rule.maxLength || !rule.pattern.test(value)) {
+        throw new errors_1.GatewayProtocolError(`Invalid ${rule.header} invocation header`, { code: 'invalid_request', status: 400 });
+    }
+    return value;
+}
+function readGatewayInvocationMetadata(headers, rawHeaders = []) {
+    const metadata = {};
+    for (const rule of INVOCATION_HEADERS) {
+        const entries = Object.entries(headers).filter(([name]) => name.toLowerCase() === rule.header);
+        const wireCount = rawHeaders.filter((name, index) => index % 2 === 0 && name.toLowerCase() === rule.header).length;
+        if (entries.length > 1 || wireCount > 1) {
+            throw new errors_1.GatewayProtocolError(`Repeated ${rule.header} invocation header`, { code: 'invalid_request', status: 400 });
+        }
+        if (entries.length)
+            metadata[rule.field] = validateValue(entries[0][1], rule);
+    }
+    return metadata;
+}
+/** Rebuild only declared headers; runtime objects cannot smuggle auth or host. */
+function gatewayInvocationHeaders(metadata) {
+    const headers = {};
+    for (const rule of INVOCATION_HEADERS) {
+        const value = metadata?.[rule.field];
+        if (value !== undefined)
+            headers[rule.header] = validateValue(value, rule);
+    }
+    return headers;
+}
+//# sourceMappingURL=InvocationMetadata.js.map

package/dist/api/ai-gateway/auth/AiConnectionsInvocationKeyIssuer.d.ts

@@ -1,3 +1,4 @@
+import type { AuthContext } from '../../auth/AuthContext';
 import type { StoreContext } from '../../chatkit/store';
 import type { AIConnectionInvocationConfig } from '../../../agents/types';
 import { type GatewayDeployment, type InvocationTokenCodec } from './InvocationTokenCodec';
@@ -11,6 +12,17 @@ export interface AiConnectionsInvocationKeyIssuerOptions {
     reuseSafetyMarginMs?: number;
     maxCacheEntries?: number;
     now?: () => Date;
+    /**
+     * Resolve the owner's active Gateway model for this invocation.
+     *
+     * The task runtime reaches the Gateway through this key, so it must name a model the owner
+     * actually selected; otherwise the runner falls back to a placeholder the Gateway cannot route.
+     * The resolver reuses the same visible-model authority the Gateway serves at `/v1/models`.
+     */
+    resolveModel?: (input: {
+        webId: string;
+        auth: AuthContext;
+    }) => Promise<string | undefined>;
 }
 /**
  * Produces a short-lived stateless Gateway token at the trusted execution
@@ -27,11 +39,13 @@ export declare class AiConnectionsInvocationKeyIssuer {
     private readonly reuseSafetyMarginMs;
     private readonly maxCacheEntries;
     private readonly now;
+    private readonly resolveModel?;
     private readonly cache;
     private readonly pending;
     constructor(options: AiConnectionsInvocationKeyIssuerOptions);
     issue(context: StoreContext): Promise<AIConnectionInvocationConfig>;
     issueClientConfiguration(context: StoreContext): Promise<AIConnectionInvocationConfig>;
+    private resolveOwnerModel;
     private issueScoped;
     private createInvocation;
     private toInvocationConfig;

package/dist/api/ai-gateway/auth/AiConnectionsInvocationKeyIssuer.js

@@ -25,28 +25,46 @@ class AiConnectionsInvocationKeyIssuer {
         this.reuseSafetyMarginMs = normalizeSafetyMargin(options.reuseSafetyMarginMs, this.ttlMs);
         this.maxCacheEntries = normalizeMaxCacheEntries(options.maxCacheEntries);
         this.now = options.now ?? (() => new Date());
+        this.resolveModel = options.resolveModel;
     }
     async issue(context) {
         const auth = requireTrustedSolidAuth(context.auth);
+        const model = await this.resolveOwnerModel(auth);
         if (auth.viaApiKey === true && auth.clientId && auth.clientSecret) {
             return {
                 baseUrl: this.baseUrl,
                 apiKey: encodeClientCredentialsApiKey(auth.clientId, auth.clientSecret),
+                ...(model ? { model } : {}),
             };
         }
-        return this.issueScoped(auth, ['models:read', 'inference:write']);
+        return this.issueScoped(auth, ['models:read', 'inference:write'], model);
     }
     async issueClientConfiguration(context) {
         const auth = requireInteractiveSolidAuth(context.auth);
         return this.issueScoped(auth, ['client-config:read', 'client-config:write']);
     }
-    async issueScoped(auth, scopes) {
+    async resolveOwnerModel(auth) {
+        if (!this.resolveModel) {
+            return undefined;
+        }
+        try {
+            const webId = (0, InvocationTokenCodec_1.requireCanonicalWebId)(auth.webId);
+            const model = await this.resolveModel({ webId, auth });
+            return typeof model === 'string' && model.trim().length > 0 ? model.trim() : undefined;
+        }
+        catch {
+            // A model-lookup failure must not block issuing the invocation key; the runner will then
+            // surface the same provider error it would have without a model.
+            return undefined;
+        }
+    }
+    async issueScoped(auth, scopes, model) {
         const webId = (0, InvocationTokenCodec_1.requireCanonicalWebId)(auth.webId);
         const cacheKey = `${webId}\n${scopes.join(' ')}`;
         const now = this.now();
         const cached = this.cache.get(cacheKey);
         if (cached && cached.expiresAt.getTime() - now.getTime() >= this.reuseSafetyMarginMs) {
-            return this.toInvocationConfig(cached);
+            return this.toInvocationConfig(cached, model);
         }
         let pending = this.pending.get(cacheKey);
         if (!pending) {
@@ -60,7 +78,7 @@ class AiConnectionsInvocationKeyIssuer {
             void pending.then(clearPending, clearPending);
         }
         const issued = await pending;
-        return this.toInvocationConfig(issued);
+        return this.toInvocationConfig(issued, model);
     }
     createInvocation(cacheKey, webId, scopes, createdAt) {
         this.pruneCache(createdAt);
@@ -78,11 +96,12 @@ class AiConnectionsInvocationKeyIssuer {
         this.cache.set(cacheKey, cached);
         return cached;
     }
-    toInvocationConfig(invocation) {
+    toInvocationConfig(invocation, model) {
         return {
             baseUrl: this.baseUrl,
             apiKey: invocation.plaintext,
             expiresAt: invocation.expiresAt.toISOString(),
+            ...(model ? { model } : {}),
         };
     }
     pruneCache(now) {

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

@@ -0,0 +1,4 @@
+export type AuthorizationCallbackPageState = 'received' | 'invalid' | 'denied' | 'failed';
+export declare const AUTHORIZATION_CALLBACK_PAGE_CSP: string;
+/** Never pass provider values into this document; only a fixed status is accepted. */
+export declare function renderAuthorizationCallbackPage(state: AuthorizationCallbackPageState): string;

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

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUTHORIZATION_CALLBACK_PAGE_CSP = void 0;
+exports.renderAuthorizationCallbackPage = renderAuthorizationCallbackPage;
+const node_crypto_1 = require("node:crypto");
+const COPY = {
+    received: {
+        title: '授权结果已送达 Xpod',
+        description: '切回应用继续完成连接。连接进度会在 Xpod 中显示。',
+    },
+    invalid: {
+        title: '授权链接已失效',
+        description: '此授权链接无效或已过期。请返回 Xpod，重新发起连接。',
+    },
+    denied: {
+        title: '授权未完成',
+        description: '本次授权没有完成。请返回 Xpod，检查连接状态后重试。',
+    },
+    failed: {
+        title: '暂时无法接收授权',
+        description: 'Xpod 未能接收本次授权结果。请返回应用，重新发起连接。',
+    },
+};
+// The standalone loopback listener cannot depend on the user's gateway or
+// load external resources. Tokens match packages/shared-ui/src/theme.css.
+const STYLE = `
+:root{color-scheme:light dark;--canvas:#F7F4ED;--text:#2B2621;--muted:#655D53;--action:#563E84;--on-action:#F7F4ED;--hover:#4B3672;--pressed:#402E61}
+*{box-sizing:border-box}
+body{margin:0;min-height:100vh;min-height:100dvh;background:var(--canvas);color:var(--text);font-family:'PingFang SC','SF Pro Text',-apple-system,BlinkMacSystemFont,'Segoe UI','Noto Sans SC','Helvetica Neue',Arial,sans-serif}
+.page{min-height:100vh;min-height:100dvh;display:grid;grid-template-rows:auto 1fr auto;max-width:1120px;margin:auto;padding:36px 48px 28px}
+.brand{display:flex;align-items:center;gap:10px;font-size:22px;font-weight:600;letter-spacing:-.6px;line-height:1.2}
+.brand svg{width:28px;height:28px;flex:none}
+main{align-self:center;width:100%;max-width:560px;margin:64px auto 96px}
+h1{font-size:36px;font-weight:600;line-height:1.4;letter-spacing:-1px;margin:0 0 20px;text-wrap:balance}
+.description{font-size:17px;line-height:1.9;color:var(--muted);max-width:30em;margin:0 0 36px}
+.return{display:inline-flex;align-items:center;justify-content:center;min-height:48px;padding:12px 24px;background:var(--action);color:var(--on-action);border:1px solid transparent;border-radius:8px;font-size:16px;font-weight:600;line-height:1.4;text-decoration:none;white-space:nowrap}
+.return:hover{background:var(--hover)}
+.return:active{background:var(--pressed);transform:translateY(1px)}
+.return:focus-visible{outline:3px solid var(--action);outline-offset:5px}
+footer{font-size:13px;line-height:1.8;color:var(--muted)}
+@media(prefers-color-scheme:dark){:root{--canvas:#211D19;--text:#F7F4ED;--muted:#C7BEB2;--action:#B7ABC3;--on-action:#211D19;--hover:#C7BDD0;--pressed:#A79ABA}}
+@media(max-width:600px){.page{padding:28px 24px 24px}.brand{font-size:20px}main{margin:56px auto 72px}h1{font-size:28px;letter-spacing:-.6px}.description{font-size:16px;margin-bottom:28px}.return{width:100%}}
+@media(forced-colors:active){.return{border-color:ButtonText}}
+`;
+const STYLE_HASH = (0, node_crypto_1.createHash)('sha256').update(STYLE).digest('base64');
+exports.AUTHORIZATION_CALLBACK_PAGE_CSP = `default-src 'none'; style-src 'sha256-${STYLE_HASH}'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'`;
+/** Static source brand asset from ui/public/brand/xpod-app-24.svg. */
+const XPOD_MARK = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" aria-hidden="true" focusable="false"><rect x="1" y="1" width="22" height="22" rx="5" fill="#563E84"/><g fill="#F7F4ED"><path d="M7 5H12V11H18V19H7Z"/><path d="M14 5L19 9H14Z"/></g></svg>';
+/** Never pass provider values into this document; only a fixed status is accepted. */
+function renderAuthorizationCallbackPage(state) {
+    const { title, description } = COPY[state];
+    return `<!doctype html>
+<html lang="zh-CN">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<meta name="referrer" content="no-referrer">
+<meta name="color-scheme" content="light dark">
+<title>${title} · Xpod</title>
+<style>${STYLE}</style>
+</head>
+<body>
+<div class="page">
+<header class="brand">${XPOD_MARK}<span>Xpod</span></header>
+<main aria-labelledby="callback-title">
+<h1 id="callback-title">${title}</h1>
+<p class="description">${description}</p>
+<a class="return" href="xpod://ai-connections">返回 Xpod</a>
+</main>
+<footer>你可以关闭此页面，并在 Xpod 中继续操作。</footer>
+</div>
+</body>
+</html>`;
+}
+//# sourceMappingURL=AuthorizationCallbackPage.js.map

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoopbackAuthorizationCallbackReceiver = void 0;
 const node_http_1 = require("node:http");
+const AuthorizationCallbackPage_1 = require("./AuthorizationCallbackPage");
 /** Receives authorization codes locally; credential exchange belongs to the authenticated caller. */
 class LoopbackAuthorizationCallbackReceiver {
     constructor() {
@@ -84,15 +85,15 @@ class LoopbackAuthorizationCallbackReceiver {
         throw new Error('The registered local authorization callback ports are unavailable. Close the application using them and retry.');
     }
     async handle(request, response, port, registrations) {
-        const reply = (status, success = false) => {
+        const reply = (status, state = 'invalid') => {
             response.writeHead(status, {
                 'Content-Type': 'text/html; charset=utf-8',
                 'Cache-Control': 'no-store',
                 'Connection': 'close',
-                'Content-Security-Policy': "default-src 'none'; frame-ancestors 'none'",
+                'Content-Security-Policy': AuthorizationCallbackPage_1.AUTHORIZATION_CALLBACK_PAGE_CSP,
                 'Referrer-Policy': 'no-referrer',
             });
-            response.end(success ? '授权已返回 Xpod，请切回应用完成连接。' : '授权回调无效或已过期，请返回应用重试。');
+            response.end((0, AuthorizationCallbackPage_1.renderAuthorizationCallbackPage)(state));
         };
         const allowedHosts = ['localhost', '127.0.0.1'].map(host => port === 80 ? host : `${host}:${port}`);
         if (request.method !== 'GET' || !allowedHosts.includes(request.headers.host ?? '') ||
@@ -125,10 +126,10 @@ class LoopbackAuthorizationCallbackReceiver {
         registration.close();
         try {
             await registration.onCallback(query.has('code') ? { code: query.get('code') } : { error: query.get('error') });
-            reply(200, !query.has('error'));
+            reply(200, query.has('error') ? 'denied' : 'received');
         }
         catch {
-            reply(500);
+            reply(500, 'failed');
         }
     }
 }

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

@@ -1,3 +1,4 @@
+import type { GatewayCredentialHealthRecord } from '../AiGatewayService';
 import { aiModelResource, aiProviderResource, credentialResource } from '@undefineds.co/models';
 import type { EncryptedCredentialSecret } from '../credentials/KeyWrapper';
 import type { CredentialVault, ProviderSecret } from '../credentials/CredentialVault';
@@ -128,6 +129,11 @@ export interface ConnectCredentialRecord {
     priority?: number;
     enabled?: boolean;
     health?: 'healthy' | 'reauthRequired' | 'disabled' | 'error' | 'invalid' | 'unknown';
+    failCount?: number;
+    rateLimitResetAt?: Date;
+    lastFailureCode?: string;
+    lastFailureAt?: Date;
+    lastUsedAt?: Date;
     selectedModels?: AiGatewayModelSummary[];
     metadata?: Record<string, unknown>;
 }
@@ -244,6 +250,9 @@ export declare class PodConnectedCredentialRepository implements PodCredentialRe
     private readonly credentialTemplate;
     private readonly aiProviderTemplate;
     constructor(options?: PodConnectedCredentialRepositoryOptions);
+    recordSuccess(input: GatewayCredentialHealthRecord): Promise<void>;
+    recordFailure(input: GatewayCredentialHealthRecord): Promise<void>;
+    private recordHealth;
     getCredential(input: {
         webId: string;
         provider: string;
@@ -277,6 +286,7 @@ export declare class PodConnectedCredentialRepository implements PodCredentialRe
         quota?: {
             status: 'available' | 'unsupported' | 'exhausted' | 'error';
         };
+        cooldownUntil?: Date;
         encryptedSecret: EncryptedCredentialSecret;
         version?: number;
         runtimeCredential?: Record<string, unknown>;
@@ -413,7 +423,7 @@ declare abstract class SignedConnectAttemptAdapterBase {
     protected assertInput(input: ConnectBeginInput, mode: ConnectMode): void;
 }
 export interface BrowserAssistedApiKeyConnectAdapterOptions extends SignedConnectAttemptAdapterOptions {
-    consoleUrl: string;
+    consoleUrl: string | ((input: ConnectBeginInput) => string);
 }
 export declare class BrowserAssistedApiKeyConnectAdapter extends SignedConnectAttemptAdapterBase implements ProviderConnectAdapter {
     readonly mode: ConnectMode;
@@ -538,6 +548,10 @@ export interface AiProviderCredentialSummary {
     baseUrl?: string;
     proxyUrl?: string;
     expiresAt?: string;
+    lastFailureCode?: string;
+    lastFailureAt?: string;
+    rateLimitResetAt?: string;
+    failCount?: number;
     version: number;
     quota?: unknown;
 }