@qvac/sdk 0.14.1 → 0.16.0

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

@@ -0,0 +1,190 @@
+import { toolCallbackResultSchema } from '../../../schemas/completion-stream.js';
+import { aggregateEvents } from '../../../utils/aggregate-events.js';
+import { CompletionFailedError } from '../../../utils/errors-server.js';
+import { dispatchPluginStream } from './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 +1,5 @@
-import type { CompletionStreamRequest, CompletionStreamResponse } from "../../../schemas/index";
-import type { DelegatedHandlerOptions } from "../profiling/index";
+import type { CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index';
+import type { DelegatedHandlerOptions } from '../profiling/index';
 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,8 +1,8 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { stream } from "../delegate-transport.js";
-import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getRPC } from '../../bare/delegate-rpc-client.js';
+import { stream } from '../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 ?? {};
@@ -13,7 +13,7 @@ export async function* handleCompletionStreamDelegated(request, options) {
     }
     const { providerPublicKey, timeout, healthCheckTimeout } = entry.delegated;
     try {
-        logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        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 };
@@ -31,21 +31,21 @@ export async function* handleCompletionStreamDelegated(request, options) {
         }
     }
     catch (error) {
-        logger.error("Error in delegated completion stream:", error);
+        logger.error('Error in delegated completion stream:', error);
         const message = error instanceof Error ? error.message : String(error);
         yield {
-            type: "completionStream",
+            type: 'completionStream',
             done: true,
             events: [
                 {
-                    type: "completionDone",
+                    type: 'completionDone',
                     seq: 0,
-                    stopReason: "error",
+                    stopReason: 'error',
                     error: {
-                        message: `Error communicating with provider: ${message}`,
-                    },
-                },
-            ],
+                        message: `Error communicating with provider: ${message}`
+                    }
+                }
+            ]
         };
     }
 }

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

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

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

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

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

@@ -1,4 +1,4 @@
-import type { DeleteCacheRequest, DeleteCacheResponse } from "../../../schemas/index";
+import type { DeleteCacheRequest, DeleteCacheResponse } from '../../../schemas/index';
 /**
  * RPC handler for `deleteCache(...)`. The three KV-cache bookkeeping
  * layers (on-disk `.bin`, `initializedCaches`, `cachedMessageCounts`)

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

@@ -1,5 +1,5 @@
-import { deleteKvCacheState } from "../../bare/plugins/llamacpp-completion/ops/kv-cache-session.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { deleteKvCacheState } from '../../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
@@ -12,26 +12,26 @@ const logger = getServerLogger();
  */
 export async function handleDeleteCache(request) {
     try {
-        if ("all" in request && request.all) {
+        if ('all' in request && request.all) {
             await deleteKvCacheState({ all: true });
         }
-        else if ("kvCacheKey" in request) {
+        else if ('kvCacheKey' in request) {
             await deleteKvCacheState({
                 kvCacheKey: request.kvCacheKey,
-                ...(request.modelId !== undefined && { modelId: request.modelId }),
+                ...(request.modelId !== undefined && { modelId: request.modelId })
             });
         }
         return {
-            type: "deleteCache",
-            success: true,
+            type: 'deleteCache',
+            success: true
         };
     }
     catch (error) {
-        logger.error("Error deleting cache:", error);
+        logger.error('Error deleting cache:', error);
         return {
-            type: "deleteCache",
+            type: 'deleteCache',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

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

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

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

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

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

@@ -1,3 +1,3 @@
-import type { DownloadAssetRequest, DownloadAssetResponse, ModelProgressUpdate } from "../../../schemas/index";
+import type { DownloadAssetRequest, DownloadAssetResponse, ModelProgressUpdate } from '../../../schemas/index';
 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

@@ -50,14 +50,14 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     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 "./load-model/resolve.js";
-import { buildDownloadProfilingFields, } from "./load-model/types.js";
-import { nowMs, generateProfileId } from "../../../profiling/clock.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { getRequestRegistry, withRequestContext, } from "../../bare/runtime/index.js";
-import { generateServerRequestId } from "../../bare/runtime/request-id.js";
-import { InferenceCancelledError } from "../../../utils/errors-server.js";
+import { PROFILING_KEY, OPERATION_EVENT_KEY } from '../../../schemas/index.js';
+import { resolveModelPath, resolveModelPathWithStats } from './load-model/resolve.js';
+import { buildDownloadProfilingFields } from './load-model/types.js';
+import { nowMs, generateProfileId } from '../../../profiling/clock.js';
+import { getServerLogger } from '../../../logging/index.js';
+import { getRequestRegistry, withRequestContext } from '../../bare/runtime/index.js';
+import { generateServerRequestId } from '../../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 };
@@ -72,7 +72,7 @@ export async function handleDownloadAsset(request, progressCallback) {
         // non-match for this kind.
         const ctx = __addDisposableResource(env_1, await getRequestRegistry().begin({
             requestId,
-            kind: "downloadAsset",
+            kind: 'downloadAsset'
         }), true);
         const log = withRequestContext(getServerLogger(), ctx);
         log.debug(`downloadAsset start assetSrc=${assetSrc}`);
@@ -80,8 +80,8 @@ export async function handleDownloadAsset(request, progressCallback) {
             requestBinding: {
                 signal: ctx.signal,
                 scope: ctx.scope,
-                requestId,
-            },
+                requestId
+            }
         };
         try {
             const totalDownloadStart = profilingEnabled ? nowMs() : 0;
@@ -96,22 +96,22 @@ export async function handleDownloadAsset(request, progressCallback) {
                 await resolveModelPath(assetSrc, progressCallback, seed, ctx.signal, hooks);
             }
             const response = {
-                type: "downloadAsset",
+                type: 'downloadAsset',
                 success: true,
-                assetId: assetSrc,
+                assetId: assetSrc
             };
             if (profilingEnabled) {
                 const totalDownloadTimeMs = nowMs() - totalDownloadStart;
                 const profileId = profilingMeta?.id ?? generateProfileId();
                 const { gauges, tags } = buildDownloadProfilingFields(downloadStats, sourceType);
-                gauges["totalDownloadTime"] = totalDownloadTimeMs;
+                gauges['totalDownloadTime'] = totalDownloadTimeMs;
                 const operationEvent = {
-                    op: "downloadAsset",
-                    kind: "handler",
+                    op: 'downloadAsset',
+                    kind: 'handler',
                     ms: totalDownloadTimeMs,
                     profileId,
                     gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
-                    tags: Object.keys(tags).length > 0 ? tags : undefined,
+                    tags: Object.keys(tags).length > 0 ? tags : undefined
                 };
                 response[OPERATION_EVENT_KEY] = operationEvent;
             }
@@ -126,11 +126,11 @@ export async function handleDownloadAsset(request, progressCallback) {
                 log.info(`downloadAsset cancelled requestId=${requestId}`);
                 throw error;
             }
-            logger.error("Error downloading asset:", error);
+            logger.error('Error downloading asset:', error);
             return {
-                type: "downloadAsset",
+                type: 'downloadAsset',
                 success: false,
-                error: error instanceof Error ? error.message : "Unknown error",
+                error: error instanceof Error ? error.message : 'Unknown error'
             };
         }
     }

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

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

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

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

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

@@ -1,3 +1,3 @@
-import type { FinetuneProgressResponse, FinetuneRequest, FinetuneResult } from "../../../schemas/index";
+import type { FinetuneProgressResponse, FinetuneRequest, FinetuneResult } from '../../../schemas/index';
 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,16 +1,18 @@
-import { dispatchPluginReply } from "./plugin-dispatch.js";
-import { startFinetune } from "../../bare/plugins/llamacpp-completion/ops/finetune.js";
+import { dispatchPluginReply } from './plugin-dispatch.js';
+import { startFinetune } from '../../bare/plugins/llamacpp-completion/ops/finetune.js';
 export async function handleFinetune(request, progressCallback) {
     if (progressCallback &&
-        (request.operation === "start" || request.operation === "resume" || request.operation === undefined)) {
+        (request.operation === 'start' ||
+            request.operation === 'resume' ||
+            request.operation === undefined)) {
         return startFinetune(request, (progress) => {
             const update = {
-                type: "finetune:progress",
+                type: 'finetune:progress',
                 modelId: request.modelId,
-                ...progress,
+                ...progress
             };
             progressCallback(update);
         });
     }
-    return dispatchPluginReply(request.modelId, "finetune", request);
+    return dispatchPluginReply(request.modelId, 'finetune', request);
 }

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

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

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

@@ -1,7 +1,8 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getPlugin } from "../../plugins/registry.js";
-import { ModelNotFoundError } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getPlugin } from '../../plugins/registry.js';
+import { detectToolDialectFromName } from '../../utils/tools/index.js';
+import { ModelNotFoundError } from '../../../utils/errors-server.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 export function handleGetLoadedModelInfo(request) {
     const { modelId } = request;
@@ -15,25 +16,30 @@ export function handleGetLoadedModelInfo(request) {
             isDelegated: true,
             handlers: [],
             providerInfo: {
-                providerPublicKey: entry.delegated.providerPublicKey,
-            },
+                providerPublicKey: entry.delegated.providerPublicKey
+            }
         };
-        return { type: "getLoadedModelInfo", info };
+        return { type: 'getLoadedModelInfo', info };
     }
     const plugin = getPlugin(entry.local.modelType);
     if (!plugin) {
         logger.warn(`getLoadedModelInfo: no plugin registered for modelType "${entry.local.modelType}" on loaded model "${modelId}"`);
     }
+    const handlers = plugin ? Object.keys(plugin.handlers) : [];
     const info = {
         modelId: entry.id,
         isDelegated: false,
         modelType: entry.local.modelType,
-        handlers: plugin ? Object.keys(plugin.handlers) : [],
+        handlers,
         loadedAt: entry.local.loadedAt,
         ...(plugin && { displayName: plugin.displayName }),
         ...(plugin && { addonPackage: plugin.addonPackage }),
         ...(entry.local.name && { name: entry.local.name }),
         ...(entry.local.path && { path: entry.local.path }),
+        // Same detection the completion normalizer uses, so callers see the dialect it parses.
+        ...(handlers.includes('completionStream') && {
+            toolDialect: detectToolDialectFromName(entry.local.name, entry.local.path)
+        })
     };
-    return { type: "getLoadedModelInfo", info };
+    return { type: 'getLoadedModelInfo', info };
 }

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

@@ -1,3 +1,3 @@
-import type { GetModelInfoRequest, GetModelInfoResponse } from "../../../schemas/index";
+import type { GetModelInfoRequest, GetModelInfoResponse } from '../../../schemas/index';
 export declare function handleGetModelInfo(request: GetModelInfoRequest): Promise<GetModelInfoResponse>;
 //# sourceMappingURL=get-model-info.d.ts.map

package/dist/server/rpc/handlers/get-model-info.js

@@ -1,10 +1,10 @@
-import { models } from "../../../models/registry/models.js";
-import { getAllModelIds, getModelEntry, } from "../../bare/registry/model-registry.js";
-import { generateShortHash } from "../../utils/index.js";
-import { promises as fsPromises } from "bare-fs";
-import { getShardPath, getModelsCacheDir, getSingleFileCachePath, } from "../../utils/cache/paths.js";
-import { validateAndJoinPath } from "../../utils/path-security.js";
-import { ModelNotFoundError } from "../../../utils/errors-server.js";
+import { models } from '../../../models/registry/models.js';
+import { getAllModelIds, getModelEntry } from '../../bare/registry/model-registry.js';
+import { generateShortHash } from '../../utils/index.js';
+import { promises as fsPromises } from 'bare-fs';
+import { getShardPath, getModelsCacheDir, getSingleFileCachePath } from '../../utils/cache/paths.js';
+import { validateAndJoinPath } from '../../utils/path-security.js';
+import { ModelNotFoundError } from '../../../utils/errors-server.js';
 export async function handleGetModelInfo(request) {
     const { name } = request;
     const catalogEntry = models.find((m) => m.name === name);
@@ -31,7 +31,7 @@ export async function handleGetModelInfo(request) {
             const instance = {
                 registryId: id,
                 loadedAt: entry.local.loadedAt,
-                config: entry.local.config,
+                config: entry.local.config
             };
             loadedInstances.push(instance);
         }
@@ -57,18 +57,18 @@ export async function handleGetModelInfo(request) {
         cacheFiles,
         actualSize,
         cachedAt,
-        loadedInstances: loadedInstances.length > 0 ? loadedInstances : undefined,
+        loadedInstances: loadedInstances.length > 0 ? loadedInstances : undefined
     };
     return {
-        type: "getModelInfo",
-        modelInfo,
+        type: 'getModelInfo',
+        modelInfo
     };
 }
 async function handleShardedModel(cacheKey, shardMetadata) {
     const fileEntries = shardMetadata.map((s) => ({
         filename: s.filename,
         expectedSize: s.expectedSize,
-        sha256Checksum: s.sha256Checksum,
+        sha256Checksum: s.sha256Checksum
     }));
     const paths = shardMetadata.map((s) => getShardPath(cacheKey, s.filename));
     return checkCacheStatus(fileEntries, paths);
@@ -80,21 +80,21 @@ async function handleCompanionSetModel(companionSet, primaryRegistryPath, addon)
         filename: f.targetName,
         expectedSize: f.expectedSize,
         sha256Checksum: f.sha256Checksum,
-        key: f.key,
+        key: f.key
     }));
-    const canonicalPaths = files.map((f) => validateAndJoinPath(baseCache, "sets", setKey, f.targetName));
+    const canonicalPaths = files.map((f) => validateAndJoinPath(baseCache, 'sets', setKey, f.targetName));
     const canonicalResult = await checkCacheStatus(fileEntries, canonicalPaths, primaryKey);
     if (canonicalResult.isCached)
         return canonicalResult;
-    const isOnnxSet = files.some((f) => f.primary === true && f.targetName.endsWith(".onnx"));
+    const isOnnxSet = files.some((f) => f.primary === true && f.targetName.endsWith('.onnx'));
     if (isOnnxSet) {
         const legacyCacheKey = generateShortHash(primaryRegistryPath);
-        const legacyPaths = files.map((f) => validateAndJoinPath(baseCache, "onnx", legacyCacheKey, f.targetName));
+        const legacyPaths = files.map((f) => validateAndJoinPath(baseCache, 'onnx', legacyCacheKey, f.targetName));
         const legacyResult = await checkCacheStatus(fileEntries, legacyPaths, primaryKey);
         if (legacyResult.isCached)
             return legacyResult;
     }
-    else if (addon === "nmt") {
+    else if (addon === 'nmt') {
         // Legacy flat-cache compatibility for Bergamot-style companion sets.
         // This is valid only for families whose runtime still works with explicit
         // per-file absolute paths; it is not a generic rule for all companion sets.
@@ -147,7 +147,7 @@ async function checkCacheStatus(files, paths, primaryKey) {
             sha256Checksum: file.sha256Checksum,
             isCached: fileCached,
             actualSize: fileActualSize,
-            cachedAt: fileCachedAt,
+            cachedAt: fileCachedAt
         });
     }
     if (!primaryPath && cacheFiles.length > 0) {
@@ -156,7 +156,7 @@ async function checkCacheStatus(files, paths, primaryKey) {
     const result = {
         cacheFiles,
         isCached: allCached,
-        primaryPath,
+        primaryPath
     };
     if (allCached) {
         result.actualSize = totalActualSize;
@@ -167,7 +167,7 @@ async function checkCacheStatus(files, paths, primaryKey) {
     return result;
 }
 async function handleSingleFileModel(registryPath, expectedSize, sha256Checksum) {
-    const filename = registryPath.split("/").pop() || registryPath;
+    const filename = registryPath.split('/').pop() || registryPath;
     const filePath = getSingleFileCachePath(registryPath);
     return checkCacheStatus([{ filename, expectedSize, sha256Checksum }], [filePath]);
 }