@qvac/sdk 0.10.1 → 0.11.0

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,9 @@ export declare class WorkerFileNotFoundError extends QvacErrorBase {
 export declare class PearWorkerEntryRequiredError extends QvacErrorBase {
     constructor(workerEntry: string, cause?: unknown);
 }
+export declare class BundleVerificationFailedError extends QvacErrorBase {
+    constructor(bundlePath: string, cause?: unknown);
+}
 export declare class ConfigFileNotFoundError extends QvacErrorBase {
     constructor(searchPaths: string, cause?: unknown);
 }

package/dist/utils/errors-client.js

@@ -121,6 +121,11 @@ export class PearWorkerEntryRequiredError extends QvacErrorBase {
         super(createErrorOptions(SDK_CLIENT_ERROR_CODES.PEAR_WORKER_ENTRY_REQUIRED, [workerEntry], cause));
     }
 }
+export class BundleVerificationFailedError extends QvacErrorBase {
+    constructor(bundlePath, cause) {
+        super(createErrorOptions(SDK_CLIENT_ERROR_CODES.BUNDLE_VERIFICATION_FAILED, [bundlePath], 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);
 }
@@ -65,6 +82,74 @@ export declare class AttachmentNotFoundError extends QvacErrorBase {
 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

@@ -115,6 +115,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));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qvac/sdk",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -173,19 +173,19 @@
   },
   "dependencies": {
     "@qvac/decoder-audio": "^0.3.7",
-    "@qvac/diffusion-cpp": "^0.3.0",
-    "@qvac/embed-llamacpp": "^0.14.0",
+    "@qvac/diffusion-cpp": "^0.7.0",
+    "@qvac/embed-llamacpp": "^0.16.0",
     "@qvac/error": "^0.1.1",
     "@qvac/langdetect-text": "^0.1.2",
-    "@qvac/llm-llamacpp": "^0.17.1",
+    "@qvac/llm-llamacpp": "^0.20.0",
     "@qvac/logging": "^0.1.0",
-    "@qvac/ocr-onnx": "^0.4.2",
-    "@qvac/rag": "^0.4.4",
-    "@qvac/registry-client": "^0.4.1",
-    "@qvac/transcription-parakeet": "^0.3.1",
-    "@qvac/transcription-whispercpp": "^0.6.1",
-    "@qvac/translation-nmtcpp": "^2.0.1",
-    "@qvac/tts-onnx": "^0.8.4",
+    "@qvac/ocr-onnx": "^0.5.0",
+    "@qvac/rag": "^0.5.0",
+    "@qvac/registry-client": "^0.5.0",
+    "@qvac/transcription-parakeet": "^0.5.0",
+    "@qvac/transcription-whispercpp": "^0.7.0",
+    "@qvac/translation-nmtcpp": "^3.0.0",
+    "@qvac/tts-onnx": "^0.9.0",
     "fast-safe-stringify": "2.1.1",
     "which-runtime": "^1.3.2",
     "zod": "^4.3.0"
@@ -195,7 +195,7 @@
     "@expo/config-plugins": "^54.0.4",
     "@lancedb/lancedb": "^0.21.3",
     "@modelcontextprotocol/sdk": "^1.12.1",
-    "@qvac/cli": "^0.2.4",
+    "@qvac/cli": "^0.4.0",
     "@sqliteai/sqlite-wasm": "3.50.4-sync.0.8.30-vector.0.9.23",
     "@types/node": "^24.2.1",
     "@types/tar-stream": "^3.1.4",
@@ -226,7 +226,7 @@
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "@qvac/cli": "^0.2.4",
+    "@qvac/cli": "^0.4.0",
     "bare-abort-controller": "^1.0.0",
     "bare-buffer": "^3.4.2",
     "bare-crypto": "^1.13.4",
@@ -240,7 +240,7 @@
     "bare-os": "^3.6.2",
     "bare-path": "^3.0.0",
     "bare-process": "^4.2.2",
-    "bare-rpc": "^1.0.0",
+    "bare-rpc": "^1.3.2",
     "bare-runtime": "^1.24.2",
     "bare-stream": "^2.7.0",
     "bare-subprocess": "^5.2.3",
@@ -251,9 +251,11 @@
     "expo-build-properties": ">=0.12.0",
     "expo-device": "^8.0.0",
     "expo-file-system": "^19.0.15",
+    "hyperblobs": "^2.8.0",
     "hyperdb": "^4.19.0",
+    "hyperdht": "^6.23.0",
     "hyperdrive": "^13.0.1",
-    "hyperswarm": "^4.12.1",
+    "hyperswarm": "^4.14.0",
     "llm-splitter": "~0.2.0",
     "pear-pipe": "^1.0.6",
     "react-native-bare-kit": "0.12.3",
@@ -281,6 +283,9 @@
     "compact-encoding": {
       "optional": true
     },
+    "hyperdht": {
+      "optional": true
+    },
     "pear-pipe": {
       "optional": true
     }