mppx 0.8.1 → 0.8.3

package/src/cli/cli.ts

@@ -16,7 +16,11 @@ import { validate as validateDiscovery } from '../discovery/Validate.js'
 import { createDefaultStore, createKeychain, resolveAccountName } from './account.js'
 import { loadConfig, resolveAcceptPayment, selectChallenge } from './internal.js'
 import type { Plugin } from './plugins/plugin.js'
-import { readTempoKeystore, resolveTempoAccount } from './plugins/tempo.js'
+import {
+  orderTempoChargeChallengesByBalance,
+  readTempoKeystore,
+  resolveTempoAccount,
+} from './plugins/tempo.js'
 import {
   chainName,
   confirm,
@@ -151,6 +155,18 @@ function formatPayment(payment: unknown): string {
     .join(' ')
 }
 
+function filterChallengesByCurrency(
+  challenges: readonly Challenge.Challenge[],
+  currency: string | undefined,
+): Challenge.Challenge[] {
+  if (!currency) return [...challenges]
+  const normalized = currency.toLowerCase()
+  return challenges.filter((challenge) => {
+    const offered = challenge.request.currency
+    return typeof offered === 'string' && offered.toLowerCase() === normalized
+  })
+}
+
 async function fetchServicesRegistry(): Promise<ServiceRegistryService[]> {
   const url = process.env.MPPX_SERVICES_URL ?? servicesRegistryUrl
   const response = await globalThis.fetch(url)
@@ -198,6 +214,7 @@ const cli = Cli.create('mppx', {
     autoSwap: z.boolean().optional().describe('Auto-swap source tokens into payment currency'),
     config: z.string().optional().describe('Path to config file'),
     confirm: z.boolean().optional().default(false).describe('Show confirmation prompts'),
+    currency: z.string().optional().describe('Payment currency/token address to select'),
     data: z.string().optional().describe('Send request body (implies POST unless -X is set)'),
     fail: z.boolean().optional().describe('Fail silently on HTTP errors (exit 22)'),
     header: z.array(z.string()).optional().describe('Add header (repeatable)'),
@@ -357,12 +374,31 @@ const cli = Cli.create('mppx', {
         return
       }
 
-      const selected = selectChallenge(
-        Challenge.fromResponseList(challengeResponse),
-        loaded?.config,
-      )
+      const methodOpts = parseMethodOpts(c.options.methodOpt)
+      const offeredChallenges = Challenge.fromResponseList(challengeResponse)
+      const currencyChallenges = filterChallengesByCurrency(offeredChallenges, c.options.currency)
+      if (c.options.currency && currencyChallenges.length === 0) {
+        const offers = offeredChallenges
+          .map((challenge) => challenge.request.currency)
+          .filter((currency): currency is string => typeof currency === 'string')
+          .join(', ')
+        return c.error({
+          code: 'UNSUPPORTED_CURRENCY',
+          message: `Server did not offer payment currency ${c.options.currency}.${offers ? ` Offered currencies: ${offers}.` : ''}`,
+          exitCode: 2,
+        })
+      }
+      const challenges = await orderTempoChargeChallengesByBalance(currencyChallenges, {
+        options: {
+          account: c.options.account,
+          network: c.options.network,
+          rpcUrl: c.options.rpcUrl,
+        },
+      })
+
+      const selected = selectChallenge(challenges, loaded?.config)
       if (!selected) {
-        const offers = Challenge.fromResponseList(challengeResponse)
+        const offers = challenges
           .map((challenge) => `${challenge.method}/${challenge.intent}`)
           .join(', ')
         return c.error({
@@ -393,7 +429,7 @@ const cli = Cli.create('mppx', {
             rpcUrl: c.options.rpcUrl,
             slippage: c.options.slippage,
           },
-          methodOpts: parseMethodOpts(c.options.methodOpt),
+          methodOpts,
         })
         tokenSymbol = pluginResult.tokenSymbol
         tokenDecimals = pluginResult.tokenDecimals

package/src/cli/plugins/tempo.ts

@@ -9,7 +9,9 @@ import { Base64 } from 'ox'
 import type { Address } from 'viem'
 import { createClient, http } from 'viem'
 import { privateKeyToAccount } from 'viem/accounts'
+import { Actions } from 'viem/tempo'
 
+import type * as Challenge from '../../Challenge.js'
 import { normalizeHeaders } from '../../client/internal/Fetch.js'
 import * as Constants from '../../Constants.js'
 import * as Credential from '../../Credential.js'
@@ -30,10 +32,88 @@ import {
   pc,
   resolveChain,
   resolveRpcUrl,
+  type Network,
 } from '../utils.js'
 import { createPlugin, type Plugin } from './plugin.js'
 
 const packageJson = createRequire(import.meta.url)('../../../package.json') as { name: string }
+const booleanOption = z.union([
+  z.boolean(),
+  z.literal('true').transform(() => true),
+  z.literal('false').transform(() => false),
+])
+const tempoOptionSchema = z.object({
+  autoSwap: z.optional(booleanOption),
+  channel: z.optional(z.coerce.string()),
+  deposit: z.optional(z.union([z.string(), z.number()])),
+  payWith: z.optional(z.string()),
+  slippage: z.optional(z.coerce.number()),
+  tokenIn: z.optional(z.string()),
+})
+const tempoOptionKeys = [
+  'autoSwap',
+  'channel',
+  'deposit',
+  'payWith',
+  'slippage',
+  'tokenIn',
+] as const
+const tempoChargeChallengeScoreOrder = [
+  'payable',
+  'unknownBalance',
+  'insufficientBalance',
+  'unsupported',
+] as const
+
+type TempoChargeChallengeScore = (typeof tempoChargeChallengeScoreOrder)[number]
+
+/**
+ * Orders Tempo charge challenges by whether the configured wallet can satisfy them.
+ *
+ * Direct balances are preferred first. Unsupported or unpayable challenges keep
+ * their original relative order.
+ */
+export async function orderTempoChargeChallengesByBalance(
+  challenges: readonly Challenge.Challenge[],
+  ctx: {
+    options: {
+      account?: string | undefined
+      network?: Network | undefined
+      rpcUrl?: string | undefined
+    }
+  },
+): Promise<Challenge.Challenge[]> {
+  const tempoPositions: number[] = []
+  const tempoChallenges: Challenge.Challenge[] = []
+  for (const [index, challenge] of challenges.entries()) {
+    if (!isTempoChargeChallenge(challenge)) continue
+    tempoPositions.push(index)
+    tempoChallenges.push(challenge)
+  }
+  if (tempoChallenges.length < 2) return [...challenges]
+
+  const probe = await resolveBalanceProbe(ctx).catch(() => undefined)
+  if (!probe) return [...challenges]
+
+  const scored = await Promise.all(
+    tempoChallenges.map(async (challenge, index) => ({
+      challenge,
+      index,
+      score: await scoreTempoChargeChallenge(challenge, probe),
+    })),
+  )
+  scored.sort(
+    (left, right) =>
+      tempoChargeChallengeScoreOrder.indexOf(left.score) -
+        tempoChargeChallengeScoreOrder.indexOf(right.score) || left.index - right.index,
+  )
+
+  const ordered = [...challenges]
+  for (const [index, position] of tempoPositions.entries()) {
+    ordered[position] = scored[index]!.challenge
+  }
+  return ordered
+}
 
 export function tempo() {
   let _session:
@@ -60,23 +140,7 @@ export function tempo() {
       const accountName = resolveAccountName(options.account)
       const challengeRequest = challenge.request as Record<string, unknown>
       const currency = challengeRequest.currency as string | undefined
-      const booleanOption = z.union([
-        z.boolean(),
-        z.literal('true').transform(() => true),
-        z.literal('false').transform(() => false),
-      ])
-      const tempoOpts = parseOptions(
-        z.object({
-          autoSwap: z.optional(booleanOption),
-          channel: z.optional(z.coerce.string()),
-          deposit: z.optional(z.union([z.string(), z.number()])),
-          payWith: z.optional(z.string()),
-          slippage: z.optional(z.coerce.number()),
-          tokenIn: z.optional(z.string()),
-        }),
-        methodOpts,
-        ['autoSwap', 'channel', 'deposit', 'payWith', 'slippage', 'tokenIn'],
-      )
+      const tempoOpts = parseTempoOptions(methodOpts)
       const autoSwap = resolveAutoSwap({
         autoSwap: tempoOpts.autoSwap ?? options.autoSwap,
         payWith: tempoOpts.payWith ?? options.payWith,
@@ -746,6 +810,86 @@ function detectTerminalBg(
 
 // --- Account helpers ---
 
+type BalanceProbe = {
+  account: Address
+  client: ReturnType<typeof createClient>
+}
+
+function parseTempoOptions(rawOptions: Record<string, string>) {
+  return parseOptions(tempoOptionSchema, rawOptions, tempoOptionKeys)
+}
+
+function isTempoChargeChallenge(challenge: Challenge.Challenge): boolean {
+  return challenge.method === 'tempo' && challenge.intent === 'charge'
+}
+
+async function resolveBalanceProbe(ctx: {
+  options: {
+    account?: string | undefined
+    network?: Network | undefined
+    rpcUrl?: string | undefined
+  }
+}): Promise<BalanceProbe | undefined> {
+  const accountName = resolveAccountName(ctx.options.account)
+  const privateKey =
+    process.env.MPPX_PRIVATE_KEY?.trim() ||
+    (isTempoAccount(accountName) ? undefined : await createKeychain(accountName).get())
+
+  let account: Address | undefined
+  if (privateKey) {
+    account = privateKeyToAccount(privateKey as `0x${string}`).address
+  } else if (isTempoAccount(accountName) && hasTempoCliSync()) {
+    account = resolveTempoAccount(accountName)?.wallet_address as Address | undefined
+  } else {
+    const fallback = fallbackFromTempo()
+    if (fallback) {
+      const fallbackKey = await createKeychain(fallback).get()
+      if (fallbackKey) account = privateKeyToAccount(fallbackKey as `0x${string}`).address
+    }
+  }
+  if (!account) return undefined
+
+  const rpcUrl = resolveRpcUrl(ctx.options.rpcUrl, { network: ctx.options.network })
+  const client = createClient({
+    chain: await resolveChain({ network: ctx.options.network, rpcUrl }),
+    transport: http(rpcUrl),
+  })
+
+  return {
+    account,
+    client,
+  }
+}
+
+async function scoreTempoChargeChallenge(
+  challenge: Challenge.Challenge,
+  probe: BalanceProbe,
+): Promise<TempoChargeChallengeScore> {
+  const request = challenge.request as Record<string, unknown>
+  const currency = request.currency
+  const amount = request.amount
+  if (typeof currency !== 'string' || typeof amount !== 'string') return 'unsupported'
+
+  const requiredChainId = (request.methodDetails as { chainId?: number } | undefined)?.chainId
+  if (requiredChainId && probe.client.chain?.id && requiredChainId !== probe.client.chain.id) {
+    return 'unsupported'
+  }
+
+  const amountRaw = BigInt(amount)
+  if (amountRaw === 0n) return 'payable'
+
+  const balance = await Actions.token
+    .getBalance(probe.client as never, {
+      account: probe.account,
+      token: currency as Address,
+    })
+    .then((value) => value.amount)
+    .catch(() => undefined)
+  if (balance === undefined) return 'unknownBalance'
+  if (balance >= amountRaw) return 'payable'
+  return 'insufficientBalance'
+}
+
 function parseOptions<const schema extends z.ZodType>(
   schema: schema,
   rawOptions: unknown,

package/src/cli/utils.ts

@@ -287,6 +287,10 @@ export const testnetTokens = [
   '0x20c0000000000000000000000000000000000003',
 ] as const
 
+function toBaseUnitAmount(value: bigint | { amount: bigint }) {
+  return typeof value === 'bigint' ? value : value.amount
+}
+
 export function isTestnet(chain: Chain) {
   return chain.id !== tempoMainnet.id
 }
@@ -295,10 +299,18 @@ export async function fetchTokenInfo(
   client: ReturnType<typeof createClient>,
   token: Address,
   account: Address,
-) {
+): Promise<{
+  balance: bigint
+  decimals: number
+  symbol: string
+  token: Address
+}> {
   const { Actions } = await import('viem/tempo')
   const [balance, metadata] = await Promise.all([
-    Actions.token.getBalance(client, { account, token }).catch(() => 0n),
+    Actions.token
+      .getBalance(client, { account, token })
+      .then(toBaseUnitAmount)
+      .catch(() => 0n),
     Actions.token.getMetadata(client, { token }).catch(() => ({ symbol: token as string })),
   ])
   const knownSymbols: Record<string, string> = {

package/src/client/Mppx.test-d.ts

@@ -62,6 +62,15 @@ describe('create.Config', () => {
     expectTypeOf<Config>().toHaveProperty('methods')
   })
 
+  test('accepts payment retry cap', () => {
+    const mppx = Mppx.create({
+      maxPaymentRetries: 1,
+      methods: [charge()],
+    })
+
+    expectTypeOf(mppx.fetch).toBeFunction()
+  })
+
   test('paymentPreferences callback exposes typed method keys', () => {
     const mppx = Mppx.create({
       methods: [tempo({ account: {} as Account })],

package/src/client/Mppx.test.ts

@@ -41,6 +41,47 @@ describe('Mppx.create', () => {
     expect(mppx.transport.name).toBe('mcp')
   })
 
+  test('behavior: passes maxPaymentRetries to fetch wrapper', async () => {
+    const testMethod = Method.toClient(
+      Method.from({
+        name: 'test',
+        intent: 'test',
+        schema: Methods.charge.schema,
+      }),
+      {
+        async createCredential() {
+          return 'credential'
+        },
+      },
+    )
+    const challenge = Challenge.from({
+      id: 'retry-cap',
+      realm,
+      method: 'test',
+      intent: 'test',
+      request: { amount: '1' },
+    })
+    let callCount = 0
+    const fetch = vi.fn(async () => {
+      callCount++
+      return new Response(null, {
+        status: 402,
+        headers: { 'WWW-Authenticate': Challenge.serialize(challenge) },
+      })
+    })
+    const mppx = Mppx.create({
+      fetch: fetch as typeof globalThis.fetch,
+      maxPaymentRetries: 1,
+      methods: [testMethod],
+      polyfill: false,
+    })
+
+    const response = await mppx.fetch('https://example.com/api')
+
+    expect(response.status).toBe(402)
+    expect(callCount).toBe(2)
+  })
+
   test('behavior: with multiple methods', () => {
     const stripeCharge = Method.from({
       name: 'stripe',

package/src/client/Mppx.ts

@@ -100,6 +100,7 @@ export function create<
   >,
 >(config: create.Config<methods, transport>): Mppx<methods, transport> {
   const {
+    maxPaymentRetries,
     onChallenge,
     orderChallenges,
     polyfill = true,
@@ -122,6 +123,7 @@ export function create<
     acceptPaymentPolicy,
     ...(config.fetch && { fetch: config.fetch }),
     eventDispatcher: events,
+    ...(maxPaymentRetries !== undefined && { maxPaymentRetries }),
     ...(resolvedOnChallenge && { onChallenge: resolvedOnChallenge }),
     ...(orderChallenges && { orderChallenges }),
     methods,
@@ -298,6 +300,8 @@ export declare namespace create {
           },
         ) => Promise<string | undefined>)
       | undefined
+    /** Maximum number of payment challenge retries after the initial response. @default 3 */
+    maxPaymentRetries?: Fetch.from.Config['maxPaymentRetries'] | undefined
     /** Filters and sorts supported challenges before credential creation. */
     orderChallenges?: AcceptPayment.OrderChallenges<FlattenMethods<methods>> | undefined
     /** Client-declared supported payment methods, keyed by typed `method/intent` strings. */

package/src/client/Transport.test.ts

@@ -2,6 +2,7 @@ import { Challenge, Credential, Mcp } from 'mppx'
 import { Transport } from 'mppx/client'
 import { Methods } from 'mppx/tempo'
 import { Header as x402_Header, Types as x402_Types, type PaymentRequired } from 'mppx/x402'
+import { Base64 } from 'ox'
 import { describe, expect, test } from 'vp/test'
 
 import * as x402_ChallengeBrand from '../x402/internal/ChallengeBrand.js'
@@ -43,6 +44,25 @@ const x402PaymentRequired = {
   x402Version: 2,
 } satisfies PaymentRequired
 
+const unsupportedSolanaAccept = {
+  amount: '10000',
+  asset: 'USDC',
+  maxTimeoutSeconds: 60,
+  network: 'solana:mainnet',
+  payTo: '9xQeWvG816bUx9EPjHmaT23yvVM2ZWdYqPxfowV5n2kg',
+  scheme: 'exact',
+}
+
+const unsupportedSchemeAccept = {
+  ...x402PaymentRequired.accepts[0]!,
+  scheme: 'upto',
+}
+
+// Strict x402 encoding rejects unsupported accepts before the transport can filter them.
+function encodeRawPaymentRequiredHeader(value: unknown): string {
+  return Base64.fromString(JSON.stringify(value))
+}
+
 describe('http', () => {
   describe('isPaymentRequired', () => {
     test.each([
@@ -140,6 +160,28 @@ describe('http', () => {
         }),
         name: 'Payment auth and x402 challenges when both are present',
       },
+      {
+        expectedIds: [`${x402_Types.syntheticChallengeIdPrefix}0`],
+        expectedMethods: [x402_Types.paymentMethod],
+        headers: () => ({
+          'PAYMENT-REQUIRED': encodeRawPaymentRequiredHeader({
+            ...x402PaymentRequired,
+            accepts: [x402PaymentRequired.accepts[0]!, unsupportedSolanaAccept],
+          }),
+        }),
+        name: 'x402 challenges filtered from mixed EVM and Solana accepts',
+      },
+      {
+        expectedIds: [`${x402_Types.syntheticChallengeIdPrefix}0`],
+        expectedMethods: [x402_Types.paymentMethod],
+        headers: () => ({
+          'PAYMENT-REQUIRED': encodeRawPaymentRequiredHeader({
+            ...x402PaymentRequired,
+            accepts: [x402PaymentRequired.accepts[0]!, unsupportedSchemeAccept],
+          }),
+        }),
+        name: 'x402 challenges filtered from mixed exact and non-exact accepts',
+      },
     ])('returns $name', async ({ expectedIds, expectedMethods, headers }) => {
       const transport = Transport.http()
       const response = new Response(null, {
@@ -151,6 +193,42 @@ describe('http', () => {
       expect(challenges.map((entry) => entry.id)).toEqual(expectedIds)
       expect(challenges.map((entry) => entry.method)).toEqual(expectedMethods)
     })
+
+    test('returns Payment auth challenges when x402 accepts are unsupported', async () => {
+      const transport = Transport.http()
+      const response = new Response(null, {
+        status: 402,
+        headers: {
+          'PAYMENT-REQUIRED': encodeRawPaymentRequiredHeader({
+            ...x402PaymentRequired,
+            accepts: [unsupportedSolanaAccept],
+          }),
+          'WWW-Authenticate': Challenge.serialize(challenge),
+        },
+      })
+
+      const challenges = (await transport.getChallenges?.(response)) ?? []
+
+      expect(challenges.map((entry) => entry.id)).toEqual([challenge.id])
+      expect(challenges.map((entry) => entry.method)).toEqual(['tempo'])
+    })
+
+    test('returns no challenges when only unsupported x402 accepts are present', async () => {
+      const transport = Transport.http()
+      const response = new Response(null, {
+        status: 402,
+        headers: {
+          'PAYMENT-REQUIRED': encodeRawPaymentRequiredHeader({
+            ...x402PaymentRequired,
+            accepts: [unsupportedSolanaAccept],
+          }),
+        },
+      })
+
+      const challenges = (await transport.getChallenges?.(response)) ?? []
+      expect(challenges).toEqual([])
+      expect(() => transport.getChallenge(response)).toThrow('No challenge in response.')
+    })
   })
 
   describe('setCredential', () => {
@@ -322,8 +400,24 @@ describe('http (MCP-over-HTTP)', () => {
       data: { challenges: [challenge] },
     },
   }
+  const resultMessage = {
+    jsonrpc: '2.0',
+    id: 1,
+    result: {
+      content: [{ type: 'text', text: 'Payment Required' }],
+      isError: true,
+      _meta: {
+        [Mcp.paymentRequiredMetaKey]: {
+          httpStatus: 402,
+          challenges: [challenge],
+        },
+      },
+    },
+  }
   const jsonBody = () =>
     new Response(JSON.stringify(errorMessage), { headers: { 'content-type': 'application/json' } })
+  const jsonResultBody = () =>
+    new Response(JSON.stringify(resultMessage), { headers: { 'content-type': 'application/json' } })
   const sseBody = () =>
     new Response(`event: message\ndata: ${JSON.stringify(errorMessage)}\n\n`, {
       headers: { 'content-type': 'text/event-stream' },
@@ -332,6 +426,9 @@ describe('http (MCP-over-HTTP)', () => {
   test('detects -32042 in a JSON body (JSON-RPC request)', async () => {
     expect(await Transport.http().isPaymentRequired(jsonBody(), jsonRpcRequest)).toBe(true)
   })
+  test('detects payment-required metadata in a JSON-RPC result', async () => {
+    expect(await Transport.http().isPaymentRequired(jsonResultBody(), jsonRpcRequest)).toBe(true)
+  })
   test('ignores a JSON-RPC response for a different request id', async () => {
     const response = new Response(JSON.stringify({ ...errorMessage, id: 2 }), {
       headers: { 'content-type': 'application/json' },
@@ -403,6 +500,10 @@ describe('http (MCP-over-HTTP)', () => {
     const challenges = await Transport.http().getChallenges!(sseBody(), jsonRpcRequest)
     expect(challenges.map((entry) => entry.id)).toEqual([challenge.id])
   })
+  test('getChallenges extracts an MCP result metadata challenge', async () => {
+    const challenges = await Transport.http().getChallenges!(jsonResultBody(), jsonRpcRequest)
+    expect(challenges.map((entry) => entry.id)).toEqual([challenge.id])
+  })
   test('setCredential routes the MCP challenge into the JSON-RPC _meta', async () => {
     const transport = Transport.http()
     const [mcpChallenge] = await transport.getChallenges!(sseBody(), jsonRpcRequest)
@@ -473,6 +574,20 @@ describe('mcp', () => {
       },
     },
   }
+  const mcpResult: Mcp.Response = {
+    jsonrpc: '2.0',
+    id: 1,
+    result: {
+      content: [],
+      isError: true,
+      _meta: {
+        [Mcp.paymentRequiredMetaKey]: {
+          httpStatus: 402,
+          challenges: [challenge],
+        },
+      },
+    },
+  }
 
   test('extracts payment-required challenges from JSON-RPC errors', async () => {
     const transport = Transport.mcp()
@@ -483,6 +598,15 @@ describe('mcp', () => {
     ])
   })
 
+  test('extracts payment-required challenges from tool result metadata', async () => {
+    const transport = Transport.mcp()
+
+    expect(await transport.isPaymentRequired(mcpResult)).toBe(true)
+    expect((await transport.getChallenges?.(mcpResult))?.map((entry) => entry.id)).toEqual([
+      challenge.id,
+    ])
+  })
+
   test('sets credentials in JSON-RPC _meta', () => {
     const result = Transport.mcp().setCredential(mcpRequest, Credential.serialize(credential))
 

package/src/client/Transport.ts

@@ -1,7 +1,7 @@
 import * as Challenge from '../Challenge.js'
 import * as Credential from '../Credential.js'
 import * as Mcp from '../Mcp.js'
-import { mcp as mcpProtocol } from './internal/protocols/Mcp.js'
+import { mcp as mcpProtocol, paymentRequiredData } 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'
@@ -144,6 +144,12 @@ export function http(): Transport<RequestInit, Response> {
   })
 }
 
+function mcpPaymentRequiredChallenges(response: Mcp.Response) {
+  const data = paymentRequiredData(response)
+  if (!data) throw new Error('No challenge in response.')
+  return data.challenges
+}
+
 /**
  * MCP protocol transport for direct JSON-RPC objects.
  *
@@ -155,20 +161,16 @@ export function mcp() {
     name: 'mcp',
 
     isPaymentRequired(response) {
-      return 'error' in response && response.error?.code === Mcp.paymentRequiredCode
+      return !!paymentRequiredData(response)
     },
 
     getChallenges(response) {
-      if (!('error' in response) || !response.error) throw new Error('Response is not an error.')
-      const challenges = response.error.data?.challenges
-      if (!challenges?.length) throw new Error('No challenge in error response.')
-      return challenges
+      return mcpPaymentRequiredChallenges(response)
     },
 
     getChallenge(response) {
-      if (!('error' in response) || !response.error) throw new Error('Response is not an error.')
-      const challenge = response.error.data?.challenges[0]
-      if (!challenge) throw new Error('No challenge in error response.')
+      const challenge = mcpPaymentRequiredChallenges(response)[0]
+      if (!challenge) throw new Error('No challenge in response.')
       return challenge
     },
 

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

@@ -57,6 +57,15 @@ describe('Fetch.from', () => {
     })
   })
 
+  test('behavior: accepts payment retry cap', () => {
+    const fetch = Fetch.from({
+      maxPaymentRetries: 1,
+      methods: [charge()],
+    })
+
+    expectTypeOf(fetch).toBeFunction()
+  })
+
   test('behavior: events infer payload types from methods', () => {
     const method = charge()
     const dispatcher = Fetch.createEventDispatcher<[typeof method]>()