@qvac/sdk 0.15.0 → 0.17.0

package/dist/server/utils/config-transform.js

@@ -1,15 +1,13 @@
 import { normalizeModelType, ModelType } from '../../schemas/index.js';
+import { buildParakeetReloadConfig, buildWhisperReloadConfig } from '../../server/bare/plugins/asr-ggml/config.js';
 export function transformConfigForReload(modelType, config) {
     const canonicalType = normalizeModelType(modelType);
     switch (canonicalType) {
         case ModelType.whispercppTranscription: {
-            const whisperConfig = config;
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const { contextParams, miscConfig, ...whisperParams } = whisperConfig;
-            return {
-                whisperConfig: whisperParams,
-                ...(miscConfig && { miscConfig })
-            };
+            return buildWhisperReloadConfig(config);
+        }
+        case ModelType.parakeetTranscription: {
+            return buildParakeetReloadConfig(config);
         }
         case ModelType.llamacppCompletion:
         case ModelType.llamacppEmbedding:

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

@@ -1,12 +1,12 @@
-export * from './archive';
-export * from './cache/types';
-export * from './cache/auto-history';
-export * from './cache/paths';
-export * from './checksum';
-export * from './config-transform';
-export * from './expand-gguf-shards';
-export * from './formatting';
-export * from './gguf-tensor-extractor';
-export * from './path-security';
-export * from './shard-utils';
+export * from './archive.js';
+export * from './cache/types.js';
+export * from './cache/auto-history.js';
+export * from './cache/paths.js';
+export * from './checksum.js';
+export * from './config-transform.js';
+export * from './expand-gguf-shards.js';
+export * from './formatting.js';
+export * from './gguf-tensor-extractor.js';
+export * from './path-security.js';
+export * from './shard-utils.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/path-security.d.ts

@@ -1,4 +1,4 @@
-export { sanitizePathComponent } from '../../utils/path-sanitize';
+export { sanitizePathComponent } from '../../utils/path-sanitize.js';
 /**
  * Check whether a target path is contained within a base directory.
  * Both paths are resolved to absolute before comparison.

package/dist/server/utils/qvac-paths.js

@@ -1,5 +1,5 @@
 import path from 'bare-path';
-import { getEnv } from '../env.js';
+import { getEnv } from '../../server/env.js';
 export function getQvacPath(...subPaths) {
     return path.join(getEnv().HOME_DIR, '.qvac', ...subPaths);
 }

package/dist/server/utils/response-format.d.ts

@@ -1,3 +1,3 @@
-import type { ResponseFormat } from '../../schemas/index';
+import type { ResponseFormat } from '../../schemas/index.js';
 export declare function getResponseFormatJsonSchema(responseFormat: ResponseFormat): string | undefined;
 //# sourceMappingURL=response-format.d.ts.map

package/dist/server/utils/shard-utils.d.ts

@@ -1,4 +1,4 @@
-import type { ShardPatternInfo, ShardUrl } from '../../schemas/index';
+import type { ShardPatternInfo, ShardUrl } from '../../schemas/index.js';
 /**
  * Detect if model filename follows shard pattern (00001-of-0000x)
  */

package/dist/server/utils/tool-integration.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, ToolDialect } from '../../schemas/index';
+import type { Tool, ToolDialect } from '../../schemas/index.js';
 interface HistoryMessage {
     role: string;
     content: string;

package/dist/server/utils/tool-integration.js

@@ -1,5 +1,5 @@
-import { detectToolDialectFromName } from './tools/index.js';
-import { getModelInfo } from '../bare/registry/model-registry.js';
+import { detectToolDialectFromName } from '../../server/utils/tools/index.js';
+import { getModelInfo } from '../../server/bare/registry/model-registry.js';
 /**
  * Static tools mode: prepend tools right after the system message (or at the
  * very start when no system message is present). The tool block stays in the

package/dist/server/utils/tools/dialect.d.ts

@@ -1,4 +1,4 @@
-import type { ToolDialect } from '../../../schemas/index';
+import type { ToolDialect } from '../../../schemas/index.js';
 /**
  * Detects the tool-call dialect from a model's registry name and file path.
  * Defaults to "hermes" (its parser chain also covers unknown JSON-payload

package/dist/server/utils/tools/dialect.js

@@ -12,6 +12,8 @@ export function detectToolDialectFromName(name, path) {
         return 'gemma4';
     if (/gpt[_-]?oss/.test(tag))
         return 'harmony';
+    if (/deepseek[-_. ]?v(?:4|3[._-]?2)(?![0-9])/.test(tag))
+        return 'dsml';
     if (/lfm[_-]?\d/.test(tag))
         return 'pythonic';
     return 'hermes';

package/dist/server/utils/tools/index.d.ts

@@ -1,3 +1,3 @@
-export { detectToolDialectFromName } from './dialect';
-export { parseToolCalls } from './parser';
+export { detectToolDialectFromName } from './dialect.js';
+export { parseToolCalls } from './parser.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/utils/tools/parser.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, ToolCall, ToolCallError, ToolDialect } from '../../../schemas/index';
+import type { Tool, ToolCall, ToolCallError, ToolDialect } from '../../../schemas/index.js';
 export declare function parseToolCalls(text: string, tools: Tool[], dialect?: ToolDialect): {
     toolCalls: ToolCall[];
     errors: ToolCallError[];

package/dist/server/utils/tools/parser.js

@@ -1,10 +1,11 @@
-import { stripThinkingBlocks } from './shared.js';
-import { parseGemmaFormat, parseGenericFormat, parseLlamacppFormat } from './parsers/json.js';
-import { parseHermesFormat } from './parsers/hermes.js';
-import { parsePythonicFormat } from './parsers/pythonic.js';
-import { parseHarmonyFormat } from './parsers/harmony.js';
-import { parseQwen35Format } from './parsers/qwen35.js';
-import { parseGemma4NativeFormat } from './parsers/gemma4native.js';
+import { stripThinkingBlocks } from '../../../server/utils/tools/shared.js';
+import { parseGemmaFormat, parseGenericFormat, parseLlamacppFormat } from '../../../server/utils/tools/parsers/json.js';
+import { parseHermesFormat } from '../../../server/utils/tools/parsers/hermes.js';
+import { parsePythonicFormat } from '../../../server/utils/tools/parsers/pythonic.js';
+import { parseHarmonyFormat } from '../../../server/utils/tools/parsers/harmony.js';
+import { parseQwen35Format } from '../../../server/utils/tools/parsers/qwen35.js';
+import { parseGemma4NativeFormat } from '../../../server/utils/tools/parsers/gemma4native.js';
+import { parseDsmlFormat } from '../../../server/utils/tools/parsers/dsml.js';
 function pickFormatParsers(dialect) {
     switch (dialect) {
         case 'pythonic':
@@ -25,8 +26,14 @@ function pickFormatParsers(dialect) {
             // No JSON fallback: Gemma4 emits only its native channel-thought dialect
             // and never falls back to JSON-envelope formats.
             return [parseGemma4NativeFormat];
+        case 'dsml':
+            // Hermes fallback: DeepSeek templates fall back to OpenAI-style JSON when
+            // the DSML block fails to materialise.
+            return [parseDsmlFormat, parseHermesFormat, parseLlamacppFormat];
         default:
-            // Gemma4 first: `<|tool_call>` is uniquely distinctive and can't
+            // DSML first: the `<｜DSML｜` token is unique to DeepSeek and can't
+            // false-match another dialect.
+            // Gemma4 next: `<|tool_call>` is uniquely distinctive and can't
             // false-match other dialects.
             // Harmony next: `to=functions.` is also uniquely Harmony.
             // Qwen35 before Hermes: defers to Hermes when JSON is inside <tool_call>,
@@ -34,6 +41,7 @@ function pickFormatParsers(dialect) {
             // Pythonic last: its bare `[name(...)]` form can match payloads that
             // look like other dialects.
             return [
+                parseDsmlFormat,
                 parseGemma4NativeFormat,
                 parseHarmonyFormat,
                 parseQwen35Format,

package/dist/server/utils/tools/parsers/dsml.d.ts

@@ -0,0 +1,4 @@
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
+export declare function parseDsmlFormat(text: string, tools: Tool[]): ParserResult;
+//# sourceMappingURL=dsml.d.ts.map

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

@@ -0,0 +1,176 @@
+import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
+// DeepSeek marks DSML tags with a fullwidth vertical line (U+FF5C `｜`), not
+// the ASCII pipe used by the visually similar `<|...|>` markers of the harmony
+// and gemma4 dialects — the two must not be conflated. V4 wraps calls in
+// `tool_calls`; V3.2 used `function_calls`. Both carry the same invoke/
+// parameter grammar, so only the wrapper name differs.
+const OPENER_REGEX = /<｜DSML｜(?:tool_calls|function_calls|invoke)/;
+const INVOKE_OPEN_REGEX = /<｜DSML｜invoke([ \t\r\n][^>]*)?>/g;
+const INVOKE_CLOSE_TAG = '</｜DSML｜invoke>';
+const PARAMETER_REGEX = /<｜DSML｜parameter([ \t\r\n][^>]*)?>([\s\S]*?)<\/｜DSML｜parameter>/g;
+const NAME_ATTR_REGEX = /(?:^|\s)name="([^"]*)"/;
+const STRING_ATTR_REGEX = /(?:^|\s)string="(true|false)"/i;
+const FALLBACK_DIALECT_REGEX = /<tool_call>|"name"\s*:/;
+function coerceBySchemaType(value, type) {
+    switch (type) {
+        case 'number': {
+            const n = Number(value);
+            if (value.length === 0 || Number.isNaN(n))
+                throw new Error(`invalid number value: "${value}"`);
+            return n;
+        }
+        case 'integer': {
+            const n = Number(value);
+            if (value.length === 0 || Number.isNaN(n) || !Number.isInteger(n))
+                throw new Error(`invalid integer value: "${value}"`);
+            return n;
+        }
+        case 'boolean': {
+            const v = value.toLowerCase();
+            if (v === 'true')
+                return true;
+            if (v === 'false')
+                return false;
+            throw new Error(`invalid boolean value: "${value}"`);
+        }
+        case 'array':
+        case 'object':
+            return JSON.parse(value);
+        default:
+            return value;
+    }
+}
+function coerceParamValue(raw, isString, type) {
+    const trimmed = raw.trim();
+    if (isString === undefined)
+        return coerceBySchemaType(trimmed, type);
+    if (isString === 'true')
+        return trimmed;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch (err) {
+        throw new Error(`invalid JSON for string="false" parameter: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function collectInvokes(text) {
+    const openers = Array.from(text.matchAll(INVOKE_OPEN_REGEX));
+    return openers.map((opener, i) => {
+        const start = opener.index;
+        const bodyStart = start + opener[0].length;
+        const limit = openers[i + 1]?.index ?? text.length;
+        const rel = text.slice(bodyStart, limit).indexOf(INVOKE_CLOSE_TAG);
+        const closed = rel !== -1;
+        const closeAt = bodyStart + rel;
+        const end = closed ? closeAt + INVOKE_CLOSE_TAG.length : limit;
+        return {
+            attrs: opener[1] ?? '',
+            body: closed ? text.slice(bodyStart, closeAt) : '',
+            closed,
+            start,
+            consumedEnd: closed ? end : bodyStart,
+            raw: text.slice(start, end).trim()
+        };
+    });
+}
+function textOutsideInvokes(text, invokes) {
+    const parts = [];
+    let cursor = 0;
+    for (const invoke of invokes) {
+        parts.push(text.slice(cursor, invoke.start));
+        cursor = invoke.consumedEnd;
+    }
+    parts.push(text.slice(cursor));
+    return parts.join('\n');
+}
+// Parses DeepSeek's DSML tool-call dialect (V3.2 / V4):
+//   <｜DSML｜tool_calls>
+//   <｜DSML｜invoke name="NAME">
+//   <｜DSML｜parameter name="KEY" string="true">VALUE</｜DSML｜parameter>
+//   </｜DSML｜invoke>
+//   </｜DSML｜tool_calls>
+export function parseDsmlFormat(text, tools) {
+    const toolCalls = [];
+    const errors = [];
+    if (!OPENER_REGEX.test(text)) {
+        return { matched: false, toolCalls, errors };
+    }
+    // Invokes are collected from the whole text rather than per block: a block
+    // cut off before its close tag still carries complete invokes, and a single
+    // pass recovers them without re-counting the ones inside closed blocks.
+    const invokes = collectInvokes(text);
+    if (invokes.length === 0) {
+        if (FALLBACK_DIALECT_REGEX.test(text)) {
+            return { matched: false, toolCalls, errors };
+        }
+        return {
+            matched: true,
+            toolCalls,
+            errors: [
+                {
+                    code: 'PARSE_ERROR',
+                    message: 'DSML tool call block contains no <｜DSML｜invoke name="NAME"> element',
+                    raw: text.trim()
+                }
+            ]
+        };
+    }
+    for (const invoke of invokes) {
+        const raw = invoke.raw;
+        if (!invoke.closed) {
+            errors.push({
+                code: 'PARSE_ERROR',
+                message: `DSML invoke is missing its ${INVOKE_CLOSE_TAG} close tag`,
+                raw
+            });
+            continue;
+        }
+        const name = NAME_ATTR_REGEX.exec(invoke.attrs)?.[1]?.trim();
+        if (!name) {
+            errors.push({
+                code: 'PARSE_ERROR',
+                message: 'DSML invoke is missing a name attribute',
+                raw
+            });
+            continue;
+        }
+        const properties = tools.find((t) => t.name === name)?.parameters?.properties ?? {};
+        const args = {};
+        let parseError;
+        for (const param of invoke.body.matchAll(PARAMETER_REGEX)) {
+            const attrs = param[1] ?? '';
+            const key = NAME_ATTR_REGEX.exec(attrs)?.[1]?.trim();
+            if (!key) {
+                parseError = 'DSML parameter is missing a name attribute';
+                break;
+            }
+            const isString = STRING_ATTR_REGEX.exec(attrs)?.[1]?.toLowerCase();
+            try {
+                args[key] = coerceParamValue(param[2], isString, properties[key]?.type);
+            }
+            catch (err) {
+                parseError = `${key}: ${err instanceof Error ? err.message : String(err)}`;
+                break;
+            }
+        }
+        if (parseError !== undefined) {
+            errors.push({ code: 'PARSE_ERROR', message: parseError, raw });
+            continue;
+        }
+        const validation = validateToolArguments(name, args, tools);
+        if (!validation.isValid && validation.error) {
+            errors.push({ ...validation.error, raw });
+            continue;
+        }
+        toolCalls.push({
+            id: generateStableToolCallId(name, args),
+            name,
+            arguments: args,
+            raw
+        });
+    }
+    if (toolCalls.length === 0 && FALLBACK_DIALECT_REGEX.test(textOutsideInvokes(text, invokes))) {
+        return { matched: false, toolCalls: [], errors: [] };
+    }
+    return { matched: true, toolCalls, errors };
+}

package/dist/server/utils/tools/parsers/gemma4native.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '../../../../schemas/index';
-import { type ParserResult } from '../shared';
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
 export declare function parseGemma4NativeFormat(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=gemma4native.d.ts.map

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

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, validateToolArguments } from '../shared.js';
+import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
 // Transliterates Gemma 4's JS-literal argument body to valid JSON so it can
 // be parsed with JSON.parse. The body uses:
 //   - <|"|>...<|"|> instead of "..." for string values

package/dist/server/utils/tools/parsers/harmony.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '../../../../schemas/index';
-import { type ParserResult } from '../shared';
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
 export declare function parseHarmonyFormat(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=harmony.d.ts.map

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

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, validateToolArguments } from '../shared.js';
+import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
 const HARMONY_FRAME_RE = /to=functions\.([\w-]+)\s+<\|constrain\|>json<\|message\|>([\s\S]*?)(?=<\|call\|>|$)/g;
 export function parseHarmonyFormat(text, tools) {
     const toolCalls = [];

package/dist/server/utils/tools/parsers/hermes.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '../../../../schemas/index';
-import { type ParserResult } from '../shared';
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
 export declare function parseHermesFormat(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=hermes.d.ts.map

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

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../shared.js';
+import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../../../../server/utils/tools/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)

package/dist/server/utils/tools/parsers/json.d.ts

@@ -1,5 +1,5 @@
-import type { Tool } from '../../../../schemas/index';
-import { type ParserResult } from '../shared';
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
 export declare function parseGemmaFormat(text: string, tools: Tool[]): ParserResult;
 export declare function parseLlamacppFormat(text: string, tools: Tool[]): ParserResult;
 export declare function parseGenericFormat(text: string, tools: Tool[]): ParserResult;

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

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../shared.js';
+import { generateStableToolCallId, isValidToolCall, validateToolArguments } from '../../../../server/utils/tools/shared.js';
 export function parseGemmaFormat(text, tools) {
     const toolCalls = [];
     const errors = [];

package/dist/server/utils/tools/parsers/pythonic.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '../../../../schemas/index';
-import { type ParserResult } from '../shared';
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
 export declare function parsePythonicFormat(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=pythonic.d.ts.map

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

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, validateToolArguments } from '../shared.js';
+import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
 // Pythonic `[name(k=v), ...]` arrays. LFM 2.x is auto-routed; Llama-style
 // tokens are kept for callers that opt in via `completion({ toolDialect:
 // "pythonic" })` for a model known to emit Pythonic. Pure string parsing —

package/dist/server/utils/tools/parsers/qwen35.d.ts

@@ -1,4 +1,4 @@
-import type { Tool } from '../../../../schemas/index';
-import { type ParserResult } from '../shared';
+import type { Tool } from '../../../../schemas/index.js';
+import { type ParserResult } from '../../../../server/utils/tools/shared.js';
 export declare function parseQwen35Format(text: string, tools: Tool[]): ParserResult;
 //# sourceMappingURL=qwen35.d.ts.map

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

@@ -1,4 +1,4 @@
-import { generateStableToolCallId, validateToolArguments } from '../shared.js';
+import { generateStableToolCallId, validateToolArguments } from '../../../../server/utils/tools/shared.js';
 // Coerce raw parameter text to the type declared in the tool's JSON schema.
 // String values are raw (not JSON-quoted); arrays/objects are valid JSON.
 function coerceParamValue(raw, schema) {

package/dist/server/utils/tools/shared.d.ts

@@ -1,4 +1,4 @@
-import type { Tool, ToolCall, ToolCallError } from '../../../schemas/index';
+import type { Tool, ToolCall, ToolCallError } from '../../../schemas/index.js';
 export type ParserResult = {
     matched: boolean;
     toolCalls: ToolCall[];

package/dist/server/utils/worker-lock.js

@@ -2,7 +2,7 @@ import fs from 'bare-fs';
 import path from 'bare-path';
 import os from 'bare-os';
 import { getServerLogger } from '../../logging/index.js';
-import { getQvacPath } from './qvac-paths.js';
+import { getQvacPath } from '../../server/utils/qvac-paths.js';
 const logger = getServerLogger();
 const LOCK_FILENAME = '.worker.lock';
 function getLockFilePath() {

package/dist/server/worker-core.js

@@ -1,16 +1,18 @@
 import os from 'bare-os';
 import Signal from 'bare-signals';
-import { createBareKitRPCServer, createIPCClient } from './rpc/create-server.js';
-import { destroySwarm } from './bare/hyperswarm.js';
-import { initEnv, getValidatedEnv } from './env.js';
-import { closeAllRagInstances } from './bare/rag-hyperdb/index.js';
-import { cleanupDownloads } from './rpc/handlers/load-model/download-manager.js';
-import { unloadAllModels } from './bare/registry/model-registry.js';
-import { closeRegistryClient } from './bare/registry/registry-client.js';
-import { clearAllLoggingStreams, startLogBuffering, stopLogBufferingWithTimeout } from './bare/registry/logging-stream-registry.js';
+import { createBareKitRPCServer, createIPCClient } from '../server/rpc/create-server.js';
+import { destroySwarm } from '../server/bare/hyperswarm.js';
+import { initEnv, getValidatedEnv } from '../server/env.js';
+import { closeAllRagInstances } from '../server/bare/rag-hyperdb/index.js';
+import { cleanupDownloads } from '../server/rpc/handlers/load-model/download-manager.js';
+import { unloadAllModels } from '../server/bare/registry/model-registry.js';
+import { closeRegistryClient } from '../server/bare/registry/registry-client.js';
+import { clearAllLoggingStreams, startLogBuffering, stopLogBufferingWithTimeout } from '../server/bare/registry/logging-stream-registry.js';
 import { clearAllAddonLoggers, getServerLogger, SDK_LOG_ID, SDK_ALL_LOG_ID } from '../logging/index.js';
-import { clearPlugins } from './plugins/index.js';
-import { acquireWorkerLock, releaseWorkerLock } from './utils/worker-lock.js';
+import { clearPlugins } from '../server/plugins/index.js';
+import { acquireWorkerLock, releaseWorkerLock } from '../server/utils/worker-lock.js';
+import { nativeResourceCollectorDependencies } from '../server/bare/resources/native.js';
+import { destroyWorkerResourceCollector, initializeWorkerResourceCollector } from '../server/bare/resources/worker-collector.js';
 let coreInitialized = false;
 let rpcInitialized = false;
 // Set true when the cleanup body has run at least once. Lets both
@@ -57,6 +59,7 @@ export function initializeWorkerCore() {
     startLogBuffering(SDK_ALL_LOG_ID);
     const { hasRPCConfig } = initEnv();
     acquireWorkerLock();
+    initializeWorkerResourceCollector(nativeResourceCollectorDependencies);
     setupShutdownHandlers();
     coreInitialized = true;
     logger.debug('Worker core initialized');
@@ -122,6 +125,7 @@ async function runCleanup() {
     if (cleanupRan)
         return;
     cleanupRan = true;
+    destroyWorkerResourceCollector();
     clearRegistries();
     await Promise.allSettled([
         destroySwarm(),

package/dist/server/worker.js

@@ -1,10 +1,10 @@
 /**
  * Default worker entry point that registers ALL built-in plugins.
  */
-import { initializeWorkerCore, ensureRPCSetup } from './worker-core.js';
-import { registerPlugins } from './plugins/index.js';
+import { initializeWorkerCore, ensureRPCSetup } from '../server/worker-core.js';
+import { registerPlugins } from '../server/plugins/index.js';
 import { getServerLogger } from '../logging/index.js';
-import { llmPlugin, embeddingsPlugin, whisperPlugin, bciPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, vlaPlugin, classificationPlugin } from './bare/plugins/index.js';
+import { llmPlugin, embeddingsPlugin, whisperPlugin, bciPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, audioGenPlugin, vlaPlugin, classificationPlugin } from '../server/bare/plugins/index.js';
 const { hasRPCConfig } = initializeWorkerCore();
 const logger = getServerLogger();
 logger.info('🐻 Hello from Bare');
@@ -18,6 +18,7 @@ registerPlugins([
     ttsPlugin,
     ocrPlugin,
     diffusionPlugin,
+    audioGenPlugin,
     vlaPlugin,
     classificationPlugin
 ]);

package/dist/utils/aggregate-events.d.ts

@@ -1,5 +1,5 @@
-import type { CompletionError, CompletionEvent, CompletionFinal, CompletionStats, StopReason, ToolCall } from '../schemas/index';
-import { type ToolHandlerMap } from './tool-helpers';
+import type { CompletionError, CompletionEvent, CompletionFinal, CompletionStats, StopReason, ToolCall } from '../schemas/index.js';
+import { type ToolHandlerMap } from '../utils/tool-helpers.js';
 export type AggregatedEvents = {
     contentText: string;
     thinkingText: string;

package/dist/utils/aggregate-events.js

@@ -1,5 +1,5 @@
-import { normalizeAssistantCacheContent } from './cache-normalize.js';
-import { attachHandlersToToolCalls } from './tool-helpers.js';
+import { normalizeAssistantCacheContent } from '../utils/cache-normalize.js';
+import { attachHandlersToToolCalls } from '../utils/tool-helpers.js';
 export function aggregateEvents(events) {
     let contentText = '';
     let thinkingText = '';

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

@@ -124,9 +124,6 @@ export declare class TranscriptionFailedError extends QvacErrorBase {
 export declare class TextToSpeechStreamFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
-export declare class TranslationFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
 export declare class CancelFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -219,11 +219,6 @@ export class TextToSpeechStreamFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_STREAM_FAILED, details ? [details] : undefined, cause));
     }
 }
-export class TranslationFailedError extends QvacErrorBase {
-    constructor(details, cause) {
-        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TRANSLATION_FAILED, details ? [details] : undefined, cause));
-    }
-}
 export class CancelFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CANCEL_FAILED, details ? [details] : undefined, cause));

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

@@ -1,5 +1,5 @@
 import { QvacErrorBase } from '@qvac/error';
-import type { CompletionStats, ToolCallWithCall } from '../schemas/index';
+import type { CompletionStats, ToolCallWithCall } from '../schemas/index.js';
 /**
  * Partial completion payload attached to `InferenceCancelledError` when a
  * cancel hits mid-stream. Mirrors the named fields on `CompletionFinal`

package/dist/utils/mcp-adapter.d.ts

@@ -1,7 +1,7 @@
-import type { Tool } from '../schemas/tools';
-import type { McpClientInput } from '../schemas/mcp-adapter';
-import type { ToolHandler } from './tool-helpers';
-export type { McpClient, McpClientInput } from '../schemas/mcp-adapter';
+import type { Tool } from '../schemas/tools.js';
+import type { McpClientInput } from '../schemas/mcp-adapter.js';
+import type { ToolHandler } from '../utils/tool-helpers.js';
+export type { McpClient, McpClientInput } from '../schemas/mcp-adapter.js';
 export type ToolHandlerMap = Map<string, ToolHandler>;
 export type McpToolsResult = {
     tools: Tool[];

package/dist/utils/mcp-adapter.js

@@ -1,4 +1,4 @@
-import { mapValues } from './object.js';
+import { mapValues } from '../utils/object.js';
 const VALID_TYPES = ['string', 'number', 'integer', 'boolean', 'object', 'array'];
 function isValidType(value) {
     return typeof value === 'string' && VALID_TYPES.includes(value);

package/dist/utils/tool-helpers.d.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import { type Tool, type ToolCall, type ToolCallWithCall } from '../schemas/tools';
+import { type Tool, type ToolCall, type ToolCallWithCall } from '../schemas/tools.js';
 type ZodObjectType = z.ZodObject<z.ZodRawShape>;
 export type ToolHandler = (args: Record<string, unknown>) => Promise<unknown>;
 export type ToolInput<T extends ZodObjectType = ZodObjectType> = {

package/dist/utils/tool-helpers.js

@@ -1,5 +1,5 @@
 import { toolSchema } from '../schemas/tools.js';
-import { InvalidToolsArrayError, InvalidToolSchemaError } from './errors-client.js';
+import { InvalidToolsArrayError, InvalidToolSchemaError } from '../utils/errors-client.js';
 function zodTypeToJsonSchemaType(type) {
     switch (type) {
         case 'string':