@qvac/sdk 0.8.1 → 1.0.0

package/dist/client/api/translate.js

@@ -1,7 +1,6 @@
 import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { translateResponseSchema, normalizeModelType, ModelType, } from "../../schemas/index.js";
+import { translateResponseSchema, } from "../../schemas/index.js";
 import { detectOne } from "@qvac/langdetect-text";
-import { TranslationFailedError } from "../../utils/errors-client.js";
 /**
  * Translates text from one language to another using a specified translation model.
  * Supports both NMT (Neural Machine Translation) and LLM models.
@@ -13,7 +12,7 @@ import { TranslationFailedError } from "../../utils/errors-client.js";
  * @param params.to - Target language code
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true.
  * @returns Object with tokenStream generator and text/stats properties
- * @throws {QvacErrorBase} When translation fails with an error message or when language detection fails
+ * @throws {Error} When translation fails with an error message or when language detection fails
  * @example
  * ```typescript
  * // Streaming mode (default)
@@ -42,21 +41,22 @@ import { TranslationFailedError } from "../../utils/errors-client.js";
  * console.log(await response.text);
  * ```
  */
-export function translate(params, options) {
-    const canonicalModelType = normalizeModelType(params.modelType);
-    const isLlm = canonicalModelType === ModelType.llamacppCompletion;
-    let sourceLanguage = isLlm ? params.from : undefined;
-    if (!sourceLanguage && isLlm) {
-        const detected = detectOne(params.text);
-        if (detected.code === "und" || detected.language === "Undetermined") {
-            throw new TranslationFailedError("Could not detect the source language. Please specify the 'from' parameter explicitly.");
+export function translate(params) {
+    let sourceLanguage = params.modelType === "llm" ? params.from : undefined;
+    if (!sourceLanguage) {
+        const modelType = params.modelType;
+        if (modelType === "llm") {
+            const detected = detectOne(params.text);
+            if (detected.code === "und" || detected.language === "Undetermined") {
+                throw new Error("Could not detect the source language. Please specify the 'from' parameter explicitly.");
+            }
+            sourceLanguage = detected.language;
         }
-        sourceLanguage = detected.language;
     }
     const request = {
         type: "translate",
         ...params,
-        ...(isLlm && {
+        ...(params.modelType === "llm" && {
             from: sourceLanguage,
         }),
     };
@@ -67,7 +67,7 @@ export function translate(params, options) {
     });
     if (params.stream) {
         const tokenStream = (async function* () {
-            for await (const response of streamRpc(request, options)) {
+            for await (const response of streamRpc(request)) {
                 if (response.type === "translate") {
                     const streamResponse = translateResponseSchema.parse(response);
                     if (!streamResponse.done) {
@@ -93,7 +93,7 @@ export function translate(params, options) {
         })();
         const textPromise = (async () => {
             let buffer = "";
-            for await (const response of streamRpc(request, options)) {
+            for await (const response of streamRpc(request)) {
                 if (response.type === "translate") {
                     const streamResponse = translateResponseSchema.parse(response);
                     buffer += streamResponse.token;

package/dist/client/api/unload-model.d.ts

@@ -2,14 +2,10 @@ import { type UnloadModelParams } from "../../schemas/index";
 /**
  * Unloads a previously loaded model from the server.
  *
- * When the last model is unloaded (no more models remain), this function
- * automatically closes the RPC connection, allowing the process to exit
- * naturally without requiring manual cleanup.
- *
  * @param params - The parameters for unloading the model
  * @param params.modelId - The unique identifier of the model to unload
  * @param params.clearStorage - Whether to clear the storage for the model
- * @throws {QvacErrorBase} When the response type is invalid or when the unload operation fails
+ * @throws {Error} When the response type is invalid or when the unload operation fails
  */
 export declare function unloadModel(params: UnloadModelParams): Promise<void>;
 //# sourceMappingURL=unload-model.d.ts.map

package/dist/client/api/unload-model.js

@@ -1,20 +1,13 @@
 import {} from "../../schemas/index.js";
-import { send, close } from "../rpc/rpc-client.js";
+import { send } from "../rpc/rpc-client.js";
 import { stopLoggingStreamForModel } from "../logging-stream-registry.js";
-import { InvalidResponseError, ModelUnloadFailedError, } from "../../utils/errors-client.js";
-import { getClientLogger } from "../../logging/index.js";
-const logger = getClientLogger();
 /**
  * Unloads a previously loaded model from the server.
  *
- * When the last model is unloaded (no more models remain), this function
- * automatically closes the RPC connection, allowing the process to exit
- * naturally without requiring manual cleanup.
- *
  * @param params - The parameters for unloading the model
  * @param params.modelId - The unique identifier of the model to unload
  * @param params.clearStorage - Whether to clear the storage for the model
- * @throws {QvacErrorBase} When the response type is invalid or when the unload operation fails
+ * @throws {Error} When the response type is invalid or when the unload operation fails
  */
 export async function unloadModel(params) {
     const request = {
@@ -24,16 +17,10 @@ export async function unloadModel(params) {
     };
     const response = await send(request);
     if (response.type !== "unloadModel") {
-        throw new InvalidResponseError("unloadModel");
+        throw new Error("Invalid response type");
     }
     if (!response.success) {
-        throw new ModelUnloadFailedError(params.modelId);
+        throw new Error("Failed to unload model");
     }
     stopLoggingStreamForModel(params.modelId);
-    // Auto-close when no models remain AND no providers are active
-    if (response.hasActiveModels === false &&
-        response.hasActiveProviders === false) {
-        logger.info("🧹 No models or providers active, automatically closing RPC connection...");
-        await close();
-    }
 }

package/dist/client/index.d.ts

@@ -1,2 +1,2 @@
-export { send, stream, close } from "./rpc/rpc-client";
+export { send, stream } from "./rpc/rpc-client";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/index.js

@@ -1 +1 @@
-export { send, stream, close } from "./rpc/rpc-client.js";
+export { send, stream } from "./rpc/rpc-client.js";

package/dist/client/logging-stream-registry.d.ts

@@ -1,5 +1,5 @@
 import { type Logger } from "../logging/index";
-export declare function startLoggingStreamForModel(modelId: string, modelLogger: Logger): void;
+export declare function startLoggingStreamForModel(modelId: string, logger: Logger): void;
 export declare function stopLoggingStreamForModel(modelId: string): void;
 export declare function hasActiveStreamForModel(modelId: string): boolean;
 //# sourceMappingURL=logging-stream-registry.d.ts.map

package/dist/client/logging-stream-registry.js

@@ -1,14 +1,13 @@
-import { getClientLogger } from "../logging/index.js";
+import {} from "../logging/index.js";
 import { loggingStream } from "./api/logging-stream.js";
-const logger = getClientLogger();
 const activeStreams = new Map();
-export function startLoggingStreamForModel(modelId, modelLogger) {
+export function startLoggingStreamForModel(modelId, logger) {
     if (activeStreams.has(modelId)) {
-        logger.warn(`Logging stream already active for model ${modelId}`);
+        console.warn(`Logging stream already active for model ${modelId}`);
         return;
     }
-    const streamIterator = loggingStream({ id: modelId });
-    activeStreams.set(modelId, { logger: modelLogger, streamIterator });
+    const streamIterator = loggingStream({ modelId });
+    activeStreams.set(modelId, { logger, streamIterator });
     try {
         void (async () => {
             try {
@@ -16,24 +15,24 @@ export function startLoggingStreamForModel(modelId, modelLogger) {
                     const logLevel = logMessage.level;
                     switch (logLevel) {
                         case "error":
-                            modelLogger.error(`[${logMessage.namespace}]`, logMessage.message);
+                            logger.error(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "warn":
-                            modelLogger.warn(`[${logMessage.namespace}]`, logMessage.message);
+                            logger.warn(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "info":
-                            modelLogger.info(`[${logMessage.namespace}]`, logMessage.message);
+                            logger.info(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "debug":
-                            modelLogger.debug(`[${logMessage.namespace}]`, logMessage.message);
+                            logger.debug(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         default:
-                            modelLogger.info(`[${logMessage.namespace}]`, logMessage.message);
+                            logger.info(`[${logMessage.namespace}]`, logMessage.message);
                     }
                 }
             }
             catch (error) {
-                logger.error(`Logging stream error for model ${modelId}:`, error);
+                console.error(`Logging stream error for model ${modelId}:`, error);
             }
             finally {
                 activeStreams.delete(modelId);
@@ -41,7 +40,7 @@ export function startLoggingStreamForModel(modelId, modelLogger) {
         })();
     }
     catch (error) {
-        logger.error(`Failed to start logging stream for model ${modelId}:`, error);
+        console.error(`Failed to start logging stream for model ${modelId}:`, error);
         activeStreams.delete(modelId);
         throw error;
     }
@@ -53,7 +52,7 @@ export function stopLoggingStreamForModel(modelId) {
         // Terminate the stream iterator - this will close the RPC connection
         // and the server-side async generator will automatically terminate
         void stream.streamIterator.return(undefined);
-        logger.debug(`Stopped logging stream for model ${modelId}`);
+        console.debug(`Stopped logging stream for model ${modelId}`);
     }
 }
 export function hasActiveStreamForModel(modelId) {

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

@@ -1,11 +1,147 @@
 import type { Request, Response } from "../../schemas/index";
 export declare function send<T extends Request>(request: T): Promise<Response>;
-export declare function getRPC(): Promise<{
+export declare function stream<T extends Request>(request: T): AsyncGenerator<{
+    type: "cancel";
+    success: boolean;
+    error?: string | undefined;
+} | {
+    type: "completionStream";
+    token: string;
+    done?: boolean | undefined;
+    stats?: {
+        timeToFirstToken: number;
+        tokensPerSecond: number;
+        cacheTokens: number;
+    } | undefined;
+    toolCallEvent?: {
+        type: "toolCall";
+        call: {
+            id: string;
+            name: string;
+            arguments: Record<string, unknown>;
+            raw?: string | undefined;
+        };
+    } | {
+        type: "toolCallError";
+        error: {
+            code: "PARSE_ERROR" | "VALIDATION_ERROR" | "UNKNOWN_TOOL";
+            message: string;
+            raw?: string | undefined;
+        };
+    } | undefined;
+    toolCalls?: {
+        id: string;
+        name: string;
+        arguments: Record<string, unknown>;
+        raw?: string | undefined;
+    }[] | undefined;
+    error?: string | undefined;
+} | {
+    type: "deleteCache";
+    success: boolean;
+    error?: string | undefined;
+} | {
+    type: "textToSpeech";
+    buffer: number[];
+    done: boolean;
+} | {
+    type: "modelProgress";
+    downloaded: number;
+    total: number;
+    percentage: number;
+    downloadKey: string;
+} | {
+    type: "loadModel";
+    success: boolean;
+    modelId?: string | undefined;
+    error?: string | undefined;
+} | {
+    type: "downloadAsset";
+    success: boolean;
+    assetId?: string | undefined;
+    error?: string | undefined;
+} | {
+    type: "embed";
+    success: boolean;
+    embedding: number[];
+    error?: string | undefined;
+} | {
+    type: "loggingStream";
+    modelId: string;
+    level: "error" | "warn" | "info" | "debug" | "off";
+    namespace: string;
+    message: string;
+    timestamp: number;
+} | {
+    type: "provide";
+    success: boolean;
+    error?: string | undefined;
+    publicKey?: string | undefined;
+} | {
+    type: "stopProvide";
+    success: boolean;
+    error?: string | undefined;
+} | {
+    type: "unloadModel";
+    success: boolean;
+    error?: string | undefined;
+} | {
+    type: "pong";
+    number: number;
+} | {
+    type: "transcribeStream";
+    text?: string | undefined;
+    done?: boolean | undefined;
+    error?: string | undefined;
+} | {
+    type: "translate";
+    token: string;
+    done?: boolean | undefined;
+    stats?: {
+        processedTokens: number;
+        processingTime: number;
+    } | undefined;
+    error?: string | undefined;
+} | {
+    type: "error";
+    message: string;
+    stack?: string | undefined;
+    timestamp?: string | undefined;
+    name?: string | undefined;
+    code?: number | undefined;
+    cause?: unknown;
+} | {
+    type: "rag";
+    success: boolean;
+    operation: "saveEmbeddings";
+    processed: {
+        status: "fulfilled" | "rejected";
+        id?: string | undefined;
+        error?: string | undefined;
+    }[];
+    droppedIndices: number[];
+    error?: string | undefined;
+} | {
+    type: "rag";
+    success: boolean;
+    operation: "search";
+    results: {
+        id: string;
+        content: string;
+        score: number;
+    }[];
+    error?: string | undefined;
+} | {
+    type: "rag";
+    success: boolean;
+    operation: "deleteEmbeddings";
+    error?: string | undefined;
+}, void, any>;
+export declare function getRPC(): {
     request(): {
         send(payload: string): void;
         reply(): Promise<Buffer<ArrayBuffer>>;
         createResponseStream(): AsyncGenerator<Buffer<ArrayBuffer>, void, unknown>;
     };
-}>;
-export declare function close(): void;
+};
 //# sourceMappingURL=bare-client.d.ts.map

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

@@ -1,93 +1,31 @@
-import { normalizeModelType } from "../../schemas/index.js";
-import os from "bare-os";
 import { handlers } from "../../server/rpc/handlers/index.js";
-import { PearWorkerEntryRequiredError, RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.js";
-import { initializeConfig } from "../init-hooks.js";
-import { setSDKConfig } from "../../server/bare/registry/config-registry.js";
-import { setRuntimeContext } from "../../server/bare/registry/runtime-context-registry.js";
-import { resolveModelConfig } from "../../server/bare/registry/model-config-registry.js";
-import { resolveConfig } from "../config-loader/resolve-config.bare.js";
-import { getClientLogger } from "../../logging/index.js";
-import { getAllPlugins } from "../../server/plugins/index.js";
-import { initializeWorkerCore } from "../../server/worker-core.js";
-const logger = getClientLogger();
-/**
- * Load worker entry to register plugins before any SDK calls.
- *
- * If plugins are already registered (e.g., by a Pear worker bootstrap),
- * skip loading the default worker but still initialize worker core.
- *
- * NOTE: For Pear apps, the fallback (loading default worker) cannot work.
- *
- * The default worker is intentionally excluded from `pear stage --compact`
- * to enable tree-shaking of unused built-in plugins. When a Pear app tries
- * to dynamically import it at runtime, the path resolves to a pear:// URL.
- * The default worker imports built-in plugins, which load native addons
- * (.bare files). Native addons cannot be loaded from pear:// URLs, causing
- * UNSUPPORTED_PROTOCOL errors.
- *
- * Instead, we detect Pear runtime and throw a clear error directing users
- * to use the generated worker entry (qvac/worker.pear.entry.mjs).
- *
- * The fallback only works in non-Pear environments.
- */
-async function loadWorkerEntry() {
-    initializeWorkerCore();
-    if (getAllPlugins().length > 0) {
-        logger.info("📦 Plugins already registered, worker core initialized");
-        return;
-    }
-    const { isPear } = await import("which-runtime");
-    if (isPear) {
-        throw new PearWorkerEntryRequiredError("qvac/worker.pear.entry.mjs");
-    }
-    // Fallback: load default worker (all built-in plugins)
-    logger.info("📦 Loading default worker (all built-in plugins)");
-    const workerPath = "../../server/" + "worker.js";
-    await import(workerPath);
-}
-let workerEntryLoaded = false;
 // Get the handler for a request type
-function getHandler(type) {
+const getHandler = (type) => {
     const handler = handlers[type];
     return typeof handler === "function" ? handler : undefined;
-}
-function applyDeviceDefaultsToLoadModel(request) {
-    if (request.type !== "loadModel" || !("modelSrc" in request)) {
-        return request;
-    }
-    let canonicalType;
-    try {
-        canonicalType = normalizeModelType(request.modelType);
-    }
-    catch {
-        return request;
-    }
-    const rawConfig = request.modelConfig ?? {};
-    const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
-    return { ...request, modelConfig: configWithDefaults };
-}
+};
 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 RPCNoHandlerError(request.type);
-    const processedRequest = applyDeviceDefaultsToLoadModel(request);
-    return (await handler(processedRequest));
+        throw new Error(`No handler function for ${request.type}`);
+    return (await handler(request));
 }
-async function* stream(request) {
+export async function* stream(request) {
     const handler = getHandler(request.type);
     if (!handler)
-        throw new RPCNoHandlerError(request.type);
+        throw new Error(`No handler function for ${request.type}`);
     // Special handling for loadModel with progress
     if (request.type === "loadModel" &&
         "withProgress" in request &&
         request.withProgress) {
-        const processedRequest = applyDeviceDefaultsToLoadModel(request);
         async function* streamWithProgress() {
             const queue = [];
             let done = false;
             const loadModelHandler = handler;
-            loadModelHandler(processedRequest, (update) => queue.push(update))
+            loadModelHandler(request, (update) => queue.push(update))
                 .then((final) => {
                 queue.push(final);
                 done = true;
@@ -147,7 +85,7 @@ async function* stream(request) {
         }
     }
 }
-function createMockRPCRequest() {
+const createMockRPCRequest = () => {
     let requestData = null;
     return {
         send(payload) {
@@ -156,64 +94,25 @@ function createMockRPCRequest() {
         },
         async reply() {
             if (!requestData) {
-                throw new RPCRequestNotSentError();
-            }
-            // Handle special internal config initialization message
-            if (typeof requestData === "object" &&
-                "type" in requestData &&
-                requestData.type === "__init_config") {
-                try {
-                    const initData = requestData;
-                    if (initData.config) {
-                        setSDKConfig(initData.config);
-                    }
-                    if (initData.runtimeContext) {
-                        setRuntimeContext(initData.runtimeContext);
-                    }
-                    return Buffer.from(JSON.stringify({ success: true }));
-                }
-                catch (error) {
-                    return Buffer.from(JSON.stringify({
-                        success: false,
-                        error: error instanceof Error ? error.message : String(error),
-                    }));
-                }
+                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 RPCRequestNotSentError();
+                throw new Error("No request data - call send() first");
             }
             for await (const response of stream(requestData)) {
                 yield Buffer.from(JSON.stringify(response) + "\n");
             }
         },
     };
-}
-let configInitialized = false;
-export async function getRPC() {
-    if (!workerEntryLoaded) {
-        await loadWorkerEntry();
-        workerEntryLoaded = true;
-    }
-    const mockRPC = {
+};
+export function getRPC() {
+    return {
         request() {
             return createMockRPCRequest();
         },
     };
-    // Initialize config once on first call
-    if (!configInitialized) {
-        const runtimeContext = {
-            runtime: "bare",
-            platform: os.platform(),
-        };
-        await initializeConfig(mockRPC, resolveConfig, runtimeContext);
-        configInitialized = true;
-    }
-    return mockRPC;
-}
-export function close() {
-    // noop
 }

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

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