@qvac/sdk 0.18.2 → 0.19.0

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

@@ -0,0 +1,49 @@
+import { send } from '../rpc/rpc-client.js';
+import { InvalidDeleteCacheParamsError, DeleteCacheFailedError } from '../../utils/errors-client.js';
+/**
+ * Deletes KV cache files.
+ *
+ * @param params - The delete cache parameters
+ * @param params.all - If true, deletes all cache files
+ * @param params.kvCacheKey - The cache key to delete
+ * @param params.modelId - Optional: specific model ID to delete within the cache key. If not provided, deletes entire cache key.
+ * @returns Promise resolving to success status
+ * @throws {QvacErrorBase} When the cache parameters are invalid (`InvalidDeleteCacheParamsError`) or the server reports a delete failure (`DeleteCacheFailedError`).
+ * @example
+ * ```typescript
+ * // Delete all caches
+ * await deleteCache({ all: true });
+ *
+ * // Delete entire cache key (all models)
+ * await deleteCache({ kvCacheKey: "my-session" });
+ *
+ * // Delete only specific model within cache key
+ * await deleteCache({ kvCacheKey: "my-session", modelId: "model-abc123" });
+ * ```
+ */
+export async function deleteCache(params) {
+    let req;
+    if ('all' in params && params.all) {
+        req = {
+            type: 'deleteCache',
+            all: true
+        };
+    }
+    else if ('kvCacheKey' in params) {
+        req = {
+            type: 'deleteCache',
+            kvCacheKey: params.kvCacheKey,
+            modelId: params.modelId
+        };
+    }
+    else {
+        throw new InvalidDeleteCacheParamsError();
+    }
+    const response = (await send(req));
+    if (!response.success && response.error) {
+        throw new DeleteCacheFailedError(response.error);
+    }
+    return {
+        success: response.success
+    };
+}

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

@@ -0,0 +1,93 @@
+import { type DiffusionClientParams, type DiffusionStats } from '@qvac/inference/surface';
+export interface DiffusionProgressTick {
+    step: number;
+    totalSteps: number;
+    elapsedMs: number;
+}
+interface DiffusionResult {
+    progressStream: AsyncGenerator<DiffusionProgressTick>;
+    outputs: Promise<Uint8Array[]>;
+    stats: Promise<DiffusionStats | undefined>;
+}
+/**
+ * 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 declare function diffusion(params: DiffusionClientParams): DiffusionResult;
+export {};
+//# sourceMappingURL=diffusion.d.ts.map

package/dist/src/client/api/diffusion.js

@@ -0,0 +1,177 @@
+import { diffusionStreamResponseSchema } from '@qvac/inference/surface';
+import { stream as streamRpc } from '../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 !== undefined &&
+                        parsed.totalSteps !== undefined &&
+                        parsed.elapsedMs !== undefined) {
+                        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/src/client/api/download-asset.d.ts

@@ -0,0 +1,52 @@
+import { type DownloadAssetOptions as BaseDownloadAssetOptions, type RPCOptions } from '@qvac/inference/surface';
+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.
+ * 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
+ *   - requireHttpChecksum: Per-call override — reject a Hugging Face HTTP download that exposes no usable SHA-256 instead of downloading it unverified. Defaults to the engine config (false).
+ *   - requireSecureTransport: Per-call override — reject plaintext http:// and HTTPS→HTTP downgrades for every HTTP source (loopback exempt); when unset, only Hugging Face transport is hardened. Defaults to the engine config (false).
+ *   - 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/src/client/api/download-asset.js

@@ -0,0 +1,89 @@
+import { send, stream } from '../rpc/rpc-client.js';
+import { downloadAssetOptionsToRequestSchema } from '@qvac/inference/surface';
+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.
+ *
+ * This function is specifically designed for download-only operations and
+ * doesn't accept runtime configuration options like modelConfig.
+ * 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
+ *   - requireHttpChecksum: Per-call override — reject a Hugging Face HTTP download that exposes no usable SHA-256 instead of downloading it unverified. Defaults to the engine config (false).
+ *   - requireSecureTransport: Per-call override — reject plaintext http:// and HTTPS→HTTP downgrades for every HTTP source (loopback exempt); when unset, only Hugging Face transport is hardened. Defaults to the engine config (false).
+ *   - 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/src/client/api/embed.d.ts

@@ -0,0 +1,42 @@
+import { type EmbedStats, type RPCOptions } from '@qvac/inference/surface';
+/**
+ * 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/src/client/api/embed.js

@@ -0,0 +1,30 @@
+import { send } from '../rpc/rpc-client.js';
+import {} from '@qvac/inference/surface';
+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
+    // `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/src/client/api/finetune.d.ts

@@ -0,0 +1,92 @@
+import { type FinetuneGetStateParams, type FinetuneProgress, type FinetuneResult, type FinetuneRunParams, type FinetuneStopParams, type RPCOptions } from '@qvac/inference/surface';
+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