@sema-agent/core 1.291.0 → 1.293.0

package/dist/core/runner/runtask.js

@@ -2,7 +2,7 @@ import { AgentHarness, DEFAULT_COMPACTION_SETTINGS, uuidv7 } from "../../interna
 import { CheckpointError, BINDING_CHECKPOINT_VERSION, checkpointVersionOf, MAX_SUPPORTED_CHECKPOINT_VERSION, remainingBudgetMicroUsd, validatePendingSteer, winnerFromOutcome, } from "../checkpoint-store.js";
 import { effectiveCushionMs, estimateCycleMs, minLiveWriteoutWindowMs, recordCallSample, recordToolSample, recordTtftSample, softExecDeadlineMs, writeoutCushionMs } from "./call-cap.js";
 import { engineVersion } from "../version.js";
-import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionWalltimeAbort, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
+import { DEFAULT_COMPACTION_INSTRUCTIONS, createRapidRefillState, isCompactionManualCancel, isCompactionWalltimeAbort, maybeCompact, nextTrimForceBackoff, recordCompactionAndCheckRapidRefill } from "../auto-compaction.js";
 import { ASK_USER_QUESTION_TOOL_NAME } from "../ask-question.js";
 import { computeCostMicroUsd, modelCostToPricing } from "../pricing.js";
 import { emitTrace } from "../trace.js";
@@ -41,7 +41,7 @@ import { createBrainMemorySelector } from "../memory-recall.js";
 import { buildRecallQuery, runDynamicRecall } from "../dynamic-recall.js";
 import { guardedMemoryStore } from "../memory.js";
 import { releaseSession } from "../../agents/session-util.js";
-export const DEFAULT_MAX_TURNS = 500;
+export const DEFAULT_MAX_TURNS = 1000;
 const MAX_CONSECUTIVE_COMPACTION_FAILURES = 3;
 const STOP_HOOK_BLOCK_CAP = 8;
 const COMPACTION_REGROWTH_FACTOR = 1.5;
@@ -335,9 +335,8 @@ export class Runner {
         const manualCompactRef = { requested: false, waiters: [] };
         const drainManualCompactWaiters = (outcome) => {
             manualCompactRef.requested = false;
-            manualCompactRef.instructions = undefined;
             for (const w of manualCompactRef.waiters.splice(0))
-                w(outcome);
+                w.resolve(outcome);
         };
         const runStartedAt = Date.now();
         const taskIdRef = { current: spec.taskId, sessionId: spec.sessionId };
@@ -532,15 +531,39 @@ export class Runner {
             compact: async (opts) => {
                 if (resultValue)
                     throw steeringError("the task has already finished");
+                if (opts?.signal?.aborted)
+                    return "mooted";
                 const h = handle ?? (await orTimeout(ready));
                 if (!h)
                     throw steeringError("the task is not running");
+                if (opts?.signal?.aborted)
+                    return "mooted";
                 return new Promise((resolve) => {
-                    manualCompactRef.requested = true;
-                    if (opts?.instructions !== undefined) {
-                        manualCompactRef.instructions = opts.instructions;
+                    const signal = opts?.signal;
+                    const entry = {
+                        resolve,
+                        ...(signal !== undefined ? { signal } : {}),
+                        ...(opts?.instructions !== undefined ? { instructions: opts.instructions } : {}),
+                    };
+                    if (signal !== undefined) {
+                        const onAbort = () => {
+                            const i = manualCompactRef.waiters.indexOf(entry);
+                            if (i >= 0) {
+                                manualCompactRef.waiters.splice(i, 1);
+                                if (manualCompactRef.waiters.length === 0) {
+                                    manualCompactRef.requested = false;
+                                }
+                                entry.resolve("mooted");
+                            }
+                        };
+                        entry.resolve = (outcome) => {
+                            signal.removeEventListener("abort", onAbort);
+                            resolve(outcome);
+                        };
+                        signal.addEventListener("abort", onAbort, { once: true });
                     }
-                    manualCompactRef.waiters.push(resolve);
+                    manualCompactRef.requested = true;
+                    manualCompactRef.waiters.push(entry);
                 });
             },
             detach: (toolCallId) => {
@@ -1626,9 +1649,8 @@ export class Runner {
         let trimForceBackoff = false;
         const drainManualCompact = (outcome) => {
             manualCompactRef.requested = false;
-            manualCompactRef.instructions = undefined;
             for (const w of manualCompactRef.waiters.splice(0))
-                w(outcome);
+                w.resolve(outcome);
         };
         const onTurnBoundary = async (event) => {
             let boundarySteered = false;
@@ -1863,17 +1885,35 @@ export class Runner {
                 return undefined;
             }
             const claimedManual = forceManual
-                ? { instructions: manualCompactRef.instructions, waiters: manualCompactRef.waiters.splice(0) }
+                ? (() => {
+                    const waiters = manualCompactRef.waiters.splice(0);
+                    let instructions;
+                    for (let i = waiters.length - 1; i >= 0; i--) {
+                        if (waiters[i].instructions !== undefined) {
+                            instructions = waiters[i].instructions;
+                            break;
+                        }
+                    }
+                    return { instructions, waiters };
+                })()
                 : undefined;
             if (forceManual) {
                 manualCompactRef.requested = false;
-                manualCompactRef.instructions = undefined;
             }
             const resolveClaimedWaiters = (outcome) => {
                 if (claimedManual !== undefined)
                     for (const w of claimedManual.waiters.splice(0))
-                        w(outcome);
+                        w.resolve(outcome);
             };
+            const claimedCancelSignals = claimedManual?.waiters.flatMap((w) => (w.signal !== undefined ? [w.signal] : [])) ?? [];
+            const manualCancelSignal = claimedCancelSignals.length === 0
+                ? undefined
+                : claimedCancelSignals.length === 1
+                    ? claimedCancelSignals[0]
+                    : AbortSignal.any(claimedCancelSignals);
+            const compactionPassSignal = claimedCancelSignals.length > 0
+                ? AbortSignal.any([prepared.abortController.signal, ...claimedCancelSignals])
+                : prepared.abortController.signal;
             const trimPressureArmed = prepared.trimPressureRef.droppedMessages;
             if (trimPressureArmed)
                 prepared.trimPressureRef.droppedMessages = false;
@@ -1893,7 +1933,8 @@ export class Runner {
                     thinking: prepared.thinking,
                     settings: { ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction },
                     customInstructions: manualInstructions ?? spec.compaction?.instructions ?? DEFAULT_COMPACTION_INSTRUCTIONS,
-                    signal: prepared.abortController.signal,
+                    signal: compactionPassSignal,
+                    ...(manualCancelSignal !== undefined ? { manualCancelSignal } : {}),
                     minTokens: forceManual ? 0 : compactionFloor,
                     force: forceManual,
                     onInputTruncated: (info) => emitTrace(tracer, () => ({ kind: "compaction.input_truncated", version: 1, taskId, label: info.label, droppedChars: info.droppedChars, keptChars: info.keptChars, ts: Date.now() })),
@@ -1984,7 +2025,12 @@ export class Runner {
                 }
             }
             catch (err) {
-                if (!prepared.abortController.signal.aborted) {
+                const manualCancelAbort = !prepared.abortController.signal.aborted && isCompactionManualCancel(err);
+                if (manualCancelAbort) {
+                    emitTrace(tracer, () => ({ kind: "compaction.mooted", version: 1, taskId, reason: "cancelled", ts: Date.now() }));
+                    manualOutcome = "mooted";
+                }
+                else if (!prepared.abortController.signal.aborted) {
                     const walltimeAbort = isCompactionWalltimeAbort(err);
                     if (!walltimeAbort)
                         compactionBreaker.failures += 1;