@qvac/sdk 0.13.3 → 0.13.4

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

@@ -10,8 +10,9 @@ 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, WorkerCrashedError, WorkerShutdownError, } from "../../utils/errors-client.js";
+import { BareRuntimeBinaryNotFoundError, RPCInitTimeoutError, WorkerCrashedError, WorkerShutdownError, } from "../../utils/errors-client.js";
 const RPC_INIT_TIMEOUT_MS = 30_000;
+const WORKER_STDERR_TAIL_CHARS = 16_384;
 const logger = getClientLogger();
 let rpcInstance = null;
 let rpcPromise = null;
@@ -144,21 +145,74 @@ function bestEffortUnlinkSocket(socketPath) {
         logger.debug("Failed to unlink IPC socket path", { socketPath, error });
     }
 }
-function snapshotAndResetState() {
-    const workerToClose = bareWorkerProc;
-    const serverToClose = ipcServer;
-    const socketPathToClose = currentSocketPath;
+function appendWorkerStderrTail(current, chunk) {
+    const next = current + chunk;
+    if (next.length <= WORKER_STDERR_TAIL_CHARS)
+        return next;
+    return next.slice(next.length - WORKER_STDERR_TAIL_CHARS);
+}
+function createWorkerStartupError(details, stderrTail) {
+    const stderr = stderrTail.trimEnd();
+    if (!stderr)
+        return new Error(details);
+    return new Error(`${details}\n\nWorker stderr:\n${stderr}`);
+}
+function resetModuleState() {
     rpcInstance = null;
     rpcPromise = null;
     bareWorkerProc = null;
     ipcServer = null;
     currentSocketPath = null;
     workerLifeController = null;
+}
+function snapshotAndResetState() {
+    const workerToClose = bareWorkerProc;
+    const serverToClose = ipcServer;
+    const socketPathToClose = currentSocketPath;
+    resetModuleState();
     return { workerToClose, serverToClose, socketPathToClose };
 }
+// Shared cleanup for every init reject path: reset module state, stop the
+// worker + IPC server, and remove the socket so a failed start never leaks
+// resources. Mirrors closeSyncForExit without the planned-shutdown abort.
+function teardownFailedInit() {
+    const { workerToClose, serverToClose, socketPathToClose } = snapshotAndResetState();
+    if (workerToClose) {
+        try {
+            workerToClose.kill("SIGTERM");
+        }
+        catch (error) {
+            logger.debug("Failed to kill bare worker after init failure", { error });
+        }
+    }
+    if (serverToClose) {
+        try {
+            serverToClose.close();
+        }
+        catch (error) {
+            logger.debug("Failed to close IPC server after init failure", { error });
+        }
+    }
+    bestEffortUnlinkSocket(socketPathToClose);
+}
 export function getWorkerLifeSignal() {
     return workerLifeController?.signal ?? null;
 }
+function getWorkerStderr(proc) {
+    return proc.stderr ?? null;
+}
+// `bare-runtime` resolves its platform binary with
+// `require('bare-runtime-<platform>-<arch>')` and throws a terse
+// `No binaries found for target '<platform>-<arch>'` whenever that package —
+// or one of its nested deps — is absent. Under pnpm that happens even on a
+// supported platform, so surface an actionable error instead of the raw throw.
+function mapBareSpawnError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/No binar(?:y|ies) found for target/i.test(message)) {
+        return new BareRuntimeBinaryNotFoundError(process.platform, process.arch, error);
+    }
+    return error instanceof Error ? error : new Error(message);
+}
 // `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) {
@@ -170,12 +224,7 @@ function handlePostHandshakeExit(code, exitSignal, spawn) {
     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;
+        resetModuleState();
     }
     try {
         spawn.server.close();
@@ -223,17 +272,16 @@ async function ensureRPC() {
     workerLifeController = spawnController;
     rpcPromise = new Promise((resolve, reject) => {
         let settled = false;
+        let workerStderrTail = "";
         const timer = setTimeout(() => {
             if (settled)
                 return;
             settled = true;
-            rpcPromise = null;
-            rpcInstance = null;
-            bareWorkerProc = null;
-            ipcServer = null;
-            currentSocketPath = null;
-            workerLifeController = null;
-            reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS));
+            const cause = workerStderrTail
+                ? createWorkerStartupError("Worker did not establish IPC before the RPC initialization timeout", workerStderrTail)
+                : undefined;
+            teardownFailedInit();
+            reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS, cause));
         }, RPC_INIT_TIMEOUT_MS);
         ipcServer = createServer((socket) => {
             if (settled)
@@ -248,12 +296,7 @@ async function ensureRPC() {
                 return;
             settled = true;
             clearTimeout(timer);
-            rpcPromise = null;
-            rpcInstance = null;
-            bareWorkerProc = null;
-            ipcServer = null;
-            currentSocketPath = null;
-            workerLifeController = null;
+            teardownFailedInit();
             reject(error);
         });
         ipcServer.listen(socketPath, () => {
@@ -262,35 +305,61 @@ async function ensureRPC() {
                 server: ipcServer,
                 socketPath,
             };
-            bareWorkerProc = spawn("bare", {
-                args: [
-                    WORKER_PATH,
-                    JSON.stringify({
-                        QVAC_IPC_SOCKET_PATH: socketPath,
-                        // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
-                        HOME_DIR: process.env["SNAP_USER_COMMON"]
-                            ? String(process.env["SNAP_USER_COMMON"])
-                            : os.homedir(),
-                    }),
-                ],
-                stdio: ["inherit", "inherit", "inherit"],
-            });
+            try {
+                bareWorkerProc = spawn("bare", {
+                    args: [
+                        WORKER_PATH,
+                        JSON.stringify({
+                            QVAC_IPC_SOCKET_PATH: socketPath,
+                            // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
+                            HOME_DIR: process.env["SNAP_USER_COMMON"]
+                                ? String(process.env["SNAP_USER_COMMON"])
+                                : os.homedir(),
+                        }),
+                    ],
+                    platform: process.platform,
+                    arch: process.arch,
+                    stdio: ["inherit", "inherit", "pipe"],
+                });
+            }
+            catch (error) {
+                // `spawn` resolves the bare binary synchronously and can throw before
+                // the worker exists, so there is no process to emit "exit". Without
+                // this, the throw escapes the `listen` callback as an uncaught
+                // exception and crashes the host process.
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                teardownFailedInit();
+                reject(mapBareSpawnError(error));
+                return;
+            }
             if (bareWorkerProc) {
+                getWorkerStderr(bareWorkerProc)?.on("data", (chunk) => {
+                    const text = chunk.toString();
+                    workerStderrTail = appendWorkerStderrTail(workerStderrTail, text);
+                    process.stderr.write(chunk);
+                });
                 bareWorkerProc.on("exit", (code, exitSignal) => {
                     if (settled) {
                         handlePostHandshakeExit(code, exitSignal, spawnResources);
                         return;
                     }
-                    // Worker died before handshake — reject the init promise.
+                    // Pre-handshake failures are rejected from "close" so stderr has
+                    // drained before we assemble the startup error cause.
+                });
+                bareWorkerProc.on("close", (...args) => {
+                    if (settled)
+                        return;
+                    const code = typeof args[0] === "number" ? args[0] : null;
+                    const exitSignal = typeof args[1] === "string" ? args[1] : null;
+                    // Worker died before handshake. Use close, not exit, so piped
+                    // stderr has drained before we build the error cause.
                     settled = true;
                     clearTimeout(timer);
-                    rpcPromise = null;
-                    rpcInstance = null;
-                    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`)));
+                    teardownFailedInit();
+                    reject(new RPCInitTimeoutError(RPC_INIT_TIMEOUT_MS, createWorkerStartupError(`Worker process exited with code ${code}, signal ${exitSignal} before IPC connection was established`, workerStderrTail)));
                 });
             }
         });

package/dist/index.d.ts

@@ -10,7 +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 { BareRuntimeBinaryNotFoundError, 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

@@ -35,8 +35,11 @@ export { ContextOverflowError, RequestIdConflictError, RequestNotFoundError, Req
 // `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";
+// `BareRuntimeBinaryNotFoundError` is thrown when the worker fails to
+// spawn because the platform's `bare-runtime-<platform>-<arch>` package is
+// missing (common under pnpm). Exported so consumers can pattern-match with
+// `instanceof`.
+export { BareRuntimeBinaryNotFoundError, 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

@@ -35,6 +35,7 @@ export declare const SDK_CLIENT_ERROR_CODES: {
     readonly BARE_PACK_ERROR: 50611;
     readonly INVALID_PLUGIN_SPECIFIER: 50612;
     readonly BARE_IMPORTS_MAP_NOT_FOUND: 50613;
+    readonly BARE_RUNTIME_BINARY_NOT_FOUND: 50614;
     readonly PROFILER_INVALID_CAPACITY: 50800;
 };
 declare const clientErrorDefinitions: ErrorCodesMap;

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

@@ -40,6 +40,7 @@ export const SDK_CLIENT_ERROR_CODES = {
     BARE_PACK_ERROR: 50611,
     INVALID_PLUGIN_SPECIFIER: 50612,
     BARE_IMPORTS_MAP_NOT_FOUND: 50613,
+    BARE_RUNTIME_BINARY_NOT_FOUND: 50614,
     // Profiler Errors (50,800-50,899)
     PROFILER_INVALID_CAPACITY: 50800,
 };
@@ -188,6 +189,10 @@ const clientErrorDefinitions = {
         name: "BARE_IMPORTS_MAP_NOT_FOUND",
         message: (sdkName, expectedPath) => `bare-imports.json not found.\n\n  Expected at: ${expectedPath}\n\n  Make sure ${sdkName} is installed in your project.`,
     },
+    [SDK_CLIENT_ERROR_CODES.BARE_RUNTIME_BINARY_NOT_FOUND]: {
+        name: "BARE_RUNTIME_BINARY_NOT_FOUND",
+        message: (platform, arch) => `Could not load the Bare runtime binary for ${platform}-${arch}. The platform package "bare-runtime-${platform}-${arch}" (or one of its dependencies) is missing from node_modules — commonly seen with pnpm, which does not always install nested optional dependencies. Fix it by installing the platform package directly (e.g. \`pnpm add bare-runtime-${platform}-${arch}\`) or by installing with npm or bun. See https://github.com/tetherto/qvac/issues/1492`,
+    },
     // Profiler Errors (50,800-50,899)
     [SDK_CLIENT_ERROR_CODES.PROFILER_INVALID_CAPACITY]: {
         name: "PROFILER_INVALID_CAPACITY",

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

@@ -1,4 +1,26 @@
 import { generateStableToolCallId, isValidToolCall, validateToolArguments, } from "../shared.js";
+// Qwen3.5/3.6 can fuse its two tool templates into one frame, embedding the
+// XML `<function=NAME>` token as a bare string key inside the JSON envelope:
+//   {"function=NAME","arguments":{...}}  (invalid JSON, not parseable as-is)
+// Rewrite only that exact shape to a canonical `{"name":NAME,"arguments":...}`
+// frame. Kept deliberately narrow so well-formed JSON frames are never touched.
+function repairFunctionEqualsJson(candidate) {
+    const match = /^\{\s*"function=([^"]+)"\s*,\s*"arguments"\s*:\s*([\s\S]+)\}\s*$/.exec(candidate);
+    if (!match)
+        return undefined;
+    return `{"name":${JSON.stringify(match[1])},"arguments":${match[2]}}`;
+}
+function parseHermesJson(candidate) {
+    try {
+        return JSON.parse(candidate);
+    }
+    catch (err) {
+        const repaired = repairFunctionEqualsJson(candidate);
+        if (repaired === undefined)
+            throw err;
+        return JSON.parse(repaired);
+    }
+}
 // Hermes-style: JSON payload wrapped in `<tool_call>...</tool_call>` tags
 export function parseHermesFormat(text, tools) {
     const toolCalls = [];
@@ -21,7 +43,7 @@ export function parseHermesFormat(text, tools) {
         const trimmedJson = callJson.trim();
         let callItem;
         try {
-            callItem = JSON.parse(trimmedJson);
+            callItem = parseHermesJson(trimmedJson);
         }
         catch (error) {
             errors.push({
@@ -69,7 +91,7 @@ function recoverIncompleteHermesFrame(text, tools) {
     }
     let parsed;
     try {
-        parsed = JSON.parse(candidate);
+        parsed = parseHermesJson(candidate);
     }
     catch {
         return { matched: false, toolCalls: [], errors: [] };

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

@@ -94,6 +94,9 @@ export declare class InvalidPluginSpecifierError extends QvacErrorBase {
 export declare class BareImportsMapNotFoundError extends QvacErrorBase {
     constructor(sdkName: string, expectedPath: string, cause?: unknown);
 }
+export declare class BareRuntimeBinaryNotFoundError extends QvacErrorBase {
+    constructor(platform: string, arch: string, cause?: unknown);
+}
 export declare class ConfigFileNotFoundError extends QvacErrorBase {
     constructor(searchPaths: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -166,6 +166,11 @@ export class BareImportsMapNotFoundError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BARE_IMPORTS_MAP_NOT_FOUND, [sdkName, expectedPath], cause));
     }
 }
+export class BareRuntimeBinaryNotFoundError extends QvacErrorBase {
+    constructor(platform, arch, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BARE_RUNTIME_BINARY_NOT_FOUND, [platform, arch], cause));
+    }
+}
 export class ConfigFileNotFoundError extends QvacErrorBase {
     constructor(searchPaths, cause) {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_NOT_FOUND, [searchPaths], cause));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.13.3",
+  "version": "0.13.4",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",