@qvac/sdk 0.6.0 → 0.7.0

package/dist/client/api/get-model-info.d.ts

@@ -2,11 +2,9 @@ import { type GetModelInfoParams } from "../../schemas/index";
 export declare function getModelInfo(params: GetModelInfoParams): Promise<{
     name: string;
     modelId: string;
-    hyperdriveKey: string;
-    hyperbeeKey: string;
     expectedSize: number;
     sha256Checksum: string;
-    addon: "llamacpp-completion" | "whispercpp-transcription" | "llamacpp-embedding" | "nmtcpp-translation" | "onnx-tts" | "onnx-ocr" | "vad";
+    addon: "llm" | "whisper" | "embeddings" | "nmt" | "tts" | "ocr" | "vad" | "other";
     isCached: boolean;
     isLoaded: boolean;
     cacheFiles: {
@@ -18,6 +16,15 @@ export declare function getModelInfo(params: GetModelInfoParams): Promise<{
         actualSize?: number | undefined;
         cachedAt?: Date | undefined;
     }[];
+    registryPath?: string | undefined;
+    registrySource?: string | undefined;
+    blobCoreKey?: string | undefined;
+    blobBlockOffset?: number | undefined;
+    blobBlockLength?: number | undefined;
+    blobByteOffset?: number | undefined;
+    engine?: string | undefined;
+    quantization?: string | undefined;
+    params?: string | undefined;
     actualSize?: number | undefined;
     cachedAt?: Date | undefined;
     loadedInstances?: {

package/dist/client/api/index.d.ts

@@ -15,4 +15,6 @@ export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings,
 export { textToSpeech } from "./text-to-speech";
 export { getModelInfo } from "./get-model-info";
 export { ocr } from "./ocr";
+export { invokePlugin, invokePluginStream } from "./invoke-plugin";
+export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, type ModelRegistrySearchParams, } from "./registry";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -15,3 +15,5 @@ export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings,
 export { textToSpeech } from "./text-to-speech.js";
 export { getModelInfo } from "./get-model-info.js";
 export { ocr } from "./ocr.js";
+export { invokePlugin, invokePluginStream } from "./invoke-plugin.js";
+export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, } from "./registry.js";

package/dist/client/api/invoke-plugin.d.ts

@@ -0,0 +1,14 @@
+export interface InvokePluginOptions<TParams = unknown> {
+    modelId: string;
+    handler: string;
+    params: TParams;
+}
+/**
+ * Invoke a non-streaming plugin handler.
+ */
+export declare function invokePlugin<TResponse = unknown, TParams = unknown>(options: InvokePluginOptions<TParams>): Promise<TResponse>;
+/**
+ * Invoke a streaming plugin handler.
+ */
+export declare function invokePluginStream<TResponse = unknown, TParams = unknown>(options: InvokePluginOptions<TParams>): AsyncGenerator<TResponse>;
+//# sourceMappingURL=invoke-plugin.d.ts.map

package/dist/client/api/invoke-plugin.js

@@ -0,0 +1,38 @@
+import { send, stream } from "../rpc/rpc-client.js";
+import { InvalidResponseError } from "../../utils/errors-client.js";
+/**
+ * Invoke a non-streaming plugin handler.
+ */
+export async function invokePlugin(options) {
+    const request = {
+        type: "pluginInvoke",
+        modelId: options.modelId,
+        handler: options.handler,
+        params: options.params,
+    };
+    const response = await send(request);
+    if (response.type !== "pluginInvoke") {
+        throw new InvalidResponseError("pluginInvoke");
+    }
+    return response.result;
+}
+/**
+ * Invoke a streaming plugin handler.
+ */
+export async function* invokePluginStream(options) {
+    const request = {
+        type: "pluginInvokeStream",
+        modelId: options.modelId,
+        handler: options.handler,
+        params: options.params,
+    };
+    for await (const chunk of stream(request)) {
+        const response = chunk;
+        if (response.type !== "pluginInvokeStream") {
+            throw new InvalidResponseError("pluginInvokeStream");
+        }
+        if (!response.done) {
+            yield response.result;
+        }
+    }
+}

package/dist/client/api/registry.d.ts

@@ -0,0 +1,14 @@
+import type { ModelRegistryEntry, ModelRegistryEntryAddon } from "../../schemas/index";
+export type { ModelRegistryEntry, ModelRegistryEntryAddon };
+export interface ModelRegistrySearchParams {
+    filter?: string;
+    engine?: string;
+    quantization?: string;
+    modelType?: ModelRegistryEntryAddon;
+    addon?: ModelRegistryEntryAddon;
+}
+declare function modelRegistryList(): Promise<ModelRegistryEntry[]>;
+declare function modelRegistrySearch(params?: ModelRegistrySearchParams): Promise<ModelRegistryEntry[]>;
+declare function modelRegistryGetModel(registryPath: string, registrySource: string): Promise<ModelRegistryEntry>;
+export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel };
+//# sourceMappingURL=registry.d.ts.map

package/dist/client/api/registry.js

@@ -0,0 +1,37 @@
+import { send } from "../rpc/rpc-client.js";
+import { ModelRegistryQueryFailedError } from "../../utils/errors-client.js";
+function validateRegistryResponse(response, fallbackError) {
+    if (!response.success) {
+        throw new ModelRegistryQueryFailedError(response.error ?? fallbackError ?? "Unknown registry error");
+    }
+}
+async function modelRegistryList() {
+    const request = {
+        type: "modelRegistryList",
+    };
+    const response = (await send(request));
+    validateRegistryResponse(response);
+    return response.models;
+}
+async function modelRegistrySearch(params = {}) {
+    const { modelType, ...rest } = params;
+    const request = {
+        type: "modelRegistrySearch",
+        ...rest,
+        addon: modelType ?? rest.addon,
+    };
+    const response = (await send(request));
+    validateRegistryResponse(response);
+    return response.models;
+}
+async function modelRegistryGetModel(registryPath, registrySource) {
+    const request = {
+        type: "modelRegistryGetModel",
+        registryPath,
+        registrySource,
+    };
+    const response = (await send(request));
+    validateRegistryResponse(response, `Model not found: ${registrySource}/${registryPath}`);
+    return response.model;
+}
+export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel };

package/dist/client/api/transcribe.js

@@ -1,6 +1,5 @@
 import { transcribeStreamResponseSchema, } from "../../schemas/index.js";
 import { stream } from "../rpc/rpc-client.js";
-import { TranscriptionFailedError } from "../../utils/errors-client.js";
 /**
  * This function streams audio transcription results in real-time, yielding
  * text chunks as they become available from the model.
@@ -24,9 +23,6 @@ export async function* transcribeStream(params) {
     for await (const response of stream(request)) {
         if (response.type === "transcribeStream") {
             const streamResponse = transcribeStreamResponseSchema.parse(response);
-            if (streamResponse.error) {
-                throw new TranscriptionFailedError(streamResponse.error);
-            }
             if (streamResponse.text) {
                 yield streamResponse.text;
             }

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

@@ -34,6 +34,6 @@ export async function unloadModel(params) {
     if (response.hasActiveModels === false &&
         response.hasActiveProviders === false) {
         logger.info("🧹 No models or providers active, automatically closing RPC connection...");
-        close();
+        await close();
     }
 }

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

@@ -2,8 +2,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
+ * 2. Packaged Electron app (via process.resourcesPath)
+ * 3. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 4. 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

@@ -28,8 +28,8 @@ async function findProjectRoot() {
             }
         }
     }
-    catch {
-        // Fall through
+    catch (error) {
+        logger.debug("Project root search failed, using cwd:", { error });
     }
     return process.cwd();
 }
@@ -79,11 +79,32 @@ async function findConfigFile(searchDir) {
     }
     return undefined;
 }
+function getResourcesPath() {
+    const { resourcesPath } = process;
+    return typeof resourcesPath === "string" ? resourcesPath : undefined;
+}
+async function findPackagedConfig() {
+    const resourcesPath = getResourcesPath();
+    if (!resourcesPath)
+        return undefined;
+    const candidates = [
+        path.join(resourcesPath, "app", "qvac.config.json"),
+        path.join(resourcesPath, "app.asar.unpacked", "qvac.config.json"),
+        path.join(resourcesPath, "qvac.config.json"),
+    ];
+    for (const candidate of candidates) {
+        if (await fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    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
+ * 2. Packaged Electron app (via process.resourcesPath)
+ * 3. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 4. SDK defaults
  */
 export async function resolveConfig() {
     const configPath = process.env["QVAC_CONFIG_PATH"];
@@ -102,6 +123,12 @@ export async function resolveConfig() {
             return config;
         }
     }
+    const packagedConfig = await findPackagedConfig();
+    if (packagedConfig) {
+        const config = await loadJsonConfig(packagedConfig);
+        logger.info(`✅ Loaded config from packaged app: ${packagedConfig}`);
+        return config;
+    }
     const projectRoot = await findProjectRoot();
     if (projectRoot) {
         const configFile = await findConfigFile(projectRoot);

package/dist/client/init-hooks.js

@@ -1,4 +1,5 @@
 import { getClientLogger, setGlobalLogLevel, setGlobalConsoleOutput, } from "../logging/index.js";
+import { SetConfigFailedError } from "../utils/errors-client.js";
 const logger = getClientLogger();
 function applyClientLoggerSettings(config) {
     if (config.loggerLevel !== undefined) {
@@ -23,7 +24,7 @@ async function sendInitMessage(rpc, config, runtimeContext) {
     // 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");
+        throw new SetConfigFailedError(parsed.error ?? "Unknown error");
     }
 }
 /**

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

@@ -1,3 +1,5 @@
+import type { Request, Response } from "../../schemas/index";
+export declare function send<T extends Request>(request: T): Promise<Response>;
 export declare function getRPC(): Promise<{
     request(): {
         send(payload: string): void;

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

@@ -1,12 +1,52 @@
 import { normalizeModelType } from "../../schemas/index.js";
 import os from "bare-os";
 import { handlers } from "../../server/rpc/handlers/index.js";
-import { RPCNoHandlerError, RPCRequestNotSentError, } from "../../utils/errors-client.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 handler = handlers[type];
@@ -27,10 +67,7 @@ function applyDeviceDefaultsToLoadModel(request) {
     const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
     return { ...request, modelConfig: configWithDefaults };
 }
-async function send(request) {
-    if (request.type === "ping") {
-        return { type: "pong", number: Math.random() * 100 };
-    }
+export async function send(request) {
     const handler = getHandler(request.type);
     if (!handler)
         throw new RPCNoHandlerError(request.type);
@@ -110,7 +147,7 @@ async function* stream(request) {
         }
     }
 }
-const createMockRPCRequest = () => {
+function createMockRPCRequest() {
     let requestData = null;
     return {
         send(payload) {
@@ -154,9 +191,13 @@ const createMockRPCRequest = () => {
             }
         },
     };
-};
+}
 let configInitialized = false;
 export async function getRPC() {
+    if (!workerEntryLoaded) {
+        await loadWorkerEntry();
+        workerEntryLoaded = true;
+    }
     const mockRPC = {
         request() {
             return createMockRPCRequest();

package/dist/client/rpc/expo-device-info.d.ts

@@ -0,0 +1,6 @@
+export declare function getDeviceInfo(): Promise<{
+    platform: "android" | "ios" | undefined;
+    deviceModel: string | undefined;
+    deviceBrand: string | undefined;
+}>;
+//# sourceMappingURL=expo-device-info.d.ts.map

package/dist/client/rpc/expo-device-info.js

@@ -0,0 +1,32 @@
+import { getClientLogger } from "../../logging/index.js";
+const logger = getClientLogger();
+export async function getDeviceInfo() {
+    try {
+        const expoModulesCore = await import("expo-modules-core");
+        // this looks odd, but is necessary to ensure that import can be used safely.
+        // It will crash the app if the module is not installed, but the node dependency is present.
+        const nativeDeviceModule = expoModulesCore.requireOptionalNativeModule("ExpoDevice");
+        if (nativeDeviceModule) {
+            const Device = await import("expo-device");
+            logger.info(`Device: ${Device.modelName} ${Device.brand} ${Device.osName}`);
+            const osName = Device?.osName?.toLowerCase();
+            return {
+                platform: osName?.includes("ios")
+                    ? "ios"
+                    : osName?.includes("android")
+                        ? "android"
+                        : undefined,
+                deviceModel: Device.modelName ?? undefined,
+                deviceBrand: Device.brand ?? undefined,
+            };
+        }
+    }
+    catch {
+        logger.debug("expo-device not available, device info will be omitted");
+    }
+    return {
+        platform: undefined,
+        deviceModel: undefined,
+        deviceBrand: undefined,
+    };
+}

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

@@ -3,6 +3,7 @@ import { RPCConnectionFailedError } from "../../utils/errors-client.js";
 import { initializeConfig } from "../init-hooks.js";
 import { resolveConfig } from "../config-loader/resolve-config.expo.js";
 import { getClientLogger } from "../../logging/index.js";
+import { getDeviceInfo } from "./expo-device-info.js";
 const logger = getClientLogger();
 let rpcInstance = null;
 let rpcPromise = null;
@@ -14,32 +15,7 @@ async function getRuntimeContext() {
     if (cachedRuntimeContext) {
         return cachedRuntimeContext;
     }
-    // expo-device is optional - gracefully handle if not installed
-    let deviceModel;
-    let deviceBrand;
-    let platform;
-    try {
-        const expoModulesCore = await import("expo-modules-core");
-        // this looks odd, but is necessary to ensure that import can be used safely.
-        // It will crash the app if the module is not installed, but the node dependency is present.
-        const nativeDeviceModule = expoModulesCore.requireOptionalNativeModule("ExpoDevice");
-        if (nativeDeviceModule) {
-            const Device = await import("expo-device");
-            logger.info(`Device: ${Device.modelName} ${Device.brand} ${Device.osName}`);
-            const osName = Device?.osName?.toLowerCase();
-            if (osName?.includes("ios")) {
-                platform = "ios";
-            }
-            else if (osName?.includes("android")) {
-                platform = "android";
-            }
-            deviceModel = Device.modelName ?? undefined;
-            deviceBrand = Device.brand ?? undefined;
-        }
-    }
-    catch {
-        logger.debug("expo-device not available, device info will be omitted");
-    }
+    const { platform, deviceModel, deviceBrand } = await getDeviceInfo();
     cachedRuntimeContext = {
         runtime: "react-native",
         platform,
@@ -72,14 +48,15 @@ export async function getRPC() {
         const worklet = new bareKitModule.Worklet();
         workletInstance = worklet;
         logger.debug("Starting new worklet");
-        // Load the mobile bundle - this will be generated by the Expo plugin
-        // using the user's installed bare library versions
+        // Load the mobile bundle - generated by expo plugin during prebuild
+        // The expo plugin handles bundle selection:
+        // 1. Uses qvac/worker.bundle.js if exists (user pre-generated)
+        // 2. Generates tree-shaken bundle if qvac.config.* exists
+        // 3. Generates default bundle (all plugins) otherwise
         let mobileBundle;
         try {
-            // We need require here or the contents of the bundle will be interpreted as a module
-            mobileBundle =
-                // eslint-disable-next-line @typescript-eslint/no-require-imports
-                require("@qvac/sdk/worker.mobile.bundle");
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            mobileBundle = require("@qvac/sdk/worker.mobile.bundle");
         }
         catch (error) {
             const message = "Failed to load mobile worker bundle. Make sure the QVAC Expo plugin is configured. " +

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

@@ -5,5 +5,5 @@ export declare function getRPC(): {
         createResponseStream: () => AsyncGenerator<unknown, void, unknown>;
     };
 };
-export declare function close(): void;
+export declare function close(): Promise<void>;
 //# sourceMappingURL=node-rpc-client.d.ts.map