@qvac/sdk 0.17.1 → 0.18.1

package/dist/server/bare/plugins/llamacpp-completion/ops/completion-stream.js

@@ -1,10 +1,9 @@
-import { TOOLS_MODE } from '../../../../../schemas/tools.js';
 import { logCacheDisabled, logCacheInit, logCacheSave, logMessagesToAddon } from '../../../../../server/bare/plugins/llamacpp-completion/ops/cache-logger.js';
 import { extractSystemPrompt, getCurrentCacheInfo } from '../../../../../server/bare/ops/kv-cache-utils.js';
 import { getModel, getModelConfig } from '../../../../../server/bare/registry/model-registry.js';
 import { decideCachedHistorySlice, shouldCommitCachedTurn } from '../../../../../server/bare/plugins/llamacpp-completion/ops/kv-cache-state.js';
 import { createKvCacheSession, generateConfigHash } from '../../../../../server/bare/plugins/llamacpp-completion/ops/kv-cache-session.js';
-import { appendToolsToHistory, detectToolDialect, prependToolsToHistory } from '../../../../../server/utils/tool-integration.js';
+import { detectToolDialect, prependToolsToHistory } from '../../../../../server/utils/tool-integration.js';
 import { parseToolCalls } from '../../../../../server/utils/tools/index.js';
 import { getResponseFormatJsonSchema } from '../../../../../server/utils/response-format.js';
 import { buildAutoCacheSaveHistory } from '../../../../../server/utils/index.js';
@@ -56,29 +55,60 @@ export function transformMessages(messages) {
     }
     return transformed;
 }
-async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, cacheKey, tools) {
+/**
+ * Prime the cache prefix with the system prompt only.
+ *
+ * Tools deliberately stay out of the prefix: a message list with no user turn
+ * is not a renderable conversation for every chat template (Qwen3.5 raises
+ * `No user query found in messages.` because it anchors its tool block on the
+ * last user query), and a template failure degrades the whole render rather
+ * than just the tool block. Tools travel with the turn instead.
+ */
+async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, cacheKey, onResponse) {
     const primeMessages = [{ role: 'system', content: systemPromptToUse }];
-    let toolCount = 0;
-    if (tools && tools.length > 0) {
-        const transformedTools = transformMessages(tools);
-        primeMessages.push(...transformedTools);
-        toolCount = tools.length;
-    }
-    logCacheInit(cacheKey, systemPromptToUse, toolCount);
+    logCacheInit(cacheKey, systemPromptToUse);
     logMessagesToAddon(primeMessages, 'CACHE_INIT');
     const primeResponse = await runModel(model, primeMessages, {
         cacheKey: cachePathToUse,
         saveCacheToDisk: true,
         prefill: true
     });
+    // Register the prime so an abort during a cold-cache prefill cancels it.
+    onResponse?.(primeResponse);
     await primeResponse.await();
 }
+/**
+ * Attach the tool block ahead of a turn payload, mirroring the no-kv-cache
+ * path (`prependToolsToHistory`).
+ */
+function withToolBlock(messages, toolBlock) {
+    if (toolBlock.length === 0)
+        return messages;
+    return [...toolBlock, ...messages];
+}
+/**
+ * Whether a payload carrying this tool block actually gets it in front of the
+ * model. Qwen-family templates anchor their tool section on the last user
+ * query and raise without one, and the addon answers that by re-rendering the
+ * turn with tools stripped — a usable prompt with no tools in it. Recording
+ * such a turn as "the block is cached now" would suppress the block for the
+ * rest of the session, so require a user message before believing it landed.
+ */
+function rendersToolBlock(messages, toolBlock) {
+    if (toolBlock.length === 0)
+        return false;
+    return messages.some((msg) => msg.role === 'user');
+}
 /**
  * Pick the messages that need to reach the model for the next turn.
  *
- * Static mode (no `tools` argument):
- *   - Cache miss: send the whole history minus the system message (which
- *     was primed during cache init).
+ * Tools are never baked into the primed prefix — a prefix with no user turn is
+ * not a renderable conversation for every template — so they travel with a
+ * turn instead.
+ *
+ *   - Empty history: nothing to slice; send whatever non-system messages
+ *     exist. (The call site always reports the cache as existing, so this
+ *     is the only way into this branch.)
  *   - Cache hit with a recorded `savedCount`: send only the unsaved tail
  *     (`history.slice(savedCount)`), so a multi-message turn (e.g. a
  *     consumer pushing both an assistant transcript and a follow-up user
@@ -86,66 +116,46 @@ async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, c
  *   - Cache hit with a stale/missing `savedCount`: fall back to the full
  *     non-system history. The session is told (`dropStaleSavedCount`) so
  *     the bad boundary doesn't propagate into the next turn.
- *
- * Dynamic mode (`tools` argument set):
- *   - The addon anchors the tool block after the last user message and
- *     trims tools + the assistant's tool-call output from the cache once
- *     the chain resolves. After that trim, the cache only holds messages
- *     up to the last user turn, so the SDK has to ship the right slice
- *     plus the (possibly new) tool set:
- *       * tool-chain continuation (last role is "tool"): send the trailing
- *         consecutive tool messages, no tool block — tools are still
- *         anchored in the cache from the previous round.
- *       * new user turn after a chain (prev role is "assistant"): send
- *         [assistant, user] so the model sees its own final reply before
- *         the new prompt, then re-anchor the tool block.
- *       * otherwise: send just the last message + tool block.
+ *   - The tool block travels only with the turn that writes it into the
+ *     cache; see `skipToolBlock` below.
  */
-function prepareMessagesForCache(session, turn, cacheExists, history, tools) {
-    const addTools = tools?.length ? transformMessages(tools) : [];
-    const dynamic = addTools.length > 0;
+function prepareMessagesForCache(session, turn, cacheExists, history, tools, toolBlockEvictable = false) {
+    const toolBlock = tools?.length ? transformMessages(tools) : [];
     if (!(cacheExists && history.length > 0)) {
         const historyWithoutSystem = history.filter((msg) => msg.role !== 'system');
-        return [...transformMessages(historyWithoutSystem), ...addTools];
+        return {
+            messages: withToolBlock(transformMessages(historyWithoutSystem), toolBlock),
+            toolBlockCached: rendersToolBlock(historyWithoutSystem, toolBlock)
+        };
     }
-    if (!dynamic) {
-        // Static path — slice from the turn's `savedCount` so callers can
-        // stage multiple messages between completions. `decideCachedHistorySlice`
-        // also guards against the QVAC-17780 stale-count regression: if the
-        // saved boundary would slice the history down to an empty payload
-        // (e.g. after a cancelled mid-decode), it falls back to the full
-        // non-system history and signals the caller to drop the bad entry.
-        // The session owns the entry; `dropStaleSavedCount` clears it
-        // without touching the on-disk file (the file is still trustworthy
-        // — only the boundary count is wrong).
-        const { messages, clearStaleCount } = decideCachedHistorySlice(turn.savedCount, cacheExists, history);
-        if (clearStaleCount) {
-            session.dropStaleSavedCount(turn);
-        }
-        return transformMessages(messages);
-    }
-    // Dynamic path. The addon trimmed tools after the previous round, so the
-    // cache no longer holds the saved-count we'd rely on for slicing — pick
-    // the right fragment based on the role of the last history message.
-    const lastMsg = history[history.length - 1];
-    if (lastMsg.role === 'tool') {
-        const trailingTools = [];
-        for (let i = history.length - 1; i >= 0; i--) {
-            const msg = history[i];
-            if (msg.role !== 'tool')
-                break;
-            trailingTools.unshift(msg);
-        }
-        return transformMessages(trailingTools);
+    // Slice from the turn's `savedCount` so callers can
+    // stage multiple messages between completions. `decideCachedHistorySlice`
+    // also guards against the QVAC-17780 stale-count regression: if the
+    // saved boundary would slice the history down to an empty payload
+    // (e.g. after a cancelled mid-decode), it falls back to the full
+    // non-system history and signals the caller to drop the bad entry.
+    // The session owns the entry; `dropStaleSavedCount` clears it
+    // without touching the on-disk file (the file is still trustworthy
+    // — only the boundary count is wrong).
+    const { messages, clearStaleCount } = decideCachedHistorySlice(turn.savedCount, cacheExists, history);
+    if (clearStaleCount) {
+        session.dropStaleSavedCount(turn);
     }
-    if (lastMsg.role === 'user') {
-        const prevMsg = history[history.length - 2];
-        const tail = prevMsg?.role === 'assistant' ? [prevMsg, lastMsg] : [lastMsg];
-        return [...transformMessages(tail), ...addTools];
-    }
-    return [...transformMessages([lastMsg]), ...addTools];
+    // The block is never trimmed back out of the cache, so re-sending it every
+    // turn would leave one copy per turn and grow the prefix with the
+    // conversation. Skip it only when the prefix is known to hold a rendered
+    // one: `toolBlockCached` records that a previous turn actually got it into
+    // the cache, which a committed message count does not prove. A stale
+    // boundary means we are resending the whole conversation anyway, and an
+    // evictable block can no longer be assumed present.
+    const skipToolBlock = turn.toolBlockCached && !clearStaleCount && !toolBlockEvictable;
+    const blockToSend = skipToolBlock ? [] : toolBlock;
+    return {
+        messages: withToolBlock(transformMessages(messages), blockToSend),
+        toolBlockCached: skipToolBlock || rendersToolBlock(messages, blockToSend)
+    };
 }
-async function* processModelResponse(model, messagesToSend, tools, generationParams, cacheOptions, dialect) {
+async function* processModelResponse(model, messagesToSend, tools, generationParams, cacheOptions, dialect, onResponse) {
     const runOptions = {
         ...(generationParams && { generationParams }),
         ...(cacheOptions?.cacheKey !== undefined && {
@@ -158,6 +168,8 @@ async function* processModelResponse(model, messagesToSend, tools, generationPar
     const hasRunOptions = Object.keys(runOptions).length > 0;
     const modelStart = nowMs();
     const response = await runModel(model, messagesToSend, hasRunOptions ? runOptions : undefined);
+    // Hand the admitted response back so the caller can cancel just this job.
+    onResponse?.(response);
     let accumulatedText = '';
     let producedTokens = false;
     let emittedPieces = 0;
@@ -185,7 +197,8 @@ async function* processModelResponse(model, messagesToSend, tools, generationPar
         ...buildStreamResult(modelExecutionMs, stats),
         toolCalls: toolCallsResult,
         responseText: accumulatedText,
-        producedTokens
+        producedTokens,
+        stoppedAtContextBoundary: responseWithStats.stats?.stopReason === 'contextOverflow'
     };
 }
 export async function* completion(params, opts) {
@@ -194,9 +207,13 @@ export async function* completion(params, opts) {
     const requestLogger = opts.logger ?? logger;
     const modelConfig = getModelConfig(modelId);
     const toolsEnabled = modelConfig.tools === true;
-    const toolsMode = modelConfig.toolsMode;
-    const dynamicTools = !!tools?.length && toolsEnabled && toolsMode === TOOLS_MODE.dynamic;
-    const staticTools = !!tools?.length && toolsEnabled && !dynamicTools;
+    const toolsActive = !!tools?.length && toolsEnabled;
+    // Sliding is opt-in (`n_discarded` defaults to 0). Once on, the addon's
+    // discard window opens at the end of the primed prefix — which is where the
+    // tool block sits, since the prime is the system prompt alone — and nothing
+    // protects it. So while sliding is possible the block cannot be assumed to
+    // survive, and it has to travel with every turn.
+    const toolBlockEvictable = (modelConfig.n_discarded ?? 0) > 0;
     const dialect = tools && tools.length > 0 ? (params.toolDialect ?? detectToolDialect(modelId)) : undefined;
     // `responseFormat` is forwarded to the addon as a per-request
     // `generationParams.json_schema`, which the addon converts to GBNF and
@@ -216,56 +233,45 @@ export async function* completion(params, opts) {
         }
     }
     const model = getModel(modelId);
-    // Hard-cancel wiring: when the registry aborts the request's signal,
-    // forward to the addon so the C++ work stops as soon as it can. The
-    // SDK still treats `signal.aborted` as the truth for cancel detection
-    // (post-completion bookkeeping below) — this listener only shortens
-    // the latency between "user clicked stop" and "addon stops decoding".
-    //
-    // Fire-and-forget by construction (event listeners can't `await`), but
-    // `addon.cancel()` returns a Promise — if it ever rejects the bare
-    // `void` would leak it as an unhandledRejection. Attach `.catch(...)`
-    // so a rejection is logged and the process stays clean; the iterator
-    // below still sees EOF/empty tokens via the addon's normal cancel path
-    // so callers aren't affected.
-    const onAbort = () => {
-        const addon = model.addon;
-        if (addon?.cancel) {
-            addon.cancel.call(addon).catch((err) => {
-                requestLogger.warn(`[cancel] addon.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
-            });
-        }
+    // Per-request hard cancel: under continuous batching the model runs several
+    // jobs at once, so an abort must cancel only THIS request's job, not the
+    // whole model — `response.cancel()` routes to the addon's per-job cancel.
+    // `.catch(...)` keeps the fire-and-forget cancel from leaking a rejection.
+    let activeResponse = null;
+    const cancelActive = () => {
+        activeResponse?.cancel().catch((err) => {
+            requestLogger.warn(`[cancel] response.cancel() rejected during abort for modelId=${modelId}: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    };
+    // Publish each run's response as it's admitted; the `signal.aborted` re-check
+    // cancels it if the abort landed while run() was still being admitted.
+    const setActiveResponse = (response) => {
+        activeResponse = response;
+        if (signal.aborted)
+            cancelActive();
     };
+    const onAbort = () => cancelActive();
     signal.addEventListener('abort', onAbort, { once: true });
-    // `addEventListener("abort", ..., { once: true })` does *not* fire if
-    // the signal is already aborted at register time — but the registry
-    // synchronously aborts a fresh controller when `parentSignal` was
-    // already aborted at `begin(...)`. Without this fall-through, the
-    // addon would keep decoding until the post-loop check notices.
-    // Re-using `onAbort` here keeps the listener body as the single
-    // source of truth for "what cancel does."
+    // `{ once: true }` won't fire for an already-aborted signal (e.g. an
+    // already-aborted parentSignal at begin), so fire once here; a no-op before
+    // any response exists.
     if (signal.aborted)
         onAbort();
-    // Detach the abort listener on every exit path (happy, throw, generator
-    // `return()` from upstream). `{ once: true }` already removes the
-    // listener if the signal fires, so the `removeEventListener` here is
-    // the cleanup hook for the signal-never-fired path.
     scope.defer(() => {
         signal.removeEventListener('abort', onAbort);
+        // Drop the ref so a late abort can't cancel an already-settled response.
+        activeResponse = null;
     });
     if (!kvCache) {
         // KV-cache disabled — straight passthrough, no session involvement.
         let historyWithTools = history;
-        if (staticTools && tools) {
+        if (toolsActive && tools) {
             historyWithTools = prependToolsToHistory(history, tools);
         }
-        else if (dynamicTools && tools) {
-            historyWithTools = appendToolsToHistory(history, tools);
-        }
         const transformedHistory = transformMessages(historyWithTools);
         logCacheDisabled();
         logMessagesToAddon(transformedHistory, 'NO_CACHE');
-        return yield* processModelResponse(model, transformedHistory, tools, mergedGenerationParams, undefined, dialect);
+        return yield* processModelResponse(model, transformedHistory, tools, mergedGenerationParams, undefined, dialect, setActiveResponse);
     }
     // ---- KV-cache path. The session owns all three bookkeeping layers
     // (on-disk `.bin`, `initializedCaches`, `cachedMessageCounts`). The
@@ -275,19 +281,15 @@ export async function* completion(params, opts) {
     // unwind through the same `scope.defer` hook. ----
     const session = createKvCacheSession(modelId, { logger: requestLogger });
     const systemPromptFromHistory = extractSystemPrompt(history);
-    // Dynamic mode lets each turn carry its own tool set, so the cache
-    // hash must not depend on the tool list — otherwise a tool change
-    // would force a fresh cache file and defeat the whole optimisation.
-    const configHash = generateConfigHash(systemPromptFromHistory, dynamicTools ? undefined : tools);
+    // The tool block is baked into the cache on the turn that first sends it and
+    // never trimmed, so a late or changed tool set has to land on a fresh cache
+    // rather than a warm prefix holding the old block.
+    const configHash = generateConfigHash(systemPromptFromHistory, toolsActive ? tools : undefined);
     const systemPromptToUse = systemPromptFromHistory ||
         modelConfig.system_prompt ||
         'You are a helpful assistant.';
     const primeIfMissing = async (cachePath) => {
-        await initSystemPromptCache(model, cachePath, systemPromptToUse, typeof kvCache === 'string' ? kvCache : 'auto', 
-        // Static-mode tools are baked into the system-prompt cache so
-        // they're shared across the session. Dynamic-mode tools belong
-        // to a per-turn anchor and must not enter the system cache.
-        staticTools ? tools : undefined);
+        await initSystemPromptCache(model, cachePath, systemPromptToUse, typeof kvCache === 'string' ? kvCache : 'auto', setActiveResponse);
     };
     let turn;
     if (typeof kvCache === 'string') {
@@ -295,7 +297,8 @@ export async function* completion(params, opts) {
             kind: 'custom',
             customKey: kvCache,
             configHash,
-            primeIfMissing
+            primeIfMissing,
+            signal
         });
     }
     else {
@@ -308,7 +311,8 @@ export async function* completion(params, opts) {
             kind: 'auto',
             configHash,
             history: cacheMessages,
-            primeIfMissing
+            primeIfMissing,
+            signal
         });
     }
     // Single cleanup hook for every non-success exit path. `commitTurn`
@@ -320,15 +324,17 @@ export async function* completion(params, opts) {
     // `cacheExists` is implied by `beginTurn` — the session either found
     // an existing cache or just primed one. Pass `true` to the message
     // selector so the slicing branches engage.
-    const messagesToSend = prepareMessagesForCache(session, turn, 
-    /* cacheExists */ true, history, dynamicTools ? tools : undefined);
+    const payload = prepareMessagesForCache(session, turn, 
+    /* cacheExists */ true, history, toolsActive ? tools : undefined, toolBlockEvictable);
+    const messagesToSend = payload.messages;
     logMessagesToAddon(messagesToSend, 'PROMPT_SEND');
-    const result = yield* processModelResponse(model, messagesToSend, tools, mergedGenerationParams, { cacheKey: turn.cachePath, saveCacheToDisk: true }, dialect);
+    const result = yield* processModelResponse(model, messagesToSend, tools, mergedGenerationParams, { cacheKey: turn.cachePath, saveCacheToDisk: true }, dialect, setActiveResponse);
     const shouldCommitTurn = shouldCommitCachedTurn({
         aborted: signal.aborted,
         producedTokens: result.producedTokens,
         generatedTokens: result.stats?.generatedTokens,
-        predict: mergedGenerationParams?.predict ?? modelConfig.predict
+        predict: mergedGenerationParams?.predict ?? modelConfig.predict,
+        stoppedAtContextBoundary: result.stoppedAtContextBoundary
     });
     if (typeof kvCache === 'string') {
         // Custom-key path: the addon wrote the new cache state inline at
@@ -337,7 +343,8 @@ export async function* completion(params, opts) {
         if (shouldCommitTurn) {
             await session.commitTurn(turn, {
                 kind: 'static',
-                messageCount: history.length + 1
+                messageCount: history.length + 1,
+                toolBlockCached: payload.toolBlockCached
             });
         }
         return result;
@@ -368,7 +375,8 @@ export async function* completion(params, opts) {
     await session.commitTurn(turn, {
         kind: 'autoRename',
         targetCachePath: postResponseCacheInfo.cachePath,
-        messageCount: savedHistory.length
+        messageCount: savedHistory.length,
+        toolBlockCached: payload.toolBlockCached
     });
     return result;
 }

package/dist/server/bare/plugins/llamacpp-completion/ops/finetune.js

@@ -57,15 +57,52 @@ import { getRequestRegistry, withRequestContext } from '../../../../../server/ba
 import { generateServerRequestId } from '../../../../../server/bare/runtime/request-id.js';
 import { getServerLogger } from '../../../../../logging/index.js';
 const PAUSE_CHECKPOINT_PREFIX = 'pause_checkpoint_step_';
-const finetuneRuntimeState = new Set();
+// Ref-count, not a Set: with an exclusive writer a second finetune queues behind
+// the first, and both register before admission. A Set let the first's cleanup
+// clear the key while the second was still training, so getFinetuneState()
+// reported IDLE mid-run. Each call owns one ref and releases exactly one.
+const finetuneRuntimeState = new Map();
 function getRunningFinetuneState(modelId) {
-    return finetuneRuntimeState.has(modelId);
+    return (finetuneRuntimeState.get(modelId) ?? 0) > 0;
 }
 function registerRunningFinetune(modelId) {
-    finetuneRuntimeState.add(modelId);
+    finetuneRuntimeState.set(modelId, (finetuneRuntimeState.get(modelId) ?? 0) + 1);
 }
 export function clearFinetuneRuntimeState(modelId) {
-    finetuneRuntimeState.delete(modelId);
+    const count = finetuneRuntimeState.get(modelId);
+    if (count === undefined)
+        return;
+    if (count <= 1)
+        finetuneRuntimeState.delete(modelId);
+    else
+        finetuneRuntimeState.set(modelId, count - 1);
+}
+// modelIds whose single in-flight finetune currently HOLDS the exclusive lane
+// (admitted, past the queued-abort check). One finetune per model (see the
+// reject-second guard in startFinetune), so this is a plain membership set. Only an
+// admitted finetune may be paused through the addon-global model.pause(); a finetune
+// still queued behind a reader is cancelled instead, so pause never touches an
+// unrelated reader.
+const admittedFinetunes = new Set();
+// The single in-flight finetune's requestId per model. A QUEUED finetune is cancelled
+// by this id, not by a broad cancel({ modelId, kind }): the registry's grant→register
+// handoff leaves a brief window where the request is in neither the wait queue nor the
+// active set — a broad cancel misses it, but cancel({ requestId }) covers it via the
+// cancel-before-begin tripwire.
+const finetuneRequestIds = new Map();
+// Models whose admitted finetune is mid-pause: model.pause() has been called but has
+// not settled. A new finetune is rejected during this window even if the runtime ref
+// has already cleared, because handle.await() can settle before model.pause() resolves.
+const pausingModels = new Set();
+// Cancel the model's in-flight finetune by its tracked requestId (covers the
+// registry grant→register handoff window via the cancel-before-begin tripwire),
+// falling back to a broad cancel if the id is unknown.
+function cancelTrackedFinetune(modelId) {
+    const requestId = finetuneRequestIds.get(modelId);
+    if (requestId !== undefined)
+        getRequestRegistry().cancel({ requestId });
+    else
+        getRequestRegistry().cancel({ modelId, kind: 'finetune' });
 }
 export function getFinetuneStateFromCheckpoints(options) {
     const checkpointDirectory = options.checkpointSaveDir ?? './checkpoints';
@@ -105,24 +142,35 @@ export async function startFinetune(request, onProgress) {
     try {
         const model = getModel(request.modelId);
         validateExplicitFinetuneOperation(request);
-        // Mark RUNNING before the async begin() so an immediate getFinetuneState()
-        // poll observes RUNNING, not IDLE. register is a no-op when a finetune is
-        // already running on this model, so only clear on a failed begin() if this
-        // call actually set the flag.
-        const wasRunning = getRunningFinetuneState(request.modelId);
+        // One finetune per model: reject a second start/resume while one is pending or
+        // running. With no queued finetune peers, pause/cancel never has to disambiguate
+        // multiple finetunes, and a finetune that arrives mid-pause is simply rejected
+        // because the pausing one still occupies the model until it unwinds.
+        if (getRunningFinetuneState(request.modelId) || pausingModels.has(request.modelId)) {
+            throw new CompletionFailedError(`Model "${request.modelId}" already has an active finetune; pause or cancel it before starting another`);
+        }
+        // Stable id, used for registry scoping and for targeted cancellation of this
+        // finetune while it is queued (see pauseFinetune / cancelFinetune).
+        const requestId = request.requestId ?? generateServerRequestId();
+        // Take a ref before the async begin() so an immediate getFinetuneState() poll
+        // observes RUNNING, not IDLE, and a concurrent start is rejected above. Released
+        // on a failed begin() or on scope unwind below.
         registerRunningFinetune(request.modelId);
+        finetuneRequestIds.set(request.modelId, requestId);
         // Scope the run into the registry so cancel({ requestId }) and
         // cancel({ modelId, kind: "finetune" }) reach it; onAbort forwards to
         // model.cancel().
         const ctx = __addDisposableResource(env_1, await getRequestRegistry()
             .begin({
-            requestId: request.requestId ?? generateServerRequestId(),
+            requestId,
             kind: 'finetune',
             modelId: request.modelId
         })
             .catch((err) => {
-            if (!wasRunning)
-                clearFinetuneRuntimeState(request.modelId);
+            clearFinetuneRuntimeState(request.modelId);
+            if (finetuneRequestIds.get(request.modelId) === requestId) {
+                finetuneRequestIds.delete(request.modelId);
+            }
             throw err;
         }), true);
         const requestLogger = withRequestContext(getServerLogger(), ctx);
@@ -130,7 +178,30 @@ export async function startFinetune(request, onProgress) {
         // removes the listener first.
         ctx.scope.defer(() => {
             clearFinetuneRuntimeState(request.modelId);
+            if (finetuneRequestIds.get(request.modelId) === requestId) {
+                finetuneRequestIds.delete(request.modelId);
+            }
+        });
+        // A finetune cancelled while queued resolves aborted without the exclusive
+        // slot, so completions may still hold the lane. Stop before the global cancel
+        // or any native finetune so neither runs against them.
+        if (ctx.signal.aborted) {
+            return { type: 'finetune', status: 'CANCELLED' };
+        }
+        // Past the queued-abort check: this finetune now holds the exclusive lane. Mark
+        // it admitted so pauseFinetune pauses THIS finetune via model.pause() rather than
+        // global-pausing (and killing a reader) while it is merely queued.
+        admittedFinetunes.add(request.modelId);
+        ctx.scope.defer(() => {
+            admittedFinetunes.delete(request.modelId);
         });
+        // The pre-admission validation above ran before this request queued for the
+        // exclusive lane, so a peer finetune could have changed the checkpoint state
+        // while we waited. Re-validate now that we hold the lane exclusively and the
+        // state is stable.
+        validateExplicitFinetuneOperation(request);
+        // Global cancel is finetune's only stop; it runs exclusively, so nothing else
+        // is on the model when this fires.
         const onAbort = () => {
             model.cancel().catch((err) => {
                 requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${err instanceof Error ? err.message : String(err)}`);
@@ -167,19 +238,38 @@ export async function startFinetune(request, onProgress) {
     }
 }
 export async function pauseFinetune(modelId) {
+    // Validate the model is loaded on every path (matches main; getModel throws
+    // ModelNotFoundError for an unknown/unloaded model) before reporting any state.
     const model = getModel(modelId);
-    await model.pause();
-    return {
-        type: 'finetune',
-        status: 'PAUSED'
-    };
+    if (admittedFinetunes.has(modelId)) {
+        // The single finetune holds the model exclusively, so the addon-global pause is
+        // safe (nothing else runs on the model). Bar a new finetune until the native
+        // pause settles: the runtime ref can clear when handle.await() resolves, which
+        // may precede model.pause()'s resolution.
+        pausingModels.add(modelId);
+        try {
+            await model.pause();
+        }
+        finally {
+            pausingModels.delete(modelId);
+        }
+        return { type: 'finetune', status: 'PAUSED' };
+    }
+    if (getRunningFinetuneState(modelId)) {
+        // A finetune is pending but not yet admitted (queued behind a reader). A global
+        // pause would cancel that unrelated reader, so cancel the queued finetune by its
+        // own requestId. Nothing has trained, so report CANCELLED rather than a false
+        // PAUSED.
+        cancelTrackedFinetune(modelId);
+        return { type: 'finetune', status: 'CANCELLED' };
+    }
+    // No finetune on this model: a no-op pause, but the model was validated above.
+    return { type: 'finetune', status: 'PAUSED' };
 }
 // Routes cancellation through the registry; the model.cancel() forward is
 // installed by startFinetune, so never call model.cancel() here.
 export function cancelFinetune(modelId) {
-    // cancel() is synchronous; Promise.resolve keeps the Promise<FinetuneResult>
-    // return shape.
-    getRequestRegistry().cancel({ modelId, kind: 'finetune' });
+    cancelTrackedFinetune(modelId);
     return Promise.resolve({
         type: 'finetune',
         status: 'CANCELLED'