@qvac/sdk 0.4.1 → 0.6.0

package/dist/client/config-loader/resolve-config.expo.js

@@ -0,0 +1,62 @@
+/**
+ * Config loader for Expo/React Native runtime
+ * Only uses expo-file-system - no Node.js or Bare imports
+ */
+import { File, Paths } from "expo-file-system";
+import { validateConfig, parseJsonConfig, } from "./config-utils.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
+function fileExists(filePath) {
+    try {
+        const file = new File(filePath);
+        return file.exists;
+    }
+    catch {
+        return false;
+    }
+}
+async function readFile(filePath) {
+    const file = new File(filePath);
+    return await file.text();
+}
+async function loadJsonConfig(filePath) {
+    const content = await readFile(filePath);
+    const parsed = parseJsonConfig(content, filePath);
+    return validateConfig(parsed);
+}
+/**
+ * Resolution order for Expo:
+ * 1. QVAC_CONFIG_PATH environment variable (if set)
+ * 2. Default Expo path: ${Paths.document.uri}qvac.config.json
+ * 3. SDK defaults
+ *
+ * Note: Only JSON config files are supported in React Native
+ */
+export async function resolveConfig() {
+    // Check environment variable first
+    const configPath = typeof process !== "undefined"
+        ? process.env?.["QVAC_CONFIG_PATH"]
+        : undefined;
+    if (configPath) {
+        if (fileExists(configPath)) {
+            logger.info(`✅ Loaded config from: ${configPath}`);
+            return await loadJsonConfig(configPath);
+        }
+    }
+    // Try default Expo document directory path
+    try {
+        const documentDir = Paths.document.uri;
+        if (documentDir) {
+            const defaultExpoConfigPath = `${documentDir}qvac.config.json`;
+            if (fileExists(defaultExpoConfigPath)) {
+                logger.info(`✅ Loaded config from: ${defaultExpoConfigPath}`);
+                return await loadJsonConfig(defaultExpoConfigPath);
+            }
+        }
+    }
+    catch {
+        // Paths not available
+    }
+    logger.info("ℹ️ No config file found, using SDK defaults");
+    return undefined;
+}

package/dist/client/config-loader/resolve-config.node.d.ts

@@ -0,0 +1,9 @@
+import { type QvacConfig } from "./config-utils";
+/**
+ * Resolution order for Node.js:
+ * 1. QVAC_CONFIG_PATH environment variable
+ * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 3. SDK defaults
+ */
+export declare function resolveConfig(): Promise<QvacConfig | undefined>;
+//# sourceMappingURL=resolve-config.node.d.ts.map

package/dist/client/config-loader/resolve-config.node.js

@@ -0,0 +1,118 @@
+/**
+ * Config loader for Node.js runtime
+ * Uses Node.js fs/promises and path modules
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import { pathToFileURL } from "url";
+import { validateConfig, parseJsonConfig, } from "./config-utils.js";
+import { ConfigFileParseFailedError } from "../../utils/errors-client.js";
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
+async function findProjectRoot() {
+    try {
+        let currentDir = path.resolve(process.cwd());
+        const root = path.parse(currentDir).root;
+        while (currentDir !== root) {
+            try {
+                const packageJsonPath = path.join(currentDir, "package.json");
+                await fs.access(packageJsonPath);
+                return currentDir;
+            }
+            catch {
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir) {
+                    break;
+                }
+                currentDir = parentDir;
+            }
+        }
+    }
+    catch {
+        // Fall through
+    }
+    return process.cwd();
+}
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readFile(filePath) {
+    return await fs.readFile(filePath, { encoding: "utf-8" });
+}
+async function loadJsonConfig(filePath) {
+    const content = await readFile(filePath);
+    const parsed = parseJsonConfig(content, filePath);
+    return validateConfig(parsed);
+}
+async function loadJsConfig(filePath) {
+    try {
+        let importPath = filePath;
+        // Windows requires file:// URLs for dynamic imports
+        if (process.platform === "win32" && !process.env["JEST_WORKER_ID"]) {
+            importPath = pathToFileURL(filePath).toString();
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const configModule = await import(importPath);
+        return validateConfig(configModule.default || configModule);
+    }
+    catch (error) {
+        throw new ConfigFileParseFailedError(filePath, error instanceof Error ? error.message : String(error), error);
+    }
+}
+async function findConfigFile(searchDir) {
+    const configFiles = [
+        { name: "qvac.config.ts", type: "ts" },
+        { name: "qvac.config.js", type: "js" },
+        { name: "qvac.config.json", type: "json" },
+    ];
+    for (const { name, type } of configFiles) {
+        const filePath = path.resolve(searchDir, name);
+        if (await fileExists(filePath)) {
+            return { path: filePath, type };
+        }
+    }
+    return undefined;
+}
+/**
+ * Resolution order for Node.js:
+ * 1. QVAC_CONFIG_PATH environment variable
+ * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 3. SDK defaults
+ */
+export async function resolveConfig() {
+    const configPath = process.env["QVAC_CONFIG_PATH"];
+    if (configPath) {
+        const normalizedPath = path.resolve(configPath);
+        if (await fileExists(normalizedPath)) {
+            const ext = normalizedPath.endsWith(".json")
+                ? "json"
+                : normalizedPath.endsWith(".ts")
+                    ? "ts"
+                    : "js";
+            const config = ext === "json"
+                ? await loadJsonConfig(normalizedPath)
+                : await loadJsConfig(normalizedPath);
+            logger.info(`✅ Loaded config from: ${normalizedPath}`);
+            return config;
+        }
+    }
+    const projectRoot = await findProjectRoot();
+    if (projectRoot) {
+        const configFile = await findConfigFile(projectRoot);
+        if (configFile) {
+            const config = configFile.type === "json"
+                ? await loadJsonConfig(configFile.path)
+                : await loadJsConfig(configFile.path);
+            logger.info(`✅ Loaded config from: ${configFile.path}`);
+            return config;
+        }
+    }
+    logger.info("ℹ️ No config file found, using SDK defaults");
+    return undefined;
+}

package/dist/client/init-hooks.d.ts

@@ -1,6 +1,21 @@
+import type { QvacConfig, RuntimeContext } from "../schemas/index";
+type ResolveConfigFn = () => Promise<QvacConfig | undefined>;
+interface RPCClient {
+    request(command: number): any;
+}
 /**
- * Replays cached configuration to the worker after initialization.
- * This ensures config persists across worker restarts.
+ * Initializes SDK configuration and runtime context.
+ * Config is loaded once and becomes immutable on the worker side.
+ *
+ * @param rpc - The RPC client instance
+ * @param resolveConfig - Runtime-specific config resolver function
+ * @param runtimeContext - Optional runtime context (platform, device info)
  */
-export declare const replayConfigIfCached: (rpc: any) => Promise<void>;
+export declare function initializeConfig(rpc: RPCClient, resolveConfig: ResolveConfigFn, runtimeContext?: RuntimeContext): Promise<void>;
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use initializeConfig instead
+ */
+export declare function replayConfigIfCached(): void;
+export {};
 //# sourceMappingURL=init-hooks.d.ts.map

package/dist/client/init-hooks.js

@@ -1,37 +1,65 @@
-import { getCachedConfig } from "./config-manager.js";
+import { getClientLogger, setGlobalLogLevel, setGlobalConsoleOutput, } from "../logging/index.js";
+const logger = getClientLogger();
+function applyClientLoggerSettings(config) {
+    if (config.loggerLevel !== undefined) {
+        setGlobalLogLevel(config.loggerLevel);
+    }
+    if (config.loggerConsoleOutput !== undefined) {
+        setGlobalConsoleOutput(config.loggerConsoleOutput);
+    }
+}
+async function sendInitMessage(rpc, config, runtimeContext) {
+    const initMessage = {
+        type: "__init_config",
+        config,
+        runtimeContext,
+    };
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const req = rpc.request(1);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    req.send(JSON.stringify(initMessage), "utf8");
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    const response = await req.reply("utf8");
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument
+    const parsed = JSON.parse(response.toString());
+    if (!parsed.success) {
+        throw new Error(parsed.error ?? "Unknown error");
+    }
+}
 /**
- * Replays cached configuration to the worker after initialization.
- * This ensures config persists across worker restarts.
+ * Initializes SDK configuration and runtime context.
+ * Config is loaded once and becomes immutable on the worker side.
+ *
+ * @param rpc - The RPC client instance
+ * @param resolveConfig - Runtime-specific config resolver function
+ * @param runtimeContext - Optional runtime context (platform, device info)
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const replayConfigIfCached = async (rpc) => {
-    const config = getCachedConfig();
-    if (!config) {
-        console.log("No cached config to replay");
+export async function initializeConfig(rpc, resolveConfig, runtimeContext) {
+    const config = await resolveConfig();
+    // Nothing to initialize
+    if (!config && !runtimeContext) {
         return;
     }
-    console.log("🔄 Replaying cached config to worker:", config);
+    // Apply client-side logger settings
+    if (config) {
+        applyClientLoggerSettings(config);
+        logger.info("📦 Initializing SDK config");
+    }
+    if (runtimeContext) {
+        logger.info("📱 Runtime context:", runtimeContext);
+    }
     try {
-        const request = {
-            type: "setConfig",
-            config,
-        };
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        const req = rpc.request(1);
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        req.send(JSON.stringify(request), "utf8");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        const response = await req.reply("utf8");
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
-        const parsed = JSON.parse(response.toString());
-        if (parsed.type !== "setConfig" || !parsed.success) {
-            console.error("Failed to replay config:", parsed.error);
-        }
-        else {
-            console.log("✅ Config successfully replayed to worker");
-        }
+        await sendInitMessage(rpc, config, runtimeContext);
+        logger.info("✅ Initialization complete");
     }
     catch (error) {
-        console.error("Error replaying config:", error);
+        logger.error("❌ Initialization failed:", error);
     }
-};
+}
+/**
+ * Legacy function for backward compatibility
+ * @deprecated Use initializeConfig instead
+ */
+export function replayConfigIfCached() {
+    logger.warn("⚠️ replayConfigIfCached is deprecated and has no effect. Config is now loaded from file during initialization.");
+}

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

@@ -1,5 +1,5 @@
 import { type Logger } from "../logging/index";
-export declare function startLoggingStreamForModel(modelId: string, logger: Logger): void;
+export declare function startLoggingStreamForModel(modelId: string, modelLogger: 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,13 +1,14 @@
-import {} from "../logging/index.js";
+import { getClientLogger } from "../logging/index.js";
 import { loggingStream } from "./api/logging-stream.js";
+const logger = getClientLogger();
 const activeStreams = new Map();
-export function startLoggingStreamForModel(modelId, logger) {
+export function startLoggingStreamForModel(modelId, modelLogger) {
     if (activeStreams.has(modelId)) {
-        console.warn(`Logging stream already active for model ${modelId}`);
+        logger.warn(`Logging stream already active for model ${modelId}`);
         return;
     }
-    const streamIterator = loggingStream({ modelId });
-    activeStreams.set(modelId, { logger, streamIterator });
+    const streamIterator = loggingStream({ id: modelId });
+    activeStreams.set(modelId, { logger: modelLogger, streamIterator });
     try {
         void (async () => {
             try {
@@ -15,24 +16,24 @@ export function startLoggingStreamForModel(modelId, logger) {
                     const logLevel = logMessage.level;
                     switch (logLevel) {
                         case "error":
-                            logger.error(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.error(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "warn":
-                            logger.warn(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.warn(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "info":
-                            logger.info(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.info(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         case "debug":
-                            logger.debug(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.debug(`[${logMessage.namespace}]`, logMessage.message);
                             break;
                         default:
-                            logger.info(`[${logMessage.namespace}]`, logMessage.message);
+                            modelLogger.info(`[${logMessage.namespace}]`, logMessage.message);
                     }
                 }
             }
             catch (error) {
-                console.error(`Logging stream error for model ${modelId}:`, error);
+                logger.error(`Logging stream error for model ${modelId}:`, error);
             }
             finally {
                 activeStreams.delete(modelId);
@@ -40,7 +41,7 @@ export function startLoggingStreamForModel(modelId, logger) {
         })();
     }
     catch (error) {
-        console.error(`Failed to start logging stream for model ${modelId}:`, error);
+        logger.error(`Failed to start logging stream for model ${modelId}:`, error);
         activeStreams.delete(modelId);
         throw error;
     }
@@ -52,7 +53,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);
-        console.debug(`Stopped logging stream for model ${modelId}`);
+        logger.debug(`Stopped logging stream for model ${modelId}`);
     }
 }
 export function hasActiveStreamForModel(modelId) {

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

@@ -1,190 +1,9 @@
-import type { Request, Response } from "../../schemas/index";
-export declare function send<T extends Request>(request: T): Promise<Response>;
-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;
-    shardInfo?: {
-        currentShard: number;
-        totalShards: number;
-        shardName: string;
-        overallDownloaded: number;
-        overallTotal: number;
-        overallPercentage: number;
-    } | undefined;
-} | {
-    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;
-    hasActiveModels?: boolean | undefined;
-    hasActiveProviders?: boolean | 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;
-} | {
-    type: "setConfig";
-    success: boolean;
-    error?: string | undefined;
-} | {
-    type: "getModelInfo";
-    modelInfo: {
-        name: string;
-        modelId: string;
-        hyperdriveKey: string;
-        hyperbeeKey: string;
-        expectedSize: number;
-        sha256Checksum: string;
-        addon: "llm" | "whisper" | "embeddings" | "nmt" | "vad" | "tts";
-        isCached: boolean;
-        isLoaded: boolean;
-        cacheFiles: {
-            filename: string;
-            path: string;
-            expectedSize: number;
-            sha256Checksum: string;
-            isCached: boolean;
-            actualSize?: number | undefined;
-            cachedAt?: Date | undefined;
-        }[];
-        actualSize?: number | undefined;
-        cachedAt?: Date | undefined;
-        loadedInstances?: {
-            registryId: string;
-            loadedAt: Date;
-            config?: unknown;
-        }[] | undefined;
-    };
-}, void, any>;
-export declare function getRPC(): {
+export declare function getRPC(): Promise<{
     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