2020117-agent 0.2.5 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # 2020117-agent
 
-Decentralized AI agent runtime for the [2020117](https://2020117.xyz) network. Connects your agent to the DVM compute marketplace via API polling + P2P Hyperswarm, with Lightning/Cashu micro-payments.
+Decentralized AI agent runtime for the [2020117](https://2020117.xyz) network. Connects your agent to the DVM compute marketplace via API polling + P2P Hyperswarm, with CLINK Lightning payments.
 
 ## Quick Start
 
@@ -14,8 +14,8 @@ npx 2020117-agent --kind=5302 --processor=exec:./translate.sh
 # Run as provider (HTTP backend)
 npx 2020117-agent --kind=5200 --processor=http://localhost:7860 --models=sdxl-lightning,sd3.5-turbo
 
-# P2P streaming customer
-npx 2020117-customer --kind=5100 --budget=50 "Explain quantum computing"
+# P2P session — rent an agent by the minute
+npx 2020117-session --kind=5200 --budget=500 --port=8080
 ```
 
 ## Setup
@@ -47,10 +47,8 @@ npx 2020117-agent --agent=my-agent --kind=5100
 
 | Command | Description |
 |---------|-------------|
-| `2020117-agent` | Unified agent (API polling + P2P listening) |
-| `2020117-customer` | P2P streaming customer |
-| `2020117-provider` | P2P-only provider |
-| `2020117-pipeline` | Multi-step pipeline agent |
+| `2020117-agent` | Unified agent (API polling + P2P session listening) |
+| `2020117-session` | P2P session client (CLI REPL + HTTP proxy) |
 
 ## CLI Parameters
 
@@ -64,10 +62,11 @@ npx 2020117-agent --agent=my-agent --kind=5100
 | `--max-jobs` | `MAX_JOBS` | Max concurrent jobs (default: 3) |
 | `--api-key` | `API_2020117_KEY` | API key (overrides `.2020117_keys`) |
 | `--api-url` | `API_2020117_URL` | API base URL |
-| `--sub-kind` | `SUB_KIND` | Sub-task kind (enables pipeline) |
-| `--sub-channel` | `SUB_CHANNEL` | Sub-task channel: `p2p` or `api` |
-| `--budget` | `SUB_BUDGET` | P2P sub-task budget in sats |
+| `--sub-kind` | `SUB_KIND` | Sub-task kind (enables pipeline via API) |
 | `--skill` | `SKILL_FILE` | Path to skill JSON file describing agent capabilities |
+| `--port` | `SESSION_PORT` | Session HTTP proxy port (default: 8080) |
+| `--provider` | `PROVIDER_PUBKEY` | Target provider public key |
+| `--lightning-address` | `LIGHTNING_ADDRESS` | Provider's Lightning Address (auto-fetched from platform if not set) |
 
 Environment variables also work: `AGENT=my-agent DVM_KIND=5100 2020117-agent`
 
@@ -85,7 +84,7 @@ Environment variables also work: `AGENT=my-agent DVM_KIND=5100 2020117-agent`
 ```js
 import { createProcessor } from '2020117-agent/processor'
 import { SwarmNode } from '2020117-agent/swarm'
-import { mintTokens } from '2020117-agent/cashu'
+import { collectPayment } from '2020117-agent/clink'
 import { hasApiKey, registerService } from '2020117-agent/api'
 ```
 
@@ -99,14 +98,14 @@ import { hasApiKey, registerService } from '2020117-agent/api'
   (heartbeat,       │  (inbox → accept →  │
    inbox, result)   │   process → result) │
                     │                     │
-  Hyperswarm DHT ◄──┤  P2P Listener      │──► Cashu Payments
-  (encrypted TCP)   │  (offer → chunks → │     (mint/split/claim)
-                    │   result)           │
+  Hyperswarm DHT ◄──┤  P2P Sessions      │──► CLINK Payments
+  (encrypted TCP)   │  (session → HTTP   │     (ndebit via Lightning)
+                    │   tunnel → result) │
                     └─────────────────────┘
 ```
 
 - **API channel**: Polls platform inbox, accepts jobs, submits results. Lightning payments on completion.
-- **P2P channel**: Listens on Hyperswarm DHT topic `SHA256("2020117-dvm-kind-{kind}")`. Cashu micro-payments per chunk.
+- **P2P channel**: Listens on Hyperswarm DHT topic `SHA256("2020117-dvm-kind-{kind}")`. Interactive sessions with CLINK per-minute billing.
 - Both channels share a single capacity counter — the agent never overloads.
 
 ## Development

package/dist/agent.d.ts

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /**
- * 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 + CLINK debit payments)
+ * Unified Agent Runtime — runs as a long-lived daemon that handles:
+ *   1. Async platform tasks (inbox polling → accept → process → submit result)
+ *   2. P2P sessions (Hyperswarm + CLINK per-minute billing)
  *
  * Both channels share a single capacity counter so the agent never overloads.
  *

package/dist/agent.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 /**
- * 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 + CLINK debit payments)
+ * Unified Agent Runtime — runs as a long-lived daemon that handles:
+ *   1. Async platform tasks (inbox polling → accept → process → submit result)
+ *   2. P2P sessions (Hyperswarm + CLINK per-minute billing)
  *
  * Both channels share a single capacity counter so the agent never overloads.
  *
@@ -42,18 +42,12 @@ for (const arg of process.argv.slice(2)) {
         case '--sub-kind':
             process.env.SUB_KIND = val;
             break;
-        case '--sub-channel':
-            process.env.SUB_CHANNEL = val;
-            break;
         case '--sub-provider':
             process.env.SUB_PROVIDER = val;
             break;
         case '--sub-bid':
             process.env.SUB_BID = val;
             break;
-        case '--budget':
-            process.env.SUB_BUDGET = val;
-            break;
         case '--api-key':
             process.env.API_2020117_KEY = val;
             break;
@@ -73,10 +67,8 @@ for (const arg of process.argv.slice(2)) {
 }
 import { randomBytes } from 'crypto';
 import { SwarmNode, topicFromKind } from './swarm.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, getProfile, } from './api.js';
+import { hasApiKey, loadAgentName, registerService, startHeartbeatLoop, getInbox, acceptJob, sendFeedback, submitResult, createJob, getJob, getProfile, reportSession, } from './api.js';
 import { initClinkAgent, collectPayment } from './clink.js';
 import { readFileSync } from 'fs';
 import WebSocket from 'ws';
@@ -86,18 +78,13 @@ const MAX_CONCURRENT = Number(process.env.MAX_JOBS) || 3;
 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 ---
 let 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;
-const SUB_CHANNEL = process.env.SUB_CHANNEL || 'p2p';
 const SUB_PROVIDER = process.env.SUB_PROVIDER || undefined;
 const SUB_BID = Number(process.env.SUB_BID) || 100;
-const MAX_SATS_PER_CHUNK = Number(process.env.MAX_SATS_PER_CHUNK) || 5;
 const MIN_BID_SATS = Number(process.env.MIN_BID_SATS) || SATS_PER_CHUNK * CHUNKS_PER_PAYMENT; // default = pricing per job
-const SUB_BATCH_SIZE = Number(process.env.SUB_BATCH_SIZE) || 500; // chars to accumulate before local processing
 // --- Skill file loading ---
 function loadSkill() {
     const skillPath = process.env.SKILL_FILE;
@@ -153,7 +140,7 @@ async function main() {
     state.processor = await createProcessor();
     console.log(`[${label}] kind=${KIND} processor=${state.processor.name} maxJobs=${MAX_CONCURRENT}`);
     if (SUB_KIND) {
-        console.log(`[${label}] Pipeline: sub-task kind=${SUB_KIND} via ${SUB_CHANNEL}${SUB_CHANNEL === 'api' ? ` (bid=${SUB_BID}${SUB_PROVIDER ? `, provider=${SUB_PROVIDER}` : ''})` : ` (budget=${SUB_BUDGET} sats)`}`);
+        console.log(`[${label}] Pipeline: sub-task kind=${SUB_KIND} (bid=${SUB_BID}${SUB_PROVIDER ? `, provider=${SUB_PROVIDER}` : ''})`);
     }
     else if (state.processor.name === 'none') {
         console.warn(`[${label}] WARNING: processor=none without SUB_KIND — generate() will pass through input as-is`);
@@ -266,23 +253,13 @@ async function processAsyncJob(label, inboxJobId, input, params) {
         console.log(`[${label}] Job ${providerJobId}: processing "${input.slice(0, 60)}..."`);
         await sendFeedback(providerJobId, 'processing');
         let result;
-        // Pipeline: delegate sub-task then process locally
+        // Pipeline: delegate sub-task via API then process locally
         if (SUB_KIND) {
-            console.log(`[${label}] Job ${providerJobId}: delegating to kind ${SUB_KIND} via ${SUB_CHANNEL}...`);
+            console.log(`[${label}] Job ${providerJobId}: delegating to kind ${SUB_KIND}...`);
             try {
-                if (SUB_CHANNEL === 'api') {
-                    // API delegation is non-streaming — collect full result, then process
-                    const subResult = await delegateAPI(SUB_KIND, input, SUB_BID, SUB_PROVIDER);
-                    console.log(`[${label}] Job ${providerJobId}: sub-task returned ${subResult.length} chars`);
-                    result = await state.processor.generate({ input: subResult, params });
-                }
-                else {
-                    // P2P delegation — stream-collect from sub-provider, batch-translate
-                    result = '';
-                    for await (const chunk of pipelineStream(SUB_KIND, input, SUB_BUDGET)) {
-                        result += chunk;
-                    }
-                }
+                const subResult = await delegateAPI(SUB_KIND, input, SUB_BID, SUB_PROVIDER);
+                console.log(`[${label}] Job ${providerJobId}: sub-task returned ${subResult.length} chars`);
+                result = await state.processor.generate({ input: subResult, params });
             }
             catch (e) {
                 console.error(`[${label}] Job ${providerJobId}: sub-task failed: ${e.message}, using original input`);
@@ -307,50 +284,6 @@ async function processAsyncJob(label, inboxJobId, input, params) {
     }
 }
 // --- Sub-task delegation ---
-/**
- * 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',
-    });
-}
-/**
- * Streaming pipeline: delegates to a sub-provider via P2P, accumulates
- * chunks into batches, translates each batch locally via streaming Ollama,
- * and yields the translated tokens.
- *
- * Flow: sub-provider streams → batch → Ollama stream-translate → yield tokens
- */
-async function* pipelineStream(kind, input, budgetSats) {
-    let batch = '';
-    async function* translateBatch(text) {
-        for await (const token of state.processor.generateStream({ input: text })) {
-            yield token;
-        }
-    }
-    for await (const chunk of delegateP2PStream(kind, input, budgetSats)) {
-        batch += chunk;
-        // When batch is big enough, translate and stream out
-        if (batch.length >= SUB_BATCH_SIZE) {
-            yield* translateBatch(batch);
-            batch = '';
-        }
-    }
-    // Translate remaining text
-    if (batch.length > 0) {
-        yield* translateBatch(batch);
-    }
-}
 /**
  * Delegate a sub-task via platform API. Creates a job, then polls until
  * the result is available (max 120s).
@@ -382,17 +315,13 @@ async function delegateAPI(kind, input, bidSats, provider) {
     }
     throw new Error(`Sub-task ${jobId} timed out after 120s`);
 }
-// --- 4. P2P Swarm Listener ---
-const p2pJobs = new Map();
 const activeSessions = new Map();
 // Backend WebSocket connections for WS tunnel (keyed by ws_id)
 const backendWebSockets = new Map();
 async function startSwarmListener(label) {
     const node = new SwarmNode();
     state.swarmNode = node;
-    const satsPerPayment = SATS_PER_CHUNK * CHUNKS_PER_PAYMENT;
     const topic = topicFromKind(KIND);
-    console.log(`[${label}] P2P: ${SATS_PER_CHUNK} sat/chunk, ${CHUNKS_PER_PAYMENT} chunks/payment (${satsPerPayment} sats/cycle)`);
     console.log(`[${label}] Joining swarm topic for kind ${KIND}`);
     await node.listen(topic);
     console.log(`[${label}] P2P listening for customers...`);
@@ -672,65 +601,6 @@ async function startSwarmListener(label) {
             }
             return;
         }
-        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',
-                    id: msg.id,
-                    message: `No capacity (${state.activeJobs}/${MAX_CONCURRENT} slots used)`,
-                });
-                console.log(`[${label}] P2P job ${msg.id}: rejected (no capacity)`);
-                return;
-            }
-            if (msg.budget !== undefined) {
-                console.log(`[${label}] Customer budget: ${msg.budget} sats`);
-            }
-            const job = {
-                socket,
-                credit: CHUNKS_PER_PAYMENT, // start with free credit; debit after delivery
-                ndebit: msg.ndebit,
-                totalEarned: 0,
-                stopped: false,
-            };
-            p2pJobs.set(msg.id, job);
-            // Send offer (price quote — no payment yet)
-            node.send(socket, {
-                type: 'offer',
-                id: msg.id,
-                sats_per_chunk: SATS_PER_CHUNK,
-                chunks_per_payment: CHUNKS_PER_PAYMENT,
-            });
-            // Generate first, pay after delivery
-            node.send(socket, { type: 'accepted', id: msg.id });
-            await runP2PGeneration(node, job, msg, label);
-            // Debit after result delivered
-            if (!job.stopped) {
-                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}: post-delivery debit failed`);
-                }
-            }
-        }
-        if (msg.type === 'stop') {
-            const job = p2pJobs.get(msg.id);
-            if (job)
-                handleStop(job, msg.id, label);
-        }
     });
     // Handle customer disconnect — payments already settled via CLINK
     node.on('peer-leave', (peerId) => {
@@ -742,15 +612,6 @@ async function startSwarmListener(label) {
                 endSession(node, session, 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 — P2P job ${jobId} (${job.totalEarned} sats earned)`);
-                job.stopped = true;
-                p2pJobs.delete(jobId);
-                releaseSlot();
-            }
-        }
         // Clean up backend WebSockets for this peer
         for (const [wsId, entry] of backendWebSockets) {
             if (entry.peerId === peerId) {
@@ -763,24 +624,6 @@ async function startSwarmListener(label) {
         }
     });
 }
-async function runP2PGeneration(node, job, msg, label) {
-    const source = SUB_KIND
-        ? pipelineStream(SUB_KIND, msg.input || '', SUB_BUDGET)
-        : state.processor.generateStream({ input: msg.input || '', params: msg.params });
-    await streamToCustomer({
-        node,
-        job,
-        jobId: msg.id,
-        source,
-        satsPerChunk: SATS_PER_CHUNK,
-        chunksPerPayment: CHUNKS_PER_PAYMENT,
-        lightningAddress: LIGHTNING_ADDRESS,
-        label,
-    });
-    // No batch claim needed — CLINK payments settle instantly via Lightning
-    p2pJobs.delete(msg.id);
-    releaseSlot();
-}
 // --- Session helpers ---
 function findSessionBySocket(socket) {
     for (const session of activeSessions.values()) {
@@ -826,6 +669,10 @@ function endSession(node, session, label) {
     // Update P2P lifetime counters — no batch claim needed with CLINK (payments settled instantly)
     state.p2pSessionsCompleted++;
     state.p2pTotalEarnedSats += session.totalEarned;
+    // Report session to platform activity feed (best-effort, no content exposed)
+    if (hasApiKey()) {
+        reportSession({ kind: KIND, durationS, totalSats: session.totalEarned });
+    }
     activeSessions.delete(session.sessionId);
 }
 // --- 5. Graceful shutdown ---

package/dist/api.d.ts

@@ -100,3 +100,12 @@ export declare function proxyDebit(opts: {
     lightningAddress: string;
     amountSats: number;
 }): Promise<ProxyDebitResult | null>;
+/**
+ * Report a completed P2P session to the platform for the activity feed.
+ * Content stays private — only metadata (kind, duration, sats) is sent.
+ */
+export declare function reportSession(opts: {
+    kind: number;
+    durationS: number;
+    totalSats: number;
+}): Promise<void>;

package/dist/api.js

@@ -282,3 +282,19 @@ export async function proxyDebit(opts) {
         amount_sats: opts.amountSats,
     });
 }
+/**
+ * Report a completed P2P session to the platform for the activity feed.
+ * Content stays private — only metadata (kind, duration, sats) is sent.
+ */
+export async function reportSession(opts) {
+    try {
+        await apiPost('/api/dvm/session-report', {
+            kind: opts.kind,
+            duration_s: opts.durationS,
+            total_sats: opts.totalSats,
+        });
+    }
+    catch {
+        // Best-effort — don't break session cleanup
+    }
+}

package/dist/clink.d.ts

@@ -1,5 +1,5 @@
 /**
- * CLINK payment utilities — replaces Cashu for P2P payments
+ * CLINK payment utilities — debit-based Lightning payments for P2P sessions
  *
  * Provider uses ndebit to pull payments from customer's wallet.
  * Invoice generation via LNURL-pay from provider's own Lightning Address.

package/dist/clink.js

@@ -1,5 +1,5 @@
 /**
- * CLINK payment utilities — replaces Cashu for P2P payments
+ * CLINK payment utilities — debit-based Lightning payments for P2P sessions
  *
  * Provider uses ndebit to pull payments from customer's wallet.
  * Invoice generation via LNURL-pay from provider's own Lightning Address.

package/dist/p2p-customer.d.ts

@@ -13,7 +13,7 @@
  */
 import { SwarmNode } from './swarm.js';
 /**
- * Configuration for a P2P streaming session.
+ * Configuration for a P2P connection.
  */
 export interface P2PStreamOptions {
     /** DVM kind number (e.g. 5100 for text generation) */

package/dist/p2p-customer.js

@@ -35,7 +35,7 @@ import { randomBytes } from 'crypto';
 export async function* streamFromProvider(opts) {
     const { kind, input, budgetSats, ndebit, maxSatsPerChunk = 5, timeoutMs = 120_000, label = 'p2p', params, } = opts;
     if (!ndebit) {
-        throw new Error('ndebit authorization required for P2P streaming');
+        throw new Error('ndebit authorization required for P2P connection');
     }
     const jobId = randomBytes(8).toString('hex');
     const tag = `${label}-${jobId.slice(0, 8)}`;

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "2020117-agent",
-  "version": "0.2.5",
+  "version": "0.3.1",
   "description": "2020117 agent runtime — API polling + Hyperswarm P2P + CLINK Lightning payments",
   "type": "module",
   "bin": {
     "2020117-agent": "./dist/agent.js",
-    "2020117-pipeline": "./dist/pipeline.js",
     "2020117-session": "./dist/session.js"
   },
   "files": [
@@ -15,18 +14,15 @@
     "./processor": "./dist/processor.js",
     "./swarm": "./dist/swarm.js",
     "./clink": "./dist/clink.js",
-    "./api": "./dist/api.js",
-    "./p2p-provider": "./dist/p2p-provider.js"
+    "./api": "./dist/api.js"
   },
   "scripts": {
     "agent": "node dist/agent.js",
-    "pipeline": "node dist/pipeline.js",
     "session": "node dist/session.js",
     "build": "tsc",
     "prepublishOnly": "tsc",
     "typecheck": "tsc --noEmit",
     "dev:agent": "npx tsx src/agent.ts",
-    "dev:pipeline": "npx tsx src/pipeline.ts",
     "dev:session": "npx tsx src/session.ts"
   },
   "dependencies": {

package/dist/cashu.d.ts

@@ -1,41 +0,0 @@
-/**
- * Cashu eCash helper — mint, send, receive, melt tokens
- *
- * Uses testnut.cashu.space (fake sats) for PoC.
- * Switch to mint.coinos.io for production.
- */
-import { Mint, Wallet } from '@cashu/cashu-ts';
-export declare function createWallet(mintUrl?: string): {
-    mint: Mint;
-    wallet: Wallet;
-};
-/**
- * Mint new tokens (testnut mints fake tokens without real Lightning payment)
- */
-export declare function mintTokens(amount: number, mintUrl?: string): Promise<{
-    token: string;
-    proofs: import("@cashu/cashu-ts").Proof[];
-}>;
-/**
- * Verify and receive a Cashu token — swaps proofs with the mint to prevent double-spend
- */
-export declare function receiveToken(tokenStr: string): Promise<{
-    proofs: import("@cashu/cashu-ts").Proof[];
-    amount: number;
-    mintUrl: string;
-}>;
-/**
- * Get the total amount of a token without claiming it
- */
-export declare function peekToken(tokenStr: string): {
-    amount: number;
-    mint: string;
-    proofCount: number;
-};
-/**
- * Split a large token into multiple micro-tokens of a given amount.
- * Used for streaming payments: customer pre-splits budget into per-payment chunks.
- *
- * Example: splitTokens(token_100sats, 10) → 10 tokens of 10 sats each
- */
-export declare function splitTokens(tokenStr: string, perAmount: number): Promise<string[]>;

package/dist/cashu.js

@@ -1,112 +0,0 @@
-/**
- * Cashu eCash helper — mint, send, receive, melt tokens
- *
- * Uses testnut.cashu.space (fake sats) for PoC.
- * Switch to mint.coinos.io for production.
- */
-import { Mint, Wallet, getEncodedToken, getDecodedToken, MintQuoteState } from '@cashu/cashu-ts';
-const DEFAULT_MINT_URL = process.env.CASHU_MINT_URL || 'https://nofee.testnut.cashu.space';
-export function createWallet(mintUrl = DEFAULT_MINT_URL) {
-    const mint = new Mint(mintUrl);
-    const wallet = new Wallet(mint);
-    return { mint, wallet };
-}
-/**
- * Mint new tokens (testnut mints fake tokens without real Lightning payment)
- */
-export async function mintTokens(amount, mintUrl = DEFAULT_MINT_URL) {
-    const { wallet } = createWallet(mintUrl);
-    await wallet.loadMint();
-    // Request a mint quote
-    const quote = await wallet.createMintQuote(amount);
-    console.log(`[cashu] Mint quote created: ${quote.quote}`);
-    // For testnut, quotes are auto-paid. For real mints, you'd pay the Lightning invoice.
-    // Poll until quote is paid
-    let state = quote.state;
-    for (let i = 0; i < 30 && state !== MintQuoteState.PAID; i++) {
-        await sleep(1000);
-        const check = await wallet.checkMintQuote(quote.quote);
-        state = check.state;
-    }
-    if (state !== MintQuoteState.PAID) {
-        throw new Error(`Mint quote not paid after 30s (state: ${state}). For real mints, pay invoice: ${quote.request}`);
-    }
-    // Mint the tokens (v3.5 returns Proof[] directly)
-    const proofs = await wallet.mintProofs(amount, quote.quote);
-    console.log(`[cashu] Minted ${amount} sats (${proofs.length} proofs)`);
-    // Encode as a portable token string
-    const token = getEncodedToken({ mint: mintUrl, proofs });
-    return { token, proofs };
-}
-/**
- * Verify and receive a Cashu token — swaps proofs with the mint to prevent double-spend
- */
-export async function receiveToken(tokenStr) {
-    const decoded = getDecodedToken(tokenStr);
-    const mintUrl = decoded.mint;
-    if (!mintUrl)
-        throw new Error('Token has no mint URL');
-    const { wallet } = createWallet(mintUrl);
-    await wallet.loadMint();
-    // Swap proofs with the mint (this claims them, preventing re-use)
-    const proofs = await wallet.receive(tokenStr);
-    const total = proofs.reduce((sum, p) => sum + p.amount, 0);
-    console.log(`[cashu] Received ${total} sats from token (${proofs.length} proofs)`);
-    return { proofs, amount: total, mintUrl };
-}
-/**
- * Get the total amount of a token without claiming it
- */
-export function peekToken(tokenStr) {
-    const decoded = getDecodedToken(tokenStr);
-    const total = decoded.proofs.reduce((sum, p) => sum + p.amount, 0);
-    return { amount: total, mint: decoded.mint, proofCount: decoded.proofs.length };
-}
-/**
- * Split a large token into multiple micro-tokens of a given amount.
- * Used for streaming payments: customer pre-splits budget into per-payment chunks.
- *
- * Example: splitTokens(token_100sats, 10) → 10 tokens of 10 sats each
- */
-export async function splitTokens(tokenStr, perAmount) {
-    const decoded = getDecodedToken(tokenStr);
-    const mintUrl = decoded.mint;
-    if (!mintUrl)
-        throw new Error('Token has no mint URL');
-    const { wallet } = createWallet(mintUrl);
-    await wallet.loadMint();
-    const microTokens = [];
-    let remaining = decoded.proofs;
-    while (true) {
-        const total = remaining.reduce((sum, p) => sum + p.amount, 0);
-        if (total < perAmount)
-            break;
-        let retries = 5;
-        while (retries > 0) {
-            try {
-                const { send, keep: kept } = await wallet.send(perAmount, remaining);
-                microTokens.push(getEncodedToken({ mint: mintUrl, proofs: send }));
-                remaining = kept;
-                break;
-            }
-            catch (e) {
-                if (retries > 1 && /rate.limit/i.test(e.message || '')) {
-                    const delay = (6 - retries) * 2000; // 2s, 4s, 6s, 8s
-                    console.log(`[cashu] Rate limited, waiting ${delay / 1000}s... (${retries - 1} retries left)`);
-                    await sleep(delay);
-                    retries--;
-                }
-                else {
-                    throw e;
-                }
-            }
-        }
-        if (remaining.length === 0)
-            break;
-    }
-    console.log(`[cashu] Split into ${microTokens.length} micro-tokens of ${perAmount} sats each`);
-    return microTokens;
-}
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}

package/dist/customer.d.ts

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

package/dist/customer.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone P2P Customer — connects to a provider, streams results with CLINK debit payments.
- *
- * Usage:
- *   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)) {
-    if (!arg.startsWith('--'))
-        continue;
-    const eq = arg.indexOf('=');
-    if (eq === -1)
-        continue;
-    const key = arg.slice(0, eq);
-    const val = arg.slice(eq + 1);
-    switch (key) {
-        case '--kind':
-            process.env.DVM_KIND = val;
-            break;
-        case '--budget':
-            process.env.BUDGET_SATS = val;
-            break;
-        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 --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, 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',
-    })) {
-        process.stdout.write(chunk);
-        output += chunk;
-    }
-    console.log(`\n[customer] Done (${output.length} chars)`);
-}
-main().catch(err => { console.error('[customer] Fatal:', err.message || err); process.exit(1); });

package/dist/p2p-provider.d.ts

@@ -1,62 +0,0 @@
-/**
- * Shared P2P provider protocol — reusable building blocks for provider-side
- * streaming with credit-based flow control and CLINK debit payments.
- *
- * Provider actively pulls payments from customer's wallet via CLINK ndebit,
- * generating invoices from their own Lightning Address via LNURL-pay.
- *
- * Consumers: agent.ts, provider.ts
- */
-import { SwarmNode } from './swarm.js';
-/** Per-connection job state for P2P streaming */
-export interface P2PJobState {
-    socket: any;
-    credit: number;
-    ndebit: string;
-    totalEarned: number;
-    stopped: boolean;
-}
-/** Options for {@link streamToCustomer} */
-export interface StreamOptions {
-    node: SwarmNode;
-    job: P2PJobState;
-    jobId: string;
-    source: AsyncIterable<string>;
-    satsPerChunk: number;
-    chunksPerPayment: number;
-    lightningAddress: string;
-    label: string;
-}
-/**
- * Provider pulls a payment cycle from the customer's wallet via CLINK debit.
- *
- * Generates an invoice from the provider's Lightning Address, then sends a
- * debit request to the customer's wallet service via Nostr relay.
- *
- * Returns true if payment succeeded and credit was added.
- */
-export declare function collectP2PPayment(opts: {
-    job: P2PJobState;
-    node: SwarmNode;
-    jobId: string;
-    satsPerChunk: number;
-    chunksPerPayment: number;
-    lightningAddress: string;
-    label: string;
-}): Promise<boolean>;
-/**
- * Handle an incoming `stop` message: mark the job as stopped.
- */
-export declare function handleStop(job: P2PJobState, jobId: string, label: string): void;
-/**
- * Stream chunks from an async source to the customer with credit-based
- * flow control. When credit runs out, the provider debits the customer's
- * wallet via CLINK before continuing.
- *
- * Returns the concatenated full output string.
- *
- * **Cleanup note**: this function does NOT delete the job from any map or
- * release any capacity slot — callers are responsible for post-stream
- * cleanup.
- */
-export declare function streamToCustomer(opts: StreamOptions): Promise<string>;

package/dist/p2p-provider.js

@@ -1,105 +0,0 @@
-/**
- * Shared P2P provider protocol — reusable building blocks for provider-side
- * streaming with credit-based flow control and CLINK debit payments.
- *
- * Provider actively pulls payments from customer's wallet via CLINK ndebit,
- * generating invoices from their own Lightning Address via LNURL-pay.
- *
- * Consumers: agent.ts, provider.ts
- */
-import { collectPayment } from './clink.js';
-// ---------------------------------------------------------------------------
-// Payment helpers
-// ---------------------------------------------------------------------------
-/**
- * Provider pulls a payment cycle from the customer's wallet via CLINK debit.
- *
- * Generates an invoice from the provider's Lightning Address, then sends a
- * debit request to the customer's wallet service via Nostr relay.
- *
- * Returns true if payment succeeded and credit was added.
- */
-export async function collectP2PPayment(opts) {
-    const { job, node, jobId, satsPerChunk, chunksPerPayment, lightningAddress, label } = opts;
-    const amount = satsPerChunk * chunksPerPayment;
-    try {
-        const result = await collectPayment({
-            ndebit: job.ndebit,
-            lightningAddress,
-            amountSats: amount,
-        });
-        if (!result.ok) {
-            console.log(`[${label}] P2P job ${jobId}: debit failed: ${result.error}`);
-            return false;
-        }
-        job.credit += chunksPerPayment;
-        job.totalEarned += amount;
-        console.log(`[${label}] P2P job ${jobId}: debit OK +${amount} sats → +${chunksPerPayment} chunks (credit: ${job.credit}, total: ${job.totalEarned} sats)`);
-        node.send(job.socket, { type: 'payment_ack', id: jobId, amount });
-        return true;
-    }
-    catch (e) {
-        console.log(`[${label}] P2P job ${jobId}: debit error: ${e.message}`);
-        return false;
-    }
-}
-/**
- * Handle an incoming `stop` message: mark the job as stopped.
- */
-export function handleStop(job, jobId, label) {
-    console.log(`[${label}] P2P job ${jobId}: customer requested stop`);
-    job.stopped = true;
-}
-// ---------------------------------------------------------------------------
-// Streaming
-// ---------------------------------------------------------------------------
-/**
- * Stream chunks from an async source to the customer with credit-based
- * flow control. When credit runs out, the provider debits the customer's
- * wallet via CLINK before continuing.
- *
- * Returns the concatenated full output string.
- *
- * **Cleanup note**: this function does NOT delete the job from any map or
- * release any capacity slot — callers are responsible for post-stream
- * cleanup.
- */
-export async function streamToCustomer(opts) {
-    const { node, job, jobId, source, satsPerChunk, chunksPerPayment, lightningAddress, label } = opts;
-    let fullOutput = '';
-    try {
-        for await (const chunk of source) {
-            if (job.stopped) {
-                console.log(`[${label}] P2P job ${jobId}: stopped by customer`);
-                break;
-            }
-            if (job.credit <= 0) {
-                // Pull next payment from customer's wallet
-                console.log(`[${label}] P2P job ${jobId}: credit exhausted, debiting customer...`);
-                const paid = await collectP2PPayment({
-                    job, node, jobId, satsPerChunk, chunksPerPayment, lightningAddress, label,
-                });
-                if (!paid || job.stopped) {
-                    console.log(`[${label}] P2P job ${jobId}: ending (paid=${paid}, stopped=${job.stopped})`);
-                    break;
-                }
-            }
-            fullOutput += chunk;
-            node.send(job.socket, { type: 'chunk', id: jobId, data: chunk });
-            job.credit--;
-        }
-    }
-    catch (e) {
-        console.error(`[${label}] P2P job ${jobId} generation error: ${e.message}`);
-        node.send(job.socket, { type: 'error', id: jobId, message: e.message });
-    }
-    // Send final result
-    node.send(job.socket, {
-        type: 'result',
-        id: jobId,
-        output: fullOutput,
-        total_sats: job.totalEarned,
-    });
-    console.log(`[${label}] P2P job ${jobId} completed (${fullOutput.length} chars, ${job.totalEarned} sats earned)`);
-    return fullOutput;
-}

package/dist/pipeline.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * Pipeline — chain multiple P2P providers in sequence.
- *
- * Usage:
- *   BUDGET_SATS=100 CLINK_NDEBIT=ndebit1... TARGET_LANG=Chinese npm run pipeline "Write a short poem"
- */
-export {};

package/dist/pipeline.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-/**
- * Pipeline — chain multiple P2P providers in sequence.
- *
- * Usage:
- *   BUDGET_SATS=100 CLINK_NDEBIT=ndebit1... TARGET_LANG=Chinese npm run pipeline "Write a short poem"
- */
-// --- CLI args → env (before any imports) ---
-for (const arg of process.argv.slice(2)) {
-    if (!arg.startsWith('--'))
-        continue;
-    const eq = arg.indexOf('=');
-    if (eq === -1)
-        continue;
-    const key = arg.slice(0, eq);
-    const val = arg.slice(eq + 1);
-    switch (key) {
-        case '--ndebit':
-            process.env.CLINK_NDEBIT = val;
-            break;
-        case '--budget':
-            process.env.BUDGET_SATS = val;
-            break;
-    }
-}
-import { streamFromProvider } from './p2p-customer.js';
-import { getOnlineProviders } from './api.js';
-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 || '';
-const GEN_KIND = Number(process.env.GEN_KIND) || 5100;
-const TRANS_KIND = Number(process.env.TRANS_KIND) || 5302;
-const TARGET_LANG = process.env.TARGET_LANG || 'Chinese';
-async function showProviders(kind, label) {
-    try {
-        const agents = await getOnlineProviders(kind);
-        if (agents.length === 0) {
-            console.log(`[${label}] No providers online for kind ${kind}`);
-        }
-        else {
-            console.log(`[${label}] ${agents.length} provider(s) online for kind ${kind}:`);
-            for (const a of agents) {
-                const cap = a.capacity !== undefined ? `, capacity: ${a.capacity}` : '';
-                const price = a.pricing ? `, pricing: ${JSON.stringify(a.pricing)}` : '';
-                console.log(`[${label}]   - ${a.username || a.user_id} (${a.status}${cap}${price})`);
-            }
-        }
-    }
-    catch {
-        console.log(`[${label}] Could not query platform`);
-    }
-}
-async function collectStream(opts) {
-    let output = '';
-    for await (const chunk of streamFromProvider(opts)) {
-        process.stdout.write(chunk);
-        output += chunk;
-    }
-    return output;
-}
-async function main() {
-    const prompt = process.argv.slice(2).filter(a => !a.startsWith('--')).join(' ');
-    if (!prompt) {
-        console.error('Usage: 2020117-pipeline --ndebit=ndebit1... --budget=100 "your prompt"');
-        process.exit(1);
-    }
-    if (!NDEBIT) {
-        console.error('[pipeline] Error: --ndebit=ndebit1... required (CLINK debit authorization)');
-        process.exit(1);
-    }
-    console.log('='.repeat(60));
-    console.log(`Pipeline: generate (kind ${GEN_KIND}) → translate to ${TARGET_LANG} (kind ${TRANS_KIND})`);
-    console.log(`Total budget: ${BUDGET_SATS} sats`);
-    console.log('='.repeat(60));
-    const genBudget = Math.ceil(BUDGET_SATS * 0.6);
-    const transBudget = BUDGET_SATS - genBudget;
-    // Phase 1: Text Generation
-    console.log(`\n${'─'.repeat(60)}`);
-    console.log(`Phase 1: Text Generation (budget: ${genBudget} sats)`);
-    console.log('─'.repeat(60));
-    await showProviders(GEN_KIND, 'gen');
-    const generated = await collectStream({
-        kind: GEN_KIND, input: prompt, budgetSats: genBudget, ndebit: NDEBIT,
-        maxSatsPerChunk: MAX_SATS_PER_CHUNK, label: 'gen',
-    });
-    if (!generated.trim()) {
-        console.error('\n[pipeline] Phase 1 produced no output, aborting');
-        process.exit(1);
-    }
-    // Phase 2: Translation
-    console.log(`\n${'─'.repeat(60)}`);
-    console.log(`Phase 2: Translation to ${TARGET_LANG} (budget: ${transBudget} sats)`);
-    console.log('─'.repeat(60));
-    await showProviders(TRANS_KIND, 'trans');
-    const translated = await collectStream({
-        kind: TRANS_KIND, input: `Translate the following text to ${TARGET_LANG}:\n\n${generated}`,
-        budgetSats: transBudget, ndebit: NDEBIT, maxSatsPerChunk: MAX_SATS_PER_CHUNK, label: 'trans',
-    });
-    // Summary
-    console.log(`\n${'='.repeat(60)}`);
-    console.log('Pipeline complete!');
-    console.log('='.repeat(60));
-    console.log(`\nGenerated (${generated.length} chars):\n${generated}`);
-    console.log(`\nTranslated (${translated.length} chars):\n${translated}`);
-}
-main().catch(err => { console.error('[pipeline] Fatal:', err.message || err); process.exit(1); });

package/dist/provider.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone Provider daemon — thin wrapper around shared P2P provider protocol.
- * For most use cases, prefer `2020117-agent` which handles both API + P2P.
- */
-export {};

package/dist/provider.js

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone Provider daemon — thin wrapper around shared P2P provider protocol.
- * For most use cases, prefer `2020117-agent` which handles both API + P2P.
- */
-// --- CLI args → env (before any imports) ---
-for (const arg of process.argv.slice(2)) {
-    if (!arg.startsWith('--'))
-        continue;
-    const eq = arg.indexOf('=');
-    if (eq === -1)
-        continue;
-    const key = arg.slice(0, eq);
-    const val = arg.slice(eq + 1);
-    switch (key) {
-        case '--kind':
-            process.env.DVM_KIND = val;
-            break;
-        case '--lightning-address':
-            process.env.LIGHTNING_ADDRESS = val;
-            break;
-    }
-}
-import { SwarmNode, topicFromKind } from './swarm.js';
-import { createProcessor } from './processor.js';
-import { hasApiKey, registerService, startHeartbeatLoop } from './api.js';
-import { initClinkAgent } from './clink.js';
-import { collectP2PPayment, handleStop, streamToCustomer } from './p2p-provider.js';
-const KIND = Number(process.env.DVM_KIND) || 5100;
-const SATS_PER_CHUNK = Number(process.env.SATS_PER_CHUNK) || 1;
-const CHUNKS_PER_PAYMENT = Number(process.env.CHUNKS_PER_PAYMENT) || 10;
-const LIGHTNING_ADDRESS = process.env.LIGHTNING_ADDRESS || '';
-const jobs = new Map();
-async function main() {
-    if (!LIGHTNING_ADDRESS) {
-        console.error('[provider] Error: --lightning-address=you@wallet.com required');
-        process.exit(1);
-    }
-    const processor = await createProcessor();
-    await processor.verify();
-    console.log(`[provider] Processor "${processor.name}" verified`);
-    // Initialize CLINK agent identity
-    const { pubkey } = initClinkAgent();
-    console.log(`[provider] CLINK: ${LIGHTNING_ADDRESS} (agent pubkey: ${pubkey.slice(0, 16)}...)`);
-    // Platform registration
-    let stopHeartbeat = null;
-    if (hasApiKey()) {
-        console.log('[provider] Registering on platform...');
-        await registerService({ kind: KIND, satsPerChunk: SATS_PER_CHUNK, chunksPerPayment: CHUNKS_PER_PAYMENT, model: processor.name });
-        stopHeartbeat = startHeartbeatLoop();
-    }
-    else {
-        console.log('[provider] No API key — P2P-only mode');
-    }
-    const satsPerPayment = SATS_PER_CHUNK * CHUNKS_PER_PAYMENT;
-    const node = new SwarmNode();
-    const topic = topicFromKind(KIND);
-    console.log(`[provider] Streaming payment: ${SATS_PER_CHUNK} sat/chunk, ${CHUNKS_PER_PAYMENT} chunks/payment (${satsPerPayment} sats/cycle)`);
-    await node.listen(topic);
-    console.log(`[provider] Listening for customers...\n`);
-    node.on('message', async (msg, socket, peerId) => {
-        const tag = peerId.slice(0, 8);
-        if (msg.type === 'request') {
-            console.log(`[provider] Job ${msg.id} from ${tag}: "${(msg.input || '').slice(0, 60)}..."`);
-            if (!msg.ndebit) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'Request requires ndebit authorization' });
-                return;
-            }
-            if (msg.budget !== undefined) {
-                console.log(`[provider] Customer budget: ${msg.budget} sats`);
-            }
-            const job = {
-                socket, credit: 0, ndebit: msg.ndebit, totalEarned: 0, stopped: false,
-            };
-            jobs.set(msg.id, job);
-            node.send(socket, { type: 'offer', id: msg.id, sats_per_chunk: SATS_PER_CHUNK, chunks_per_payment: CHUNKS_PER_PAYMENT });
-            // 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: 'provider',
-            });
-            if (!paid) {
-                jobs.delete(msg.id);
-                return;
-            }
-            node.send(socket, { type: 'accepted', id: msg.id });
-            const source = processor.generateStream({ input: msg.input || '', params: msg.params });
-            await streamToCustomer({
-                node, job, jobId: msg.id, source,
-                satsPerChunk: SATS_PER_CHUNK, chunksPerPayment: CHUNKS_PER_PAYMENT,
-                lightningAddress: LIGHTNING_ADDRESS, label: 'provider',
-            });
-            jobs.delete(msg.id);
-        }
-        if (msg.type === 'stop') {
-            const job = jobs.get(msg.id);
-            if (job)
-                handleStop(job, msg.id, 'provider');
-        }
-    });
-    process.on('SIGINT', async () => {
-        console.log('\n[provider] Shutting down...');
-        if (stopHeartbeat)
-            stopHeartbeat();
-        await node.destroy();
-        process.exit(0);
-    });
-}
-main().catch(err => { console.error('[provider] Fatal:', err); process.exit(1); });