@qvac/sdk 0.4.1 → 0.6.0

package/dist/server/bare/registry/model-registry.d.ts

@@ -1,35 +1,13 @@
-import type EventEmitter from "events";
 import type FilesystemDL from "@qvac/dl-filesystem";
+import type { CanonicalModelType } from "../../../schemas/index";
+import type BaseInference from "@qvac/infer-base";
 interface AddonInterface {
     cancel(jobId?: string): Promise<void>;
 }
-export interface AnyModel {
-    load(...args: unknown[]): Promise<void>;
-    run(input: unknown): Promise<EventEmitter & {
-        onUpdate(callback: (data: string) => void): {
-            await: () => Promise<void>;
-        };
-        onUpdate(callback: (data: {
-            outputArray: Int16Array;
-        }) => void): {
-            await: () => Promise<void>;
-        };
-        onError(callback: (error: Error) => void): void;
-        onUpdate(callback: (data: Array<{
-            text: string;
-        }>) => void): {
-            await: () => Promise<void>;
-        };
-        cancel(): Promise<void>;
-        iterate(): AsyncIterableIterator<string | Array<{
-            text: string;
-        }>>;
-        await(): Promise<void>;
-    }>;
+export type AnyModel = Omit<BaseInference, "addon"> & {
     reload?(config: unknown): Promise<void>;
-    unload?(): Promise<void>;
     addon?: AddonInterface;
-}
+};
 interface DelegateOptions {
     topic: string;
     providerPublicKey: string;
@@ -40,6 +18,7 @@ interface LocalOptions {
     path: string;
     loadedAt: Date;
     config: unknown;
+    modelType: CanonicalModelType;
     name?: string | undefined;
     loader: FilesystemDL;
 }
@@ -53,6 +32,7 @@ export declare function registerModel(id: string, options: {
     model: AnyModel;
     path: string;
     config: unknown;
+    modelType: CanonicalModelType;
     loader: FilesystemDL;
     name?: string | undefined;
 } | {

package/dist/server/bare/registry/model-registry.js

@@ -1,4 +1,6 @@
 import { ModelAlreadyRegisteredError, ModelNotFoundError, ModelIsDelegatedError, } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 // Global registry state - using stateless functions to manage it
 const modelRegistry = new Map();
 export function registerModel(id, options) {
@@ -17,7 +19,7 @@ export function registerModel(id, options) {
                 timeout,
             },
         });
-        console.log(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
+        logger.info(`Delegated model registered: ${id} -> topic: ${topic}, provider: ${providerPublicKey}, timeout: ${timeout}ms`);
     }
     else {
         modelRegistry.set(id, {
@@ -28,12 +30,13 @@ export function registerModel(id, options) {
                 path: options.path,
                 loadedAt: new Date(),
                 config: options.config,
+                modelType: options.modelType,
                 loader: options.loader,
                 name: options.name,
             },
         });
         const nameStr = options.name ? ` (${options.name})` : "";
-        console.log(`Local model registered: ${id}${nameStr} -> ${options.path}`);
+        logger.info(`Local model registered: ${id}${nameStr} -> ${options.path}`);
     }
 }
 export function getModelEntry(id) {
@@ -56,7 +59,7 @@ export function unregisterModel(id) {
     const entry = modelRegistry.get(id);
     if (entry) {
         modelRegistry.delete(id);
-        console.log(`Model unregistered: ${id}`);
+        logger.debug(`Model unregistered: ${id}`);
         return entry;
     }
     return null;
@@ -99,7 +102,7 @@ export function updateModelConfig(id, config) {
 }
 export function clearRegistry() {
     modelRegistry.clear();
-    console.log("Model registry cleared");
+    logger.info("Model registry cleared");
 }
 export function getRegistryStats() {
     return {
@@ -113,9 +116,9 @@ export async function unloadAllModels() {
         const entry = modelRegistry.get(modelId);
         if (entry?.local?.model && entry.local.model.unload) {
             await entry.local.model.unload();
-            console.log(`Model unloaded: ${modelId}`);
+            logger.debug(`Model unloaded: ${modelId}`);
         }
         modelRegistry.delete(modelId);
     }
-    console.log(`Unloaded ${modelIds.length} models`);
+    logger.info(`Unloaded ${modelIds.length} models`);
 }

package/dist/server/bare/registry/runtime-context-registry.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeContext } from "../../../schemas/index";
+export declare function setRuntimeContext(ctx: RuntimeContext): void;
+export declare function getRuntimeContext(): RuntimeContext;
+export declare function isMobile(): boolean;
+export declare function isAndroid(): boolean;
+export declare function isIOS(): boolean;
+//# sourceMappingURL=runtime-context-registry.d.ts.map

package/dist/server/bare/registry/runtime-context-registry.js

@@ -0,0 +1,26 @@
+// ============================================
+// Runtime context state
+// ============================================
+let context = {};
+let isSet = false;
+export function setRuntimeContext(ctx) {
+    if (isSet)
+        return;
+    context = ctx;
+    isSet = true;
+}
+export function getRuntimeContext() {
+    return context;
+}
+// ============================================
+// Convenience helpers
+// ============================================
+export function isMobile() {
+    return context.runtime === "react-native";
+}
+export function isAndroid() {
+    return context.platform === "android";
+}
+export function isIOS() {
+    return context.platform === "ios";
+}

package/dist/server/bare/utils/loader-adapter.d.ts

@@ -0,0 +1,7 @@
+import type FilesystemDL from "@qvac/dl-filesystem";
+/**
+ * Adapts FilesystemDL to addon Loader interface by adding download stub.
+ * download() is never called when using filesystem loader.
+ */
+export declare function asLoader<T>(loader: FilesystemDL): T;
+//# sourceMappingURL=loader-adapter.d.ts.map

package/dist/server/bare/utils/loader-adapter.js

@@ -0,0 +1,9 @@
+/**
+ * Adapts FilesystemDL to addon Loader interface by adding download stub.
+ * download() is never called when using filesystem loader.
+ */
+export function asLoader(loader) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access
+    loader.download = () => Promise.reject(new Error("download not supported"));
+    return loader;
+}

package/dist/server/error-handlers.js

@@ -1,4 +1,6 @@
 import { createErrorResponse, responseSchema } from "../schemas/index.js";
+import { getServerLogger } from "../logging/index.js";
+const logger = getServerLogger();
 export function sendErrorResponse(req, error) {
     try {
         const errorResponse = createErrorResponse(error);
@@ -6,7 +8,7 @@ export function sendErrorResponse(req, error) {
         req.reply(responseData, "utf-8");
     }
     catch (responseError) {
-        console.error("Failed to create error response:", responseError);
+        logger.error("Failed to create error response:", responseError);
         const fallbackError = createErrorResponse(new Error("Internal server error"));
         req.reply(JSON.stringify(fallbackError), "utf-8");
     }
@@ -19,7 +21,7 @@ export function sendStreamErrorResponse(stream, error) {
         stream.end();
     }
     catch (responseError) {
-        console.error("Failed to create stream error response:", responseError);
+        logger.error("Failed to create stream error response:", responseError);
         const fallbackError = createErrorResponse(new Error("Internal server error"));
         stream.write(JSON.stringify(fallbackError) + "\n", "utf-8");
         stream.end();

package/dist/server/rpc/create-server.js

@@ -1,19 +1,21 @@
 import RPC from "bare-rpc";
 import { connect } from "bare-net";
 import { handleRequest } from "./handle-request.js";
+import { getServerLogger } from "../../logging/index.js";
+const logger = getServerLogger();
 export function createBareKitRPCServer() {
     const { IPC } = globalThis
         .BareKit;
     return new RPC(IPC, handleRequest);
 }
 export function createIPCClient(socketPath) {
-    console.log(`Connecting to IPC socket at ${socketPath}`);
+    logger.info(`Connecting to IPC socket at ${socketPath}`);
     const socket = connect(socketPath);
     socket.on("connect", () => {
-        console.log("Connected to IPC server");
+        logger.info("Connected to IPC server");
     });
     socket.on("error", (err) => {
-        console.error("IPC client connection error:", err);
+        logger.error("IPC client connection error:", err);
     });
     return new RPC(socket, handleRequest);
 }

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

@@ -1,10 +1,12 @@
 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 { 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 { setSDKConfig } from "../bare/registry/config-registry.js";
+import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
 import { handleUnloadModel } from "./handlers/unload-model.js";
 import { handleTranscribeStream } from "./handlers/transcribe-stream.js";
 import { handleEmbed } from "./handlers/embed.js";
@@ -16,10 +18,12 @@ 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 { handleSetConfig } from "./handlers/set-config.js";
 import { handleGetModelInfo } from "./handlers/get-model-info.js";
+import { handleOCRStream } from "./handlers/ocr-stream.js";
 import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
 import { NoDataReceivedError, UnknownRequestTypeError, } from "../../utils/errors-client.js";
+import { normalizeModelType } from "../../schemas/index.js";
+import { resolveModelConfig } from "../bare/registry/model-config-registry.js";
 export async function handleRequest(req) {
     try {
         const rawData = req.data?.toString();
@@ -27,7 +31,31 @@ export async function handleRequest(req) {
             throw new NoDataReceivedError();
         }
         const jsonData = JSON.parse(rawData);
-        const request = requestSchema.parse(jsonData);
+        // Handle special internal config initialization message
+        if (jsonData &&
+            typeof jsonData === "object" &&
+            "type" in jsonData &&
+            jsonData.type === "__init_config") {
+            try {
+                const initData = jsonData;
+                if (initData.config) {
+                    setSDKConfig(initData.config);
+                }
+                if (initData.runtimeContext) {
+                    setRuntimeContext(initData.runtimeContext);
+                }
+                req.reply(JSON.stringify({ success: true }), "utf-8");
+            }
+            catch (error) {
+                req.reply(JSON.stringify({
+                    success: false,
+                    error: error instanceof Error ? error.message : String(error),
+                }), "utf-8");
+            }
+            return;
+        }
+        const processedData = applyDeviceDefaultsToRequest(jsonData);
+        const request = requestSchema.parse(processedData);
         switch (request.type) {
             case "downloadAsset": {
                 if (request.withProgress) {
@@ -84,13 +112,19 @@ export async function handleRequest(req) {
                         sendStreamErrorResponse(stream, error);
                     }
                 }
+                else if (request.delegate) {
+                    try {
+                        const response = await handleLoadModelDelegated(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
+                }
                 else {
-                    // Route to appropriate handler based on delegation
+                    // Load without progress/delegate, or reload config
                     try {
-                        const handler = request.delegate
-                            ? handleLoadModelDelegated
-                            : handleLoadModel;
-                        const response = await handler(request);
+                        const response = await handleLoadModel(request);
                         req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
                     }
                     catch (error) {
@@ -211,12 +245,35 @@ export async function handleRequest(req) {
                 break;
             }
             case "rag": {
-                try {
-                    const response = await handleRag(request);
-                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                // Only ingest, saveEmbeddings, and reindex support progress
+                const supportsProgress = request.operation === "ingest" ||
+                    request.operation === "saveEmbeddings" ||
+                    request.operation === "reindex";
+                const withProgress = supportsProgress && request.withProgress;
+                if (withProgress) {
+                    const stream = req.createResponseStream();
+                    try {
+                        const response = await handleRag(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);
+                    }
                 }
-                catch (error) {
-                    sendErrorResponse(req, error);
+                else {
+                    try {
+                        const response = await handleRag(request);
+                        req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    }
+                    catch (error) {
+                        sendErrorResponse(req, error);
+                    }
                 }
                 break;
             }
@@ -245,9 +302,9 @@ export async function handleRequest(req) {
                 }
                 break;
             }
-            case "setConfig": {
+            case "getModelInfo": {
                 try {
-                    const response = handleSetConfig(request);
+                    const response = await handleGetModelInfo(request);
                     req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
                 }
                 catch (error) {
@@ -255,13 +312,18 @@ export async function handleRequest(req) {
                 }
                 break;
             }
-            case "getModelInfo": {
+            case "ocrStream": {
+                const stream = req.createResponseStream();
                 try {
-                    const response = await handleGetModelInfo(request);
-                    req.reply(JSON.stringify(responseSchema.parse(response)), "utf-8");
+                    for await (const response of handleOCRStream(request)) {
+                        const validatedResponse = responseSchema.parse(response);
+                        const data = JSON.stringify(validatedResponse);
+                        stream.write(data + "\n", "utf-8");
+                    }
+                    stream.end();
                 }
                 catch (error) {
-                    sendErrorResponse(req, error);
+                    sendStreamErrorResponse(stream, error);
                 }
                 break;
             }
@@ -274,3 +336,37 @@ export async function handleRequest(req) {
         sendErrorResponse(req, error);
     }
 }
+/**
+ * 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;
+    }
+    // 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,15 +1,26 @@
 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",
@@ -17,7 +28,7 @@ export async function cancelHandler(request) {
         };
     }
     catch (error) {
-        console.error("Error during cancellation:", error);
+        logger.error("Error during cancellation:", error);
         return {
             type: "cancel",
             success: false,

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

@@ -2,6 +2,8 @@ import { getModelEntry } from "../../bare/registry/model-registry.js";
 import { getRPC } from "../../bare/delegate-rpc-client.js";
 import { stream } from "../../../client/rpc/rpc-client.js";
 import { ModelIsDelegatedError } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function* handleCompletionStreamDelegated(request) {
     // Get delegation info from model registry
     const entry = getModelEntry(request.modelId);
@@ -10,7 +12,7 @@ export async function* handleCompletionStreamDelegated(request) {
     }
     const { topic, providerPublicKey, timeout } = entry.delegated;
     try {
-        console.log(`📤 Sending delegated completionStream request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}`);
+        logger.debug(`📤 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 });
         // Use the regular stream function with the HyperSwarm RPC instance
@@ -21,7 +23,7 @@ export async function* handleCompletionStreamDelegated(request) {
         }
     }
     catch (error) {
-        console.error("Error in delegated completion stream:", error);
+        logger.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,4 @@
-import { completion } from "../../bare/addons/llamacpp/index.js";
+import { completion } from "../../bare/addons/llamacpp-completion/index.js";
 export async function* handleCompletionStream(request) {
     const filteredHistory = request.history.map(({ role, content, attachments }) => ({
         role,

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

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

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

@@ -1,4 +1,6 @@
 import { resolveModelPath } from "./load-model/resolve.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleDownloadAsset(request, progressCallback) {
     const { assetSrc, seed } = request;
     try {
@@ -10,7 +12,7 @@ export async function handleDownloadAsset(request, progressCallback) {
         };
     }
     catch (error) {
-        console.error("Error downloading asset:", error);
+        logger.error("Error downloading asset:", error);
         return {
             type: "downloadAsset",
             success: false,

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

@@ -1,4 +1,6 @@
-import { embed } from "../../bare/addons/llamacpp/index.js";
+import { embed } from "../../bare/addons/llamacpp-embedding/index.js";
+import { getServerLogger } from "../../../logging/index.js";
+const logger = getServerLogger();
 export async function handleEmbed(request) {
     const { modelId, text } = request;
     try {
@@ -10,7 +12,7 @@ export async function handleEmbed(request) {
         };
     }
     catch (error) {
-        console.error("Error during embedding:", error);
+        logger.error("Error during embedding:", error);
         return {
             type: "embed",
             success: false,

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

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

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

@@ -6,7 +6,8 @@ import { promises as fsPromises } from "bare-fs";
 import path from "bare-path";
 import { getShardPath } from "../../utils/cache.js";
 import { ModelNotFoundError } from "../../../utils/errors-server.js";
-export const handleGetModelInfo = async (request) => {
+import { normalizeModelType } from "../../../schemas/model-types.js";
+export async function handleGetModelInfo(request) {
     const { name } = request;
     const catalogEntry = models.find((m) => m.name === name);
     if (!catalogEntry) {
@@ -34,6 +35,10 @@ export const handleGetModelInfo = async (request) => {
         }
     }
     const isLoaded = loadedInstances.length > 0;
+    // Normalize addon from alias to canonical (vad passes through as-is)
+    const normalizedAddon = catalogEntry.addon === "vad"
+        ? "vad"
+        : normalizeModelType(catalogEntry.addon);
     const modelInfo = {
         name: catalogEntry.name,
         modelId: catalogEntry.modelId,
@@ -41,7 +46,7 @@ export const handleGetModelInfo = async (request) => {
         hyperbeeKey: catalogEntry.hyperbeeKey,
         expectedSize: catalogEntry.expectedSize,
         sha256Checksum: catalogEntry.sha256Checksum,
-        addon: catalogEntry.addon,
+        addon: normalizedAddon,
         isCached,
         isLoaded,
         cacheFiles,
@@ -53,7 +58,7 @@ export const handleGetModelInfo = async (request) => {
         type: "getModelInfo",
         modelInfo,
     };
-};
+}
 async function handleShardedModel(hyperdriveKey, shardMetadata) {
     const cacheFiles = [];
     let allShardsCached = true;
@@ -66,13 +71,19 @@ async function handleShardedModel(hyperdriveKey, shardMetadata) {
         let shardCachedAt;
         try {
             const stats = await fsPromises.stat(shardPath);
-            shardIsCached = stats.isFile();
-            if (shardIsCached) {
+            const fileExists = stats.isFile();
+            if (fileExists) {
                 shardActualSize = stats.size;
                 shardCachedAt = stats.mtime;
-                totalActualSize += stats.size;
-                if (!latestCachedAt || stats.mtime > latestCachedAt) {
-                    latestCachedAt = stats.mtime;
+                shardIsCached = stats.size === shard.expectedSize;
+                if (shardIsCached) {
+                    totalActualSize += stats.size;
+                    if (!latestCachedAt || stats.mtime > latestCachedAt) {
+                        latestCachedAt = stats.mtime;
+                    }
+                }
+                else {
+                    allShardsCached = false;
                 }
             }
             else {
@@ -114,10 +125,11 @@ async function handleSingleFileModel(hyperdriveKey, modelId, expectedSize, sha25
     let fileCachedAt;
     try {
         const stats = await fsPromises.stat(filePath);
-        fileIsCached = stats.isFile();
-        if (fileIsCached) {
+        const fileExists = stats.isFile();
+        if (fileExists) {
             fileActualSize = stats.size;
             fileCachedAt = stats.mtime;
+            fileIsCached = stats.size === expectedSize;
         }
     }
     catch {

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

@@ -12,6 +12,8 @@ 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";
 export declare const handlers: {
     completionStream: typeof handleCompletionStream;
     downloadAsset: typeof handleDownloadAsset;
@@ -27,7 +29,7 @@ export declare const handlers: {
     rag: typeof handleRag;
     cancel: typeof cancelHandler;
     textToSpeech: typeof handleTextToSpeech;
-    setConfig: (request: import("../../../schemas").SetConfigRequest) => import("../../../schemas").SetConfigResponse;
-    getModelInfo: (request: import("../../../schemas").GetModelInfoRequest) => Promise<import("../../../schemas").GetModelInfoResponse>;
+    getModelInfo: typeof handleGetModelInfo;
+    ocrStream: typeof handleOCRStream;
 };
 //# sourceMappingURL=index.d.ts.map