mppx 0.8.17 → 0.8.18

package/src/proxy/internal/Route.test.ts

@@ -1,217 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import * as Route from './Route.js'
-
-describe('pathname', () => {
-  test('behavior: returns pathname without basePath', () => {
-    expect(
-      Route.pathname(new URL('http://localhost/api/proxy/openai/v1/models'), '/api/proxy'),
-    ).toBe('/openai/v1/models')
-  })
-
-  test('behavior: handles basePath with trailing slash', () => {
-    expect(
-      Route.pathname(new URL('http://localhost/api/proxy/stripe/v1/charges'), '/api/proxy/'),
-    ).toBe('/stripe/v1/charges')
-  })
-
-  test('behavior: returns pathname as-is when no basePath', () => {
-    expect(Route.pathname(new URL('http://localhost/openai/v1/models'))).toBe('/openai/v1/models')
-  })
-
-  test('error: returns null when basePath does not match', () => {
-    expect(
-      Route.pathname(new URL('http://localhost/other/openai/v1/models'), '/api/proxy'),
-    ).toBeNull()
-  })
-
-  test('error: returns null for basePath prefix collision', () => {
-    expect(Route.pathname(new URL('http://localhost/proxy2/openai/v1/models'), '/proxy')).toBeNull()
-  })
-
-  test('behavior: returns empty string when pathname equals basePath', () => {
-    expect(Route.pathname(new URL('http://localhost/proxy'), '/proxy')).toBe('')
-  })
-})
-
-describe('parse', () => {
-  test('behavior: extracts serviceId and upstreamPath', () => {
-    expect(Route.parse('/openai/v1/chat/completions')).toMatchInlineSnapshot(`
-      {
-        "serviceId": "openai",
-        "upstreamPath": "/v1/chat/completions",
-      }
-    `)
-  })
-
-  test('behavior: parses anthropic service path', () => {
-    expect(Route.parse('/anthropic/v1/messages')).toMatchInlineSnapshot(`
-      {
-        "serviceId": "anthropic",
-        "upstreamPath": "/v1/messages",
-      }
-    `)
-  })
-
-  test('behavior: returns root upstreamPath when no sub-path', () => {
-    expect(Route.parse('/stripe')).toMatchInlineSnapshot(`
-      {
-        "serviceId": "stripe",
-        "upstreamPath": "/",
-      }
-    `)
-  })
-
-  test('error: returns null for root path', () => {
-    expect(Route.parse('/')).toBeNull()
-  })
-
-  test('error: returns null for empty pathname', () => {
-    expect(Route.parse('')).toBeNull()
-  })
-})
-
-describe('match', () => {
-  test('behavior: matches exact method and path', () => {
-    const routes = { 'POST /v1/chat/completions': 'chat' }
-    const result = Route.match(routes, 'POST', '/v1/chat/completions')
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "key": "POST /v1/chat/completions",
-        "value": "chat",
-      }
-    `)
-  })
-
-  test('behavior: matches wildcard pattern', () => {
-    const routes = { 'POST /v1/images/*': 'images' }
-    const result = Route.match(routes, 'POST', '/v1/images/generations')
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "key": "POST /v1/images/*",
-        "value": "images",
-      }
-    `)
-  })
-
-  test('behavior: method-less pattern matches any method', () => {
-    const routes = { '/v1/*': 'catchall' }
-    expect(Route.match(routes, 'GET', '/v1/models')).toMatchInlineSnapshot(`
-      {
-        "key": "/v1/*",
-        "value": "catchall",
-      }
-    `)
-    expect(Route.match(routes, 'POST', '/v1/completions')).toMatchInlineSnapshot(`
-      {
-        "key": "/v1/*",
-        "value": "catchall",
-      }
-    `)
-  })
-
-  test('behavior: matches named params', () => {
-    const routes = { 'GET /v1/users/:id': 'user' }
-    const result = Route.match(routes, 'GET', '/v1/users/123')
-    expect(result).toMatchInlineSnapshot(`
-      {
-        "key": "GET /v1/users/:id",
-        "value": "user",
-      }
-    `)
-  })
-
-  test('behavior: first match wins', () => {
-    const routes = {
-      'POST /v1/chat/completions': 'specific',
-      'POST /v1/*': 'general',
-    }
-    expect(Route.match(routes, 'POST', '/v1/chat/completions')?.value).toBe('specific')
-  })
-
-  test('behavior: case insensitive method matching', () => {
-    const routes = { 'POST /v1/chat': 'chat' }
-    expect(Route.match(routes, 'post', '/v1/chat')).toMatchInlineSnapshot(`
-      {
-        "key": "POST /v1/chat",
-        "value": "chat",
-      }
-    `)
-  })
-
-  test('error: returns null when no match', () => {
-    const routes = { 'POST /v1/chat/completions': 'chat' }
-    expect(Route.match(routes, 'POST', '/v2/unknown')).toBeNull()
-  })
-
-  test('error: returns null for wrong method', () => {
-    const routes = { 'POST /v1/chat/completions': 'chat' }
-    expect(Route.match(routes, 'GET', '/v1/chat/completions')).toBeNull()
-  })
-})
-
-describe('matchPath', () => {
-  const paidOnly = (v: unknown) => v !== true
-
-  test('behavior: matches route by path without filter', () => {
-    const routes = { 'GET /v1/models': true }
-    expect(Route.matchPath(routes, '/v1/models')).toMatchObject({
-      key: 'GET /v1/models',
-    })
-  })
-
-  test('behavior: matches paid endpoint by path', () => {
-    const routes = { 'GET /v1/generate': { pay: () => {} } }
-    expect(Route.matchPath(routes, '/v1/generate', paidOnly)).toMatchObject({
-      key: 'GET /v1/generate',
-    })
-  })
-
-  test('behavior: skips free passthrough routes with filter', () => {
-    const routes = {
-      'GET /v1/models': true,
-      'POST /v1/generate': { pay: () => {} },
-    }
-    expect(Route.matchPath(routes, '/v1/models', paidOnly)).toBeNull()
-  })
-
-  test('behavior: matches paid route even with different method', () => {
-    const routes = {
-      'GET /v1/stream': { pay: () => {} },
-    }
-    expect(Route.matchPath(routes, '/v1/stream', paidOnly)).toMatchObject({
-      key: 'GET /v1/stream',
-    })
-  })
-
-  test('behavior: skips free and matches next paid route', () => {
-    const routes = {
-      'GET /v1/*': true,
-      'POST /v1/*': { pay: () => {} },
-    }
-    const result = Route.matchPath(routes, '/v1/cachedContents', paidOnly)
-    expect(result).toMatchObject({ key: 'POST /v1/*' })
-  })
-
-  // TODO (brendanryan): Relax this if `matchPath()` gains method-aware disambiguation.
-  test('error: returns null when multiple paid routes share the same path', () => {
-    const routes = {
-      'GET /v1/stream': { pay: () => {} },
-      'POST /v1/stream': { pay: () => {} },
-    }
-    expect(Route.matchPath(routes, '/v1/stream', paidOnly)).toBeNull()
-  })
-
-  test('error: returns null when all routes are free', () => {
-    const routes = {
-      'GET /v1/models': true,
-      'GET /v1/status': true,
-    }
-    expect(Route.matchPath(routes, '/v1/models', paidOnly)).toBeNull()
-  })
-
-  test('error: returns null when no path match', () => {
-    const routes = { 'POST /v1/generate': { pay: () => {} } }
-    expect(Route.matchPath(routes, '/v2/unknown', paidOnly)).toBeNull()
-  })
-})

package/src/proxy/internal/Route.ts

@@ -1,64 +0,0 @@
-const httpMethods = new Set(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'HEAD', 'OPTIONS'])
-
-/** Extracts the pathname from a URL, stripping the optional `basePath` prefix. Returns `null` if the path doesn't match. */
-export function pathname(url: URL, basePath?: string): string | null {
-  let pathname = url.pathname
-  if (basePath) {
-    const base = basePath.replace(/\/+$/, '')
-    if (!(pathname === base || pathname.startsWith(`${base}/`))) return null
-    pathname = pathname.slice(base.length)
-  }
-  return pathname
-}
-
-/** Splits a `/{serviceId}/rest/of/path` pathname into its service ID and upstream path. */
-export function parse(pathname: string): { serviceId: string; upstreamPath: string } | null {
-  const segments = pathname.split('/').filter(Boolean)
-  const serviceId = segments[0]
-  if (!serviceId) return null
-
-  const upstreamPath = `/${segments.slice(1).join('/')}`
-  return { serviceId, upstreamPath }
-}
-
-/** Finds the first route matching both the HTTP method and path (via `URLPattern`). */
-export function match(
-  routes: Record<string, unknown>,
-  method: string,
-  path: string,
-): { key: string; value: unknown } | null {
-  for (const [key, value] of Object.entries(routes)) {
-    const { method: routeMethod, pattern } = parseRouteKey(key)
-    if (routeMethod && routeMethod !== method.toUpperCase()) continue
-    const urlPattern = new URLPattern({ pathname: pattern })
-    if (urlPattern.test({ pathname: path })) return { key, value }
-  }
-  return null
-}
-
-/** Finds the first route matching the path, ignoring the HTTP method. Optional `filter` predicate can exclude routes. */
-export function matchPath(
-  routes: Record<string, unknown>,
-  path: string,
-  filter?: (value: unknown) => boolean,
-): { key: string; value: unknown } | null {
-  let match: { key: string; value: unknown } | null = null
-  for (const [key, value] of Object.entries(routes)) {
-    if (filter && !filter(value)) continue
-    const { pattern } = parseRouteKey(key)
-    const urlPattern = new URLPattern({ pathname: pattern })
-    if (!urlPattern.test({ pathname: path })) continue
-    if (match) return null
-    match = { key, value }
-  }
-  return match
-}
-
-/** Parses a proxy route key like `"POST /v1/messages"` into method + pathname pattern. */
-export function parseRouteKey(key: string): { method: string | undefined; pattern: string } {
-  const tokens = key.trim().split(/\s+/)
-  if (tokens.length >= 2 && httpMethods.has(tokens[0]!.toUpperCase())) {
-    return { method: tokens[0]!.toUpperCase(), pattern: tokens.slice(1).join(' ') }
-  }
-  return { method: undefined, pattern: key }
-}

package/src/proxy/services/anthropic.test.ts

@@ -1,132 +0,0 @@
-import { Receipt } 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 { afterEach, describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-import { accounts, asset, client } from '~test/tempo/viem.js'
-
-import * as ApiProxy from '../Proxy.js'
-import { anthropic } from './anthropic.js'
-
-const apiKey = 'sk-ant-test-fake-anthropic-key'
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-const mppx_server = Mppx_server.create({
-  methods: [
-    tempo_server({
-      account: accounts[0],
-      currency: asset,
-      getClient: () => client,
-    }),
-  ],
-  secretKey,
-})
-
-const mppx_client = Mppx_client.create({
-  polyfill: false,
-  methods: [
-    tempo_client({
-      account: accounts[1],
-      getClient: () => client,
-    }),
-  ],
-})
-
-let proxyServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-let upstreamServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-
-afterEach(() => {
-  proxyServer?.close()
-  upstreamServer?.close()
-})
-
-describe('anthropic', () => {
-  test('behavior: proxies POST /v1/messages with charge and injects x-api-key', async () => {
-    upstreamServer = await Http.createServer((req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          headers: {
-            'x-api-key': req.headers['x-api-key'],
-          },
-        }),
-      )
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        anthropic({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/messages': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await mppx_client.fetch(`${proxyServer.url}/anthropic/v1/messages`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ model: 'claude-3-opus-20240229', max_tokens: 1, messages: [] }),
-    })
-    expect(res.status).toBe(200)
-
-    const body = (await res.json()) as { headers: { 'x-api-key': string } }
-    expect(body.headers['x-api-key']).toBe(apiKey)
-
-    const receipt = Receipt.fromResponse(res)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-  })
-
-  test('behavior: returns 402 without credential', async () => {
-    upstreamServer = await Http.createServer((_req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end('{}')
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        anthropic({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/messages': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/anthropic/v1/messages`, {
-      method: 'POST',
-    })
-    expect(res.status).toBe(402)
-    expect(res.headers.get('WWW-Authenticate')).toContain('Payment')
-  })
-
-  test('behavior: returns 404 for unmatched route', async () => {
-    upstreamServer = await Http.createServer((_req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end('{}')
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        anthropic({
-          apiKey,
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/messages': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/anthropic/v1/unknown`)
-    expect(res.status).toBe(404)
-  })
-})

package/src/proxy/services/anthropic.ts

@@ -1,53 +0,0 @@
-import * as Service from '../Service.js'
-
-/**
- * Creates an Anthropic service definition.
- *
- * Injects `x-api-key` header for upstream authentication.
- * Per-endpoint `apiKey` overrides are supported via `options`.
- *
- * @example
- * ```ts
- * anthropic({
- *   apiKey: 'sk-ant-...',
- *   routes: {
- *     'POST /v1/messages': mppx.charge({ amount: '0.03' }),
- *     'POST /v1/complete': mppx.charge({ amount: '0.02' }),
- *   },
- * })
- * ```
- */
-export function anthropic(config: anthropic.Config) {
-  return Service.from<anthropic.Config>('anthropic', {
-    baseUrl: config.baseUrl ?? 'https://api.anthropic.com',
-    categories: ['ai'],
-    description: 'Claude language models for messages and completions.',
-    docs: {
-      apiReference: 'https://docs.anthropic.com/en/api/getting-started',
-      homepage: 'https://docs.anthropic.com/en/docs/intro-to-claude',
-    },
-    onUpstreamError: config.onUpstreamError,
-    rewriteRequest(request, ctx) {
-      const apiKey = ctx.apiKey ?? config.apiKey
-      request.headers.set('x-api-key', apiKey)
-      return request
-    },
-    routes: config.routes,
-    title: 'Anthropic',
-  })
-}
-
-export declare namespace anthropic {
-  export type Config = Service.From<{
-    /** Anthropic API key. Used as `x-api-key` header. */
-    apiKey: string
-    /** Base URL override. Defaults to `'https://api.anthropic.com'`. */
-    baseUrl?: string | undefined
-    routes:
-      | 'POST /v1/messages'
-      | 'POST /v1/messages/batches'
-      | 'GET /v1/messages/batches'
-      | 'GET /v1/messages/batches/:batchId'
-      | 'POST /v1/complete'
-  }>
-}

package/src/proxy/services/hooks.test-d.ts

@@ -1,14 +0,0 @@
-import { expectTypeOf, test } from 'vp/test'
-
-import { openai } from './openai.js'
-
-test('upstream error hooks preserve service-specific context', () => {
-  openai({
-    apiKey: 'test',
-    onUpstreamError(context) {
-      expectTypeOf(context.apiKey).toEqualTypeOf<string | undefined>()
-      return { retry: false }
-    },
-    routes: { 'POST /v1/chat/completions': true },
-  })
-})

package/src/proxy/services/hooks.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, test } from 'vp/test'
-
-import type * as Service from '../Service.js'
-import { anthropic } from './anthropic.js'
-import { openai } from './openai.js'
-import { stripe } from './stripe.js'
-
-describe('service hooks', () => {
-  const onUpstreamError: Service.UpstreamErrorHandler = () => ({ retry: false })
-
-  test.each([
-    [
-      'openai',
-      () =>
-        openai({
-          apiKey: 'test',
-          onUpstreamError,
-          routes: { 'POST /v1/chat/completions': true },
-        }),
-    ],
-    [
-      'anthropic',
-      () =>
-        anthropic({
-          apiKey: 'test',
-          onUpstreamError,
-          routes: { 'POST /v1/messages': true },
-        }),
-    ],
-    [
-      'stripe',
-      () =>
-        stripe({
-          apiKey: 'test',
-          onUpstreamError,
-          routes: { 'POST /v1/charges': true },
-        }),
-    ],
-  ] as const)('preserves hooks for %s', (_name, createService) => {
-    const service = createService()
-
-    expect(service.onUpstreamError).toBe(onUpstreamError)
-  })
-})

package/src/proxy/services/openai.test.ts

@@ -1,157 +0,0 @@
-import { Receipt } 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 { afterEach, describe, expect, test } from 'vp/test'
-import * as Http from '~test/Http.js'
-import { accounts, asset, client } from '~test/tempo/viem.js'
-
-import * as ApiProxy from '../Proxy.js'
-import { openai } from './openai.js'
-
-const apiKey = process.env.VITE_OPENAI_API_KEY
-if (!apiKey) console.warn('OPENAI_API_KEY not set — openai proxy tests will be skipped')
-
-const secretKey = 'test-secret-key-test-secret-key-32'
-
-const mppx_server = Mppx_server.create({
-  methods: [
-    tempo_server({
-      account: accounts[0],
-      currency: asset,
-      getClient: () => client,
-    }),
-  ],
-  secretKey,
-})
-
-const mppx_client = Mppx_client.create({
-  polyfill: false,
-  methods: [
-    tempo_client({
-      account: accounts[1],
-      getClient: () => client,
-    }),
-  ],
-})
-
-let proxyServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-let upstreamServer: Awaited<ReturnType<typeof Http.createServer>> | undefined
-
-afterEach(() => {
-  proxyServer?.close()
-  upstreamServer?.close()
-})
-
-describe('openai', () => {
-  test('security: strips caller-supplied OpenAI tenant headers before proxying', async () => {
-    upstreamServer = await Http.createServer((req, res) => {
-      res.writeHead(200, { 'Content-Type': 'application/json' })
-      res.end(
-        JSON.stringify({
-          headers: {
-            authorization: req.headers.authorization,
-            organization: req.headers['openai-organization'],
-            project: req.headers['openai-project'],
-          },
-        }),
-      )
-    })
-
-    const proxy = ApiProxy.create({
-      services: [
-        openai({
-          apiKey: 'sk-test',
-          baseUrl: upstreamServer.url,
-          routes: {
-            'POST /v1/chat/completions': true,
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/openai/v1/chat/completions`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'OpenAI-Organization': 'org_attacker',
-        'OpenAI-Project': 'proj_attacker',
-      },
-      body: '{}',
-    })
-    expect(res.status).toBe(200)
-
-    const body = (await res.json()) as {
-      headers: {
-        authorization: string
-        organization?: string | string[] | undefined
-        project?: string | string[] | undefined
-      }
-    }
-    expect(body.headers.authorization).toBe('Bearer sk-test')
-    expect(body.headers.organization).toBeUndefined()
-    expect(body.headers.project).toBeUndefined()
-  })
-})
-
-describe.skipIf(!apiKey)('openai', () => {
-  test('behavior: proxies GET /v1/models with charge', async () => {
-    const proxy = ApiProxy.create({
-      services: [
-        openai({
-          apiKey: apiKey!,
-          routes: {
-            'GET /v1/models': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await mppx_client.fetch(`${proxyServer.url}/openai/v1/models`)
-    expect(res.status).toBe(200)
-
-    const body = (await res.json()) as { data: unknown[] }
-    expect(body.data).toBeDefined()
-    expect(Array.isArray(body.data)).toBe(true)
-
-    const receipt = Receipt.fromResponse(res)
-    expect(receipt.status).toBe('success')
-    expect(receipt.method).toBe('tempo')
-  })
-
-  test('behavior: returns 402 without credential', async () => {
-    const proxy = ApiProxy.create({
-      services: [
-        openai({
-          apiKey: apiKey!,
-          routes: {
-            'GET /v1/models': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/openai/v1/models`)
-    expect(res.status).toBe(402)
-    expect(res.headers.get('WWW-Authenticate')).toContain('Payment')
-  })
-
-  test('behavior: returns 404 for unmatched route', async () => {
-    const proxy = ApiProxy.create({
-      services: [
-        openai({
-          apiKey: apiKey!,
-          routes: {
-            'GET /v1/models': mppx_server.charge({ amount: '1', decimals: 6 }),
-          },
-        }),
-      ],
-    })
-    proxyServer = await Http.createServer(proxy.listener)
-
-    const res = await fetch(`${proxyServer.url}/openai/v1/unknown`)
-    expect(res.status).toBe(404)
-  })
-})