@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/client/rpc/bare-client.js

@@ -0,0 +1,82 @@
+import { handlers } from "../../server/rpc/handlers/index.js";
+// Get the handler for a request type
+const getHandler = (type) => {
+    const handler = handlers[type];
+    return typeof handler === "function" ? handler : undefined;
+};
+export async function send(request) {
+    if (request.type === "ping") {
+        return { type: "pong", number: Math.random() * 100 };
+    }
+    const handler = getHandler(request.type);
+    if (!handler)
+        throw new Error(`No handler function for ${request.type}`);
+    return (await handler(request));
+}
+export async function* stream(request) {
+    const handler = getHandler(request.type);
+    if (!handler)
+        throw new Error(`No handler function for ${request.type}`);
+    // Special handling for loadModel with progress
+    if (request.type === "loadModel" &&
+        "withProgress" in request &&
+        request.withProgress) {
+        async function* streamWithProgress() {
+            const queue = [];
+            let done = false;
+            const loadModelHandler = handler;
+            loadModelHandler(request, (update) => queue.push(update))
+                .then((final) => {
+                queue.push(final);
+                done = true;
+            })
+                .catch((error) => {
+                done = true;
+                throw error;
+            });
+            while (!done || queue.length > 0) {
+                if (queue.length > 0) {
+                    yield queue.shift();
+                }
+                else {
+                    await new Promise((resolve) => setTimeout(resolve, 10));
+                }
+            }
+        }
+        yield* streamWithProgress();
+    }
+    else {
+        yield* handler(request);
+    }
+}
+const createMockRPCRequest = () => {
+    let requestData = null;
+    return {
+        send(payload) {
+            // Parse the JSON payload to get the actual request data
+            requestData = JSON.parse(payload);
+        },
+        async reply() {
+            if (!requestData) {
+                throw new Error("No request data - call send() first");
+            }
+            const response = await send(requestData);
+            return Buffer.from(JSON.stringify(response));
+        },
+        async *createResponseStream() {
+            if (!requestData) {
+                throw new Error("No request data - call send() first");
+            }
+            for await (const response of stream(requestData)) {
+                yield Buffer.from(JSON.stringify(response) + "\n");
+            }
+        },
+    };
+};
+export function getRPC() {
+    return {
+        request() {
+            return createMockRPCRequest();
+        },
+    };
+}

package/dist/client/rpc/bare-rpc-client.d.ts

@@ -0,0 +1,4 @@
+import RPC from "bare-rpc";
+export declare function getRPC(): Promise<RPC>;
+export declare const cleanup: () => void;
+//# sourceMappingURL=bare-rpc-client.d.ts.map

package/dist/client/rpc/bare-rpc-client.js

@@ -0,0 +1,87 @@
+import RPC from "bare-rpc";
+import { spawn } from "bare-subprocess";
+import { createServer } from "bare-net";
+import os from "bare-os";
+import path from "bare-path";
+import process from "bare-process";
+let rpcInstance = null;
+let ipcServer = null;
+let childProcess = null;
+const cwd = process.cwd();
+// Resolve worker path relative to this module's location (in the SDK)
+// In Bare, we'll use a simpler path resolution
+let WORKER_PATH;
+if (cwd.includes("/dist/") || cwd.includes("\\dist\\")) {
+    // Running from compiled dist/ - worker is in same dist/ folder
+    const distRoot = cwd.includes("/dist/")
+        ? cwd.split("/dist/")[0] + "/dist"
+        : cwd.split("\\dist\\")[0] + "\\dist";
+    WORKER_PATH = path.join(distRoot, "server/worker.js");
+}
+else {
+    // Running from source - worker is in dist/ folder
+    WORKER_PATH = path.resolve(cwd, "dist/server/worker.js");
+}
+const SOCKET_PATH = path.join(os.tmpdir(), `qvac-worker-${process.pid}.sock`);
+export function getRPC() {
+    if (rpcInstance) {
+        console.log("returning cached bare rpc");
+        return Promise.resolve(rpcInstance);
+    }
+    console.log("initRPC for bare runtime with socket:", SOCKET_PATH);
+    // Start IPC server (Unix socket)
+    const serverPromise = new Promise((resolve, reject) => {
+        const server = createServer((socket) => {
+            console.log("Worker connected via IPC socket");
+            // Create RPC instance using the socket
+            rpcInstance = new RPC(socket, () => {
+                // Use this for async callbacks
+            });
+            resolve(rpcInstance);
+        });
+        server.on("error", (err) => {
+            console.error("Failed to start IPC server:", err);
+            reject(err);
+        });
+        server.listen(SOCKET_PATH, () => {
+            console.log(`IPC server listening on ${SOCKET_PATH}`);
+            ipcServer = server;
+            // Spawn the worker process only after the socket is listening
+            console.log("Spawning worker at:", WORKER_PATH);
+            childProcess = spawn("bare", [
+                WORKER_PATH,
+                JSON.stringify({
+                    QVAC_IPC_SOCKET_PATH: SOCKET_PATH,
+                    HOME_DIR: os.homedir(),
+                }),
+            ], {
+                stdio: ["inherit", "inherit", "inherit"],
+            });
+            childProcess.on("exit", (code) => {
+                console.log("Worker process exited with code:", code);
+                // Clean up
+                rpcInstance = null;
+                if (ipcServer) {
+                    ipcServer.close();
+                    ipcServer = null;
+                }
+            });
+            childProcess.on("error", (err) => {
+                console.error("Worker process error:", err);
+            });
+        });
+    });
+    return serverPromise;
+}
+// Clean up function
+export const cleanup = () => {
+    if (childProcess) {
+        childProcess.kill();
+        childProcess = null;
+    }
+    if (ipcServer) {
+        ipcServer.close();
+        ipcServer = null;
+    }
+    rpcInstance = null;
+};

package/dist/client/rpc/expo-rpc-client.d.ts

@@ -0,0 +1,3 @@
+import RPC from "bare-rpc";
+export declare const getRPC: () => Promise<RPC>;
+//# sourceMappingURL=expo-rpc-client.d.ts.map

package/dist/client/rpc/expo-rpc-client.js

@@ -0,0 +1,57 @@
+import RPC from "bare-rpc";
+let rpcInstance = null;
+let rpcPromise = null;
+console.log("EXPO RPC Client bundle");
+export const getRPC = async () => {
+    if (rpcInstance) {
+        return rpcInstance;
+    }
+    if (rpcPromise) {
+        return rpcPromise;
+    }
+    rpcPromise = (async () => {
+        const { Paths } = await import("expo-file-system");
+        const bareKitModule = await import("react-native-bare-kit");
+        const worklet = new bareKitModule.Worklet();
+        console.log("Starting worklet");
+        // Load the mobile bundle - this will be generated by the Expo plugin
+        // using the user's installed bare library versions
+        let mobileBundle;
+        try {
+            // We need require here or the contents of the bundle will be interpreted as a module
+            mobileBundle =
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                require("@qvac/sdk/worker.mobile.bundle");
+        }
+        catch (error) {
+            const message = "Failed to load mobile worker bundle. Make sure the QVAC Expo plugin is configured. " +
+                `Add '@qvac/sdk/expo-plugin' to your app.json plugins array. ` +
+                `Error: ${String(error)}`;
+            console.error(message);
+            throw new Error(message);
+        }
+        worklet.start("worker.bundle", mobileBundle, [
+            // Normalize arg number across platforms
+            "react-native-bare-kit",
+            "worker.js",
+            JSON.stringify({
+                HOME_DIR: Paths.document.uri.replace("file://", ""),
+            }),
+        ]);
+        console.log("Worklet started");
+        rpcInstance = new RPC(worklet.IPC, () => {
+            // Use this for async callbacks
+        });
+        return rpcInstance;
+    })();
+    try {
+        return await rpcPromise;
+    }
+    catch (error) {
+        console.error(`Failed to initialize RPC: ${String(error)}`);
+        throw error;
+    }
+    finally {
+        rpcPromise = null;
+    }
+};

package/dist/client/rpc/node-rpc-client.d.ts

@@ -0,0 +1,9 @@
+export declare function getRPC(): {
+    request: (command: number) => {
+        send: (data: string, encoding: BufferEncoding) => void;
+        reply: (encoding: BufferEncoding) => Promise<Buffer>;
+        createResponseStream: () => AsyncGenerator<unknown, void, unknown>;
+    };
+};
+export declare const cleanup: () => void;
+//# sourceMappingURL=node-rpc-client.d.ts.map

package/dist/client/rpc/node-rpc-client.js

@@ -0,0 +1,99 @@
+import RPC from "bare-rpc";
+import spawn, {} from "bare-runtime/spawn";
+import { createServer } from "node:net";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+let rpcInstance = null;
+let rpcPromise = null;
+let bareWorkerProc = null;
+// Smart path resolution for worker
+let WORKER_PATH;
+if (__dirname.includes("/dist/") || __dirname.includes("\\dist\\")) {
+    const distRoot = __dirname.includes("/dist/")
+        ? __dirname.split("/dist/")[0] + "/dist"
+        : __dirname.split("\\dist\\")[0] + "\\dist";
+    WORKER_PATH = path.join(distRoot, "server/worker.js");
+}
+else {
+    WORKER_PATH = path.resolve(__dirname, "../../dist/server/worker.js");
+}
+const SOCKET_PATH = process.platform === "win32"
+    ? `\\\\.\\pipe\\qvac-worker-${process.pid}`
+    : path.join(os.tmpdir(), `qvac-worker-${process.pid}.sock`);
+async function ensureRPC() {
+    if (rpcInstance)
+        return rpcInstance;
+    if (rpcPromise)
+        return rpcPromise;
+    rpcPromise = new Promise((resolve, reject) => {
+        const server = createServer((socket) => {
+            rpcInstance = new RPC(socket, () => { });
+            resolve(rpcInstance);
+        });
+        server.on("error", reject);
+        server.listen(SOCKET_PATH, () => {
+            bareWorkerProc = spawn("bare", {
+                args: [
+                    WORKER_PATH,
+                    JSON.stringify({
+                        QVAC_IPC_SOCKET_PATH: SOCKET_PATH,
+                        HOME_DIR: os.homedir(),
+                    }),
+                ],
+                stdio: ["inherit", "inherit", "inherit"],
+            });
+        });
+    });
+    return rpcPromise;
+}
+const mockRPC = {
+    request: (command) => {
+        let sentData = null;
+        return {
+            send: (data, encoding) => {
+                sentData = { data, encoding };
+            },
+            reply: async (encoding) => {
+                if (!sentData) {
+                    throw new Error("Must call send() before reply()");
+                }
+                const rpc = await ensureRPC();
+                const req = rpc.request(command);
+                req.send(sentData.data, sentData.encoding);
+                const response = await req.reply(encoding);
+                return Buffer.isBuffer(response)
+                    ? response
+                    : Buffer.from(typeof response === "string" ? response : "", encoding);
+            },
+            createResponseStream: async function* () {
+                if (!sentData) {
+                    throw new Error("Must call send() before createResponseStream()");
+                }
+                const rpc = await ensureRPC();
+                const req = rpc.request(command);
+                req.send(sentData.data, sentData.encoding);
+                const stream = req.createResponseStream({
+                    encoding: sentData.encoding,
+                });
+                for await (const chunk of stream) {
+                    yield chunk;
+                }
+            },
+        };
+    },
+};
+export function getRPC() {
+    return mockRPC;
+}
+export const cleanup = () => {
+    console.log("🧹 Cleaning up RPC client");
+    if (bareWorkerProc) {
+        console.log("🐻🔫 Killing bare worker process");
+        bareWorkerProc.kill("SIGTERM");
+    }
+};
+// Register cleanup handlers for the parent process
+process.once("exit", cleanup);

package/dist/client/rpc/rpc-client.d.ts

@@ -0,0 +1,5 @@
+import type RPC from "bare-rpc";
+import { type Request, type Response, type RPCOptions } from "../../schemas/index";
+export declare function send<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): Promise<Response>;
+export declare function stream<T extends Request>(request: T, rpc?: RPC, options?: RPCOptions): AsyncGenerator<Response>;
+//# sourceMappingURL=rpc-client.d.ts.map

package/dist/client/rpc/rpc-client.js

@@ -0,0 +1,91 @@
+import { requestSchema, responseSchema, } from "../../schemas/index.js";
+import { RPCError } from "./rpc-error.js";
+import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
+let rpcInstance = null;
+function checkAndThrowError(response) {
+    if (response.type === "error") {
+        throw new RPCError(response);
+    }
+}
+async function getRPC() {
+    if (rpcInstance)
+        return rpcInstance;
+    const isRN = typeof navigator !== "undefined" && navigator.product === "ReactNative";
+    // Detect Bare runtime - Bare exposes global Bare object
+    // TODO we can use something like https://www.npmjs.com/package/which-runtime at some point
+    const isBare = typeof globalThis !== "undefined" && "Bare" in globalThis;
+    // TODO Lots of type unsafe hacks to make this work cross platform
+    if (isRN) {
+        console.log("React Native runtime detected");
+        // Only import expo client for React Native - Metro won't bundle the Node client
+        const expoRPCClientPath = "./expo-rpc-client";
+        const mod = (await import(expoRPCClientPath));
+        rpcInstance = await (typeof mod === "function" ? mod() : mod.getRPC());
+        return rpcInstance;
+    }
+    else if (isBare) {
+        console.log("Bare runtime detected");
+        // Use dynamic import for Bare client
+        const mod = await import("./bare-client.js");
+        rpcInstance = mod.getRPC();
+        return rpcInstance;
+    }
+    else {
+        console.log("Node runtime detected");
+        // Use dynamic import for Node client to prevent Metro from bundling it
+        const mod = await import("./node-rpc-client.js");
+        rpcInstance = mod.getRPC();
+        return rpcInstance;
+    }
+}
+export async function send(request, rpc, options) {
+    const parsedRequest = requestSchema.parse(request);
+    const rpcInstance = rpc || (await getRPC());
+    const req = rpcInstance.request(1);
+    // TODO temp for debugging, find a better solution to exclude large payloads
+    // Log request type and basic info, avoid logging large payloads
+    if (request.type === "transcribeStream") {
+        console.log("RPC Client sending:", {
+            type: request.type,
+            modelId: request.modelId,
+            audioChunkSize: request.audioChunk.length,
+        });
+    }
+    else {
+        console.log("RPC Client sending:", request);
+    }
+    const payload = JSON.stringify(parsedRequest);
+    req.send(payload, "utf-8");
+    const response = await withTimeout(req.reply("utf-8"), options?.timeout);
+    const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
+    console.log("ResPayload", { type: resPayload.type });
+    checkAndThrowError(resPayload);
+    return resPayload;
+}
+export async function* stream(request, rpc, options = {}) {
+    const parsedRequest = requestSchema.parse(request);
+    const rpcInstance = rpc || (await getRPC());
+    const req = rpcInstance.request(1);
+    req.send(JSON.stringify(parsedRequest), "utf-8");
+    const responseStream = req.createResponseStream({ encoding: "utf-8" });
+    let buffer = "";
+    async function* processStream() {
+        for await (const chunk of responseStream) {
+            yield chunk;
+        }
+    }
+    const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
+    for await (const chunk of streamWithTimeout) {
+        buffer += chunk.toString();
+        // Process complete lines (newline-delimited JSON)
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || ""; // Keep incomplete line in buffer
+        for (const line of lines) {
+            if (line.trim()) {
+                const response = responseSchema.parse(JSON.parse(line));
+                checkAndThrowError(response);
+                yield response;
+            }
+        }
+    }
+}

package/dist/client/rpc/rpc-error.d.ts

@@ -0,0 +1,19 @@
+import type { ErrorResponse } from "../../schemas/index";
+export declare class RPCError extends Error {
+    readonly timestamp?: string;
+    readonly remoteStack?: string;
+    readonly code?: number;
+    readonly cause?: unknown;
+    readonly isQvacError: boolean;
+    constructor(errorResponse: ErrorResponse);
+    toJSON(): {
+        name: string;
+        code: number | undefined;
+        message: string;
+        stack: string | undefined;
+        cause: unknown;
+        timestamp: string | undefined;
+        isQvacError: boolean;
+    };
+}
+//# sourceMappingURL=rpc-error.d.ts.map

package/dist/client/rpc/rpc-error.js

@@ -0,0 +1,39 @@
+export class RPCError extends Error {
+    timestamp;
+    remoteStack;
+    code;
+    cause;
+    isQvacError;
+    constructor(errorResponse) {
+        super(errorResponse.message);
+        // If this was originally a QvacError, preserve its structure
+        if (errorResponse.name && errorResponse.code) {
+            this.name = errorResponse.name;
+            this.code = errorResponse.code;
+            this.cause = errorResponse.cause;
+            this.isQvacError = true;
+        }
+        else {
+            this.name = "RPCError";
+            this.isQvacError = false;
+        }
+        if (errorResponse.timestamp) {
+            this.timestamp = errorResponse.timestamp;
+        }
+        if (errorResponse.stack) {
+            this.remoteStack = errorResponse.stack;
+            this.stack = `${this.stack}\n--- Worker Stack ---\n${errorResponse.stack}`;
+        }
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            stack: this.stack,
+            cause: this.cause,
+            timestamp: this.timestamp,
+            isQvacError: this.isQvacError,
+        };
+    }
+}

package/dist/constants/audio.d.ts

@@ -0,0 +1,3 @@
+export declare const FORMATS_NEEDING_DECODE: readonly [".mp3", ".m4a", ".ogg", ".flac", ".aac", ".wav"];
+export declare const SUPPORTED_AUDIO_FORMATS: readonly [".mp3", ".m4a", ".ogg", ".wav", ".flac", ".aac", ".raw"];
+//# sourceMappingURL=audio.d.ts.map

package/dist/constants/audio.js

@@ -0,0 +1,17 @@
+export const FORMATS_NEEDING_DECODE = [
+    ".mp3",
+    ".m4a",
+    ".ogg",
+    ".flac",
+    ".aac",
+    ".wav",
+];
+export const SUPPORTED_AUDIO_FORMATS = [
+    ".mp3",
+    ".m4a",
+    ".ogg",
+    ".wav",
+    ".flac",
+    ".aac",
+    ".raw",
+];

package/dist/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./audio";
+//# sourceMappingURL=index.d.ts.map

package/dist/constants/index.js

@@ -0,0 +1 @@
+export * from "./audio.js";

package/dist/examples/delegated-inference/consumer.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=consumer.d.ts.map

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

@@ -0,0 +1,56 @@
+import { completion, LLAMA_3_2_1B_INST_Q4_0, loadModel } from "@qvac/sdk";
+// Topic hex (required)
+const topicHex = process.argv[2];
+if (!topicHex) {
+    console.error("❌ Topic hex is required. Usage: node consumer.ts <topic-hex> <provider-public-key> [consumer-seed]");
+    process.exit(1);
+}
+// Provider public key (required)
+const providerPublicKey = process.argv[3];
+if (!providerPublicKey) {
+    console.error("❌ Provider public key is required. Usage: node consumer.ts <topic-hex> <provider-public-key> [consumer-seed]");
+    process.exit(1);
+}
+try {
+    // Optional: Consumer seed for deterministic consumer identity (for firewall testing)
+    const consumerSeed = process.argv[4];
+    process.env["QVAC_HYPERSWARM_SEED"] = consumerSeed;
+    console.log(`🚀 Testing delegated inference`);
+    console.log(`📡 Topic: ${topicHex}`);
+    console.log(`🔑 Provider: ${providerPublicKey}`);
+    if (consumerSeed) {
+        console.log(`🔑 Consumer seed: ${consumerSeed.substring(0, 16)}... (deterministic identity)`);
+    }
+    else {
+        console.log(`🎲 No consumer seed provided (random identity)`);
+    }
+    const modelId = await loadModel({
+        modelSrc: LLAMA_3_2_1B_INST_Q4_0,
+        modelType: "llm",
+        delegate: {
+            topic: topicHex,
+            providerPublicKey,
+            timeout: 5_000, // Optional: 5 second timeout for delegated requests
+            fallbackToLocal: true, // Optional: Fall back to local inference if delegation fails
+        },
+        onProgress: (progress) => {
+            console.log(`📊 Download progress: ${progress.percentage.toFixed(1)}% (${progress.downloaded}/${progress.total} bytes)`);
+        },
+    });
+    console.log(`✅ Delegated model registered: ${modelId}`);
+    const response = completion({
+        modelId,
+        history: [{ role: "user", content: "Hello!" }],
+        stream: true,
+    });
+    for await (const token of response.tokenStream) {
+        console.log(`📨 Response: ${token}`);
+    }
+    console.log("🔍 Stats:", await response.stats);
+    console.log("\n🎯 Delegation infrastructure working! Server correctly detected and routed the delegated request.");
+    process.exit(0);
+}
+catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+}

package/dist/examples/delegated-inference/provider.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=provider.d.ts.map

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

@@ -0,0 +1,57 @@
+import { startQVACProvider } from "@qvac/sdk";
+// Random topic if not provided
+const topic = process.argv[2] ||
+    "66646f696865726f6569686a726530776a66646f696865726f6569686a726530";
+// Optional: Seed for deterministic provider identity (64-character hex string)
+const seed = process.argv[3];
+process.env["QVAC_HYPERSWARM_SEED"] = seed;
+// Optional: Consumer public key for firewall (allow only this consumer)
+const allowedConsumerPublicKey = process.argv[4];
+console.log(`🚀 Starting provider service with topic: ${topic}...`);
+try {
+    if (allowedConsumerPublicKey) {
+        console.log(`🔒 Firewall enabled: only allowing consumer ${allowedConsumerPublicKey}`);
+    }
+    // Start the provider service with optional firewall and seed
+    const response = await startQVACProvider({
+        topic,
+        firewall: allowedConsumerPublicKey
+            ? {
+                mode: "allow",
+                publicKeys: [allowedConsumerPublicKey],
+            }
+            : 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(`   📡 Topic (shared): ${topic}`);
+    console.log(`   🆔 Provider Public Key (unique): ${response.publicKey}`);
+    console.log("");
+    console.log("💡 Consumer command:");
+    console.log(`   node consumer.ts ${topic} ${response.publicKey}`);
+    console.log("");
+    console.log("💡 To reproduce this provider identity:");
+    console.log(`   node provider.ts ${topic} ${seed || "<random-seed>"}`);
+    if (!seed) {
+        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 4th argument");
+    console.log(`   4. Run consumer with: node consumer.ts ${topic} ${response.publicKey} <consumer-seed>`);
+    // Keep the process running
+    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:", error);
+    process.exit(1);
+}

package/dist/examples/download-with-cancel.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=download-with-cancel.d.ts.map