@qvac/sdk 0.8.2 → 0.9.0

package/dist/server/bare/registry/registry-client.js

@@ -1,5 +1,6 @@
 import { QVACRegistryClient } from "@qvac/registry-client";
 import { getCacheDir } from "../../utils/cache.js";
+import { registerSwarm, unregisterSwarm, registerCorestore, unregisterCorestore, } from "../runtime-lifecycle.js";
 import { getServerLogger } from "../../../logging/index.js";
 import { DEFAULT_REGISTRY_CORE_KEY } from "../../../constants/index.js";
 const logger = getServerLogger();
@@ -15,6 +16,18 @@ export async function getRegistryClient() {
         storage: getCacheDir(`registry-corestore/${DEFAULT_REGISTRY_CORE_KEY}`),
     });
     await registryClient.ready();
+    if (registryClient.corestore) {
+        registerCorestore(registryClient.corestore, {
+            label: "registry-client",
+            createdAt: Date.now(),
+        });
+    }
+    if (registryClient.hyperswarm) {
+        registerSwarm(registryClient.hyperswarm, {
+            label: "registry-client",
+            createdAt: Date.now(),
+        });
+    }
     logger.info("✅ Registry client ready");
     return registryClient;
 }
@@ -23,6 +36,8 @@ export async function closeRegistryClient() {
         return;
     const client = registryClient;
     registryClient = null;
+    const corestore = client.corestore;
+    const hyperswarm = client.hyperswarm;
     logger.info("🔌 Closing registry client...");
     try {
         await client.close();
@@ -31,6 +46,12 @@ export async function closeRegistryClient() {
     catch (error) {
         logger.error("❌ Error closing registry client:", error instanceof Error ? error.message : String(error));
     }
+    finally {
+        if (corestore)
+            unregisterCorestore(corestore);
+        if (hyperswarm)
+            unregisterSwarm(hyperswarm);
+    }
 }
 export function hasActiveRegistryClient() {
     return registryClient !== null;

package/dist/server/bare/runtime-lifecycle.d.ts

@@ -0,0 +1,28 @@
+export interface SuspendableSwarm {
+    readonly suspended: boolean;
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+}
+export interface SuspendableStore {
+    suspend(): Promise<void>;
+    resume(): Promise<void>;
+}
+type LifecycleState = "active" | "suspending" | "suspended" | "resuming";
+interface ResourceMeta {
+    label: string;
+    createdAt: number;
+}
+export declare function registerSwarm(swarm: SuspendableSwarm, meta: ResourceMeta): void;
+export declare function unregisterSwarm(swarm: SuspendableSwarm): void;
+export declare function registerCorestore(store: SuspendableStore, meta: ResourceMeta): void;
+export declare function unregisterCorestore(store: SuspendableStore): void;
+export declare function getLifecycleState(): LifecycleState;
+export declare function getRegisteredResourceCounts(): {
+    swarms: number;
+    stores: number;
+};
+export declare function resetLifecycleState(): void;
+export declare function suspendRuntime(): Promise<void>;
+export declare function resumeRuntime(): Promise<void>;
+export {};
+//# sourceMappingURL=runtime-lifecycle.d.ts.map

package/dist/server/bare/runtime-lifecycle.js

@@ -0,0 +1,132 @@
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
+const swarms = new Map();
+const stores = new Map();
+let state = "active";
+let transitionPromise = null;
+export function registerSwarm(swarm, meta) {
+    swarms.set(swarm, meta);
+    logger.debug(`Lifecycle: registered swarm [${meta.label}]`);
+}
+export function unregisterSwarm(swarm) {
+    const meta = swarms.get(swarm);
+    swarms.delete(swarm);
+    if (meta) {
+        logger.debug(`Lifecycle: unregistered swarm [${meta.label}]`);
+    }
+}
+export function registerCorestore(store, meta) {
+    stores.set(store, meta);
+    logger.debug(`Lifecycle: registered corestore [${meta.label}]`);
+}
+export function unregisterCorestore(store) {
+    const meta = stores.get(store);
+    stores.delete(store);
+    if (meta) {
+        logger.debug(`Lifecycle: unregistered corestore [${meta.label}]`);
+    }
+}
+export function getLifecycleState() {
+    return state;
+}
+export function getRegisteredResourceCounts() {
+    return { swarms: swarms.size, stores: stores.size };
+}
+export function resetLifecycleState() {
+    swarms.clear();
+    stores.clear();
+    state = "active";
+    transitionPromise = null;
+}
+async function runPhase(snapshot, liveSet, fn, phaseLabel) {
+    const errors = [];
+    for (const [resource, meta] of snapshot) {
+        try {
+            await fn(resource);
+            logger.debug(`Lifecycle: ${phaseLabel} [${meta.label}] OK`);
+        }
+        catch (error) {
+            if (!liveSet.has(resource))
+                continue;
+            logger.error(`Lifecycle: ${phaseLabel} [${meta.label}] failed:`, error);
+            errors.push(new Error(`${meta.label}: ${String(error)}`));
+        }
+    }
+    if (errors.length > 0) {
+        throw new AggregateError(errors, `Lifecycle ${phaseLabel} phase failed`);
+    }
+}
+export async function suspendRuntime() {
+    if (state === "suspended")
+        return;
+    if (state === "suspending" && transitionPromise)
+        return transitionPromise;
+    // Opposite transition in flight: wait for it, then re-evaluate
+    if (state === "resuming" && transitionPromise) {
+        await transitionPromise;
+        return suspendRuntime();
+    }
+    state = "suspending";
+    logger.info(`⏸️ Suspending runtime (${swarms.size} swarms, ${stores.size} stores)`);
+    transitionPromise = (async () => {
+        const swarmSnapshot = Array.from(swarms.entries());
+        const storeSnapshot = Array.from(stores.entries());
+        await runPhase(swarmSnapshot, swarms, async (swarm) => {
+            if (!swarm.suspended)
+                await swarm.suspend();
+        }, "suspend-swarm");
+        await runPhase(storeSnapshot, stores, async (store) => {
+            await store.suspend();
+        }, "suspend-store");
+    })()
+        .then(() => {
+        state = "suspended";
+        logger.info("⏸️ Runtime suspended");
+    })
+        .catch((error) => {
+        // Partial failure: commit to target so recovery resume() can repair
+        // instead of leaving state as "suspending" which blocks all future calls.
+        state = "suspended";
+        logger.error("⏸️ Runtime suspend partially failed, state committed for recovery");
+        throw error;
+    })
+        .finally(() => {
+        transitionPromise = null;
+    });
+    return transitionPromise;
+}
+export async function resumeRuntime() {
+    if (state === "active")
+        return;
+    if (state === "resuming" && transitionPromise)
+        return transitionPromise;
+    if (state === "suspending" && transitionPromise) {
+        await transitionPromise;
+        return resumeRuntime();
+    }
+    state = "resuming";
+    logger.info(`▶️ Resuming runtime (${stores.size} stores, ${swarms.size} swarms)`);
+    transitionPromise = (async () => {
+        const storeSnapshot = Array.from(stores.entries());
+        const swarmSnapshot = Array.from(swarms.entries());
+        await runPhase(storeSnapshot, stores, async (store) => {
+            await store.resume();
+        }, "resume-store");
+        await runPhase(swarmSnapshot, swarms, async (swarm) => {
+            await swarm.resume();
+        }, "resume-swarm");
+    })()
+        .then(() => {
+        state = "active";
+        logger.info("▶️ Runtime resumed");
+    })
+        .catch((error) => {
+        state = "active";
+        logger.error("▶️ Runtime resume partially failed, state committed for recovery");
+        throw error;
+    })
+        .finally(() => {
+        transitionPromise = null;
+    });
+    return transitionPromise;
+}

package/dist/server/bare/types/addon-responses.d.ts

@@ -0,0 +1,62 @@
+export interface LlmStats {
+    TTFT?: number;
+    TPS?: number;
+    CacheTokens?: number;
+    generatedTokens?: number;
+    backendDevice?: "cpu" | "gpu";
+}
+export interface LlmResponse {
+    stats?: LlmStats;
+    iterate(): AsyncIterable<string>;
+}
+export interface NmtStats {
+    totalTime?: number;
+    totalTokens?: number;
+    decodeTime?: number;
+    encodeTime?: number;
+    TPS?: number;
+    TTFT?: number;
+}
+export interface NmtResponse {
+    stats?: NmtStats;
+    iterate(): AsyncIterable<string>;
+}
+export interface TtsStats {
+    audioDurationMs?: number;
+    totalSamples?: number;
+}
+export interface TtsResponse {
+    stats?: TtsStats;
+    iterate(): AsyncIterable<{
+        outputArray: ArrayLike<number>;
+    }>;
+}
+export interface EmbedStats {
+    total_time_ms?: number;
+    tokens_per_second?: number;
+    total_tokens?: number;
+    backendDevice?: "cpu" | "gpu";
+}
+export interface EmbedResponse {
+    stats?: EmbedStats;
+    await(): Promise<Float32Array[][]>;
+}
+export interface TranscribeStats {
+    audioDurationMs?: number;
+    realTimeFactor?: number;
+    tokensPerSecond?: number;
+    totalTokens?: number;
+    totalSegments?: number;
+    whisperEncodeMs?: number;
+    whisperDecodeMs?: number;
+    encoderMs?: number;
+    decoderMs?: number;
+    melSpecMs?: number;
+}
+export interface TranscribeResponse {
+    stats?: TranscribeStats;
+    iterate(): AsyncIterable<Array<{
+        text: string;
+    }>>;
+}
+//# sourceMappingURL=addon-responses.d.ts.map

package/dist/server/bare/types/addon-responses.js

@@ -0,0 +1 @@
+export {};

package/dist/server/env.js

@@ -11,7 +11,9 @@ let validatedEnv = null;
  * Returns whether RPC config was parsed from arguments.
  */
 export function initEnv() {
-    const defaultHomeDir = process.env["HOME"] || process.env["USERPROFILE"] || "/tmp";
+    const defaultHomeDir = process.env["HOME"] ??
+        process.env["USERPROFILE"] ??
+        "/tmp";
     let envConfig = {
         HOME_DIR: defaultHomeDir,
     };

package/dist/server/rpc/delegate-transport.js

@@ -12,7 +12,7 @@ import { DelegateProviderError } from "../../utils/errors-server.js";
 import { cleanupStaleConnection } from "../bare/delegate-rpc-client.js";
 import { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime, } from "./profiling/delegation-profiler.js";
 const logger = getServerLogger();
-import { getNextCommandId } from "./delegate-utils.js";
+import { getNextCommandId } from "./rpc-utils.js";
 function checkAndThrowError(response) {
     if (response.type === "error") {
         throw new DelegateProviderError(response.message || "Unknown provider error", response.code);

package/dist/server/rpc/handle-request.js

@@ -1,18 +1,21 @@
 import { requestSchema, normalizeModelType, PROFILING_KEY, } from "../../schemas/index.js";
 import { nowMs } from "../../profiling/index.js";
 import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
-import { sendErrorResponse } from "../error-handlers.js";
-import { RPCNoDataReceivedError, RPCUnknownRequestTypeError, } from "../../utils/errors-server.js";
+import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
+import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError, } from "../../utils/errors-server.js";
 import { registry } from "./handler-registry.js";
-import { executeHandler, handleInitConfig, isInitConfigMessage, } from "./handler-utils.js";
+import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, } from "./handler-utils.js";
 import { createServerProfiler } from "./profiling/index.js";
 export async function handleRequest(req) {
     let profiler;
     let validationStart = 0;
     try {
         const rawData = req.data?.toString();
+        // Duplex stream request: metadata arrives as the first chunk on the
+        // request stream (client used createRequestStream instead of send).
         if (!rawData) {
-            throw new RPCNoDataReceivedError();
+            await handleDuplexRequest(req);
+            return;
         }
         // Timing runs unconditionally since we can't know if client
         // requested profiling until after parsing.
@@ -67,6 +70,49 @@ function extractProfilingMeta(data) {
         profilingMeta: meta,
     };
 }
+async function handleDuplexRequest(req) {
+    const inputStream = req.createRequestStream();
+    const outputStream = req.createResponseStream();
+    let profiler;
+    try {
+        const firstChunk = await new Promise((resolve, reject) => {
+            const onData = (data) => {
+                inputStream.off("error", onError);
+                inputStream.pause();
+                resolve(data);
+            };
+            const onError = (err) => {
+                inputStream.off("data", onData);
+                reject(err instanceof Error ? err : new Error(String(err)));
+            };
+            inputStream.once("data", onData);
+            inputStream.once("error", onError);
+        });
+        const parseStart = nowMs();
+        const jsonData = JSON.parse(firstChunk.toString());
+        const jsonParseMs = nowMs() - parseStart;
+        const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
+        profiler = createServerProfiler(profilingMeta);
+        profiler.markRequestParsed(jsonParseMs);
+        const validationStart = nowMs();
+        const processedData = applyDeviceDefaultsToRequest(cleanData);
+        const request = requestSchema.parse(processedData);
+        attachProfilingMetaToRequest(request, profilingMeta);
+        profiler.markRequestValidated(nowMs() - validationStart);
+        const entry = registry[request.type];
+        if (!entry) {
+            throw new RPCUnknownRequestTypeError(request.type);
+        }
+        if (entry.type !== "duplex") {
+            throw new PluginHandlerTypeMismatchError(request.type, "duplex", entry.type);
+        }
+        await executeDuplexHandler(req, request, entry, inputStream, outputStream, profiler);
+    }
+    catch (error) {
+        inputStream.destroy();
+        sendStreamErrorResponse(outputStream, error, profiler);
+    }
+}
 /**
  * Apply device-specific config defaults to loadModel requests before schema parsing.
  * This ensures device defaults are applied before schema defaults.

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

@@ -7,6 +7,7 @@ import { handleCompletionStreamDelegated } from "./handlers/completion-stream-de
 import { getModelEntry } from "../bare/registry/model-registry.js";
 import { handleUnloadModel } from "./handlers/unload-model.js";
 import { handleUnloadModelDelegated } from "./handlers/unload-model-delegated.js";
+import { handleTranscribe } from "./handlers/transcribe.js";
 import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
 import { handleEmbed } from "./handlers/embed.js";
 import { handleTranslate } from "./handlers/translate.js";
@@ -20,15 +21,24 @@ import { handleTextToSpeech } from "./handlers/text-to-speech.js";
 import { handleGetModelInfo } from "./handlers/get-model-info.js";
 import { handleOCRStream } from "./handlers/ocr-stream.js";
 import { handleHeartbeat } from "./handlers/heartbeat.js";
+import { handleFinetune } from "./handlers/finetune.js";
 import { handleHeartbeatDelegated } from "./handlers/heartbeat-delegated.js";
 import { handleCancelDelegated } from "./handlers/cancel-delegated.js";
+import { handleDiffusionStream } from "./handlers/diffusion-stream.js";
 import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
+import { handleSuspend } from "./handlers/suspend.js";
+import { handleResume } from "./handlers/resume.js";
 function ragSupportsProgress(request) {
     if (request.type !== "rag")
         return false;
     return ["ingest", "saveEmbeddings", "reindex"].includes(request.operation);
 }
+function finetuneSupportsProgress(request) {
+    if (request.type !== "finetune")
+        return false;
+    return ["start", "resume", undefined].includes(request.operation);
+}
 function isModelDelegated(request) {
     if (!("modelId" in request))
         return false;
@@ -78,12 +88,16 @@ export const registry = {
         type: "reply",
         handler: handleModelRegistryGetModel,
     },
+    suspend: { type: "reply", handler: handleSuspend },
+    resume: { type: "reply", handler: handleResume },
     // Simple Stream handlers
-    transcribeStream: { type: "stream", handler: handleTranscribeStream },
+    transcribe: { type: "stream", handler: handleTranscribe },
+    transcribeStream: { type: "duplex", handler: handleTranscribeStream },
     loggingStream: { type: "stream", handler: handleLoggingStream },
     translate: { type: "stream", handler: handleTranslate },
     textToSpeech: { type: "stream", handler: handleTextToSpeech },
     ocrStream: { type: "stream", handler: handleOCRStream },
+    diffusionStream: { type: "stream", handler: handleDiffusionStream },
     pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },
     // Handlers with delegation support
     loadModel: {
@@ -110,4 +124,9 @@ export const registry = {
         handler: handleRag,
         supportsProgress: ragSupportsProgress,
     },
+    finetune: {
+        type: "reply",
+        handler: handleFinetune,
+        supportsProgress: finetuneSupportsProgress,
+    },
 };

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

@@ -4,13 +4,15 @@ 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";
-    handler: ReplyHandler | StreamHandler | ProgressHandler;
-    delegatedHandler?: ReplyHandler | StreamHandler | ProgressHandler;
+    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 executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, profiler: ServerProfiler): Promise<void>;
 type InitConfigMessage = {
     type: "__init_config";

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

@@ -1,9 +1,11 @@
 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 { nowMs } from "../../profiling/clock.js";
+import { isTerminalChunk } from "./rpc-utils.js";
+import { createProgressThrottle } from "./progress-throttle.js";
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -32,6 +34,7 @@ async function executeReplyHandler(req, request, handler, profiler, isDelegated)
 async function executeStreamHandler(req, request, handler, profiler, isDelegated) {
     const stream = req.createResponseStream();
     profiler.startHandler();
+    let sentFinalChunk = false;
     try {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let generator;
@@ -43,12 +46,22 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
             generator = handler(request);
         }
         for await (const response of generator) {
-            stream.write(profiler.serialize(response, false) + "\n", "utf-8");
+            if (isTerminalChunk(response)) {
+                profiler.endHandler();
+                stream.write(profiler.serialize(response, true) + "\n", "utf-8");
+                sentFinalChunk = true;
+            }
+            else {
+                stream.write(profiler.serialize(response, false) + "\n", "utf-8");
+            }
         }
-        profiler.endHandler();
-        const trailer = profiler.serialize();
-        if (trailer) {
-            stream.write(trailer + "\n", "utf-8");
+        // Fallback
+        if (!sentFinalChunk) {
+            profiler.endHandler();
+            const trailer = profiler.serialize();
+            if (trailer) {
+                stream.write(trailer + "\n", "utf-8");
+            }
         }
         stream.end();
     }
@@ -57,73 +70,59 @@ async function executeStreamHandler(req, request, handler, profiler, isDelegated
         sendStreamErrorResponse(stream, error, profiler);
     }
 }
-const PROGRESS_THROTTLE_MS = 150;
 async function executeProgressHandler(req, request, handler, profiler, isDelegated) {
     const stream = req.createResponseStream();
     profiler.startHandler();
-    let lastProgressWrite = 0;
-    let pendingUpdate = null;
-    let flushTimer = null;
-    const writeProgress = (update) => {
-        stream.write(profiler.serialize(update, false) + "\n", "utf-8");
-    };
-    const progressCallback = (update) => {
-        const now = nowMs();
-        if (now - lastProgressWrite >= PROGRESS_THROTTLE_MS) {
-            lastProgressWrite = now;
-            pendingUpdate = null;
-            writeProgress(update);
-        }
-        else {
-            pendingUpdate = update;
-            if (!flushTimer) {
-                flushTimer = setTimeout(() => {
-                    flushTimer = null;
-                    if (pendingUpdate) {
-                        lastProgressWrite = nowMs();
-                        writeProgress(pendingUpdate);
-                        pendingUpdate = null;
-                    }
-                }, PROGRESS_THROTTLE_MS - (now - lastProgressWrite));
-            }
-        }
+    const writeBatch = (updates) => {
+        const payload = updates
+            .map((u) => profiler.serialize(u, false))
+            .join("\n");
+        stream.write(payload + "\n", "utf-8");
     };
+    const throttle = createProgressThrottle(writeBatch);
     try {
         let response;
         if (isDelegated) {
             const profilingMeta = getProfilingMetaFromRequest(request);
-            const options = { progressCallback };
+            const options = { progressCallback: throttle.push };
             if (profilingMeta) {
                 options.profilingMeta = profilingMeta;
             }
             response = await handler(request, options);
         }
         else {
-            response = await handler(request, progressCallback);
-        }
-        if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
-        }
-        if (pendingUpdate) {
-            writeProgress(pendingUpdate);
-            pendingUpdate = null;
+            response = await handler(request, throttle.push);
         }
+        throttle.flush();
         profiler.endHandler();
         stream.write(profiler.serialize(response, true) + "\n", "utf-8");
         stream.end();
     }
     catch (error) {
-        if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
+        throttle.flush();
+        profiler.endHandler();
+        sendStreamErrorResponse(stream, error, profiler);
+    }
+}
+export async function executeDuplexHandler(_req, request, entry, inputStream, outputStream, profiler) {
+    const handler = entry.delegatedHandler && entry.isDelegated?.(request)
+        ? entry.delegatedHandler
+        : entry.handler;
+    profiler.startHandler();
+    try {
+        for await (const response of handler(request, inputStream)) {
+            outputStream.write(profiler.serialize(response, false) + "\n", "utf-8");
         }
-        if (pendingUpdate) {
-            writeProgress(pendingUpdate);
-            pendingUpdate = null;
+        profiler.endHandler();
+        const trailer = profiler.serialize();
+        if (trailer) {
+            outputStream.write(trailer + "\n", "utf-8");
         }
+        outputStream.end();
+    }
+    catch (error) {
         profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
+        sendStreamErrorResponse(outputStream, error, profiler);
     }
 }
 // Unified handler executor with delegation and progress support
@@ -135,6 +134,9 @@ export async function executeHandler(req, request, entry, profiler) {
         (typeof entry.supportsProgress === "function"
             ? entry.supportsProgress(request)
             : entry.supportsProgress);
+    if (entry.type === "duplex") {
+        throw new PluginHandlerTypeMismatchError(request.type, "reply or stream", "duplex");
+    }
     if (entry.type === "stream") {
         await executeStreamHandler(req, request, handler, profiler, isDelegated);
     }

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

@@ -1,10 +1,12 @@
 import { deleteCache as deleteCacheUtil } from "../../bare/ops/kv-cache-utils.js";
+import { clearCachedMessageCounts } from "../../bare/plugins/llamacpp-completion/ops/completion-stream.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 export async function handleDeleteCache(request) {
     try {
         if ("all" in request && request.all) {
             await deleteCacheUtil({ all: true });
+            clearCachedMessageCounts();
         }
         else if ("kvCacheKey" in request) {
             const params = {
@@ -14,6 +16,7 @@ export async function handleDeleteCache(request) {
                 params.modelId = request.modelId;
             }
             await deleteCacheUtil(params);
+            clearCachedMessageCounts();
         }
         return {
             type: "deleteCache",

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

@@ -0,0 +1,3 @@
+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

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

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

@@ -0,0 +1,3 @@
+import type { FinetuneProgressResponse, FinetuneRequest, FinetuneResult } from "../../../schemas/index";
+export declare function handleFinetune(request: FinetuneRequest, progressCallback?: (update: FinetuneProgressResponse) => void): Promise<FinetuneResult>;
+//# sourceMappingURL=finetune.d.ts.map

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

@@ -0,0 +1,16 @@
+import { dispatchPluginReply } from "./plugin-dispatch.js";
+import { startFinetune } from "../../bare/plugins/llamacpp-completion/ops/finetune.js";
+export async function handleFinetune(request, progressCallback) {
+    if (progressCallback &&
+        (request.operation === "start" || request.operation === "resume" || request.operation === undefined)) {
+        return startFinetune(request, (progress) => {
+            const update = {
+                type: "finetune:progress",
+                modelId: request.modelId,
+                ...progress,
+            };
+            progressCallback(update);
+        });
+    }
+    return dispatchPluginReply(request.modelId, "finetune", request);
+}