@qvac/sdk 0.14.1 → 0.16.0

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

@@ -1,45 +1,29 @@
-import { TOOLS_MODE } from "../../../../../schemas/tools.js";
-import { logCacheDisabled, logCacheInit, logCacheSave, logMessagesToAddon, } from "./cache-logger.js";
-import { extractSystemPrompt, getCurrentCacheInfo, } from "../../../ops/kv-cache-utils.js";
-import { getModel, getModelConfig, } from "../../../registry/model-registry.js";
-import { decideCachedHistorySlice } from "./kv-cache-state.js";
-import { createKvCacheSession, generateConfigHash, } from "./kv-cache-session.js";
-import { appendToolsToHistory, detectToolDialect, prependToolsToHistory, } from "../../../../utils/tool-integration.js";
-import { parseToolCalls } from "../../../../utils/tools/index.js";
-import { getResponseFormatJsonSchema } from "../../../../utils/response-format.js";
-import { buildAutoCacheSaveHistory } from "../../../../utils/index.js";
-import { getServerLogger } from "../../../../../logging/index.js";
-import { AttachmentNotFoundError } from "../../../../../utils/errors-server.js";
-import { nowMs } from "../../../../../profiling/index.js";
-import { buildStreamResult } from "../../../../../profiling/model-execution.js";
-import { normalizeCompletionStats } from "./completion-stats.js";
-import fs from "bare-fs";
+import { TOOLS_MODE } from '../../../../../schemas/tools.js';
+import { logCacheDisabled, logCacheInit, logCacheSave, logMessagesToAddon } from './cache-logger.js';
+import { extractSystemPrompt, getCurrentCacheInfo } from '../../../ops/kv-cache-utils.js';
+import { getModel, getModelConfig } from '../../../registry/model-registry.js';
+import { decideCachedHistorySlice, shouldCommitCachedTurn } from './kv-cache-state.js';
+import { createKvCacheSession, generateConfigHash } from './kv-cache-session.js';
+import { appendToolsToHistory, detectToolDialect, prependToolsToHistory } from '../../../../utils/tool-integration.js';
+import { parseToolCalls } from '../../../../utils/tools/index.js';
+import { getResponseFormatJsonSchema } from '../../../../utils/response-format.js';
+import { buildAutoCacheSaveHistory } from '../../../../utils/index.js';
+import { getServerLogger } from '../../../../../logging/index.js';
+import { AttachmentNotFoundError } from '../../../../../utils/errors-server.js';
+import { nowMs } from '../../../../../profiling/index.js';
+import { buildStreamResult } from '../../../../../profiling/model-execution.js';
+import { normalizeCompletionStats } from './completion-stats.js';
+import fs from 'bare-fs';
 const logger = getServerLogger();
-/**
- * Decide whether a completed turn earned the right to record its kv-cache
- * boundary. A `savedCount` is only safe to write when the turn ran to
- * completion AND produced at least one token — anything else (cancelled
- * mid-decode, zero-token reply, early EOS) leaves the on-disk cache file
- * in an unknown state relative to `history.length + 1`, and a stale entry
- * would slice the next turn's history down to an empty payload.
- *
- * Replaces the pre-0.11.0 `shouldRecordSavedCount(wasCancelled, ...)` with
- * a signal-driven check that reads directly from the request's
- * `AbortSignal`. The local helper keeps the call sites in
- * `completion-stream.ts` honest without importing the registry every time.
- */
-function shouldCommitTurn(signal, producedTokens) {
-    return !signal.aborted && producedTokens;
-}
 function transformMessage(message) {
     const transformed = [];
     // Check if it's a tool definition (has type: "function")
-    if ("type" in message && message.type === "function") {
+    if ('type' in message && message.type === 'function') {
         transformed.push({
-            type: "function",
+            type: 'function',
             name: message.name,
             description: message.description,
-            parameters: message.parameters,
+            parameters: message.parameters
         });
         return transformed;
     }
@@ -52,13 +36,13 @@ function transformMessage(message) {
             transformed.push({
                 role: msg.role,
                 content: attachment.path,
-                type: "media",
+                type: 'media'
             });
         }
     }
     transformed.push({
         role: msg.role,
-        content: msg.content,
+        content: msg.content
     });
     return transformed;
 }
@@ -66,7 +50,7 @@ function runModel(model, prompt, opts) {
     const run = model.run.bind(model);
     return run(prompt, opts);
 }
-function transformMessages(messages) {
+export function transformMessages(messages) {
     const transformed = [];
     for (const message of messages) {
         transformed.push(...transformMessage(message));
@@ -74,9 +58,7 @@ function transformMessages(messages) {
     return transformed;
 }
 async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, cacheKey, tools) {
-    const primeMessages = [
-        { role: "system", content: systemPromptToUse },
-    ];
+    const primeMessages = [{ role: 'system', content: systemPromptToUse }];
     let toolCount = 0;
     if (tools && tools.length > 0) {
         const transformedTools = transformMessages(tools);
@@ -84,11 +66,11 @@ async function initSystemPromptCache(model, cachePathToUse, systemPromptToUse, c
         toolCount = tools.length;
     }
     logCacheInit(cacheKey, systemPromptToUse, toolCount);
-    logMessagesToAddon(primeMessages, "CACHE_INIT");
+    logMessagesToAddon(primeMessages, 'CACHE_INIT');
     const primeResponse = await runModel(model, primeMessages, {
         cacheKey: cachePathToUse,
         saveCacheToDisk: true,
-        prefill: true,
+        prefill: true
     });
     await primeResponse.await();
 }
@@ -124,7 +106,7 @@ function prepareMessagesForCache(session, turn, cacheExists, history, tools) {
     const addTools = tools?.length ? transformMessages(tools) : [];
     const dynamic = addTools.length > 0;
     if (!(cacheExists && history.length > 0)) {
-        const historyWithoutSystem = history.filter((msg) => msg.role !== "system");
+        const historyWithoutSystem = history.filter((msg) => msg.role !== 'system');
         return [...transformMessages(historyWithoutSystem), ...addTools];
     }
     if (!dynamic) {
@@ -147,19 +129,19 @@ function prepareMessagesForCache(session, turn, cacheExists, history, tools) {
     // 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") {
+    if (lastMsg.role === 'tool') {
         const trailingTools = [];
         for (let i = history.length - 1; i >= 0; i--) {
             const msg = history[i];
-            if (msg.role !== "tool")
+            if (msg.role !== 'tool')
                 break;
             trailingTools.unshift(msg);
         }
         return transformMessages(trailingTools);
     }
-    if (lastMsg.role === "user") {
+    if (lastMsg.role === 'user') {
         const prevMsg = history[history.length - 2];
-        const tail = prevMsg?.role === "assistant" ? [prevMsg, lastMsg] : [lastMsg];
+        const tail = prevMsg?.role === 'assistant' ? [prevMsg, lastMsg] : [lastMsg];
         return [...transformMessages(tail), ...addTools];
     }
     return [...transformMessages([lastMsg]), ...addTools];
@@ -168,16 +150,16 @@ async function* processModelResponse(model, messagesToSend, tools, generationPar
     const runOptions = {
         ...(generationParams && { generationParams }),
         ...(cacheOptions?.cacheKey !== undefined && {
-            cacheKey: cacheOptions.cacheKey,
+            cacheKey: cacheOptions.cacheKey
         }),
         ...(cacheOptions?.saveCacheToDisk !== undefined && {
-            saveCacheToDisk: cacheOptions.saveCacheToDisk,
-        }),
+            saveCacheToDisk: cacheOptions.saveCacheToDisk
+        })
     };
     const hasRunOptions = Object.keys(runOptions).length > 0;
     const modelStart = nowMs();
     const response = await runModel(model, messagesToSend, hasRunOptions ? runOptions : undefined);
-    let accumulatedText = "";
+    let accumulatedText = '';
     let producedTokens = false;
     let toolCallsResult = [];
     for await (const token of response.iterate()) {
@@ -201,7 +183,7 @@ async function* processModelResponse(model, messagesToSend, tools, generationPar
         ...buildStreamResult(modelExecutionMs, stats),
         toolCalls: toolCallsResult,
         responseText: accumulatedText,
-        producedTokens,
+        producedTokens
     };
 }
 export async function* completion(params, opts) {
@@ -213,9 +195,7 @@ export async function* completion(params, opts) {
     const toolsMode = modelConfig.toolsMode;
     const dynamicTools = !!tools?.length && toolsEnabled && toolsMode === TOOLS_MODE.dynamic;
     const staticTools = !!tools?.length && toolsEnabled && !dynamicTools;
-    const dialect = tools && tools.length > 0
-        ? (params.toolDialect ?? detectToolDialect(modelId))
-        : undefined;
+    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
     // applies for the duration of the request only. This avoids mutating
@@ -229,7 +209,7 @@ export async function* completion(params, opts) {
         if (jsonSchema !== undefined) {
             mergedGenerationParams = {
                 ...(generationParams ?? {}),
-                json_schema: jsonSchema,
+                json_schema: jsonSchema
             };
         }
     }
@@ -254,7 +234,7 @@ export async function* completion(params, opts) {
             });
         }
     };
-    signal.addEventListener("abort", onAbort, { once: true });
+    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
@@ -269,7 +249,7 @@ export async function* completion(params, opts) {
     // 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);
+        signal.removeEventListener('abort', onAbort);
     });
     if (!kvCache) {
         // KV-cache disabled — straight passthrough, no session involvement.
@@ -282,7 +262,7 @@ export async function* completion(params, opts) {
         }
         const transformedHistory = transformMessages(historyWithTools);
         logCacheDisabled();
-        logMessagesToAddon(transformedHistory, "NO_CACHE");
+        logMessagesToAddon(transformedHistory, 'NO_CACHE');
         return yield* processModelResponse(model, transformedHistory, tools, mergedGenerationParams, undefined, dialect);
     }
     // ---- KV-cache path. The session owns all three bookkeeping layers
@@ -299,34 +279,34 @@ export async function* completion(params, opts) {
     const configHash = generateConfigHash(systemPromptFromHistory, dynamicTools ? undefined : tools);
     const systemPromptToUse = systemPromptFromHistory ||
         modelConfig.system_prompt ||
-        "You are a helpful assistant.";
+        'You are a helpful assistant.';
     const primeIfMissing = async (cachePath) => {
-        await initSystemPromptCache(model, cachePath, systemPromptToUse, typeof kvCache === "string" ? kvCache : "auto", 
+        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);
     };
     let turn;
-    if (typeof kvCache === "string") {
+    if (typeof kvCache === 'string') {
         turn = await session.beginTurn({
-            kind: "custom",
+            kind: 'custom',
             customKey: kvCache,
             configHash,
-            primeIfMissing,
+            primeIfMissing
         });
     }
     else {
         const cacheMessages = history.map((msg) => ({
             role: msg.role,
             content: msg.content,
-            attachments: msg.attachments ?? undefined,
+            attachments: msg.attachments ?? undefined
         }));
         turn = await session.beginTurn({
-            kind: "auto",
+            kind: 'auto',
             configHash,
             history: cacheMessages,
-            primeIfMissing,
+            primeIfMissing
         });
     }
     // Single cleanup hook for every non-success exit path. `commitTurn`
@@ -340,16 +320,22 @@ export async function* completion(params, opts) {
     // selector so the slicing branches engage.
     const messagesToSend = prepareMessagesForCache(session, turn, 
     /* cacheExists */ true, history, dynamicTools ? tools : undefined);
-    logMessagesToAddon(messagesToSend, "PROMPT_SEND");
+    logMessagesToAddon(messagesToSend, 'PROMPT_SEND');
     const result = yield* processModelResponse(model, messagesToSend, tools, mergedGenerationParams, { cacheKey: turn.cachePath, saveCacheToDisk: true }, dialect);
-    if (typeof kvCache === "string") {
+    const shouldCommitTurn = shouldCommitCachedTurn({
+        aborted: signal.aborted,
+        producedTokens: result.producedTokens,
+        generatedTokens: result.stats?.generatedTokens,
+        predict: mergedGenerationParams?.predict ?? modelConfig.predict
+    });
+    if (typeof kvCache === 'string') {
         // Custom-key path: the addon wrote the new cache state inline at
         // the same path. Either commit (records the boundary, suppresses
         // rollback) or fall through to the deferred rollback.
-        if (shouldCommitTurn(signal, result.producedTokens)) {
+        if (shouldCommitTurn) {
             await session.commitTurn(turn, {
-                kind: "static",
-                messageCount: history.length + 1,
+                kind: 'static',
+                messageCount: history.length + 1
             });
         }
         return result;
@@ -366,22 +352,21 @@ export async function* completion(params, opts) {
         logger.warn(`[kv-cache] Auto cache tool-call turn; rolling back to avoid disk leak. path=${turn.cachePath}`);
         return result;
     }
-    if (!shouldCommitTurn(signal, result.producedTokens)) {
-        // Cancelled or zero-token turn — the addon wrote the file but its
-        // contents don't correspond to a clean turn boundary. Let the
-        // deferred rollback unlink it.
+    if (!shouldCommitTurn) {
+        // Cancelled, zero-token, or budget-exhausted turns do not establish
+        // a trustworthy message boundary.
         return result;
     }
     const savedHistory = buildAutoCacheSaveHistory(history.map((msg) => ({
         role: msg.role,
         content: msg.content,
-        attachments: msg.attachments ?? undefined,
+        attachments: msg.attachments ?? undefined
     })), result.responseText);
     const postResponseCacheInfo = await getCurrentCacheInfo(modelId, configHash, savedHistory);
     await session.commitTurn(turn, {
-        kind: "autoRename",
+        kind: 'autoRename',
         targetCachePath: postResponseCacheInfo.cachePath,
-        messageCount: savedHistory.length,
+        messageCount: savedHistory.length
     });
     return result;
 }

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

@@ -13,14 +13,14 @@
  * + extraction logic without a real model load.
  */
 export function isAddonContextOverflowError(err) {
-    if (typeof err !== "object" || err === null)
+    if (typeof err !== 'object' || err === null)
         return false;
     const code = err.code;
     // Anchor to the codeString tail (`[ <addonId> :: ContextOverflow ]`)
     // so we don't false-positive on a hypothetical sibling like
     // `ContextOverflowRecovered` or `PostContextOverflow` after an
     // addon-side rename.
-    if (typeof code === "string" && /::\s*ContextOverflow\s*\]/.test(code)) {
+    if (typeof code === 'string' && /::\s*ContextOverflow\s*\]/.test(code)) {
         return true;
     }
     // Message-substring fallback for the bare `LlamaModel::processPromptImpl`
@@ -28,7 +28,7 @@ export function isAddonContextOverflowError(err) {
     // two known C++-emitted formats only — broader substring would catch
     // wrapper / cause-chain text that mentions overflow without being one.
     const message = err.message;
-    return (typeof message === "string" &&
+    return (typeof message === 'string' &&
         /(?:context overflow at prefill step|processPromptImpl: context overflow)/i.test(message));
 }
 /**
@@ -49,7 +49,7 @@ export function parseContextOverflowMessage(message) {
     if (longForm?.[1] && longForm[2]) {
         return {
             promptTokens: Number(longForm[1]),
-            ctxSize: Number(longForm[2]),
+            ctxSize: Number(longForm[2])
         };
     }
     // "[TextLlm] context overflow at prefill step (N tokens, max M)\n"
@@ -58,7 +58,7 @@ export function parseContextOverflowMessage(message) {
     if (shortForm?.[1] && shortForm[2]) {
         return {
             promptTokens: Number(shortForm[1]),
-            ctxSize: Number(shortForm[2]),
+            ctxSize: Number(shortForm[2])
         };
     }
     return {};

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

@@ -1,5 +1,5 @@
-import type { FinetuneRunParams, FinetuneRunRequest, FinetuneProgress, FinetuneRequest, FinetuneResult, FinetuneStatus, FinetuneGetStateRequest } from "../../../../../schemas/index";
-type FinetuneOptions = FinetuneRunParams["options"];
+import type { FinetuneRunParams, FinetuneRunRequest, FinetuneProgress, FinetuneRequest, FinetuneResult, FinetuneStatus, FinetuneGetStateRequest } from '../../../../../schemas/index';
+type FinetuneOptions = FinetuneRunParams['options'];
 export declare function clearFinetuneRuntimeState(modelId: string): void;
 export declare function getFinetuneStateFromCheckpoints(options: FinetuneOptions): FinetuneStatus;
 export declare function startFinetune(request: FinetuneRunRequest, onProgress?: (progress: FinetuneProgress) => void): Promise<FinetuneResult>;

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

@@ -50,13 +50,13 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import fs from "bare-fs";
-import { getModel, } from "../../../registry/model-registry.js";
-import { CompletionFailedError, } from "../../../../../utils/errors-server.js";
-import { getRequestRegistry, withRequestContext, } from "../../../runtime/index.js";
-import { generateServerRequestId } from "../../../runtime/request-id.js";
-import { getServerLogger } from "../../../../../logging/index.js";
-const PAUSE_CHECKPOINT_PREFIX = "pause_checkpoint_step_";
+import fs from 'bare-fs';
+import { getModel } from '../../../registry/model-registry.js';
+import { CompletionFailedError } from '../../../../../utils/errors-server.js';
+import { getRequestRegistry, withRequestContext } from '../../../runtime/index.js';
+import { generateServerRequestId } from '../../../runtime/request-id.js';
+import { getServerLogger } from '../../../../../logging/index.js';
+const PAUSE_CHECKPOINT_PREFIX = 'pause_checkpoint_step_';
 const finetuneRuntimeState = new Set();
 function getRunningFinetuneState(modelId) {
     return finetuneRuntimeState.has(modelId);
@@ -68,35 +68,35 @@ export function clearFinetuneRuntimeState(modelId) {
     finetuneRuntimeState.delete(modelId);
 }
 export function getFinetuneStateFromCheckpoints(options) {
-    const checkpointDirectory = options.checkpointSaveDir ?? "./checkpoints";
+    const checkpointDirectory = options.checkpointSaveDir ?? './checkpoints';
     if (!fs.existsSync(checkpointDirectory)) {
-        return "IDLE";
+        return 'IDLE';
     }
     try {
         const entries = fs.readdirSync(checkpointDirectory);
         for (const entry of entries) {
-            if (typeof entry !== "string") {
+            if (typeof entry !== 'string') {
                 continue;
             }
             if (entry.startsWith(PAUSE_CHECKPOINT_PREFIX)) {
-                return "PAUSED";
+                return 'PAUSED';
             }
         }
     }
     catch (error) {
         throw new CompletionFailedError(`Failed to inspect finetune checkpoints in "${checkpointDirectory}"`, error);
     }
-    return "IDLE";
+    return 'IDLE';
 }
 function validateExplicitFinetuneOperation(request) {
     if (!request.operation) {
         return;
     }
     const state = getFinetuneStateFromCheckpoints(request.options);
-    if (request.operation === "start" && state === "PAUSED") {
+    if (request.operation === 'start' && state === 'PAUSED') {
         throw new CompletionFailedError(`Model "${request.modelId}" has a paused finetune checkpoint; resume it or cancel it before starting from scratch`);
     }
-    if (request.operation === "resume" && state === "IDLE") {
+    if (request.operation === 'resume' && state === 'IDLE') {
         throw new CompletionFailedError(`Model "${request.modelId}" has no paused finetune checkpoint to resume`);
     }
 }
@@ -117,8 +117,8 @@ export async function startFinetune(request, onProgress) {
         const ctx = __addDisposableResource(env_1, await getRequestRegistry()
             .begin({
             requestId: request.requestId ?? generateServerRequestId(),
-            kind: "finetune",
-            modelId: request.modelId,
+            kind: 'finetune',
+            modelId: request.modelId
         })
             .catch((err) => {
             if (!wasRunning)
@@ -136,24 +136,24 @@ export async function startFinetune(request, onProgress) {
                 requestLogger.warn(`[cancel] model.cancel() rejected during abort for modelId=${request.modelId}: ${err instanceof Error ? err.message : String(err)}`);
             });
         };
-        ctx.signal.addEventListener("abort", onAbort, { once: true });
+        ctx.signal.addEventListener('abort', onAbort, { once: true });
         if (ctx.signal.aborted)
             onAbort();
         ctx.scope.defer(() => {
-            ctx.signal.removeEventListener("abort", onAbort);
+            ctx.signal.removeEventListener('abort', onAbort);
         });
         const handle = await model.finetune(request.options);
         if (onProgress) {
-            handle.on("stats", onProgress);
+            handle.on('stats', onProgress);
             ctx.scope.defer(() => {
-                handle.removeListener("stats", onProgress);
+                handle.removeListener('stats', onProgress);
             });
         }
         const result = await handle.await();
         return {
-            type: "finetune",
+            type: 'finetune',
             status: result.status,
-            stats: result.stats,
+            stats: result.stats
         };
     }
     catch (e_1) {
@@ -170,8 +170,8 @@ export async function pauseFinetune(modelId) {
     const model = getModel(modelId);
     await model.pause();
     return {
-        type: "finetune",
-        status: "PAUSED",
+        type: 'finetune',
+        status: 'PAUSED'
     };
 }
 // Routes cancellation through the registry; the model.cancel() forward is
@@ -179,31 +179,31 @@ export async function pauseFinetune(modelId) {
 export function cancelFinetune(modelId) {
     // cancel() is synchronous; Promise.resolve keeps the Promise<FinetuneResult>
     // return shape.
-    getRequestRegistry().cancel({ modelId, kind: "finetune" });
+    getRequestRegistry().cancel({ modelId, kind: 'finetune' });
     return Promise.resolve({
-        type: "finetune",
-        status: "CANCELLED",
+        type: 'finetune',
+        status: 'CANCELLED'
     });
 }
 export function getFinetuneState(params) {
     const runtimeState = getRunningFinetuneState(params.modelId);
     return {
-        type: "finetune",
-        status: runtimeState ? "RUNNING" : getFinetuneStateFromCheckpoints(params.options),
+        type: 'finetune',
+        status: runtimeState ? 'RUNNING' : getFinetuneStateFromCheckpoints(params.options)
     };
 }
 export async function finetune(request, onProgress) {
     if (request.operation === undefined ||
-        request.operation === "start" ||
-        request.operation === "resume") {
+        request.operation === 'start' ||
+        request.operation === 'resume') {
         return startFinetune(request, onProgress);
     }
     switch (request.operation) {
-        case "getState":
+        case 'getState':
             return getFinetuneState(request);
-        case "pause":
+        case 'pause':
             return pauseFinetune(request.modelId);
-        case "cancel":
+        case 'cancel':
             return cancelFinetune(request.modelId);
     }
 }

package/dist/server/bare/plugins/llamacpp-completion/ops/kv-cache-session.d.ts

@@ -1,6 +1,6 @@
-import { generateConfigHash } from "../../../ops/kv-cache-utils";
-import type { CacheMessage } from "../../../../utils/index";
-import type { Logger } from "../../../../../logging/types";
+import { generateConfigHash } from '../../../ops/kv-cache-utils';
+import type { CacheMessage } from '../../../../utils/index';
+import type { Logger } from '../../../../../logging/types';
 export interface TurnHandle {
     /** Resolved on-disk cache file path the addon will read from / write to. */
     readonly cachePath: string;
@@ -12,7 +12,7 @@ export interface TurnHandle {
     readonly savedCount: number;
 }
 export interface BeginCustomTurnInput {
-    kind: "custom";
+    kind: 'custom';
     /** User-provided session key (`completion({ kvCache: "session-a" })`). */
     customKey: string;
     /** Hash of system prompt + (static) tool names. */
@@ -26,7 +26,7 @@ export interface BeginCustomTurnInput {
     primeIfMissing: (cachePath: string) => Promise<void>;
 }
 export interface BeginAutoTurnInput {
-    kind: "auto";
+    kind: 'auto';
     /** Hash of system prompt + (static) tool names. */
     configHash: string;
     /** Conversation history used to compute the pre-response cache key. */
@@ -36,12 +36,12 @@ export interface BeginAutoTurnInput {
 }
 export type BeginTurnInput = BeginCustomTurnInput | BeginAutoTurnInput;
 export interface StaticCommitResult {
-    kind: "static";
+    kind: 'static';
     /** `history.length + 1` — recorded at the turn's current `cachePath`. */
     messageCount: number;
 }
 export interface AutoRenameCommitResult {
-    kind: "autoRename";
+    kind: 'autoRename';
     /**
      * Destination path the addon's pre-response cache file should be
      * renamed to (computed from `cacheMessages + responseText`). The