@qwen-code/arena-agent 0.0.10-dev.0 → 0.0.10-dev.10

package/dist/server.js

@@ -1,13 +1,13 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
-import { cp, mkdir, readFile, readdir, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
+import { cp, copyFile, 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 { isCodeArenaMode } from "./mode.js";
-import { historyMetadata, loadStoredHistory, loadStoredHistoryState, saveStoredHistory, sessionStorageRoot, } from "./history.js";
+import { historyMetadata, IncrementalHistoryWriter, loadStoredHistory, loadStoredHistoryState, saveStoredHistory, sessionStorageRoot, } from "./history.js";
 import { ModelBashMetricJudge, SessionMetricsAnalyzer, } from "./metrics.js";
 import { ModelConversationMetricJudge } from "./conversation-metrics.js";
 import { MockModelClient } from "./mock.js";
@@ -171,14 +171,21 @@ function sessionUndoMetadataPath(session) {
 function sessionUndoWorkspacePath(session) {
     return path.join(sessionUndoRoot(session), "workspace");
 }
+function sessionUndoHistoryPath(session) {
+    return path.join(sessionUndoRoot(session), "history.json");
+}
 function sessionRetryPath(session) {
     return path.join(session.root, "model-retry.json");
 }
 function historyHash(messages) {
-    return crypto
-        .createHash("sha256")
-        .update(JSON.stringify({ messages }))
-        .digest("hex");
+    const hash = crypto.createHash("sha256");
+    hash.update('{"messages":[');
+    for (let index = 0; index < messages.length; index += 1) {
+        if (index)
+            hash.update(",");
+        hash.update(JSON.stringify(messages[index]));
+    }
+    return hash.update("]}").digest("hex");
 }
 async function loadModelRetry(session) {
     try {
@@ -284,7 +291,6 @@ async function loadUndoCheckpoint(session) {
             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");
         }
@@ -292,7 +298,36 @@ async function loadUndoCheckpoint(session) {
         if (!workspace.isDirectory()) {
             throw new Error("undo checkpoint workspace is not a directory");
         }
-        return checkpoint;
+        let undoHistoryExists = true;
+        try {
+            await stat(sessionUndoHistoryPath(session));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            undoHistoryExists = false;
+        }
+        if (!undoHistoryExists) {
+            if (!Array.isArray(checkpoint.messages)) {
+                throw new Error("undo checkpoint history is missing");
+            }
+            // Migrate checkpoints written before undo history became disk-backed.
+            await saveStoredHistory(sessionUndoHistoryPath(session), checkpoint.messages, undefined, checkpoint.metrics ?? null);
+            await writeFile(sessionUndoMetadataPath(session), JSON.stringify({
+                version: 1,
+                messageId: checkpoint.messageId,
+                input: checkpoint.input,
+                attachments: checkpoint.attachments,
+                createdAt: checkpoint.createdAt,
+            }), "utf8");
+        }
+        return {
+            version: 1,
+            messageId: checkpoint.messageId,
+            input: checkpoint.input,
+            attachments: checkpoint.attachments,
+            createdAt: checkpoint.createdAt,
+        };
     }
     catch (error) {
         if (error.code === "ENOENT")
@@ -344,16 +379,11 @@ async function installDirectory(staging, target) {
     }
 }
 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);
@@ -366,6 +396,19 @@ async function prepareUndoCheckpoint(session, messageId, input, attachments) {
             filter: (source) => snapshotIncludes(session.workspace, source),
             verbatimSymlinks: true,
         });
+        const undoHistory = path.join(staging, "history.json");
+        try {
+            await copyFile(sessionHistoryPath(session), undoHistory, fs.constants.COPYFILE_FICLONE);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+            await saveStoredHistory(undoHistory, [], undefined, null, []);
+        }
+        await copyFile(`${sessionHistoryPath(session)}.journal.jsonl`, `${undoHistory}.journal.jsonl`, fs.constants.COPYFILE_FICLONE).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
         await writeFile(path.join(staging, "checkpoint.json"), JSON.stringify(checkpoint), "utf8");
         await installDirectory(staging, target);
         session.undoCheckpoint = checkpoint;
@@ -432,9 +475,9 @@ async function createSession(context, clientContext) {
         root: paths.root,
         workspace: paths.workspace,
         artifacts: paths.artifacts,
-        history: null,
         undoCheckpoint: null,
         events: [],
+        eventBytes: 0,
         nextEventId: 1,
         subscribers: new Set(),
         running: null,
@@ -497,9 +540,9 @@ async function getSession(context, sessionId) {
             root: paths.root,
             workspace: paths.workspace,
             artifacts: paths.artifacts,
-            history: null,
             undoCheckpoint: null,
             events: [],
+            eventBytes: 0,
             nextEventId: 1,
             subscribers: new Set(),
             running: null,
@@ -553,14 +596,35 @@ function authorize(request, response, session) {
     session.touchedAt = Date.now();
     return true;
 }
+const maxStoredEvents = 1000;
+const maxStoredEventBytes = 16 * 1024 * 1024;
 function emit(session, data) {
-    const event = { id: String(session.nextEventId++), data };
+    const id = String(session.nextEventId++);
+    const frame = `id: ${id}\ndata: ${JSON.stringify(data)}\n\n`;
+    const event = {
+        id,
+        type: data.type,
+        frame,
+        bytes: Buffer.byteLength(frame),
+    };
     session.events.push(event);
-    if (session.events.length > 1000)
-        session.events.shift();
-    const frame = `id: ${event.id}\ndata: ${JSON.stringify(data)}\n\n`;
-    for (const response of session.subscribers)
-        response.write(frame);
+    session.eventBytes += event.bytes;
+    while (session.events.length > 1 &&
+        (session.events.length > maxStoredEvents ||
+            session.eventBytes > maxStoredEventBytes)) {
+        const removed = session.events.shift();
+        if (removed)
+            session.eventBytes -= removed.bytes;
+    }
+    for (const response of [...session.subscribers]) {
+        if (response.write(frame))
+            continue;
+        // Do not let a slow or disconnected SSE client make Node buffer an
+        // unbounded copy of a large history stream. The client reconnects with its
+        // last event id and replays from the bounded ring.
+        session.subscribers.delete(response);
+        response.end();
+    }
     return event;
 }
 function openEventStream(request, response, session) {
@@ -574,11 +638,19 @@ function openEventStream(request, response, session) {
     response.flushHeaders();
     response.write(": connected\n\n");
     const lastEventId = Number(request.headers["last-event-id"] || 0);
+    let replayBackpressured = false;
     for (const event of session.events) {
         if (Number(event.id) > lastEventId) {
-            response.write(`id: ${event.id}\ndata: ${JSON.stringify(event.data)}\n\n`);
+            if (!response.write(event.frame)) {
+                replayBackpressured = true;
+                break;
+            }
         }
     }
+    if (replayBackpressured) {
+        response.end();
+        return;
+    }
     session.subscribers.add(response);
     const heartbeat = setInterval(() => response.write(": heartbeat\n\n"), 15_000);
     const close = () => {
@@ -805,6 +877,13 @@ function createUiStream(session, messageId) {
                 });
                 return;
             }
+            if (event.type === "memory.update") {
+                emit(session, { type: "memory.update", status: event.status,
+                    ...(event.code ? { code: event.code } : {}),
+                    ...(event.error ? { error: event.error } : {}),
+                    ...(event.usage ? { usage: event.usage } : {}) });
+                return;
+            }
             if (event.type === "compaction") {
                 emit(session, {
                     type: "compaction",
@@ -973,10 +1052,6 @@ function createUiStream(session, messageId) {
             }
             if (event.type === "result") {
                 closeOpenParts();
-                emit(session, {
-                    type: "data-messages",
-                    data: { messages: event.messages || [] },
-                });
                 emit(session, {
                     type: "finish",
                     finishReason: event.status === "success" ? "stop" : "error",
@@ -1007,16 +1082,10 @@ function createUiStream(session, messageId) {
     };
 }
 async function readHistory(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;
+    return loadStoredHistory(sessionHistoryPath(session));
 }
-async function saveHistory(session, messages, config, metrics, tools) {
-    await saveStoredHistory(sessionHistoryPath(session), messages, historyMetadata(config, session.id), metrics, tools);
-    session.history = structuredClone([...messages]);
+async function saveHistory(session, messages, config, metrics, tools, memory) {
+    await saveStoredHistory(sessionHistoryPath(session), messages, historyMetadata(config, session.id), metrics, tools, memory);
 }
 function sessionMetricsAnalyzer(config, signal) {
     const sideQueryModel = config.metricsSideQueryModel || config.model;
@@ -1100,12 +1169,21 @@ async function runAgent(context, session, prompt, messageId, controller, interru
     try {
         const storedHistory = await loadStoredHistoryState(sessionHistoryPath(session));
         const history = storedHistory?.messages;
+        const historyWriter = await IncrementalHistoryWriter.create(sessionHistoryPath(session), storedHistory, historyMetadata(sessionConfig, session.id));
+        session.sessionMemory ||= {};
+        let latestTools = storedHistory?.tools;
         const result = await new Agent(sessionConfig, sink, {
             askUserHandler,
             sessionId: session.id,
             sessionAffinityId: session.sessionAffinityId,
             signal: controller.signal,
-            onCheckpoint: (messages, tools) => saveHistory(session, messages, sessionConfig, undefined, tools),
+            reuseHistoryMessages: true,
+            sessionMemory: (session.sessionMemory ||= {}),
+            storedSessionMemory: storedHistory?.session_memory,
+            onCheckpoint: (messages, tools, memory) => {
+                latestTools = [...tools];
+                return historyWriter.checkpoint(messages, tools, memory);
+            },
             onModelFailure: (messages, error) => {
                 failedModelCheckpoint = structuredClone([...messages]);
                 failedModelError = error;
@@ -1119,6 +1197,7 @@ async function runAgent(context, session, prompt, messageId, controller, interru
             interrupted: interruptionGeneration !== undefined,
             userMessage,
             resumeFromHistory,
+            restoreSessionMemory: sessionConfig.restoreSessionMemory,
         });
         let deliveredResult = result;
         let retryable = false;
@@ -1126,7 +1205,7 @@ async function runAgent(context, session, prompt, messageId, controller, interru
             !controller.signal.aborted &&
             failedModelCheckpoint) {
             const checkpoint = structuredClone(failedModelCheckpoint);
-            await saveHistory(session, checkpoint, sessionConfig);
+            await historyWriter.checkpoint(checkpoint, latestTools);
             await saveModelRetry(session, {
                 version: 1,
                 sessionId: session.id,
@@ -1157,7 +1236,7 @@ async function runAgent(context, session, prompt, messageId, controller, interru
                 currentTurnMessages,
             })
             : undefined;
-        await saveHistory(session, deliveredResult.messages, sessionConfig, metrics);
+        await historyWriter.finalize(deliveredResult.messages, metrics, latestTools);
         if (result.status === "success" || controller.signal.aborted) {
             if (interruptionGeneration !== undefined &&
                 session.interruptionGeneration === interruptionGeneration) {
@@ -1487,8 +1566,12 @@ async function undoLastTurn(config, request, response, session) {
         });
         return;
     }
+    const checkpointHistory = await loadStoredHistoryState(sessionUndoHistoryPath(session));
+    const checkpointMessages = checkpointHistory?.messages || [];
+    const checkpointMetrics = checkpointHistory?.metrics ?? null;
     await restoreUndoWorkspace(session);
-    await saveHistory(session, checkpoint.messages, config, checkpoint.metrics ?? null);
+    await saveHistory(session, checkpointMessages, config, checkpointMetrics, checkpointHistory?.tools, checkpointHistory?.session_memory ?? null);
+    session.sessionMemory = {};
     await clearModelRetry(session);
     session.pendingInterruption = false;
     session.activePrompt = null;
@@ -1496,13 +1579,14 @@ async function undoLastTurn(config, request, response, session) {
     await saveSessionMetadata(session);
     let turnStart = -1;
     for (let index = session.events.length - 1; index >= 0; index -= 1) {
-        if (session.events[index]?.data.type === "start") {
+        if (session.events[index]?.type === "start") {
             turnStart = index;
             break;
         }
     }
     if (turnStart >= 0)
         session.events.splice(turnStart);
+    session.eventBytes = session.events.reduce((total, stored) => total + stored.bytes, 0);
     session.turnStartEventId = session.events.at(-1)?.id || "0";
     const event = emit(session, {
         type: "data-turn-undone",
@@ -1510,8 +1594,7 @@ async function undoLastTurn(config, request, response, session) {
             messageId: checkpoint.messageId,
             input: checkpoint.input,
             attachments: checkpoint.attachments,
-            messages: checkpoint.messages,
-            metrics: checkpoint.metrics ?? null,
+            historyUpdated: true,
             canUndo: false,
         },
     });
@@ -1522,8 +1605,8 @@ async function undoLastTurn(config, request, response, session) {
         messageId: checkpoint.messageId,
         input: checkpoint.input,
         attachments: checkpoint.attachments,
-        messages: checkpoint.messages,
-        metrics: checkpoint.metrics ?? null,
+        messages: checkpointMessages,
+        metrics: checkpointMetrics,
         lastEventId: event.id,
         canUndo: false,
     });