@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/bare/delegate-connect-diagnostics.d.ts

@@ -1,9 +0,0 @@
-export declare const DHT_BOOTSTRAP_WAIT_CAP_MS = 5000;
-interface BootstrappableDht {
-    bootstrapped: boolean;
-    fullyBootstrapped(): Promise<void>;
-}
-export declare function ensureDhtBootstrapped(dht: BootstrappableDht, timeout: number | undefined): Promise<void>;
-export declare function describeConnectFailure(error: unknown, publicKey: string, relayCount: number): string;
-export {};
-//# sourceMappingURL=delegate-connect-diagnostics.d.ts.map

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

@@ -1,38 +0,0 @@
-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.d.ts

@@ -1,10 +0,0 @@
-import RPC from 'bare-rpc';
-import type { RPCOptions } from '../../schemas/index.js';
-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
- * attempt creates a fresh connection instead of reusing a dead RPC.
- */
-export declare function cleanupStaleConnection(publicKey: string): void;
-//# sourceMappingURL=delegate-rpc-client.d.ts.map

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

@@ -1,219 +0,0 @@
-import { getSwarm } from './hyperswarm.js';
-import { getSDKConfig } from '../../server/bare/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';
-import { getServerLogger } from '../../logging/index.js';
-import { nowMs } from '../../profiling/index.js';
-import { cacheDelegationConnectionTime, clearPeerConnectionTracking } from '../../server/rpc/profiling/delegation-profiler.js';
-import { getNextCommandId } from '../../server/rpc/rpc-utils.js';
-import { Buffer } from 'bare-buffer';
-const logger = getServerLogger();
-const activeRPCs = new Map();
-const activeConnections = new Map();
-// 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 getConfiguredRelayCount() {
-    return getSDKConfig().swarmRelays?.length ?? 0;
-}
-function isHeartbeatResponse(payload) {
-    return (typeof payload === 'object' &&
-        payload !== null &&
-        payload['type'] === 'heartbeat');
-}
-async function isRPCConnectionHealthy(rpc, timeout = HEALTH_CHECK_TIMEOUT_MS) {
-    try {
-        const req = rpc.request(getNextCommandId());
-        req.send(JSON.stringify({ type: 'heartbeat' }), 'utf-8');
-        const response = await withTimeout(req.reply('utf-8'), timeout);
-        const payload = JSON.parse(response?.toString() || '{}');
-        return isHeartbeatResponse(payload);
-    }
-    catch (error) {
-        logger.debug('RPC health check failed', { error });
-        return false;
-    }
-}
-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)
-        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);
-    }
-}
-// 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)
-            return undefined;
-        return Math.max(timeout - (nowMs() - operationStart), 0);
-    };
-    const existingRpc = activeRPCs.get(publicKey);
-    if (existingRpc) {
-        const remainingTimeout = getRemainingTimeout();
-        const probeTimeout = remainingTimeout === undefined
-            ? healthCheckCap
-            : Math.min(remainingTimeout / 2, healthCheckCap);
-        const isHealthy = await isRPCConnectionHealthy(existingRpc, probeTimeout);
-        if (isHealthy) {
-            return existingRpc;
-        }
-        logger.info(`🧹 Cached RPC failed health check for peer ${publicKey}, reconnecting`);
-        cleanupStaleConnection(publicKey);
-    }
-    const connectionStart = nowMs();
-    let conn;
-    const relayCount = getConfiguredRelayCount();
-    try {
-        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}`);
-        const rpc = new RPC(conn, () => {
-            // No-op handler since we're only sending requests, not receiving them
-        });
-        trackConnection(publicKey, conn, rpc);
-        const connectionDuration = nowMs() - connectionStart;
-        cacheDelegationConnectionTime(publicKey, connectionDuration);
-        return rpc;
-    }
-    catch (error) {
-        if (conn && !conn.destroyed) {
-            conn.destroy();
-        }
-        cleanupStaleConnection(publicKey);
-        logger.error('Failed to establish RPC connection:', error);
-        throw new DelegateConnectionFailedError(`RPC connection failed: ${describeConnectFailure(error, publicKey, relayCount)}`, error);
-    }
-}
-// 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 withTimeout(inflight, options.timeout);
-}
-/**
- * Remove a stale RPC connection for a peer.
- * Called when a delegation request fails (e.g., timeout) so the next
- * attempt creates a fresh connection instead of reusing a dead RPC.
- */
-export function cleanupStaleConnection(publicKey) {
-    logger.info(`🗑️ Removing stale connection for peer: ${publicKey} after failed delegation`);
-    activeRPCs.delete(publicKey);
-    const conn = activeConnections.get(publicKey);
-    if (conn) {
-        conn.destroy();
-        activeConnections.delete(publicKey);
-    }
-    clearPeerConnectionTracking(publicKey);
-}

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

@@ -1,10 +0,0 @@
-import Hyperswarm from 'hyperswarm';
-import { type FirewallConfig } from '../../schemas/provide.js';
-export declare function getSwarm({ firewallConfig }?: {
-    firewallConfig?: FirewallConfig | undefined;
-}): Hyperswarm;
-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

@@ -1,103 +0,0 @@
-import env from 'bare-env';
-import Hyperswarm from 'hyperswarm';
-import crypto from 'bare-crypto';
-import { envSchema } from '../../schemas/provide.js';
-import { getSDKConfig } from '../../server/bare/registry/config-registry.js';
-import { registerSwarm, unregisterSwarm } from '../../server/bare/runtime-lifecycle.js';
-import { getServerLogger } from '../../logging/index.js';
-import { Buffer } from 'bare-buffer';
-const logger = getServerLogger();
-function getHyperswarmSeedBuffer() {
-    const parsedEnv = envSchema.safeParse(env);
-    if (parsedEnv.success) {
-        return Buffer.from(parsedEnv.data.QVAC_HYPERSWARM_SEED, 'hex');
-    }
-    else {
-        logger.info(`🎲 No seed provided, generating random seed (provider will have random identity)`);
-        return crypto.randomBytes(32);
-    }
-}
-function createFirewallFunction(config) {
-    if (!config || config.publicKeys.length === 0) {
-        return () => false;
-    }
-    const { mode, publicKeys } = config;
-    const publicKeySet = new Set(publicKeys);
-    return (remotePublicKey) => {
-        const remoteKeyHex = remotePublicKey.toString('hex');
-        if (mode === 'allow') {
-            const allowed = publicKeySet.has(remoteKeyHex);
-            if (!allowed) {
-                logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (not in allowlist)`);
-            }
-            else {
-                logger.debug(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (in allowlist)`);
-            }
-            return !allowed;
-        }
-        else {
-            const denied = publicKeySet.has(remoteKeyHex);
-            if (denied) {
-                logger.debug(`🚫 Firewall: Denied connection from ${remoteKeyHex.substring(0, 16)}... (in denylist)`);
-            }
-            else {
-                logger.debug(`✅ Firewall: Allowed connection from ${remoteKeyHex.substring(0, 16)}... (not in denylist)`);
-            }
-            return denied;
-        }
-    };
-}
-function createSwarm(firewallConfig) {
-    const seed = getHyperswarmSeedBuffer();
-    const firewall = createFirewallFunction(firewallConfig);
-    const getRelays = () => {
-        const config = getSDKConfig();
-        const relayPublicKeys = config.swarmRelays;
-        if (!relayPublicKeys || relayPublicKeys.length === 0) {
-            return null;
-        }
-        return relayPublicKeys.map((key) => Buffer.from(key, 'hex'));
-    };
-    const swarmOptions = { seed, firewall, relayThrough: getRelays };
-    return new Hyperswarm(swarmOptions);
-}
-let swarm = null;
-// 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;
-    }
-    swarm = createSwarm(firewallConfig);
-    registerSwarm(swarm, { label: 'shared-swarm', createdAt: Date.now() });
-    return swarm;
-}
-export function registerProvider() {
-    activeProviderCount++;
-}
-export function unregisterProvider() {
-    if (activeProviderCount > 0)
-        activeProviderCount--;
-}
-export function hasActiveProviders() {
-    return activeProviderCount > 0;
-}
-export async function destroySwarm() {
-    if (!swarm)
-        return;
-    const ref = swarm;
-    swarm = null;
-    try {
-        await ref.destroy();
-        unregisterSwarm(ref);
-        activeProviderCount = 0;
-    }
-    catch (error) {
-        if (swarm === null)
-            swarm = ref;
-        throw error;
-    }
-}

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

@@ -1,13 +0,0 @@
-import { type BciStreamOpts, type BciTranscribeParams, type TranscribeSegment, type TranscribeStats } from '../../../schemas/index.js';
-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

@@ -1,248 +0,0 @@
-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 '../../../server/bare/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 '../../../server/bare/utils/transcribe-metadata.js';
-import { getRequestRegistry, withRequestContext } from '../../../server/bare/runtime/index.js';
-import { generateServerRequestId } from '../../../server/bare/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;
-    }
-}