2020117-agent 0.1.5 → 0.1.7

package/dist/agent.js

@@ -470,13 +470,34 @@ async function startSwarmListener(label) {
                 const resBody = await res.text();
                 const resHeaders = {};
                 res.headers.forEach((v, k) => { resHeaders[k] = v; });
-                node.send(socket, {
-                    type: 'http_response',
-                    id: msg.id,
-                    status: res.status,
-                    headers: resHeaders,
-                    body: resBody,
-                });
+                // Chunk large responses to avoid swarm transport truncation
+                const CHUNK_SIZE = 48_000; // ~48KB per chunk (safe margin under 64KB NOISE frame)
+                if (resBody.length > CHUNK_SIZE) {
+                    const chunks = [];
+                    for (let i = 0; i < resBody.length; i += CHUNK_SIZE) {
+                        chunks.push(resBody.slice(i, i + CHUNK_SIZE));
+                    }
+                    for (let i = 0; i < chunks.length; i++) {
+                        node.send(socket, {
+                            type: 'http_response',
+                            id: msg.id,
+                            status: i === 0 ? res.status : undefined,
+                            headers: i === 0 ? resHeaders : undefined,
+                            body: chunks[i],
+                            chunk_index: i,
+                            chunk_total: chunks.length,
+                        });
+                    }
+                }
+                else {
+                    node.send(socket, {
+                        type: 'http_response',
+                        id: msg.id,
+                        status: res.status,
+                        headers: resHeaders,
+                        body: resBody,
+                    });
+                }
             }
             catch (e) {
                 node.send(socket, {

package/dist/cashu.js

@@ -81,10 +81,27 @@ export async function splitTokens(tokenStr, perAmount) {
         const total = remaining.reduce((sum, p) => sum + p.amount, 0);
         if (total < perAmount)
             break;
-        const { send, keep } = await wallet.send(perAmount, remaining);
-        microTokens.push(getEncodedToken({ mint: mintUrl, proofs: send }));
-        remaining = keep;
-        if (keep.length === 0)
+        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`);

package/dist/session.js

@@ -59,6 +59,8 @@ const state = {
     sessionId: '',
     skill: null,
     satsPerMinute: 0,
+    satsPerToken: 1,
+    tickIntervalMs: 60_000,
     microTokens: [],
     tokenIndex: 0,
     totalSpent: 0,
@@ -67,6 +69,7 @@ const state = {
     httpServer: null,
     shuttingDown: false,
     pendingRequests: new Map(),
+    chunkBuffers: new Map(),
     outputCounter: 0,
 };
 // --- Helpers ---
@@ -109,6 +112,34 @@ function sendAndWait(msg, timeoutMs) {
 // --- 6. Message handler ---
 function setupMessageHandler() {
     state.node.on('message', (msg) => {
+        // Handle chunked HTTP responses — reassemble before resolving
+        if (msg.type === 'http_response' && msg.chunk_total && msg.chunk_total > 1) {
+            const id = msg.id;
+            let buf = state.chunkBuffers.get(id);
+            if (!buf) {
+                buf = { chunks: new Array(msg.chunk_total), total: msg.chunk_total, firstMsg: msg };
+                state.chunkBuffers.set(id, buf);
+            }
+            buf.chunks[msg.chunk_index ?? 0] = msg.body ?? '';
+            const received = buf.chunks.filter(c => c !== undefined).length;
+            if (received < buf.total)
+                return; // wait for more chunks
+            // All chunks received — reassemble and resolve
+            const assembled = {
+                ...buf.firstMsg,
+                body: buf.chunks.join(''),
+                chunk_index: undefined,
+                chunk_total: undefined,
+            };
+            state.chunkBuffers.delete(id);
+            const pending = state.pendingRequests.get(id);
+            if (pending) {
+                clearTimeout(pending.timer);
+                state.pendingRequests.delete(id);
+                pending.resolve(assembled);
+            }
+            return;
+        }
         // Check pending requests first — match by id
         const pending = state.pendingRequests.get(msg.id);
         if (pending) {
@@ -155,38 +186,42 @@ function setupMessageHandler() {
     });
 }
 // --- 3. Tick timer ---
-function startTickTimer() {
-    state.tickTimer = setInterval(async () => {
-        if (state.shuttingDown)
-            return;
-        if (remainingTokens() <= 0) {
-            log('Budget exhausted — ending session');
-            await endSession();
-            return;
-        }
-        // Low balance warning
-        if (remainingTokens() <= 2) {
-            warn(`Low balance! Only ${remainingTokens()} tick(s) remaining (${remainingSats()} sats)`);
-        }
-        const token = state.microTokens[state.tokenIndex++];
-        state.totalSpent += state.satsPerMinute;
-        const tickId = randomBytes(4).toString('hex');
-        try {
-            const resp = await sendAndWait({
-                type: 'session_tick',
-                id: tickId,
-                session_id: state.sessionId,
-                token,
-                budget: BUDGET,
-            }, 15_000);
-            if (resp.balance !== undefined) {
-                log(`Tick OK — balance: ${resp.balance} sats`);
-            }
-        }
-        catch (e) {
-            warn(`Tick failed: ${e.message}`);
+async function sendTick() {
+    if (state.shuttingDown)
+        return false;
+    if (remainingTokens() <= 0) {
+        log('Budget exhausted — ending session');
+        await endSession();
+        return false;
+    }
+    if (remainingTokens() <= 2) {
+        warn(`Low balance! Only ${remainingTokens()} tick(s) remaining (${remainingSats()} sats)`);
+    }
+    const token = state.microTokens[state.tokenIndex++];
+    state.totalSpent += state.satsPerToken;
+    const tickId = randomBytes(4).toString('hex');
+    try {
+        const resp = await sendAndWait({
+            type: 'session_tick',
+            id: tickId,
+            session_id: state.sessionId,
+            token,
+            budget: BUDGET,
+        }, 15_000);
+        if (resp.balance !== undefined) {
+            log(`Tick OK — balance: ${resp.balance} sats`);
         }
-    }, TICK_INTERVAL_MS);
+        return true;
+    }
+    catch (e) {
+        warn(`Tick failed: ${e.message}`);
+        return false;
+    }
+}
+function startTickTimer() {
+    // Send first tick immediately (prepay) to prevent provider timeout
+    sendTick();
+    state.tickTimer = setInterval(() => sendTick(), state.tickIntervalMs);
 }
 // --- 4. HTTP proxy ---
 function startHttpProxy() {
@@ -251,6 +286,11 @@ function startHttpProxy() {
 }
 // --- 5. CLI REPL ---
 function startRepl() {
+    // Skip REPL when stdin is not a TTY (e.g. background process, piped input)
+    if (!process.stdin.isTTY) {
+        log('Non-interactive mode (no TTY) — session will run until budget exhausted or provider ends it');
+        return;
+    }
     const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
@@ -453,6 +493,7 @@ async function endSession() {
         pending.reject(new Error('Session ending'));
         state.pendingRequests.delete(id);
     }
+    state.chunkBuffers.clear();
     // Send session_end
     if (state.node && state.socket && state.sessionId) {
         const duration = elapsedSeconds();
@@ -519,10 +560,15 @@ async function main() {
     log(`Pricing: ${satsPerMinute} sats/min`);
     log(`Budget: ${BUDGET} sats (~${Math.floor(BUDGET / satsPerMinute)} min)`);
     // 4. Mint and split tokens
+    // Cashu tokens must be whole sats. If rate < 1, use 1 sat tokens with longer tick intervals.
+    const satsPerToken = Math.max(1, Math.ceil(satsPerMinute));
+    const tickMinutes = satsPerToken / satsPerMinute; // e.g. 0.1 sats/min → 1 sat every 10 min
+    state.tickIntervalMs = Math.round(tickMinutes * 60_000);
+    state.satsPerToken = satsPerToken;
     log(`Minting ${BUDGET} sats...`);
     const { token: bigToken } = await mintTokens(BUDGET);
-    log(`Splitting into ${satsPerMinute}-sat micro-tokens...`);
-    state.microTokens = await splitTokens(bigToken, satsPerMinute);
+    log(`Splitting into ${satsPerToken}-sat micro-tokens (tick every ${tickMinutes} min)...`);
+    state.microTokens = await splitTokens(bigToken, satsPerToken);
     log(`Ready: ${state.microTokens.length} micro-tokens`);
     if (state.microTokens.length === 0) {
         warn('Budget too small for even one tick payment');

package/dist/swarm.d.ts

@@ -50,6 +50,8 @@ export interface SwarmMessage {
     headers?: Record<string, string>;
     body?: string;
     status?: number;
+    chunk_index?: number;
+    chunk_total?: number;
 }
 /**
  * Create a deterministic topic hash from a service kind number.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "2020117 agent runtime — API polling + Hyperswarm P2P + Cashu streaming payments",
   "type": "module",
   "bin": {