@sema-agent/core 5.7.0 → 5.9.0

package/dist/engine/harness/agent-harness.js

@@ -185,9 +185,8 @@ export class AgentHarness {
     steeringQueueMode;
     maxOutputTokens;
     maxOutputTokensPerCall;
-    callDeadlineMsPerCall;
     stallTimeoutsPerCall;
-    toolDeadline;
+    abortResultDetails;
     loopTrace;
     resilience;
     maxToolConcurrency;
@@ -217,9 +216,8 @@ export class AgentHarness {
         this.steeringQueueMode = options.steeringMode ?? "one-at-a-time";
         this.maxOutputTokens = options.maxOutputTokens;
         this.maxOutputTokensPerCall = options.maxOutputTokensPerCall;
-        this.callDeadlineMsPerCall = options.callDeadlineMsPerCall;
         this.stallTimeoutsPerCall = options.stallTimeoutsPerCall;
-        this.toolDeadline = options.toolDeadline;
+        this.abortResultDetails = options.abortResultDetails;
         this.loopTrace = options.loopTrace;
         this.resilience = options.resilience;
         this.maxToolConcurrency = options.maxToolConcurrency;
@@ -407,7 +405,6 @@ export class AgentHarness {
                 },
                 reasoning: streamOptions?.reasoning,
                 maxTokens: streamOptions?.maxTokens,
-                callDeadlineMs: streamOptions?.callDeadlineMs,
                 stallTimeouts: streamOptions?.stallTimeouts,
                 maxTokensDynamic: streamOptions?.maxTokensDynamic,
                 staticReasoningCutDowngrade: streamOptions?.staticReasoningCutDowngrade,
@@ -442,12 +439,10 @@ export class AgentHarness {
         return {
             model: turnState.model,
             reasoning: turnState.thinkingLevel,
-            liveThinkingLevel: () => self.thinkingLevel,
             ...(this.maxOutputTokens !== undefined ? { maxTokens: this.maxOutputTokens } : {}),
             ...(this.maxOutputTokensPerCall !== undefined ? { maxTokensPerCall: this.maxOutputTokensPerCall } : {}),
-            ...(this.callDeadlineMsPerCall !== undefined ? { callDeadlineMsPerCall: this.callDeadlineMsPerCall } : {}),
             ...(this.stallTimeoutsPerCall !== undefined ? { stallTimeoutsPerCall: this.stallTimeoutsPerCall } : {}),
-            ...(this.toolDeadline !== undefined ? { toolDeadline: this.toolDeadline } : {}),
+            ...(this.abortResultDetails !== undefined ? { abortResultDetails: this.abortResultDetails } : {}),
             ...(this.resilience !== undefined ? { resilience: this.resilience } : {}),
             ...(this.maxToolConcurrency !== undefined ? { maxToolConcurrency: this.maxToolConcurrency } : {}),
             ...(this.streamingToolExecution === true && (this.getHandlers("tool_call")?.size ?? 0) === 0
@@ -511,9 +506,6 @@ export class AgentHarness {
                 get degenerateOutput() {
                     return self.loopRecovery?.degenerateOutput;
                 },
-                get walltimeCutoff() {
-                    return self.loopRecovery?.walltimeCutoff;
-                },
                 get promptTooLong() {
                     const ptl = self.loopRecovery?.promptTooLong;
                     if (!ptl)
@@ -681,7 +673,7 @@ export class AgentHarness {
             for (let i = newMessages.length - 1; i >= 0; i--) {
                 const message = newMessages[i];
                 if (message.role === "assistant") {
-                    return mergeTruncatedOutputChain(newMessages, i, this.loopRecovery?.walltimeCutoff?.detect);
+                    return mergeTruncatedOutputChain(newMessages, i);
                 }
             }
             throw new AgentHarnessError("invalid_state", "AgentHarness prompt completed without an assistant message");
@@ -931,54 +923,25 @@ function isEmptyFailureAssistant(message) {
         return false;
     return m.content.every((c) => c.type === "text" ? c.text.trim() === "" : c.type === "thinking" ? c.thinking.trim() === "" : false);
 }
-function mergeTruncatedOutputChain(messages, lastAssistantIndex, isWalltimeCutoff) {
+function mergeTruncatedOutputChain(messages, lastAssistantIndex) {
     const last = messages[lastAssistantIndex];
     const lastText = last.content.map((c) => (c.type === "text" ? c.text : "")).join("");
     const parts = [];
     let i = lastAssistantIndex;
     while (i - 2 >= 0) {
         const mid = messages[i - 1];
-        const downstreamText = parts.join("") + lastText;
-        const walltimeGate = last.stopReason === "error" || downstreamText.trim() === "";
-        let head;
-        let walltimeStep = false;
-        let nextI = i - 2;
-        if (mid.role === "custom") {
-            const h = messages[i - 2];
-            if (h.role !== "assistant")
-                break;
-            const assistant = h;
-            const step = (mid.customType === "loop:truncated-output-continue" && assistant.stopReason === "length") ||
-                (mid.customType === "loop:midstream-partial-continue" && assistant.stopReason === "stop") ||
-                (mid.customType === "loop:walltime-cutoff-recovery" && assistant.stopReason === "error" && walltimeGate);
-            if (!step)
-                break;
-            head = assistant;
-            walltimeStep = mid.customType === "loop:walltime-cutoff-recovery";
-        }
-        else if (mid.role === "user" && isWalltimeCutoff) {
-            let j = i - 1;
-            while (j >= 0 && messages[j].role === "user")
-                j--;
-            if (j < 0 || j >= i - 1)
-                break;
-            const h = messages[j];
-            if (h.role !== "assistant")
-                break;
-            const assistant = h;
-            if (!(assistant.stopReason === "error" && isWalltimeCutoff(assistant) && walltimeGate))
-                break;
-            head = assistant;
-            walltimeStep = true;
-            nextI = j;
-        }
-        else {
+        if (mid.role !== "custom")
             break;
-        }
-        const headText = head.content.map((c) => (c.type === "text" ? c.text : "")).join("");
-        const needsBreak = walltimeStep && downstreamText !== "" && headText !== "";
-        parts.unshift(needsBreak ? `${headText}\n\n` : headText);
-        i = nextI;
+        const h = messages[i - 2];
+        if (h.role !== "assistant")
+            break;
+        const head = h;
+        const step = (mid.customType === "loop:truncated-output-continue" && head.stopReason === "length") ||
+            (mid.customType === "loop:midstream-partial-continue" && head.stopReason === "stop");
+        if (!step)
+            break;
+        parts.unshift(head.content.map((c) => (c.type === "text" ? c.text : "")).join(""));
+        i = i - 2;
     }
     if (parts.length === 0) {
         return last;

package/dist/engine/harness/types.d.ts

@@ -88,11 +88,6 @@ export interface ExecutionEnvExecOptions {
     onStdout?: (chunk: string) => void;
     onStderr?: (chunk: string) => void;
     detachSignal?: AbortSignal;
-    onSpawn?: (handle: {
-        pid: number;
-        kill: () => void;
-    }) => void;
-    onDetachAdopted?: () => void;
     autoBackgroundOnTimeout?: boolean;
 }
 export interface FileSystem {
@@ -144,6 +139,8 @@ export interface Shell {
     cleanup(): Promise<void>;
 }
 export interface ExecutionEnv extends FileSystem, Shell {
+    readonly lifetimeMs?: number;
+    readonly lifetimeStartedAt?: number;
 }
 export interface SessionTreeEntryBase {
     type: string;
@@ -544,17 +541,8 @@ export interface AgentHarnessOptions<TSkill extends Skill = Skill, TPromptTempla
     followUpMode?: QueueMode;
     maxOutputTokens?: number;
     maxOutputTokensPerCall?: () => number | undefined;
-    callDeadlineMsPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
-    toolDeadline?: {
-        deadlineMs: () => number | undefined;
-        onCut?: (info: {
-            toolCallId: string;
-            toolName: string;
-            elapsedMs: number;
-            settled: Promise<void>;
-        }) => void;
-    };
+    abortResultDetails?: () => Record<string, unknown> | undefined;
     loopTrace?: (step: import("../loop/agent-loop.js").LoopStep) => void;
     resilience?: import("../llm/types.js").ResilienceOptions;
     maxToolConcurrency?: number;

package/dist/engine/llm/types.d.ts

@@ -45,7 +45,6 @@ export interface StreamOptions {
     maxTokensDynamic?: boolean;
     staticReasoningCutDowngrade?: boolean;
     resilience?: ResilienceOptions;
-    callDeadlineMs?: number;
     stallTimeouts?: StallTimeouts;
     maxRetries?: number;
     maxRetryDelayMs?: number;
@@ -69,15 +68,9 @@ export interface SimpleStreamOptions extends StreamOptions {
 }
 export type StreamFunction<TApi extends Api = Api, TOptions extends StreamOptions = StreamOptions> = (model: Model<TApi>, context: Context, options?: TOptions) => AssistantMessageEventStreamContract;
 export type ImagesFunction<TApi extends ImagesApi = ImagesApi, TOptions extends ImagesOptions = ImagesOptions> = (model: ImagesModel<TApi>, context: ImagesContext, options?: TOptions) => Promise<AssistantImages>;
-export interface TextSignatureV1 {
-    v: 1;
-    id: string;
-    phase?: "commentary" | "final_answer";
-}
 export interface TextContent {
     type: "text";
     text: string;
-    textSignature?: string;
 }
 export interface ThinkingContent {
     type: "thinking";
@@ -100,7 +93,6 @@ export interface ToolCall {
     id: string;
     name: string;
     arguments: Record<string, unknown>;
-    thoughtSignature?: string;
     executionMode?: "sequential" | "parallel";
 }
 export interface Usage {
@@ -143,7 +135,7 @@ export interface AssistantMessage {
     usageMissing?: true;
     stopReason: StopReason;
     errorMessage?: string;
-    errorKind?: "length_empty" | "degenerate" | "walltime_cutoff";
+    errorKind?: "length_empty" | "degenerate";
     partialFinalized?: true;
     repetition?: {
         cut?: RepetitionEvent;
@@ -260,28 +252,15 @@ export interface AssistantMessageEventStreamLike extends AsyncIterable<Assistant
     result(): Promise<AssistantMessage>;
 }
 export interface OpenAICompletionsCompat {
-    supportsStore?: boolean;
-    supportsDeveloperRole?: boolean;
     supportsReasoningEffort?: boolean;
     reasoningEffortLevels?: ThinkingLevel[];
-    supportsUsageInStreaming?: boolean;
     maxTokensField?: "max_completion_tokens" | "max_tokens";
-    requiresToolResultName?: boolean;
-    requiresAssistantAfterToolResult?: boolean;
-    requiresThinkingAsText?: boolean;
     requiresReasoningContentOnAssistantMessages?: boolean;
     thinkingFormat?: "openai" | "openrouter" | "deepseek" | "together" | "zai" | "qwen" | "qwen-chat-template";
-    openRouterRouting?: OpenRouterRouting;
-    vercelGatewayRouting?: VercelGatewayRouting;
-    zaiToolStream?: boolean;
-    supportsStrictMode?: boolean;
-    cacheControlFormat?: "anthropic";
-    sendSessionAffinityHeaders?: boolean;
-    supportsLongCacheRetention?: boolean;
 }
 export interface OpenAIResponsesCompat {
-    sendSessionIdHeader?: boolean;
-    supportsLongCacheRetention?: boolean;
+    supportsReasoningEffort?: boolean;
+    reasoningEffortLevels?: ThinkingLevel[];
 }
 export interface AnthropicMessagesCompat {
     thinkingMode?: "budget" | "adaptive";
@@ -289,48 +268,6 @@ export interface AnthropicMessagesCompat {
     supportsTemperature?: boolean;
     contextManagement?: boolean;
     interleavedThinking?: boolean;
-    supportsEagerToolInputStreaming?: boolean;
-    supportsLongCacheRetention?: boolean;
-    sendSessionAffinityHeaders?: boolean;
-    supportsCacheControlOnTools?: boolean;
-}
-export interface OpenRouterRouting {
-    allow_fallbacks?: boolean;
-    require_parameters?: boolean;
-    data_collection?: "deny" | "allow";
-    zdr?: boolean;
-    enforce_distillable_text?: boolean;
-    order?: string[];
-    only?: string[];
-    ignore?: string[];
-    quantizations?: string[];
-    sort?: string | {
-        by?: string;
-        partition?: string | null;
-    };
-    max_price?: {
-        prompt?: number | string;
-        completion?: number | string;
-        image?: number | string;
-        audio?: number | string;
-        request?: number | string;
-    };
-    preferred_min_throughput?: number | {
-        p50?: number;
-        p75?: number;
-        p90?: number;
-        p99?: number;
-    };
-    preferred_max_latency?: number | {
-        p50?: number;
-        p75?: number;
-        p90?: number;
-        p99?: number;
-    };
-}
-export interface VercelGatewayRouting {
-    only?: string[];
-    order?: string[];
 }
 export interface Model<TApi extends Api = Api> {
     id: string;
@@ -358,15 +295,6 @@ export interface Model<TApi extends Api = Api> {
     headers?: Record<string, string>;
     promptGuidance?: string[];
     compat?: TApi extends "openai-completions" ? OpenAICompletionsCompat : TApi extends "openai-responses" ? OpenAIResponsesCompat : TApi extends "anthropic-messages" ? AnthropicMessagesCompat : never;
-    mediaInput?: {
-        image?: {
-            maxBytes?: number;
-            maxPixels?: number;
-            maxSidePx?: number;
-            preferredSidePx?: number;
-            tokenMode?: "tile" | "detail" | "provider";
-        };
-    };
 }
 export interface ImagesModel<TApi extends ImagesApi = ImagesApi> extends Omit<Model, "api" | "provider" | "reasoning" | "contextWindow" | "maxTokens" | "compat"> {
     api: TApi;

package/dist/engine/loop/agent-loop.d.ts

@@ -1,7 +1,7 @@
 import { type AgentCoreStreamRuntimeDeps } from "./runtime-deps.js";
 import type { AgentContext, AgentEvent, AgentLoopConfig, AgentMessage, StreamFn } from "./types.js";
 export type AgentEventSink = (event: AgentEvent) => Promise<void> | void;
-export type LoopContinueReason = "next_turn" | "steer_injected" | "follow_up_injected" | "reactive_compact_retry" | "max_output_tokens_recovery" | "malformed_tool_use_retry" | "thinking_only_retry" | "midstream_partial_recovery" | "degenerate_output_recovery" | "walltime_cutoff_recovery";
+export type LoopContinueReason = "next_turn" | "steer_injected" | "follow_up_injected" | "reactive_compact_retry" | "max_output_tokens_recovery" | "malformed_tool_use_retry" | "thinking_only_retry" | "midstream_partial_recovery" | "degenerate_output_recovery";
 export type LoopTerminalReason = "completed" | "aborted_before_stream" | "assistant_error" | "stop_requested" | "malformed_tool_use_exhausted" | "truncated_output_exhausted";
 export type LoopStep = {
     kind: "continue";

package/dist/engine/loop/agent-loop.js

@@ -111,17 +111,6 @@ function createDegenerateRecoveryNudge() {
         timestamp: Date.now(),
     };
 }
-function createWalltimeCutoffRecoveryNudge() {
-    return {
-        role: "custom",
-        customType: "loop:walltime-cutoff-recovery",
-        provenance: "engine-note",
-        content: "Your previous response crossed the task's wall-clock deadline and was cut off (the partial text above is preserved). " +
-            "This is the FINAL turn: write your best current answer / deliverables NOW in one short response — no new work, no long commands.",
-        display: false,
-        timestamp: Date.now(),
-    };
-}
 function createReasoningCutContinueNudge() {
     return {
         role: "custom",
@@ -154,7 +143,6 @@ async function runLoop(initialContext, newMessages, initialConfig, signal, emit,
         truncatedOutputContinues: 0,
         staticReasoningCutRecoveries: initialContext.messages.filter((m) => m.role === "assistant" && m.staticReasoningCut === true).length,
         degenerateContinues: 0,
-        walltimeCutoffContinues: 0,
         malformedToolUseRetries: 0,
         thinkingOnlyRetries: 0,
         midstreamPartialContinues: 0,
@@ -282,47 +270,8 @@ async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
         if (message.stopReason !== "error")
             state.degenerateContinues = 0;
     }
-    {
-        const wc = state.config.recovery?.walltimeCutoff;
-        if (wc &&
-            message.stopReason === "error" &&
-            !signal?.aborted &&
-            wc.detect(message) &&
-            (wc.hasLiveWriteoutWindow === undefined || wc.hasLiveWriteoutWindow()) &&
-            executor.admittedCount === 0 &&
-            message.content.every((b) => b.type !== "toolCall") &&
-            state.walltimeCutoffContinues < (wc.maxContinues ?? 1)) {
-            state.walltimeCutoffContinues++;
-            await emit({ type: "turn_end", message, toolResults: [] });
-            const drained = (await state.config.getSteeringMessages?.()) || [];
-            state.pendingMessages = drained.length > 0 ? drained : [createWalltimeCutoffRecoveryNudge()];
-            const liveLevel = state.config.liveThinkingLevel?.();
-            if (liveLevel !== undefined)
-                state.config = Object.assign({}, state.config, { reasoning: liveLevel });
-            return { kind: "ran", recovered: "walltime_cutoff_recovery" };
-        }
-    }
     if (message.stopReason === "error" || message.stopReason === "aborted") {
         const errorFinalResults = await harvestExecutorOnErrorFinal(executor, state, message, signal, emit);
-        if (state.config.recovery?.walltimeCutoff?.detect(message)) {
-            const covered = new Set(errorFinalResults.map((r) => r.toolCallId));
-            for (const tc of message.content.filter((c) => c.type === "toolCall")) {
-                if (covered.has(tc.id))
-                    continue;
-                const synthetic = {
-                    role: "toolResult",
-                    toolCallId: tc.id,
-                    toolName: tc.name,
-                    content: [{ type: "text", text: "[call aborted by walltime cutoff — never executed]" }],
-                    isError: true,
-                    timestamp: Date.now(),
-                };
-                await emitToolResultMessage(synthetic, emit);
-                state.context.messages.push(synthetic);
-                state.newMessages.push(synthetic);
-                errorFinalResults.push(synthetic);
-            }
-        }
         await emit({ type: "turn_end", message, toolResults: errorFinalResults });
         await emit({ type: "agent_end", messages: state.newMessages });
         return { kind: "terminal", reason: "assistant_error" };
@@ -440,12 +389,10 @@ async function streamAssistantResponse(context, config, signal, emit, streamFn,
     const streamFunction = resolveAgentCoreStreamFn(runtime, streamFn);
     const resolvedApiKey = (config.getApiKey ? await config.getApiKey(config.model.provider) : undefined) || config.apiKey;
     const perCallMaxTokens = config.maxTokensPerCall?.();
-    const perCallDeadlineMs = config.callDeadlineMsPerCall?.();
     const perCallStallTimeouts = config.stallTimeoutsPerCall?.();
     const response = await streamFunction(config.model, llmContext, {
         ...config,
         ...(perCallMaxTokens !== undefined ? { maxTokens: perCallMaxTokens, maxTokensDynamic: true } : {}),
-        ...(perCallDeadlineMs !== undefined ? { callDeadlineMs: perCallDeadlineMs } : {}),
         ...(perCallStallTimeouts !== undefined ? { stallTimeouts: perCallStallTimeouts } : {}),
         ...(staticReasoningCutDowngrade === true ? { staticReasoningCutDowngrade: true } : {}),
         apiKey: resolvedApiKey,
@@ -527,28 +474,6 @@ async function executeToolCalls(currentContext, assistantMessage, config, signal
     }
     return executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor);
 }
-const engineCutResults = new WeakSet();
-function isEngineCutResult(result) {
-    return engineCutResults.has(result);
-}
-function createEngineCutNotExecutedOutcome(toolCall) {
-    return {
-        toolCall,
-        result: {
-            content: [
-                {
-                    type: "text",
-                    text: `[not executed — engine stopped waiting at the write-out deadline] ${toolCall.name} was NOT executed: ` +
-                        `an earlier tool in this batch was cut at the task's write-out deadline, so the engine closed the batch ` +
-                        `immediately to reach the final write-out turn. This call ran no side effects and is safe to re-issue ` +
-                        `later if still needed — but do not start new long-running work now; write out your best current answer.`,
-                },
-            ],
-            details: { engineCut: "walltime_writeout", notExecuted: true },
-        },
-        isError: true,
-    };
-}
 async function executeToolCallsSequential(currentContext, assistantMessage, toolCalls, config, signal, emit) {
     const finalizedCalls = [];
     const messages = [];
@@ -562,7 +487,6 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         });
         const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
         let finalized;
-        let engineCutRaw = false;
         if (preparation.kind === "immediate") {
             finalized = {
                 toolCall,
@@ -571,8 +495,7 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
             };
         }
         else {
-            const executed = await executePreparedToolCall(preparation, config, signal, emit);
-            engineCutRaw = isEngineCutResult(executed.result);
+            const executed = await executePreparedToolCall(preparation, signal, emit, config.abortResultDetails);
             finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
         }
         await emitToolExecutionEnd(finalized, emit);
@@ -580,23 +503,6 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         await emitToolResultMessage(toolResultMessage, emit);
         finalizedCalls.push(finalized);
         messages.push(toolResultMessage);
-        if (engineCutRaw) {
-            for (const later of toolCalls.slice(i + 1)) {
-                await emit({
-                    type: "tool_execution_start",
-                    toolCallId: later.id,
-                    toolName: later.name,
-                    args: later.arguments,
-                });
-                const skipped = createEngineCutNotExecutedOutcome(later);
-                await emitToolExecutionEnd(skipped, emit);
-                const skippedMessage = createToolResultMessage(skipped);
-                await emitToolResultMessage(skippedMessage, emit);
-                finalizedCalls.push(skipped);
-                messages.push(skippedMessage);
-            }
-            break;
-        }
         if (signal?.aborted) {
             break;
         }
@@ -668,7 +574,6 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     const cap = resolveToolConcurrency(config.maxToolConcurrency);
     const allFinalized = [];
     const messages = [];
-    let engineCutSeen = false;
     const remainingCalls = [];
     for (const toolCall of toolCalls) {
         const held = executor?.take(toolCall.id);
@@ -676,8 +581,6 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
             remainingCalls.push(toolCall);
             continue;
         }
-        if (held.executed && isEngineCutResult(held.executed.result))
-            engineCutSeen = true;
         const finalized = await finalizeStreamEntry(currentContext, assistantMessage, held, config, signal);
         await emitToolExecutionEnd(finalized, emit);
         const toolResultMessage = createToolResultMessage(finalized);
@@ -695,23 +598,6 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     outer: for (const batch of batches) {
         if (signal?.aborted)
             break;
-        if (engineCutSeen) {
-            for (const toolCall of batch.calls) {
-                await emit({
-                    type: "tool_execution_start",
-                    toolCallId: toolCall.id,
-                    toolName: toolCall.name,
-                    args: toolCall.arguments,
-                });
-                const skipped = createEngineCutNotExecutedOutcome(toolCall);
-                await emitToolExecutionEnd(skipped, emit);
-                const skippedMessage = createToolResultMessage(skipped);
-                await emitToolResultMessage(skippedMessage, emit);
-                allFinalized.push(skipped);
-                messages.push(skippedMessage);
-            }
-            continue;
-        }
         const entries = [];
         for (const toolCall of batch.calls) {
             await emit({
@@ -739,14 +625,7 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     return { messages, terminate: shouldTerminateToolBatch(allFinalized) };
     async function settleBatch(entries, concurrent) {
         const runOne = (entry) => async () => {
-            if (engineCutSeen) {
-                const skipped = createEngineCutNotExecutedOutcome(entry.toolCall);
-                await emitToolExecutionEnd(skipped, emit);
-                return skipped;
-            }
-            const executed = await executePreparedToolCall(entry.prepared, config, signal, emit);
-            if (isEngineCutResult(executed.result))
-                engineCutSeen = true;
+            const executed = await executePreparedToolCall(entry.prepared, signal, emit, config.abortResultDetails);
             const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, entry.prepared, executed, config, signal);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
@@ -828,10 +707,7 @@ class StreamToolExecutor {
                 return;
             }
             entry.prepared = preparation;
-            entry.executed = await executePreparedToolCall(preparation, this.config, this.signal, this.emit);
-            if (isEngineCutResult(entry.executed.result)) {
-                this.barrier = true;
-            }
+            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit, this.config.abortResultDetails);
         }
         catch (error) {
             entry.immediate = {
@@ -953,7 +829,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
             if (signal?.aborted) {
                 return {
                     kind: "immediate",
-                    result: createErrorToolResult("Operation aborted"),
+                    result: createErrorToolResult("Operation aborted", { details: config.abortResultDetails?.() }),
                     isError: true,
                 };
             }
@@ -993,13 +869,12 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
 }
-async function executePreparedToolCall(prepared, config, signal, emit) {
+async function executePreparedToolCall(prepared, signal, emit, abortResultDetails) {
     const updateEvents = [];
     let acceptingUpdates = true;
     if (signal?.aborted) {
-        return { result: createErrorToolResult("operation aborted before execution"), isError: true };
+        return { result: createErrorToolResult("operation aborted before execution", { details: abortResultDetails?.() }), isError: true };
     }
-    const startedAt = Date.now();
     const work = (async () => {
         try {
             const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
@@ -1027,48 +902,7 @@ async function executePreparedToolCall(prepared, config, signal, emit) {
             };
         }
     })();
-    const cutDeadline = config.toolDeadline?.deadlineMs();
-    if (cutDeadline === undefined)
-        return work;
-    let cutTimer;
-    const cut = new Promise((resolve) => {
-        cutTimer = setTimeout(() => {
-            const elapsedMs = Date.now() - startedAt;
-            acceptingUpdates = false;
-            try {
-                config.toolDeadline?.onCut?.({
-                    toolCallId: prepared.toolCall.id,
-                    toolName: prepared.toolCall.name,
-                    elapsedMs,
-                    settled: work.then(() => undefined, () => undefined),
-                });
-            }
-            catch {
-            }
-            const cutResult = {
-                content: [
-                    {
-                        type: "text",
-                        text: `[tool cut short at the write-out deadline] ${prepared.toolCall.name} had been running for ${Math.round(elapsedMs / 1000)}s ` +
-                            `when the task's wall-clock write-out window opened — the ENGINE stopped waiting for it so the final answer can still be written out. ` +
-                            `The tool itself was NOT cancelled and did not fail: it may have completed or may still be running in the background, and its side effects ` +
-                            `may still land after this message — treat its outcome as UNKNOWN and do NOT blindly re-issue non-idempotent operations. ` +
-                            `Do not start new long-running work — write out your best current answer now.`,
-                    },
-                ],
-                details: { engineCut: "walltime_writeout", elapsedMs },
-            };
-            engineCutResults.add(cutResult);
-            resolve({ result: cutResult, isError: true });
-        }, Math.max(0, cutDeadline - Date.now()));
-        cutTimer.unref?.();
-    });
-    try {
-        return await Promise.race([work, cut]);
-    }
-    finally {
-        clearTimeout(cutTimer);
-    }
+    return work;
 }
 async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
     let result = executed.result;

package/dist/engine/loop/types.d.ts

@@ -68,29 +68,12 @@ export interface LoopRecoveryOptions {
         detect: (message: AssistantMessage) => boolean;
         maxContinues?: number;
     };
-    walltimeCutoff?: {
-        detect: (message: AssistantMessage) => boolean;
-        maxContinues?: number;
-        hasLiveWriteoutWindow?: () => boolean;
-    };
-}
-export interface ToolCutInfo {
-    toolCallId: string;
-    toolName: string;
-    elapsedMs: number;
-    settled: Promise<void>;
-}
-export interface LoopToolDeadline {
-    deadlineMs: () => number | undefined;
-    onCut?: (info: ToolCutInfo) => void;
 }
 export interface AgentLoopConfig extends SimpleStreamOptions {
     model: Model;
     recovery?: LoopRecoveryOptions;
     maxTokensPerCall?: () => number | undefined;
-    callDeadlineMsPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
-    toolDeadline?: LoopToolDeadline;
     maxToolConcurrency?: number;
     streamingToolExecution?: boolean;
     convertToLlm: (messages: AgentMessage[]) => Message[] | Promise<Message[]>;
@@ -98,11 +81,11 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
     getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
     shouldStopAfterTurn?: (context: ShouldStopAfterTurnContext) => boolean | Promise<boolean>;
     prepareNextTurn?: (context: PrepareNextTurnContext) => AgentLoopTurnUpdate | undefined | Promise<AgentLoopTurnUpdate | undefined>;
-    liveThinkingLevel?: () => ThinkingLevel;
     getSteeringMessages?: () => Promise<AgentMessage[]>;
     getFollowUpMessages?: () => Promise<AgentMessage[]>;
     toolExecution?: ToolExecutionMode;
     beforeToolCall?: (context: BeforeToolCallContext, signal?: AbortSignal) => Promise<BeforeToolCallResult | undefined>;
+    abortResultDetails?: () => Record<string, unknown> | undefined;
     afterToolCall?: (context: AfterToolCallContext, signal?: AbortSignal) => Promise<AfterToolCallResult | undefined>;
 }
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";

package/dist/engine/session/repo-utils.d.ts

@@ -1,9 +1,8 @@
-import { type FileError, type Result, type SessionMetadata, type SessionStorage, type SessionTreeEntry } from "../harness/types.js";
+import { type SessionMetadata, type SessionStorage, type SessionTreeEntry } from "../harness/types.js";
 import type { Session } from "../harness/types.js";
 export declare function createSessionId(): string;
 export declare function createTimestamp(): string;
 export declare function toSession<TMetadata extends SessionMetadata>(storage: SessionStorage<TMetadata>): Session<TMetadata>;
-export declare function getFileSystemResultOrThrow<TValue>(result: Result<TValue, FileError>, message: string): TValue;
 export declare function getEntriesToFork(storage: SessionStorage, options: {
     entryId?: string;
     position?: "before" | "at";