2020117-agent 0.2.5 → 0.3.0

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,8 +67,6 @@ 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 { initClinkAgent, collectPayment } from './clink.js';
@@ -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()) {

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "2020117-agent",
-  "version": "0.2.5",
+  "version": "0.3.0",
   "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": {