@qvac/sdk 0.8.0 → 1.0.0

package/dist/server/bare/registry/logging-stream-registry.js

@@ -1,132 +1,53 @@
-/**
- * Logging Stream Registry
- *
- * Manages RPC subscriptions for streaming logs from server to connected clients.
- *
- * Purpose:
- * - Registers client subscriptions to model/SDK log streams
- * - Routes log messages to subscribed clients via RPC
- * - Buffers logs during model loading (before client subscribes)
- * - Manages stream lifecycle (subscribe/unsubscribe)
- *
- */
 const loggingStreams = new Map();
-// Buffering for logs emitted during model loading (before client subscribes)
-const MAX_BUFFERED_LOGS_PER_MODEL = 100;
-const BUFFER_EXPIRY_MS = 30_000;
-const BUFFERING_TIMEOUT_MS = 5_000;
-const logBuffer = new Map();
-const modelsWithBuffering = new Set();
-const bufferingTimeouts = new Map();
-function clearBufferingTimeout(id) {
-    const timeout = bufferingTimeouts.get(id);
-    if (timeout) {
-        clearTimeout(timeout);
-        bufferingTimeouts.delete(id);
+export function registerLoggingStream(modelId, streamHandler) {
+    if (!loggingStreams.has(modelId)) {
+        loggingStreams.set(modelId, new Set());
     }
+    loggingStreams.get(modelId).add(streamHandler);
 }
-export function startLogBuffering(id) {
-    modelsWithBuffering.add(id);
-}
-export function stopLogBufferingWithTimeout(id) {
-    clearBufferingTimeout(id);
-    const timeout = setTimeout(() => {
-        if (modelsWithBuffering.has(id)) {
-            modelsWithBuffering.delete(id);
-            logBuffer.delete(id);
-        }
-        bufferingTimeouts.delete(id);
-    }, BUFFERING_TIMEOUT_MS);
-    bufferingTimeouts.set(id, timeout);
-}
-export function registerLoggingStream(id, streamHandler) {
-    if (!loggingStreams.has(id)) {
-        loggingStreams.set(id, new Set());
-    }
-    loggingStreams.get(id).add(streamHandler);
-    const buffered = logBuffer.get(id);
-    if (buffered && buffered.length > 0) {
-        for (const log of buffered) {
-            try {
-                streamHandler(log.level, log.namespace, log.message);
-            }
-            catch (error) {
-                console.error(`Error flushing buffered log for ID ${id}:`, error); // fallback (avoid recursion)
-            }
-        }
-        logBuffer.delete(id);
-    }
-    modelsWithBuffering.delete(id);
-    clearBufferingTimeout(id);
-}
-export function unregisterLoggingStream(id, streamHandler) {
-    const streams = loggingStreams.get(id);
+export function unregisterLoggingStream(modelId, streamHandler) {
+    const streams = loggingStreams.get(modelId);
     if (streams) {
         streams.delete(streamHandler);
         if (streams.size === 0) {
-            loggingStreams.delete(id);
+            loggingStreams.delete(modelId);
         }
     }
 }
-export function unregisterAllLoggingStreams(id) {
-    // Simply remove all logging handlers
+export function unregisterAllLoggingStreams(modelId) {
+    // Simply remove all logging handlers for this model
     // Active streams will naturally terminate when no more logs flow
-    loggingStreams.delete(id);
-    logBuffer.delete(id);
-    modelsWithBuffering.delete(id);
-    clearBufferingTimeout(id);
+    loggingStreams.delete(modelId);
+    console.debug(`Unregistered all logging streams for model ${modelId}`);
 }
-export function sendLogToStreams(id, level, namespace, message) {
-    const streams = loggingStreams.get(id);
-    const isBuffering = modelsWithBuffering.has(id);
-    if (streams && streams.size > 0) {
+export function sendLogToStreams(modelId, level, namespace, message) {
+    const streams = loggingStreams.get(modelId);
+    if (streams) {
         for (const streamHandler of streams) {
             try {
                 streamHandler(level, namespace, message);
             }
             catch (error) {
-                console.error(`Error sending log to stream for ID ${id}:`, error); // fallback (avoid recursion)
+                console.error(`Error sending log to stream for model ${modelId}:`, error);
             }
         }
     }
-    else if (isBuffering) {
-        if (!logBuffer.has(id)) {
-            logBuffer.set(id, []);
-        }
-        const buffer = logBuffer.get(id);
-        const now = Date.now();
-        const validLogs = buffer.filter((log) => now - log.timestamp < BUFFER_EXPIRY_MS);
-        if (validLogs.length >= MAX_BUFFERED_LOGS_PER_MODEL) {
-            validLogs.shift();
-        }
-        validLogs.push({ level, namespace, message, timestamp: now });
-        logBuffer.set(id, validLogs);
-    }
 }
-export function hasLoggingStreams(id) {
-    const streams = loggingStreams.get(id);
+export function hasLoggingStreams(modelId) {
+    const streams = loggingStreams.get(modelId);
     return streams && streams.size > 0;
 }
 export function getLoggingStreamStats() {
     return {
-        totalIds: loggingStreams.size,
-        ids: Array.from(loggingStreams.keys()),
+        totalModels: loggingStreams.size,
+        modelIds: Array.from(loggingStreams.keys()),
         totalStreams: Array.from(loggingStreams.values()).reduce((sum, streams) => sum + streams.size, 0),
-        bufferedIds: logBuffer.size,
-        idsWithBuffering: modelsWithBuffering.size,
-        activeTimeouts: bufferingTimeouts.size,
     };
 }
 export function clearAllLoggingStreams() {
     const count = loggingStreams.size;
-    for (const timeout of bufferingTimeouts.values()) {
-        clearTimeout(timeout);
-    }
     loggingStreams.clear();
-    logBuffer.clear();
-    modelsWithBuffering.clear();
-    bufferingTimeouts.clear();
     if (count > 0) {
-        console.log(`🧹 Cleared logging streams for ${count} ID(s)`); // fallback (avoid recursion)
+        console.log(`🧹 Cleared logging streams for ${count} model(s)`);
     }
 }

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

@@ -1,13 +1,33 @@
-import type FilesystemDL from "@qvac/dl-filesystem";
-import type { CanonicalModelType } from "../../../schemas/index";
-import type BaseInference from "@qvac/infer-base";
+import type EventEmitter from "events";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
-export type AnyModel = Omit<BaseInference, "addon"> & {
-    reload?(config: unknown): Promise<void>;
+export interface AnyModel {
+    load(...args: unknown[]): Promise<void>;
+    run(input: unknown): Promise<EventEmitter & {
+        onUpdate(callback: (data: string) => void): {
+            await: () => Promise<void>;
+        };
+        onUpdate(callback: (data: {
+            outputArray: Int16Array;
+        }) => void): {
+            await: () => Promise<void>;
+        };
+        onError(callback: (error: Error) => void): void;
+        onUpdate(callback: (data: Array<{
+            text: string;
+        }>) => void): {
+            await: () => Promise<void>;
+        };
+        cancel(): Promise<void>;
+        iterate(): AsyncIterableIterator<string | Array<{
+            text: string;
+        }>>;
+        await(): Promise<void>;
+    }>;
+    unload?(): Promise<void>;
     addon?: AddonInterface;
-};
+}
 interface DelegateOptions {
     topic: string;
     providerPublicKey: string;
@@ -18,9 +38,6 @@ interface LocalOptions {
     path: string;
     loadedAt: Date;
     config: unknown;
-    modelType: CanonicalModelType;
-    name?: string | undefined;
-    loader: FilesystemDL;
 }
 export interface ModelEntry {
     id: string;
@@ -32,9 +49,6 @@ export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
-    modelType: CanonicalModelType;
-    loader: FilesystemDL;
-    name?: string | undefined;
 } | {
     topic: string;
     providerPublicKey: string;
@@ -50,10 +64,8 @@ export declare function getModelInfo(id: string): {
     path: string;
     loadedAt: Date;
     config: unknown;
-    name?: string;
 } | null;
 export declare function getModelConfig(id: string): unknown;
-export declare function updateModelConfig(id: string, config: unknown): void;
 export declare function clearRegistry(): void;
 export declare function getRegistryStats(): {
     totalModels: number;

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

@@ -1,11 +1,8 @@
-import { ModelAlreadyRegisteredError, ModelNotFoundError, ModelIsDelegatedError, } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
 // Global registry state - using stateless functions to manage it
 const modelRegistry = new Map();
 export function registerModel(id, options) {
     if (modelRegistry.has(id)) {
-        throw new ModelAlreadyRegisteredError(id);
+        throw new Error(`Model with ID "${id}" is already registered`);
     }
     const isDelegated = "topic" in options && "providerPublicKey" in options;
     if (isDelegated) {
@@ -19,7 +16,7 @@ export function registerModel(id, options) {
                 timeout,
             },
         });
-        logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
+        console.log(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
     }
     else {
         modelRegistry.set(id, {
@@ -30,13 +27,9 @@ export function registerModel(id, options) {
                 path: options.path,
                 loadedAt: new Date(),
                 config: options.config,
-                modelType: options.modelType,
-                loader: options.loader,
-                name: options.name,
             },
         });
-        const nameStr = options.name ? ` (${options.name})` : "";
-        logger.info(`Local model registered: ${id}${nameStr} -> ${options.path}`);
+        console.log(`Local model registered: ${id} -> ${options.path}`);
     }
 }
 export function getModelEntry(id) {
@@ -45,10 +38,11 @@ export function getModelEntry(id) {
 export function getModel(id) {
     const entry = modelRegistry.get(id);
     if (!entry) {
-        throw new ModelNotFoundError(id);
+        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 ModelIsDelegatedError(id);
+        throw new Error(`Model with ID "${id}" is delegated and cannot be accessed as a local model`);
     }
     return entry.local.model;
 }
@@ -59,7 +53,7 @@ export function unregisterModel(id) {
     const entry = modelRegistry.get(id);
     if (entry) {
         modelRegistry.delete(id);
-        logger.debug(`Model unregistered: ${id}`);
+        console.log(`Model unregistered: ${id}`);
         return entry;
     }
     return null;
@@ -72,37 +66,23 @@ export function getModelInfo(id) {
     if (!entry || !entry.local) {
         return null;
     }
-    const result = {
+    return {
         id: entry.id,
         path: entry.local.path,
         loadedAt: entry.local.loadedAt,
         config: entry.local.config,
     };
-    if (entry.local.name) {
-        result.name = entry.local.name;
-    }
-    return result;
 }
 export function getModelConfig(id) {
     const entry = modelRegistry.get(id);
     if (!entry || !entry.local) {
-        throw new ModelNotFoundError(id);
+        throw new Error(`Model with ID "${id}" not found or is delegated`);
     }
     return entry.local.config;
 }
-export function updateModelConfig(id, config) {
-    const entry = modelRegistry.get(id);
-    if (!entry) {
-        throw new ModelNotFoundError(id);
-    }
-    if (!entry.local) {
-        throw new ModelIsDelegatedError(id);
-    }
-    entry.local.config = config;
-}
 export function clearRegistry() {
     modelRegistry.clear();
-    logger.info("Model registry cleared");
+    console.log("Model registry cleared");
 }
 export function getRegistryStats() {
     return {
@@ -116,9 +96,9 @@ export async function unloadAllModels() {
         const entry = modelRegistry.get(modelId);
         if (entry?.local?.model && entry.local.model.unload) {
             await entry.local.model.unload();
-            logger.debug(`Model unloaded: ${modelId}`);
+            console.log(`Model unloaded: ${modelId}`);
         }
         modelRegistry.delete(modelId);
     }
-    logger.info(`Unloaded ${modelIds.length} models`);
+    console.log(`Unloaded ${modelIds.length} models`);
 }

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

@@ -1,5 +1,4 @@
 import type RPC from "bare-rpc";
-import { type ServerProfiler } from "./rpc/profiling/index";
-export declare function sendErrorResponse(req: RPC.IncomingRequest, error: unknown, profiler?: ServerProfiler): void;
-export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, error: unknown, profiler?: ServerProfiler): void;
+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

@@ -1,30 +1,25 @@
 import { createErrorResponse, responseSchema } from "../schemas/index.js";
-import { getServerLogger } from "../logging/index.js";
-import {} from "./rpc/profiling/index.js";
-const logger = getServerLogger();
-function buildErrorResponseData(error, profiler) {
-    const errorResponse = createErrorResponse(error);
-    const validated = responseSchema.parse(errorResponse);
-    const json = JSON.stringify(validated);
-    return profiler ? profiler.serializeError(json) : json;
-}
-export function sendErrorResponse(req, error, profiler) {
+export function sendErrorResponse(req, error) {
     try {
-        req.reply(buildErrorResponseData(error, profiler), "utf-8");
+        const errorResponse = createErrorResponse(error);
+        const responseData = JSON.stringify(responseSchema.parse(errorResponse));
+        req.reply(responseData, "utf-8");
     }
     catch (responseError) {
-        logger.error("Failed to create error response:", 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, profiler) {
+export function sendStreamErrorResponse(stream, error) {
     try {
-        stream.write(buildErrorResponseData(error, profiler) + "\n", "utf-8");
+        const errorResponse = createErrorResponse(error);
+        const responseData = JSON.stringify(responseSchema.parse(errorResponse));
+        stream.write(responseData + "\n", "utf-8");
         stream.end();
     }
     catch (responseError) {
-        logger.error("Failed to create stream error response:", 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.js

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

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

@@ -1,3 +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