mppx 0.4.9 → 0.4.10

package/src/proxy/Proxy.ts

@@ -2,6 +2,7 @@ import type * as http from 'node:http'
 
 import { createFetchProxy } from '@remix-run/fetch-proxy'
 
+import { generateProxy } from '../discovery/OpenApi.js'
 import * as Request from '../server/Request.js'
 import * as Headers from './internal/Headers.js'
 import * as Route from './internal/Route.js'
@@ -55,6 +56,24 @@ export function create(config: create.Config): Proxy {
     }),
   )
 
+  // Pre-generate static discovery responses once at startup.
+  const openApiJson = JSON.stringify(
+    generateProxy({
+      basePath: config.basePath,
+      info: {
+        title: config.title ?? 'API Proxy',
+        version: config.version ?? '1.0.0',
+      },
+      routes: buildDiscoveryRoutes(config.services),
+      serviceInfo: buildServiceInfo(config),
+    }),
+  )
+  const llmsTxt = Service.toLlmsTxt(config.services, {
+    title: config.title,
+    description: config.description,
+    openApiPath: withBasePath(config.basePath, '/openapi.json'),
+  })
+
   async function handle(request: globalThis.Request): Promise<Response> {
     const url = new URL(request.url)
 
@@ -62,68 +81,22 @@ export function create(config: create.Config): Proxy {
 
     if (!pathname) return new Response('Not Found', { status: 404 })
 
-    if (request.method === 'GET' && pathname === '/llms.txt')
-      return new Response(
-        Service.toLlmsTxt(config.services, {
-          title: config.title,
-          description: config.description,
-        }),
-        { headers: { 'Content-Type': 'text/plain; charset=utf-8' } },
-      )
-
-    if (request.method === 'GET' && pathname === '/discover.md')
-      return new Response(
-        Service.toLlmsTxt(config.services, {
-          title: config.title,
-          description: config.description,
-        }),
-        { headers: { 'Content-Type': 'text/plain; charset=utf-8' } },
-      )
-
-    if (request.method === 'GET' && (pathname === '/discover' || pathname === '/discover/')) {
-      if (wantsMarkdown(request))
-        return new Response(
-          Service.toLlmsTxt(config.services, {
-            title: config.title,
-            description: config.description,
-          }),
-          { headers: { 'Content-Type': 'text/plain; charset=utf-8' } },
-        )
-      return Response.json(config.services.map(Service.serialize))
-    }
-
     if (
       request.method === 'GET' &&
-      (pathname === '/discover/all' || pathname === '/discover/all/')
+      (pathname === '/openapi.json' || pathname === '/openapi.json/')
     ) {
-      if (wantsMarkdown(request))
-        return new Response(Service.toServicesMarkdown(config.services), {
-          headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
-        })
-      return Response.json(config.services.map(Service.serialize))
-    }
-
-    if (request.method === 'GET' && pathname === '/discover/all.md')
-      return new Response(Service.toServicesMarkdown(config.services), {
-        headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+      return new Response(openApiJson, {
+        headers: {
+          'Cache-Control': 'public, max-age=300',
+          'Content-Type': 'application/json',
+        },
       })
-
-    {
-      // List service
-      const match =
-        pathname.match(/^\/discover\/([^/]+)\.md$/) ?? pathname.match(/^\/discover\/([^/]+)\/?$/)
-      if (request.method === 'GET' && match) {
-        const service = config.services.find((s) => s.id === match[1])
-        if (!service) return new Response('Not Found', { status: 404 })
-        const wantsText = pathname.endsWith('.md') || wantsMarkdown(request)
-        if (wantsText)
-          return new Response(Service.toMarkdown(service), {
-            headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
-          })
-        return Response.json(Service.serialize(service))
-      }
     }
 
+    if (request.method === 'GET' && pathname === '/llms.txt')
+      return new Response(llmsTxt, {
+        headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+      })
     const parsed = Route.parse(pathname)
     if (!parsed) return new Response('Not Found', { status: 404 })
 
@@ -177,14 +150,20 @@ export declare namespace create {
   export type Config = {
     /** Base path prefix to strip before routing (e.g. `'/api/proxy'`). */
     basePath?: string | undefined
+    /** Free-form categories for root discovery metadata. */
+    categories?: string[] | undefined
     /** Short description of the proxy shown in `llms.txt`. */
     description?: string | undefined
+    /** Structured documentation links for root discovery metadata. */
+    docs?: Service.Docs | undefined
     /** Custom `fetch` implementation. Defaults to `globalThis.fetch`. */
     fetch?: typeof globalThis.fetch | undefined
     /** Services to proxy. Each service is mounted at `/{serviceId}/`. */
     services: Service.Service[]
     /** Human-readable title for the proxy shown in `llms.txt`. */
     title?: string | undefined
+    /** Version to include in the generated OpenAPI document. */
+    version?: string | undefined
   }
 }
 
@@ -230,41 +209,40 @@ async function proxyUpstream(options: proxyUpstream.Options): Promise<Response>
   return upstreamRes
 }
 
-const aiUserAgents = [
-  'GPTBot',
-  'OAI-SearchBot',
-  'ChatGPT-User',
-  'anthropic-ai',
-  'ClaudeBot',
-  'claude-web',
-  'PerplexityBot',
-  'Perplexity-User',
-  'Google-Extended',
-  'Googlebot',
-  'Bingbot',
-  'Amazonbot',
-  'Applebot',
-  'Applebot-Extended',
-  'FacebookBot',
-  'meta-externalagent',
-  'Bytespider',
-  'DuckAssistBot',
-  'cohere-ai',
-  'AI2Bot',
-  'CCBot',
-  'Diffbot',
-  'YouBot',
-  'MistralAI-User',
-  'GoogleAgent-Mariner',
-]
-
-const terminalUserAgents = ['curl', 'Wget', 'HTTPie', 'httpie-go', 'mppx', 'presto', 'xh']
-
-function wantsMarkdown(request: globalThis.Request): boolean {
-  const accept = request.headers.get('accept')
-  if (accept && (accept.includes('text/markdown') || accept.includes('text/plain'))) return true
-  const ua = request.headers.get('user-agent') ?? ''
-  if (aiUserAgents.some((agent) => ua.includes(agent))) return true
-  if (terminalUserAgents.some((agent) => ua.includes(agent))) return true
-  return false
+function buildDiscoveryRoutes(services: Service.Service[]) {
+  return services.flatMap((service) =>
+    Object.entries(service.routes).map(([pattern, endpoint]) => {
+      const tokens = pattern.trim().split(/\s+/)
+      const hasMethod = tokens.length >= 2
+      const path = hasMethod ? tokens.slice(1).join(' ') : tokens[0]
+      return {
+        method: hasMethod ? tokens[0]! : 'GET',
+        path: `/${service.id}${path}`,
+        payment: endpoint ? Service.paymentOf(endpoint) : null,
+      }
+    }),
+  )
+}
+
+function buildServiceInfo(config: create.Config): { categories?: string[]; docs?: Service.Docs } {
+  const categories =
+    config.categories ??
+    Array.from(new Set(config.services.flatMap((service) => service.categories ?? [])))
+
+  const docs = {
+    ...(config.docs ?? {}),
+    llms: config.docs?.llms ?? withBasePath(config.basePath, '/llms.txt'),
+  }
+
+  return {
+    ...(categories.length > 0 ? { categories } : {}),
+    docs,
+  }
+}
+
+function withBasePath(basePath: string | undefined, path: string) {
+  if (!basePath) return path
+  const normalized = basePath.startsWith('/') ? basePath : `/${basePath}`
+  const trimmed = normalized.endsWith('/') ? normalized.slice(0, -1) : normalized
+  return `${trimmed}${path}`
 }

package/src/proxy/Service.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Service from './Service.js'
 
@@ -102,6 +102,28 @@ describe('custom', () => {
   })
 })
 
+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()
+  })
+})
+
 describe('getOptions', () => {
   test('behavior: returns options from endpoint object', () => {
     const handler: Service.IntentHandler = async () => ({

package/src/proxy/Service.ts

@@ -4,12 +4,14 @@ import { Value } from 'ox'
 export type Service = {
   /** Base URL of the upstream service (e.g. `'https://api.openai.com'`). */
   baseUrl: string
+  /** Free-form service categories for discovery metadata. */
+  categories?: string[] | undefined
   /** Short description of the service. */
   description?: string | undefined
+  /** Structured service documentation links for discovery metadata. */
+  docs?: Docs | undefined
   /** Unique identifier used as the URL prefix (e.g. `'openai'` → `/{id}/...`). */
   id: string
-  /** Returns a documentation URL. Called with no argument for the service root, or with a route pattern for per-endpoint docs. */
-  docsLlmsUrl?: ((options: { route?: string | undefined }) => string | undefined) | undefined
   /** Hook to modify the upstream request before sending (e.g. inject auth headers). */
   rewriteRequest?: ((req: Request, ctx: Context) => Request | Promise<Request>) | undefined
   /** Hook to modify the upstream response before returning to the client. */
@@ -20,6 +22,12 @@ export type Service = {
   title?: string | undefined
 }
 
+export type Docs = {
+  apiReference?: string | undefined
+  homepage?: string | undefined
+  llms?: string | undefined
+}
+
 /**
  * An endpoint definition.
  *
@@ -80,9 +88,10 @@ export function from<options = unknown>(id: string, config: from.Config<options>
   const rewriteFromConfig = resolveRewriteRequest(config)
   return {
     baseUrl: config.baseUrl,
+    categories: config.categories,
     description: config.description,
+    docs: resolveDocs(config),
     id,
-    docsLlmsUrl: resolveLlmsUrl(config.docsLlmsUrl),
     routes: config.routes,
     title: config.title,
     rewriteRequest: config.rewriteRequest
@@ -102,8 +111,12 @@ export declare namespace from {
     baseUrl: string
     /** Shorthand: inject `Authorization: Bearer {token}` header. */
     bearer?: string | undefined
+    /** Free-form service categories for discovery metadata. */
+    categories?: string[] | undefined
     /** Short description of the service. */
     description?: string | undefined
+    /** Structured service documentation links for discovery metadata. */
+    docs?: Docs | undefined
     /** Shorthand: inject custom headers. */
     headers?: Record<string, string> | undefined
     /** Documentation URL for the service. String for a static base URL, or a function receiving an optional endpoint pattern. */
@@ -157,32 +170,14 @@ function resolveRewriteRequest(
   return undefined
 }
 
-/** Serializes a service for discovery responses. */
-export function serialize(s: Service) {
-  return {
-    description: s.description,
-    id: s.id,
-    docsLlmsUrl: s.docsLlmsUrl?.({}),
-    routes: Object.entries(s.routes).map(([pattern, endpoint]) => {
-      const tokens = pattern.trim().split(/\s+/)
-      const hasMethod = tokens.length >= 2
-      const path = hasMethod ? tokens.slice(1).join(' ') : tokens[0]
-      return {
-        docsLlmsUrl: s.docsLlmsUrl?.({ route: pattern }),
-        method: hasMethod ? tokens[0] : undefined,
-        path: `/${s.id}${path}`,
-        pattern: hasMethod ? `${tokens[0]} /${s.id}${path}` : `/${s.id}${path}`,
-        payment: endpoint ? resolvePayment(endpoint) : null,
-      }
-    }),
-    title: s.title,
-  }
-}
-
 /** Renders an llms.txt markdown string for a list of services. */
 export function toLlmsTxt(
   services: Service[],
-  options?: { title?: string | undefined; description?: string | undefined },
+  options?: {
+    description?: string | undefined
+    openApiPath?: string | undefined
+    title?: string | undefined
+  },
 ): string {
   const lines: string[] = [
     `# ${options?.title ?? 'API Proxy'}`,
@@ -197,65 +192,13 @@ export function toLlmsTxt(
   for (const s of services) {
     const label = s.title ?? s.id
     const desc = s.description ? `: ${s.description}` : ''
-    lines.push(`- [${label}](/discover/${s.id}.md)${desc}`)
+    lines.push(`- ${label}${desc}`)
   }
-  lines.push('', '[See all service definitions](/discover/all.md)')
+  lines.push('', `[OpenAPI discovery](${options?.openApiPath ?? '/openapi.json'})`)
 
   return lines.join('\n')
 }
 
-/** Renders a full markdown listing of all services with their routes. */
-export function toServicesMarkdown(services: Service[]): string {
-  const lines: string[] = ['# Services', '']
-
-  if (services.length === 0) return lines.join('\n')
-
-  for (const s of services) {
-    lines.push(`## [${s.title ?? s.id}](/discover/${s.id}.md)`, '')
-    if (s.description) lines.push(s.description, '')
-    pushRoutes(lines, s)
-  }
-
-  return lines.join('\n')
-}
-
-/** Renders a markdown string for a single service. */
-export function toMarkdown(s: Service): string {
-  const docsLlmsUrl = s.docsLlmsUrl?.({})
-  const lines: string[] = [`# ${s.title ?? s.id}`, '']
-  if (docsLlmsUrl) lines.push(`> Documentation: ${docsLlmsUrl}`, '')
-  if (s.description) lines.push(s.description, '')
-  pushRoutes(lines, s, '##')
-  return lines.join('\n')
-}
-
-function pushRoutes(lines: string[], s: Service, heading: '##' | '###' = '###') {
-  lines.push(`${heading} Routes`, '')
-  const serialized = serialize(s)
-  for (const route of serialized.routes) {
-    const p = route.payment as Record<string, unknown> | null
-    const desc = p?.description ? `: ${p.description}` : ''
-    lines.push(`- \`${route.pattern}\`${desc}`)
-    if (!p) {
-      lines.push('  - Type: free')
-    } else {
-      lines.push(`  - Type: ${p.intent}`)
-      if (p.amount) {
-        const perUnit = p.unitType ? `/${p.unitType}` : ''
-        if (p.decimals !== undefined) {
-          const price = Number(p.amount) / 10 ** Number(p.decimals)
-          lines.push(`  - Price: ${price}${perUnit} (${p.amount} units, ${p.decimals} decimals)`)
-        } else {
-          lines.push(`  - Units: ${p.amount}${perUnit}`)
-        }
-      }
-      if (p.currency) lines.push(`  - Currency: ${p.currency}`)
-    }
-    if (route.docsLlmsUrl) lines.push(`  - Docs: ${route.docsLlmsUrl}`)
-    lines.push('')
-  }
-}
-
 /** Extracts per-endpoint options from an endpoint definition. */
 export function getOptions(endpoint: Endpoint): EndpointOptions | undefined {
   if (typeof endpoint === 'object' && endpoint !== null && 'options' in endpoint)
@@ -263,10 +206,10 @@ export function getOptions(endpoint: Endpoint): EndpointOptions | undefined {
   return undefined
 }
 
-function resolvePayment(endpoint: Endpoint): Record<string, unknown> | null {
+export function paymentOf(endpoint: Endpoint): Record<string, unknown> | null {
   if (endpoint === true) return null
   const handler = typeof endpoint === 'function' ? endpoint : endpoint.pay
-  if (!('_internal' in handler)) return {}
+  if (!('_internal' in handler)) return null
   const {
     name,
     intent,
@@ -283,10 +226,21 @@ function resolvePayment(endpoint: Endpoint): Record<string, unknown> | null {
   return { intent, method: name, ...rest, ...(amount !== undefined && { amount }) }
 }
 
-function resolveLlmsUrl(
+function resolveDocs(config: from.Config): Docs | undefined {
+  if (config.docs) {
+    return {
+      ...config.docs,
+      ...(config.docs.llms ? {} : { llms: resolveLlmsFromLegacy(config.docsLlmsUrl) }),
+    }
+  }
+  const llms = resolveLlmsFromLegacy(config.docsLlmsUrl)
+  return llms ? { llms } : undefined
+}
+
+function resolveLlmsFromLegacy(
   input: string | ((options: { route?: string | undefined }) => string | undefined) | undefined,
-): Service['docsLlmsUrl'] {
+): string | undefined {
   if (!input) return undefined
-  if (typeof input === 'function') return input
-  return ({ route }) => (route ? undefined : input)
+  if (typeof input === 'string') return input
+  return input({}) ?? undefined
 }

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Headers from './Headers.js'
 

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

@@ -1,4 +1,4 @@
-import { describe, expect, test } from 'vitest'
+import { describe, expect, test } from 'vp/test'
 
 import * as Route from './Route.js'
 
@@ -24,6 +24,14 @@ describe('pathname', () => {
       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', () => {

package/src/proxy/internal/Route.ts

@@ -5,7 +5,7 @@ export function pathname(url: URL, basePath?: string): string | null {
   let pathname = url.pathname
   if (basePath) {
     const base = basePath.replace(/\/+$/, '')
-    if (!pathname.startsWith(base)) return null
+    if (!(pathname === base || pathname.startsWith(`${base}/`))) return null
     pathname = pathname.slice(base.length)
   }
   return pathname

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

@@ -0,0 +1,132 @@
+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'
+
+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

@@ -20,7 +20,12 @@ import * as Service from '../Service.js'
 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',
+    },
     rewriteRequest(request, ctx) {
       const apiKey = ctx.apiKey ?? config.apiKey
       request.headers.set('x-api-key', apiKey)

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

@@ -1,7 +1,7 @@
 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 'vitest'
+import { afterEach, describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'
 

package/src/proxy/services/openai.ts

@@ -20,11 +20,13 @@ import * as Service from '../Service.js'
 export function openai(config: openai.Config) {
   return Service.from<openai.Config>('openai', {
     baseUrl: config.baseUrl ?? 'https://api.openai.com',
+    categories: ['ai'],
     description: 'Chat completions, embeddings, image generation, and audio transcription.',
-    docsLlmsUrl: ({ route }) =>
-      route
-        ? `https://context7.com/websites/platform_openai/llms.txt?topic=${encodeURIComponent(route)}`
-        : 'https://context7.com/websites/platform_openai/llms.txt',
+    docs: {
+      apiReference: 'https://platform.openai.com/docs/api-reference',
+      homepage: 'https://platform.openai.com/docs',
+      llms: 'https://context7.com/websites/platform_openai/llms.txt',
+    },
     rewriteRequest(request, ctx) {
       const apiKey = ctx.apiKey ?? config.apiKey
       request.headers.set('Authorization', `Bearer ${apiKey}`)