@qvac/sdk 0.16.0 → 0.17.1

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

@@ -1,3 +1,3 @@
-import type { HandlerEntry } from './handler-utils';
+import type { HandlerEntry } from './handler-utils.js';
 export declare function shouldUseStreamErrorTransport(entry: HandlerEntry | undefined, rawRequest: Record<string, unknown> | undefined): boolean;
 //# sourceMappingURL=transport-selector.d.ts.map

package/dist/server/utils/archive.js

@@ -5,7 +5,7 @@ import { createGunzip } from 'bare-zlib';
 import tarStream from 'tar-stream';
 import { detectShardedModel, generateShardFilenames, extractTensorsFromShards, validateShardedModelCache } from './shard-utils.js';
 import { ModelLoadFailedError, ArchiveExtractionFailedError, ArchiveUnsupportedTypeError, ArchiveMissingShardsError, DownloadCancelledError } from '../../utils/errors-server.js';
-import { isPathWithinBase } from './path-security.js';
+import { isPathWithinBase } from '../../server/utils/path-security.js';
 import { getServerLogger } from '../../logging/index.js';
 import { SUPPORTED_ARCHIVE_EXTENSIONS, filenameToArchiveTypeSchema } from '../../schemas/archive.js';
 const logger = getServerLogger();

package/dist/server/utils/audio/decoder.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'bare-stream';
-import { type AudioFormat } from '../../../schemas/index';
+import { type AudioFormat } from '../../../schemas/index.js';
 export declare function needsDecoding(filePath: string): boolean;
 export declare function decodeAudioToStream(inputPath: string, audioFormat?: AudioFormat): Promise<Readable>;
 //# sourceMappingURL=decoder.d.ts.map

package/dist/server/utils/audio/decoder.js

@@ -1,7 +1,7 @@
 import fs from 'bare-fs';
 import path from 'bare-path';
 import { FFmpegDecoder } from '@qvac/decoder-audio';
-import { FORMATS_NEEDING_DECODE } from '@qvac/decoder-audio/constants.js';
+import { FORMATS_NEEDING_DECODE } from '@qvac/decoder-audio/constants';
 import { Readable } from 'bare-stream';
 import { getServerLogger } from '../../../logging/index.js';
 import {} from '../../../schemas/index.js';

package/dist/server/utils/cache/auto-history.d.ts

@@ -1,4 +1,4 @@
-import type { CacheMessage } from './types';
+import type { CacheMessage } from './types.js';
 export declare function getAutoCacheLookupHistory(currentHistory: CacheMessage[]): CacheMessage[];
 export declare function buildAutoCacheSaveHistory(currentHistory: CacheMessage[], assistantResponse: string): CacheMessage[];
 //# sourceMappingURL=auto-history.d.ts.map

package/dist/server/utils/cache/paths.d.ts

@@ -1,4 +1,4 @@
-import type { ShardFileMetadata } from '../../../schemas/index';
+import type { ShardFileMetadata } from '../../../schemas/index.js';
 export declare function getCacheDir(subDir: string): string;
 export declare function getModelsCacheDir(): string;
 export declare function getKVCacheDir(): string;

package/dist/server/utils/cache/paths.js

@@ -1,13 +1,13 @@
 import fs, { promises as fsPromises } from 'bare-fs';
 import path from 'bare-path';
-import { getConfiguredCacheDir } from '../../bare/registry/config-registry.js';
-import { getQvacPath } from '../qvac-paths.js';
-import { calculateFileChecksum } from '../checksum.js';
-import { validateAndJoinPath } from '../path-security.js';
-import { generateShortHash } from '../formatting.js';
+import { getConfiguredCacheDir } from '../../../server/bare/registry/config-registry.js';
+import { getQvacPath } from '../../../server/utils/qvac-paths.js';
+import { calculateFileChecksum } from '../../../server/utils/checksum.js';
+import { validateAndJoinPath } from '../../../server/utils/path-security.js';
+import { generateShortHash } from '../../../server/utils/formatting.js';
 import { getServerLogger } from '../../../logging/index.js';
 import { nowMs } from '../../../profiling/index.js';
-import { resolveClearStorageTarget } from '../clear-storage.js';
+import { resolveClearStorageTarget } from '../../../server/utils/clear-storage.js';
 const logger = getServerLogger();
 export function getCacheDir(subDir) {
     const cacheDir = getQvacPath(subDir);

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

@@ -1,4 +1,4 @@
-import type { DownloadHooks } from '../rpc/handlers/load-model/types';
+import type { DownloadHooks } from '../../server/rpc/handlers/load-model/types.js';
 export declare function calculateFileChecksum(filePath: string): Promise<string>;
 export declare function measureChecksum(filePath: string, hooks?: DownloadHooks): Promise<string>;
 //# sourceMappingURL=checksum.d.ts.map

package/dist/server/utils/completion-normalizer.d.ts

@@ -1,4 +1,5 @@
-import type { CompletionEvent, CompletionError, CompletionStats, NormalizerConfig, StopReason, ToolCall } from '../../schemas/index';
+import type { CompletionEvent, CompletionError, CompletionStats, NormalizerConfig, StopReason, ToolCall } from '../../schemas/index.js';
+export declare const MAX_TOOL_FRAME_CHARS = 1048576;
 export type CompletionNormalizer = ReturnType<typeof createCompletionNormalizer>;
 export declare function createCompletionNormalizer(config: NormalizerConfig): {
     push: (token: string) => CompletionEvent[];

package/dist/server/utils/completion-normalizer.js

@@ -1,4 +1,9 @@
-import { parseToolCalls } from './tools/index.js';
+import { parseToolCalls } from '../../server/utils/tools/index.js';
+export const MAX_TOOL_FRAME_CHARS = 1_048_576;
+const DSML_INVOKE_FRAMES = [' ', '\n', '\t', '\r'].map((sep) => ({
+    open: `<｜DSML｜invoke${sep}`,
+    close: '</｜DSML｜invoke>'
+}));
 const DIALECT_SPECS = {
     hermes: {
         toolFrames: [{ open: '<tool_call>', close: '</tool_call>' }]
@@ -41,6 +46,13 @@ const DIALECT_SPECS = {
     gemma4: {
         toolFrames: [{ open: '<|tool_call>', close: '<tool_call|>' }],
         thinkingFrames: [{ open: '<|channel>thought', close: '<channel|>' }]
+    },
+    dsml: {
+        toolFrames: [
+            { open: '<｜DSML｜tool_calls>', close: '</｜DSML｜tool_calls>' },
+            { open: '<｜DSML｜function_calls>', close: '</｜DSML｜function_calls>' },
+            ...DSML_INVOKE_FRAMES
+        ]
     }
 };
 // Capture-gated reasoning marker — the generic `<think>...</think>`
@@ -217,6 +229,22 @@ export function createCompletionNormalizer(config) {
             emitContent(events, raw);
         }
     }
+    function abandonToolFrame(events) {
+        const raw = toolCallBuffer + toolFramingTail;
+        toolCallBuffer = '';
+        toolFramingTail = '';
+        activeToolFrame = null;
+        state = 'content';
+        events.push({
+            type: 'toolError',
+            seq: nextSeq(),
+            error: {
+                code: 'PARSE_ERROR',
+                message: `Tool call frame exceeded ${MAX_TOOL_FRAME_CHARS} characters without a close marker`
+            }
+        });
+        emitContent(events, raw);
+    }
     function getStateTail() {
         switch (state) {
             case 'content':
@@ -254,6 +282,8 @@ export function createCompletionNormalizer(config) {
                 toolCallBuffer += buf.slice(0, safeLen);
                 toolFramingTail = buf.slice(safeLen);
                 buf = '';
+                if (toolCallBuffer.length > MAX_TOOL_FRAME_CHARS)
+                    abandonToolFrame(events);
                 continue;
             }
             if (state === 'thinkingFraming') {

package/dist/server/utils/config-transform.d.ts

@@ -1,3 +1,3 @@
-import { type ModelTypeInput } from '../../schemas/index';
+import { type ModelTypeInput } from '../../schemas/index.js';
 export declare function transformConfigForReload(modelType: ModelTypeInput, config: unknown): unknown;
 //# sourceMappingURL=config-transform.d.ts.map

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() {