@undefineds.co/xpod 0.4.14 → 0.4.15

package/config/cloud.json

@@ -508,9 +508,6 @@
       "overrideParameters": {
         "@type": "StatusWaterfallHandler",
         "handlers": [
-          {
-            "@id": "urn:undefineds:xpod:InternalPodDataHttpHandler"
-          },
           {
             "@id": "urn:undefineds:xpod:SubgraphSparqlHttpHandler"
           },

package/config/local.json

@@ -349,9 +349,6 @@
       "overrideParameters": {
         "@type": "StatusWaterfallHandler",
         "handlers": [
-          {
-            "@id": "urn:undefineds:xpod:InternalPodDataHttpHandler"
-          },
           {
             "@id": "urn:undefineds:xpod:SubgraphSparqlHttpHandler"
           },

package/config/xpod.base.json

@@ -404,30 +404,6 @@
         "value": 0
       }
     },
-    {
-      "comment": "Loopback-only runtime-signed hosted Pod data channel for AI Connection resources.",
-      "@type": "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/dist/http/InternalPodDataHttpHandler.jsonld#InternalPodDataHttpHandler",
-      "@id": "urn:undefineds:xpod:InternalPodDataHttpHandler",
-      "@context": {
-        "resourceStore": "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/dist/http/InternalPodDataHttpHandler.jsonld#InternalPodDataHttpHandler_options_resourceStore",
-        "patchBodyParser": "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/dist/http/InternalPodDataHttpHandler.jsonld#InternalPodDataHttpHandler_options_patchBodyParser",
-        "sparqlHandler": "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/dist/http/InternalPodDataHttpHandler.jsonld#InternalPodDataHttpHandler_options_sparqlHandler",
-        "baseUrl": "https://linkedsoftwaredependencies.org/bundles/npm/@undefineds.co/xpod/^0.0.0/dist/http/InternalPodDataHttpHandler.jsonld#InternalPodDataHttpHandler_options_baseUrl"
-      },
-      "resourceStore": {
-        "@id": "urn:solid-server:default:ResourceStore"
-      },
-      "patchBodyParser": {
-        "@id": "urn:solid-server:default:PatchBodyParser"
-      },
-      "sparqlHandler": {
-        "@id": "urn:undefineds:xpod:SubgraphSparqlHttpHandler"
-      },
-      "baseUrl": {
-        "@id": "urn:solid-server:default:variable:baseUrl",
-        "@type": "Variable"
-      }
-    },
     {
       "comment": "Tracing handler for request ID and logging. Added to CSS Middleware.",
       "@id": "urn:undefineds:xpod:TracingHandler",

package/dist/api/ai-config/AiConfigStore.d.ts

@@ -1,5 +1,5 @@
 import type { SolidAuthContext } from '../auth/AuthContext';
-import type { InternalPodAccessTokenProvider } from '../ai-gateway/pod/HostedPodDataAccess';
+import type { PodAccessFetchProvider } from '../ai-gateway/pod/OwnerPodAccess';
 import type { AiConfigPolicy, AiConfigPolicyPatch, AiConfigPolicyStore } from '../handlers/AiConfigHandler';
 interface AiConfigDb {
     init?: (...resources: unknown[]) => Promise<void>;
@@ -12,7 +12,7 @@ interface AiConfigDb {
     };
 }
 export interface DrizzlePodAiConfigStoreOptions {
-    internalPodAccess?: InternalPodAccessTokenProvider;
+    podAccess?: PodAccessFetchProvider;
     dbFactory?: (input: {
         webId: string;
         podUrl: string;

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

@@ -34,7 +34,10 @@ class DrizzlePodAiConfigStore {
         return mergedPolicy;
     }
     async open(input) {
-        const trustedFetch = await this.options.internalPodAccess?.getTrustedFetch(input.webId, input.auth, { podBaseUrl: input.podUrl });
+        const trustedFetch = await this.options.podAccess?.getPodFetch(input.webId, {
+            ...(input.auth ? { auth: input.auth } : {}),
+            podBaseUrl: input.podUrl,
+        });
         if (!trustedFetch)
             throw new Error('service_access_missing');
         const db = await this.dbFactory({ ...input, fetch: trustedFetch });

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

@@ -1,9 +1,6 @@
 import type { AuthContext } from '../../auth/AuthContext';
+import { type HostedPodRoute } from '../pod/HostedPodRoute';
 export declare const CALLER_POD_ACCESS_UNAVAILABLE = "caller_pod_access_unavailable";
 export declare const CALLER_DPOP_REPLAY_UNSUPPORTED = "caller_dpop_replay_unsupported";
 export declare const CALLER_OWNER_MISMATCH = "caller_owner_mismatch";
-export declare function createCallerAuthenticatedPodFetch(owner: string, auth?: AuthContext, upstream?: typeof fetch): typeof fetch | undefined;
-export declare function callerPodAccessError(owner: string, auth?: AuthContext): string;
-export declare function isInternalPodAccessAllowed(auth?: AuthContext, options?: {
-    explicitInternalAccess?: boolean;
-}): boolean;
+export declare function createCallerAuthenticatedPodFetch(owner: string, auth?: AuthContext, upstream?: typeof fetch, route?: HostedPodRoute): typeof fetch | undefined;

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

@@ -2,12 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CALLER_OWNER_MISMATCH = exports.CALLER_DPOP_REPLAY_UNSUPPORTED = exports.CALLER_POD_ACCESS_UNAVAILABLE = void 0;
 exports.createCallerAuthenticatedPodFetch = createCallerAuthenticatedPodFetch;
-exports.callerPodAccessError = callerPodAccessError;
-exports.isInternalPodAccessAllowed = isInternalPodAccessAllowed;
+const HostedPodRoute_1 = require("../pod/HostedPodRoute");
 exports.CALLER_POD_ACCESS_UNAVAILABLE = 'caller_pod_access_unavailable';
 exports.CALLER_DPOP_REPLAY_UNSUPPORTED = 'caller_dpop_replay_unsupported';
 exports.CALLER_OWNER_MISMATCH = 'caller_owner_mismatch';
-function createCallerAuthenticatedPodFetch(owner, auth, upstream = fetch) {
+function createCallerAuthenticatedPodFetch(owner, auth, upstream = fetch, route) {
     if (!auth
         || auth.type !== 'solid'
         || auth.webId !== owner
@@ -30,51 +29,13 @@ function createCallerAuthenticatedPodFetch(owner, auth, upstream = fetch) {
             headers,
         });
     };
-    const route = localHostedPodRoute();
     if (!route) {
         return authenticatedFetch;
     }
-    // The API runtime is CommonJS while solid-sdk is intentionally ESM-only.
-    // Keep the package boundary and load the SDK lazily without TypeScript
-    // lowering import() to require().
     let routedFetch;
     return async (input, init) => {
-        routedFetch ??= importSolidLocalRouteFetch().then(({ createSolidLocalRouteFetch }) => createSolidLocalRouteFetch({ fetch: authenticatedFetch, routes: () => [route] }));
+        routedFetch ??= (0, HostedPodRoute_1.createHostedPodRouteTransport)(authenticatedFetch, route);
         return (await routedFetch)(input, init);
     };
 }
-async function importSolidLocalRouteFetch() {
-    const dynamicImport = new Function('specifier', 'return import(specifier)');
-    return dynamicImport('@undefineds.co/solid-sdk/local-route-fetch');
-}
-function localHostedPodRoute() {
-    const canonicalBaseUrl = process.env.CSS_BASE_URL?.trim();
-    const mainPort = process.env.XPOD_MAIN_PORT?.trim();
-    if (!canonicalBaseUrl || !mainPort || !/^\d+$/u.test(mainPort)) {
-        return undefined;
-    }
-    return {
-        canonicalBaseUrl,
-        localBaseUrl: `http://127.0.0.1:${mainPort}/`,
-    };
-}
-function callerPodAccessError(owner, auth) {
-    if (!auth || auth.type !== 'solid') {
-        return exports.CALLER_POD_ACCESS_UNAVAILABLE;
-    }
-    if (auth.webId !== owner) {
-        return exports.CALLER_OWNER_MISMATCH;
-    }
-    if (auth.tokenType === 'DPoP' || typeof auth.dpopProof === 'string') {
-        return exports.CALLER_DPOP_REPLAY_UNSUPPORTED;
-    }
-    return exports.CALLER_POD_ACCESS_UNAVAILABLE;
-}
-function isInternalPodAccessAllowed(auth, options = {}) {
-    return options.explicitInternalAccess === true
-        || (auth?.type === 'solid' && (auth.viaApiKey === true
-            ||
-                auth.internalInvocation === true
-            || (auth.viaGatewayApiKey === true && auth.gatewayRuntimeAccess === true)));
-}
 //# sourceMappingURL=CallerPodAccess.js.map

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

@@ -30,7 +30,8 @@ export declare const LEGACY_GATEWAY_KEY_AUTHENTICATION = "legacy-gateway-key-aut
 export type GatewayAccessKeyRepositoryInternalAccessReason = typeof LEGACY_GATEWAY_KEY_AUTHENTICATION | 'gateway-key-verifier';
 export interface GatewayAccessKeyRepositoryContext {
     auth?: AuthContext;
-    internalPodAccess?: {
+    /** Set when the gateway itself is verifying a key, rather than serving an owner request. */
+    gatewayKeyVerification?: {
         reason: GatewayAccessKeyRepositoryInternalAccessReason;
     };
 }

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

@@ -44,7 +44,7 @@ class GatewayApiKeyAuthenticator {
             return infrastructureError(new Error('Gateway API key repository is not configured'));
         }
         const repositoryContext = {
-            internalPodAccess: { reason: 'gateway-key-verifier' },
+            gatewayKeyVerification: { reason: 'gateway-key-verifier' },
         };
         let record;
         try {

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

@@ -1,5 +1,6 @@
 import { credentialResource, gatewayAccessKeyResource, type GatewayAccessKeyRow } from '@undefineds.co/models';
 import type { AuthContext } from '../../auth/AuthContext';
+import { type PodAccessFetchProvider } from '../pod/OwnerPodAccess';
 import { type PodBaseUrlResolver } from '../pod/PodBaseUrlResolver';
 import { type GatewayKeyLocatorCodec } from './GatewayKeyLocatorCodec';
 import { type GatewayAccessKeyRecord, type GatewayAccessKeyRepository, type GatewayAccessKeyRepositoryContext } from './GatewayApiKeyAuthenticator';
@@ -29,7 +30,7 @@ type GatewayAccessKeyDb = {
 type GatewayAccessKeyResource = typeof gatewayAccessKeyResource;
 export interface PodGatewayAccessKeyRepositoryOptions {
     locatorCodec: GatewayKeyLocatorCodec;
-    internalPodAccess?: InternalPodAccessTokenProvider;
+    podAccess?: PodAccessFetchProvider;
     podBaseUrlResolver?: PodBaseUrlResolver;
     dbFactory?: (input: {
         owner: string;
@@ -41,16 +42,10 @@ export interface PodGatewayAccessKeyRepositoryOptions {
         credentialListResource?: typeof credentialResource;
     }) => Promise<GatewayAccessKeyDb>;
 }
-export interface InternalPodAccessTokenProvider {
-    getTrustedFetch(owner: string, auth?: AuthContext, context?: {
-        reason?: string;
-        podBaseUrl?: string;
-    }): Promise<typeof fetch | undefined>;
-}
 export declare class PodGatewayAccessKeyRepository implements GatewayAccessKeyRepository {
     private readonly dbFactory;
     private readonly locatorCodec;
-    private readonly internalPodAccess?;
+    private readonly podAccess?;
     private readonly podBaseUrlResolver?;
     private readonly usesDefaultDbFactory;
     constructor(options: PodGatewayAccessKeyRepositoryOptions);

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

@@ -4,14 +4,14 @@ exports.PodGatewayAccessKeyRepository = void 0;
 exports.clientCredentialProviderId = clientCredentialProviderId;
 const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
-const CallerPodAccess_1 = require("./CallerPodAccess");
+const OwnerPodAccess_1 = require("../pod/OwnerPodAccess");
 const AiConnectionsServiceAccess_1 = require("../service-access/AiConnectionsServiceAccess");
 const PodBaseUrlResolver_1 = require("../pod/PodBaseUrlResolver");
 const GatewayKeyLocatorCodec_1 = require("./GatewayKeyLocatorCodec");
 class PodGatewayAccessKeyRepository {
     constructor(options) {
         this.locatorCodec = options.locatorCodec;
-        this.internalPodAccess = options.internalPodAccess;
+        this.podAccess = options.podAccess;
         this.podBaseUrlResolver = options.podBaseUrlResolver;
         this.usesDefaultDbFactory = options.dbFactory === undefined;
         this.dbFactory = options.dbFactory ?? createDefaultGatewayAccessKeyDb;
@@ -48,7 +48,7 @@ class PodGatewayAccessKeyRepository {
         const { db, resource } = await this.dbForOwner(locator.owner, context);
         // Authentication uses only the legacy RDF verifier rows; issued client
         // credentials are owner-authorized management records.
-        if (!context?.internalPodAccess) {
+        if (!context?.gatewayKeyVerification) {
             const credential = await db.findById(models_1.credentialResource, clientCredentialStorageId(id));
             if (credential)
                 return clientCredentialRecord(id, locator, credential);
@@ -136,10 +136,7 @@ class PodGatewayAccessKeyRepository {
         if (!locator) {
             return;
         }
-        const { db, resource } = await this.dbForOwner(locator.owner, {
-            ...context,
-            internalPodAccess: context?.internalPodAccess ? { reason: 'gateway-key-verifier' } : undefined,
-        });
+        const { db, resource } = await this.dbForOwner(locator.owner, context);
         const credentialStorageId = clientCredentialStorageId(id);
         if (await db.findById(models_1.credentialResource, credentialStorageId)) {
             await db.updateById(models_1.credentialResource, credentialStorageId, { lastUsedAt });
@@ -171,32 +168,12 @@ class PodGatewayAccessKeyRepository {
     }
     async resolveTrustedFetch(owner, podUrl, context) {
         const auth = context?.auth;
-        if (auth?.type === 'solid' && auth.webId !== owner) {
-            throw new Error((0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
-        }
-        // DPoP proves this management request, not a request to a different Pod URL.
-        // The hosted adapter verifies the same owner and signs a resource-scoped
-        // loopback intent; it never forwards the browser's token or proof.
-        if (auth?.type === 'solid' && (auth.tokenType === 'DPoP' || auth.dpopProof)) {
-            const hostedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl: podUrl });
-            if (hostedFetch) {
-                return this.wrapPodFetch(hostedFetch);
-            }
-        }
-        const callerFetch = (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth);
-        if (callerFetch) {
-            return this.wrapPodFetch(callerFetch);
-        }
-        if (!(0, CallerPodAccess_1.isInternalPodAccessAllowed)(auth, {
-            explicitInternalAccess: Boolean(context?.internalPodAccess?.reason),
-        })) {
-            throw new Error((0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
-        }
-        const trustedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, context?.internalPodAccess?.reason === 'gateway-key-verifier'
-            ? { reason: 'gateway-key-verifier', podBaseUrl: podUrl }
-            : { podBaseUrl: podUrl });
+        const trustedFetch = await this.podAccess?.getPodFetch(owner, {
+            ...(auth ? { auth } : {}),
+            podBaseUrl: podUrl,
+        });
         if (!trustedFetch) {
-            throw new Error('AI Connection service identity is not configured');
+            throw new Error((0, OwnerPodAccess_1.podAccessError)(owner, auth));
         }
         return this.wrapPodFetch(trustedFetch);
     }

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

@@ -5,7 +5,7 @@ import type { GatewayDeployment } from '../auth/InvocationTokenCodec';
 import { type ProviderOfferingEndpointDescriptor, type ProviderCapabilities, type ProviderRegistry } from '../providers/ProviderRegistry';
 import type { OfferingAuthorizationMethod } from '../providers/OfferingAuthorization';
 import type { AuthContext } from '../../auth/AuthContext';
-import type { InternalPodAccessTokenProvider } from '../pod/HostedPodDataAccess';
+import { type PodAccessFetchProvider } from '../pod/OwnerPodAccess';
 import { type PodBaseUrlResolver } from '../pod/PodBaseUrlResolver';
 import type { AuthorizationCodeCallbackReceiver } from './LoopbackAuthorizationCallbackReceiver';
 import type { AuthorizationCodeOAuthIntegration, DeviceCodeOAuthIntegration, OAuthConnectMode } from './DeviceCodeProtocol';
@@ -223,7 +223,7 @@ type ConnectedCredentialDb = {
     };
 };
 export interface PodConnectedCredentialRepositoryOptions {
-    internalPodAccess?: InternalPodAccessTokenProvider;
+    podAccess?: PodAccessFetchProvider;
     podBaseUrlResolver?: PodBaseUrlResolver;
     providerIds?: string[];
     dbFactory?: (input: {
@@ -238,7 +238,7 @@ export interface PodConnectedCredentialRepositoryOptions {
 }
 export declare class PodConnectedCredentialRepository implements PodCredentialRepository {
     private readonly dbFactory;
-    private readonly internalPodAccess?;
+    private readonly podAccess?;
     private readonly podBaseUrlResolver?;
     private readonly providerIds;
     private readonly credentialTemplate;

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

@@ -7,7 +7,7 @@ const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
 const errors_1 = require("../errors");
 const ProviderRegistry_1 = require("../providers/ProviderRegistry");
-const CallerPodAccess_1 = require("../auth/CallerPodAccess");
+const OwnerPodAccess_1 = require("../pod/OwnerPodAccess");
 const PodBaseUrlResolver_1 = require("../pod/PodBaseUrlResolver");
 const OAuthConnectAdapter_1 = require("./OAuthConnectAdapter");
 const provider_http_transport_1 = require("../../service/provider-http-transport");
@@ -25,7 +25,7 @@ const CREDENTIAL_COLLECTION_QUERY_UNSUPPORTED = 'credential_collection_query_uns
 const credentialUpdateLocks = new Map();
 class PodConnectedCredentialRepository {
     constructor(options = {}) {
-        this.internalPodAccess = options.internalPodAccess;
+        this.podAccess = options.podAccess;
         this.podBaseUrlResolver = options.podBaseUrlResolver;
         this.providerIds = options.providerIds
             ?? ProviderRegistry_1.DEFAULT_PROVIDER_DESCRIPTORS.map((provider) => provider.id);
@@ -383,43 +383,14 @@ class PodConnectedCredentialRepository {
         return { db, credential, aiProvider, aiModel, fetch: trustedFetch };
     }
     async resolveTrustedFetch(owner, auth, podBaseUrl) {
-        if (auth?.type === 'solid' && auth.webId !== owner) {
-            throw new Error((0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
-        }
-        // A CSS account client-credentials token authenticates its exchange, not a
-        // reusable Pod request. Prefer the constrained hosted route for that wrapper.
-        if (auth?.type === 'solid'
-            && auth.webId === owner
-            && auth.viaApiKey === true
-            && typeof auth.clientId === 'string'
-            && typeof auth.clientSecret === 'string') {
-            const hostedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl });
-            if (hostedFetch) {
-                return this.wrapPodFetch(hostedFetch);
-            }
-        }
-        const callerFetch = (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth);
-        if (callerFetch) {
-            return this.wrapPodFetch(callerFetch);
-        }
-        // Browser DPoP proves the management caller but is bound to that request
-        // URL. Never replay it against the Pod; use the same-owner hosted route.
-        if (auth?.type === 'solid'
-            && auth.webId === owner
-            && (auth.tokenType === 'DPoP' || typeof auth.dpopProof === 'string')) {
-            const hostedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl });
-            if (hostedFetch) {
-                return this.wrapPodFetch(hostedFetch);
-            }
-        }
-        if (!(0, CallerPodAccess_1.isInternalPodAccessAllowed)(auth)) {
-            throw new Error((0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
-        }
-        const trustedFetch = await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl });
-        if (!trustedFetch) {
-            throw new Error('AI Connection service identity is not configured');
+        const podFetch = await this.podAccess?.getPodFetch(owner, {
+            ...(auth ? { auth } : {}),
+            podBaseUrl,
+        });
+        if (!podFetch) {
+            throw new Error((0, OwnerPodAccess_1.podAccessError)(owner, auth));
         }
-        return this.wrapPodFetch(trustedFetch);
+        return this.wrapPodFetch(podFetch);
     }
     wrapPodFetch(trustedFetch) {
         return async (input, init) => {

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GatewayProtocolError = void 0;
 exports.normalizeGatewayError = normalizeGatewayError;
+const OwnerPodAccess_1 = require("./pod/OwnerPodAccess");
 class GatewayProtocolError extends Error {
     constructor(message, options = {}) {
         super(message);
@@ -26,7 +27,7 @@ function normalizeGatewayError(error) {
             },
         };
     }
-    if (error instanceof Error && error.message === 'service_access_missing') {
+    if (error instanceof Error && (0, OwnerPodAccess_1.isPodAccessFailure)(error.message)) {
         return {
             error: {
                 code: 'service_access_missing',

package/dist/api/ai-gateway/models/PodModelSelectionRepository.d.ts

@@ -1,6 +1,6 @@
 import { aiModelResource, aiProviderResource } from '@undefineds.co/models';
 import type { AuthContext } from '../../auth/AuthContext';
-import type { InternalPodAccessTokenProvider } from '../pod/HostedPodDataAccess';
+import { type PodAccessFetchProvider } from '../pod/OwnerPodAccess';
 import { type PodBaseUrlResolver } from '../pod/PodBaseUrlResolver';
 export type PodSelectedModelStatus = 'active' | 'inactive';
 export interface PodSelectedModel {
@@ -40,7 +40,7 @@ export interface PodModelSelectionDb {
     transaction?<T>(transaction: (tx: PodModelSelectionDb) => Promise<T>): Promise<T>;
 }
 export interface PodModelSelectionRepositoryOptions {
-    internalPodAccess?: InternalPodAccessTokenProvider;
+    podAccess?: PodAccessFetchProvider;
     podBaseUrlResolver?: PodBaseUrlResolver;
     dbFactory?: (input: {
         owner: string;
@@ -82,7 +82,7 @@ export declare const DEFAULT_MODEL_SELECTION_PROVIDERS: readonly ["openai", "ant
  */
 export declare class PodModelSelectionRepository {
     private readonly dbFactory;
-    private readonly internalPodAccess?;
+    private readonly podAccess?;
     private readonly podBaseUrlResolver?;
     private readonly providerIds;
     private readonly now;

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

@@ -5,7 +5,7 @@ exports.computeSelectionVersion = computeSelectionVersion;
 const node_crypto_1 = require("node:crypto");
 const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
-const CallerPodAccess_1 = require("../auth/CallerPodAccess");
+const OwnerPodAccess_1 = require("../pod/OwnerPodAccess");
 const PodBaseUrlResolver_1 = require("../pod/PodBaseUrlResolver");
 const REMOVED_MODEL_STATUS = 'removed';
 exports.DEFAULT_MODEL_SELECTION_PROVIDERS = [
@@ -25,7 +25,7 @@ const modelSelectionLocks = new Map();
 class PodModelSelectionRepository {
     constructor(options = {}) {
         this.dbFactory = options.dbFactory ?? createDefaultModelSelectionDb;
-        this.internalPodAccess = options.internalPodAccess;
+        this.podAccess = options.podAccess;
         this.podBaseUrlResolver = options.podBaseUrlResolver;
         this.providerIds = dedupeProviders(options.providerIds ?? exports.DEFAULT_MODEL_SELECTION_PROVIDERS);
         this.now = options.now ?? (() => new Date());
@@ -314,16 +314,12 @@ class PodModelSelectionRepository {
         assertOwnerWebId(owner);
         assertAuthOwner(owner, auth);
         const podUrl = await (0, PodBaseUrlResolver_1.resolveOwnerPodBaseUrl)(owner, this.podBaseUrlResolver);
-        const hostedFetch = auth?.type === 'solid' && auth.webId === owner
-            ? await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl: podUrl })
-            : undefined;
-        const callerFetch = (0, CallerPodAccess_1.createCallerAuthenticatedPodFetch)(owner, auth);
-        const trustedFetch = hostedFetch ?? callerFetch
-            ?? await this.internalPodAccess?.getTrustedFetch(owner, auth, { podBaseUrl: podUrl });
+        const trustedFetch = await this.podAccess?.getPodFetch(owner, {
+            ...(auth ? { auth } : {}),
+            podBaseUrl: podUrl,
+        });
         if (!trustedFetch) {
-            throw new Error((0, CallerPodAccess_1.isInternalPodAccessAllowed)(auth)
-                ? 'AI Connection service identity is not configured'
-                : (0, CallerPodAccess_1.callerPodAccessError)(owner, auth));
+            throw new Error((0, OwnerPodAccess_1.podAccessError)(owner, auth));
         }
         const podFetch = async (input, init) => {
             let response;

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

@@ -0,0 +1,27 @@
+export interface HostedPodRoute {
+    /** Canonical Pod/container URL used for RDF identity and public access. */
+    canonicalBaseUrl: string;
+    /** Same resource tree exposed by the local Xpod Gateway. */
+    localBaseUrl: string;
+}
+/**
+ * The route that reaches this deployment's hosted Pods from inside the API sidecar.
+ *
+ * The inputs are resolved where they are known - when the runtime builds its services - and not
+ * read from the environment per request: the runtime restores the environment it borrowed once
+ * its services are up, so a lazy lookup would silently find nothing and address the Pod's
+ * canonical URL instead of the route that is actually reachable.
+ */
+export declare function resolveHostedPodRoute(input: {
+    canonicalBaseUrl?: string;
+    gatewayHost?: string;
+    gatewayPort?: string | number;
+}): HostedPodRoute | undefined;
+/**
+ * Wrap a transport so canonical Pod URLs are sent over the gateway route.
+ *
+ * This belongs *under* a DPoP signer, never wrapped around an authenticated fetch: the proof is
+ * made for the canonical URL, and this layer only replaces the wire target, so a DPoP-bound
+ * request stays bound to the URL the caller named.
+ */
+export declare function createHostedPodRouteTransport(transport: typeof fetch, route: HostedPodRoute | undefined): Promise<typeof fetch>;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveHostedPodRoute = resolveHostedPodRoute;
+exports.createHostedPodRouteTransport = createHostedPodRouteTransport;
+const bootstrap_1 = require("../../../runtime/bootstrap");
+/**
+ * The route that reaches this deployment's hosted Pods from inside the API sidecar.
+ *
+ * The inputs are resolved where they are known - when the runtime builds its services - and not
+ * read from the environment per request: the runtime restores the environment it borrowed once
+ * its services are up, so a lazy lookup would silently find nothing and address the Pod's
+ * canonical URL instead of the route that is actually reachable.
+ */
+function resolveHostedPodRoute(input) {
+    const canonicalBaseUrl = input.canonicalBaseUrl?.trim();
+    const gatewayPort = String(input.gatewayPort ?? '').trim();
+    if (!canonicalBaseUrl || !/^\d+$/u.test(gatewayPort)) {
+        return undefined;
+    }
+    return {
+        canonicalBaseUrl,
+        // The gateway has to be reached on the address it actually bound: `localhost` may be
+        // IPv6-only, and a wildcard bind is not connectable on every platform.
+        localBaseUrl: `${(0, bootstrap_1.localServiceUrl)(input.gatewayHost, Number(gatewayPort))}/`,
+    };
+}
+/**
+ * Wrap a transport so canonical Pod URLs are sent over the gateway route.
+ *
+ * This belongs *under* a DPoP signer, never wrapped around an authenticated fetch: the proof is
+ * made for the canonical URL, and this layer only replaces the wire target, so a DPoP-bound
+ * request stays bound to the URL the caller named.
+ */
+async function createHostedPodRouteTransport(transport, route) {
+    if (!route) {
+        return transport;
+    }
+    const { createSolidLocalRouteFetch } = await importSolidLocalRouteFetch();
+    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)');
+    return dynamicImport('@undefineds.co/solid-sdk/local-route-fetch');
+}
+//# sourceMappingURL=HostedPodRoute.js.map

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

@@ -0,0 +1,79 @@
+import { type AuthContext } from '../../auth/AuthContext';
+import { type HostedPodRoute } from './HostedPodRoute';
+import type { PodInterfaceCredential, PodInterfaceKeyAccess, PodInterfaceKeyGrant } from './PodInterfaceKeyStore';
+/** No usable Pod credential is on file for this owner; the user has to grant one. */
+export declare const POD_INTERFACE_KEY_MISSING = "pod_interface_key_missing";
+/** The owner's stored credential was refused by the Pod; it has to be granted again. */
+export declare const POD_INTERFACE_KEY_REJECTED = "pod_interface_key_rejected";
+export interface PodAccessRequestContext {
+    /** The authenticated caller, when the request carries one. */
+    auth?: AuthContext;
+    /** Physical Pod root when the identity WebID is hosted by a separate IdP. */
+    podBaseUrl?: string;
+}
+/**
+ * Source of a fetch that reaches an owner's Pod through its standard interface.
+ *
+ * `undefined` means no credential is on file, which is a state the caller reports to the user
+ * rather than papers over.
+ */
+export interface PodAccessFetchProvider {
+    getPodFetch(owner: string, context?: PodAccessRequestContext): Promise<typeof fetch | undefined>;
+}
+export interface OwnerPodAccessOptions {
+    keys: PodInterfaceKeyAccess;
+    /** Token endpoint of this deployment's Solid interface. */
+    tokenEndpoint: string;
+    /** Canonical base URL of that interface, used to keep the DPoP proof canonical. */
+    publicBaseUrl?: string;
+    /** Route this deployment exposes for its own hosted Pods, when one is needed. */
+    route?: HostedPodRoute;
+    fetch?: typeof fetch;
+    now?: () => number;
+}
+/**
+ * Reaches a Pod as its owner over the standard Solid interface.
+ *
+ * Three credentials can prove the owner, and all three are the owner's own interface key:
+ * the caller's key, when the caller presented one; the caller's reusable token, when it holds
+ * one; and the key the owner granted this deployment for work no caller is attached to.
+ *
+ * What never happens is asking the Solid server to trust the caller's network position. Every
+ * request carries a credential for the owner and addresses the Pod's own URLs, so the Pod's own
+ * authorization decides - exactly as it does for the browser.
+ */
+export declare class OwnerPodAccess implements PodAccessFetchProvider, PodInterfaceKeyGrant {
+    private readonly logger;
+    private readonly keys;
+    private readonly fetchImpl;
+    private readonly now;
+    private readonly tokenRoute;
+    private readonly route?;
+    private readonly podFetches;
+    constructor(options: OwnerPodAccessOptions);
+    /** Grant, or rotate, the owner's Pod interface key. */
+    saveKey(owner: string, credential: PodInterfaceCredential): Promise<void>;
+    forgetKey(owner: string): Promise<void>;
+    hasKey(owner: string): Promise<boolean>;
+    getPodFetch(owner: string, context?: PodAccessRequestContext): Promise<typeof fetch | undefined>;
+    private storedKeyFetch;
+    private credentialFetch;
+    private exchange;
+    private invalidateOnUnauthorized;
+}
+/**
+ * Reason an owner's Pod is out of reach, as a stable code the caller and the UI can act on.
+ *
+ * A same-owner caller is the ordinary case: Xpod knows who the user is, but holds nothing it can
+ * present to the Pod on the user's behalf. A browser session explains why its own credential was
+ * not enough - its proof is bound to the URL it was made for - while a bearer session simply has
+ * no Pod credential at all. Either way the fix is the same: grant the interface key.
+ */
+export declare function podAccessError(owner: string, auth?: AuthContext): string;
+/**
+ * Whether a failure means Xpod had no usable way into the owner's Pod.
+ *
+ * The stable wire code for this is `service_access_missing`, which callers already report; the
+ * codes below are the reason behind it, kept distinct so the UI can ask for the right fix.
+ */
+export declare function isPodAccessFailure(message: string): boolean;