@qvac/sdk 0.18.2 → 0.19.1

package/dist/client/api/finetune.js

@@ -1,144 +0,0 @@
-import { send, stream as streamRpc } from '../../client/rpc/rpc-client.js';
-import { finetuneRunParamsSchema, finetuneRunRequestSchema, finetuneStopRequestSchema, finetuneGetStateParamsSchema, finetuneGetStateRequestSchema, finetuneProgressResponseSchema, finetuneResponseSchema } from '../../schemas/index.js';
-import { InvalidResponseError, StreamEndedError } from '../../utils/errors-client.js';
-import { parseClientInput } from '../../client/parse-input.js';
-import { generateClientRequestId } from '../../client/api/client-request-id.js';
-function isFinetuneReplyParams(params) {
-    return (params.operation === 'pause' || params.operation === 'cancel' || params.operation === 'getState');
-}
-function createFinetuneReplyRequest(params) {
-    if (params.operation === 'getState') {
-        const getStateParams = parseClientInput(finetuneGetStateParamsSchema, params);
-        return parseClientInput(finetuneGetStateRequestSchema, {
-            type: 'finetune',
-            ...getStateParams
-        });
-    }
-    return parseClientInput(finetuneStopRequestSchema, {
-        type: 'finetune',
-        modelId: params.modelId,
-        operation: params.operation
-    });
-}
-export function finetune(params, rpcOptions) {
-    if (isFinetuneReplyParams(params)) {
-        const request = createFinetuneReplyRequest(params);
-        const resultPromise = (async () => {
-            const response = await send(request, rpcOptions);
-            if (!response ||
-                typeof response !== 'object' ||
-                !('type' in response) ||
-                response.type !== 'finetune') {
-                throw new InvalidResponseError('finetune');
-            }
-            return finetuneResponseSchema.parse(response);
-        })();
-        resultPromise.catch(() => { });
-        return resultPromise;
-    }
-    const runParams = parseClientInput(finetuneRunParamsSchema, params);
-    // Client-side id so the run is cancellable via cancel({ requestId }) the
-    // moment the handle is returned. Surfaced on the handle below.
-    const requestId = generateClientRequestId();
-    let resultResolver = () => { };
-    let resultRejecter = () => { };
-    const resultPromise = new Promise((resolve, reject) => {
-        resultResolver = resolve;
-        resultRejecter = reject;
-    });
-    resultPromise.catch(() => { });
-    const progressQueue = [];
-    let progressDone = false;
-    let progressResolve = null;
-    let streamError = null;
-    const processResponses = async () => {
-        try {
-            let sawTerminalResponse = false;
-            const request = parseClientInput(finetuneRunRequestSchema, {
-                type: 'finetune',
-                ...runParams,
-                requestId,
-                withProgress: true
-            });
-            const responses = streamRpc(request, rpcOptions);
-            for await (const response of responses) {
-                if (response &&
-                    typeof response === 'object' &&
-                    'type' in response &&
-                    response.type === 'finetune:progress') {
-                    const progressResponse = finetuneProgressResponseSchema.parse(response);
-                    progressQueue.push({
-                        is_train: progressResponse.is_train,
-                        loss: progressResponse.loss,
-                        loss_uncertainty: progressResponse.loss_uncertainty,
-                        accuracy: progressResponse.accuracy,
-                        accuracy_uncertainty: progressResponse.accuracy_uncertainty,
-                        global_steps: progressResponse.global_steps,
-                        current_epoch: progressResponse.current_epoch,
-                        current_batch: progressResponse.current_batch,
-                        total_batches: progressResponse.total_batches,
-                        elapsed_ms: progressResponse.elapsed_ms,
-                        eta_ms: progressResponse.eta_ms
-                    });
-                    if (progressResolve) {
-                        progressResolve();
-                        progressResolve = null;
-                    }
-                    continue;
-                }
-                if (response &&
-                    typeof response === 'object' &&
-                    'type' in response &&
-                    response.type === 'finetune') {
-                    sawTerminalResponse = true;
-                    const finetuneResponse = finetuneResponseSchema.parse(response);
-                    resultResolver(finetuneResponse);
-                    progressDone = true;
-                    if (progressResolve) {
-                        progressResolve();
-                        progressResolve = null;
-                    }
-                }
-                else {
-                    throw new InvalidResponseError('finetune');
-                }
-            }
-            if (!sawTerminalResponse) {
-                throw new StreamEndedError();
-            }
-        }
-        catch (error) {
-            streamError = error instanceof Error ? error : new Error(String(error));
-            resultRejecter(error);
-            progressDone = true;
-            if (progressResolve) {
-                progressResolve();
-                progressResolve = null;
-            }
-        }
-    };
-    void processResponses();
-    const progressStream = (async function* () {
-        while (true) {
-            if (progressQueue.length > 0) {
-                yield progressQueue.shift();
-            }
-            else if (progressDone) {
-                if (streamError !== null) {
-                    throw streamError;
-                }
-                break;
-            }
-            else {
-                await new Promise((resolve) => {
-                    progressResolve = resolve;
-                });
-            }
-        }
-    })();
-    return {
-        progressStream,
-        result: resultPromise,
-        requestId
-    };
-}

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

@@ -1,25 +0,0 @@
-import { type GetLoadedModelInfoParams, type LoadedModelInfo } from '../../schemas/index.js';
-import { type RPCOptions } from '../../schemas/common.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 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

@@ -1,36 +0,0 @@
-import {} from '../../schemas/index.js';
-import {} from '../../schemas/common.js';
-import { send } from '../../client/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,44 +0,0 @@
-import { type GetModelInfoParams } from '../../schemas/index.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 declare function getModelInfo(params: GetModelInfoParams): Promise<{
-    name: string;
-    modelId: string;
-    expectedSize: number;
-    sha256Checksum: string;
-    addon: "embeddings" | "diffusion" | "audiogen" | "tts" | "ocr" | "vla" | "llm" | "whisper" | "bci" | "nmt" | "parakeet" | "classification" | "vad" | "other";
-    isCached: boolean;
-    isLoaded: boolean;
-    cacheFiles: {
-        filename: string;
-        path: string;
-        expectedSize: number;
-        sha256Checksum: string;
-        isCached: boolean;
-        actualSize?: number | undefined;
-        cachedAt?: Date | undefined;
-    }[];
-    registryPath?: string | undefined;
-    registrySource?: string | undefined;
-    blobCoreKey?: string | undefined;
-    blobBlockOffset?: number | undefined;
-    blobBlockLength?: number | undefined;
-    blobByteOffset?: number | undefined;
-    engine?: string | undefined;
-    quantization?: string | undefined;
-    params?: string | undefined;
-    actualSize?: number | undefined;
-    cachedAt?: Date | undefined;
-    loadedInstances?: {
-        registryId: string;
-        loadedAt: Date;
-        config?: unknown;
-    }[] | undefined;
-}>;
-//# sourceMappingURL=get-model-info.d.ts.map

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

@@ -1,22 +0,0 @@
-import {} from '../../schemas/index.js';
-import { send } from '../../client/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',
-        name: params.name
-    };
-    const response = await send(request);
-    if (response.type !== 'getModelInfo') {
-        throw new InvalidResponseError('getModelInfo');
-    }
-    return response.modelInfo;
-}

package/dist/client/api/get-system-resources.d.ts

@@ -1,3 +0,0 @@
-import type { GetSystemResourcesInput, SystemResources } from '../../schemas/system-resources.js';
-export declare function getSystemResources(input?: GetSystemResourcesInput): Promise<SystemResources>;
-//# sourceMappingURL=get-system-resources.d.ts.map

package/dist/client/api/get-system-resources.js

@@ -1,16 +0,0 @@
-import { send } from '../../client/rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
-export async function getSystemResources(input) {
-    const request = {
-        type: 'getSystemResources',
-        ...(input?.sample !== undefined && { sample: input.sample })
-    };
-    const response = await send(request);
-    if (response.type !== 'getSystemResources') {
-        throw new InvalidResponseError('getSystemResources');
-    }
-    return {
-        capabilities: response.capabilities,
-        ...(response.sample && { sample: response.sample })
-    };
-}

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

@@ -1,30 +0,0 @@
-import { type HeartbeatResponse } from '../../schemas/index.js';
-import type { DelegateBase } from '../../schemas/delegate.js';
-/**
- * Checks if a delegated provider is online by sending a heartbeat round-trip.
- * 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 (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.
- *
- * @example
- * // Check if a delegated provider is online
- * try {
- *   await heartbeat({
- *     delegate: { providerPublicKey: "peerHex", timeout: 3000 },
- *   });
- *   console.log("Provider is online");
- * } catch {
- *   console.log("Provider is offline");
- * }
- *
- * @example
- * // Check if the local SDK worker is responsive
- * await heartbeat();
- */
-export declare function heartbeat(params?: {
-    delegate?: DelegateBase;
-}): Promise<HeartbeatResponse>;
-//# sourceMappingURL=heartbeat.d.ts.map

package/dist/client/api/heartbeat.js

@@ -1,38 +0,0 @@
-import {} from '../../schemas/index.js';
-import { send } from '../../client/rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
-/**
- * Checks if a delegated provider is online by sending a heartbeat round-trip.
- * 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 (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.
- *
- * @example
- * // Check if a delegated provider is online
- * try {
- *   await heartbeat({
- *     delegate: { providerPublicKey: "peerHex", timeout: 3000 },
- *   });
- *   console.log("Provider is online");
- * } catch {
- *   console.log("Provider is offline");
- * }
- *
- * @example
- * // Check if the local SDK worker is responsive
- * await heartbeat();
- */
-export async function heartbeat(params) {
-    const request = {
-        type: 'heartbeat',
-        ...(params?.delegate && { delegate: params.delegate })
-    };
-    const response = await send(request);
-    if (response.type !== 'heartbeat') {
-        throw new InvalidResponseError('heartbeat');
-    }
-    return response;
-}

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

@@ -1,36 +0,0 @@
-export { loadModel } from './load-model.js';
-export { downloadAsset } from './download-asset.js';
-export { batchCompletion } from './batch-completion.js';
-export { completion } from './completion-stream.js';
-export { deleteCache } from './delete-cache.js';
-export { unloadModel } from './unload-model.js';
-export { loggingStream } from './logging-stream.js';
-export { subscribeServerLogs, type ServerLogHandler } from './subscribe-logs.js';
-export { heartbeat } from './heartbeat.js';
-export { transcribe, transcribeStream } from './transcribe.js';
-export { bciTranscribe, bciTranscribeStream } from './bci-transcribe.js';
-export { embed } from './embed.js';
-export { finetune, type FinetuneHandle } from './finetune.js';
-export { translate } from './translate.js';
-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, textToSpeechStream } from './text-to-speech.js';
-export { getModelInfo } from './get-model-info.js';
-export { getLoadedModelInfo } from './get-loaded-model-info.js';
-export { getSystemResources } from './get-system-resources.js';
-export { ocr } from './ocr.js';
-export { invokePlugin, invokePluginStream } from './invoke-plugin.js';
-export { diffusion, type DiffusionProgressTick } from './diffusion.js';
-export { classify } from './classify.js';
-export { video, type VideoProgressTick } from './video.js';
-export { upscale } from './upscale.js';
-export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel, type ModelRegistrySearchParams } from './registry.js';
-export { suspend } from './suspend.js';
-export { resume } from './resume.js';
-export { state } from './state.js';
-export { vla, vlaHparams, vlaSetEmbodiment } from './vla.js';
-export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-helpers.js';
-export { audioGen } from '../../client/api/audio-gen.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/client/api/index.js

@@ -1,35 +0,0 @@
-export { loadModel } from './load-model.js';
-export { downloadAsset } from './download-asset.js';
-export { batchCompletion } from './batch-completion.js';
-export { completion } from './completion-stream.js';
-export { deleteCache } from './delete-cache.js';
-export { unloadModel } from './unload-model.js';
-export { loggingStream } from './logging-stream.js';
-export { subscribeServerLogs } from './subscribe-logs.js';
-export { heartbeat } from './heartbeat.js';
-export { transcribe, transcribeStream } from './transcribe.js';
-export { bciTranscribe, bciTranscribeStream } from './bci-transcribe.js';
-export { embed } from './embed.js';
-export { finetune } from './finetune.js';
-export { translate } from './translate.js';
-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, textToSpeechStream } from './text-to-speech.js';
-export { getModelInfo } from './get-model-info.js';
-export { getLoadedModelInfo } from './get-loaded-model-info.js';
-export { getSystemResources } from './get-system-resources.js';
-export { ocr } from './ocr.js';
-export { invokePlugin, invokePluginStream } from './invoke-plugin.js';
-export { diffusion } from './diffusion.js';
-export { classify } from './classify.js';
-export { video } from './video.js';
-export { upscale } from './upscale.js';
-export { modelRegistryList, modelRegistrySearch, modelRegistryGetModel } from './registry.js';
-export { suspend } from './suspend.js';
-export { resume } from './resume.js';
-export { state } from './state.js';
-export { vla, vlaHparams, vlaSetEmbodiment } from './vla.js';
-export { vlaPreprocessImage, vlaPadState, VLA_DEFAULT_IMAGE_SIZE } from './vla-helpers.js';
-export { audioGen } from '../../client/api/audio-gen.js';

package/dist/client/api/invoke-plugin.d.ts

@@ -1,31 +0,0 @@
-import type { RPCOptions } from '../../schemas/index.js';
-export interface InvokePluginOptions<TParams = unknown> {
-    modelId: string;
-    handler: string;
-    params: TParams;
-}
-/**
- * Invoke a non-streaming plugin handler.
- *
- * @param options - Invocation payload.
- * @param options.modelId - The identifier of the model instance that owns the plugin.
- * @param options.handler - Name of the plugin handler to invoke.
- * @param options.params - Handler-specific parameters, passed through to the plugin.
- * @param rpcOptions - Optional RPC options (timeout, profiling, force new connection, etc.).
- * @returns A promise resolving to the handler's result payload (typed via the `TResponse` generic).
- * @throws {QvacErrorBase} When the response type is invalid (`InvalidResponseError`) or the RPC layer fails.
- */
-export declare function invokePlugin<TResponse = unknown, TParams = unknown>(options: InvokePluginOptions<TParams>, rpcOptions?: RPCOptions): Promise<TResponse>;
-/**
- * Invoke a streaming plugin handler.
- *
- * @param options - Invocation payload.
- * @param options.modelId - The identifier of the model instance that owns the plugin.
- * @param options.handler - Name of the plugin stream handler to invoke.
- * @param options.params - Handler-specific parameters, passed through to the plugin.
- * @param rpcOptions - Optional RPC options (timeout, profiling, force new connection, etc.).
- * @returns An async generator yielding chunk payloads (typed via the `TResponse` generic) until the stream completes.
- * @throws {QvacErrorBase} When an intermediate response has the wrong type (`InvalidResponseError`) or the RPC layer fails.
- */
-export declare function invokePluginStream<TResponse = unknown, TParams = unknown>(options: InvokePluginOptions<TParams>, rpcOptions?: RPCOptions): AsyncGenerator<TResponse>;
-//# sourceMappingURL=invoke-plugin.d.ts.map

package/dist/client/api/invoke-plugin.js

@@ -1,54 +0,0 @@
-import { send, stream } from '../../client/rpc/rpc-client.js';
-import { InvalidResponseError } from '../../utils/errors-client.js';
-/**
- * Invoke a non-streaming plugin handler.
- *
- * @param options - Invocation payload.
- * @param options.modelId - The identifier of the model instance that owns the plugin.
- * @param options.handler - Name of the plugin handler to invoke.
- * @param options.params - Handler-specific parameters, passed through to the plugin.
- * @param rpcOptions - Optional RPC options (timeout, profiling, force new connection, etc.).
- * @returns A promise resolving to the handler's result payload (typed via the `TResponse` generic).
- * @throws {QvacErrorBase} When the response type is invalid (`InvalidResponseError`) or the RPC layer fails.
- */
-export async function invokePlugin(options, rpcOptions) {
-    const request = {
-        type: 'pluginInvoke',
-        modelId: options.modelId,
-        handler: options.handler,
-        params: options.params
-    };
-    const response = await send(request, rpcOptions);
-    if (response.type !== 'pluginInvoke') {
-        throw new InvalidResponseError('pluginInvoke');
-    }
-    return response.result;
-}
-/**
- * Invoke a streaming plugin handler.
- *
- * @param options - Invocation payload.
- * @param options.modelId - The identifier of the model instance that owns the plugin.
- * @param options.handler - Name of the plugin stream handler to invoke.
- * @param options.params - Handler-specific parameters, passed through to the plugin.
- * @param rpcOptions - Optional RPC options (timeout, profiling, force new connection, etc.).
- * @returns An async generator yielding chunk payloads (typed via the `TResponse` generic) until the stream completes.
- * @throws {QvacErrorBase} When an intermediate response has the wrong type (`InvalidResponseError`) or the RPC layer fails.
- */
-export async function* invokePluginStream(options, rpcOptions) {
-    const request = {
-        type: 'pluginInvokeStream',
-        modelId: options.modelId,
-        handler: options.handler,
-        params: options.params
-    };
-    for await (const chunk of stream(request, rpcOptions)) {
-        const response = chunk;
-        if (response.type !== 'pluginInvokeStream') {
-            throw new InvalidResponseError('pluginInvokeStream');
-        }
-        if (!response.done) {
-            yield response.result;
-        }
-    }
-}