@qvac/sdk 0.18.2 → 0.19.0

package/dist/client/api/diffusion.js

@@ -1,175 +0,0 @@
-import { diffusionStreamResponseSchema } from '../../schemas/index.js';
-import { stream as streamRpc } from '../../client/rpc/rpc-client.js';
-import { decodeBase64, encodeBase64 } from '../../utils/encoding.js';
-/**
- * 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
- * // 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 });
- *
- * // FLUX.2 multi-reference fusion
- * // IMPORTANT: requires the model loaded with `modelConfig: { prediction: "flux2_flow" }`
- * // and a Qwen3 text encoder via `llmModelSrc` (same loadModel requirements as the
- * // FLUX.2 img2img example above). `init_image` and `init_images` are mutually
- * // exclusive — pass one or the other, not both.
- * const refA = fs.readFileSync("scientist-a.jpg");
- * const refB = fs.readFileSync("scientist-b.jpg");
- * const { outputs } = diffusion({
- *   modelId,
- *   prompt: "a portrait using most visual traits from @image1 and the eyes from @image2",
- *   init_images: [refA, refB],
- *   width: 768,
- *   height: 768,
- * });
- *
- * // LoRA adapter for this generation (absolute path required).
- * // Persistence across subsequent diffusion() calls is controlled at
- * // loadModel time via `modelConfig.lora_apply_mode`.
- * const { outputs } = diffusion({
- *   modelId,
- *   prompt: "a watercolor cat",
- *   lora: "/home/user/loras/watercolor.safetensors",
- * });
- *
- * // ESRGAN upscale; requires the model to be loaded with `modelConfig.upscaler.model_src` set.
- * const { outputs: singleOutputs } = diffusion({
- *   modelId,
- *   prompt: "a fox portrait",
- *   width: 128,
- *   height: 128,
- *   upscale: true, // one native-scale pass
- * });
- * const single = await singleOutputs;
- * fs.writeFileSync("upscaled.png", single[0]);
- *
- * // Repeat upscale passes when needed.
- * const { outputs: hiresOutputs } = diffusion({
- *   modelId,
- *   prompt: "a fox portrait",
- *   width: 128,
- *   height: 128,
- *   upscale: { repeats: 2 },
- * });
- * const hires = await hiresOutputs;
- * fs.writeFileSync("hires.png", hires[0]);
- *
- * // With progress tracking
- * const { progressStream, outputs } = diffusion({ modelId, prompt: "a cat" });
- * for await (const { step, totalSteps } of progressStream) {
- *   console.log(`${step}/${totalSteps}`);
- * }
- * const buffers = await outputs;
- * ```
- */
-export function diffusion(params) {
-    const { init_image, init_images, ...rest } = params;
-    const request = {
-        ...rest,
-        ...(init_image !== undefined && { init_image: encodeBase64(init_image) }),
-        ...(init_images !== undefined && {
-            init_images: init_images.map(encodeBase64)
-        }),
-        type: 'diffusionStream'
-    };
-    let statsResolver = () => { };
-    let statsRejecter = () => { };
-    const statsPromise = new Promise((resolve, reject) => {
-        statsResolver = resolve;
-        statsRejecter = reject;
-    });
-    statsPromise.catch(() => { });
-    const progressQueue = [];
-    const collectedBuffers = [];
-    let progressDone = false;
-    let progressResolve = null;
-    let streamError = null;
-    let outputsResolver = () => { };
-    let outputsRejecter = () => { };
-    const outputsPromise = new Promise((resolve, reject) => {
-        outputsResolver = resolve;
-        outputsRejecter = reject;
-    });
-    outputsPromise.catch(() => { });
-    const processResponses = async () => {
-        try {
-            for await (const response of streamRpc(request)) {
-                if (response &&
-                    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
-                        });
-                        if (progressResolve) {
-                            progressResolve();
-                            progressResolve = null;
-                        }
-                    }
-                    if (parsed.data) {
-                        collectedBuffers.push(decodeBase64(parsed.data));
-                    }
-                    if (parsed.done) {
-                        statsResolver(parsed.stats);
-                        outputsResolver(collectedBuffers);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            streamError = error instanceof Error ? error : new Error(String(error));
-            statsRejecter(streamError);
-            outputsRejecter(streamError);
-        }
-        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)
-                    throw streamError;
-                return;
-            }
-            else {
-                await new Promise((resolve) => {
-                    progressResolve = resolve;
-                });
-            }
-        }
-    })();
-    return {
-        progressStream,
-        outputs: outputsPromise,
-        stats: statsPromise
-    };
-}

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

@@ -1,50 +0,0 @@
-import { type DownloadAssetOptions as BaseDownloadAssetOptions, type RPCOptions } from '../../schemas/index.js';
-export type DownloadAssetOptions = BaseDownloadAssetOptions;
-/**
- * Downloads an asset (model file) without loading it into memory.
- *
- * This function is specifically designed for download-only operations and
- * doesn't accept runtime configuration options like modelConfig or delegate.
- * Use this for download-only operations instead of loadModel for better semantic clarity.
- *
- * @param options - Download configuration including:
- *   - assetSrc: The location from which the asset is downloaded (local path, remote URL, or Hyperdrive URL)
- *   - seed: Optional boolean for hyperdrive seeding
- *   - onProgress: Optional callback for download progress
- * @param rpcOptions - Optional RPC options including per-call profiling configuration
- *
- * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID),
- *   decorated with a synchronous `requestId` field for use with
- *   `cancel({ requestId: op.requestId })` before the promise resolves.
- *
- * @throws {QvacErrorBase} When asset download 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
- * // Download model without loading
- * const assetId = await downloadAsset({
- *   assetSrc: "/path/to/model.gguf",
- *   seed: true
- * });
- *
- * // Download with progress tracking
- * const assetId = await downloadAsset({
- *   assetSrc: "pear://key123/model.gguf",
- *   onProgress: (progress) => {
- *     console.log(`Downloaded: ${progress.percentage}%`);
- *   }
- * });
- *
- * // Targeted cancel by requestId — grab the id synchronously, then
- * // cancel before the download resolves.
- * const op = downloadAsset({ assetSrc: "https://example.com/large.gguf" });
- * setTimeout(() => cancel({ requestId: op.requestId }), 1000);
- * await op; // rejects with `InferenceCancelledError`
- * ```
- */
-export declare function downloadAsset(options: DownloadAssetOptions, rpcOptions?: RPCOptions): Promise<string> & {
-    requestId: string;
-};
-//# sourceMappingURL=download-asset.d.ts.map

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

@@ -1,87 +0,0 @@
-import { send, stream } from '../../client/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 '../../client/parse-input.js';
-import { generateClientRequestId } from '../../client/api/client-request-id.js';
-/**
- * Downloads an asset (model file) without loading it into memory.
- *
- * This function is specifically designed for download-only operations and
- * doesn't accept runtime configuration options like modelConfig or delegate.
- * Use this for download-only operations instead of loadModel for better semantic clarity.
- *
- * @param options - Download configuration including:
- *   - assetSrc: The location from which the asset is downloaded (local path, remote URL, or Hyperdrive URL)
- *   - seed: Optional boolean for hyperdrive seeding
- *   - onProgress: Optional callback for download progress
- * @param rpcOptions - Optional RPC options including per-call profiling configuration
- *
- * @returns Promise that resolves to the asset ID (either the provided assetSrc or a generated ID),
- *   decorated with a synchronous `requestId` field for use with
- *   `cancel({ requestId: op.requestId })` before the promise resolves.
- *
- * @throws {QvacErrorBase} When asset download 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
- * // Download model without loading
- * const assetId = await downloadAsset({
- *   assetSrc: "/path/to/model.gguf",
- *   seed: true
- * });
- *
- * // Download with progress tracking
- * const assetId = await downloadAsset({
- *   assetSrc: "pear://key123/model.gguf",
- *   onProgress: (progress) => {
- *     console.log(`Downloaded: ${progress.percentage}%`);
- *   }
- * });
- *
- * // Targeted cancel by requestId — grab the id synchronously, then
- * // cancel before the download resolves.
- * const op = downloadAsset({ assetSrc: "https://example.com/large.gguf" });
- * setTimeout(() => cancel({ requestId: op.requestId }), 1000);
- * await op; // rejects with `InferenceCancelledError`
- * ```
- */
-export function downloadAsset(options, rpcOptions) {
-    const requestId = generateClientRequestId();
-    const inner = runDownloadAsset(options, requestId, rpcOptions);
-    return decoratePromise(inner, { requestId });
-}
-async function runDownloadAsset(options, requestId, rpcOptions) {
-    const request = parseClientInput(downloadAssetOptionsToRequestSchema, {
-        ...options,
-        requestId
-    });
-    if (options.onProgress) {
-        // Use streaming for progress updates
-        for await (const response of stream(request, rpcOptions)) {
-            if (response.type === 'modelProgress') {
-                options.onProgress(response);
-            }
-            else if (response.type === 'downloadAsset') {
-                if (!response.success) {
-                    throw new DownloadAssetFailedError(response.error);
-                }
-                return response.assetId;
-            }
-        }
-        throw new StreamEndedError();
-    }
-    else {
-        // Use regular send for simple downloading
-        const response = await send(request, rpcOptions);
-        if (response.type !== 'downloadAsset') {
-            throw new InvalidResponseError('downloadAsset');
-        }
-        if (!response.success) {
-            throw new DownloadAssetFailedError(response.error);
-        }
-        return response.assetId;
-    }
-}

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

@@ -1,42 +0,0 @@
-import { type EmbedStats, type RPCOptions } from '../../schemas/index.js';
-/**
- * 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 (decorated with `requestId`) 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: {
-    modelId: string;
-    text: string;
-}, options?: RPCOptions): Promise<{
-    embedding: number[];
-    stats?: EmbedStats;
-}> & {
-    requestId: string;
-};
-/**
- * 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 (decorated with `requestId`) 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: {
-    modelId: string;
-    text: string[];
-}, options?: RPCOptions): Promise<{
-    embedding: number[][];
-    stats?: EmbedStats;
-}> & {
-    requestId: string;
-};
-//# sourceMappingURL=embed.d.ts.map

package/dist/client/api/embed.js

@@ -1,30 +0,0 @@
-import { send } from '../../client/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/api/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
-    // `await` resolves. The same id is threaded onto the wire envelope so
-    // the server's registry entry uses it as the canonical key —
-    // matching the `loadModel` / `downloadAsset` / `completion` shape.
-    const requestId = generateClientRequestId();
-    const inner = runEmbed(params, requestId, options);
-    return decoratePromise(inner, { requestId });
-}
-async function runEmbed(params, requestId, options) {
-    const request = {
-        type: 'embed',
-        ...params,
-        requestId
-    };
-    const response = await send(request, options);
-    if (response.type !== 'embed') {
-        throw new InvalidResponseError('embed');
-    }
-    return {
-        embedding: response.embedding,
-        ...(response.stats !== undefined && { stats: response.stats })
-    };
-}

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

@@ -1,92 +0,0 @@
-import { type FinetuneGetStateParams, type FinetuneProgress, type FinetuneResult, type FinetuneRunParams, type FinetuneStopParams, type RPCOptions } from '../../schemas/index.js';
-export interface FinetuneHandle {
-    progressStream: AsyncGenerator<FinetuneProgress>;
-    result: Promise<FinetuneResult>;
-    /** Stable id for this run; pass to `cancel({ requestId })` to stop it. */
-    requestId: string;
-}
-type FinetuneReplyParams = FinetuneStopParams | FinetuneGetStateParams;
-/**
- * Starts, resumes, inspects, pauses, or cancels a finetuning job for a loaded model.
- *
- * @param params - The finetuning parameters
- * @param params.modelId - The identifier of the loaded model to finetune
- * @param params.operation - The finetuning operation. Omit it to let the add-on
- *   choose whether to start fresh or resume automatically
- * @param params.options - Finetuning options for run and `getState` operations
- * @param params.options.trainDatasetDir - Directory containing the training dataset
- * @param params.options.validation - Validation configuration for the finetuning run
- * @param params.options.outputParametersDir - Directory where output adapter parameters are written
- * @param params.options.numberOfEpochs - Optional number of epochs to run
- * @param params.options.learningRate - Optional learning rate override
- * @param params.options.contextLength - Optional context length override
- * @param params.options.batchSize - Optional batch size override
- * @param params.options.microBatchSize - Optional micro batch size override
- * @param params.options.assistantLossOnly - Optional flag to compute loss only on assistant tokens
- * @param params.options.loraRank - Optional LoRA rank override
- * @param params.options.loraAlpha - Optional LoRA alpha override
- * @param params.options.loraInitStd - Optional LoRA initialization standard deviation
- * @param params.options.loraSeed - Optional LoRA initialization seed
- * @param params.options.loraModules - Optional comma-separated LoRA module selection
- * @param params.options.checkpointSaveDir - Optional directory for checkpoint snapshots
- * @param params.options.checkpointSaveSteps - Optional checkpoint save interval
- * @param params.options.chatTemplatePath - Optional custom chat template path
- * @param params.options.lrScheduler - Optional learning rate scheduler
- * @param params.options.lrMin - Optional minimum learning rate
- * @param params.options.warmupRatio - Optional warmup ratio
- * @param params.options.warmupRatioSet - Optional flag to enable warmup ratio
- * @param params.options.warmupSteps - Optional warmup step count
- * @param params.options.warmupStepsSet - Optional flag to enable explicit warmup steps
- * @param params.options.weightDecay - Optional weight decay override
- * @param rpcOptions - Optional RPC transport options
- * @returns For omitted-operation runs, `start`, and `resume`, returns a handle
- *   with a `progressStream` generator and a terminal `result` promise. For
- *   `getState`, `pause`, and `cancel`, returns a promise that resolves to the
- *   current finetune state/result.
- * @example
- * ```typescript
- * const handle = finetune({
- *   modelId,
- *   options: {
- *     trainDatasetDir: "./dataset/train",
- *     validation: { type: "split", fraction: 0.05 },
- *     outputParametersDir: "./artifacts/lora",
- *     numberOfEpochs: 2,
- *   },
- * });
- *
- * for await (const progress of handle.progressStream) {
- *   console.log(progress.global_steps, progress.loss);
- * }
- *
- * console.log(await handle.result);
- *
- * const pauseResult = await finetune({ modelId, operation: "pause" });
- * 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/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