mppx 0.9.0 → 0.9.2

package/dist/cli/plugins/x402.d.ts

@@ -0,0 +1,3 @@
+/** Pays recognized x402 exact EVM challenges with the configured CLI account. */
+export declare function x402(): import("./plugin.js").Plugin;
+//# sourceMappingURL=x402.d.ts.map

package/dist/cli/plugins/x402.js

@@ -0,0 +1,61 @@
+import * as viemChains from 'viem/chains';
+import { evm as evmMethods, assets as evmAssets } from '../../evm/client/index.js';
+import * as Assets from '../../x402/Assets.js';
+import * as x402_ChallengeBrand from '../../x402/internal/ChallengeBrand.js';
+import { resolveAccount } from '../account.js';
+import { createPlugin } from './plugin.js';
+const knownAssets = [
+    ...Object.entries(evmAssets.base),
+    ...Object.entries(evmAssets.baseSepolia),
+    ...Object.entries(evmAssets.celo),
+    ...Object.entries(evmAssets.celoSepolia),
+];
+/** Pays recognized x402 exact EVM challenges with the configured CLI account. */
+export function x402() {
+    return createPlugin({
+        method: 'evm',
+        supports: isSupportedChallenge,
+        async setup({ challenge, options }) {
+            const request = challenge.request;
+            const chain = request.network ? resolveEvmChain(Assets.toChainId(request.network)) : undefined;
+            const known = request.network && request.asset
+                ? knownAssets.find(([, asset]) => Assets.matches(asset, request.asset, request.network))
+                : undefined;
+            const name = request.extra?.name;
+            const version = request.extra?.version;
+            const currency = request.asset && request.network && typeof name === 'string' && typeof version === 'string'
+                ? Assets.define({
+                    address: request.asset,
+                    decimals: known?.[1].decimals ?? 6,
+                    network: request.network,
+                    transfer: { name, type: 'eip3009', version },
+                })
+                : undefined;
+            const account = await resolveAccount(options.account);
+            return {
+                explorerUrl: chain?.blockExplorers?.default?.url,
+                methods: [...evmMethods({ account, ...(currency && { currencies: [currency] }) })],
+                tokenDecimals: known?.[1].decimals ?? 6,
+                tokenSymbol: known?.[0] ?? '',
+            };
+        },
+    });
+}
+/** Returns whether the CLI can create an x402 credential for this challenge. */
+function isSupportedChallenge(challenge) {
+    if (!x402_ChallengeBrand.is(challenge))
+        return false;
+    const request = challenge.request;
+    const transfer = request.extra;
+    const transferMethod = transfer?.assetTransferMethod;
+    return (request.scheme === 'exact' &&
+        typeof request.asset === 'string' &&
+        typeof request.network === 'string' &&
+        typeof transfer?.name === 'string' &&
+        typeof transfer?.version === 'string' &&
+        (transferMethod === undefined || transferMethod === 'eip3009'));
+}
+function resolveEvmChain(chainId) {
+    return Object.values(viemChains).find((chain) => chain.id === chainId);
+}
+//# sourceMappingURL=x402.js.map

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/middlewares/internal/mppx.js

@@ -21,9 +21,23 @@ export function wrap(mppx, wrapper) {
         };
         Object.assign(wrapWithMeta, methodFn);
         result[key] = wrapWithMeta;
-        // Also set shorthand intent key if Mppx registered it (no collision)
-        if (!reservedMppxKeys.has(mi.intent) && mppx[mi.intent])
-            result[mi.intent] = wrapWithMeta;
+        // Also set shorthand intent key, using the core-composed handler on collisions.
+        if (!reservedMppxKeys.has(mi.intent) && mppx[mi.intent]) {
+            const intentFn = mppx[mi.intent];
+            if (intentFn === methodFn)
+                result[mi.intent] = wrapWithMeta;
+            else {
+                const wrapIntentWithMeta = (options) => {
+                    const configured = intentFn(options);
+                    const handler = wrapper(intentFn, options);
+                    if (configured._internal)
+                        handler._internal = configured._internal;
+                    return handler;
+                };
+                Object.assign(wrapIntentWithMeta, intentFn);
+                result[mi.intent] = wrapIntentWithMeta;
+            }
+        }
         // Build nested handlers: wrapped.tempo.charge(...)
         if (!result[mi.name] || typeof result[mi.name] !== 'object')
             result[mi.name] = {};

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,18 @@ 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<{
+                customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+                    inputs: z.ZodMiniObject<{
+                        tax: z.ZodMiniObject<{
+                            calculation: z.ZodMiniString<string>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+                receipt_email: z.ZodMiniOptional<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 +55,18 @@ export declare const charge: {
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
+            } | 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,18 @@ 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<{
+                customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+                    inputs: z.ZodMiniObject<{
+                        tax: z.ZodMiniObject<{
+                            calculation: z.ZodMiniString<string>;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>>;
+                metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+                receipt_email: z.ZodMiniOptional<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 +88,18 @@ export declare function charge(parameters: charge.Parameters): Method.Client<{
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
+            } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;

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

@@ -42,6 +42,18 @@ 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<{
+                customer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+                hooks: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniObject<{
+                    inputs: import("zod/mini").ZodMiniObject<{
+                        tax: import("zod/mini").ZodMiniObject<{
+                            calculation: import("zod/mini").ZodMiniString<string>;
+                        }, import("zod/v4/core").$strip>;
+                    }, import("zod/v4/core").$strip>;
+                }, import("zod/v4/core").$strip>>;
+                metadata: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniRecord<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniString<string>>>;
+                receipt_email: import("zod/mini").ZodMiniOptional<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 +75,18 @@ export declare function stripe(parameters: stripe.Parameters): readonly [import(
             externalId?: string | undefined;
             metadata?: Record<string, string> | undefined;
             networkId: string;
+            paymentIntentOptions?: {
+                customer?: string | undefined;
+                hooks?: {
+                    inputs: {
+                        tax: {
+                            calculation: string;
+                        };
+                    };
+                } | undefined;
+                metadata?: Record<string, string> | undefined;
+                receipt_email?: string | undefined;
+            } | undefined;
             paymentMethodTypes: string[];
             recipient?: string | undefined;
         }>>;

package/dist/stripe/internal/constants.d.ts

@@ -5,4 +5,8 @@
  * Bump this when upgrading to a newer Stripe API version.
  */
 export declare const stripePreviewVersion = "2026-07-29.preview";
+/** Metadata identifying a Stripe PaymentIntent as a machine payment. */
+export declare const machinePaymentMetadata: {
+    readonly machine_payment: 'true';
+};
 //# sourceMappingURL=constants.d.ts.map

package/dist/stripe/internal/constants.js

@@ -5,4 +5,6 @@
  * Bump this when upgrading to a newer Stripe API version.
  */
 export const stripePreviewVersion = '2026-07-29.preview';
+/** Metadata identifying a Stripe PaymentIntent as a machine payment. */
+export const machinePaymentMetadata = { machine_payment: 'true' };
 //# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,16 @@
+import * as z from '../../zod.js';
+/** Stripe PaymentIntent options accepted only by server-side method input. */
+export declare const Schema: z.ZodMiniObject<{
+    customer: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    hooks: z.ZodMiniOptional<z.ZodMiniObject<{
+        inputs: z.ZodMiniObject<{
+            tax: z.ZodMiniObject<{
+                calculation: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    metadata: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniString<string>>>;
+    receipt_email: z.ZodMiniOptional<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,13 @@
+import * as z from '../../zod.js';
+/** Stripe PaymentIntent options accepted only by server-side method input. */
+export const Schema = z.object({
+    customer: z.optional(z.string().check(z.minLength(1))),
+    hooks: z.optional(z.object({
+        inputs: z.object({
+            tax: z.object({ calculation: z.string().check(z.minLength(1)) }),
+        }),
+    })),
+    metadata: z.optional(z.record(z.string(), z.string())),
+    receipt_email: z.optional(z.string().check(z.minLength(1))),
+});
+//# sourceMappingURL=payment-intent.js.map

package/dist/stripe/internal/types.d.ts

@@ -6,6 +6,10 @@ import * as StripeJsTypes from '../../stripe/server/internal/html/types.js';
  * Uses loose signatures so any Stripe SDK version is assignable.
  */
 export type StripeClient = {
+    /** Stripe-node request transport used for hosted fee-payer requests. */
+    _requestSender?: {
+        _request(...args: any[]): void;
+    } | undefined;
     paymentIntents: {
         create(...args: any[]): Promise<{
             id: string;