2020117-agent 0.1.0

package/dist/pipeline.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Pipeline — chain multiple DVM providers in sequence
+ *
+ * Usage:
+ *   BUDGET_SATS=100 TARGET_LANG=Chinese npm run pipeline "Write a short poem about the moon"
+ *
+ * Flow:
+ *   Phase 1: Connect to Provider A (text generation, kind 5100)
+ *            → stream output with micro-payments → collect full text
+ *   Phase 2: Connect to Provider B (translation, kind 5302)
+ *            → feed Phase 1 output as input → stream translated output
+ *
+ * Each phase independently mints tokens, negotiates price, and pays per chunk.
+ */
+export {};

package/dist/pipeline.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+/**
+ * Pipeline — chain multiple DVM providers in sequence
+ *
+ * Usage:
+ *   BUDGET_SATS=100 TARGET_LANG=Chinese npm run pipeline "Write a short poem about the moon"
+ *
+ * Flow:
+ *   Phase 1: Connect to Provider A (text generation, kind 5100)
+ *            → stream output with micro-payments → collect full text
+ *   Phase 2: Connect to Provider B (translation, kind 5302)
+ *            → feed Phase 1 output as input → stream translated output
+ *
+ * Each phase independently mints tokens, negotiates price, and pays per chunk.
+ */
+import { SwarmNode, topicFromKind } from './swarm.js';
+import { mintTokens, splitTokens } from './cashu.js';
+import { randomBytes } from 'crypto';
+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 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 showAvailableProviders(kind, label) {
+    try {
+        const agents = await getOnlineProviders(kind);
+        if (agents.length === 0) {
+            console.log(`[${label}] No providers online on platform for kind ${kind}`);
+        }
+        else {
+            console.log(`[${label}] ${agents.length} provider(s) online on platform 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`);
+    }
+}
+/**
+ * Run a single pipeline step: mint → connect → offer → split → pay → collect output → destroy
+ */
+async function runStep(opts) {
+    const { kind, prompt, budgetSats, label, maxSatsPerChunk } = opts;
+    const jobId = randomBytes(8).toString('hex');
+    console.log(`[${label}] Job ${jobId}: "${prompt.slice(0, 60)}..."`);
+    console.log(`[${label}] Budget: ${budgetSats} sats, max price: ${maxSatsPerChunk} sat/chunk`);
+    // --- Mint tokens ---
+    console.log(`[${label}] Minting ${budgetSats} sats...`);
+    let bigToken;
+    try {
+        const minted = await mintTokens(budgetSats);
+        bigToken = minted.token;
+        console.log(`[${label}] Token ready: ${bigToken.slice(0, 40)}...`);
+    }
+    catch (e) {
+        throw new Error(`[${label}] Mint failed: ${e.message}`);
+    }
+    // --- Connect to provider ---
+    const node = new SwarmNode();
+    const topic = topicFromKind(kind);
+    console.log(`[${label}] Looking for providers (kind ${kind})...`);
+    await node.connect(topic);
+    let peer;
+    try {
+        peer = await node.waitForPeer(30000);
+    }
+    catch {
+        await node.destroy();
+        throw new Error(`[${label}] No provider found within 30s`);
+    }
+    console.log(`[${label}] Connected to provider: ${peer.peerId.slice(0, 12)}...`);
+    // --- Streaming payment loop ---
+    return new Promise((resolve, reject) => {
+        let microTokens = [];
+        let tokenIndex = 0;
+        let output = '';
+        const cleanup = async () => {
+            clearTimeout(timer);
+            await node.destroy();
+        };
+        node.on('message', async (msg) => {
+            switch (msg.type) {
+                case 'offer': {
+                    const spc = msg.sats_per_chunk ?? 0;
+                    const cpp = msg.chunks_per_payment ?? 0;
+                    const satsPerPayment = spc * cpp;
+                    console.log(`[${label}] Offer: ${spc} sat/chunk, ${cpp} chunks/payment (${satsPerPayment} sats/cycle)`);
+                    if (spc > maxSatsPerChunk) {
+                        node.send(peer.socket, { type: 'stop', id: jobId });
+                        await cleanup();
+                        reject(new Error(`[${label}] Price too high: ${spc} sat/chunk > max ${maxSatsPerChunk}`));
+                        return;
+                    }
+                    if (satsPerPayment <= 0) {
+                        await cleanup();
+                        reject(new Error(`[${label}] Invalid offer: sats_per_payment = 0`));
+                        return;
+                    }
+                    console.log(`[${label}] Splitting ${budgetSats} sats into ${satsPerPayment}-sat micro-tokens...`);
+                    try {
+                        microTokens = await splitTokens(bigToken, satsPerPayment);
+                        console.log(`[${label}] Ready: ${microTokens.length} micro-tokens`);
+                    }
+                    catch (e) {
+                        await cleanup();
+                        reject(new Error(`[${label}] Split failed: ${e.message}`));
+                        return;
+                    }
+                    if (microTokens.length === 0) {
+                        await cleanup();
+                        reject(new Error(`[${label}] Budget too small for payment cycle`));
+                        return;
+                    }
+                    sendNextPayment();
+                    break;
+                }
+                case 'payment_ack':
+                    console.log(`[${label}] Payment confirmed: ${msg.amount} sats`);
+                    break;
+                case 'accepted':
+                    console.log(`[${label}] Job accepted, streaming...\n`);
+                    break;
+                case 'chunk':
+                    if (msg.data) {
+                        process.stdout.write(msg.data);
+                        output += msg.data;
+                    }
+                    break;
+                case 'pay_required':
+                    console.log(`\n[${label}] Payment required (earned: ${msg.earned} sats, next: ${msg.next} sats)`);
+                    if (tokenIndex < microTokens.length) {
+                        sendNextPayment();
+                    }
+                    else {
+                        console.log(`[${label}] Budget exhausted, sending stop`);
+                        node.send(peer.socket, { type: 'stop', id: jobId });
+                    }
+                    break;
+                case 'result':
+                    console.log(`\n[${label}] Done (${(msg.output || '').length} chars, ${msg.total_sats ?? '?'} sats)`);
+                    await cleanup();
+                    resolve(output || msg.output || '');
+                    break;
+                case 'error':
+                    await cleanup();
+                    reject(new Error(`[${label}] Provider error: ${msg.message}`));
+                    break;
+            }
+        });
+        function sendNextPayment() {
+            if (tokenIndex >= microTokens.length)
+                return;
+            const token = microTokens[tokenIndex++];
+            console.log(`[${label}] Sending payment ${tokenIndex}/${microTokens.length}`);
+            node.send(peer.socket, { type: 'payment', id: jobId, token });
+        }
+        // Send request
+        node.send(peer.socket, {
+            type: 'request',
+            id: jobId,
+            kind,
+            input: prompt,
+            budget: budgetSats,
+        });
+        // Timeout safety
+        const timer = setTimeout(async () => {
+            await cleanup();
+            reject(new Error(`[${label}] Timeout after 120s`));
+        }, 120000);
+    });
+}
+async function main() {
+    const prompt = process.argv.slice(2).join(' ');
+    if (!prompt) {
+        console.error('Usage: BUDGET_SATS=100 TARGET_LANG=Chinese npm run pipeline "your prompt here"');
+        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 showAvailableProviders(GEN_KIND, 'gen');
+    const generated = await runStep({
+        kind: GEN_KIND,
+        prompt,
+        budgetSats: genBudget,
+        label: 'gen',
+        maxSatsPerChunk: MAX_SATS_PER_CHUNK,
+    });
+    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 showAvailableProviders(TRANS_KIND, 'trans');
+    const translated = await runStep({
+        kind: TRANS_KIND,
+        prompt: `Translate the following text to ${TARGET_LANG}:\n\n${generated}`,
+        budgetSats: transBudget,
+        label: 'trans',
+        maxSatsPerChunk: MAX_SATS_PER_CHUNK,
+    });
+    // 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/processor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Processor interface — abstraction over the compute backend.
+ *
+ * agent.ts talks only to Processor; the actual backend is selected at
+ * startup via the PROCESSOR env var:
+ *
+ *   PROCESSOR=ollama        (default) — local Ollama
+ *   PROCESSOR=none          — pass-through, no model needed
+ *   PROCESSOR=exec:./cmd    — stdin/stdout child process
+ *   PROCESSOR=http://url    — remote HTTP endpoint
+ */
+export interface Processor {
+    /** Human-readable name for logs (e.g. "ollama:llama3.2", "none") */
+    readonly name: string;
+    /** Startup check — may throw to abort launch */
+    verify(): Promise<void>;
+    /** Non-streaming generation */
+    generate(prompt: string): Promise<string>;
+    /** Streaming generation — yields chunks as they arrive */
+    generateStream(prompt: string): AsyncGenerator<string>;
+}
+/**
+ * Factory — reads PROCESSOR env var and returns the appropriate backend.
+ */
+export declare function createProcessor(): Promise<Processor>;

package/dist/processor.js

@@ -0,0 +1,35 @@
+/**
+ * Processor interface — abstraction over the compute backend.
+ *
+ * agent.ts talks only to Processor; the actual backend is selected at
+ * startup via the PROCESSOR env var:
+ *
+ *   PROCESSOR=ollama        (default) — local Ollama
+ *   PROCESSOR=none          — pass-through, no model needed
+ *   PROCESSOR=exec:./cmd    — stdin/stdout child process
+ *   PROCESSOR=http://url    — remote HTTP endpoint
+ */
+/**
+ * Factory — reads PROCESSOR env var and returns the appropriate backend.
+ */
+export async function createProcessor() {
+    const spec = process.env.PROCESSOR || 'ollama';
+    if (spec === 'none') {
+        const { NoneProcessor } = await import('./adapters/none-processor.js');
+        return new NoneProcessor();
+    }
+    if (spec === 'ollama') {
+        const { OllamaProcessor } = await import('./adapters/ollama-processor.js');
+        return new OllamaProcessor();
+    }
+    if (spec.startsWith('exec:')) {
+        const cmd = spec.slice('exec:'.length);
+        const { ExecProcessor } = await import('./adapters/exec-processor.js');
+        return new ExecProcessor(cmd);
+    }
+    if (spec.startsWith('http://') || spec.startsWith('https://')) {
+        const { HttpProcessor } = await import('./adapters/http-processor.js');
+        return new HttpProcessor(spec);
+    }
+    throw new Error(`Unknown PROCESSOR value: "${spec}". Use: none | ollama | exec:<cmd> | http(s)://<url>`);
+}

package/dist/provider.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Provider daemon — streaming payment mode
+ *
+ * Usage:
+ *   SATS_PER_CHUNK=1 CHUNKS_PER_PAYMENT=10 npx tsx src/provider.ts
+ *
+ * Flow:
+ *   1. Join Hyperswarm topic for kind 5100 (text generation)
+ *   2. Wait for customer connections
+ *   3. Receive request → send offer (price quote)
+ *   4. Receive first payment → peek to verify, start generating
+ *   5. Stream N chunks per payment cycle
+ *   6. Pause and send pay_required → wait for next payment
+ *   7. On completion or stop → send result, batch claim all tokens
+ */
+export {};

package/dist/provider.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * Provider daemon — streaming payment mode
+ *
+ * Usage:
+ *   SATS_PER_CHUNK=1 CHUNKS_PER_PAYMENT=10 npx tsx src/provider.ts
+ *
+ * Flow:
+ *   1. Join Hyperswarm topic for kind 5100 (text generation)
+ *   2. Wait for customer connections
+ *   3. Receive request → send offer (price quote)
+ *   4. Receive first payment → peek to verify, start generating
+ *   5. Stream N chunks per payment cycle
+ *   6. Pause and send pay_required → wait for next payment
+ *   7. On completion or stop → send result, batch claim all tokens
+ */
+import { SwarmNode, topicFromKind } from './swarm.js';
+import { receiveToken, peekToken } from './cashu.js';
+import { generateStream, listModels } from './adapters/ollama.js';
+import { hasApiKey, registerService, startHeartbeatLoop } from './api.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 PAYMENT_TIMEOUT = Number(process.env.PAYMENT_TIMEOUT) || 30000;
+const MODEL = process.env.OLLAMA_MODEL || 'llama3.2';
+const jobs = new Map();
+async function main() {
+    // Verify Ollama is running
+    console.log(`[provider] Checking Ollama (model: ${MODEL})...`);
+    try {
+        const models = await listModels();
+        if (!models.some(m => m.startsWith(MODEL))) {
+            console.warn(`[provider] Model "${MODEL}" not found. Available: ${models.join(', ')}`);
+            console.warn(`[provider] Run: ollama pull ${MODEL}`);
+            process.exit(1);
+        }
+        console.log(`[provider] Ollama OK — model "${MODEL}" available`);
+    }
+    catch (e) {
+        console.error(`[provider] Ollama not reachable: ${e.message}`);
+        console.error(`[provider] Make sure Ollama is running: ollama serve`);
+        process.exit(1);
+    }
+    // --- 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: MODEL });
+        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)`);
+    console.log(`[provider] Joining topic for kind ${KIND}`);
+    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.budget !== undefined) {
+                console.log(`[provider] Customer budget: ${msg.budget} sats`);
+            }
+            // Initialize job state
+            const job = {
+                socket,
+                credit: 0,
+                tokens: [],
+                totalEarned: 0,
+                stopped: false,
+                paymentResolve: null,
+            };
+            jobs.set(msg.id, job);
+            // Send offer
+            node.send(socket, {
+                type: 'offer',
+                id: msg.id,
+                sats_per_chunk: SATS_PER_CHUNK,
+                chunks_per_payment: CHUNKS_PER_PAYMENT,
+            });
+            console.log(`[provider] Sent offer: ${SATS_PER_CHUNK} sat/chunk, ${CHUNKS_PER_PAYMENT} chunks/payment`);
+            // Wait for first payment before starting
+            const paid = await waitForPayment(job, msg.id, node);
+            if (!paid) {
+                console.log(`[provider] Job ${msg.id}: no initial payment, aborting`);
+                jobs.delete(msg.id);
+                return;
+            }
+            // Start generating
+            node.send(socket, { type: 'accepted', id: msg.id });
+            await runGeneration(node, job, msg);
+        }
+        if (msg.type === 'payment') {
+            const job = jobs.get(msg.id);
+            if (!job)
+                return;
+            if (!msg.token) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'Payment missing token' });
+                return;
+            }
+            try {
+                const peek = peekToken(msg.token);
+                const chunksUnlocked = Math.floor(peek.amount / SATS_PER_CHUNK);
+                job.credit += chunksUnlocked;
+                job.totalEarned += peek.amount;
+                job.tokens.push(msg.token);
+                console.log(`[provider] Payment for ${msg.id}: ${peek.amount} sats → +${chunksUnlocked} chunks (credit: ${job.credit}, total: ${job.totalEarned} sats)`);
+                node.send(socket, { type: 'payment_ack', id: msg.id, amount: peek.amount });
+                // Wake up generation loop if it's waiting
+                if (job.paymentResolve) {
+                    job.paymentResolve();
+                    job.paymentResolve = null;
+                }
+            }
+            catch (e) {
+                node.send(socket, { type: 'error', id: msg.id, message: `Payment failed: ${e.message}` });
+            }
+        }
+        if (msg.type === 'stop') {
+            const job = jobs.get(msg.id);
+            if (!job)
+                return;
+            console.log(`[provider] Job ${msg.id}: customer requested stop`);
+            job.stopped = true;
+            // Wake up generation loop if waiting for payment
+            if (job.paymentResolve) {
+                job.paymentResolve();
+                job.paymentResolve = null;
+            }
+        }
+    });
+    // Graceful shutdown
+    process.on('SIGINT', async () => {
+        console.log('\n[provider] Shutting down...');
+        if (stopHeartbeat)
+            stopHeartbeat();
+        await node.destroy();
+        process.exit(0);
+    });
+}
+function waitForPayment(job, jobId, node) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            job.paymentResolve = null;
+            console.log(`[provider] Job ${jobId}: payment timeout (${PAYMENT_TIMEOUT}ms)`);
+            node.send(job.socket, {
+                type: 'error',
+                id: jobId,
+                message: `Payment timeout after ${PAYMENT_TIMEOUT}ms`,
+            });
+            resolve(false);
+        }, PAYMENT_TIMEOUT);
+        job.paymentResolve = () => {
+            clearTimeout(timer);
+            resolve(true);
+        };
+        // If already has credit (shouldn't happen for initial, but just in case)
+        if (job.credit > 0) {
+            clearTimeout(timer);
+            job.paymentResolve = null;
+            resolve(true);
+        }
+    });
+}
+async function runGeneration(node, job, msg) {
+    const jobId = msg.id;
+    let fullOutput = '';
+    try {
+        for await (const chunk of generateStream({ model: MODEL, prompt: msg.input || '' })) {
+            // Check for stop
+            if (job.stopped) {
+                console.log(`[provider] Job ${jobId}: stopped by customer`);
+                break;
+            }
+            // Check credit
+            if (job.credit <= 0) {
+                // Ask for more payment
+                const nextAmount = SATS_PER_CHUNK * CHUNKS_PER_PAYMENT;
+                node.send(job.socket, {
+                    type: 'pay_required',
+                    id: jobId,
+                    earned: job.totalEarned,
+                    next: nextAmount,
+                });
+                console.log(`[provider] Job ${jobId}: pay_required (earned: ${job.totalEarned}, next: ${nextAmount})`);
+                // Wait for payment or timeout
+                const paid = await waitForPayment(job, jobId, node);
+                if (!paid || job.stopped) {
+                    console.log(`[provider] Job ${jobId}: ending (paid=${paid}, stopped=${job.stopped})`);
+                    break;
+                }
+            }
+            // Send chunk
+            fullOutput += chunk;
+            node.send(job.socket, { type: 'chunk', id: jobId, data: chunk });
+            job.credit--;
+        }
+    }
+    catch (e) {
+        console.error(`[provider] Job ${jobId} generation error: ${e.message}`);
+        node.send(job.socket, { type: 'error', id: jobId, message: e.message });
+    }
+    // Send result
+    node.send(job.socket, {
+        type: 'result',
+        id: jobId,
+        output: fullOutput,
+        total_sats: job.totalEarned,
+    });
+    console.log(`[provider] Job ${jobId} completed (${fullOutput.length} chars, ${job.totalEarned} sats earned)`);
+    // Batch claim all accumulated tokens
+    await batchClaim(job.tokens, jobId);
+    jobs.delete(jobId);
+}
+async function batchClaim(tokens, jobId) {
+    if (tokens.length === 0)
+        return;
+    console.log(`[provider] Job ${jobId}: claiming ${tokens.length} tokens...`);
+    let totalClaimed = 0;
+    for (let i = 0; i < tokens.length; i++) {
+        try {
+            const received = await receiveToken(tokens[i]);
+            totalClaimed += received.amount;
+        }
+        catch (e) {
+            console.warn(`[provider] Job ${jobId}: claim ${i + 1}/${tokens.length} failed: ${e.message}`);
+        }
+    }
+    console.log(`[provider] Job ${jobId}: claimed ${totalClaimed} sats total`);
+}
+main().catch(err => {
+    console.error('[provider] Fatal:', err);
+    process.exit(1);
+});

package/dist/swarm.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Hyperswarm P2P helper — discover peers and establish encrypted connections
+ *
+ * Provider: joins a topic (hash of service kind) and listens for connections
+ * Customer: joins the same topic to find the provider
+ *
+ * Wire protocol (newline-delimited JSON) — streaming payment:
+ *   → { type: "request", id, kind, input, budget }         customer sends job with budget
+ *   ← { type: "offer", id, sats_per_chunk, chunks_per_payment }  provider quotes price
+ *   → { type: "payment", id, token }                       customer sends micro-token
+ *   ← { type: "payment_ack", id, amount }                  provider confirms + accepts
+ *   ← { type: "accepted", id }                             provider starts generating
+ *   ← { type: "chunk", id, data }                          streaming output (N chunks)
+ *   ← { type: "pay_required", id, earned, next }           provider pauses for payment
+ *   → { type: "payment", id, token }                       customer sends next micro-token
+ *   ← { type: "payment_ack", id, amount }                  provider confirms
+ *   ← { type: "chunk", id, data }                          more chunks...
+ *   ← { type: "result", id, output, total_sats }           final result
+ *   → { type: "stop", id }                                 customer stops early
+ *   ← { type: "error", id, message }                       error
+ */
+import Hyperswarm from 'hyperswarm';
+import { EventEmitter } from 'events';
+export interface SwarmMessage {
+    type: 'request' | 'accepted' | 'chunk' | 'result' | 'error' | 'payment' | 'payment_ack' | 'offer' | 'pay_required' | 'stop';
+    id: string;
+    kind?: number;
+    input?: string;
+    output?: string;
+    data?: string;
+    token?: string;
+    amount?: number;
+    message?: string;
+    sats_per_chunk?: number;
+    chunks_per_payment?: number;
+    budget?: number;
+    earned?: number;
+    next?: number;
+    total_sats?: number;
+}
+/**
+ * Create a deterministic topic hash from a service kind number.
+ * All providers of kind 5100 join the same topic so customers can find them.
+ */
+export declare function topicFromKind(kind: number): Buffer;
+/**
+ * Thin wrapper around Hyperswarm that handles JSON message framing
+ */
+export declare class SwarmNode extends EventEmitter {
+    swarm: Hyperswarm;
+    connections: Map<string, any>;
+    private buffers;
+    constructor();
+    /** Send a JSON message to a specific peer */
+    send(socket: any, msg: SwarmMessage): void;
+    /** Broadcast a JSON message to all connected peers */
+    broadcast(msg: SwarmMessage): void;
+    /** Join a topic as server (provider) */
+    listen(topic: Buffer): Promise<void>;
+    /** Join a topic as client (customer) */
+    connect(topic: Buffer): Promise<void>;
+    /** Wait for the first peer connection (with timeout) */
+    waitForPeer(timeoutMs?: number): Promise<{
+        socket: any;
+        peerId: string;
+    }>;
+    destroy(): Promise<void>;
+}