@qvac/sdk 0.12.1 → 0.13.0

package/dist/server/bare/delegate-connect-diagnostics.js

@@ -0,0 +1,44 @@
+import { withTimeout } from "../../utils/withTimeout.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
+export const DHT_BOOTSTRAP_WAIT_CAP_MS = 5000;
+// A cold routing table makes findPeer return empty -> spurious PEER_NOT_FOUND,
+// so wait for bootstrap, but only when not yet ready to keep warm-path latency.
+export async function ensureDhtBootstrapped(dht, timeout) {
+    if (dht.bootstrapped)
+        return;
+    const cap = timeout === undefined
+        ? DHT_BOOTSTRAP_WAIT_CAP_MS
+        : Math.min(timeout, DHT_BOOTSTRAP_WAIT_CAP_MS);
+    try {
+        await withTimeout(dht.fullyBootstrapped(), cap);
+    }
+    catch (error) {
+        logger.warn(`DHT not bootstrapped within ${cap}ms before delegated connect; attempting anyway`, { error });
+    }
+}
+// Map an opaque DHT connect error onto why the peer was unreachable: not found
+// on the DHT vs found-but-un-holepunchable. Relays only bridge after a peer is
+// found, so they can never resolve a PEER_NOT_FOUND.
+export function describeConnectFailure(error, publicKey, relayCount) {
+    const code = typeof error === "object" && error !== null && "code" in error
+        ? String(error.code)
+        : undefined;
+    const relayNote = relayCount > 0
+        ? `${relayCount} swarm relay(s) configured`
+        : "no swarm relays configured";
+    switch (code) {
+        case "PEER_NOT_FOUND":
+            return `provider ${publicKey} was not found on the DHT — it may be offline, still bootstrapping, or unreachable from this network. Relays bridge a connection only after the provider is located, so they cannot find an unannounced provider (${relayNote}).`;
+        case "PEER_CONNECTION_FAILED":
+        case "CANNOT_HOLEPUNCH":
+        case "REMOTE_NOT_HOLEPUNCHABLE":
+        case "REMOTE_NOT_HOLEPUNCHING":
+        case "HOLEPUNCH_ABORTED":
+        case "HOLEPUNCH_PROBE_TIMEOUT":
+        case "HOLEPUNCH_DOUBLE_RANDOMIZED_NATS":
+            return `provider ${publicKey} was found but a connection could not be established (NAT/holepunch failure: ${code}; ${relayNote}).`;
+        default:
+            return error instanceof Error ? error.message : String(error);
+    }
+}

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

@@ -1,4 +1,6 @@
 import { getSwarm } from "./hyperswarm.js";
+import { getSDKConfig } from "./registry/config-registry.js";
+import { ensureDhtBootstrapped, describeConnectFailure, } from "./delegate-connect-diagnostics.js";
 import RPC from "bare-rpc";
 import { withTimeout } from "../../utils/withTimeout.js";
 import { DelegateConnectionFailedError } from "../../utils/errors-server.js";
@@ -6,6 +8,7 @@ import { getServerLogger } from "../../logging/index.js";
 import { nowMs } from "../../profiling/index.js";
 import { cacheDelegationConnectionTime, clearPeerConnectionTracking, } from "../rpc/profiling/delegation-profiler.js";
 import { getNextCommandId } from "../rpc/rpc-utils.js";
+import { Buffer } from "bare-buffer";
 const logger = getServerLogger();
 const activeRPCs = new Map();
 const activeConnections = new Map();
@@ -15,6 +18,9 @@ const activeConnections = new Map();
 // open multiple sockets, clobber the active maps, and leak the loser.
 const inflightConnections = new Map();
 const HEALTH_CHECK_TIMEOUT_MS = 1500;
+function getConfiguredRelayCount() {
+    return getSDKConfig().swarmRelays?.length ?? 0;
+}
 function isHeartbeatResponse(payload) {
     return (typeof payload === "object" &&
         payload !== null &&
@@ -134,18 +140,10 @@ async function ensureRPCConnection(publicKey, timeout, healthCheckTimeout) {
     }
     const connectionStart = nowMs();
     let conn;
+    const relayCount = getConfiguredRelayCount();
     try {
-        logger.info(`🔗 Establishing direct DHT connection to peer: ${publicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
-        // We deliberately do NOT `await swarm.dht.fullyBootstrapped()` here. The
-        // earlier guard (added with #1729 to side-step a theoretical PEER_NOT_FOUND
-        // on a fully-cold swarm) added a serial 1-3s wait on every first delegated
-        // call — measurably regressing `loadModel.delegation.connection` vs 0.9.0
-        // (≈3.2× slower in local benches). `getSwarm()` is invoked early during
-        // SDK init (registry/runtime), so by the time the consumer reaches this
-        // path the routing table is already warm enough; `dht.connect()` also
-        // bootstraps on demand if it isn't, so we lose nothing by skipping the
-        // explicit await.
-        getSwarm();
+        logger.info(`🔗 Establishing direct DHT connection to peer: ${publicKey}${timeout ? `, timeout: ${timeout}ms` : ""} (${relayCount} swarm relay(s) configured)`);
+        await ensureDhtBootstrapped(getSwarm().dht, getRemainingTimeout());
         conn = openDhtConnection(publicKey);
         await waitForOpen(conn, getRemainingTimeout());
         logger.info(`🍺 Peer connection opened: ${publicKey}`);
@@ -163,7 +161,7 @@ async function ensureRPCConnection(publicKey, timeout, healthCheckTimeout) {
         }
         cleanupStaleConnection(publicKey);
         logger.error("Failed to establish RPC connection:", error);
-        throw new DelegateConnectionFailedError(`RPC connection failed: ${error instanceof Error ? error.message : String(error)}`, error);
+        throw new DelegateConnectionFailedError(`RPC connection failed: ${describeConnectFailure(error, publicKey, relayCount)}`, error);
     }
 }
 // Create an RPC instance for a specific HyperSwarm peer.

package/dist/server/bare/hyperswarm.js

@@ -5,6 +5,7 @@ import { envSchema } from "../../schemas/provide.js";
 import { getSDKConfig } from "./registry/config-registry.js";
 import { registerSwarm, unregisterSwarm } from "./runtime-lifecycle.js";
 import { getServerLogger } from "../../logging/index.js";
+import { Buffer } from "bare-buffer";
 const logger = getServerLogger();
 function getHyperswarmSeedBuffer() {
     const parsedEnv = envSchema.safeParse(process.env);

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

@@ -0,0 +1,13 @@
+import { type BciStreamOpts, type BciTranscribeParams, type TranscribeSegment, type TranscribeStats } from "../../../schemas/index";
+type BciTranscribeReturn = {
+    modelExecutionMs: number;
+    stats?: TranscribeStats;
+};
+export declare function bciTranscribe(params: BciTranscribeParams & {
+    metadata: true;
+}, requestId?: string): AsyncGenerator<TranscribeSegment, BciTranscribeReturn, void>;
+export declare function bciTranscribe(params: BciTranscribeParams, requestId?: string): AsyncGenerator<string, BciTranscribeReturn, void>;
+export declare function bciTranscribeStream(modelId: string, neuralStream: AsyncIterable<Buffer>, metadata: true, opts?: BciStreamOpts, requestId?: string): AsyncGenerator<TranscribeSegment, void, void>;
+export declare function bciTranscribeStream(modelId: string, neuralStream: AsyncIterable<Buffer>, metadata?: boolean, opts?: BciStreamOpts, requestId?: string): AsyncGenerator<string, void, void>;
+export {};
+//# sourceMappingURL=bci-transcribe.d.ts.map

package/dist/server/bare/ops/bci-transcribe.js

@@ -0,0 +1,248 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { getModel } from "../registry/model-registry.js";
+import {} from "../../../schemas/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+import { TranscriptionFailedError } from "../../../utils/errors-server.js";
+import { nowMs } from "../../../profiling/index.js";
+import { buildStreamResult } from "../../../profiling/model-execution.js";
+import { toTranscribeSegment, } from "../utils/transcribe-metadata.js";
+import { getRequestRegistry, withRequestContext, } from "../runtime/index.js";
+import { generateServerRequestId } from "../runtime/request-id.js";
+async function runBci(model, input) {
+    switch (input.type) {
+        case "base64":
+            return model.transcribe(Buffer.from(input.value, "base64"));
+        case "filePath":
+            return model.transcribeFile(input.value);
+        default:
+            throw new TranscriptionFailedError("Invalid neural input");
+    }
+}
+export async function* bciTranscribe(params, requestId) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const { modelId, metadata } = params;
+        // Open a request-scoped lifecycle. The registry routes
+        // `cancel({ requestId })` and `cancel({ modelId, kind: "transcribe" })`
+        // through this context. Falls back to a server-generated id if the
+        // client didn't send one.
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
+            requestId: requestId ?? generateServerRequestId(),
+            kind: "transcribe",
+            modelId,
+        }), true);
+        const requestLogger = withRequestContext(getServerLogger(), ctx);
+        const model = getModel(modelId);
+        // Hard-cancel wiring: the BCI addon exposes a model-wide `cancel()`
+        // that interrupts the currently-running job. The per-iteration
+        // `if (ctx.signal.aborted) break` below is the soft-cancel safety net
+        // for the gap between the abort firing and the iterator's next pull.
+        const onAbort = () => {
+            if (typeof model.cancel === "function") {
+                model.cancel().catch((err) => {
+                    requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
+        };
+        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        if (ctx.signal.aborted)
+            onAbort();
+        ctx.scope.defer(() => {
+            ctx.signal.removeEventListener("abort", onAbort);
+        });
+        const modelStart = nowMs();
+        const response = await runBci(model, params.neuralData);
+        for await (const output of response.iterate()) {
+            if (ctx.signal.aborted)
+                break;
+            requestLogger.debug("BCI Transcription Update:", output);
+            const chunks = Array.isArray(output) ? output : [output];
+            if (metadata) {
+                for (const chunk of chunks) {
+                    if (!chunk.text)
+                        continue;
+                    yield toTranscribeSegment(chunk);
+                }
+                continue;
+            }
+            const text = chunks.map((chunk) => chunk.text).join("");
+            if (text.trim()) {
+                yield text;
+            }
+        }
+        const modelExecutionMs = nowMs() - modelStart;
+        const stats = {
+            ...(response.stats?.audioDurationMs !== undefined && {
+                audioDuration: response.stats.audioDurationMs,
+            }),
+            ...(response.stats?.realTimeFactor !== undefined && {
+                realTimeFactor: response.stats.realTimeFactor,
+            }),
+            ...(response.stats?.tokensPerSecond !== undefined && {
+                tokensPerSecond: response.stats.tokensPerSecond,
+            }),
+            ...(response.stats?.totalTokens !== undefined && {
+                totalTokens: response.stats.totalTokens,
+            }),
+            ...(response.stats?.totalSegments !== undefined && {
+                totalSegments: response.stats.totalSegments,
+            }),
+            ...(response.stats?.whisperEncodeMs !== undefined && {
+                whisperEncodeTime: response.stats.whisperEncodeMs,
+            }),
+            ...(response.stats?.whisperDecodeMs !== undefined && {
+                whisperDecodeTime: response.stats.whisperDecodeMs,
+            }),
+            ...(response.stats?.encoderMs !== undefined && {
+                encoderTime: response.stats.encoderMs,
+            }),
+            ...(response.stats?.decoderMs !== undefined && {
+                decoderTime: response.stats.decoderMs,
+            }),
+            ...(response.stats?.melSpecMs !== undefined && {
+                melSpecTime: response.stats.melSpecMs,
+            }),
+            ...(response.stats?.backendDevice !== undefined && {
+                backendDevice: response.stats.backendDevice,
+            }),
+            ...(response.stats?.backendId !== undefined && {
+                backendId: response.stats.backendId,
+            }),
+            ...(response.stats?.gpuMemTotalMb !== undefined && {
+                gpuMemTotalMb: response.stats.gpuMemTotalMb,
+            }),
+            ...(response.stats?.gpuMemFreeMb !== undefined && {
+                gpuMemFreeMb: response.stats.gpuMemFreeMb,
+            }),
+        };
+        return buildStreamResult(modelExecutionMs, stats);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        const result_1 = __disposeResources(env_1);
+        if (result_1)
+            await result_1;
+    }
+}
+export async function* bciTranscribeStream(modelId, neuralStream, metadata, opts, requestId) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        // Same `kind: "transcribe"` as the unary BCI variant — the registry
+        // doesn't distinguish streaming vs non-streaming variants of the same
+        // operation, so `cancel({ modelId, kind: "transcribe" })` cancels
+        // either shape.
+        const ctx = __addDisposableResource(env_2, await getRequestRegistry().begin({
+            requestId: requestId ?? generateServerRequestId(),
+            kind: "transcribe",
+            modelId,
+        }), true);
+        const requestLogger = withRequestContext(getServerLogger(), ctx);
+        const model = getModel(modelId);
+        // Hard-cancel wiring: `cancel()` tears down the active stream driver
+        // and interrupts the running window job. The per-iteration abort guard
+        // below is the soft-cancel safety net between the abort firing and the
+        // iterator's next pull.
+        const onAbort = () => {
+            if (typeof model.cancel === "function") {
+                model.cancel().catch((err) => {
+                    requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
+        };
+        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        if (ctx.signal.aborted)
+            onAbort();
+        ctx.scope.defer(() => {
+            ctx.signal.removeEventListener("abort", onAbort);
+        });
+        const streamOpts = {
+            ...(opts?.windowTimesteps !== undefined && {
+                windowTimesteps: opts.windowTimesteps,
+            }),
+            ...(opts?.hopTimesteps !== undefined && { hopTimesteps: opts.hopTimesteps }),
+            ...(opts?.emit !== undefined && { emit: opts.emit }),
+        };
+        const response = await model.transcribeStream(neuralStream, streamOpts);
+        for await (const output of response.iterate()) {
+            if (ctx.signal.aborted)
+                break;
+            requestLogger.debug("BCI Stream Transcription Update:", output);
+            const chunks = Array.isArray(output) ? output : [output];
+            if (metadata) {
+                for (const chunk of chunks) {
+                    if (!chunk.text)
+                        continue;
+                    yield toTranscribeSegment(chunk);
+                }
+                continue;
+            }
+            const text = chunks.map((chunk) => chunk.text).join("");
+            if (text.trim()) {
+                yield text;
+            }
+        }
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        const result_2 = __disposeResources(env_2);
+        if (result_2)
+            await result_2;
+    }
+}

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

@@ -66,7 +66,7 @@ export async function embed(params, requestId) {
         // `cancel({ requestId })` and broad `cancel({ modelId, kind: "embeddings" })`
         // straight to this context's signal. Falls back to a server-generated
         // id if the client didn't send one (older releases).
-        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
             kind: "embeddings",
             modelId,
@@ -121,6 +121,7 @@ export async function embed(params, requestId) {
             ...(response.stats?.tokens_per_second !== undefined && { tokensPerSecond: response.stats.tokens_per_second }),
             ...(response.stats?.total_tokens !== undefined && { totalTokens: response.stats.total_tokens }),
             ...(response.stats?.backendDevice !== undefined && { backendDevice: response.stats.backendDevice }),
+            ...(response.stats?.context_size !== undefined && { contextSize: response.stats.context_size }),
         };
         const embeddingsArray = rawEmbeddings[0];
         if (Array.isArray(text)) {

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

@@ -3,6 +3,7 @@ import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getAutoCacheLookupHistory, getKVCacheDir, validateAndJoinPath, } from "../../utils/index.js";
 import { getServerLogger } from "../../../logging/index.js";
+import { Buffer } from "bare-buffer";
 const logger = getServerLogger();
 // In-memory KV-cache state lives in `KvCacheSession` (the single
 // mutation point for all three KV-cache bookkeeping layers). This
@@ -23,13 +24,13 @@ function getToolNamesForHash(tools) {
 // Cache hash based on system prompt + tool names
 // Different tools = different cache (tools anchored in first message, protected from n_discarded)
 export function generateConfigHash(systemPrompt, tools) {
-    const hash = crypto.createHash("sha256");
+    const hash = crypto.createHash("sha-256");
     const toolNames = getToolNamesForHash(tools);
     hash.update(Buffer.from(JSON.stringify({ systemPrompt, toolNames }), "utf8"));
-    return hash.digest("hex").substring(0, 16);
+    return (hash.digest("hex")).substring(0, 16);
 }
 export function generateCacheKey(messages) {
-    const hash = crypto.createHash("sha256");
+    const hash = crypto.createHash("sha-256");
     const historyString = JSON.stringify(messages);
     const historyBuffer = Buffer.from(historyString, "utf8");
     hash.update(historyBuffer);

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

@@ -117,7 +117,7 @@ export async function* transcribe(params, requestId) {
         // `cancel({ requestId })` and `cancel({ modelId, kind: "transcribe" })`
         // through this context. Falls back to a server-generated id if the
         // client didn't send one.
-        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
             kind: "transcribe",
             modelId,
@@ -193,6 +193,10 @@ export async function* transcribe(params, requestId) {
             ...(response.stats?.encoderMs !== undefined && { encoderTime: response.stats.encoderMs }),
             ...(response.stats?.decoderMs !== undefined && { decoderTime: response.stats.decoderMs }),
             ...(response.stats?.melSpecMs !== undefined && { melSpecTime: response.stats.melSpecMs }),
+            ...(response.stats?.backendDevice !== undefined && { backendDevice: response.stats.backendDevice }),
+            ...(response.stats?.backendId !== undefined && { backendId: response.stats.backendId }),
+            ...(response.stats?.gpuMemTotalMb !== undefined && { gpuMemTotalMb: response.stats.gpuMemTotalMb }),
+            ...(response.stats?.gpuMemFreeMb !== undefined && { gpuMemFreeMb: response.stats.gpuMemFreeMb }),
         };
         return buildStreamResult(modelExecutionMs, stats);
     }
@@ -228,7 +232,7 @@ export async function* transcribeStream(modelId, audioInputStream, prompt, metad
         // doesn't distinguish streaming vs non-streaming variants of the same
         // operation, so `cancel({ modelId, kind: "transcribe" })` cancels
         // either shape.
-        const ctx = __addDisposableResource(env_2, getRequestRegistry().begin({
+        const ctx = __addDisposableResource(env_2, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
             kind: "transcribe",
             modelId,

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

@@ -116,7 +116,7 @@ export async function* translate(params, requestId) {
         // exits on `signal.aborted`, scope unwinds, and the addon may run
         // to completion in the background — acceptable because the result
         // is dropped either way.
-        const ctx = __addDisposableResource(env_1, getRequestRegistry().begin({
+        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId: requestId ?? generateServerRequestId(),
             kind: "translate",
             modelId,

package/dist/server/bare/plugins/bci-whispercpp-transcription/plugin.d.ts

@@ -0,0 +1,130 @@
+import { type CreateModelParams, type PluginModelResult } from "../../../../schemas/index";
+export declare const bciPlugin: {
+    modelType: "bci-whispercpp-transcription";
+    displayName: string;
+    addonPackage: "@qvac/bci-whispercpp";
+    loadConfigSchema: import("zod").ZodObject<{
+        whisperConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+            language: import("zod").ZodOptional<import("zod").ZodString>;
+            n_threads: import("zod").ZodOptional<import("zod").ZodNumber>;
+            temperature: import("zod").ZodOptional<import("zod").ZodNumber>;
+            suppress_nst: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            suppress_blank: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            duration_ms: import("zod").ZodOptional<import("zod").ZodNumber>;
+            translate: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            no_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            single_segment: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            print_special: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            print_progress: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            print_realtime: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            print_timestamps: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            detect_language: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            greedy_best_of: import("zod").ZodOptional<import("zod").ZodNumber>;
+            beam_search_beam_size: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        bciConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+            day_idx: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        contextParams: import("zod").ZodOptional<import("zod").ZodObject<{
+            model: import("zod").ZodOptional<import("zod").ZodString>;
+            use_gpu: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            flash_attn: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            gpu_device: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+        miscConfig: import("zod").ZodOptional<import("zod").ZodObject<{
+            caption_enabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>>;
+        backendsDir: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>;
+    createModel(params: CreateModelParams): PluginModelResult;
+    handlers: {
+        bciTranscribe: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            neuralData: import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"base64">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"filePath">;
+                value: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>], "type">;
+            type: import("zod").ZodLiteral<"bciTranscribe">;
+            requestId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            text: import("zod").ZodOptional<import("zod").ZodString>;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
+                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
+                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
+                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemFreeMb: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            type: import("zod").ZodLiteral<"bciTranscribe">;
+        }, import("zod/v4/core").$strip>>;
+        bciTranscribeStream: import("../../../../schemas/index").PluginHandlerDefinition<import("zod").ZodObject<{
+            modelId: import("zod").ZodString;
+            metadata: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            type: import("zod").ZodLiteral<"bciTranscribeStream">;
+            streamOpts: import("zod").ZodOptional<import("zod").ZodObject<{
+                windowTimesteps: import("zod").ZodOptional<import("zod").ZodNumber>;
+                hopTimesteps: import("zod").ZodOptional<import("zod").ZodNumber>;
+                emit: import("zod").ZodOptional<import("zod").ZodEnum<{
+                    full: "full";
+                    delta: "delta";
+                }>>;
+            }, import("zod/v4/core").$strip>>;
+            requestId: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            text: import("zod").ZodOptional<import("zod").ZodString>;
+            done: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            stats: import("zod").ZodOptional<import("zod").ZodObject<{
+                audioDuration: import("zod").ZodOptional<import("zod").ZodNumber>;
+                realTimeFactor: import("zod").ZodOptional<import("zod").ZodNumber>;
+                tokensPerSecond: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalTokens: import("zod").ZodOptional<import("zod").ZodNumber>;
+                totalSegments: import("zod").ZodOptional<import("zod").ZodNumber>;
+                whisperEncodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                whisperDecodeTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                encoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                decoderTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                melSpecTime: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendDevice: import("zod").ZodOptional<import("zod").ZodNumber>;
+                backendId: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemTotalMb: import("zod").ZodOptional<import("zod").ZodNumber>;
+                gpuMemFreeMb: import("zod").ZodOptional<import("zod").ZodNumber>;
+            }, import("zod/v4/core").$strip>>;
+            error: import("zod").ZodOptional<import("zod").ZodString>;
+            segment: import("zod").ZodOptional<import("zod").ZodObject<{
+                text: import("zod").ZodString;
+                startMs: import("zod").ZodNumber;
+                endMs: import("zod").ZodNumber;
+                append: import("zod").ZodBoolean;
+                id: import("zod").ZodNumber;
+            }, import("zod/v4/core").$strip>>;
+            type: import("zod").ZodLiteral<"bciTranscribeStream">;
+        }, import("zod/v4/core").$strip>>;
+    };
+    logging: {
+        module: import("@qvac/bci-whispercpp/addonLogging").AddonLogging;
+        namespace: "bci-whispercpp-transcription";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map