@qvac/sdk 0.18.2 → 0.19.0

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;
-        }
-    }
-}

package/dist/client/api/load-model.d.ts

@@ -1,178 +0,0 @@
-import { type LoadModelOptions, type LoadCustomPluginModelOptions, type LoadModelDescriptorParam, type ReloadConfigOptions, type RPCOptions, type ModelDescriptor } from '../../schemas/index.js';
-/**
- * Loads a model from a descriptor; `modelType` is inferred from `modelSrc`.
- * `modelConfig` narrows per-engine when `modelSrc.engine` is a literal,
- * otherwise falls back to a permissive shape.
- *
- * @overloadLabel "From descriptor"
- * @param options - Descriptor-based load options. `modelSrc` is a
- *   `ModelDescriptor` (e.g. one of the `LLAMA_3_2_1B_INST_Q4_0`-style
- *   constants); `modelType` is inferred from it.
- * @param rpcOptions - Optional RPC options including per-call profiling.
- * @returns Promise that resolves to the loaded model ID.
- * @throws {ModelTypeRequiredError} When `modelType` cannot be inferred from `modelSrc` at runtime.
- * @example
- * ```typescript
- * await loadModel({ modelSrc: LLAMA_3_2_1B_INST_Q4_0, modelConfig: { ctx_size: 2048 } });
- * await loadModel({ modelSrc: WHISPER_TINY });
- * ```
- */
-export declare function loadModel<S extends ModelDescriptor>(options: LoadModelDescriptorParam<S>, rpcOptions?: RPCOptions): Promise<string> & {
-    requestId: string;
-};
-/**
- * Loads a machine learning model from a local path, remote URL, or Hyperdrive key.
- *
- * This function supports multiple model types: LLM (Large Language Model), Whisper (speech recognition),
- * embeddings, NMT (translation), and TTS. It can handle both local file paths and Hyperdrive URLs (pear://).
- *
- * When `onProgress` is provided, the function uses streaming to provide real-time download progress.
- * Otherwise, it uses a simple request-response pattern for faster execution.
- *
- * @overloadLabel "Load new model"
- * @param options - An object that defines all configuration parameters required for loading the model, including:
- *   - modelSrc: The location from which the model weights are fetched (local path, remote URL, or Hyperdrive URL)
- *   - modelType: The canonical type of model ("llamacpp-completion",
- *     "whispercpp-transcription", "llamacpp-embedding", "nmtcpp-translation",
- *     "tts-ggml", ...). May be omitted when `modelSrc` is a registry descriptor
- *     that already carries the engine.
- *   - modelConfig: Model-specific configuration options (companion sources, model parameters, etc.)
- *   - fallbackSrc: For a built-in catalog model, an HTTP URL or local file path to load from when the registry is unreachable (validated against the model checksum)
- *   - onProgress: Callback for download progress updates
- *   - logger: Logger instance for model operation logs
- * @param rpcOptions - Optional RPC options including per-call profiling configuration
- *
- * @returns Promise that resolves to the model ID (either the provided modelSrc or a generated ID)
- *
- * @throws {QvacErrorBase} When model loading fails, with details in the error message
- * @throws {QvacErrorBase} When streaming ends unexpectedly (only when using onProgress)
- * @throws {QvacErrorBase} When receiving an invalid response type from the server
- *
- * @example
- * ```typescript
- * // Local file path - absolute path
- * const localModelId = await loadModel({
- *   modelSrc: "/home/user/models/llama-7b.gguf",
- *   modelType: "llamacpp-completion",
- *   modelConfig: { ctx_size: 2048 }
- * });
- *
- * // Local file path - relative path
- * const relativeModelId = await loadModel({
- *   modelSrc: "./models/whisper-base.gguf",
- *   modelType: "whispercpp-transcription"
- * });
- *
- * // Hyperdrive URL with key and path
- * const hyperdriveId = await loadModel({
- *   modelSrc: "pear://<hyperdrive-key>/llama-7b.gguf",
- *   modelType: "llamacpp-completion",
- *   modelConfig: { ctx_size: 2048 }
- * });
- *
- * // Remote HTTP/HTTPS URL with progress tracking
- * const remoteId = await loadModel({
- *   modelSrc: "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGUF/resolve/main/llama-2-7b-chat.Q4_K_M.gguf",
- *   modelType: "llamacpp-completion",
- *   onProgress: (progress) => {
- *     console.log(`Downloaded: ${progress.percentage}%`);
- *   }
- * });
- *
- * // Multimodal model with projection
- * const multimodalId = await loadModel({
- *   modelSrc: "https://huggingface.co/.../main-model.gguf",
- *   modelType: "llamacpp-completion",
- *   modelConfig: {
- *     ctx_size: 512,
- *     projectionModelSrc: "https://huggingface.co/.../projection-model.gguf"
- *   },
- *   onProgress: (progress) => {
- *     console.log(`Loading: ${progress.percentage}%`);
- *   }
- * });
- *
- * // Whisper with VAD model
- * const whisperId = await loadModel({
- *   modelSrc: "https://huggingface.co/.../whisper-model.gguf",
- *   modelType: "whispercpp-transcription",
- *   modelConfig: {
- *     mode: "caption",
- *     output_format: "plaintext",
- *     min_seconds: 2,
- *     max_seconds: 6,
- *     vadModelSrc: "https://huggingface.co/.../vad-model.bin"
- *   }
- * });
- *
- * // Load with automatic logging - logs from the model will be forwarded to your logger
- * import { getLogger } from "../../logging/index.js";
- * const logger = getLogger("my-app");
- *
- * const modelId = await loadModel({
- *   modelSrc: "/path/to/model.gguf",
- *   modelType: "llamacpp-completion",
- *   logger // Pass logger in options
- * });
- *
- * // Catalog model with an alternate source used when the registry is unreachable
- * import { LLAMA_3_2_1B_INST_Q4_0 } from "@qvac/sdk";
- * const resilientId = await loadModel({
- *   modelSrc: LLAMA_3_2_1B_INST_Q4_0,
- *   fallbackSrc: "https://mirror.example.com/llama-3.2-1b-instruct-q4_0.gguf"
- * });
- * ```
- */
-export declare function loadModel(options: LoadModelOptions, rpcOptions?: RPCOptions): Promise<string> & {
-    requestId: string;
-};
-/**
- * Loads a custom plugin model (any non-built-in `modelType` string).
- * `modelConfig` is plugin-defined; the SDK does not narrow it.
- *
- * @overloadLabel "Custom plugin"
- * @param options - Custom plugin load options. `modelType` can be any
- *   string registered by a plugin; `modelConfig` is forwarded to the
- *   plugin's `loadModel` handler unchanged.
- * @param rpcOptions - Optional RPC options including per-call profiling.
- * @returns Promise that resolves to the loaded model ID.
- */
-export declare function loadModel<T extends string>(options: LoadCustomPluginModelOptions<T>, rpcOptions?: RPCOptions): Promise<string> & {
-    requestId: string;
-};
-/**
- * Hot-reloads configuration on an already loaded model.
- *
- * @overloadLabel "Hot-reload config"
- * @param options - Configuration for reloading config on an existing model:
- *   - modelId: The ID of an existing loaded model
- *   - modelType: The type of model (must match the loaded model)
- *   - modelConfig: New configuration to apply
- * @param rpcOptions - Optional RPC options including per-call profiling configuration
- *
- * @returns Promise that resolves to the model ID
- *
- * @throws {QvacErrorBase} When model reload fails, with details in the error message
- * @throws {QvacErrorBase} When receiving an invalid response type from the server
- *
- * @example
- * ```typescript
- * // Load new model
- * const modelId = await loadModel({
- *   modelSrc: "pear://<hyperdrive-key>/whisper-tiny.gguf",
- *   modelType: "whisper",
- *   modelConfig: { language: "en" },
- * });
- *
- * // Later, update the config without reloading the model
- * await loadModel({
- *   modelId,
- *   modelType: "whisper",
- *   modelConfig: { language: "es" },
- * });
- * ```
- */
-export declare function loadModel(options: ReloadConfigOptions, rpcOptions?: RPCOptions): Promise<string> & {
-    requestId: string;
-};
-//# sourceMappingURL=load-model.d.ts.map

package/dist/client/api/load-model.js

@@ -1,130 +0,0 @@
-import { send, stream } from '../../client/rpc/rpc-client.js';
-import { startLoggingStreamForModel } from '../../client/logging-stream-registry.js';
-import { loadBuiltinToRequestSchema, loadCustomPluginToRequestSchema, reloadConfigOptionsToRequestSchema, isBuiltInModelType, isModelTypeAlias, normalizeModelType, inferModelTypeFromModelSrc, ModelType } from '../../schemas/index.js';
-import { ModelLoadFailedError, ModelTypeRequiredError, StreamEndedError, InvalidResponseError } from '../../utils/errors-client.js';
-import { assertModelSrcMatchesModelType } from '../../utils/load-model-validation.js';
-import { parseClientInput } from '../../client/parse-input.js';
-import { getClientLogger } from '../../logging/index.js';
-import { decoratePromise } from '../../utils/decorate-promise.js';
-import { generateClientRequestId } from '../../client/api/client-request-id.js';
-const logger = getClientLogger();
-function isReactNativeRuntime() {
-    const runtime = globalThis;
-    return runtime.navigator?.product === 'ReactNative';
-}
-let warnedLocalVideoModelLoad = false;
-export function loadModel(options, rpcOptions) {
-    // Generate a stable `requestId` once, synchronously, before kicking
-    // off any async work. The same id is:
-    //   - threaded onto the request envelope (`request.requestId`) so the
-    //     server's `registry.begin(...)` records it on the registry
-    //     entry; and
-    //   - attached to the returned promise via `decoratePromise` so the
-    //     caller can target this exact call with `cancel({ requestId })`
-    //     before `await` resolves. Generating client-side and surfacing
-    //     it synchronously is what closes the "stop-button race" gap for
-    //     `loadModel` / `downloadAsset` callers — same shape as the
-    //     `CompletionRun.requestId` contract.
-    const requestId = generateClientRequestId();
-    const inner = runLoadModel(options, requestId, rpcOptions);
-    return decoratePromise(inner, { requestId });
-}
-async function runLoadModel(options, requestId, rpcOptions) {
-    const isReloadConfig = 'modelId' in options && !('modelSrc' in options);
-    // Infer `modelType` from `modelSrc` when omitted; the schema still validates
-    // the resolved options below.
-    let resolvedOptions = options;
-    if (!isReloadConfig) {
-        let modelType = resolvedOptions['modelType'];
-        if (typeof modelType === 'string') {
-            assertModelSrcMatchesModelType(resolvedOptions['modelSrc'], modelType);
-        }
-        else if (modelType === undefined) {
-            const inferred = inferModelTypeFromModelSrc(resolvedOptions['modelSrc']);
-            if (!inferred) {
-                throw new ModelTypeRequiredError();
-            }
-            resolvedOptions = { ...resolvedOptions, modelType: inferred };
-            modelType = inferred;
-        }
-        if (typeof modelType === 'string' && isModelTypeAlias(modelType)) {
-            const canonical = normalizeModelType(modelType);
-            logger.warn(`Model type "${modelType}" is an alias and will be deprecated. Use "${canonical}" instead.`);
-        }
-        const canonicalModelType = typeof modelType === 'string' ? normalizeModelType(modelType) : modelType;
-        const modelConfig = resolvedOptions['modelConfig'];
-        if (isReactNativeRuntime() &&
-            canonicalModelType === ModelType.sdcppGeneration &&
-            modelConfig?.mode === 'video' &&
-            resolvedOptions['delegate'] === undefined &&
-            !warnedLocalVideoModelLoad) {
-            warnedLocalVideoModelLoad = true;
-            const message = 'QVAC video generation works on React Native, but loading the video ' +
-                'model on-device will usually fail or take several minutes — the video ' +
-                'diffusion models currently shipped by the SDK are too large to load ' +
-                'on typical mobile devices. Pass a `delegate` to `loadModel(...)` to ' +
-                'run generation on a desktop peer instead.';
-            logger.warn(message);
-        }
-    }
-    // Splice the client-generated `requestId` onto the resolved options so
-    // the wire envelope carries it. The server uses the same value as the
-    // registry-entry key — that match is what makes
-    // `cancel({ requestId: op.requestId })` a no-op when no match exists
-    // and a precise abort when it does.
-    resolvedOptions = { ...resolvedOptions, requestId };
-    const request = isReloadConfig
-        ? parseClientInput(reloadConfigOptionsToRequestSchema, resolvedOptions)
-        : isBuiltInModelType(resolvedOptions['modelType'])
-            ? parseClientInput(loadBuiltinToRequestSchema, resolvedOptions)
-            : parseClientInput(loadCustomPluginToRequestSchema, resolvedOptions);
-    const modelLogger = isReloadConfig
-        ? undefined
-        : resolvedOptions['logger'];
-    const onProgress = isReloadConfig
-        ? undefined
-        : resolvedOptions['onProgress'];
-    if (onProgress) {
-        // Use streaming for progress updates
-        for await (const response of stream(request, rpcOptions)) {
-            if (response.type === 'modelProgress') {
-                onProgress(response);
-            }
-            else if (response.type === 'loadModel') {
-                if (!response.success) {
-                    throw new ModelLoadFailedError(response.error);
-                }
-                const modelId = response.modelId;
-                // Start logging stream in the background if logger is provided, catch to avoid failing the entire loadModel operation
-                if (modelLogger) {
-                    try {
-                        startLoggingStreamForModel(modelId, modelLogger);
-                    }
-                    catch (error) {
-                        logger.warn(`Failed to start logging stream for model ${modelId}:`, error);
-                    }
-                }
-                return modelId;
-            }
-        }
-        throw new StreamEndedError();
-    }
-    // Use regular send for simple loading
-    const response = await send(request, rpcOptions);
-    if (response.type !== 'loadModel') {
-        throw new InvalidResponseError('loadModel');
-    }
-    if (!response.success) {
-        throw new ModelLoadFailedError(response.error);
-    }
-    const modelId = response.modelId;
-    if (modelLogger) {
-        try {
-            startLoggingStreamForModel(modelId, modelLogger);
-        }
-        catch (error) {
-            logger.warn(`Failed to start logging stream for model ${modelId}:`, error);
-        }
-    }
-    return modelId;
-}