2020117-agent 0.6.3 → 0.6.5

package/dist/agent.js

@@ -80,9 +80,10 @@ 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 './clink.js';
+import { generateInvoice } from './lnurl.js';
 import { generateKeypair, loadSovereignKeys, saveSovereignKeys, loadAgentName, signEvent, signEventWithPow, nip44Encrypt, nip44Decrypt, pubkeyFromPrivkey, RelayPool, } from './nostr.js';
 import { parseNwcUri, nwcGetBalance, nwcPayLightningAddress } from './nwc.js';
 import { readFileSync } from 'fs';
@@ -742,6 +743,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 +875,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 +889,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 +903,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 +915,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 +945,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/dist/lnurl.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Lightning payment utilities — invoice generation via LNURL-pay
+ *
+ * Provider generates invoices from their own Lightning Address.
+ * Customer pays invoices via NWC wallet.
+ */
+/**
+ * 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>;

package/dist/lnurl.js

@@ -0,0 +1,41 @@
+/**
+ * Lightning payment utilities — invoice generation via LNURL-pay
+ *
+ * Provider generates invoices from their own Lightning Address.
+ * Customer pays invoices via NWC wallet.
+ */
+/**
+ * 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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "description": "2020117 agent runtime — Nostr-native relay subscription + Hyperswarm P2P + Lightning payments",
   "type": "module",
   "bin": {
@@ -18,7 +18,7 @@
   "exports": {
     "./processor": "./dist/processor.js",
     "./swarm": "./dist/swarm.js",
-    "./lightning": "./dist/clink.js",
+    "./lightning": "./dist/lnurl.js",
     "./nostr": "./dist/nostr.js",
     "./nwc": "./dist/nwc.js"
   },