@undefineds.co/xpod 0.4.20 → 0.4.27

package/dist/api/ApiServer.js

@@ -4,6 +4,7 @@ exports.ApiServer = void 0;
 const node_http_1 = require("node:http");
 const global_logger_factory_1 = require("global-logger-factory");
 const NodeRuntimeHost_1 = require("../runtime/host/node/NodeRuntimeHost");
+const task_model_diagnostics_1 = require("../util/task-model-diagnostics");
 /**
  * Standalone API Server
  */
@@ -14,6 +15,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 +68,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 +81,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 +107,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 +138,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)
@@ -124,6 +184,7 @@ class ApiServer {
         const method = request.method?.toUpperCase() ?? 'GET';
         const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
         const path = url.pathname;
+        this.observeTaskGatewayResponse(request, response, method, path);
         // Handle CORS preflight
         if (method === 'OPTIONS') {
             this.handleCors(request, response);
@@ -182,6 +243,42 @@ class ApiServer {
             }
         }
     }
+    observeTaskGatewayResponse(request, response, method, path) {
+        if (method !== 'POST')
+            return;
+        const route = path === '/v1/chat/completions' ? 'chat_completions' :
+            path === '/v1/responses' ? 'responses' :
+                path === '/v1/messages' ? 'anthropic_messages' : undefined;
+        if (!route)
+            return;
+        const correlationHash = (0, task_model_diagnostics_1.hashTaskModelDiagnosticSession)(request.headers['x-opencode-session']);
+        if (!correlationHash)
+            return;
+        const startedAt = Date.now();
+        const observe = (statusSource) => {
+            response.off('finish', onFinish);
+            response.off('close', onClose);
+            // An unsent close has no actual caller HTTP status, regardless of statusCode.
+            if (statusSource === 'response_closed' && !response.headersSent)
+                return;
+            try {
+                const receipt = (0, task_model_diagnostics_1.selectTaskModelDiagnosticReceipt)({
+                    event: 'xpod.task-gateway-http-diagnostic', schemaVersion: 1, scope: 'session',
+                    correlationHash, route, callerHTTPstatus: response.statusCode, statusSource,
+                    durationMs: Math.max(0, Math.min(2147483647, Date.now() - startedAt)),
+                });
+                if (receipt)
+                    this.logger.error(JSON.stringify(receipt));
+            }
+            catch {
+                // Diagnostics are observational; a failing sink must not affect HTTP or cleanup.
+            }
+        };
+        const onFinish = () => observe('response_finished');
+        const onClose = () => observe('response_closed');
+        response.once('finish', onFinish);
+        response.once('close', onClose);
+    }
     findRoute(method, path) {
         for (const route of this.routes) {
             if (!route.allMethods && route.method !== method) {

package/dist/api/ai-config/AiConfigStore.js

@@ -17,7 +17,7 @@ class DrizzlePodAiConfigStore {
             db.findById(models_1.aiConfigResource, id),
             db.findById(XpodAiConfigSchema_1.xpodAiConfigResource, id),
         ]);
-        return policyFromRows(sharedRow, productRow);
+        return policyFromRows(sharedRow, productRow, input.podUrl);
     }
     async update(input) {
         const { db } = await this.open(input);
@@ -26,7 +26,7 @@ class DrizzlePodAiConfigStore {
             db.findById(models_1.aiConfigResource, id),
             db.findById(XpodAiConfigSchema_1.xpodAiConfigResource, id),
         ]);
-        const mergedPolicy = mergePolicy(policyFromRows(sharedCurrent, productCurrent), input.patch, this.now());
+        const mergedPolicy = mergePolicy(policyFromRows(sharedCurrent, productCurrent, input.podUrl), input.patch, this.now(), input.podUrl);
         await Promise.all([
             writeRow(db, models_1.aiConfigResource, id, sharedCurrent, sharedRowFromPolicy(mergedPolicy)),
             writeRow(db, XpodAiConfigSchema_1.xpodAiConfigResource, id, productCurrent, productRowFromPolicy(mergedPolicy)),
@@ -49,7 +49,7 @@ exports.DrizzlePodAiConfigStore = DrizzlePodAiConfigStore;
 function aiConfigResourceId() {
     return models_1.aiConfigResource.buildId({ id: 'config' });
 }
-function policyFromRows(sharedRow, productRow) {
+function policyFromRows(sharedRow, productRow, podUrl) {
     const defaults = defaultPolicy();
     if (!sharedRow && !productRow)
         return defaults;
@@ -58,7 +58,7 @@ function policyFromRows(sharedRow, productRow) {
     const models = {};
     for (const key of modelKeys) {
         if (typeof shared[key] === 'string' && shared[key])
-            models[key] = shared[key];
+            models[key] = canonicalModelReference(shared[key], podUrl);
     }
     return {
         schemaVersion: '1.0',
@@ -92,14 +92,14 @@ function policyFromRows(sharedRow, productRow) {
         updatedAt: isoDate(shared.updatedAt),
     };
 }
-function mergePolicy(current, patch, now) {
+function mergePolicy(current, patch, now, podUrl) {
     const models = { ...current.models };
     for (const key of modelKeys) {
         const value = patch.models?.[key];
         if (value === null)
             delete models[key];
         else if (value !== undefined)
-            models[key] = value;
+            models[key] = canonicalModelReference(value, podUrl);
     }
     return {
         schemaVersion: '1.0',
@@ -110,6 +110,18 @@ function mergePolicy(current, patch, now) {
         updatedAt: now.toISOString(),
     };
 }
+/** API refs may be Pod-root-relative; linked ORM columns require target-relative ids or absolute IRIs. */
+function canonicalModelReference(ref, podUrl) {
+    if (/^[a-z][a-z\d+.-]*:/i.test(ref)) {
+        // Validate without serializing: external IRI lexical identity must survive.
+        new URL(ref);
+        return ref;
+    }
+    const parsed = models_1.aiModelResource.parseRef(ref);
+    if (!parsed)
+        throw new Error('Invalid AI model resource reference');
+    return models_1.aiModelResource.buildIri(podUrl, { id: parsed.resourceId });
+}
 function sharedRowFromPolicy(policy) {
     return {
         ...Object.fromEntries(modelKeys.map((key) => [key, policy.models[key] ?? null])),

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;