@qvac/sdk 0.15.0 → 0.17.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 '../../../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 +1,5 @@
-import type { CompletionStreamRequest, CompletionStreamResponse } from '../../../schemas/index';
-import type { DelegatedHandlerOptions } from '../profiling/index';
+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,6 +1,6 @@
-import { getModelEntry } from '../../bare/registry/model-registry.js';
-import { getRPC } from '../../bare/delegate-rpc-client.js';
-import { stream } from '../delegate-transport.js';
+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();

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.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 +1,4 @@
-import { dispatchPluginStream } from './plugin-dispatch.js';
+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,4 +1,4 @@
-import type { DeleteCacheRequest, DeleteCacheResponse } from '../../../schemas/index';
+import type { DeleteCacheRequest, DeleteCacheResponse } from '../../../schemas/index.js';
 /**
  * RPC handler for `deleteCache(...)`. The three KV-cache bookkeeping
  * layers (on-disk `.bin`, `initializedCaches`, `cachedMessageCounts`)

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

@@ -1,4 +1,4 @@
-import { deleteKvCacheState } from '../../bare/plugins/llamacpp-completion/ops/kv-cache-session.js';
+import { deleteKvCacheState } from '../../../server/bare/plugins/llamacpp-completion/ops/kv-cache-session.js';
 import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 /**

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

@@ -51,12 +51,12 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     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 { 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 '../../bare/runtime/index.js';
-import { generateServerRequestId } from '../../bare/runtime/request-id.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) {

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.js';
 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 '../../../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 +1,3 @@
-import type { FinetuneProgressResponse, FinetuneRequest, FinetuneResult } from '../../../schemas/index';
+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,5 +1,5 @@
-import { dispatchPluginReply } from './plugin-dispatch.js';
-import { startFinetune } from '../../bare/plugins/llamacpp-completion/ops/finetune.js';
+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' ||

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.js';
 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,5 +1,6 @@
-import { getModelEntry } from '../../bare/registry/model-registry.js';
-import { getPlugin } from '../../plugins/registry.js';
+import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
+import { getPlugin } from '../../../server/plugins/registry.js';
+import { detectToolDialectFromName } from '../../../server/utils/tools/index.js';
 import { ModelNotFoundError } from '../../../utils/errors-server.js';
 import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
@@ -24,16 +25,21 @@ export function handleGetLoadedModelInfo(request) {
     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 })
+        ...(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 };
 }

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.js';
 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,9 +1,9 @@
 import { models } from '../../../models/registry/models.js';
-import { getAllModelIds, getModelEntry } from '../../bare/registry/model-registry.js';
-import { generateShortHash } from '../../utils/index.js';
+import { getAllModelIds, getModelEntry } from '../../../server/bare/registry/model-registry.js';
+import { generateShortHash } from '../../../server/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 { getShardPath, getModelsCacheDir, getSingleFileCachePath } from '../../../server/utils/cache/paths.js';
+import { validateAndJoinPath } from '../../../server/utils/path-security.js';
 import { ModelNotFoundError } from '../../../utils/errors-server.js';
 export async function handleGetModelInfo(request) {
     const { name } = request;

package/dist/server/rpc/handlers/get-system-resources.d.ts

@@ -0,0 +1,3 @@
+import type { GetSystemResourcesRequest, GetSystemResourcesResponse } from '../../../schemas/system-resources.js';
+export declare function handleGetSystemResources(request: GetSystemResourcesRequest): GetSystemResourcesResponse;
+//# sourceMappingURL=get-system-resources.d.ts.map

package/dist/server/rpc/handlers/get-system-resources.js

@@ -0,0 +1,53 @@
+import { getWorkerResourceCollector } from '../../../server/bare/resources/worker-collector.js';
+export function handleGetSystemResources(request) {
+    const collector = getWorkerResourceCollector();
+    if (!collector) {
+        return {
+            type: 'getSystemResources',
+            capabilities: {
+                cpu: {
+                    status: 'failed',
+                    reason: 'CPU resource collector is not initialized'
+                },
+                memory: {
+                    totalBytes: {
+                        status: 'failed',
+                        reason: 'CPU resource collector is not initialized'
+                    }
+                },
+                gpus: {
+                    status: 'failed',
+                    reason: 'GPU resource collector is not initialized'
+                }
+            },
+            ...(request.sample && {
+                sample: {
+                    sampledAt: Date.now(),
+                    cpu: {
+                        status: 'failed',
+                        reason: 'CPU resource collector is not initialized'
+                    },
+                    memory: {
+                        usedBytes: {
+                            status: 'failed',
+                            reason: 'CPU resource collector is not initialized'
+                        },
+                        totalBytes: {
+                            status: 'failed',
+                            reason: 'CPU resource collector is not initialized'
+                        }
+                    },
+                    gpus: {
+                        status: 'failed',
+                        reason: 'GPU resource collector is not initialized'
+                    }
+                }
+            })
+        };
+    }
+    return {
+        type: 'getSystemResources',
+        capabilities: collector.getCapabilities(),
+        ...(request.sample && { sample: collector.sample() })
+    };
+}

package/dist/server/rpc/handlers/heartbeat-delegated.d.ts

@@ -1,4 +1,4 @@
-import type { HeartbeatRequest, HeartbeatResponse } from '../../../schemas/index';
-import type { DelegatedHandlerOptions } from '../profiling/index';
+import type { HeartbeatRequest, HeartbeatResponse } from '../../../schemas/index.js';
+import type { DelegatedHandlerOptions } from '../../../server/rpc/profiling/index.js';
 export declare function handleHeartbeatDelegated(request: HeartbeatRequest, options?: DelegatedHandlerOptions): Promise<HeartbeatResponse>;
 //# sourceMappingURL=heartbeat-delegated.d.ts.map

package/dist/server/rpc/handlers/heartbeat-delegated.js

@@ -1,6 +1,6 @@
 import { getServerLogger } from '../../../logging/index.js';
-import { getRPC } from '../../bare/delegate-rpc-client.js';
-import { send } from '../delegate-transport.js';
+import { getRPC } from '../../../server/bare/delegate-rpc-client.js';
+import { send } from '../../../server/rpc/delegate-transport.js';
 import { DelegateConnectionFailedError } from '../../../utils/errors-server.js';
 const logger = getServerLogger();
 export async function handleHeartbeatDelegated(request, options) {

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

@@ -1,3 +1,3 @@
-import type { HeartbeatResponse } from '../../../schemas/index';
+import type { HeartbeatResponse } from '../../../schemas/index.js';
 export declare function handleHeartbeat(): HeartbeatResponse;
 //# sourceMappingURL=heartbeat.d.ts.map

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

@@ -1,39 +1,44 @@
-import { handleBatchCompletionStream } from './batch-completion-stream';
-import { handleCompletionStream } from './completion-stream';
-import { handleDownloadAsset } from './download-asset';
-import { handleLoadModel } from './load-model/index';
-import { handleUnloadModel } from './unload-model';
-import { handleEmbed } from './embed';
-import { handleTranscribe } from './transcribe';
-import { handleTranscribeStream } from './transcribe-stream';
-import { handleBciTranscribe } from './bci-transcribe';
-import { handleBciTranscribeStream } from './bci-transcribe-stream';
-import { provideHandler } from './provideHandler';
-import { stopProvideHandler } from './stopProvideHandler';
-import { handleTranslate } from './translate';
-import { handleLoggingStream } from './logging-stream';
-import { handleRag } from './rag';
-import { cancelHandler } from './cancelHandler';
-import { handleDeleteCache } from './delete-cache';
-import { handleTextToSpeech } from './text-to-speech';
-import { handleTextToSpeechStream } from './text-to-speech-stream';
-import { handleGetModelInfo } from './get-model-info';
-import { handleGetLoadedModelInfo } from './get-loaded-model-info';
-import { handleFinetune } from './finetune';
-import { handleOCRStream } from './ocr-stream';
-import { handleHeartbeat } from './heartbeat';
-import { handleDiffusionStream } from './diffusion-stream';
-import { handleVideoStream } from './video-stream';
-import { handleUpscaleStream } from './upscale-stream';
-import { handlePluginInvoke, handlePluginInvokeStream } from './plugin-invoke';
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from './registry';
-import { handleSuspend } from './suspend';
-import { handleResume } from './resume';
-import { handleState } from './state';
+import { handleBatchCompletionStream } from './batch-completion-stream.js';
+import { handleCompletionOrchestrate } from './completion-orchestrate.js';
+import { handleCompletionStream } from './completion-stream.js';
+import { handleDownloadAsset } from './download-asset.js';
+import { handleLoadModel } from './load-model/index.js';
+import { handleUnloadModel } from './unload-model.js';
+import { handleEmbed } from './embed.js';
+import { handleTranscribe } from './transcribe.js';
+import { handleTranscribeStream } from './transcribe-stream.js';
+import { handleBciTranscribe } from './bci-transcribe.js';
+import { handleBciTranscribeStream } from './bci-transcribe-stream.js';
+import { provideHandler } from './provideHandler.js';
+import { stopProvideHandler } from './stopProvideHandler.js';
+import { handleTranslate } from './translate.js';
+import { handleLoggingStream } from './logging-stream.js';
+import { handleRag } from './rag.js';
+import { cancelHandler } from './cancelHandler.js';
+import { handleDeleteCache } from './delete-cache.js';
+import { handleTextToSpeech } from './text-to-speech.js';
+import { handleTextToSpeechStream } from './text-to-speech-stream.js';
+import { handleGetModelInfo } from './get-model-info.js';
+import { handleGetLoadedModelInfo } from './get-loaded-model-info.js';
+import { handleGetSystemResources } from './get-system-resources.js';
+import { handleFinetune } from './finetune.js';
+import { handleOCRStream } from './ocr-stream.js';
+import { handleHeartbeat } from './heartbeat.js';
+import { handleDiffusionStream } from './diffusion-stream.js';
+import { handleVideoStream } from './video-stream.js';
+import { handleUpscaleStream } from './upscale-stream.js';
+import { handlePluginInvoke, handlePluginInvokeStream } from './plugin-invoke.js';
+import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from './registry.js';
+import { handleSuspend } from './suspend.js';
+import { handleResume } from './resume.js';
+import { handleState } from './state.js';
+import { handleAudioGenStream } from '../../../server/rpc/handlers/audio-gen-stream.js';
 export declare const handlers: {
+    audioGenStream: typeof handleAudioGenStream;
     heartbeat: typeof handleHeartbeat;
     batchCompletionStream: typeof handleBatchCompletionStream;
     completionStream: typeof handleCompletionStream;
+    completionOrchestrate: typeof handleCompletionOrchestrate;
     downloadAsset: typeof handleDownloadAsset;
     deleteCache: typeof handleDeleteCache;
     loadModel: typeof handleLoadModel;
@@ -53,6 +58,7 @@ export declare const handlers: {
     textToSpeechStream: typeof handleTextToSpeechStream;
     getModelInfo: typeof handleGetModelInfo;
     getLoadedModelInfo: typeof handleGetLoadedModelInfo;
+    getSystemResources: typeof handleGetSystemResources;
     finetune: typeof handleFinetune;
     ocrStream: typeof handleOCRStream;
     diffusionStream: typeof handleDiffusionStream;

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

@@ -1,4 +1,5 @@
 import { handleBatchCompletionStream } from './batch-completion-stream.js';
+import { handleCompletionOrchestrate } from './completion-orchestrate.js';
 import { handleCompletionStream } from './completion-stream.js';
 import { handleDownloadAsset } from './download-asset.js';
 import { handleLoadModel } from './load-model/index.js';
@@ -19,6 +20,7 @@ import { handleTextToSpeech } from './text-to-speech.js';
 import { handleTextToSpeechStream } from './text-to-speech-stream.js';
 import { handleGetModelInfo } from './get-model-info.js';
 import { handleGetLoadedModelInfo } from './get-loaded-model-info.js';
+import { handleGetSystemResources } from './get-system-resources.js';
 import { handleFinetune } from './finetune.js';
 import { handleOCRStream } from './ocr-stream.js';
 import { handleHeartbeat } from './heartbeat.js';
@@ -30,10 +32,13 @@ import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistry
 import { handleSuspend } from './suspend.js';
 import { handleResume } from './resume.js';
 import { handleState } from './state.js';
+import { handleAudioGenStream } from '../../../server/rpc/handlers/audio-gen-stream.js';
 export const handlers = {
+    audioGenStream: handleAudioGenStream,
     heartbeat: handleHeartbeat,
     batchCompletionStream: handleBatchCompletionStream,
     completionStream: handleCompletionStream,
+    completionOrchestrate: handleCompletionOrchestrate,
     downloadAsset: handleDownloadAsset,
     deleteCache: handleDeleteCache,
     loadModel: handleLoadModel,
@@ -53,6 +58,7 @@ export const handlers = {
     textToSpeechStream: handleTextToSpeechStream,
     getModelInfo: handleGetModelInfo,
     getLoadedModelInfo: handleGetLoadedModelInfo,
+    getSystemResources: handleGetSystemResources,
     finetune: handleFinetune,
     ocrStream: handleOCRStream,
     diffusionStream: handleDiffusionStream,

package/dist/server/rpc/handlers/load-model/download-manager.d.ts

@@ -1,7 +1,7 @@
-import type { ModelProgressUpdate } from '../../../../schemas/index';
+import type { ModelProgressUpdate } from '../../../../schemas/index.js';
 import { AbortController, type AbortSignal } from 'bare-abort-controller';
-import type { DisposableScope } from '../../../bare/runtime/disposable-scope';
-import type { DownloadHooks } from './types';
+import type { DisposableScope } from '../../../../server/bare/runtime/disposable-scope.js';
+import type { DownloadHooks } from '../../../../server/rpc/handlers/load-model/types.js';
 /**
  * Per-subscriber binding to a registry-tracked request.
  * `startOrJoinDownload` is request-aware: each caller (the

package/dist/server/rpc/handlers/load-model/download-manager.js

@@ -1,7 +1,7 @@
 import { AbortController } from 'bare-abort-controller';
 import { DownloadCancelledError, InferenceCancelledError } from '../../../../utils/errors-server.js';
 import { getServerLogger } from '../../../../logging/index.js';
-import { getRequestRegistry } from '../../../bare/runtime/index.js';
+import { getRequestRegistry } from '../../../../server/bare/runtime/index.js';
 const logger = getServerLogger();
 const activeTransfers = new Map();
 let nextSubscriberId = 0;

package/dist/server/rpc/handlers/load-model/download-stats.d.ts

@@ -1,6 +1,6 @@
-import type { ModelProgressUpdate } from '../../../../schemas/index';
-import type { DownloadStats, DownloadResult, DownloadHooks, ResolveResult } from './types';
-import type { ExplicitRegistryMetadata } from './registry-metadata';
+import type { ModelProgressUpdate } from '../../../../schemas/index.js';
+import type { DownloadStats, DownloadResult, DownloadHooks, ResolveResult } from './types.js';
+import type { ExplicitRegistryMetadata } from './registry-metadata.js';
 export declare function downloadModelFromHttpWithStats(url: string, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;
 export declare function downloadModelFromRegistryWithStats(registryPath: string, registrySource: string, progressCallback?: (progress: ModelProgressUpdate) => void, expectedChecksum?: string, downloadHooks?: DownloadHooks, explicitMetadata?: ExplicitRegistryMetadata): Promise<DownloadResult>;
 export declare function downloadModelFromHyperdriveWithStats(hyperdriveKey: string, modelFileName: string, seed?: boolean, progressCallback?: (progress: ModelProgressUpdate) => void, downloadHooks?: DownloadHooks): Promise<DownloadResult>;

package/dist/server/rpc/handlers/load-model/handler.d.ts

@@ -1,3 +1,3 @@
-import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from '../../../../schemas/index';
+import type { LoadModelRequest, LoadModelResponse, ModelProgressUpdate } from '../../../../schemas/index.js';
 export declare function handleLoadModel(request: LoadModelRequest, progressCallback?: (update: ModelProgressUpdate) => void): Promise<LoadModelResponse>;
 //# sourceMappingURL=handler.d.ts.map