@qvac/sdk 0.15.0 → 0.17.0

package/dist/server/rpc/handlers/unload-model.js

@@ -1,6 +1,6 @@
-import { unloadModel } from '../../bare/ops/unload-model.js';
-import { getRegistryStats } from '../../bare/registry/model-registry.js';
-import { hasActiveProviders } from '../../bare/hyperswarm.js';
+import { unloadModel } from '../../../server/bare/ops/unload-model.js';
+import { getRegistryStats } from '../../../server/bare/registry/model-registry.js';
+import { hasActiveProviders } from '../../../server/bare/hyperswarm.js';
 import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 export async function handleUnloadModel(request) {

package/dist/server/rpc/handlers/upscale-stream.d.ts

@@ -1,3 +1,3 @@
-import type { UpscaleStreamRequest, UpscaleStreamResponse } from '../../../schemas/sdcpp-config';
+import type { UpscaleStreamRequest, UpscaleStreamResponse } from '../../../schemas/sdcpp-config.js';
 export declare function handleUpscaleStream(request: UpscaleStreamRequest): AsyncGenerator<UpscaleStreamResponse>;
 //# sourceMappingURL=upscale-stream.d.ts.map

package/dist/server/rpc/handlers/upscale-stream.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from './plugin-dispatch.js';
+import { dispatchPluginStream } from '../../../server/rpc/handlers/plugin-dispatch.js';
 export async function* handleUpscaleStream(request) {
     yield* dispatchPluginStream(request.modelId, 'upscaleStream', request);
 }

package/dist/server/rpc/handlers/video-stream.d.ts

@@ -1,3 +1,3 @@
-import type { VideoStreamRequest, VideoStreamResponse } from '../../../schemas/sdcpp-config';
+import type { VideoStreamRequest, VideoStreamResponse } from '../../../schemas/sdcpp-config.js';
 export declare function handleVideoStream(request: VideoStreamRequest): AsyncGenerator<VideoStreamResponse>;
 //# sourceMappingURL=video-stream.d.ts.map

package/dist/server/rpc/handlers/video-stream.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from './plugin-dispatch.js';
+import { dispatchPluginStream } from '../../../server/rpc/handlers/plugin-dispatch.js';
 export async function* handleVideoStream(request) {
     yield* dispatchPluginStream(request.modelId, 'videoStream', request);
 }

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

@@ -1,3 +1,3 @@
-export { createBareKitRPCServer, createIPCClient } from './create-server';
-export { handleRequest } from './handle-request';
+export { createBareKitRPCServer, createIPCClient } from './create-server.js';
+export { handleRequest } from './handle-request.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/rpc/method-shapes.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Call shape of every RPC method, keyed by the request `type` literal.
+ *
+ * This module must stay free of handler imports: the contract export
+ * (`scripts/export-contract.ts`) loads it under Node, where the handler
+ * graph's native bare-* modules cannot be required. `handler-registry.ts`
+ * is type-bound to this map, so a registry entry whose key or `type`
+ * diverges from it fails to compile.
+ */
+export declare const methodShapes: {
+    readonly audioGenStream: "stream";
+    readonly batchCompletionStream: "stream";
+    readonly bciTranscribe: "stream";
+    readonly bciTranscribeStream: "duplex";
+    readonly cancel: "reply";
+    readonly classify: "stream";
+    readonly completionOrchestrate: "duplex";
+    readonly completionStream: "stream";
+    readonly deleteCache: "reply";
+    readonly diffusionStream: "stream";
+    readonly downloadAsset: "reply";
+    readonly embed: "reply";
+    readonly finetune: "reply";
+    readonly getLoadedModelInfo: "reply";
+    readonly getModelInfo: "reply";
+    readonly getSystemResources: "reply";
+    readonly heartbeat: "reply";
+    readonly loadModel: "reply";
+    readonly loggingStream: "stream";
+    readonly modelRegistryGetModel: "reply";
+    readonly modelRegistryList: "reply";
+    readonly modelRegistrySearch: "reply";
+    readonly ocrStream: "stream";
+    readonly pluginInvoke: "reply";
+    readonly pluginInvokeStream: "stream";
+    readonly provide: "reply";
+    readonly rag: "reply";
+    readonly resume: "reply";
+    readonly state: "reply";
+    readonly stopProvide: "reply";
+    readonly suspend: "reply";
+    readonly textToSpeech: "stream";
+    readonly textToSpeechStream: "duplex";
+    readonly transcribe: "stream";
+    readonly transcribeStream: "duplex";
+    readonly translate: "stream";
+    readonly unloadModel: "reply";
+    readonly upscaleStream: "stream";
+    readonly videoStream: "stream";
+};
+export type MethodName = keyof typeof methodShapes;
+export type MethodCallShape = (typeof methodShapes)[MethodName];
+//# sourceMappingURL=method-shapes.d.ts.map

package/dist/server/rpc/method-shapes.js

@@ -0,0 +1,50 @@
+/**
+ * Call shape of every RPC method, keyed by the request `type` literal.
+ *
+ * This module must stay free of handler imports: the contract export
+ * (`scripts/export-contract.ts`) loads it under Node, where the handler
+ * graph's native bare-* modules cannot be required. `handler-registry.ts`
+ * is type-bound to this map, so a registry entry whose key or `type`
+ * diverges from it fails to compile.
+ */
+export const methodShapes = {
+    audioGenStream: 'stream',
+    batchCompletionStream: 'stream',
+    bciTranscribe: 'stream',
+    bciTranscribeStream: 'duplex',
+    cancel: 'reply',
+    classify: 'stream',
+    completionOrchestrate: 'duplex',
+    completionStream: 'stream',
+    deleteCache: 'reply',
+    diffusionStream: 'stream',
+    downloadAsset: 'reply',
+    embed: 'reply',
+    finetune: 'reply',
+    getLoadedModelInfo: 'reply',
+    getModelInfo: 'reply',
+    getSystemResources: 'reply',
+    heartbeat: 'reply',
+    loadModel: 'reply',
+    loggingStream: 'stream',
+    modelRegistryGetModel: 'reply',
+    modelRegistryList: 'reply',
+    modelRegistrySearch: 'reply',
+    ocrStream: 'stream',
+    pluginInvoke: 'reply',
+    pluginInvokeStream: 'stream',
+    provide: 'reply',
+    rag: 'reply',
+    resume: 'reply',
+    state: 'reply',
+    stopProvide: 'reply',
+    suspend: 'reply',
+    textToSpeech: 'stream',
+    textToSpeechStream: 'duplex',
+    transcribe: 'stream',
+    transcribeStream: 'duplex',
+    translate: 'stream',
+    unloadModel: 'reply',
+    upscaleStream: 'stream',
+    videoStream: 'stream'
+};

package/dist/server/rpc/profiling/backend-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type InferenceBackendDiagnostics } from '../../../schemas/index.js';
+export declare function readBackendDiagnostics(target: unknown): InferenceBackendDiagnostics | undefined;
+//# sourceMappingURL=backend-diagnostics.d.ts.map

package/dist/server/rpc/profiling/backend-diagnostics.js

@@ -0,0 +1,16 @@
+import { getServerLogger } from '../../../logging/index.js';
+import { BACKEND_DIAGNOSTICS_KEY, inferenceBackendDiagnosticsSchema } from '../../../schemas/index.js';
+const logger = getServerLogger();
+export function readBackendDiagnostics(target) {
+    if (!target || typeof target !== 'object')
+        return undefined;
+    const diagnostics = target[BACKEND_DIAGNOSTICS_KEY];
+    if (diagnostics === undefined)
+        return undefined;
+    const result = inferenceBackendDiagnosticsSchema.safeParse(diagnostics);
+    if (!result.success) {
+        logger.debug('Ignoring invalid backend diagnostics', result.error);
+        return undefined;
+    }
+    return result.data;
+}

package/dist/server/rpc/profiling/context.d.ts

@@ -1,4 +1,4 @@
-import { type ProfilingRequestMeta, type DelegationBreakdown, type OperationEvent } from '../../../schemas/index';
+import { type ProfilingRequestMeta, type DelegationBreakdown, type OperationEvent } from '../../../schemas/index.js';
 export interface ServerProfilingContext {
     meta: ProfilingRequestMeta;
     requestStart: number;

package/dist/server/rpc/profiling/delegation-profiler.d.ts

@@ -1,5 +1,5 @@
-import { type BaseTimings } from '../../../profiling/index';
-import type { ProfilingRequestMeta, ProfilingResponseMeta, DelegationBreakdown } from '../../../schemas/index';
+import { type BaseTimings } from '../../../profiling/index.js';
+import type { ProfilingRequestMeta, ProfilingResponseMeta, DelegationBreakdown } from '../../../schemas/index.js';
 export interface DelegatedHandlerOptions {
     profilingMeta?: ProfilingRequestMeta;
 }

package/dist/server/rpc/profiling/index.d.ts

@@ -1,5 +1,5 @@
-export { createServerProfiler, type ServerProfiler } from './profiler';
-export { profileReplyHandler, profileStreamHandler } from './operation-wrappers';
-export { registerOperationMetrics, buildOperationEvent, type OperationMetricsConfig } from './operation-metrics';
-export { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, cacheDelegationConnectionTime, flushServerConnectionEvent, consumeBreakdownConnectionTime, clearPeerConnectionTracking, resetDelegationConnectionTracking, type DelegationTimings, type DelegationStreamTimings, type DelegatedHandlerOptions } from './delegation-profiler';
+export { createServerProfiler, type ServerProfiler } from './profiler.js';
+export { profileReplyHandler, profileStreamHandler } from './operation-wrappers.js';
+export { registerOperationMetrics, buildOperationEvent, type OperationMetricsConfig } from './operation-metrics.js';
+export { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, cacheDelegationConnectionTime, flushServerConnectionEvent, consumeBreakdownConnectionTime, clearPeerConnectionTracking, resetDelegationConnectionTracking, type DelegationTimings, type DelegationStreamTimings, type DelegatedHandlerOptions } from './delegation-profiler.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/server/rpc/profiling/operation-metrics.d.ts

@@ -2,8 +2,8 @@
  * Declarative extraction of operation-level metrics from request/response data.
  * Used by operation wrappers to capture handler-specific profiling events.
  */
-import type { ProfilingEvent, ProfilingEventKind } from '../../../profiling/types';
-import type { DownloadStats } from '../handlers/load-model/types';
+import type { ProfilingEvent, ProfilingEventKind } from '../../../profiling/types.js';
+import type { DownloadStats } from '../../../server/rpc/handlers/load-model/types.js';
 export type MetricExtractor<T> = (data: T) => Record<string, number> | undefined;
 export type TagExtractor<T> = (data: T) => Record<string, string> | undefined;
 export interface OperationMetricsConfig<TRequest = unknown, TResponse = unknown> {

package/dist/server/rpc/profiling/operation-metrics.js

@@ -4,6 +4,7 @@
  */
 import {} from '../../../schemas/index.js';
 import { readModelExecutionMs } from '../../../profiling/model-execution.js';
+import { readBackendDiagnostics } from './backend-diagnostics.js';
 const metricsRegistry = new Map();
 function extractDownloadStatsGauges(stats, gauges) {
     if (stats?.downloadTimeMs !== undefined) {
@@ -21,14 +22,18 @@ export function registerOperationMetrics(config) {
 }
 export function buildOperationEvent(op, profileId, ts, executionMs, request, finalResponse, ttfb) {
     const config = metricsRegistry.get(op);
+    const backend = readBackendDiagnostics(finalResponse);
     if (!config) {
-        return {
+        const event = {
             ts,
             op,
             kind: 'handler',
             profileId,
             ms: executionMs
         };
+        if (backend)
+            event.backend = backend;
+        return event;
     }
     const gauges = {};
     if (ttfb !== undefined) {
@@ -64,6 +69,9 @@ export function buildOperationEvent(op, profileId, ts, executionMs, request, fin
     if (hasGauges) {
         event.gauges = gauges;
     }
+    if (backend) {
+        event.backend = backend;
+    }
     if (hasTags) {
         event.tags = tags;
     }
@@ -233,6 +241,16 @@ registerOperationMetrics({
         const gauges = {};
         if (res.stats.generationMs !== undefined)
             gauges['generationMs'] = res.stats.generationMs;
+        if (res.stats.conditionerMs !== undefined)
+            gauges['conditionerMs'] = res.stats.conditionerMs;
+        if (res.stats.denoiseMs !== undefined)
+            gauges['denoiseMs'] = res.stats.denoiseMs;
+        if (res.stats.vaeMs !== undefined)
+            gauges['vaeMs'] = res.stats.vaeMs;
+        if (res.stats.postProcessMs !== undefined)
+            gauges['postProcessMs'] = res.stats.postProcessMs;
+        if (res.stats.stepsPerSecond !== undefined)
+            gauges['stepsPerSecond'] = res.stats.stepsPerSecond;
         if (res.stats.totalSteps !== undefined)
             gauges['totalSteps'] = res.stats.totalSteps;
         if (res.stats.totalImages !== undefined)
@@ -252,6 +270,16 @@ registerOperationMetrics({
         const gauges = {};
         if (res.stats.generationMs !== undefined)
             gauges['generationMs'] = res.stats.generationMs;
+        if (res.stats.conditionerMs !== undefined)
+            gauges['conditionerMs'] = res.stats.conditionerMs;
+        if (res.stats.denoiseMs !== undefined)
+            gauges['denoiseMs'] = res.stats.denoiseMs;
+        if (res.stats.vaeMs !== undefined)
+            gauges['vaeMs'] = res.stats.vaeMs;
+        if (res.stats.postProcessMs !== undefined)
+            gauges['postProcessMs'] = res.stats.postProcessMs;
+        if (res.stats.stepsPerSecond !== undefined)
+            gauges['stepsPerSecond'] = res.stats.stepsPerSecond;
         if (res.stats.totalSteps !== undefined)
             gauges['totalSteps'] = res.stats.totalSteps;
         if (res.stats.totalVideos !== undefined)

package/dist/server/rpc/profiling/operation-wrappers.d.ts

@@ -2,7 +2,7 @@
  * Generic wrappers for profiling handler execution.
  * Used to wrap dispatch/invoke functions with timing capture.
  */
-import { type PerCallProfiling } from '../../../schemas/index';
+import { type PerCallProfiling } from '../../../schemas/index.js';
 export interface ProfiledReplyOptions<TRequest> {
     op: string;
     request: TRequest;

package/dist/server/rpc/profiling/operation-wrappers.js

@@ -4,9 +4,10 @@
  */
 import { PROFILING_KEY, OPERATION_EVENT_KEY } from '../../../schemas/index.js';
 import { nowMs, generateProfileId } from '../../../profiling/clock.js';
-import { record, shouldProfile } from '../../../profiling/controller.js';
+import { record, shouldIncludeResourceGauges, shouldProfile } from '../../../profiling/controller.js';
+import { getWorkerResourceCollector } from '../../../server/bare/resources/worker-collector.js';
 import { buildOperationEvent } from './operation-metrics.js';
-import { isTerminalChunk } from '../rpc-utils';
+import { isTerminalChunk } from '../rpc-utils.js';
 function getRequestProfilingMeta(request) {
     if (!request || typeof request !== 'object') {
         return undefined;
@@ -17,21 +18,47 @@ function getRequestProfilingMeta(request) {
     }
     return meta;
 }
-function resolvePerCallProfiling(options) {
+function resolveOperationProfiling(options) {
     if (options.perCall) {
-        return options.perCall;
+        return { perCall: options.perCall, resourceOrigin: 'local' };
     }
     const meta = getRequestProfilingMeta(options.request);
     if (!meta) {
-        return undefined;
+        return { perCall: undefined, resourceOrigin: 'local' };
     }
     if (meta.enabled === false) {
-        return { enabled: false };
+        return {
+            perCall: { enabled: false },
+            resourceOrigin: meta.resourceOrigin ?? 'local'
+        };
     }
     return {
-        enabled: true,
-        includeServerBreakdown: meta.includeServer,
-        mode: meta.mode
+        perCall: {
+            enabled: true,
+            includeServerBreakdown: meta.includeServer,
+            includeResourceGauges: meta.includeResources,
+            mode: meta.mode
+        },
+        resourceOrigin: meta.resourceOrigin ?? 'local'
+    };
+}
+function toProfilerResourceGauge(sample, sampledAt, origin) {
+    const gpus = sample.gpus.status === 'supported'
+        ? {
+            ...sample.gpus,
+            value: sample.gpus.value.map((gpu) => ({
+                id: gpu.id,
+                compute: gpu.compute,
+                memoryUsedBytes: gpu.memoryUsedBytes
+            }))
+        }
+        : sample.gpus;
+    return {
+        origin,
+        sampledAt,
+        cpu: sample.cpu,
+        memory: sample.memory,
+        gpus
     };
 }
 function buildAndRecordOperationEvent(params) {
@@ -44,12 +71,18 @@ function buildAndRecordOperationEvent(params) {
     if (params.count !== undefined && params.count > 0) {
         event.count = params.count;
     }
+    if (shouldIncludeResourceGauges(params.profiling.perCall)) {
+        const resources = getWorkerResourceCollector()?.sample();
+        if (resources) {
+            event.resources = toProfilerResourceGauge(resources, nowMs(), params.profiling.resourceOrigin);
+        }
+    }
     record(event);
     return event;
 }
 export async function profileReplyHandler(options, handler) {
-    const perCall = resolvePerCallProfiling(options);
-    if (!shouldProfile(options.op, perCall)) {
+    const profiling = resolveOperationProfiling(options);
+    if (!shouldProfile(options.op, profiling.perCall)) {
         return handler();
     }
     const profileId = generateProfileId();
@@ -59,6 +92,7 @@ export async function profileReplyHandler(options, handler) {
         const executionMs = nowMs() - startTs;
         const event = buildAndRecordOperationEvent({
             options,
+            profiling,
             profileId,
             startTs,
             executionMs,
@@ -74,6 +108,7 @@ export async function profileReplyHandler(options, handler) {
         const executionMs = nowMs() - startTs;
         buildAndRecordOperationEvent({
             options,
+            profiling,
             profileId,
             startTs,
             executionMs,
@@ -83,8 +118,8 @@ export async function profileReplyHandler(options, handler) {
     }
 }
 export async function* profileStreamHandler(options, handler) {
-    const perCall = resolvePerCallProfiling(options);
-    if (!shouldProfile(options.op, perCall)) {
+    const profiling = resolveOperationProfiling(options);
+    if (!shouldProfile(options.op, profiling.perCall)) {
         return yield* handler();
     }
     const profileId = generateProfileId();
@@ -102,6 +137,7 @@ export async function* profileStreamHandler(options, handler) {
                     const executionMs = nowMs() - startTs;
                     buildAndRecordOperationEvent({
                         options,
+                        profiling,
                         profileId,
                         startTs,
                         executionMs,
@@ -122,6 +158,7 @@ export async function* profileStreamHandler(options, handler) {
                 const executionMs = nowMs() - startTs;
                 const event = buildAndRecordOperationEvent({
                     options,
+                    profiling,
                     profileId,
                     startTs,
                     executionMs,
@@ -142,6 +179,7 @@ export async function* profileStreamHandler(options, handler) {
         const executionMs = nowMs() - startTs;
         buildAndRecordOperationEvent({
             options,
+            profiling,
             profileId,
             startTs,
             executionMs,

package/dist/server/rpc/profiling/profiler.d.ts

@@ -1,5 +1,5 @@
-import { type Response, type ProfilingRequestMeta } from '../../../schemas/index';
-import { type ServerProfilingContext } from './context';
+import { type Response, type ProfilingRequestMeta } from '../../../schemas/index.js';
+import { type ServerProfilingContext } from './context.js';
 export type ServerProfiler = {
     markRequestParsed: (ms: number) => void;
     markRequestValidated: (ms: number) => void;

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/auto-history.js

@@ -1,22 +1,26 @@
 import { normalizeAssistantCacheContent } from '../../../utils/cache-normalize.js';
-function normalizeAssistantMessage(message) {
-    if (message.role !== 'assistant') {
-        return message;
+function normalizeCacheMessage(message) {
+    const { attachments, ...normalized } = message;
+    if (message.role === 'assistant') {
+        normalized.content = normalizeAssistantCacheContent(message.content);
     }
-    return { ...message, content: normalizeAssistantCacheContent(message.content) };
+    return {
+        ...normalized,
+        ...(attachments && attachments.length > 0 ? { attachments } : {})
+    };
 }
 export function getAutoCacheLookupHistory(currentHistory) {
     if (currentHistory.length <= 1) {
         return [];
     }
-    return currentHistory.slice(0, -1).map(normalizeAssistantMessage);
+    return currentHistory.slice(0, -1).map(normalizeCacheMessage);
 }
 export function buildAutoCacheSaveHistory(currentHistory, assistantResponse) {
     return [
-        ...currentHistory,
-        {
+        ...currentHistory.map(normalizeCacheMessage),
+        normalizeCacheMessage({
             role: 'assistant',
-            content: normalizeAssistantCacheContent(assistantResponse)
-        }
+            content: assistantResponse
+        })
     ];
 }

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