@qvac/sdk 0.18.2 → 0.19.0

package/dist/server/rpc/handlers/cancelHandler.js

@@ -1,69 +0,0 @@
-import { cancel as cancelByModelId } from '../../../server/bare/ops/cancel.js';
-import { getRequestRegistry } from '../../../server/bare/runtime/index.js';
-import { markClearCacheForRequest } from '../../../server/rpc/handlers/load-model/download-manager.js';
-import { getServerLogger } from '../../../logging/index.js';
-const logger = getServerLogger();
-/**
- * Cancel RPC entry point. The 5-arm `switch (request.operation)`
- * dispatcher that lived here through 0.10.x was retired in 0.11.0:
- * every long-running handler now registers itself on the
- * worker-singleton `RequestRegistry`, so the cancel surface narrows to
- * two paths that route through the same registry primitive:
- *
- *  - `{ operation: "request", requestId, clearCache? }` — targeted
- *    cancel by client-generated id. Looks up the registry entry,
- *    fires its abort signal, optionally marks the underlying download
- *    transfer for cache clear. The "stop-button race" case (client
- *    cancel beats its own begin to the worker) is handled inside the
- *    registry via the cancel-before-begin tripwire.
- *
- *  - `{ operation: "broad", modelId, kind? }` — abort every in-flight
- *    request on a model (optionally narrowed by `kind`). Used for
- *    model unload, app shutdown, and admin sweeps where the caller
- *    has no `requestId`. Delegates to the `cancel` bare op so the
- *    `ModelNotLoadedError` validation is shared with internal
- *    server-side broad cancels.
- *
- * Always returns `success: true` plus a `cancelled` count (the number
- * of contexts this call flipped to `cancelling` — already-cancelled
- * contexts are not counted). A targeted cancel with no in-flight
- * match still returns `success: true, cancelled: 0`; the
- * cancel-before-begin tripwire ensures the cancel is applied
- * retroactively if a matching begin arrives within the registry's
- * race window.
- */
-export function cancelHandler(request) {
-    try {
-        if (request.operation === 'request') {
-            if (request.clearCache) {
-                markClearCacheForRequest(request.requestId);
-            }
-            const cancelled = getRequestRegistry().cancel({
-                requestId: request.requestId
-            });
-            if (cancelled === 0) {
-                // info-level (not debug) because the decorated-promise pattern
-                // makes "no in-flight match" a common and user-visible case:
-                // a Stop button fired after the request settled but before
-                // the UI cleared lands here. The cancel-before-begin tripwire
-                // inside the registry already captured the cancel for any
-                // matching begin in flight; this log just helps operators
-                // debugging "my Stop button isn't working" without lowering
-                // the log level.
-                logger.info(`[cancel] no in-flight request matched requestId=${request.requestId}`);
-            }
-            return { type: 'cancel', success: true, cancelled };
-        }
-        // operation === "broad"
-        const cancelled = cancelByModelId({ modelId: request.modelId }, request.kind ? { kind: request.kind } : undefined);
-        return { type: 'cancel', success: true, cancelled };
-    }
-    catch (error) {
-        logger.error('Error during cancellation:', error);
-        return {
-            type: 'cancel',
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error'
-        };
-    }
-}

package/dist/server/rpc/handlers/classify.d.ts

@@ -1,3 +0,0 @@
-import type { ClassifyRequest, ClassifyResponse } from '../../../schemas/classification.js';
-export declare function handleClassify(request: ClassifyRequest): AsyncGenerator<ClassifyResponse>;
-//# sourceMappingURL=classify.d.ts.map

package/dist/server/rpc/handlers/classify.js

@@ -1,4 +0,0 @@
-import { dispatchPluginStream } from '../../../server/rpc/handlers/plugin-dispatch.js';
-export async function* handleClassify(request) {
-    yield* dispatchPluginStream(request.modelId, 'classify', request);
-}

package/dist/server/rpc/handlers/completion-orchestrate.d.ts

@@ -1,42 +0,0 @@
-import type { CompletionOrchestrateRequest, CompletionOrchestrateResponse, CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index.js';
-import { type ToolCallbackResult } from '../../../schemas/completion-stream.js';
-/**
- * Reads newline-delimited JSON tool results off the duplex request stream
- * and resolves per-callId waiters. Chunk boundaries don't align with lines,
- * so a partial tail is buffered until its newline arrives.
- *
- * The pump is torn down by `close()` (called from a `finally` when
- * orchestration ends, however it ends) so the upstream iterator is returned
- * and the reader stops holding the request stream open.
- */
-export declare class ToolResultReader {
-    private buffer;
-    private readonly results;
-    private readonly waiters;
-    private failed;
-    private closed;
-    private readonly iterator;
-    constructor(inputStream: AsyncIterable<Buffer>);
-    private pump;
-    private failWaiters;
-    private accept;
-    waitFor(callId: string, timeoutMs?: number): Promise<ToolCallbackResult>;
-    /**
-     * Stop the pump and release the upstream iterator. Idempotent. Pending
-     * waiters are failed so a caller blocked in `waitFor` can't hang after the
-     * stream is torn down.
-     */
-    close(): void;
-}
-type RunTurn = (request: CompletionStreamRequest) => AsyncGenerator<CompletionStreamResponse, void, unknown>;
-/**
- * The orchestration core, pure over its collaborators so it unit-tests
- * without the plugin registry: runs completion turns, forwards their events
- * downstream, and when a turn requests tool calls, emits `toolCallback`
- * frames and blocks on the client's results before starting the next turn
- * with the extended history.
- */
-export declare function orchestrateCompletion(request: CompletionOrchestrateRequest, runTurn: RunTurn, reader: Pick<ToolResultReader, 'waitFor'>): AsyncGenerator<CompletionOrchestrateResponse>;
-export declare function handleCompletionOrchestrate(request: CompletionOrchestrateRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<CompletionOrchestrateResponse>;
-export {};
-//# sourceMappingURL=completion-orchestrate.d.ts.map

package/dist/server/rpc/handlers/completion-orchestrate.js

@@ -1,190 +0,0 @@
-import { toolCallbackResultSchema } from '../../../schemas/completion-stream.js';
-import { aggregateEvents } from '../../../utils/aggregate-events.js';
-import { CompletionFailedError } from '../../../utils/errors-server.js';
-import { dispatchPluginStream } from '../../../server/rpc/handlers/plugin-dispatch.js';
-const DEFAULT_MAX_TOOL_TURNS = 8;
-// Generous ceiling on one client-side tool execution: long enough for a slow
-// MCP round trip, short enough that a client that stopped reading can't pin a
-// model slot forever.
-const TOOL_RESULT_TIMEOUT_MS = 5 * 60 * 1000;
-// A single tool result is small JSON; anything past this without a newline is a
-// malformed/hostile client trying to grow the buffer without bound. Fail loudly
-// instead of accumulating forever.
-const MAX_TOOL_RESULT_LINE_BYTES = 16 * 1024 * 1024;
-/**
- * Reads newline-delimited JSON tool results off the duplex request stream
- * and resolves per-callId waiters. Chunk boundaries don't align with lines,
- * so a partial tail is buffered until its newline arrives.
- *
- * The pump is torn down by `close()` (called from a `finally` when
- * orchestration ends, however it ends) so the upstream iterator is returned
- * and the reader stops holding the request stream open.
- */
-export class ToolResultReader {
-    buffer = '';
-    results = new Map();
-    waiters = new Map();
-    failed;
-    closed = false;
-    iterator;
-    constructor(inputStream) {
-        this.iterator = inputStream[Symbol.asyncIterator]();
-        void this.pump();
-    }
-    async pump() {
-        try {
-            while (!this.closed) {
-                const next = await this.iterator.next();
-                if (next.done)
-                    break;
-                this.buffer += next.value.toString();
-                let nl;
-                while ((nl = this.buffer.indexOf('\n')) !== -1) {
-                    const line = this.buffer.slice(0, nl);
-                    this.buffer = this.buffer.slice(nl + 1);
-                    if (line.trim())
-                        this.accept(line);
-                }
-                if (this.buffer.length > MAX_TOOL_RESULT_LINE_BYTES) {
-                    throw new CompletionFailedError('tool result frame exceeds the maximum size');
-                }
-            }
-            if (!this.closed && this.buffer.trim())
-                this.accept(this.buffer);
-        }
-        catch (error) {
-            this.failWaiters(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    failWaiters(error) {
-        this.failed = error;
-        // Wake every waiter; each rethrows via waitFor's failure check.
-        for (const [callId, resolve] of this.waiters) {
-            this.waiters.delete(callId);
-            resolve({ callId, error: error.message });
-        }
-    }
-    accept(line) {
-        const parsed = toolCallbackResultSchema.parse(JSON.parse(line));
-        const waiter = this.waiters.get(parsed.callId);
-        if (waiter) {
-            this.waiters.delete(parsed.callId);
-            waiter(parsed);
-        }
-        else {
-            this.results.set(parsed.callId, parsed);
-        }
-    }
-    async waitFor(callId, timeoutMs = TOOL_RESULT_TIMEOUT_MS) {
-        const buffered = this.results.get(callId);
-        if (buffered) {
-            this.results.delete(callId);
-            return buffered;
-        }
-        if (this.failed)
-            throw this.failed;
-        return await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.waiters.delete(callId);
-                reject(new CompletionFailedError(`tool callback ${callId} timed out`));
-            }, timeoutMs);
-            this.waiters.set(callId, (result) => {
-                clearTimeout(timer);
-                resolve(result);
-            });
-        });
-    }
-    /**
-     * Stop the pump and release the upstream iterator. Idempotent. Pending
-     * waiters are failed so a caller blocked in `waitFor` can't hang after the
-     * stream is torn down.
-     */
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        this.buffer = '';
-        this.results.clear();
-        if (!this.failed)
-            this.failWaiters(new CompletionFailedError('tool result stream closed'));
-        void this.iterator.return?.();
-    }
-}
-/**
- * The orchestration core, pure over its collaborators so it unit-tests
- * without the plugin registry: runs completion turns, forwards their events
- * downstream, and when a turn requests tool calls, emits `toolCallback`
- * frames and blocks on the client's results before starting the next turn
- * with the extended history.
- */
-export async function* orchestrateCompletion(request, runTurn, reader) {
-    // Pull the loop bound out of the per-turn base; everything else (including
-    // `requestId`) flows into each inner completionStream turn. Threading the
-    // orchestrate `requestId` down is what makes `cancel({ requestId })` reach
-    // the turn that's currently generating — the expensive part a Stop button
-    // targets. Turns run strictly sequentially: turn N's request-registry entry
-    // is disposed (on the `for await` break below) before turn N+1 calls
-    // `begin(...)`, so reusing the id can't collide in `entries`. A cancel that
-    // lands between turns (during a tool-result wait) is caught by the
-    // registry's cancel-before-begin tripwire and aborts the next turn's
-    // `begin(...)`. Each turn's `history` and `type` are set below.
-    const { maxToolTurns, ...turnBase } = request;
-    const maxTurns = maxToolTurns ?? DEFAULT_MAX_TOOL_TURNS;
-    let history = [...request.history];
-    for (let turn = 0; turn < maxTurns; turn++) {
-        const turnEvents = [];
-        const innerRequest = {
-            ...turnBase,
-            history,
-            type: 'completionStream'
-        };
-        for await (const response of runTurn(innerRequest)) {
-            turnEvents.push(...response.events);
-            yield { type: 'completionOrchestrate', turn, events: response.events };
-            if (response.done)
-                break;
-        }
-        const { toolCalls, rawFullText, contentText, error, cancelled } = aggregateEvents(turnEvents);
-        // Terminal turn: the model answered (or failed/was cancelled) without
-        // requesting tools — the client folds the forwarded events itself.
-        if (error || cancelled || toolCalls.length === 0) {
-            yield { type: 'completionOrchestrate', done: true };
-            return;
-        }
-        // The assistant's tool-call turn goes back verbatim so the model sees
-        // its own call syntax; each result follows as a `tool` message.
-        history = [...history, { role: 'assistant', content: rawFullText ?? contentText }];
-        for (const call of toolCalls) {
-            yield {
-                type: 'completionOrchestrate',
-                turn,
-                toolCallback: { callId: call.id, name: call.name, arguments: call.arguments }
-            };
-            const result = await reader.waitFor(call.id);
-            const content = result.error !== undefined
-                ? JSON.stringify({ error: result.error })
-                : JSON.stringify(result.result ?? null);
-            history = [...history, { role: 'tool', content }];
-        }
-    }
-    // Turn cap reached without a natural end. Emit a terminal done frame with a
-    // stopReason so the client can tell this was truncated (the model still
-    // wanted a tool) rather than a natural finish; the last turn's events carry
-    // whatever the model produced.
-    yield { type: 'completionOrchestrate', done: true, stopReason: 'maxToolTurns' };
-}
-export async function* handleCompletionOrchestrate(request, inputStream) {
-    const reader = new ToolResultReader(inputStream);
-    const runTurn = async function* (innerRequest) {
-        yield* dispatchPluginStream(innerRequest.modelId, 'completionStream', innerRequest);
-    };
-    try {
-        yield* orchestrateCompletion(request, runTurn, reader);
-    }
-    finally {
-        // Tear the reader down however orchestration ends -- natural finish, turn
-        // cap, error, or the client abandoning the stream -- so the pump stops and
-        // the request stream isn't held open.
-        reader.close();
-    }
-}

package/dist/server/rpc/handlers/completion-stream-delegated.d.ts

@@ -1,5 +0,0 @@
-import type { CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index.js';
-import type { DelegatedHandlerOptions } from '../../../server/rpc/profiling/index.js';
-export type HandleCompletionStreamDelegatedOptions = DelegatedHandlerOptions;
-export declare function handleCompletionStreamDelegated(request: CompletionStreamRequest, options?: HandleCompletionStreamDelegatedOptions): AsyncGenerator<CompletionStreamResponse>;
-//# sourceMappingURL=completion-stream-delegated.d.ts.map

package/dist/server/rpc/handlers/completion-stream-delegated.js

@@ -1,51 +0,0 @@
-import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
-import { getRPC } from '../../../server/bare/delegate-rpc-client.js';
-import { stream } from '../../../server/rpc/delegate-transport.js';
-import { ModelIsDelegatedError } from '../../../utils/errors-server.js';
-import { getServerLogger } from '../../../logging/index.js';
-const logger = getServerLogger();
-export async function* handleCompletionStreamDelegated(request, options) {
-    const { profilingMeta } = options ?? {};
-    // Get delegation info from model registry
-    const entry = getModelEntry(request.modelId);
-    if (!entry?.isDelegated) {
-        throw new ModelIsDelegatedError(request.modelId);
-    }
-    const { providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
-    try {
-        logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ''}`);
-        const rpc = await getRPC(providerPublicKey, { timeout, healthCheckTimeout });
-        // Build delegate options with profiling metadata
-        const delegateOpts = { peerKey: providerPublicKey };
-        if (profilingMeta) {
-            delegateOpts.profilingMeta = profilingMeta;
-        }
-        if (timeout) {
-            delegateOpts.timeout = timeout;
-        }
-        // Use the regular stream function with the HyperSwarm RPC instance
-        const responseStream = stream(request, rpc, delegateOpts);
-        // Yield each response from the stream
-        for await (const response of responseStream) {
-            yield response;
-        }
-    }
-    catch (error) {
-        logger.error('Error in delegated completion stream:', error);
-        const message = error instanceof Error ? error.message : String(error);
-        yield {
-            type: 'completionStream',
-            done: true,
-            events: [
-                {
-                    type: 'completionDone',
-                    seq: 0,
-                    stopReason: 'error',
-                    error: {
-                        message: `Error communicating with provider: ${message}`
-                    }
-                }
-            ]
-        };
-    }
-}

package/dist/server/rpc/handlers/completion-stream.d.ts

@@ -1,3 +0,0 @@
-import type { CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index.js';
-export declare function handleCompletionStream(request: CompletionStreamRequest): AsyncGenerator<CompletionStreamResponse>;
-//# sourceMappingURL=completion-stream.d.ts.map

package/dist/server/rpc/handlers/completion-stream.js

@@ -1,4 +0,0 @@
-import { dispatchPluginStream } from '../../../server/rpc/handlers/plugin-dispatch.js';
-export async function* handleCompletionStream(request) {
-    yield* dispatchPluginStream(request.modelId, 'completionStream', request);
-}

package/dist/server/rpc/handlers/delete-cache.d.ts

@@ -1,12 +0,0 @@
-import type { DeleteCacheRequest, DeleteCacheResponse } from '../../../schemas/index.js';
-/**
- * RPC handler for `deleteCache(...)`. The three KV-cache bookkeeping
- * layers (on-disk `.bin`, `initializedCaches`, `cachedMessageCounts`)
- * are private to `kv-cache-session.ts`; this handler delegates to that
- * module's single administrative entry point (`deleteKvCacheState`).
- * The handler must have **zero** direct references to
- * `fsPromises.unlink`, the `initializedCaches` set, or the
- * `cachedMessageCounts` map.
- */
-export declare function handleDeleteCache(request: DeleteCacheRequest): Promise<DeleteCacheResponse>;
-//# sourceMappingURL=delete-cache.d.ts.map

package/dist/server/rpc/handlers/delete-cache.js

@@ -1,37 +0,0 @@
-import { deleteKvCacheState } from '../../../server/bare/plugins/llamacpp-completion/ops/kv-cache-session.js';
-import { getServerLogger } from '../../../logging/index.js';
-const logger = getServerLogger();
-/**
- * RPC handler for `deleteCache(...)`. The three KV-cache bookkeeping
- * layers (on-disk `.bin`, `initializedCaches`, `cachedMessageCounts`)
- * are private to `kv-cache-session.ts`; this handler delegates to that
- * module's single administrative entry point (`deleteKvCacheState`).
- * The handler must have **zero** direct references to
- * `fsPromises.unlink`, the `initializedCaches` set, or the
- * `cachedMessageCounts` map.
- */
-export async function handleDeleteCache(request) {
-    try {
-        if ('all' in request && request.all) {
-            await deleteKvCacheState({ all: true });
-        }
-        else if ('kvCacheKey' in request) {
-            await deleteKvCacheState({
-                kvCacheKey: request.kvCacheKey,
-                ...(request.modelId !== undefined && { modelId: request.modelId })
-            });
-        }
-        return {
-            type: 'deleteCache',
-            success: true
-        };
-    }
-    catch (error) {
-        logger.error('Error deleting cache:', error);
-        return {
-            type: 'deleteCache',
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error'
-        };
-    }
-}

package/dist/server/rpc/handlers/diffusion-stream.d.ts

@@ -1,3 +0,0 @@
-import type { DiffusionStreamRequest, DiffusionStreamResponse } from '../../../schemas/sdcpp-config.js';
-export declare function handleDiffusionStream(request: DiffusionStreamRequest): AsyncGenerator<DiffusionStreamResponse>;
-//# sourceMappingURL=diffusion-stream.d.ts.map

package/dist/server/rpc/handlers/diffusion-stream.js

@@ -1,4 +0,0 @@
-import { dispatchPluginStream } from '../../../server/rpc/handlers/plugin-dispatch.js';
-export async function* handleDiffusionStream(request) {
-    yield* dispatchPluginStream(request.modelId, 'diffusionStream', request);
-}

package/dist/server/rpc/handlers/download-asset.d.ts

@@ -1,3 +0,0 @@
-import type { DownloadAssetRequest, DownloadAssetResponse, ModelProgressUpdate } from '../../../schemas/index.js';
-export declare function handleDownloadAsset(request: DownloadAssetRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<DownloadAssetResponse>;
-//# sourceMappingURL=download-asset.d.ts.map

package/dist/server/rpc/handlers/download-asset.js

@@ -1,146 +0,0 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-import { PROFILING_KEY, OPERATION_EVENT_KEY } from '../../../schemas/index.js';
-import { resolveModelPath, resolveModelPathWithStats } from '../../../server/rpc/handlers/load-model/resolve.js';
-import { buildDownloadProfilingFields } from '../../../server/rpc/handlers/load-model/types.js';
-import { nowMs, generateProfileId } from '../../../profiling/clock.js';
-import { getServerLogger } from '../../../logging/index.js';
-import { getRequestRegistry, withRequestContext } from '../../../server/bare/runtime/index.js';
-import { generateServerRequestId } from '../../../server/bare/runtime/request-id.js';
-import { InferenceCancelledError } from '../../../utils/errors-server.js';
-const logger = getServerLogger();
-export async function handleDownloadAsset(request, progressCallback) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const { assetSrc, seed } = request;
-        const profilingMeta = request[PROFILING_KEY];
-        const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
-        const requestId = request.requestId ?? generateServerRequestId();
-        // `downloadAsset` is artifact-shaped, not model-shaped — there is no
-        // `modelId` to register on the registry entry. Cancel by `requestId`
-        // is the primary path; `cancel({ modelId })` is intentionally a
-        // non-match for this kind.
-        const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
-            requestId,
-            kind: 'downloadAsset'
-        }), true);
-        const log = withRequestContext(getServerLogger(), ctx);
-        log.debug(`downloadAsset start assetSrc=${assetSrc}`);
-        const hooks = {
-            requestBinding: {
-                signal: ctx.signal,
-                scope: ctx.scope,
-                requestId
-            }
-        };
-        try {
-            const totalDownloadStart = profilingEnabled ? nowMs() : 0;
-            let sourceType;
-            let downloadStats;
-            if (profilingEnabled) {
-                const result = await resolveModelPathWithStats(assetSrc, progressCallback, seed, ctx.signal, hooks);
-                sourceType = result.sourceType;
-                downloadStats = result.downloadStats;
-            }
-            else {
-                await resolveModelPath(assetSrc, progressCallback, seed, ctx.signal, hooks);
-            }
-            const response = {
-                type: 'downloadAsset',
-                success: true,
-                assetId: assetSrc
-            };
-            if (profilingEnabled) {
-                const totalDownloadTimeMs = nowMs() - totalDownloadStart;
-                const profileId = profilingMeta?.id ?? generateProfileId();
-                const { gauges, tags } = buildDownloadProfilingFields(downloadStats, sourceType);
-                gauges['totalDownloadTime'] = totalDownloadTimeMs;
-                const operationEvent = {
-                    op: 'downloadAsset',
-                    kind: 'handler',
-                    ms: totalDownloadTimeMs,
-                    profileId,
-                    gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
-                    tags: Object.keys(tags).length > 0 ? tags : undefined
-                };
-                response[OPERATION_EVENT_KEY] = operationEvent;
-            }
-            return response;
-        }
-        catch (error) {
-            // Mirror the load-model handler's cancel contract: a typed cancel
-            // bubbles up as the rejection so client-side callers can branch on
-            // `instanceof InferenceCancelledError`. Every other error keeps
-            // the legacy `success: false` envelope.
-            if (error instanceof InferenceCancelledError) {
-                log.info(`downloadAsset cancelled requestId=${requestId}`);
-                throw error;
-            }
-            logger.error('Error downloading asset:', error);
-            return {
-                type: 'downloadAsset',
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error'
-            };
-        }
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            await result_1;
-    }
-}

package/dist/server/rpc/handlers/embed.d.ts

@@ -1,3 +0,0 @@
-import type { EmbedRequest, EmbedResponse } from '../../../schemas/index.js';
-export declare function handleEmbed(request: EmbedRequest): Promise<EmbedResponse>;
-//# sourceMappingURL=embed.d.ts.map

package/dist/server/rpc/handlers/embed.js

@@ -1,4 +0,0 @@
-import { dispatchPluginReply } from '../../../server/rpc/handlers/plugin-dispatch.js';
-export async function handleEmbed(request) {
-    return dispatchPluginReply(request.modelId, 'embed', request);
-}

package/dist/server/rpc/handlers/finetune.d.ts

@@ -1,3 +0,0 @@
-import type { FinetuneProgressResponse, FinetuneRequest, FinetuneResult } from '../../../schemas/index.js';
-export declare function handleFinetune(request: FinetuneRequest, progressCallback?: (update: FinetuneProgressResponse) => void): Promise<FinetuneResult>;
-//# sourceMappingURL=finetune.d.ts.map

package/dist/server/rpc/handlers/finetune.js

@@ -1,18 +0,0 @@
-import { dispatchPluginReply } from '../../../server/rpc/handlers/plugin-dispatch.js';
-import { startFinetune } from '../../../server/bare/plugins/llamacpp-completion/ops/finetune.js';
-export async function handleFinetune(request, progressCallback) {
-    if (progressCallback &&
-        (request.operation === 'start' ||
-            request.operation === 'resume' ||
-            request.operation === undefined)) {
-        return startFinetune(request, (progress) => {
-            const update = {
-                type: 'finetune:progress',
-                modelId: request.modelId,
-                ...progress
-            };
-            progressCallback(update);
-        });
-    }
-    return dispatchPluginReply(request.modelId, 'finetune', request);
-}

package/dist/server/rpc/handlers/get-loaded-model-info.d.ts

@@ -1,3 +0,0 @@
-import type { GetLoadedModelInfoRequest, GetLoadedModelInfoResponse } from '../../../schemas/index.js';
-export declare function handleGetLoadedModelInfo(request: GetLoadedModelInfoRequest): GetLoadedModelInfoResponse;
-//# sourceMappingURL=get-loaded-model-info.d.ts.map