@qvac/sdk 0.14.0 → 0.15.0

package/dist/server/bare/ops/bci-transcribe.js

@@ -50,23 +50,23 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { getModel } from "../registry/model-registry.js";
-import {} from "../../../schemas/index.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { TranscriptionFailedError } from "../../../utils/errors-server.js";
-import { nowMs } from "../../../profiling/index.js";
-import { buildStreamResult } from "../../../profiling/model-execution.js";
-import { toTranscribeSegment, } from "../utils/transcribe-metadata.js";
-import { getRequestRegistry, withRequestContext, } from "../runtime/index.js";
-import { generateServerRequestId } from "../runtime/request-id.js";
+import { getModel } from '../registry/model-registry.js';
+import {} from '../../../schemas/index.js';
+import { getServerLogger } from '../../../logging/index.js';
+import { TranscriptionFailedError } from '../../../utils/errors-server.js';
+import { nowMs } from '../../../profiling/index.js';
+import { buildStreamResult } from '../../../profiling/model-execution.js';
+import { toTranscribeSegment } from '../utils/transcribe-metadata.js';
+import { getRequestRegistry, withRequestContext } from '../runtime/index.js';
+import { generateServerRequestId } from '../runtime/request-id.js';
 async function runBci(model, input) {
     switch (input.type) {
-        case "base64":
-            return model.transcribe(Buffer.from(input.value, "base64"));
-        case "filePath":
+        case 'base64':
+            return model.transcribe(Buffer.from(input.value, 'base64'));
+        case 'filePath':
             return model.transcribeFile(input.value);
         default:
-            throw new TranscriptionFailedError("Invalid neural input");
+            throw new TranscriptionFailedError('Invalid neural input');
     }
 }
 export async function* bciTranscribe(params, requestId) {
@@ -79,8 +79,8 @@ export async function* bciTranscribe(params, requestId) {
         // client didn't send one.
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
-            kind: "transcribe",
-            modelId,
+            kind: 'transcribe',
+            modelId
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
         const model = getModel(modelId);
@@ -89,24 +89,24 @@ export async function* bciTranscribe(params, requestId) {
         // `if (ctx.signal.aborted) break` below is the soft-cancel safety net
         // for the gap between the abort firing and the iterator's next pull.
         const onAbort = () => {
-            if (typeof model.cancel === "function") {
+            if (typeof model.cancel === 'function') {
                 model.cancel().catch((err) => {
                     requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
                 });
             }
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
         if (ctx.signal.aborted)
             onAbort();
         ctx.scope.defer(() => {
-            ctx.signal.removeEventListener("abort", onAbort);
+            ctx.signal.removeEventListener('abort', onAbort);
         });
         const modelStart = nowMs();
         const response = await runBci(model, params.neuralData);
         for await (const output of response.iterate()) {
             if (ctx.signal.aborted)
                 break;
-            requestLogger.debug("BCI Transcription Update:", output);
+            requestLogger.debug('BCI Transcription Update:', output);
             const chunks = Array.isArray(output) ? output : [output];
             if (metadata) {
                 for (const chunk of chunks) {
@@ -116,7 +116,7 @@ export async function* bciTranscribe(params, requestId) {
                 }
                 continue;
             }
-            const text = chunks.map((chunk) => chunk.text).join("");
+            const text = chunks.map((chunk) => chunk.text).join('');
             if (text.trim()) {
                 yield text;
             }
@@ -124,47 +124,47 @@ export async function* bciTranscribe(params, requestId) {
         const modelExecutionMs = nowMs() - modelStart;
         const stats = {
             ...(response.stats?.audioDurationMs !== undefined && {
-                audioDuration: response.stats.audioDurationMs,
+                audioDuration: response.stats.audioDurationMs
             }),
             ...(response.stats?.realTimeFactor !== undefined && {
-                realTimeFactor: response.stats.realTimeFactor,
+                realTimeFactor: response.stats.realTimeFactor
             }),
             ...(response.stats?.tokensPerSecond !== undefined && {
-                tokensPerSecond: response.stats.tokensPerSecond,
+                tokensPerSecond: response.stats.tokensPerSecond
             }),
             ...(response.stats?.totalTokens !== undefined && {
-                totalTokens: response.stats.totalTokens,
+                totalTokens: response.stats.totalTokens
             }),
             ...(response.stats?.totalSegments !== undefined && {
-                totalSegments: response.stats.totalSegments,
+                totalSegments: response.stats.totalSegments
             }),
             ...(response.stats?.whisperEncodeMs !== undefined && {
-                whisperEncodeTime: response.stats.whisperEncodeMs,
+                whisperEncodeTime: response.stats.whisperEncodeMs
             }),
             ...(response.stats?.whisperDecodeMs !== undefined && {
-                whisperDecodeTime: response.stats.whisperDecodeMs,
+                whisperDecodeTime: response.stats.whisperDecodeMs
             }),
             ...(response.stats?.encoderMs !== undefined && {
-                encoderTime: response.stats.encoderMs,
+                encoderTime: response.stats.encoderMs
             }),
             ...(response.stats?.decoderMs !== undefined && {
-                decoderTime: response.stats.decoderMs,
+                decoderTime: response.stats.decoderMs
             }),
             ...(response.stats?.melSpecMs !== undefined && {
-                melSpecTime: response.stats.melSpecMs,
+                melSpecTime: response.stats.melSpecMs
             }),
             ...(response.stats?.backendDevice !== undefined && {
-                backendDevice: response.stats.backendDevice,
+                backendDevice: response.stats.backendDevice
             }),
             ...(response.stats?.backendId !== undefined && {
-                backendId: response.stats.backendId,
+                backendId: response.stats.backendId
             }),
             ...(response.stats?.gpuMemTotalMb !== undefined && {
-                gpuMemTotalMb: response.stats.gpuMemTotalMb,
+                gpuMemTotalMb: response.stats.gpuMemTotalMb
             }),
             ...(response.stats?.gpuMemFreeMb !== undefined && {
-                gpuMemFreeMb: response.stats.gpuMemFreeMb,
-            }),
+                gpuMemFreeMb: response.stats.gpuMemFreeMb
+            })
         };
         return buildStreamResult(modelExecutionMs, stats);
     }
@@ -187,8 +187,8 @@ export async function* bciTranscribeStream(modelId, neuralStream, metadata, opts
         // either shape.
         const ctx = __addDisposableResource(env_2, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
-            kind: "transcribe",
-            modelId,
+            kind: 'transcribe',
+            modelId
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
         const model = getModel(modelId);
@@ -197,30 +197,30 @@ export async function* bciTranscribeStream(modelId, neuralStream, metadata, opts
         // below is the soft-cancel safety net between the abort firing and the
         // iterator's next pull.
         const onAbort = () => {
-            if (typeof model.cancel === "function") {
+            if (typeof model.cancel === 'function') {
                 model.cancel().catch((err) => {
                     requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
                 });
             }
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
         if (ctx.signal.aborted)
             onAbort();
         ctx.scope.defer(() => {
-            ctx.signal.removeEventListener("abort", onAbort);
+            ctx.signal.removeEventListener('abort', onAbort);
         });
         const streamOpts = {
             ...(opts?.windowTimesteps !== undefined && {
-                windowTimesteps: opts.windowTimesteps,
+                windowTimesteps: opts.windowTimesteps
             }),
             ...(opts?.hopTimesteps !== undefined && { hopTimesteps: opts.hopTimesteps }),
-            ...(opts?.emit !== undefined && { emit: opts.emit }),
+            ...(opts?.emit !== undefined && { emit: opts.emit })
         };
         const response = await model.transcribeStream(neuralStream, streamOpts);
         for await (const output of response.iterate()) {
             if (ctx.signal.aborted)
                 break;
-            requestLogger.debug("BCI Stream Transcription Update:", output);
+            requestLogger.debug('BCI Stream Transcription Update:', output);
             const chunks = Array.isArray(output) ? output : [output];
             if (metadata) {
                 for (const chunk of chunks) {
@@ -230,7 +230,7 @@ export async function* bciTranscribeStream(modelId, neuralStream, metadata, opts
                 }
                 continue;
             }
-            const text = chunks.map((chunk) => chunk.text).join("");
+            const text = chunks.map((chunk) => chunk.text).join('');
             if (text.trim()) {
                 yield text;
             }

package/dist/server/bare/ops/cancel.d.ts

@@ -1,5 +1,5 @@
-import { type CancelInferenceBaseParams } from "../../../schemas/index";
-import type { RequestKind } from "../runtime/index";
+import { type CancelInferenceBaseParams } from '../../../schemas/index';
+import type { RequestKind } from '../runtime/index';
 /**
  * Broad cancel: abort every in-flight request matching `modelId` (and
  * optionally a `kind`). Maps onto `RequestRegistry.cancel({ modelId })`

package/dist/server/bare/ops/cancel.js

@@ -1,8 +1,8 @@
-import { getModel } from "../registry/model-registry.js";
-import { cancelInferenceBaseSchema, } from "../../../schemas/index.js";
-import { ModelNotLoadedError } from "../../../utils/errors-server.js";
-import { getRequestRegistry } from "../runtime/index.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { getModel } from '../registry/model-registry.js';
+import { cancelInferenceBaseSchema } from '../../../schemas/index.js';
+import { ModelNotLoadedError } from '../../../utils/errors-server.js';
+import { getRequestRegistry } from '../runtime/index.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 /**
  * Broad cancel: abort every in-flight request matching `modelId` (and
@@ -40,7 +40,7 @@ export function cancel(params, opts) {
         // Callers (workbench "Stop" button, app shutdown sweeps) often
         // fire-and-forget; log so operators can see when a broad cancel
         // landed against a registry with nothing in flight on this model.
-        logger.debug(`[cancel] no in-flight request matched modelId=${modelId}${opts?.kind ? ` kind=${opts.kind}` : ""}`);
+        logger.debug(`[cancel] no in-flight request matched modelId=${modelId}${opts?.kind ? ` kind=${opts.kind}` : ''}`);
     }
     return cancelled;
 }

package/dist/server/bare/ops/embed.d.ts

@@ -1,4 +1,4 @@
-import { type EmbedParams, type EmbedStats } from "../../../schemas/index";
+import { type EmbedParams, type EmbedStats } from '../../../schemas/index';
 export interface EmbedResult {
     embedding: number[] | number[][];
     stats?: EmbedStats;

package/dist/server/bare/ops/embed.js

@@ -50,14 +50,14 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { getModel } from "../registry/model-registry.js";
-import { embedParamsSchema } from "../../../schemas/index.js";
-import { buildUnaryResult } from "../../../profiling/model-execution.js";
-import { EmbedNoEmbeddingsError, EmbedFailedError, InferenceCancelledError, } from "../../../utils/errors-server.js";
-import { nowMs } from "../../../profiling/index.js";
-import { getRequestRegistry, withRequestContext, } from "../runtime/index.js";
-import { generateServerRequestId } from "../runtime/request-id.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { getModel } from '../registry/model-registry.js';
+import { embedParamsSchema } from '../../../schemas/index.js';
+import { buildUnaryResult } from '../../../profiling/model-execution.js';
+import { EmbedNoEmbeddingsError, EmbedFailedError, InferenceCancelledError } from '../../../utils/errors-server.js';
+import { nowMs } from '../../../profiling/index.js';
+import { getRequestRegistry, withRequestContext } from '../runtime/index.js';
+import { generateServerRequestId } from '../runtime/request-id.js';
+import { getServerLogger } from '../../../logging/index.js';
 export async function embed(params, requestId) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
@@ -68,9 +68,15 @@ export async function embed(params, requestId) {
         // id if the client didn't send one (older releases).
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
-            kind: "embeddings",
-            modelId,
-        }), true);
+            kind: 'embeddings',
+            modelId
+        })
+        // `requestLogger` is intentionally referenced once so the
+        // request-scoped logger is built at handler entry per the canonical
+        // shape, even when this op has no per-step emits beyond the
+        // registry's own lifecycle lines. Future addon-level warns inside
+        // this body should route through `requestLogger`.
+        , true);
         // `requestLogger` is intentionally referenced once so the
         // request-scoped logger is built at handler entry per the canonical
         // shape, even when this op has no per-step emits beyond the
@@ -95,7 +101,7 @@ export async function embed(params, requestId) {
                 });
             }
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
         // `{ once: true }` does not fire if the signal is already aborted at
         // register time. The registry may abort synchronously when a
         // cancel-before-begin race resolves or the parent signal was pre-
@@ -104,7 +110,7 @@ export async function embed(params, requestId) {
         if (ctx.signal.aborted)
             onAbort();
         ctx.scope.defer(() => {
-            ctx.signal.removeEventListener("abort", onAbort);
+            ctx.signal.removeEventListener('abort', onAbort);
         });
         const modelStart = nowMs();
         const response = (await model.run(text));
@@ -118,10 +124,14 @@ export async function embed(params, requestId) {
         const modelExecutionMs = nowMs() - modelStart;
         const stats = {
             ...(response.stats?.total_time_ms !== undefined && { totalTime: response.stats.total_time_ms }),
-            ...(response.stats?.tokens_per_second !== undefined && { tokensPerSecond: response.stats.tokens_per_second }),
+            ...(response.stats?.tokens_per_second !== undefined && {
+                tokensPerSecond: response.stats.tokens_per_second
+            }),
             ...(response.stats?.total_tokens !== undefined && { totalTokens: response.stats.total_tokens }),
-            ...(response.stats?.backendDevice !== undefined && { backendDevice: response.stats.backendDevice }),
-            ...(response.stats?.context_size !== undefined && { contextSize: response.stats.context_size }),
+            ...(response.stats?.backendDevice !== undefined && {
+                backendDevice: response.stats.backendDevice
+            }),
+            ...(response.stats?.context_size !== undefined && { contextSize: response.stats.context_size })
         };
         const embeddingsArray = rawEmbeddings[0];
         if (Array.isArray(text)) {

package/dist/server/bare/ops/kv-cache-utils.d.ts

@@ -1,4 +1,4 @@
-import { type CacheMessage } from "../../utils/index";
+import { type CacheMessage } from '../../utils/index';
 export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
 export declare function generateConfigHash(systemPrompt: string | null, tools?: unknown): string;
 export declare function generateCacheKey(messages: CacheMessage[]): string;

package/dist/server/bare/ops/kv-cache-utils.js

@@ -1,16 +1,16 @@
-import crypto from "bare-crypto";
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { getAutoCacheLookupHistory, getKVCacheDir, validateAndJoinPath, } from "../../utils/index.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { Buffer } from "bare-buffer";
+import crypto from 'bare-crypto';
+import { promises as fsPromises } from 'bare-fs';
+import path from 'bare-path';
+import { getAutoCacheLookupHistory, getKVCacheDir, validateAndJoinPath } from '../../utils/index.js';
+import { getServerLogger } from '../../../logging/index.js';
+import { Buffer } from 'bare-buffer';
 const logger = getServerLogger();
 // In-memory KV-cache state lives in `KvCacheSession` (the single
 // mutation point for all three KV-cache bookkeeping layers). This
 // module keeps only the pure path / hash utilities that don't touch
 // in-memory state.
 export function extractSystemPrompt(messages) {
-    const systemMessage = messages.find((msg) => msg.role === "system");
+    const systemMessage = messages.find((msg) => msg.role === 'system');
     return systemMessage ? systemMessage.content : null;
 }
 function getToolNamesForHash(tools) {
@@ -18,23 +18,23 @@ function getToolNamesForHash(tools) {
         return [];
     return tools
         .map((t) => t.name)
-        .filter((n) => typeof n === "string")
+        .filter((n) => typeof n === 'string')
         .sort();
 }
 // Cache hash based on system prompt + tool names
 // Different tools = different cache (tools anchored in first message, protected from n_discarded)
 export function generateConfigHash(systemPrompt, tools) {
-    const hash = crypto.createHash("sha-256");
+    const hash = crypto.createHash('sha-256');
     const toolNames = getToolNamesForHash(tools);
-    hash.update(Buffer.from(JSON.stringify({ systemPrompt, toolNames }), "utf8"));
-    return (hash.digest("hex")).substring(0, 16);
+    hash.update(Buffer.from(JSON.stringify({ systemPrompt, toolNames }), 'utf8'));
+    return hash.digest('hex').substring(0, 16);
 }
 export function generateCacheKey(messages) {
-    const hash = crypto.createHash("sha-256");
+    const hash = crypto.createHash('sha-256');
     const historyString = JSON.stringify(messages);
-    const historyBuffer = Buffer.from(historyString, "utf8");
+    const historyBuffer = Buffer.from(historyString, 'utf8');
     hash.update(historyBuffer);
-    const hashString = hash.digest("hex");
+    const hashString = hash.digest('hex');
     return hashString.substring(0, 16);
 }
 export async function getCacheFilePath(modelId, configHash, cacheKey) {
@@ -77,7 +77,7 @@ export async function renameCacheFile(oldPath, newPath) {
         return true;
     }
     catch (error) {
-        logger.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
+        logger.error('Error renaming cache file:', error instanceof Error ? error.message : String(error));
         return false;
     }
 }
@@ -87,15 +87,13 @@ export async function renameCacheFile(oldPath, newPath) {
 // avoids drift between the two layers.
 export async function deleteCache(options) {
     const cacheDir = getKVCacheDir();
-    if ("all" in options) {
+    if ('all' in options) {
         await fsPromises.rm(cacheDir, { recursive: true, force: true });
         await fsPromises.mkdir(cacheDir, { recursive: true });
         return cacheDir;
     }
     const kvCacheDir = validateAndJoinPath(cacheDir, options.kvCacheKey);
-    const targetDir = options.modelId !== undefined
-        ? validateAndJoinPath(kvCacheDir, options.modelId)
-        : kvCacheDir;
+    const targetDir = options.modelId !== undefined ? validateAndJoinPath(kvCacheDir, options.modelId) : kvCacheDir;
     await fsPromises.rm(targetDir, { recursive: true, force: true });
     return targetDir;
 }

package/dist/server/bare/ops/load-model.d.ts

@@ -1,5 +1,5 @@
-import { type LoadModelServerParams } from "../../../schemas/index";
-import type { LoadTimingStats } from "../../../profiling/types";
+import { type LoadModelServerParams } from '../../../schemas/index';
+import type { LoadTimingStats } from '../../../profiling/types';
 export interface LoadModelResult {
     timing?: LoadTimingStats;
 }

package/dist/server/bare/ops/load-model.js

@@ -1,13 +1,13 @@
-import { loadModelServerParamsSchema, normalizeModelType, } from "../../../schemas/index.js";
-import { nowMs } from "../../../profiling/clock.js";
-import { isModelLoaded, registerModel, } from "../registry/model-registry.js";
-import { startLogBuffering, stopLogBufferingWithTimeout, } from "../registry/logging-stream-registry.js";
-import { detectShardedModel, generateShardFilenames, validateShardedModelCache, } from "../../utils/index.js";
-import { PluginNotFoundError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError, } from "../../../utils/errors-server.js";
-import { getPlugin } from "../../plugins/index.js";
-import { promises as fsPromises } from "bare-fs";
-import path from "bare-path";
-import { getServerLogger } from "../../../logging/index.js";
+import { loadModelServerParamsSchema, normalizeModelType } from '../../../schemas/index.js';
+import { nowMs } from '../../../profiling/clock.js';
+import { isModelLoaded, registerModel } from '../registry/model-registry.js';
+import { startLogBuffering, stopLogBufferingWithTimeout } from '../registry/logging-stream-registry.js';
+import { detectShardedModel, generateShardFilenames, validateShardedModelCache } from '../../utils/index.js';
+import { PluginNotFoundError, ModelFileNotFoundError, ModelFileNotFoundInDirError, ModelFileLocateFailedError } from '../../../utils/errors-server.js';
+import { getPlugin } from '../../plugins/index.js';
+import { promises as fsPromises } from 'bare-fs';
+import path from 'bare-path';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 export async function loadModel(params, options) {
     const { modelId, modelPath, options: modelOptions, artifacts, modelName } = loadModelServerParamsSchema.parse(params);
@@ -60,23 +60,19 @@ export async function loadModel(params, options) {
             modelPath,
             modelConfig: modelConfig,
             modelName,
-            artifacts,
+            artifacts
         });
         await result.model.load(false);
-        const modelInitializationTimeMs = options?.collectTiming
-            ? nowMs() - initStart
-            : undefined;
+        const modelInitializationTimeMs = options?.collectTiming ? nowMs() - initStart : undefined;
         logger.info(`${modelType} model ${modelId} loaded`);
         registerModel(modelId, {
             model: result.model,
             path: modelPath,
             config: modelConfig,
             modelType: modelType,
-            name: modelName,
+            name: modelName
         });
-        return modelInitializationTimeMs !== undefined
-            ? { timing: { modelInitializationTimeMs } }
-            : {};
+        return modelInitializationTimeMs !== undefined ? { timing: { modelInitializationTimeMs } } : {};
     }
     finally {
         stopLogBufferingWithTimeout(modelId);

package/dist/server/bare/ops/transcribe.d.ts

@@ -1,6 +1,6 @@
-import { type TranscribeParams, type TranscribeSegment, type TranscribeStats, type TranscribeStreamEvent, type ParakeetStreamingRunConfig } from "../../../schemas/index";
-import { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment } from "../utils/transcribe-metadata";
-export { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment, };
+import { type TranscribeParams, type TranscribeSegment, type TranscribeStats, type TranscribeStreamEvent, type ParakeetStreamingRunConfig } from '../../../schemas/index';
+import { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment } from '../utils/transcribe-metadata';
+export { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment };
 type TranscribeReturn = {
     modelExecutionMs: number;
     stats?: TranscribeStats;