@qvac/sdk 0.10.1 → 0.11.0

package/dist/server/bare/runtime/request-registry.d.ts

@@ -0,0 +1,136 @@
+import { type AbortSignal } from "bare-abort-controller";
+import type { RequestContext, RequestKind } from "./request-context";
+import type { Logger } from "../../../logging/types";
+/**
+ * Outcome the caller declares when terminating a request through
+ * `registry.end(...)`. The registry maps it to a terminal `RequestState`
+ * before disposing the scope so observers see a coherent final state.
+ */
+export type RequestOutcome = "completed" | "failed" | "cancelled";
+export interface BeginOpts {
+    /** Stable identity. Caller-provided so the client and server agree. */
+    requestId: string;
+    kind: RequestKind;
+    modelId?: string;
+    /**
+     * Optional parent abort signal — typically the worker-level "shutdown"
+     * signal. When the parent aborts, the request's own signal aborts too.
+     * Composes through a `addEventListener("abort", ...)` hook so cancelling
+     * the parent does not require iterating the registry.
+     */
+    parentSignal?: AbortSignal;
+}
+export interface CancelByRequestId {
+    requestId: string;
+    reason?: string;
+}
+export interface CancelByModelId {
+    modelId: string;
+    kind?: RequestKind;
+    reason?: string;
+}
+export type CancelTarget = CancelByRequestId | CancelByModelId;
+/**
+ * Per-kind admission rule. Kinds without a registered policy have no
+ * admission control (every `begin(...)` is accepted as long as the
+ * request id is unique).
+ */
+export interface ConcurrencyPolicy {
+    kind: RequestKind;
+    /**
+     * When true, at most one in-flight request per `(kind, modelId)`
+     * tuple — a second `begin(...)` rejects with
+     * `RequestRejectedByPolicyError`. Requests without a `modelId` are
+     * unaffected.
+     */
+    oneAtATimePerModel: boolean;
+}
+/**
+ * `ManagedRequestContext` is the value `begin(...)` returns. It extends
+ * `RequestContext` with an async-dispose method so handlers can write:
+ *
+ *   await using ctx = registry.begin({ ... });
+ *
+ * On dispose the scope unwinds (LIFO cleanup) and the registry slot is
+ * freed. If the handler doesn't override `ctx.state` before unwinding,
+ * the registry derives the terminal state from `signal.aborted` —
+ * `"cancelled"` when an abort was recorded, `"completed"` otherwise.
+ */
+export interface ManagedRequestContext extends RequestContext {
+    [Symbol.asyncDispose](): Promise<void>;
+}
+export interface RequestRegistry {
+    /**
+     * Open a new request. Throws:
+     *  - `RequestIdConflictError` if `requestId` is already present
+     *    (UUIDv4 collision is astronomically unlikely; the guard exists
+     *    so a buggy client retry sending the same id can't silently
+     *    overwrite an in-flight request).
+     *  - `RequestRejectedByPolicyError` if a concurrency policy was
+     *    registered for `opts.kind` and the new request would violate
+     *    it (e.g. `oneAtATimePerModel` rejects when another request
+     *    with the same `(kind, modelId)` pair is already in flight).
+     */
+    begin(opts: BeginOpts): ManagedRequestContext;
+    /**
+     * Register or replace the concurrency policy for a `RequestKind`.
+     * Subsequent `begin(...)` calls for that kind run the policy before
+     * allocating a controller / scope. One policy per kind — calling
+     * twice replaces the previous declaration.
+     *
+     * @example
+     *   r.policy({ kind: "completion", oneAtATimePerModel: true });
+     *   await using a = r.begin({ requestId: "r-1", kind: "completion", modelId: "m1" });
+     *   r.begin({ requestId: "r-2", kind: "completion", modelId: "m1" });
+     *   // → throws RequestRejectedByPolicyError (code 52420)
+     */
+    policy(opts: ConcurrencyPolicy): void;
+    /** Look up an in-flight request by id. */
+    get(requestId: string): RequestContext | null;
+    /**
+     * Snapshot of currently-tracked requests. Useful for diagnostics /
+     * structured logs ("which requests are in flight right now?"). Returns
+     * a fresh array; mutations on it are not observed by the registry.
+     */
+    list(): RequestContext[];
+    /**
+     * Cancel matching requests. Returns the number of contexts whose abort
+     * was triggered by *this* call (already-cancelled contexts are skipped
+     * so callers can rely on the count to log "n requests cancelled" once).
+     *
+     * For `{ modelId }` and an optional `kind`, cancels every active
+     * request that matches the predicate. This is the broad-cancel path
+     * the pre-registry `cancel({ modelId })` API maps to.
+     */
+    cancel(target: CancelTarget): number;
+    /**
+     * Cancel every active request — the worker-shutdown / model-unload
+     * sweep. The reason is forwarded to each request as the abort reason
+     * so handler logs can distinguish a normal cancel from a sweep.
+     * Resolves once all targeted contexts have flipped to `"cancelling"`;
+     * scope unwinding still happens on each handler's own dispose path.
+     */
+    cancelAll(reason: "shutdown" | "modelUnload"): Promise<void>;
+    /**
+     * Mark a request finished and dispose its scope. Equivalent to
+     * `await ctx[Symbol.asyncDispose]()` with an explicit outcome.
+     * Idempotent — calling `end` after a scope dispose is a no-op.
+     */
+    end(requestId: string, outcome: RequestOutcome): Promise<void>;
+}
+export declare function createRequestRegistry(options?: {
+    /** Defaults to `getServerLogger()`. Tests inject a stub. */
+    logger?: Logger;
+}): RequestRegistry;
+/**
+ * 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 declare const __requestRegistryTestHooks: {
+    cancelBeforeBeginMaxEntries: number;
+    cancelBeforeBeginTtlMs: number;
+};
+//# sourceMappingURL=request-registry.d.ts.map

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/types/addon-responses.d.ts

@@ -60,8 +60,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/rpc/handler-registry.js

@@ -27,6 +27,7 @@ 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 { handleUpscaleStream } from "./handlers/upscale-stream.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 +49,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 +122,7 @@ export const registry = {
     textToSpeechStream: { type: "duplex", handler: handleTextToSpeechStream },
     ocrStream: { type: "stream", handler: handleOCRStream },
     diffusionStream: { type: "stream", handler: handleDiffusionStream },
+    upscaleStream: { type: "stream", handler: handleUpscaleStream },
     pluginInvokeStream: { type: "stream", handler: handlePluginInvokeStream },
     // Handlers with delegation support
     loadModel: {

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

@@ -3,38 +3,35 @@ 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();
+/**
+ * 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 === "inference" || request.operation === "embeddings") {
-        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;
-    }
-    if (request.operation === "downloadAsset" && request.delegate) {
-        const target = {
-            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;
+    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;
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    const { delegate: _delegate, ...providerRequest } = request;
-    return providerRequest;
+    return target;
 }
 export async function handleCancelDelegated(request, options) {
     const target = resolveDelegationTarget(request);
@@ -55,7 +52,7 @@ export async function handleCancelDelegated(request, options) {
         if (options?.profilingMeta) {
             delegateOpts.profilingMeta = options.profilingMeta;
         }
-        await send(toProviderCancelRequest(request), rpc, delegateOpts);
+        await send(request, rpc, delegateOpts);
         return { type: "cancel", success: true };
     }
     catch (error) {