@qwen-code/arena-agent 0.0.8 → 0.0.9-dev.0

package/dist/server.js

@@ -1,14 +1,20 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
-import { cp, mkdir, readFile, readdir, realpath, rename, stat, writeFile, } from "node:fs/promises";
+import { cp, mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
 import http from "node:http";
 import path from "node:path";
 import { Agent } from "./agent.js";
 import { attachmentMimeType, attachmentUserMessage, maxAttachmentBytesPerMessage, maxAttachmentsPerMessage, maxUploadBytes, mimeTypes, saveAttachment, uploadsDirectory, } from "./attachments.js";
 import { configFromEnv } from "./config.js";
-import { loadStoredHistory, saveStoredHistory, sessionStorageRoot, } from "./history.js";
+import { historyMetadata, loadStoredHistory, loadStoredHistoryState, saveStoredHistory, sessionStorageRoot, } from "./history.js";
+import { ModelBashMetricJudge, SessionMetricsAnalyzer, } from "./metrics.js";
+import { ModelConversationMetricJudge } from "./conversation-metrics.js";
+import { MockModelClient } from "./mock.js";
 import { EventSink } from "./protocol.js";
-import { projectRoot } from "./spec.js";
+import { HttpModelClient } from "./provider.js";
+import { embeddedAsset } from "./runtime-assets.js";
+import { StructuredSideQueryRunner } from "./side-query.js";
+import { projectRoot, toolDefinitions } from "./spec.js";
 const sessionSeedExcludes = new Set([
     ".arena",
     ".cache",
@@ -154,6 +160,69 @@ function sessionHistoryPath(session) {
 function sessionMetadataPath(session) {
     return path.join(session.root, "session.json");
 }
+function sessionUndoRoot(session) {
+    return path.join(session.root, "undo");
+}
+function sessionUndoMetadataPath(session) {
+    return path.join(sessionUndoRoot(session), "checkpoint.json");
+}
+function sessionUndoWorkspacePath(session) {
+    return path.join(sessionUndoRoot(session), "workspace");
+}
+function sessionRetryPath(session) {
+    return path.join(session.root, "model-retry.json");
+}
+function historyHash(messages) {
+    return crypto
+        .createHash("sha256")
+        .update(JSON.stringify({ messages }))
+        .digest("hex");
+}
+async function loadModelRetry(session) {
+    try {
+        const value = JSON.parse(await readFile(sessionRetryPath(session), "utf8"));
+        if (value.version !== 1 ||
+            value.sessionId !== session.id ||
+            typeof value.messageId !== "string" ||
+            typeof value.prompt !== "string" ||
+            typeof value.failedAt !== "number" ||
+            typeof value.error !== "string" ||
+            typeof value.historyHash !== "string" ||
+            !/^[a-f0-9]{64}$/.test(value.historyHash)) {
+            throw new Error("invalid persisted model retry state");
+        }
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+}
+async function saveModelRetry(session, retry) {
+    const target = sessionRetryPath(session);
+    const temporary = `${target}.${crypto.randomUUID()}.tmp`;
+    await writeFile(temporary, JSON.stringify(retry), "utf8");
+    await rename(temporary, target);
+}
+async function clearModelRetry(session) {
+    await rm(sessionRetryPath(session), { force: true });
+}
+async function modelRetryForHistory(session, messages) {
+    let retry;
+    try {
+        retry = await loadModelRetry(session);
+    }
+    catch {
+        await clearModelRetry(session);
+        return undefined;
+    }
+    if (retry && historyHash(messages) !== retry.historyHash) {
+        await clearModelRetry(session);
+        return undefined;
+    }
+    return retry;
+}
 function hashToken(token) {
     return crypto.createHash("sha256").update(token).digest("hex");
 }
@@ -206,6 +275,120 @@ async function saveSessionMetadata(session) {
     await writeFile(temporary, JSON.stringify(metadata), "utf8");
     await rename(temporary, target);
 }
+async function loadUndoCheckpoint(session) {
+    try {
+        const checkpoint = JSON.parse(await readFile(sessionUndoMetadataPath(session), "utf8"));
+        if (checkpoint.version !== 1 ||
+            typeof checkpoint.messageId !== "string" ||
+            typeof checkpoint.input !== "string" ||
+            !Array.isArray(checkpoint.attachments) ||
+            !Array.isArray(checkpoint.messages) ||
+            typeof checkpoint.createdAt !== "number") {
+            throw new Error("invalid persisted undo checkpoint");
+        }
+        const workspace = await stat(sessionUndoWorkspacePath(session));
+        if (!workspace.isDirectory()) {
+            throw new Error("undo checkpoint workspace is not a directory");
+        }
+        return checkpoint;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function snapshotIncludes(root, source) {
+    const relative = path.relative(root, source);
+    if (!relative)
+        return true;
+    return !relative
+        .split(path.sep)
+        .some((part) => sessionSeedExcludes.has(part));
+}
+function checkpointAttachment(attachment) {
+    return {
+        name: attachment.name,
+        path: attachment.path,
+        mimeType: attachment.mimeType,
+        size: attachment.size,
+        ...(attachment.imageMimeType
+            ? { imageMimeType: attachment.imageMimeType }
+            : {}),
+        ...(attachment.sourceUrl ? { sourceUrl: attachment.sourceUrl } : {}),
+    };
+}
+async function installDirectory(staging, target) {
+    const previous = `${target}.${crypto.randomUUID()}.previous`;
+    let movedPrevious = false;
+    try {
+        await rename(target, previous);
+        movedPrevious = true;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    try {
+        await rename(staging, target);
+    }
+    catch (error) {
+        if (movedPrevious)
+            await rename(previous, target).catch(() => undefined);
+        throw error;
+    }
+    if (movedPrevious) {
+        await rm(previous, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+async function prepareUndoCheckpoint(session, messageId, input, attachments) {
+    const storedHistory = await loadStoredHistoryState(sessionHistoryPath(session));
+    const checkpoint = {
+        version: 1,
+        messageId,
+        input,
+        attachments: attachments.map(checkpointAttachment),
+        messages: structuredClone((await readHistory(session)) || []),
+        ...(storedHistory?.metrics
+            ? { metrics: structuredClone(storedHistory.metrics) }
+            : {}),
+        createdAt: Date.now(),
+    };
+    const target = sessionUndoRoot(session);
+    const staging = `${target}.${crypto.randomUUID()}.tmp`;
+    try {
+        await mkdir(staging, { recursive: true });
+        await cp(session.workspace, path.join(staging, "workspace"), {
+            recursive: true,
+            mode: fs.constants.COPYFILE_FICLONE,
+            filter: (source) => snapshotIncludes(session.workspace, source),
+            verbatimSymlinks: true,
+        });
+        await writeFile(path.join(staging, "checkpoint.json"), JSON.stringify(checkpoint), "utf8");
+        await installDirectory(staging, target);
+        session.undoCheckpoint = checkpoint;
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function restoreUndoWorkspace(session) {
+    const source = sessionUndoWorkspacePath(session);
+    const staging = `${session.workspace}.${crypto.randomUUID()}.restore`;
+    try {
+        await cp(source, staging, {
+            recursive: true,
+            mode: fs.constants.COPYFILE_FICLONE,
+            verbatimSymlinks: true,
+        });
+        await installDirectory(staging, session.workspace);
+    }
+    catch (error) {
+        await rm(staging, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
 async function seedSessionWorkspace(context, target) {
     await mkdir(target, { recursive: true });
     if (process.env.ARENA_SESSION_WORKSPACE_MODE === "empty") {
@@ -246,10 +429,13 @@ async function createSession(context, clientContext) {
         root: paths.root,
         workspace: paths.workspace,
         artifacts: paths.artifacts,
+        history: null,
+        undoCheckpoint: null,
         events: [],
         nextEventId: 1,
         subscribers: new Set(),
         running: null,
+        preparingTurn: false,
         pendingInput: null,
         pendingInterruption: false,
         interruptionGeneration: 0,
@@ -304,10 +490,13 @@ async function getSession(context, sessionId) {
             root: paths.root,
             workspace: paths.workspace,
             artifacts: paths.artifacts,
+            history: null,
+            undoCheckpoint: null,
             events: [],
             nextEventId: 1,
             subscribers: new Set(),
             running: null,
+            preparingTurn: false,
             pendingInput: null,
             pendingInterruption: metadata.pendingInterruption === true,
             interruptionGeneration: typeof metadata.interruptionGeneration === "number" &&
@@ -327,6 +516,7 @@ async function getSession(context, sessionId) {
             mkdir(loaded.workspace, { recursive: true }),
             mkdir(loaded.artifacts, { recursive: true }),
         ]);
+        loaded.undoCheckpoint = await loadUndoCheckpoint(loaded);
         const raced = context.sessions.get(sessionId);
         if (raced)
             return raced;
@@ -546,7 +736,7 @@ function createUiStream(session, messageId) {
     };
     emit(session, { type: "start", messageId });
     return {
-        consume(event) {
+        consume(event, resultOptions = {}) {
             if (event.type === "model.start") {
                 state.toolParts = new Map();
                 emit(session, {
@@ -737,6 +927,8 @@ function createUiStream(session, messageId) {
                     type: "trigger:turn-complete",
                     status: event.status,
                     error: event.error,
+                    messageId: state.messageId,
+                    retryable: resultOptions.retryable === true,
                 });
                 state.completed = true;
             }
@@ -757,16 +949,56 @@ function createUiStream(session, messageId) {
     };
 }
 async function readHistory(session) {
-    return loadStoredHistory(sessionHistoryPath(session));
+    if (session.history)
+        return structuredClone(session.history);
+    const messages = await loadStoredHistory(sessionHistoryPath(session));
+    if (messages)
+        session.history = structuredClone(messages);
+    return messages ? structuredClone(messages) : undefined;
+}
+async function saveHistory(session, messages, config, metrics) {
+    await saveStoredHistory(sessionHistoryPath(session), messages, historyMetadata(config, session.id), metrics);
+    session.history = structuredClone([...messages]);
 }
-async function saveHistory(session, messages) {
-    await saveStoredHistory(sessionHistoryPath(session), messages);
+function sessionMetricsAnalyzer(config, signal) {
+    const sideQueryModel = config.metricsSideQueryModel || config.model;
+    const runner = config.metricsSideQueryEnabled
+        ? new StructuredSideQueryRunner(sideQueryModel.startsWith("mock/")
+            ? new MockModelClient()
+            : new HttpModelClient(config), {
+            model: sideQueryModel,
+            maxTokens: config.metricsSideQueryMaxTokens,
+            maxAttempts: config.metricsSideQueryMaxAttempts,
+            enableThinking: config.metricsSideQueryEnableThinking,
+            thinkingBudget: config.metricsSideQueryThinkingBudget,
+            signal,
+        })
+        : undefined;
+    return new SessionMetricsAnalyzer({
+        fallbackOfferedToolNames: toolDefinitions().map((definition) => definition.function.name),
+        ...(runner ? { judge: new ModelBashMetricJudge(runner) } : {}),
+        ...(runner
+            ? { conversationJudge: new ModelConversationMetricJudge(runner) }
+            : {}),
+    });
+}
+function lastAssistantText(messages) {
+    if (!messages)
+        return "";
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role === "assistant")
+            return message.content;
+    }
+    return "";
 }
-async function runAgent(context, session, prompt, messageId, interruptionGeneration, userMessage) {
+async function runAgent(context, session, prompt, messageId, controller, interruptionGeneration, userMessage, resumeFromHistory = false) {
     const ui = createUiStream(session, messageId);
-    const controller = new AbortController();
-    session.running = { controller };
-    let pendingResult = null;
+    let failedModelCheckpoint;
+    let failedModelError;
+    let currentOfferedToolNames = [];
+    const offeredToolNamesByCallId = new Map();
+    const currentTurnMessages = [];
     let sink;
     const askUserHandler = (toolCallId, questions) => new Promise((resolve, reject) => {
         if (controller.signal.aborted) {
@@ -785,10 +1017,20 @@ async function runAgent(context, session, prompt, messageId, interruptionGenerat
     sink = new EventSink({
         format: "silent",
         onEvent: (event) => {
-            if (event.type === "result") {
-                pendingResult = event;
+            if (event.type === "model.start") {
+                currentOfferedToolNames = [...(event.offered_tool_names || [])];
             }
-            else {
+            else if (event.type === "message" && event.message?.role === "assistant") {
+                for (const call of event.message.tool_calls || []) {
+                    if (call.id) {
+                        offeredToolNamesByCallId.set(call.id, [...currentOfferedToolNames]);
+                    }
+                }
+            }
+            if (event.type === "message" && event.message) {
+                currentTurnMessages.push(structuredClone(event.message));
+            }
+            if (event.type !== "result") {
                 ui.consume(event);
             }
         },
@@ -798,12 +1040,17 @@ async function runAgent(context, session, prompt, messageId, interruptionGenerat
         workspace: session.workspace,
     };
     try {
-        const history = await readHistory(session);
+        const storedHistory = await loadStoredHistoryState(sessionHistoryPath(session));
+        const history = storedHistory?.messages;
         const result = await new Agent(sessionConfig, sink, {
             askUserHandler,
             sessionId: session.id,
             signal: controller.signal,
-            onCheckpoint: (messages) => saveHistory(session, messages),
+            onCheckpoint: (messages) => saveHistory(session, messages, sessionConfig),
+            onModelFailure: (messages, error) => {
+                failedModelCheckpoint = structuredClone([...messages]);
+                failedModelError = error;
+            },
             clientContext: {
                 currentDate: session.currentDate,
                 timezone: session.timezone,
@@ -812,10 +1059,42 @@ async function runAgent(context, session, prompt, messageId, interruptionGenerat
         }).run(prompt, history, {
             interrupted: interruptionGeneration !== undefined,
             userMessage,
+            resumeFromHistory,
         });
-        const shouldPersistHistory = result.status === "success" || controller.signal.aborted;
-        if (shouldPersistHistory) {
-            await saveHistory(session, result.messages);
+        let deliveredResult = result;
+        let retryable = false;
+        if (result.status === "error" &&
+            !controller.signal.aborted &&
+            failedModelCheckpoint) {
+            const checkpoint = structuredClone(failedModelCheckpoint);
+            await saveHistory(session, checkpoint, sessionConfig);
+            await saveModelRetry(session, {
+                version: 1,
+                sessionId: session.id,
+                messageId,
+                prompt,
+                failedAt: Date.now(),
+                error: errorMessage(failedModelError ?? result.error ?? "model failed"),
+                historyHash: historyHash(checkpoint),
+            });
+            deliveredResult = { ...result, messages: checkpoint };
+            retryable = true;
+        }
+        else {
+            await clearModelRetry(session);
+        }
+        const metrics = await sessionMetricsAnalyzer(sessionConfig, controller.signal).update({
+            messages: deliveredResult.messages,
+            previous: storedHistory?.metrics,
+            throughTurnId: messageId,
+            turnStatus: deliveredResult.status,
+            offeredToolNamesByCallId,
+            ...(!resumeFromHistory ? { currentUserText: prompt } : {}),
+            previousAssistantText: lastAssistantText(history),
+            currentTurnMessages,
+        });
+        await saveHistory(session, deliveredResult.messages, sessionConfig, metrics);
+        if (result.status === "success" || controller.signal.aborted) {
             if (interruptionGeneration !== undefined &&
                 session.interruptionGeneration === interruptionGeneration) {
                 session.pendingInterruption = false;
@@ -823,7 +1102,11 @@ async function runAgent(context, session, prompt, messageId, interruptionGenerat
         }
         session.touchedAt = Date.now();
         await saveSessionMetadata(session);
-        ui.consume(pendingResult || result);
+        emit(session, {
+            type: "data-session-metrics",
+            data: { metrics },
+        });
+        ui.consume(deliveredResult, { retryable });
     }
     catch (error) {
         session.touchedAt = Date.now();
@@ -916,7 +1199,9 @@ async function triggerToken(context, request, response) {
 async function uploadAttachment(request, response, session) {
     if (!authorize(request, response, session))
         return;
-    if (session.running) {
+    if (session.running ||
+        session.preparingTurn ||
+        session.activePrompt !== null) {
         writeJson(response, 409, {
             error: "attachments cannot be uploaded while a turn is running",
         });
@@ -949,7 +1234,9 @@ async function uploadAttachment(request, response, session) {
 async function appendMessage(context, request, response, session) {
     if (!authorize(request, response, session))
         return;
-    if (session.running) {
+    if (session.running ||
+        session.preparingTurn ||
+        session.activePrompt !== null) {
         writeJson(response, 409, { error: "a turn is already running" });
         return;
     }
@@ -1001,6 +1288,22 @@ async function appendMessage(context, request, response, session) {
         ? attachmentUserMessage(prompt, attachments)
         : undefined;
     const messageId = String(payload.messageId || message.id || crypto.randomUUID());
+    if (session.running ||
+        session.preparingTurn ||
+        session.activePrompt !== null) {
+        writeJson(response, 409, { error: "a turn is already running" });
+        return;
+    }
+    const controller = new AbortController();
+    session.preparingTurn = true;
+    try {
+        await prepareUndoCheckpoint(session, messageId, prompt, attachments);
+        await clearModelRetry(session);
+        session.running = { controller };
+    }
+    finally {
+        session.preparingTurn = false;
+    }
     const interruptionGeneration = session.pendingInterruption
         ? session.interruptionGeneration
         : undefined;
@@ -1019,19 +1322,144 @@ async function appendMessage(context, request, response, session) {
         partId: request.headers["x-part-id"] || null,
     });
     queueMicrotask(() => {
-        void runAgent(context, session, prompt, messageId, interruptionGeneration, userMessage);
+        void runAgent(context, session, prompt, messageId, controller, interruptionGeneration, userMessage);
     });
 }
+async function retryModelTurn(context, request, response, session) {
+    if (!authorize(request, response, session))
+        return;
+    const body = await readJson(request);
+    if (body.messageId !== undefined && typeof body.messageId !== "string") {
+        writeJson(response, 400, { error: "messageId must be a string" });
+        return;
+    }
+    if (session.running ||
+        session.preparingTurn ||
+        session.activePrompt !== null) {
+        writeJson(response, 409, { error: "a turn is already running" });
+        return;
+    }
+    const controller = new AbortController();
+    session.running = { controller };
+    const releaseReservation = () => {
+        if (session.running?.controller === controller)
+            session.running = null;
+    };
+    try {
+        const currentHistory = (await readHistory(session)) || [];
+        const retry = await modelRetryForHistory(session, currentHistory);
+        if (!retry) {
+            releaseReservation();
+            writeJson(response, 409, {
+                error: "no failed model request is available",
+            });
+            return;
+        }
+        if (body.messageId && body.messageId !== retry.messageId) {
+            releaseReservation();
+            writeJson(response, 409, {
+                error: "the requested failed turn is no longer retryable",
+            });
+            return;
+        }
+        const messageId = crypto.randomUUID();
+        session.turnStartEventId = session.events.at(-1)?.id || "0";
+        session.activePrompt = retry.prompt;
+        session.touchedAt = Date.now();
+        writeJson(response, 202, {
+            accepted: true,
+            sessionId: session.id,
+            messageId,
+            retryOf: retry.messageId,
+        });
+        queueMicrotask(() => {
+            void runAgent(context, session, retry.prompt, messageId, controller, undefined, undefined, true);
+        });
+    }
+    catch (error) {
+        releaseReservation();
+        throw error;
+    }
+}
 async function sessionMessages(context, request, response, session) {
     if (!authorize(request, response, session))
         return;
-    const messages = (await readHistory(session)) || [];
+    const stored = await loadStoredHistoryState(sessionHistoryPath(session));
+    const messages = stored?.messages || [];
+    const turnActive = Boolean(session.running || session.preparingTurn || session.activePrompt !== null);
+    const retry = turnActive
+        ? undefined
+        : await modelRetryForHistory(session, messages);
     writeJson(response, 200, {
         messages,
         lastEventId: session.running
             ? session.turnStartEventId
             : session.events.at(-1)?.id || "0",
         activePrompt: session.activePrompt,
+        canUndo: session.undoCheckpoint !== null,
+        retryable: Boolean(retry),
+        retryMessageId: retry?.messageId || null,
+        metrics: stored?.metrics || null,
+    });
+}
+async function undoLastTurn(config, request, response, session) {
+    if (!authorize(request, response, session))
+        return;
+    if (session.running || session.preparingTurn || session.activePrompt !== null) {
+        writeJson(response, 409, {
+            error: "the active turn must finish or be cancelled before it can be undone",
+        });
+        return;
+    }
+    const checkpoint = session.undoCheckpoint;
+    if (!checkpoint) {
+        writeJson(response, 200, {
+            undone: false,
+            messages: (await readHistory(session)) || [],
+            lastEventId: session.events.at(-1)?.id || "0",
+            canUndo: false,
+        });
+        return;
+    }
+    await restoreUndoWorkspace(session);
+    await saveHistory(session, checkpoint.messages, config, checkpoint.metrics ?? null);
+    await clearModelRetry(session);
+    session.pendingInterruption = false;
+    session.activePrompt = null;
+    session.touchedAt = Date.now();
+    await saveSessionMetadata(session);
+    let turnStart = -1;
+    for (let index = session.events.length - 1; index >= 0; index -= 1) {
+        if (session.events[index]?.data.type === "start") {
+            turnStart = index;
+            break;
+        }
+    }
+    if (turnStart >= 0)
+        session.events.splice(turnStart);
+    session.turnStartEventId = session.events.at(-1)?.id || "0";
+    const event = emit(session, {
+        type: "data-turn-undone",
+        data: {
+            messageId: checkpoint.messageId,
+            input: checkpoint.input,
+            attachments: checkpoint.attachments,
+            messages: checkpoint.messages,
+            metrics: checkpoint.metrics ?? null,
+            canUndo: false,
+        },
+    });
+    session.undoCheckpoint = null;
+    await rm(sessionUndoRoot(session), { recursive: true, force: true });
+    writeJson(response, 200, {
+        undone: true,
+        messageId: checkpoint.messageId,
+        input: checkpoint.input,
+        attachments: checkpoint.attachments,
+        messages: checkpoint.messages,
+        metrics: checkpoint.metrics ?? null,
+        lastEventId: event.id,
+        canUndo: false,
     });
 }
 function normalizeInputAnswers(pending, submitted) {
@@ -1208,18 +1636,26 @@ async function safeWorkspaceFile(session, encodedPath) {
         throw error;
     }
 }
-async function serveFile(response, filePath, cache = false, isolated = false) {
-    const info = await stat(filePath);
-    if (!info.isFile()) {
-        const error = new Error("not found");
-        error.code = "ENOENT";
-        throw error;
+async function serveFile(response, filePath, cache = false, isolated = false, assetName) {
+    const asset = assetName ? embeddedAsset(assetName) : undefined;
+    let size;
+    if (asset) {
+        size = asset.byteLength;
+    }
+    else {
+        const info = await stat(filePath);
+        if (!info.isFile()) {
+            const error = new Error("not found");
+            error.code = "ENOENT";
+            throw error;
+        }
+        size = info.size;
     }
     response.writeHead(200, {
         ...corsHeaders(),
         "content-type": mimeTypes[path.extname(filePath).toLowerCase()] ||
             "application/octet-stream",
-        "content-length": info.size,
+        "content-length": size,
         "cache-control": cache ? "public, max-age=300" : "no-cache",
         "x-content-type-options": "nosniff",
         ...(isolated
@@ -1229,7 +1665,12 @@ async function serveFile(response, filePath, cache = false, isolated = false) {
             }
             : {}),
     });
-    fs.createReadStream(filePath).pipe(response);
+    if (asset) {
+        response.end(asset);
+    }
+    else {
+        fs.createReadStream(filePath).pipe(response);
+    }
 }
 function sessionRoute(pathname, suffix) {
     return pathname.match(new RegExp(`^/ai-proxy/realtime/v1/sessions/([A-Za-z0-9-]{1,128})/${suffix}$`));
@@ -1251,7 +1692,9 @@ function createRequestHandler(context) {
         const outputMatch = sessionRoute(url.pathname, "out");
         const appendMatch = sessionRoute(url.pathname, "in/append");
         const messagesMatch = apiSessionRoute(url.pathname, "messages");
+        const retryMatch = apiSessionRoute(url.pathname, "retry");
         const cancelMatch = apiSessionRoute(url.pathname, "cancel");
+        const undoMatch = apiSessionRoute(url.pathname, "undo");
         const inputMatch = apiSessionRoute(url.pathname, "input-response");
         const uploadMatch = apiSessionRoute(url.pathname, "uploads");
         const workspaceMatch = workspaceRoute(url.pathname);
@@ -1289,9 +1732,15 @@ function createRequestHandler(context) {
             else if (messagesMatch && request.method === "GET") {
                 await sessionMessages(context, request, response, await getSession(context, messagesMatch[1] || ""));
             }
+            else if (retryMatch && request.method === "POST") {
+                await retryModelTurn(context, request, response, await getSession(context, retryMatch[1] || ""));
+            }
             else if (cancelMatch && request.method === "POST") {
                 await cancelTurn(request, response, await getSession(context, cancelMatch[1] || ""));
             }
+            else if (undoMatch && request.method === "POST") {
+                await undoLastTurn(context.config, request, response, await getSession(context, undoMatch[1] || ""));
+            }
             else if (inputMatch && request.method === "POST") {
                 await respondToInput(request, response, await getSession(context, inputMatch[1] || ""));
             }
@@ -1318,16 +1767,16 @@ function createRequestHandler(context) {
             }
             else if (["/", "/index.html"].includes(url.pathname) ||
                 /^\/agent\/[A-Za-z0-9-]{1,128}$/.test(url.pathname)) {
-                await serveFile(response, path.join(context.webRoot, "index.html"));
+                await serveFile(response, path.join(context.webRoot, "index.html"), false, false, "web/index.html");
             }
             else if (url.pathname === "/app.js") {
-                await serveFile(response, context.appScript, true);
+                await serveFile(response, context.appScript, true, false, "dist/web/app.js");
             }
             else if (url.pathname === "/sdk.js") {
-                await serveFile(response, path.join(projectRoot(), "dist", "sdk.js"), true);
+                await serveFile(response, path.join(projectRoot(), "dist", "sdk.js"), true, false, "dist/sdk.js");
             }
             else if (["/styles.css", "/fonts.css", "/arena-logo.svg"].includes(url.pathname)) {
-                await serveFile(response, path.join(context.webRoot, url.pathname.slice(1)), true);
+                await serveFile(response, path.join(context.webRoot, url.pathname.slice(1)), true, false, `web/${url.pathname.slice(1)}`);
             }
             else {
                 writeJson(response, 404, { error: "not found" });
@@ -1379,6 +1828,7 @@ export async function startServer(options = {}) {
         const cutoff = Date.now() - 6 * 60 * 60 * 1000;
         for (const [sessionId, session] of context.sessions) {
             if (!session.running &&
+                !session.preparingTurn &&
                 !session.subscribers.size &&
                 session.touchedAt < cutoff) {
                 context.sessions.delete(sessionId);