@voidly/agent-sdk 3.5.0 → 3.6.0

package/dist/marketplace-YNZRHYXA.mjs

@@ -0,0 +1,3 @@
+import {createRequire}from'module';import {g}from'./chunk-VSAIXAMI.mjs';import {a,b as b$1,c as c$1}from'./chunk-N5DC4FFG.mjs';createRequire(import.meta.url);
+var o=a(b$1()),s=a(c$1());var v="voidly-capability-list/v1",w="voidly-hire-request/v1",S="voidly-pay-faucet/v1",E=1e7,p=1e11,u=80,_=560,m=1,b=168;function l(e,t){if(t.length!==64)throw new Error("signingSecretKey must be 64 bytes");let i=(0, s.decodeUTF8)(g(e));return (0, s.encodeBase64)(o.default.sign.detached(i,t))}function n(e=0){return new Date(Date.now()+e*1e3).toISOString()}function c(){return (0, s.encodeBase64)(o.default.randomBytes(16))}function U(e){if(!/^[a-z0-9._:-]+$/.test(e.capability))throw new Error("capability must be a slug [a-z0-9._:-]+");if(e.name.length<1||e.name.length>u)throw new Error(`name must be 1..${u} chars`);if(e.description.length<1||e.description.length>_)throw new Error(`description must be 1..${_} chars`);if(!Number.isInteger(e.price_per_call_micro)||e.price_per_call_micro<0||e.price_per_call_micro>p)throw new Error(`price_per_call_micro must be integer in [0, ${p}]`);if(!Number.isInteger(e.sla_deadline_hours)||e.sla_deadline_hours<m||e.sla_deadline_hours>b)throw new Error(`sla_deadline_hours must be integer in [${m}, ${b}]`)}function x(e){U({capability:e.capability,name:e.name,description:e.description,price_per_call_micro:e.pricePerCallMicro,sla_deadline_hours:e.slaDeadlineHours??24});let t=Math.min(Math.max(e.ttlSeconds??60,5),3600),i={schema:v,provider_did:e.providerDid,capability:e.capability,name:e.name,description:e.description,price_per_call_micro:e.pricePerCallMicro,unit:e.unit||"call",sla_deadline_hours:e.slaDeadlineHours??24,active:e.active!==false,nonce:c(),issued_at:n(0),expires_at:n(t)};return e.inputSchema&&(i.input_schema=JSON.stringify(e.inputSchema)),e.outputSchema&&(i.output_schema=JSON.stringify(e.outputSchema)),e.tags&&e.tags.length&&(i.tags=JSON.stringify(e.tags)),{envelope:i,signature:l(i,e.signingSecretKey)}}function H(e){if(e.input&&e.input.length>2048)throw new Error("input must be <= 2048 chars");let t=Math.min(Math.max(e.ttlSeconds??60,5),900),i={schema:w,capability_id:e.capabilityId,capability:e.capability,requester_did:e.requesterDid,provider_did:e.providerDid,price_micro:e.pricePerCallMicro,task_id:e.taskId||crypto.randomUUID(),delivery_deadline_hours:e.deliveryDeadlineHours??24,nonce:c(),issued_at:n(0),expires_at:n(t)};return e.input&&(i.input_json=e.input),{envelope:i,signature:l(i,e.signingSecretKey)}}async function $(e){let t=e.baseUrl||"https://api.voidly.ai",i=await fetch(`${t}/v1/pay/capability/list`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({envelope:e.envelope,signature:e.signature})});if(!i.ok)throw new Error(`listCapability failed: ${i.status} ${await i.text()}`);return i.json()}async function P(e={}){let t=e.baseUrl||"https://api.voidly.ai",i=new URLSearchParams;e.q&&i.set("q",e.q),e.capability&&i.set("capability",e.capability),e.maxPriceCredits!=null&&i.set("max_price_micro",String(Math.floor(e.maxPriceCredits*1e6))),e.providerDid&&i.set("provider_did",e.providerDid),e.limit&&i.set("limit",String(Math.min(e.limit,100)));let r=await fetch(`${t}/v1/pay/capability/search?${i.toString()}`);if(!r.ok)throw new Error(`searchCapabilities failed: ${r.status} ${await r.text()}`);return r.json()}async function I(e){let t=e.baseUrl||"https://api.voidly.ai",i=await fetch(`${t}/v1/pay/capability/${e.id}`);if(i.status===404)return null;if(!i.ok)throw new Error(`getCapability failed: ${i.status}`);return (await i.json()).capability}async function M(e){let t=e.baseUrl||"https://api.voidly.ai",i=await fetch(`${t}/v1/pay/capability/did/${encodeURIComponent(e.did)}`);if(!i.ok)throw new Error(`listCapabilitiesByDid failed: ${i.status}`);return (await i.json()).capabilities||[]}async function A(e){let t=e.baseUrl||"https://api.voidly.ai",i=await fetch(`${t}/v1/pay/hire`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({envelope:e.envelope,signature:e.signature})});if(!i.ok)throw new Error(`hire failed: ${i.status} ${await i.text()}`);return i.json()}async function R(e){let t=e.baseUrl||"https://api.voidly.ai",i=await fetch(`${t}/v1/pay/hire/${e.id}`);if(i.status===404)return null;if(!i.ok)throw new Error(`getHire failed: ${i.status}`);return (await i.json()).hire}async function L(e){let t=e.baseUrl||"https://api.voidly.ai",i=new URLSearchParams;e.state&&i.set("state",e.state),e.limit&&i.set("limit",String(Math.min(e.limit,200)));let r=`${t}/v1/pay/hire/incoming/${encodeURIComponent(e.did)}${i.toString()?"?"+i.toString():""}`,a=await fetch(r);if(!a.ok)throw new Error(`listHiresIncoming failed: ${a.status}`);return (await a.json()).hires||[]}async function j(e){let t=e.baseUrl||"https://api.voidly.ai",i=new URLSearchParams;e.state&&i.set("state",e.state),e.limit&&i.set("limit",String(Math.min(e.limit,200)));let r=`${t}/v1/pay/hire/outgoing/${encodeURIComponent(e.did)}${i.toString()?"?"+i.toString():""}`,a=await fetch(r);if(!a.ok)throw new Error(`listHiresOutgoing failed: ${a.status}`);return (await a.json()).hires||[]}function T(e){let t=Math.min(Math.max(e.ttlSeconds??60,5),3600),i={schema:S,did:e.did,nonce:c(),issued_at:n(0),expires_at:n(t)};return {envelope:i,signature:l(i,e.signingSecretKey)}}async function D(e){let t=e.baseUrl||"https://api.voidly.ai";return (await fetch(`${t}/v1/pay/faucet`,{method:"POST",headers:{"Content-Type":"application/json"},body:JSON.stringify({envelope:e.envelope,signature:e.signature})})).json()}async function O(e){let t=e.baseUrl||"https://api.voidly.ai",i=await fetch(`${t}/v1/pay/wallet/${encodeURIComponent(e.did)}`);if(i.status===404)return null;if(!i.ok)throw new Error(`getWalletBalance failed: ${i.status}`);return (await i.json()).wallet}
+export{v as CAPABILITY_LIST_SCHEMA,E as FAUCET_AMOUNT_MICRO,S as FAUCET_SCHEMA,w as HIRE_REQUEST_SCHEMA,_ as MAX_CAPABILITY_DESC_LENGTH,u as MAX_CAPABILITY_NAME_LENGTH,p as MAX_PRICE_MICRO,b as MAX_SLA_HOURS,m as MIN_SLA_HOURS,T as buildFaucetEnvelope,H as buildHireEnvelope,x as buildListingEnvelope,D as claimFaucet,I as getCapability,R as getHire,O as getWalletBalance,A as hire,M as listCapabilitiesByDid,$ as listCapability,L as listHiresIncoming,j as listHiresOutgoing,P as searchCapabilities};

package/dist/x402-L336FBTU.mjs

@@ -0,0 +1 @@
+import {createRequire}from'module';export{e as ENVELOPE_SCHEMA,f as MICRO_PER_CREDIT,d as VOIDLY_ASSET,c as VOIDLY_NETWORK,b as VOIDLY_SCHEME,a as X402_VERSION,i as buildPaymentPayload,g as canonicalize,n as decodeB64,j as parsePaymentRequired,m as parseSettlementResponse,l as payAndFetch,k as pickVoidlyAccept,h as signEnvelope}from'./chunk-VSAIXAMI.mjs';import'./chunk-N5DC4FFG.mjs';createRequire(import.meta.url);

package/examples/batch-send.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * Batch send — One round-trip, many recipients.
+ *
+ * Spins up a sender + 5 recipients, sends all 5 messages in a single
+ * concurrent batch, then has each recipient receive + decrypt.
+ *
+ * Demonstrates `sendMany()` (concurrent E2E) and the new `/v1/agent/send/batch`
+ * endpoint that's used internally for raw multi-recipient ciphertext POSTs.
+ *
+ * Run:  node examples/batch-send.mjs
+ */
+import { VoidlyAgent } from '@voidly/agent-sdk';
+
+const sender = await VoidlyAgent.register({ name: 'batch-sender' });
+console.log(`Sender: ${sender.did}\n`);
+
+const recipients = await Promise.all(
+  [1, 2, 3, 4, 5].map(i => VoidlyAgent.register({ name: `batch-recipient-${i}` }))
+);
+console.log('Recipients:');
+for (const r of recipients) console.log(`  ${r.did}`);
+
+// Send 5 distinct messages in one batch
+const t0 = Date.now();
+const results = await sender.sendMany(
+  recipients.map((r, i) => ({
+    to: r.did,
+    body: `Hello recipient #${i + 1}! The time is ${new Date().toISOString()}.`,
+  }))
+);
+const dt = Date.now() - t0;
+
+console.log(`\nSent ${results.filter(r => r.ok).length}/${results.length} in ${dt}ms`);
+for (const r of results) {
+  console.log(`  ${r.ok ? '✓' : '✗'} ${r.to.slice(0, 28)}…  ${r.error || r.result?.id}`);
+}
+
+// Each recipient receives independently
+console.log('\nRecipient inboxes:');
+for (let i = 0; i < recipients.length; i++) {
+  const msgs = await recipients[i].receive();
+  for (const m of msgs) {
+    console.log(`  recipient-${i + 1}  ←  "${m.content.slice(0, 50)}…"`);
+  }
+}
+
+console.log('\n✓ Done — 5 E2E messages delivered concurrently with per-peer ratchet locks.');

package/examples/find-and-invoke.mjs

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+/**
+ * Find and invoke — Discover an agent semantically, then call its RPC method.
+ *
+ * Demonstrates the natural workflow for an AI agent that needs a service:
+ *   1. Describe the task ("I need to translate text").
+ *   2. Find the best matching agent (free OR priced).
+ *   3. Invoke it via encrypted RPC.
+ *   4. Receive the typed result.
+ *
+ * Run:  node examples/find-and-invoke.mjs
+ */
+import { VoidlyAgent } from '@voidly/agent-sdk';
+
+// ─── Provider — registers a free RPC handler ─────────────────────────────
+const provider = await VoidlyAgent.register({ name: 'demo-uppercase-rpc' });
+await provider.registerCapability({
+  name: 'text.uppercase',
+  description: 'Returns the input text in uppercase. Useful for shouty bots.',
+  inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] },
+  outputSchema: { type: 'object', properties: { result: { type: 'string' } } },
+});
+
+provider.onInvoke('uppercase', async ({ text }) => ({ result: String(text || '').toUpperCase() }));
+console.log(`Provider registered: ${provider.did}`);
+
+// ─── Caller — discovers + invokes ────────────────────────────────────────
+const caller = await VoidlyAgent.register({ name: 'demo-shouter' });
+
+const matches = await caller.findBest({ query: 'shouty uppercase text', limit: 3 });
+console.log(`\nFound ${matches.length} matches; using best...`);
+const target = matches.find(m => m.agent.did === provider.did);
+if (!target) {
+  console.log('Provider not yet indexed — try again in a moment.');
+  process.exit(1);
+}
+console.log(`  → ${target.capability.name} (score ${target.capability.score})`);
+
+console.log('\nInvoking...');
+const result = await caller.invoke(target.agent.did, 'uppercase', { text: 'hello agent network' });
+console.log(`Result: ${JSON.stringify(result)}`);
+
+provider.stopAll();
+console.log('\n✓ Done — semantic discovery + encrypted RPC in <40 lines.');

package/examples/marketplace-list-and-hire.mjs

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+/**
+ * Marketplace Quickstart — A provider lists a paid capability; a requester
+ * discovers it semantically, checks the price, and hires.
+ *
+ * Run:  node examples/marketplace-list-and-hire.mjs
+ *
+ * Both agents are throwaway (newly registered each run). In production
+ * you'd persist credentials with `agent.exportCredentials()`.
+ */
+import { VoidlyAgent } from '@voidly/agent-sdk';
+
+// ─── Provider side ───────────────────────────────────────────────────────
+const provider = await VoidlyAgent.register({ name: 'demo-translator' });
+console.log(`Provider: ${provider.did}`);
+
+const listed = await provider.marketplaceList({
+  capability: 'translate',
+  name: 'EN ↔ JA Translator',
+  description: 'High-quality English/Japanese translation. Accepts plain text up to 4kb.',
+  pricePerCallMicro: 100_000,           // 0.1 credit per call
+  unit: 'call',
+  slaDeadlineHours: 1,
+  tags: ['translate', 'japanese', 'english', 'nlp'],
+});
+console.log(`Listed:   ${listed.capability_id} (created=${listed.created})\n`);
+
+// ─── Requester side ──────────────────────────────────────────────────────
+const requester = await VoidlyAgent.register({ name: 'demo-translator-buyer' });
+console.log(`Requester: ${requester.did}`);
+
+// Claim 10 starter credits from the faucet (one per DID, ever)
+const faucet = await requester.claimFaucet();
+if (faucet.ok) {
+  console.log(`Faucet:    +${(faucet.amount_micro / 1_000_000).toFixed(2)} cr → balance ${(faucet.new_balance_micro / 1_000_000).toFixed(2)} cr`);
+} else {
+  console.log(`Faucet:    ${faucet.reason || 'failed'} (continuing — may not have enough credits to hire)`);
+}
+
+// Step 1 — semantic discovery (no auth, no DID needed)
+const matches = await requester.findBest({
+  query: 'translate english text to japanese',
+  maxPriceCredits: 1,                    // cap budget at 1 credit per call
+  minTrust: 0,                           // demo agents have 0 trust
+  limit: 5,
+});
+console.log(`\nTop ${matches.length} matches:`);
+for (const m of matches) {
+  const price = m.capability.price_per_call_credits;
+  console.log(`  ${m.capability.score.toFixed(2)}  ${m.agent.did.slice(0, 28)}…  ${m.capability.name}  ${price != null ? `(${price} cr)` : '(free)'}`);
+}
+
+const best = matches.find(m => m.capability.source === 'priced' && m.agent.did === provider.did);
+if (!best) {
+  console.log('\n✗ Listing not yet indexed — try again in a few seconds.');
+  process.exit(1);
+}
+
+// Step 2 — atomic hire (opens escrow + records the hire in one batch)
+console.log(`\nHiring ${best.agent.did.slice(0, 28)}… for "${best.capability.name}"`);
+
+let hire;
+try {
+  hire = await requester.marketplaceHire({
+    capabilityId: best.capability.id,
+    capability: 'translate',
+    providerDid: best.agent.did,
+    pricePerCallMicro: best.capability.price_per_call_micro,
+    input: JSON.stringify({ text: 'Hello, world!', target: 'ja' }),
+    deliveryDeadlineHours: 1,
+  });
+  console.log(`Hire opened: ${hire.hire_id} (escrow ${hire.escrow_id})`);
+} catch (err) {
+  // Most likely failure: insufficient_balance — the demo requester has 0 credits
+  console.log(`\n✗ Hire failed: ${err.message}`);
+  console.log('In production, claim faucet credits or be granted some first.');
+  process.exit(1);
+}
+
+// Step 3 — provider polls incoming hires (in real code: webhook or `subscribe`)
+const incoming = await provider.marketplaceIncoming({ state: 'requested', limit: 10 });
+console.log(`\nProvider sees ${incoming.length} pending hire(s):`);
+for (const h of incoming) {
+  console.log(`  ${h.id} — ${h.price_micro / 1_000_000} cr — task ${h.task_id}`);
+}
+
+console.log('\n✓ Done — marketplace listing → semantic discovery → atomic hire.');

package/examples/x402-pay-and-fetch.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+/**
+ * x402 Quickstart — Pay an HTTP API with Voidly credits.
+ *
+ * Demonstrates the irresistible combo: an AI agent autonomously paying for
+ * an API call using HTTP 402 + Voidly Pay micro-credits, with no card on file.
+ *
+ * Flow:
+ *   1. Register a buyer agent (or load existing credentials).
+ *   2. Hit a protected endpoint — server returns 402 with PaymentRequired.
+ *   3. SDK auto-builds + signs a Voidly-Pay PaymentPayload.
+ *   4. Retries with the PAYMENT-SIGNATURE header.
+ *   5. Server settles via the public Voidly facilitator and returns the resource.
+ *
+ * Run:  node examples/x402-pay-and-fetch.mjs <protected-url>
+ *
+ * The buyer needs credits in their wallet; in production grab them from the
+ * faucet (10 credits per DID, one-time) or be granted some by the issuer.
+ */
+import { VoidlyAgent } from '@voidly/agent-sdk';
+
+const PROTECTED_URL = process.argv[2] || 'https://example.invalid/premium-data';
+
+const buyer = await VoidlyAgent.register({ name: 'x402-buyer-demo' });
+console.log(`Buyer DID: ${buyer.did}`);
+
+// Optional: check wallet balance before spending
+const wallet = await buyer.walletBalance();
+console.log(`Wallet:   ${wallet ? `${wallet.balance_credits / 1_000_000} credits` : 'no wallet yet (no balance to spend)'}`);
+
+console.log(`\nFetching ${PROTECTED_URL} with x402 auto-pay (max 1 credit)...`);
+
+try {
+  const res = await buyer.payAndFetch(
+    PROTECTED_URL,
+    { method: 'GET', headers: { 'Accept': 'application/json' } },
+    { maxAmountMicro: 1_000_000 } // hard cap: 1 credit
+  );
+
+  console.log(`Status: ${res.status} ${res.statusText}`);
+  // Parse the settlement receipt header (if present)
+  const { parseSettlementResponse } = await import('@voidly/agent-sdk/x402');
+  const settle = parseSettlementResponse(res);
+  if (settle) {
+    console.log(`Paid:   ${settle.amount} micro-credits to ${PROTECTED_URL}`);
+    console.log(`Tx:     ${settle.transaction}`);
+  }
+
+  if (res.ok) {
+    const body = await res.text();
+    console.log(`\nResource:\n${body.slice(0, 500)}`);
+  } else if (res.status === 402) {
+    console.log('\n✗ Server still returned 402 after payment — check accept entries.');
+  }
+} catch (err) {
+  console.error(`\n✗ Pay-and-fetch failed:`, err.message);
+}
+
+console.log('\n✓ Done — agent paid for an API call without a credit card.');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidly/agent-sdk",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "description": "E2E encrypted agent-to-agent communication SDK — Double Ratchet, X3DH, deniable auth, ML-KEM-768 post-quantum, SSE streaming, ratchet persistence, multi-relay federation",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -29,8 +29,9 @@
     "tweetnacl-util": "^0.15.1"
   },
   "devDependencies": {
+    "@types/node": "^22.0.0",
     "tsup": "^8.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^6.0.3"
   },
   "keywords": [
     "agent",

package/examples/post-quantum.mjs

@@ -1,99 +0,0 @@
-#!/usr/bin/env node
-/**
- * Post-Quantum + Ratchet Persistence — Future-proof encrypted messaging.
- *
- * Run:  node examples/post-quantum.mjs
- *
- * Features demonstrated:
- *   1. ML-KEM-768 hybrid key exchange (NIST FIPS 203) — quantum-resistant
- *   2. Double Ratchet forward secrecy — compromise now can't decrypt past messages
- *   3. Ratchet persistence — session survives agent restarts
- *   4. Sealed sender — relay can't see who sent the message
- *   5. Deniable auth — both parties can produce the signature (plausible deniability)
- */
-import { VoidlyAgent } from '@voidly/agent-sdk';
-
-// ─── Register with full security config ─────────────────────────────────────
-const alice = await VoidlyAgent.register(
-  { name: 'pq-alice', capabilities: ['chat', 'intel'] },
-  {
-    pq: true,              // Enable ML-KEM-768 post-quantum hybrid
-    padding: true,         // Pad all messages to power-of-2 (traffic analysis resistance)
-    sealedSender: true,    // Hide sender DID from relay metadata
-    deniable: true,        // HMAC signatures (both parties can produce — deniable)
-    persist: 'memory',     // Ratchet state persists in memory (use 'file' or 'relay' for disk)
-    autoPin: true,         // TOFU: pin first-seen keys, warn on change
-  }
-);
-
-const bob = await VoidlyAgent.register(
-  { name: 'pq-bob', capabilities: ['chat', 'analysis'] },
-  {
-    pq: true,
-    padding: true,
-    sealedSender: true,
-    deniable: true,
-    persist: 'memory',
-    autoPin: true,
-  }
-);
-
-console.log(`Alice: ${alice.did} (PQ + sealed + deniable)`);
-console.log(`Bob:   ${bob.did} (PQ + sealed + deniable)\n`);
-
-// ─── Verify post-quantum is active ──────────────────────────────────────────
-const threat = alice.threatModel();
-console.log('Active protections:');
-threat.protections.forEach(p => console.log(`  ✓ ${p}`));
-console.log('Known gaps:');
-threat.gaps.forEach(g => console.log(`  ⚠ ${g}`));
-
-// ─── Send messages with full protection stack ───────────────────────────────
-console.log('\nSending with PQ hybrid + Double Ratchet + sealed sender + padding...');
-await alice.send(bob.did, 'Quantum-resistant hello from Alice', { threadId: 'pq-demo' });
-await alice.send(bob.did, 'Even a quantum computer cannot decrypt this retroactively');
-
-// Bob receives and decrypts
-const messages = await bob.receive({ limit: 10 });
-for (const msg of messages) {
-  console.log(`\n  Bob received: "${msg.content}"`);
-  console.log(`    From:            ${msg.from.slice(0, 30)}...`);
-  console.log(`    Signature valid: ${msg.signatureValid}`);
-}
-
-// ─── Demonstrate forward secrecy ────────────────────────────────────────────
-console.log('\n─── Forward Secrecy Demo ───');
-console.log('Ratchet advances with each message — past keys are deleted.');
-console.log('Even if an attacker compromises the agent NOW, they cannot');
-console.log('decrypt messages that were already received and processed.\n');
-
-// Bob replies — DH ratchet advances
-await bob.send(alice.did, 'Reply from Bob — ratchet advanced');
-const replies = await alice.receive({ limit: 5 });
-for (const r of replies) {
-  console.log(`  Alice received: "${r.content}"`);
-}
-
-// ─── Credential export (includes ratchet state) ─────────────────────────────
-console.log('\n─── Credential Export ───');
-const creds = alice.exportCredentials();
-console.log(`  DID:          ${creds.did}`);
-console.log(`  Signing key:  ${creds.signingSecretKey.slice(0, 16)}...`);
-console.log(`  PQ enabled:   ${!!creds.mlkemSecretKey}`);
-
-// Restore agent from credentials (e.g., after restart)
-const restored = VoidlyAgent.fromCredentials(creds, {
-  pq: true, padding: true, sealedSender: true, deniable: true, persist: 'memory',
-});
-console.log(`  Restored DID: ${restored.did} (matches: ${restored.did === alice.did})`);
-
-// ─── Flush ratchet state ────────────────────────────────────────────────────
-await alice.flushRatchetState();
-console.log('\n  Ratchet state flushed to persistence backend.');
-
-// Clean shutdown
-alice.stopAll();
-bob.stopAll();
-restored.stopAll();
-
-console.log('\n✓ Done — post-quantum hybrid encryption with forward secrecy.');

package/examples/sse-streaming.mjs

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-/**
- * SSE Streaming — Real-time message delivery via Server-Sent Events.
- *
- * Run:  node examples/sse-streaming.mjs
- *
- * Instead of polling, Bob opens an SSE connection to the relay.
- * Messages arrive in near-real-time (~1s latency) with automatic reconnection.
- * All decryption still happens client-side.
- */
-import { VoidlyAgent } from '@voidly/agent-sdk';
-
-const alice = await VoidlyAgent.register({ name: 'sse-alice' });
-const bob   = await VoidlyAgent.register(
-  { name: 'sse-bob' },
-  { transport: ['sse', 'long-poll'] }  // Prefer SSE, fall back to long-poll
-);
-
-console.log(`Alice: ${alice.did}`);
-console.log(`Bob:   ${bob.did} (SSE transport)\n`);
-
-// Bob listens via SSE — messages arrive in near-real-time
-const handle = bob.listen(
-  (msg) => {
-    console.log(`  ← Bob received: "${msg.content}" from ${msg.from.slice(0, 24)}...`);
-    console.log(`    Signature valid: ${msg.signatureValid}`);
-  },
-  {
-    interval: 2000,    // Reconnect interval if SSE drops
-    adaptive: true,    // Back off when idle
-    heartbeat: false,  // Don't send pings
-  }
-);
-
-// Wait for SSE connection to establish
-await new Promise(r => setTimeout(r, 1500));
-
-// Alice sends a burst of messages
-console.log('Alice sending 3 messages...');
-await alice.send(bob.did, 'Message 1 — SSE delivery');
-await alice.send(bob.did, 'Message 2 — near-real-time');
-await alice.send(bob.did, 'Message 3 — all encrypted');
-
-// Wait for delivery
-await new Promise(r => setTimeout(r, 5000));
-
-// Clean shutdown
-handle.stop();
-alice.stopAll();
-bob.stopAll();
-
-console.log('\n✓ Done — SSE streaming with E2E encryption.');