mppx 0.6.31 → 0.8.0

package/src/client/Transport.ts

@@ -1,19 +1,11 @@
 import * as Challenge from '../Challenge.js'
 import * as Credential from '../Credential.js'
 import * as Mcp from '../Mcp.js'
-import * as x402_Header from '../x402/Header.js'
-import * as x402_ChallengeBrand from '../x402/internal/ChallengeBrand.js'
-import * as x402_Types from '../x402/Types.js'
-
-const paymentRequiredStatus = 402
-const paymentAuthChallengeHeader = 'WWW-Authenticate'
-const paymentAuthCredentialHeader = 'Authorization'
-const credentialHeaders = [
-  paymentAuthCredentialHeader,
-  x402_Types.paymentRequiredHeader,
-  x402_Types.paymentResponseHeader,
-  x402_Types.paymentSignatureHeader,
-]
+import { mcp as mcpProtocol } from './internal/protocols/Mcp.js'
+import { mpp as mppProtocol } from './internal/protocols/Mpp.js'
+import type { Protocol } from './internal/protocols/Protocol.js'
+import { paymentRequiredStatus } from './internal/protocols/Shared.js'
+import { x402 as x402Protocol } from './internal/protocols/X402.js'
 
 /**
  * Client-side transport adapter.
@@ -24,12 +16,21 @@ const credentialHeaders = [
 export type Transport<in out request = unknown, in out response = unknown> = {
   /** Transport name for identification. */
   name: string
-  /** Checks if a response indicates payment is required. */
-  isPaymentRequired: (response: response) => boolean
+  /**
+   * Checks if a response indicates payment is required. May inspect the request (to gate
+   * body reads) and be async (to read a response body).
+   */
+  isPaymentRequired: (response: response, request?: request) => boolean | Promise<boolean>
   /** Extracts all challenges from a payment-required response, when the transport supports multiple offers. */
-  getChallenges?: (response: response) => Challenge.Challenge[]
+  getChallenges?: (
+    response: response,
+    request?: request,
+  ) => Challenge.Challenge[] | Promise<Challenge.Challenge[]>
   /** Extracts the challenge from a payment-required response. */
-  getChallenge: (response: response) => Challenge.Challenge
+  getChallenge: (
+    response: response,
+    request?: request,
+  ) => Challenge.Challenge | Promise<Challenge.Challenge>
   /** Attaches a credential to a request. */
   setCredential: (
     request: request,
@@ -75,87 +76,79 @@ export function from<request, response>(
   return transport
 }
 
-/**
- * HTTP transport for client-side payment handling.
- *
- * - Detects payment required via 402 status
- * - Extracts Payment auth challenges from `WWW-Authenticate`
- * - Falls back to x402 exact challenges from `PAYMENT-REQUIRED`
- * - Sends credentials via `Authorization` or `PAYMENT-SIGNATURE`
- */
-export function http() {
+/** HTTP transport that composes payment protocols while keeping `fetch` as the single boundary. */
+export function http(): Transport<RequestInit, Response> {
+  const protocols: readonly Protocol[] = [mppProtocol(), x402Protocol(), mcpProtocol()]
+  const protocolForChallenge = new WeakMap<Challenge.Challenge, Protocol>()
+
+  const remember = (protocol: Protocol, challenges: Challenge.Challenge[]) => {
+    for (const challenge of challenges) protocolForChallenge.set(challenge, protocol)
+    return challenges
+  }
+
+  // Collect every protocol offer. Header-only 402 paths stay synchronous; MCP returns a promise
+  // only when it has to inspect a JSON-RPC/SSE body.
+  const collect = (
+    response: Response,
+    request?: RequestInit,
+  ): Challenge.Challenge[] | Promise<Challenge.Challenge[]> => {
+    const collectFrom = (
+      index: number,
+      collected: Challenge.Challenge[],
+    ): Challenge.Challenge[] | Promise<Challenge.Challenge[]> => {
+      for (let i = index; i < protocols.length; i++) {
+        const protocol = protocols[i]!
+        const challenges = protocol.getChallenges(response, request)
+        if (challenges instanceof Promise)
+          return challenges.then((list) =>
+            collectFrom(i + 1, [...collected, ...remember(protocol, list)]),
+          )
+        collected.push(...remember(protocol, challenges))
+      }
+      return collected
+    }
+    return collectFrom(0, [])
+  }
+
   return from<RequestInit, Response>({
     name: 'http',
 
-    isPaymentRequired(response) {
-      return response.status === paymentRequiredStatus
+    isPaymentRequired(response, request) {
+      if (response.status === paymentRequiredStatus) return true // HTTP 402 — sync fast path
+      const challenges = collect(response, request)
+      return challenges instanceof Promise
+        ? challenges.then((list) => list.length > 0)
+        : challenges.length > 0
     },
 
-    getChallenges(response) {
-      return paymentRequiredChallenges(response)
+    getChallenges(response, request) {
+      return collect(response, request)
     },
 
-    getChallenge(response) {
-      const challenge = paymentRequiredChallenges(response)[0]
-      if (!challenge) throw new Error('No challenge in response.')
-      return challenge
+    getChallenge(response, request) {
+      const pick = (challenges: Challenge.Challenge[]): Challenge.Challenge => {
+        const challenge = challenges[0]
+        if (!challenge) throw new Error('No challenge in response.')
+        return challenge
+      }
+      const challenges = collect(response, request)
+      return challenges instanceof Promise ? challenges.then(pick) : pick(challenges)
     },
 
     setCredential(request, credential, options) {
-      const headers = new Headers(request.headers)
-      for (const header of credentialHeaders) headers.delete(header)
-      if (isX402Challenge(options?.challenge)) {
-        headers.set(x402_Types.paymentSignatureHeader, credential)
-      } else {
-        headers.set(paymentAuthCredentialHeader, credential)
-      }
-      return { ...request, headers }
+      const protocol = options?.challenge ? protocolForChallenge.get(options.challenge) : undefined
+      const fallback = protocols[0]
+      if (!protocol && !fallback) throw new Error('No protocol to attach the credential.')
+      return (protocol ?? fallback)!.setCredential(request, credential)
     },
   })
 }
 
-function paymentRequiredChallenges(response: Response): Challenge.Challenge[] {
-  return [
-    ...(response.headers.has(paymentAuthChallengeHeader)
-      ? Challenge.fromResponseList(response)
-      : []),
-    ...x402Challenges(response),
-  ]
-}
-
-function x402Challenges(response: Response): Challenge.Challenge[] {
-  const header = response.headers.get(x402_Types.paymentRequiredHeader)
-  if (!header) return []
-  const paymentRequired = x402_Header.decodePaymentRequired(header)
-  if (response.url && paymentRequired.resource.url !== response.url)
-    throw new Error('x402 payment-required resource does not match response URL.')
-  return paymentRequired.accepts.map((accepted, index) =>
-    x402_ChallengeBrand.mark(
-      Challenge.from({
-        id: `${x402_Types.syntheticChallengeIdPrefix}${index}`,
-        intent: x402_Types.exactIntent,
-        method: x402_Types.paymentMethod,
-        realm: new URL(paymentRequired.resource.url).host,
-        request: {
-          ...accepted,
-          ...(paymentRequired.extensions ? { extensions: paymentRequired.extensions } : {}),
-          resource: paymentRequired.resource,
-        },
-      }),
-    ),
-  )
-}
-
-function isX402Challenge(challenge: Challenge.Challenge | undefined): boolean {
-  return x402_ChallengeBrand.is(challenge)
-}
-
 /**
- * MCP transport for client-side payment handling.
+ * MCP protocol transport for direct JSON-RPC objects.
  *
- * - Detects payment required via error code -32042
- * - Extracts challenges from `error.data.challenges[0]`
- * - Sends credentials via `_meta["org.paymentauth/credential"]`
+ * Prefer {@link http} for MCP-over-HTTP fetches; this remains for callers that already operate on
+ * parsed MCP request/response objects.
  */
 export function mcp() {
   return from<Mcp.Request, Mcp.Response>({
@@ -185,8 +178,8 @@ export function mcp() {
         ...request,
         params: {
           ...request.params,
-          _meta: {
-            ...request.params?._meta,
+          ['_meta']: {
+            ...request.params?.['_meta'],
             [Mcp.credentialMetaKey]: parsed,
           },
         },

package/src/client/index.ts

@@ -1,5 +1,29 @@
+export * as Constants from '../Constants.js'
 export * as Expires from '../Expires.js'
 export * as Fetch from './internal/Fetch.js'
-export { evm, session, stripe, tempo } from './Methods.js'
+export {
+  evm,
+  session,
+  sessionManager,
+  sessionMethod,
+  sessionLegacy,
+  sessionLegacyManager,
+  stripe,
+  tempo,
+} from './Methods.js'
+export {
+  createChannelStore,
+  createJsonChannelStore,
+  entryKey,
+  type ChannelStore,
+  type JsonChannelKv,
+} from '../tempo/session/client/ChannelStore.js'
+export type { ChargeContext } from '../tempo/client/Charge.js'
+export type {
+  ResolveAccount,
+  ResolveAccountCall,
+  ResolveAccountInfo,
+  ResolveAccountOperation,
+} from '../tempo/client/ResolveAccount.js'
 export * as Mppx from './Mppx.js'
 export * as Transport from './Transport.js'

package/src/client/internal/Fetch.test.ts

@@ -1,16 +1,17 @@
-import { Challenge, Errors, Receipt } from 'mppx'
+import { Challenge, Credential, Errors, Mcp, Receipt } from 'mppx'
 import { tempo } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
+import { Header as x402_Header, Types as x402_Types, type PaymentRequired } from 'mppx/x402'
 import { createClient, defineChain } from 'viem'
 import { describe, expect, test, vi } from 'vp/test'
 import * as Http from '~test/Http.js'
-import { rpcUrl } from '~test/tempo/prool.js'
+import { rpcUrl } from '~test/tempo/rpc.js'
 import { accounts, asset, chain, client, http } from '~test/tempo/viem.js'
 
 import * as Fetch from './Fetch.js'
 
 const realm = 'api.example.com'
-const secretKey = 'test-secret-key'
+const secretKey = 'test-secret-key-test-secret-key-32'
 
 const server = Mppx_server.create({
   methods: [
@@ -334,6 +335,21 @@ const noopMethod = {
   createCredential: async () => 'credential',
 } as any
 
+const x402PaymentRequired = {
+  accepts: [
+    {
+      amount: '10000',
+      asset: '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
+      maxTimeoutSeconds: 60,
+      network: 'eip155:84532',
+      payTo: '0x209693Bc6afc0C5328bA36FaF03C514EF312287C',
+      scheme: x402_Types.schemes[0],
+    },
+  ],
+  resource: { url: 'https://example.com/api' },
+  x402Version: 2,
+} satisfies PaymentRequired
+
 /** Builds a valid 402 response with a WWW-Authenticate header. */
 function make402(overrides?: { expires?: string; intent?: string; method?: string }) {
   const method = overrides?.method ?? 'test'
@@ -350,6 +366,19 @@ function make402(overrides?: { expires?: string; intent?: string; method?: strin
   })
 }
 
+function makeCombined402() {
+  const response = make402()
+  const headers = new Headers(response.headers)
+  headers.set(
+    x402_Types.paymentRequiredHeader,
+    x402_Header.encodePaymentRequired(x402PaymentRequired),
+  )
+  return new Response(null, {
+    status: 402,
+    headers,
+  })
+}
+
 describe('Fetch.from: init passthrough (non-402)', () => {
   test('preserves init object identity while adding Accept-Payment', async () => {
     const receivedInits: (RequestInit | undefined)[] = []
@@ -669,7 +698,183 @@ describe('Fetch.from: 402 retry path', () => {
     expect(headers.get('Authorization')).toBe('credential')
   })
 
-  test('sends credential retry to the final 402 response URL', async () => {
+  test('chooses native Payment-auth from combined MPP and x402 HTTP 402 offers', async () => {
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    const mockFetch: typeof globalThis.fetch = async (_input, init) => {
+      calls.push({ init })
+      callCount++
+      if (callCount === 1) return makeCombined402()
+      return new Response('OK', { status: 200 })
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+
+    const response = await fetch('https://example.com/api')
+
+    expect(response.status).toBe(200)
+    expect(calls).toHaveLength(2)
+    const retryHeaders = new Headers(calls[1]!.init?.headers)
+    expect(retryHeaders.get('Authorization')).toBe('credential')
+    expect(retryHeaders.get(x402_Types.paymentSignatureHeader)).toBeNull()
+  })
+
+  test('settles MCP-over-HTTP JSON-RPC payment challenges at the fetch boundary', async () => {
+    const mcpChallenge = Challenge.from({
+      id: 'mcp-challenge',
+      intent: 'test',
+      method: 'test',
+      realm: 'test',
+      request: { amount: '1' },
+    })
+    const method = {
+      ...noopMethod,
+      createCredential: async ({ challenge }: { challenge: Challenge.Challenge }) =>
+        Credential.serialize({ challenge, payload: { source: 'mcp' } }),
+    }
+    const initialBody = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: { name: 'paid-tool' },
+    })
+    let callCount = 0
+    const calls: { init: RequestInit | undefined }[] = []
+    const mockFetch: typeof globalThis.fetch = async (_input, init) => {
+      calls.push({ init })
+      callCount++
+      if (callCount === 1)
+        return Response.json({
+          jsonrpc: '2.0',
+          id: 1,
+          error: {
+            code: Mcp.paymentRequiredCode,
+            message: 'Payment Required',
+            data: { challenges: [mcpChallenge] },
+          },
+        })
+
+      const body = JSON.parse(init?.body as string)
+      expect(new Headers(init?.headers).get('Authorization')).toBeNull()
+      expect(body.params['_meta'][Mcp.credentialMetaKey]).toMatchObject({
+        payload: { source: 'mcp' },
+      })
+      return Response.json({ ok: true })
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [method],
+    })
+
+    const response = await fetch('https://example.com/mcp', {
+      method: 'POST',
+      headers: { accept: 'application/json, text/event-stream' },
+      body: initialBody,
+    })
+
+    expect(response.status).toBe(200)
+    expect(calls).toHaveLength(2)
+  })
+
+  test('settles MCP-over-HTTP when the JSON-RPC request body is carried by Request input', async () => {
+    const mcpChallenge = Challenge.from({
+      id: 'mcp-request-input-challenge',
+      intent: 'test',
+      method: 'test',
+      realm: 'test',
+      request: { amount: '1' },
+    })
+    const method = {
+      ...noopMethod,
+      createCredential: async ({ challenge }: { challenge: Challenge.Challenge }) =>
+        Credential.serialize({ challenge, payload: { source: 'request-input' } }),
+    }
+    const initialBody = JSON.stringify({
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: { name: 'paid-tool' },
+    })
+    let callCount = 0
+    const calls: { init: RequestInit | undefined; input: RequestInfo | URL }[] = []
+    const mockFetch: typeof globalThis.fetch = async (input, init) => {
+      calls.push({ input, init })
+      callCount++
+      if (callCount === 1) {
+        expect(input).toBeInstanceOf(Request)
+        expect(await (input as Request).text()).toBe(initialBody)
+        return Response.json({
+          jsonrpc: '2.0',
+          id: 1,
+          error: {
+            code: Mcp.paymentRequiredCode,
+            message: 'Payment Required',
+            data: { challenges: [mcpChallenge] },
+          },
+        })
+      }
+
+      const body = JSON.parse(init?.body as string)
+      expect(body.params['_meta'][Mcp.credentialMetaKey]).toMatchObject({
+        payload: { source: 'request-input' },
+      })
+      return Response.json({ ok: true })
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [method],
+    })
+    const request = new Request('https://example.com/mcp', {
+      method: 'POST',
+      headers: { accept: 'application/json, text/event-stream' },
+      body: initialBody,
+    })
+
+    const response = await fetch(request)
+
+    expect(response.status).toBe(200)
+    expect(calls).toHaveLength(2)
+    expect(calls[1]?.input).toBe(request)
+  })
+
+  test('settles native HTTP 402 when a POST body is carried by Request input', async () => {
+    const initialBody = JSON.stringify({ ok: true })
+    let callCount = 0
+    const calls: { init: RequestInit | undefined; input: RequestInfo | URL }[] = []
+    const mockFetch: typeof globalThis.fetch = async (input, init) => {
+      calls.push({ input, init })
+      callCount++
+      const request = input instanceof Request && !init ? input : new Request(input, init)
+      expect(await request.text()).toBe(initialBody)
+      if (callCount === 1) return make402()
+
+      expect(request.headers.get('Authorization')).toBe('credential')
+      return new Response('OK', { status: 200 })
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+    const request = new Request('https://example.com/api', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: initialBody,
+    })
+
+    const response = await fetch(request)
+
+    expect(response.status).toBe(200)
+    expect(calls).toHaveLength(2)
+    expect(calls[1]?.input).toBe(request)
+  })
+
+  test('sends credential retry to the final same-origin 402 response URL', async () => {
     let callCount = 0
     const calls: { input: RequestInfo | URL; init: RequestInit | undefined }[] = []
     const mockFetch: typeof globalThis.fetch = async (input, init) => {
@@ -678,7 +883,7 @@ describe('Fetch.from: 402 retry path', () => {
       if (callCount === 1) {
         const response = make402()
         Object.defineProperty(response, 'url', {
-          value: 'https://payments.example.com/protected',
+          value: 'https://api.example.com/redirected-protected',
         })
         return response
       }
@@ -694,10 +899,35 @@ describe('Fetch.from: 402 retry path', () => {
 
     expect(response.status).toBe(200)
     expect(calls[0]!.input).toBe('https://api.example.com/protected')
-    expect(calls[1]!.input).toBe('https://payments.example.com/protected')
+    expect(calls[1]!.input).toBe('https://api.example.com/redirected-protected')
     expect(new Headers(calls[1]!.init?.headers).get('Authorization')).toBe('credential')
   })
 
+  test('rejects credential retry to a cross-origin 402 response URL', async () => {
+    const calls: { input: RequestInfo | URL; init: RequestInit | undefined }[] = []
+    const mockFetch: typeof globalThis.fetch = async (input, init) => {
+      calls.push({ input, init })
+      const response = make402()
+      Object.defineProperty(response, 'url', {
+        value: 'https://payments.example.com/protected',
+      })
+      return response
+    }
+
+    const fetch = Fetch.from({
+      fetch: mockFetch,
+      methods: [noopMethod],
+    })
+
+    await expect(fetch('https://api.example.com/protected')).rejects.toThrow(
+      'Refusing to send payment credential across redirect from https://api.example.com to https://payments.example.com',
+    )
+
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.input).toBe('https://api.example.com/protected')
+    expect(new Headers(calls[0]!.init?.headers).get('Authorization')).toBeNull()
+  })
+
   test('emits client events and allows challenge handler to provide credential', async () => {
     const events: string[] = []
     const createCredential = vi.fn(async () => 'method-credential')

package/src/client/internal/Fetch.ts

@@ -1,4 +1,5 @@
 import * as Challenge from '../../Challenge.js'
+import * as Constants from '../../Constants.js'
 import * as Expires from '../../Expires.js'
 import * as AcceptPayment from '../../internal/AcceptPayment.js'
 import type { MaybePromise } from '../../internal/types.js'
@@ -173,8 +174,9 @@ export function from<const methods extends readonly Method.AnyClient[]>(
 
   const wrappedFetch = async (input: RequestInfo | URL, init?: from.RequestInit<methods>) => {
     const callerHeaders = getCallerHeaders(input, init?.headers)
-    const hasExplicitAcceptPayment = callerHeaders.has('Accept-Payment')
+    const hasExplicitAcceptPayment = callerHeaders.has(Constants.Headers.acceptPayment)
     const paymentPreferences = resolvePaymentPreferences(callerHeaders, resolvedAcceptPayment)
+    const capturedBody = captureRequestBody(input, init, callerHeaders)
     const initialRequest = prepareInitialRequest(
       input,
       init,
@@ -183,9 +185,10 @@ export function from<const methods extends readonly Method.AnyClient[]>(
       hasExplicitAcceptPayment,
       acceptPaymentPolicy,
     )
-    const response = await baseFetch(initialRequest.input, initialRequest.init)
+    const response = await baseFetch(cloneRequestInput(initialRequest.input), initialRequest.init)
+    const transportRequest = withCapturedBody(initialRequest.init, await capturedBody)
 
-    if (!transport.isPaymentRequired(response)) return response
+    if (!(await transport.isPaymentRequired(response, transportRequest as never))) return response
 
     // Only extract context for payment handling after confirming 402.
     const context = (init as Record<string, unknown> | undefined)?.context
@@ -193,7 +196,7 @@ export function from<const methods extends readonly Method.AnyClient[]>(
       context: _,
       orderChallenges: requestOrderChallenges,
       ...fetchInit
-    } = (initialRequest.init ?? {}) as Record<string, unknown>
+    } = (transportRequest ?? {}) as Record<string, unknown>
 
     let challenge: Challenge.Challenge | undefined
     let challenges: readonly Challenge.Challenge[] | undefined
@@ -201,8 +204,8 @@ export function from<const methods extends readonly Method.AnyClient[]>(
 
     try {
       challenges = transport.getChallenges
-        ? transport.getChallenges(response)
-        : [transport.getChallenge(response)]
+        ? await transport.getChallenges(response, transportRequest as never)
+        : [await transport.getChallenge(response, transportRequest as never)]
 
       const candidates = AcceptPayment.selectChallengeCandidates(
         challenges,
@@ -262,7 +265,7 @@ export function from<const methods extends readonly Method.AnyClient[]>(
       )
 
       const paymentResponse = await baseFetch(
-        resolvePaymentRetryInput(response, initialRequest.input),
+        resolvePaymentRetryInput(response, initialRequest.input, initialRequest.input),
         transport.setCredential(
           {
             ...fetchInit,
@@ -665,7 +668,13 @@ function snapshotInit<methods extends readonly Method.AnyClient[]>(
 }
 
 function snapshotInput(input: RequestInfo | URL | undefined): RequestInfo | URL | undefined {
-  if (input instanceof Request) return input.clone()
+  if (input instanceof Request) {
+    try {
+      return input.clone()
+    } catch {
+      return input
+    }
+  }
   if (input instanceof URL) return new URL(input)
   return input
 }
@@ -717,7 +726,7 @@ function prepareInitialRequest<methods extends readonly Method.AnyClient[]>(
   callerHeaders.forEach((value, key) => {
     headers.set(key, value)
   })
-  headers.set('Accept-Payment', header)
+  headers.set(Constants.Headers.acceptPayment, header)
 
   if (init) {
     // Preserve init identity for callers like websocket upgrade helpers that
@@ -737,6 +746,35 @@ function prepareInitialRequest<methods extends readonly Method.AnyClient[]>(
   }
 }
 
+function captureRequestBody<methods extends readonly Method.AnyClient[]>(
+  input: RequestInfo | URL,
+  init: from.RequestInit<methods> | undefined,
+  headers: Headers,
+): Promise<string | undefined> | undefined {
+  if (!(input instanceof Request) || init?.body !== undefined || !input.body || input.bodyUsed)
+    return undefined
+  if (!headers.has('mcp-method')) {
+    const accept = headers.get('accept')?.toLowerCase() ?? ''
+    if (!accept.includes('application/json') || !accept.includes('text/event-stream'))
+      return undefined
+  }
+  try {
+    return input
+      .clone()
+      .text()
+      .catch(() => undefined)
+  } catch {
+    return undefined
+  }
+}
+
+function withCapturedBody<methods extends readonly Method.AnyClient[]>(
+  init: from.RequestInit<methods> | undefined,
+  body: string | undefined,
+): from.RequestInit<methods> | undefined {
+  return body === undefined ? init : ({ ...init, body } as from.RequestInit<methods>)
+}
+
 /** @internal */
 function getCallerHeaders(input: RequestInfo | URL, headers: HeadersInit | undefined): Headers {
   if (headers) return new Headers(headers)
@@ -752,6 +790,15 @@ function unwrapFetch(fetch: typeof globalThis.fetch): typeof globalThis.fetch {
   return current as typeof globalThis.fetch
 }
 
+function cloneRequestInput(input: RequestInfo | URL): RequestInfo | URL {
+  if (!(input instanceof Request) || !input.body || input.bodyUsed) return input
+  try {
+    return input.clone()
+  } catch {
+    return input
+  }
+}
+
 /** @internal */
 function isWrappedFetch(fetch: typeof globalThis.fetch): fetch is WrappedFetch {
   return Boolean((fetch as WrappedFetch)[MPPX_FETCH_WRAPPER])
@@ -781,7 +828,7 @@ function resolvePaymentPreferences<methods extends readonly Method.AnyClient[]>(
   headers: Headers,
   acceptPayment: AcceptPayment.Resolved<methods>,
 ): AcceptPayment.Resolved<methods> {
-  const header = headers.get('Accept-Payment')
+  const header = headers.get(Constants.Headers.acceptPayment)
   if (!header) return acceptPayment
 
   try {
@@ -847,6 +894,17 @@ function resolveRequestUrl(input: RequestInfo | URL): URL {
 function resolvePaymentRetryInput(
   response: Response,
   fallback: RequestInfo | URL,
+  initialInput: RequestInfo | URL,
 ): RequestInfo | URL {
-  return response.url ? response.url : fallback
+  if (!response.url) return fallback
+
+  const responseUrl = new URL(response.url)
+  const initialUrl = resolveRequestUrl(initialInput)
+  if (responseUrl.origin !== initialUrl.origin) {
+    throw new Error(
+      `Refusing to send payment credential across redirect from ${initialUrl.origin} to ${responseUrl.origin}`,
+    )
+  }
+
+  return response.url
 }