@qvac/sdk 0.12.0 → 0.12.2

package/NOTICE

@@ -266,21 +266,13 @@ Third-Party Model Licenses
   chatterbox-multilingual-ONNX
     https://huggingface.co/onnx-community/chatterbox-multilingual-ONNX
   chatterbox-s3gen
-    s3:///qvac_models_compiled/chatterbox/2026-05-08/chatterbox-s3gen.gguf
+    https://huggingface.co/ResembleAI/chatterbox-turbo
   chatterbox-s3gen-mtl
-    s3:///qvac_models_compiled/chatterbox/2026-05-08/chatterbox-s3gen-mtl.gguf
+    https://huggingface.co/ResembleAI/chatterbox
   chatterbox-t3-mtl
-    s3:///qvac_models_compiled/chatterbox/2026-05-08/chatterbox-t3-mtl.gguf
-  chatterbox-t3-mtl-q4_0
-    s3:///qvac_models_compiled/ggml/chatterbox/2026-05-18/chatterbox-t3-mtl-q4_0.gguf
-  chatterbox-t3-mtl-q8_0
-    s3:///qvac_models_compiled/ggml/chatterbox/2026-05-18/chatterbox-t3-mtl-q8_0.gguf
+    https://huggingface.co/ResembleAI/chatterbox
   chatterbox-t3-turbo
-    s3:///qvac_models_compiled/chatterbox/2026-05-08/chatterbox-t3-turbo.gguf
-  chatterbox-t3-turbo-q4_0
-    s3:///qvac_models_compiled/ggml/chatterbox/2026-05-18/chatterbox-t3-turbo-q4_0.gguf
-  chatterbox-t3-turbo-q8_0
-    s3:///qvac_models_compiled/ggml/chatterbox/2026-05-18/chatterbox-t3-turbo-q8_0.gguf
+    https://huggingface.co/ResembleAI/chatterbox-turbo
   chatterbox-turbo-ONNX
     https://huggingface.co/ResembleAI/chatterbox-turbo-ONNX
   de-base-ggml-model-f16

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

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

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

@@ -5,9 +5,10 @@
 import fs from "bare-fs";
 import path from "bare-path";
 import process from "bare-process";
-import { validateConfig, parseJsonConfig, } from "./config-utils.js";
-import { ConfigFileParseFailedError } from "../../utils/errors-client.js";
+import { validateConfig } from "./config-utils.js";
+import { ConfigFileInvalidError, ConfigFileParseFailedError, } from "../../utils/errors-client.js";
 import { getClientLogger } from "../../logging/index.js";
+const SUPPORTED_CONFIG_FILE_EXTS = [".js", ".json"];
 const logger = getClientLogger();
 function findProjectRoot() {
     return process.cwd();
@@ -15,19 +16,16 @@ function findProjectRoot() {
 function fileExists(filePath) {
     return fs.existsSync(filePath);
 }
-function readFile(filePath) {
-    const result = fs.readFileSync(filePath, "utf-8");
-    return typeof result === "string" ? result : result.toString("utf-8");
-}
-function loadJsonConfig(filePath) {
-    const content = readFile(filePath);
-    const parsed = parseJsonConfig(content, filePath);
-    return validateConfig(parsed);
+function assertBareConfigExtension(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (!SUPPORTED_CONFIG_FILE_EXTS.includes(ext)) {
+        throw new ConfigFileInvalidError(filePath, "Given config file format unsupported on this platform. Use qvac.config.js or qvac.config.json in the project root, or set QVAC_CONFIG_PATH to a .js or .json file.");
+    }
 }
-async function loadJsConfig(filePath) {
+function loadConfigFromPath(filePath) {
+    assertBareConfigExtension(filePath);
     try {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-        const configModule = await import(filePath);
+        const configModule = require(filePath);
         return validateConfig(configModule.default || configModule);
     }
     catch (error) {
@@ -35,15 +33,11 @@ async function loadJsConfig(filePath) {
     }
 }
 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 configFiles = SUPPORTED_CONFIG_FILE_EXTS.map((ext) => `qvac.config${ext}`);
+    for (const name of configFiles) {
         const filePath = path.resolve(searchDir, name);
         if (fileExists(filePath)) {
-            return { path: filePath, type };
+            return filePath;
         }
     }
     return undefined;
@@ -51,34 +45,26 @@ function findConfigFile(searchDir) {
 /**
  * Resolution order for Bare:
  * 1. QVAC_CONFIG_PATH environment variable
- * 2. Config file in project root (qvac.config.ts, qvac.config.js, qvac.config.json)
+ * 2. Config file in project root (qvac.config.js, qvac.config.json)
  * 3. SDK defaults
  */
+// eslint-disable-next-line @typescript-eslint/require-await -- matches Node/Expo resolver signature
 export async function resolveConfig() {
     const configPath = process.env["QVAC_CONFIG_PATH"];
     if (configPath) {
         const normalizedPath = path.resolve(configPath);
         if (fileExists(normalizedPath)) {
-            const ext = normalizedPath.endsWith(".json")
-                ? "json"
-                : normalizedPath.endsWith(".ts")
-                    ? "ts"
-                    : "js";
-            const config = ext === "json"
-                ? loadJsonConfig(normalizedPath)
-                : await loadJsConfig(normalizedPath);
+            const config = loadConfigFromPath(normalizedPath);
             logger.info(`✅ Loaded config from: ${normalizedPath}`);
             return config;
         }
     }
     const projectRoot = findProjectRoot();
     if (projectRoot) {
-        const configFile = findConfigFile(projectRoot);
-        if (configFile) {
-            const config = configFile.type === "json"
-                ? loadJsonConfig(configFile.path)
-                : await loadJsConfig(configFile.path);
-            logger.info(`✅ Loaded config from: ${configFile.path}`);
+        const configFilePath = findConfigFile(projectRoot);
+        if (configFilePath) {
+            const config = loadConfigFromPath(configFilePath);
+            logger.info(`✅ Loaded config from: ${configFilePath}`);
             return config;
         }
     }

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

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

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

@@ -193,6 +193,10 @@ function createMockRPCRequest() {
     };
 }
 let configInitialized = false;
+// No child worker on Bare-direct — `#rpc` interface stub.
+export function getWorkerLifeSignal() {
+    return null;
+}
 export async function getRPC() {
     await ensureWorkerReady();
     const mockRPC = {

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

@@ -1,4 +1,5 @@
 import RPC from "bare-rpc";
+export declare function getWorkerLifeSignal(): AbortSignal | null;
 export declare function getRPC(): Promise<RPC>;
 export declare function close(): Promise<void>;
 export declare function createDuplexSession(payload: string, commandId: number): Promise<{

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

@@ -28,6 +28,10 @@ async function getRuntimeContext() {
     };
     return cachedRuntimeContext;
 }
+// No child-process exit on Expo (Worklet lifecycle) — `#rpc` interface stub.
+export function getWorkerLifeSignal() {
+    return null;
+}
 export async function getRPC() {
     if (rpcInstance) {
         return rpcInstance;

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

@@ -1,4 +1,5 @@
 import RPC from "bare-rpc";
+export declare function getWorkerLifeSignal(): AbortSignal | null;
 export declare function getRPC(): Promise<RPC>;
 export declare function createDuplexSession(payload: string, commandId: number): Promise<{
     requestStream: RPC.OutgoingStream;

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

@@ -10,7 +10,7 @@ import { fileURLToPath } from "node:url";
 import { initializeConfig } from "../init-hooks.js";
 import { resolveConfig } from "../config-loader/resolve-config.node.js";
 import { getClientLogger } from "../../logging/index.js";
-import { RPCInitTimeoutError } from "../../utils/errors-client.js";
+import { RPCInitTimeoutError, WorkerCrashedError, WorkerShutdownError, } from "../../utils/errors-client.js";
 const RPC_INIT_TIMEOUT_MS = 30_000;
 const logger = getClientLogger();
 let rpcInstance = null;
@@ -19,6 +19,11 @@ let bareWorkerProc = null;
 let ipcServer = null;
 let currentSocketPath = null;
 let closePromise = null;
+// Aborted when the worker dies (crash) or close() runs (planned). Used
+// to unblock in-flight `req.reply()` callers — bare-rpc's `_onerror`
+// does not iterate `_outgoingRequests`, so without this signal they
+// would hang on the dead socket.
+let workerLifeController = null;
 /**
  * Find project root by looking for package.json (sync version)
  * Safe to call at module load time
@@ -148,9 +153,42 @@ function snapshotAndResetState() {
     bareWorkerProc = null;
     ipcServer = null;
     currentSocketPath = null;
+    workerLifeController = null;
     return { workerToClose, serverToClose, socketPathToClose };
 }
+export function getWorkerLifeSignal() {
+    return workerLifeController?.signal ?? null;
+}
+// `spawn` carries this listener's own captured resources. Module-level
+// state may belong to a newer ensureRPC() by the time we fire.
+function handlePostHandshakeExit(code, exitSignal, spawn) {
+    if (spawn.controller.signal.aborted) {
+        // close() already handled teardown.
+        logger.debug(`Bare worker exited after planned shutdown (code=${code}, signal=${exitSignal})`);
+        return;
+    }
+    logger.info(`🪦 Bare worker exited post-handshake (code=${code}, signal=${exitSignal})`);
+    // Only clear module state if we're still the active spawn.
+    if (workerLifeController === spawn.controller) {
+        rpcInstance = null;
+        rpcPromise = null;
+        bareWorkerProc = null;
+        ipcServer = null;
+        currentSocketPath = null;
+        workerLifeController = null;
+    }
+    try {
+        spawn.server.close();
+    }
+    catch (err) {
+        logger.debug("Failed to close IPC server after worker crash", { err });
+    }
+    spawn.controller.abort(new WorkerCrashedError(code, exitSignal));
+    bestEffortUnlinkSocket(spawn.socketPath);
+}
 function closeSyncForExit() {
+    // Abort before kill so the exit handler sees planned intent.
+    workerLifeController?.abort(new WorkerShutdownError());
     const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
     if (workerToClose) {
         try {
@@ -180,6 +218,9 @@ async function ensureRPC() {
     }
     const socketPath = createSocketPath();
     currentSocketPath = socketPath;
+    // Allocated here so the init race and exit handler share one controller.
+    const spawnController = new AbortController();
+    workerLifeController = spawnController;
     rpcPromise = new Promise((resolve, reject) => {
         let settled = false;
         const timer = setTimeout(() => {
@@ -191,6 +232,7 @@ async function ensureRPC() {
             bareWorkerProc = null;
             ipcServer = null;
             currentSocketPath = null;
+            workerLifeController = null;
             reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS));
         }, RPC_INIT_TIMEOUT_MS);
         ipcServer = createServer((socket) => {
@@ -211,9 +253,15 @@ async function ensureRPC() {
             bareWorkerProc = null;
             ipcServer = null;
             currentSocketPath = null;
+            workerLifeController = null;
             reject(error);
         });
         ipcServer.listen(socketPath, () => {
+            const spawnResources = {
+                controller: spawnController,
+                server: ipcServer,
+                socketPath,
+            };
             bareWorkerProc = spawn("bare", {
                 args: [
                     WORKER_PATH,
@@ -228,9 +276,12 @@ async function ensureRPC() {
                 stdio: ["inherit", "inherit", "inherit"],
             });
             if (bareWorkerProc) {
-                bareWorkerProc.on("exit", (code) => {
-                    if (settled)
+                bareWorkerProc.on("exit", (code, exitSignal) => {
+                    if (settled) {
+                        handlePostHandshakeExit(code, exitSignal, spawnResources);
                         return;
+                    }
+                    // Worker died before handshake — reject the init promise.
                     settled = true;
                     clearTimeout(timer);
                     rpcPromise = null;
@@ -238,6 +289,7 @@ async function ensureRPC() {
                     bareWorkerProc = null;
                     ipcServer = null;
                     currentSocketPath = null;
+                    workerLifeController = null;
                     reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS, new Error(`Worker process exited with code ${code} before IPC connection was established`)));
                 });
             }
@@ -248,9 +300,25 @@ async function ensureRPC() {
         runtime: "node",
         platform: process.platform,
     };
-    await initializeConfig(rpc, resolveConfig, runtimeContext);
+    // init-hooks calls bare-rpc directly, bypassing rpc-client's race.
+    await Promise.race([
+        initializeConfig(rpc, resolveConfig, runtimeContext),
+        rejectOnAbort(spawnController.signal),
+    ]);
     return rpc;
 }
+function rejectOnAbort(signal) {
+    return new Promise((_, reject) => {
+        const fail = () => reject(signal.reason instanceof Error
+            ? signal.reason
+            : new WorkerCrashedError(null, null));
+        if (signal.aborted) {
+            fail();
+            return;
+        }
+        signal.addEventListener("abort", fail, { once: true });
+    });
+}
 export async function getRPC() {
     return ensureRPC();
 }
@@ -260,6 +328,24 @@ export async function createDuplexSession(payload, commandId) {
     const requestStream = req.createRequestStream();
     const responseStream = req.createResponseStream({ encoding: "utf-8" });
     requestStream.write(payload, "utf-8");
+    // Destroy on worker death so consumers' for-await throws instead of hangs.
+    const lifeSignal = workerLifeController?.signal;
+    if (lifeSignal && !lifeSignal.aborted) {
+        const onAbort = () => {
+            const err = lifeSignal.reason instanceof Error
+                ? lifeSignal.reason
+                : new WorkerCrashedError(null, null);
+            try {
+                requestStream.destroy?.(err);
+            }
+            catch { }
+            try {
+                responseStream.destroy?.(err);
+            }
+            catch { }
+        };
+        lifeSignal.addEventListener("abort", onAbort, { once: true });
+    }
     return { requestStream, responseStream };
 }
 export async function close() {
@@ -270,6 +356,9 @@ export async function close() {
     if (!rpcInstance && !rpcPromise && !bareWorkerProc && !ipcServer)
         return;
     logger.info("🧹 Closing RPC client");
+    // Abort before kill: exit handler sees planned intent; any in-flight
+    // caller (contract violators) rejects with WorkerShutdownError.
+    workerLifeController?.abort(new WorkerShutdownError());
     const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
     closePromise = (async () => {
         if (workerToClose) {

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

@@ -2,7 +2,8 @@ import { requestSchema, responseSchema, PROFILING_TRAILER_KEY, } from "../../sch
 import { reconstructError } from "./rpc-error.js";
 import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
 import { getClientLogger, summarizeRequest } from "../../logging/index.js";
-import { getRPC, close as closeRPC, createDuplexSession } from "#rpc";
+import { getRPC, close as closeRPC, createDuplexSession, getWorkerLifeSignal, } from "#rpc";
+import { WorkerCrashedError } from "../../utils/errors-client.js";
 import { nowMs, shouldProfile, shouldIncludeServerBreakdown, generateId as createProfileId, createProfilingMeta, createProfilingDisabledMeta, injectProfilingMetaIntoObject, extractProfilingMeta, stripProfilingMeta, recordFailure, } from "../../profiling/index.js";
 import { createClientTimings, createClientStreamTimings, recordClientEvents, recordClientStreamEvents, cacheConnectionTime, flushConnectionTime, resetConnectionTracking, } from "./profiling/index.js";
 const logger = getClientLogger();
@@ -13,6 +14,98 @@ function getNextCommandId() {
     commandCounter = (commandCounter + 1) % Number.MAX_SAFE_INTEGER;
     return commandCounter;
 }
+// Race in-flight reply/stream pulls against the worker-life signal —
+// bare-rpc's `_onerror` does not iterate `_outgoingRequests`, so without
+// this they hang on a dead socket.
+function lifeSignalAbortError(signal) {
+    if (signal.reason instanceof Error)
+        return signal.reason;
+    return new WorkerCrashedError(null, null);
+}
+async function awaitWithLifeSignal(p) {
+    // Null on Bare-direct / Expo and pre-spawn.
+    const lifeSignal = getWorkerLifeSignal();
+    if (!lifeSignal)
+        return p;
+    if (lifeSignal.aborted)
+        throw lifeSignalAbortError(lifeSignal);
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            lifeSignal.removeEventListener("abort", onAbort);
+            reject(lifeSignalAbortError(lifeSignal));
+        };
+        lifeSignal.addEventListener("abort", onAbort, { once: true });
+        p.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            lifeSignal.removeEventListener("abort", onAbort);
+            resolve(value);
+        }, (err) => {
+            if (settled)
+                return;
+            settled = true;
+            lifeSignal.removeEventListener("abort", onAbort);
+            // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- forwarding upstream rejection as-is
+            reject(err);
+        });
+    });
+}
+async function* iterateWithLifeSignal(source) {
+    // Null on Bare-direct / Expo and pre-spawn.
+    const lifeSignal = getWorkerLifeSignal();
+    if (!lifeSignal) {
+        yield* source;
+        return;
+    }
+    if (lifeSignal.aborted)
+        throw lifeSignalAbortError(lifeSignal);
+    try {
+        while (true) {
+            const nextP = source.next();
+            const result = await new Promise((resolve, reject) => {
+                let settled = false;
+                const onAbort = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    lifeSignal.removeEventListener("abort", onAbort);
+                    reject(lifeSignalAbortError(lifeSignal));
+                };
+                lifeSignal.addEventListener("abort", onAbort, { once: true });
+                nextP.then((value) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    lifeSignal.removeEventListener("abort", onAbort);
+                    resolve(value);
+                }, (err) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    lifeSignal.removeEventListener("abort", onAbort);
+                    // eslint-disable-next-line @typescript-eslint/prefer-promise-reject-errors -- forwarding upstream rejection as-is
+                    reject(err);
+                });
+            });
+            if (result.done)
+                return;
+            yield result.value;
+        }
+    }
+    finally {
+        // Fire-and-forget cleanup. If the source is suspended on a never-
+        // settling read (worker dead), `.return()` propagates an abrupt
+        // completion through the for-await chain so inner streams get
+        // destroyed. The `.catch` swallows the case where the underlying
+        // stream cannot honour `.return()` cleanly.
+        void source.return?.(undefined).catch(() => { });
+    }
+}
 function checkAndThrowError(response) {
     if (response.type === "error") {
         // Use the typed-error reconstructor map in `rpc-error.ts` so the
@@ -23,12 +116,28 @@ function checkAndThrowError(response) {
         throw reconstructError(response);
     }
 }
+function invalidateRPCInstance() {
+    rpcInstance = null;
+    firstConnectionPending = true;
+    resetConnectionTracking();
+}
 async function getRPCInstance() {
     if (rpcInstance)
         return { rpc: await rpcInstance };
     const connectionStart = firstConnectionPending ? nowMs() : null;
     rpcInstance = getRPC();
     const rpc = await rpcInstance;
+    // Drop the cache on worker death so the next call respawns and
+    // records connectionMs again as a "first" connection.
+    const lifeSignal = getWorkerLifeSignal();
+    if (lifeSignal?.aborted) {
+        invalidateRPCInstance();
+    }
+    else if (lifeSignal) {
+        lifeSignal.addEventListener("abort", invalidateRPCInstance, {
+            once: true,
+        });
+    }
     if (connectionStart !== null && firstConnectionPending) {
         firstConnectionPending = false;
         return { rpc, connectionMs: nowMs() - connectionStart };
@@ -63,7 +172,7 @@ async function sendBase(request, rpc, options, signalDisable = false) {
         : parsedRequest;
     const payload = JSON.stringify(payloadObj);
     req.send(payload, "utf-8");
-    const response = await withTimeout(req.reply("utf-8"), options?.timeout);
+    const response = await awaitWithLifeSignal(withTimeout(req.reply("utf-8"), options?.timeout));
     const resPayload = responseSchema.parse(JSON.parse(response?.toString() || "{}"));
     logger.debug("ResPayload", { type: resPayload.type });
     checkAndThrowError(resPayload);
@@ -87,7 +196,7 @@ async function sendProfiled(request, rpc, options) {
         timings.requestStringifyMs = nowMs() - stringifyStart;
         timings.sendStart = nowMs();
         req.send(payload, "utf-8");
-        const response = await withTimeout(req.reply("utf-8"), options?.timeout);
+        const response = await awaitWithLifeSignal(withTimeout(req.reply("utf-8"), options?.timeout));
         timings.firstResponseAt = nowMs();
         const parseStart = nowMs();
         const rawParsed = JSON.parse(response?.toString() || "{}");
@@ -140,7 +249,7 @@ async function* streamBase(request, rpc, options = {}, signalDisable = false) {
         }
     }
     const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
-    for await (const chunk of streamWithTimeout) {
+    for await (const chunk of iterateWithLifeSignal(streamWithTimeout)) {
         buffer += chunk.toString();
         // Process complete lines (newline-delimited JSON)
         const lines = buffer.split("\n");
@@ -181,7 +290,7 @@ async function* streamProfiled(request, rpc, options = {}) {
             }
         }
         const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
-        for await (const chunk of streamWithTimeout) {
+        for await (const chunk of iterateWithLifeSignal(streamWithTimeout)) {
             const chunkTime = nowMs();
             if (timings.firstChunkAt === undefined) {
                 timings.firstChunkAt = chunkTime;
@@ -361,8 +470,6 @@ async function duplexProfiled(request, options = {}) {
 export async function close() {
     if (!rpcInstance)
         return;
-    rpcInstance = null;
-    firstConnectionPending = true;
-    resetConnectionTracking();
+    invalidateRPCInstance();
     await closeRPC();
 }

package/dist/index.d.ts

@@ -10,6 +10,7 @@ export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio";
 export { InferenceCancelledError } from "./utils/errors-server";
 export type { InferenceCancelledPartial } from "./utils/errors-server";
 export { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, } from "./utils/errors-server";
+export { WorkerCrashedError, WorkerShutdownError, } from "./utils/errors-client";
 export { getLogger, SDK_LOG_ID } from "./logging/index";
 export type { Logger, LogTransport, LoggerOptions } from "./logging/index";
 export { profiler } from "./profiling/index";

package/dist/index.js

@@ -30,6 +30,11 @@ export { SUPPORTED_AUDIO_FORMATS } from "./constants/audio.js";
 // the worker side.
 export { InferenceCancelledError } from "./utils/errors-server.js";
 export { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, RequestRejectedByPolicyError, } from "./utils/errors-server.js";
+// `WorkerCrashedError` and `WorkerShutdownError` are thrown by the
+// rpc-client life-signal race when the bare worker exits unexpectedly
+// or close()/process-exit teardown runs while a caller is in flight.
+// Exported so consumers can pattern-match with `instanceof`.
+export { WorkerCrashedError, WorkerShutdownError, } from "./utils/errors-client.js";
 // Logging exports
 export { getLogger, SDK_LOG_ID } from "./logging/index.js";
 // Profiler exports

package/dist/schemas/sdk-errors-client.d.ts

@@ -14,6 +14,8 @@ export declare const SDK_CLIENT_ERROR_CODES: {
     readonly RPC_RESPONSE_STREAM_NOT_CREATED: 50202;
     readonly RPC_CONNECTION_FAILED: 50203;
     readonly RPC_INIT_TIMEOUT: 50204;
+    readonly WORKER_CRASHED: 50205;
+    readonly WORKER_SHUTDOWN: 50206;
     readonly PROVIDER_START_FAILED: 50400;
     readonly PROVIDER_STOP_FAILED: 50401;
     readonly DELEGATE_NO_FINAL_RESPONSE: 50402;

package/dist/schemas/sdk-errors-client.js

@@ -17,6 +17,8 @@ export const SDK_CLIENT_ERROR_CODES = {
     RPC_RESPONSE_STREAM_NOT_CREATED: 50202,
     RPC_CONNECTION_FAILED: 50203,
     RPC_INIT_TIMEOUT: 50204,
+    WORKER_CRASHED: 50205,
+    WORKER_SHUTDOWN: 50206,
     // Provider/Delegation Errors (50,400-50,599)
     PROVIDER_START_FAILED: 50400,
     PROVIDER_STOP_FAILED: 50401,
@@ -100,6 +102,14 @@ const clientErrorDefinitions = {
         name: "RPC_INIT_TIMEOUT",
         message: (timeoutMs) => `RPC initialization timed out after ${timeoutMs}ms — the worker process may have failed to start`,
     },
+    [SDK_CLIENT_ERROR_CODES.WORKER_CRASHED]: {
+        name: "WORKER_CRASHED",
+        message: (code, signal) => `Bare worker exited mid-request (code=${code}, signal=${signal}) — in-flight calls were aborted`,
+    },
+    [SDK_CLIENT_ERROR_CODES.WORKER_SHUTDOWN]: {
+        name: "WORKER_SHUTDOWN",
+        message: () => `SDK is shutting down — in-flight RPC call aborted`,
+    },
     // Provider/Delegation Errors (50,400-50,599)
     [SDK_CLIENT_ERROR_CODES.PROVIDER_START_FAILED]: {
         name: "PROVIDER_START_FAILED",

package/dist/server/utils/tools/parsers/qwen35.js

@@ -22,12 +22,16 @@ function coerceParamValue(raw, schema) {
                 throw new Error(`invalid integer value: "${trimmed}"`);
             return n;
         }
-        case "boolean":
-            if (trimmed === "true")
+        case "boolean": {
+            // Qwen3.5/3.6 intermittently emit Python-style capitalised booleans
+            // (`True`/`False`); accept any casing so a valid call isn't dropped.
+            const v = trimmed.toLowerCase();
+            if (v === "true")
                 return true;
-            if (trimmed === "false")
+            if (v === "false")
                 return false;
             throw new Error(`invalid boolean value: "${trimmed}"`);
+        }
         case "array":
         case "object":
             return JSON.parse(trimmed);

package/dist/utils/errors-client.d.ts

@@ -41,6 +41,14 @@ export declare class RPCConnectionFailedError extends QvacErrorBase {
 export declare class RPCInitTimeoutError extends QvacErrorBase {
     constructor(timeoutMs: number, cause?: unknown);
 }
+export declare class WorkerCrashedError extends QvacErrorBase {
+    readonly exitCode: number | null;
+    readonly exitSignal: NodeJS.Signals | null;
+    constructor(exitCode: number | null, exitSignal: NodeJS.Signals | null, cause?: unknown);
+}
+export declare class WorkerShutdownError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
 export declare class ProviderStartFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -74,6 +74,20 @@ export class RPCInitTimeoutError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_INIT_TIMEOUT, [timeoutMs], cause));
     }
 }
+export class WorkerCrashedError extends QvacErrorBase {
+    exitCode;
+    exitSignal;
+    constructor(exitCode, exitSignal, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_CRASHED, [String(exitCode), String(exitSignal)], cause));
+        this.exitCode = exitCode;
+        this.exitSignal = exitSignal;
+    }
+}
+export class WorkerShutdownError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_SHUTDOWN, undefined, cause));
+    }
+}
 // ============== Provider/Delegation Errors ==============
 export class ProviderStartFailedError extends QvacErrorBase {
     constructor(details, cause) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -131,6 +131,11 @@
       "types": "./dist/commands/index.d.ts",
       "import": "./dist/commands/index.js"
     },
+    "./models": {
+      "types": "./dist/models/registry/index.d.ts",
+      "import": "./dist/models/registry/index.js",
+      "require": "./dist/models/registry/index.js"
+    },
     "./pear-pre": "./dist/pear/pre.js"
   },
   "imports": {