mppx 0.8.15 → 0.8.18

package/src/client/node.test.ts

@@ -1,115 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs'
-import { homedir, tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { DatabaseSync } from 'node:sqlite'
-
-import { describe, expect, test } from 'vp/test'
-
-import type { ChannelEntry } from '../tempo/session/client/ChannelOps.js'
-import { entryKey } from '../tempo/session/client/ChannelStore.js'
-import { createSqliteChannelStore, defaultChannelDatabasePath } from './node.js'
-
-const channel: ChannelEntry = {
-  channelId: `0x${'11'.repeat(32)}`,
-  cumulativeAmount: 2_000_000n,
-  deposit: 10_000_000n,
-  descriptor: {
-    authorizedSigner: '0x0000000000000000000000000000000000000001',
-    expiringNonceHash: `0x${'22'.repeat(32)}`,
-    operator: '0x0000000000000000000000000000000000000000',
-    payee: '0x0000000000000000000000000000000000000002',
-    payer: '0x0000000000000000000000000000000000000003',
-    salt: `0x${'33'.repeat(32)}`,
-    token: '0x0000000000000000000000000000000000000004',
-  },
-  escrow: '0x0000000000000000000000000000000000000005',
-  chainId: 4217,
-  opened: true,
-}
-
-describe('SQLite ChannelStore', () => {
-  test('defaults to the shared Tempo wallet channels database', () => {
-    expect(defaultChannelDatabasePath()).toBe(join(homedir(), '.tempo', 'wallet', 'channels.db'))
-  })
-
-  test('persists a namespaced channel across fresh client instances', () => {
-    const directory = mkdtempSync(join(tmpdir(), 'mppx-channels-'))
-    const path = join(directory, 'channels.db')
-    try {
-      const first = createSqliteChannelStore({ namespace: 'https://api.example.com', path })
-      first.set(channel)
-      first.close()
-
-      const second = createSqliteChannelStore({ namespace: 'https://api.example.com', path })
-      expect(second.get(entryKey(channel))).toEqual(channel)
-      second.set({ ...channel, cumulativeAmount: 1_000_000n, deposit: 5_000_000n })
-      expect(second.get(entryKey(channel))).toMatchObject({
-        cumulativeAmount: 2_000_000n,
-        deposit: 10_000_000n,
-      })
-      second.close()
-    } finally {
-      rmSync(directory, { recursive: true })
-    }
-  })
-
-  test('rehydrates an existing wallet-cli v2 channel row', () => {
-    const directory = mkdtempSync(join(tmpdir(), 'mppx-wallet-channels-'))
-    const path = join(directory, 'channels.db')
-    try {
-      const database = new DatabaseSync(path)
-      database.exec(`CREATE TABLE channels (
-        channel_id TEXT PRIMARY KEY,
-        version INTEGER NOT NULL DEFAULT 1,
-        origin TEXT NOT NULL,
-        request_url TEXT NOT NULL DEFAULT '',
-        chain_id INTEGER NOT NULL,
-        escrow_contract TEXT NOT NULL,
-        token TEXT NOT NULL,
-        payee TEXT NOT NULL,
-        payer TEXT NOT NULL,
-        authorized_signer TEXT NOT NULL,
-        salt TEXT NOT NULL,
-        deposit TEXT NOT NULL,
-        cumulative_amount TEXT NOT NULL,
-        challenge_echo TEXT NOT NULL,
-        state TEXT NOT NULL DEFAULT 'active',
-        close_requested_at INTEGER NOT NULL DEFAULT 0,
-        grace_ready_at INTEGER NOT NULL DEFAULT 0,
-        created_at INTEGER NOT NULL,
-        last_used_at INTEGER NOT NULL,
-        accepted_cumulative TEXT NOT NULL DEFAULT '0',
-        server_spent TEXT NOT NULL DEFAULT '0',
-        session_protocol TEXT NOT NULL DEFAULT 'v1',
-        descriptor_json TEXT
-      )`)
-      database
-        .prepare(`INSERT INTO channels (
-          channel_id, origin, chain_id, escrow_contract, token, payee, payer,
-          authorized_signer, salt, deposit, cumulative_amount, challenge_echo,
-          state, created_at, last_used_at, session_protocol, descriptor_json
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, '{}', 'active', 1, 1, 'v2', ?)`)
-        .run(
-          channel.channelId,
-          'https://api.example.com',
-          channel.chainId,
-          channel.escrow,
-          channel.descriptor.token,
-          channel.descriptor.payee,
-          channel.descriptor.payer,
-          channel.descriptor.authorizedSigner,
-          channel.descriptor.salt,
-          channel.deposit.toString(),
-          channel.cumulativeAmount.toString(),
-          JSON.stringify(channel.descriptor),
-        )
-      database.close()
-
-      const store = createSqliteChannelStore({ namespace: 'https://api.example.com', path })
-      expect(store.get(entryKey(channel))).toEqual(channel)
-      store.close()
-    } finally {
-      rmSync(directory, { recursive: true })
-    }
-  })
-})

package/src/client/node.ts

@@ -1,247 +0,0 @@
-import { mkdirSync } from 'node:fs'
-import { homedir } from 'node:os'
-import { dirname, join } from 'node:path'
-import { DatabaseSync } from 'node:sqlite'
-
-import type { ChannelEntry } from '../tempo/session/client/ChannelOps.js'
-import {
-  deserializeEntry,
-  entryKey,
-  serializeEntry,
-  type ChannelStore,
-  type StoredChannel,
-} from '../tempo/session/client/ChannelStore.js'
-
-const schemaVersion = 2
-
-/** Options for the Node SQLite-backed payer channel store. */
-export type SqliteChannelStoreOptions = {
-  /** Service namespace, normally the protected API origin. */
-  namespace?: string | undefined
-  /** SQLite file path. Defaults to Tempo Wallet's shared channel database. */
-  path?: string | undefined
-  /** Full protected URL retained for CLI session-management requests. */
-  requestUrl?: string | undefined
-}
-
-/** A SQLite-backed channel store that can release its database handle. */
-export type SqliteChannelStore = ChannelStore & {
-  /** Absolute or caller-supplied path opened by this store. */
-  readonly path: string
-  /** Closes the underlying SQLite connection. */
-  close(): void
-}
-
-type ChannelRow = {
-  chain_id: number
-  channel_id: string
-  cumulative_amount: string
-  deposit: string
-  descriptor_json: string | null
-  entry_json: string | null
-  escrow_contract: string
-  state: string
-}
-
-/** Returns the channel database shared by Tempo command-line applications. */
-export function defaultChannelDatabasePath(): string {
-  return join(homedir(), '.tempo', 'wallet', 'channels.db')
-}
-
-/**
- * Creates a synchronous Node SQLite implementation of {@link ChannelStore}.
- *
- * The schema is compatible with Tempo Wallet's existing `channels` table, so
- * a fresh MPPx client can reuse v2 session records without a separate migration
- * command. A namespace keeps identical payment scopes at different services
- * isolated from one another.
- */
-export function createSqliteChannelStore(
-  options: SqliteChannelStoreOptions = {},
-): SqliteChannelStore {
-  const path = options.path ?? defaultChannelDatabasePath()
-  const namespace = options.namespace ?? ''
-  const requestUrl = options.requestUrl ?? namespace
-  const origin = resolveOrigin(requestUrl, namespace)
-  mkdirSync(dirname(path), { recursive: true })
-  const database = new DatabaseSync(path)
-  database.exec('PRAGMA journal_mode = WAL')
-  database.exec('PRAGMA busy_timeout = 5000')
-  ensureSchema(database)
-
-  const getRow = database.prepare(`SELECT channel_id, chain_id, escrow_contract,
-      cumulative_amount, deposit, descriptor_json, entry_json, state
-    FROM channels
-    WHERE scope_key = ?`)
-  const deleteScope = database.prepare('DELETE FROM channels WHERE scope_key = ?')
-  const deleteOtherScopeChannel = database.prepare(
-    'DELETE FROM channels WHERE scope_key = ? AND channel_id <> ?',
-  )
-  const upsert = database.prepare(`INSERT INTO channels (
-      channel_id, version, scope_key, origin, request_url, chain_id, escrow_contract, token,
-      payee, payer, authorized_signer, salt, session_protocol, descriptor_json, entry_json,
-      deposit, cumulative_amount, accepted_cumulative, challenge_echo, state,
-      close_requested_at, grace_ready_at, created_at, last_used_at, server_spent
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'v2', ?, ?, ?, ?, '0', '{}', 'active',
-      0, 0, ?, ?, '0')
-    ON CONFLICT(channel_id) DO UPDATE SET
-      version = excluded.version,
-      scope_key = excluded.scope_key,
-      origin = excluded.origin,
-      request_url = excluded.request_url,
-      chain_id = excluded.chain_id,
-      escrow_contract = excluded.escrow_contract,
-      token = excluded.token,
-      payee = excluded.payee,
-      payer = excluded.payer,
-      authorized_signer = excluded.authorized_signer,
-      salt = excluded.salt,
-      session_protocol = excluded.session_protocol,
-      descriptor_json = excluded.descriptor_json,
-      entry_json = excluded.entry_json,
-      deposit = excluded.deposit,
-      cumulative_amount = excluded.cumulative_amount,
-      state = 'active',
-      close_requested_at = 0,
-      last_used_at = excluded.last_used_at`)
-
-  return {
-    path,
-    get(key) {
-      const row = getRow.get(scopedKey(namespace, key)) as ChannelRow | undefined
-      return row ? entryFromRow(row) : undefined
-    },
-    set(entry) {
-      const scopeKey = scopedKey(namespace, entryKey(entry))
-      database.exec('BEGIN IMMEDIATE')
-      try {
-        const existing = getRow.get(scopeKey) as ChannelRow | undefined
-        const merged = mergeEntry(existing ? entryFromRow(existing) : undefined, entry)
-        const stored = serializeEntry(merged)
-        const now = Math.floor(Date.now() / 1_000)
-        deleteOtherScopeChannel.run(scopeKey, merged.channelId)
-        upsert.run(
-          merged.channelId,
-          schemaVersion,
-          scopeKey,
-          origin,
-          requestUrl,
-          merged.chainId,
-          merged.escrow,
-          merged.descriptor.token,
-          merged.descriptor.payee,
-          merged.descriptor.payer,
-          merged.descriptor.authorizedSigner,
-          merged.descriptor.salt,
-          JSON.stringify(merged.descriptor),
-          JSON.stringify(stored),
-          merged.deposit.toString(),
-          merged.cumulativeAmount.toString(),
-          now,
-          now,
-        )
-        database.exec('COMMIT')
-      } catch (error) {
-        database.exec('ROLLBACK')
-        throw error
-      }
-    },
-    delete(key) {
-      deleteScope.run(scopedKey(namespace, key))
-    },
-    close() {
-      database.close()
-    },
-  }
-}
-
-function resolveOrigin(requestUrl: string, fallback: string): string {
-  try {
-    return new URL(requestUrl).origin
-  } catch {
-    return fallback
-  }
-}
-
-function scopedKey(namespace: string, key: string): string {
-  return `${namespace}\n${key}`
-}
-
-function mergeEntry(current: ChannelEntry | undefined, incoming: ChannelEntry): ChannelEntry {
-  if (!current || current.channelId.toLowerCase() !== incoming.channelId.toLowerCase())
-    return incoming
-  return {
-    ...incoming,
-    cumulativeAmount:
-      current.cumulativeAmount > incoming.cumulativeAmount
-        ? current.cumulativeAmount
-        : incoming.cumulativeAmount,
-    deposit: current.deposit > incoming.deposit ? current.deposit : incoming.deposit,
-  }
-}
-
-function entryFromRow(row: ChannelRow): ChannelEntry {
-  if (row.entry_json) {
-    const stored = JSON.parse(row.entry_json) as StoredChannel
-    return deserializeEntry({ ...stored, opened: row.state === 'active' })
-  }
-
-  if (!row.descriptor_json) throw new Error('v2 channel row is missing its descriptor')
-  const descriptor = JSON.parse(row.descriptor_json) as ChannelEntry['descriptor']
-  return {
-    channelId: row.channel_id as ChannelEntry['channelId'],
-    cumulativeAmount: BigInt(row.cumulative_amount),
-    deposit: BigInt(row.deposit),
-    descriptor,
-    escrow: row.escrow_contract as ChannelEntry['escrow'],
-    chainId: row.chain_id,
-    opened: row.state === 'active',
-  }
-}
-
-function ensureSchema(database: DatabaseSync): void {
-  database.exec(`CREATE TABLE IF NOT EXISTS channels (
-    channel_id TEXT PRIMARY KEY,
-    version INTEGER NOT NULL DEFAULT 1,
-    scope_key TEXT,
-    origin TEXT NOT NULL,
-    request_url TEXT NOT NULL DEFAULT '',
-    chain_id INTEGER NOT NULL,
-    escrow_contract TEXT NOT NULL,
-    token TEXT NOT NULL,
-    payee TEXT NOT NULL,
-    payer TEXT NOT NULL,
-    authorized_signer TEXT NOT NULL,
-    salt TEXT NOT NULL,
-    deposit TEXT NOT NULL,
-    cumulative_amount TEXT NOT NULL,
-    challenge_echo TEXT NOT NULL,
-    state TEXT NOT NULL DEFAULT 'active',
-    close_requested_at INTEGER NOT NULL DEFAULT 0,
-    grace_ready_at INTEGER NOT NULL DEFAULT 0,
-    created_at INTEGER NOT NULL,
-    last_used_at INTEGER NOT NULL,
-    accepted_cumulative TEXT NOT NULL DEFAULT '0',
-    server_spent TEXT NOT NULL DEFAULT '0',
-    session_protocol TEXT NOT NULL DEFAULT 'v1',
-    descriptor_json TEXT,
-    entry_json TEXT
-  )`)
-  addColumn(database, 'scope_key TEXT')
-  addColumn(database, 'entry_json TEXT')
-  database.exec(`UPDATE channels
-    SET scope_key = origin || char(10) || lower(payee) || ':' || lower(token) || ':' ||
-      lower(escrow_contract) || ':' || chain_id
-    WHERE scope_key IS NULL AND session_protocol = 'v2' AND descriptor_json IS NOT NULL`)
-  database.exec(
-    'CREATE UNIQUE INDEX IF NOT EXISTS idx_channels_scope_key ON channels(scope_key) WHERE scope_key IS NOT NULL',
-  )
-  database.exec('CREATE INDEX IF NOT EXISTS idx_channels_origin ON channels(origin)')
-}
-
-function addColumn(database: DatabaseSync, definition: string): void {
-  const name = definition.slice(0, definition.indexOf(' '))
-  const columns = database.prepare('PRAGMA table_info(channels)').all() as Array<{ name: string }>
-  if (columns.some((column) => column.name === name)) return
-  database.exec(`ALTER TABLE channels ADD COLUMN ${definition}`)
-}

package/src/discovery/Discovery.test.ts

@@ -1,214 +0,0 @@
-import { DiscoveryDocument, PaymentInfo, ServiceInfo } from './Discovery.js'
-
-describe('PaymentInfo', () => {
-  test('normalizes legacy shorthand to offers', () => {
-    const result = PaymentInfo.safeParse({
-      amount: '1000',
-      intent: 'charge',
-      method: 'tempo',
-    })
-    expect(result.success).toBe(true)
-    expect(result.data).toEqual({
-      offers: [{ amount: '1000', intent: 'charge', method: 'tempo' }],
-    })
-  })
-
-  test('parses offers format without modification', () => {
-    const result = PaymentInfo.safeParse({
-      offers: [{ amount: '1000', intent: 'charge', method: 'tempo' }],
-    })
-    expect(result.success).toBe(true)
-    expect(result.data).toEqual({
-      offers: [{ amount: '1000', intent: 'charge', method: 'tempo' }],
-    })
-  })
-
-  test('parses a session with null amount', () => {
-    const result = PaymentInfo.safeParse({
-      amount: null,
-      intent: 'session',
-      method: 'tempo',
-    })
-    expect(result.success).toBe(true)
-    expect(result.data?.offers[0]?.amount).toBeNull()
-  })
-
-  test('accepts custom intents', () => {
-    const result = PaymentInfo.safeParse({
-      amount: '100',
-      intent: 'subscribe',
-      method: 'tempo',
-    })
-    expect(result.success).toBe(true)
-    expect(result.data?.offers[0]?.intent).toBe('subscribe')
-  })
-
-  test('rejects invalid amount pattern', () => {
-    const result = PaymentInfo.safeParse({
-      amount: '01',
-      intent: 'charge',
-      method: 'tempo',
-    })
-    expect(result.success).toBe(false)
-  })
-
-  test('rejects mixed shorthand and offers shapes', () => {
-    const result = PaymentInfo.safeParse({
-      amount: '100',
-      offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  test('rejects empty offers arrays', () => {
-    const result = PaymentInfo.safeParse({ offers: [] })
-    expect(result.success).toBe(false)
-  })
-
-  test('rejects malformed offers', () => {
-    const result = PaymentInfo.safeParse({
-      offers: [{ amount: '01', intent: 'charge', method: 'tempo' }],
-    })
-    expect(result.success).toBe(false)
-  })
-
-  test('accepts x402 format with unknown fields', () => {
-    const result = PaymentInfo.safeParse({
-      price: '0.54',
-      pricingMode: 'fixed',
-      protocols: ['x402', 'mpp'],
-    })
-    expect(result.success).toBe(true)
-    expect(result.data).toEqual({
-      offers: [{ price: '0.54', pricingMode: 'fixed', protocols: ['x402', 'mpp'] }],
-    })
-  })
-})
-
-describe('ServiceInfo', () => {
-  test('parses a full service info', () => {
-    const result = ServiceInfo.safeParse({
-      categories: ['ai', 'search'],
-      docs: {
-        apiReference: 'https://example.com/api',
-        homepage: 'https://example.com',
-        llms: 'https://example.com/llms.txt',
-      },
-    })
-    expect(result.success).toBe(true)
-    expect(result.data?.categories).toEqual(['ai', 'search'])
-  })
-
-  test('accepts relative paths for doc links', () => {
-    const result = ServiceInfo.safeParse({
-      docs: {
-        llms: '/llms.txt',
-        apiReference: '/docs/api',
-      },
-    })
-    expect(result.success).toBe(true)
-    expect(result.data?.docs?.llms).toBe('/llms.txt')
-  })
-
-  test('rejects invalid doc URIs', () => {
-    const result = ServiceInfo.safeParse({
-      docs: {
-        homepage: 'not-a-uri',
-      },
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
-describe('DiscoveryDocument', () => {
-  test('parses a minimal document', () => {
-    const result = DiscoveryDocument.safeParse({
-      info: { title: 'Test', version: '1.0.0' },
-      openapi: '3.1.0',
-    })
-    expect(result.success).toBe(true)
-  })
-
-  test('parses a document with discovery extensions', () => {
-    const result = DiscoveryDocument.safeParse({
-      info: { title: 'Test', version: '1.0.0' },
-      openapi: '3.1.0',
-      paths: {
-        '/search': {
-          post: {
-            'x-payment-info': {
-              amount: '100',
-              intent: 'charge',
-              method: 'tempo',
-            },
-            responses: {
-              '200': { description: 'OK' },
-              '402': { description: 'Payment Required' },
-            },
-          },
-        },
-      },
-      'x-service-info': {
-        categories: ['search'],
-      },
-    })
-    expect(result.success).toBe(true)
-    expect(result.data?.paths?.['/search']?.post?.['x-payment-info']).toEqual({
-      offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
-    })
-  })
-
-  test('normalizes offers-based discovery documents', () => {
-    const result = DiscoveryDocument.safeParse({
-      info: { title: 'Test', version: '1.0.0' },
-      openapi: '3.1.0',
-      paths: {
-        '/search': {
-          post: {
-            'x-payment-info': {
-              offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
-            },
-            responses: {
-              '200': { description: 'OK' },
-              '402': { description: 'Payment Required' },
-            },
-          },
-        },
-      },
-    })
-    expect(result.success).toBe(true)
-    expect(result.data?.paths?.['/search']?.post?.['x-payment-info']).toEqual({
-      offers: [{ amount: '100', intent: 'charge', method: 'tempo' }],
-    })
-  })
-
-  test('accepts path items with summary, parameters, and extensions', () => {
-    const result = DiscoveryDocument.safeParse({
-      info: { title: 'Test', version: '1.0.0' },
-      openapi: '3.1.0',
-      paths: {
-        '/search': {
-          summary: 'Search endpoints',
-          parameters: [{ name: 'q', in: 'query' }],
-          'x-custom': 'hello',
-          post: {
-            'x-payment-info': {
-              amount: '100',
-              intent: 'charge',
-              method: 'tempo',
-            },
-            responses: { '402': { description: 'Payment Required' } },
-          },
-        },
-      },
-    })
-    expect(result.success).toBe(true)
-  })
-
-  test('rejects missing info', () => {
-    const result = DiscoveryDocument.safeParse({
-      openapi: '3.1.0',
-    })
-    expect(result.success).toBe(false)
-  })
-})

package/src/discovery/Discovery.ts

@@ -1,105 +0,0 @@
-import * as z from '../zod.js'
-
-const uriOrPathPattern = /^([a-zA-Z][a-zA-Z\d+.-]*:\/\/\S+|\/\S*)$/
-const paymentInfoFieldNames = new Set(['amount', 'currency', 'description', 'intent', 'method'])
-
-function uriOrPath() {
-  return z.string().check(z.regex(uriOrPathPattern, 'Invalid URI or path'))
-}
-
-const PaymentOffer = z.looseObject({
-  amount: z.optional(
-    z.union([z.null(), z.string().check(z.regex(/^(0|[1-9][0-9]*)$/, 'Invalid amount'))]),
-  ),
-  currency: z.optional(z.string()),
-  description: z.optional(z.string()),
-  intent: z.optional(z.string()),
-  method: z.optional(z.string()),
-})
-
-/**
- * Schema for the `x-payment-info` OpenAPI extension on an operation.
- *
- * Only validates spec-defined fields when present; unknown fields are ignored.
- * Discovery is advisory only. Runtime 402 challenges remain authoritative.
- */
-export const PaymentInfo = z.pipe(
-  z
-    .looseObject({
-      amount: z.optional(
-        z.union([z.null(), z.string().check(z.regex(/^(0|[1-9][0-9]*)$/, 'Invalid amount'))]),
-      ),
-      currency: z.optional(z.string()),
-      description: z.optional(z.string()),
-      intent: z.optional(z.string()),
-      method: z.optional(z.string()),
-      offers: z.optional(z.array(PaymentOffer).check(z.minLength(1))),
-    })
-    .check(
-      z.refine(
-        (value) =>
-          value.offers === undefined || Object.keys(value).every((key) => key === 'offers'),
-        'Cannot mix offers with flat payment info fields',
-      ),
-    ),
-  z.transform((value) => {
-    if (value.offers) return { offers: value.offers }
-
-    const offer: Record<string, unknown> = {}
-    for (const [key, field] of Object.entries(value)) {
-      if (key === 'offers') continue
-      if (paymentInfoFieldNames.has(key) || field !== undefined) offer[key] = field
-    }
-
-    return { offers: [offer] }
-  }),
-)
-export type PaymentInfo = z.infer<typeof PaymentInfo>
-
-const ServiceDocs = z.looseObject({
-  apiReference: z.optional(uriOrPath()),
-  homepage: z.optional(uriOrPath()),
-  llms: z.optional(uriOrPath()),
-})
-
-/**
- * Schema for the `x-service-info` OpenAPI extension at the document root.
- */
-export const ServiceInfo = z.looseObject({
-  categories: z.optional(z.array(z.string())),
-  docs: z.optional(ServiceDocs),
-})
-export type ServiceInfo = z.infer<typeof ServiceInfo>
-
-const OperationObject = z.looseObject({
-  'x-payment-info': z.optional(PaymentInfo),
-  requestBody: z.optional(z.unknown()),
-  responses: z.optional(z.record(z.string(), z.unknown())),
-  summary: z.optional(z.string()),
-})
-
-const PathItem = z.looseObject({
-  delete: z.optional(OperationObject),
-  get: z.optional(OperationObject),
-  head: z.optional(OperationObject),
-  options: z.optional(OperationObject),
-  patch: z.optional(OperationObject),
-  post: z.optional(OperationObject),
-  put: z.optional(OperationObject),
-  trace: z.optional(OperationObject),
-})
-
-/**
- * Minimal schema for an OpenAPI discovery document annotated with
- * `x-service-info` and per-operation `x-payment-info`.
- */
-export const DiscoveryDocument = z.looseObject({
-  openapi: z.string(),
-  info: z.looseObject({
-    title: z.string(),
-    version: z.string(),
-  }),
-  'x-service-info': z.optional(ServiceInfo),
-  paths: z.optional(z.record(z.string(), PathItem)),
-})
-export type DiscoveryDocument = z.infer<typeof DiscoveryDocument>