@qvac/sdk 0.8.1 → 1.0.0

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

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

package/dist/server/rpc/delegate-utils.d.ts

@@ -1,2 +0,0 @@
-export declare function getNextCommandId(): number;
-//# sourceMappingURL=delegate-utils.d.ts.map

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

@@ -1,5 +0,0 @@
-let commandCounter = 0;
-export function getNextCommandId() {
-    commandCounter = (commandCounter + 1) % Number.MAX_SAFE_INTEGER;
-    return commandCounter;
-}

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

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

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

@@ -1,113 +0,0 @@
-import {} from "../../schemas/index.js";
-import { handleCompletionStream } from "./handlers/completion-stream.js";
-import { handleDownloadAsset } from "./handlers/download-asset.js";
-import { handleLoadModel } from "./handlers/load-model/index.js";
-import { handleLoadModelDelegated } from "./handlers/load-model-delegated.js";
-import { handleCompletionStreamDelegated } from "./handlers/completion-stream-delegated.js";
-import { getModelEntry } from "../bare/registry/model-registry.js";
-import { handleUnloadModel } from "./handlers/unload-model.js";
-import { handleUnloadModelDelegated } from "./handlers/unload-model-delegated.js";
-import { 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 { handleGetModelInfo } from "./handlers/get-model-info.js";
-import { handleOCRStream } from "./handlers/ocr-stream.js";
-import { handleHeartbeat } from "./handlers/heartbeat.js";
-import { handleHeartbeatDelegated } from "./handlers/heartbeat-delegated.js";
-import { handleCancelDelegated } from "./handlers/cancel-delegated.js";
-import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
-function ragSupportsProgress(request) {
-    if (request.type !== "rag")
-        return false;
-    return ["ingest", "saveEmbeddings", "reindex"].includes(request.operation);
-}
-function isModelDelegated(request) {
-    if (!("modelId" in request))
-        return false;
-    const entry = getModelEntry(request.modelId);
-    return entry?.isDelegated ?? false;
-}
-function isCancelDelegated(request) {
-    if (request.type !== "cancel")
-        return false;
-    if (request.operation === "inference") {
-        return isModelDelegated(request);
-    }
-    if (request.operation === "downloadAsset") {
-        return !!request.delegate;
-    }
-    return false;
-}
-export const registry = {
-    // Simple Reply handlers
-    heartbeat: {
-        type: "reply",
-        handler: handleHeartbeat,
-        delegatedHandler: handleHeartbeatDelegated,
-        isDelegated: (r) => r.type === "heartbeat" && !!r.delegate,
-    },
-    unloadModel: {
-        type: "reply",
-        handler: handleUnloadModel,
-        delegatedHandler: handleUnloadModelDelegated,
-        isDelegated: isModelDelegated,
-    },
-    embed: { type: "reply", handler: handleEmbed },
-    cancel: {
-        type: "reply",
-        handler: cancelHandler,
-        delegatedHandler: handleCancelDelegated,
-        isDelegated: isCancelDelegated,
-    },
-    provide: { type: "reply", handler: provideHandler },
-    stopProvide: { type: "reply", handler: stopProvideHandler },
-    deleteCache: { type: "reply", handler: handleDeleteCache },
-    getModelInfo: { type: "reply", handler: handleGetModelInfo },
-    pluginInvoke: { type: "reply", handler: handlePluginInvoke },
-    modelRegistryList: { type: "reply", handler: handleModelRegistryList },
-    modelRegistrySearch: { type: "reply", handler: handleModelRegistrySearch },
-    modelRegistryGetModel: {
-        type: "reply",
-        handler: handleModelRegistryGetModel,
-    },
-    // Simple Stream handlers
-    transcribeStream: { type: "stream", handler: handleTranscribeStream },
-    loggingStream: { type: "stream", handler: handleLoggingStream },
-    translate: { type: "stream", handler: handleTranslate },
-    textToSpeech: { type: "stream", handler: handleTextToSpeech },
-    ocrStream: { type: "stream", handler: handleOCRStream },
-    pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },
-    // Handlers with delegation support
-    loadModel: {
-        type: "reply",
-        handler: handleLoadModel,
-        delegatedHandler: handleLoadModelDelegated,
-        isDelegated: (r) => r.type === "loadModel" && !!r.delegate,
-        supportsProgress: true,
-    },
-    completionStream: {
-        type: "stream",
-        handler: handleCompletionStream,
-        delegatedHandler: handleCompletionStreamDelegated,
-        isDelegated: isModelDelegated,
-    },
-    // Handlers with progress support
-    downloadAsset: {
-        type: "reply",
-        handler: handleDownloadAsset,
-        supportsProgress: true,
-    },
-    rag: {
-        type: "reply",
-        handler: handleRag,
-        supportsProgress: ragSupportsProgress,
-    },
-};

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

@@ -1,23 +0,0 @@
-import { type QvacConfig, type Request, type Response, type RuntimeContext } from "../../schemas/index";
-import type RPC from "bare-rpc";
-import { type ServerProfiler } from "./profiling/index";
-type ReplyHandler = (request: any, ...args: any[]) => Promise<Response> | Response;
-type StreamHandler = (request: any, ...args: any[]) => AsyncGenerator<Response>;
-type ProgressHandler = (request: any, ...args: any[]) => Promise<Response>;
-export type HandlerEntry = {
-    type: "reply" | "stream";
-    handler: ReplyHandler | StreamHandler | ProgressHandler;
-    delegatedHandler?: ReplyHandler | StreamHandler | ProgressHandler;
-    isDelegated?: (request: Request) => boolean;
-    supportsProgress?: boolean | ((request: Request) => boolean);
-};
-export declare function executeHandler(req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, profiler: ServerProfiler): Promise<void>;
-type InitConfigMessage = {
-    type: "__init_config";
-    config: QvacConfig;
-    runtimeContext?: RuntimeContext;
-};
-export declare function isInitConfigMessage(data: unknown): data is InitConfigMessage;
-export declare function handleInitConfig(req: RPC.IncomingRequest, data: InitConfigMessage): void;
-export {};
-//# sourceMappingURL=handler-utils.d.ts.map

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

@@ -1,170 +0,0 @@
-import { PROFILING_KEY, } from "../../schemas/index.js";
-import { sendErrorResponse, sendStreamErrorResponse, } from "../error-handlers.js";
-import { setSDKConfig } from "../bare/registry/config-registry.js";
-import { setRuntimeContext } from "../bare/registry/runtime-context-registry.js";
-import {} from "./profiling/index.js";
-import { nowMs } from "../../profiling/clock.js";
-function getProfilingMetaFromRequest(request) {
-    if (PROFILING_KEY in request) {
-        return request[PROFILING_KEY];
-    }
-    return undefined;
-}
-async function executeReplyHandler(req, request, handler, profiler, isDelegated) {
-    profiler.startHandler();
-    try {
-        let response;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            response = await handler(request, profilingMeta ? { profilingMeta } : undefined);
-        }
-        else {
-            response = await handler(request);
-        }
-        profiler.endHandler();
-        req.reply(profiler.serialize(response, true), "utf-8");
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendErrorResponse(req, error, profiler);
-    }
-}
-async function executeStreamHandler(req, request, handler, profiler, isDelegated) {
-    const stream = req.createResponseStream();
-    profiler.startHandler();
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let generator;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            generator = handler(request, profilingMeta ? { profilingMeta } : undefined);
-        }
-        else {
-            generator = handler(request);
-        }
-        for await (const response of generator) {
-            stream.write(profiler.serialize(response, false) + "\n", "utf-8");
-        }
-        profiler.endHandler();
-        const trailer = profiler.serialize();
-        if (trailer) {
-            stream.write(trailer + "\n", "utf-8");
-        }
-        stream.end();
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
-    }
-}
-const PROGRESS_THROTTLE_MS = 150;
-async function executeProgressHandler(req, request, handler, profiler, isDelegated) {
-    const stream = req.createResponseStream();
-    profiler.startHandler();
-    let lastProgressWrite = 0;
-    let pendingUpdate = null;
-    let flushTimer = null;
-    const writeProgress = (update) => {
-        stream.write(profiler.serialize(update, false) + "\n", "utf-8");
-    };
-    const progressCallback = (update) => {
-        const now = nowMs();
-        if (now - lastProgressWrite >= PROGRESS_THROTTLE_MS) {
-            lastProgressWrite = now;
-            pendingUpdate = null;
-            writeProgress(update);
-        }
-        else {
-            pendingUpdate = update;
-            if (!flushTimer) {
-                flushTimer = setTimeout(() => {
-                    flushTimer = null;
-                    if (pendingUpdate) {
-                        lastProgressWrite = nowMs();
-                        writeProgress(pendingUpdate);
-                        pendingUpdate = null;
-                    }
-                }, PROGRESS_THROTTLE_MS - (now - lastProgressWrite));
-            }
-        }
-    };
-    try {
-        let response;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            const options = { progressCallback };
-            if (profilingMeta) {
-                options.profilingMeta = profilingMeta;
-            }
-            response = await handler(request, options);
-        }
-        else {
-            response = await handler(request, progressCallback);
-        }
-        if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
-        }
-        if (pendingUpdate) {
-            writeProgress(pendingUpdate);
-            pendingUpdate = null;
-        }
-        profiler.endHandler();
-        stream.write(profiler.serialize(response, true) + "\n", "utf-8");
-        stream.end();
-    }
-    catch (error) {
-        if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
-        }
-        if (pendingUpdate) {
-            writeProgress(pendingUpdate);
-            pendingUpdate = null;
-        }
-        profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
-    }
-}
-// Unified handler executor with delegation and progress support
-export async function executeHandler(req, request, entry, profiler) {
-    const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
-    const handler = isDelegated ? entry.delegatedHandler : entry.handler;
-    const wantsProgress = "withProgress" in request &&
-        request.withProgress &&
-        (typeof entry.supportsProgress === "function"
-            ? entry.supportsProgress(request)
-            : entry.supportsProgress);
-    if (entry.type === "stream") {
-        await executeStreamHandler(req, request, handler, profiler, isDelegated);
-    }
-    else if (wantsProgress) {
-        await executeProgressHandler(req, request, handler, profiler, isDelegated);
-    }
-    else {
-        await executeReplyHandler(req, request, handler, profiler, isDelegated);
-    }
-}
-export function isInitConfigMessage(data) {
-    return (typeof data === "object" &&
-        data !== null &&
-        "type" in data &&
-        data.type === "__init_config");
-}
-export function handleInitConfig(req, data) {
-    try {
-        if (data.config) {
-            setSDKConfig(data.config);
-        }
-        if (data.runtimeContext) {
-            setRuntimeContext(data.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");
-    }
-}

package/dist/server/rpc/handlers/cancel-delegated.d.ts

@@ -1,4 +0,0 @@
-import type { CancelRequest, CancelResponse } from "../../../schemas/cancel";
-import type { DelegatedHandlerOptions } from "../profiling/index";
-export declare function handleCancelDelegated(request: CancelRequest, options?: DelegatedHandlerOptions): Promise<CancelResponse>;
-//# sourceMappingURL=cancel-delegated.d.ts.map

package/dist/server/rpc/handlers/cancel-delegated.js

@@ -1,71 +0,0 @@
-import { getServerLogger } from "../../../logging/index.js";
-import { getModelEntry } from "../../bare/registry/model-registry.js";
-import { getRPC } from "../../bare/delegate-rpc-client.js";
-import { send } from "../delegate-transport.js";
-const logger = getServerLogger();
-function resolveDelegationTarget(request) {
-    if (request.operation === "inference") {
-        const entry = getModelEntry(request.modelId);
-        if (!entry?.isDelegated || !entry.delegated) {
-            return null;
-        }
-        const target = {
-            topic: entry.delegated.topic,
-            providerPublicKey: entry.delegated.providerPublicKey,
-        };
-        if (entry.delegated.timeout !== undefined) {
-            target.timeout = entry.delegated.timeout;
-        }
-        return target;
-    }
-    if (request.operation === "downloadAsset" && request.delegate) {
-        const target = {
-            topic: request.delegate.topic,
-            providerPublicKey: request.delegate.providerPublicKey,
-        };
-        if (request.delegate.timeout !== undefined) {
-            target.timeout = request.delegate.timeout;
-        }
-        return target;
-    }
-    return null;
-}
-function toProviderCancelRequest(request) {
-    if (request.operation !== "downloadAsset") {
-        return request;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { delegate: _delegate, ...providerRequest } = request;
-    return providerRequest;
-}
-export async function handleCancelDelegated(request, options) {
-    const target = resolveDelegationTarget(request);
-    if (!target) {
-        logger.warn(`Delegated cancel skipped (no delegation target): operation=${request.operation}`);
-        return { type: "cancel", success: true };
-    }
-    try {
-        const rpc = await getRPC(target.topic, target.providerPublicKey, {
-            timeout: target.timeout,
-        });
-        const delegateOpts = {
-            peerKey: target.providerPublicKey,
-        };
-        if (target.timeout !== undefined) {
-            delegateOpts.timeout = target.timeout;
-        }
-        if (options?.profilingMeta) {
-            delegateOpts.profilingMeta = options.profilingMeta;
-        }
-        await send(toProviderCancelRequest(request), rpc, delegateOpts);
-        return { type: "cancel", success: true };
-    }
-    catch (error) {
-        logger.error("Error during delegated cancellation:", error);
-        return {
-            type: "cancel",
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-}

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

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