@otto-code/brain 0.8.12 → 0.8.14

package/dist/service/router.js

@@ -205,30 +205,39 @@ function resolveCatalog(getCatalog) {
  * the supervisor is running marked 'loaded'. Falls back to just the running
  * model when no catalog provider is wired in.
  */
-export function buildModelList(supervisor, getCatalog) {
-    const loadedId = supervisor.model ? supervisor.model.id : null;
+export function buildModelList(supervisor, getCatalog, scheduler = null) {
+    const supervisors = scheduler && typeof scheduler.supervisors === "function"
+        ? scheduler.supervisors()
+        : [supervisor];
+    const residentFor = (modelId) => supervisors.find((candidate) => candidate.model?.id === modelId && candidate.state !== "stopped") ?? null;
     const stateOf = (model) => {
-        if (!loadedId || model.id !== loadedId)
+        const resident = residentFor(model.id);
+        if (!resident)
             return "not-loaded";
-        if (supervisor.state === "ready")
+        if (resident.state === "ready")
             return "loaded";
-        if (supervisor.state === "starting")
+        if (resident.state === "starting")
             return "loading";
         return "not-loaded";
     };
     let catalog = resolveCatalog(getCatalog);
     // Guarantee the running model appears even if the snapshot predates it.
-    if (supervisor.model && !catalog.some((m) => m.id === loadedId)) {
-        catalog = [supervisor.model, ...catalog];
+    for (const resident of supervisors) {
+        if (resident.model && !catalog.some((model) => model.id === resident.model?.id)) {
+            catalog.unshift(resident.model);
+        }
     }
-    return catalog.map((model) => describeModel(model, {
-        state: stateOf(model),
-        profile: model.id === loadedId ? supervisor.profile : null,
-        createdAt: model.id === loadedId ? supervisor.startedAt : null,
-    }));
+    return catalog.map((model) => {
+        const resident = residentFor(model.id);
+        return describeModel(model, {
+            state: stateOf(model),
+            profile: resident?.profile ?? null,
+            createdAt: resident?.startedAt ?? null,
+        });
+    });
 }
 /** Handle the model-discovery endpoints ourselves; returns true if it did. */
-function handleModelsRoute(req, res, supervisor, getCatalog) {
+function handleModelsRoute(req, res, supervisor, getCatalog, scheduler = null) {
     if (req.method !== "GET")
         return false;
     const url = (req.url || "").split("?")[0];
@@ -238,7 +247,7 @@ function handleModelsRoute(req, res, supervisor, getCatalog) {
         : null;
     if (!isList && single === null)
         return false;
-    const list = buildModelList(supervisor, getCatalog);
+    const list = buildModelList(supervisor, getCatalog, scheduler);
     let payload;
     if (single !== null) {
         const entry = list.find((e) => e.id === single);
@@ -264,16 +273,6 @@ function handleModelsRoute(req, res, supervisor, getCatalog) {
     res.end(body);
     return true;
 }
-/**
- * Correlates the chunks of one proxied stream for the reasoning tracker. A
- * counter rather than a uuid: it never leaves the process and only has to be
- * unique among the handful of streams in flight at once.
- */
-let streamCounter = 0;
-function nextStreamId() {
-    streamCounter += 1;
-    return `s${streamCounter}`;
-}
 /**
  * The reasoning tracker is module-scoped rather than per-router because both
  * proxy paths need it and `proxyBuffered` is a free function. One service
@@ -429,12 +428,16 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
     const slotId = slot ?? null;
     return new Promise((resolve) => {
         let settled = false;
-        const streamId = nextStreamId();
+        // Opened before anything can fail, so every exit below has a lease to
+        // release. Releasing is terminal and idempotent, which is what makes it
+        // safe to call `done()` from all six paths that can end this request
+        // without any of them having to know whether another got there first.
+        const lease = reasoning?.begin() ?? null;
         const done = () => {
-            // Always release the reasoning flag, including on the error and abort
-            // paths: a stream that dies mid-thought would otherwise pin the rail on
+            // Always release the stage, including on the error and abort paths: a
+            // stream that dies mid-thought would otherwise pin the rail on
             // "thinking" until the service restarts.
-            reasoning?.end(streamId);
+            lease?.end();
             if (!settled) {
                 settled = true;
                 resolve();
@@ -470,8 +473,13 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
             res.writeHead(upstreamRes.statusCode ?? 502, outHeaders);
             const isStream = String(upstreamRes.headers["content-type"] || "").includes("event-stream");
             const upstreamResponseFailed = (error) => {
-                if (settled)
+                // The release runs even when the queue has already settled. On an
+                // interrupt the client's socket close settles first, and this is the
+                // event that says the upstream stream is finally over.
+                if (settled) {
+                    lease?.end();
                     return;
+                }
                 const message = `llama-server response ended unexpectedly: ${error.message}`;
                 telemetry.record({
                     at: new Date().toISOString(),
@@ -493,7 +501,7 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
                 let sawReasoning = false;
                 upstreamRes.on("data", (chunk) => {
                     const text = String(chunk);
-                    reasoning?.observe(streamId, text);
+                    lease?.observe(text);
                     if (chunkHasContent(text))
                         sawContent = true;
                     if (chunkHasReasoning(text))
@@ -571,13 +579,11 @@ function proxyBuffered({ agent, model, supervisor, telemetry, logger, req, res,
             }
             done();
         });
-        // This is the first authoritative inference-stage signal: the request is
-        // being dispatched to llama-server and is waiting for prompt processing or
-        // its first output delta. The slot association is set once here, at the
-        // same moment, so `observe` stays free of any per-chunk slot work.
-        reasoning?.begin(streamId);
+        // The slot association is set once, here at dispatch, so `observe` stays
+        // free of any per-chunk slot work - and so the reaper has a row to check
+        // this request against if its release is ever missed.
         if (slotId !== null)
-            reasoning?.setSlot(streamId, slotId);
+            lease?.setSlot(slotId);
         upstream.end(outbound);
     });
 }
@@ -658,19 +664,24 @@ export function injectSystemAddendum(body, addendum, shape) {
  * a switch; an unnamed request rides the pin.
  */
 export function decideModelGate(params) {
-    const { lockModel, requestedName, pinned, resolved } = params;
+    const { lockModel, requestedName, pinned, pinnedModels = pinned ? [pinned] : [], resolved, } = params;
     if (lockModel) {
-        if (!pinned) {
-            return { ok: false, status: 503, message: "no model is loaded yet on this locked host" };
+        if (pinnedModels.length === 0) {
+            return { ok: false, status: 503, message: "no models are selected on this locked host" };
         }
-        if (requestedName && requestedName !== pinned.id && requestedName !== pinned.displayName) {
+        const selected = requestedName
+            ? pinnedModels.find((model) => model.id === requestedName || model.displayName === requestedName)
+            : pinnedModels[0];
+        if (!selected) {
             return {
                 ok: false,
                 status: 409,
-                message: `model switching is disabled on this host; only "${pinned.displayName}" is served`,
+                message: `model switching is disabled on this host; served models: ${pinnedModels
+                    .map((model) => `"${model.displayName}"`)
+                    .join(", ")}`,
             };
         }
-        return { ok: true, model: pinned };
+        return { ok: true, model: selected };
     }
     if (!resolved) {
         return {
@@ -684,7 +695,7 @@ export function decideModelGate(params) {
     return { ok: true, model: resolved };
 }
 /** Buffer a completion request, resolve its target model, and queue it. */
-function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, scheduler, modelGate, }) {
+function scheduleCompletion({ req, res, agent, telemetry, logger, scheduler, modelGate, }) {
     const chunks = [];
     let size = 0;
     let tooBig = false;
@@ -737,10 +748,22 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
         // relaunched - and not at dispatch time either, where a sibling admitted in
         // the same pass could see the same slot free and pin it too.
         let slot = null;
-        const queued = scheduler.submit(model, () => proxyBuffered({
+        // A queued request outlives its client. The reader can interrupt, close the
+        // chat, or lose the socket while the job still waits behind another model's
+        // turn, and without this the job is admitted anyway: a full generation for
+        // nobody, on a slot the live chats are queued for, wired to a response that
+        // closed before the proxy could listen to it. One flag, read by the
+        // scheduler before it pins anything, keeps the request from ever reaching
+        // the engine. (`close` also fires on a healthy finish, by which point the
+        // job has long since been dispatched and the flag is never read again.)
+        let abandoned = false;
+        res.on("close", () => {
+            abandoned = true;
+        });
+        const queued = scheduler.submit(model, (resident) => proxyBuffered({
             agent,
             model,
-            supervisor,
+            supervisor: resident,
             telemetry,
             logger,
             req,
@@ -748,9 +771,15 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
             body,
             reasoning: reasoningTracker,
             slot,
-        }), { session, onSlotFree: (id) => (slot = id) });
+        }), { session, onSlotFree: (id) => (slot = id), abandoned: () => abandoned });
         logger?.info?.(`queued ${req.method ?? "POST"} ${req.url ?? "completion"} for ${model.displayName}; queue depth ${scheduler.stats().queued}`);
-        queued.catch((error) => sendError(res, 502, `could not serve ${model.displayName}: ${errorMessage(error)}`));
+        queued.catch((error) => {
+            // The client may be the reason this failed, and writing into a socket it
+            // already closed throws where nothing is left to catch it.
+            if (res.writableEnded || res.destroyed)
+                return;
+            sendError(res, 502, `could not serve ${model.displayName}: ${errorMessage(error)}`);
+        });
     });
 }
 // The bench ranking is read from disk (one JSON per run). A completion request
@@ -758,7 +787,7 @@ function scheduleCompletion({ req, res, agent, supervisor, telemetry, logger, sc
 // (rare), so the router caches the ranking and re-reads it at most once per
 // window - the cheap time-based trigger.
 const RANKING_TTL_MS = 60000;
-export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, statusEvents = null, scheduler: suppliedScheduler = null, }) {
+export function createRouter({ supervisor, telemetry, logger, getCatalog = null, loadModel = null, loadRanking = () => rankModels(), queryGpuInfo = queryGpu, version = null, getConfig = null, getEvals = null, getLockModel = () => false, getDefaultModel = () => null, getLockedModels = () => [], applyConfigPatch = null, getAllowConfigWrite = () => false, hostApi = null, getResources = null, statusEvents = null, scheduler: suppliedScheduler = null, }) {
     // llama-server may close an idle response socket while this scheduler holds
     // the next request in queue. A reused keep-alive socket then fails as
     // ECONNRESET ("socket hang up") before the queued request reaches inference.
@@ -792,6 +821,10 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
         if (state === "starting") {
             telemetry.reset();
             scheduler?.forgetSlots();
+            // The tracker's pins name the same vanished slots, and a pin that
+            // outlives the process it named is not evidence - it can collide with a
+            // new request's slot id and shield a dead request from the reaper.
+            reasoningTracker.forgetSlots();
         }
     });
     // GPU total VRAM is static hardware, so it is queried once at startup and
@@ -851,11 +884,20 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
     // The single model this host will serve when switching is locked: the
     // resident model if one is up, else the configured default resolved through
     // the catalog. Null means nothing is loadable yet.
-    const pinnedModel = () => {
-        if (supervisor.model)
-            return supervisor.model;
-        const def = getDefaultModel();
-        return def ? resolveModel(def) : null;
+    const pinnedModels = () => {
+        const configured = getLockedModels();
+        const names = configured.length > 0 ? configured : [getDefaultModel()].filter(Boolean);
+        const selected = names
+            .map((name) => resolveModel(name ?? null))
+            .filter((model) => model !== null);
+        if (selected.length > 0)
+            return selected;
+        const residents = scheduler && typeof scheduler.supervisors === "function"
+            ? scheduler.supervisors()
+            : [supervisor];
+        return residents
+            .map((candidate) => candidate.model)
+            .filter((model) => model !== null);
     };
     // Decide whether a completion for `name` may run. The lock/default are read
     // live so a POST /__host/config change takes effect without a restart. Only
@@ -865,7 +907,8 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
         return decideModelGate({
             lockModel: lock,
             requestedName: name,
-            pinned: lock ? pinnedModel() : null,
+            pinned: null,
+            pinnedModels: lock ? pinnedModels() : [],
             resolved: lock ? null : resolveModel(name),
         });
     };
@@ -880,6 +923,10 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
      */
     const buildCheapStatus = async () => {
         const schedulerStats = scheduler ? scheduler.stats() : null;
+        const residentSupervisors = scheduler && typeof scheduler.supervisors === "function"
+            ? scheduler.supervisors()
+            : [supervisor];
+        const residents = residentSupervisors.filter((candidate) => candidate.model !== null && candidate.state !== "stopped");
         // Slots come from a loopback GET on the resident llama-server. That is
         // cheap enough to pay on every sample - unlike GPU sampling, which spawns
         // `nvidia-smi` and stays opt-in. Skipped entirely unless a model is
@@ -887,6 +934,23 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
         const slots = supervisor.state === "ready"
             ? await sampleSlots({ host: supervisor.host, port: supervisor.internalPort }).catch(() => null)
             : null;
+        // Both truths are in hand exactly here, and nowhere else: `slots` is what
+        // llama-server says is running, `inference` is what the proxy believes. A
+        // missed release used to survive until the service restarted, because
+        // `reasoning` outranks every engine signal on the rail. Reconciling the two
+        // makes any such leak self-heal within a few samples, and `reconcile` is
+        // built so it can only ever clear a request the engine contradicts (see
+        // its own contract).
+        const reaped = reasoningTracker.reconcile({
+            busySlots: slots?.threads ? new Set(slots.threads.map((thread) => thread.slot)) : null,
+            busyCount: slots ? slots.busy : null,
+        });
+        for (const request of reaped) {
+            logger?.warn?.(`released inference stage ${request.id} (${request.stage}` +
+                `${request.slotId === null ? "" : `, slot ${request.slotId}`}) after ` +
+                `${Math.round(request.ageMs / 1000)}s the engine reported it idle - ` +
+                `a completion did not report its end`);
+        }
         return {
             version,
             // Additive, and separate from `version`: the package version says which
@@ -895,6 +959,7 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
             // package version.
             apiVersion: HOST_API_VERSION,
             ...supervisor.status(),
+            residents: residents.map((resident) => resident.status()),
             telemetry: { ...telemetry.totals, warning: telemetry.warning },
             scheduler: schedulerStats,
             recent: telemetry.records.slice(-10),
@@ -983,7 +1048,7 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
             return;
         // Answer model discovery ourselves so ids are real names (not paths), the
         // whole catalog is listed, and each carries LM Studio's context fields.
-        if (handleModelsRoute(req, res, supervisor, getCatalog))
+        if (handleModelsRoute(req, res, supervisor, getCatalog, scheduler))
             return;
         // With a scheduler wired in, completion requests are queued and served in
         // turns - including loading/switching to the model they ask for - instead
@@ -993,7 +1058,6 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
                 req,
                 res,
                 agent,
-                supervisor,
                 telemetry,
                 logger,
                 scheduler,
@@ -1043,13 +1107,13 @@ export function createRouter({ supervisor, telemetry, logger, getCatalog = null,
                 let sawContent = false;
                 let sawReasoning = false;
                 if (isCompletion) {
-                    const streamId = nextStreamId();
+                    const lease = reasoningTracker.begin();
                     // Released on close, not just on end: an aborted stream would
                     // otherwise pin `/__host/status` on "thinking" forever.
-                    const releaseReasoning = () => reasoningTracker.end(streamId);
+                    const releaseReasoning = () => lease.end();
                     upstreamRes.on("data", (chunk) => {
                         const text = String(chunk);
-                        reasoningTracker.observe(streamId, text);
+                        lease.observe(text);
                         if (chunkHasContent(text))
                             sawContent = true;
                         if (chunkHasReasoning(text))

package/dist/service/scheduler.d.ts

@@ -84,6 +84,18 @@ export interface SchedulerSupervisor {
     model: Model | null;
     profile: Profile | null;
 }
+/**
+ * The scheduler surface consumed by the router and host operations. A managed
+ * process pool implements the same contract while choosing which resident
+ * supervisor owns each submitted model.
+ */
+export interface ModelScheduler<TSupervisor extends SchedulerSupervisor = SchedulerSupervisor> {
+    submit(model: Model, run: (supervisor: TSupervisor) => Promise<unknown>, options?: SchedulerSubmitOptions): Promise<unknown>;
+    stats(): SchedulerStats;
+    forgetSlots(): void;
+    supervisorFor(modelId: string): TSupervisor | null;
+    supervisors(): TSupervisor[];
+}
 /**
  * The answer to a live slot measurement: how many sequence slots are free, and
  * optionally WHICH ones. `idle` drives admission (see CAPACITY); `ids` lets
@@ -115,8 +127,8 @@ export interface SlotMeasurement {
  * behavior but must never fail the completion that is about to run.
  */
 export type SlotEraser = (slotId: number) => Promise<void>;
-export interface SchedulerOptions {
-    supervisor: SchedulerSupervisor;
+export interface SchedulerOptions<TSupervisor extends SchedulerSupervisor = SchedulerSupervisor> {
+    supervisor: TSupervisor;
     loadModel: (model: Model) => Promise<void>;
     logger?: ((message: string) => void) | null;
     /**
@@ -190,9 +202,23 @@ export interface SchedulerSubmitOptions {
      * and their attribution is not per-slot.
      */
     onSlotFree?: ((slotId: number | null) => void) | null;
+    /**
+     * Asked before this job is admitted: has whoever queued it stopped caring?
+     *
+     * A completion whose client left is the ordinary case - an interrupt, a
+     * closed chat, a dead socket - and it can happen at any point while the job
+     * waits behind another model's turn. Admitting it anyway costs a full
+     * generation of GPU time for a reader that is gone, holds one of the slots
+     * the remaining chats are queued for, and hands the proxy a response that
+     * closed before it could wire a listener to it. Dropping the job here, before
+     * it is pinned to a slot, is the cheapest and least surprising place to
+     * refuse: nothing reaches the engine, no slot is erased for a handoff that
+     * will not happen, and the job's promise settles like any other.
+     */
+    abandoned?: (() => boolean) | null;
 }
 /** A queued request or host operation bound to a resolved catalog model. */
-export interface QueuedJob {
+export interface QueuedJob<TSupervisor extends SchedulerSupervisor = SchedulerSupervisor> {
     modelId: string;
     model: Model;
     kind: SchedulerJobKind;
@@ -200,6 +226,7 @@ export interface QueuedJob {
     session: string | null;
     onStart: (() => void) | null;
     onSlotFree: ((slotId: number | null) => void) | null;
+    abandoned: (() => boolean) | null;
     /**
      * The engine slot this job was pinned to at admission, or null when none was
      * named. Kept on the job so a later pass can exclude it from the ids it hands
@@ -209,7 +236,7 @@ export interface QueuedJob {
      * busy behavior would serialize the pair onto it while another slot sat empty.
      */
     slotId: number | null;
-    run: () => Promise<unknown>;
+    run: (supervisor: TSupervisor) => Promise<unknown>;
     resolve: (value: unknown) => void;
     reject: (error: unknown) => void;
 }
@@ -224,13 +251,13 @@ export interface SchedulerStats {
         kind: Exclude<SchedulerJobKind, "completion">;
     } | null;
 }
-export declare class Scheduler {
+export declare class Scheduler<TSupervisor extends SchedulerSupervisor = SchedulerSupervisor> implements ModelScheduler<TSupervisor> {
     #private;
-    supervisor: SchedulerSupervisor;
+    supervisor: TSupervisor;
     loadModel: (model: Model) => Promise<void>;
     logger: ((message: string) => void) | null;
     /** Submitted, not yet claimed by a turn. */
-    queue: QueuedJob[];
+    queue: QueuedJob<TSupervisor>[];
     lastTurnId: string | null;
     /**
      * Per model: the session whose jobs most recently filled its slots. That
@@ -239,7 +266,7 @@ export declare class Scheduler {
      */
     hotSessions: Map<string, string>;
     /** The exclusive operation in flight, if any. Reported by `stats()`. */
-    activeJob: QueuedJob | null;
+    activeJob: QueuedJob<TSupervisor> | null;
     onChange: (() => void) | null;
     freeSlots: SchedulerOptions["freeSlots"];
     slotPollMs: number;
@@ -252,7 +279,7 @@ export declare class Scheduler {
      * engine reloads a model - slot ids do not survive the relaunch.
      */
     slotOwners: Map<number, string | null>;
-    constructor({ supervisor, loadModel, logger, onChange, freeSlots, slotPollMs, eraseSlot, }: SchedulerOptions);
+    constructor({ supervisor, loadModel, logger, onChange, freeSlots, slotPollMs, eraseSlot, }: SchedulerOptions<TSupervisor>);
     /** Id of the model that is actually loaded and ready, or null. */
     get loadedId(): string | null;
     /** How many requests may run at once against the resident model (static ceiling). */
@@ -263,7 +290,7 @@ export declare class Scheduler {
      * Dispatch is deferred a microtask so a burst of requests submitted together
      * shares one turn rather than the first one taking a turn by itself.
      */
-    submit(model: Model, run: () => Promise<unknown>, { kind, exclusive, onStart, session, onSlotFree, }?: SchedulerSubmitOptions): Promise<unknown>;
+    submit(model: Model, run: (supervisor: TSupervisor) => Promise<unknown>, { kind, exclusive, onStart, session, onSlotFree, abandoned, }?: SchedulerSubmitOptions): Promise<unknown>;
     /**
      * Drop every recorded slot owner. The engine's slots do not survive a model
      * (re)launch, so their owners do not either - a stale entry would make the
@@ -279,6 +306,10 @@ export declare class Scheduler {
      * supervisor says the slots are gone. Both paths are idempotent.
      */
     forgetSlots(): void;
+    /** True only when this engine has no claimed, queued, or running work. */
+    get isIdle(): boolean;
+    supervisorFor(modelId: string): TSupervisor | null;
+    supervisors(): TSupervisor[];
     /** Queue snapshot for the status endpoint / UI. */
     stats(): SchedulerStats;
 }

package/dist/service/scheduler.js

@@ -9,7 +9,7 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var _Scheduler_instances, _Scheduler_batch, _Scheduler_running, _Scheduler_turnId, _Scheduler_freeSlotIds, _Scheduler_busy, _Scheduler_dirty, _Scheduler_slotTimer, _Scheduler_announce, _Scheduler_takeTurn, _Scheduler_take, _Scheduler_warmSessions, _Scheduler_claimJob, _Scheduler_sampleFreeSlots, _Scheduler_pollForSlot, _Scheduler_start, _Scheduler_eraseFor, _Scheduler_dispatch, _Scheduler_resetSlots, _Scheduler_pass;
+var _Scheduler_instances, _Scheduler_batch, _Scheduler_running, _Scheduler_turnId, _Scheduler_freeSlotIds, _Scheduler_busy, _Scheduler_dirty, _Scheduler_slotTimer, _Scheduler_announce, _Scheduler_takeTurn, _Scheduler_take, _Scheduler_purgeAbandoned, _Scheduler_warmSessions, _Scheduler_claimJob, _Scheduler_sampleFreeSlots, _Scheduler_pollForSlot, _Scheduler_start, _Scheduler_eraseFor, _Scheduler_dispatch, _Scheduler_resetSlots, _Scheduler_pass;
 const MAX_CONCURRENCY = 16;
 /** A short, safe description of an unknown error value for log lines. */
 function describeError(error) {
@@ -82,7 +82,7 @@ export class Scheduler {
      * Dispatch is deferred a microtask so a burst of requests submitted together
      * shares one turn rather than the first one taking a turn by itself.
      */
-    submit(model, run, { kind = "completion", exclusive = kind !== "completion", onStart = null, session = null, onSlotFree = null, } = {}) {
+    submit(model, run, { kind = "completion", exclusive = kind !== "completion", onStart = null, session = null, onSlotFree = null, abandoned = null, } = {}) {
         return new Promise((resolve, reject) => {
             this.queue.push({
                 modelId: model.id,
@@ -92,6 +92,7 @@ export class Scheduler {
                 session: session ?? null,
                 onStart,
                 onSlotFree,
+                abandoned: abandoned ?? null,
                 slotId: null,
                 run,
                 resolve,
@@ -118,6 +119,19 @@ export class Scheduler {
     forgetSlots() {
         this.slotOwners.clear();
     }
+    /** True only when this engine has no claimed, queued, or running work. */
+    get isIdle() {
+        return (this.queue.length === 0 &&
+            __classPrivateFieldGet(this, _Scheduler_batch, "f").length === 0 &&
+            __classPrivateFieldGet(this, _Scheduler_running, "f").size === 0 &&
+            this.activeJob === null);
+    }
+    supervisorFor(modelId) {
+        return this.supervisor.model?.id === modelId ? this.supervisor : null;
+    }
+    supervisors() {
+        return [this.supervisor];
+    }
     /** Queue snapshot for the status endpoint / UI. */
     stats() {
         const waiting = {};
@@ -169,6 +183,33 @@ _Scheduler_batch = new WeakMap(), _Scheduler_running = new WeakMap(), _Scheduler
     if (taken.length > 0)
         __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
     return taken;
+}, _Scheduler_purgeAbandoned = function _Scheduler_purgeAbandoned() {
+    const dropped = [];
+    const isAbandoned = (job) => {
+        try {
+            return job.abandoned?.() === true;
+        }
+        catch {
+            // A predicate that throws is not permission to drop the job.
+            return false;
+        }
+    };
+    __classPrivateFieldSet(this, _Scheduler_batch, __classPrivateFieldGet(this, _Scheduler_batch, "f").filter((job) => {
+        if (!isAbandoned(job))
+            return true;
+        dropped.push(job);
+        return false;
+    }), "f");
+    for (const job of __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_take).call(this, isAbandoned))
+        dropped.push(job);
+    if (dropped.length === 0)
+        return;
+    this.logger?.(`dropping ${dropped.length} queued job(s) whose caller went away`);
+    // Resolved, not rejected: the caller asked for this by leaving, and a
+    // rejection would only be reported into a socket that is already gone.
+    for (const job of dropped)
+        job.resolve(undefined);
+    __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_announce).call(this);
 }, _Scheduler_warmSessions = function _Scheduler_warmSessions() {
     const warm = new Set();
     for (const job of __classPrivateFieldGet(this, _Scheduler_running, "f"))
@@ -269,7 +310,7 @@ async function _Scheduler_start(job) {
     void (async () => {
         try {
             job.onStart?.();
-            job.resolve(await job.run());
+            job.resolve(await job.run(this.supervisor));
         }
         catch (error) {
             job.reject(error);
@@ -352,6 +393,11 @@ async function _Scheduler_pass() {
     // the sample the first time capacity is checked; consumed in `#start`.
     __classPrivateFieldSet(this, _Scheduler_freeSlotIds, null, "f");
     for (;;) {
+        // Before any decision is derived from the queue, drop what nobody is
+        // waiting for, so every count read below is honest. Per iteration rather
+        // than once per pass: a turn boundary is crossed inside this loop, and a
+        // caller can leave while the job ahead of it is being started.
+        __classPrivateFieldGet(this, _Scheduler_instances, "m", _Scheduler_purgeAbandoned).call(this);
         // An exclusive operation owns the engine alone.
         if (this.activeJob !== null)
             return;