@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,60 +0,0 @@
-import type { SourceType } from '../../../../schemas/index.js';
-import type { AbortSignal } from 'bare-abort-controller';
-import type { DisposableScope } from '../../../../server/bare/runtime/disposable-scope.js';
-export interface DownloadStats {
-    downloadTimeMs?: number;
-    totalBytesDownloaded?: number;
-    downloadSpeedBps?: number;
-    checksumValidationTimeMs?: number;
-    cacheHit?: boolean;
-    sharedTransfer?: boolean;
-}
-export interface ResolveResult {
-    path: string;
-    sourceType: SourceType;
-    downloadStats?: DownloadStats;
-}
-export interface DownloadResult {
-    path: string;
-    stats?: DownloadStats;
-}
-/**
- * Internal request binding threaded through `DownloadHooks` so the
- * download manager's `startOrJoinDownload` can register a per-subscriber
- * cancel hook against the caller's `RequestContext`. The binding's
- * fields mirror the registry context's surface area: `signal` is wired
- * to a subscriber-removing listener, `scope` registers the idempotent
- * cleanup, and `requestId` lets `cancelTransfer` (legacy entry point)
- * route cancels through `registry.cancel(...)` rather than reaching
- * into the transfer directly.
- */
-export interface DownloadRequestBinding {
-    signal: AbortSignal;
-    scope: DisposableScope;
-    requestId: string;
-}
-export interface DownloadHooks {
-    onDownloadKey?: (key: string) => void;
-    markCacheHit?: () => void;
-    markCacheMiss?: () => void;
-    markSharedTransfer?: () => void;
-    addChecksumValidationTimeMs?: (durationMs: number) => void;
-    /**
-     * When set, `startOrJoinDownload` attaches a per-subscriber cancel
-     * listener bound to this request. `registry.cancel({ requestId })`
-     * aborts only this subscriber; the transfer keeps running for siblings
-     * joined on the same `downloadKey` until the last subscriber leaves.
-     */
-    requestBinding?: DownloadRequestBinding;
-}
-export interface LoadModelProfilingMeta {
-    sourceType?: string;
-    downloadStats?: DownloadStats;
-    modelInitializationTimeMs?: number;
-    totalLoadTimeMs?: number;
-}
-export declare function buildDownloadProfilingFields(downloadStats: DownloadStats | undefined, sourceType?: string): {
-    gauges: Record<string, number>;
-    tags: Record<string, string>;
-};
-//# sourceMappingURL=types.d.ts.map

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

@@ -1,28 +0,0 @@
-export function buildDownloadProfilingFields(downloadStats, sourceType) {
-    const gauges = {};
-    const tags = {};
-    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;
-        }
-        if (downloadStats.cacheHit !== undefined) {
-            tags['cacheHit'] = downloadStats.cacheHit ? 'true' : 'false';
-        }
-        if (downloadStats.sharedTransfer) {
-            tags['sharedTransfer'] = 'true';
-        }
-    }
-    if (sourceType) {
-        tags['sourceType'] = sourceType;
-    }
-    return { gauges, tags };
-}

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

@@ -1,7 +0,0 @@
-import type { LoadModelSrcRequest, LoadModelResponse, ModelProgressUpdate } from '../../../schemas/index.js';
-import type { DelegatedHandlerOptions } from '../../../server/rpc/profiling/index.js';
-export interface HandleLoadModelDelegatedOptions extends DelegatedHandlerOptions {
-    progressCallback?: (update: ModelProgressUpdate) => void;
-}
-export declare function handleLoadModelDelegated(request: LoadModelSrcRequest, options?: HandleLoadModelDelegatedOptions): Promise<LoadModelResponse>;
-//# sourceMappingURL=load-model-delegated.d.ts.map

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

@@ -1,132 +0,0 @@
-import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, modelInputToSrcSchema } from '../../../schemas/index.js';
-import { registerModel, isModelLoaded, unregisterModel } from '../../../server/bare/registry/model-registry.js';
-import { send, stream } from '../../../server/rpc/delegate-transport.js';
-import { getRPC } from '../../../server/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');
-    }
-    const { delegate } = request;
-    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)' : ''}`);
-        const rpc = await getRPC(providerPublicKey, {
-            timeout,
-            healthCheckTimeout,
-            forceNewConnection
-        });
-        // Strip out the delegate field to avoid infinite delegation
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { delegate: _, ...providerRequest } = request;
-        let finalResponse;
-        let delegationBreakdown;
-        let operationEvent;
-        // Build delegate options with profiling metadata
-        const delegateOpts = { peerKey: providerPublicKey };
-        if (profilingMeta) {
-            delegateOpts.profilingMeta = profilingMeta;
-        }
-        if (timeout) {
-            delegateOpts.timeout = timeout;
-        }
-        if (request.withProgress) {
-            // Use streaming for progress updates
-            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') {
-                    // Forward progress updates to the client
-                    if (progressCallback) {
-                        progressCallback(response);
-                    }
-                }
-                else if (response.type === 'loadModel') {
-                    finalResponse = response;
-                    operationEvent = response[OPERATION_EVENT_KEY];
-                    break;
-                }
-            }
-            if (!finalResponse) {
-                throw new DelegateNoFinalResponseError();
-            }
-        }
-        else {
-            // Use simple send for non-progress requests
-            logger.debug('📤 Using simple send mode for loadModel');
-            const providerResponse = await send(providerRequest, rpc, delegateOpts);
-            finalResponse = providerResponse;
-            const typedResponse = providerResponse;
-            delegationBreakdown = typedResponse[DELEGATION_BREAKDOWN_KEY];
-            operationEvent = typedResponse[OPERATION_EVENT_KEY];
-        }
-        if (!finalResponse || !finalResponse.success) {
-            logger.error('Provider failed to load model:', finalResponse?.error);
-            return {
-                type: 'loadModel',
-                success: false,
-                error: `Provider failed to load model: ${finalResponse?.error || 'Unknown error'}`
-            };
-        }
-        const modelId = finalResponse.modelId ||
-            modelInputToSrcSchema.parse(request.modelSrc) ||
-            `delegated-${Date.now()}`;
-        const delegateOptions = {
-            providerPublicKey
-        };
-        if (timeout !== undefined) {
-            delegateOptions.timeout = timeout;
-        }
-        if (healthCheckTimeout !== undefined) {
-            delegateOptions.healthCheckTimeout = healthCheckTimeout;
-        }
-        if (isModelLoaded(modelId)) {
-            logger.info(`Delegated model ${modelId} is already registered, replacing with new provider: ${providerPublicKey}`);
-            unregisterModel(modelId);
-        }
-        registerModel(modelId, delegateOptions);
-        logger.info(`✅ Delegated model registered: ${modelId} -> provider: ${providerPublicKey}`);
-        const result = {
-            type: 'loadModel',
-            success: true,
-            modelId
-        };
-        if (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);
-        if (fallbackToLocal) {
-            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);
-                return {
-                    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)}`
-                };
-            }
-        }
-        return {
-            type: 'loadModel',
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error'
-        };
-    }
-}

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

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

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

@@ -1,39 +0,0 @@
-import { registerLoggingStream, unregisterLoggingStream } from '../../../server/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',
-            // 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()
-        };
-        logQueue.push(logResponse);
-        if (pendingResolve) {
-            const resolve = pendingResolve;
-            pendingResolve = null;
-            resolve();
-        }
-    };
-    registerLoggingStream(id, streamHandler);
-    try {
-        while (true) {
-            while (logQueue.length > 0) {
-                yield logQueue.shift();
-            }
-            // Wait for new logs - stream will terminate when client disconnects
-            await new Promise((resolve) => {
-                pendingResolve = resolve;
-            });
-        }
-    }
-    finally {
-        unregisterLoggingStream(id, streamHandler);
-    }
-}

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

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

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

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

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

@@ -1,3 +0,0 @@
-export declare function dispatchPluginReply<TRequest, TResponse>(modelId: string, handlerName: string, request: TRequest): Promise<TResponse>;
-export declare function dispatchPluginStream<TRequest, TResponse>(modelId: string, handlerName: string, request: TRequest, inputStream?: AsyncIterable<Buffer>): AsyncGenerator<TResponse>;
-//# sourceMappingURL=plugin-dispatch.d.ts.map

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

@@ -1,63 +0,0 @@
-import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
-import { getAllPlugins, getPlugin } from '../../../server/plugins/index.js';
-import { profileReplyHandler, profileStreamHandler } from '../../../server/rpc/profiling/index.js';
-import { ModelNotFoundError, ModelIsDelegatedError, ModelOperationNotSupportedError, PluginNotFoundError, PluginHandlerTypeMismatchError } from '../../../utils/errors-server.js';
-function resolvePluginHandlerDef(modelId, handlerName) {
-    const entry = getModelEntry(modelId);
-    if (!entry) {
-        throw new ModelNotFoundError(modelId);
-    }
-    if (entry.isDelegated) {
-        throw new ModelIsDelegatedError(modelId);
-    }
-    const plugin = getPlugin(entry.local.modelType);
-    if (!plugin) {
-        throw new PluginNotFoundError(entry.local.modelType);
-    }
-    const handlerDef = plugin.handlers[handlerName];
-    if (!handlerDef) {
-        const loadedModelType = entry.local.modelType;
-        const supportedOperations = Object.keys(plugin.handlers);
-        const suggestedModelTypes = getAllPlugins()
-            .filter((p) => p.modelType !== loadedModelType && handlerName in p.handlers)
-            .map((p) => p.modelType);
-        throw new ModelOperationNotSupportedError(modelId, loadedModelType, handlerName, supportedOperations, suggestedModelTypes);
-    }
-    return handlerDef;
-}
-function resolvePluginHandler(modelId, handlerName, request) {
-    const handlerDef = resolvePluginHandlerDef(modelId, handlerName);
-    return {
-        result: handlerDef.handler(request),
-        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');
-        }
-        return result;
-    });
-}
-export async function* dispatchPluginStream(modelId, handlerName, request, inputStream) {
-    yield* profileStreamHandler({ op: handlerName, request }, async function* () {
-        const handlerDef = resolvePluginHandlerDef(modelId, handlerName);
-        if (inputStream) {
-            if (!handlerDef.duplex) {
-                throw new PluginHandlerTypeMismatchError(handlerName, 'duplex', handlerDef.streaming ? 'streaming' : 'reply');
-            }
-            yield* handlerDef.handler(request, inputStream);
-        }
-        else {
-            if (handlerDef.duplex) {
-                throw new PluginHandlerTypeMismatchError(handlerName, 'streaming', 'duplex');
-            }
-            if (!handlerDef.streaming) {
-                throw new PluginHandlerTypeMismatchError(handlerName, 'streaming', 'reply');
-            }
-            yield* handlerDef.handler(request);
-        }
-    });
-}

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

@@ -1,4 +0,0 @@
-import type { PluginInvokeRequest, PluginInvokeResponse, PluginInvokeStreamRequest, PluginInvokeStreamResponse } from '../../../schemas/plugin.js';
-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,81 +0,0 @@
-import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
-import { getPlugin, getPluginHandler } from '../../../server/plugins/index.js';
-import { profileReplyHandler, profileStreamHandler } from '../../../server/rpc/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);
-    if (!modelEntry) {
-        throw new ModelNotFoundError(modelId);
-    }
-    if (modelEntry.isDelegated) {
-        throw new ModelIsDelegatedError(modelId);
-    }
-    const modelType = modelEntry.local.modelType;
-    const plugin = getPlugin(modelType);
-    if (!plugin) {
-        throw new PluginNotFoundError(modelType);
-    }
-    const handlerDef = getPluginHandler(modelType, handlerName);
-    if (!handlerDef) {
-        const availableHandlers = Object.keys(plugin.handlers);
-        throw new PluginHandlerNotFoundError(modelType, handlerName, availableHandlers);
-    }
-    return { modelType, plugin, handlerDef };
-}
-export async function handlePluginInvoke(request) {
-    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');
-        }
-        const parseResult = handlerDef.requestSchema.safeParse(params);
-        if (!parseResult.success) {
-            throw new PluginRequestValidationFailedError(handlerName, formatZodError(parseResult.error));
-        }
-        const result = await handlerDef.handler(parseResult.data);
-        const responseParseResult = handlerDef.responseSchema.safeParse(result);
-        if (!responseParseResult.success) {
-            throw new PluginResponseValidationFailedError(handlerName, formatZodError(responseParseResult.error));
-        }
-        return {
-            type: 'pluginInvoke',
-            result: responseParseResult.data
-        };
-    });
-}
-export async function* handlePluginInvokeStream(request) {
-    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');
-        }
-        const parseResult = handlerDef.requestSchema.safeParse(params);
-        if (!parseResult.success) {
-            throw new PluginRequestValidationFailedError(handlerName, formatZodError(parseResult.error));
-        }
-        const generator = handlerDef.handler(parseResult.data);
-        for await (const chunk of generator) {
-            const responseParseResult = handlerDef.responseSchema.safeParse(chunk);
-            if (!responseParseResult.success) {
-                throw new PluginResponseValidationFailedError(handlerName, formatZodError(responseParseResult.error));
-            }
-            yield {
-                type: 'pluginInvokeStream',
-                result: responseParseResult.data,
-                done: false
-            };
-        }
-        yield {
-            type: 'pluginInvokeStream',
-            result: null,
-            done: true
-        };
-    });
-}

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

@@ -1,3 +0,0 @@
-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,38 +0,0 @@
-import RPC from 'bare-rpc';
-import { createRpcProxy } from './proxy.js';
-import { hasActiveProviders } from '../../../../server/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!');
-    });
-    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()` —
-        // which decrements `activeProviderCount` to 0 — we drop incoming
-        // connections at the RPC layer when there's no active provider, so
-        // peers can no longer dispatch delegated requests at us.
-        if (!hasActiveProviders()) {
-            logger.debug(`🚪 Dropping inbound connection from ${peerPubkey?.substring(0, 16)}... — provider is stopped`);
-            conn.destroy();
-            return;
-        }
-        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...');
-        new RPC(conn, createRpcProxy());
-        logger.debug('✅ RPC instance created successfully');
-        conn.on('close', () => {
-            logger.debug(`🔌 Connection closed for peer: ${peerPubkey?.substring(0, 16)}`);
-        });
-        conn.on('error', (err) => {
-            logger.error(`❌ Connection error for peer ${peerPubkey?.substring(0, 16)}:`, err);
-        });
-    });
-    logger.debug('✅ Connection listener set up');
-}

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

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

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

@@ -1,66 +0,0 @@
-import { getSwarm, hasActiveProviders, registerProvider } from '../../../../server/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
-// undone without destroying the swarm (which is shared with consumers), so
-// we only ever set them up once per process and gate inbound RPC mounting
-// inside the listener on `hasActiveProviders()`.
-let listenerAttached = false;
-// Consumers reach the provider by calling `dht.connect(publicKey)` directly,
-// so the provider only needs its DHT server bound on its keyPair — no topic
-// announce required. `swarm.listen()` is the minimal operation that makes
-// the keyPair reachable on the DHT.
-//
-// This handler is idempotent: a second `startQVACProvider()` call returns
-// success without re-listening, re-attaching listeners, or double-counting
-// the active-provider counter (which would prevent a single `stopQVACProvider`
-// from cleanly shutting things down).
-export async function provideHandler(request) {
-    const swarm = getSwarm({
-        firewallConfig: request.firewall
-    });
-    logger.debug('🚀 Provide request received:', request);
-    try {
-        const pubKey = swarm.keyPair.publicKey;
-        logger.debug('🔑 Provider public key:', pubKey.toString('hex'));
-        if (hasActiveProviders()) {
-            logger.info('ℹ️ Provider already running, returning existing identity');
-            return {
-                type: 'provide',
-                success: true,
-                publicKey: pubKey.toString('hex')
-            };
-        }
-        // We must wait for the DHT routing table to populate BEFORE announcing.
-        // `swarm.listen()` only does a single initial announce using whatever
-        // 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...');
-        await swarm.dht.fullyBootstrapped();
-        logger.info('🌐 Announcing provider on DHT (binding keyPair)...');
-        await swarm.listen();
-        logger.info('🎯 Provider is listening and ready to accept connections');
-        if (!listenerAttached) {
-            setupConnectionHandlers(swarm);
-            listenerAttached = true;
-        }
-        registerProvider();
-        return {
-            type: 'provide',
-            success: true,
-            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');
-        return {
-            type: 'provide',
-            success: false,
-            error: error instanceof Error ? error.message : 'Unknown error'
-        };
-    }
-}

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

@@ -1,3 +0,0 @@
-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 +0,0 @@
-import { handleRequest } from '../../../../server/rpc/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());
-        try {
-            logger.debug('🚀 Calling handleRequest...');
-            await handleRequest(rpcRequest);
-            logger.debug('✅ handleRequest completed successfully');
-        }
-        catch (error) {
-            logger.error('❌ Error:', error instanceof Error ? error.message : error);
-            const errorResponse = JSON.stringify({
-                type: 'error',
-                error: error instanceof Error ? error.message : 'Unknown error'
-            });
-            logger.debug('📤 Sending error response:', errorResponse);
-            rpcRequest.reply(errorResponse, 'utf-8');
-        }
-    };
-}

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

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

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

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

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

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