@qvac/sdk 0.5.0 → 0.6.1

package/dist/expo/plugins/withMobileBundle.js

@@ -24,12 +24,9 @@ function withMobileBundle(config) {
             throw new WorkerFileNotFoundError(workerPath);
         }
         try {
-            // Truncate incompatible RPC clients for mobile (keep only rpc-client.js and expo-rpc-client.js)
-            const rpcClientsToTruncate = [
-                "node-rpc-client.js",
-                "bare-rpc-client.js",
-                "bare-client.js",
-            ];
+            // Truncate incompatible RPC clients for mobile
+            // Keep: rpc-client.js, expo-rpc-client.js, bare-client.js (needed for worker bundle)
+            const rpcClientsToTruncate = ["node-rpc-client.js"];
             const truncatedContent = "// This RPC client is not available in mobile environments";
             for (const clientFile of rpcClientsToTruncate) {
                 const clientPath = path.join(qvacSdkPath, "dist", "client", "rpc", clientFile);
@@ -38,9 +35,15 @@ function withMobileBundle(config) {
                     console.log(`🔧 QVAC: Truncated ${clientFile} for mobile compatibility`);
                 }
             }
+            // Copy bare imports configuration for bare-pack
+            const bareImportsSource = path.join(qvacSdkPath, "bare-imports.json");
+            const importsMapPath = path.join(qvacSdkPath, "dist", "imports.json");
+            if (fs.existsSync(bareImportsSource)) {
+                fs.copyFileSync(bareImportsSource, importsMapPath);
+                console.log("🔧 QVAC: Copied bare-imports.json for mobile bundle");
+            }
             // Remove optional modules from the bundle
             const optionalModules = [
-                "crypto",
                 "expo-file-system",
                 "react-native-bare-kit",
                 "@qvac/sdk/worker.mobile.bundle",
@@ -48,9 +51,25 @@ function withMobileBundle(config) {
             const deferFlags = optionalModules
                 .map((mod) => `--defer "${mod}"`)
                 .join(" ");
-            // Generate the bundle using bun bare-pack with the current project's dependencies
-            // We use the project root as working directory so bare-pack uses the user's node_modules
-            execSync(`cd "${projectRoot}" && npx bare-pack --target android-arm64 --target ios-arm64 --target ios-arm64-simulator --linked ${deferFlags} --out "${outputPath}" "${workerPath}"`, { stdio: "inherit", cwd: projectRoot });
+            // Detect bare-pack version (v1.x uses --target, v2.x uses --host)
+            let platformFlag = "--host";
+            try {
+                const versionOutput = execSync(`npx bare-pack --version "${workerPath}"`, { cwd: projectRoot, encoding: "utf-8" }).trim();
+                const versionMatch = versionOutput.match(/v?(\d+)\./);
+                const majorVersion = versionMatch && versionMatch[1] ? parseInt(versionMatch[1], 10) : 2;
+                if (majorVersion < 2) {
+                    platformFlag = "--target";
+                }
+            }
+            catch (error) {
+                throw new Error(`Failed to detect bare-pack version. Ensure bare-pack is installed: npm install bare-pack`, { cause: error });
+            }
+            const platforms = ["android-arm64", "ios-arm64", "ios-arm64-simulator"];
+            const platformFlags = platforms
+                .map((p) => `${platformFlag} ${p}`)
+                .join(" ");
+            // Generate the bundle using bare-pack with the current project's dependencies
+            execSync(`cd "${projectRoot}" && npx bare-pack ${platformFlags} --linked --imports "${importsMapPath}" ${deferFlags} --out "${outputPath}" "${workerPath}"`, { stdio: "inherit", cwd: projectRoot });
             console.log("🫡 QVAC: Mobile worker bundle generated successfully");
         }
         catch (error) {

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, getModelInfo, loggingStream, } from "./client/api/index";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, textToSpeech, getModelInfo, loggingStream, ocr, } from "./client/api/index";
 export { close } from "./client/index";
-export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallWithCall, type ToolCallError, type ToolCallEvent, type CompletionStats, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, type QvacConfig, type ModelInfo, type GetModelInfoParams, type LoadedInstance, type CacheFileInfo, toolSchema, type McpClient, type McpClientInput, } from "./schemas/index";
+export { type ModelProgressUpdate, type LoadModelOptions, type DownloadAssetOptions, type Tool, type ToolCall, type ToolCallWithCall, type ToolCallError, type ToolCallEvent, type CompletionStats, VERBOSITY, type Attachment, type CompletionParams, type RagSearchResult, type RagSaveEmbeddingsResult, type RagReindexResult, type RagEmbeddedDoc, type RagDoc, type RagWorkspaceInfo, type RagCloseWorkspaceParams, type RagDeleteWorkspaceParams, type RagIngestStage, type RagReindexStage, type RagSaveStage, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, type QvacConfig, type ModelInfo, type GetModelInfoParams, type LoadedInstance, type CacheFileInfo, toolSchema, type McpClient, type McpClientInput, type OCRClientParams, type OCRTextBlock, type OCROptions, } from "./schemas/index";
 export { type ToolInput, type ToolHandler } from "./utils/tool-helpers";
+export { PUBLIC_MODEL_TYPES as MODEL_TYPES } from "./schemas/index";
 export * from "./models/hyperdrive/index";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";
 export { getLogger, SDK_LOG_ID } from "./logging/index";

package/dist/index.js

@@ -1,8 +1,10 @@
 // Public API exports only
-export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, textToSpeech, getModelInfo, loggingStream, } from "./client/api/index.js";
+export { completion, deleteCache, loadModel, downloadAsset, ping, startQVACProvider, stopQVACProvider, unloadModel, transcribe, transcribeStream, embed, translate, cancel, ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, textToSpeech, getModelInfo, loggingStream, ocr, } from "./client/api/index.js";
 export { close } from "./client/index.js";
 export { VERBOSITY, SDK_CLIENT_ERROR_CODES, SDK_SERVER_ERROR_CODES, toolSchema, } from "./schemas/index.js";
 export {} from "./utils/tool-helpers.js";
+// Model types - canonical naming with backward-compatible aliases
+export { PUBLIC_MODEL_TYPES as MODEL_TYPES } from "./schemas/index.js";
 // Hyperdrive model constants
 export * from "./models/hyperdrive/index.js";
 export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio.js";

package/dist/logging/addon.js

@@ -7,11 +7,25 @@ const PRIORITY_TO_LEVEL = {
     3: "debug",
     4: "debug",
 };
-// Track ALL loggers per namespace: Map<namespace, Set<Logger>>
-const addonLoggers = new Map();
-// Track modelId → { namespace, logger } for cleanup on unload
-const modelLoggers = new Map();
+const ADDON_LOGGERS_KEY = Symbol.for("@qvac/sdk:addon-loggers");
+const MODEL_LOGGERS_KEY = Symbol.for("@qvac/sdk:model-loggers");
+function getAddonLoggers() {
+    const global = globalThis;
+    if (!global[ADDON_LOGGERS_KEY]) {
+        global[ADDON_LOGGERS_KEY] = new Map();
+    }
+    return global[ADDON_LOGGERS_KEY];
+}
+function getModelLoggers() {
+    const global = globalThis;
+    if (!global[MODEL_LOGGERS_KEY]) {
+        global[MODEL_LOGGERS_KEY] = new Map();
+    }
+    return global[MODEL_LOGGERS_KEY];
+}
 export function registerAddonLogger(modelId, namespace, logger) {
+    const addonLoggers = getAddonLoggers();
+    const modelLoggers = getModelLoggers();
     if (!addonLoggers.has(namespace)) {
         addonLoggers.set(namespace, new Set());
     }
@@ -19,6 +33,8 @@ export function registerAddonLogger(modelId, namespace, logger) {
     modelLoggers.set(modelId, { namespace, logger });
 }
 export function unregisterAddonLogger(modelId) {
+    const addonLoggers = getAddonLoggers();
+    const modelLoggers = getModelLoggers();
     const entry = modelLoggers.get(modelId);
     if (entry) {
         addonLoggers.get(entry.namespace)?.delete(entry.logger);
@@ -44,7 +60,7 @@ function routeLog(logger, level, message) {
 }
 export function createAddonLoggerCallback(namespace) {
     return (priority, message) => {
-        const loggers = addonLoggers.get(namespace);
+        const loggers = getAddonLoggers().get(namespace);
         if (!loggers || loggers.size === 0)
             return;
         const level = PRIORITY_TO_LEVEL[priority] ?? "debug";
@@ -54,6 +70,6 @@ export function createAddonLoggerCallback(namespace) {
     };
 }
 export function clearAllAddonLoggers() {
-    addonLoggers.clear();
-    modelLoggers.clear();
+    getAddonLoggers().clear();
+    getModelLoggers().clear();
 }

package/dist/logging/base-logger.js

@@ -36,12 +36,12 @@ export function createBaseLogger(namespace, options, extensions) {
                 const result = transport(level, namespace, message);
                 if (result instanceof Promise) {
                     result.catch((error) => {
-                        console.error(`Transport error in ${namespace}:`, error);
+                        console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
                     });
                 }
             }
             catch (error) {
-                console.error(`Transport error in ${namespace}:`, error);
+                console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
             }
         }
     };

package/dist/logging/client-logger.js

@@ -1,13 +1,24 @@
 import { getLogger } from "./logger.js";
 const CLIENT_NAMESPACE = "sdk:client";
-let cachedLogger = null;
+const CLIENT_LOGGER_KEY = Symbol.for("@qvac/sdk:client-logger");
+function getCachedClientLogger() {
+    const global = globalThis;
+    return global[CLIENT_LOGGER_KEY] ?? null;
+}
+function setCachedClientLogger(logger) {
+    const global = globalThis;
+    global[CLIENT_LOGGER_KEY] = logger;
+}
 export function getClientLogger(options) {
-    if (!options && cachedLogger) {
-        return cachedLogger;
+    if (!options) {
+        const cached = getCachedClientLogger();
+        if (cached) {
+            return cached;
+        }
     }
     const logger = getLogger(CLIENT_NAMESPACE, options);
     if (!options) {
-        cachedLogger = logger;
+        setCachedClientLogger(logger);
     }
     return logger;
 }

package/dist/logging/index.d.ts

@@ -6,4 +6,5 @@ export { getClientLogger } from "./client-logger";
 export type { Logger, LoggerOptions, LogTransport } from "./types";
 export { ADDON_NAMESPACES, SDK_LOG_ID, SDK_SERVER_NAMESPACE, type AddonNamespace, } from "./namespaces";
 export { registerAddonLogger, unregisterAddonLogger, createAddonLoggerCallback, clearAllAddonLoggers, } from "./addon";
+export { summarizeRequest } from "./utils";
 //# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

@@ -5,3 +5,4 @@ export { getServerLogger } from "./server-logger.js";
 export { getClientLogger } from "./client-logger.js";
 export { ADDON_NAMESPACES, SDK_LOG_ID, SDK_SERVER_NAMESPACE, } from "./namespaces.js";
 export { registerAddonLogger, unregisterAddonLogger, createAddonLoggerCallback, clearAllAddonLoggers, } from "./addon.js";
+export { summarizeRequest } from "./utils.js";

package/dist/logging/logger.js

@@ -1,5 +1,13 @@
 import { safeTransport } from "./transport.js";
 import { createBaseLogger } from "./base-logger.js";
+const LOGGER_CACHE_KEY = Symbol.for("@qvac/sdk:logger-cache");
+function getLoggerCache() {
+    const global = globalThis;
+    if (!global[LOGGER_CACHE_KEY]) {
+        global[LOGGER_CACHE_KEY] = new Map();
+    }
+    return global[LOGGER_CACHE_KEY];
+}
 function createLogger(namespace, options) {
     const safeOptions = options
         ? {
@@ -9,17 +17,17 @@ function createLogger(namespace, options) {
         : undefined;
     return createBaseLogger(namespace, safeOptions);
 }
-const loggerCache = new Map();
 export function getLogger(namespace, options) {
+    const cache = getLoggerCache();
     if (!options) {
-        const cached = loggerCache.get(namespace);
+        const cached = cache.get(namespace);
         if (cached) {
             return cached;
         }
     }
     const logger = createLogger(namespace, options);
     if (!options) {
-        loggerCache.set(namespace, logger);
+        cache.set(namespace, logger);
     }
     return logger;
 }

package/dist/logging/namespaces.d.ts

@@ -4,6 +4,7 @@ export declare const ADDON_NAMESPACES: {
     readonly WHISPERCPP: "whispercpp";
     readonly TTS: "tts";
     readonly NMTCPP: "nmtcpp";
+    readonly RAG_HYPERDB: "rag:hyperdb";
 };
 export type AddonNamespace = (typeof ADDON_NAMESPACES)[keyof typeof ADDON_NAMESPACES];
 export declare const SDK_LOG_ID = "__sdk__";

package/dist/logging/namespaces.js

@@ -4,6 +4,7 @@ export const ADDON_NAMESPACES = {
     WHISPERCPP: "whispercpp",
     TTS: "tts",
     NMTCPP: "nmtcpp",
+    RAG_HYPERDB: "rag:hyperdb",
 };
 // Reserved ID for SDK server logs
 export const SDK_LOG_ID = "__sdk__";

package/dist/logging/registry.d.ts

@@ -16,6 +16,11 @@
  *
  * NOTE: This is separate from server/bare/registry/logging-stream-registry.ts
  * which manages RPC subscriptions for streaming logs to connected clients.
+ *
+ * IMPORTANT: Some bundlers may evaluate the same logical module multiple times with
+ * subpath imports like `#rpc`, which can duplicate internal module state.
+ * We use globalThis + Symbol.for() to guarantees a single instance across all
+ * module evaluations and runtimes.
  */
 import type { LogLevel } from "@qvac/logging";
 import type { Logger } from "./types";

package/dist/logging/registry.js

@@ -16,21 +16,33 @@
  *
  * NOTE: This is separate from server/bare/registry/logging-stream-registry.ts
  * which manages RPC subscriptions for streaming logs to connected clients.
+ *
+ * IMPORTANT: Some bundlers may evaluate the same logical module multiple times with
+ * subpath imports like `#rpc`, which can duplicate internal module state.
+ * We use globalThis + Symbol.for() to guarantees a single instance across all
+ * module evaluations and runtimes.
  */
-const allLoggers = new Set();
+const REGISTRY_KEY = Symbol.for("@qvac/sdk:logger-registry");
+function getRegistry() {
+    const global = globalThis;
+    if (!global[REGISTRY_KEY]) {
+        global[REGISTRY_KEY] = new Set();
+    }
+    return global[REGISTRY_KEY];
+}
 export function registerLogger(logger) {
-    allLoggers.add(logger);
+    getRegistry().add(logger);
 }
 export function unregisterLogger(logger) {
-    allLoggers.delete(logger);
+    getRegistry().delete(logger);
 }
 export function setGlobalLogLevel(level) {
-    for (const logger of allLoggers) {
+    for (const logger of getRegistry()) {
         logger.setLevel(level);
     }
 }
 export function setGlobalConsoleOutput(enabled) {
-    for (const logger of allLoggers) {
+    for (const logger of getRegistry()) {
         logger.setConsoleOutput(enabled);
     }
 }

package/dist/logging/transport.js

@@ -4,12 +4,12 @@ export function safeTransport(transport, namespace) {
             const result = transport(level, ns, message);
             if (result instanceof Promise) {
                 result.catch((error) => {
-                    console.error(`Transport error in ${namespace}:`, error);
+                    console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
                 });
             }
         }
         catch (error) {
-            console.error(`Transport error in ${namespace}:`, error);
+            console.error(`Transport error in ${namespace}:`, error); // fallback (avoid recursion)
         }
     };
 }

package/dist/logging/utils.d.ts

@@ -1,4 +1,6 @@
 import type { LogLevel } from "@qvac/logging";
+import type { Request } from "../schemas/index";
 export declare function isLevelEnabled(messageLevel: LogLevel, currentLevel: LogLevel): boolean;
 export declare function formatArg(arg: unknown): string;
+export declare function summarizeRequest(request: Request): Record<string, unknown>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/logging/utils.js

@@ -45,3 +45,65 @@ export function formatArg(arg) {
         return "[object]";
     }
 }
+export function summarizeRequest(request) {
+    const summary = { type: request.type };
+    if ("modelId" in request)
+        summary["modelId"] = request["modelId"];
+    // Only summarize requests with large payloads
+    if (request.type === "transcribeStream") {
+        const chunk = request["audioChunk"];
+        summary["audioChunk"] = `[${chunk.type}: ${chunk.value.length} bytes]`;
+        return summary;
+    }
+    if (request.type === "ocrStream") {
+        const img = request["image"];
+        summary["image"] = `[${img.type}: ${img.value.length} bytes]`;
+        return summary;
+    }
+    if (request.type === "embed") {
+        const text = request["text"];
+        if (Array.isArray(text)) {
+            const totalLen = text.reduce((sum, t) => sum + t.length, 0);
+            summary["text"] = `[${text.length} items, ${totalLen} chars]`;
+        }
+        else if (text.length > 200) {
+            summary["text"] = `[${text.length} chars]`;
+        }
+        else {
+            summary["text"] = text;
+        }
+        return summary;
+    }
+    if (request.type === "rag") {
+        const op = request["operation"];
+        if (op === "ingest" || op === "chunk") {
+            summary["operation"] = op;
+            if ("workspace" in request)
+                summary["workspace"] = request["workspace"];
+            const docs = request["documents"];
+            if (Array.isArray(docs)) {
+                const totalLen = docs.reduce((sum, d) => sum + d.length, 0);
+                summary["documents"] = `[${docs.length} docs, ${totalLen} chars]`;
+            }
+            else if (docs.length > 200) {
+                summary["documents"] = `[${docs.length} chars]`;
+            }
+            else {
+                summary["documents"] = docs;
+            }
+            return summary;
+        }
+        if (op === "saveEmbeddings") {
+            summary["operation"] = op;
+            if ("workspace" in request)
+                summary["workspace"] = request["workspace"];
+            const docs = request["documents"];
+            const dims = docs[0]?.embedding?.length ?? 0;
+            summary["documents"] =
+                `[${docs.length} docs with ${dims}-dim embeddings]`;
+            return summary;
+        }
+    }
+    // All other requests - return full request (no large payloads)
+    return request;
+}