@qvac/sdk 0.10.2 → 0.12.0

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

@@ -0,0 +1,297 @@
+import { AbortController } from "bare-abort-controller";
+import { createDisposableScope, } from "./disposable-scope.js";
+import { RequestIdConflictError, RequestRejectedByPolicyError, } from "../../../utils/errors-server.js";
+import { getServerLogger } from "../../../logging/index.js";
+/**
+ * Tuning knobs for the "cancelled-before-begin" bookkeeping set.
+ *
+ * The race window is bounded by the client-to-server round-trip: a
+ * `cancel({ requestId })` issued by the client at the same time as the
+ * matching `completion(...)` either lands first (and we need to remember
+ * it long enough for the server's `begin(...)` to follow) or lands
+ * second (and we never touch this set). 30 seconds is overkill for a
+ * 500ms round-trip but gives slow networks / pause-the-debugger
+ * scenarios enough slack while still bounding worst-case retention.
+ *
+ * The size cap protects against a buggy or malicious client firing a
+ * stream of cancels for ids that never get a `begin(...)` follow-up —
+ * each `cancel({ requestId })` that doesn't match an in-flight context
+ * inserts one entry, so without a cap the worker would grow the map
+ * unbounded. At the cap, the oldest entry is evicted.
+ *
+ * Tweak with care: both bounds appear in the registry race test
+ * (`bounded cancel-before-begin set does not grow past its cap`).
+ */
+const CANCEL_BEFORE_BEGIN_MAX_ENTRIES = 128;
+const CANCEL_BEFORE_BEGIN_TTL_MS = 30_000;
+export function createRequestRegistry(options) {
+    const entries = new Map();
+    const policies = new Map();
+    const logger = options?.logger ?? getServerLogger();
+    function logLifecycle(event, ctx, durationMs) {
+        const modelId = ctx.modelId !== undefined ? ctx.modelId : "-";
+        const base = `[request-lifecycle] ${event} requestId=${ctx.requestId} kind=${ctx.kind} modelId=${modelId} state=${ctx.state}`;
+        const line = durationMs !== undefined ? `${base} durationMs=${durationMs}` : base;
+        // `failed` end emits at `warn` so log shippers can alert on
+        // `level>=warn` for this prefix without parsing `state=failed`
+        // out of the message body. Everything else stays at `info`.
+        if (event === "end" && ctx.state === "failed") {
+            logger.warn(line);
+        }
+        else {
+            logger.info(line);
+        }
+    }
+    /**
+     * "Cancelled-before-begin" tripwire. A
+     * `cancel({ requestId })` whose target isn't yet in `entries` records
+     * the id here; the subsequent `begin({ requestId: <same id> })` then
+     * aborts the new controller before returning. Map order is insertion
+     * order — the iterator's first key is the oldest entry, which makes
+     * the size-cap eviction free.
+     *
+     * Invariants:
+     *   - Every read path (`begin`, `cancel`-by-id) calls
+     *     `pruneCancelBeforeBeginExpired()` first so a 30s+ stale entry
+     *     never decides a fresh `begin(...)`.
+     *   - Insertion enforces the size cap by evicting the oldest entry
+     *     when at capacity — a malicious client cannot grow this map
+     *     unbounded.
+     *   - On a successful `begin(...)` match, the entry is consumed
+     *     (removed) so a second `begin(...)` with the same id (which
+     *     would itself throw `RequestIdConflictError`) doesn't see a
+     *     phantom pre-cancel.
+     */
+    const cancelledBeforeBegin = new Map();
+    function pruneCancelBeforeBeginExpired(now = Date.now()) {
+        if (cancelledBeforeBegin.size === 0)
+            return;
+        const cutoff = now - CANCEL_BEFORE_BEGIN_TTL_MS;
+        for (const [id, entry] of cancelledBeforeBegin) {
+            if (entry.at > cutoff)
+                break; // Insertion order ⇒ rest are newer.
+            cancelledBeforeBegin.delete(id);
+        }
+    }
+    function recordCancelBeforeBegin(requestId, reason) {
+        const now = Date.now();
+        pruneCancelBeforeBeginExpired(now);
+        // Re-canceling an id that is already tracked refreshes its TTL but
+        // keeps the original reason — the first cancel "won" the race.
+        if (cancelledBeforeBegin.has(requestId)) {
+            const existing = cancelledBeforeBegin.get(requestId);
+            cancelledBeforeBegin.delete(requestId);
+            cancelledBeforeBegin.set(requestId, { ...existing, at: now });
+            return;
+        }
+        if (cancelledBeforeBegin.size >= CANCEL_BEFORE_BEGIN_MAX_ENTRIES) {
+            const oldest = cancelledBeforeBegin.keys().next().value;
+            if (oldest !== undefined)
+                cancelledBeforeBegin.delete(oldest);
+        }
+        cancelledBeforeBegin.set(requestId, reason !== undefined ? { at: now, reason } : { at: now });
+    }
+    function consumeCancelBeforeBegin(requestId) {
+        pruneCancelBeforeBeginExpired();
+        const entry = cancelledBeforeBegin.get(requestId);
+        if (!entry)
+            return undefined;
+        cancelledBeforeBegin.delete(requestId);
+        return entry;
+    }
+    function cancelEntry(entry, reason) {
+        if (entry.controller.signal.aborted)
+            return false;
+        entry.ctx.state = "cancelling";
+        entry.controller.abort(reason);
+        logLifecycle("cancel", entry.ctx);
+        return true;
+    }
+    async function disposeEntry(entry, outcome) {
+        if (entry.scope.disposed)
+            return;
+        entry.ctx.state = outcome;
+        entry.detachParent();
+        logLifecycle("end", entry.ctx, Date.now() - entry.startedAt);
+        // Pull the entry out before unwinding so observers (e.g. a `cancel(...)`
+        // racing with dispose) don't see a half-disposed context.
+        entries.delete(entry.ctx.requestId);
+        await entry.scope[Symbol.asyncDispose]();
+    }
+    function begin(opts) {
+        if (entries.has(opts.requestId)) {
+            throw new RequestIdConflictError(opts.requestId);
+        }
+        // Admission control runs before allocation so a rejected begin
+        // leaves no controller / scope behind.
+        const policy = policies.get(opts.kind);
+        if (policy && policy.oneAtATimePerModel && opts.modelId !== undefined) {
+            for (const existing of entries.values()) {
+                if (existing.ctx.kind !== opts.kind)
+                    continue;
+                if (existing.ctx.modelId !== opts.modelId)
+                    continue;
+                throw new RequestRejectedByPolicyError(opts.requestId, opts.kind, opts.modelId, `another ${opts.kind} request (${existing.ctx.requestId}) is already running on this model`);
+            }
+        }
+        const controller = new AbortController();
+        const scope = createDisposableScope();
+        // Stop-button race close. If a
+        // `cancel({ requestId })` already arrived for this id, abort the
+        // new controller before observers can subscribe to it. The
+        // tripwire entry is consumed so a later, separate `begin(...)`
+        // with the same id is unaffected (in practice ids are UUIDv4 and
+        // never reused; this guard just keeps the contract self-
+        // consistent under retries).
+        const preCancel = consumeCancelBeforeBegin(opts.requestId);
+        if (preCancel) {
+            controller.abort(preCancel.reason);
+        }
+        let detachParent = () => { };
+        if (opts.parentSignal) {
+            const parent = opts.parentSignal;
+            if (parent.aborted) {
+                controller.abort(parent.reason);
+            }
+            else {
+                const onParentAbort = () => controller.abort(parent.reason);
+                parent.addEventListener("abort", onParentAbort, { once: true });
+                detachParent = () => parent.removeEventListener("abort", onParentAbort);
+            }
+        }
+        const ctx = {
+            requestId: opts.requestId,
+            kind: opts.kind,
+            modelId: opts.modelId,
+            signal: controller.signal,
+            scope,
+            // Land the context in `cancelling` from the outset whenever the
+            // controller was already aborted by `begin(...)` itself — either
+            // the Stop-button race (`preCancel`) or a `parentSignal` that was
+            // already aborted at begin time. Both branches abort the
+            // controller above, so without this guard observers would see a
+            // momentarily-`running` context with an already-aborted signal.
+            state: preCancel || opts.parentSignal?.aborted ? "cancelling" : "running",
+        };
+        const entry = {
+            ctx,
+            controller,
+            scope,
+            detachParent,
+            startedAt: Date.now(),
+        };
+        entries.set(opts.requestId, entry);
+        logLifecycle("begin", ctx);
+        return {
+            get requestId() {
+                return ctx.requestId;
+            },
+            get kind() {
+                return ctx.kind;
+            },
+            get modelId() {
+                return ctx.modelId;
+            },
+            get signal() {
+                return ctx.signal;
+            },
+            get scope() {
+                return ctx.scope;
+            },
+            get state() {
+                return ctx.state;
+            },
+            set state(next) {
+                ctx.state = next;
+            },
+            [Symbol.asyncDispose]: async () => {
+                await disposeEntry(entry, derivedTerminalState(ctx));
+            },
+        };
+    }
+    function get(requestId) {
+        return entries.get(requestId)?.ctx ?? null;
+    }
+    function list() {
+        return Array.from(entries.values(), (e) => e.ctx);
+    }
+    function cancel(target) {
+        let cancelled = 0;
+        if ("requestId" in target) {
+            const entry = entries.get(target.requestId);
+            if (entry) {
+                if (cancelEntry(entry, target.reason))
+                    cancelled++;
+                return cancelled;
+            }
+            // Stop-button race: the client beat its own
+            // `begin(...)`. Record the cancel so the next matching `begin`
+            // aborts immediately. The return value stays 0 — no in-flight
+            // request was matched, which is still the truth — but the
+            // *effective* cancel will land when the begin arrives.
+            recordCancelBeforeBegin(target.requestId, target.reason);
+            return cancelled;
+        }
+        for (const entry of entries.values()) {
+            if (entry.ctx.modelId !== target.modelId)
+                continue;
+            if (target.kind && entry.ctx.kind !== target.kind)
+                continue;
+            if (cancelEntry(entry, target.reason))
+                cancelled++;
+        }
+        return cancelled;
+    }
+    function cancelAll(reason) {
+        for (const entry of entries.values()) {
+            cancelEntry(entry, reason);
+        }
+        // The interface returns Promise<void> so we can later make this an
+        // async sweep that awaits per-handler scope unwinding (e.g. join on
+        // the disposers). Today every handler unwinds on its own dispose
+        // path, so the function only needs to fire-and-forget the abort.
+        return Promise.resolve();
+    }
+    async function end(requestId, outcome) {
+        const entry = entries.get(requestId);
+        if (!entry)
+            return;
+        await disposeEntry(entry, outcome);
+    }
+    function policy(opts) {
+        policies.set(opts.kind, opts);
+    }
+    return {
+        begin,
+        get,
+        list,
+        cancel,
+        cancelAll,
+        end,
+        policy,
+        // Test-only: lets the registry race tests assert the bound
+        // invariants on the internal "cancelled-before-begin" set without
+        // exposing it as a public surface. Kept off the `RequestRegistry`
+        // interface (typed via the augmented return type below) so handler
+        // code can't depend on it accidentally.
+        __cancelBeforeBeginSize: () => cancelledBeforeBegin.size,
+    };
+}
+/**
+ * Test-only knobs exported for `request-registry.test.ts` so the bound
+ * assertions can pin the documented limits without re-reading them via
+ * fragile string comparison. **Not part of the public SDK surface.**
+ *
+ * @internal
+ */
+export const __requestRegistryTestHooks = {
+    cancelBeforeBeginMaxEntries: CANCEL_BEFORE_BEGIN_MAX_ENTRIES,
+    cancelBeforeBeginTtlMs: CANCEL_BEFORE_BEGIN_TTL_MS,
+};
+function derivedTerminalState(ctx) {
+    if (ctx.state === "failed")
+        return "failed";
+    if (ctx.signal.aborted || ctx.state === "cancelled")
+        return "cancelled";
+    return "completed";
+}

package/dist/server/bare/runtime/with-request-context.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from "../../../logging/types";
+export interface RequestLogContext {
+    requestId: string;
+    kind: string;
+    modelId: string | undefined;
+}
+/**
+ * Wraps `logger` so every emit is prefixed with
+ * `[request-lifecycle <kind> requestId=<id> modelId=<modelId>] `
+ * (the `modelId=...` segment is dropped when absent). The wrapper is a
+ * thin shim: `setLevel` / `getLevel` / `addTransport` / `setConsoleOutput`
+ * pass through to the underlying logger, and transport callbacks receive
+ * the prefixed message.
+ *
+ * @example
+ *   await using ctx = registry.begin({ requestId, kind: "completion", modelId });
+ *   const log = withRequestContext(getServerLogger(), ctx);
+ *   log.info("decoding token 7");
+ *   // → "[request-lifecycle completion requestId=<id> modelId=<id>] decoding token 7"
+ */
+export declare function withRequestContext(logger: Logger, ctx: RequestLogContext): Logger;
+//# sourceMappingURL=with-request-context.d.ts.map

package/dist/server/bare/runtime/with-request-context.js

@@ -0,0 +1,53 @@
+/**
+ * Wraps `logger` so every emit is prefixed with
+ * `[request-lifecycle <kind> requestId=<id> modelId=<modelId>] `
+ * (the `modelId=...` segment is dropped when absent). The wrapper is a
+ * thin shim: `setLevel` / `getLevel` / `addTransport` / `setConsoleOutput`
+ * pass through to the underlying logger, and transport callbacks receive
+ * the prefixed message.
+ *
+ * @example
+ *   await using ctx = registry.begin({ requestId, kind: "completion", modelId });
+ *   const log = withRequestContext(getServerLogger(), ctx);
+ *   log.info("decoding token 7");
+ *   // → "[request-lifecycle completion requestId=<id> modelId=<id>] decoding token 7"
+ */
+export function withRequestContext(logger, ctx) {
+    const prefix = ctx.modelId !== undefined
+        ? `[request-lifecycle ${ctx.kind} requestId=${ctx.requestId} modelId=${ctx.modelId}] `
+        : `[request-lifecycle ${ctx.kind} requestId=${ctx.requestId}] `;
+    function pick(method) {
+        switch (method) {
+            case "error":
+                return logger.error;
+            case "warn":
+                return logger.warn;
+            case "info":
+                return logger.info;
+            case "debug":
+                return logger.debug;
+            case "trace":
+                return logger.trace;
+        }
+    }
+    function emit(method, args) {
+        const sink = pick(method);
+        if (args.length === 0) {
+            sink(prefix);
+            return;
+        }
+        const [first, ...rest] = args;
+        sink(prefix + String(first), ...rest);
+    }
+    return {
+        error: (...args) => emit("error", args),
+        warn: (...args) => emit("warn", args),
+        info: (...args) => emit("info", args),
+        debug: (...args) => emit("debug", args),
+        trace: (...args) => emit("trace", args),
+        setLevel: (level) => logger.setLevel(level),
+        getLevel: () => logger.getLevel(),
+        addTransport: (transport) => logger.addTransport(transport),
+        setConsoleOutput: (enabled) => logger.setConsoleOutput(enabled),
+    };
+}

package/dist/server/bare/runtime-lifecycle.js

@@ -78,17 +78,17 @@ export async function suspendRuntime() {
         return suspendRuntime();
     }
     state = "suspending";
-    logger.info(`⏸️ Suspending runtime (${swarms.size} swarms, ${stores.size} stores)`);
+    logger.info(`⏸️ Suspending runtime (${stores.size} stores, ${swarms.size} swarms)`);
     transitionPromise = (async () => {
         const swarmSnapshot = Array.from(swarms.entries());
         const storeSnapshot = Array.from(stores.entries());
+        await runPhase(storeSnapshot, stores, async (store) => {
+            await store.suspend();
+        }, "suspend-store");
         await runPhase(swarmSnapshot, swarms, async (swarm) => {
             if (!swarm.suspended)
                 await swarm.suspend();
         }, "suspend-swarm");
-        await runPhase(storeSnapshot, stores, async (store) => {
-            await store.suspend();
-        }, "suspend-store");
     })()
         .then(() => {
         state = "suspended";
@@ -116,16 +116,16 @@ export async function resumeRuntime() {
         return resumeRuntime();
     }
     state = "resuming";
-    logger.info(`▶️ Resuming runtime (${stores.size} stores, ${swarms.size} swarms)`);
+    logger.info(`▶️ Resuming runtime (${swarms.size} swarms, ${stores.size} stores)`);
     transitionPromise = (async () => {
-        const storeSnapshot = Array.from(stores.entries());
         const swarmSnapshot = Array.from(swarms.entries());
-        await runPhase(storeSnapshot, stores, async (store) => {
-            await store.resume();
-        }, "resume-store");
+        const storeSnapshot = Array.from(stores.entries());
         await runPhase(swarmSnapshot, swarms, async (swarm) => {
             await swarm.resume();
         }, "resume-swarm");
+        await runPhase(storeSnapshot, stores, async (store) => {
+            await store.resume();
+        }, "resume-store");
     })()
         .then(() => {
         state = "active";

package/dist/server/bare/types/addon-responses.d.ts

@@ -2,6 +2,7 @@ export interface LlmStats {
     TTFT?: number;
     TPS?: number;
     CacheTokens?: number;
+    promptTokens?: number;
     generatedTokens?: number;
     backendDevice?: "cpu" | "gpu";
 }
@@ -60,8 +61,18 @@ export interface TranscribeAddonSegment {
     toAppend?: boolean;
     id?: number;
 }
+export interface TranscribeAddonVadEvent {
+    type: "vad";
+    speaking: boolean;
+    probability: number;
+}
+export interface TranscribeAddonEndOfTurnEvent {
+    type: "endOfTurn";
+    silenceDurationMs: number;
+}
+export type TranscribeAddonOutput = Array<TranscribeAddonSegment> | TranscribeAddonVadEvent | TranscribeAddonEndOfTurnEvent;
 export interface TranscribeResponse {
     stats?: TranscribeStats;
-    iterate(): AsyncIterable<Array<TranscribeAddonSegment>>;
+    iterate(): AsyncIterable<TranscribeAddonOutput>;
 }
 //# sourceMappingURL=addon-responses.d.ts.map

package/dist/server/env.js

@@ -11,7 +11,10 @@ let validatedEnv = null;
  * Returns whether RPC config was parsed from arguments.
  */
 export function initEnv() {
-    const defaultHomeDir = process.env["HOME"] ??
+    const defaultHomeDir = 
+    // Snap's HOME can be revision-scoped; SNAP_USER_COMMON is stable.
+    process.env["SNAP_USER_COMMON"] ??
+        process.env["HOME"] ??
         process.env["USERPROFILE"] ??
         "/tmp";
     let envConfig = {

package/dist/server/plugins/index.d.ts

@@ -1,2 +1,2 @@
-export { registerPlugin, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry";
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry";
 //# sourceMappingURL=index.d.ts.map

package/dist/server/plugins/index.js

@@ -1 +1 @@
-export { registerPlugin, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry.js";
+export { registerPlugin, registerPlugins, getPlugin, getPluginHandler, hasPlugin, getAllPlugins, clearPlugins, unregisterPlugin, } from "./registry.js";

package/dist/server/plugins/registry.d.ts

@@ -1,5 +1,6 @@
 import { type QvacPlugin, type PluginHandlerDefinition } from "../../schemas/plugin";
 export declare function registerPlugin(plugin: QvacPlugin): void;
+export declare function registerPlugins(pluginList: readonly QvacPlugin[]): void;
 export declare function getPlugin(modelType: string): QvacPlugin | undefined;
 export declare function getPluginHandler(modelType: string, handlerName: string): PluginHandlerDefinition | undefined;
 export declare function hasPlugin(modelType: string): boolean;

package/dist/server/plugins/registry.js

@@ -43,6 +43,11 @@ export function registerPlugin(plugin) {
         loggingModule.setLogger(createAddonLoggerCallback(plugin.logging.namespace));
     }
 }
+export function registerPlugins(pluginList) {
+    for (const plugin of pluginList) {
+        registerPlugin(plugin);
+    }
+}
 export function getPlugin(modelType) {
     return plugins.get(modelType);
 }

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

@@ -27,6 +27,9 @@ import { handleFinetune } from "./handlers/finetune.js";
 import { handleHeartbeatDelegated } from "./handlers/heartbeat-delegated.js";
 import { handleCancelDelegated } from "./handlers/cancel-delegated.js";
 import { handleDiffusionStream } from "./handlers/diffusion-stream.js";
+import { handleVideoStream } from "./handlers/video-stream.js";
+import { handleUpscaleStream } from "./handlers/upscale-stream.js";
+import { handleClassify } from "./handlers/classify.js";
 import { handlePluginInvoke, handlePluginInvokeStream, } from "./handlers/plugin-invoke.js";
 import { handleModelRegistryList, handleModelRegistrySearch, handleModelRegistryGetModel, } from "./handlers/registry.js";
 import { handleSuspend } from "./handlers/suspend.js";
@@ -48,16 +51,33 @@ function isModelDelegated(request) {
     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 === "inference" || request.operation === "embeddings") {
-        return isModelDelegated(request);
-    }
-    if (request.operation === "downloadAsset") {
-        return !!request.delegate;
-    }
-    return false;
+    if (request.operation !== "broad")
+        return false;
+    return isModelDelegated(request);
 }
 export const registry = {
     // Simple Reply handlers
@@ -104,6 +124,9 @@ export const registry = {
     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: {

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

@@ -0,0 +1,9 @@
+import type { Request } from "../../schemas/index";
+import type { HandlerEntry } from "./handler-utils";
+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

@@ -0,0 +1,14 @@
+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.js

@@ -6,6 +6,7 @@ import { setRuntimeContext } from "../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 "./handler-selection.js";
 function getProfilingMetaFromRequest(request) {
     if (PROFILING_KEY in request) {
         return request[PROFILING_KEY];
@@ -74,9 +75,7 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
     const stream = req.createResponseStream();
     profiler.startHandler();
     const writeBatch = (updates) => {
-        const payload = updates
-            .map((u) => profiler.serialize(u, false))
-            .join("\n");
+        const payload = updates.map((u) => profiler.serialize(u, false)).join("\n");
         stream.write(payload + "\n", "utf-8");
     };
     const throttle = createProgressThrottle(writeBatch);
@@ -105,9 +104,7 @@ async function executeProgressHandler(req, request, handler, profiler, isDelegat
     }
 }
 export async function executeDuplexHandler(_req, request, entry, inputStream, outputStream, profiler) {
-    const handler = entry.delegatedHandler && entry.isDelegated?.(request)
-        ? entry.delegatedHandler
-        : entry.handler;
+    const { handler } = selectHandler(entry, request);
     profiler.startHandler();
     try {
         for await (const response of handler(request, inputStream)) {
@@ -127,13 +124,8 @@ export async function executeDuplexHandler(_req, request, entry, inputStream, ou
 }
 // 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);
+    const { handler, isDelegated } = selectHandler(entry, request);
+    const wantsProgress = handlerSupportsProgress(entry, request);
     if (entry.type === "duplex") {
         throw new PluginHandlerTypeMismatchError(request.type, "reply or stream", "duplex");
     }