2020117-agent 0.1.15 → 0.2.0

package/dist/agent.d.ts

@@ -2,7 +2,7 @@
 /**
  * Unified Agent Runtime — runs as a long-lived daemon that handles both:
  *   1. Async platform tasks (inbox polling → accept → Ollama → submit result)
- *   2. Real-time P2P streaming (Hyperswarm + Cashu micro-payments)
+ *   2. Real-time P2P streaming (Hyperswarm + CLINK debit payments)
  *
  * Both channels share a single capacity counter so the agent never overloads.
  *

package/dist/agent.js

@@ -2,7 +2,7 @@
 /**
  * Unified Agent Runtime — runs as a long-lived daemon that handles both:
  *   1. Async platform tasks (inbox polling → accept → Ollama → submit result)
- *   2. Real-time P2P streaming (Hyperswarm + Cashu micro-payments)
+ *   2. Real-time P2P streaming (Hyperswarm + CLINK debit payments)
  *
  * Both channels share a single capacity counter so the agent never overloads.
  *
@@ -66,15 +66,18 @@ for (const arg of process.argv.slice(2)) {
         case '--skill':
             process.env.SKILL_FILE = val;
             break;
+        case '--lightning-address':
+            process.env.LIGHTNING_ADDRESS = val;
+            break;
     }
 }
 import { randomBytes } from 'crypto';
 import { SwarmNode, topicFromKind } from './swarm.js';
-import { waitForPayment, handlePayment, handleStop, streamToCustomer, batchClaim } from './p2p-provider.js';
+import { collectP2PPayment, handleStop, streamToCustomer } from './p2p-provider.js';
 import { streamFromProvider } from './p2p-customer.js';
 import { createProcessor } from './processor.js';
 import { hasApiKey, loadAgentName, registerService, startHeartbeatLoop, getInbox, acceptJob, sendFeedback, submitResult, createJob, getJob, } from './api.js';
-import { peekToken } from './cashu.js';
+import { initClinkAgent, collectPayment } from './clink.js';
 import { readFileSync } from 'fs';
 import WebSocket from 'ws';
 // --- Config from env ---
@@ -84,6 +87,8 @@ const POLL_INTERVAL = Number(process.env.POLL_INTERVAL) || 30_000;
 const SATS_PER_CHUNK = Number(process.env.SATS_PER_CHUNK) || 1;
 const CHUNKS_PER_PAYMENT = Number(process.env.CHUNKS_PER_PAYMENT) || 10;
 const PAYMENT_TIMEOUT = Number(process.env.PAYMENT_TIMEOUT) || 30_000;
+// --- CLINK payment config ---
+const LIGHTNING_ADDRESS = process.env.LIGHTNING_ADDRESS || '';
 // --- Sub-task delegation config ---
 const SUB_KIND = process.env.SUB_KIND ? Number(process.env.SUB_KIND) : null;
 const SUB_BUDGET = Number(process.env.SUB_BUDGET) || 50;
@@ -158,13 +163,18 @@ async function main() {
     if (state.skill) {
         console.log(`[${label}] Skill: ${state.skill.name} v${state.skill.version} (${state.skill.features.join(', ')})`);
     }
-    // 2. Platform registration + heartbeat
+    // 2. Initialize CLINK agent identity (for P2P session debit)
+    if (LIGHTNING_ADDRESS) {
+        const { pubkey } = initClinkAgent();
+        console.log(`[${label}] CLINK: ${LIGHTNING_ADDRESS} (agent pubkey: ${pubkey.slice(0, 16)}...)`);
+    }
+    // 3. Platform registration + heartbeat
     await setupPlatform(label);
-    // 3. Async inbox poller
+    // 4. Async inbox poller
     startInboxPoller(label);
-    // 4. P2P swarm listener
+    // 5. P2P swarm listener
     await startSwarmListener(label);
-    // 5. Graceful shutdown
+    // 6. Graceful shutdown
     setupShutdown(label);
     console.log(`[${label}] Agent ready — async + P2P channels active\n`);
 }
@@ -290,14 +300,18 @@ async function processAsyncJob(label, inboxJobId, input, params) {
 }
 // --- Sub-task delegation ---
 /**
- * Delegate a sub-task via Hyperswarm P2P with Cashu streaming payments.
+ * Delegate a sub-task via Hyperswarm P2P with CLINK debit payments.
  * Thin wrapper around the shared streamFromProvider() module.
  */
 async function* delegateP2PStream(kind, input, budgetSats) {
+    const ndebit = process.env.CLINK_NDEBIT || '';
+    if (!ndebit)
+        throw new Error('Pipeline sub-delegation requires CLINK_NDEBIT env var (--ndebit)');
     yield* streamFromProvider({
         kind,
         input,
         budgetSats,
+        ndebit,
         maxSatsPerChunk: MAX_SATS_PER_CHUNK,
         label: 'sub-p2p',
     });
@@ -382,77 +396,89 @@ async function startSwarmListener(label) {
         }
         // --- Session protocol ---
         if (msg.type === 'session_start') {
+            if (!LIGHTNING_ADDRESS) {
+                console.warn(`[${label}] Session rejected: no --lightning-address configured`);
+                node.send(socket, { type: 'error', id: msg.id, message: 'Provider has no Lightning Address configured' });
+                return;
+            }
+            if (!msg.ndebit) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'session_start requires ndebit authorization' });
+                return;
+            }
             const satsPerMinute = state.skill?.pricing?.sats_per_minute
                 || Number(process.env.SATS_PER_MINUTE)
                 || msg.sats_per_minute
                 || 10;
+            const BILLING_INTERVAL_MIN = 10;
+            const debitAmount = satsPerMinute * BILLING_INTERVAL_MIN;
             const sessionId = randomBytes(8).toString('hex');
-            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min`);
+            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min, billing every ${BILLING_INTERVAL_MIN}min (${debitAmount} sats)`);
             const session = {
                 socket,
                 peerId,
                 sessionId,
                 satsPerMinute,
-                tokens: [],
+                ndebit: msg.ndebit,
                 totalEarned: 0,
                 startedAt: Date.now(),
-                lastTickAt: Date.now(),
+                lastDebitAt: Date.now(),
+                debitTimer: null,
                 timeoutTimer: null,
             };
-            // Dynamic timeout based on tick value: if a tick covers N minutes of service,
-            // allow N minutes + 2 min grace before timing out. Updates on each tick.
-            const baseTimeoutMs = satsPerMinute > 0
-                ? Math.max(120_000, Math.round((1 / satsPerMinute) * 60_000) + 120_000)
-                : 120_000;
-            session.timeoutTimer = setInterval(() => {
-                // Recalculate timeout based on last tick amount
-                const lastTickAmount = session.totalEarned > 0
-                    ? Math.max(1, session.tokens.length > 0 ? peekToken(session.tokens[session.tokens.length - 1]).amount : 1)
-                    : 1;
-                const tickCoverageMs = satsPerMinute > 0
-                    ? Math.round((lastTickAmount / satsPerMinute) * 60_000) + 120_000
-                    : baseTimeoutMs;
-                const elapsed = Date.now() - session.lastTickAt;
-                if (elapsed > tickCoverageMs) {
-                    console.log(`[${label}] Session ${sessionId}: timeout (no tick for ${Math.round(elapsed / 1000)}s, limit ${Math.round(tickCoverageMs / 1000)}s)`);
-                    endSession(node, session, label);
-                }
-            }, 30_000);
             activeSessions.set(sessionId, session);
+            // Debit first 10 minutes immediately (prepaid model)
+            const firstDebit = await collectPayment({
+                ndebit: session.ndebit,
+                lightningAddress: LIGHTNING_ADDRESS,
+                amountSats: debitAmount,
+            });
+            if (!firstDebit.ok) {
+                console.warn(`[${label}] Session ${sessionId}: first debit failed: ${firstDebit.error}`);
+                node.send(socket, { type: 'error', id: msg.id, message: `Payment failed: ${firstDebit.error}` });
+                activeSessions.delete(sessionId);
+                return;
+            }
+            session.totalEarned += debitAmount;
+            session.lastDebitAt = Date.now();
+            console.log(`[${label}] Session ${sessionId}: first ${BILLING_INTERVAL_MIN}min paid (${debitAmount} sats)`);
             node.send(socket, {
                 type: 'session_ack',
                 id: msg.id,
                 session_id: sessionId,
                 sats_per_minute: satsPerMinute,
             });
-            return;
-        }
-        if (msg.type === 'session_tick') {
-            const session = activeSessions.get(msg.session_id || '');
-            if (!session) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'Unknown session' });
-                return;
-            }
-            if (!msg.token) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'Tick missing token' });
-                return;
-            }
-            try {
-                const peek = peekToken(msg.token);
-                session.tokens.push(msg.token);
-                session.totalEarned += peek.amount;
-                session.lastTickAt = Date.now();
-                console.log(`[${label}] Session ${session.sessionId}: tick ${peek.amount} sats (total: ${session.totalEarned})`);
+            // Notify customer of the debit
+            node.send(socket, {
+                type: 'session_tick_ack',
+                id: sessionId,
+                session_id: sessionId,
+                amount: debitAmount,
+                balance: msg.budget ? msg.budget - session.totalEarned : undefined,
+            });
+            // Debit every 10 minutes
+            session.debitTimer = setInterval(async () => {
+                const debit = await collectPayment({
+                    ndebit: session.ndebit,
+                    lightningAddress: LIGHTNING_ADDRESS,
+                    amountSats: debitAmount,
+                });
+                if (!debit.ok) {
+                    console.log(`[${label}] Session ${sessionId}: debit failed (${debit.error}) — ending session`);
+                    endSession(node, session, label);
+                    return;
+                }
+                session.totalEarned += debitAmount;
+                session.lastDebitAt = Date.now();
+                console.log(`[${label}] Session ${sessionId}: debit OK (+${debitAmount}, total: ${session.totalEarned} sats)`);
+                // Notify customer
                 node.send(socket, {
                     type: 'session_tick_ack',
-                    id: msg.id,
-                    session_id: session.sessionId,
+                    id: sessionId,
+                    session_id: sessionId,
+                    amount: debitAmount,
                     balance: msg.budget ? msg.budget - session.totalEarned : undefined,
                 });
-            }
-            catch (e) {
-                node.send(socket, { type: 'error', id: msg.id, message: `Tick payment failed: ${e.message}` });
-            }
+            }, BILLING_INTERVAL_MIN * 60_000);
             return;
         }
         if (msg.type === 'session_end') {
@@ -640,6 +666,14 @@ async function startSwarmListener(label) {
         }
         if (msg.type === 'request') {
             console.log(`[${label}] P2P job ${msg.id} from ${tag}: "${(msg.input || '').slice(0, 60)}..."`);
+            if (!LIGHTNING_ADDRESS) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'Provider has no Lightning Address configured' });
+                return;
+            }
+            if (!msg.ndebit) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'Request requires ndebit authorization' });
+                return;
+            }
             if (!acquireSlot()) {
                 node.send(socket, {
                     type: 'error',
@@ -655,10 +689,9 @@ async function startSwarmListener(label) {
             const job = {
                 socket,
                 credit: 0,
-                tokens: [],
+                ndebit: msg.ndebit,
                 totalEarned: 0,
                 stopped: false,
-                paymentResolve: null,
             };
             p2pJobs.set(msg.id, job);
             // Send offer
@@ -668,10 +701,16 @@ async function startSwarmListener(label) {
                 sats_per_chunk: SATS_PER_CHUNK,
                 chunks_per_payment: CHUNKS_PER_PAYMENT,
             });
-            // Wait for first payment
-            const paid = await waitForPayment(job, msg.id, node, label, PAYMENT_TIMEOUT);
+            // Debit first payment cycle via CLINK
+            const paid = await collectP2PPayment({
+                job, node, jobId: msg.id,
+                satsPerChunk: SATS_PER_CHUNK,
+                chunksPerPayment: CHUNKS_PER_PAYMENT,
+                lightningAddress: LIGHTNING_ADDRESS,
+                label,
+            });
             if (!paid) {
-                console.log(`[${label}] P2P job ${msg.id}: no initial payment, aborting`);
+                console.log(`[${label}] P2P job ${msg.id}: first debit failed, aborting`);
                 p2pJobs.delete(msg.id);
                 releaseSlot();
                 return;
@@ -680,18 +719,13 @@ async function startSwarmListener(label) {
             node.send(socket, { type: 'accepted', id: msg.id });
             await runP2PGeneration(node, job, msg, label);
         }
-        if (msg.type === 'payment') {
-            const job = p2pJobs.get(msg.id);
-            if (job)
-                handlePayment(node, socket, msg, job, SATS_PER_CHUNK, label);
-        }
         if (msg.type === 'stop') {
             const job = p2pJobs.get(msg.id);
             if (job)
                 handleStop(job, msg.id, label);
         }
     });
-    // Handle customer disconnect — claim any earned tokens immediately
+    // Handle customer disconnect — payments already settled via CLINK
     node.on('peer-leave', (peerId) => {
         const tag = peerId.slice(0, 8);
         // Find and end all sessions for this peer
@@ -704,9 +738,8 @@ async function startSwarmListener(label) {
         // Clean up any P2P streaming jobs for this peer
         for (const [jobId, job] of p2pJobs) {
             if (job.socket?.remotePublicKey?.toString('hex') === peerId) {
-                console.log(`[${label}] Peer ${tag} disconnected — claiming P2P job ${jobId} tokens`);
+                console.log(`[${label}] Peer ${tag} disconnected — P2P job ${jobId} (${job.totalEarned} sats earned)`);
                 job.stopped = true;
-                batchClaim(job.tokens, jobId, label);
                 p2pJobs.delete(jobId);
                 releaseSlot();
             }
@@ -734,10 +767,10 @@ async function runP2PGeneration(node, job, msg, label) {
         source,
         satsPerChunk: SATS_PER_CHUNK,
         chunksPerPayment: CHUNKS_PER_PAYMENT,
-        timeoutMs: PAYMENT_TIMEOUT,
+        lightningAddress: LIGHTNING_ADDRESS,
         label,
     });
-    await batchClaim(job.tokens, msg.id, label);
+    // No batch claim needed — CLINK payments settle instantly via Lightning
     p2pJobs.delete(msg.id);
     releaseSlot();
 }
@@ -751,8 +784,13 @@ function findSessionBySocket(socket) {
 }
 function endSession(node, session, label) {
     const durationS = Math.round((Date.now() - session.startedAt) / 1000);
+    // Stop debit timer
+    if (session.debitTimer) {
+        clearInterval(session.debitTimer);
+        session.debitTimer = null;
+    }
     if (session.timeoutTimer) {
-        clearInterval(session.timeoutTimer);
+        clearTimeout(session.timeoutTimer);
         session.timeoutTimer = null;
     }
     // Close all backend WebSockets for this peer
@@ -778,11 +816,9 @@ function endSession(node, session, label) {
         // Socket may already be closed (peer disconnect)
     }
     console.log(`[${label}] Session ${session.sessionId} ended: ${session.totalEarned} sats, ${durationS}s`);
-    // Update P2P lifetime counters
+    // Update P2P lifetime counters — no batch claim needed with CLINK (payments settled instantly)
     state.p2pSessionsCompleted++;
     state.p2pTotalEarnedSats += session.totalEarned;
-    // Batch claim tokens
-    batchClaim(session.tokens, session.sessionId, label);
     activeSessions.delete(session.sessionId);
 }
 // --- 5. Graceful shutdown ---

package/dist/clink.d.ts

@@ -0,0 +1,42 @@
+/**
+ * CLINK payment utilities — replaces Cashu for P2P payments
+ *
+ * Provider uses ndebit to pull payments from customer's wallet.
+ * Invoice generation via LNURL-pay from provider's own Lightning Address.
+ */
+export declare function initClinkAgent(): {
+    privateKey: Uint8Array;
+    pubkey: string;
+};
+export interface DebitResult {
+    ok: boolean;
+    preimage?: string;
+    error?: string;
+}
+/**
+ * Provider calls this to debit customer's wallet via CLINK protocol.
+ * Sends a Kind 21002 event to the customer's wallet service via Nostr relay.
+ */
+export declare function debitCustomer(opts: {
+    ndebit: string;
+    bolt11: string;
+    timeoutSeconds?: number;
+}): Promise<DebitResult>;
+/**
+ * Resolve a Lightning Address to a bolt11 invoice via LNURL-pay protocol.
+ * The provider calls this on their OWN Lightning Address to generate
+ * an invoice that pays themselves.
+ *
+ * Flow: address → .well-known/lnurlp → callback?amount= → bolt11
+ */
+export declare function generateInvoice(lightningAddress: string, amountSats: number): Promise<string>;
+/**
+ * Full payment cycle: generate invoice from provider's Lightning Address,
+ * then debit customer's wallet via CLINK.
+ */
+export declare function collectPayment(opts: {
+    ndebit: string;
+    lightningAddress: string;
+    amountSats: number;
+    timeoutSeconds?: number;
+}): Promise<DebitResult>;

package/dist/clink.js

@@ -0,0 +1,87 @@
+/**
+ * CLINK payment utilities — replaces Cashu for P2P payments
+ *
+ * Provider uses ndebit to pull payments from customer's wallet.
+ * Invoice generation via LNURL-pay from provider's own Lightning Address.
+ */
+import { ClinkSDK, decodeBech32, generateSecretKey, getPublicKey, newNdebitPaymentRequest } from '@shocknet/clink-sdk';
+// --- Agent identity ---
+let agentKey = null;
+let agentPubkey = null;
+export function initClinkAgent() {
+    agentKey = generateSecretKey();
+    agentPubkey = getPublicKey(agentKey);
+    console.log(`[clink] Agent identity: ${agentPubkey.slice(0, 16)}...`);
+    return { privateKey: agentKey, pubkey: agentPubkey };
+}
+/**
+ * Provider calls this to debit customer's wallet via CLINK protocol.
+ * Sends a Kind 21002 event to the customer's wallet service via Nostr relay.
+ */
+export async function debitCustomer(opts) {
+    if (!agentKey)
+        throw new Error('CLINK agent not initialized — call initClinkAgent() first');
+    const decoded = decodeBech32(opts.ndebit);
+    if (decoded.type !== 'ndebit')
+        throw new Error(`Invalid ndebit string (got type: ${decoded.type})`);
+    const sdk = new ClinkSDK({
+        privateKey: agentKey,
+        relays: [decoded.data.relay],
+        toPubKey: decoded.data.pubkey,
+        defaultTimeoutSeconds: opts.timeoutSeconds ?? 30,
+    });
+    const result = await sdk.Ndebit(newNdebitPaymentRequest(opts.bolt11, undefined, decoded.data.pointer));
+    if (result.res === 'ok') {
+        return { ok: true, preimage: result.preimage };
+    }
+    return { ok: false, error: result.error || 'Debit rejected' };
+}
+// --- Invoice generation via LNURL-pay ---
+/**
+ * Resolve a Lightning Address to a bolt11 invoice via LNURL-pay protocol.
+ * The provider calls this on their OWN Lightning Address to generate
+ * an invoice that pays themselves.
+ *
+ * Flow: address → .well-known/lnurlp → callback?amount= → bolt11
+ */
+export async function generateInvoice(lightningAddress, amountSats) {
+    const [user, domain] = lightningAddress.split('@');
+    if (!user || !domain)
+        throw new Error(`Invalid Lightning Address: ${lightningAddress}`);
+    // Step 1: Fetch LNURL-pay metadata
+    const metaUrl = `https://${domain}/.well-known/lnurlp/${user}`;
+    const metaResp = await fetch(metaUrl);
+    if (!metaResp.ok)
+        throw new Error(`LNURL fetch failed: ${metaResp.status} from ${metaUrl}`);
+    const meta = await metaResp.json();
+    if (meta.tag !== 'payRequest')
+        throw new Error(`Not a LNURL-pay endpoint (tag: ${meta.tag})`);
+    const amountMsats = amountSats * 1000;
+    if (amountMsats < meta.minSendable)
+        throw new Error(`Amount ${amountSats} sats below min ${meta.minSendable / 1000} sats`);
+    if (amountMsats > meta.maxSendable)
+        throw new Error(`Amount ${amountSats} sats above max ${meta.maxSendable / 1000} sats`);
+    // Step 2: Request invoice from callback
+    const sep = meta.callback.includes('?') ? '&' : '?';
+    const invoiceUrl = `${meta.callback}${sep}amount=${amountMsats}`;
+    const invoiceResp = await fetch(invoiceUrl);
+    if (!invoiceResp.ok)
+        throw new Error(`Invoice request failed: ${invoiceResp.status}`);
+    const invoiceData = await invoiceResp.json();
+    if (!invoiceData.pr)
+        throw new Error(`No invoice returned: ${invoiceData.reason || 'unknown error'}`);
+    return invoiceData.pr;
+}
+// --- Combined: generate invoice + debit ---
+/**
+ * Full payment cycle: generate invoice from provider's Lightning Address,
+ * then debit customer's wallet via CLINK.
+ */
+export async function collectPayment(opts) {
+    const bolt11 = await generateInvoice(opts.lightningAddress, opts.amountSats);
+    return debitCustomer({
+        ndebit: opts.ndebit,
+        bolt11,
+        timeoutSeconds: opts.timeoutSeconds,
+    });
+}

package/dist/customer.d.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /**
- * Standalone P2P Customer — connects to a provider, streams results with Cashu payments.
+ * Standalone P2P Customer — connects to a provider, streams results with CLINK debit payments.
  *
  * Usage:
- *   2020117-customer --kind=5100 --budget=50 "Explain quantum computing"
+ *   2020117-customer --kind=5100 --budget=50 --ndebit=ndebit1... "Explain quantum computing"
  */
 export {};

package/dist/customer.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
- * Standalone P2P Customer — connects to a provider, streams results with Cashu payments.
+ * Standalone P2P Customer — connects to a provider, streams results with CLINK debit payments.
  *
  * Usage:
- *   2020117-customer --kind=5100 --budget=50 "Explain quantum computing"
+ *   2020117-customer --kind=5100 --budget=50 --ndebit=ndebit1... "Explain quantum computing"
  */
 // --- CLI args → env (before any imports) ---
 for (const arg of process.argv.slice(2)) {
@@ -24,26 +24,35 @@ for (const arg of process.argv.slice(2)) {
         case '--max-price':
             process.env.MAX_SATS_PER_CHUNK = val;
             break;
+        case '--ndebit':
+            process.env.CLINK_NDEBIT = val;
+            break;
     }
 }
 import { streamFromProvider } from './p2p-customer.js';
 const KIND = Number(process.env.DVM_KIND) || 5100;
 const BUDGET_SATS = Number(process.env.BUDGET_SATS) || 100;
 const MAX_SATS_PER_CHUNK = Number(process.env.MAX_SATS_PER_CHUNK) || 5;
+const NDEBIT = process.env.CLINK_NDEBIT || '';
 async function main() {
     const prompt = process.argv.slice(2).filter(a => !a.startsWith('--')).join(' ');
     if (!prompt) {
-        console.error('Usage: 2020117-customer --kind=5100 --budget=50 "your prompt here"');
+        console.error('Usage: 2020117-customer --kind=5100 --budget=50 --ndebit=ndebit1... "your prompt here"');
+        process.exit(1);
+    }
+    if (!NDEBIT) {
+        console.error('[customer] Error: --ndebit=ndebit1... required (CLINK debit authorization)');
         process.exit(1);
     }
     console.log(`[customer] Prompt: "${prompt.slice(0, 60)}..."`);
     console.log(`[customer] Budget: ${BUDGET_SATS} sats, max price: ${MAX_SATS_PER_CHUNK} sat/chunk`);
-    // Stream from provider (handles connection, negotiation, payments internally)
+    // Stream from provider (handles connection, negotiation, CLINK payments internally)
     let output = '';
     for await (const chunk of streamFromProvider({
         kind: KIND,
         input: prompt,
         budgetSats: BUDGET_SATS,
+        ndebit: NDEBIT,
         maxSatsPerChunk: MAX_SATS_PER_CHUNK,
         label: 'customer',
     })) {

package/dist/p2p-customer.d.ts

@@ -1,9 +1,10 @@
 /**
  * Shared P2P customer protocol — connects to a provider via Hyperswarm,
- * negotiates price, pays with Cashu micro-tokens, and streams chunks.
+ * negotiates price, authorizes CLINK debit payments, and streams chunks.
  *
- * Extracted from agent.ts delegateP2PStream(), customer.ts, and pipeline.ts runStep()
- * to eliminate triple duplication of the same protocol logic.
+ * The customer sends an ndebit authorization with the request. The provider
+ * pulls payments directly from the customer's wallet via CLINK debit —
+ * the customer does not send payment messages.
  *
  * Exports:
  *   - P2PStreamOptions — config interface
@@ -21,6 +22,8 @@ export interface P2PStreamOptions {
     input: string;
     /** Total budget in sats for this session */
     budgetSats: number;
+    /** Customer's ndebit1... authorization for CLINK debit payments */
+    ndebit: string;
     /** Maximum acceptable price per chunk in sats (default: 5) */
     maxSatsPerChunk?: number;
     /** Overall timeout in milliseconds (default: 120_000) */
@@ -31,8 +34,8 @@ export interface P2PStreamOptions {
     params?: Record<string, unknown>;
 }
 /**
- * Connect to a provider via Hyperswarm, negotiate price, pay with Cashu
- * micro-tokens, and yield output chunks as they arrive.
+ * Connect to a provider via Hyperswarm, authorize CLINK debit payments,
+ * and yield output chunks as they arrive.
  *
  * Creates and destroys its own temporary SwarmNode — callers do not need
  * to manage any swarm state.
@@ -43,6 +46,7 @@ export interface P2PStreamOptions {
  *   kind: 5100,
  *   input: 'Explain quantum computing',
  *   budgetSats: 50,
+ *   ndebit: 'ndebit1...',
  * })) {
  *   process.stdout.write(chunk)
  * }