@undefineds.co/xpod 0.4.14 → 0.4.16

package/config/cloud.json

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

package/config/components-ignore.json

@@ -1,20 +1,32 @@
 [
   "ActivityEmitter",
+  "assertPublicProbeTarget",
+  "base64ByteLength",
   "BaseQuintStore",
   "ClaudeAuthenticationError",
   "CliCommandError",
   "CodeBuddyAuthError",
+  "createPinnedHeadProbeRequest",
+  "createPodOwnershipNodeAccessResolver",
   "DisabledSparqlFeatureError",
   "Error",
   "InvalidRelaySessionRequestError",
   "InvalidTunnelTokenError",
+  "isPublicIpAddress",
   "LEGACY_DERIVED_INDEX_CONSUMER_ID",
   "LOG_FILE_PATTERN",
   "NodeRouteSourceNotFoundError",
+  "normalizeContext",
   "Omit",
+  "P2P_DATA_PLANE_LIMITS",
+  "P2PDataPlaneAbortError",
+  "P2PDataPlaneLimitError",
   "P2PSessionExpiredError",
   "P2PSessionNotFoundError",
   "P2PSignalingRequestError",
+  "registerDeviceNotificationRuntime",
+  "resolveCurrentLogFile",
+  "resolveLogFilePattern",
   "SearchApiError",
   "SolidFsConflictError",
   "SolidFsNotFoundError",
@@ -23,12 +35,5 @@
   "UnsupportedSparqlQueryError",
   "VectorApiError",
   "WaitingRunnerError",
-  "assertPublicProbeTarget",
-  "createPinnedHeadProbeRequest",
-  "createPodOwnershipNodeAccessResolver",
-  "isPublicIpAddress",
-  "normalizeContext",
-  "registerDeviceNotificationRuntime",
-  "resolveCurrentLogFile",
-  "resolveLogFilePattern"
+  "XPOD_P2P_ACCEPT_HEADER"
 ]

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,22 @@
-import type { AuthContext } from '../../auth/AuthContext';
+import type { AuthContext, SolidAuthContext } 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;
+/**
+ * Whether the caller presented a token that is its own Pod credential.
+ *
+ * The token was already verified against the Solid issuer - signature, expiry and owner - and
+ * the owner check below binds it to the Pod being opened, so its origin does not matter: a
+ * caller that holds a valid Bearer token for the owner may use it, whether or not the token
+ * arrived wrapped as `sk-`. What is excluded is a principal Xpod authenticated for itself: a
+ * gateway access key or a runtime invocation token proves the caller to the gateway, not to the
+ * Pod, and forwarding one would turn a gateway credential into Pod access. A DPoP-bound token is
+ * excluded as well, because replaying it needs the caller's private key, which never leaves the
+ * caller.
+ */
+export declare function isCallerOwnPodBearer(owner: string, auth?: AuthContext): auth is SolidAuthContext & {
+    accessToken: string;
+    tokenType: 'Bearer';
+};
+export declare function createCallerAuthenticatedPodFetch(owner: string, auth?: AuthContext, upstream?: typeof fetch, route?: HostedPodRoute): typeof fetch | undefined;

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

@@ -1,20 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CALLER_OWNER_MISMATCH = exports.CALLER_DPOP_REPLAY_UNSUPPORTED = exports.CALLER_POD_ACCESS_UNAVAILABLE = void 0;
+exports.isCallerOwnPodBearer = isCallerOwnPodBearer;
 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) {
-    if (!auth
-        || auth.type !== 'solid'
-        || auth.webId !== owner
-        || auth.viaApiKey !== true
-        || auth.tokenType !== 'Bearer'
-        || typeof auth.accessToken !== 'string'
-        || auth.accessToken.trim() === '') {
+/**
+ * Whether the caller presented a token that is its own Pod credential.
+ *
+ * The token was already verified against the Solid issuer - signature, expiry and owner - and
+ * the owner check below binds it to the Pod being opened, so its origin does not matter: a
+ * caller that holds a valid Bearer token for the owner may use it, whether or not the token
+ * arrived wrapped as `sk-`. What is excluded is a principal Xpod authenticated for itself: a
+ * gateway access key or a runtime invocation token proves the caller to the gateway, not to the
+ * Pod, and forwarding one would turn a gateway credential into Pod access. A DPoP-bound token is
+ * excluded as well, because replaying it needs the caller's private key, which never leaves the
+ * caller.
+ */
+function isCallerOwnPodBearer(owner, auth) {
+    return auth?.type === 'solid'
+        && auth.webId === owner
+        && auth.viaGatewayApiKey !== true
+        && auth.internalInvocation !== true
+        && auth.tokenType === 'Bearer'
+        && typeof auth.accessToken === 'string'
+        && auth.accessToken.trim() !== '';
+}
+function createCallerAuthenticatedPodFetch(owner, auth, upstream = fetch, route) {
+    if (!isCallerOwnPodBearer(owner, auth)) {
         return undefined;
     }
     const accessToken = auth.accessToken;
@@ -30,51 +45,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,15 @@ 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 global_logger_factory_1 = require("global-logger-factory");
+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 +49,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 +137,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,36 +169,19 @@ 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');
+            const reason = (0, OwnerPodAccess_1.podAccessError)(owner, auth);
+            // The reason decides what the user has to do, and it is invisible in the wire response.
+            (0, global_logger_factory_1.getLoggerFor)('PodGatewayAccessKeyRepository').warn(`No Pod fetch for ${owner}: ${reason}`);
+            throw new Error(reason);
         }
-        return this.wrapPodFetch(trustedFetch);
+        return this.wrapPodFetch(trustedFetch, owner);
     }
-    wrapPodFetch(trustedFetch) {
+    wrapPodFetch(trustedFetch, owner) {
         return async (input, init) => {
             // Comunica can inject a malformed content-length value; let the runtime recompute it.
             const headers = new Headers(input instanceof Request ? input.headers : undefined);
@@ -210,6 +191,8 @@ class PodGatewayAccessKeyRepository {
             headers.delete('content-length');
             const response = await trustedFetch(input, { ...init, headers });
             if (response.status === 403) {
+                const url = input instanceof Request ? input.url : String(input);
+                (0, global_logger_factory_1.getLoggerFor)('PodGatewayAccessKeyRepository').warn(`The Pod refused the caller's credential for ${owner}: ${url}`);
                 throw new Error('service_access_missing');
             }
             return response;

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>;