@qvac/sdk 0.14.0 → 0.15.0

package/dist/client/api/bci-transcribe.js

@@ -1,23 +1,23 @@
-import { bciTranscribeResponseSchema, bciTranscribeClientParamsSchema, bciTranscribeStreamResponseSchema, } from "../../schemas/index.js";
-import { stream, duplex } from "../rpc/rpc-client.js";
-import { getClientLogger } from "../../logging/index.js";
-import { TranscriptionFailedError } from "../../utils/errors-client.js";
-import { decoratePromise } from "../../utils/decorate-promise.js";
-import { parseClientInput } from "../parse-input.js";
-import { generateClientRequestId } from "./client-request-id.js";
+import { bciTranscribeResponseSchema, bciTranscribeClientParamsSchema, bciTranscribeStreamResponseSchema } from '../../schemas/index.js';
+import { stream, duplex } from '../rpc/rpc-client.js';
+import { getClientLogger } from '../../logging/index.js';
+import { TranscriptionFailedError } from '../../utils/errors-client.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { parseClientInput } from '../parse-input.js';
+import { generateClientRequestId } from './client-request-id.js';
 const logger = getClientLogger();
 function buildBciTranscribeRequest(params, requestId) {
     return {
-        type: "bciTranscribe",
+        type: 'bciTranscribe',
         modelId: params.modelId,
-        neuralData: typeof params.neuralData === "string"
-            ? { type: "filePath", value: params.neuralData }
+        neuralData: typeof params.neuralData === 'string'
+            ? { type: 'filePath', value: params.neuralData }
             : {
-                type: "base64",
-                value: Buffer.from(params.neuralData).toString("base64"),
+                type: 'base64',
+                value: Buffer.from(params.neuralData).toString('base64')
             },
         ...(params.metadata === true && { metadata: true }),
-        requestId,
+        requestId
     };
 }
 export function bciTranscribe(params, options) {
@@ -31,7 +31,7 @@ async function runBciTranscribe(params, requestId, options) {
     if (params.metadata === true) {
         const segments = [];
         for await (const response of stream(request, options)) {
-            if (response.type === "bciTranscribe") {
+            if (response.type === 'bciTranscribe') {
                 const parsed = bciTranscribeResponseSchema.parse(response);
                 if (parsed.segment) {
                     segments.push(parsed.segment);
@@ -43,9 +43,9 @@ async function runBciTranscribe(params, requestId, options) {
         }
         return segments;
     }
-    let fullText = "";
+    let fullText = '';
     for await (const response of stream(request, options)) {
-        if (response.type === "bciTranscribe") {
+        if (response.type === 'bciTranscribe') {
             const parsed = bciTranscribeResponseSchema.parse(response);
             if (parsed.text) {
                 fullText += parsed.text;
@@ -60,26 +60,26 @@ async function runBciTranscribe(params, requestId, options) {
 function buildBciTranscribeStreamRequest(params, requestId) {
     const streamOpts = {
         ...(params.windowTimesteps !== undefined && {
-            windowTimesteps: params.windowTimesteps,
+            windowTimesteps: params.windowTimesteps
         }),
         ...(params.hopTimesteps !== undefined && {
-            hopTimesteps: params.hopTimesteps,
+            hopTimesteps: params.hopTimesteps
         }),
-        ...(params.emit !== undefined && { emit: params.emit }),
+        ...(params.emit !== undefined && { emit: params.emit })
     };
     return {
-        type: "bciTranscribeStream",
+        type: 'bciTranscribeStream',
         modelId: params.modelId,
         ...(params.metadata === true && { metadata: true }),
         ...(Object.keys(streamOpts).length > 0 && { streamOpts }),
-        requestId,
+        requestId
     };
 }
 export function bciTranscribeStream(params, options) {
     if (params.metadata === true) {
-        return createBciStreamSession(params, options, processLineMetadata, "BciTranscribeStreamMetadataSession");
+        return createBciStreamSession(params, options, processLineMetadata, 'BciTranscribeStreamMetadataSession');
     }
-    return createBciStreamSession(params, options, processLine, "BciTranscribeStreamSession");
+    return createBciStreamSession(params, options, processLine, 'BciTranscribeStreamSession');
 }
 async function createBciStreamSession(params, options, process, sessionName) {
     const requestId = generateClientRequestId();
@@ -105,7 +105,7 @@ async function createBciStreamSession(params, options, process, sessionName) {
             }
             consumed = true;
             return responses;
-        },
+        }
     };
 }
 /**
@@ -114,11 +114,11 @@ async function createBciStreamSession(params, options, process, sessionName) {
  * whatever values it returns. `null` from `process` terminates the stream.
  */
 async function* parseLines(responseStream, process) {
-    let buf = "";
+    let buf = '';
     for await (const chunk of responseStream) {
         buf += chunk.toString();
-        const lines = buf.split("\n");
-        buf = lines.pop() || "";
+        const lines = buf.split('\n');
+        buf = lines.pop() || '';
         for (const line of lines) {
             const result = process(line);
             if (result === null)
@@ -141,12 +141,12 @@ function parseResponseLine(line) {
         parsed = JSON.parse(line);
     }
     catch {
-        logger.warn("bciTranscribeStream: malformed JSON from server:", line);
+        logger.warn('bciTranscribeStream: malformed JSON from server:', line);
         return null;
     }
     const obj = parsed;
-    if (obj["type"] === "error") {
-        throw new TranscriptionFailedError(obj["message"] ?? "Unknown server error");
+    if (obj['type'] === 'error') {
+        throw new TranscriptionFailedError(obj['message'] ?? 'Unknown server error');
     }
     return bciTranscribeStreamResponseSchema.parse(parsed);
 }
@@ -166,7 +166,7 @@ function processWith(line, extract) {
     return extract(response);
 }
 function processLine(line) {
-    return processWith(line, (response) => response.text?.trim() ? response.text : undefined);
+    return processWith(line, (response) => (response.text?.trim() ? response.text : undefined));
 }
 function processLineMetadata(line) {
     return processWith(line, (response) => response.segment);

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

@@ -1,4 +1,4 @@
-import { type CancelClientInput } from "../../schemas/index";
+import { type CancelClientInput } from '../../schemas/index';
 /**
  * Cancels an ongoing operation.
  *

package/dist/client/api/cancel.js

@@ -1,6 +1,6 @@
-import { send } from "../rpc/rpc-client.js";
-import {} from "../../schemas/index.js";
-import { InvalidResponseError, CancelFailedError } from "../../utils/errors-client.js";
+import { send } from '../rpc/rpc-client.js';
+import {} from '../../schemas/index.js';
+import { InvalidResponseError, CancelFailedError } from '../../utils/errors-client.js';
 /**
  * Cancels an ongoing operation.
  *
@@ -36,36 +36,36 @@ import { InvalidResponseError, CancelFailedError } from "../../utils/errors-clie
 export async function cancel(params) {
     const wireParams = normalizeCancelParams(params);
     const request = {
-        type: "cancel",
-        ...wireParams,
+        type: 'cancel',
+        ...wireParams
     };
     const response = await send(request);
-    if (response.type !== "cancel") {
-        throw new InvalidResponseError("cancel");
+    if (response.type !== 'cancel') {
+        throw new InvalidResponseError('cancel');
     }
     if (!response.success) {
         throw new CancelFailedError(response.error);
     }
 }
 function normalizeCancelParams(params) {
-    if ("operation" in params) {
-        if (params.operation === "request" || params.operation === "broad") {
+    if ('operation' in params) {
+        if (params.operation === 'request' || params.operation === 'broad') {
             return params;
         }
         // Legacy per-kind sugar: { operation: "inference"|"embeddings", modelId }
-        if (params.operation === "inference") {
+        if (params.operation === 'inference') {
             return {
-                operation: "broad",
+                operation: 'broad',
                 modelId: params.modelId,
-                kind: "completion",
+                kind: 'completion'
             };
         }
-        return { operation: "broad", modelId: params.modelId, kind: "embeddings" };
+        return { operation: 'broad', modelId: params.modelId, kind: 'embeddings' };
     }
-    if ("requestId" in params) {
+    if ('requestId' in params) {
         const wire = {
-            operation: "request",
-            requestId: params.requestId,
+            operation: 'request',
+            requestId: params.requestId
         };
         if (params.clearCache !== undefined) {
             wire.clearCache = params.clearCache;
@@ -73,8 +73,8 @@ function normalizeCancelParams(params) {
         return wire;
     }
     const broad = {
-        operation: "broad",
-        modelId: params.modelId,
+        operation: 'broad',
+        modelId: params.modelId
     };
     if (params.kind !== undefined) {
         broad.kind = params.kind;

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

@@ -1,4 +1,4 @@
-import { type ClassifyClientParams, type ClassificationResult } from "../../schemas/index";
+import { type ClassifyClientParams, type ClassificationResult } from '../../schemas/index';
 /**
  * Classifies an image using a loaded classification model.
  *

package/dist/client/api/classify.js

@@ -1,6 +1,6 @@
-import { classifyResponseSchema, } from "../../schemas/index.js";
-import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { encodeBase64 } from "../../utils/encoding.js";
+import { classifyResponseSchema } from '../../schemas/index.js';
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { encodeBase64 } from '../../utils/encoding.js';
 /**
  * Classifies an image using a loaded classification model.
  *
@@ -23,16 +23,19 @@ import { encodeBase64 } from "../../utils/encoding.js";
  */
 export async function classify(params) {
     const request = {
-        type: "classify",
+        type: 'classify',
         modelId: params.modelId,
         image: encodeBase64(params.image),
         ...(params.topK !== undefined && { topK: params.topK }),
         ...(params.width !== undefined && { width: params.width }),
         ...(params.height !== undefined && { height: params.height }),
-        ...(params.channels !== undefined && { channels: params.channels }),
+        ...(params.channels !== undefined && { channels: params.channels })
     };
     for await (const response of streamRpc(request)) {
-        if (response && typeof response === "object" && "type" in response && response.type === "classify") {
+        if (response &&
+            typeof response === 'object' &&
+            'type' in response &&
+            response.type === 'classify') {
             const parsed = classifyResponseSchema.parse(response);
             if (parsed.done) {
                 return parsed.results;

package/dist/client/api/client-request-id.js

@@ -23,5 +23,5 @@ export function generateClientRequestId() {
     for (let i = 0; i < bytes.length; i++) {
         bytes[i] = Math.floor(Math.random() * 256);
     }
-    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
 }

package/dist/client/api/completion-stream.d.ts

@@ -1,6 +1,6 @@
-import { type CompletionClientParams, type CompletionRun, type McpClientInput, type Tool, type RPCOptions } from "../../schemas/index";
-import { type ToolInput } from "../../utils/tool-helpers";
-type CompletionParams = Omit<CompletionClientParams, "tools"> & {
+import { type CompletionClientParams, type CompletionRun, type McpClientInput, type Tool, type RPCOptions } from '../../schemas/index';
+import { type ToolInput } from '../../utils/tool-helpers';
+type CompletionParams = Omit<CompletionClientParams, 'tools'> & {
     tools?: Tool[] | ToolInput[];
     mcp?: McpClientInput[];
     rpcOptions?: RPCOptions;

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

@@ -1,11 +1,11 @@
-import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { getClientLogger } from "../../logging/index.js";
-import { completionStreamResponseSchema, } from "../../schemas/index.js";
-import { CompletionFailedError, InferenceCancelledError, } from "../../utils/errors-server.js";
-import { getMcpToolsWithHandlers } from "../../utils/mcp-adapter.js";
-import { validateTools, } from "../../utils/tool-helpers.js";
-import { buildFinalFromEvents } from "../../utils/aggregate-events.js";
-import { generateClientRequestId } from "./client-request-id.js";
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { getClientLogger } from '../../logging/index.js';
+import { completionStreamResponseSchema } from '../../schemas/index.js';
+import { CompletionFailedError, InferenceCancelledError } from '../../utils/errors-server.js';
+import { getMcpToolsWithHandlers } from '../../utils/mcp-adapter.js';
+import { validateTools } from '../../utils/tool-helpers.js';
+import { buildFinalFromEvents } from '../../utils/aggregate-events.js';
+import { generateClientRequestId } from './client-request-id.js';
 const logger = getClientLogger();
 /**
  * Generates completion from a language model based on conversation history.
@@ -179,7 +179,7 @@ export function completion(params) {
                 }
             }
             const request = {
-                type: "completionStream",
+                type: 'completionStream',
                 modelId: params.modelId,
                 history: params.history,
                 kvCache: params.kvCache,
@@ -190,22 +190,22 @@ export function completion(params) {
                 emitRawDeltas: params.emitRawDeltas,
                 toolDialect: params.toolDialect,
                 responseFormat: params.responseFormat,
-                requestId,
+                requestId
             };
             const responses = streamRpc(request, params.rpcOptions);
             for await (const response of responses) {
                 if (response &&
-                    typeof response === "object" &&
-                    "type" in response &&
-                    response.type === "completionStream") {
+                    typeof response === 'object' &&
+                    'type' in response &&
+                    response.type === 'completionStream') {
                     const streamResponse = completionStreamResponseSchema.parse(response);
                     for (const event of streamResponse.events) {
                         allEvents.push(event);
                         eventQueue.push(event);
-                        if (event.type === "contentDelta") {
+                        if (event.type === 'contentDelta') {
                             tokenQueue.push(event.text);
                         }
-                        else if (event.type === "toolCall") {
+                        else if (event.type === 'toolCall') {
                             toolEventQueue.push(event);
                         }
                     }
@@ -232,7 +232,7 @@ export function completion(params) {
                             const err = new InferenceCancelledError(requestId, {
                                 text: final.contentText,
                                 toolCalls: final.toolCalls,
-                                ...(final.stats && { stats: final.stats }),
+                                ...(final.stats && { stats: final.stats })
                             });
                             finalRejecter(err);
                             statsRejecter(err);
@@ -327,7 +327,7 @@ export function completion(params) {
             toolCallStream,
             text: textPromise,
             stats: statsPromise,
-            toolCalls: toolCallsPromise,
+            toolCalls: toolCallsPromise
         };
     }
     else {
@@ -345,7 +345,7 @@ export function completion(params) {
             toolCallStream,
             text: textPromise,
             stats: statsPromise,
-            toolCalls: toolCallsPromise,
+            toolCalls: toolCallsPromise
         };
     }
 }

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

@@ -1,5 +1,5 @@
-import { send } from "../rpc/rpc-client.js";
-import { InvalidDeleteCacheParamsError, DeleteCacheFailedError, } from "../../utils/errors-client.js";
+import { send } from '../rpc/rpc-client.js';
+import { InvalidDeleteCacheParamsError, DeleteCacheFailedError } from '../../utils/errors-client.js';
 /**
  * Deletes KV cache files.
  *
@@ -23,17 +23,17 @@ import { InvalidDeleteCacheParamsError, DeleteCacheFailedError, } from "../../ut
  */
 export async function deleteCache(params) {
     let req;
-    if ("all" in params && params.all) {
+    if ('all' in params && params.all) {
         req = {
-            type: "deleteCache",
-            all: true,
+            type: 'deleteCache',
+            all: true
         };
     }
-    else if ("kvCacheKey" in params) {
+    else if ('kvCacheKey' in params) {
         req = {
-            type: "deleteCache",
+            type: 'deleteCache',
             kvCacheKey: params.kvCacheKey,
-            modelId: params.modelId,
+            modelId: params.modelId
         };
     }
     else {
@@ -44,6 +44,6 @@ export async function deleteCache(params) {
         throw new DeleteCacheFailedError(response.error);
     }
     return {
-        success: response.success,
+        success: response.success
     };
 }

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

@@ -1,4 +1,4 @@
-import { type DiffusionClientParams, type DiffusionStats } from "../../schemas/index";
+import { type DiffusionClientParams, type DiffusionStats } from '../../schemas/index';
 export interface DiffusionProgressTick {
     step: number;
     totalSteps: number;

package/dist/client/api/diffusion.js

@@ -1,6 +1,6 @@
-import { diffusionStreamResponseSchema, } from "../../schemas/index.js";
-import { stream as streamRpc } from "../rpc/rpc-client.js";
-import { decodeBase64, encodeBase64 } from "../../utils/encoding.js";
+import { diffusionStreamResponseSchema } from '../../schemas/index.js';
+import { stream as streamRpc } from '../rpc/rpc-client.js';
+import { decodeBase64, encodeBase64 } from '../../utils/encoding.js';
 /**
  * Generates images using a loaded diffusion model.
  *
@@ -86,9 +86,9 @@ export function diffusion(params) {
         ...rest,
         ...(init_image !== undefined && { init_image: encodeBase64(init_image) }),
         ...(init_images !== undefined && {
-            init_images: init_images.map(encodeBase64),
+            init_images: init_images.map(encodeBase64)
         }),
-        type: "diffusionStream",
+        type: 'diffusionStream'
     };
     let statsResolver = () => { };
     let statsRejecter = () => { };
@@ -113,12 +113,16 @@ export function diffusion(params) {
         try {
             for await (const response of streamRpc(request)) {
                 if (response &&
-                    typeof response === "object" &&
-                    "type" in response &&
-                    response.type === "diffusionStream") {
+                    typeof response === 'object' &&
+                    'type' in response &&
+                    response.type === 'diffusionStream') {
                     const parsed = diffusionStreamResponseSchema.parse(response);
                     if (parsed.step != null && parsed.totalSteps != null && parsed.elapsedMs != null) {
-                        progressQueue.push({ step: parsed.step, totalSteps: parsed.totalSteps, elapsedMs: parsed.elapsedMs });
+                        progressQueue.push({
+                            step: parsed.step,
+                            totalSteps: parsed.totalSteps,
+                            elapsedMs: parsed.elapsedMs
+                        });
                         if (progressResolve) {
                             progressResolve();
                             progressResolve = null;
@@ -157,13 +161,15 @@ export function diffusion(params) {
                 return;
             }
             else {
-                await new Promise((resolve) => { progressResolve = resolve; });
+                await new Promise((resolve) => {
+                    progressResolve = resolve;
+                });
             }
         }
     })();
     return {
         progressStream,
         outputs: outputsPromise,
-        stats: statsPromise,
+        stats: statsPromise
     };
 }

package/dist/client/api/download-asset.d.ts

@@ -1,4 +1,4 @@
-import { type DownloadAssetOptions as BaseDownloadAssetOptions, type RPCOptions } from "../../schemas/index";
+import { type DownloadAssetOptions as BaseDownloadAssetOptions, type RPCOptions } from '../../schemas/index';
 export type DownloadAssetOptions = BaseDownloadAssetOptions;
 /**
  * Downloads an asset (model file) without loading it into memory.

package/dist/client/api/download-asset.js

@@ -1,9 +1,9 @@
-import { send, stream } from "../rpc/rpc-client.js";
-import { downloadAssetOptionsToRequestSchema, } from "../../schemas/index.js";
-import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError, } from "../../utils/errors-client.js";
-import { decoratePromise } from "../../utils/decorate-promise.js";
-import { parseClientInput } from "../parse-input.js";
-import { generateClientRequestId } from "./client-request-id.js";
+import { send, stream } from '../rpc/rpc-client.js';
+import { downloadAssetOptionsToRequestSchema } from '../../schemas/index.js';
+import { DownloadAssetFailedError, StreamEndedError, InvalidResponseError } from '../../utils/errors-client.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { parseClientInput } from '../parse-input.js';
+import { generateClientRequestId } from './client-request-id.js';
 /**
  * Downloads an asset (model file) without loading it into memory.
  *
@@ -56,15 +56,15 @@ export function downloadAsset(options, rpcOptions) {
 async function runDownloadAsset(options, requestId, rpcOptions) {
     const request = parseClientInput(downloadAssetOptionsToRequestSchema, {
         ...options,
-        requestId,
+        requestId
     });
     if (options.onProgress) {
         // Use streaming for progress updates
         for await (const response of stream(request, rpcOptions)) {
-            if (response.type === "modelProgress") {
+            if (response.type === 'modelProgress') {
                 options.onProgress(response);
             }
-            else if (response.type === "downloadAsset") {
+            else if (response.type === 'downloadAsset') {
                 if (!response.success) {
                     throw new DownloadAssetFailedError(response.error);
                 }
@@ -76,8 +76,8 @@ async function runDownloadAsset(options, requestId, rpcOptions) {
     else {
         // Use regular send for simple downloading
         const response = await send(request, rpcOptions);
-        if (response.type !== "downloadAsset") {
-            throw new InvalidResponseError("downloadAsset");
+        if (response.type !== 'downloadAsset') {
+            throw new InvalidResponseError('downloadAsset');
         }
         if (!response.success) {
             throw new DownloadAssetFailedError(response.error);

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

@@ -1,4 +1,4 @@
-import { type EmbedStats, type RPCOptions } from "../../schemas/index";
+import { type EmbedStats, type RPCOptions } from '../../schemas/index';
 /**
  * Generates embeddings for a single text using a specified model.
  *

package/dist/client/api/embed.js

@@ -1,8 +1,8 @@
-import { send } from "../rpc/rpc-client.js";
-import {} from "../../schemas/index.js";
-import { InvalidResponseError } from "../../utils/errors-client.js";
-import { decoratePromise } from "../../utils/decorate-promise.js";
-import { generateClientRequestId } from "./client-request-id.js";
+import { send } from '../rpc/rpc-client.js';
+import {} from '../../schemas/index.js';
+import { InvalidResponseError } from '../../utils/errors-client.js';
+import { decoratePromise } from '../../utils/decorate-promise.js';
+import { generateClientRequestId } from './client-request-id.js';
 export function embed(params, options) {
     // Client-generated `requestId` is surfaced synchronously on the
     // returned promise so the caller can `cancel({ requestId })` before
@@ -15,16 +15,16 @@ export function embed(params, options) {
 }
 async function runEmbed(params, requestId, options) {
     const request = {
-        type: "embed",
+        type: 'embed',
         ...params,
-        requestId,
+        requestId
     };
     const response = await send(request, options);
-    if (response.type !== "embed") {
-        throw new InvalidResponseError("embed");
+    if (response.type !== 'embed') {
+        throw new InvalidResponseError('embed');
     }
     return {
         embedding: response.embedding,
-        ...(response.stats !== undefined && { stats: response.stats }),
+        ...(response.stats !== undefined && { stats: response.stats })
     };
 }

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

@@ -1,4 +1,4 @@
-import { type FinetuneGetStateParams, type FinetuneProgress, type FinetuneResult, type FinetuneRunParams, type FinetuneStopParams, type RPCOptions } from "../../schemas/index";
+import { type FinetuneGetStateParams, type FinetuneProgress, type FinetuneResult, type FinetuneRunParams, type FinetuneStopParams, type RPCOptions } from '../../schemas/index';
 export interface FinetuneHandle {
     progressStream: AsyncGenerator<FinetuneProgress>;
     result: Promise<FinetuneResult>;