@qvac/sdk 0.10.2 → 0.12.0

package/dist/server/worker.js

@@ -2,21 +2,24 @@
  * Default worker entry point that registers ALL built-in plugins.
  */
 import { initializeWorkerCore, ensureRPCSetup } from "./worker-core.js";
-import { registerPlugin } from "./plugins/index.js";
+import { registerPlugins } from "./plugins/index.js";
 import { getServerLogger } from "../logging/index.js";
-import { llmPlugin, embeddingsPlugin, whisperPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, } from "./bare/plugins/index.js";
+import { llmPlugin, embeddingsPlugin, whisperPlugin, parakeetPlugin, nmtPlugin, ttsPlugin, ocrPlugin, diffusionPlugin, vlaPlugin, classificationPlugin, } from "./bare/plugins/index.js";
 const { hasRPCConfig } = initializeWorkerCore();
 const logger = getServerLogger();
 logger.info("🐻 Hello from Bare");
-// Register all built-in plugins
-registerPlugin(llmPlugin);
-registerPlugin(embeddingsPlugin);
-registerPlugin(whisperPlugin);
-registerPlugin(parakeetPlugin);
-registerPlugin(nmtPlugin);
-registerPlugin(ttsPlugin);
-registerPlugin(ocrPlugin);
-registerPlugin(diffusionPlugin);
+registerPlugins([
+    llmPlugin,
+    embeddingsPlugin,
+    whisperPlugin,
+    parakeetPlugin,
+    nmtPlugin,
+    ttsPlugin,
+    ocrPlugin,
+    diffusionPlugin,
+    vlaPlugin,
+    classificationPlugin,
+]);
 logger.info(hasRPCConfig
     ? "Parsed RPC configuration from arguments"
     : "Using default configuration (direct mode)");

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

@@ -7,10 +7,19 @@ export type AggregatedEvents = {
     toolCalls: ToolCall[];
     rawFullText: string | undefined;
     error: CompletionError | 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

@@ -6,6 +6,7 @@ export function aggregateEvents(events) {
     let stats;
     let rawFullText;
     let error;
+    let cancelled = false;
     const toolCalls = [];
     for (const event of events) {
         if (event.type === "contentDelta") {
@@ -24,15 +25,29 @@ export function aggregateEvents(events) {
             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 === "cancelled") {
+                cancelled = true;
+            }
         }
     }
-    return { contentText, thinkingText, stats, toolCalls, rawFullText, error };
+    return {
+        contentText,
+        thinkingText,
+        stats,
+        toolCalls,
+        rawFullText,
+        error,
+        cancelled,
+    };
 }
 export function buildFinalFromEvents(events, handlers) {
-    const { contentText, thinkingText, stats, toolCalls, rawFullText, error } = aggregateEvents(events);
+    const { contentText, thinkingText, stats, toolCalls, rawFullText, error, cancelled, } = aggregateEvents(events);
     const attachedToolCalls = attachHandlersToToolCalls(toolCalls, handlers);
     const fullText = rawFullText ?? contentText;
     const cacheableAssistantContent = attachedToolCalls.length === 0
@@ -48,5 +63,5 @@ export function buildFinalFromEvents(events, handlers) {
             cacheableAssistantContent,
         }),
     };
-    return { final, error };
+    return { final, error, cancelled };
 }

package/dist/utils/decorate-promise.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Attach metadata to a Promise so the metadata is reachable
+ * synchronously while the promise's normal async surface keeps working.
+ *
+ * The decorated-promise pattern lets a long-running client-API call
+ * (`loadModel(...)`, `downloadAsset(...)`) return a value that is both:
+ *   - a `Promise<T>` you can `await` for the resolved result; and
+ *   - a record carrying call metadata (`requestId`) you can read
+ *     synchronously to target the in-flight call with
+ *     `cancel({ requestId })` before it resolves.
+ *
+ * Implementation notes:
+ *   - `Object.assign` attaches enumerable own properties without
+ *     touching the prototype chain, so `await`, `.then`, `.catch`,
+ *     `.finally`, and async-await unwrapping continue to work exactly
+ *     as for a plain `Promise<T>`.
+ *   - The intersection type `Promise<T> & M` is sound because the
+ *     resolved-value type `T` does not intersect with `M`'s key set in
+ *     practice (callers pick metadata keys that don't collide with
+ *     `Promise` members like `then`/`catch`/`finally`). Picking such a
+ *     key would shadow the Promise method and break the unwrap chain;
+ *     don't.
+ *   - We deliberately avoid extending `Promise.prototype` or calling
+ *     `Object.setPrototypeOf`. Either would silently affect every
+ *     promise in the worker; the plain-object approach is intentional
+ *     and the helper exists to keep call sites consistent.
+ *
+ * @example
+ *   const op = decoratePromise(innerPromise, { requestId: "abc" });
+ *   op.requestId; // "abc" (synchronous)
+ *   await op;     // resolves to T (legacy contract preserved)
+ */
+export declare function decoratePromise<T, M extends Record<string, unknown>>(promise: Promise<T>, metadata: M): Promise<T> & M;
+//# sourceMappingURL=decorate-promise.d.ts.map

package/dist/utils/decorate-promise.js

@@ -0,0 +1,35 @@
+/**
+ * Attach metadata to a Promise so the metadata is reachable
+ * synchronously while the promise's normal async surface keeps working.
+ *
+ * The decorated-promise pattern lets a long-running client-API call
+ * (`loadModel(...)`, `downloadAsset(...)`) return a value that is both:
+ *   - a `Promise<T>` you can `await` for the resolved result; and
+ *   - a record carrying call metadata (`requestId`) you can read
+ *     synchronously to target the in-flight call with
+ *     `cancel({ requestId })` before it resolves.
+ *
+ * Implementation notes:
+ *   - `Object.assign` attaches enumerable own properties without
+ *     touching the prototype chain, so `await`, `.then`, `.catch`,
+ *     `.finally`, and async-await unwrapping continue to work exactly
+ *     as for a plain `Promise<T>`.
+ *   - The intersection type `Promise<T> & M` is sound because the
+ *     resolved-value type `T` does not intersect with `M`'s key set in
+ *     practice (callers pick metadata keys that don't collide with
+ *     `Promise` members like `then`/`catch`/`finally`). Picking such a
+ *     key would shadow the Promise method and break the unwrap chain;
+ *     don't.
+ *   - We deliberately avoid extending `Promise.prototype` or calling
+ *     `Object.setPrototypeOf`. Either would silently affect every
+ *     promise in the worker; the plain-object approach is intentional
+ *     and the helper exists to keep call sites consistent.
+ *
+ * @example
+ *   const op = decoratePromise(innerPromise, { requestId: "abc" });
+ *   op.requestId; // "abc" (synchronous)
+ *   await op;     // resolves to T (legacy contract preserved)
+ */
+export function decoratePromise(promise, metadata) {
+    return Object.assign(promise, metadata);
+}

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

@@ -68,6 +68,24 @@ export declare class WorkerFileNotFoundError extends QvacErrorBase {
 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 ConfigFileNotFoundError extends QvacErrorBase {
     constructor(searchPaths: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -121,6 +121,37 @@ export class PearWorkerEntryRequiredError extends QvacErrorBase {
         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 ConfigFileNotFoundError extends QvacErrorBase {
     constructor(searchPaths, cause) {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.CONFIG_FILE_NOT_FOUND, [searchPaths], cause));

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

@@ -1,4 +1,21 @@
 import { QvacErrorBase } from "@qvac/error";
+import type { CompletionStats, ToolCallWithCall } from "../schemas/index";
+/**
+ * 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);
 }
@@ -35,8 +52,11 @@ export declare class TtsArtifactsRequiredError extends QvacErrorBase {
 export declare class TtsReferenceAudioRequiredError extends QvacErrorBase {
     constructor(cause?: unknown);
 }
-export declare class ParakeetArtifactsRequiredError extends QvacErrorBase {
-    constructor(details?: string, 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);
@@ -59,12 +79,105 @@ export declare class TranslationFailedError extends QvacErrorBase {
 export declare class CompletionFailedError extends QvacErrorBase {
     constructor(details?: string, cause?: unknown);
 }
+/**
+ * Thrown when the prompt exceeds the loaded model's configured context
+ * window — 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.
+ *
+ * Carries the addon-reported prompt size and the model's context window
+ * when the addon's error message includes them (the C++ overflow paths
+ * in `TextLlmContext.cpp` and `MtmdLlmContext.cpp` format both numbers
+ * into the message; the bare `processPromptImpl: context overflow`
+ * fallback in `LlamaModel.cpp` carries neither — both fields are
+ * therefore optional). `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 {
+    readonly promptTokens?: number;
+    readonly ctxSize?: number;
+    readonly modelId?: string;
+    constructor(promptTokens?: number, ctxSize?: number, modelId?: string, cause?: unknown);
+    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 `RequestRegistry.begin(...)` when a registered concurrency
+ * policy rejects the request (e.g. `oneAtATimePerModel` for the
+ * `completion` kind). 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);
 }

package/dist/utils/errors-server.js

@@ -63,9 +63,14 @@ export class TtsReferenceAudioRequiredError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TTS_REFERENCE_AUDIO_REQUIRED, undefined, cause));
     }
 }
-export class ParakeetArtifactsRequiredError extends QvacErrorBase {
-    constructor(details, cause) {
-        super(createErrorOptions(SDK_SERVER_ERROR_CODES.PARAKEET_ARTIFACTS_REQUIRED, details ? [details] : undefined, cause));
+export class LegacyParakeetModelDeprecatedError extends QvacErrorBase {
+    constructor(legacyFields, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LEGACY_PARAKEET_MODEL_DEPRECATED, [legacyFields.join(", ")], cause));
+    }
+}
+export class LegacyTtsModelDeprecatedError extends QvacErrorBase {
+    constructor(legacyFields, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.LEGACY_TTS_MODEL_DEPRECATED, [legacyFields.join(", ")], cause));
     }
 }
 // ============== Model Unloading Errors ==============
@@ -105,6 +110,49 @@ export class CompletionFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.COMPLETION_FAILED, details ? [details] : undefined, cause));
     }
 }
+/**
+ * Thrown when the prompt exceeds the loaded model's configured context
+ * window — 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.
+ *
+ * Carries the addon-reported prompt size and the model's context window
+ * when the addon's error message includes them (the C++ overflow paths
+ * in `TextLlmContext.cpp` and `MtmdLlmContext.cpp` format both numbers
+ * into the message; the bare `processPromptImpl: context overflow`
+ * fallback in `LlamaModel.cpp` carries neither — both fields are
+ * therefore optional). `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 class ContextOverflowError extends QvacErrorBase {
+    promptTokens;
+    ctxSize;
+    modelId;
+    constructor(promptTokens, ctxSize, modelId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.CONTEXT_OVERFLOW, [
+            promptTokens !== undefined ? String(promptTokens) : "",
+            ctxSize !== undefined ? String(ctxSize) : "",
+            modelId ?? "",
+        ], cause));
+        if (promptTokens !== undefined)
+            this.promptTokens = promptTokens;
+        if (ctxSize !== undefined)
+            this.ctxSize = ctxSize;
+        if (modelId !== undefined)
+            this.modelId = modelId;
+    }
+    toErrorResponseFields() {
+        return {
+            ...(this.promptTokens !== undefined && { promptTokens: this.promptTokens }),
+            ...(this.ctxSize !== undefined && { ctxSize: this.ctxSize }),
+            ...(this.modelId !== undefined && { modelId: this.modelId }),
+        };
+    }
+}
 export class AttachmentNotFoundError extends QvacErrorBase {
     constructor(path, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.ATTACHMENT_NOT_FOUND, [path], cause));
@@ -115,6 +163,103 @@ export class CancelFailedError extends QvacErrorBase {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.CANCEL_FAILED, details ? [details] : undefined, cause));
     }
 }
+export class RequestIdConflictError extends QvacErrorBase {
+    requestId;
+    constructor(requestId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.REQUEST_ID_CONFLICT, [requestId], cause));
+        this.requestId = requestId;
+    }
+    /**
+     * 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() {
+        return { requestId: this.requestId };
+    }
+}
+export class RequestNotFoundError extends QvacErrorBase {
+    requestId;
+    constructor(requestId, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.REQUEST_NOT_FOUND, [requestId], cause));
+        this.requestId = requestId;
+    }
+    toErrorResponseFields() {
+        return { requestId: this.requestId };
+    }
+}
+/**
+ * Thrown by `RequestRegistry.begin(...)` when a registered concurrency
+ * policy rejects the request (e.g. `oneAtATimePerModel` for the
+ * `completion` kind). Distinct from `RequestIdConflictError`, which
+ * only fires on UUID collisions.
+ */
+export class RequestRejectedByPolicyError extends QvacErrorBase {
+    requestId;
+    kind;
+    modelId;
+    reason;
+    constructor(requestId, kind, modelId, reason, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.REQUEST_REJECTED_BY_POLICY, [requestId, kind, modelId, reason], cause));
+        this.requestId = requestId;
+        this.kind = kind;
+        this.modelId = modelId;
+        this.reason = reason;
+    }
+    toErrorResponseFields() {
+        return {
+            requestId: this.requestId,
+            kind: this.kind,
+            modelId: this.modelId,
+            reason: this.reason,
+        };
+    }
+}
+/**
+ * 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 class InferenceCancelledError extends QvacErrorBase {
+    requestId;
+    partial;
+    constructor(requestId, partial = {}, cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.INFERENCE_CANCELLED, [requestId], cause));
+        this.requestId = requestId;
+        this.partial = partial;
+    }
+}
+export class AsyncDisposeUnavailableError extends QvacErrorBase {
+    constructor(cause) {
+        super(createErrorOptions(SDK_SERVER_ERROR_CODES.ASYNC_DISPOSE_UNAVAILABLE, [], cause));
+    }
+}
 export class TextToSpeechFailedError extends QvacErrorBase {
     constructor(details, cause) {
         super(createErrorOptions(SDK_SERVER_ERROR_CODES.TEXT_TO_SPEECH_FAILED, details ? [details] : undefined, cause));