mppx 0.8.14 → 0.8.17

package/src/middlewares/hono.test.ts

@@ -4,7 +4,7 @@ import { Challenge, Credential, Method, Receipt, z } from 'mppx'
 import {
   evm as evm_client,
   Mppx as Mppx_client,
-  sessionLegacy as sessionIntent,
+  session as sessionIntent,
   tempo as tempo_client,
 } from 'mppx/client'
 import { Mppx, discovery, payment } from 'mppx/hono'
@@ -15,11 +15,9 @@ import {
   paymentSignatureHeader,
   type PaymentPayload,
 } from 'mppx/x402'
-import type { Address } from 'viem'
 import { Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
-import { deployEscrow } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client, fundAccount } from '~test/tempo/viem.js'
 
 function createServer(app: Hono) {
@@ -203,7 +201,9 @@ describe('charge', () => {
     const { mppx } = createChargeHarness(false)
 
     const app = new Hono()
-    app.get('/', mppx.charge({ amount: '1' }), (c) => c.json({ fortune: 'You will be rich' }))
+    app.get('/', mppx.charge({ amount: '1', description: 'Daily fortune' }), (c) =>
+      c.json({ fortune: 'You will be rich' }),
+    )
     discovery(app, mppx, { auto: true, info: { title: 'Auto API', version: '2.0.0' } })
 
     const server = await createServer(app)
@@ -216,6 +216,7 @@ describe('charge', () => {
     expect(body.paths['/'].get['x-payment-info'].offers[0]).toMatchObject({
       amount: '1000000',
       currency: asset,
+      description: 'Daily fortune',
       intent: 'charge',
       method: 'tempo',
     })
@@ -386,16 +387,13 @@ describe('scope binding', () => {
 })
 
 describe('session', () => {
-  let escrowContract: Address
-
   function createSessionHarness(feePayer: boolean) {
     const mppx = Mppx.create({
       methods: [
-        tempo_server.sessionLegacy({
+        tempo_server.session({
           getClient: () => client,
           account: accounts[0],
           currency: asset,
-          escrowContract,
           ...(feePayer ? { feePayer: accounts[1] } : {}),
         } as any),
       ],
@@ -417,7 +415,6 @@ describe('session', () => {
   }
 
   beforeAll(async () => {
-    escrowContract = await deployEscrow()
     await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
     await fundAccount({ address: accounts[1].address, token: asset })
     await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })

package/src/middlewares/nextjs.test.ts

@@ -1,18 +1,12 @@
 import * as http from 'node:http'
 
 import { Challenge, Credential, Receipt } from 'mppx'
-import {
-  Mppx as Mppx_client,
-  sessionLegacy as sessionIntent,
-  tempo as tempo_client,
-} from 'mppx/client'
+import { Mppx as Mppx_client, session as sessionIntent, tempo as tempo_client } from 'mppx/client'
 import { Mppx, discovery, payment } from 'mppx/nextjs'
 import { tempo as tempo_server } from 'mppx/server'
-import type { Address } from 'viem'
 import { Addresses } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
 import * as TestHttp from '~test/Http.js'
-import { deployEscrow } from '~test/tempo/legacy/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
 
 function createServer(handler: (request: Request) => Promise<Response> | Response) {
@@ -278,16 +272,13 @@ describe('charge', () => {
 })
 
 describe('session', () => {
-  let escrowContract: Address
-
   function createSessionHarness(feePayer: boolean) {
     const mppx = Mppx.create({
       methods: [
-        tempo_server.sessionLegacy({
+        tempo_server.session({
           getClient: () => client,
           account: accounts[0],
           currency: asset,
-          escrowContract,
           ...(feePayer ? { feePayer: accounts[1] } : {}),
         } as any),
       ],
@@ -309,7 +300,6 @@ describe('session', () => {
   }
 
   beforeAll(async () => {
-    escrowContract = await deployEscrow()
     await fundAccount({ address: accounts[1].address, token: Addresses.pathUsd })
     await fundAccount({ address: accounts[1].address, token: asset })
     await fundAccount({ address: accounts[2].address, token: Addresses.pathUsd })

package/src/proxy/Proxy.test.ts

@@ -1,14 +1,12 @@
 import { Challenge, Credential, Method, Receipt, z } from 'mppx'
 import { Mppx as Mppx_client, tempo as tempo_client } from 'mppx/client'
 import { Mppx as Mppx_server, tempo as tempo_server } from 'mppx/server'
-import type { Address } from 'viem'
-import { afterEach, beforeAll, describe, expect, test } from 'vp/test'
+import { afterEach, describe, expect, test } from 'vp/test'
 import { tempoNetwork } from '~test/config.js'
 import * as Http from '~test/Http.js'
-import { deployEscrow } from '~test/tempo/legacy/session.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'
 
-import { sessionManager } from '../tempo/legacy/client/index.js'
+import { sessionManager } from '../tempo/session/client/SessionManager.js'
 import { deserializeSessionReceipt } from '../tempo/session/precompile/Protocol.js'
 import * as ApiProxy from './Proxy.js'
 import * as Service from './Service.js'
@@ -76,13 +74,6 @@ const mppx_client = Mppx_client.create({
 
 let upstream: Awaited<ReturnType<typeof Http.createServer>> | undefined
 let proxyServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-let sessionEscrow: Address
-
-beforeAll(async () => {
-  if (!isLocalnet) return
-  sessionEscrow = await deployEscrow()
-})
-
 afterEach(() => {
   upstream?.close()
   proxyServer?.close()
@@ -181,6 +172,7 @@ describe('create', () => {
   })
 
   test('behavior: GET /openapi.json returns discovery JSON', async () => {
+    const alternateAsset = '0x20c0000000000000000000000000000000000002'
     const proxy = ApiProxy.create({
       categories: ['gateway'],
       docs: {
@@ -196,6 +188,10 @@ describe('create', () => {
           routes: {
             'GET /v1/models': true,
             'POST /v1/generate': mppx_server.charge({ amount: '1', description: 'Generate text' }),
+            'POST /v1/multi': mppx_server.compose(
+              ['tempo/charge', { amount: '1', currency: asset, decimals: 6 }],
+              ['tempo/charge', { amount: '2', currency: alternateAsset, decimals: 6 }],
+            ),
             'POST /v1/stream': mppx_server.session({
               amount: '1',
               description: 'Stream text',
@@ -231,6 +227,20 @@ describe('create', () => {
       intent: 'charge',
       method: 'tempo',
     })
+    expect(body.paths['/api/v1/multi'].post['x-payment-info'].offers).toEqual([
+      expect.objectContaining({
+        amount: '1000000',
+        currency: asset,
+        intent: 'charge',
+        method: 'tempo',
+      }),
+      expect.objectContaining({
+        amount: '2000000',
+        currency: alternateAsset,
+        intent: 'charge',
+        method: 'tempo',
+      }),
+    ])
     expect(body.paths['/api/v1/stream'].post['x-payment-info'].offers[0]).toMatchObject({
       amount: '1000000',
       currency: asset,
@@ -576,7 +586,7 @@ describe('create', () => {
     expect(res.status).toBe(402)
   })
 
-  test('behavior: management POST uses credential method binding to disambiguate same-path paid routes', async () => {
+  test('behavior: management POST uses composed credential binding to disambiguate same-path paid routes', async () => {
     const alpha = Method.from({
       name: 'alpha',
       intent: 'charge',
@@ -631,7 +641,7 @@ describe('create', () => {
         Service.from('api', {
           baseUrl: 'https://example.com',
           routes: {
-            'GET /v1/stream': handler['alpha/charge']({ amount: '1' }),
+            'GET /v1/stream': handler.compose(['alpha/charge', { amount: '1' }]),
             'PATCH /v1/stream': handler['beta/charge']({ amount: '1' }),
           },
         }),
@@ -907,10 +917,9 @@ describe.runIf(isLocalnet)('plain HTTP session proxy', () => {
 
     const sessionHandler = Mppx_server.create({
       methods: [
-        tempo_server.sessionLegacy({
+        tempo_server.session({
           account: accounts[0],
           currency: asset,
-          escrowContract: sessionEscrow,
           getClient: () => client,
           chainId: client.chain!.id,
         }),
@@ -937,7 +946,6 @@ describe.runIf(isLocalnet)('plain HTTP session proxy', () => {
     const manager = sessionManager({
       account: accounts[1],
       client,
-      escrowContract: sessionEscrow,
       fetch: globalThis.fetch,
       maxDeposit: '3',
     })
@@ -967,10 +975,9 @@ describe.runIf(isLocalnet)('plain HTTP session proxy', () => {
 
     const sessionHandler = Mppx_server.create({
       methods: [
-        tempo_server.sessionLegacy({
+        tempo_server.session({
           account: accounts[0],
           currency: asset,
-          escrowContract: sessionEscrow,
           getClient: () => client,
           chainId: client.chain!.id,
         }),
@@ -997,7 +1004,7 @@ describe.runIf(isLocalnet)('plain HTTP session proxy', () => {
     const sessionClient = Mppx_client.create({
       polyfill: false,
       methods: [
-        tempo_client.sessionLegacy.method({
+        tempo_client.session({
           account: accounts[1],
           getClient: () => client,
           maxDeposit: '2',

package/src/proxy/Proxy.ts

@@ -128,7 +128,14 @@ export function create(config: create.Config): Proxy {
     const endpoint = matched.value as Service.Endpoint
     const ctx: Service.Context = { request, service, upstreamPath }
 
-    if (endpoint === true) return proxyUpstream({ request, service, ctx, proxy })
+    if (endpoint === true)
+      return proxyUpstream({
+        request,
+        service,
+        ctx,
+        proxy,
+        onUpstreamError: service.onUpstreamError ?? config.onUpstreamError,
+      })
 
     const handler = typeof endpoint === 'function' ? endpoint : endpoint.pay
     const scope =
@@ -161,6 +168,7 @@ export function create(config: create.Config): Proxy {
       service,
       ctx: { ...ctx, ...options },
       proxy,
+      onUpstreamError: service.onUpstreamError ?? config.onUpstreamError,
     })
     return result.withReceipt(upstreamRes)
   }
@@ -183,6 +191,8 @@ export declare namespace create {
     docs?: Service.Docs | undefined
     /** Custom `fetch` implementation. Defaults to `globalThis.fetch`. */
     fetch?: typeof globalThis.fetch | undefined
+    /** Default handler for failed upstream attempts. Services may override it. */
+    onUpstreamError?: Service.UpstreamErrorHandler | undefined
     /** Services to proxy. Each service is mounted at `/{serviceId}/`. */
     services: Service.Service[]
     /** Human-readable title for the proxy shown in `llms.txt`. */
@@ -195,6 +205,7 @@ export declare namespace create {
 declare namespace proxyUpstream {
   type Options = {
     ctx: Service.Context
+    onUpstreamError?: Service.UpstreamErrorHandler | undefined
     proxy: (input: URL | RequestInfo, init?: RequestInit) => Promise<Response>
     request: globalThis.Request
     service: Service.Service
@@ -203,7 +214,7 @@ declare namespace proxyUpstream {
 
 /** @internal */
 async function proxyUpstream(options: proxyUpstream.Options): Promise<Response> {
-  const { request, service, ctx, proxy } = options
+  const { request, service, ctx, proxy, onUpstreamError } = options
   const url = ctx.upstreamPath + new URL(request.url).search
   const headers = Headers.scrub(request.headers)
 
@@ -221,17 +232,137 @@ async function proxyUpstream(options: proxyUpstream.Options): Promise<Response>
     init.duplex = 'half'
   }
 
-  let upstreamReq = new globalThis.Request(new URL(url, new URL(service.baseUrl).origin), init)
+  const upstreamRequest = new globalThis.Request(
+    new URL(url, new URL(service.baseUrl).origin),
+    init,
+  )
+
+  if (!onUpstreamError)
+    return proxyUpstreamOnce({
+      ctx,
+      proxy,
+      service,
+      upstreamRequest,
+    })
+
+  for (let attempt = 1; ; attempt++) {
+    const outcome = await proxyUpstreamAttempt({
+      ctx,
+      proxy,
+      service,
+      upstreamRequest,
+    })
+
+    let response = outcome.response
+    if (response && service.rewriteResponse) response = await service.rewriteResponse(response, ctx)
+    if (response?.ok) return response
+
+    const handlerResponse = response?.clone()
 
-  if (service.rewriteRequest) upstreamReq = await service.rewriteRequest(upstreamReq, ctx)
+    const action = await onUpstreamError({
+      ...ctx,
+      attempt,
+      error: outcome.error,
+      response: handlerResponse,
+      upstreamRequest: outcome.upstreamRequest,
+    })
+
+    if (!action.retry) {
+      if (action.response) {
+        if (response) void cancelResponseBody(response)
+        return action.response
+      }
+      if (response) {
+        if (handlerResponse) void cancelResponseBody(handlerResponse)
+        return response
+      }
+      throw outcome.error
+    }
+
+    for (const failedResponse of [response, handlerResponse])
+      if (failedResponse) void cancelResponseBody(failedResponse)
+    await waitForRetry(action.delay, request.signal)
+  }
+}
+
+/** Proxies one request without retaining a replay copy of its body. */
+async function proxyUpstreamOnce(options: proxyUpstreamAttempt.Options): Promise<Response> {
+  const { ctx, proxy, service } = options
+  let upstreamRequest = options.upstreamRequest
 
-  let upstreamRes = await proxy(upstreamReq)
+  if (service.rewriteRequest) upstreamRequest = await service.rewriteRequest(upstreamRequest, ctx)
 
-  upstreamRes = Headers.scrubResponse(upstreamRes)
+  let response = await proxy(upstreamRequest)
+  response = Headers.scrubResponse(response)
 
-  if (service.rewriteResponse) upstreamRes = await service.rewriteResponse(upstreamRes, ctx)
+  if (service.rewriteResponse) response = await service.rewriteResponse(response, ctx)
 
-  return upstreamRes
+  return response
+}
+
+declare namespace proxyUpstreamAttempt {
+  type Options = {
+    ctx: Service.Context
+    proxy: (input: URL | RequestInfo, init?: RequestInit) => Promise<Response>
+    service: Service.Service
+    upstreamRequest: Request
+  }
+
+  type Result = {
+    error: unknown | undefined
+    response: Response | undefined
+    upstreamRequest: Request
+  }
+}
+
+/** Performs one independently replayable upstream request attempt. */
+async function proxyUpstreamAttempt(
+  options: proxyUpstreamAttempt.Options,
+): Promise<proxyUpstreamAttempt.Result> {
+  const { ctx, proxy, service } = options
+  let upstreamRequest = options.upstreamRequest.clone()
+
+  try {
+    if (service.rewriteRequest) upstreamRequest = await service.rewriteRequest(upstreamRequest, ctx)
+
+    let response = await proxy(upstreamRequest)
+    response = Headers.scrubResponse(response)
+
+    return { error: undefined, response, upstreamRequest }
+  } catch (error) {
+    return { error, response: undefined, upstreamRequest }
+  }
+}
+
+/** Cancels an unused failed response body before a retry. */
+async function cancelResponseBody(response: Response): Promise<void> {
+  if (!response.body || response.bodyUsed) return
+  try {
+    await response.body.cancel()
+  } catch {
+    return
+  }
+}
+
+/** Waits for a retry delay while respecting request cancellation. */
+async function waitForRetry(delay = 0, signal: AbortSignal): Promise<void> {
+  if (signal.aborted)
+    throw signal.reason ?? new DOMException('The operation was aborted.', 'AbortError')
+  if (!Number.isFinite(delay) || delay <= 0) return
+
+  await new Promise<void>((resolve, reject) => {
+    const onAbort = () => {
+      clearTimeout(timeout)
+      signal.removeEventListener('abort', onAbort)
+      reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'))
+    }
+    const timeout = setTimeout(() => {
+      signal.removeEventListener('abort', onAbort)
+      resolve()
+    }, delay)
+    signal.addEventListener('abort', onAbort, { once: true })
+    if (signal.aborted) onAbort()
+  })
 }
 
 function buildDiscoveryRoutes(services: Service.Service[]) {
@@ -310,7 +441,14 @@ function matchesPaymentBinding(endpoint: unknown, binding: PaymentBinding | null
   if (!binding) return true
   const payment = Service.paymentOf(endpoint as Exclude<Service.Endpoint, true>)
   if (!payment) return true
-  return payment.method === binding.method && payment.intent === binding.intent
+  const offers = Array.isArray(payment.offers) ? payment.offers : [payment]
+  return offers.some(
+    (offer) =>
+      typeof offer === 'object' &&
+      offer !== null &&
+      offer.method === binding.method &&
+      offer.intent === binding.intent,
+  )
 }
 
 function createFetchProxy(