@qvac/sdk 0.9.2 → 0.10.1

package/dist/client/api/completion-stream.js

@@ -1,18 +1,49 @@
 import { stream as streamRpc } from "../rpc/rpc-client.js";
 import { getClientLogger } from "../../logging/index.js";
 import { completionStreamResponseSchema, } from "../../schemas/index.js";
+import { CompletionFailedError } from "../../utils/errors-server.js";
 import { getMcpToolsWithHandlers } from "../../utils/mcp-adapter.js";
-import { attachHandlersToToolCalls, validateTools, } from "../../utils/tool-helpers.js";
+import { validateTools, } from "../../utils/tool-helpers.js";
+import { buildFinalFromEvents } from "../../utils/aggregate-events.js";
 const logger = getClientLogger();
 /**
  * Generates completion from a language model based on conversation history.
  *
+ * Returns a `CompletionRun` whose canonical surfaces are:
+ *
+ *  - `events`  — `AsyncIterable<CompletionEvent>` of ordered, typed events.
+ *  - `final`   — `Promise<CompletionFinal>` with aggregated results once the
+ *                stream ends (content, thinking, tool calls, stats, raw text).
+ *
+ * Legacy convenience fields (`tokenStream`, `text`, `toolCallStream`,
+ * `toolCalls`, `stats`) are still available but deprecated — they derive
+ * from `events` / `final` internally.
+ *
  * @param params - The completion parameters
  * @param params.modelId - The identifier of the model to use for completion
  * @param params.history - Array of conversation messages with role, content, and optional attachments
  * @param params.stream - Whether to stream tokens (true) or return complete response (false). Defaults to true
  * @param params.tools - Optional array of tools (can be simple ToolInput with Zod schemas or full Tool objects)
  * @param params.mcp - Optional array of MCP client inputs for tool integration
+ * @param params.captureThinking - Best-effort parsing of `<think>` blocks into `thinkingDelta` events; `final.raw.fullText` always preserves the original output
+ * @param params.emitRawDeltas - When true, every raw model token is also emitted as a `rawDelta` event
+ * @param params.toolDialect - Override the SDK's name-based dialect detection. Use when your model emits a known format (`"hermes"`, `"pythonic"`, or `"json"`) the auto-router doesn't recognise. Drives both streaming frame detection and finalization parsing.
+ * Common override case: Llama 3.x tool-calling fine-tunes that emit the native pythonic header (`<|start_header_id|>tool_call<|end_header_id|>...<|eot_id|>`).
+ * @param params.responseFormat - Optional structured-output constraint applied to the model's output:
+ *   - `{ type: "text" }` — no constraint (default behavior)
+ *   - `{ type: "json_object" }` — output must be a JSON object
+ *   - `{ type: "json_schema", json_schema: { name, schema, description?, strict? } }` — output must validate against `schema`
+ *
+ *   The schema is converted to GBNF natively by llama.cpp and applied for the
+ *   duration of the request only. `json_schema.name` and `json_schema.description`
+ *   are accepted for OpenAI compatibility but only used at the API boundary —
+ *   they do not affect generation. **`json_schema.strict` is currently accepted
+ *   for compatibility but does NOT trigger OpenAI's auto-tightening semantics**
+ *   (implicit `additionalProperties: false`, all properties required). The
+ *   schema is forwarded to the addon as-is, so callers who want strict
+ *   validation must encode it explicitly in `schema`.
+ *
+ *   Cannot be combined with `tools` (tools already constrain output via their parameter schema).
  * @param params.kvCache - Optional KV cache configuration. Cache files are organized hierarchically:
  *   - Structure: `{kvCacheKey}/{modelId}/{configHash}.bin`
  *   - The configHash includes model config + system prompt to ensure cache isolation
@@ -21,17 +52,29 @@ const logger = getClientLogger();
  *   - `false` or `undefined`: No caching
  *   - ⚡ Performance: When cache exists, only the last message is sent to the model (includes multimodal attachments)
  *   - 🗑️ Cleanup: Use `deleteCache({ kvCacheKey })` to remove cached sessions
- * @returns Object with tokenStream generator, toolCallStream generator, text promise, toolCalls promise (with call() method), and stats promise
+ *
+ *   **Auto-cache (`kvCache: true`) — assistant turn contract.** When
+ *   pushing the assistant turn back into `history` for the next call,
+ *   use `(await run.final).cacheableAssistantContent`. That's the exact
+ *   string the SDK persisted to the cache key on this turn, so re-using
+ *   it verbatim guarantees the next-turn lookup hits.
+ *   - Any post-processing of the assistant text (rewriting, summarizing,
+ *     stripping model stop tokens like `<|im_end|>`) before pushing it
+ *     back will miss the cache. Push the canonical string unchanged.
+ *   - `cacheableAssistantContent` is omitted on tool-call turns - those
+ *     can't be auto-cached today.
+ * @returns A CompletionRun — consume via `events` / `final`.
  * @example
  * ```typescript
  * import { z } from "zod";
  *
- * const result = completion({
+ * const run = completion({
  *   modelId: "llama-2",
  *   history: [
  *     { role: "user", content: "What's the weather in Tokyo?" }
  *   ],
  *   stream: true,
+ *   captureThinking: true,
  *   tools: [{
  *     name: "get_weather",
  *     description: "Get current weather",
@@ -44,10 +87,12 @@ const logger = getClientLogger();
  *   }]
  * });
  *
- * for await (const token of result.tokenStream) {
- *   process.stdout.write(token);
+ * for await (const event of run.events) {
+ *   if (event.type === "contentDelta") process.stdout.write(event.text);
+ *   if (event.type === "toolCall") console.log(event.call.name, event.call.arguments);
  * }
  *
+ * const result = await run.final;
  * for (const toolCall of await result.toolCalls) {
  *   if (toolCall.invoke) {
  *     const toolResult = await toolCall.invoke();
@@ -57,7 +102,6 @@ const logger = getClientLogger();
  * ```
  */
 export function completion(params) {
-    let stats;
     let statsResolver = () => { };
     let statsRejecter = () => { };
     const statsPromise = new Promise((resolve, reject) => {
@@ -65,7 +109,6 @@ export function completion(params) {
         statsRejecter = reject;
     });
     statsPromise.catch(() => { });
-    let toolCallsArray = [];
     let toolCallsResolver = () => { };
     let toolCallsRejecter = () => { };
     const toolCallsPromise = new Promise((resolve, reject) => {
@@ -73,14 +116,36 @@ export function completion(params) {
         toolCallsRejecter = reject;
     });
     toolCallsPromise.catch(() => { });
+    let finalResolver = () => { };
+    let finalRejecter = () => { };
+    const finalPromise = new Promise((resolve, reject) => {
+        finalResolver = resolve;
+        finalRejecter = reject;
+    });
+    finalPromise.catch(() => { });
     const tokenQueue = [];
     const toolEventQueue = [];
-    let tokenDone = false;
-    let toolDone = false;
+    const eventQueue = [];
+    let done = false;
     let tokenResolve = null;
     let toolResolve = null;
-    let textBuffer = "";
+    let eventResolve = null;
     let streamError = null;
+    const allEvents = [];
+    function notifyWaiters() {
+        if (tokenResolve) {
+            tokenResolve();
+            tokenResolve = null;
+        }
+        if (toolResolve) {
+            toolResolve();
+            toolResolve = null;
+        }
+        if (eventResolve) {
+            eventResolve();
+            eventResolve = null;
+        }
+    }
     const processResponses = async () => {
         try {
             let allTools = [];
@@ -113,6 +178,10 @@ export function completion(params) {
                 tools: allTools.length > 0 ? allTools : undefined,
                 stream: params.stream ?? true,
                 generationParams: params.generationParams,
+                captureThinking: params.captureThinking,
+                emitRawDeltas: params.emitRawDeltas,
+                toolDialect: params.toolDialect,
+                responseFormat: params.responseFormat,
             };
             const responses = streamRpc(request, params.rpcOptions);
             for await (const response of responses) {
@@ -121,43 +190,32 @@ export function completion(params) {
                     "type" in response &&
                     response.type === "completionStream") {
                     const streamResponse = completionStreamResponseSchema.parse(response);
-                    if (!streamResponse.done) {
-                        const token = streamResponse.token;
-                        if (token) {
-                            textBuffer += token;
-                            tokenQueue.push(token);
-                            if (tokenResolve) {
-                                tokenResolve();
-                                tokenResolve = null;
-                            }
+                    for (const event of streamResponse.events) {
+                        allEvents.push(event);
+                        eventQueue.push(event);
+                        if (event.type === "contentDelta") {
+                            tokenQueue.push(event.text);
                         }
-                        if (streamResponse.toolCallEvent) {
-                            toolEventQueue.push(streamResponse.toolCallEvent);
-                            if (toolResolve) {
-                                toolResolve();
-                                toolResolve = null;
-                            }
+                        else if (event.type === "toolCall") {
+                            toolEventQueue.push(event);
                         }
                     }
-                    else {
-                        if (streamResponse.token) {
-                            textBuffer += streamResponse.token;
-                        }
-                        stats = streamResponse.stats;
-                        statsResolver(stats);
-                        const rawToolCalls = streamResponse.toolCalls || [];
-                        toolCallsArray = attachHandlersToToolCalls(rawToolCalls, allHandlers);
-                        toolCallsResolver(toolCallsArray);
-                        tokenDone = true;
-                        toolDone = true;
-                        if (tokenResolve) {
-                            tokenResolve();
-                            tokenResolve = null;
+                    notifyWaiters();
+                    if (streamResponse.done) {
+                        const { final, error } = buildFinalFromEvents(allEvents, allHandlers);
+                        if (error) {
+                            const err = new CompletionFailedError(error.message, error);
+                            finalRejecter(err);
+                            statsRejecter(err);
+                            toolCallsRejecter(err);
                         }
-                        if (toolResolve) {
-                            toolResolve();
-                            toolResolve = null;
+                        else {
+                            finalResolver(final);
+                            statsResolver(final.stats);
+                            toolCallsResolver(final.toolCalls);
                         }
+                        done = true;
+                        notifyWaiters();
                     }
                 }
             }
@@ -166,31 +224,42 @@ export function completion(params) {
             streamError = error instanceof Error ? error : new Error(String(error));
             statsRejecter(error);
             toolCallsRejecter(error);
-            tokenDone = true;
-            toolDone = true;
-            if (tokenResolve) {
-                tokenResolve();
-                tokenResolve = null;
-            }
-            if (toolResolve) {
-                toolResolve();
-                toolResolve = null;
-            }
+            finalRejecter(error);
+            done = true;
+            notifyWaiters();
         }
     };
     void processResponses();
     const textPromise = (async () => {
-        await statsPromise;
-        return textBuffer;
+        const final = await finalPromise;
+        return final.contentText;
     })();
     textPromise.catch(() => { });
+    const eventStream = (async function* () {
+        while (true) {
+            if (eventQueue.length > 0) {
+                yield eventQueue.shift();
+            }
+            else if (done) {
+                if (streamError !== null) {
+                    throw streamError;
+                }
+                break;
+            }
+            else {
+                await new Promise((resolve) => {
+                    eventResolve = resolve;
+                });
+            }
+        }
+    })();
     if (params.stream) {
         const tokenStream = (async function* () {
             while (true) {
                 if (tokenQueue.length > 0) {
                     yield tokenQueue.shift();
                 }
-                else if (tokenDone) {
+                else if (done) {
                     if (streamError !== null) {
                         throw streamError;
                     }
@@ -208,7 +277,7 @@ export function completion(params) {
                 if (toolEventQueue.length > 0) {
                     yield toolEventQueue.shift();
                 }
-                else if (toolDone) {
+                else if (done) {
                     if (streamError !== null) {
                         throw streamError;
                     }
@@ -222,6 +291,8 @@ export function completion(params) {
             }
         })();
         return {
+            events: eventStream,
+            final: finalPromise,
             tokenStream,
             toolCallStream,
             text: textPromise,
@@ -237,6 +308,8 @@ export function completion(params) {
             //Empty generator for non-streaming mode
         })();
         return {
+            events: eventStream,
+            final: finalPromise,
             tokenStream,
             toolCallStream,
             text: textPromise,

package/dist/client/api/delete-cache.d.ts

@@ -6,6 +6,7 @@
  * @param params.kvCacheKey - The cache key to delete
  * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
  * @returns Promise resolving to success status
+ * @throws {QvacErrorBase} When the cache parameters are invalid (`InvalidDeleteCacheParamsError`) or the server reports a delete failure (`DeleteCacheFailedError`).
  * @example
  * ```typescript
  * // Delete all caches

package/dist/client/api/delete-cache.js

@@ -8,6 +8,7 @@ import { InvalidDeleteCacheParamsError, DeleteCacheFailedError, } from "../../ut
  * @param params.kvCacheKey - The cache key to delete
  * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
  * @returns Promise resolving to success status
+ * @throws {QvacErrorBase} When the cache parameters are invalid (`InvalidDeleteCacheParamsError`) or the server reports a delete failure (`DeleteCacheFailedError`).
  * @example
  * ```typescript
  * // Delete all caches

package/dist/client/api/diffusion.d.ts

@@ -10,15 +10,30 @@ interface DiffusionResult {
     stats: Promise<DiffusionStats | undefined>;
 }
 /**
- * Generate images using a loaded diffusion model.
+ * Generates images using a loaded diffusion model.
+ *
+ * @param params - Diffusion request parameters (model, prompt, dimensions, sampler, seed, etc.).
+ * @returns A result object exposing `progressStream` (async iterator of `{ step, totalSteps, elapsedMs }`), `outputs` (promise of the generated image buffers), and `stats` (promise of generation statistics).
+ *
+ * Supports both txt2img (no `init_image`) and img2img (with `init_image`).
  *
  * @example
  * ```typescript
- * // Basic usage
+ * // txt2img
  * const { outputs, stats } = diffusion({ modelId, prompt: "a cat" });
  * const buffers = await outputs;
  * fs.writeFileSync("output.png", buffers[0]);
  *
+ * // img2img (SD/SDXL — SDEdit)
+ * const initImage = fs.readFileSync("input.png");
+ * const { outputs } = diffusion({ modelId, prompt: "oil painting style", init_image: initImage, strength: 0.7 });
+ *
+ * // img2img (FLUX.2 — in-context conditioning)
+ * // IMPORTANT: FLUX img2img requires `prediction: "flux2_flow"` to be set on the
+ * // model config at loadModel time (e.g. `loadModel(src, { modelType: "diffusion",
+ * // modelConfig: { prediction: "flux2_flow" } })`).
+ * const { outputs } = diffusion({ modelId, prompt: "turn into watercolor", init_image: initImage });
+ *
  * // With progress tracking
  * const { progressStream, outputs } = diffusion({ modelId, prompt: "a cat" });
  * for await (const { step, totalSteps } of progressStream) {

package/dist/client/api/diffusion.js

@@ -1,16 +1,31 @@
 import { diffusionStreamResponseSchema, } from "../../schemas/index.js";
 import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { decodeBase64 } from "../../utils/encoding.js";
+import { decodeBase64, encodeBase64 } from "../../utils/encoding.js";
 /**
- * Generate images using a loaded diffusion model.
+ * Generates images using a loaded diffusion model.
+ *
+ * @param params - Diffusion request parameters (model, prompt, dimensions, sampler, seed, etc.).
+ * @returns A result object exposing `progressStream` (async iterator of `{ step, totalSteps, elapsedMs }`), `outputs` (promise of the generated image buffers), and `stats` (promise of generation statistics).
+ *
+ * Supports both txt2img (no `init_image`) and img2img (with `init_image`).
  *
  * @example
  * ```typescript
- * // Basic usage
+ * // txt2img
  * const { outputs, stats } = diffusion({ modelId, prompt: "a cat" });
  * const buffers = await outputs;
  * fs.writeFileSync("output.png", buffers[0]);
  *
+ * // img2img (SD/SDXL — SDEdit)
+ * const initImage = fs.readFileSync("input.png");
+ * const { outputs } = diffusion({ modelId, prompt: "oil painting style", init_image: initImage, strength: 0.7 });
+ *
+ * // img2img (FLUX.2 — in-context conditioning)
+ * // IMPORTANT: FLUX img2img requires `prediction: "flux2_flow"` to be set on the
+ * // model config at loadModel time (e.g. `loadModel(src, { modelType: "diffusion",
+ * // modelConfig: { prediction: "flux2_flow" } })`).
+ * const { outputs } = diffusion({ modelId, prompt: "turn into watercolor", init_image: initImage });
+ *
  * // With progress tracking
  * const { progressStream, outputs } = diffusion({ modelId, prompt: "a cat" });
  * for await (const { step, totalSteps } of progressStream) {
@@ -20,9 +35,11 @@ import { decodeBase64 } from "../../utils/encoding.js";
  * ```
  */
 export function diffusion(params) {
+    const { init_image, ...rest } = params;
     const request = {
+        ...rest,
+        ...(init_image !== undefined && { init_image: encodeBase64(init_image) }),
         type: "diffusionStream",
-        ...params,
     };
     let statsResolver = () => { };
     let statsRejecter = () => { };

package/dist/client/api/embed.d.ts

@@ -2,10 +2,12 @@ import { type EmbedStats, type RPCOptions } from "../../schemas/index";
 /**
  * Generates embeddings for a single text using a specified model.
  *
+ * @overloadLabel "Single text"
  * @param params - The parameters for the embedding
  * @param params.modelId - The identifier of the embedding model to use
  * @param params.text - The input text to embed
  * @param options - Optional RPC options including per-call profiling
+ * @returns A promise resolving to an object with `embedding` (a single `number[]` vector) and optional `stats` performance data.
  * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
  */
 export declare function embed(params: {
@@ -18,10 +20,12 @@ export declare function embed(params: {
 /**
  * Generates embeddings for multiple texts using a specified model.
  *
+ * @overloadLabel "Multiple texts"
  * @param params - The parameters for the embedding
  * @param params.modelId - The identifier of the embedding model to use
  * @param params.text - The input texts to embed
  * @param options - Optional RPC options including per-call profiling
+ * @returns A promise resolving to an object with `embedding` (one `number[]` vector per input text, i.e. `number[][]`) and optional `stats` performance data.
  * @throws {QvacErrorBase} When the response type is invalid or when the embedding fails
  */
 export declare function embed(params: {

package/dist/client/api/finetune.d.ts

@@ -63,7 +63,28 @@ type FinetuneReplyParams = FinetuneStopParams | FinetuneGetStateParams;
  * console.log(pauseResult.status);
  * ```
  */
+/**
+ * Run / start / resume a finetune job. Returns a handle with a streaming
+ * `progressStream` and a terminal `result` promise.
+ *
+ * @overloadLabel "Run / start / resume"
+ * @param params - The finetuning run parameters (see the function-level
+ *   docs for the full breakdown of `params.options`).
+ * @param rpcOptions - Optional RPC transport options.
+ * @returns A `FinetuneHandle` with `progressStream` (yields per-step loss
+ *   metrics) and `result` (resolves once the run terminates).
+ */
 export declare function finetune(params: FinetuneRunParams, rpcOptions?: RPCOptions): FinetuneHandle;
+/**
+ * Stop / pause / cancel an in-flight finetune, or query its current state.
+ *
+ * @overloadLabel "Stop / getState / pause / cancel"
+ * @param params - Finetune control parameters; `params.operation` selects
+ *   `pause`, `cancel`, or `getState`.
+ * @param rpcOptions - Optional RPC transport options.
+ * @returns A promise that resolves to the current `FinetuneResult`
+ *   (status + last-known progress).
+ */
 export declare function finetune(params: FinetuneReplyParams, rpcOptions?: RPCOptions): Promise<FinetuneResult>;
 export {};
 //# sourceMappingURL=finetune.d.ts.map

package/dist/client/api/get-loaded-model-info.d.ts

@@ -0,0 +1,25 @@
+import { type GetLoadedModelInfoParams, type LoadedModelInfo } from "../../schemas/index";
+import { type RPCOptions } from "../../schemas/common";
+/**
+ * Returns introspection info for a loaded `modelId` (local or delegated).
+ *
+ * For local models, `info.modelType` and `info.handlers` are authoritative.
+ * Use them to preflight an SDK call before sending the actual RPC, e.g.
+ * confirm that a model supports `transcribeStream` before calling `transcribe()`.
+ *
+ * For delegated models, only `modelId`, `isDelegated: true`, `providerInfo`,
+ * and `handlers: []` are populated. Preflight against a delegated model is
+ * best-effort and falls through to the provider's error response.
+ *
+ * Throws `ModelNotFoundError` if no entry exists for `modelId`.
+ *
+ * @example
+ * ```typescript
+ * const info = await getLoadedModelInfo({ modelId });
+ * if (info.isDelegated || info.handlers.includes("completionStream")) {
+ *   // safe to call completion(); delegated path defers to provider
+ * }
+ * ```
+ */
+export declare function getLoadedModelInfo(params: GetLoadedModelInfoParams, rpcOptions?: RPCOptions): Promise<LoadedModelInfo>;
+//# sourceMappingURL=get-loaded-model-info.d.ts.map

package/dist/client/api/get-loaded-model-info.js

@@ -0,0 +1,36 @@
+import {} from "../../schemas/index.js";
+import {} from "../../schemas/common.js";
+import { send } from "../rpc/rpc-client.js";
+import { InvalidResponseError } from "../../utils/errors-client.js";
+/**
+ * Returns introspection info for a loaded `modelId` (local or delegated).
+ *
+ * For local models, `info.modelType` and `info.handlers` are authoritative.
+ * Use them to preflight an SDK call before sending the actual RPC, e.g.
+ * confirm that a model supports `transcribeStream` before calling `transcribe()`.
+ *
+ * For delegated models, only `modelId`, `isDelegated: true`, `providerInfo`,
+ * and `handlers: []` are populated. Preflight against a delegated model is
+ * best-effort and falls through to the provider's error response.
+ *
+ * Throws `ModelNotFoundError` if no entry exists for `modelId`.
+ *
+ * @example
+ * ```typescript
+ * const info = await getLoadedModelInfo({ modelId });
+ * if (info.isDelegated || info.handlers.includes("completionStream")) {
+ *   // safe to call completion(); delegated path defers to provider
+ * }
+ * ```
+ */
+export async function getLoadedModelInfo(params, rpcOptions) {
+    const request = {
+        type: "getLoadedModelInfo",
+        modelId: params.modelId,
+    };
+    const response = await send(request, rpcOptions);
+    if (response.type !== "getLoadedModelInfo") {
+        throw new InvalidResponseError("getLoadedModelInfo");
+    }
+    return response.info;
+}

package/dist/client/api/get-model-info.d.ts

@@ -1,10 +1,18 @@
 import { type GetModelInfoParams } from "../../schemas/index";
+/**
+ * Returns status information for a catalog model, including cache state and loaded instances.
+ *
+ * @param params - Query parameters.
+ * @param params.name - The model's registry name (as found in the SDK's built-in catalog) to look up.
+ * @returns A promise resolving to the model's status information (cache presence, loaded instances, size on disk, etc.).
+ * @throws {QvacErrorBase} When the response type is invalid (`InvalidResponseError`) or the RPC layer fails.
+ */
 export declare function getModelInfo(params: GetModelInfoParams): Promise<{
     name: string;
     modelId: string;
     expectedSize: number;
     sha256Checksum: string;
-    addon: "llm" | "whisper" | "embeddings" | "nmt" | "parakeet" | "tts" | "ocr" | "diffusion" | "vad" | "other";
+    addon: "embeddings" | "llm" | "whisper" | "nmt" | "parakeet" | "tts" | "ocr" | "diffusion" | "vad" | "other";
     isCached: boolean;
     isLoaded: boolean;
     cacheFiles: {

package/dist/client/api/get-model-info.js

@@ -1,6 +1,14 @@
 import {} from "../../schemas/index.js";
 import { send } from "../rpc/rpc-client.js";
 import { InvalidResponseError } from "../../utils/errors-client.js";
+/**
+ * Returns status information for a catalog model, including cache state and loaded instances.
+ *
+ * @param params - Query parameters.
+ * @param params.name - The model's registry name (as found in the SDK's built-in catalog) to look up.
+ * @returns A promise resolving to the model's status information (cache presence, loaded instances, size on disk, etc.).
+ * @throws {QvacErrorBase} When the response type is invalid (`InvalidResponseError`) or the RPC layer fails.
+ */
 export async function getModelInfo(params) {
     const request = {
         type: "getModelInfo",

package/dist/client/api/heartbeat.d.ts

@@ -5,7 +5,7 @@ import type { DelegateBase } from "../../schemas/delegate";
  * Can also be used to check if the local SDK worker is responsive.
  *
  * @param params - Delegation target to check
- * @param params.delegate - The provider to check (topic + publicKey + optional timeout)
+ * @param params.delegate - The provider to check (providerPublicKey + optional timeout)
  * @returns A promise that resolves to a heartbeat response if the provider is reachable.
  * @throws {QvacErrorBase} When the provider is unreachable or the response is invalid.
  *
@@ -13,7 +13,7 @@ import type { DelegateBase } from "../../schemas/delegate";
  * // Check if a delegated provider is online
  * try {
  *   await heartbeat({
- *     delegate: { topic: "topicHex", providerPublicKey: "peerHex", timeout: 3000 },
+ *     delegate: { providerPublicKey: "peerHex", timeout: 3000 },
  *   });
  *   console.log("Provider is online");
  * } catch {

package/dist/client/api/heartbeat.js

@@ -6,7 +6,7 @@ import { InvalidResponseError } from "../../utils/errors-client.js";
  * Can also be used to check if the local SDK worker is responsive.
  *
  * @param params - Delegation target to check
- * @param params.delegate - The provider to check (topic + publicKey + optional timeout)
+ * @param params.delegate - The provider to check (providerPublicKey + optional timeout)
  * @returns A promise that resolves to a heartbeat response if the provider is reachable.
  * @throws {QvacErrorBase} When the provider is unreachable or the response is invalid.
  *
@@ -14,7 +14,7 @@ import { InvalidResponseError } from "../../utils/errors-client.js";
  * // Check if a delegated provider is online
  * try {
  *   await heartbeat({
- *     delegate: { topic: "topicHex", providerPublicKey: "peerHex", timeout: 3000 },
+ *     delegate: { providerPublicKey: "peerHex", timeout: 3000 },
  *   });
  *   console.log("Provider is online");
  * } catch {

package/dist/client/api/index.d.ts

@@ -13,12 +13,14 @@ export { cancel } from "./cancel";
 export { startQVACProvider } from "./provide";
 export { stopQVACProvider } from "./stop-provider";
 export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, } from "./rag";
-export { textToSpeech } from "./text-to-speech";
+export { textToSpeech, textToSpeechStream } from "./text-to-speech";
 export { getModelInfo } from "./get-model-info";
+export { getLoadedModelInfo } from "./get-loaded-model-info";
 export { ocr } from "./ocr";
 export { invokePlugin, invokePluginStream } from "./invoke-plugin";
 export { diffusion, type DiffusionProgressTick } from "./diffusion";
 export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, type ModelRegistrySearchParams, } from "./registry";
 export { suspend } from "./suspend";
 export { resume } from "./resume";
+export { state } from "./state";
 //# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -13,11 +13,13 @@ export { cancel } from "./cancel.js";
 export { startQVACProvider } from "./provide.js";
 export { stopQVACProvider } from "./stop-provider.js";
 export { ragChunk, ragIngest, ragSaveEmbeddings, ragSearch, ragDeleteEmbeddings, ragReindex, ragListWorkspaces, ragCloseWorkspace, ragDeleteWorkspace, } from "./rag.js";
-export { textToSpeech } from "./text-to-speech.js";
+export { textToSpeech, textToSpeechStream } from "./text-to-speech.js";
 export { getModelInfo } from "./get-model-info.js";
+export { getLoadedModelInfo } from "./get-loaded-model-info.js";
 export { ocr } from "./ocr.js";
 export { invokePlugin, invokePluginStream } from "./invoke-plugin.js";
 export { diffusion } from "./diffusion.js";
 export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, } from "./registry.js";
 export { suspend } from "./suspend.js";
 export { resume } from "./resume.js";
+export { state } from "./state.js";