@qvac/sdk 0.9.2 → 0.10.0

package/dist/schemas/translation-config.js

@@ -1,7 +1,5 @@
 import { z } from "zod";
 import { modelSrcInputSchema } from "./model-src-utils.js";
-// Marian/Opus model languages
-export const MARIAN_LANGUAGES = ["en", "de", "es", "it", "ru", "ja"];
 // Bergamot supports many more language pairs
 export const BERGAMOT_LANGUAGES = [
     "en",
@@ -29,6 +27,39 @@ export const BERGAMOT_LANGUAGES = [
     "sl",
     "uk",
     "zh",
+    "az",
+    "be",
+    "bn",
+    "bs",
+    "da",
+    "el",
+    "fa",
+    "gu",
+    "he",
+    "hi",
+    "hr",
+    "id",
+    "kn",
+    "ml",
+    "ms",
+    "mt",
+    "nb",
+    "nn",
+    "re",
+    "ro",
+    "sq",
+    "sr",
+    "sv",
+    "ta",
+    "te",
+    "tr",
+    "vi",
+];
+export const BERGAMOT_MODEL_RE = /^(.+\/)model\.([a-z]+)\.intgemm\.alphas\.bin$/;
+export const BERGAMOT_CJK_LANG_PAIRS = [
+    "enja",
+    "enko",
+    "enzh",
 ];
 // IndicTrans2 model languages
 export const INDICTRANS_LANGUAGES = [
@@ -83,11 +114,10 @@ export const AFRICAN_LANGUAGES_MAP = new Map([
 ]);
 // Union of all NMT languages (for general type usage)
 export const NMT_LANGUAGES = [
-    ...MARIAN_LANGUAGES,
     ...BERGAMOT_LANGUAGES,
     ...INDICTRANS_LANGUAGES,
 ];
-export const NMT_ENGINES = ["Opus", "Bergamot", "IndicTrans"];
+export const NMT_ENGINES = ["Bergamot", "IndicTrans"];
 // Common generation parameters (without language fields)
 const nmtGenerationParamsSchema = z.object({
     mode: z.enum(["full"]).optional(),
@@ -100,12 +130,6 @@ const nmtGenerationParamsSchema = z.object({
     topk: z.number().optional(),
     topp: z.number().optional(),
 });
-// Opus engine config (Marian-based) - supports MARIAN_LANGUAGES
-const opusConfigSchema = nmtGenerationParamsSchema.extend({
-    engine: z.literal("Opus"),
-    from: z.enum(MARIAN_LANGUAGES),
-    to: z.enum(MARIAN_LANGUAGES),
-});
 // Pivot model configuration for Bergamot (for translation via intermediate language)
 const bergamotPivotModelSchema = nmtGenerationParamsSchema
     .extend({
@@ -133,7 +157,6 @@ const indicTransConfigSchema = nmtGenerationParamsSchema.extend({
 });
 // Discriminated union of all engine configs
 export const nmtConfigBaseSchema = z.discriminatedUnion("engine", [
-    opusConfigSchema,
     bergamotConfigSchema,
     indicTransConfigSchema,
 ]);

package/dist/server/bare/delegate-rpc-client.d.ts

@@ -1,6 +1,6 @@
 import RPC from "bare-rpc";
 import type { RPCOptions } from "../../schemas/index";
-export declare function getRPC(topic: string, publicKey: string, options?: RPCOptions): Promise<RPC>;
+export declare function getRPC(publicKey: string, options?: RPCOptions): Promise<RPC>;
 /**
  * Remove a stale RPC connection for a peer.
  * Called when a delegation request fails (e.g., timeout) so the next

package/dist/server/bare/delegate-rpc-client.js

@@ -7,12 +7,13 @@ import { nowMs } from "../../profiling/index.js";
 import { cacheDelegationConnectionTime, clearPeerConnectionTracking, } from "../rpc/profiling/delegation-profiler.js";
 import { getNextCommandId } from "../rpc/rpc-utils.js";
 const logger = getServerLogger();
-// Map of active RPC instances by public key
 const activeRPCs = new Map();
-// Map to store underlying connections for cleanup
 const activeConnections = new Map();
-// Track whether the global connection handler has been registered
-let connectionHandlerRegistered = false;
+// In-flight `ensureRPCConnection` promises keyed by peer. Concurrent
+// `getRPC(publicKey)` callers (without `forceNewConnection`) join the same
+// promise instead of each running their own bootstrap+connect, which would
+// open multiple sockets, clobber the active maps, and leak the loser.
+const inflightConnections = new Map();
 const HEALTH_CHECK_TIMEOUT_MS = 1500;
 function isHeartbeatResponse(payload) {
     return (typeof payload === "object" &&
@@ -32,72 +33,92 @@ async function isRPCConnectionHealthy(rpc, timeout = HEALTH_CHECK_TIMEOUT_MS) {
         return false;
     }
 }
-/**
- * Register the swarm "connection" handler once (not per getRPC call).
- * This fixes the event listener leak where each getRPC() call added
- * a new listener, causing duplicate RPC instances on the same stream.
- */
-function ensureConnectionHandler() {
-    if (connectionHandlerRegistered)
-        return;
-    connectionHandlerRegistered = true;
-    const swarm = getSwarm();
-    swarm.on("connection", (conn) => {
-        const peerPubkey = conn.remotePublicKey?.toString("hex");
-        if (!peerPubkey)
-            return;
-        logger.info(`🍺 New peer connection established: ${peerPubkey}`);
-        // Create RPC instance for this connection (as client)
-        const rpc = new RPC(conn, () => {
-            // No-op handler since we're only sending requests, not receiving them
-        });
-        // Store RPC instance and connection by peer ID for lookup
-        activeRPCs.set(peerPubkey, rpc);
-        activeConnections.set(peerPubkey, conn);
-        conn.on("close", () => {
-            logger.debug(`Connection closed for peer: ${peerPubkey}`);
-            activeRPCs.delete(peerPubkey);
-            activeConnections.delete(peerPubkey);
-            clearPeerConnectionTracking(peerPubkey);
-        });
-        conn.on("error", (err) => {
-            logger.error(`Connection error for peer ${peerPubkey}:`, err);
-            activeRPCs.delete(peerPubkey);
-            activeConnections.delete(peerPubkey);
-            clearPeerConnectionTracking(peerPubkey);
-        });
+function trackConnection(publicKey, conn, rpc) {
+    activeRPCs.set(publicKey, rpc);
+    activeConnections.set(publicKey, conn);
+    conn.on("close", () => {
+        logger.debug(`Connection closed for peer: ${publicKey}`);
+        if (activeConnections.get(publicKey) === conn) {
+            activeConnections.delete(publicKey);
+            activeRPCs.delete(publicKey);
+            clearPeerConnectionTracking(publicKey);
+        }
+    });
+    conn.on("error", (err) => {
+        logger.error(`Connection error for peer ${publicKey}:`, err);
+        if (activeConnections.get(publicKey) === conn) {
+            activeConnections.delete(publicKey);
+            activeRPCs.delete(publicKey);
+            clearPeerConnectionTracking(publicKey);
+        }
     });
 }
 async function closeConnection(publicKey) {
     const existingConnection = activeConnections.get(publicKey);
-    if (existingConnection) {
-        logger.info(`🔌 Closing existing connection for peer: ${publicKey}`);
-        // Wait for the close event before returning so Hyperswarm's internal
-        // _allConnections is cleaned up before we attempt to rejoin/flush.
-        await new Promise((resolve) => {
-            existingConnection.on("close", () => {
-                resolve();
-            });
-            existingConnection.destroy();
-        });
-        if (activeConnections.get(publicKey) !== existingConnection)
-            return;
+    if (!existingConnection)
+        return;
+    logger.info(`🔌 Closing existing connection for peer: ${publicKey}`);
+    // Wait for the close event before returning so any pending cleanup
+    // in the underlying DHT stream completes before we reconnect.
+    await new Promise((resolve) => {
+        existingConnection.once("close", () => resolve());
+        existingConnection.destroy();
+    });
+    if (activeConnections.get(publicKey) === existingConnection) {
         activeConnections.delete(publicKey);
         activeRPCs.delete(publicKey);
         clearPeerConnectionTracking(publicKey);
     }
 }
-// Establish RPC connection to a peer if not already connected
-async function ensureRPCConnection(topic, publicKey, timeout, healthCheckTimeout) {
+// Open a direct DHT connection to a peer by public key. Bypasses topic
+// discovery entirely — we already know who we're talking to, so we skip
+// swarm.join()/flush() and let the DHT route by public key.
+function openDhtConnection(publicKey) {
+    const swarm = getSwarm();
+    const relayThrough = swarm.relayThrough
+        ? swarm.relayThrough(false, swarm)
+        : null;
+    return swarm.dht.connect(Buffer.from(publicKey, "hex"), {
+        keyPair: swarm.keyPair,
+        relayThrough,
+    });
+}
+// Resolve when the DHT connection emits "open"; reject promptly on "error"
+// or "close" so firewall-rejected / abruptly-closed connects fail fast
+// instead of dragging out the full delegate timeout (60s on cold paths).
+function waitForOpen(conn, timeout) {
+    const opened = new Promise((resolve, reject) => {
+        const cleanup = () => {
+            conn.removeListener("open", onOpen);
+            conn.removeListener("error", onError);
+            conn.removeListener("close", onClose);
+        };
+        const onOpen = () => {
+            cleanup();
+            resolve();
+        };
+        const onError = (err) => {
+            cleanup();
+            reject(err);
+        };
+        const onClose = () => {
+            cleanup();
+            reject(new DelegateConnectionFailedError("Connection closed before open (peer unreachable or rejected by firewall)"));
+        };
+        conn.once("open", onOpen);
+        conn.once("error", onError);
+        conn.once("close", onClose);
+    });
+    return withTimeout(opened, timeout);
+}
+async function ensureRPCConnection(publicKey, timeout, healthCheckTimeout) {
     const healthCheckCap = healthCheckTimeout ?? HEALTH_CHECK_TIMEOUT_MS;
     const operationStart = nowMs();
     const getRemainingTimeout = () => {
-        if (timeout === undefined) {
+        if (timeout === undefined)
             return undefined;
-        }
         return Math.max(timeout - (nowMs() - operationStart), 0);
     };
-    // Check if we already have an RPC instance for this peer
     const existingRpc = activeRPCs.get(publicKey);
     if (existingRpc) {
         const remainingTimeout = getRemainingTimeout();
@@ -111,89 +132,77 @@ async function ensureRPCConnection(topic, publicKey, timeout, healthCheckTimeout
         logger.info(`🧹 Cached RPC failed health check for peer ${publicKey}, reconnecting`);
         cleanupStaleConnection(publicKey);
     }
-    const swarm = getSwarm();
     const connectionStart = nowMs();
-    // Track the listener so we can clean it up on timeout
-    let onConnection = () => { };
+    let conn;
     try {
-        logger.info(`🔗 Establishing RPC connection to topic: ${topic}, peer: ${publicKey}, timeout: ${timeout}ms`);
-        const connectionPromise = new Promise((resolve, reject) => {
-            const topicBuffer = Buffer.from(topic, "hex");
-            swarm.join(topicBuffer, {
-                server: false,
-                client: true,
-            });
-            // Wait for the specific peer's connection event instead of just
-            // checking after flush. This handles the case where flush resolves
-            // (discovery done) but the P2P connection is still being established
-            // via holepunching or relays.
-            onConnection = (conn) => {
-                const peerPubkey = conn.remotePublicKey?.toString("hex");
-                if (peerPubkey === publicKey) {
-                    swarm.removeListener("connection", onConnection);
-                    // The global handler (ensureConnectionHandler) will create the RPC
-                    // and store it in activeRPCs. Give it a tick to run first.
-                    const rpc = activeRPCs.get(publicKey);
-                    if (rpc) {
-                        resolve(rpc);
-                    }
-                    else {
-                        // Global handler runs synchronously before us in the same event,
-                        // so this shouldn't happen, but handle it just in case
-                        setTimeout(() => {
-                            const delayedRpc = activeRPCs.get(publicKey);
-                            if (delayedRpc) {
-                                resolve(delayedRpc);
-                            }
-                            else {
-                                reject(new DelegateConnectionFailedError(`Connection established but RPC not created for peer ${publicKey}`));
-                            }
-                        }, 100);
-                    }
-                }
-            };
-            swarm.on("connection", onConnection);
-            // Also flush to trigger discovery. After flush, check if the connection
-            // was already established (the global handler may have caught it).
-            void swarm.flush().then(() => {
-                logger.info(`✅ Flush completed for topic: ${topic}`);
-                logger.debug(`📊 Active RPC connections: ${activeRPCs.size}`);
-                const rpc = activeRPCs.get(publicKey);
-                if (rpc) {
-                    swarm.removeListener("connection", onConnection);
-                    resolve(rpc);
-                }
-                // If not connected after flush, the onConnection listener keeps
-                // waiting until the timeout from withTimeout kicks in.
-                // Hyperswarm may still establish the connection via retries/relays.
-                logger.debug(`⏳ Peer not connected after flush, waiting for connection event...`);
-            });
+        logger.info(`🔗 Establishing direct DHT connection to peer: ${publicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        // Ensure the DHT routing table is populated before attempting to look up
+        // the peer. On a cold swarm the table is nearly empty and findPeer can
+        // return PEER_NOT_FOUND immediately even when the provider is reachable.
+        const bootstrapStart = nowMs();
+        const swarm = getSwarm();
+        logger.info(`⏳ Waiting for DHT to fully bootstrap before connect...`);
+        await withTimeout(swarm.dht.fullyBootstrapped(), getRemainingTimeout());
+        logger.info(`✅ DHT bootstrapped in ${(nowMs() - bootstrapStart).toFixed(0)}ms`);
+        conn = openDhtConnection(publicKey);
+        await waitForOpen(conn, getRemainingTimeout());
+        logger.info(`🍺 Peer connection opened: ${publicKey}`);
+        const rpc = new RPC(conn, () => {
+            // No-op handler since we're only sending requests, not receiving them
         });
-        const rpc = await withTimeout(connectionPromise, getRemainingTimeout());
+        trackConnection(publicKey, conn, rpc);
         const connectionDuration = nowMs() - connectionStart;
         cacheDelegationConnectionTime(publicKey, connectionDuration);
         return rpc;
     }
     catch (error) {
-        // Clean up the per-request connection listener
-        swarm.removeListener("connection", onConnection);
-        // Remove stale connection so next attempt creates a fresh one
-        // instead of reusing a dead RPC
+        if (conn && !conn.destroyed) {
+            conn.destroy();
+        }
         cleanupStaleConnection(publicKey);
         logger.error("Failed to establish RPC connection:", error);
         throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
     }
 }
-// Create an RPC instance for a specific HyperSwarm peer
-export async function getRPC(topic, publicKey, options = {}) {
-    // Ensure the global connection handler is registered (once)
-    ensureConnectionHandler();
-    // Close existing connection if forceNewConnection is true
-    // Await the close to avoid racing with the subsequent join/flush
+// Create an RPC instance for a specific HyperSwarm peer.
+// Connects directly via the DHT using the peer's public key — no topic
+// discovery required.
+//
+// Concurrent calls for the same peer share a single in-flight bootstrap +
+// connect operation, but each caller still gets its own `timeout` enforced
+// against the shared promise (via `withTimeout`) — so a fast caller that
+// gives up at 5s does not block a slow caller waiting up to 60s.
+//
+// `forceNewConnection` always tears down the existing socket first and
+// starts a fresh attempt outside the shared promise.
+export async function getRPC(publicKey, options = {}) {
     if (options.forceNewConnection) {
         await closeConnection(publicKey);
+        return await ensureRPCConnection(publicKey, options.timeout, options.healthCheckTimeout);
+    }
+    let inflight = inflightConnections.get(publicKey);
+    if (!inflight) {
+        inflight = ensureRPCConnection(publicKey, options.timeout, options.healthCheckTimeout);
+        const tracked = inflight;
+        inflightConnections.set(publicKey, tracked);
+        // Clear the inflight entry on settle. We register a single combined
+        // settle handler via `then(handler, handler)` so that on rejection the
+        // failure is *observed* on `tracked` itself — using `tracked.finally(...)`
+        // returns a fresh promise that re-rejects with the original error, and
+        // since nothing awaits that fresh promise it would surface as an
+        // unhandled rejection. The worker treats unhandled rejections as fatal
+        // and tears down the swarm + cancels all in-flight downloads, which then
+        // breaks the legitimate fallback-to-local path that the caller awaits via
+        // `withTimeout(inflight, ...)` below. Caller still observes the original
+        // rejection through `await withTimeout(inflight, ...)`.
+        const clearInflight = () => {
+            if (inflightConnections.get(publicKey) === tracked) {
+                inflightConnections.delete(publicKey);
+            }
+        };
+        tracked.then(clearInflight, clearInflight);
     }
-    return await ensureRPCConnection(topic, publicKey, options.timeout, options.healthCheckTimeout);
+    return await withTimeout(inflight, options.timeout);
 }
 /**
  * Remove a stale RPC connection for a peer.

package/dist/server/bare/hyperswarm.d.ts

@@ -3,8 +3,8 @@ import { type FirewallConfig } from "../../schemas/provide";
 export declare function getSwarm({ firewallConfig, }?: {
     firewallConfig?: FirewallConfig | undefined;
 }): Hyperswarm;
-export declare function registerProviderTopic(topic: string): void;
-export declare function unregisterProviderTopic(topic: string): void;
+export declare function registerProvider(): void;
+export declare function unregisterProvider(): void;
 export declare function hasActiveProviders(): boolean;
 export declare function destroySwarm(): Promise<void>;
 //# sourceMappingURL=hyperswarm.d.ts.map

package/dist/server/bare/hyperswarm.js

@@ -61,7 +61,11 @@ function createSwarm(firewallConfig) {
     return new Hyperswarm(swarmOptions);
 }
 let swarm = null;
-const activeProviderTopics = new Set();
+// Delegation is always 1:1 (single provider service per SDK instance), but we
+// still use a counter to be resilient against duplicate provide/stopProvide
+// calls and to avoid ever reporting "no active providers" while one is still
+// running.
+let activeProviderCount = 0;
 export function getSwarm({ firewallConfig, } = {}) {
     if (swarm) {
         return swarm;
@@ -70,14 +74,15 @@ export function getSwarm({ firewallConfig, } = {}) {
     registerSwarm(swarm, { label: "shared-swarm", createdAt: Date.now() });
     return swarm;
 }
-export function registerProviderTopic(topic) {
-    activeProviderTopics.add(topic);
+export function registerProvider() {
+    activeProviderCount++;
 }
-export function unregisterProviderTopic(topic) {
-    activeProviderTopics.delete(topic);
+export function unregisterProvider() {
+    if (activeProviderCount > 0)
+        activeProviderCount--;
 }
 export function hasActiveProviders() {
-    return activeProviderTopics.size > 0;
+    return activeProviderCount > 0;
 }
 export async function destroySwarm() {
     if (!swarm)
@@ -87,7 +92,7 @@ export async function destroySwarm() {
     try {
         await ref.destroy();
         unregisterSwarm(ref);
-        activeProviderTopics.clear();
+        activeProviderCount = 0;
     }
     catch (error) {
         if (swarm === null)

package/dist/server/bare/ops/cancel.js

@@ -1,12 +1,19 @@
 import { getModel } from "../registry/model-registry.js";
 import { cancelInferenceBaseSchema, } from "../../../schemas/index.js";
 import { ModelNotLoadedError } from "../../../utils/errors-server.js";
+import { noteCancelRequested } from "../plugins/llamacpp-completion/ops/kv-cache-state.js";
 export async function cancel(params) {
     const { modelId } = cancelInferenceBaseSchema.parse(params);
     const model = getModel(modelId);
     if (!model) {
         throw new ModelNotLoadedError(modelId);
     }
+    // Must be recorded *before* `addon.cancel()` so the in-flight
+    // `completion()` for this model sees the bumped counter when it
+    // snapshots after `processModelResponse` returns. This is the signal
+    // that tells `completion()` not to record a `savedCount` for the
+    // kv-cache on a cancelled turn.
+    noteCancelRequested(modelId);
     if (model.addon && model.addon.cancel) {
         await model.addon.cancel();
     }

package/dist/server/bare/ops/kv-cache-utils.d.ts

@@ -1,13 +1,10 @@
+import { type CacheMessage } from "../../utils/index";
 export declare function markCacheInitialized(modelId: string, configHash: string, cacheKey: string): void;
 export declare function isCacheInitialized(modelId: string, configHash: string, cacheKey: string): boolean;
-export declare function clearCacheRegistry(cacheKey?: string): void;
-export interface CacheMessage {
-    role: string;
-    content: string;
-    attachments?: {
-        path: string;
-    }[] | undefined;
-}
+export declare function clearCacheRegistry(scope?: {
+    cacheKey?: string | undefined;
+    modelId?: string | undefined;
+}): void;
 export declare function extractSystemPrompt(messages: CacheMessage[]): string | null;
 export declare function generateConfigHash(systemPrompt: string | null, tools?: unknown): string;
 export declare function generateCacheKey(messages: CacheMessage[]): string;
@@ -20,12 +17,12 @@ export declare function getCurrentCacheInfo(modelId: string, configHash: string,
     cacheKey: string;
     cachePath: string;
 }>;
-export declare function renameCacheFile(oldPath: string, newPath: string): Promise<void>;
+export declare function renameCacheFile(oldPath: string, newPath: string): Promise<boolean>;
 export declare function customCacheExists(modelId: string, configHash: string, cacheKey: string): Promise<boolean>;
 export declare function deleteCache(options: {
     all: true;
 } | {
     kvCacheKey: string;
     modelId?: string;
-}): Promise<void>;
+}): Promise<string>;
 //# sourceMappingURL=kv-cache-utils.d.ts.map

package/dist/server/bare/ops/kv-cache-utils.js

@@ -1,7 +1,7 @@
 import crypto from "bare-crypto";
 import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
-import { getKVCacheDir, validateAndJoinPath } from "../../utils/index.js";
+import { getAutoCacheLookupHistory, getKVCacheDir, validateAndJoinPath, } from "../../utils/index.js";
 import { getServerLogger } from "../../../logging/index.js";
 const logger = getServerLogger();
 // In-memory registry tracks caches initialized this session (addon defers disk writes)
@@ -15,16 +15,24 @@ export function markCacheInitialized(modelId, configHash, cacheKey) {
 export function isCacheInitialized(modelId, configHash, cacheKey) {
     return initializedCaches.has(getCacheRegistryKey(modelId, configHash, cacheKey));
 }
-export function clearCacheRegistry(cacheKey) {
-    if (cacheKey) {
-        for (const key of initializedCaches) {
-            if (key.includes(`:${cacheKey}`)) {
-                initializedCaches.delete(key);
-            }
-        }
-    }
-    else {
+export function clearCacheRegistry(scope) {
+    if (!scope || (scope.cacheKey === undefined && scope.modelId === undefined)) {
         initializedCaches.clear();
+        return;
+    }
+    // key format: "modelId:configHash:cacheKey"
+    for (const key of initializedCaches) {
+        const firstSep = key.indexOf(":");
+        const secondSep = key.indexOf(":", firstSep + 1);
+        if (firstSep === -1 || secondSep === -1)
+            continue;
+        const modelId = key.slice(0, firstSep);
+        const cacheKey = key.slice(secondSep + 1);
+        if (scope.cacheKey !== undefined && cacheKey !== scope.cacheKey)
+            continue;
+        if (scope.modelId !== undefined && modelId !== scope.modelId)
+            continue;
+        initializedCaches.delete(key);
     }
 }
 export function extractSystemPrompt(messages) {
@@ -73,8 +81,7 @@ export async function findMatchingCache(modelId, configHash, currentHistory) {
     if (currentHistory.length <= 1) {
         return null;
     }
-    // Generate cache key for history minus the last message
-    const previousHistory = currentHistory.slice(0, -1);
+    const previousHistory = getAutoCacheLookupHistory(currentHistory);
     const cacheKey = generateCacheKey(previousHistory);
     const cachePath = await getCacheFilePath(modelId, configHash, cacheKey);
     try {
@@ -93,9 +100,11 @@ export async function getCurrentCacheInfo(modelId, configHash, currentHistory) {
 export async function renameCacheFile(oldPath, newPath) {
     try {
         await fsPromises.rename(oldPath, newPath);
+        return true;
     }
     catch (error) {
         logger.error("Error renaming cache file:", error instanceof Error ? error.message : String(error));
+        return false;
     }
 }
 export async function customCacheExists(modelId, configHash, cacheKey) {
@@ -116,33 +125,15 @@ export async function customCacheExists(modelId, configHash, cacheKey) {
 }
 export async function deleteCache(options) {
     const cacheDir = getKVCacheDir();
-    if ("all" in options && options.all) {
-        try {
-            await fsPromises.rm(cacheDir, { recursive: true });
-            await fsPromises.mkdir(cacheDir, { recursive: true });
-        }
-        catch (error) {
-            logger.error("Error deleting all caches:", error instanceof Error ? error.message : String(error));
-        }
-    }
-    else if ("kvCacheKey" in options) {
-        const kvCacheDir = validateAndJoinPath(cacheDir, options.kvCacheKey);
-        if (options.modelId) {
-            const modelCacheDir = validateAndJoinPath(kvCacheDir, options.modelId);
-            try {
-                await fsPromises.rm(modelCacheDir, { recursive: true });
-            }
-            catch (error) {
-                logger.error(`Error deleting model cache ${options.kvCacheKey}/${options.modelId}:`, error instanceof Error ? error.message : String(error));
-            }
-        }
-        else {
-            try {
-                await fsPromises.rm(kvCacheDir, { recursive: true });
-            }
-            catch (error) {
-                logger.error(`Error deleting cache ${options.kvCacheKey}:`, error instanceof Error ? error.message : String(error));
-            }
-        }
+    if ("all" in options) {
+        await fsPromises.rm(cacheDir, { recursive: true, force: true });
+        await fsPromises.mkdir(cacheDir, { recursive: true });
+        return cacheDir;
     }
+    const kvCacheDir = validateAndJoinPath(cacheDir, options.kvCacheKey);
+    const targetDir = options.modelId !== undefined
+        ? validateAndJoinPath(kvCacheDir, options.modelId)
+        : kvCacheDir;
+    await fsPromises.rm(targetDir, { recursive: true, force: true });
+    return targetDir;
 }

package/dist/server/bare/ops/load-model.js

@@ -73,7 +73,6 @@ export async function loadModel(params, options) {
             config: modelConfig,
             modelType: modelType,
             name: modelName,
-            loader: result.loader,
         });
         return modelInitializationTimeMs !== undefined
             ? { timing: { modelInitializationTimeMs } }

package/dist/server/bare/ops/transcribe.d.ts

@@ -1,7 +1,14 @@
-import { type TranscribeParams, type TranscribeStats } from "../../../schemas/index";
-export declare function transcribe(params: TranscribeParams): AsyncGenerator<string, {
+import { type TranscribeParams, type TranscribeSegment, type TranscribeStats } from "../../../schemas/index";
+import { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment } from "../utils/transcribe-metadata";
+export { assertMetadataSupported, toTranscribeSegment, type WhisperAddonSegment, };
+type TranscribeReturn = {
     modelExecutionMs: number;
     stats?: TranscribeStats;
-}, void>;
-export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt?: string): AsyncGenerator<string, void, void>;
+};
+export declare function transcribe(params: TranscribeParams & {
+    metadata: true;
+}): AsyncGenerator<TranscribeSegment, TranscribeReturn, void>;
+export declare function transcribe(params: TranscribeParams): AsyncGenerator<string, TranscribeReturn, void>;
+export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt: string | undefined, metadata: true): AsyncGenerator<TranscribeSegment, void, void>;
+export declare function transcribeStream(modelId: string, audioInputStream: AsyncIterable<Buffer>, prompt?: string, metadata?: boolean): AsyncGenerator<string, void, void>;
 //# sourceMappingURL=transcribe.d.ts.map