@qvac/sdk 0.18.2 → 0.19.0

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

@@ -1,179 +0,0 @@
-import {} from '../../schemas/index.js';
-import { handleBatchCompletionStream } from '../../server/rpc/handlers/batch-completion-stream.js';
-import { handleCompletionOrchestrate } from '../../server/rpc/handlers/completion-orchestrate.js';
-import { handleCompletionStream } from '../../server/rpc/handlers/completion-stream.js';
-import { handleDownloadAsset } from '../../server/rpc/handlers/download-asset.js';
-import { handleLoadModel } from '../../server/rpc/handlers/load-model/index.js';
-import { handleLoadModelDelegated } from '../../server/rpc/handlers/load-model-delegated.js';
-import { handleCompletionStreamDelegated } from '../../server/rpc/handlers/completion-stream-delegated.js';
-import { getModelEntry } from '../../server/bare/registry/model-registry.js';
-import { handleUnloadModel } from '../../server/rpc/handlers/unload-model.js';
-import { handleUnloadModelDelegated } from '../../server/rpc/handlers/unload-model-delegated.js';
-import { handleTranscribe } from '../../server/rpc/handlers/transcribe.js';
-import { handleTranscribeStream } from '../../server/rpc/handlers/transcribe-stream.js';
-import { handleBciTranscribe } from '../../server/rpc/handlers/bci-transcribe.js';
-import { handleBciTranscribeStream } from '../../server/rpc/handlers/bci-transcribe-stream.js';
-import { handleEmbed } from '../../server/rpc/handlers/embed.js';
-import { handleTranslate } from '../../server/rpc/handlers/translate.js';
-import { handleLoggingStream } from '../../server/rpc/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 '../../server/rpc/handlers/rag.js';
-import { handleDeleteCache } from '../../server/rpc/handlers/delete-cache.js';
-import { handleTextToSpeech } from '../../server/rpc/handlers/text-to-speech.js';
-import { handleTextToSpeechStream } from '../../server/rpc/handlers/text-to-speech-stream.js';
-import { handleGetModelInfo } from '../../server/rpc/handlers/get-model-info.js';
-import { handleGetLoadedModelInfo } from '../../server/rpc/handlers/get-loaded-model-info.js';
-import { handleGetSystemResources } from '../../server/rpc/handlers/get-system-resources.js';
-import { handleOCRStream } from '../../server/rpc/handlers/ocr-stream.js';
-import { handleHeartbeat } from '../../server/rpc/handlers/heartbeat.js';
-import { handleFinetune } from '../../server/rpc/handlers/finetune.js';
-import { handleHeartbeatDelegated } from '../../server/rpc/handlers/heartbeat-delegated.js';
-import { handleCancelDelegated } from '../../server/rpc/handlers/cancel-delegated.js';
-import { handleDiffusionStream } from '../../server/rpc/handlers/diffusion-stream.js';
-import { handleVideoStream } from '../../server/rpc/handlers/video-stream.js';
-import { handleUpscaleStream } from '../../server/rpc/handlers/upscale-stream.js';
-import { handleClassify } from '../../server/rpc/handlers/classify.js';
-import { handleAudioGenStream } from '../../server/rpc/handlers/audio-gen-stream.js';
-import { handlePluginInvoke, handlePluginInvokeStream } from '../../server/rpc/handlers/plugin-invoke.js';
-import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel } from '../../server/rpc/handlers/registry.js';
-import { handleSuspend } from '../../server/rpc/handlers/suspend.js';
-import { handleResume } from '../../server/rpc/handlers/resume.js';
-import { handleState } from '../../server/rpc/handlers/state.js';
-function ragSupportsProgress(request) {
-    if (request.type !== 'rag')
-        return false;
-    return ['ingest', 'saveEmbeddings', 'reindex'].includes(request.operation);
-}
-function finetuneSupportsProgress(request) {
-    if (request.type !== 'finetune')
-        return false;
-    return ['start', 'resume', undefined].includes(request.operation);
-}
-function isModelDelegated(request) {
-    if (!('modelId' in request))
-        return false;
-    const entry = getModelEntry(request.modelId);
-    return entry?.isDelegated ?? false;
-}
-/**
- * Should the cancel be forwarded to a delegated provider?
- *
- * After the 0.11.0 wire-schema collapse the cancel envelope has two
- * operations:
- *
- *  - `request` — targeted cancel by `requestId`. Always handled
- *    locally: the worker-singleton `RequestRegistry` is the source of
- *    truth for active requests (delegated handlers register their own
- *    requests on it the same way local handlers do), so a `requestId`
- *    cancel always lands on the right worker without needing a hop
- *    through the provider. Returning `false` here keeps the cancel on
- *    the local cancel handler, where it routes through the registry
- *    and (for downloads) the `markClearCacheForRequest` helper.
- *
- *  - `broad` — abort every in-flight request on a model. Forwarded to
- *    the delegated provider iff the targeted model itself is
- *    delegated; the provider then runs the same broad-cancel sweep
- *    server-side. Local broad cancels for non-delegated models stay
- *    on this worker.
- */
-function isCancelDelegated(request) {
-    if (request.type !== 'cancel')
-        return false;
-    if (request.operation !== 'broad')
-        return false;
-    return isModelDelegated(request);
-}
-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 },
-    getLoadedModelInfo: { type: 'reply', handler: handleGetLoadedModelInfo },
-    getSystemResources: { type: 'reply', handler: handleGetSystemResources },
-    pluginInvoke: { type: 'reply', handler: handlePluginInvoke },
-    modelRegistryList: { type: 'reply', handler: handleModelRegistryList },
-    modelRegistrySearch: { type: 'reply', handler: handleModelRegistrySearch },
-    modelRegistryGetModel: {
-        type: 'reply',
-        handler: handleModelRegistryGetModel
-    },
-    suspend: { type: 'reply', handler: handleSuspend },
-    resume: { type: 'reply', handler: handleResume },
-    state: { type: 'reply', handler: handleState },
-    // Simple Stream handlers
-    audioGenStream: { type: 'stream', handler: handleAudioGenStream },
-    transcribe: { type: 'stream', handler: handleTranscribe },
-    transcribeStream: { type: 'duplex', handler: handleTranscribeStream },
-    bciTranscribe: { type: 'stream', handler: handleBciTranscribe },
-    bciTranscribeStream: { type: 'duplex', handler: handleBciTranscribeStream },
-    loggingStream: { type: 'stream', handler: handleLoggingStream },
-    translate: { type: 'stream', handler: handleTranslate },
-    textToSpeech: { type: 'stream', handler: handleTextToSpeech },
-    textToSpeechStream: { type: 'duplex', handler: handleTextToSpeechStream },
-    ocrStream: { type: 'stream', handler: handleOCRStream },
-    diffusionStream: { type: 'stream', handler: handleDiffusionStream },
-    videoStream: { type: 'stream', handler: handleVideoStream },
-    upscaleStream: { type: 'stream', handler: handleUpscaleStream },
-    classify: { type: 'stream', handler: handleClassify },
-    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
-    },
-    // Deliberately no delegated handler: tool callbacks execute code on the
-    // client machine, so only the user's own local worker may orchestrate
-    // (see completionOrchestrateResponseSchema's contract note).
-    completionOrchestrate: { type: 'duplex', handler: handleCompletionOrchestrate },
-    batchCompletionStream: {
-        type: 'stream',
-        handler: handleBatchCompletionStream
-    },
-    // Handlers with progress support
-    downloadAsset: {
-        type: 'reply',
-        handler: handleDownloadAsset,
-        supportsProgress: true
-    },
-    rag: {
-        type: 'reply',
-        handler: handleRag,
-        supportsProgress: ragSupportsProgress
-    },
-    finetune: {
-        type: 'reply',
-        handler: handleFinetune,
-        supportsProgress: finetuneSupportsProgress
-    }
-};

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

@@ -1,9 +0,0 @@
-import type { Request } from '../../schemas/index.js';
-import type { HandlerEntry } from '../../server/rpc/handler-utils.js';
-export interface HandlerSelection {
-    handler: HandlerEntry['handler'];
-    isDelegated: boolean;
-}
-export declare function selectHandler(entry: HandlerEntry, request: Request): HandlerSelection;
-export declare function handlerSupportsProgress(entry: HandlerEntry, request: Request): boolean;
-//# sourceMappingURL=handler-selection.d.ts.map

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

@@ -1,14 +0,0 @@
-export function selectHandler(entry, request) {
-    const isDelegated = !!(entry.delegatedHandler && entry.isDelegated?.(request));
-    return {
-        handler: isDelegated ? entry.delegatedHandler : entry.handler,
-        isDelegated
-    };
-}
-export function handlerSupportsProgress(entry, request) {
-    return !!('withProgress' in request &&
-        request.withProgress &&
-        (typeof entry.supportsProgress === 'function'
-            ? entry.supportsProgress(request)
-            : entry.supportsProgress));
-}

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

@@ -1,30 +0,0 @@
-import { type QvacConfig, type Request, type Response, type RuntimeContext } from '../../schemas/index.js';
-import type RPC from 'bare-rpc';
-import { type ServerProfiler } from './profiling/index.js';
-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>;
-type DuplexStreamHandler = (request: any, inputStream: any) => AsyncGenerator<Response>;
-export type HandlerEntry = {
-    type: 'reply' | 'stream' | 'duplex';
-    handler: ReplyHandler | StreamHandler | ProgressHandler | DuplexStreamHandler;
-    delegatedHandler?: ReplyHandler | StreamHandler | ProgressHandler | DuplexStreamHandler;
-    isDelegated?: (request: Request) => boolean;
-    supportsProgress?: boolean | ((request: Request) => boolean);
-};
-export declare function executeDuplexHandler(_req: RPC.IncomingRequest, request: Request, entry: HandlerEntry, inputStream: ReturnType<RPC.IncomingRequest['createRequestStream']>, outputStream: ReturnType<RPC.IncomingRequest['createResponseStream']>, profiler: ServerProfiler): Promise<void>;
-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;
-type ShutdownMessage = {
-    type: '__shutdown__';
-};
-export declare function isShutdownMessage(data: unknown): data is ShutdownMessage;
-export declare function handleShutdown(req: RPC.IncomingRequest): Promise<void>;
-export {};
-//# sourceMappingURL=handler-utils.d.ts.map

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

@@ -1,183 +0,0 @@
-import { PROFILING_KEY } from '../../schemas/index.js';
-import { sendErrorResponse, sendStreamErrorResponse } from '../../server/error-handlers.js';
-import { PluginHandlerTypeMismatchError } from '../../utils/errors-server.js';
-import { setSDKConfig } from '../../server/bare/registry/config-registry.js';
-import { setRuntimeContext } from '../../server/bare/registry/runtime-context-registry.js';
-import {} from './profiling/index.js';
-import { isTerminalChunk } from './rpc-utils.js';
-import { createProgressThrottle } from './progress-throttle.js';
-import { handlerSupportsProgress, selectHandler } from '../../server/rpc/handler-selection.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();
-    let sentFinalChunk = false;
-    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) {
-            if (isTerminalChunk(response)) {
-                profiler.endHandler();
-                stream.write(profiler.serialize(response, true) + '\n', 'utf-8');
-                sentFinalChunk = true;
-            }
-            else {
-                stream.write(profiler.serialize(response, false) + '\n', 'utf-8');
-            }
-        }
-        // Fallback
-        if (!sentFinalChunk) {
-            profiler.endHandler();
-            const trailer = profiler.serialize();
-            if (trailer) {
-                stream.write(trailer + '\n', 'utf-8');
-            }
-        }
-        stream.end();
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
-    }
-}
-async function executeProgressHandler(req, request, handler, profiler, isDelegated) {
-    const stream = req.createResponseStream();
-    profiler.startHandler();
-    const writeBatch = (updates) => {
-        const payload = updates.map((u) => profiler.serialize(u, false)).join('\n');
-        stream.write(payload + '\n', 'utf-8');
-    };
-    const throttle = createProgressThrottle(writeBatch);
-    try {
-        let response;
-        if (isDelegated) {
-            const profilingMeta = getProfilingMetaFromRequest(request);
-            const options = { progressCallback: throttle.push };
-            if (profilingMeta) {
-                options.profilingMeta = profilingMeta;
-            }
-            response = await handler(request, options);
-        }
-        else {
-            response = await handler(request, throttle.push);
-        }
-        throttle.flush();
-        profiler.endHandler();
-        stream.write(profiler.serialize(response, true) + '\n', 'utf-8');
-        stream.end();
-    }
-    catch (error) {
-        throttle.flush();
-        profiler.endHandler();
-        sendStreamErrorResponse(stream, error, profiler);
-    }
-}
-export async function executeDuplexHandler(_req, request, entry, inputStream, outputStream, profiler) {
-    const { handler } = selectHandler(entry, request);
-    profiler.startHandler();
-    try {
-        for await (const response of handler(request, inputStream)) {
-            outputStream.write(profiler.serialize(response, false) + '\n', 'utf-8');
-        }
-        profiler.endHandler();
-        const trailer = profiler.serialize();
-        if (trailer) {
-            outputStream.write(trailer + '\n', 'utf-8');
-        }
-        outputStream.end();
-    }
-    catch (error) {
-        profiler.endHandler();
-        sendStreamErrorResponse(outputStream, error, profiler);
-    }
-}
-// Unified handler executor with delegation and progress support
-export async function executeHandler(req, request, entry, profiler) {
-    const { handler, isDelegated } = selectHandler(entry, request);
-    const wantsProgress = handlerSupportsProgress(entry, request);
-    if (entry.type === 'duplex') {
-        throw new PluginHandlerTypeMismatchError(request.type, 'reply or stream', 'duplex');
-    }
-    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');
-    }
-}
-export function isShutdownMessage(data) {
-    return (typeof data === 'object' &&
-        data !== null &&
-        'type' in data &&
-        data.type === '__shutdown__');
-}
-export async function handleShutdown(req) {
-    try {
-        // Lazy import to avoid the import cycle:
-        //   handler-utils -> worker-core -> create-server -> handle-request
-        //   -> handler-utils. By the time this runs, all modules are loaded.
-        const { cleanupForTerminate } = await import('../../server/worker-core.js');
-        await cleanupForTerminate();
-        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/audio-gen-stream.d.ts

@@ -1,3 +0,0 @@
-import type { AudioGenStreamRequest, AudioGenStreamResponse } from '../../../schemas/audio-gen.js';
-export declare function handleAudioGenStream(request: AudioGenStreamRequest): AsyncGenerator<AudioGenStreamResponse>;
-//# sourceMappingURL=audio-gen-stream.d.ts.map

package/dist/server/rpc/handlers/audio-gen-stream.js

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

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

@@ -1,80 +0,0 @@
-import type { BatchCompletionStreamRequest } from '../../../schemas/index.js';
-export declare function handleBatchCompletionStream(request: BatchCompletionStreamRequest): AsyncGenerator<{
-    type: "batchCompletionStream";
-    events: {
-        id: string;
-        event: {
-            type: "contentDelta";
-            seq: number;
-            text: string;
-        } | {
-            type: "rawDelta";
-            seq: number;
-            text: string;
-        } | {
-            type: "thinkingDelta";
-            seq: number;
-            text: string;
-        } | {
-            type: "toolCall";
-            seq: number;
-            call: {
-                id: string;
-                name: string;
-                arguments: Record<string, unknown>;
-                raw?: string | undefined;
-            };
-        } | {
-            type: "toolError";
-            seq: number;
-            error: {
-                code: "PARSE_ERROR" | "VALIDATION_ERROR" | "UNKNOWN_TOOL";
-                message: string;
-                raw?: string | undefined;
-            };
-        } | {
-            type: "completionStats";
-            seq: number;
-            stats: {
-                timeToFirstToken?: number | undefined;
-                tokensPerSecond?: number | undefined;
-                cacheTokens?: number | undefined;
-                promptTokens?: number | undefined;
-                generatedTokens?: number | undefined;
-                emittedTokens?: number | undefined;
-                avgConcurrentSeq?: number | undefined;
-                backendDevice?: "gpu" | "cpu" | undefined;
-            };
-        } | {
-            type: "completionDone";
-            seq: number;
-            stopReason: "error";
-            error: {
-                message: string;
-            };
-            raw?: {
-                fullText: string;
-            } | undefined;
-        } | {
-            type: "completionDone";
-            seq: number;
-            stopReason?: "cancelled" | "eos" | "length" | "stopSequence" | undefined;
-            raw?: {
-                fullText: string;
-            } | undefined;
-        };
-    }[];
-    done?: boolean | undefined;
-    ids?: string[] | undefined;
-    stats?: {
-        timeToFirstToken?: number | undefined;
-        tokensPerSecond?: number | undefined;
-        cacheTokens?: number | undefined;
-        promptTokens?: number | undefined;
-        generatedTokens?: number | undefined;
-        emittedTokens?: number | undefined;
-        avgConcurrentSeq?: number | undefined;
-        backendDevice?: "gpu" | "cpu" | undefined;
-    } | undefined;
-}, void, any>;
-//# sourceMappingURL=batch-completion-stream.d.ts.map

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

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

package/dist/server/rpc/handlers/bci-transcribe-stream.d.ts

@@ -1,3 +0,0 @@
-import type { BciTranscribeStreamRequest, BciTranscribeStreamResponse } from '../../../schemas/index.js';
-export declare function handleBciTranscribeStream(request: BciTranscribeStreamRequest, inputStream: AsyncIterable<Buffer>): AsyncGenerator<BciTranscribeStreamResponse>;
-//# sourceMappingURL=bci-transcribe-stream.d.ts.map

package/dist/server/rpc/handlers/bci-transcribe-stream.js

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

package/dist/server/rpc/handlers/bci-transcribe.d.ts

@@ -1,3 +0,0 @@
-import type { BciTranscribeRequest, BciTranscribeResponse } from '../../../schemas/index.js';
-export declare function handleBciTranscribe(request: BciTranscribeRequest): AsyncGenerator<BciTranscribeResponse>;
-//# sourceMappingURL=bci-transcribe.d.ts.map

package/dist/server/rpc/handlers/bci-transcribe.js

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

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

@@ -1,4 +0,0 @@
-import type { CancelRequest, CancelResponse } from '../../../schemas/cancel.js';
-import type { DelegatedHandlerOptions } from '../../../server/rpc/profiling/index.js';
-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,66 +0,0 @@
-import { getServerLogger } from '../../../logging/index.js';
-import { getModelEntry } from '../../../server/bare/registry/model-registry.js';
-import { getRPC } from '../../../server/bare/delegate-rpc-client.js';
-import { send } from '../../../server/rpc/delegate-transport.js';
-const logger = getServerLogger();
-/**
- * Resolve the delegated provider for a cancel request, if any.
- *
- * After the 0.11.0 wire-schema collapse the cancel envelope has only
- * two operations. Only `broad` cancels delegate at the cancel layer —
- * see `isCancelDelegated` in `handler-registry.ts` for the policy and
- * the rationale.
- *
- * The targeted `request` arm is handled locally because the registry
- * is worker-singleton and already holds the entry for delegated
- * requests (the delegated handler registers its own context on the
- * provider-facing side). For pre-0.11.0 behaviour where a `requestId`
- * cancel against a delegated model needed to round-trip to the
- * provider, hold onto the delegated `loadModel(...).requestId` and
- * fire a broad cancel against the model id instead.
- */
-function resolveDelegationTarget(request) {
-    if (request.operation !== 'broad')
-        return null;
-    const entry = getModelEntry(request.modelId);
-    if (!entry?.isDelegated)
-        return null;
-    const target = {
-        providerPublicKey: entry.delegated.providerPublicKey
-    };
-    if (entry.delegated.timeout !== undefined) {
-        target.timeout = entry.delegated.timeout;
-    }
-    return target;
-}
-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.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(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/cancelHandler.d.ts

@@ -1,32 +0,0 @@
-import type { CancelRequest, CancelResponse } from '../../../schemas/cancel.js';
-/**
- * Cancel RPC entry point. The 5-arm `switch (request.operation)`
- * dispatcher that lived here through 0.10.x was retired in 0.11.0:
- * every long-running handler now registers itself on the
- * worker-singleton `RequestRegistry`, so the cancel surface narrows to
- * two paths that route through the same registry primitive:
- *
- *  - `{ operation: "request", requestId, clearCache? }` — targeted
- *    cancel by client-generated id. Looks up the registry entry,
- *    fires its abort signal, optionally marks the underlying download
- *    transfer for cache clear. The "stop-button race" case (client
- *    cancel beats its own begin to the worker) is handled inside the
- *    registry via the cancel-before-begin tripwire.
- *
- *  - `{ operation: "broad", modelId, kind? }` — abort every in-flight
- *    request on a model (optionally narrowed by `kind`). Used for
- *    model unload, app shutdown, and admin sweeps where the caller
- *    has no `requestId`. Delegates to the `cancel` bare op so the
- *    `ModelNotLoadedError` validation is shared with internal
- *    server-side broad cancels.
- *
- * Always returns `success: true` plus a `cancelled` count (the number
- * of contexts this call flipped to `cancelling` — already-cancelled
- * contexts are not counted). A targeted cancel with no in-flight
- * match still returns `success: true, cancelled: 0`; the
- * cancel-before-begin tripwire ensures the cancel is applied
- * retroactively if a matching begin arrives within the registry's
- * race window.
- */
-export declare function cancelHandler(request: CancelRequest): CancelResponse;
-//# sourceMappingURL=cancelHandler.d.ts.map