@qvac/sdk 0.1.0-dev.1760648187.328e967

package/dist/server/bare/registry/model-registry.d.ts

@@ -0,0 +1,64 @@
+interface AddonInterface {
+    cancel(jobId?: string): Promise<void>;
+}
+export interface AnyModel {
+    load(...args: unknown[]): Promise<void>;
+    run(input: unknown): Promise<{
+        onUpdate(callback: (data: string) => void): {
+            await: () => Promise<void>;
+        };
+        onUpdate(callback: (data: Array<{
+            text: string;
+        }>) => void): {
+            await: () => Promise<void>;
+        };
+        iterate(): AsyncIterableIterator<string | Array<{
+            text: string;
+        }>>;
+        await(): Promise<void>;
+    }>;
+    unload?(): Promise<void>;
+    addon?: AddonInterface;
+}
+interface DelegateOptions {
+    topic: string;
+    providerPublicKey: string;
+    timeout?: number | undefined;
+}
+interface LocalOptions {
+    model: AnyModel;
+    path: string;
+    loadedAt: Date;
+}
+export interface ModelEntry {
+    id: string;
+    isDelegated: boolean;
+    local?: LocalOptions;
+    delegated?: DelegateOptions;
+}
+export declare function registerModel(id: string, options: {
+    model: AnyModel;
+    path: string;
+} | {
+    topic: string;
+    providerPublicKey: string;
+    timeout?: number;
+}): void;
+export declare function getModelEntry(id: string): ModelEntry | null;
+export declare function getModel(id: string): AnyModel;
+export declare function isModelLoaded(id: string): boolean;
+export declare function unregisterModel(id: string): ModelEntry | null;
+export declare function getAllModelIds(): string[];
+export declare function getModelInfo(id: string): {
+    id: string;
+    path: string;
+    loadedAt: Date;
+} | null;
+export declare function clearRegistry(): void;
+export declare function getRegistryStats(): {
+    totalModels: number;
+    modelIds: string[];
+};
+export declare function unloadAllModels(): Promise<void>;
+export {};
+//# sourceMappingURL=model-registry.d.ts.map

package/dist/server/bare/registry/model-registry.js

@@ -0,0 +1,95 @@
+// Global registry state - using stateless functions to manage it
+const modelRegistry = new Map();
+export function registerModel(id, options) {
+    if (modelRegistry.has(id)) {
+        throw new Error(`Model with ID "${id}" is already registered`);
+    }
+    const isDelegated = "topic" in options && "providerPublicKey" in options;
+    if (isDelegated) {
+        const { topic, providerPublicKey, timeout } = options;
+        modelRegistry.set(id, {
+            id,
+            isDelegated: true,
+            delegated: {
+                topic,
+                providerPublicKey,
+                timeout,
+            },
+        });
+        console.log(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
+    }
+    else {
+        modelRegistry.set(id, {
+            id,
+            isDelegated: false,
+            local: {
+                model: options.model,
+                path: options.path,
+                loadedAt: new Date(),
+            },
+        });
+        console.log(`Local model registered: ${id} -> ${options.path}`);
+    }
+}
+export function getModelEntry(id) {
+    return modelRegistry.get(id) || null;
+}
+export function getModel(id) {
+    const entry = modelRegistry.get(id);
+    if (!entry) {
+        const availableIds = Array.from(modelRegistry.keys());
+        throw new Error(`Model with ID "${id}" not found in registry. Available models: ${availableIds.join(", ")}`);
+    }
+    if (!entry.local) {
+        throw new Error(`Model with ID "${id}" is delegated and cannot be accessed as a local model`);
+    }
+    return entry.local.model;
+}
+export function isModelLoaded(id) {
+    return modelRegistry.has(id);
+}
+export function unregisterModel(id) {
+    const entry = modelRegistry.get(id);
+    if (entry) {
+        modelRegistry.delete(id);
+        console.log(`Model unregistered: ${id}`);
+        return entry;
+    }
+    return null;
+}
+export function getAllModelIds() {
+    return Array.from(modelRegistry.keys());
+}
+export function getModelInfo(id) {
+    const entry = modelRegistry.get(id);
+    if (!entry || !entry.local) {
+        return null;
+    }
+    return {
+        id: entry.id,
+        path: entry.local.path,
+        loadedAt: entry.local.loadedAt,
+    };
+}
+export function clearRegistry() {
+    modelRegistry.clear();
+    console.log("Model registry cleared");
+}
+export function getRegistryStats() {
+    return {
+        totalModels: modelRegistry.size,
+        modelIds: Array.from(modelRegistry.keys()),
+    };
+}
+export async function unloadAllModels() {
+    const modelIds = getAllModelIds();
+    for (const modelId of modelIds) {
+        const entry = modelRegistry.get(modelId);
+        if (entry?.local?.model && entry.local.model.unload) {
+            await entry.local.model.unload();
+            console.log(`Model unloaded: ${modelId}`);
+        }
+        modelRegistry.delete(modelId);
+    }
+    console.log(`Unloaded ${modelIds.length} models`);
+}

package/dist/server/error-handlers.d.ts

@@ -0,0 +1,4 @@
+import type RPC from "bare-rpc";
+export declare function sendErrorResponse(req: RPC.IncomingRequest, error: unknown): void;
+export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, error: unknown): void;
+//# sourceMappingURL=error-handlers.d.ts.map

package/dist/server/error-handlers.js

@@ -0,0 +1,27 @@
+import { createErrorResponse, responseSchema } from "../schemas/index.js";
+export function sendErrorResponse(req, error) {
+    try {
+        const errorResponse = createErrorResponse(error);
+        const responseData = JSON.stringify(responseSchema.parse(errorResponse));
+        req.reply(responseData, "utf-8");
+    }
+    catch (responseError) {
+        console.error("Failed to create error response:", responseError);
+        const fallbackError = createErrorResponse(new Error("Internal server error"));
+        req.reply(JSON.stringify(fallbackError), "utf-8");
+    }
+}
+export function sendStreamErrorResponse(stream, error) {
+    try {
+        const errorResponse = createErrorResponse(error);
+        const responseData = JSON.stringify(responseSchema.parse(errorResponse));
+        stream.write(responseData + "\n", "utf-8");
+        stream.end();
+    }
+    catch (responseError) {
+        console.error("Failed to create stream error response:", responseError);
+        const fallbackError = createErrorResponse(new Error("Internal server error"));
+        stream.write(JSON.stringify(fallbackError) + "\n", "utf-8");
+        stream.end();
+    }
+}

package/dist/server/http-server.d.ts

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

package/dist/server/http-server.js

@@ -0,0 +1,189 @@
+// import http from "bare-http1";
+// import process from "bare-process";
+// import { loadModel, completion } from "./handlers/llamacpp";
+// // import { loadWhisperModel, transcribe } from "./whisper.js";
+export {};
+// export type Request = http.HTTPIncomingMessage;
+// export type Response = http.HTTPServerResponse;
+// export type RouteHandler = (
+//   req: Request,
+//   res: Response
+// ) => Promise<void>;
+// // async function transcribeRoute(
+// //   req: http.Request,
+// //   res: http.Response
+// // ): Promise<void> {
+// //   if (req.method !== 'POST') {
+// //     res.statusCode = 405;
+// //     res.setHeader('Content-Type', 'application/json');
+// //     const errorResponse = JSON.stringify({ error: 'Method not allowed' });
+// //     res.setHeader("Content-Length", errorResponse.length);
+// //     res.write(errorResponse);
+// //     res.end();
+// //     return;
+// //   }
+// //   try {
+// //     // Read the request body
+// //     let body = '';
+// //     req.on('data', (chunk) => {
+// //       body += chunk;
+// //     });
+// //     await new Promise((resolve) => {
+// //       req.on('end', resolve);
+// //     });
+// //     // Parse JSON body
+// //     const { audio: b64Audio } = JSON.parse(body);
+// //     if (!b64Audio) {
+// //       res.statusCode = 400;
+// //       res.setHeader('Content-Type', 'application/json');
+// //       const errorResponse = JSON.stringify({ error: 'Missing b64Audio in request body' });
+// //       res.setHeader("Content-Length", errorResponse.length);
+// //       res.write(errorResponse);
+// //       res.end();
+// //       return;
+// //     }
+// //     // Call transcribe function
+// //     const transcription = await transcribe(b64Audio);
+// //     // Return transcription result
+// //     res.statusCode = 200;
+// //     res.setHeader('Content-Type', 'application/json');
+// //     const response = JSON.stringify({ transcription });
+// //     res.setHeader("Content-Length", response.length);
+// //     res.write(response);
+// //     res.end();
+// //   } catch (error) {
+// //     console.error('Transcription error:', error);
+// //     res.statusCode = 500;
+// //     res.setHeader('Content-Type', 'application/json');
+// //     const errorResponse = JSON.stringify({ error: 'Internal server error' });
+// //     res.setHeader("Content-Length", errorResponse.length);
+// //     res.write(errorResponse);
+// //     res.end();
+// //   }
+// // }
+// async function completionRoute(
+//   req: Request,
+//   res: Response
+// ): Promise<void> {
+//   if (req.method !== 'POST') {
+//     res.statusCode = 405;
+//     res.setHeader('Content-Type', 'application/json');
+//     const errorResponse = JSON.stringify({ error: 'Method not allowed' });
+//     res.setHeader("Content-Length", errorResponse.length);
+//     res.write(errorResponse);
+//     res.end();
+//     return;
+//   }
+//   try {
+//     // Read the request body
+//     let body = '';
+//     req.on('data', (chunk) => {
+//       body += chunk;
+//     });
+//     await new Promise((resolve) => {
+//       req.on('end', resolve);
+//     });
+//     // Parse JSON body
+//     const { messages } = JSON.parse(body);
+//     if (!messages || !Array.isArray(messages)) {
+//       res.statusCode = 400;
+//       res.setHeader('Content-Type', 'application/json');
+//       const errorResponse = JSON.stringify({ error: 'Missing or invalid messages in request body' });
+//       res.setHeader("Content-Length", errorResponse.length);
+//       res.write(errorResponse);
+//       res.end();
+//       return;
+//     }
+//     // Call completion function
+//     const response = await completion(messages);
+//     // Return completion result
+//     res.statusCode = 200;
+//     res.setHeader('Content-Type', 'application/json');
+//     const jsonResponse = JSON.stringify({ response });
+//     res.setHeader("Content-Length", jsonResponse.length);
+//     res.write(jsonResponse);
+//     res.end();
+//   } catch (error) {
+//     console.error('Completion error:', error);
+//     res.statusCode = 500;
+//     res.setHeader('Content-Type', 'application/json');
+//     const errorResponse = JSON.stringify({ error: 'Internal server error' });
+//     res.setHeader("Content-Length", errorResponse.length);
+//     res.write(errorResponse);
+//     res.end();
+//   }
+// }
+// export const routes: Record<string, RouteHandler> = {
+//   // '/transcribe': transcribeRoute,
+//   '/completion': completionRoute
+// };
+// export async function handleRequest(
+//   req: Request,
+//   res: Response
+// ): Promise<void> {
+//   // Set CORS headers
+//   res.setHeader('Access-Control-Allow-Origin', '*');
+//   res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+//   res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+//   // Handle preflight requests
+//   if (req.method === 'OPTIONS') {
+//     res.statusCode = 200;
+//     res.end();
+//     return;
+//   }
+//   const url = new URL(req.url!, `http://${req.headers.host}`);
+//   const route = routes[url.pathname];
+//   if (route) {
+//     await route(req, res);
+//   } else {
+//     // Handle 404 for unknown routes
+//     res.statusCode = 404;
+//     res.setHeader('Content-Type', 'application/json');
+//     const errorResponse = JSON.stringify({ error: 'Route not found' });
+//     res.setHeader("Content-Length", errorResponse.length);
+//     res.write(errorResponse);
+//     res.end();
+//   }
+// }
+// async function startServer(port: number = 3000): Promise<void> {
+//   const server = http.createServer(handleRequest);
+//   server.listen(port, () => {
+//     console.log(`HTTP server listening on port ${port}`);
+//   });
+//   // Handle graceful shutdown
+//   process.on('SIGTERM', () => {
+//     console.log('Shutting down HTTP server...');
+//     server.close(() => {
+//       console.log('HTTP server closed');
+//       process.exit(0);
+//     });
+//   });
+//   process.on('SIGINT', () => {
+//     console.log('Shutting down HTTP server...');
+//     server.close(() => {
+//       console.log('HTTP server closed');
+//       process.exit(0);
+//     });
+//   });
+// }
+// // Main application startup
+// async function main() {
+//   console.log("🚀 Starting QVAC Notes server...");
+//   try {
+//     // Load models on startup
+//     console.log("Loading Whisper model...");
+//     // await loadWhisperModel();
+//     console.log("✅ Whisper model loaded");
+//     // Load LLM model (you may want to make this configurable)
+//     console.log("Loading LLM model...");
+//     await loadModel("/Users/marco/.cache/lm-studio/models/lmstudio-community/medgemma-4b-it-GGUF/medgemma-4b-it-Q4_K_M.gguf");
+//     console.log("✅ LLM model loaded");
+//     // Start HTTP server
+//     await startServer();
+//   } catch (error) {
+//     console.error("❌ Failed to start server:", error);
+//     process.exit(1);
+//   }
+// }
+// // Start the server
+// main().catch(console.error);

package/dist/server/rpc/create-server.d.ts

@@ -0,0 +1,4 @@
+import RPC from "bare-rpc";
+export declare function createBareKitRPCServer(): RPC;
+export declare function createIPCClient(socketPath: string): RPC;
+//# sourceMappingURL=create-server.d.ts.map

package/dist/server/rpc/create-server.js

@@ -0,0 +1,19 @@
+import RPC from "bare-rpc";
+import { connect } from "bare-net";
+import { handleRequest } from "./handle-request.js";
+export function createBareKitRPCServer() {
+    const { IPC } = globalThis
+        .BareKit;
+    return new RPC(IPC, handleRequest);
+}
+export function createIPCClient(socketPath) {
+    console.log(`Connecting to IPC socket at ${socketPath}`);
+    const socket = connect(socketPath);
+    socket.on("connect", () => {
+        console.log("Connected to IPC server");
+    });
+    socket.on("error", (err) => {
+        console.error("IPC client connection error:", err);
+    });
+    return new RPC(socket, handleRequest);
+}

package/dist/server/rpc/handle-request.d.ts

@@ -0,0 +1,12 @@
+import type RPC from "bare-rpc";
+export type BareRPCRequest = {
+    data: Buffer;
+    reply: (data: string, encoding: BufferEncoding) => void;
+    createResponseStream: () => {
+        write: (data: string, encoding: BufferEncoding) => void;
+        end: () => void;
+        [Symbol.asyncIterator]?: () => AsyncIterator<Buffer>;
+    };
+};
+export declare function handleRequest(req: RPC.IncomingRequest): Promise<void>;
+//# sourceMappingURL=handle-request.d.ts.map

package/dist/server/rpc/handle-request.js

@@ -0,0 +1,220 @@
+import { requestSchema, responseSchema, } from "../../schemas/index.js";
+import { handleCompletionStream } from "./handlers/completion-stream.js";
+import { handleDownloadAsset } from "./handlers/download-asset.js";
+import { handleLoadModel } from "./handlers/load-model.js";
+import { handleLoadModelDelegated } from "./handlers/load-model-delegated.js";
+import { handleCompletionStreamDelegated } from "./handlers/completion-stream-delegated.js";
+import { getModelEntry } from "../bare/registry/model-registry.js";
+import { handleUnloadModel } from "./handlers/unload-model.js";
+import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
+import { handleEmbed } from "./handlers/embed.js";
+import { handleTranslate } from "./handlers/translate.js";
+import { handleLoggingStream } from "./handlers/logging-stream.js";
+import { cancelHandler } from "./handlers/cancelHandler.js";
+import { provideHandler } from "./handlers/provideHandler.js";
+import { handleRag } from "./handlers/rag.js";
+import { sendErrorResponse, sendStreamErrorResponse } from "../error-handlers";
+export async function handleRequest(req) {
+    try {
+        const rawData = req.data?.toString();
+        if (!rawData) {
+            throw new Error("No data received");
+        }
+        const jsonData = JSON.parse(rawData);
+        const request = requestSchema.parse(jsonData);
+        switch (request.type) {
+            case "downloadAsset": {
+                if (request.withProgress) {
+                    const stream = req.createResponseStream();
+                    try {
+                        const response = await handleDownloadAsset(request, (update) => {
+                            const data = JSON.stringify(responseSchema.parse(update));
+                            stream.write(data + "\n", "utf-8");
+                        });
+                        // Send final response
+                        const data = JSON.stringify(responseSchema.parse(response));
+                        stream.write(data + "\n", "utf-8");
+                        stream.end();
+                    }
+                    catch (error) {
+                        sendStreamErrorResponse(stream, error);
+                    }
+                }
+                else {
+                    try {
+                        const response = await handleDownloadAsset(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
+                }
+                break;
+            }
+            case "loadModel": {
+                if (request.withProgress) {
+                    const stream = req.createResponseStream();
+                    try {
+                        // Route to appropriate handler based on delegation
+                        let response;
+                        if (request.delegate) {
+                            response = await handleLoadModelDelegated(request, (update) => {
+                                const data = JSON.stringify(responseSchema.parse(update));
+                                stream.write(data + "\n", "utf-8");
+                            });
+                        }
+                        else {
+                            response = await handleLoadModel(request, (update) => {
+                                const data = JSON.stringify(responseSchema.parse(update));
+                                stream.write(data + "\n", "utf-8");
+                            });
+                        }
+                        // Send final response
+                        const data = JSON.stringify(responseSchema.parse(response));
+                        stream.write(data + "\n", "utf-8");
+                        stream.end();
+                    }
+                    catch (error) {
+                        sendStreamErrorResponse(stream, error);
+                    }
+                }
+                else {
+                    // Route to appropriate handler based on delegation
+                    try {
+                        const handler = request.delegate
+                            ? handleLoadModelDelegated
+                            : handleLoadModel;
+                        const response = await handler(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
+                }
+                break;
+            }
+            case "completionStream": {
+                const stream = req.createResponseStream();
+                try {
+                    // Check if the model is delegated and route accordingly
+                    const entry = getModelEntry(request.modelId);
+                    const handler = entry?.isDelegated
+                        ? handleCompletionStreamDelegated
+                        : handleCompletionStream;
+                    for await (const response of handler(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                    break;
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
+            case "unloadModel": {
+                const response = await handleUnloadModel(request);
+                req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                break;
+            }
+            case "transcribeStream": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleTranscribeStream(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                    return;
+                }
+                break;
+            }
+            case "loggingStream": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleLoggingStream(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                    return;
+                }
+                break;
+            }
+            case "ping": {
+                const res = {
+                    type: "pong",
+                    number: Math.random() * 100,
+                };
+                req.reply(JSON.stringify(res), "utf-8");
+                break;
+            }
+            case "embed": {
+                try {
+                    const response = await handleEmbed(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "translate": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleTranslate(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
+            case "cancel": {
+                try {
+                    const response = await cancelHandler(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "provide": {
+                const response = await provideHandler(request);
+                req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                break;
+            }
+            case "rag": {
+                try {
+                    const response = await handleRag(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            default: {
+                throw new Error(`Unknown request type`);
+            }
+        }
+    }
+    catch (error) {
+        sendErrorResponse(req, error);
+    }
+}

package/dist/server/rpc/handlers/cancelHandler.d.ts

@@ -0,0 +1,3 @@
+import type { CancelRequest, CancelResponse } from "../../../schemas/cancel";
+export declare function cancelHandler(request: CancelRequest): Promise<CancelResponse>;
+//# sourceMappingURL=cancelHandler.d.ts.map

package/dist/server/rpc/handlers/cancelHandler.js

@@ -0,0 +1,27 @@
+import { cancel } from "../../bare/addons/index.js";
+import { createCancelFunction } from "./load-model/download-manager.js";
+export async function cancelHandler(request) {
+    try {
+        switch (request.operation) {
+            case "inference":
+                await cancel({ modelId: request.modelId });
+                break;
+            case "downloadAsset":
+                const cancelDownload = createCancelFunction(request.downloadKey, request.clearCache);
+                cancelDownload();
+                break;
+        }
+        return {
+            type: "cancel",
+            success: true,
+        };
+    }
+    catch (error) {
+        console.error("Error during cancellation:", error);
+        return {
+            type: "cancel",
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+}