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

package/dist/agent.js

@@ -1,20 +1,78 @@
 import crypto from "node:crypto";
+import path from "node:path";
+import { agentArenaCompactionThreshold } from "./compaction-threshold.js";
 import { setTimeout as delay } from "node:timers/promises";
 import { supportsModelInput, } from "./config.js";
-import { compactMessagesIfNeeded, maintainSessionMemory, contextFromHistory } from "./compaction.js";
+import { compactMessagesIfNeeded, maintainSessionMemory, contextFromHistory, sessionMemoryMatchesHistory, settleSessionMemory, storedSessionMemory } from "./compaction.js";
 import { ANTHROPIC_INCOMPLETE_STREAM_ERROR_CODE } from "./anthropic.js";
+import { rememberRestoredCalls, restoredArenaHistory } from "./arena-history.js";
 import { modelCallLogPath, withoutLeadingSystemMessage } from "./history.js";
 import { MockModelClient } from "./mock.js";
+import { CAPACITY_MODEL_ERROR, INCOMPLETE_MODEL_RESPONSE, TRANSIENT_MODEL_ERROR, incompleteModelResponse } from "./model-stream.js";
 import { contentPartMediaTypes, JsonlModelCallDiagnostics, } from "./model-diagnostics.js";
-import { RESPONSES_CAPACITY_ERROR_CODE, RESPONSES_TRANSIENT_ERROR_CODE, } from "./openai-responses.js";
+import { RESPONSES_INCOMPLETE_STREAM_ERROR_CODE } from "./openai-responses.js";
 import { HttpModelClient, ModelCapabilityError } from "./provider.js";
 import { RepetitiveOutputDetector } from "./repetitive-output.js";
 import { detectRepoContext } from "./repo.js";
-import { isCodeArenaMode } from "./mode.js";
+import { defaultStepLimit, isCodeArenaMode } from "./mode.js";
 import { defaultClientContext, interruptedUserMessage, repoSystemMessage, systemMessage, } from "./spec.js";
 import { imageInputFallbackConnection, ToolExecutor, } from "./tools.js";
 import { initializeWorkspace } from "./workspace.js";
 import { checkpointAction, } from "./midturn-checkpoint-hook.js";
+function wrapMalformedToolArguments(argumentsText) {
+    try {
+        JSON.parse(argumentsText);
+        return argumentsText;
+    }
+    catch {
+        return JSON.stringify({ __malformedToolArguments: argumentsText });
+    }
+}
+/** Keep Agent Arena history replayable without losing the model's invalid input. */
+function normalizeToolCallHistory(message, mode, historyCall) {
+    if (isCodeArenaMode(mode) || message.role !== "assistant")
+        return message;
+    // A failed Responses stream can retain completed native items without the
+    // assembled tool_calls batch. Restore their identities so resume can pair
+    // them with interrupted results instead of replaying orphaned calls.
+    const calls = message.tool_calls?.length ? message.tool_calls
+        : message.openai_response_items?.flatMap((item) => item.type === "function_call" && typeof item.call_id === "string" &&
+            typeof item.name === "string" && typeof item.arguments === "string"
+            ? [{ id: item.call_id, type: "function", function: { name: item.name, arguments: item.arguments } }]
+            : []) ?? message.tool_calls;
+    let changed = Boolean(calls?.length && calls !== message.tool_calls);
+    const toolCalls = calls?.map((original) => {
+        const call = historyCall ? historyCall(original) : original;
+        if (call !== original)
+            changed = true;
+        if (typeof call.function?.arguments !== "string")
+            return call;
+        const argumentsText = wrapMalformedToolArguments(call.function.arguments);
+        if (argumentsText === call.function.arguments)
+            return call;
+        changed = true;
+        return { ...call, function: { ...call.function, arguments: argumentsText } };
+    });
+    // Native Responses replays these items instead of tool_calls. Normalize both
+    // representations while leaving reasoning and other opaque items intact.
+    const responseItems = message.openai_response_items?.map((item) => {
+        if (item.type !== "function_call" || typeof item.arguments !== "string")
+            return item;
+        const paired = toolCalls?.find(call => call.id === item.call_id);
+        const argumentsText = paired?.function.arguments ?? wrapMalformedToolArguments(item.arguments);
+        if (argumentsText === item.arguments)
+            return item;
+        changed = true;
+        return { ...item, arguments: argumentsText };
+    });
+    return changed
+        ? {
+            ...message,
+            ...(toolCalls ? { tool_calls: toolCalls } : {}),
+            ...(responseItems ? { openai_response_items: responseItems } : {}),
+        }
+        : message;
+}
 function parseToolResult(content) {
     try {
         return JSON.parse(content);
@@ -23,6 +81,41 @@ function parseToolResult(content) {
         return {};
     }
 }
+/** Live Agent Arena results arrive in completion order. Checkpoint writes stay
+ * serialized by the consumer, and every started operation settles before exit.
+ * Code Arena retains its sequential execution path.
+ */
+async function* completedTools(calls, parallel, execute) {
+    if (!parallel) {
+        for (const call of calls)
+            yield { call, message: await execute(call) };
+        return;
+    }
+    const queue = [];
+    let wake;
+    const settled = Promise.all(calls.map(async (call) => {
+        try {
+            queue.push({ status: "fulfilled", value: { call, message: await execute(call) } });
+        }
+        catch (reason) {
+            queue.push({ status: "rejected", reason });
+        }
+        wake?.();
+    }));
+    try {
+        for (let count = 0; count < calls.length; count++) {
+            if (!queue.length)
+                await new Promise(resolve => { wake = resolve; });
+            const result = queue.shift();
+            if (result.status === "rejected")
+                throw result.reason;
+            yield result.value;
+        }
+    }
+    finally {
+        await settled;
+    }
+}
 // Network faults that abort an in-flight stream (a dropped socket, a reset, a
 // DNS blip). undici surfaces these mid-stream as `TypeError: fetch failed` or
 // `TypeError: terminated`; some are also reachable via an errno-style code on
@@ -43,8 +136,11 @@ const retryableStreamCodes = new Set([
     "UND_ERR_BODY_TIMEOUT",
     "ARENA_STREAM_IDLE_TIMEOUT",
     ANTHROPIC_INCOMPLETE_STREAM_ERROR_CODE,
-    RESPONSES_CAPACITY_ERROR_CODE,
-    RESPONSES_TRANSIENT_ERROR_CODE,
+    CAPACITY_MODEL_ERROR,
+    TRANSIENT_MODEL_ERROR,
+    RESPONSES_INCOMPLETE_STREAM_ERROR_CODE,
+    "ARENA_EMPTY_MODEL_RESPONSE",
+    INCOMPLETE_MODEL_RESPONSE,
 ]);
 const capacityErrorMaxRetries = 5;
 function describeError(error) {
@@ -64,7 +160,7 @@ function isRetryableStreamError(error) {
     return code !== undefined && retryableStreamCodes.has(code);
 }
 function streamRetryLimit(error, configuredLimit) {
-    return errorCode(error) === RESPONSES_CAPACITY_ERROR_CODE
+    return errorCode(error) === CAPACITY_MODEL_ERROR
         ? Math.min(configuredLimit, capacityErrorMaxRetries)
         : configuredLimit;
 }
@@ -270,15 +366,20 @@ class CheckpointFailure extends Error {
         this.cause = cause;
     }
 }
-// Rebuild the runtime repo context from the current workspace on every run.
+// Refresh live Git state on every run, using the saved target when available.
 // The history argument is retained for callers; it never supplies runtime state.
-export function resolveRepoContext(workspace, _history, mode = "arena") {
-    return isCodeArenaMode(mode) ? undefined : detectRepoContext(workspace);
+export function resolveRepoContext(workspace, _history, mode = "arena", repoDirectory) {
+    return isCodeArenaMode(mode) ? undefined : detectRepoContext(workspace, repoDirectory);
 }
 export class Agent {
     config;
     sink;
     options;
+    checkpointQueue = Promise.resolve();
+    restoredToolCalls = new Set();
+    checkpointError;
+    persistedMemory;
+    repoDirectory;
     memoryCache;
     client;
     tools;
@@ -290,6 +391,7 @@ export class Agent {
         this.sink = sink;
         this.options = options;
         this.memoryCache = options.sessionMemory || {};
+        this.repoDirectory = options.repoDirectory;
         this.sessionId =
             options.sessionId || crypto.randomUUID().replaceAll("-", "");
         this.sessionAffinityId = options.sessionAffinityId || crypto.randomUUID();
@@ -305,19 +407,24 @@ export class Agent {
             (!needsMainHttpClient && !needsFallbackHttpClient)
             ? undefined
             : new JsonlModelCallDiagnostics(modelCallLogPath(config.stateRoot, config.tenantId, this.sessionId));
-        this.client =
-            options.client ||
-                (config.model.startsWith("mock/")
-                    ? new MockModelClient()
-                    : new HttpModelClient(config, {
-                        sessionAffinityId: this.sessionAffinityId,
-                        ...(diagnostics ? { diagnostics } : {}),
-                    }));
+        const client = options.client ||
+            (config.model.startsWith("mock/")
+                ? new MockModelClient()
+                : new HttpModelClient(config, {
+                    sessionAffinityId: this.sessionAffinityId,
+                    onRequest: options.onModelRequest,
+                    ...(diagnostics ? { diagnostics } : {}),
+                }));
+        this.client = isCodeArenaMode(config.mode) ? client : {
+            stream: request => client.stream({ ...request,
+                messages: restoredArenaHistory(request.messages, this.restoredToolCalls) }),
+        };
         const imageInputFallbackClient = options.imageInputFallbackClient ||
             (fallbackConnection
                 ? new HttpModelClient(config, {
                     connection: fallbackConnection,
                     sessionAffinityId: this.sessionAffinityId,
+                    onRequest: options.onModelRequest,
                     ...(diagnostics ? { diagnostics } : {}),
                 })
                 : undefined);
@@ -332,6 +439,16 @@ export class Agent {
                 });
     }
     async run(prompt, history, runOptions = {}) {
+        try {
+            return await this.runTurn(prompt, history, runOptions);
+        }
+        finally {
+            await this.tools.closeConnectors?.();
+            await settleSessionMemory(this.memoryCache);
+            await this.checkpointQueue;
+        }
+    }
+    async runTurn(prompt, history, runOptions) {
         if (runOptions.resumeFromHistory && !history?.length) {
             throw new Error("resumeFromHistory requires a non-empty history");
         }
@@ -344,15 +461,25 @@ export class Agent {
             ? interruptedUserMessage(baseUserMessage, this.config.mode)
             : structuredClone(baseUserMessage);
         const clientContext = this.options.clientContext || defaultClientContext();
-        const repoContext = resolveRepoContext(this.config.workspace, history, this.config.mode);
+        const repoContext = resolveRepoContext(this.config.workspace, history, this.config.mode, this.repoDirectory);
+        if (repoContext) {
+            this.repoDirectory = path.relative(this.config.workspace, repoContext.checkoutPath);
+        }
         // System instructions belong to this invocation, never to the saved dialogue.
         // Older local histories included a system message; accept them without
         // carrying the old runtime configuration into the next request.
-        const dialogue = withoutLeadingSystemMessage(history || []);
+        const dialogue = withoutLeadingSystemMessage(history || []).map((message) => normalizeToolCallHistory(message, this.config.mode));
+        this.restoredToolCalls.clear();
+        if (!isCodeArenaMode(this.config.mode))
+            rememberRestoredCalls(dialogue, this.restoredToolCalls);
         const trajectory = completeInterruptedToolCalls(this.options.reuseHistoryMessages ? [...dialogue] : structuredClone(dialogue));
+        const connectors = this.config.disallowedTools?.includes("list_connector_tools")
+            ? undefined : this.config.connectors;
+        const connectedConnectors = this.config.disallowedTools?.includes("list_connector_tools")
+            ? undefined : this.config.connectedConnectors;
         const runtimeSystemMessage = repoContext
-            ? repoSystemMessage(clientContext, repoContext, this.config.mode, this.workspaceContext, this.config.maxTurns)
-            : systemMessage(clientContext, this.workspaceContext, this.config.mode, this.config.maxTurns);
+            ? repoSystemMessage(clientContext, repoContext, this.config.mode, this.workspaceContext, this.config.maxTurns, connectors, connectedConnectors)
+            : systemMessage(clientContext, this.workspaceContext, this.config.mode, this.config.maxTurns, connectors, connectedConnectors);
         applySystemPromptConfig(runtimeSystemMessage, this.config);
         if (runOptions.resumeFromHistory) {
             if (!isContinuableHistory(dialogue)) {
@@ -362,25 +489,65 @@ export class Agent {
         else {
             trajectory.push(userMessage);
         }
+        // A new human reply requires discovery again. Same-turn continuation only
+        // reloads schemas from paired discovery results; it never repeats writes.
+        await this.tools.beginConnectorTurn?.(runOptions.resumeFromHistory ? dialogue : undefined);
         // Compaction projects model input with a runtime system prefix; the lossless
         // trajectory and its checkpoints remain in the official dialogue format.
         const messages = modelContextFromTrajectory([runtimeSystemMessage, ...trajectory]);
+        if (!isCodeArenaMode(this.config.mode)) {
+            const saved = this.persistedMemory ?? this.options.storedSessionMemory ?? storedSessionMemory(this.memoryCache);
+            preflightUnsupportedMedia(this.config, messages);
+            // Opting out of restoration must not delete a still-valid durable snapshot.
+            this.persistedMemory = saved?.version === 1 ? structuredClone(saved) : undefined;
+            if (this.persistedMemory?.latest && !sessionMemoryMatchesHistory(this.persistedMemory.latest, messages)) {
+                this.persistedMemory.latest = undefined;
+            }
+            if (this.persistedMemory?.update?.status === "pending") {
+                this.persistedMemory.update = { status: "cancelled", code: "MEMORY_INTERRUPTED",
+                    error: "Previous process ended during a memory update" };
+            }
+            this.memoryCache.latest = undefined;
+            this.memoryCache.state = undefined;
+            this.memoryCache.latestUsage = undefined;
+            this.memoryCache.attemptedPrefix = undefined;
+            this.memoryCache.update = undefined;
+            if (this.config.compactionMode !== "summary" &&
+                (runOptions.restoreSessionMemory ?? this.config.restoreSessionMemory ?? true) && saved?.version === 1) {
+                if (sessionMemoryMatchesHistory(saved.latest, messages)) {
+                    this.memoryCache.latest = structuredClone(saved.latest);
+                }
+                this.memoryCache.update = this.persistedMemory?.update;
+                if (saved.latest && !this.memoryCache.latest) {
+                    this.memoryCache.update = { status: "error", code: "MEMORY_STALE_HISTORY",
+                        error: "Saved memory does not match the current history prefix" };
+                }
+                if (this.memoryCache.update)
+                    this.sink.emit({ type: "memory.update", session_id: this.sessionId, ...this.memoryCache.update });
+            }
+        }
         const recordMessage = async (message) => {
-            messages.push(message);
-            const recorded = structuredClone(message);
+            const normalized = normalizeToolCallHistory(message, this.config.mode, call => this.tools.historyCall(call));
+            messages.push(normalized);
+            const recorded = structuredClone(normalized);
             trajectory.push(recorded);
             this.sink.message(this.sessionId, recorded, trajectory);
             await this.checkpoint(trajectory);
         };
-        await this.maybeCompact(messages, trajectory);
-        this.sink.start(this.sessionId, trajectory);
         try {
+            const compaction = await this.maybeCompact(messages, trajectory);
+            this.sink.start(this.sessionId, trajectory);
+            if (compaction === "checkpoint")
+                return await this.pause(trajectory, "checkpoint");
             await this.checkpoint(trajectory);
             const maxTurns = this.config.maxTurns
                 ? Math.max(1, Math.floor(this.config.maxTurns))
-                : undefined;
+                : isCodeArenaMode(this.config.mode) ? undefined : defaultStepLimit("arena");
             for (let step = 1;; step += 1) {
                 if (maxTurns !== undefined && step > maxTurns) {
+                    if (!isCodeArenaMode(this.config.mode)) {
+                        return await this.pause(trajectory, "step_limit");
+                    }
                     throw new Error(`agent reached max_turns limit (${maxTurns})`);
                 }
                 if (this.options.signal?.aborted) {
@@ -389,13 +556,15 @@ export class Agent {
                 // Every transport is replayable from local history. Native Responses
                 // stores its encrypted reasoning output items there, so compaction is
                 // safe at the same tool-step boundaries as the other protocols.
-                if (step > 1)
-                    await this.maybeCompact(messages, trajectory, "inner");
+                if (step > 1 && await this.maybeCompact(messages, trajectory, "inner") === "checkpoint") {
+                    return await this.pause(trajectory, "checkpoint");
+                }
                 const offeredTools = this.tools.availableTools();
                 this.sink.modelStart(this.sessionId, step, offeredTools.map((tool) => tool.function.name));
                 let assistant;
+                let finishReason;
                 try {
-                    assistant = await this.assistantTurn(messages, offeredTools, trajectory);
+                    ({ assistant, finishReason } = await this.assistantTurn(messages, offeredTools, trajectory));
                 }
                 catch (error) {
                     if (error instanceof CheckpointExit) {
@@ -415,8 +584,19 @@ export class Agent {
                     this.options.onModelFailure?.(trajectory, error);
                     throw error;
                 }
-                const finishReason = assistant.tool_calls?.length ? "tool_calls" : "stop";
                 this.sink.modelComplete(this.sessionId, step, finishReason, assistant.usage);
+                if (finishReason === "length") {
+                    // A completed but truncated request is not a transport failure. Keep
+                    // its evidence without retrying it or executing unfinished tool calls.
+                    await recordMessage(assistant);
+                    throw new Error("Model response was truncated (finish_reason=length). " +
+                        "The turn did not complete; any partial output has been preserved.");
+                }
+                if (finishReason === "incomplete" || finishReason === "content_filter") {
+                    await recordMessage(assistant);
+                    throw new Error(`Model response was incomplete (finish_reason=${finishReason}). ` +
+                        "The turn did not complete; any partial output has been preserved.");
+                }
                 if (assistant.tool_calls?.length &&
                     this.options.midturnCheckpointHook) {
                     const event = {
@@ -434,49 +614,65 @@ export class Agent {
                 }
                 await recordMessage(assistant);
                 if (!assistant.tool_calls?.length) {
-                    return this.sink.result(this.sessionId, "success", trajectory);
+                    return await this.finish(trajectory, "success");
                 }
                 const completedToolCallIds = [];
-                for (const call of assistant.tool_calls) {
+                let needsInput = false;
+                const execute = async (call) => {
                     const toolCallId = String(call.id || "");
                     const toolName = String(call.function?.name || "tool");
                     this.sink.toolStart(this.sessionId, toolCallId, toolName);
-                    const toolMessage = await this.tools.execute(call, toolName === "ask_user" || toolName === "add_voice"
+                    return this.tools.execute(call, toolName === "ask_user" || toolName === "add_voice" ||
+                        (!isCodeArenaMode(this.config.mode) && toolName === "generate_image")
                         ? {
                             sessionId: this.sessionId,
                             messages: structuredClone(trajectory),
                             signal: this.options.signal,
                         }
                         : undefined);
+                };
+                for await (const { call, message: toolMessage } of completedTools(assistant.tool_calls, !isCodeArenaMode(this.config.mode), execute)) {
+                    const toolCallId = String(call.id || "");
+                    const toolName = String(call.function?.name || "tool");
                     const toolResult = parseToolResult(toolMessage.content);
                     const skippedAskUser = toolName === "ask_user" && toolResult.skipped === true;
                     if (this.options.signal?.aborted && !skippedAskUser) {
                         throw this.options.signal.reason || new Error("operation cancelled");
                     }
                     await recordMessage(toolMessage);
+                    if (this.tools.takeInteractionBoundary(toolCallId)) {
+                        rememberRestoredCalls(messages, this.restoredToolCalls);
+                    }
                     completedToolCallIds.push(toolCallId);
                     this.sink.toolComplete(this.sessionId, toolCallId, toolName);
-                    if (toolName === "ask_user" || toolName === "add_voice") {
+                    if (toolName === "ask_user" || toolName === "add_voice" ||
+                        (!isCodeArenaMode(this.config.mode) && toolName === "generate_image")) {
                         if (toolResult.status === "needs_input") {
-                            const visualMessage = this.tools.takeVisualMessage(completedToolCallIds);
-                            if (visualMessage) {
-                                await recordMessage(visualMessage);
-                            }
                             const questions = Array.isArray(toolResult.questions)
                                 ? toolResult.questions
                                 : [];
                             this.sink.inputRequired(this.sessionId, toolCallId, questions);
-                            return this.sink.result(this.sessionId, "needs_input", trajectory);
+                            if (isCodeArenaMode(this.config.mode)) {
+                                const visualMessage = this.tools.takeVisualMessage(completedToolCallIds);
+                                if (visualMessage)
+                                    await recordMessage(visualMessage);
+                                return await this.finish(trajectory, "needs_input");
+                            }
+                            needsInput = true;
                         }
                     }
                     if (this.options.signal?.aborted) {
                         throw this.options.signal.reason || new Error("operation cancelled");
                     }
                 }
-                const visualMessage = this.tools.takeVisualMessage(completedToolCallIds);
+                // Image parts retain the assistant's declaration order independently
+                // of which tool result completed first.
+                const visualMessage = this.tools.takeVisualMessage(assistant.tool_calls.map(call => call.id));
                 if (visualMessage) {
                     await recordMessage(visualMessage);
                 }
+                if (needsInput)
+                    return await this.finish(trajectory, "needs_input");
                 if (runOptions.singleStep) {
                     return await this.pause(trajectory, "single_step");
                 }
@@ -484,13 +680,38 @@ export class Agent {
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            return this.sink.result(this.sessionId, "error", trajectory, message);
+            return await this.finish(trajectory, "error", message);
         }
     }
     async checkpoint(messages) {
-        await this.options.onCheckpoint?.(messages, this.tools.availableTools());
+        const snapshot = [...messages];
+        const tools = this.tools.availableTools();
+        const currentMemory = storedSessionMemory(this.memoryCache);
+        const memory = isCodeArenaMode(this.config.mode) ? undefined : (currentMemory || this.persistedMemory
+            ? { version: 1, latest: currentMemory?.latest ?? this.persistedMemory?.latest,
+                update: currentMemory?.update ?? this.persistedMemory?.update }
+            : null);
+        if (memory !== undefined)
+            this.persistedMemory = memory ?? undefined;
+        const write = this.checkpointQueue.then(() => this.options.onCheckpoint?.(snapshot, tools, memory));
+        this.checkpointQueue = write.catch(error => { this.checkpointError ??= error; });
+        await write;
+        if (this.checkpointError)
+            throw this.checkpointError;
+    }
+    async finish(messages, status, error) {
+        await settleSessionMemory(this.memoryCache);
+        try {
+            await this.checkpoint(messages);
+        }
+        catch (failure) {
+            status = "error";
+            error ??= failure instanceof Error ? failure.message : String(failure);
+        }
+        return this.sink.result(this.sessionId, status, messages, error, undefined, this.memoryCache.update);
     }
     async makeCheckpoint(messages, tools, event, action) {
+        await settleSessionMemory(this.memoryCache, event.type !== "before_compaction" || action !== "snapshot_continue");
         await this.checkpoint(messages);
         if (!this.options.onMidturnCheckpoint) {
             throw new Error("mid-turn checkpoint hook triggered without a snapshot handler");
@@ -499,9 +720,12 @@ export class Agent {
     }
     async pause(messages, reason) {
         this.options.signal?.throwIfAborted();
+        await settleSessionMemory(this.memoryCache, reason !== "single_step");
+        if (reason === "single_step" || reason === "step_limit")
+            await this.checkpoint(messages);
         await this.options.onPause?.(messages, this.tools.availableTools());
         this.options.signal?.throwIfAborted();
-        return this.sink.result(this.sessionId, "paused", messages, undefined, reason);
+        return this.sink.result(this.sessionId, "paused", messages, undefined, reason, this.memoryCache.update);
     }
     async maybeCompact(messages, trajectory, source = "outer") {
         preflightUnsupportedMedia(this.config, messages);
@@ -511,50 +735,83 @@ export class Agent {
                 triggerRatio: this.config.contextCompactionRatio,
                 summaryMaxTokens: this.config.compactionSummaryMaxTokens,
                 reasoningEffort: this.config.reasoningEffort,
-                ...(this.options.compactionThresholdTokens === undefined ? {} : {
-                    compactionThresholdTokens: this.options.compactionThresholdTokens,
-                }),
-                legacy: isCodeArenaMode(this.config.mode),
+                compactionThresholdTokens: isCodeArenaMode(this.config.mode) ? undefined
+                    : agentArenaCompactionThreshold(this.config.contextWindow, this.config.contextCompactionRatio, this.options.compactionThresholdTokens ?? this.config.compactionThresholdTokens),
+                legacy: isCodeArenaMode(this.config.mode) || this.config.compactionMode === "summary",
+                onBeforeCompaction: !isCodeArenaMode(this.config.mode) && this.options.midturnCheckpointHook
+                    ? async (estimatedTokensBefore, thresholdTokens) => {
+                        const event = {
+                            type: "before_compaction", sessionId: this.sessionId, toolCalls: [],
+                            compaction: {
+                                count: trajectory.filter(message => message.role === "compaction" && !message.undone).length + 1,
+                                mode: this.config.compactionMode === "summary" ? "summary" : "rolling",
+                                source, estimatedTokensBefore, thresholdTokens,
+                            },
+                        };
+                        let action;
+                        try {
+                            action = checkpointAction(await this.options.midturnCheckpointHook(event));
+                            if (action !== "continue") {
+                                await this.makeCheckpoint(trajectory, this.tools.availableTools(), event, action);
+                            }
+                        }
+                        catch (error) {
+                            throw new CheckpointFailure(error);
+                        }
+                        if (action === "snapshot_exit")
+                            throw new CheckpointExit(event);
+                    }
+                    : undefined,
             };
             const contextLength = messages.length;
             const result = settings.legacy
                 ? await compactMessagesIfNeeded(messages, this.tools.availableTools(), this.client, this.config.model, settings, this.options.signal)
-                : await maintainSessionMemory(messages, messages, this.memoryCache, this.tools.availableTools(), this.client, this.config.model, settings, this.config.memoryUpdateTokens, this.options.signal, (usage, success) => this.sink.emit({ type: "memory.update", session_id: this.sessionId,
-                    status: success ? "success" : "invalid", ...(usage ? { usage } : {}) }));
+                : await maintainSessionMemory(messages, messages, this.memoryCache, this.tools.availableTools(), this.client, this.config.model, settings, this.config.memoryUpdateTokens, this.options.signal, update => {
+                    this.sink.emit({ type: "memory.update", session_id: this.sessionId, ...update });
+                    // Serialized with message checkpoints; persistence failures surface at
+                    // the next checkpoint/finish instead of becoming unhandled rejections.
+                    return this.checkpoint(trajectory).catch(() => undefined);
+                });
             if (result.compacted) {
-                if (!settings.legacy) {
-                    const covered = this.memoryCache.state.coveredMessages;
-                    const retained = contextLength - covered;
-                    // Insert at the covered boundary, before the retained original tail.
-                    // Marker position is the resume boundary; no separate index is stored.
-                    let insertion = trajectory.length;
-                    let remaining = retained;
-                    while (remaining > 0 && insertion > 0) {
-                        if (trajectory[--insertion].role !== "compaction")
-                            remaining--;
-                    }
-                    trajectory.splice(insertion, 0, {
-                        role: "compaction", content: [{ type: "text", text: result.memory }],
-                        undone: false,
-                        compaction: {
-                            ratio: result.estimatedTokensBefore / this.config.contextWindow,
-                            tokens_at_compaction: result.estimatedTokensBefore,
-                            source,
-                        },
-                    });
+                const covered = settings.legacy ? result.coveredMessages : this.memoryCache.state.coveredMessages;
+                const retained = contextLength - covered;
+                // Insert at the covered boundary, before the retained original tail.
+                // Marker position is the resume boundary; no separate index is stored.
+                let insertion = trajectory.length;
+                let remaining = retained;
+                while (remaining > 0 && insertion > 0) {
+                    if (trajectory[--insertion].role !== "compaction")
+                        remaining--;
+                }
+                trajectory.splice(insertion, 0, {
+                    role: "compaction", content: [{ type: "text", text: result.memory }],
+                    undone: false,
+                    compaction: {
+                        ratio: result.estimatedTokensBefore / this.config.contextWindow,
+                        tokens_at_compaction: result.estimatedTokensBefore,
+                        source,
+                        retained_messages: retained,
+                    },
+                });
+                if (!isCodeArenaMode(this.config.mode)) {
                     // Coverage indices referred to the pre-compaction history. The next
                     // update reads its prior memory from the newly embedded block.
                     this.memoryCache.state = undefined;
                     this.memoryCache.latest = undefined;
                     this.memoryCache.latestUsage = undefined;
                     this.memoryCache.attemptedPrefix = undefined;
+                    this.persistedMemory = undefined;
                 }
                 await this.checkpoint(trajectory);
                 this.sink.compaction(this.sessionId, result.usage);
             }
             return result.compacted;
         }
-        catch {
+        catch (error) {
+            if (error instanceof CheckpointExit)
+                return "checkpoint";
+            if (error instanceof CheckpointFailure)
+                throw error.cause;
             // Compaction is protective rather than task-critical. If its dedicated
             // summary request fails, keep the original history and let the normal
             // model request (and its retry policy) decide whether it still fits.
@@ -581,6 +838,7 @@ export class Agent {
             const calls = new Map();
             const responseItems = new Map();
             let usage;
+            let finishReason;
             let reasoningDetails;
             const detectors = this.options.midturnCheckpointHook ? {
                 content: new RepetitiveOutputDetector(),
@@ -649,6 +907,9 @@ export class Agent {
                     // letting the last non-empty value win.
                     if (chunk.usage)
                         usage = chunk.usage;
+                    if (chunk.choices?.[0]?.finish_reason) {
+                        finishReason = chunk.choices[0].finish_reason;
+                    }
                     if (chunk.reasoning_details?.length) {
                         reasoningDetails = chunk.reasoning_details;
                     }
@@ -687,6 +948,11 @@ export class Agent {
                         if (fragment.function?.arguments) {
                             call.function.arguments += String(fragment.function.arguments);
                         }
+                        // Metadata is an opaque value for this index, not a text delta.
+                        // Later fragments that omit it must not erase an earlier signature.
+                        if (fragment.extra_content !== undefined) {
+                            call.extra_content = structuredClone(fragment.extra_content);
+                        }
                         calls.set(index, call);
                         this.sink.delta(this.sessionId, {
                             tool_calls: [
@@ -698,11 +964,23 @@ export class Agent {
                                         name: String(fragment.function?.name || ""),
                                         arguments: String(fragment.function?.arguments || ""),
                                     },
+                                    ...(fragment.extra_content !== undefined
+                                        ? { extra_content: structuredClone(fragment.extra_content) }
+                                        : {}),
                                 },
                             ],
                         });
                     }
                 }
+                if (finishReason === "tool_calls" && !calls.size) {
+                    throw incompleteModelResponse("Model stopped for tool calls but returned no tool calls");
+                }
+                if (finishReason !== "length" && finishReason !== "incomplete" && finishReason !== "content_filter" &&
+                    !calls.size && !contentParts.join("").trim()) {
+                    throw Object.assign(new Error("Model returned an empty response without tool calls"), {
+                        code: "ARENA_EMPTY_MODEL_RESPONSE",
+                    });
+                }
             }
             catch (error) {
                 // Iterator cleanup may itself report the intentional transport abort.
@@ -734,7 +1012,7 @@ export class Agent {
                 const openaiResponseItems = [...responseItems.entries()]
                     .sort(([left], [right]) => left - right)
                     .map(([, item]) => item);
-                const partial = content || reasoningContent || openaiResponseItems.length
+                const partial = content || reasoningContent || openaiResponseItems.length || usage
                     ? {
                         role: "assistant",
                         content,
@@ -770,7 +1048,10 @@ export class Agent {
                     .sort(([left], [right]) => left - right)
                     .map(([, call]) => call);
             }
-            return assistant;
+            return {
+                assistant,
+                finishReason: finishReason ?? (assistant.tool_calls?.length ? "tool_calls" : "stop"),
+            };
         }
     }
     async retryBackoff(attempt) {