2020117-agent 0.6.4 → 0.6.6

package/dist/agent.js

@@ -80,6 +80,7 @@ for (const arg of process.argv.slice(2)) {
     }
 }
 import { randomBytes } from 'crypto';
+import { createConnection } from 'net';
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { createProcessor } from './processor.js';
 import { generateInvoice } from './lnurl.js';
@@ -257,10 +258,11 @@ async function setupNostr(label) {
     // 7. Subscribe to NIP-XX prompts (Kind 25802)
     subscribeNipXX(label);
     // 8. Subscribe to DVM requests (Kind 5xxx)
-    // P2P-only: still subscribes but handleDvmRequest will ignore broadcast jobs,
-    // only responding to direct requests (p tag = our pubkey)
-    subscribeDvmRequests(label);
-    subscribeDvmResults(label);
+    // P2P-only: skip relay subscription entirely — only serve P2P customers
+    if (!P2P_ONLY) {
+        subscribeDvmRequests(label);
+        subscribeDvmResults(label);
+    }
     // 9. Start heartbeat (Kind 30333 to relay)
     const pricing = {};
     const priceSats = SATS_PER_CHUNK * CHUNKS_PER_PAYMENT;
@@ -551,12 +553,6 @@ async function handleDvmRequest(label, event) {
     // Skip own events
     if (event.pubkey === state.sovereignKeys.pubkey)
         return;
-    // P2P-only mode: only handle direct requests (p tag pointing to us)
-    if (P2P_ONLY) {
-        const isDirected = event.tags.some(t => t[0] === 'p' && t[1] === state.sovereignKeys.pubkey);
-        if (!isDirected)
-            return;
-    }
     // Dedup: skip already-seen events
     if (!markSeen(event.id))
         return;
@@ -742,6 +738,80 @@ async function delegateNostr(label, kind, input, bidSats, provider) {
         });
     });
 }
+/**
+ * Inject think:false into Ollama chat/generate requests.
+ * Suppresses reasoning tokens on models like qwen3 that enable thinking by default.
+ */
+function injectThinkFalse(rawBytes) {
+    const raw = rawBytes.toString();
+    const sep = raw.indexOf('\r\n\r\n');
+    if (sep === -1)
+        return rawBytes;
+    const header = raw.slice(0, sep + 4);
+    const body = raw.slice(sep + 4);
+    if (!header.includes('POST') || (!header.includes('/api/generate') && !header.includes('/api/chat')))
+        return rawBytes;
+    try {
+        const json = JSON.parse(body);
+        if (json.think !== undefined)
+            return rawBytes;
+        json.think = false;
+        const newBody = JSON.stringify(json);
+        const newHeader = header.replace(/Content-Length:\s*\d+/i, `Content-Length: ${Buffer.byteLength(newBody)}`);
+        return Buffer.from(newHeader + newBody);
+    }
+    catch {
+        return rawBytes;
+    }
+}
+/**
+ * After session payment, switch this socket to a raw TCP pipe to the HTTP backend.
+ * The customer then has direct HTTP API access (Ollama, SD-WebUI, etc.) with true streaming.
+ * This removes SwarmNode's JSON framing from the socket and replaces it with a bidirectional pipe.
+ */
+function startTcpProxy(session, node, processorUrl, label) {
+    let addr;
+    try {
+        const u = new URL(processorUrl);
+        addr = { host: u.hostname, port: Number(u.port) || (u.protocol === 'https:' ? 443 : 80) };
+    }
+    catch {
+        console.error(`[${label}] Session ${session.sessionId}: invalid backend URL ${processorUrl}`);
+        endSession(node, session, label);
+        return;
+    }
+    session.proxyStarted = true;
+    const socket = session.socket;
+    const backend = createConnection(addr.port, addr.host);
+    backend.setKeepAlive(true);
+    // Remove SwarmNode's newline-delimited JSON listener so raw HTTP bytes flow through
+    socket.removeAllListeners('data');
+    socket.on('data', (chunk) => backend.write(injectThinkFalse(chunk)));
+    backend.pipe(socket);
+    let cleaned = false;
+    const cleanup = () => {
+        if (cleaned)
+            return;
+        cleaned = true;
+        try {
+            socket.destroy();
+        }
+        catch { }
+        try {
+            backend.destroy();
+        }
+        catch { }
+        endSession(node, session, label);
+    };
+    socket.on('close', cleanup);
+    socket.on('error', () => cleanup());
+    backend.on('close', cleanup);
+    backend.on('error', (e) => {
+        console.log(`[${label}] Session ${session.sessionId}: backend error: ${e.message}`);
+        cleanup();
+    });
+    console.log(`[${label}] Session ${session.sessionId}: TCP proxy → ${addr.host}:${addr.port}`);
+}
 const activeSessions = new Map();
 // Dedup: track recently seen DVM request event IDs (prevent double-processing from relay + inbox)
 const seenEventIds = new Set();
@@ -800,7 +870,9 @@ async function startSwarmListener(label) {
         }
         // --- Session protocol ---
         if (msg.type === 'session_start') {
-            if (!LIGHTNING_ADDRESS) {
+            const processorUrl = process.env.PROCESSOR || '';
+            const proxyMode = processorUrl.startsWith('http://') || processorUrl.startsWith('https://');
+            if (!proxyMode && !LIGHTNING_ADDRESS) {
                 node.send(socket, { type: 'error', id: msg.id, message: 'Provider Lightning Address not configured' });
                 return;
             }
@@ -812,7 +884,8 @@ async function startSwarmListener(label) {
             const BILLING_INTERVAL_MIN = 1;
             const billingAmount = satsPerMinute * BILLING_INTERVAL_MIN;
             const sessionId = randomBytes(8).toString('hex');
-            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min, payment=${paymentMethod}, billing every ${BILLING_INTERVAL_MIN}min (${billingAmount} sats)`);
+            const modeLabel = proxyMode ? `proxy→${processorUrl}` : `${satsPerMinute} sats/min`;
+            console.log(`[${label}] Session ${sessionId} from ${tag}: ${modeLabel}`);
             const session = {
                 socket,
                 peerId,
@@ -825,6 +898,8 @@ async function startSwarmListener(label) {
                 billingTimer: null,
                 timeoutTimer: null,
                 customerPubkey: msg.pubkey || undefined,
+                proxyMode,
+                proxyStarted: false,
             };
             activeSessions.set(sessionId, session);
             node.send(socket, {
@@ -835,12 +910,23 @@ async function startSwarmListener(label) {
                 payment_method: paymentMethod,
                 pubkey: state.sovereignKeys?.pubkey,
             });
-            // Send first billing tick
-            await sendBillingTick(node, session, billingAmount, label);
-            // Recurring billing every 10 minutes
-            session.billingTimer = setInterval(() => {
-                sendBillingTick(node, session, billingAmount, label);
-            }, BILLING_INTERVAL_MIN * 60_000);
+            if (proxyMode) {
+                if (billingAmount <= 0 || !LIGHTNING_ADDRESS) {
+                    // Free proxy — open TCP pipe immediately
+                    startTcpProxy(session, node, processorUrl, label);
+                }
+                else {
+                    // Paid proxy — one-time session fee, TCP pipe starts on payment (session_tick_ack)
+                    await sendBillingTick(node, session, billingAmount, label);
+                }
+            }
+            else {
+                // Per-minute billing for structured request/result sessions
+                await sendBillingTick(node, session, billingAmount, label);
+                session.billingTimer = setInterval(() => {
+                    sendBillingTick(node, session, billingAmount, label);
+                }, BILLING_INTERVAL_MIN * 60_000);
+            }
             return;
         }
         // Customer sent payment (Lightning preimage)
@@ -854,6 +940,10 @@ async function startSwarmListener(label) {
                 session.lastPaidAt = Date.now();
                 console.log(`[${label}] Session ${session.sessionId}: invoice payment received (+${amount}, total: ${session.totalEarned} sats)`);
             }
+            // Proxy mode: switch to raw TCP pipe after first payment confirmed
+            if (session.proxyMode && !session.proxyStarted) {
+                startTcpProxy(session, node, process.env.PROCESSOR || '', label);
+            }
             return;
         }
         if (msg.type === 'session_end') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "2020117 agent runtime — Nostr-native relay subscription + Hyperswarm P2P + Lightning payments",
   "type": "module",
   "bin": {