@qvac/sdk 0.14.0 → 0.15.0

package/dist/server/rpc/handler-utils.d.ts

@@ -1,28 +1,28 @@
-import { type QvacConfig, type Request, type Response, type RuntimeContext } from "../../schemas/index";
-import type RPC from "bare-rpc";
-import { type ServerProfiler } from "./profiling/index";
+import { type QvacConfig, type Request, type Response, type RuntimeContext } from '../../schemas/index';
+import type RPC from 'bare-rpc';
+import { type ServerProfiler } from './profiling/index';
 type ReplyHandler = (request: any, ...args: any[]) => Promise<Response> | Response;
 type StreamHandler = (request: any, ...args: any[]) => AsyncGenerator<Response>;
 type ProgressHandler = (request: any, ...args: any[]) => Promise<Response>;
 type DuplexStreamHandler = (request: any, inputStream: any) => AsyncGenerator<Response>;
 export type HandlerEntry = {
-    type: "reply" | "stream" | "duplex";
+    type: 'reply' | 'stream' | 'duplex';
     handler: ReplyHandler | StreamHandler | ProgressHandler | DuplexStreamHandler;
     delegatedHandler?: ReplyHandler | StreamHandler | ProgressHandler | DuplexStreamHandler;
     isDelegated?: (request: Request) => boolean;
     supportsProgress?: boolean | ((request: Request) => boolean);
 };
-export declare function executeDuplexHandler(_req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, inputStream: ReturnType<RPC.IncomingRequest["createRequestStream"]>, outputStream: ReturnType<RPC.IncomingRequest["createResponseStream"]>, profiler: ServerProfiler): Promise<void>;
+export declare function executeDuplexHandler(_req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, inputStream: ReturnType<RPC.IncomingRequest['createRequestStream']>, outputStream: ReturnType<RPC.IncomingRequest['createResponseStream']>, profiler: ServerProfiler): Promise<void>;
 export declare function executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, profiler: ServerProfiler): Promise<void>;
 type InitConfigMessage = {
-    type: "__init_config";
+    type: '__init_config';
     config: QvacConfig;
     runtimeContext?: RuntimeContext;
 };
 export declare function isInitConfigMessage(data: unknown): data is InitConfigMessage;
 export declare function handleInitConfig(req: RPC.IncomingRequest, data: InitConfigMessage): void;
 type ShutdownMessage = {
-    type: "__shutdown__";
+    type: '__shutdown__';
 };
 export declare function isShutdownMessage(data: unknown): data is ShutdownMessage;
 export declare function handleShutdown(req: RPC.IncomingRequest): Promise<void>;

package/dist/server/rpc/handler-utils.js

@@ -1,12 +1,12 @@
-import { PROFILING_KEY, } from "../../schemas/index.js";
-import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
-import { PluginHandlerTypeMismatchError } from "../../utils/errors-server.js";
-import { setSDKConfig } from "../bare/registry/config-registry.js";
-import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
-import {} from "./profiling/index.js";
-import { isTerminalChunk } from "./rpc-utils.js";
-import { createProgressThrottle } from "./progress-throttle.js";
-import { handlerSupportsProgress, selectHandler, } from "./handler-selection.js";
+import { PROFILING_KEY } from '../../schemas/index.js';
+import { sendErrorResponse, sendStreamErrorResponse } from '../error-handlers.js';
+import { PluginHandlerTypeMismatchError } from '../../utils/errors-server.js';
+import { setSDKConfig } from '../bare/registry/config-registry.js';
+import { setRuntimeContext } from '../bare/registry/runtime-context-registry.js';
+import {} from './profiling/index.js';
+import { isTerminalChunk } from './rpc-utils.js';
+import { createProgressThrottle } from './progress-throttle.js';
+import { handlerSupportsProgress, selectHandler } from './handler-selection.js';
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -25,7 +25,7 @@ async function executeReplyHandler(req, request, handler, profiler, isDelegated)
             response = await handler(request);
         }
         profiler.endHandler();
-        req.reply(profiler.serialize(response, true), "utf-8");
+        req.reply(profiler.serialize(response, true), 'utf-8');
     }
     catch (error) {
         profiler.endHandler();
@@ -49,11 +49,11 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
         for await (const response of generator) {
             if (isTerminalChunk(response)) {
                 profiler.endHandler();
-                stream.write(profiler.serialize(response, true) + "\n", "utf-8");
+                stream.write(profiler.serialize(response, true) + '\n', 'utf-8');
                 sentFinalChunk = true;
             }
             else {
-                stream.write(profiler.serialize(response, false) + "\n", "utf-8");
+                stream.write(profiler.serialize(response, false) + '\n', 'utf-8');
             }
         }
         // Fallback
@@ -61,7 +61,7 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
             profiler.endHandler();
             const trailer = profiler.serialize();
             if (trailer) {
-                stream.write(trailer + "\n", "utf-8");
+                stream.write(trailer + '\n', 'utf-8');
             }
         }
         stream.end();
@@ -75,8 +75,8 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
     const stream = req.createResponseStream();
     profiler.startHandler();
     const writeBatch = (updates) => {
-        const payload = updates.map((u) => profiler.serialize(u, false)).join("\n");
-        stream.write(payload + "\n", "utf-8");
+        const payload = updates.map((u) => profiler.serialize(u, false)).join('\n');
+        stream.write(payload + '\n', 'utf-8');
     };
     const throttle = createProgressThrottle(writeBatch);
     try {
@@ -94,7 +94,7 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
         }
         throttle.flush();
         profiler.endHandler();
-        stream.write(profiler.serialize(response, true) + "\n", "utf-8");
+        stream.write(profiler.serialize(response, true) + '\n', 'utf-8');
         stream.end();
     }
     catch (error) {
@@ -108,12 +108,12 @@ export async function executeDuplexHandler(_req, request, entry, inputStream, ou
     profiler.startHandler();
     try {
         for await (const response of handler(request, inputStream)) {
-            outputStream.write(profiler.serialize(response, false) + "\n", "utf-8");
+            outputStream.write(profiler.serialize(response, false) + '\n', 'utf-8');
         }
         profiler.endHandler();
         const trailer = profiler.serialize();
         if (trailer) {
-            outputStream.write(trailer + "\n", "utf-8");
+            outputStream.write(trailer + '\n', 'utf-8');
         }
         outputStream.end();
     }
@@ -126,10 +126,10 @@ export async function executeDuplexHandler(_req, request, entry, inputStream, ou
 export async function executeHandler(req, request, entry, profiler) {
     const { handler, isDelegated } = selectHandler(entry, request);
     const wantsProgress = handlerSupportsProgress(entry, request);
-    if (entry.type === "duplex") {
-        throw new PluginHandlerTypeMismatchError(request.type, "reply or stream", "duplex");
+    if (entry.type === 'duplex') {
+        throw new PluginHandlerTypeMismatchError(request.type, 'reply or stream', 'duplex');
     }
-    if (entry.type === "stream") {
+    if (entry.type === 'stream') {
         await executeStreamHandler(req, request, handler, profiler, isDelegated);
     }
     else if (wantsProgress) {
@@ -140,10 +140,7 @@ export async function executeHandler(req, request, entry, profiler) {
     }
 }
 export function isInitConfigMessage(data) {
-    return (typeof data === "object" &&
-        data !== null &&
-        "type" in data &&
-        data.type === "__init_config");
+    return (typeof data === 'object' && data !== null && 'type' in data && data.type === '__init_config');
 }
 export function handleInitConfig(req, data) {
     try {
@@ -153,34 +150,34 @@ export function handleInitConfig(req, data) {
         if (data.runtimeContext) {
             setRuntimeContext(data.runtimeContext);
         }
-        req.reply(JSON.stringify({ success: true }), "utf-8");
+        req.reply(JSON.stringify({ success: true }), 'utf-8');
     }
     catch (error) {
         req.reply(JSON.stringify({
             success: false,
-            error: error instanceof Error ? error.message : String(error),
-        }), "utf-8");
+            error: error instanceof Error ? error.message : String(error)
+        }), 'utf-8');
     }
 }
 export function isShutdownMessage(data) {
-    return (typeof data === "object" &&
+    return (typeof data === 'object' &&
         data !== null &&
-        "type" in data &&
-        data.type === "__shutdown__");
+        'type' in data &&
+        data.type === '__shutdown__');
 }
 export async function handleShutdown(req) {
     try {
         // Lazy import to avoid the import cycle:
         //   handler-utils -> worker-core -> create-server -> handle-request
         //   -> handler-utils. By the time this runs, all modules are loaded.
-        const { cleanupForTerminate } = await import("../worker-core.js");
+        const { cleanupForTerminate } = await import('../worker-core.js');
         await cleanupForTerminate();
-        req.reply(JSON.stringify({ success: true }), "utf-8");
+        req.reply(JSON.stringify({ success: true }), 'utf-8');
     }
     catch (error) {
         req.reply(JSON.stringify({
             success: false,
-            error: error instanceof Error ? error.message : String(error),
-        }), "utf-8");
+            error: error instanceof Error ? error.message : String(error)
+        }), 'utf-8');
     }
 }

package/dist/server/rpc/handlers/batch-completion-stream.d.ts

@@ -0,0 +1,78 @@
+import type { BatchCompletionStreamRequest } from '../../../schemas/index';
+export declare function handleBatchCompletionStream(request: BatchCompletionStreamRequest): AsyncGenerator<{
+    type: "batchCompletionStream";
+    events: {
+        id: string;
+        event: {
+            type: "contentDelta";
+            seq: number;
+            text: string;
+        } | {
+            type: "rawDelta";
+            seq: number;
+            text: string;
+        } | {
+            type: "thinkingDelta";
+            seq: number;
+            text: string;
+        } | {
+            type: "toolCall";
+            seq: number;
+            call: {
+                id: string;
+                name: string;
+                arguments: Record<string, unknown>;
+                raw?: string | undefined;
+            };
+        } | {
+            type: "toolError";
+            seq: number;
+            error: {
+                code: "PARSE_ERROR" | "VALIDATION_ERROR" | "UNKNOWN_TOOL";
+                message: string;
+                raw?: string | undefined;
+            };
+        } | {
+            type: "completionStats";
+            seq: number;
+            stats: {
+                timeToFirstToken?: number | undefined;
+                tokensPerSecond?: number | undefined;
+                cacheTokens?: number | undefined;
+                promptTokens?: number | undefined;
+                generatedTokens?: number | undefined;
+                avgConcurrentSeq?: number | undefined;
+                backendDevice?: "gpu" | "cpu" | undefined;
+            };
+        } | {
+            type: "completionDone";
+            seq: number;
+            stopReason: "error";
+            error: {
+                message: string;
+            };
+            raw?: {
+                fullText: string;
+            } | undefined;
+        } | {
+            type: "completionDone";
+            seq: number;
+            stopReason?: "cancelled" | "eos" | "length" | "stopSequence" | undefined;
+            raw?: {
+                fullText: string;
+            } | undefined;
+        };
+    }[];
+    done?: boolean | undefined;
+    ids?: string[] | undefined;
+    stats?: {
+        timeToFirstToken?: number | undefined;
+        tokensPerSecond?: number | undefined;
+        cacheTokens?: number | undefined;
+        promptTokens?: number | undefined;
+        generatedTokens?: number | undefined;
+        avgConcurrentSeq?: number | undefined;
+        backendDevice?: "gpu" | "cpu" | undefined;
+    } | undefined;
+}, void, any>;
+//# sourceMappingURL=batch-completion-stream.d.ts.map

package/dist/server/rpc/handlers/batch-completion-stream.js

@@ -0,0 +1,4 @@
+import { dispatchPluginStream } from './plugin-dispatch.js';
+export async function* handleBatchCompletionStream(request) {
+    yield* dispatchPluginStream(request.modelId, 'batchCompletionStream', request);
+}

package/dist/server/rpc/handlers/bci-transcribe-stream.d.ts

@@ -1,3 +1,3 @@
-import type { BciTranscribeStreamRequest, BciTranscribeStreamResponse } from "../../../schemas/index";
+import type { BciTranscribeStreamRequest, BciTranscribeStreamResponse } from '../../../schemas/index';
 export declare function handleBciTranscribeStream(request: BciTranscribeStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<BciTranscribeStreamResponse>;
 //# sourceMappingURL=bci-transcribe-stream.d.ts.map

package/dist/server/rpc/handlers/bci-transcribe-stream.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleBciTranscribeStream(request, inputStream) {
-    yield* dispatchPluginStream(request.modelId, "bciTranscribeStream", request, inputStream);
+    yield* dispatchPluginStream(request.modelId, 'bciTranscribeStream', request, inputStream);
 }

package/dist/server/rpc/handlers/bci-transcribe.d.ts

@@ -1,3 +1,3 @@
-import type { BciTranscribeRequest, BciTranscribeResponse } from "../../../schemas/index";
+import type { BciTranscribeRequest, BciTranscribeResponse } from '../../../schemas/index';
 export declare function handleBciTranscribe(request: BciTranscribeRequest): AsyncGenerator<BciTranscribeResponse>;
 //# sourceMappingURL=bci-transcribe.d.ts.map

package/dist/server/rpc/handlers/bci-transcribe.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleBciTranscribe(request) {
-    yield* dispatchPluginStream(request.modelId, "bciTranscribe", request);
+    yield* dispatchPluginStream(request.modelId, 'bciTranscribe', request);
 }

package/dist/server/rpc/handlers/cancel-delegated.d.ts

@@ -1,4 +1,4 @@
-import type { CancelRequest, CancelResponse } from "../../../schemas/cancel";
-import type { DelegatedHandlerOptions } from "../profiling/index";
+import type { CancelRequest, CancelResponse } from '../../../schemas/cancel';
+import type { DelegatedHandlerOptions } from '../profiling/index';
 export declare function handleCancelDelegated(request: CancelRequest, options?: DelegatedHandlerOptions): Promise<CancelResponse>;
 //# sourceMappingURL=cancel-delegated.d.ts.map

package/dist/server/rpc/handlers/cancel-delegated.js

@@ -1,7 +1,7 @@
-import { getServerLogger } from "../../../logging/index.js";
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { send } from "../delegate-transport.js";
+import { getServerLogger } from '../../../logging/index.js';
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getRPC } from '../../bare/delegate-rpc-client.js';
+import { send } from '../delegate-transport.js';
 const logger = getServerLogger();
 /**
  * Resolve the delegated provider for a cancel request, if any.
@@ -20,13 +20,13 @@ const logger = getServerLogger();
  * fire a broad cancel against the model id instead.
  */
 function resolveDelegationTarget(request) {
-    if (request.operation !== "broad")
+    if (request.operation !== 'broad')
         return null;
     const entry = getModelEntry(request.modelId);
     if (!entry?.isDelegated)
         return null;
     const target = {
-        providerPublicKey: entry.delegated.providerPublicKey,
+        providerPublicKey: entry.delegated.providerPublicKey
     };
     if (entry.delegated.timeout !== undefined) {
         target.timeout = entry.delegated.timeout;
@@ -37,14 +37,14 @@ export async function handleCancelDelegated(request, options) {
     const target = resolveDelegationTarget(request);
     if (!target) {
         logger.warn(`Delegated cancel skipped (no delegation target): operation=${request.operation}`);
-        return { type: "cancel", success: true };
+        return { type: 'cancel', success: true };
     }
     try {
         const rpc = await getRPC(target.providerPublicKey, {
-            timeout: target.timeout,
+            timeout: target.timeout
         });
         const delegateOpts = {
-            peerKey: target.providerPublicKey,
+            peerKey: target.providerPublicKey
         };
         if (target.timeout !== undefined) {
             delegateOpts.timeout = target.timeout;
@@ -53,14 +53,14 @@ export async function handleCancelDelegated(request, options) {
             delegateOpts.profilingMeta = options.profilingMeta;
         }
         await send(request, rpc, delegateOpts);
-        return { type: "cancel", success: true };
+        return { type: 'cancel', success: true };
     }
     catch (error) {
-        logger.error("Error during delegated cancellation:", error);
+        logger.error('Error during delegated cancellation:', error);
         return {
-            type: "cancel",
+            type: 'cancel',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

package/dist/server/rpc/handlers/cancelHandler.d.ts

@@ -1,4 +1,4 @@
-import type { CancelRequest, CancelResponse } from "../../../schemas/cancel";
+import type { CancelRequest, CancelResponse } from '../../../schemas/cancel';
 /**
  * Cancel RPC entry point. The 5-arm `switch (request.operation)`
  * dispatcher that lived here through 0.10.x was retired in 0.11.0:

package/dist/server/rpc/handlers/cancelHandler.js

@@ -1,7 +1,7 @@
-import { cancel as cancelByModelId } from "../../bare/ops/cancel.js";
-import { getRequestRegistry } from "../../bare/runtime/index.js";
-import { markClearCacheForRequest } from "./load-model/download-manager.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { cancel as cancelByModelId } from '../../bare/ops/cancel.js';
+import { getRequestRegistry } from '../../bare/runtime/index.js';
+import { markClearCacheForRequest } from './load-model/download-manager.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 /**
  * Cancel RPC entry point. The 5-arm `switch (request.operation)`
@@ -34,12 +34,12 @@ const logger = getServerLogger();
  */
 export function cancelHandler(request) {
     try {
-        if (request.operation === "request") {
+        if (request.operation === 'request') {
             if (request.clearCache) {
                 markClearCacheForRequest(request.requestId);
             }
             const cancelled = getRequestRegistry().cancel({
-                requestId: request.requestId,
+                requestId: request.requestId
             });
             if (cancelled === 0) {
                 // info-level (not debug) because the decorated-promise pattern
@@ -52,18 +52,18 @@ export function cancelHandler(request) {
                 // the log level.
                 logger.info(`[cancel] no in-flight request matched requestId=${request.requestId}`);
             }
-            return { type: "cancel", success: true, cancelled };
+            return { type: 'cancel', success: true, cancelled };
         }
         // operation === "broad"
         const cancelled = cancelByModelId({ modelId: request.modelId }, request.kind ? { kind: request.kind } : undefined);
-        return { type: "cancel", success: true, cancelled };
+        return { type: 'cancel', success: true, cancelled };
     }
     catch (error) {
-        logger.error("Error during cancellation:", error);
+        logger.error('Error during cancellation:', error);
         return {
-            type: "cancel",
+            type: 'cancel',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

package/dist/server/rpc/handlers/classify.d.ts

@@ -1,3 +1,3 @@
-import type { ClassifyRequest, ClassifyResponse } from "../../../schemas/classification";
+import type { ClassifyRequest, ClassifyResponse } from '../../../schemas/classification';
 export declare function handleClassify(request: ClassifyRequest): AsyncGenerator<ClassifyResponse>;
 //# sourceMappingURL=classify.d.ts.map

package/dist/server/rpc/handlers/classify.js

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleClassify(request) {
-    yield* dispatchPluginStream(request.modelId, "classify", request);
+    yield* dispatchPluginStream(request.modelId, 'classify', request);
 }

package/dist/server/rpc/handlers/completion-stream-delegated.d.ts

@@ -1,5 +1,5 @@
-import type { CompletionStreamRequest, CompletionStreamResponse } from "../../../schemas/index";
-import type { DelegatedHandlerOptions } from "../profiling/index";
+import type { CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index';
+import type { DelegatedHandlerOptions } from '../profiling/index';
 export type HandleCompletionStreamDelegatedOptions = DelegatedHandlerOptions;
 export declare function handleCompletionStreamDelegated(request: CompletionStreamRequest, options?: HandleCompletionStreamDelegatedOptions): AsyncGenerator<CompletionStreamResponse>;
 //# sourceMappingURL=completion-stream-delegated.d.ts.map

package/dist/server/rpc/handlers/completion-stream-delegated.js

@@ -1,8 +1,8 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { stream } from "../delegate-transport.js";
-import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getRPC } from '../../bare/delegate-rpc-client.js';
+import { stream } from '../delegate-transport.js';
+import { ModelIsDelegatedError } from '../../../utils/errors-server.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 export async function* handleCompletionStreamDelegated(request, options) {
     const { profilingMeta } = options ?? {};
@@ -13,7 +13,7 @@ export async function* handleCompletionStreamDelegated(request, options) {
     }
     const { providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
     try {
-        logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ''}`);
         const rpc = await getRPC(providerPublicKey, { timeout, healthCheckTimeout });
         // Build delegate options with profiling metadata
         const delegateOpts = { peerKey: providerPublicKey };
@@ -31,21 +31,21 @@ export async function* handleCompletionStreamDelegated(request, options) {
         }
     }
     catch (error) {
-        logger.error("Error in delegated completion stream:", error);
+        logger.error('Error in delegated completion stream:', error);
         const message = error instanceof Error ? error.message : String(error);
         yield {
-            type: "completionStream",
+            type: 'completionStream',
             done: true,
             events: [
                 {
-                    type: "completionDone",
+                    type: 'completionDone',
                     seq: 0,
-                    stopReason: "error",
+                    stopReason: 'error',
                     error: {
-                        message: `Error communicating with provider: ${message}`,
-                    },
-                },
-            ],
+                        message: `Error communicating with provider: ${message}`
+                    }
+                }
+            ]
         };
     }
 }

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

@@ -1,3 +1,3 @@
-import type { CompletionStreamRequest, CompletionStreamResponse } from "../../../schemas/index";
+import type { CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index';
 export declare function handleCompletionStream(request: CompletionStreamRequest): AsyncGenerator<CompletionStreamResponse>;
 //# sourceMappingURL=completion-stream.d.ts.map

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

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleCompletionStream(request) {
-    yield* dispatchPluginStream(request.modelId, "completionStream", request);
+    yield* dispatchPluginStream(request.modelId, 'completionStream', request);
 }

package/dist/server/rpc/handlers/delete-cache.d.ts

@@ -1,4 +1,4 @@
-import type { DeleteCacheRequest, DeleteCacheResponse } from "../../../schemas/index";
+import type { DeleteCacheRequest, DeleteCacheResponse } from '../../../schemas/index';
 /**
  * RPC handler for `deleteCache(...)`. The three KV-cache bookkeeping
  * layers (on-disk `.bin`, `initializedCaches`, `cachedMessageCounts`)

package/dist/server/rpc/handlers/delete-cache.js

@@ -1,5 +1,5 @@
-import { deleteKvCacheState } from "../../bare/plugins/llamacpp-completion/ops/kv-cache-session.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { deleteKvCacheState } from '../../bare/plugins/llamacpp-completion/ops/kv-cache-session.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 /**
  * RPC handler for `deleteCache(...)`. The three KV-cache bookkeeping
@@ -12,26 +12,26 @@ const logger = getServerLogger();
  */
 export async function handleDeleteCache(request) {
     try {
-        if ("all" in request && request.all) {
+        if ('all' in request && request.all) {
             await deleteKvCacheState({ all: true });
         }
-        else if ("kvCacheKey" in request) {
+        else if ('kvCacheKey' in request) {
             await deleteKvCacheState({
                 kvCacheKey: request.kvCacheKey,
-                ...(request.modelId !== undefined && { modelId: request.modelId }),
+                ...(request.modelId !== undefined && { modelId: request.modelId })
             });
         }
         return {
-            type: "deleteCache",
-            success: true,
+            type: 'deleteCache',
+            success: true
         };
     }
     catch (error) {
-        logger.error("Error deleting cache:", error);
+        logger.error('Error deleting cache:', error);
         return {
-            type: "deleteCache",
+            type: 'deleteCache',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

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

@@ -1,3 +1,3 @@
-import type { DiffusionStreamRequest, DiffusionStreamResponse } from "../../../schemas/sdcpp-config";
+import type { DiffusionStreamRequest, DiffusionStreamResponse } from '../../../schemas/sdcpp-config';
 export declare function handleDiffusionStream(request: DiffusionStreamRequest): AsyncGenerator<DiffusionStreamResponse>;
 //# sourceMappingURL=diffusion-stream.d.ts.map

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

@@ -1,4 +1,4 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { dispatchPluginStream } from './plugin-dispatch.js';
 export async function* handleDiffusionStream(request) {
-    yield* dispatchPluginStream(request.modelId, "diffusionStream", request);
+    yield* dispatchPluginStream(request.modelId, 'diffusionStream', request);
 }

package/dist/server/rpc/handlers/download-asset.d.ts

@@ -1,3 +1,3 @@
-import type { DownloadAssetRequest, DownloadAssetResponse, ModelProgressUpdate } from "../../../schemas/index";
+import type { DownloadAssetRequest, DownloadAssetResponse, ModelProgressUpdate } from '../../../schemas/index';
 export declare function handleDownloadAsset(request: DownloadAssetRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<DownloadAssetResponse>;
 //# sourceMappingURL=download-asset.d.ts.map