mppx 0.8.17 → 0.8.18

package/src/proxy/Proxy.upstreamError.test.ts

@@ -1,364 +0,0 @@
-import { describe, expect, test, vi } from 'vp/test'
-
-import * as Mppx from '../server/Mppx.js'
-import * as Proxy from './Proxy.js'
-import * as Service from './Service.js'
-
-type CreatePaidProxyParameters = {
-  fetch: typeof globalThis.fetch
-  method?: 'GET' | 'POST' | undefined
-  onPayment?: (() => void) | undefined
-  onProxyError?: Service.UpstreamErrorHandler | undefined
-  onServiceError?: Service.UpstreamErrorHandler | undefined
-  rewriteRequest?: Service.Service['rewriteRequest']
-  rewriteResponse?: Service.Service['rewriteResponse']
-}
-
-function createPaidProxy(parameters: CreatePaidProxyParameters): Proxy.Proxy {
-  const method = parameters.method ?? 'GET'
-  const service = Service.from('api', {
-    baseUrl: 'https://upstream.example',
-    onUpstreamError: parameters.onServiceError,
-    rewriteRequest: parameters.rewriteRequest,
-    routes: {
-      [`${method} /resource`]: createPaidHandler(parameters.onPayment),
-    },
-  })
-  service.rewriteResponse = parameters.rewriteResponse
-  return Proxy.create({
-    fetch: parameters.fetch,
-    onUpstreamError: parameters.onProxyError,
-    services: [service],
-  })
-}
-
-function createPaidHandler(onPayment?: () => void): Service.IntentHandler {
-  return async () => {
-    onPayment?.()
-    return {
-      status: 200,
-      withReceipt<response>(response: response): response {
-        if (!(response instanceof Response)) throw new Mppx.MissingReceiptResponseError()
-        const headers = new Headers(response.headers)
-        headers.set('Payment-Receipt', 'test-receipt')
-        return new Response(response.body, {
-          headers,
-          status: response.status,
-          statusText: response.statusText,
-        }) as response
-      },
-    }
-  }
-}
-
-function paidRequest(init?: RequestInit): Request {
-  const headers = new Headers(init?.headers)
-  headers.set('Authorization', 'Payment test-credential')
-  return new Request('https://proxy.example/api/resource', {
-    ...init,
-    headers,
-  })
-}
-
-describe('onUpstreamError', () => {
-  test('retries upstream without verifying payment again', async () => {
-    const onPayment = vi.fn()
-    const onUpstreamError = vi.fn((context: Service.UpstreamErrorContext) => ({
-      retry: context.attempt < 3,
-    })) as Service.UpstreamErrorHandler
-    let attempts = 0
-    const fetch = vi.fn(async () => {
-      attempts++
-      if (attempts < 3) return new Response('unavailable', { status: 503 })
-      return Response.json({ ok: true })
-    }) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onPayment, onServiceError: onUpstreamError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(200)
-    expect(response.headers.get('Payment-Receipt')).toBe('test-receipt')
-    expect(await response.json()).toEqual({ ok: true })
-    expect(fetch).toHaveBeenCalledTimes(3)
-    expect(onPayment).toHaveBeenCalledTimes(1)
-    expect(onUpstreamError).toHaveBeenCalledTimes(2)
-    expect(onUpstreamError).toHaveBeenCalledWith(
-      expect.objectContaining({
-        attempt: 1,
-        error: undefined,
-        response: expect.objectContaining({ status: 503 }),
-        service: expect.objectContaining({ id: 'api' }),
-        upstreamPath: '/resource',
-        upstreamRequest: expect.objectContaining({ url: 'https://upstream.example/resource' }),
-      }),
-    )
-  })
-
-  test('uses the proxy handler when the service has no override', async () => {
-    const upstreamError = new Error('connection reset')
-    const onProxyError = vi.fn((context: Service.UpstreamErrorContext) => ({
-      retry: context.attempt < 2,
-    })) as Service.UpstreamErrorHandler
-    let attempts = 0
-    const fetch = vi.fn(async () => {
-      attempts++
-      if (attempts === 1) throw upstreamError
-      return new Response('recovered')
-    }) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onProxyError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(200)
-    expect(await response.text()).toBe('recovered')
-    expect(response.headers.get('Payment-Receipt')).toBe('test-receipt')
-    expect(onProxyError).toHaveBeenCalledWith(
-      expect.objectContaining({
-        attempt: 1,
-        error: upstreamError,
-        response: undefined,
-      }),
-    )
-  })
-
-  test('prefers the service handler over the proxy default', async () => {
-    const onProxyError = vi.fn(() => ({ retry: true as const }))
-    const onServiceError = vi.fn(() => ({ retry: false as const }))
-    const fetch = vi.fn(
-      async () => new Response('rate limited', { status: 429 }),
-    ) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onProxyError, onServiceError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(429)
-    expect(response.headers.get('Payment-Receipt')).toBe('test-receipt')
-    expect(fetch).toHaveBeenCalledTimes(1)
-    expect(onServiceError).toHaveBeenCalledTimes(1)
-    expect(onProxyError).not.toHaveBeenCalled()
-  })
-
-  test('returns a handler fallback and attaches a receipt when it succeeds', async () => {
-    const onServiceError = vi.fn(() => ({
-      response: Response.json({ cached: true }),
-      retry: false as const,
-    }))
-    const fetch = vi.fn(
-      async () => new Response('unavailable', { status: 503 }),
-    ) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onServiceError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(200)
-    expect(response.headers.get('Payment-Receipt')).toBe('test-receipt')
-    expect(await response.json()).toEqual({ cached: true })
-  })
-
-  test('attaches a receipt when an upstream error is returned', async () => {
-    const fetch = vi.fn(
-      async () => new Response('upstream failed', { status: 500 }),
-    ) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(500)
-    expect(response.headers.get('Payment-Receipt')).toBe('test-receipt')
-    expect(await response.text()).toBe('upstream failed')
-  })
-
-  test('preserves streaming when error recovery is disabled', async () => {
-    const clone = vi.spyOn(Request.prototype, 'clone')
-    const fetch = vi.fn(async (input: URL | RequestInfo, init?: RequestInit) => {
-      expect(await new Request(input, init).text()).toBe('streamed body')
-      return new Response('ok')
-    }) as typeof globalThis.fetch
-    const proxy = Proxy.create({
-      fetch,
-      services: [
-        Service.from('api', {
-          baseUrl: 'https://upstream.example',
-          routes: { 'POST /resource': true },
-        }),
-      ],
-    })
-
-    try {
-      const response = await proxy.fetch(
-        new Request('https://proxy.example/api/resource', {
-          body: 'streamed body',
-          method: 'POST',
-        }),
-      )
-
-      expect(response.status).toBe(200)
-      expect(clone).not.toHaveBeenCalled()
-    } finally {
-      clone.mockRestore()
-    }
-  })
-
-  test('preserves a failed response body read by the handler', async () => {
-    const onServiceError = vi.fn(async ({ response }: Service.UpstreamErrorContext) => {
-      expect(await response?.text()).toBe('upstream failed')
-      return { retry: false as const }
-    })
-    const fetch = vi.fn(
-      async () => new Response('upstream failed', { status: 503 }),
-    ) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onServiceError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(503)
-    expect(await response.text()).toBe('upstream failed')
-  })
-
-  test('preserves a recovery response derived from the failed body', async () => {
-    const onServiceError = vi.fn(({ response }: Service.UpstreamErrorContext) => ({
-      response: new Response(response?.body, { status: 200 }),
-      retry: false as const,
-    }))
-    const fetch = vi.fn(
-      async () => new Response('recovered body', { status: 503 }),
-    ) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onServiceError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(200)
-    expect(response.headers.get('Payment-Receipt')).toBe('test-receipt')
-    expect(await response.text()).toBe('recovered body')
-  })
-
-  test('does not block a retry when the handler partially reads the failed body', async () => {
-    const onServiceError = vi.fn(async ({ response }: Service.UpstreamErrorContext) => {
-      await response?.body?.getReader().read()
-      return { retry: true as const }
-    })
-    let attempts = 0
-    const fetch = vi.fn(async () => {
-      attempts++
-      if (attempts > 1) return new Response('recovered')
-      return new Response(
-        new ReadableStream({
-          start(controller) {
-            controller.enqueue(new TextEncoder().encode('partial failure'))
-          },
-        }),
-        { status: 503 },
-      )
-    }) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onServiceError })
-
-    const response = await proxy.fetch(paidRequest())
-
-    expect(response.status).toBe(200)
-    expect(await response.text()).toBe('recovered')
-    expect(fetch).toHaveBeenCalledTimes(2)
-  })
-
-  test('does not retry response rewrite failures', async () => {
-    const rewriteError = new Error('invalid upstream response')
-    const onServiceError = vi.fn(() => ({ retry: true as const }))
-    const rewriteResponse = vi.fn(() => {
-      throw rewriteError
-    })
-    const fetch = vi.fn(async () => new Response('created')) as typeof globalThis.fetch
-    const proxy = createPaidProxy({
-      fetch,
-      method: 'POST',
-      onServiceError,
-      rewriteResponse,
-    })
-
-    await expect(
-      proxy.fetch(paidRequest({ body: 'create resource', method: 'POST' })),
-    ).rejects.toBe(rewriteError)
-    expect(fetch).toHaveBeenCalledTimes(1)
-    expect(onServiceError).not.toHaveBeenCalled()
-  })
-
-  test('preserves a POST body across delayed retries', async () => {
-    const bodies: string[] = []
-    const rewriteRequest = vi.fn((request: Request) => request)
-    const onServiceError = vi.fn(() => ({ delay: 1, retry: true as const }))
-    const fetch = vi.fn(async (input: URL | RequestInfo, init?: RequestInit) => {
-      const request = new Request(input, init)
-      bodies.push(await request.text())
-      if (bodies.length === 1) return new Response('rate limited', { status: 429 })
-      return Response.json({ ok: true })
-    }) as typeof globalThis.fetch
-    const proxy = createPaidProxy({
-      fetch,
-      method: 'POST',
-      onServiceError,
-      rewriteRequest,
-    })
-
-    const response = await proxy.fetch(
-      paidRequest({
-        body: JSON.stringify({ prompt: 'hello' }),
-        headers: { 'Content-Type': 'application/json' },
-        method: 'POST',
-      }),
-    )
-
-    expect(response.status).toBe(200)
-    expect(bodies).toEqual(['{"prompt":"hello"}', '{"prompt":"hello"}'])
-    expect(rewriteRequest).toHaveBeenCalledTimes(2)
-    expect(onServiceError).toHaveBeenCalledTimes(1)
-  })
-
-  test('stops a delayed retry when the client aborts', async () => {
-    const controller = new AbortController()
-    let handlerCalled: (() => void) | undefined
-    const called = new Promise<void>((resolve) => {
-      handlerCalled = resolve
-    })
-    const onServiceError: Service.UpstreamErrorHandler = () => {
-      handlerCalled?.()
-      return { delay: 60_000, retry: true }
-    }
-    const fetch = vi.fn(
-      async () => new Response('unavailable', { status: 503 }),
-    ) as typeof globalThis.fetch
-    const proxy = createPaidProxy({ fetch, onServiceError })
-    const response = proxy.fetch(paidRequest({ signal: controller.signal }))
-    const assertion = expect(response).rejects.toThrow('stop retrying')
-
-    await called
-    controller.abort(new Error('stop retrying'))
-
-    await assertion
-    expect(fetch).toHaveBeenCalledTimes(1)
-  })
-
-  test('also recovers free upstream routes without adding a receipt', async () => {
-    const onUpstreamError = vi.fn(() => ({ retry: true as const }))
-    let attempts = 0
-    const fetch = vi.fn(async () => {
-      attempts++
-      if (attempts === 1) return new Response('unavailable', { status: 503 })
-      return new Response('public resource')
-    }) as typeof globalThis.fetch
-    const proxy = Proxy.create({
-      fetch,
-      services: [
-        Service.from('api', {
-          baseUrl: 'https://upstream.example',
-          onUpstreamError,
-          routes: { 'GET /resource': true },
-        }),
-      ],
-    })
-
-    const response = await proxy.fetch(new Request('https://proxy.example/api/resource'))
-
-    expect(response.status).toBe(200)
-    expect(await response.text()).toBe('public resource')
-    expect(response.headers.get('Payment-Receipt')).toBeNull()
-    expect(fetch).toHaveBeenCalledTimes(2)
-  })
-})

package/src/proxy/Service.test.ts

@@ -1,252 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import * as Service from './Service.js'
-
-describe('from', () => {
-  test('behavior: creates service with id and baseUrl', () => {
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      routes: { 'GET /v1/status': true },
-    })
-    expect(service.id).toBe('api')
-    expect(service.baseUrl).toBe('https://api.example.com')
-  })
-
-  test('behavior: preserves upstream error hook', () => {
-    const onUpstreamError: Service.UpstreamErrorHandler = () => ({ retry: false })
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      onUpstreamError,
-      routes: { 'GET /v1/status': true },
-    })
-
-    expect(service.onUpstreamError).toBe(onUpstreamError)
-  })
-
-  test('behavior: bearer sets Authorization header', async () => {
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      bearer: 'sk-123',
-      routes: { 'GET /v1/data': true },
-    })
-    const req = new Request('https://example.com')
-    const ctx = { request: req, service, upstreamPath: '/v1/data' }
-    const result = await service.rewriteRequest!(req, ctx)
-    expect(result.headers.get('authorization')).toBe('Bearer sk-123')
-  })
-
-  test('behavior: headers sets custom headers', async () => {
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      headers: { 'X-Api-Key': 'secret' },
-      routes: { 'GET /v1/data': true },
-    })
-    const req = new Request('https://example.com')
-    const ctx = { request: req, service, upstreamPath: '/v1/data' }
-    const result = await service.rewriteRequest!(req, ctx)
-    expect(result.headers.get('x-api-key')).toBe('secret')
-  })
-
-  test('behavior: multiple headers sets all headers', async () => {
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      headers: { 'X-Key': 'a', 'X-Secret': 'b' },
-      routes: { 'GET /v1/data': true },
-    })
-    const req = new Request('https://example.com')
-    const ctx = { request: req, service, upstreamPath: '/v1/data' }
-    const result = await service.rewriteRequest!(req, ctx)
-    expect(result.headers.get('x-key')).toBe('a')
-    expect(result.headers.get('x-secret')).toBe('b')
-  })
-
-  test('behavior: mutate calls mutate function', async () => {
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      mutate: (req) => {
-        req.headers.set('X-Mutated', 'yes')
-        return req
-      },
-      routes: { 'GET /v1/data': true },
-    })
-    const req = new Request('https://example.com')
-    const ctx = { request: req, service, upstreamPath: '/v1/data' }
-    const result = await service.rewriteRequest!(req, ctx)
-    expect(result.headers.get('x-mutated')).toBe('yes')
-  })
-
-  test('behavior: no auth config means no rewriteRequest', () => {
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      routes: { 'GET /v1/data': true },
-    })
-    expect(service.rewriteRequest).toBeUndefined()
-  })
-
-  test('behavior: per-endpoint options override service bearer', async () => {
-    const handler: Service.IntentHandler = async () => ({
-      status: 200 as const,
-      withReceipt: <T>(r: T) => r,
-    })
-    const service = Service.from('api', {
-      baseUrl: 'https://api.example.com',
-      bearer: 'sk-default',
-      routes: {
-        'GET /v1/data': {
-          pay: handler,
-          options: { bearer: 'sk-override' },
-        },
-      },
-    })
-    const endpoint = service.routes['GET /v1/data']!
-    const options = Service.getOptions(endpoint)
-    const req = new Request('https://example.com')
-    const ctx = { request: req, service, upstreamPath: '/v1/data', ...options }
-    const result = await service.rewriteRequest!(req, ctx)
-    expect(result.headers.get('authorization')).toBe('Bearer sk-override')
-  })
-})
-
-describe('custom', () => {
-  test('behavior: alias for from', () => {
-    expect(Service.custom).toBe(Service.from)
-  })
-})
-
-describe('paymentOf', () => {
-  test('behavior: returns null for free passthrough endpoint', () => {
-    expect(Service.paymentOf(true)).toBeNull()
-  })
-
-  test('behavior: returns null for paid handler without _internal metadata', () => {
-    const handler: Service.IntentHandler = async () => ({
-      status: 200 as const,
-      withReceipt: <T>(r: T) => r,
-    })
-    expect(Service.paymentOf(handler)).toBeNull()
-  })
-
-  test('behavior: returns null for paid endpoint object without _internal metadata', () => {
-    const handler: Service.IntentHandler = async () => ({
-      status: 200 as const,
-      withReceipt: <T>(r: T) => r,
-    })
-    expect(Service.paymentOf({ pay: handler, options: {} })).toBeNull()
-  })
-
-  test('behavior: derives payment metadata from the canonical request', () => {
-    const handler = Object.assign(
-      async () => ({
-        status: 200 as const,
-        withReceipt: <T>(r: T) => r,
-      }),
-      {
-        _internal: {
-          _canonicalRequest: {
-            amount: '1000000',
-            currency: '0xUSDC',
-            recipient: '0x1',
-          },
-          _stableBinding: () => ({}),
-          amount: '1',
-          asset: 'raw-asset',
-          authorize: () => undefined,
-          client: { apiKey: 'secret' },
-          decimals: 6,
-          description: 'Generate text',
-          defaults: {},
-          intent: 'charge',
-          name: 'mock',
-          request: () => ({}),
-          respond: () => undefined,
-          schema: {},
-          stableBinding: () => ({}),
-          transport: {},
-          verify: () => undefined,
-        },
-      },
-    )
-
-    expect(Service.paymentOf(handler as never)).toEqual({
-      amount: '1000000',
-      currency: '0xUSDC',
-      description: 'Generate text',
-      intent: 'charge',
-      method: 'mock',
-      recipient: '0x1',
-    })
-  })
-
-  test('behavior: derives every explicitly composed payment offer', () => {
-    const handler = Object.assign(
-      async () => ({
-        status: 200 as const,
-        withReceipt: <T>(r: T) => r,
-      }),
-      {
-        _internal: {
-          offers: [
-            {
-              _canonicalRequest: { amount: '1000000', currency: '0xUSDC' },
-              amount: '1',
-              decimals: 6,
-              description: 'USDC',
-              intent: 'charge',
-              name: 'tempo',
-            },
-            {
-              _canonicalRequest: { amount: '2000000', currency: '0xNANOUSD' },
-              amount: '2',
-              decimals: 6,
-              description: 'NANOUSD',
-              intent: 'charge',
-              name: 'tempo',
-            },
-          ],
-        },
-      },
-    )
-
-    expect(Service.paymentOf(handler as never)).toEqual({
-      offers: [
-        {
-          amount: '1000000',
-          currency: '0xUSDC',
-          description: 'USDC',
-          intent: 'charge',
-          method: 'tempo',
-        },
-        {
-          amount: '2000000',
-          currency: '0xNANOUSD',
-          description: 'NANOUSD',
-          intent: 'charge',
-          method: 'tempo',
-        },
-      ],
-    })
-  })
-})
-
-describe('getOptions', () => {
-  test('behavior: returns options from endpoint object', () => {
-    const handler: Service.IntentHandler = async () => ({
-      status: 200 as const,
-      withReceipt: <T>(r: T) => r,
-    })
-    const endpoint: Service.Endpoint = { pay: handler, options: { apiKey: 'sk-123' } }
-    expect(Service.getOptions(endpoint)).toEqual({ apiKey: 'sk-123' })
-  })
-
-  test('behavior: returns undefined for function endpoint', () => {
-    const handler: Service.IntentHandler = async () => ({
-      status: 200 as const,
-      withReceipt: <T>(r: T) => r,
-    })
-    expect(Service.getOptions(handler)).toBeUndefined()
-  })
-
-  test('behavior: returns undefined for true endpoint', () => {
-    expect(Service.getOptions(true)).toBeUndefined()
-  })
-})