MPP Session Flow (Streaming Payments)

Before writing code

Fetch live docs:

1. Fetch https://www.npmjs.com/package/mppx for the session middleware API and payment channel configuration
2. Fetch https://paymentauth.org/ for the canonical session intent specification
3. Web-search mpp session streaming micropayments payment channel for session implementation patterns
4. Web-search site:mpp.dev session for session-specific documentation

Conceptual Architecture

What Session Intent Is

The session intent implements streaming micropayments — often described as "OAuth for money". The agent authorizes a spending limit upfront, then streams micropayments continuously as it consumes resources:

1. Client opens session with spending cap
2. Server creates payment channel
3. Client makes requests — each deducts from the spending cap
4. Micropayments stream at sub-cent costs, sub-millisecond latency
5. Session closes — final settlement on-chain (single transaction)

When to Use Session

• Per-token billing — LLM inference charged per token generated
• Continuous data feeds — Real-time market data, sensor streams
• Compute metering — Pay for actual CPU/GPU seconds used
• Bandwidth metering — Pay per KB transferred
• Any high-frequency, low-value access pattern

Session vs Charge Comparison

Server-Side Implementation

// Protect a route with a session payment gate
app.get('/api/stream', mppx.session({ maxAmount: '10000' }), async (c) => {
  // Deducts from the session's spending cap
  return c.json({ data: 'streaming content' });
});

Session Lifecycle

1. Open — Client sends initial request; server returns 402 with session challenge
2. Authorize — Client authorizes spending cap (e.g., 10,000 units)
3. Active — Client makes requests; each deducts from the cap
4. Refill — Client can extend the cap before it runs out
5. Close — Either party closes; final settlement happens on-chain
6. Settled — Single on-chain transaction for the total consumed amount

Payment Channel

Session payments use a payment channel — an off-chain mechanism where:

• Funds are locked upfront in a channel
• Each micropayment updates the channel state without on-chain transactions
• Only the opening and closing transactions go on-chain
• This enables thousands of sub-cent payments at sub-millisecond latency

Spending Cap Management

• Agent sets the maximum they're willing to spend in the session
• Server deducts from this cap per request/unit consumed
• Agent can monitor remaining balance
• If cap is exhausted, server returns 402 for a new session
• Agent can proactively extend the cap

Metering Patterns

Best Practices

• Set reasonable default spending caps (not too high for safety, not too low for UX)
• Implement cap exhaustion warnings before the cap runs out
• Log metering data for billing reconciliation
• Handle session interruptions gracefully (network drops, server restarts)
• Implement session resumption where possible
• Monitor session durations and spending patterns for pricing optimization

Fetch the latest mppx SDK documentation and MPP specification for exact session API, payment channel mechanics, and configuration options before implementing.