@undefineds.co/xpod 0.4.20 → 0.4.27

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;
 }
@@ -673,6 +687,7 @@ export declare class ProviderConnectService {
         credentialId: string;
         expectedVersion: number;
         patch: {
+            apiKey?: string;
             label?: string;
             enabled?: boolean;
             priority?: number;

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

@@ -33,6 +33,57 @@ class PodConnectedCredentialRepository {
         this.credentialTemplate = (0, drizzle_solid_1.alias)(models_1.credentialResource, 'credentialTemplate');
         this.aiProviderTemplate = (0, drizzle_solid_1.alias)(models_1.aiProviderResource, 'aiProviderTemplate');
     }
+    async recordSuccess(input) {
+        await this.recordHealth(input, true);
+    }
+    async recordFailure(input) {
+        await this.recordHealth(input, false);
+    }
+    async recordHealth(input, success) {
+        const { db, credential } = await this.dbForOwner(input.webId, input.auth);
+        const key = JSON.stringify([input.webId, input.credentialId]);
+        const previous = credentialUpdateLocks.get(key) ?? Promise.resolve();
+        let release;
+        const pending = new Promise((resolve) => { release = resolve; });
+        credentialUpdateLocks.set(key, pending);
+        await previous;
+        try {
+            const row = await db.findById(credential, input.credentialId);
+            if (!row)
+                return;
+            const current = recordFromCredentialRow(row);
+            // A late request for an old secret must not invalidate its replacement.
+            if (current.webId !== input.webId || current.credentialIri !== input.credentialIri
+                || current.status !== 'active'
+                || (input.expectedVersion !== undefined && input.expectedVersion !== current.version))
+                return;
+            const occurredAt = input.occurredAt ?? new Date();
+            if (Math.max(current.lastFailureAt?.getTime() ?? 0, current.lastUsedAt?.getTime() ?? 0) > occurredAt.getTime())
+                return;
+            const classifications = ['authentication', 'login_expired', 'quota_exhausted', 'authorization', 'rate_limited', 'upstream_unavailable', 'provider_error'];
+            const suppliedCode = input.failureCode ?? 'provider_error';
+            const failureCode = suppliedCode === 'authentication' && current.authMode === 'deviceCodeOAuth'
+                ? 'login_expired' : classifications.includes(suppliedCode) ? suppliedCode : 'provider_error';
+            const authenticationFailed = failureCode === 'authentication' || failureCode === 'login_expired';
+            const health = success ? 'healthy' : authenticationFailed
+                ? current.authMode === 'deviceCodeOAuth' ? 'reauthRequired' : 'invalid'
+                : current.health ?? 'healthy';
+            await db.updateById(credential, input.credentialId, {
+                failCount: success ? 0 : (current.failCount ?? 0) + 1,
+                lastFailureCode: success ? null : failureCode,
+                lastFailureAt: success ? null : occurredAt,
+                rateLimitResetAt: !success && failureCode === 'rate_limited' ? input.rateLimitResetAt ?? null : null,
+                ...(success ? { lastUsedAt: occurredAt, reauthRequired: false } :
+                    failureCode === 'login_expired' ? { reauthRequired: true } : {}),
+                metadata: { ...current.metadata, health },
+            });
+        }
+        finally {
+            release();
+            if (credentialUpdateLocks.get(key) === pending)
+                credentialUpdateLocks.delete(key);
+        }
+    }
     async getCredential(input) {
         const rows = await this.listProviderCredentials(input);
         const requestedId = models_1.aiRuntimeRepository.credentialId(input);
@@ -80,7 +131,8 @@ class PodConnectedCredentialRepository {
                 defaultModel: defaultModelFromMetadata(record.metadata),
                 priority: record.priority ?? 100,
                 health: record.health ?? (record.reauthRequired ? 'reauthRequired' : 'healthy'),
-                quota: { status: 'available' },
+                quota: { status: record.lastFailureCode === 'quota_exhausted' ? 'exhausted' : 'available' },
+                cooldownUntil: record.rateLimitResetAt,
                 encryptedSecret: record.encryptedSecret,
                 version: record.version,
                 runtimeCredential: runtimeCredentialFromMetadata({ ...record.metadata, offeringId }),
@@ -153,6 +205,12 @@ class PodConnectedCredentialRepository {
             deployment: input.deployment,
             version: currentVersion + 1,
         };
+        if (input.patch.health === 'healthy') {
+            merged.lastFailureCode = undefined;
+            merged.lastFailureAt = undefined;
+            merged.rateLimitResetAt = undefined;
+            merged.failCount = 0;
+        }
         if (merged.status === 'revoked' && input.patch.enabled === undefined) {
             merged.enabled = false;
         }
@@ -603,10 +661,10 @@ class BrowserAssistedApiKeyConnectAdapter extends SignedConnectAttemptAdapterBas
     }
     async begin(input) {
         this.assertInput(input, 'browserAssistedApiKey');
+        const url = new URL(typeof this.consoleUrl === 'function' ? this.consoleUrl(input) : this.consoleUrl);
         const now = this.now();
         const expiresAt = new Date(now.getTime() + 5 * 60 * 1000);
         const attempt = await this.createAttempt(input, expiresAt);
-        const url = new URL(this.consoleUrl);
         url.searchParams.set('xpod_connect_attempt', attempt.id);
         url.searchParams.set('xpod_provider', this.provider);
         return {
@@ -1816,28 +1874,49 @@ class ProviderConnectService {
             throw new Error('credential_pool_not_configured');
         }
         const existing = await this.credentialRepository.getCredentialById(input);
-        const metadata = metadataFromRowValue(existing?.metadata) ?? {};
+        if (!existing)
+            return undefined;
+        if (input.expectedVersion !== (existing.version ?? 0))
+            throw new Error('credential_version_conflict');
+        const replacingKey = Object.prototype.hasOwnProperty.call(input.patch, 'apiKey');
+        let replacement = {};
+        if (replacingKey) {
+            if (typeof input.patch.apiKey !== 'string' || !input.patch.apiKey.trim())
+                throw new Error('invalid_api_key');
+            if (existing.authMode !== 'apiKey')
+                throw new Error('credential_auth_mode_mismatch');
+            if (!this.vault)
+                throw new Error('credential_pool_not_configured');
+            replacement = {
+                encryptedSecret: await this.vault.seal({ webId: input.webId }, existing.credentialIri, existing.provider, { type: 'apiKey', apiKey: input.patch.apiKey.trim() }),
+                reauthRequired: false, failCount: 0, lastFailureCode: undefined,
+                lastFailureAt: undefined, rateLimitResetAt: undefined,
+                health: (input.patch.enabled ?? existing.enabled) === false ? 'disabled' : 'unknown',
+            };
+        }
+        const metadata = metadataFromRowValue(existing.metadata) ?? {};
         const updated = await this.credentialRepository.updateCredential({
             ...input,
-            patch: metadataWithoutUndefined({
-                accountLabel: input.patch.label,
-                enabled: input.patch.enabled,
-                priority: input.patch.priority,
-                proxyUrl: input.patch.proxyUrl === undefined
-                    ? undefined
-                    : (0, provider_http_transport_1.normalizeProviderProxyUrl)(input.patch.proxyUrl),
-                health: input.patch.enabled === false ? 'disabled' : undefined,
-                metadata: metadataWithoutUndefined({
-                    ...metadata,
-                    baseUrl: input.patch.baseUrl ?? metadata.baseUrl,
+            patch: { ...metadataWithoutUndefined({
+                    accountLabel: input.patch.label,
+                    enabled: input.patch.enabled,
+                    priority: input.patch.priority,
                     proxyUrl: input.patch.proxyUrl === undefined
-                        ? metadata.proxyUrl
+                        ? undefined
                         : (0, provider_http_transport_1.normalizeProviderProxyUrl)(input.patch.proxyUrl),
-                    priority: input.patch.priority ?? metadata.priority,
-                    enabled: input.patch.enabled ?? metadata.enabled,
-                    health: input.patch.enabled === false ? 'disabled' : metadata.health,
-                }),
-            }),
+                    health: input.patch.enabled === false ? 'disabled' : undefined,
+                    metadata: metadataWithoutUndefined({
+                        ...metadata,
+                        baseUrl: input.patch.baseUrl ?? metadata.baseUrl,
+                        proxyUrl: input.patch.proxyUrl === undefined
+                            ? metadata.proxyUrl
+                            : (0, provider_http_transport_1.normalizeProviderProxyUrl)(input.patch.proxyUrl),
+                        priority: input.patch.priority ?? metadata.priority,
+                        enabled: input.patch.enabled ?? metadata.enabled,
+                        health: replacingKey ? replacement.health : input.patch.enabled === false ? 'disabled' : metadata.health,
+                        ...(replacingKey ? { maskedHint: maskApiKey(input.patch.apiKey.trim()) } : {}),
+                    }),
+                }), ...replacement },
         });
         return updated ? publicPoolCredentialSummary(updated) : undefined;
     }
@@ -2198,6 +2277,10 @@ function publicPoolCredentialSummary(record) {
         baseUrl: stringMetadata(metadata, 'baseUrl'),
         proxyUrl: (0, provider_http_transport_1.redactProviderProxyUrl)(record.proxyUrl ?? stringMetadata(metadata, 'proxyUrl')),
         expiresAt: record.expiresAt?.toISOString(),
+        lastFailureCode: record.lastFailureCode,
+        lastFailureAt: record.lastFailureAt?.toISOString(),
+        rateLimitResetAt: record.rateLimitResetAt?.toISOString(),
+        failCount: record.failCount,
         version: record.version ?? 0,
         quota: metadata.quota ?? metadata.quotaStatus,
     });
@@ -2495,6 +2578,11 @@ function credentialRowFromRecord(record) {
         accountLabel: record.accountLabel,
         label: record.accountLabel,
         reauthRequired: record.reauthRequired ?? false,
+        failCount: record.failCount ?? 0,
+        rateLimitResetAt: record.rateLimitResetAt ?? null,
+        lastFailureCode: record.lastFailureCode ?? null,
+        lastFailureAt: record.lastFailureAt ?? null,
+        lastUsedAt: record.lastUsedAt,
         proxyUrl: (0, provider_http_transport_1.normalizeProviderProxyUrl)(record.proxyUrl ?? stringMetadata(metadata, 'proxyUrl')),
         lastRefreshAt: new Date(),
         metadata,
@@ -2532,6 +2620,11 @@ function recordFromCredentialRow(row) {
         status,
         accountLabel: stringFrom(row.accountLabel) || stringFrom(row.label) || undefined,
         expiresAt: dateFrom(row.expiresAt),
+        failCount: typeof row.failCount === 'number' ? row.failCount : 0,
+        rateLimitResetAt: dateFrom(row.rateLimitResetAt),
+        lastFailureCode: stringFrom(row.lastFailureCode) || undefined,
+        lastFailureAt: dateFrom(row.lastFailureAt),
+        lastUsedAt: dateFrom(row.lastUsedAt),
         scopes: Array.isArray(row.scopes) ? row.scopes.map(String) : undefined,
         version: versionFromRow(row),
         reauthRequired,
@@ -3210,17 +3303,11 @@ function oneTimeOAuthCredential(body, now, expectedVersion, integration, fallbac
     };
 }
 function safeProviderError(body) {
-    const code = stringFrom(body.error);
-    if (SAFE_PROVIDER_ERROR_CODES.has(code)) {
-        return code;
-    }
-    if (!code) {
-        return 'provider_error';
-    }
-    if (code.endsWith('_error')) {
-        return 'provider_error';
-    }
-    return 'provider_error';
+    const error = body.error;
+    const code = stringFrom(error && typeof error === 'object' && !Array.isArray(error)
+        ? error.code
+        : error);
+    return SAFE_PROVIDER_ERROR_CODES.has(code) ? code : 'provider_error';
 }
 const SAFE_PROVIDER_ERROR_CODES = new Set([
     'authorization_pending',
@@ -3228,6 +3315,7 @@ const SAFE_PROVIDER_ERROR_CODES = new Set([
     'expired_token',
     'access_denied',
     'invalid_grant',
+    'invalid_token',
     'invalid_client',
 ]);
 function pendingResult(input, status, intervalSeconds, provider = normalizeProvider(input.provider), offeringId = input.offeringId) {

package/dist/api/ai-gateway/models/ProviderModelsAdapter.js

@@ -29,12 +29,15 @@ class ProviderModelsResponseError extends Error {
     }
 }
 exports.ProviderModelsResponseError = ProviderModelsResponseError;
+// Codex protocol compatibility baseline, independent of Xpod and ACP wrapper versions.
+// Verified release: https://github.com/openai/codex/releases/tag/rust-v0.160.0
+const CODEX_MODELS_CLIENT_VERSION = '0.160.0';
 /** Discovers the models currently enabled for a ChatGPT Codex subscription. */
 class CodexSubscriptionModelsAdapter {
     constructor(options = {}) {
         this.protocol = 'codex-models';
         this.transport = options.transport ?? new provider_http_transport_1.ProviderHttpTransport();
-        this.clientVersion = options.clientVersion ?? '0.0.0';
+        this.clientVersion = options.clientVersion ?? CODEX_MODELS_CLIENT_VERSION;
     }
     async fetch(input) {
         const accessToken = stringSecret(input.secret, 'accessToken', 'access_token');
@@ -57,7 +60,7 @@ class CodexSubscriptionModelsAdapter {
             const models = Array.isArray(body?.models) ? body.models : [];
             return models
                 .filter((model) => Boolean(model) && typeof model === 'object')
-                .filter((model) => model.visibility !== 'hide')
+                .filter((model) => model.visibility === 'list')
                 .map((model) => ({
                 id: String(model.slug ?? model.id ?? '').trim(),
                 ...(typeof model.display_name === 'string' && model.display_name.trim()

package/dist/api/ai-gateway/pod/HostedPodRoute.d.ts

@@ -25,10 +25,3 @@ export declare function resolveHostedPodRoute(input: {
  * request stays bound to the URL the caller named.
  */
 export declare function createHostedPodRouteTransport(transport: typeof fetch, route: HostedPodRoute | undefined): Promise<typeof fetch>;
-/**
- * Compiled single-file runtimes unpack their packages into a cache directory and resolve that
- * archive themselves, so a bare specifier is not part of their module map: the import fails with
- * `Cannot find module` and the AI gateway answers 500. The extracted package is a real file, so
- * load it through its own URL when the specifier cannot be resolved.
- */
-export declare function resolveStagedLocalRouteFetch(): string | undefined;

package/dist/api/ai-gateway/pod/HostedPodRoute.js

@@ -1,34 +1,7 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveHostedPodRoute = resolveHostedPodRoute;
 exports.createHostedPodRouteTransport = createHostedPodRouteTransport;
-exports.resolveStagedLocalRouteFetch = resolveStagedLocalRouteFetch;
-const node_fs_1 = require("node:fs");
-const path = __importStar(require("node:path"));
-const node_url_1 = require("node:url");
 const bootstrap_1 = require("../../../runtime/bootstrap");
 /**
  * The route that reaches this deployment's hosted Pods from inside the API sidecar.
@@ -66,49 +39,8 @@ async function createHostedPodRouteTransport(transport, route) {
     return createSolidLocalRouteFetch({ fetch: transport, routes: () => [route] });
 }
 async function importSolidLocalRouteFetch() {
-    // The API runtime is CommonJS while solid-sdk is intentionally ESM-only. Keep the package
-    // boundary and load the SDK without TypeScript lowering import() to require().
-    const dynamicImport = new Function('specifier', 'return import(specifier)');
-    const specifier = '@undefineds.co/solid-sdk/local-route-fetch';
-    try {
-        return await dynamicImport(specifier);
-    }
-    catch (error) {
-        const staged = resolveStagedLocalRouteFetch();
-        if (!staged)
-            throw error;
-        return dynamicImport(staged);
-    }
-}
-/**
- * Compiled single-file runtimes unpack their packages into a cache directory and resolve that
- * archive themselves, so a bare specifier is not part of their module map: the import fails with
- * `Cannot find module` and the AI gateway answers 500. The extracted package is a real file, so
- * load it through its own URL when the specifier cannot be resolved.
- */
-function resolveStagedLocalRouteFetch() {
-    const cacheRoot = process.env.XPOD_BUN_SINGLE_CACHE_DIR?.trim();
-    if (!cacheRoot)
-        return undefined;
-    const relative = path.join('node_modules', '@undefineds.co', 'solid-sdk', 'dist', 'local-route-fetch.js');
-    const candidates = [path.join(cacheRoot, relative)];
-    try {
-        for (const entry of (0, node_fs_1.readdirSync)(cacheRoot)) {
-            candidates.push(path.join(cacheRoot, entry, relative));
-        }
-    }
-    catch {
-        // A missing or unreadable cache root just means there is nothing to fall back to.
-    }
-    for (const candidate of candidates) {
-        try {
-            if ((0, node_fs_1.statSync)(candidate).isFile())
-                return (0, node_url_1.pathToFileURL)(candidate).href;
-        }
-        catch {
-            continue;
-        }
-    }
-    return undefined;
+    // The public CommonJS entry also lets the single-file bundler include this exact SDK
+    // version. Module resolution and initialization failures must retain their original cause.
+    return require('@undefineds.co/solid-sdk/local-route-fetch');
 }
 //# sourceMappingURL=HostedPodRoute.js.map

package/dist/api/ai-gateway/pod/OwnerPodAccess.d.ts

@@ -97,7 +97,6 @@ export declare class OwnerPodAccess implements PodAccessFetchProvider {
      */
     private taskCredentialFetch;
     private credentialFetch;
-    private invalidateOnUnauthorized;
 }
 /**
  * Reason an owner's Pod is out of reach, as a stable code the caller and the UI can act on.

package/dist/api/ai-gateway/pod/OwnerPodAccess.js

@@ -69,37 +69,77 @@ class OwnerPodAccess {
         if (!credential) {
             return undefined;
         }
-        return await this.credentialFetch(owner, credential);
+        const sessionCredential = { ...credential, version: String(credential.version) };
+        return await this.credentialFetch(owner, sessionCredential, async () => {
+            const current = await this.taskCredentials.forRef({
+                credentialRef: credential.credentialRef,
+                ownerWebId: owner,
+                version: credential.version,
+            });
+            if (!current || current.credentialRef !== credential.credentialRef || current.version !== credential.version
+                || current.clientId !== credential.clientId || current.clientSecret !== credential.clientSecret) {
+                this.sessions.invalidate(sessionCredential);
+                throw new Error(`${exports.POD_INTERFACE_KEY_REJECTED}:task_grant_unusable`);
+            }
+        });
     }
-    async credentialFetch(owner, credential) {
-        let session;
-        try {
-            session = await this.sessions.session(credential);
-        }
-        catch (error) {
-            const status = error instanceof SolidSessionFactory_1.SolidSessionError ? error.status : undefined;
-            this.logger.warn(`Pod interface key refused for ${owner}: ${String(error)}`);
-            throw new Error(`${exports.POD_INTERFACE_KEY_REJECTED}:${status ?? 'invalid_response'}`);
-        }
+    async credentialFetch(owner, credential, assertAuthorized) {
+        const currentSession = async () => {
+            try {
+                const session = await this.sessions.session(credential);
+                if (!sameWebIdOwner(session.webId, owner)) {
+                    this.sessions.invalidate(credential, session);
+                    throw new SolidSessionFactory_1.SolidSessionError('token_owner_mismatch');
+                }
+                return session;
+            }
+            catch (error) {
+                const status = error instanceof SolidSessionFactory_1.SolidSessionError ? error.status : undefined;
+                this.logger.warn(`Pod interface key refused for ${owner}: ${String(error)}`);
+                throw new Error(`${exports.POD_INTERFACE_KEY_REJECTED}:${status ?? 'invalid_response'}`);
+            }
+        };
+        // Preserve immediate credential validation at getPodFetch, then check again per request.
+        let session = await currentSession();
         const transport = await (this.transport ??= (0, HostedPodRoute_1.createHostedPodRouteTransport)(this.fetchImpl, this.route));
-        const authenticated = (0, solid_client_authn_core_1.buildAuthenticatedFetch)(session.accessToken, {
-            ...(session.dpopKey ? { dpopKey: session.dpopKey } : {}),
+        const authenticatedFor = (value) => (0, solid_client_authn_core_1.buildAuthenticatedFetch)(value.accessToken, {
+            ...(value.dpopKey ? { dpopKey: value.dpopKey } : {}),
             fetch: transport,
         });
-        return this.invalidateOnUnauthorized(credential, authenticated);
-    }
-    invalidateOnUnauthorized(credential, podFetch) {
+        let authenticated = authenticatedFor(session);
         return async (input, init) => {
-            const response = await podFetch(input, init);
+            await assertAuthorized?.();
+            const requestSession = await currentSession();
+            // Recheck a task grant after a possibly slow exchange, before dispatching its token.
+            await assertAuthorized?.();
+            if (session !== requestSession) {
+                session = requestSession;
+                authenticated = authenticatedFor(session);
+            }
+            const response = await authenticated(input, init);
             if (response.status === 401) {
-                // The token stopped being accepted; the next request exchanges the key again.
-                this.sessions.invalidate(credential);
+                // Return the original rejection; writes are never replayed to try another token.
+                this.sessions.invalidate(credential, requestSession);
             }
             return response;
         };
     }
 }
 exports.OwnerPodAccess = OwnerPodAccess;
+/**
+ * Whether an exchanged token names the owner it was requested for.
+ *
+ * A WebID is a full URI, so identity is the exact URI, fragment included: two fragments on the
+ * same document (`#alice` and `#bob`) are different principals, and a fragmentless document is a
+ * different URI from its `#me` principal. The token must name exactly the owner that was asked for.
+ * Any normalization belongs at the authoritative claim/provisioning/fixture source, never here.
+ */
+function sameWebIdOwner(sessionWebId, owner) {
+    if (!sessionWebId) {
+        return true;
+    }
+    return sessionWebId === owner;
+}
 /**
  * Reason an owner's Pod is out of reach, as a stable code the caller and the UI can act on.
  *

package/dist/api/ai-gateway/providers/AnthropicRuntimeAdapter.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicRuntimeAdapter = void 0;
+const InvocationMetadata_1 = require("../InvocationMetadata");
 const ProviderRuntimeAdapter_1 = require("./ProviderRuntimeAdapter");
 const ANTHROPIC_BASE_URL = 'https://api.anthropic.com/v1';
 const ANTHROPIC_VERSION = '2023-06-01';
@@ -20,6 +21,7 @@ class AnthropicRuntimeAdapter extends ProviderRuntimeAdapter_1.BaseProviderRunti
             allowCredentialBaseUrl: this.allowCredentialBaseUrl,
         });
         const headers = new Headers({
+            ...(0, InvocationMetadata_1.gatewayInvocationHeaders)(input.invocationMetadata),
             'x-api-key': input.apiKey,
             'anthropic-version': ANTHROPIC_VERSION,
         });