mppx 0.17.0 → 0.17.3

package/dist/cli/sessions/Manager.js

@@ -1,4 +1,5 @@
 import * as Challenge from '../../Challenge.js';
+import * as ProofRealm from '../../client/internal/ProofRealm.js';
 import { resolveEscrow } from '../../tempo/session/client/ChannelOps.js';
 import { getSessionManagerInternals } from '../../tempo/session/client/internal/SessionManager.js';
 import { sessionManager } from '../../tempo/session/client/SessionManager.js';
@@ -25,6 +26,14 @@ function assertCloseChallengeScope(challenge, channel) {
 /** Rehydrates durable session context and cooperatively closes it through the manager. */
 export async function closeWithSessionManager(parameters) {
     assertCloseChallengeScope(parameters.challenge, parameters.channel);
+    let channel = parameters.channel;
+    if (channel.origin === undefined) {
+        const url = new URL(parameters.input instanceof Request ? parameters.input.url : parameters.input);
+        if (!['http:', 'https:'].includes(url.protocol))
+            throw new Error('Legacy session close requires an HTTP origin');
+        ProofRealm.assert(parameters.challenge, url, parameters.manager.trustedTempoProofRealms);
+        channel = { ...channel, origin: url.origin };
+    }
     const networkFetch = resolveFetch(parameters.fetch);
     let pendingChallenge;
     const validatedFetch = async (input, init) => {
@@ -48,7 +57,9 @@ export async function closeWithSessionManager(parameters) {
         escrow: parameters.channel.escrow,
         fetch: validatedFetch,
     });
-    getSessionManagerInternals(manager).rehydrate(parameters);
+    getSessionManagerInternals(manager).rehydrate({ ...parameters, channel });
+    if (channel !== parameters.channel)
+        await parameters.manager.channelStore?.set(channel);
     const receipt = await manager.close();
     if (!receipt)
         throw new Error('Session close response did not include a payment receipt.');

package/dist/cli/sessions/store.js

@@ -33,6 +33,7 @@ export class SessionBusyError extends Error {
     }
 }
 const storedChannelSchema = z.object({
+    origin: z.optional(z.string()),
     channelId: z.hash(),
     cumulativeAmount: z.string(),
     deposit: z.string(),
@@ -183,6 +184,11 @@ export function createSessionRegistry(options = {}) {
         const previous = previousValue === undefined ? undefined : parseStoredSession(previousValue, file);
         if (previous)
             assertSameSession(previous, input, file);
+        const origin = previous?.channel.origin ?? channel.origin;
+        if (previous?.channel.origin && channel.origin && previous.channel.origin !== channel.origin)
+            throw stateError(file, 'Session payment origin mismatch.');
+        if (origin !== undefined && new URL(origin).origin !== origin)
+            throw stateError(file, 'Session payment origin must be a normalized origin.');
         const challenge = parseSessionChallenge(input.challenge, file);
         assertChallengeMatchesChannel(challenge, channel, file);
         const receipt = input.receipt
@@ -193,7 +199,7 @@ export function createSessionRegistry(options = {}) {
         const spent = maxBigInt(input.spent ?? 0n, receipt ? BigInt(receipt.spent) : 0n, previous ? BigInt(previous.spent) : 0n);
         if (spent > cumulativeAmount)
             throw stateError(file, 'Session spend exceeds the locally authorized cumulative amount.');
-        const storedChannel = sanitizeStoredChannel(serializeEntry({ ...channel, cumulativeAmount }), file);
+        const storedChannel = sanitizeStoredChannel(serializeEntry({ ...channel, cumulativeAmount, ...(origin !== undefined && { origin }) }), file);
         const timestamp = monotonicTimestamp(previous?.updatedAt, now(), file);
         const latestReceipt = selectLatestReceipt(previous?.receipt, receipt);
         const account = sanitizeAccount(input.account, file);

package/dist/cli/utils.d.ts

@@ -58,6 +58,8 @@ export declare function fmtRequestValue(key: string, value: unknown, ctx: {
 }): string;
 export declare function decodeMemo(hex: string): string | undefined;
 export declare function fmtChallengeValue(key: string, value: unknown): string;
+/** Formats a problem-details field for display, serializing nested objects and arrays as JSON. */
+export declare function fmtProblemValue(value: unknown): string;
 export declare function link(url: string, text: string): string;
 export declare function parseMethodOpts(raw: string | string[] | undefined): Record<string, string>;
 /** Returns true when the CLI is running inside an agent wrapper that prefers machine-readable output. */

package/dist/cli/utils.js

@@ -141,6 +141,12 @@ export function fmtChallengeValue(key, value) {
     }
     return String(value);
 }
+/** Formats a problem-details field for display, serializing nested objects and arrays as JSON. */
+export function fmtProblemValue(value) {
+    if (value !== null && typeof value === 'object')
+        return JSON.stringify(value);
+    return String(value);
+}
 export function link(url, text) {
     return pc.link(url, text);
 }

package/dist/cli/validate/helpers.d.ts

@@ -37,7 +37,7 @@ export type Counts = {
     skipped: number;
 };
 export declare function printResults(results: CheckResult[], counts: Counts): void;
-/** Fetches the validation target without allowing it to redirect probes elsewhere. */
+/** Fetches a validation target without automatic payments or redirected probes. */
 export declare function fetchWithTimeout(url: RequestInfo | URL, init: RequestInit, timeoutMs?: number): Promise<Response>;
 export declare function formatBytes(bytes: number): string;
 export declare const HTTP_METHODS: Set<string>;

package/dist/cli/validate/helpers.js

@@ -1,3 +1,4 @@
+import { identityOf, skipPayment, unwrapFetch } from '../../client/internal/Fetch.js';
 import { pc } from '../utils.js';
 export function check(label, detail) {
     return detail ? { label, detail, severity: 'pass' } : { label, severity: 'pass' };
@@ -57,12 +58,23 @@ export function printResults(results, counts) {
             counts.skipped++;
     }
 }
-/** Fetches the validation target without allowing it to redirect probes elsewhere. */
+/** Fetches a validation target without automatic payments or redirected probes. */
 export async function fetchWithTimeout(url, init, timeoutMs = 15_000) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        return await fetch(url, { ...init, redirect: 'error', signal: controller.signal });
+        const fetch = globalThis.fetch;
+        const base = unwrapFetch(fetch);
+        const identity = identityOf(fetch);
+        const options = {
+            [skipPayment]: true,
+            ...init,
+            redirect: 'error',
+            signal: controller.signal,
+        };
+        return identity
+            ? (await identity.send((input, init) => base(input, { ...init, [skipPayment]: true }), new Request(url, options))).response
+            : await base(url, options);
     }
     finally {
         clearTimeout(timeout);

package/dist/client/Mppx.d.ts

@@ -189,7 +189,7 @@ export declare namespace create {
         /** Transport to use (defaults to HTTP). */
         transport?: transport | undefined;
         /**
-         * Server origins allowed to request zero-amount Tempo proofs for a realm other than their
+         * Server origins allowed to request zero-amount Tempo proofs or session payments for a realm other than their
          * hostname, mapped to that realm, such as `{ 'https://api.example.com': 'MPP Payment' }`.
          * With `Transport.mcp()`, which has no origin, only realms listed here are trusted,
          * whatever their origin.

package/dist/client/Mppx.js

@@ -4,6 +4,7 @@ import * as IdentityClient from '../identity/Client.js';
 import * as AcceptPayment from '../internal/AcceptPayment.js';
 import * as Fetch from './internal/Fetch.js';
 import * as MethodChallenge from './internal/MethodChallenge.js';
+import * as MethodResponse from './internal/MethodResponse.js';
 import * as ProofRealm from './internal/ProofRealm.js';
 import * as Transport from './Transport.js';
 const preparedPaymentMethods = new WeakMap();
@@ -71,7 +72,10 @@ export function create(config) {
     function onPaymentResponse(handler) {
         return events.on('payment.response', handler);
     }
-    async function preparePayment(response, options) {
+    async function preparePayment(response, options, 
+    // Credential context known before selection, such as an explicit session close passed to
+    // `createCredential`, so methods can accept offers they would otherwise skip.
+    selectionContext) {
         const eventResponse = snapshotResponse(response);
         const challenges = await transport.getChallenges(response, options?.request);
         const challengeSnapshots = Object.freeze(challenges.map((candidate) => snapshotValue(candidate)));
@@ -79,7 +83,12 @@ export function create(config) {
         let challenge;
         let mi;
         try {
-            const candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, preferences);
+            let candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, preferences, selectionContext);
+            // Without a context yet, as in `preparePayment(response).createCredential(context)`, fall back
+            // to offers a method skips only by policy: an explicit close may still use them, and the
+            // method enforces the policy for anything else when the credential is created.
+            if (candidates.length === 0 && selectionContext === undefined)
+                candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, preferences, AcceptPayment.deferredContext);
             const orderedCandidates = await resolveChallengeOrder(candidates, options?.orderChallenges ?? orderChallenges);
             const selected = orderedCandidates[0];
             if (!selected)
@@ -104,7 +113,7 @@ export function create(config) {
                 try {
                     if (selectedChallenge.expires)
                         Expires.assert(selectedChallenge.expires, selectedChallenge.id);
-                    const createCredential = memoizeCreateCredential((overrideContext) => createCredentialForMethod(selectedChallenge, selectedMethod, overrideContext ?? context));
+                    const createCredential = memoizeCreateCredential((overrideContext) => createCredentialForMethod(selectedChallenge, selectedMethod, overrideContext ?? context, responseUrl?.origin));
                     const eventCredential = await events.emit('challenge.received', createChallengeReceivedPayload({
                         challenge: selectedChallenge,
                         challenges,
@@ -237,7 +246,7 @@ export function create(config) {
         preparePayment,
         prepareRequest: prepareRequest,
         async createCredential(response, context, options) {
-            const prepared = await preparePayment(response, options);
+            const prepared = await preparePayment(response, options, context);
             return prepared.createCredential(context);
         },
     };
@@ -474,9 +483,12 @@ function resolveChallengePreferences(fallback, override) {
 async function resolveChallengeOrder(candidates, orderChallenges) {
     return orderChallenges ? orderChallenges(candidates) : candidates;
 }
-async function createCredentialForMethod(challenge, mi, context) {
+async function createCredentialForMethod(challenge, mi, context, origin) {
     const parsedContext = mi.context && context !== undefined ? mi.context.parse(context) : undefined;
-    return mi.createCredential(parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge });
+    const parameters = parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge };
+    if (origin)
+        MethodResponse.attachOrigin(parameters, origin);
+    return mi.createCredential(parameters);
 }
 /** Returns the URL of the HTTP server that sent `response`, or `undefined` when it has none. */
 function resolveResponseUrl(response) {

package/dist/client/internal/Fetch.d.ts

@@ -6,6 +6,8 @@ import type * as Method from '../../Method.js';
 import type * as z from '../../zod.js';
 import * as Transport from '../Transport.js';
 import * as ProofRealm from './ProofRealm.js';
+/** Per-request payment opt-out preserved by forwarding fetch layers. @internal */
+export declare const skipPayment: unique symbol;
 export type ClientEventMap<methods extends readonly Method.AnyClient[] = readonly Method.AnyClient[], response = Response> = {
     'challenge.received': ChallengeReceivedPayload<methods, response>;
     'credential.created': CredentialCreatedPayload<methods, response>;
@@ -114,7 +116,7 @@ export declare namespace from {
         /** Transport to use for challenge extraction and credential attachment. */
         transport?: Transport.AnyTransport | undefined;
         /**
-         * Server origins allowed to request zero-amount Tempo proofs for a realm other than their
+         * Server origins allowed to request zero-amount Tempo proofs or session payments for a realm other than their
          * hostname, mapped to that realm, such as `{ 'https://api.example.com': 'MPP Payment' }`.
          */
         trustedTempoProofRealms?: ProofRealm.TrustedRealms | undefined;

package/dist/client/internal/Fetch.js

@@ -8,12 +8,15 @@ import * as Transport from '../Transport.js';
 import * as MethodChallenge from './MethodChallenge.js';
 import * as MethodResponse from './MethodResponse.js';
 import * as ProofRealm from './ProofRealm.js';
+import { adapterOwnsPayment } from './protocols/Mcp.js';
 // We tag wrappers with a global symbol so we can recognize wrappers created by mppx,
 // even across multiple module instances/bundles. This lets restore() avoid clobbering
 // an unrelated fetch installed by user code or another library.
 const MPPX_FETCH_WRAPPER = Symbol.for('mppx.fetch.wrapper');
 /** Identity runner of an mppx fetch wrapper, inherited when that wrapper is wrapped again. */
 const MPPX_FETCH_IDENTITY = Symbol.for('mppx.fetch.identity');
+/** Per-request payment opt-out preserved by forwarding fetch layers. @internal */
+export const skipPayment = Symbol.for('mppx.fetch.skipPayment');
 const defaultMaxPaymentRetries = 3;
 const maxErrorBodyBytes = 64 * 1024;
 const errorBodyTimeoutMs = 2_000;
@@ -125,6 +128,10 @@ export function from(config) {
         const initialRequest = prepareInitialRequest(input, init, callerHeaders, paymentPreferences.header, hasExplicitAcceptPayment, acceptPaymentPolicy);
         let response = await send(cloneRequestInput(initialRequest.input), initialRequest.init);
         const transportRequest = withCapturedBody(initialRequest.init, await capturedBody);
+        if (init?.[skipPayment])
+            return response;
+        if (adapterOwnsPayment(transportRequest))
+            return response;
         if (!(await transport.isPaymentRequired(response, transportRequest)))
             return response;
         // Only extract context for payment handling after confirming 402.
@@ -139,7 +146,7 @@ export function from(config) {
         try {
             for (let retry = 0; retry < maxPaymentRetries; retry++) {
                 challenges = await transport.getChallenges(response, transportRequest);
-                const candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, paymentPreferences.entries);
+                const candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, paymentPreferences.entries, context);
                 const orderedCandidates = await resolveChallengeOrder(candidates, requestOrderChallenges ??
                     orderChallenges);
                 const selected = orderedCandidates[0];
@@ -161,7 +168,7 @@ export function from(config) {
                 if (challenge.expires)
                     Expires.assert(challenge.expires, challenge.id);
                 await identity?.challenge(response, { challenge: selectedChallenge }, resolveRequestUrl(initialRequest.input).href);
-                const paymentInput = resolvePaymentRetryInput(response, initialRequest.input, initialRequest.input);
+                const paymentInput = await resolvePaymentRetryInput(response, initialRequest.input, initialRequest.input, fetchInit);
                 ProofRealm.assert(selectedChallenge, () => resolveRequestUrl(paymentInput), trustedTempoProofRealms);
                 const previousCredential = preparedCredential;
                 const key = Challenge.serialize(selectedChallenge);
@@ -184,10 +191,13 @@ export function from(config) {
                         await settleAttempt(previousCredential, { status: 'rejected' });
                         preparedCredential = undefined;
                     }
+                    // A new payment must not start for a request the caller already aborted.
+                    resolveRequestSignal(input, init)?.throwIfAborted();
                     const credentialContext = overrideContext ?? context;
                     if (!MethodChallenge.has(selected.method))
                         return resolveCredential(selectedChallenge, selected.method, credentialContext);
                     const attempt = {
+                        origin: resolveRequestUrl(paymentInput).origin,
                         prepare: () => MethodChallenge.handle(selected.method, {
                             challenge: selectedChallenge,
                             context: credentialContext,
@@ -205,6 +215,7 @@ export function from(config) {
                         .prepare()
                         .then(() => resolveCredential(selectedChallenge, selected.method, credentialContext, attempt));
                     preparedCredential = {
+                        context: credentialContext,
                         attempt,
                         key: overrideContext === undefined ? key : undefined,
                         method: selected.method,
@@ -233,6 +244,7 @@ export function from(config) {
                     await settleAttempt(prepared, { status: 'rejected' });
                     preparedCredential = undefined;
                 }
+                const effectiveContext = preparedCredential ? preparedCredential.context : context;
                 validateCredentialHeaderValue(credential);
                 await events.emit('credential.created', createCredentialCreatedPayload({
                     challenge: selectedChallenge,
@@ -316,6 +328,7 @@ export function from(config) {
                     if (!response.ok)
                         return response;
                     return MethodResponse.handle(selected.method, {
+                        context: effectiveContext,
                         challenge: selectedChallenge,
                         credential,
                         fetch: baseFetch,
@@ -747,6 +760,8 @@ export function validateCredentialHeaderValue(credential) {
 async function resolveCredential(challenge, mi, context, attempt) {
     const parsedContext = mi.context && context !== undefined ? mi.context.parse(context) : undefined;
     const parameters = parsedContext !== undefined ? { challenge, context: parsedContext } : { challenge };
+    if (attempt?.origin)
+        MethodResponse.attachOrigin(parameters, attempt.origin);
     if (attempt)
         MethodResponse.attachAttempt(mi, parameters, attempt);
     return mi.createCredential(parameters);
@@ -807,7 +822,21 @@ function resolveRequestUrl(input) {
         return new URL(input.url);
     return new URL(input, isBrowser() ? globalThis.location.href : undefined);
 }
-function resolvePaymentRetryInput(response, fallback, initialInput) {
+/** Rejects Request modes whose paid retry cannot carry a credential to the server. */
+function assertPayableRequest(input, init) {
+    const request = input instanceof Request ? input : undefined;
+    const mode = init.mode ?? request?.mode;
+    // Fetch strips the Authorization header from no-cors requests.
+    if (mode === 'no-cors')
+        throw new Error('Cannot automatically pay a no-cors request: it cannot carry a credential.');
+    const cache = init.cache ?? request?.cache;
+    // A cache-only retry never reaches the server.
+    if (cache === 'only-if-cached')
+        throw new Error('Cannot automatically pay an only-if-cached request: its retry cannot reach the server.');
+}
+/** Retains Request state while targeting the same-origin challenge response URL. */
+async function resolvePaymentRetryInput(response, fallback, initialInput, init) {
+    assertPayableRequest(fallback, init);
     if (!response.url)
         return fallback;
     const responseUrl = new URL(response.url);
@@ -815,6 +844,42 @@ function resolvePaymentRetryInput(response, fallback, initialInput) {
     if (responseUrl.origin !== initialUrl.origin) {
         throw new Error(`Refusing to send payment credential across redirect from ${initialUrl.origin} to ${responseUrl.origin}`);
     }
+    const method = (init.method ?? (fallback instanceof Request ? fallback.method : 'GET')).toUpperCase();
+    // Fetch does not expose the redirect chain, so a non-GET/HEAD request may
+    // have become a GET before reaching the challenge (301/302/303).
+    if (response.redirected && method !== 'GET' && method !== 'HEAD')
+        throw new Error(`Cannot automatically pay a redirected ${method} request. Use prepareRequest() to preserve redirect semantics.`);
+    if (fallback instanceof Request) {
+        // A replacement body makes a consumed or locked original body irrelevant.
+        // Otherwise retain the original body for any later payment challenges.
+        const source = init.body != null ? fallback : fallback.clone();
+        // User-created requests cannot use navigate mode; retry a navigation as same-origin.
+        const request = new Request(source, fallback.mode === 'navigate' && init.mode === undefined
+            ? { ...init, mode: 'same-origin' }
+            : init);
+        // Fetch never sends a URL fragment, and the response URL has none.
+        if (request.url.split('#')[0] === response.url)
+            return request;
+        if (request.body) {
+            // Retargeting would turn the body into a stream without a length (and keepalive rejects
+            // streams). Retarget a buffered copy so the paid retry keeps its Content-Length.
+            return new Request(response.url, {
+                body: await request.arrayBuffer(),
+                cache: request.cache,
+                credentials: request.credentials,
+                headers: request.headers,
+                integrity: request.integrity,
+                keepalive: request.keepalive,
+                method: request.method,
+                mode: request.mode,
+                redirect: request.redirect,
+                referrer: request.referrer,
+                referrerPolicy: request.referrerPolicy,
+                signal: request.signal,
+            });
+        }
+        return new Request(response.url, request);
+    }
     return response.url;
 }
 //# sourceMappingURL=Fetch.js.map

package/dist/client/internal/MethodResponse.d.ts

@@ -7,6 +7,8 @@ export type AttemptOutcome = {
     status: 'accepted' | 'pending' | 'rejected';
 };
 export type Attempt = {
+    /** Authorized HTTP origin, checked before any credential is signed. */
+    origin?: string | undefined;
     /** Re-runs method preparation when serialized state changed before signing. */
     prepare: () => Promise<void>;
     /** Settles state created for one credential attempt. */
@@ -14,6 +16,8 @@ export type Attempt = {
 };
 /** Inputs available when a client method handles a successful paid response. */
 export type HandlerParameters = {
+    /** Original request policy for automatic follow-up payments. */
+    context?: unknown;
     challenge: Challenge.Challenge;
     credential: string;
     fetch: typeof globalThis.fetch;
@@ -41,4 +45,8 @@ export declare function handle(method: Method.AnyClient, parameters: HandlerPara
 export declare function registerTransactionHash<const method extends Method.AnyClient>(method: method, derive: TransactionHash): method;
 /** Returns the credential's on-chain hash when its method can derive it. */
 export declare function getTransactionHash(method: Method.AnyClient, credential: string): string | undefined;
+/** Associates an explicitly verified HTTP origin with credential creation. */
+export declare function attachOrigin(parameters: object, origin: string): void;
+/** Returns the authorized origin for direct or fetch-owned credential creation. */
+export declare function getOrigin(parameters: object): string | undefined;
 //# sourceMappingURL=MethodResponse.d.ts.map

package/dist/client/internal/MethodResponse.js

@@ -1,5 +1,6 @@
 const handlers = new WeakMap();
 const attempts = new WeakMap();
+const origins = new WeakMap();
 const transactionHashes = new WeakMap();
 /** Registers an internal response adapter without changing the public method shape. */
 export function register(method, handler) {
@@ -38,4 +39,12 @@ export function getTransactionHash(method, credential) {
         return undefined;
     }
 }
+/** Associates an explicitly verified HTTP origin with credential creation. */
+export function attachOrigin(parameters, origin) {
+    origins.set(parameters, origin);
+}
+/** Returns the authorized origin for direct or fetch-owned credential creation. */
+export function getOrigin(parameters) {
+    return origins.get(parameters) ?? attempts.get(parameters)?.origin;
+}
 //# sourceMappingURL=MethodResponse.js.map

package/dist/client/internal/ProofRealm.d.ts

@@ -1,12 +1,12 @@
 import type * as Challenge from '../../Challenge.js';
 /**
- * Pins that let a server origin request zero-amount Tempo proofs for a realm other than its
+ * Pins that let a server origin request zero-amount Tempo proofs or session payments for a realm other than its
  * hostname, keyed by origin (`scheme://host[:port]`), such as
  * `{ 'https://api.example.com': 'MPP Payment' }`.
  */
 export type TrustedRealms = Readonly<Record<string, string>>;
 /**
- * Refuses a zero-amount Tempo proof whose realm the HTTP server that sent the Challenge does not
+ * Refuses a Tempo proof or session payment whose realm the HTTP server that sent the Challenge does not
  * own. A proof authenticates the payer at the Challenge realm, so a foreign origin could otherwise
  * relay another server's Challenge and replay the signed proof there. The server owns the realm
  * when it is the request hostname, or when `trustedRealms` pins it to the request origin. Pass
@@ -14,7 +14,7 @@ export type TrustedRealms = Readonly<Record<string, string>>;
  */
 export declare function assert(challenge: Challenge.Challenge, url: URL | (() => URL), trustedRealms: TrustedRealms | undefined): void;
 /**
- * Refuses a zero-amount Tempo proof on a transport without an origin, such as MCP, unless
+ * Refuses a Tempo proof or session payment on a transport without an origin, such as MCP, unless
  * `trustedRealms` lists its realm.
  */
 export declare function assertWithoutOrigin(challenge: Challenge.Challenge, trustedRealms: readonly string[] | undefined): void;

package/dist/client/internal/ProofRealm.js

@@ -1,12 +1,12 @@
 /**
- * Refuses a zero-amount Tempo proof whose realm the HTTP server that sent the Challenge does not
+ * Refuses a Tempo proof or session payment whose realm the HTTP server that sent the Challenge does not
  * own. A proof authenticates the payer at the Challenge realm, so a foreign origin could otherwise
  * relay another server's Challenge and replay the signed proof there. The server owns the realm
  * when it is the request hostname, or when `trustedRealms` pins it to the request origin. Pass
  * `url` as a function to resolve it only for proof Challenges.
  */
 export function assert(challenge, url, trustedRealms) {
-    if (!isProof(challenge))
+    if (!isProof(challenge) && !(challenge.method === 'tempo' && challenge.intent === 'session'))
         return;
     url = typeof url === 'function' ? url() : url;
     const { realm } = challenge;
@@ -19,11 +19,11 @@ export function assert(challenge, url, trustedRealms) {
     throw new Error(`Refusing to sign Tempo proof for realm ${JSON.stringify(realm)} from ${url.origin}. Pin the realm to this origin with \`trustedTempoProofRealms\` if this server is expected to issue it.`);
 }
 /**
- * Refuses a zero-amount Tempo proof on a transport without an origin, such as MCP, unless
+ * Refuses a Tempo proof or session payment on a transport without an origin, such as MCP, unless
  * `trustedRealms` lists its realm.
  */
 export function assertWithoutOrigin(challenge, trustedRealms) {
-    if (!isProof(challenge))
+    if (!isProof(challenge) && !(challenge.method === 'tempo' && challenge.intent === 'session'))
         return;
     if (trustedRealms?.includes(challenge.realm))
         return;

package/dist/client/internal/protocols/Mcp.d.ts

@@ -1,5 +1,9 @@
 import * as Mcp from '../../../Mcp.js';
 import type { Protocol } from './Protocol.js';
+/** Metadata that delegates all payment decisions to the MCP client adapter. */
+export declare const adapterPaymentMetaKey = "mppx/payment-client";
+/** Whether the caller's MCP adapter owns approval and payment retry for this request. */
+export declare function adapterOwnsPayment(request?: RequestInit): boolean;
 type CorePaymentRequiredData = NonNullable<Mcp.ErrorObject['data']>;
 export type PaymentRequiredData = Pick<CorePaymentRequiredData, 'challenges'> & Partial<Pick<CorePaymentRequiredData, 'httpStatus' | 'problem'>>;
 /** Extracts validated payment-required data from MCP errors or tool result metadata. */

package/dist/client/internal/protocols/Mcp.js

@@ -1,6 +1,6 @@
-import { createParser } from 'eventsource-parser';
 import * as Challenge from '../../../Challenge.js';
 import * as Credential from '../../../Credential.js';
+import { createParser } from '../../../internal/sse.js';
 import * as Mcp from '../../../Mcp.js';
 import { paymentRequiredStatus } from './Shared.js';
 /** Returns the JSON-RPC request id — only requests can receive a `-32042` response. */
@@ -18,6 +18,22 @@ function jsonRpcRequestId(body) {
         return undefined;
     }
 }
+/** Metadata that delegates all payment decisions to the MCP client adapter. */
+export const adapterPaymentMetaKey = 'mppx/payment-client';
+/** Whether the caller's MCP adapter owns approval and payment retry for this request. */
+export function adapterOwnsPayment(request) {
+    if (typeof request?.body !== 'string')
+        return false;
+    try {
+        const message = JSON.parse(request.body);
+        return (message?.jsonrpc === '2.0' &&
+            message?.method === 'tools/call' &&
+            message.params?._meta?.[adapterPaymentMetaKey] === true);
+    }
+    catch {
+        return false;
+    }
+}
 // Bound automatic inspection; the caller retains the original response stream.
 const maxInspectionBytes = 1024 * 1024;
 const responseCache = new WeakMap();
@@ -99,18 +115,16 @@ async function parseSseJsonRpcResponse(response) {
     let received = 0;
     let dataEventSeen = false;
     let message;
-    const parser = createParser({
-        onEvent(event) {
-            if (dataEventSeen || !event.data)
-                return;
-            dataEventSeen = true;
-            if (event.event && event.event !== 'message')
-                return;
-            try {
-                message = parseMessage(JSON.parse(event.data));
-            }
-            catch { }
-        },
+    const parser = createParser((event) => {
+        if (dataEventSeen || !event.data)
+            return;
+        dataEventSeen = true;
+        if (event.event !== 'message')
+            return;
+        try {
+            message = parseMessage(JSON.parse(event.data));
+        }
+        catch { }
     });
     try {
         for (;;) {
@@ -119,7 +133,6 @@ async function parseSseJsonRpcResponse(response) {
             const { done, value } = await reader.read();
             if (done) {
                 parser.feed(decoder.decode());
-                parser.reset({ consume: true });
                 return message;
             }
             received += value.byteLength;

package/dist/identity/Client.js

@@ -1,6 +1,7 @@
 import * as Challenge from '../Challenge.js';
 import * as Credential from '../Credential.js';
 import * as SigningContext from './internal/SigningContext.js';
+const skipPayment = Symbol.for('mppx.fetch.skipPayment');
 /** x402 credential headers (v2 and v1); a request carrying one is a paid attempt. */
 const x402CredentialHeaders = ['payment-signature', 'x-payment'];
 /**
@@ -99,7 +100,12 @@ export function wrapFetch(fetch, client, context) {
         // A retry may answer a refreshed challenge: bind proofs to the challenge its credential
         // carries, and let provers prepare for a refreshed 402 of the same method and intent.
         const challenge = credentialChallenge(request.headers) ?? context?.challenge;
-        const { response } = await client.send(fetch, request, { ...context, challenge });
+        const { response } = await client.send((input, options) => fetch(input, {
+            ...options,
+            ...(init?.[skipPayment]
+                ? { [skipPayment]: true }
+                : {}),
+        }), request, { ...context, challenge });
         if (response.status === 402 && challenge)
             // A 402 without a parseable Payment challenge is returned as is: the caller decides.
             for (const next of challengesOf(response))

package/dist/internal/AcceptPayment.d.ts

@@ -3,10 +3,17 @@ import type { MaybePromise } from './types.js';
 type MethodLike = {
     canHandleChallenge?: ((parameters: {
         challenge: Challenge.Challenge;
+        context?: unknown;
     }) => boolean) | undefined;
     intent: string;
     name: string;
 };
+/**
+ * Selection context for flows that receive the credential context only after an offer is chosen,
+ * such as `preparePayment()`. Methods may accept offers they would otherwise skip by policy and
+ * enforce that policy when the credential is created.
+ */
+export declare const deferredContext: unique symbol;
 /** Supported challenge paired with the configured client method that can sign it. */
 export type ChallengeCandidate<method extends MethodLike = MethodLike> = method extends MethodLike ? {
     challenge: Challenge.Challenge<Record<string, unknown>, method['intent'], method['name']>;
@@ -79,8 +86,11 @@ export declare function selectChallenge<const methods extends readonly MethodLik
     challenge: Challenge.Challenge;
     method: methods[number];
 } | undefined;
-/** Returns supported challenge candidates ordered by client payment preferences. */
-export declare function selectChallengeCandidates<const methods extends readonly MethodLike[]>(challenges: readonly Challenge.Challenge[], methods: methods, preferences: readonly Entry[]): ChallengeCandidate<methods[number]>[];
+/**
+ * Returns supported challenge candidates ordered by client payment preferences.
+ * `context` is the caller's credential context, when known before selection.
+ */
+export declare function selectChallengeCandidates<const methods extends readonly MethodLike[]>(challenges: readonly Challenge.Challenge[], methods: methods, preferences: readonly Entry[], context?: unknown): ChallengeCandidate<methods[number]>[];
 /** Returns the canonical `method/intent` key for a method or challenge-like value. */
 export declare function keyOf(value: {
     intent: string;