@qvac/sdk 0.18.2 → 0.19.0

package/dist/src/utils/errors-client.js

@@ -0,0 +1,305 @@
+import { QvacErrorBase } from '@qvac/error';
+import { SDK_CLIENT_ERROR_CODES } from '../schemas/sdk-errors-client.js';
+import { SDK_SERVER_ERROR_CODES } from '../schemas/sdk-errors-server.js';
+import { createErrorOptions } from './errors-base.js';
+// ============== Response Validation Errors ==============
+export class InvalidResponseError extends QvacErrorBase {
+    constructor(expected, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_RESPONSE_TYPE, [expected], cause));
+    }
+}
+export class InvalidOperationError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_OPERATION_IN_RESPONSE, undefined, cause));
+    }
+}
+export class StreamEndedError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.STREAM_ENDED_WITHOUT_RESPONSE, undefined, cause));
+    }
+}
+export class InvalidAudioChunkError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_AUDIO_CHUNK_TYPE, undefined, cause));
+    }
+}
+export class InvalidToolsArrayError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_TOOLS_ARRAY, undefined, cause));
+    }
+}
+export class InvalidToolSchemaError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_TOOL_SCHEMA, [details], cause));
+    }
+}
+export class OCRFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.OCR_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class ModelTypeRequiredError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.MODEL_TYPE_REQUIRED, undefined, cause));
+    }
+}
+export class ModelSrcTypeMismatchError extends QvacErrorBase {
+    constructor(inferred, resolved, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.MODEL_SRC_TYPE_MISMATCH, [inferred, resolved], cause));
+    }
+}
+// ============== RPC Communication Errors ==============
+export class RPCNoHandlerError extends QvacErrorBase {
+    constructor(requestType, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_NO_HANDLER, [requestType], cause));
+    }
+}
+export class RPCRequestNotSentError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_REQUEST_NOT_SENT, undefined, cause));
+    }
+}
+export class RPCResponseStreamNotCreatedError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_RESPONSE_STREAM_NOT_CREATED, undefined, cause));
+    }
+}
+export class RPCConnectionFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_CONNECTION_FAILED, [details], cause));
+    }
+}
+export class RPCInitTimeoutError extends QvacErrorBase {
+    constructor(timeoutMs, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.RPC_INIT_TIMEOUT, [timeoutMs], cause));
+    }
+}
+export class WorkerCrashedError extends QvacErrorBase {
+    exitCode;
+    exitSignal;
+    constructor(exitCode, exitSignal, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_CRASHED, [String(exitCode), String(exitSignal)], cause));
+        this.exitCode = exitCode;
+        this.exitSignal = exitSignal;
+    }
+}
+/**
+ * A worker that failed before the IPC handshake, attached as the `cause` of
+ * `RPCInitTimeoutError`. `workerExited` separates a dead worker from a merely
+ * slow one; `exitCode` / `exitSignal` mirror what `WorkerCrashedError` carries
+ * on the post-handshake path.
+ */
+export class WorkerStartupError extends QvacErrorBase {
+    /** False while the process is still running and simply has not connected. */
+    workerExited;
+    exitCode;
+    exitSignal;
+    /** Bounded tail of the worker's stderr; empty when it wrote nothing. */
+    stderrTail;
+    constructor(details, exit, stderrTail, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_STARTUP_FAILED, [details, stderrTail], cause));
+        this.workerExited = exit !== null;
+        this.exitCode = exit?.code ?? null;
+        this.exitSignal = exit?.signal ?? null;
+        this.stderrTail = stderrTail;
+    }
+}
+export class WorkerShutdownError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_SHUTDOWN, undefined, cause));
+    }
+}
+// ============== Build/Bundle Errors ==============
+export class SDKNotFoundInNodeModulesError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.SDK_NOT_FOUND_IN_NODE_MODULES, undefined, cause));
+    }
+}
+export class MultipleSDKInstallationsError extends QvacErrorBase {
+    constructor(packages, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.MULTIPLE_SDK_INSTALLATIONS, [packages], cause));
+    }
+}
+export class WorkerFileNotFoundError extends QvacErrorBase {
+    constructor(workerPath, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_FILE_NOT_FOUND, [workerPath], cause));
+    }
+}
+export class PearWorkerEntryRequiredError extends QvacErrorBase {
+    constructor(workerEntry, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.PEAR_WORKER_ENTRY_REQUIRED, [workerEntry], cause));
+    }
+}
+export class WorkerPluginsNotRegisteredError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.WORKER_PLUGINS_NOT_REGISTERED, [], cause));
+    }
+}
+export class BundleVerificationFailedError extends QvacErrorBase {
+    constructor(bundlePath, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BUNDLE_VERIFICATION_FAILED, [bundlePath], cause));
+    }
+}
+export class BarePackNotInstalledError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BARE_PACK_NOT_INSTALLED, undefined, cause));
+    }
+}
+export class BarePackError extends QvacErrorBase {
+    constructor(exitCode, entryPath, outputPath, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BARE_PACK_ERROR, [exitCode, entryPath, outputPath], cause));
+    }
+}
+export class InvalidPluginSpecifierError extends QvacErrorBase {
+    constructor(specifiers, cause) {
+        const list = specifiers.map((s) => `  - ${s}`).join('\n');
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.INVALID_PLUGIN_SPECIFIER, [list], cause));
+    }
+}
+export class BareImportsMapNotFoundError extends QvacErrorBase {
+    constructor(sdkName, expectedPath, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BARE_IMPORTS_MAP_NOT_FOUND, [sdkName, expectedPath], cause));
+    }
+}
+export class BareRuntimeBinaryNotFoundError extends QvacErrorBase {
+    constructor(platform, arch, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BARE_RUNTIME_BINARY_NOT_FOUND, [platform, arch], cause));
+    }
+}
+export class ConfigFileNotFoundError extends QvacErrorBase {
+    constructor(searchPaths, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_NOT_FOUND, [searchPaths], cause));
+    }
+}
+export class ConfigFileInvalidError extends QvacErrorBase {
+    constructor(filePath, reason, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_INVALID, [filePath, reason], cause));
+    }
+}
+export class ConfigFileParseFailedError extends QvacErrorBase {
+    constructor(filePath, error, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_PARSE_FAILED, [filePath, error], cause));
+    }
+}
+export class ConfigValidationFailedError extends QvacErrorBase {
+    constructor(errors, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_VALIDATION_FAILED, [errors], cause));
+    }
+}
+export class RequestValidationFailedError extends QvacErrorBase {
+    constructor(errors, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.REQUEST_VALIDATION_FAILED, [errors], cause));
+    }
+}
+// ============== Operation Errors (Client-side wrappers for server operations) ==============
+// These are used by client API to throw errors based on server responses
+// They reference server error codes but are thrown on client side
+export class ModelUnloadFailedError extends QvacErrorBase {
+    constructor(modelId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_UNLOAD_FAILED, modelId ? [modelId] : undefined, cause));
+    }
+}
+export class EmbedFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.EMBED_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class TranscriptionFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TRANSCRIPTION_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class TextToSpeechStreamFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_STREAM_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class CancelFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CANCEL_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGChunkFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_CHUNK_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGSaveFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_SAVE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGSearchFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_SEARCH_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGDeleteFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_DELETE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGCloseWorkspaceFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_WORKSPACE_CLOSE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class RAGListWorkspacesFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.RAG_LIST_WORKSPACES_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DownloadAssetFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DOWNLOAD_ASSET_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DownloadCancelledError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DOWNLOAD_CANCELLED, undefined, cause));
+    }
+}
+export class ChecksumValidationFailedError extends QvacErrorBase {
+    constructor(fileName, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CHECKSUM_VALIDATION_FAILED, [fileName], cause));
+    }
+}
+export class HTTPError extends QvacErrorBase {
+    constructor(status, statusText, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.HTTP_ERROR, [status, statusText], cause));
+    }
+}
+export class ModelLoadFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.MODEL_LOAD_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class DeleteCacheFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.DELETE_CACHE_FAILED, details ? [details] : undefined, cause));
+    }
+}
+export class InvalidDeleteCacheParamsError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.INVALID_DELETE_CACHE_PARAMS, undefined, cause));
+    }
+}
+export class SetConfigFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.SET_CONFIG_FAILED, details ? [details] : undefined, cause));
+    }
+}
+// ============== QVAC Model Registry Operation Errors ==============
+// Registry client errors (19,001-20,000) are re-thrown directly from @qvac/registry-client
+// Only SDK-specific errors are defined here
+export class ModelRegistryQueryFailedError extends QvacErrorBase {
+    constructor(details, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.QVAC_MODEL_REGISTRY_QUERY_FAILED, details ? [details] : undefined, cause));
+    }
+}
+// ============== Profiler Errors ==============
+export class ProfilerInvalidCapacityError extends QvacErrorBase {
+    constructor(minCapacity, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.PROFILER_INVALID_CAPACITY, [minCapacity], cause));
+    }
+}

package/dist/src/utils/errors-server.d.ts

@@ -0,0 +1,380 @@
+import { QvacErrorBase } from '@qvac/error';
+import type { CompletionStats, ToolCallWithCall } from '@qvac/inference/surface';
+/**
+ * Partial completion payload attached to `InferenceCancelledError` when a
+ * cancel hits mid-stream. Mirrors the named fields on `CompletionFinal`
+ * so callers who want the partial output can read `.partial.text`,
+ * `.partial.toolCalls`, `.partial.stats` directly without reaching for
+ * a `Partial<CompletionFinal>` import.
+ *
+ * Fields are all optional: a same-tick cancel-before-begin races every
+ * event; a cancel after the first content chunk carries `text` but no
+ * `stats`; a cancel after a tool-call frame carries both.
+ */
+export interface InferenceCancelledPartial {
+    text?: string;
+    toolCalls?: ToolCallWithCall[];
+    stats?: CompletionStats;
+}
+export declare class ModelAlreadyRegisteredError extends QvacErrorBase {
+    constructor(modelId: string, cause?: unknown);
+}
+export declare class ModelNotFoundError extends QvacErrorBase {
+    constructor(modelId: string, cause?: unknown);
+}
+export declare class ModelNotLoadedError extends QvacErrorBase {
+    constructor(modelId: string, cause?: unknown);
+}
+export declare class ModelLoadFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class ModelFileNotFoundError extends QvacErrorBase {
+    constructor(modelPath: string, cause?: unknown);
+}
+export declare class ModelFileNotFoundInDirError extends QvacErrorBase {
+    constructor(modelFile: string, modelDir: string, modelType: string, cause?: unknown);
+}
+export declare class ModelFileLocateFailedError extends QvacErrorBase {
+    constructor(modelType: string, modelPath: string, cause?: unknown);
+}
+export declare class ProjectionModelRequiredError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class VADModelRequiredError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class TtsArtifactsRequiredError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class TtsReferenceAudioRequiredError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class LegacyParakeetModelDeprecatedError extends QvacErrorBase {
+    constructor(legacyFields: readonly string[], cause?: unknown);
+}
+export declare class LegacyTtsModelDeprecatedError extends QvacErrorBase {
+    constructor(legacyFields: readonly 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 EmbedNoEmbeddingsError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class TranscriptionFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class AudioFileNotFoundError extends QvacErrorBase {
+    constructor(filePath: string, cause?: unknown);
+}
+export declare class TranslationFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class CompletionFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+/** The overflow sizes as one record; fields admit explicit `undefined` so a parser result assigns directly. */
+export type ContextOverflowErrorSizes = {
+    promptTokens?: number | undefined;
+    cachedTokens?: number | undefined;
+    requiredTokens?: number | undefined;
+    ctxSize?: number | undefined;
+};
+/**
+ * Thrown when a request no longer fits the model's effective context
+ * capacity — distinct from a generic `CompletionFailedError` so consumers
+ * can drive UX (truncate, summarize, or surface a "increase ctx_size /
+ * start a new thread" CTA) instead of treating it as an opaque failure.
+ *
+ * All size fields are optional: they carry whatever the addon guard
+ * reported (a cold prompt, a warm cached-plus-prompt split, or a bare
+ * overflow with no numbers). `modelId` is supplied by the server-side
+ * handler that wraps the addon error.
+ *
+ * Round-trips the RPC boundary via the typed-error reconstructor in
+ * `client/rpc/rpc-error.ts`, so `err instanceof ContextOverflowError`
+ * works on the consumer side.
+ */
+export declare class ContextOverflowError extends QvacErrorBase {
+    /** The prompt alone, in tokens; unset when the source reported KV cells. */
+    readonly promptTokens?: number;
+    /** Cached conversation on a warm-cache overflow, in `ctxSize` units. */
+    readonly cachedTokens?: number;
+    /** Total the failing guard reported, in `ctxSize` units; can equal the window (`>=` triggers). */
+    readonly requiredTokens?: number;
+    /** Effective per-request ceiling: `ctx_size` split across slots at `parallel > 1`. */
+    readonly ctxSize?: number;
+    readonly modelId?: string;
+    /** Canonical form: the parsed sizes as one record. */
+    constructor(contextSizes: ContextOverflowErrorSizes, modelId?: string, cause?: unknown);
+    /** @deprecated Kept for external consumers of the published package; in-repo callers use the record form. */
+    constructor(promptTokens?: number, ctxSize?: number, modelId?: string, cause?: unknown, extraSizes?: {
+        cachedTokens?: number | undefined;
+        requiredTokens?: number | undefined;
+    });
+    toErrorResponseFields(): Record<string, unknown>;
+}
+export declare class AttachmentNotFoundError extends QvacErrorBase {
+    constructor(path: string, cause?: unknown);
+}
+export declare class CancelFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class RequestIdConflictError extends QvacErrorBase {
+    readonly requestId: string;
+    constructor(requestId: string, cause?: unknown);
+    /**
+     * Surface typed fields on the RPC error envelope so the client-side
+     * reconstructor in `client/rpc/rpc-error.ts` can rebuild this exact
+     * class on the consumer side. Without this, `err instanceof
+     * RequestIdConflictError` would always be `false` after the error
+     * crosses the worker boundary.
+     */
+    toErrorResponseFields(): Record<string, unknown>;
+}
+export declare class RequestNotFoundError extends QvacErrorBase {
+    readonly requestId: string;
+    constructor(requestId: string, cause?: unknown);
+    toErrorResponseFields(): Record<string, unknown>;
+}
+/**
+ * Thrown by `await RequestRegistry.begin(...)` when a registered concurrency
+ * policy refuses the request. Under the default queue policy a same-model
+ * request waits FIFO rather than rejecting, so this fires on the bounded-queue
+ * cases: an explicit `onOverflow: "reject"`, the per-model queue-depth cap, or
+ * a `queueTimeoutMs` elapsing while waiting. Distinct from
+ * `RequestIdConflictError`, which only fires on UUID collisions.
+ */
+export declare class RequestRejectedByPolicyError extends QvacErrorBase {
+    readonly requestId: string;
+    readonly kind: string;
+    readonly modelId: string;
+    readonly reason: string;
+    constructor(requestId: string, kind: string, modelId: string, reason: string, cause?: unknown);
+    toErrorResponseFields(): Record<string, unknown>;
+}
+/**
+ * Thrown when a long-running inference request was cancelled before
+ * completion. The `events` stream on `CompletionRun` ends normally with
+ * `stopReason: "cancelled"` on the last `completionDone`, but the
+ * promise-aggregates on the same run (`final` / `text` / `toolCalls` /
+ * `stats`) reject with this error so callers can't accidentally treat a
+ * cancelled run as a successful one.
+ *
+ * Carries:
+ *  - `requestId` — correlates with `run.requestId` so callers know which
+ *    in-flight request was cancelled when they fan out multiple cancels.
+ *  - `partial` — whatever the aggregator accumulated up to the cancel
+ *    point. Optional fields so consumers can opt into "show partial":
+ *
+ *      try { await run.text } catch (err) {
+ *        if (err instanceof InferenceCancelledError) {
+ *          renderPartial(err.partial.text);
+ *        }
+ *      }
+ *
+ * The error is constructed client-side in
+ * `client/api/completion-stream.ts` when the wire stream ends with
+ * `stopReason: "cancelled"` — the partial payload comes from the
+ * client's own event aggregator. The class lives in `errors-server.ts`
+ * (and is re-exported from the package root) because the *semantic*
+ * origin of the cancel is server-side, and other handlers
+ * (embeddings, transcribe, …) will reuse the same class once their
+ * cancel surface lands.
+ */
+export declare class InferenceCancelledError extends QvacErrorBase {
+    readonly requestId: string;
+    readonly partial: InferenceCancelledPartial;
+    constructor(requestId: string, partial?: InferenceCancelledPartial, cause?: unknown);
+}
+export declare class AsyncDisposeUnavailableError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class TextToSpeechFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class TextToSpeechStreamFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class ConfigReloadNotSupportedError extends QvacErrorBase {
+    constructor(modelId: string, cause?: unknown);
+}
+export declare class ModelTypeMismatchError extends QvacErrorBase {
+    constructor(expectedType: string, providedType: string, cause?: unknown);
+}
+export declare class ModelOperationNotSupportedError extends QvacErrorBase {
+    readonly modelId: string;
+    readonly modelType: string;
+    readonly operation: string;
+    readonly supportedOperations: readonly string[];
+    readonly suggestedModelTypes: readonly string[];
+    constructor(modelId: string, modelType: string, operation: string, supportedOperations: readonly string[], suggestedModelTypes: readonly string[], cause?: unknown);
+}
+export declare class OCRFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class ImageFileNotFoundError extends QvacErrorBase {
+    constructor(filePath: string, cause?: unknown);
+}
+export declare class InvalidImageInputError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class InvalidAudioInputError 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 RAGUnknownOperationError extends QvacErrorBase {
+    constructor(operation: string, cause?: unknown);
+}
+export declare class RAGHyperDBFailedError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class FileNotFoundError extends QvacErrorBase {
+    constructor(path: 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 {
+    /** HTTP status code; `0` denotes a connection/network failure (no response). */
+    readonly httpStatus: number;
+    constructor(status: number, statusText: string, cause?: unknown);
+}
+export declare class NoResponseBodyError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class ResponseBodyNotReadableError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class NoBlobFoundError extends QvacErrorBase {
+    constructor(fileName: string, cause?: unknown);
+}
+export declare class DownloadAssetFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class SeedingNotSupportedError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class HyperdriveDownloadFailedError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class RegistryDownloadFailedError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class InvalidShardUrlPatternError extends QvacErrorBase {
+    constructor(url: string, cause?: unknown);
+}
+export declare class ArchiveExtractionFailedError extends QvacErrorBase {
+    constructor(archivePath: string, cause?: unknown);
+}
+export declare class ArchiveUnsupportedTypeError extends QvacErrorBase {
+    constructor(archivePath: string, cause?: unknown);
+}
+export declare class ArchiveMissingShardsError extends QvacErrorBase {
+    constructor(missingFile: string, cause?: unknown);
+}
+export declare class PartialDownloadOfflineError extends QvacErrorBase {
+    constructor(url: string, downloadedBytes: number, 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 CacheDirNotAbsoluteError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class CacheDirNotWritableError extends QvacErrorBase {
+    constructor(cacheDir: string, details?: string, cause?: unknown);
+}
+export declare class ConfigAlreadySetError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class FFmpegNotAvailableError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class AudioPlayerFailedError extends QvacErrorBase {
+    constructor(details: string, cause?: unknown);
+}
+export declare class InvalidAudioChunkError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class RAGWorkspaceModelMismatchError extends QvacErrorBase {
+    constructor(workspace: string, existingModelId: string, newModelId: string, cause?: unknown);
+}
+export declare class RAGWorkspaceNotFoundError extends QvacErrorBase {
+    constructor(workspace: string, cause?: unknown);
+}
+export declare class RAGWorkspaceInUseError extends QvacErrorBase {
+    constructor(workspace: string, cause?: unknown);
+}
+export declare class RAGWorkspaceNotOpenError extends QvacErrorBase {
+    constructor(workspace: string, cause?: unknown);
+}
+export declare class RPCNoDataReceivedError extends QvacErrorBase {
+    constructor(cause?: unknown);
+}
+export declare class RPCUnknownRequestTypeError extends QvacErrorBase {
+    constructor(requestType: string, cause?: unknown);
+}
+export declare class PluginNotFoundError extends QvacErrorBase {
+    constructor(modelType: string, cause?: unknown);
+}
+export declare class PluginHandlerNotFoundError extends QvacErrorBase {
+    constructor(modelType: string, handler: string, availableHandlers?: string[], cause?: unknown);
+}
+export declare class PluginRequestValidationFailedError extends QvacErrorBase {
+    constructor(handler: string, details?: string, cause?: unknown);
+}
+export declare class PluginResponseValidationFailedError extends QvacErrorBase {
+    constructor(handler: string, details?: string, cause?: unknown);
+}
+export declare class PluginAlreadyRegisteredError extends QvacErrorBase {
+    constructor(modelType: string, cause?: unknown);
+}
+export declare class PluginModelTypeReservedError extends QvacErrorBase {
+    constructor(modelType: string, cause?: unknown);
+}
+export declare class PluginLoadConfigValidationFailedError extends QvacErrorBase {
+    constructor(modelType: string, details: string, cause?: unknown);
+}
+export declare class PluginHandlerTypeMismatchError extends QvacErrorBase {
+    constructor(handlerName: string, expected: string, actual: string, cause?: unknown);
+}
+export declare class PluginLoggingInvalidError extends QvacErrorBase {
+    constructor(modelType: string, reason: string, cause?: unknown);
+}
+export declare class PluginDefinitionInvalidError extends QvacErrorBase {
+    constructor(modelType: string, details: string, cause?: unknown);
+}
+export declare class LifecycleSuspendFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class LifecycleResumeFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+export declare class LifecycleOperationBlockedError extends QvacErrorBase {
+    constructor(requestType: string, lifecycleState: string);
+}
+export declare class PathTraversalError extends QvacErrorBase {
+    constructor(component: string, basePath: string, cause?: unknown);
+}
+export declare class ModelRegistryQueryFailedError extends QvacErrorBase {
+    constructor(details?: string, cause?: unknown);
+}
+//# sourceMappingURL=errors-server.d.ts.map