@routedock/routedock 0.1.2 → 0.3.0

package/dist/SessionStore-CCVO0PHM.d.ts

@@ -1,152 +0,0 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-
-/**
- * TypeScript types for the RouteDock manifest format.
- * Derived from packages/sdk/src/schemas/routedock.schema.json (draft-07).
- *
- * Section 5 of ROUTEDOCK_MASTER.md is the canonical specification.
- */
-type PaymentMode = 'x402' | 'mpp-charge' | 'mpp-session';
-/** Per-request pricing config — used by x402 and mpp-charge modes */
-interface PricingConfig {
-    /** Cost per request in the payment asset, e.g. "0.001" */
-    amount: string;
-    per: 'request';
-    /** x402 facilitator URL (OpenZeppelin Channels). Required for x402 mode. */
-    facilitator?: string;
-}
-/** Per-voucher pricing config — used by mpp-session (one-way-channel) mode */
-interface SessionPricingConfig {
-    /** Cost per voucher, e.g. "0.0001" */
-    rate: string;
-    per: 'voucher';
-    /** Soroban contract address (C...) for the one-way-channel contract */
-    channel_contract: string;
-    /** Minimum initial deposit to open a channel, e.g. "0.10" */
-    min_deposit: string;
-    /**
-     * Ledgers the server has to settle before the funder can reclaim.
-     * Default: 17280 (~24h). Do NOT reduce in production — this is a
-     * security parameter the server depends on to settle first.
-     */
-    refund_waiting_period_ledgers: number;
-}
-/** Full RouteDock discovery manifest — served at /.well-known/routedock.json */
-interface RouteDockManifest {
-    /** Schema version — always "1.0" */
-    routedock: '1.0';
-    /** Human-readable provider name */
-    name: string;
-    /** Human-readable description of the provider's data or service */
-    description: string;
-    /** Payment modes supported by this provider */
-    modes: PaymentMode[];
-    /** Stellar network this provider operates on */
-    network: 'testnet' | 'mainnet';
-    /** Asset ticker symbol, e.g. "USDC" */
-    asset: string;
-    /** Stellar Asset Contract (SAC) address for the payment asset */
-    asset_contract: string;
-    /** Stellar address (G...) that receives payments */
-    payee: string;
-    /** Pricing configuration per supported payment mode */
-    pricing: {
-        x402?: PricingConfig;
-        'mpp-charge'?: PricingConfig;
-        'mpp-session'?: SessionPricingConfig;
-    };
-    /** Map of endpoint name to HTTP method + path, e.g. { price: "GET /price" } */
-    endpoints: Record<string, string>;
-    /** Capability tags indexed with trigram search in the provider registry */
-    tags: string[];
-}
-/** Result returned by client.pay() for any payment mode */
-interface PaymentResult {
-    /** Parsed response body from the provider */
-    data: unknown;
-    /** On-chain Stellar transaction hash, or null for session voucher calls */
-    txHash: string | null;
-    /** Payment mode that was used for this call */
-    mode: PaymentMode;
-    /** Amount paid in the payment asset (decimal string) */
-    amount: string;
-    /** Unix timestamp (ms) when the payment completed */
-    timestamp: number;
-}
-/** Result returned by session.close() */
-interface SessionCloseResult {
-    /** On-chain transaction hash for the channel close */
-    closeTxHash: string;
-    /** Total amount settled across all vouchers (decimal string) */
-    totalPaid: string;
-    /** Number of vouchers issued during the session */
-    vouchersIssued: number;
-}
-/** Handle for a live MPP session returned by client.openSession() */
-interface SessionHandle {
-    /** Stellar channel contract address (C...) */
-    channelId: string;
-    /** Transaction hash from the channel-open on-chain call */
-    openTxHash: string;
-    /**
-     * Async generator of server-sent event data.
-     * Each iteration sends a voucher and yields the parsed response.
-     * UNAUDITED: uses stellar-experimental/one-way-channel contract.
-     */
-    stream(): AsyncIterable<unknown>;
-    /** Close the channel on-chain with the highest signed voucher */
-    close(): Promise<SessionCloseResult>;
-}
-/**
- * Durable session state stored in Supabase (sessions table).
- * cumulative_amount is a decimal string to avoid float precision loss.
- * The monotonic invariant is enforced both here and at the DB level via trigger.
- */
-interface SessionState {
-    channel_id: string;
-    payee: string;
-    payer: string;
-    /** Monotonically increasing cumulative amount — stored as string to preserve precision */
-    cumulative_amount: string;
-    last_signature: string;
-    status: 'open' | 'closing' | 'closed';
-    opened_at: string;
-    updated_at: string;
-    settlement_tx_hash: string | null;
-}
-declare class RouteDockError extends Error {
-    constructor(message: string);
-}
-/** Manifest fetch failed, schema invalid, or required fields missing */
-declare class RouteDockManifestError extends RouteDockError {
-    constructor(message: string);
-}
-/** No payment mode in the manifest is supported by this client */
-declare class RouteDockNoSupportedModeError extends RouteDockError {
-    constructor(message: string);
-}
-/** Session invariant violated (e.g. non-monotonic voucher amount) */
-declare class RouteDockSessionError extends RouteDockError {
-    constructor(message: string);
-}
-/** Local spend cap or on-chain policy rejected the payment */
-declare class RouteDockPolicyRejectedError extends RouteDockError {
-    readonly reason: string;
-    constructor(reason: string);
-}
-
-interface SessionStore {
-    get(channelId: string): Promise<SessionState | null>;
-    /** Enforce monotonic invariant at application level before writing */
-    upsert(channelId: string, state: SessionState): Promise<void>;
-    close(channelId: string): Promise<void>;
-}
-declare class SupabaseSessionStore implements SessionStore {
-    private readonly supabase;
-    constructor(supabase: SupabaseClient);
-    get(channelId: string): Promise<SessionState | null>;
-    upsert(channelId: string, state: SessionState): Promise<void>;
-    close(channelId: string): Promise<void>;
-}
-
-export { type PaymentMode as P, RouteDockError as R, type SessionCloseResult as S, type PaymentResult as a, type PricingConfig as b, type RouteDockManifest as c, RouteDockManifestError as d, RouteDockNoSupportedModeError as e, RouteDockPolicyRejectedError as f, RouteDockSessionError as g, type SessionHandle as h, type SessionPricingConfig as i, type SessionState as j, type SessionStore as k, SupabaseSessionStore as l };

package/dist/routedockMiddleware-B7WTB3LT.d.cts

@@ -1,53 +0,0 @@
-import { RequestHandler } from 'express';
-import { P as PaymentMode, c as RouteDockManifest } from './SessionStore-CCVO0PHM.cjs';
-
-interface RouteDockMiddlewareOptions {
-    modes: PaymentMode[];
-    pricing: {
-        x402?: string;
-        'mpp-charge'?: string;
-        'mpp-session'?: {
-            rate: string;
-            channelContract: string;
-        };
-    };
-    asset: string;
-    /** Stellar Asset Contract address for the payment asset */
-    assetContract: string;
-    payee: string;
-    network: 'testnet' | 'mainnet';
-    /** Private key (S...) of the server/payee account */
-    payeeSecretKey: string;
-    /** Required for x402 mode */
-    facilitatorApiKey?: string;
-    /** Required for mpp-session mode — ed25519 public key (G...) for verifying commitments */
-    commitmentPublicKey?: string;
-    /** Full RouteDock manifest — served at /.well-known/routedock.json */
-    manifest: RouteDockManifest;
-    /** Called after each successful on-chain settlement */
-    onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>;
-    /** Called when a new mpp-session is opened (first voucher received) */
-    onSessionOpen?: (channelId: string) => Promise<void>;
-    /** Called after each verified voucher in an mpp-session */
-    onVoucher?: (voucherIndex: number, cumulativeAmount: string) => Promise<void>;
-}
-/**
- * Express middleware factory for RouteDock provider endpoints.
- *
- * Automatically serves /.well-known/routedock.json and enforces payment
- * verification for all three modes (x402, mpp-charge, mpp-session).
- *
- * @example
- * ```ts
- * import { routedock } from '@routedock/sdk/provider'
- *
- * app.use('/price', routedock({
- *   modes: ['x402', 'mpp-charge'],
- *   pricing: { x402: '0.001', 'mpp-charge': '0.0008' },
- *   ...
- * }))
- * ```
- */
-declare function routedock(opts: RouteDockMiddlewareOptions): RequestHandler;
-
-export { type RouteDockMiddlewareOptions as R, routedock as r };

package/dist/routedockMiddleware-DRgdrycG.d.ts

@@ -1,53 +0,0 @@
-import { RequestHandler } from 'express';
-import { P as PaymentMode, c as RouteDockManifest } from './SessionStore-CCVO0PHM.js';
-
-interface RouteDockMiddlewareOptions {
-    modes: PaymentMode[];
-    pricing: {
-        x402?: string;
-        'mpp-charge'?: string;
-        'mpp-session'?: {
-            rate: string;
-            channelContract: string;
-        };
-    };
-    asset: string;
-    /** Stellar Asset Contract address for the payment asset */
-    assetContract: string;
-    payee: string;
-    network: 'testnet' | 'mainnet';
-    /** Private key (S...) of the server/payee account */
-    payeeSecretKey: string;
-    /** Required for x402 mode */
-    facilitatorApiKey?: string;
-    /** Required for mpp-session mode — ed25519 public key (G...) for verifying commitments */
-    commitmentPublicKey?: string;
-    /** Full RouteDock manifest — served at /.well-known/routedock.json */
-    manifest: RouteDockManifest;
-    /** Called after each successful on-chain settlement */
-    onSettled?: (txHash: string, amount: string, mode: string) => Promise<void>;
-    /** Called when a new mpp-session is opened (first voucher received) */
-    onSessionOpen?: (channelId: string) => Promise<void>;
-    /** Called after each verified voucher in an mpp-session */
-    onVoucher?: (voucherIndex: number, cumulativeAmount: string) => Promise<void>;
-}
-/**
- * Express middleware factory for RouteDock provider endpoints.
- *
- * Automatically serves /.well-known/routedock.json and enforces payment
- * verification for all three modes (x402, mpp-charge, mpp-session).
- *
- * @example
- * ```ts
- * import { routedock } from '@routedock/sdk/provider'
- *
- * app.use('/price', routedock({
- *   modes: ['x402', 'mpp-charge'],
- *   pricing: { x402: '0.001', 'mpp-charge': '0.0008' },
- *   ...
- * }))
- * ```
- */
-declare function routedock(opts: RouteDockMiddlewareOptions): RequestHandler;
-
-export { type RouteDockMiddlewareOptions as R, routedock as r };

package/src/client/ModeRouter.ts

@@ -1,104 +0,0 @@
-import Ajv from 'ajv'
-import type { RouteDockManifest, PaymentMode } from '../types.js'
-import { RouteDockManifestError, RouteDockNoSupportedModeError } from '../types.js'
-import schema from '../schemas/routedock.schema.json' assert { type: 'json' }
-
-const ajv = new Ajv()
-const validateManifest = ajv.compile(schema)
-
-interface CacheEntry {
-  manifest: RouteDockManifest
-  fetchedAt: number
-}
-
-const CACHE_TTL_MS = 60_000
-
-/** In-memory manifest cache keyed by base URL. */
-const manifestCache = new Map<string, CacheEntry>()
-
-export interface ModeSelectOptions {
-  /** Force mpp-session if the provider supports it */
-  sustained?: boolean
-  session?: boolean
-  /**
-   * Override mode selection and use this specific mode.
-   * Throws RouteDockNoSupportedModeError if the provider does not support it.
-   */
-  forceMode?: PaymentMode
-}
-
-/** Fetch, validate, and cache a RouteDock manifest from `baseUrl`. */
-export async function fetchManifest(baseUrl: string): Promise<RouteDockManifest> {
-  const cached = manifestCache.get(baseUrl)
-  if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) {
-    return cached.manifest
-  }
-
-  const url = baseUrl.replace(/\/$/, '') + '/.well-known/routedock.json'
-  let raw: unknown
-  try {
-    const resp = await fetch(url)
-    if (!resp.ok) {
-      throw new RouteDockManifestError(`Manifest fetch failed: HTTP ${resp.status} from ${url}`)
-    }
-    raw = await resp.json()
-  } catch (err) {
-    if (err instanceof RouteDockManifestError) throw err
-    throw new RouteDockManifestError(`Manifest fetch error: ${String(err)}`)
-  }
-
-  if (!validateManifest(raw)) {
-    const msgs = ajv.errorsText(validateManifest.errors)
-    throw new RouteDockManifestError(`Invalid manifest at ${url}: ${msgs}`)
-  }
-
-  const manifest = raw as unknown as RouteDockManifest
-  manifestCache.set(baseUrl, { manifest, fetchedAt: Date.now() })
-  return manifest
-}
-
-/**
- * Deterministic mode selection per Section 6.3 of ROUTEDOCK_MASTER.md:
- * 1. If { sustained | session } AND manifest supports mpp-session → mpp-session
- * 2. Else if manifest supports mpp-charge AND network is Stellar → mpp-charge
- * 3. Else if manifest supports x402 → x402
- * 4. Else throw RouteDockNoSupportedModeError
- */
-export function selectMode(
-  manifest: RouteDockManifest,
-  options: ModeSelectOptions = {},
-): PaymentMode {
-  const modes = manifest.modes
-
-  if (options.forceMode) {
-    if (!modes.includes(options.forceMode)) {
-      throw new RouteDockNoSupportedModeError(
-        `Provider does not support forced mode: ${options.forceMode} (available: ${modes.join(', ')})`,
-      )
-    }
-    console.log(`[RouteDock] ${manifest.name} → ${options.forceMode} (forced)`)
-    return options.forceMode
-  }
-
-  if ((options.sustained || options.session) && modes.includes('mpp-session')) {
-    const mode: PaymentMode = 'mpp-session'
-    console.log(`[RouteDock] ${manifest.name} → ${mode}`)
-    return mode
-  }
-
-  if (modes.includes('mpp-charge')) {
-    const mode: PaymentMode = 'mpp-charge'
-    console.log(`[RouteDock] ${manifest.name} → ${mode}`)
-    return mode
-  }
-
-  if (modes.includes('x402')) {
-    const mode: PaymentMode = 'x402'
-    console.log(`[RouteDock] ${manifest.name} → ${mode}`)
-    return mode
-  }
-
-  throw new RouteDockNoSupportedModeError(
-    `No supported payment mode found in manifest (modes: ${modes.join(', ')})`,
-  )
-}

package/src/client/MppChargeClient.ts

@@ -1,44 +0,0 @@
-import { Keypair } from '@stellar/stellar-sdk'
-import { stellar } from '@stellar/mpp/charge/client'
-import { Mppx } from 'mppx/client'
-import type { RouteDockManifest, PaymentResult } from '../types.js'
-import { RouteDockManifestError } from '../types.js'
-
-export class MppChargeClient {
-  constructor(
-    private readonly keypair: Keypair,
-    private readonly network: 'testnet' | 'mainnet',
-  ) {}
-
-  async pay(url: string, manifest: RouteDockManifest): Promise<PaymentResult> {
-    const pricing = manifest.pricing['mpp-charge']
-    if (!pricing) {
-      throw new RouteDockManifestError('manifest.pricing.mpp-charge missing')
-    }
-
-    let txHash: string | null = null
-
-    const mppx = Mppx.create({
-      polyfill: false,
-      methods: [
-        stellar.charge({
-          keypair: this.keypair,
-          mode: 'pull',
-          onProgress(event) {
-            if (event.type === 'paid') {
-              txHash = event.hash
-            }
-          },
-        }),
-      ],
-    })
-
-    const response = await mppx.fetch(url)
-    if (!response.ok) {
-      throw new RouteDockManifestError(`MPP charge failed: HTTP ${response.status}`)
-    }
-
-    const data = await response.json()
-    return { data, txHash, mode: 'mpp-charge', amount: pricing.amount, timestamp: Date.now() }
-  }
-}

package/src/client/MppSessionClient.ts

@@ -1,144 +0,0 @@
-/**
- * MppSessionClient — uses @stellar/mpp channel/client for off-chain
- * cumulative commitments against a pre-deployed one-way-channel contract.
- *
- * The channel is deployed and funded before the agent runs. The client
- * signs ed25519 commitments per the one-way-channel protocol — the
- * @stellar/mpp library handles the 402 challenge-response cycle.
- */
-import { Keypair } from '@stellar/stellar-sdk'
-import { stellar } from '@stellar/mpp/channel/client'
-import { Mppx } from 'mppx/client'
-import type {
-  RouteDockManifest,
-  SessionHandle,
-  SessionCloseResult,
-} from '../types.js'
-import {
-  RouteDockManifestError,
-  RouteDockSessionError,
-} from '../types.js'
-
-const MIN_REFUND_WAITING_PERIOD = 17_280
-
-export class MppSessionClient {
-  constructor(
-    private readonly keypair: Keypair,
-    private readonly network: 'testnet' | 'mainnet',
-  ) {}
-
-  async openSession(
-    url: string,
-    manifest: RouteDockManifest,
-    commitmentSecret: string,
-  ): Promise<SessionHandle> {
-    const pricing = manifest.pricing['mpp-session']
-    if (!pricing) {
-      throw new RouteDockManifestError('manifest.pricing.mpp-session missing')
-    }
-
-    const refundPeriod = pricing.refund_waiting_period_ledgers
-    if (refundPeriod < MIN_REFUND_WAITING_PERIOD) {
-      throw new RouteDockManifestError(
-        `refund_waiting_period_ledgers ${refundPeriod} < minimum ${MIN_REFUND_WAITING_PERIOD}`,
-      )
-    }
-
-    const commitmentKey = Keypair.fromSecret(commitmentSecret)
-    const channelContract = pricing.channel_contract
-    const agentPublicKey = this.keypair.publicKey()
-
-    let currentCumulative = 0n
-    let vouchersIssued = 0
-
-    const mppx = Mppx.create({
-      polyfill: false,
-      methods: [
-        stellar.channel({
-          commitmentKey,
-          sourceAccount: this.keypair.publicKey(),
-          onProgress(event) {
-            if (event.type === 'signed') {
-              currentCumulative = BigInt(event.cumulativeAmount)
-            }
-          },
-        }),
-      ],
-    })
-
-    const openTxHash = channelContract
-
-    const handle: SessionHandle = {
-      channelId: channelContract,
-      openTxHash,
-
-      async *stream(): AsyncIterable<unknown> {
-        while (true) {
-          let resp: globalThis.Response | null = null
-          for (let attempt = 0; attempt < 3; attempt++) {
-            try {
-              resp = await mppx.fetch(url)
-              if (resp.ok) break
-              resp = null
-            } catch {
-              if (attempt === 2) throw new RouteDockSessionError('Voucher request failed after 3 retries')
-              await new Promise(r => setTimeout(r, 1000 * (attempt + 1)))
-            }
-          }
-          if (!resp || !resp.ok) {
-            throw new RouteDockSessionError(`Voucher request failed: HTTP ${resp?.status ?? 'unknown'}`)
-          }
-          vouchersIssued++
-          yield await resp.json()
-        }
-      },
-
-      async close(): Promise<SessionCloseResult> {
-        const { rpc: rpcMod, Contract, nativeToScVal, TransactionBuilder, BASE_FEE } = await import('@stellar/stellar-sdk')
-        const rpcUrl = 'https://soroban-testnet.stellar.org'
-        const server = new rpcMod.Server(rpcUrl)
-        const contract = new Contract(channelContract)
-        const passphrase = 'Test SDF Network ; September 2015'
-
-        const account = await server.getAccount(agentPublicKey)
-        const simTx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase: passphrase })
-          .addOperation(contract.call('prepare_commitment', nativeToScVal(currentCumulative, { type: 'i128' })))
-          .setTimeout(30)
-          .build()
-        const simResult = await server.simulateTransaction(simTx)
-        if (rpcMod.Api.isSimulationError(simResult)) {
-          throw new RouteDockSessionError(`prepare_commitment simulation failed: ${simResult.error}`)
-        }
-        const commitmentBytes = (simResult as { result?: { retval?: { bytes: () => Buffer } } }).result?.retval?.bytes()
-        if (!commitmentBytes) throw new RouteDockSessionError('prepare_commitment returned no bytes')
-
-        const signature = commitmentKey.sign(Buffer.from(commitmentBytes))
-
-        const closeResp = await fetch(url, {
-          method: 'DELETE',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            amount: currentCumulative.toString(),
-            signature: Buffer.from(signature).toString('hex'),
-          }),
-        })
-
-        if (!closeResp.ok) {
-          throw new RouteDockSessionError(`Channel close failed: HTTP ${closeResp.status}`)
-        }
-
-        const closeData = (await closeResp.json()) as { closeTxHash?: string }
-        const closeTxHash = closeData.closeTxHash ?? null
-
-        if (!closeTxHash) {
-          throw new RouteDockSessionError('Channel close response missing closeTxHash')
-        }
-
-        const totalPaid = (Number(currentCumulative) / 1e7).toFixed(7)
-        return { closeTxHash, totalPaid, vouchersIssued }
-      },
-    }
-
-    return handle
-  }
-}

package/src/client/RouteDockClient.ts

@@ -1,124 +0,0 @@
-import { Keypair } from '@stellar/stellar-sdk'
-import { fetchManifest, selectMode, type ModeSelectOptions } from './ModeRouter.js'
-import { X402Client } from './x402Client.js'
-import { MppChargeClient } from './MppChargeClient.js'
-import { MppSessionClient } from './MppSessionClient.js'
-import type { PaymentResult, SessionHandle } from '../types.js'
-import {
-  RouteDockManifestError,
-  RouteDockPolicyRejectedError,
-} from '../types.js'
-
-export interface SpendCap {
-  /** Maximum total USDC spend per day (decimal string, e.g. "1.00") */
-  daily: string
-  asset: 'USDC'
-}
-
-export interface RouteDockClientConfig {
-  /** Stellar keypair or raw secret key (S...) */
-  wallet: Keypair | string
-  network: 'testnet' | 'mainnet'
-  /** Optional local daily spend cap — checked before every payment */
-  spendCap?: SpendCap
-  /** Ed25519 secret key (S...) for signing channel commitments. Required for mpp-session. */
-  commitmentSecret?: string | undefined
-}
-
-export class RouteDockClient {
-  private readonly keypair: Keypair
-  private readonly network: 'testnet' | 'mainnet'
-  private readonly spendCap: SpendCap | undefined
-  private readonly commitmentSecret: string | undefined
-
-  /** Local daily accumulator keyed by YYYY-MM-DD */
-  private dailySpend: { date: string; total: number } = { date: '', total: 0 }
-
-  private readonly x402: X402Client
-  private readonly charge: MppChargeClient
-  private readonly session: MppSessionClient
-
-  constructor(config: RouteDockClientConfig) {
-    this.keypair =
-      typeof config.wallet === 'string' ? Keypair.fromSecret(config.wallet) : config.wallet
-    this.network = config.network
-    this.spendCap = config.spendCap
-    this.commitmentSecret = config.commitmentSecret
-
-    const secretKey = this.keypair.secret()
-    this.x402 = new X402Client(secretKey, this.network)
-    this.charge = new MppChargeClient(this.keypair, this.network)
-    this.session = new MppSessionClient(this.keypair, this.network)
-  }
-
-  /**
-   * Pay for one request at `url`. Fetches manifest, selects payment mode,
-   * checks local spend cap, executes payment, returns result.
-   */
-  async pay(url: string, options?: ModeSelectOptions): Promise<PaymentResult> {
-    const baseUrl = new URL(url).origin
-    const manifest = await fetchManifest(baseUrl)
-    const mode = selectMode(manifest, options)
-
-    let result: PaymentResult
-
-    switch (mode) {
-      case 'x402':
-        result = await this.x402.pay(url, manifest)
-        break
-      case 'mpp-charge':
-        result = await this.charge.pay(url, manifest)
-        break
-      case 'mpp-session':
-        throw new RouteDockManifestError(
-          'Use client.openSession() for mpp-session mode — client.pay() only handles discrete payments',
-        )
-      default:
-        throw new RouteDockManifestError(`Unknown payment mode: ${mode as string}`)
-    }
-
-    this._checkAndRecordSpend(result.amount)
-    return result
-  }
-
-  /**
-   * Open a sustained MPP session at `url`. Verifies mpp-session is supported
-   * before opening a channel. Returns a SessionHandle for streaming + closing.
-   */
-  async openSession(url: string): Promise<SessionHandle> {
-    const baseUrl = new URL(url).origin
-    const manifest = await fetchManifest(baseUrl)
-
-    if (!manifest.modes.includes('mpp-session')) {
-      throw new RouteDockManifestError(
-        `Provider at ${baseUrl} does not support mpp-session mode`,
-      )
-    }
-
-    if (!this.commitmentSecret) {
-      throw new RouteDockManifestError(
-        'commitmentSecret is required in RouteDockClientConfig for mpp-session mode',
-      )
-    }
-
-    return this.session.openSession(url, manifest, this.commitmentSecret)
-  }
-
-  /** Check local daily cap and record the spend. Throws if cap exceeded. */
-  private _checkAndRecordSpend(amount: string): void {
-    if (!this.spendCap) return
-
-    const today = new Date().toISOString().slice(0, 10)
-    if (this.dailySpend.date !== today) {
-      this.dailySpend = { date: today, total: 0 }
-    }
-
-    const amountNum = parseFloat(amount)
-    const capNum = parseFloat(this.spendCap.daily)
-    if (this.dailySpend.total + amountNum > capNum) {
-      throw new RouteDockPolicyRejectedError('local_daily_cap_exceeded')
-    }
-
-    this.dailySpend.total += amountNum
-  }
-}

package/src/client/index.ts

@@ -1,8 +0,0 @@
-// Client-only exports (no provider/Express)
-export * from '../types.js'
-export * from './RouteDockClient.js'
-export * from './ModeRouter.js'
-export * from './x402Client.js'
-export * from './MppChargeClient.js'
-export * from './MppSessionClient.js'
-export * from '../store/SessionStore.js'