@qvac/sdk 0.14.0 → 0.15.0

package/dist/examples/completion-stop-reason.js

@@ -21,7 +21,7 @@
  * The same `stopReason` is also available on the terminal `completionDone`
  * event in the `events` stream.
  */
-import { completion, loadModel, unloadModel, QWEN3_600M_INST_Q4, } from "@qvac/sdk";
+import { completion, loadModel, unloadModel, QWEN3_600M_INST_Q4 } from '@qvac/sdk';
 try {
     const modelId = await loadModel({
         modelSrc: QWEN3_600M_INST_Q4,
@@ -31,33 +31,33 @@ try {
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ Model loaded: ${modelId}\n`);
     // --- Case 1: natural EOS ---
-    console.log("▸ Case 1: natural EOS (no predict limit)");
+    console.log('▸ Case 1: natural EOS (no predict limit)');
     const run1 = completion({
         modelId,
-        history: [{ role: "user", content: "Say hi in one word." }],
-        stream: true,
+        history: [{ role: 'user', content: 'Say hi in one word.' }],
+        stream: true
     });
     for await (const event of run1.events) {
-        if (event.type === "contentDelta")
+        if (event.type === 'contentDelta')
             process.stdout.write(event.text);
     }
     const final1 = await run1.final;
-    console.log(`\n▸ stopReason: ${final1.stopReason ?? "(undefined — natural EOS)"}`);
+    console.log(`\n▸ stopReason: ${final1.stopReason ?? '(undefined — natural EOS)'}`);
     // --- Case 2: predict budget exhausted → stopReason = "length" ---
-    console.log("\n▸ Case 2: predict budget hit (predict: 10)");
+    console.log('\n▸ Case 2: predict budget hit (predict: 10)');
     const run2 = completion({
         modelId,
-        history: [{ role: "user", content: "Count from 1 to 100, one number per line." }],
+        history: [{ role: 'user', content: 'Count from 1 to 100, one number per line.' }],
         generationParams: { predict: 10 },
-        stream: true,
+        stream: true
     });
     for await (const event of run2.events) {
-        if (event.type === "contentDelta")
+        if (event.type === 'contentDelta')
             process.stdout.write(event.text);
     }
     const final2 = await run2.final;
@@ -66,6 +66,6 @@ try {
     process.exit(0);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/concurrent-completion-collision.js

@@ -21,28 +21,28 @@
  * Run from packages/sdk:
  *   bun run examples/concurrent-completion-collision.ts
  */
-import { completion, loadModel, unloadModel, QWEN3_1_7B_INST_Q4, LLAMA_3_2_1B_INST_Q4_0, RequestRejectedByPolicyError, } from "@qvac/sdk";
+import { completion, loadModel, unloadModel, QWEN3_1_7B_INST_Q4, LLAMA_3_2_1B_INST_Q4_0, RequestRejectedByPolicyError } from '@qvac/sdk';
 async function runCompletion(label, modelId, prompt) {
     try {
         // `completion()` starts the request synchronously, so calling this for two
         // tasks in the same tick puts both "in flight" before either is awaited.
         const result = completion({
             modelId,
-            history: [{ role: "user", content: prompt }],
-            stream: false,
+            history: [{ role: 'user', content: prompt }],
+            stream: false
         });
         const text = await result.text;
         return { label, ok: true, text };
     }
     catch (error) {
-        const code = typeof error === "object" && error !== null && "code" in error
+        const code = typeof error === 'object' && error !== null && 'code' in error
             ? error.code
             : undefined;
         const base = {
             label,
             ok: false,
             errorName: error instanceof Error ? error.constructor.name : typeof error,
-            message: error instanceof Error ? error.message : String(error),
+            message: error instanceof Error ? error.message : String(error)
         };
         return code !== undefined ? { ...base, code } : base;
     }
@@ -51,29 +51,29 @@ function report(title, outcomes) {
     console.log(`\n▸ ${title}`);
     for (const o of outcomes) {
         if (o.ok) {
-            const preview = o.text.replace(/\s+/g, " ").slice(0, 70);
-            console.log(`  ▸ ${o.label}: ${preview}${o.text.length > 70 ? "…" : ""}`);
+            const preview = o.text.replace(/\s+/g, ' ').slice(0, 70);
+            console.log(`  ▸ ${o.label}: ${preview}${o.text.length > 70 ? '…' : ''}`);
         }
         else {
-            const policy = o.code === 52420 ? " (rejected by policy)" : "";
-            console.log(`  ✖ ${o.label}: ${o.errorName}${o.code !== undefined ? ` [${o.code}]` : ""}${policy} — ${o.message}`);
+            const policy = o.code === 52420 ? ' (rejected by policy)' : '';
+            console.log(`  ✖ ${o.label}: ${o.errorName}${o.code !== undefined ? ` [${o.code}]` : ''}${policy} — ${o.message}`);
         }
     }
 }
 try {
     const modelA = await loadModel({
         modelSrc: QWEN3_1_7B_INST_Q4,
-        modelConfig: { ctx_size: 4096 },
+        modelConfig: { ctx_size: 4096 }
     });
     // Part 1 — same model, two concurrent completions.
     const sameModel = await Promise.all([
-        runCompletion("req-A1", modelA, "What is Bitcoin? One sentence."),
-        runCompletion("req-A2", modelA, "What is a hash function? One sentence."),
+        runCompletion('req-A1', modelA, 'What is Bitcoin? One sentence.'),
+        runCompletion('req-A2', modelA, 'What is a hash function? One sentence.')
     ]);
-    report("Part 1 — two concurrent completions on the SAME model (expect both to succeed, serialized):", sameModel);
+    report('Part 1 — two concurrent completions on the SAME model (expect both to succeed, serialized):', sameModel);
     const rejected = sameModel.filter((o) => !o.ok).length;
     if (rejected === 0) {
-        console.log("  ▸ Both succeeded: the second was queued behind the first and ran when the slot freed (no 52420, no addon collision).");
+        console.log('  ▸ Both succeeded: the second was queued behind the first and ran when the slot freed (no 52420, no addon collision).');
     }
     else {
         console.log(`  ▸ ${rejected}/2 failed — the FIFO admission queue should have serialized these. Check the completion policy.`);
@@ -81,18 +81,18 @@ try {
     // Part 2 — different models, two concurrent completions (the "parallel that works").
     const modelB = await loadModel({
         modelSrc: LLAMA_3_2_1B_INST_Q4_0,
-        modelConfig: { ctx_size: 4096 },
+        modelConfig: { ctx_size: 4096 }
     });
     const differentModels = await Promise.all([
-        runCompletion("req-A", modelA, "Name one use of Bitcoin. One sentence."),
-        runCompletion("req-B", modelB, "Name one use of Ethereum. One sentence."),
+        runCompletion('req-A', modelA, 'Name one use of Bitcoin. One sentence.'),
+        runCompletion('req-B', modelB, 'Name one use of Ethereum. One sentence.')
     ]);
-    report("Part 2 — two concurrent completions on DIFFERENT models (expect both succeed):", differentModels);
+    report('Part 2 — two concurrent completions on DIFFERENT models (expect both succeed):', differentModels);
     await unloadModel({ modelId: modelA, clearStorage: false });
     await unloadModel({ modelId: modelB, clearStorage: false });
-    console.log(`\n▸ rejected-by-policy error available for instanceof checks: ${typeof RequestRejectedByPolicyError === "function"}`);
+    console.log(`\n▸ rejected-by-policy error available for instanceof checks: ${typeof RequestRejectedByPolicyError === 'function'}`);
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/config/blind-relay/blind-relay.config.js

@@ -1,7 +1,7 @@
 export default {
     swarmRelays: [
-        "0000000000000000000000000000000000000000000000000000000000000001",
-        "0000000000000000000000000000000000000000000000000000000000000002",
-        "0000000000000000000000000000000000000000000000000000000000000003",
-    ],
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        '0000000000000000000000000000000000000000000000000000000000000002',
+        '0000000000000000000000000000000000000000000000000000000000000003'
+    ]
 };

package/dist/examples/config/default/default.config.js

@@ -1,6 +1,6 @@
 export default {
-    loggerLevel: "info",
+    loggerLevel: 'info',
     loggerConsoleOutput: true,
     httpDownloadConcurrency: 3,
-    httpConnectionTimeoutMs: 10000,
+    httpConnectionTimeoutMs: 10000
 };

package/dist/examples/config/plugins/plugins.config.js

@@ -1,4 +1,4 @@
-import { PLUGIN_LLM, PLUGIN_NMT } from "@qvac/sdk";
+import { PLUGIN_LLM, PLUGIN_NMT } from '@qvac/sdk';
 export default {
-    plugins: [PLUGIN_LLM, PLUGIN_NMT],
+    plugins: [PLUGIN_LLM, PLUGIN_NMT]
 };

package/dist/examples/config-reload.js

@@ -1,47 +1,47 @@
-import { WHISPER_TINY, loadModel, transcribe, unloadModel } from "../index";
+import { WHISPER_TINY, loadModel, transcribe, unloadModel } from '../index';
 // Parse command line arguments
 const args = process.argv.slice(2);
 if (!args[0]) {
-    console.error("✖ Usage: bun run examples/config-reload.ts <audio-file-path>");
+    console.error('✖ Usage: bun run examples/config-reload.ts <audio-file-path>');
     process.exit(1);
 }
 const audioFilePath = args[0];
 try {
     // Initial load with English language
-    console.log("▸ Loading Whisper model with English config...");
+    console.log('▸ Loading Whisper model with English config...');
     const modelId = await loadModel({
         modelSrc: WHISPER_TINY,
         modelConfig: {
-            language: "en",
-        },
+            language: 'en'
+        }
     });
     // Transcribe with English config
-    console.log("▸ Transcribing audio with English config...");
+    console.log('▸ Transcribing audio with English config...');
     const englishText = await transcribe({
         modelId,
-        audioChunk: audioFilePath,
+        audioChunk: audioFilePath
     });
     console.log(`Transcription (EN): ${englishText}`);
     // Hot reload config - change language and temperature
-    console.log("▸ Hot reloading config (changing language and temperature)...");
+    console.log('▸ Hot reloading config (changing language and temperature)...');
     const reloadedId = await loadModel({
         modelId,
-        modelType: "whispercpp-transcription",
+        modelType: 'whispercpp-transcription',
         modelConfig: {
-            language: "es", // Change to Spanish
-        },
+            language: 'es' // Change to Spanish
+        }
     });
     console.log(`▸ Config reloaded, same model ID: ${reloadedId === modelId}`);
     // Transcribe again with updated config
-    console.log("▸ Transcribing with updated config...");
+    console.log('▸ Transcribing with updated config...');
     const spanishText = await transcribe({
         modelId,
-        audioChunk: audioFilePath,
+        audioChunk: audioFilePath
     });
     console.log(`Transcription (ES): ${spanishText}`);
     await unloadModel({ modelId });
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/default-config-usage.js

@@ -16,31 +16,28 @@
 // Note: This example uses .js file for the config
 // However it could be .json or .ts as well, depending on your needs.
 const configDir = import.meta.dirname ?? process.cwd();
-process.env["QVAC_CONFIG_PATH"] =
-    `${configDir}/config/default/default.config.js`;
-console.log(`▸ Using config from: ${process.env["QVAC_CONFIG_PATH"]}`);
-const { loadModel, unloadModel, completion, LLAMA_3_2_1B_INST_Q4_0 } = await import("@qvac/sdk");
+process.env['QVAC_CONFIG_PATH'] = `${configDir}/config/default/default.config.js`;
+console.log(`▸ Using config from: ${process.env['QVAC_CONFIG_PATH']}`);
+const { loadModel, unloadModel, completion, LLAMA_3_2_1B_INST_Q4_0 } = await import('@qvac/sdk');
 try {
-    console.log("▸ Loading model with configured settings...");
+    console.log('▸ Loading model with configured settings...');
     const modelId = await loadModel({
-        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0
     });
-    console.log("▸ Running completion...");
+    console.log('▸ Running completion...');
     const result = completion({
         modelId,
-        history: [
-            { role: "user", content: "Say 'Config works!' in exactly 3 words." },
-        ],
-        stream: true,
+        history: [{ role: 'user', content: "Say 'Config works!' in exactly 3 words." }],
+        stream: true
     });
     for await (const token of result.tokenStream) {
         process.stdout.write(token);
     }
-    console.log("\n");
+    console.log('\n');
     await unloadModel({ modelId });
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }
 export {};

package/dist/examples/delegated-inference/composite.js

@@ -1,25 +1,25 @@
-import { spawn } from "child_process";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { completion, loadModel, close, LLAMA_3_2_1B_INST_Q4_0, } from "@qvac/sdk";
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { completion, loadModel, close, LLAMA_3_2_1B_INST_Q4_0 } from '@qvac/sdk';
 // The consumer connects to the provider directly via its public key over the
 // DHT (`dht.connect(publicKey)`). No topic or discovery step is involved —
 // the provider just needs its DHT server listening on its keyPair.
 const PROVIDER_STARTUP_TIMEOUT_MS = 60_000;
 const __dirname = dirname(fileURLToPath(import.meta.url));
-const providerScript = join(__dirname, "provider.ts");
+const providerScript = join(__dirname, 'provider.ts');
 function spawnProviderProcess() {
-    const child = spawn("bun", ["run", providerScript], {
-        stdio: ["pipe", "pipe", "pipe"],
+    const child = spawn('bun', ['run', providerScript], {
+        stdio: ['pipe', 'pipe', 'pipe']
     });
-    child.stderr?.on("data", (chunk) => {
+    child.stderr?.on('data', (chunk) => {
         process.stderr.write(chunk);
     });
     return child;
 }
 function terminateProvider(provider) {
     if (!provider.killed) {
-        provider.kill("SIGTERM");
+        provider.kill('SIGTERM');
     }
 }
 // The provider's Hyperswarm identity (and therefore its public key) is
@@ -28,11 +28,11 @@ function terminateProvider(provider) {
 //   "▸ Provider Public Key: <hex>"
 function waitForProviderPublicKey(provider) {
     return new Promise((resolve, reject) => {
-        let output = "";
+        let output = '';
         const timeout = setTimeout(() => {
-            reject(new Error("Provider did not emit its public key in time"));
+            reject(new Error('Provider did not emit its public key in time'));
         }, PROVIDER_STARTUP_TIMEOUT_MS);
-        provider.stdout.on("data", (chunk) => {
+        provider.stdout.on('data', (chunk) => {
             const str = chunk.toString();
             output += str;
             process.stdout.write(str);
@@ -42,40 +42,40 @@ function waitForProviderPublicKey(provider) {
                 resolve(match[1]);
             }
         });
-        provider.on("error", (err) => {
+        provider.on('error', (err) => {
             clearTimeout(timeout);
             reject(err);
         });
-        provider.on("close", (code) => {
+        provider.on('close', (code) => {
             clearTimeout(timeout);
             reject(new Error(`Provider exited unexpectedly (code ${String(code)})`));
         });
     });
 }
 async function runDelegatedCompletion(providerPublicKey) {
-    console.log("▸ Loading model via delegation...");
+    console.log('▸ Loading model via delegation...');
     const modelId = await loadModel({
         modelSrc: LLAMA_3_2_1B_INST_Q4_0,
         delegate: {
             providerPublicKey,
-            timeout: 30_000,
+            timeout: 30_000
         },
         onProgress: (p) => {
             const mb = (n) => (n / 1e6).toFixed(1);
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ Model loaded: ${modelId}`);
-    console.log("▸ Running delegated completion (streamed)...");
+    console.log('▸ Running delegated completion (streamed)...');
     const response = completion({
         modelId,
-        history: [{ role: "user", content: "Say hello in exactly 5 words." }],
-        stream: true,
+        history: [{ role: 'user', content: 'Say hello in exactly 5 words.' }],
+        stream: true
     });
-    console.log("▸ Response:");
+    console.log('▸ Response:');
     for await (const token of response.tokenStream) {
         process.stdout.write(token);
     }
@@ -84,7 +84,7 @@ async function runDelegatedCompletion(providerPublicKey) {
 }
 const provider = spawnProviderProcess();
 try {
-    console.log("▸ Waiting for provider to start and announce its key...");
+    console.log('▸ Waiting for provider to start and announce its key...');
     const publicKey = await waitForProviderPublicKey(provider);
     console.log(`\n▸ Provider ready — key: ${publicKey}\n`);
     await runDelegatedCompletion(publicKey);

package/dist/examples/delegated-inference/consumer-profiled.js

@@ -1,43 +1,43 @@
-import { close, completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, profiler, } from "@qvac/sdk";
+import { close, completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, profiler } from '@qvac/sdk';
 const providerPublicKey = process.argv[2];
 if (!providerPublicKey) {
-    console.error("✖ Usage: bun run consumer-profiled.ts <providerPublicKey>");
+    console.error('✖ Usage: bun run consumer-profiled.ts <providerPublicKey>');
     process.exit(1);
 }
 try {
-    profiler.enable({ mode: "verbose", includeServerBreakdown: true });
-    console.log("▸ Profiler enabled");
+    profiler.enable({ mode: 'verbose', includeServerBreakdown: true });
+    console.log('▸ Profiler enabled');
     console.log(`\n▸ Provider: ${providerPublicKey}\n`);
-    console.log("▸ Loading model (delegated, unary)...");
+    console.log('▸ Loading model (delegated, unary)...');
     const modelId = await loadModel({
         modelSrc: LLAMA_3_2_1B_INST_Q4_0,
         delegate: {
             providerPublicKey,
-            timeout: 60_000,
-        },
+            timeout: 60_000
+        }
     });
     console.log(`▸ Model loaded: ${modelId}`);
-    console.log("▸ Running completion (delegated, streamed)...");
+    console.log('▸ Running completion (delegated, streamed)...');
     const response = completion({
         modelId,
-        history: [{ role: "user", content: "Say hello in exactly 5 words." }],
-        stream: true,
+        history: [{ role: 'user', content: 'Say hello in exactly 5 words.' }],
+        stream: true
     });
-    console.log("▸ Response:");
+    console.log('▸ Response:');
     for await (const token of response.tokenStream) {
         process.stdout.write(token);
     }
     await response.stats;
-    console.log("\n▸ Completion done\n");
-    console.log("▸ Profiler Summary");
+    console.log('\n▸ Completion done\n');
+    console.log('▸ Profiler Summary');
     console.log(profiler.exportSummary());
-    console.log("▸ Profiler Table");
+    console.log('▸ Profiler Table');
     console.log(profiler.exportTable());
     // Look for delegation-specific metrics
     const json = profiler.exportJSON();
-    const delegationMetrics = Object.keys(json.aggregates).filter((k) => k.includes("delegation") || k.includes("delegated"));
+    const delegationMetrics = Object.keys(json.aggregates).filter((k) => k.includes('delegation') || k.includes('delegated'));
     if (delegationMetrics.length > 0) {
-        console.log("▸ Delegation Metrics");
+        console.log('▸ Delegation Metrics');
         for (const key of delegationMetrics) {
             const agg = json.aggregates[key];
             if (agg) {
@@ -46,14 +46,14 @@ try {
         }
     }
     else {
-        console.log("▸ No delegation-specific metrics found");
-        console.log("    (delegation profiling may need to be triggered)");
+        console.log('▸ No delegation-specific metrics found');
+        console.log('    (delegation profiling may need to be triggered)');
     }
     profiler.disable();
     void close();
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     profiler.disable();
     process.exit(1);
 }

package/dist/examples/delegated-inference/consumer.js

@@ -1,13 +1,13 @@
-import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, close, } from "@qvac/sdk";
+import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel, close } from '@qvac/sdk';
 const providerPublicKey = process.argv[2];
 if (!providerPublicKey) {
-    console.error("✖ Provider public key is required. Usage: node consumer.ts <provider-public-key> [consumer-seed]");
+    console.error('✖ Provider public key is required. Usage: node consumer.ts <provider-public-key> [consumer-seed]');
     process.exit(1);
 }
 try {
     // Optional: Consumer seed for deterministic consumer identity (for firewall testing)
     const consumerSeed = process.argv[3];
-    process.env["QVAC_HYPERSWARM_SEED"] = consumerSeed;
+    process.env['QVAC_HYPERSWARM_SEED'] = consumerSeed;
     console.log(`▸ Testing delegated inference`);
     console.log(`▸ Provider: ${providerPublicKey}`);
     if (consumerSeed) {
@@ -25,7 +25,7 @@ try {
             // very first run. Subsequent connections in the same process are
             // sub-second because the DHT is already warm.
             timeout: 60_000,
-            fallbackToLocal: true, // Optional: Fall back to local inference if delegation fails
+            fallbackToLocal: true // Optional: Fall back to local inference if delegation fails
             // forceNewConnection: true, // Optional: Force a new connection instead of reusing cached one
         },
         onProgress: (p) => {
@@ -33,23 +33,23 @@ try {
             const line = `▸ Downloading ${p.percentage.toFixed(0)}% (${mb(p.downloaded)}/${mb(p.total)} MB)`;
             process.stderr.write(process.stderr.isTTY ? `\r${line}` : `${line}\n`);
             if (p.percentage >= 100)
-                process.stderr.write("\n");
-        },
+                process.stderr.write('\n');
+        }
     });
     console.log(`▸ Delegated model registered: ${modelId}`);
     const response = completion({
         modelId,
-        history: [{ role: "user", content: "Hello!" }],
-        stream: true,
+        history: [{ role: 'user', content: 'Hello!' }],
+        stream: true
     });
     for await (const token of response.tokenStream) {
         process.stdout.write(token);
     }
-    console.log("\n▸ Stats:", await response.stats);
-    console.log("▸ Delegation infrastructure working! Server correctly detected and routed the delegated request.");
+    console.log('\n▸ Stats:', await response.stats);
+    console.log('▸ Delegation infrastructure working! Server correctly detected and routed the delegated request.');
     void close();
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }

package/dist/examples/delegated-inference/provider.js

@@ -1,8 +1,8 @@
-import { startQVACProvider } from "@qvac/sdk";
+import { startQVACProvider } from '@qvac/sdk';
 // Optional: Seed for deterministic provider identity (64-character hex string)
 const seed = process.argv[2];
 if (seed) {
-    process.env["QVAC_HYPERSWARM_SEED"] = seed;
+    process.env['QVAC_HYPERSWARM_SEED'] = seed;
 }
 // Optional: Consumer public key for firewall (allow only this consumer)
 const allowedConsumerPublicKey = process.argv[3];
@@ -14,39 +14,39 @@ try {
     const response = await startQVACProvider({
         firewall: allowedConsumerPublicKey
             ? {
-                mode: "allow",
-                publicKeys: [allowedConsumerPublicKey],
+                mode: 'allow',
+                publicKeys: [allowedConsumerPublicKey]
             }
-            : undefined,
+            : undefined
     });
-    console.log("▸ Provider service started successfully!");
-    console.log("▸ Provider is now available for delegated inference requests");
-    console.log("");
-    console.log("▸ Connection Details:");
+    console.log('▸ Provider service started successfully!');
+    console.log('▸ Provider is now available for delegated inference requests');
+    console.log('');
+    console.log('▸ Connection Details:');
     console.log(`▸ Provider Public Key: ${response.publicKey}`);
-    console.log("");
-    console.log("▸ Consumer command:");
+    console.log('');
+    console.log('▸ Consumer command:');
     console.log(`   node consumer.ts ${response.publicKey}`);
-    console.log("");
-    console.log("▸ To reproduce this provider identity:");
-    console.log(`   node provider.ts ${seed || "<random-seed>"}`);
+    console.log('');
+    console.log('▸ To reproduce this provider identity:');
+    console.log(`   node provider.ts ${seed || '<random-seed>'}`);
     if (!seed) {
-        console.log("   (Note: seed was random this time, set one for reproducible identity)");
+        console.log('   (Note: seed was random this time, set one for reproducible identity)');
     }
-    console.log("");
-    console.log("▸ For firewall testing:");
-    console.log("   1. Generate a consumer seed (64-char hex)");
-    console.log("   2. Get consumer public key: getConsumerPublicKey(consumerSeed)");
-    console.log("   3. Restart provider with consumer public key as 2nd argument");
+    console.log('');
+    console.log('▸ For firewall testing:');
+    console.log('   1. Generate a consumer seed (64-char hex)');
+    console.log('   2. Get consumer public key: getConsumerPublicKey(consumerSeed)');
+    console.log('   3. Restart provider with consumer public key as 2nd argument');
     console.log(`   4. Run consumer with: node consumer.ts ${response.publicKey} <consumer-seed>`);
-    console.log("▸ Provider is running... Press Ctrl+C to stop");
-    process.on("SIGINT", () => {
-        console.log("\n▸ Provider service stopped");
+    console.log('▸ Provider is running... Press Ctrl+C to stop');
+    process.on('SIGINT', () => {
+        console.log('\n▸ Provider service stopped');
         process.exit(0);
     });
     process.stdin.resume();
 }
 catch (error) {
-    console.error("✖", error);
+    console.error('✖', error);
     process.exit(1);
 }