@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/worker-core.js

@@ -1,206 +0,0 @@
-import os from 'bare-os';
-import Signal from 'bare-signals';
-import { createBareKitRPCServer, createIPCClient } from '../server/rpc/create-server.js';
-import { destroySwarm } from '../server/bare/hyperswarm.js';
-import { initEnv, getValidatedEnv } from '../server/env.js';
-import { closeAllRagInstances } from '../server/bare/rag-hyperdb/index.js';
-import { cleanupDownloads } from '../server/rpc/handlers/load-model/download-manager.js';
-import { unloadAllModels } from '../server/bare/registry/model-registry.js';
-import { closeRegistryClient } from '../server/bare/registry/registry-client.js';
-import { clearAllLoggingStreams, startLogBuffering, stopLogBufferingWithTimeout } from '../server/bare/registry/logging-stream-registry.js';
-import { clearAllAddonLoggers, getServerLogger, SDK_LOG_ID, SDK_ALL_LOG_ID } from '../logging/index.js';
-import { clearPlugins } from '../server/plugins/index.js';
-import { acquireWorkerLock, releaseWorkerLock } from '../server/utils/worker-lock.js';
-import { nativeResourceCollectorDependencies } from '../server/bare/resources/native.js';
-import { destroyWorkerResourceCollector, initializeWorkerResourceCollector } from '../server/bare/resources/worker-collector.js';
-let coreInitialized = false;
-let rpcInitialized = false;
-// Set true when the cleanup body has run at least once. Lets both
-// cleanupForTerminate (pre-terminate path) and shutdownBareDirectWorker
-// (signal/exit path) call runCleanup() without doing duplicate work.
-let cleanupRan = false;
-// Set true when shutdownBareDirectWorker is in flight. Distinct from
-// cleanupRan: cleanupForTerminate must NOT set this, otherwise a later
-// SIGTERM/SIGINT/uncaught-exception would early-return at the guard
-// in shutdownBareDirectWorker and skip releaseWorkerLock + Bare.exit.
-let isShuttingDown = false;
-const logger = getServerLogger();
-// Defense-in-depth grace period for the SIGKILL safety net armed before
-// Bare.exit() in shutdownBareDirectWorker. If Bare.exit cannot
-// terminate the worker within this window — typically because some path
-// holds a non-cancellable native handle (e.g. a libuv worker thread
-// blocked on flock; see QVAC-18197) — we force-kill the OS process to
-// guarantee bounded shutdown time.
-const FORCE_EXIT_GRACE_MS = 3_000;
-function scheduleForceExit() {
-    const timer = setTimeout(() => {
-        logger.error(`Bare.exit did not terminate the worker within ${FORCE_EXIT_GRACE_MS}ms — ` +
-            `force-killing self (likely blocked native handle)`);
-        try {
-            os.kill(os.pid(), 'SIGKILL');
-        }
-        catch {
-            // best-effort — if SIGKILL itself fails, there's nothing more to do
-        }
-    }, FORCE_EXIT_GRACE_MS);
-    // Don't let the safety-net timer keep the process alive on the happy
-    // path. Bare returns an object (not a number) from setTimeout.
-    if (timer && typeof timer === 'object' && 'unref' in timer) {
-        ;
-        timer.unref();
-    }
-}
-export function initializeWorkerCore() {
-    if (coreInitialized) {
-        const validatedEnv = getValidatedEnv();
-        return { hasRPCConfig: !!validatedEnv.QVAC_IPC_SOCKET_PATH };
-    }
-    startLogBuffering(SDK_LOG_ID);
-    startLogBuffering(SDK_ALL_LOG_ID);
-    const { hasRPCConfig } = initEnv();
-    acquireWorkerLock();
-    initializeWorkerResourceCollector(nativeResourceCollectorDependencies);
-    setupShutdownHandlers();
-    coreInitialized = true;
-    logger.debug('Worker core initialized');
-    logger.debug('Arguments to worker:', Bare.argv);
-    return { hasRPCConfig };
-}
-export function ensureRPCSetup() {
-    if (rpcInitialized)
-        return;
-    if (!coreInitialized) {
-        initializeWorkerCore();
-    }
-    try {
-        const validatedEnv = getValidatedEnv();
-        const ipcSocketPath = validatedEnv.QVAC_IPC_SOCKET_PATH;
-        if (ipcSocketPath) {
-            logger.info(`Running in desktop mode, connecting to IPC socket: ${ipcSocketPath}`);
-            const rpc = createIPCClient(ipcSocketPath, {
-                onDisconnect: () => void shutdownBareDirectWorker('ipc-disconnect')
-            });
-            logger.debug('Desktop IPC client created?', !!rpc);
-        }
-        else {
-            logger.info('Running in BareKit IPC mode');
-            createBareKitRPCServer();
-        }
-        logger.info('Bare worker started and listening for RPC requests');
-        logger.debug('Working directory:', os.cwd());
-        rpcInitialized = true;
-        // The worker is now reachable, so a `subscribeServerLogs` client can connect.
-        // Bound the global startup buffer the same way model-load buffering is bounded:
-        // if nothing subscribes within the grace window, stop buffering so every server
-        // log doesn't keep churning that buffer for the worker's whole lifetime. A
-        // subscriber that connects in time cancels the timeout and flushes the buffer.
-        stopLogBufferingWithTimeout(SDK_ALL_LOG_ID);
-    }
-    catch (error) {
-        logger.error('Worker error:', error);
-        Bare.exit(1);
-    }
-}
-export function isCoreInitialized() {
-    return coreInitialized;
-}
-function clearRegistries() {
-    clearAllLoggingStreams();
-    clearAllAddonLoggers();
-    clearPlugins();
-}
-/**
- * Run the cleanup body shared by terminal and graceful-shutdown paths.
- * Clears plugin registries (which calls each addon's `releaseLogger` →
- * frees env-bound js_ref_t state), unloads all loaded models (which calls
- * each addon's `destroyInstance`), and closes infra (swarm, rag, downloads,
- * registry client). Does NOT touch the worker lock or call `Bare.exit`.
- *
- * Idempotent: subsequent calls are no-ops via the `cleanupRan` flag. The
- * underlying clearPlugins / unloadAllModels / closers are also idempotent
- * on empty registries, but the flag avoids the redundant log noise and
- * allocator churn.
- */
-async function runCleanup() {
-    if (cleanupRan)
-        return;
-    cleanupRan = true;
-    destroyWorkerResourceCollector();
-    clearRegistries();
-    await Promise.allSettled([
-        destroySwarm(),
-        closeAllRagInstances(),
-        cleanupDownloads(),
-        unloadAllModels(),
-        closeRegistryClient()
-    ]);
-}
-/**
- * Pre-terminate cleanup, callable while the worker is still alive.
- *
- * On platforms where the worker lives in the same OS process as the JS host
- * (i.e. mobile via react-native-bare-kit Worklet), `Bare.exit()` would
- * kill the entire app. This path runs the same registry/model cleanup as
- * `shutdownBareDirectWorker` but skips the lock release + exit, leaving the
- * caller (typically the SDK client about to call `worklet.terminate()`)
- * responsible for tearing the worker down.
- *
- * Critical for clean termination: addons hold static state with js_ref_t
- * handles into the current V8 isolate; without this cleanup, those refs
- * survive into the next worklet's isolate and crash on first access.
- */
-export async function cleanupForTerminate() {
-    // Intentionally does NOT set isShuttingDown — that flag is reserved for
-    // shutdownBareDirectWorker so a later SIGTERM/SIGINT still gets to run
-    // the lock release + Bare.exit path. runCleanup is idempotent on its
-    // own, so a follow-up shutdownBareDirectWorker call won't redo the body.
-    if (cleanupRan)
-        return;
-    logger.info('🧹 Pre-terminate cleanup starting...');
-    try {
-        await runCleanup();
-        logger.info('✅ Pre-terminate cleanup completed');
-    }
-    catch (error) {
-        logger.error('❌ Error during pre-terminate cleanup:', error);
-    }
-}
-export async function shutdownBareDirectWorker(reason) {
-    if (isShuttingDown)
-        return;
-    isShuttingDown = true;
-    const messages = {
-        signal: '🐻 Bare worker shutdown signal received, cleaning up...',
-        'rpc-close': '🧹 Bare direct mode RPC closed, cleaning up...',
-        'uncaught-exception': '💥 Uncaught exception, cleaning up...',
-        'unhandled-rejection': '💥 Unhandled rejection, cleaning up...',
-        'ipc-disconnect': '🔌 Parent IPC disconnected, cleaning up...'
-    };
-    logger.info(messages[reason]);
-    try {
-        // Idempotent: if cleanupForTerminate already ran, this is a no-op.
-        await runCleanup();
-        logger.info('✅ Cleanup completed successfully');
-    }
-    catch (error) {
-        logger.error('❌ Error during shutdown cleanup:', error);
-    }
-    releaseWorkerLock();
-    scheduleForceExit();
-    const isGraceful = reason === 'signal' || reason === 'rpc-close';
-    Bare.exit(isGraceful ? 0 : 1);
-}
-function setupShutdownHandlers() {
-    const signals = new Signal.Emitter();
-    signals.unref();
-    signals.once('SIGTERM', () => void shutdownBareDirectWorker('signal'));
-    signals.once('SIGINT', () => void shutdownBareDirectWorker('signal'));
-    Bare.on('uncaughtException', (err) => {
-        logger.error('Uncaught exception in worker:', err);
-        void shutdownBareDirectWorker('uncaught-exception');
-    });
-    Bare.on('unhandledRejection', (reason) => {
-        logger.error('Unhandled rejection in worker:', reason);
-        void shutdownBareDirectWorker('unhandled-rejection');
-    });
-}

package/dist/server/worker.d.ts

@@ -1,5 +0,0 @@
-/**
- * Default worker entry point that registers ALL built-in plugins.
- */
-export {};
-//# sourceMappingURL=worker.d.ts.map

package/dist/server/worker.js

@@ -1,34 +0,0 @@
-/**
- * Default worker entry point that registers ALL built-in plugins.
- */
-import { initializeWorkerCore, ensureRPCSetup } from '../server/worker-core.js';
-import { registerPlugins } from '../server/plugins/index.js';
-import { getServerLogger } from '../logging/index.js';
-import { llmPlugin, embeddingsPlugin, whisperPlugin, bciPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, audioGenPlugin, vlaPlugin, classificationPlugin } from '../server/bare/plugins/index.js';
-const { hasRPCConfig } = initializeWorkerCore();
-const logger = getServerLogger();
-logger.info('🐻 Hello from Bare');
-registerPlugins([
-    llmPlugin,
-    embeddingsPlugin,
-    whisperPlugin,
-    bciPlugin,
-    parakeetPlugin,
-    nmtPlugin,
-    ttsPlugin,
-    ocrPlugin,
-    diffusionPlugin,
-    audioGenPlugin,
-    vlaPlugin,
-    classificationPlugin
-]);
-logger.info(hasRPCConfig
-    ? 'Parsed RPC configuration from arguments'
-    : 'Using default configuration (direct mode)');
-// Auto-setup RPC only if we successfully parsed RPC configuration
-if (hasRPCConfig) {
-    ensureRPCSetup();
-}
-else {
-    logger.info('Running in direct mode - RPC setup will be lazy');
-}

package/dist/utils/aggregate-events.d.ts

@@ -1,26 +0,0 @@
-import type { CompletionError, CompletionEvent, CompletionFinal, CompletionStats, StopReason, ToolCall } from '../schemas/index.js';
-import { type ToolHandlerMap } from '../utils/tool-helpers.js';
-export type AggregatedEvents = {
-    contentText: string;
-    thinkingText: string;
-    stats: CompletionStats | undefined;
-    toolCalls: ToolCall[];
-    rawFullText: string | undefined;
-    error: CompletionError | undefined;
-    stopReason: StopReason | undefined;
-    /**
-     * True when the terminal `completionDone` carried
-     * `stopReason: "cancelled"`. The client wrapper rejects the
-     * promise-aggregates (`final` / `text` / `toolCalls` / `stats`) with
-     * `InferenceCancelledError` carrying the partial state when this is
-     * set; the `events` stream itself still ends normally.
-     */
-    cancelled: boolean;
-};
-export declare function aggregateEvents(events: CompletionEvent[]): AggregatedEvents;
-export declare function buildFinalFromEvents(events: CompletionEvent[], handlers: ToolHandlerMap): {
-    final: CompletionFinal;
-    error: CompletionError | undefined;
-    cancelled: boolean;
-};
-//# sourceMappingURL=aggregate-events.d.ts.map

package/dist/utils/aggregate-events.js

@@ -1,73 +0,0 @@
-import { normalizeAssistantCacheContent } from '../utils/cache-normalize.js';
-import { attachHandlersToToolCalls } from '../utils/tool-helpers.js';
-export function aggregateEvents(events) {
-    let contentText = '';
-    let thinkingText = '';
-    let stats;
-    let rawFullText;
-    let error;
-    let stopReason;
-    let cancelled = false;
-    const toolCalls = [];
-    for (const event of events) {
-        if (event.type === 'contentDelta') {
-            contentText += event.text;
-        }
-        else if (event.type === 'thinkingDelta') {
-            thinkingText += event.text;
-        }
-        else if (event.type === 'completionStats') {
-            stats = event.stats;
-        }
-        else if (event.type === 'toolCall') {
-            toolCalls.push(event.call);
-        }
-        else if (event.type === 'completionDone') {
-            if ('raw' in event && event.raw) {
-                rawFullText = event.raw.fullText;
-            }
-            // Error wins over cancelled if a wire event ever carries both
-            // signals: a mid-stream addon failure makes the partial state
-            // unsafe to expose, regardless of why the loop exited.
-            if (event.stopReason === 'error' && 'error' in event) {
-                error = event.error;
-            }
-            else {
-                if (event.stopReason !== undefined) {
-                    stopReason = event.stopReason;
-                }
-                if (event.stopReason === 'cancelled') {
-                    cancelled = true;
-                }
-            }
-        }
-    }
-    return {
-        contentText,
-        thinkingText,
-        stats,
-        toolCalls,
-        rawFullText,
-        error,
-        stopReason,
-        cancelled
-    };
-}
-export function buildFinalFromEvents(events, handlers) {
-    const { contentText, thinkingText, stats, toolCalls, rawFullText, error, stopReason, cancelled } = aggregateEvents(events);
-    const attachedToolCalls = attachHandlersToToolCalls(toolCalls, handlers);
-    const fullText = rawFullText ?? contentText;
-    const cacheableAssistantContent = attachedToolCalls.length === 0 ? normalizeAssistantCacheContent(fullText) : undefined;
-    const final = {
-        contentText,
-        ...(thinkingText && { thinkingText }),
-        toolCalls: attachedToolCalls,
-        ...(stats && { stats }),
-        raw: { fullText },
-        ...(cacheableAssistantContent !== undefined && {
-            cacheableAssistantContent
-        }),
-        ...(stopReason !== undefined && { stopReason })
-    };
-    return { final, error, cancelled };
-}

package/dist/utils/errors-client.d.ts

@@ -1,178 +0,0 @@
-import { QvacErrorBase } from '@qvac/error';
-export declare class InvalidResponseError extends QvacErrorBase {
-    constructor(expected: string, cause?: unknown);
-}
-export declare class InvalidOperationError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class StreamEndedError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class InvalidAudioChunkError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class InvalidToolsArrayError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class InvalidToolSchemaError extends QvacErrorBase {
-    constructor(details: string, cause?: unknown);
-}
-export declare class OCRFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class ModelTypeRequiredError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class ModelSrcTypeMismatchError extends QvacErrorBase {
-    constructor(inferred: string, resolved: string, cause?: unknown);
-}
-export declare class RPCNoHandlerError extends QvacErrorBase {
-    constructor(requestType: string, cause?: unknown);
-}
-export declare class RPCRequestNotSentError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class RPCResponseStreamNotCreatedError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class RPCConnectionFailedError extends QvacErrorBase {
-    constructor(details: string, cause?: unknown);
-}
-export declare class RPCInitTimeoutError extends QvacErrorBase {
-    constructor(timeoutMs: number, cause?: unknown);
-}
-export declare class WorkerCrashedError extends QvacErrorBase {
-    readonly exitCode: number | null;
-    readonly exitSignal: NodeJS.Signals | null;
-    constructor(exitCode: number | null, exitSignal: NodeJS.Signals | null, cause?: unknown);
-}
-export declare class WorkerShutdownError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class ProviderStartFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class ProviderStopFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class DelegateNoFinalResponseError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class DelegateProviderError extends QvacErrorBase {
-    constructor(details: string, cause?: unknown);
-}
-export declare class DelegateConnectionFailedError extends QvacErrorBase {
-    constructor(details: string, cause?: unknown);
-}
-export declare class SDKNotFoundInNodeModulesError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class MultipleSDKInstallationsError extends QvacErrorBase {
-    constructor(packages: string, cause?: unknown);
-}
-export declare class WorkerFileNotFoundError extends QvacErrorBase {
-    constructor(workerPath: string, cause?: unknown);
-}
-export declare class PearWorkerEntryRequiredError extends QvacErrorBase {
-    constructor(workerEntry: string, cause?: unknown);
-}
-export declare class WorkerPluginsNotRegisteredError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class BundleVerificationFailedError extends QvacErrorBase {
-    constructor(bundlePath: string, cause?: unknown);
-}
-export declare class BarePackNotInstalledError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class BarePackError extends QvacErrorBase {
-    constructor(exitCode: number, entryPath: string, outputPath: string, cause?: unknown);
-}
-export declare class InvalidPluginSpecifierError extends QvacErrorBase {
-    constructor(specifiers: string[], cause?: unknown);
-}
-export declare class BareImportsMapNotFoundError extends QvacErrorBase {
-    constructor(sdkName: string, expectedPath: string, cause?: unknown);
-}
-export declare class BareRuntimeBinaryNotFoundError extends QvacErrorBase {
-    constructor(platform: string, arch: string, cause?: unknown);
-}
-export declare class ConfigFileNotFoundError extends QvacErrorBase {
-    constructor(searchPaths: string, cause?: unknown);
-}
-export declare class ConfigFileInvalidError extends QvacErrorBase {
-    constructor(filePath: string, reason: string, cause?: unknown);
-}
-export declare class ConfigFileParseFailedError extends QvacErrorBase {
-    constructor(filePath: string, error: string, cause?: unknown);
-}
-export declare class ConfigValidationFailedError extends QvacErrorBase {
-    constructor(errors: string, cause?: unknown);
-}
-export declare class RequestValidationFailedError extends QvacErrorBase {
-    constructor(errors: string, cause?: unknown);
-}
-export declare class ModelUnloadFailedError extends QvacErrorBase {
-    constructor(modelId?: string, cause?: unknown);
-}
-export declare class EmbedFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class TranscriptionFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class TextToSpeechStreamFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class CancelFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class RAGChunkFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class RAGSaveFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class RAGSearchFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class RAGDeleteFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class RAGCloseWorkspaceFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class RAGListWorkspacesFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class DownloadAssetFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class DownloadCancelledError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class ChecksumValidationFailedError extends QvacErrorBase {
-    constructor(fileName: string, cause?: unknown);
-}
-export declare class HTTPError extends QvacErrorBase {
-    constructor(status: number, statusText: string, cause?: unknown);
-}
-export declare class ModelLoadFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class DeleteCacheFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class InvalidDeleteCacheParamsError extends QvacErrorBase {
-    constructor(cause?: unknown);
-}
-export declare class SetConfigFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class ModelRegistryQueryFailedError extends QvacErrorBase {
-    constructor(details?: string, cause?: unknown);
-}
-export declare class ProfilerInvalidCapacityError extends QvacErrorBase {
-    constructor(minCapacity: number, cause?: unknown);
-}
-//# sourceMappingURL=errors-client.d.ts.map