mppx 0.9.0 → 0.9.1

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

@@ -77,7 +77,8 @@ export function paymentRequiredData(message) {
     if (!message)
         return undefined;
     if ('error' in message) {
-        if (message.error?.code !== Mcp.paymentRequiredCode)
+        if (message.error?.code !== Mcp.paymentRequiredCode &&
+            message.error?.code !== Mcp.paymentVerificationFailedCode)
             return undefined;
         return paymentRequiredDataFromValue(message.error.data);
     }

package/dist/mcp/client/McpClient.js

@@ -5,6 +5,7 @@ import * as AcceptPayment from '../../internal/AcceptPayment.js';
 import * as core_Mcp from '../../Mcp.js';
 import * as z from '../../zod.js';
 const MPPX_MCP_CLIENT_WRAPPER = Symbol.for('mppx.mcp.client.wrapper');
+const maxPaymentAttempts = 3;
 /**
  * Adds automatic payment handling to an MCP SDK client.
  *
@@ -80,7 +81,8 @@ export function isPaymentRequiredError(error) {
         return false;
     if (!('code' in error) || !('message' in error))
         return false;
-    if (error.code !== core_Mcp.paymentRequiredCode)
+    const code = error.code;
+    if (code !== core_Mcp.paymentRequiredCode && code !== core_Mcp.paymentVerificationFailedCode)
         return false;
     return isPaymentRequiredData(error.data);
 }
@@ -98,7 +100,7 @@ async function createCredential(challenge, config) {
 function createPaymentAwareCallTool(callTool, config) {
     const methods = config.methods.flat();
     const paymentPreferences = AcceptPayment.resolve(methods, config.paymentPreferences);
-    const retryWithPayment = async (params, call, paymentRequired, cause) => {
+    const retryWithPayment = async (params, call, paymentRequired, cause, attemptsRemaining = maxPaymentAttempts) => {
         const challenges = paymentRequired.challenges;
         const candidates = AcceptPayment.selectChallengeCandidates(challenges, methods, paymentPreferences.entries);
         const orderedCandidates = config.orderChallenges
@@ -122,14 +124,24 @@ function createPaymentAwareCallTool(callTool, config) {
             methods,
         });
         const parsed = Credential.deserialize(credential);
-        const retryResult = await callTool({
-            ...params,
-            _meta: {
-                ...params._meta,
-                [core_Mcp.credentialMetaKey]: parsed,
-            },
-        }, call.resultSchema, call.requestOptions);
-        return withReceipt(retryResult);
+        try {
+            const retryResult = await callTool({
+                ...params,
+                _meta: {
+                    ...params._meta,
+                    [core_Mcp.credentialMetaKey]: parsed,
+                },
+            }, call.resultSchema, call.requestOptions);
+            const nextPaymentRequired = getPaymentRequiredMeta(retryResult);
+            if (nextPaymentRequired && attemptsRemaining > 1)
+                return retryWithPayment(params, call, nextPaymentRequired, retryResult, attemptsRemaining - 1);
+            return withReceipt(retryResult);
+        }
+        catch (error) {
+            if (!isPaymentRequiredError(error) || attemptsRemaining <= 1)
+                throw error;
+            return retryWithPayment(params, call, error.data, error, attemptsRemaining - 1);
+        }
     };
     return async (params, call) => {
         try {

package/dist/mcp/server/Transport.d.ts

@@ -1,5 +1,5 @@
 import type { CallToolResult, McpError } from '@modelcontextprotocol/sdk/types.js';
-import type * as Credential from '../../Credential.js';
+import * as Credential from '../../Credential.js';
 import * as core_Mcp from '../../Mcp.js';
 import * as Transport from '../../server/Transport.js';
 /**
@@ -18,7 +18,7 @@ export type McpSdk = Transport.Transport<Extra, McpError, CallToolResult>;
  * MCP SDK transport for server-side payment handling with `@modelcontextprotocol/sdk`.
  *
  * - Reads credentials from `_meta["org.paymentauth/credential"]`
- * - Issues challenges as `McpError` with code `-32042` and challenge in `error.data`
+ * - Maps payment errors to their specification-defined JSON-RPC codes
  * - Attaches receipts via `_meta["org.paymentauth/receipt"]` on tool results
  *
  * @example

package/dist/mcp/server/Transport.js

@@ -1,3 +1,4 @@
+import * as Credential from '../../Credential.js';
 import * as core_Mcp from '../../Mcp.js';
 import * as Transport from '../../server/Transport.js';
 import * as McpCredential from '../internal/Credential.js';
@@ -5,7 +6,7 @@ import * as McpCredential from '../internal/Credential.js';
  * MCP SDK transport for server-side payment handling with `@modelcontextprotocol/sdk`.
  *
  * - Reads credentials from `_meta["org.paymentauth/credential"]`
- * - Issues challenges as `McpError` with code `-32042` and challenge in `error.data`
+ * - Maps payment errors to their specification-defined JSON-RPC codes
  * - Attaches receipts via `_meta["org.paymentauth/receipt"]` on tool results
  *
  * @example
@@ -41,7 +42,13 @@ export function mcpSdk() {
             };
         },
         getCredential(extra) {
-            return McpCredential.parse(extra._meta?.[core_Mcp.credentialMetaKey])?.value ?? null;
+            const value = extra._meta?.[core_Mcp.credentialMetaKey];
+            if (value === undefined)
+                return null;
+            const parsed = McpCredential.parse(value);
+            if (!parsed)
+                throw new Credential.InvalidCredentialEncodingError();
+            return parsed.value;
         },
         async respondChallenge({ challenge, error }) {
             if (!McpErrorClass) {
@@ -55,8 +62,8 @@ export function mcpSdk() {
                     throw err;
                 }
             }
-            return new McpErrorClass(core_Mcp.paymentRequiredCode, error?.message ?? 'Payment Required', {
-                httpStatus: 402,
+            return new McpErrorClass(core_Mcp.errorCode(error), error?.message ?? 'Payment Required', {
+                httpStatus: error?.status ?? 402,
                 challenges: [challenge],
                 ...(error && { problem: error.toProblemDetails(challenge.id) }),
             });

package/dist/server/Mppx.d.ts

@@ -99,7 +99,13 @@ export type PaymentSuccessContext<method extends Method.Method = Method.Method,
     input?: Transport.InputOf<transport> | undefined;
     method: ServerMethodDescriptor<method>;
     receipt: Receipt.Receipt;
+    /** Canonical request represented by the challenge. */
     request: z.output<method['schema']['request']>;
+    /**
+     * Resolved method input before request-schema output transforms. Absent during
+     * standalone credential verification when no route options are supplied.
+     */
+    requestInput?: z.input<method['schema']['request']> | undefined;
 }>;
 /** Options for standalone credential verification. */
 export type VerifyCredentialOptions = {

package/dist/server/Mppx.js

@@ -73,6 +73,7 @@ export function create(config) {
                         input: ctx.input,
                         receipt: ctx.receipt,
                         request: ctx.request,
+                        ...(ctx.requestInput !== undefined && { requestInput: ctx.requestInput }),
                     });
                 }
             }));
@@ -280,6 +281,7 @@ export function create(config) {
             parsedCredential,
             parsedRequest,
             request,
+            requestInput: shouldValidateRoute ? request : undefined,
         };
     }
     async function validateCredentialFn(input, options) {
@@ -293,7 +295,7 @@ export function create(config) {
     // broadcastCredential: single-call end-to-end validation and broadcast
     async function broadcastCredentialFn(input, options) {
         const prepared = await prepareStandaloneCredential(input, options, { emitFailures: true });
-        const { method: mi, parsedCredential, parsedRequest, request, envelope } = prepared;
+        const { method: mi, parsedCredential, parsedRequest, request, requestInput, envelope, } = prepared;
         const emitStandalonePaymentFailed = async (parameters) => {
             await serverEvents.emit('payment.failed', createPaymentFailedContext({
                 capturedRequest: options?.capturedRequest,
@@ -313,7 +315,7 @@ export function create(config) {
             receipt = await broadcast({ credential: parsedCredential, envelope, request });
         }
         catch (e) {
-            const error = e instanceof Errors.PaymentError ? e : new Errors.VerificationFailedError();
+            const error = e instanceof Errors.PaymentError ? e : new Errors.InternalPaymentError();
             await emitStandalonePaymentFailed({
                 challenge: prepared.credential.challenge,
                 credential: parsedCredential,
@@ -331,6 +333,7 @@ export function create(config) {
             method: mi,
             receipt,
             request: parsedRequest,
+            ...(requestInput !== undefined && { requestInput }),
         }));
         return receipt;
     }
@@ -548,7 +551,11 @@ function createMethodFn(parameters) {
             // Credential was provided but malformed
             if (credentialError) {
                 const reason = getSafeCredentialReason(credentialError);
-                const error = new Errors.MalformedCredentialError(reason ? { reason } : {});
+                const error = credentialError instanceof Errors.PaymentError
+                    ? credentialError
+                    : reason
+                        ? new Errors.MalformedCredentialError({ reason })
+                        : new Errors.InternalPaymentError();
                 await emitPaymentFailed({
                     challenge,
                     credential: null,
@@ -610,6 +617,7 @@ function createMethodFn(parameters) {
                                 method,
                                 receipt: authorized.receipt,
                                 request: parsedRequest,
+                                requestInput: request,
                             }));
                             return success(authorized.receipt, {
                                 managementResponse: authorized.response,
@@ -619,7 +627,7 @@ function createMethodFn(parameters) {
                     catch (e) {
                         if (!(e instanceof Errors.PaymentError))
                             console.error('mppx: internal authorization error', e);
-                        const error = e instanceof Errors.PaymentError ? e : new Errors.VerificationFailedError();
+                        const error = e instanceof Errors.PaymentError ? e : new Errors.InternalPaymentError();
                         await emitPaymentFailed({
                             challenge,
                             credential: null,
@@ -792,7 +800,7 @@ function createMethodFn(parameters) {
             catch (e) {
                 if (!(e instanceof Errors.PaymentError))
                     console.error('mppx: internal verification error', e);
-                const error = e instanceof Errors.PaymentError ? e : new Errors.VerificationFailedError();
+                const error = e instanceof Errors.PaymentError ? e : new Errors.InternalPaymentError();
                 await emitPaymentFailed({
                     challenge,
                     credential: parsedCredential,
@@ -832,6 +840,7 @@ function createMethodFn(parameters) {
                 method,
                 receipt: receiptData,
                 request: parsedRequest,
+                requestInput: request,
             }));
             return success(receiptData, {
                 challengeId: credential.challenge.id,
@@ -991,6 +1000,9 @@ function createPaymentSuccessContext(parameters) {
         method: snapshotMethod(parameters.method),
         receipt: snapshotValue(parameters.receipt),
         request: snapshotValue(parameters.request),
+        ...(parameters.requestInput !== undefined && {
+            requestInput: snapshotValue(parameters.requestInput),
+        }),
     });
 }
 function snapshotMethod(method) {
@@ -1035,8 +1047,65 @@ function snapshotValue(value) {
         return freezeSnapshot(structuredClone(value));
     }
     catch {
-        return freezeSnapshot(value);
+        return freezeSnapshot(cloneSnapshotFallback(value));
+    }
+}
+/**
+ * Copies object containers when `structuredClone` rejects callable values.
+ * Functions remain callable references, while their containing request data is
+ * detached so snapshot freezing and nested writes cannot affect hook-owned
+ * objects.
+ */
+function cloneSnapshotFallback(value, seen = new WeakMap()) {
+    if (!value || typeof value !== 'object')
+        return value;
+    const existing = seen.get(value);
+    if (existing)
+        return existing;
+    if (value instanceof Date)
+        return new Date(value);
+    if (value instanceof RegExp)
+        return new RegExp(value.source, value.flags);
+    if (value instanceof URL)
+        return new URL(value);
+    if (value instanceof Headers)
+        return new Headers(value);
+    if (value instanceof ArrayBuffer)
+        return value.slice(0);
+    if (ArrayBuffer.isView(value)) {
+        const buffer = new Uint8Array(value.buffer, value.byteOffset, value.byteLength).slice().buffer;
+        if (value instanceof DataView)
+            return new DataView(buffer);
+        const Constructor = value.constructor;
+        return new Constructor(buffer);
+    }
+    if (value instanceof Map) {
+        const snapshot = new Map();
+        seen.set(value, snapshot);
+        for (const [key, entry] of value)
+            snapshot.set(cloneSnapshotFallback(key, seen), cloneSnapshotFallback(entry, seen));
+        return snapshot;
+    }
+    if (value instanceof Set) {
+        const snapshot = new Set();
+        seen.set(value, snapshot);
+        for (const entry of value)
+            snapshot.add(cloneSnapshotFallback(entry, seen));
+        return snapshot;
+    }
+    const snapshot = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value));
+    seen.set(value, snapshot);
+    for (const key of Reflect.ownKeys(value)) {
+        if (Array.isArray(value) && key === 'length')
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+            continue;
+        if ('value' in descriptor)
+            descriptor.value = cloneSnapshotFallback(descriptor.value, seen);
+        Object.defineProperty(snapshot, key, descriptor);
     }
+    return snapshot;
 }
 function snapshotInputProperty(input) {
     if (input === undefined)

package/dist/server/Transport.js

@@ -1,8 +1,8 @@
 import * as Challenge from '../Challenge.js';
 import * as Constants from '../Constants.js';
 import * as Credential from '../Credential.js';
-import * as Errors from '../Errors.js';
 import * as core_Mcp from '../Mcp.js';
+import * as McpCredential from '../mcp/internal/Credential.js';
 import * as Receipt from '../Receipt.js';
 import * as Html from './internal/html/config.js';
 import { serviceWorker } from './internal/html/serviceWorker.gen.js';
@@ -147,17 +147,20 @@ export function mcp() {
         },
         getCredential(request) {
             const meta = request.params?._meta;
-            const credential = meta?.[core_Mcp.credentialMetaKey];
-            if (!credential)
+            const value = meta?.[core_Mcp.credentialMetaKey];
+            if (value === undefined)
                 return null;
-            return credential;
+            const parsed = McpCredential.parse(value);
+            if (!parsed)
+                throw new Credential.InvalidCredentialEncodingError();
+            return parsed.value;
         },
         respondChallenge({ challenge, input, error }) {
             return {
                 jsonrpc: '2.0',
                 id: input.id,
                 error: {
-                    code: mcpErrorCode(error),
+                    code: core_Mcp.errorCode(error),
                     message: error?.message ?? 'Payment Required',
                     data: {
                         httpStatus: error?.status ?? 402,
@@ -187,16 +190,6 @@ export function mcp() {
         },
     });
 }
-/** @internal */
-function mcpErrorCode(error) {
-    if (!error)
-        return core_Mcp.paymentRequiredCode;
-    if (error instanceof Errors.MalformedCredentialError)
-        return -32602;
-    if (error instanceof Errors.PaymentRequiredError)
-        return core_Mcp.paymentRequiredCode;
-    return core_Mcp.paymentVerificationFailedCode;
-}
 export function safeUrl(url) {
     try {
         if (url instanceof URL)

package/dist/stripe/Methods.d.ts

@@ -22,6 +22,9 @@ export declare const charge: {
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
             networkId: z.ZodMiniString<string>;
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniObject<{
+                metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            }, z.core.$strip>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -43,6 +46,9 @@ export declare const charge: {
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                metadata: Record<string, string>;
+            } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;

package/dist/stripe/Methods.js

@@ -1,6 +1,7 @@
 import { parseUnits } from 'viem';
 import * as Method from '../Method.js';
 import * as z from '../zod.js';
+import * as PaymentIntent from './internal/payment-intent.js';
 /**
  * Stripe charge intent for one-time payments via Shared Payment Tokens (SPTs).
  *
@@ -24,9 +25,10 @@ export const charge = Method.from({
             externalId: z.optional(z.string()),
             metadata: z.optional(z.record(z.string(), z.string())),
             networkId: z.string(),
+            paymentIntentOptions: z.optional(PaymentIntent.Schema),
             paymentMethodTypes: z.array(z.string()).check(z.minLength(1)),
             recipient: z.optional(z.string()),
-        }), z.transform(({ amount, decimals, metadata, networkId, paymentMethodTypes, ...rest }) => ({
+        }), z.transform(({ amount, decimals, metadata, networkId, paymentIntentOptions: _, paymentMethodTypes, ...rest }) => ({
             ...rest,
             amount: parseUnits(amount, decimals).toString(),
             methodDetails: {

package/dist/stripe/client/Charge.d.ts

@@ -55,6 +55,9 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
             networkId: z.ZodMiniString<string>;
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniObject<{
+                metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            }, z.core.$strip>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -76,6 +79,9 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                metadata: Record<string, string>;
+            } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;

package/dist/stripe/client/Methods.d.ts

@@ -42,6 +42,9 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
             externalId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             metadata: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>>;
             networkId: import("zod/mini").ZodMiniString<string>;
+            paymentIntentOptions: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniObject<{
+                metadata: import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>;
+            }, import("zod/v4/core").$strip>>;
             paymentMethodTypes: import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniString<string>>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
@@ -63,6 +66,9 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                metadata: Record<string, string>;
+            } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;

package/dist/stripe/internal/payment-intent.d.ts

@@ -0,0 +1,7 @@
+import * as z from '../../zod.js';
+/** Stripe PaymentIntent options accepted only by server-side method input. */
+export declare const Schema: z.ZodMiniObject<{
+    metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+}, z.core.$strip>;
+export type Options = z.infer<typeof Schema>;
+//# sourceMappingURL=payment-intent.d.ts.map

package/dist/stripe/internal/payment-intent.js

@@ -0,0 +1,6 @@
+import * as z from '../../zod.js';
+/** Stripe PaymentIntent options accepted only by server-side method input. */
+export const Schema = z.object({
+    metadata: z.record(z.string(), z.string()),
+});
+//# sourceMappingURL=payment-intent.js.map

package/dist/stripe/server/Charge.d.ts

@@ -49,6 +49,9 @@ export declare function charge<const parameters extends charge.Parameters>(param
             externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
             metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
             networkId: z.ZodMiniString<string>;
+            paymentIntentOptions: z.ZodMiniOptional<z.ZodMiniObject<{
+                metadata: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>;
+            }, z.core.$strip>>;
             paymentMethodTypes: z.ZodMiniArray<z.ZodMiniString<string>>;
             recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
         }, z.core.$strip>, z.ZodMiniTransform<{
@@ -70,6 +73,9 @@ export declare function charge<const parameters extends charge.Parameters>(param
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                metadata: Record<string, string>;
+            } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;

package/dist/stripe/server/Charge.js

@@ -117,13 +117,14 @@ export function charge(parameters) {
         onPaymentSuccess,
         async verify({ credential, envelope, request }) {
             const { challenge } = credential;
+            const { paymentIntentOptions, ...methodRequest } = request;
             const resolvedRequest = (() => {
-                const parsed = Methods.charge.schema.request.safeParse(request);
+                const parsed = Methods.charge.schema.request.safeParse(methodRequest);
                 if (parsed.success)
                     return parsed.data;
                 // verifyCredential() passes the HMAC-bound challenge request, which is
                 // already in canonical output form and should not be transformed again.
-                return request;
+                return methodRequest;
             })();
             Expires.assert(challenge.expires, challenge.id);
             const parsed = Methods.charge.schema.credential.payload.safeParse(credential.payload);
@@ -138,7 +139,11 @@ export function charge(parameters) {
                 });
             }
             const userMetadata = resolvedRequest.methodDetails?.metadata;
-            const resolvedMetadata = { ...buildAnalytics({ credential }), ...userMetadata };
+            const resolvedMetadata = {
+                ...buildAnalytics({ credential }),
+                ...userMetadata,
+                ...paymentIntentOptions?.metadata,
+            };
             const settlement = validateConnectSettlement({
                 amount: resolvedRequest.amount,
                 settlement: typeof connect === 'function'

package/dist/stripe/server/Methods.js

@@ -3,6 +3,8 @@ import { charge as evmCharge } from '../../evm/server/Charge.js';
 import * as tempoDefaults from '../../tempo/internal/defaults.js';
 import { charge as tempoCharge } from '../../tempo/server/Charge.js';
 import { session as tempoSession } from '../../tempo/session/server/Session.js';
+import * as z from '../../zod.js';
+import * as PaymentIntent from '../internal/payment-intent.js';
 import { charge as charge_ } from './Charge.js';
 import { findOrCreateDepositAddress as _findOrCreateDepositAddress } from './internal/deposit-address.js';
 import { recordCryptoPayment } from './internal/record-payment.js';
@@ -96,14 +98,14 @@ export function stripe(parameters) {
         const handler = callMetadata
             ? createPaymentSuccessHandler(client, 'tempo', connect, { ...metadata, ...callMetadata })
             : tempoPaymentHandler;
-        return tempoCharge({
+        return withPaymentIntentInput(tempoCharge({
             currency: tempoCurrency,
             recipient,
             ...(!livemode && { testnet: true }),
             canOffer: cryptoCanOffer,
             onPaymentSuccess: handler,
             ...rest,
-        });
+        }));
     }
     function makeTempoSession(params) {
         const { recipient, ...rest } = params;
@@ -119,14 +121,14 @@ export function stripe(parameters) {
         const handler = callMetadata
             ? createPaymentSuccessHandler(client, 'base', connect, { ...metadata, ...callMetadata })
             : basePaymentHandler;
-        return evmCharge({
+        return withPaymentIntentInput(evmCharge({
             currency: livemode ? EvmAssets.base.USDC : EvmAssets.baseSepolia.USDC,
             recipient,
             x402,
             canOffer: cryptoCanOffer,
             onPaymentSuccess: handler,
             ...rest,
-        });
+        }));
     }
     const defaultMethodBuilders = {
         tempo: (addresses) => {
@@ -180,7 +182,7 @@ export function stripe(parameters) {
                     const canOffer = m.canOffer
                         ? (params) => cryptoCanOffer(params) && m.canOffer(params)
                         : cryptoCanOffer;
-                    result.push({ ...m, canOffer, onPaymentSuccess });
+                    result.push(withPaymentIntentInput({ ...m, canOffer, onPaymentSuccess }));
                 }
             }
         }
@@ -267,16 +269,69 @@ function customRails(additional) {
 }
 function createPaymentSuccessHandler(client, network, connect, metadata) {
     return (params) => {
-        const { receipt, request } = params;
+        const { receipt, request, requestInput } = params;
         if (receipt?.reference && request?.amount) {
+            const resolvedMetadata = {
+                ...metadata,
+                ...requestInput?.paymentIntentOptions?.metadata,
+            };
             return recordCryptoPayment(client, {
                 network,
                 reference: receipt.reference,
                 amount: String(request.amount),
                 ...(connect && { connect }),
-                ...(metadata && { metadata }),
+                ...(Object.keys(resolvedMetadata).length > 0 && { metadata: resolvedMetadata }),
             });
         }
     };
 }
+/**
+ * Extends a rail's server-only input with Stripe PaymentIntent options while
+ * keeping its canonical request unchanged. The schema strips the options
+ * before challenge serialization, and delegated lifecycle hooks receive the
+ * underlying rail request without Stripe-only fields. The wrapper retains the
+ * options only in `requestInput` for payment-success recording.
+ */
+function withPaymentIntentInput(method) {
+    const baseSchema = method.schema.request;
+    const baseRequest = method.request;
+    const baseRespond = method.respond;
+    const baseBroadcast = method.broadcast;
+    const baseValidate = method.validate;
+    const baseVerify = method.verify;
+    return {
+        ...method,
+        // Accept Stripe-only options without changing the canonical rail schema.
+        schema: {
+            ...method.schema,
+            request: z.pipe(z.custom(), z.transform((input) => {
+                const { paymentIntentOptions, ...request } = input;
+                z.optional(PaymentIntent.Schema).parse(paymentIntentOptions);
+                // Only the base schema's output is included in the challenge.
+                return baseSchema.parse(request);
+            })),
+        },
+        async request(context) {
+            const { paymentIntentOptions, ...request } = context.request;
+            const resolved = baseRequest ? await baseRequest({ ...context, request }) : request;
+            return { ...resolved, paymentIntentOptions };
+        },
+        ...(baseRespond && {
+            respond: (context) => baseRespond(withoutPaymentIntentOptions(context)),
+        }),
+        ...(baseBroadcast && {
+            broadcast: (context) => baseBroadcast(withoutPaymentIntentOptions(context)),
+        }),
+        ...(baseValidate && {
+            validate: (context) => baseValidate(withoutPaymentIntentOptions(context)),
+        }),
+        ...(baseVerify && {
+            verify: (context) => baseVerify(withoutPaymentIntentOptions(context)),
+        }),
+    };
+}
+function withoutPaymentIntentOptions(context) {
+    const { paymentIntentOptions: _, ...request } = context.request;
+    return { ...context, request };
+}
 //# sourceMappingURL=Methods.js.map