@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/bare/runtime-lifecycle.js

@@ -1,15 +1,11 @@
-import { getServerLogger } from "../../logging/index.js";
-import { LifecycleOperationBlockedError } from "../../utils/errors-server.js";
+import { getServerLogger } from '../../logging/index.js';
+import { LifecycleOperationBlockedError } from '../../utils/errors-server.js';
 const logger = getServerLogger();
-const LIFECYCLE_ALLOWED_TYPES = new Set([
-    "suspend",
-    "resume",
-    "state",
-]);
+const LIFECYCLE_ALLOWED_TYPES = new Set(['suspend', 'resume', 'state']);
 const swarms = new Map();
 const stores = new Map();
 const resumeListeners = new Set();
-let state = "active";
+let state = 'active';
 let transitionPromise = null;
 /**
  * Register a callback fired after the runtime returns to "active". Lets in-flight
@@ -28,7 +24,7 @@ function notifyResume() {
             listener();
         }
         catch (error) {
-            logger.error("Lifecycle: onResume listener threw:", error);
+            logger.error('Lifecycle: onResume listener threw:', error);
         }
     }
 }
@@ -58,7 +54,7 @@ export function getLifecycleState() {
     return state;
 }
 export function assertLifecycleAllowed(request) {
-    if (state === "active" || LIFECYCLE_ALLOWED_TYPES.has(request.type))
+    if (state === 'active' || LIFECYCLE_ALLOWED_TYPES.has(request.type))
         return;
     throw new LifecycleOperationBlockedError(request.type, state);
 }
@@ -69,7 +65,7 @@ export function resetLifecycleState() {
     swarms.clear();
     stores.clear();
     resumeListeners.clear();
-    state = "active";
+    state = 'active';
     transitionPromise = null;
 }
 async function runPhase(snapshot, liveSet, fn, phaseLabel) {
@@ -91,37 +87,37 @@ async function runPhase(snapshot, liveSet, fn, phaseLabel) {
     }
 }
 export async function suspendRuntime() {
-    if (state === "suspended")
+    if (state === 'suspended')
         return;
-    if (state === "suspending" && transitionPromise)
+    if (state === 'suspending' && transitionPromise)
         return transitionPromise;
     // Opposite transition in flight: wait for it, then re-evaluate
-    if (state === "resuming" && transitionPromise) {
+    if (state === 'resuming' && transitionPromise) {
         await transitionPromise;
         return suspendRuntime();
     }
-    state = "suspending";
+    state = 'suspending';
     logger.info(`⏸️ Suspending runtime (${stores.size} stores, ${swarms.size} swarms)`);
     transitionPromise = (async () => {
         const swarmSnapshot = Array.from(swarms.entries());
         const storeSnapshot = Array.from(stores.entries());
         await runPhase(storeSnapshot, stores, async (store) => {
             await store.suspend();
-        }, "suspend-store");
+        }, 'suspend-store');
         await runPhase(swarmSnapshot, swarms, async (swarm) => {
             if (!swarm.suspended)
                 await swarm.suspend();
-        }, "suspend-swarm");
+        }, 'suspend-swarm');
     })()
         .then(() => {
-        state = "suspended";
-        logger.info("⏸️ Runtime suspended");
+        state = 'suspended';
+        logger.info('⏸️ Runtime suspended');
     })
         .catch((error) => {
         // Partial failure: commit to target so recovery resume() can repair
         // instead of leaving state as "suspending" which blocks all future calls.
-        state = "suspended";
-        logger.error("⏸️ Runtime suspend partially failed, state committed for recovery");
+        state = 'suspended';
+        logger.error('⏸️ Runtime suspend partially failed, state committed for recovery');
         throw error;
     })
         .finally(() => {
@@ -130,34 +126,34 @@ export async function suspendRuntime() {
     return transitionPromise;
 }
 export async function resumeRuntime() {
-    if (state === "active")
+    if (state === 'active')
         return;
-    if (state === "resuming" && transitionPromise)
+    if (state === 'resuming' && transitionPromise)
         return transitionPromise;
-    if (state === "suspending" && transitionPromise) {
+    if (state === 'suspending' && transitionPromise) {
         await transitionPromise;
         return resumeRuntime();
     }
-    state = "resuming";
+    state = 'resuming';
     logger.info(`▶️ Resuming runtime (${swarms.size} swarms, ${stores.size} stores)`);
     transitionPromise = (async () => {
         const swarmSnapshot = Array.from(swarms.entries());
         const storeSnapshot = Array.from(stores.entries());
         await runPhase(swarmSnapshot, swarms, async (swarm) => {
             await swarm.resume();
-        }, "resume-swarm");
+        }, 'resume-swarm');
         await runPhase(storeSnapshot, stores, async (store) => {
             await store.resume();
-        }, "resume-store");
+        }, 'resume-store');
     })()
         .then(() => {
-        state = "active";
-        logger.info("▶️ Runtime resumed");
+        state = 'active';
+        logger.info('▶️ Runtime resumed');
         notifyResume();
     })
         .catch((error) => {
-        state = "suspended";
-        logger.error("▶️ Runtime resume partially failed, staying suspended for retry");
+        state = 'suspended';
+        logger.error('▶️ Runtime resume partially failed, staying suspended for retry');
         throw error;
     })
         .finally(() => {

package/dist/server/bare/types/addon-responses.d.ts

@@ -4,7 +4,8 @@ export interface LlmStats {
     CacheTokens?: number;
     promptTokens?: number;
     generatedTokens?: number;
-    backendDevice?: "cpu" | "gpu";
+    avgConcurrentSeq?: number;
+    backendDevice?: 'cpu' | 'gpu';
 }
 export interface LlmResponse {
     stats?: LlmStats;
@@ -25,6 +26,8 @@ export interface NmtResponse {
 export interface TtsStats {
     audioDurationMs?: number;
     totalSamples?: number;
+    enhancerBackendDevice?: number;
+    enhancerBackendId?: number;
 }
 export interface TtsResponse {
     stats?: TtsStats;
@@ -36,7 +39,7 @@ export interface EmbedStats {
     total_time_ms?: number;
     tokens_per_second?: number;
     total_tokens?: number;
-    backendDevice?: "cpu" | "gpu";
+    backendDevice?: 'cpu' | 'gpu';
     context_size?: number;
 }
 export interface EmbedResponse {
@@ -68,12 +71,12 @@ export interface TranscribeAddonSegment {
     id?: number;
 }
 export interface TranscribeAddonVadEvent {
-    type: "vad";
+    type: 'vad';
     speaking: boolean;
     probability: number;
 }
 export interface TranscribeAddonEndOfTurnEvent {
-    type: "endOfTurn";
+    type: 'endOfTurn';
     silenceDurationMs: number;
 }
 export type TranscribeAddonOutput = Array<TranscribeAddonSegment> | TranscribeAddonVadEvent | TranscribeAddonEndOfTurnEvent;

package/dist/server/bare/utils/audio-input.d.ts

@@ -1,5 +1,5 @@
-import { Readable } from "bare-stream";
-import type { AudioInput, AudioFormat } from "../../../schemas/index";
+import { Readable } from 'bare-stream';
+import type { AudioInput, AudioFormat } from '../../../schemas/index';
 /**
  * Converts an AudioInput (base64 or filePath) into a Readable stream,
  * decoding the audio when necessary.

package/dist/server/bare/utils/audio-input.js

@@ -1,7 +1,7 @@
-import { Readable } from "bare-stream";
-import fs from "bare-fs";
-import { needsDecoding, decodeAudioToStream, } from "../../utils/audio/decoder.js";
-import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../utils/errors-server.js";
+import { Readable } from 'bare-stream';
+import fs from 'bare-fs';
+import { needsDecoding, decodeAudioToStream } from '../../utils/audio/decoder.js';
+import { AudioFileNotFoundError, InvalidAudioChunkError } from '../../../utils/errors-server.js';
 /**
  * Converts an AudioInput (base64 or filePath) into a Readable stream,
  * decoding the audio when necessary.
@@ -10,11 +10,11 @@ import { AudioFileNotFoundError, InvalidAudioChunkError, } from "../../../utils/
  */
 export async function createAudioStream(audioChunk, audioFormat) {
     switch (audioChunk.type) {
-        case "base64": {
-            const audioBuffer = Buffer.from(audioChunk.value, "base64");
+        case 'base64': {
+            const audioBuffer = Buffer.from(audioChunk.value, 'base64');
             return Readable.from([audioBuffer]);
         }
-        case "filePath": {
+        case 'filePath': {
             const filePath = audioChunk.value;
             try {
                 fs.accessSync(filePath);

package/dist/server/bare/utils/transcribe-metadata.d.ts

@@ -1,4 +1,4 @@
-import { type TranscribeSegment } from "../../../schemas/index";
+import { type TranscribeSegment } from '../../../schemas/index';
 export interface WhisperAddonSegment {
     text: string;
     start?: number;

package/dist/server/bare/utils/transcribe-metadata.js

@@ -1,5 +1,5 @@
-import { ModelType } from "../../../schemas/index.js";
-import { TranscriptionFailedError } from "../../../utils/errors-server.js";
+import { ModelType } from '../../../schemas/index.js';
+import { TranscriptionFailedError } from '../../../utils/errors-server.js';
 /**
  * Normalize a native whisper-addon segment to the SDK-level `TranscribeSegment`
  * shape exposed to callers: seconds → milliseconds, `toAppend` → `append`,
@@ -11,7 +11,7 @@ export function toTranscribeSegment(chunk) {
         startMs: (chunk.start ?? 0) * 1000,
         endMs: (chunk.end ?? 0) * 1000,
         append: chunk.toAppend ?? false,
-        id: chunk.id ?? 0,
+        id: chunk.id ?? 0
     };
 }
 /**
@@ -23,6 +23,6 @@ export function assertMetadataSupported(modelId, engineType, metadata) {
     if (!metadata)
         return;
     if (engineType !== ModelType.whispercppTranscription) {
-        throw new TranscriptionFailedError(`metadata mode is not supported on model ${modelId} (engine: ${engineType || "unknown"}); only the whisper engine supports metadata`);
+        throw new TranscriptionFailedError(`metadata mode is not supported on model ${modelId} (engine: ${engineType || 'unknown'}); only the whisper engine supports metadata`);
     }
 }

package/dist/server/bare/utils/tts-stats.d.ts

@@ -1,4 +1,4 @@
-import type { TtsStats } from "../../../schemas/index";
+import type { TtsStats } from '../../../schemas/index';
 /**
  * Shared types and utilities for TTS operations.
  * Used by both text-to-speech.ts and text-to-speech-stream.ts.
@@ -13,10 +13,14 @@ export type TtsOpYield = {
     chunkIndex?: number;
     sentenceChunk?: string;
 };
+type AddonTtsStats = {
+    audioDurationMs?: number;
+    totalSamples?: number;
+    enhancerBackendDevice?: number;
+    enhancerBackendId?: number;
+};
 export declare function collectTtsStats(response: {
-    stats?: {
-        audioDurationMs?: number;
-        totalSamples?: number;
-    };
+    stats?: AddonTtsStats;
 }): TtsStats;
+export {};
 //# sourceMappingURL=tts-stats.d.ts.map

package/dist/server/bare/utils/tts-stats.js

@@ -1,10 +1,16 @@
 export function collectTtsStats(response) {
     return {
         ...(response.stats?.audioDurationMs !== undefined && {
-            audioDuration: response.stats.audioDurationMs,
+            audioDuration: response.stats.audioDurationMs
         }),
         ...(response.stats?.totalSamples !== undefined && {
-            totalSamples: response.stats.totalSamples,
+            totalSamples: response.stats.totalSamples
         }),
+        ...(response.stats?.enhancerBackendDevice !== undefined && {
+            enhancerBackendDevice: response.stats.enhancerBackendDevice
+        }),
+        ...(response.stats?.enhancerBackendId !== undefined && {
+            enhancerBackendId: response.stats.enhancerBackendId
+        })
     };
 }

package/dist/server/env.js

@@ -1,9 +1,9 @@
-import env from "bare-env";
-import { isBareKit } from "which-runtime";
-import { z } from "zod";
+import env from 'bare-env';
+import { isBareKit } from 'which-runtime';
+import { z } from 'zod';
 const envSchema = z.object({
     QVAC_IPC_SOCKET_PATH: z.string().optional(),
-    HOME_DIR: z.string(),
+    HOME_DIR: z.string()
 });
 let validatedEnv = null;
 /**
@@ -13,13 +13,13 @@ let validatedEnv = null;
 export function initEnv() {
     const defaultHomeDir = 
     // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
-    env["SNAP_USER_COMMON"] ?? env["HOME"] ?? env["USERPROFILE"] ?? "/tmp";
+    env['SNAP_USER_COMMON'] ?? env['HOME'] ?? env['USERPROFILE'] ?? '/tmp';
     let envConfig = {
-        HOME_DIR: defaultHomeDir,
+        HOME_DIR: defaultHomeDir
     };
     let hasRPCConfig = false;
     if (isBareKit && Bare.argv[0]) {
-        envConfig["HOME_DIR"] = Bare.argv[0];
+        envConfig['HOME_DIR'] = Bare.argv[0];
     }
     // Try to parse any argument as JSON config (fail gracefully)
     if (Bare.argv[2]) {
@@ -45,7 +45,7 @@ export function getEnv() {
     }
     return {
         ...env,
-        ...validatedEnv,
+        ...validatedEnv
     };
 }
 /**

package/dist/server/error-handlers.d.ts

@@ -1,5 +1,5 @@
-import type RPC from "bare-rpc";
-import { type ServerProfiler } from "./rpc/profiling/index";
+import type RPC from 'bare-rpc';
+import { type ServerProfiler } from './rpc/profiling/index';
 export declare function sendErrorResponse(req: RPC.IncomingRequest, error: unknown, profiler?: ServerProfiler): void;
-export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, error: unknown, profiler?: ServerProfiler): void;
+export declare function sendStreamErrorResponse(stream: ReturnType<RPC.IncomingRequest['createResponseStream']>, error: unknown, profiler?: ServerProfiler): void;
 //# sourceMappingURL=error-handlers.d.ts.map

package/dist/server/error-handlers.js

@@ -1,6 +1,6 @@
-import { createErrorResponse, responseSchema } from "../schemas/index.js";
-import { getServerLogger } from "../logging/index.js";
-import {} from "./rpc/profiling/index.js";
+import { createErrorResponse, responseSchema } from '../schemas/index.js';
+import { getServerLogger } from '../logging/index.js';
+import {} from './rpc/profiling/index.js';
 const logger = getServerLogger();
 function buildErrorResponseData(error, profiler) {
     const errorResponse = createErrorResponse(error);
@@ -10,23 +10,23 @@ function buildErrorResponseData(error, profiler) {
 }
 export function sendErrorResponse(req, error, profiler) {
     try {
-        req.reply(buildErrorResponseData(error, profiler), "utf-8");
+        req.reply(buildErrorResponseData(error, profiler), 'utf-8');
     }
     catch (responseError) {
-        logger.error("Failed to create error response:", responseError);
-        const fallbackError = createErrorResponse(new Error("Internal server error"));
-        req.reply(JSON.stringify(fallbackError), "utf-8");
+        logger.error('Failed to create error response:', responseError);
+        const fallbackError = createErrorResponse(new Error('Internal server error'));
+        req.reply(JSON.stringify(fallbackError), 'utf-8');
     }
 }
 export function sendStreamErrorResponse(stream, error, profiler) {
     try {
-        stream.write(buildErrorResponseData(error, profiler) + "\n", "utf-8");
+        stream.write(buildErrorResponseData(error, profiler) + '\n', 'utf-8');
         stream.end();
     }
     catch (responseError) {
-        logger.error("Failed to create stream error response:", responseError);
-        const fallbackError = createErrorResponse(new Error("Internal server error"));
-        stream.write(JSON.stringify(fallbackError) + "\n", "utf-8");
+        logger.error('Failed to create stream error response:', responseError);
+        const fallbackError = createErrorResponse(new Error('Internal server error'));
+        stream.write(JSON.stringify(fallbackError) + '\n', 'utf-8');
         stream.end();
     }
 }

package/dist/server/plugins/index.d.ts

@@ -1,2 +1,2 @@
-export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry";
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin } from './registry';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/index.js

@@ -1 +1 @@
-export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry.js";
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin } from './registry.js';

package/dist/server/plugins/registry.d.ts

@@ -1,4 +1,4 @@
-import { type QvacPlugin, type PluginHandlerDefinition } from "../../schemas/plugin";
+import { type QvacPlugin, type PluginHandlerDefinition } from '../../schemas/plugin';
 export declare function registerPlugin(plugin: QvacPlugin): void;
 export declare function registerPlugins(pluginList: readonly QvacPlugin[]): void;
 export declare function getPlugin(modelType: string): QvacPlugin | undefined;

package/dist/server/plugins/registry.js

@@ -1,18 +1,16 @@
-import { pluginDefinitionRuntimeSchema, } from "../../schemas/plugin.js";
-import { isModelTypeAlias } from "../../schemas/index.js";
-import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, PluginModelTypeReservedError, } from "../../utils/errors-server.js";
-import { createAddonLoggerCallback } from "../../logging/addon.js";
-import { formatZodError } from "../../utils/zod-error.js";
+import { pluginDefinitionRuntimeSchema } from '../../schemas/plugin.js';
+import { isModelTypeAlias } from '../../schemas/index.js';
+import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, PluginModelTypeReservedError } from '../../utils/errors-server.js';
+import { createAddonLoggerCallback } from '../../logging/addon.js';
+import { formatZodError } from '../../utils/zod-error.js';
 const plugins = new Map();
 function getModelTypeForError(plugin) {
-    if (!plugin || typeof plugin !== "object")
-        return "(unknown)";
-    if (!("modelType" in plugin))
-        return "(unknown)";
+    if (!plugin || typeof plugin !== 'object')
+        return '(unknown)';
+    if (!('modelType' in plugin))
+        return '(unknown)';
     const modelType = plugin.modelType;
-    return typeof modelType === "string" && modelType.length > 0
-        ? modelType
-        : "(unknown)";
+    return typeof modelType === 'string' && modelType.length > 0 ? modelType : '(unknown)';
 }
 function validatePluginDefinition(plugin) {
     const result = pluginDefinitionRuntimeSchema.safeParse(plugin);
@@ -31,8 +29,8 @@ export function registerPlugin(plugin) {
     // Validate logging module shape if provided
     if (plugin.logging?.module) {
         const loggingModule = plugin.logging.module;
-        if (typeof loggingModule["setLogger"] !== "function") {
-            throw new PluginLoggingInvalidError(plugin.modelType, "logging.module must have a setLogger(callback) function");
+        if (typeof loggingModule['setLogger'] !== 'function') {
+            throw new PluginLoggingInvalidError(plugin.modelType, 'logging.module must have a setLogger(callback) function');
         }
     }
     plugins.set(plugin.modelType, plugin);

package/dist/server/rpc/create-server.d.ts

@@ -1,4 +1,4 @@
-import RPC from "bare-rpc";
+import RPC from 'bare-rpc';
 export declare function createBareKitRPCServer(): RPC;
 export interface IPCClientOptions {
     onDisconnect?: () => void;

package/dist/server/rpc/create-server.js

@@ -1,24 +1,45 @@
-import RPC from "bare-rpc";
-import { connect } from "bare-net";
-import { handleRequest } from "./handle-request.js";
-import { getServerLogger } from "../../logging/index.js";
+import RPC from 'bare-rpc';
+import { connect } from 'bare-net';
+import { handleRequest } from './handle-request.js';
+import { getServerLogger } from '../../logging/index.js';
 const logger = getServerLogger();
 export function createBareKitRPCServer() {
-    const { IPC } = globalThis
-        .BareKit;
+    const { IPC } = globalThis.BareKit;
     return new RPC(IPC, handleRequest);
 }
+/**
+ * Dial the client's IPC endpoint. Two encodings cross the handshake:
+ *
+ * - `tcp://host:port` — a loopback TCP endpoint. Used by clients whose
+ *   runtime has no portable server for filesystem sockets, notably the
+ *   Python `asyncio` transport (`start_unix_server` is Unix-only, and
+ *   asyncio has no cross-platform named-pipe server). One code path on
+ *   every OS, so Windows dials the same way Linux/macOS do.
+ * - anything else — a filesystem path: a Unix domain socket, or a
+ *   `\\.\pipe\...` named pipe on Windows, as the Node client (`node:net`)
+ *   creates.
+ */
+function connectToEndpoint(endpoint) {
+    if (endpoint.startsWith('tcp://')) {
+        const hostPort = endpoint.slice('tcp://'.length);
+        const sep = hostPort.lastIndexOf(':');
+        const host = hostPort.slice(0, sep);
+        const port = Number(hostPort.slice(sep + 1));
+        return connect(port, host);
+    }
+    return connect(endpoint);
+}
 export function createIPCClient(socketPath, options) {
     logger.info(`Connecting to IPC socket at ${socketPath}`);
-    const socket = connect(socketPath);
-    socket.on("connect", () => {
-        logger.info("Connected to IPC server");
+    const socket = connectToEndpoint(socketPath);
+    socket.on('connect', () => {
+        logger.info('Connected to IPC server');
     });
-    socket.on("error", (err) => {
-        logger.error("IPC client connection error:", err);
+    socket.on('error', (err) => {
+        logger.error('IPC client connection error:', err);
     });
-    socket.on("close", () => {
-        logger.warn("IPC socket closed — parent process likely terminated");
+    socket.on('close', () => {
+        logger.warn('IPC socket closed — parent process likely terminated');
         options?.onDisconnect?.();
     });
     return new RPC(socket, handleRequest);

package/dist/server/rpc/delegate-transport.d.ts

@@ -4,9 +4,9 @@
  * This module provides `send` and `stream` functions for server-side
  * delegation to remote peers (via HyperSwarm RPC).
  */
-import type RPC from "bare-rpc";
-import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, type Request, type Response, type RPCOptions, type DelegationBreakdown, type OperationEvent } from "../../schemas/index";
-import type { DelegatedHandlerOptions } from "./profiling/index";
+import type RPC from 'bare-rpc';
+import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, type Request, type Response, type RPCOptions, type DelegationBreakdown, type OperationEvent } from '../../schemas/index';
+import type { DelegatedHandlerOptions } from './profiling/index';
 export interface DelegateOptions extends RPCOptions, DelegatedHandlerOptions {
     peerKey?: string;
 }