@qvac/sdk 0.14.1 → 0.16.0

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

@@ -1,5 +1,5 @@
-import type { LoadModelSrcRequest, LoadModelResponse, ModelProgressUpdate } from "../../../schemas/index";
-import type { DelegatedHandlerOptions } from "../profiling/index";
+import type { LoadModelSrcRequest, LoadModelResponse, ModelProgressUpdate } from '../../../schemas/index';
+import type { DelegatedHandlerOptions } from '../profiling/index';
 export interface HandleLoadModelDelegatedOptions extends DelegatedHandlerOptions {
     progressCallback?: (update: ModelProgressUpdate) => void;
 }

package/dist/server/rpc/handlers/load-model-delegated.js

@@ -1,24 +1,24 @@
-import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, modelInputToSrcSchema } from "../../../schemas/index.js";
-import { registerModel, isModelLoaded, unregisterModel } from "../../bare/registry/model-registry.js";
-import { send, stream, } from "../delegate-transport.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { handleLoadModel } from "./load-model/index.js";
-import { ModelLoadFailedError, DelegateNoFinalResponseError, } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
+import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, modelInputToSrcSchema } from '../../../schemas/index.js';
+import { registerModel, isModelLoaded, unregisterModel } from '../../bare/registry/model-registry.js';
+import { send, stream } from '../delegate-transport.js';
+import { getRPC } from '../../bare/delegate-rpc-client.js';
+import { handleLoadModel } from './load-model/index.js';
+import { ModelLoadFailedError, DelegateNoFinalResponseError } from '../../../utils/errors-server.js';
+import { getServerLogger } from '../../../logging/index.js';
 const logger = getServerLogger();
 export async function handleLoadModelDelegated(request, options) {
     const { progressCallback, profilingMeta } = options ?? {};
     if (!request.delegate) {
-        throw new ModelLoadFailedError("Delegate information is required for delegated load model");
+        throw new ModelLoadFailedError('Delegate information is required for delegated load model');
     }
     const { delegate } = request;
-    const { providerPublicKey, timeout, healthCheckTimeout, fallbackToLocal, forceNewConnection, } = delegate;
+    const { providerPublicKey, timeout, healthCheckTimeout, fallbackToLocal, forceNewConnection } = delegate;
     try {
-        logger.info(`📤 Sending delegated loadModel request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ""}${forceNewConnection ? " (forcing new connection)" : ""}`);
+        logger.info(`📤 Sending delegated loadModel request to provider: ${providerPublicKey}${timeout ? `, timeout: ${timeout}ms` : ''}${forceNewConnection ? ' (forcing new connection)' : ''}`);
         const rpc = await getRPC(providerPublicKey, {
             timeout,
             healthCheckTimeout,
-            forceNewConnection,
+            forceNewConnection
         });
         // Strip out the delegate field to avoid infinite delegation
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -36,16 +36,16 @@ export async function handleLoadModelDelegated(request, options) {
         }
         if (request.withProgress) {
             // Use streaming for progress updates
-            logger.debug("📊 Using streaming mode for loadModel with progress");
+            logger.debug('📊 Using streaming mode for loadModel with progress');
             const responseStream = stream(providerRequest, rpc, delegateOpts);
             for await (const response of responseStream) {
-                if (response.type === "modelProgress") {
+                if (response.type === 'modelProgress') {
                     // Forward progress updates to the client
                     if (progressCallback) {
                         progressCallback(response);
                     }
                 }
-                else if (response.type === "loadModel") {
+                else if (response.type === 'loadModel') {
                     finalResponse = response;
                     operationEvent = response[OPERATION_EVENT_KEY];
                     break;
@@ -57,7 +57,7 @@ export async function handleLoadModelDelegated(request, options) {
         }
         else {
             // Use simple send for non-progress requests
-            logger.debug("📤 Using simple send mode for loadModel");
+            logger.debug('📤 Using simple send mode for loadModel');
             const providerResponse = await send(providerRequest, rpc, delegateOpts);
             finalResponse = providerResponse;
             const typedResponse = providerResponse;
@@ -65,18 +65,18 @@ export async function handleLoadModelDelegated(request, options) {
             operationEvent = typedResponse[OPERATION_EVENT_KEY];
         }
         if (!finalResponse || !finalResponse.success) {
-            logger.error("Provider failed to load model:", finalResponse?.error);
+            logger.error('Provider failed to load model:', finalResponse?.error);
             return {
-                type: "loadModel",
+                type: 'loadModel',
                 success: false,
-                error: `Provider failed to load model: ${finalResponse?.error || "Unknown error"}`,
+                error: `Provider failed to load model: ${finalResponse?.error || 'Unknown error'}`
             };
         }
         const modelId = finalResponse.modelId ||
             modelInputToSrcSchema.parse(request.modelSrc) ||
             `delegated-${Date.now()}`;
         const delegateOptions = {
-            providerPublicKey,
+            providerPublicKey
         };
         if (timeout !== undefined) {
             delegateOptions.timeout = timeout;
@@ -91,41 +91,42 @@ export async function handleLoadModelDelegated(request, options) {
         registerModel(modelId, delegateOptions);
         logger.info(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
         const result = {
-            type: "loadModel",
+            type: 'loadModel',
             success: true,
-            modelId,
+            modelId
         };
         if (delegationBreakdown) {
-            result[DELEGATION_BREAKDOWN_KEY] =
-                delegationBreakdown;
+            ;
+            result[DELEGATION_BREAKDOWN_KEY] = delegationBreakdown;
         }
         if (operationEvent) {
+            ;
             result[OPERATION_EVENT_KEY] = operationEvent;
         }
         return result;
     }
     catch (error) {
-        logger.error("Error in delegated load model:", error);
+        logger.error('Error in delegated load model:', error);
         if (fallbackToLocal) {
-            logger.info("🔄 Fallback to local model loading enabled, attempting local load...");
+            logger.info('🔄 Fallback to local model loading enabled, attempting local load...');
             try {
                 // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 const { delegate: _, ...localRequest } = request;
                 return await handleLoadModel(localRequest, progressCallback);
             }
             catch (localError) {
-                logger.error("❌ Local fallback also failed:", localError);
+                logger.error('❌ Local fallback also failed:', localError);
                 return {
-                    type: "loadModel",
+                    type: 'loadModel',
                     success: false,
-                    error: `Both delegated and local loading failed. Delegated error: ${error instanceof Error ? error.message : String(error)}. Local error: ${localError instanceof Error ? localError.message : String(localError)}`,
+                    error: `Both delegated and local loading failed. Delegated error: ${error instanceof Error ? error.message : String(error)}. Local error: ${localError instanceof Error ? localError.message : String(localError)}`
                 };
             }
         }
         return {
-            type: "loadModel",
+            type: 'loadModel',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

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

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

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

@@ -1,18 +1,18 @@
-import { registerLoggingStream, unregisterLoggingStream, } from "../../bare/registry/logging-stream-registry.js";
+import { registerLoggingStream, unregisterLoggingStream } from '../../bare/registry/logging-stream-registry.js';
 export async function* handleLoggingStream(request) {
     const { id } = request;
     const logQueue = [];
     let pendingResolve = null;
     const streamHandler = (level, namespace, message, sourceId) => {
         const logResponse = {
-            type: "loggingStream",
+            type: 'loggingStream',
             // For the global SDK_ALL_LOG_ID stream `sourceId` is the real origin of the
             // log; for a per-id stream it equals the subscription `id`.
             id: sourceId,
             level: level,
             namespace,
             message,
-            timestamp: Date.now(),
+            timestamp: Date.now()
         };
         logQueue.push(logResponse);
         if (pendingResolve) {

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

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

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

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

package/dist/server/rpc/handlers/plugin-dispatch.js

@@ -1,7 +1,7 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getAllPlugins, getPlugin } from "../../plugins/index.js";
-import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
-import { ModelNotFoundError, ModelIsDelegatedError, ModelOperationNotSupportedError, PluginNotFoundError, PluginHandlerTypeMismatchError, } from "../../../utils/errors-server.js";
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getAllPlugins, getPlugin } from '../../plugins/index.js';
+import { profileReplyHandler, profileStreamHandler } from '../profiling/index.js';
+import { ModelNotFoundError, ModelIsDelegatedError, ModelOperationNotSupportedError, PluginNotFoundError, PluginHandlerTypeMismatchError } from '../../../utils/errors-server.js';
 function resolvePluginHandlerDef(modelId, handlerName) {
     const entry = getModelEntry(modelId);
     if (!entry) {
@@ -29,14 +29,14 @@ function resolvePluginHandler(modelId, handlerName, request) {
     const handlerDef = resolvePluginHandlerDef(modelId, handlerName);
     return {
         result: handlerDef.handler(request),
-        streaming: handlerDef.streaming,
+        streaming: handlerDef.streaming
     };
 }
 export async function dispatchPluginReply(modelId, handlerName, request) {
     return profileReplyHandler({ op: handlerName, request }, async () => {
         const { result, streaming } = resolvePluginHandler(modelId, handlerName, request);
         if (streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
+            throw new PluginHandlerTypeMismatchError(handlerName, 'reply', 'streaming');
         }
         return result;
     });
@@ -46,16 +46,16 @@ export async function* dispatchPluginStream(modelId, handlerName, request, input
         const handlerDef = resolvePluginHandlerDef(modelId, handlerName);
         if (inputStream) {
             if (!handlerDef.duplex) {
-                throw new PluginHandlerTypeMismatchError(handlerName, "duplex", handlerDef.streaming ? "streaming" : "reply");
+                throw new PluginHandlerTypeMismatchError(handlerName, 'duplex', handlerDef.streaming ? 'streaming' : 'reply');
             }
             yield* handlerDef.handler(request, inputStream);
         }
         else {
             if (handlerDef.duplex) {
-                throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "duplex");
+                throw new PluginHandlerTypeMismatchError(handlerName, 'streaming', 'duplex');
             }
             if (!handlerDef.streaming) {
-                throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
+                throw new PluginHandlerTypeMismatchError(handlerName, 'streaming', 'reply');
             }
             yield* handlerDef.handler(request);
         }

package/dist/server/rpc/handlers/plugin-invoke.d.ts

@@ -1,4 +1,4 @@
-import type { PluginInvokeRequest, PluginInvokeResponse, PluginInvokeStreamRequest, PluginInvokeStreamResponse } from "../../../schemas/plugin";
+import type { PluginInvokeRequest, PluginInvokeResponse, PluginInvokeStreamRequest, PluginInvokeStreamResponse } from '../../../schemas/plugin';
 export declare function handlePluginInvoke(request: PluginInvokeRequest): Promise<PluginInvokeResponse>;
 export declare function handlePluginInvokeStream(request: PluginInvokeStreamRequest): AsyncGenerator<PluginInvokeStreamResponse>;
 //# sourceMappingURL=plugin-invoke.d.ts.map

package/dist/server/rpc/handlers/plugin-invoke.js

@@ -1,9 +1,9 @@
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getPlugin, getPluginHandler } from "../../plugins/index.js";
-import { profileReplyHandler, profileStreamHandler, } from "../profiling/index.js";
-import { PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, PluginRequestValidationFailedError, PluginResponseValidationFailedError, ModelIsDelegatedError, ModelNotFoundError, } from "../../../utils/errors-server.js";
-import { getServerLogger } from "../../../logging/index.js";
-import { formatZodError } from "../../../utils/zod-error.js";
+import { getModelEntry } from '../../bare/registry/model-registry.js';
+import { getPlugin, getPluginHandler } from '../../plugins/index.js';
+import { profileReplyHandler, profileStreamHandler } from '../profiling/index.js';
+import { PluginNotFoundError, PluginHandlerNotFoundError, PluginHandlerTypeMismatchError, PluginRequestValidationFailedError, PluginResponseValidationFailedError, ModelIsDelegatedError, ModelNotFoundError } from '../../../utils/errors-server.js';
+import { getServerLogger } from '../../../logging/index.js';
+import { formatZodError } from '../../../utils/zod-error.js';
 const logger = getServerLogger();
 function resolvePluginHandler(modelId, handlerName) {
     const modelEntry = getModelEntry(modelId);
@@ -26,12 +26,12 @@ function resolvePluginHandler(modelId, handlerName) {
     return { modelType, plugin, handlerDef };
 }
 export async function handlePluginInvoke(request) {
-    return profileReplyHandler({ op: "pluginInvoke", request }, async () => {
+    return profileReplyHandler({ op: 'pluginInvoke', request }, async () => {
         const { modelId, handler: handlerName, params } = request;
         logger.debug(`[pluginInvoke] modelId=${modelId} handler=${handlerName}`);
         const { handlerDef } = resolvePluginHandler(modelId, handlerName);
         if (handlerDef.streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "reply", "streaming");
+            throw new PluginHandlerTypeMismatchError(handlerName, 'reply', 'streaming');
         }
         const parseResult = handlerDef.requestSchema.safeParse(params);
         if (!parseResult.success) {
@@ -43,18 +43,18 @@ export async function handlePluginInvoke(request) {
             throw new PluginResponseValidationFailedError(handlerName, formatZodError(responseParseResult.error));
         }
         return {
-            type: "pluginInvoke",
-            result: responseParseResult.data,
+            type: 'pluginInvoke',
+            result: responseParseResult.data
         };
     });
 }
 export async function* handlePluginInvokeStream(request) {
-    yield* profileStreamHandler({ op: "pluginInvokeStream", request }, async function* () {
+    yield* profileStreamHandler({ op: 'pluginInvokeStream', request }, async function* () {
         const { modelId, handler: handlerName, params } = request;
         logger.debug(`[pluginInvokeStream] modelId=${modelId} handler=${handlerName}`);
         const { handlerDef } = resolvePluginHandler(modelId, handlerName);
         if (!handlerDef.streaming) {
-            throw new PluginHandlerTypeMismatchError(handlerName, "streaming", "reply");
+            throw new PluginHandlerTypeMismatchError(handlerName, 'streaming', 'reply');
         }
         const parseResult = handlerDef.requestSchema.safeParse(params);
         if (!parseResult.success) {
@@ -67,15 +67,15 @@ export async function* handlePluginInvokeStream(request) {
                 throw new PluginResponseValidationFailedError(handlerName, formatZodError(responseParseResult.error));
             }
             yield {
-                type: "pluginInvokeStream",
+                type: 'pluginInvokeStream',
                 result: responseParseResult.data,
-                done: false,
+                done: false
             };
         }
         yield {
-            type: "pluginInvokeStream",
+            type: 'pluginInvokeStream',
             result: null,
-            done: true,
+            done: true
         };
     });
 }

package/dist/server/rpc/handlers/provideHandler/connection.d.ts

@@ -1,3 +1,3 @@
-import type Hyperswarm from "hyperswarm";
+import type Hyperswarm from 'hyperswarm';
 export declare function setupConnectionHandlers(swarm: Hyperswarm): void;
 //# sourceMappingURL=connection.d.ts.map

package/dist/server/rpc/handlers/provideHandler/connection.js

@@ -1,15 +1,15 @@
-import RPC from "bare-rpc";
-import { createRpcProxy } from "./proxy.js";
-import { hasActiveProviders } from "../../../bare/hyperswarm.js";
-import { getServerLogger } from "../../../../logging/index.js";
+import RPC from 'bare-rpc';
+import { createRpcProxy } from './proxy.js';
+import { hasActiveProviders } from '../../../bare/hyperswarm.js';
+import { getServerLogger } from '../../../../logging/index.js';
 const logger = getServerLogger();
 export function setupConnectionHandlers(swarm) {
-    logger.debug("👂 Setting up connection listener...");
-    swarm.on("close", () => {
-        logger.debug("🔗 Connection closed!");
+    logger.debug('👂 Setting up connection listener...');
+    swarm.on('close', () => {
+        logger.debug('🔗 Connection closed!');
     });
-    swarm.on("connection", (conn) => {
-        const peerPubkey = conn.remotePublicKey?.toString("hex");
+    swarm.on('connection', (conn) => {
+        const peerPubkey = conn.remotePublicKey?.toString('hex');
         // The swarm is shared between consumer and provider sides, and once
         // `swarm.listen()` has bound our keyPair on the DHT we cannot un-bind
         // it without destroying the swarm. To honor `stopQVACProvider()` —
@@ -21,18 +21,18 @@ export function setupConnectionHandlers(swarm) {
             conn.destroy();
             return;
         }
-        logger.debug("🔗 Connection event triggered!");
+        logger.debug('🔗 Connection event triggered!');
         logger.info(`📡 New connection established from: ${peerPubkey?.substring(0, 16)}...`);
-        logger.debug("🔐 Full peer public key:", peerPubkey);
-        logger.debug("⚙️ Creating RPC instance for connection...");
+        logger.debug('🔐 Full peer public key:', peerPubkey);
+        logger.debug('⚙️ Creating RPC instance for connection...');
         new RPC(conn, createRpcProxy());
-        logger.debug("✅ RPC instance created successfully");
-        conn.on("close", () => {
+        logger.debug('✅ RPC instance created successfully');
+        conn.on('close', () => {
             logger.debug(`🔌 Connection closed for peer: ${peerPubkey?.substring(0, 16)}`);
         });
-        conn.on("error", (err) => {
+        conn.on('error', (err) => {
             logger.error(`❌ Connection error for peer ${peerPubkey?.substring(0, 16)}:`, err);
         });
     });
-    logger.debug("✅ Connection listener set up");
+    logger.debug('✅ Connection listener set up');
 }

package/dist/server/rpc/handlers/provideHandler/handler.d.ts

@@ -1,3 +1,3 @@
-import type { ProvideRequest, ProvideResponse } from "../../../../schemas/provide";
+import type { ProvideRequest, ProvideResponse } from '../../../../schemas/provide';
 export declare function provideHandler(request: ProvideRequest): Promise<ProvideResponse>;
 //# sourceMappingURL=handler.d.ts.map

package/dist/server/rpc/handlers/provideHandler/handler.js

@@ -1,6 +1,6 @@
-import { getSwarm, hasActiveProviders, registerProvider, } from "../../../bare/hyperswarm.js";
-import { setupConnectionHandlers } from "./connection.js";
-import { getServerLogger } from "../../../../logging/index.js";
+import { getSwarm, hasActiveProviders, registerProvider } from '../../../bare/hyperswarm.js';
+import { setupConnectionHandlers } from './connection.js';
+import { getServerLogger } from '../../../../logging/index.js';
 const logger = getServerLogger();
 // Tracks whether the connection listener has been attached on this swarm
 // instance. `swarm.listen()` and `swarm.on("connection", ...)` cannot be
@@ -19,18 +19,18 @@ let listenerAttached = false;
 // from cleanly shutting things down).
 export async function provideHandler(request) {
     const swarm = getSwarm({
-        firewallConfig: request.firewall,
+        firewallConfig: request.firewall
     });
-    logger.debug("🚀 Provide request received:", request);
+    logger.debug('🚀 Provide request received:', request);
     try {
         const pubKey = swarm.keyPair.publicKey;
-        logger.debug("🔑 Provider public key:", pubKey.toString("hex"));
+        logger.debug('🔑 Provider public key:', pubKey.toString('hex'));
         if (hasActiveProviders()) {
-            logger.info("ℹ️ Provider already running, returning existing identity");
+            logger.info('ℹ️ Provider already running, returning existing identity');
             return {
-                type: "provide",
+                type: 'provide',
                 success: true,
-                publicKey: pubKey.toString("hex"),
+                publicKey: pubKey.toString('hex')
             };
         }
         // We must wait for the DHT routing table to populate BEFORE announcing.
@@ -38,29 +38,29 @@ export async function provideHandler(request) {
         // peers are in the routing table at that moment — if the DHT isn't
         // bootstrapped yet, that announce reaches very few nodes and consumers
         // won't be able to find us via dht.connect(publicKey).
-        logger.info("🌐 Waiting for DHT to fully bootstrap...");
+        logger.info('🌐 Waiting for DHT to fully bootstrap...');
         await swarm.dht.fullyBootstrapped();
-        logger.info("🌐 Announcing provider on DHT (binding keyPair)...");
+        logger.info('🌐 Announcing provider on DHT (binding keyPair)...');
         await swarm.listen();
-        logger.info("🎯 Provider is listening and ready to accept connections");
+        logger.info('🎯 Provider is listening and ready to accept connections');
         if (!listenerAttached) {
             setupConnectionHandlers(swarm);
             listenerAttached = true;
         }
         registerProvider();
         return {
-            type: "provide",
+            type: 'provide',
             success: true,
-            publicKey: pubKey.toString("hex"),
+            publicKey: pubKey.toString('hex')
         };
     }
     catch (error) {
-        logger.error("❌ Error in provide handler:", error);
-        logger.error("❌ Error stack:", error instanceof Error ? error.stack : "No stack trace");
+        logger.error('❌ Error in provide handler:', error);
+        logger.error('❌ Error stack:', error instanceof Error ? error.stack : 'No stack trace');
         return {
-            type: "provide",
+            type: 'provide',
             success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
+            error: error instanceof Error ? error.message : 'Unknown error'
         };
     }
 }

package/dist/server/rpc/handlers/provideHandler/proxy.d.ts

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

package/dist/server/rpc/handlers/provideHandler/proxy.js

@@ -1,24 +1,24 @@
-import { handleRequest } from "../../handle-request.js";
-import { getServerLogger } from "../../../../logging/index.js";
+import { handleRequest } from '../../handle-request.js';
+import { getServerLogger } from '../../../../logging/index.js';
 const logger = getServerLogger();
 // Proxies RPC requests to the main handler: handleRequest
 export function createRpcProxy() {
     return async (rpcRequest) => {
-        logger.debug("📬 RPC request callback triggered!");
-        logger.debug("📦 Raw RPC request data:", rpcRequest.data?.toString());
+        logger.debug('📬 RPC request callback triggered!');
+        logger.debug('📦 Raw RPC request data:', rpcRequest.data?.toString());
         try {
-            logger.debug("🚀 Calling handleRequest...");
+            logger.debug('🚀 Calling handleRequest...');
             await handleRequest(rpcRequest);
-            logger.debug("✅ handleRequest completed successfully");
+            logger.debug('✅ handleRequest completed successfully');
         }
         catch (error) {
-            logger.error("❌ Error:", error instanceof Error ? error.message : error);
+            logger.error('❌ Error:', error instanceof Error ? error.message : error);
             const errorResponse = JSON.stringify({
-                type: "error",
-                error: error instanceof Error ? error.message : "Unknown error",
+                type: 'error',
+                error: error instanceof Error ? error.message : 'Unknown error'
             });
-            logger.debug("📤 Sending error response:", errorResponse);
-            rpcRequest.reply(errorResponse, "utf-8");
+            logger.debug('📤 Sending error response:', errorResponse);
+            rpcRequest.reply(errorResponse, 'utf-8');
         }
     };
 }

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

@@ -1,2 +1,2 @@
-export { provideHandler } from "./provideHandler/handler";
+export { provideHandler } from './provideHandler/handler';
 //# sourceMappingURL=provideHandler.d.ts.map

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

@@ -1,2 +1,2 @@
 // Re-export the provideHandler from the refactored provideHandler modules
-export { provideHandler } from "./provideHandler/handler.js";
+export { provideHandler } from './provideHandler/handler.js';

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

@@ -1,3 +1,3 @@
-import type { RagRequest, RagResponse, RagProgressUpdate } from "../../../schemas/index";
+import type { RagRequest, RagResponse, RagProgressUpdate } from '../../../schemas/index';
 export declare function handleRag(request: RagRequest, onProgress?: (update: RagProgressUpdate) => void): Promise<RagResponse>;
 //# sourceMappingURL=rag.d.ts.map