@qvac/sdk 0.8.0 → 1.0.0

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

@@ -1,103 +1,253 @@
-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 } from "../error-handlers.js";
-import { RPCNoDataReceivedError, RPCUnknownRequestTypeError, } from "../../utils/errors-server.js";
-import { registry } from "./handler-registry.js";
-import { executeHandler, handleInitConfig, isInitConfigMessage, } from "./handler-utils.js";
-import { createServerProfiler } from "./profiling/index.js";
+import { requestSchema, responseSchema, } from "../../schemas/index.js";
+import { handleCompletionStream } from "./handlers/completion-stream.js";
+import { handleDownloadAsset } from "./handlers/download-asset.js";
+import { handleLoadModel } from "./handlers/load-model.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 { handleTranscribeStream } from "./handlers/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 { sendErrorResponse, sendStreamErrorResponse } from "../error-handlers";
 export async function handleRequest(req) {
-    let profiler;
-    let validationStart = 0;
     try {
         const rawData = req.data?.toString();
         if (!rawData) {
-            throw new RPCNoDataReceivedError();
+            throw new Error("No data received");
         }
-        // Timing runs unconditionally since we can't know if client
-        // requested profiling until after parsing.
-        const parseStart = nowMs();
         const jsonData = JSON.parse(rawData);
-        const jsonParseMs = nowMs() - parseStart;
-        // Handle internal config initialization (bypasses schema)
-        if (isInitConfigMessage(jsonData)) {
-            handleInitConfig(req, jsonData);
-            return;
+        const request = requestSchema.parse(jsonData);
+        switch (request.type) {
+            case "downloadAsset": {
+                if (request.withProgress) {
+                    const stream = req.createResponseStream();
+                    try {
+                        const response = await handleDownloadAsset(request, (update) => {
+                            const data = JSON.stringify(responseSchema.parse(update));
+                            stream.write(data + "\n", "utf-8");
+                        });
+                        // Send final response
+                        const data = JSON.stringify(responseSchema.parse(response));
+                        stream.write(data + "\n", "utf-8");
+                        stream.end();
+                    }
+                    catch (error) {
+                        sendStreamErrorResponse(stream, error);
+                    }
+                }
+                else {
+                    try {
+                        const response = await handleDownloadAsset(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
+                }
+                break;
+            }
+            case "loadModel": {
+                if (request.withProgress) {
+                    const stream = req.createResponseStream();
+                    try {
+                        // Route to appropriate handler based on delegation
+                        let response;
+                        if (request.delegate) {
+                            response = await handleLoadModelDelegated(request, (update) => {
+                                const data = JSON.stringify(responseSchema.parse(update));
+                                stream.write(data + "\n", "utf-8");
+                            });
+                        }
+                        else {
+                            response = await handleLoadModel(request, (update) => {
+                                const data = JSON.stringify(responseSchema.parse(update));
+                                stream.write(data + "\n", "utf-8");
+                            });
+                        }
+                        // Send final response
+                        const data = JSON.stringify(responseSchema.parse(response));
+                        stream.write(data + "\n", "utf-8");
+                        stream.end();
+                    }
+                    catch (error) {
+                        sendStreamErrorResponse(stream, error);
+                    }
+                }
+                else {
+                    // Route to appropriate handler based on delegation
+                    try {
+                        const handler = request.delegate
+                            ? handleLoadModelDelegated
+                            : handleLoadModel;
+                        const response = await handler(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
+                }
+                break;
+            }
+            case "completionStream": {
+                const stream = req.createResponseStream();
+                try {
+                    // Check if the model is delegated and route accordingly
+                    const entry = getModelEntry(request.modelId);
+                    const handler = entry?.isDelegated
+                        ? handleCompletionStreamDelegated
+                        : handleCompletionStream;
+                    for await (const response of handler(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                    break;
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
+            case "unloadModel": {
+                const response = await handleUnloadModel(request);
+                req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                break;
+            }
+            case "transcribeStream": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleTranscribeStream(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                    return;
+                }
+                break;
+            }
+            case "loggingStream": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleLoggingStream(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                    return;
+                }
+                break;
+            }
+            case "ping": {
+                const res = {
+                    type: "pong",
+                    number: Math.random() * 100,
+                };
+                req.reply(JSON.stringify(res), "utf-8");
+                break;
+            }
+            case "embed": {
+                try {
+                    const response = await handleEmbed(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "translate": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleTranslate(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
+            case "cancel": {
+                try {
+                    const response = await cancelHandler(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "provide": {
+                const response = await provideHandler(request);
+                req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                break;
+            }
+            case "stopProvide": {
+                const response = stopProvideHandler(request);
+                req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                break;
+            }
+            case "rag": {
+                try {
+                    const response = await handleRag(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "deleteCache": {
+                try {
+                    const response = await handleDeleteCache(request);
+                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                }
+                catch (error) {
+                    sendErrorResponse(req, error);
+                }
+                break;
+            }
+            case "textToSpeech": {
+                const stream = req.createResponseStream();
+                try {
+                    for await (const response of handleTextToSpeech(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
+                }
+                catch (error) {
+                    sendStreamErrorResponse(stream, error);
+                }
+                break;
+            }
+            default: {
+                throw new Error(`Unknown request type`);
+            }
         }
-        const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
-        profiler = createServerProfiler(profilingMeta);
-        profiler.markRequestParsed(jsonParseMs);
-        validationStart = nowMs();
-        const processedData = applyDeviceDefaultsToRequest(cleanData);
-        const request = requestSchema.parse(processedData);
-        attachProfilingMetaToRequest(request, profilingMeta);
-        profiler.markRequestValidated(nowMs() - validationStart);
-        validationStart = 0;
-        const entry = registry[request.type];
-        if (!entry) {
-            throw new RPCUnknownRequestTypeError(request.type);
-        }
-        await executeHandler(req, request, entry, profiler);
     }
     catch (error) {
-        if (profiler && validationStart > 0) {
-            profiler.markRequestValidated(nowMs() - validationStart);
-        }
-        sendErrorResponse(req, error, profiler);
-    }
-}
-function attachProfilingMetaToRequest(request, profilingMeta) {
-    if (!profilingMeta)
-        return;
-    Object.defineProperty(request, PROFILING_KEY, {
-        value: profilingMeta,
-        enumerable: false,
-        configurable: true,
-        writable: false,
-    });
-}
-function extractProfilingMeta(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,
-    };
-}
-/**
- * Apply device-specific config defaults to loadModel requests before schema parsing.
- * This ensures device defaults are applied before schema defaults.
- *
- * Priority: User config > Device defaults > Schema defaults
- */
-function applyDeviceDefaultsToRequest(data) {
-    if (!data || typeof data !== "object")
-        return data;
-    const obj = data;
-    const requestType = obj["type"];
-    // Only process loadModel requests (not reload config which uses modelId)
-    if (requestType !== "loadModel" ||
-        !obj["modelType"] ||
-        !("modelSrc" in obj)) {
-        return data;
-    }
-    // Normalize model type to canonical form
-    let canonicalType;
-    try {
-        canonicalType = normalizeModelType(obj["modelType"]);
-    }
-    catch {
-        // Invalid model type, let schema validation handle it
-        return data;
+        sendErrorResponse(req, error);
     }
-    // Apply device defaults and full schema defaults to modelConfig
-    const rawConfig = obj["modelConfig"] ?? {};
-    const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
-    return {
-        ...obj,
-        modelConfig: configWithDefaults,
-    };
 }

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

@@ -1,26 +1,15 @@
-import { cancel } from "../../bare/ops/cancel.js";
+import { cancel } from "../../bare/addons/index.js";
 import { createCancelFunction } from "./load-model/download-manager.js";
-import { cancelRagOperation, DEFAULT_WORKSPACE, } from "../../bare/rag-hyperdb/index.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
 export async function cancelHandler(request) {
     try {
         switch (request.operation) {
             case "inference":
                 await cancel({ modelId: request.modelId });
                 break;
-            case "downloadAsset": {
+            case "downloadAsset":
                 const cancelDownload = createCancelFunction(request.downloadKey, request.clearCache);
                 cancelDownload();
                 break;
-            }
-            case "rag": {
-                const cancelled = cancelRagOperation(request.workspace);
-                if (!cancelled) {
-                    logger.warn(`No active RAG operation to cancel for workspace: ${request.workspace ?? DEFAULT_WORKSPACE}`);
-                }
-                break;
-            }
         }
         return {
             type: "cancel",
@@ -28,7 +17,7 @@ export async function cancelHandler(request) {
         };
     }
     catch (error) {
-        logger.error("Error during cancellation:", error);
+        console.error("Error during cancellation:", error);
         return {
             type: "cancel",
             success: false,

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

@@ -1,5 +1,3 @@
 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>;
+export declare function handleCompletionStreamDelegated(request: CompletionStreamRequest): AsyncGenerator<CompletionStreamResponse>;
 //# sourceMappingURL=completion-stream-delegated.d.ts.map

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

@@ -1,38 +1,26 @@
 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 ?? {};
+import { stream } from "../../../client/rpc/rpc-client.js";
+export async function* handleCompletionStreamDelegated(request) {
     // Get delegation info from model registry
     const entry = getModelEntry(request.modelId);
     if (!entry?.isDelegated || !entry.delegated) {
-        throw new ModelIsDelegatedError(request.modelId);
+        throw new Error(`Model ${request.modelId} is not a delegated model`);
     }
     const { topic, providerPublicKey, timeout } = entry.delegated;
     try {
-        logger.debug(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        console.log(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
         // Create RPC instance for this HyperSwarm peer
         const rpc = await getRPC(topic, providerPublicKey, { timeout });
-        // Build delegate options with profiling metadata
-        const delegateOpts = { peerKey: providerPublicKey };
-        if (profilingMeta) {
-            delegateOpts.profilingMeta = profilingMeta;
-        }
-        if (timeout) {
-            delegateOpts.timeout = timeout;
-        }
         // Use the regular stream function with the HyperSwarm RPC instance
-        const responseStream = stream(request, rpc, delegateOpts);
+        const responseStream = stream(request, rpc, { timeout });
         // Yield each response from the stream
         for await (const response of responseStream) {
             yield response;
         }
     }
     catch (error) {
-        logger.error("Error in delegated completion stream:", error);
+        console.error("Error in delegated completion stream:", error);
         yield {
             type: "completionStream",
             token: `Error communicating with provider: ${error instanceof Error ? error.message : String(error)}`,

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

@@ -1,4 +1,43 @@
-import { dispatchPluginStream } from "./plugin-dispatch.js";
+import { completion } from "../../bare/addons/llamacpp/index.js";
 export async function* handleCompletionStream(request) {
-    yield* dispatchPluginStream(request.modelId, "completionStream", request);
+    const filteredHistory = request.history.map(({ role, content, attachments }) => ({
+        role,
+        content,
+        attachments: attachments ?? [],
+    }));
+    const stream = completion({
+        history: filteredHistory,
+        modelId: request.modelId,
+        kvCache: request.kvCache,
+        ...(request.tools && { tools: request.tools }),
+    });
+    let stats;
+    let toolCalls = [];
+    let done = false;
+    let buffer = "";
+    while (!done) {
+        const result = await stream.next();
+        if (result.done) {
+            stats = result.value.stats;
+            toolCalls = result.value.toolCalls;
+            done = true;
+        }
+        else {
+            buffer += result.value.token;
+            if (request.stream) {
+                yield {
+                    type: "completionStream",
+                    token: result.value.token,
+                    toolCallEvent: result.value.toolCallEvent,
+                };
+            }
+        }
+    }
+    yield {
+        type: "completionStream",
+        token: buffer,
+        done: true,
+        stats,
+        toolCalls,
+    };
 }

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

@@ -1,6 +1,4 @@
-import { deleteCache as deleteCacheUtil } from "../../bare/ops/kv-cache-utils.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
+import { deleteCache as deleteCacheUtil } from "../../bare/addons/llamacpp/kv-cache-utils.js";
 export async function handleDeleteCache(request) {
     try {
         if ("all" in request && request.all) {
@@ -21,7 +19,7 @@ export async function handleDeleteCache(request) {
         };
     }
     catch (error) {
-        logger.error("Error deleting cache:", error);
+        console.error("Error deleting cache:", error);
         return {
             type: "deleteCache",
             success: false,

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

@@ -1,70 +1,17 @@
-import { PROFILING_KEY, OPERATION_EVENT_KEY, } from "../../../schemas/index.js";
-import { resolveModelPath, resolveModelPathWithStats, } from "./load-model/resolve.js";
-import { nowMs, generateProfileId } from "../../../profiling/clock.js";
-import { getServerLogger } from "../../../logging/index.js";
-const logger = getServerLogger();
+import { resolveModelPath } from "./load-model/resolve.js";
+import path from "bare-path";
 export async function handleDownloadAsset(request, progressCallback) {
     const { assetSrc, seed } = request;
-    const profilingMeta = request[PROFILING_KEY];
-    const profilingEnabled = profilingMeta?.enabled !== false && !!profilingMeta;
     try {
-        const totalDownloadStart = profilingEnabled ? nowMs() : 0;
-        let sourceType;
-        let downloadStats;
-        if (profilingEnabled) {
-            const result = await resolveModelPathWithStats(assetSrc, progressCallback, seed);
-            sourceType = result.sourceType;
-            downloadStats = result.downloadStats;
-        }
-        else {
-            await resolveModelPath(assetSrc, progressCallback, seed);
-        }
-        const response = {
+        const assetPath = await resolveModelPath(assetSrc, progressCallback, seed);
+        return {
             type: "downloadAsset",
             success: true,
-            assetId: assetSrc,
+            assetId: path.basename(assetPath),
         };
-        if (profilingEnabled) {
-            const totalDownloadTimeMs = nowMs() - totalDownloadStart;
-            const profileId = profilingMeta?.id ?? generateProfileId();
-            const gauges = {
-                totalDownloadTime: totalDownloadTimeMs,
-            };
-            if (downloadStats) {
-                if (downloadStats.downloadTimeMs !== undefined) {
-                    gauges["downloadTime"] = downloadStats.downloadTimeMs;
-                }
-                if (downloadStats.totalBytesDownloaded !== undefined) {
-                    gauges["totalBytesDownloaded"] = downloadStats.totalBytesDownloaded;
-                }
-                if (downloadStats.downloadSpeedBps !== undefined) {
-                    gauges["downloadSpeedBps"] = downloadStats.downloadSpeedBps;
-                }
-                if (downloadStats.checksumValidationTimeMs !== undefined) {
-                    gauges["checksumValidationTime"] = downloadStats.checksumValidationTimeMs;
-                }
-            }
-            const tags = {};
-            if (sourceType) {
-                tags["sourceType"] = sourceType;
-            }
-            if (downloadStats?.cacheHit !== undefined) {
-                tags["cacheHit"] = downloadStats.cacheHit ? "true" : "false";
-            }
-            const operationEvent = {
-                op: "downloadAsset",
-                kind: "handler",
-                ms: totalDownloadTimeMs,
-                profileId,
-                gauges: Object.keys(gauges).length > 0 ? gauges : undefined,
-                tags: Object.keys(tags).length > 0 ? tags : undefined,
-            };
-            response[OPERATION_EVENT_KEY] = operationEvent;
-        }
-        return response;
     }
     catch (error) {
-        logger.error("Error downloading asset:", error);
+        console.error("Error downloading asset:", error);
         return {
             type: "downloadAsset",
             success: false,

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

@@ -1,4 +1,21 @@
-import { dispatchPluginReply } from "./plugin-dispatch.js";
+import { embed } from "../../bare/addons/llamacpp/index.js";
 export async function handleEmbed(request) {
-    return dispatchPluginReply(request.modelId, "embed", request);
+    const { modelId, text } = request;
+    try {
+        const embedding = await embed({ modelId, text });
+        return {
+            type: "embed",
+            success: true,
+            embedding,
+        };
+    }
+    catch (error) {
+        console.error("Error during embedding:", error);
+        return {
+            type: "embed",
+            success: false,
+            embedding: [],
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
 }

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

@@ -12,13 +12,7 @@ import { handleRag } from "./rag";
 import { cancelHandler } from "./cancelHandler";
 import { handleDeleteCache } from "./delete-cache";
 import { handleTextToSpeech } from "./text-to-speech";
-import { handleGetModelInfo } from "./get-model-info";
-import { handleOCRStream } from "./ocr-stream";
-import { handlePing } from "./ping";
-import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke";
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from "./registry";
 export declare const handlers: {
-    ping: typeof handlePing;
     completionStream: typeof handleCompletionStream;
     downloadAsset: typeof handleDownloadAsset;
     deleteCache: typeof handleDeleteCache;
@@ -33,12 +27,5 @@ export declare const handlers: {
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
     textToSpeech: typeof handleTextToSpeech;
-    getModelInfo: typeof handleGetModelInfo;
-    ocrStream: typeof handleOCRStream;
-    pluginInvoke: typeof handlePluginInvoke;
-    pluginInvokeStream: typeof handlePluginInvokeStream;
-    modelRegistryList: typeof handleModelRegistryList;
-    modelRegistrySearch: typeof handleModelRegistrySearch;
-    modelRegistryGetModel: typeof handleModelRegistryGetModel;
 };
 //# sourceMappingURL=index.d.ts.map

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

@@ -12,13 +12,7 @@ import { handleRag } from "./rag.js";
 import { cancelHandler } from "./cancelHandler.js";
 import { handleDeleteCache } from "./delete-cache.js";
 import { handleTextToSpeech } from "./text-to-speech.js";
-import { handleGetModelInfo } from "./get-model-info.js";
-import { handleOCRStream } from "./ocr-stream.js";
-import { handlePing } from "./ping.js";
-import { handlePluginInvoke, handlePluginInvokeStream } from "./plugin-invoke.js";
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./registry.js";
 export const handlers = {
-    ping: handlePing,
     completionStream: handleCompletionStream,
     downloadAsset: handleDownloadAsset,
     deleteCache: handleDeleteCache,
@@ -33,11 +27,4 @@ export const handlers = {
     rag: handleRag,
     cancel: cancelHandler,
     textToSpeech: handleTextToSpeech,
-    getModelInfo: handleGetModelInfo,
-    ocrStream: handleOCRStream,
-    pluginInvoke: handlePluginInvoke,
-    pluginInvokeStream: handlePluginInvokeStream,
-    modelRegistryList: handleModelRegistryList,
-    modelRegistrySearch: handleModelRegistrySearch,
-    modelRegistryGetModel: handleModelRegistryGetModel,
 };