@qvac/sdk 0.14.1 → 0.16.0

package/dist/server/rpc/delegate-transport.js

@@ -4,18 +4,18 @@
  * This module provides `send` and `stream` functions for server-side
  * delegation to remote peers (via HyperSwarm RPC).
  */
-import { requestSchema, responseSchema, PROFILING_KEY, PROFILING_TRAILER_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, } from "../../schemas/index.js";
-import { nowMs, extractProfilingMeta, stripProfilingMeta, recordFailure, generateId, } from "../../profiling/index.js";
-import { withTimeout, withTimeoutStream } from "../../utils/withTimeout.js";
-import { getServerLogger } from "../../logging/index.js";
-import { DelegateProviderError } from "../../utils/errors-server.js";
-import { cleanupStaleConnection } from "../bare/delegate-rpc-client.js";
-import { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime, } from "./profiling/delegation-profiler.js";
+import { requestSchema, responseSchema, PROFILING_KEY, PROFILING_TRAILER_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY } from '../../schemas/index.js';
+import { nowMs, extractProfilingMeta, stripProfilingMeta, recordFailure, generateId } from '../../profiling/index.js';
+import { withTimeout, withTimeoutStream } from '../../utils/withTimeout.js';
+import { getServerLogger } from '../../logging/index.js';
+import { DelegateProviderError } from '../../utils/errors-server.js';
+import { cleanupStaleConnection } from '../bare/delegate-rpc-client.js';
+import { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime } from './profiling/delegation-profiler.js';
 const logger = getServerLogger();
-import { getNextCommandId } from "./rpc-utils.js";
+import { getNextCommandId } from './rpc-utils.js';
 function checkAndThrowError(response) {
-    if (response.type === "error") {
-        throw new DelegateProviderError(response.message || "Unknown provider error", response.code);
+    if (response.type === 'error') {
+        throw new DelegateProviderError(response.message || 'Unknown provider error', response.code);
     }
 }
 function isConnectionError(error) {
@@ -40,17 +40,17 @@ async function sendBase(request, rpc, options, profilingMeta) {
     try {
         const parsedRequest = requestSchema.parse(request);
         const req = rpc.request(getNextCommandId());
-        logger.debug("[delegate-transport] Sending:", { type: request.type });
+        logger.debug('[delegate-transport] Sending:', { type: request.type });
         // Propagate per-call disable signal to delegated provider
         const finalRequest = profilingMeta?.enabled === false
             ? { ...parsedRequest, [PROFILING_KEY]: { enabled: false } }
             : parsedRequest;
         const payload = JSON.stringify(finalRequest);
-        req.send(payload, "utf-8");
-        const response = await withTimeout(req.reply("utf-8"), options?.timeout);
-        const rawPayload = JSON.parse(response?.toString() || "{}");
+        req.send(payload, 'utf-8');
+        const response = await withTimeout(req.reply('utf-8'), options?.timeout);
+        const rawPayload = JSON.parse(response?.toString() || '{}');
         const resPayload = responseSchema.parse(stripProfilingMeta(rawPayload));
-        logger.debug("[delegate-transport] Response:", { type: resPayload.type });
+        logger.debug('[delegate-transport] Response:', { type: resPayload.type });
         checkAndThrowError(resPayload);
         return resPayload;
     }
@@ -72,32 +72,32 @@ async function sendProfiled(request, rpc, options, profilingMeta) {
             : undefined;
         const parsedRequest = requestSchema.parse(request);
         const req = rpc.request(getNextCommandId());
-        logger.debug("[delegate-transport] Sending (profiled):", {
-            type: request.type,
+        logger.debug('[delegate-transport] Sending (profiled):', {
+            type: request.type
         });
         const stringifyStart = nowMs();
         const profilingEnvelope = { id: profileId };
         if (includeServerBreakdown) {
-            profilingEnvelope["includeServer"] = true;
+            profilingEnvelope['includeServer'] = true;
         }
         const requestWithProfiling = {
             ...parsedRequest,
-            [PROFILING_KEY]: profilingEnvelope,
+            [PROFILING_KEY]: profilingEnvelope
         };
         const payload = JSON.stringify(requestWithProfiling);
         timings.requestStringifyMs = nowMs() - stringifyStart;
         timings.sendStart = nowMs();
-        req.send(payload, "utf-8");
-        const response = await withTimeout(req.reply("utf-8"), options?.timeout);
+        req.send(payload, 'utf-8');
+        const response = await withTimeout(req.reply('utf-8'), options?.timeout);
         timings.firstResponseAt = nowMs();
         const parseStart = nowMs();
-        const rawPayload = JSON.parse(response?.toString() || "{}");
+        const rawPayload = JSON.parse(response?.toString() || '{}');
         timings.responseJsonParseMs = nowMs() - parseStart;
         const serverMeta = extractProfilingMeta(rawPayload);
         const cleanPayload = stripProfilingMeta(rawPayload);
         const resPayload = responseSchema.parse(cleanPayload);
-        logger.debug("[delegate-transport] Response (profiled):", {
-            type: resPayload.type,
+        logger.debug('[delegate-transport] Response (profiled):', {
+            type: resPayload.type
         });
         checkAndThrowError(resPayload);
         const delegationBreakdown = recordDelegationEvents(timings, serverMeta, connectionMs);
@@ -112,8 +112,8 @@ async function sendProfiled(request, rpc, options, profilingMeta) {
         const base = {
             ts: nowMs(),
             op: timings.requestType,
-            kind: "delegation",
-            profileId: timings.profileId,
+            kind: 'delegation',
+            profileId: timings.profileId
         };
         recordFailure(base, timings.requestStart, error);
         throw error;
@@ -132,14 +132,14 @@ async function* streamBase(request, rpc, options = {}, profilingMeta) {
     try {
         const parsedRequest = requestSchema.parse(request);
         const req = rpc.request(getNextCommandId());
-        logger.debug("[delegate-transport] Streaming:", { type: request.type });
+        logger.debug('[delegate-transport] Streaming:', { type: request.type });
         // Propagate per-call disable signal to delegated provider
         const finalRequest = profilingMeta?.enabled === false
             ? { ...parsedRequest, [PROFILING_KEY]: { enabled: false } }
             : parsedRequest;
-        req.send(JSON.stringify(finalRequest), "utf-8");
-        const responseStream = req.createResponseStream({ encoding: "utf-8" });
-        let buffer = "";
+        req.send(JSON.stringify(finalRequest), 'utf-8');
+        const responseStream = req.createResponseStream({ encoding: 'utf-8' });
+        let buffer = '';
         async function* processStream() {
             for await (const chunk of responseStream) {
                 yield chunk;
@@ -149,8 +149,8 @@ async function* streamBase(request, rpc, options = {}, profilingMeta) {
         for await (const chunk of streamWithTimeout) {
             buffer += chunk.toString();
             // Process complete lines (newline-delimited JSON)
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || ""; // Keep incomplete line in buffer
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || ''; // Keep incomplete line in buffer
             for (const line of lines) {
                 if (!line.trim())
                     continue;
@@ -177,20 +177,20 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
         }
         const parsedRequest = requestSchema.parse(request);
         const req = rpc.request(getNextCommandId());
-        logger.debug("[delegate-transport] Streaming (profiled):", {
-            type: request.type,
+        logger.debug('[delegate-transport] Streaming (profiled):', {
+            type: request.type
         });
         const stringifyStart = nowMs();
         const requestWithProfiling = {
             ...parsedRequest,
-            [PROFILING_KEY]: { id: profileId },
+            [PROFILING_KEY]: { id: profileId }
         };
         const payload = JSON.stringify(requestWithProfiling);
         timings.requestStringifyMs = nowMs() - stringifyStart;
         timings.sendStart = nowMs();
-        req.send(payload, "utf-8");
-        const responseStream = req.createResponseStream({ encoding: "utf-8" });
-        let buffer = "";
+        req.send(payload, 'utf-8');
+        const responseStream = req.createResponseStream({ encoding: 'utf-8' });
+        let buffer = '';
         async function* processStream() {
             for await (const chunk of responseStream) {
                 yield chunk;
@@ -200,8 +200,8 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
         let lastServerMeta;
         for await (const chunk of streamWithTimeout) {
             buffer += chunk.toString();
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
             for (const line of lines) {
                 if (!line.trim())
                     continue;
@@ -222,8 +222,7 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
                 if (serverMeta?.operation) {
                     response[OPERATION_EVENT_KEY] = serverMeta.operation;
                 }
-                response[DELEGATION_BREAKDOWN_KEY] =
-                    buildDelegationStreamBreakdown(timings);
+                response[DELEGATION_BREAKDOWN_KEY] = buildDelegationStreamBreakdown(timings);
                 yield response;
             }
         }
@@ -234,8 +233,8 @@ async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
         const base = {
             ts: nowMs(),
             op: timings.requestType,
-            kind: "delegation",
-            profileId: timings.profileId,
+            kind: 'delegation',
+            profileId: timings.profileId
         };
         recordFailure(base, timings.requestStart, error);
         throw error;

package/dist/server/rpc/handle-request.d.ts

@@ -1,3 +1,3 @@
-import type RPC from "bare-rpc";
+import type RPC from 'bare-rpc';
 export declare function handleRequest(req: RPC.IncomingRequest): Promise<void>;
 //# sourceMappingURL=handle-request.d.ts.map

package/dist/server/rpc/handle-request.js

@@ -1,13 +1,13 @@
-import { requestSchema, normalizeModelType, PROFILING_KEY, } from "../../schemas/index.js";
-import { nowMs } from "../../profiling/index.js";
-import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
-import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
-import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError, } from "../../utils/errors-server.js";
-import { registry } from "./handler-registry.js";
-import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, handleShutdown, isShutdownMessage, } from "./handler-utils.js";
-import { createServerProfiler } from "./profiling/index.js";
-import { assertLifecycleAllowed } from "../bare/runtime-lifecycle.js";
-import { shouldUseStreamErrorTransport } from "./transport-selector.js";
+import { requestSchema, normalizeModelType, PROFILING_KEY } from '../../schemas/index.js';
+import { nowMs } from '../../profiling/index.js';
+import { resolveModelConfig } from '../bare/registry/model-config-registry.js';
+import { sendErrorResponse, sendStreamErrorResponse } from '../error-handlers.js';
+import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError } from '../../utils/errors-server.js';
+import { registry } from './handler-registry.js';
+import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, handleShutdown, isShutdownMessage } from './handler-utils.js';
+import { createServerProfiler } from './profiling/index.js';
+import { assertLifecycleAllowed } from '../bare/runtime-lifecycle.js';
+import { shouldUseStreamErrorTransport } from './transport-selector.js';
 export async function handleRequest(req) {
     let profiler;
     let validationStart = 0;
@@ -39,10 +39,10 @@ export async function handleRequest(req) {
             return;
         }
         const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
-        if (cleanData && typeof cleanData === "object") {
+        if (cleanData && typeof cleanData === 'object') {
             rawRequest = cleanData;
-            const rawType = rawRequest["type"];
-            if (typeof rawType === "string") {
+            const rawType = rawRequest['type'];
+            if (typeof rawType === 'string') {
                 entry = registry[rawType];
             }
         }
@@ -80,18 +80,18 @@ function attachProfilingMetaToRequest(request, profilingMeta) {
         value: profilingMeta,
         enumerable: false,
         configurable: true,
-        writable: false,
+        writable: false
     });
 }
 function extractProfilingMeta(data) {
-    if (!data || typeof data !== "object" || !(PROFILING_KEY in data)) {
+    if (!data || typeof data !== 'object' || !(PROFILING_KEY in data)) {
         return { data, profilingMeta: undefined };
     }
     const obj = data;
     const { [PROFILING_KEY]: meta, ...rest } = obj;
     return {
         data: rest,
-        profilingMeta: meta,
+        profilingMeta: meta
     };
 }
 async function handleDuplexRequest(req) {
@@ -101,16 +101,16 @@ async function handleDuplexRequest(req) {
     try {
         const firstChunk = await new Promise((resolve, reject) => {
             const onData = (data) => {
-                inputStream.off("error", onError);
+                inputStream.off('error', onError);
                 inputStream.pause();
                 resolve(data);
             };
             const onError = (err) => {
-                inputStream.off("data", onData);
+                inputStream.off('data', onData);
                 reject(err instanceof Error ? err : new Error(String(err)));
             };
-            inputStream.once("data", onData);
-            inputStream.once("error", onError);
+            inputStream.once('data', onData);
+            inputStream.once('error', onError);
         });
         const parseStart = nowMs();
         const jsonData = JSON.parse(firstChunk.toString());
@@ -128,8 +128,8 @@ async function handleDuplexRequest(req) {
         if (!entry) {
             throw new RPCUnknownRequestTypeError(request.type);
         }
-        if (entry.type !== "duplex") {
-            throw new PluginHandlerTypeMismatchError(request.type, "duplex", entry.type);
+        if (entry.type !== 'duplex') {
+            throw new PluginHandlerTypeMismatchError(request.type, 'duplex', entry.type);
         }
         await executeDuplexHandler(req, request, entry, inputStream, outputStream, profiler);
     }
@@ -145,30 +145,28 @@ async function handleDuplexRequest(req) {
  * Priority: User config > Device defaults > Schema defaults
  */
 function applyDeviceDefaultsToRequest(data) {
-    if (!data || typeof data !== "object")
+    if (!data || typeof data !== 'object')
         return data;
     const obj = data;
-    const requestType = obj["type"];
+    const requestType = obj['type'];
     // Only process loadModel requests (not reload config which uses modelId)
-    if (requestType !== "loadModel" ||
-        !obj["modelType"] ||
-        !("modelSrc" in obj)) {
+    if (requestType !== 'loadModel' || !obj['modelType'] || !('modelSrc' in obj)) {
         return data;
     }
     // Normalize model type to canonical form
     let canonicalType;
     try {
-        canonicalType = normalizeModelType(obj["modelType"]);
+        canonicalType = normalizeModelType(obj['modelType']);
     }
     catch {
         // Invalid model type, let schema validation handle it
         return data;
     }
     // Apply device defaults and full schema defaults to modelConfig
-    const rawConfig = obj["modelConfig"] ?? {};
+    const rawConfig = obj['modelConfig'] ?? {};
     const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
     return {
         ...obj,
-        modelConfig: configWithDefaults,
+        modelConfig: configWithDefaults
     };
 }

package/dist/server/rpc/handler-registry.d.ts

@@ -1,3 +1,3 @@
-import type { HandlerEntry } from "./handler-utils";
+import type { HandlerEntry } from './handler-utils';
 export declare const registry: Record<string, HandlerEntry>;
 //# sourceMappingURL=handler-registry.d.ts.map

package/dist/server/rpc/handler-registry.js

@@ -1,54 +1,56 @@
-import {} from "../../schemas/index.js";
-import { handleCompletionStream } from "./handlers/completion-stream.js";
-import { handleDownloadAsset } from "./handlers/download-asset.js";
-import { handleLoadModel } from "./handlers/load-model/index.js";
-import { handleLoadModelDelegated } from "./handlers/load-model-delegated.js";
-import { handleCompletionStreamDelegated } from "./handlers/completion-stream-delegated.js";
-import { getModelEntry } from "../bare/registry/model-registry.js";
-import { handleUnloadModel } from "./handlers/unload-model.js";
-import { handleUnloadModelDelegated } from "./handlers/unload-model-delegated.js";
-import { handleTranscribe } from "./handlers/transcribe.js";
-import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
-import { handleBciTranscribe } from "./handlers/bci-transcribe.js";
-import { handleBciTranscribeStream } from "./handlers/bci-transcribe-stream.js";
-import { handleEmbed } from "./handlers/embed.js";
-import { handleTranslate } from "./handlers/translate.js";
-import { handleLoggingStream } from "./handlers/logging-stream.js";
-import { cancelHandler } from "./handlers/cancelHandler.js";
-import { provideHandler } from "./handlers/provideHandler.js";
-import { stopProvideHandler } from "./handlers/stopProvideHandler.js";
-import { handleRag } from "./handlers/rag.js";
-import { handleDeleteCache } from "./handlers/delete-cache.js";
-import { handleTextToSpeech } from "./handlers/text-to-speech.js";
-import { handleTextToSpeechStream } from "./handlers/text-to-speech-stream.js";
-import { handleGetModelInfo } from "./handlers/get-model-info.js";
-import { handleGetLoadedModelInfo } from "./handlers/get-loaded-model-info.js";
-import { handleOCRStream } from "./handlers/ocr-stream.js";
-import { handleHeartbeat } from "./handlers/heartbeat.js";
-import { handleFinetune } from "./handlers/finetune.js";
-import { handleHeartbeatDelegated } from "./handlers/heartbeat-delegated.js";
-import { handleCancelDelegated } from "./handlers/cancel-delegated.js";
-import { handleDiffusionStream } from "./handlers/diffusion-stream.js";
-import { handleVideoStream } from "./handlers/video-stream.js";
-import { handleUpscaleStream } from "./handlers/upscale-stream.js";
-import { handleClassify } from "./handlers/classify.js";
-import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
-import { handleSuspend } from "./handlers/suspend.js";
-import { handleResume } from "./handlers/resume.js";
-import { handleState } from "./handlers/state.js";
+import {} from '../../schemas/index.js';
+import { handleBatchCompletionStream } from './handlers/batch-completion-stream.js';
+import { handleCompletionOrchestrate } from './handlers/completion-orchestrate.js';
+import { handleCompletionStream } from './handlers/completion-stream.js';
+import { handleDownloadAsset } from './handlers/download-asset.js';
+import { handleLoadModel } from './handlers/load-model/index.js';
+import { handleLoadModelDelegated } from './handlers/load-model-delegated.js';
+import { handleCompletionStreamDelegated } from './handlers/completion-stream-delegated.js';
+import { getModelEntry } from '../bare/registry/model-registry.js';
+import { handleUnloadModel } from './handlers/unload-model.js';
+import { handleUnloadModelDelegated } from './handlers/unload-model-delegated.js';
+import { handleTranscribe } from './handlers/transcribe.js';
+import { handleTranscribeStream } from './handlers/transcribe-stream.js';
+import { handleBciTranscribe } from './handlers/bci-transcribe.js';
+import { handleBciTranscribeStream } from './handlers/bci-transcribe-stream.js';
+import { handleEmbed } from './handlers/embed.js';
+import { handleTranslate } from './handlers/translate.js';
+import { handleLoggingStream } from './handlers/logging-stream.js';
+import { cancelHandler } from './handlers/cancelHandler.js';
+import { provideHandler } from './handlers/provideHandler.js';
+import { stopProvideHandler } from './handlers/stopProvideHandler.js';
+import { handleRag } from './handlers/rag.js';
+import { handleDeleteCache } from './handlers/delete-cache.js';
+import { handleTextToSpeech } from './handlers/text-to-speech.js';
+import { handleTextToSpeechStream } from './handlers/text-to-speech-stream.js';
+import { handleGetModelInfo } from './handlers/get-model-info.js';
+import { handleGetLoadedModelInfo } from './handlers/get-loaded-model-info.js';
+import { handleOCRStream } from './handlers/ocr-stream.js';
+import { handleHeartbeat } from './handlers/heartbeat.js';
+import { handleFinetune } from './handlers/finetune.js';
+import { handleHeartbeatDelegated } from './handlers/heartbeat-delegated.js';
+import { handleCancelDelegated } from './handlers/cancel-delegated.js';
+import { handleDiffusionStream } from './handlers/diffusion-stream.js';
+import { handleVideoStream } from './handlers/video-stream.js';
+import { handleUpscaleStream } from './handlers/upscale-stream.js';
+import { handleClassify } from './handlers/classify.js';
+import { handlePluginInvoke, handlePluginInvokeStream } from './handlers/plugin-invoke.js';
+import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from './handlers/registry.js';
+import { handleSuspend } from './handlers/suspend.js';
+import { handleResume } from './handlers/resume.js';
+import { handleState } from './handlers/state.js';
 function ragSupportsProgress(request) {
-    if (request.type !== "rag")
+    if (request.type !== 'rag')
         return false;
-    return ["ingest", "saveEmbeddings", "reindex"].includes(request.operation);
+    return ['ingest', 'saveEmbeddings', 'reindex'].includes(request.operation);
 }
 function finetuneSupportsProgress(request) {
-    if (request.type !== "finetune")
+    if (request.type !== 'finetune')
         return false;
-    return ["start", "resume", undefined].includes(request.operation);
+    return ['start', 'resume', undefined].includes(request.operation);
 }
 function isModelDelegated(request) {
-    if (!("modelId" in request))
+    if (!('modelId' in request))
         return false;
     const entry = getModelEntry(request.modelId);
     return entry?.isDelegated ?? false;
@@ -75,91 +77,99 @@ function isModelDelegated(request) {
  *    on this worker.
  */
 function isCancelDelegated(request) {
-    if (request.type !== "cancel")
+    if (request.type !== 'cancel')
         return false;
-    if (request.operation !== "broad")
+    if (request.operation !== 'broad')
         return false;
     return isModelDelegated(request);
 }
 export const registry = {
     // Simple Reply handlers
     heartbeat: {
-        type: "reply",
+        type: 'reply',
         handler: handleHeartbeat,
         delegatedHandler: handleHeartbeatDelegated,
-        isDelegated: (r) => r.type === "heartbeat" && !!r.delegate,
+        isDelegated: (r) => r.type === 'heartbeat' && !!r.delegate
     },
     unloadModel: {
-        type: "reply",
+        type: 'reply',
         handler: handleUnloadModel,
         delegatedHandler: handleUnloadModelDelegated,
-        isDelegated: isModelDelegated,
+        isDelegated: isModelDelegated
     },
-    embed: { type: "reply", handler: handleEmbed },
+    embed: { type: 'reply', handler: handleEmbed },
     cancel: {
-        type: "reply",
+        type: 'reply',
         handler: cancelHandler,
         delegatedHandler: handleCancelDelegated,
-        isDelegated: isCancelDelegated,
+        isDelegated: isCancelDelegated
     },
-    provide: { type: "reply", handler: provideHandler },
-    stopProvide: { type: "reply", handler: stopProvideHandler },
-    deleteCache: { type: "reply", handler: handleDeleteCache },
-    getModelInfo: { type: "reply", handler: handleGetModelInfo },
-    getLoadedModelInfo: { type: "reply", handler: handleGetLoadedModelInfo },
-    pluginInvoke: { type: "reply", handler: handlePluginInvoke },
-    modelRegistryList: { type: "reply", handler: handleModelRegistryList },
-    modelRegistrySearch: { type: "reply", handler: handleModelRegistrySearch },
+    provide: { type: 'reply', handler: provideHandler },
+    stopProvide: { type: 'reply', handler: stopProvideHandler },
+    deleteCache: { type: 'reply', handler: handleDeleteCache },
+    getModelInfo: { type: 'reply', handler: handleGetModelInfo },
+    getLoadedModelInfo: { type: 'reply', handler: handleGetLoadedModelInfo },
+    pluginInvoke: { type: 'reply', handler: handlePluginInvoke },
+    modelRegistryList: { type: 'reply', handler: handleModelRegistryList },
+    modelRegistrySearch: { type: 'reply', handler: handleModelRegistrySearch },
     modelRegistryGetModel: {
-        type: "reply",
-        handler: handleModelRegistryGetModel,
+        type: 'reply',
+        handler: handleModelRegistryGetModel
     },
-    suspend: { type: "reply", handler: handleSuspend },
-    resume: { type: "reply", handler: handleResume },
-    state: { type: "reply", handler: handleState },
+    suspend: { type: 'reply', handler: handleSuspend },
+    resume: { type: 'reply', handler: handleResume },
+    state: { type: 'reply', handler: handleState },
     // Simple Stream handlers
-    transcribe: { type: "stream", handler: handleTranscribe },
-    transcribeStream: { type: "duplex", handler: handleTranscribeStream },
-    bciTranscribe: { type: "stream", handler: handleBciTranscribe },
-    bciTranscribeStream: { type: "duplex", handler: handleBciTranscribeStream },
-    loggingStream: { type: "stream", handler: handleLoggingStream },
-    translate: { type: "stream", handler: handleTranslate },
-    textToSpeech: { type: "stream", handler: handleTextToSpeech },
-    textToSpeechStream: { type: "duplex", handler: handleTextToSpeechStream },
-    ocrStream: { type: "stream", handler: handleOCRStream },
-    diffusionStream: { type: "stream", handler: handleDiffusionStream },
-    videoStream: { type: "stream", handler: handleVideoStream },
-    upscaleStream: { type: "stream", handler: handleUpscaleStream },
-    classify: { type: "stream", handler: handleClassify },
-    pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },
+    transcribe: { type: 'stream', handler: handleTranscribe },
+    transcribeStream: { type: 'duplex', handler: handleTranscribeStream },
+    bciTranscribe: { type: 'stream', handler: handleBciTranscribe },
+    bciTranscribeStream: { type: 'duplex', handler: handleBciTranscribeStream },
+    loggingStream: { type: 'stream', handler: handleLoggingStream },
+    translate: { type: 'stream', handler: handleTranslate },
+    textToSpeech: { type: 'stream', handler: handleTextToSpeech },
+    textToSpeechStream: { type: 'duplex', handler: handleTextToSpeechStream },
+    ocrStream: { type: 'stream', handler: handleOCRStream },
+    diffusionStream: { type: 'stream', handler: handleDiffusionStream },
+    videoStream: { type: 'stream', handler: handleVideoStream },
+    upscaleStream: { type: 'stream', handler: handleUpscaleStream },
+    classify: { type: 'stream', handler: handleClassify },
+    pluginInvokeStream: { type: 'stream', handler: handlePluginInvokeStream },
     // Handlers with delegation support
     loadModel: {
-        type: "reply",
+        type: 'reply',
         handler: handleLoadModel,
         delegatedHandler: handleLoadModelDelegated,
-        isDelegated: (r) => r.type === "loadModel" && !!r.delegate,
-        supportsProgress: true,
+        isDelegated: (r) => r.type === 'loadModel' && !!r.delegate,
+        supportsProgress: true
     },
     completionStream: {
-        type: "stream",
+        type: 'stream',
         handler: handleCompletionStream,
         delegatedHandler: handleCompletionStreamDelegated,
-        isDelegated: isModelDelegated,
+        isDelegated: isModelDelegated
+    },
+    // Deliberately no delegated handler: tool callbacks execute code on the
+    // client machine, so only the user's own local worker may orchestrate
+    // (see completionOrchestrateResponseSchema's contract note).
+    completionOrchestrate: { type: 'duplex', handler: handleCompletionOrchestrate },
+    batchCompletionStream: {
+        type: 'stream',
+        handler: handleBatchCompletionStream
     },
     // Handlers with progress support
     downloadAsset: {
-        type: "reply",
+        type: 'reply',
         handler: handleDownloadAsset,
-        supportsProgress: true,
+        supportsProgress: true
     },
     rag: {
-        type: "reply",
+        type: 'reply',
         handler: handleRag,
-        supportsProgress: ragSupportsProgress,
+        supportsProgress: ragSupportsProgress
     },
     finetune: {
-        type: "reply",
+        type: 'reply',
         handler: handleFinetune,
-        supportsProgress: finetuneSupportsProgress,
-    },
+        supportsProgress: finetuneSupportsProgress
+    }
 };

package/dist/server/rpc/handler-selection.d.ts

@@ -1,7 +1,7 @@
-import type { Request } from "../../schemas/index";
-import type { HandlerEntry } from "./handler-utils";
+import type { Request } from '../../schemas/index';
+import type { HandlerEntry } from './handler-utils';
 export interface HandlerSelection {
-    handler: HandlerEntry["handler"];
+    handler: HandlerEntry['handler'];
     isDelegated: boolean;
 }
 export declare function selectHandler(entry: HandlerEntry, request: Request): HandlerSelection;

package/dist/server/rpc/handler-selection.js

@@ -2,13 +2,13 @@ export function selectHandler(entry, request) {
     const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
     return {
         handler: isDelegated ? entry.delegatedHandler : entry.handler,
-        isDelegated,
+        isDelegated
     };
 }
 export function handlerSupportsProgress(entry, request) {
-    return !!("withProgress" in request &&
+    return !!('withProgress' in request &&
         request.withProgress &&
-        (typeof entry.supportsProgress === "function"
+        (typeof entry.supportsProgress === 'function'
             ? entry.supportsProgress(request)
             : entry.supportsProgress));
 }