@sema-agent/core 5.8.0 → 5.10.0

package/dist/core/strategy-store.js

@@ -1,3 +1,25 @@
+function invalidKnob(message, code) {
+    const e = new Error(message);
+    e.code = code;
+    return e;
+}
+function resolveFindLimit(limit) {
+    if (limit === Number.POSITIVE_INFINITY)
+        return limit;
+    if (!Number.isInteger(limit) || limit < 0) {
+        throw invalidKnob(`StrategyStore.find: limit must be a non-negative integer, or Infinity for "no cap" (got ${String(limit)})`, "config.strategy_find_limit_invalid");
+    }
+    return limit;
+}
+function resolveCapacityCap(name, cap) {
+    if (cap === Number.POSITIVE_INFINITY) {
+        throw invalidKnob(`InMemoryStrategyStore ${name} cannot be Infinity — a per-scope capacity cap can be widened but not turned off; pass a large finite integer instead`, "config.strategy_max_size_invalid");
+    }
+    if (!Number.isInteger(cap) || cap < 0) {
+        throw invalidKnob(`InMemoryStrategyStore ${name} must be a non-negative integer (got ${String(cap)})`, "config.strategy_max_size_invalid");
+    }
+    return cap;
+}
 const STOP = new Set([
     "the", "and", "for", "with", "from", "this", "that", "into", "your", "you", "are", "was", "were", "has",
     "have", "had", "not", "but", "all", "any", "can", "use", "using", "via", "then", "than", "out", "get",
@@ -24,10 +46,10 @@ function score(s) {
     return (s.confidence + 1) * (1 / (1 + ageDays(s.ts)));
 }
 export class InMemoryStrategyStore {
-    maxPerScope;
     byScope = new Map();
+    maxPerScope;
     constructor(maxPerScope = 100) {
-        this.maxPerScope = maxPerScope;
+        this.maxPerScope = resolveCapacityCap("maxPerScope", maxPerScope);
     }
     save(s) {
         const arr = this.byScope.get(s.scope) ?? [];
@@ -49,6 +71,7 @@ export class InMemoryStrategyStore {
         this.byScope.set(s.scope, arr);
     }
     find(scope, query, limit) {
+        const cap = resolveFindLimit(limit);
         const arr = this.byScope.get(scope);
         if (!arr || arr.length === 0) {
             return [];
@@ -61,11 +84,11 @@ export class InMemoryStrategyStore {
             const probTokens = new Set(tokens(s.problem));
             return qSig.every((t) => probTokens.has(t));
         });
-        return matches.sort((a, b) => score(b) - score(a)).slice(0, Math.max(0, Number.isFinite(limit) ? limit : 0));
+        return matches.sort((a, b) => score(b) - score(a)).slice(0, cap);
     }
     prune(scope, maxSize) {
+        const n = resolveCapacityCap("maxSize", maxSize);
         const arr = this.byScope.get(scope);
-        const n = Math.max(0, maxSize);
         if (arr && arr.length > n) {
             arr.sort((a, b) => score(b) - score(a));
             arr.length = n;

package/dist/core/task-registry-shared.d.ts

@@ -40,7 +40,6 @@ export interface SemaTaskHandle {
     createdAt: number;
     updatedAt: number;
     outputFile?: string;
-    outputOffset?: number;
     completionId?: string;
 }
 export declare function mintCompletionId(target: {

package/dist/core/tool-policy.d.ts

@@ -70,6 +70,11 @@ export declare function createTranscriptIntegrityPolicy(opts?: {
     readAllow?: readonly string[];
     tools?: string[];
 }): ToolPolicy;
+export interface AskDelegationProvenance {
+    readonly parentToolCallId: string;
+    readonly depth: number;
+    readonly agentName?: string;
+}
 export interface AskRequest {
     toolName: string;
     toolCallId: string;
@@ -81,12 +86,15 @@ export interface AskRequest {
     readonly fromSubagent?: true;
     readonly sourceAgentName?: string;
     readonly requiresRealApproval?: boolean;
+    readonly delegation?: AskDelegationProvenance;
 }
 export type OnAsk = "deny" | "allow" | ((req: AskRequest, signal?: AbortSignal) => AskOutcome | Promise<AskOutcome>);
 export type AskOutcome = boolean | "unavailable" | {
     allow: boolean;
     updatedInput?: unknown;
 };
+export declare function withDelegationProvenance(onAsk: OnAsk, delegation: AskDelegationProvenance): OnAsk;
+export declare function askApproverIdentity(onAsk: unknown): unknown;
 export type ResolvedAsk = PermissionResult & {
     approverUnavailable?: true;
     presentedInput?: unknown;

package/dist/core/tool-policy.js

@@ -516,6 +516,17 @@ export function createTranscriptIntegrityPolicy(opts) {
         },
     };
 }
+const delegatedApproverRoot = new WeakMap();
+export function withDelegationProvenance(onAsk, delegation) {
+    if (typeof onAsk !== "function")
+        return onAsk;
+    const wrapper = (req, signal) => req.delegation !== undefined ? onAsk(req, signal) : onAsk({ ...req, delegation }, signal);
+    delegatedApproverRoot.set(wrapper, askApproverIdentity(onAsk));
+    return wrapper;
+}
+export function askApproverIdentity(onAsk) {
+    return typeof onAsk === "function" ? (delegatedApproverRoot.get(onAsk) ?? onAsk) : onAsk;
+}
 function tryCloneArgs(v) {
     try {
         const value = structuredClone(v);

package/dist/core/tools.js

@@ -64,7 +64,15 @@ export function defineTool(spec, options) {
                 ret = await spec.execute(params, options?.enrichCtx ? { ...options.enrichCtx(baseCtx), toolCallId, signal } : baseCtx);
             }
             catch (err) {
-                throw new Error(formatToolError(err));
+                const wrapped = new Error(formatToolError(err));
+                if (err !== null && typeof err === "object") {
+                    const src = err;
+                    if (src.details !== undefined)
+                        wrapped.details = src.details;
+                    if (typeof src.errorKind === "string")
+                        wrapped.errorKind = src.errorKind;
+                }
+                throw wrapped;
             }
             const { content, details, terminate, isError } = normalizeContent(ret);
             const guarded = isEmptyToolContent(content)

package/dist/core/trace.d.ts

@@ -134,8 +134,6 @@ export type TraceEvent = {
     firstTokenMs?: number;
     callStartedAt?: number;
     costMicroUsd?: number;
-    callCap?: number;
-    capThinkingSkipped?: boolean;
     stopReason?: string;
     ts: number;
 } | {

package/dist/core/types.d.ts

@@ -98,6 +98,10 @@ export interface ToolExecuteContext {
     model?: Model;
     thinkingLevel?: ThinkingLevel;
     principal?: string;
+    onAsk?: import("./tool-policy.js").OnAsk;
+    onQuestion?: import("./ask-question.js").OnQuestion;
+    handsReadOnly?: true;
+    interactiveTools?: false;
     oneShot?: boolean;
     clientContext?: TaskSpec["clientContext"];
     excludeTools?: readonly string[];
@@ -116,6 +120,7 @@ export interface ToolExecuteContext {
         scope: string;
         ttlMs?: number;
     };
+    checkpointStoreDisabledForChildren?: true;
     taskId?: string;
     sessionId?: string;
     backgroundScope?: "task" | "session";
@@ -317,7 +322,7 @@ export interface TaskSpec {
     resilience?: ResilienceOptions;
     finalVerification?: boolean;
     maxSuspends?: number;
-    checkpointStore?: import("./checkpoint-store.js").CheckpointStore;
+    checkpointStore?: import("./checkpoint-store.js").CheckpointStore | null;
     handsReadOnly?: boolean;
     additionalDirectories?: string[];
     enablePlanMode?: boolean;
@@ -410,6 +415,7 @@ export interface TaskResult {
     remoteEnvFailures?: RemoteEnvFailureNote[];
     errorMessage?: string;
     errorCode?: string;
+    retryAfterMs?: number;
     degraded?: {
         from: string;
         to: string;
@@ -523,6 +529,7 @@ export type TaskEvent = ({
     isError: boolean;
     output?: unknown;
     structured?: unknown;
+    errorCode?: string;
     truncated?: boolean;
     totalChars?: number;
 } & TaskEventIdentity) | ({

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

@@ -50,6 +50,7 @@ export declare class AgentHarness<TSkill extends Skill = Skill, TPromptTemplate
     private maxOutputTokens?;
     private maxOutputTokensPerCall?;
     private stallTimeoutsPerCall?;
+    private abortResultDetails?;
     private loopTrace?;
     private resilience?;
     private maxToolConcurrency?;

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

@@ -186,6 +186,7 @@ export class AgentHarness {
     maxOutputTokens;
     maxOutputTokensPerCall;
     stallTimeoutsPerCall;
+    abortResultDetails;
     loopTrace;
     resilience;
     maxToolConcurrency;
@@ -216,6 +217,7 @@ export class AgentHarness {
         this.maxOutputTokens = options.maxOutputTokens;
         this.maxOutputTokensPerCall = options.maxOutputTokensPerCall;
         this.stallTimeoutsPerCall = options.stallTimeoutsPerCall;
+        this.abortResultDetails = options.abortResultDetails;
         this.loopTrace = options.loopTrace;
         this.resilience = options.resilience;
         this.maxToolConcurrency = options.maxToolConcurrency;
@@ -440,6 +442,7 @@ export class AgentHarness {
             ...(this.maxOutputTokens !== undefined ? { maxTokens: this.maxOutputTokens } : {}),
             ...(this.maxOutputTokensPerCall !== undefined ? { maxTokensPerCall: this.maxOutputTokensPerCall } : {}),
             ...(this.stallTimeoutsPerCall !== undefined ? { stallTimeoutsPerCall: this.stallTimeoutsPerCall } : {}),
+            ...(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

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

@@ -542,6 +542,7 @@ export interface AgentHarnessOptions<TSkill extends Skill = Skill, TPromptTempla
     maxOutputTokens?: number;
     maxOutputTokensPerCall?: () => number | undefined;
     stallTimeoutsPerCall?: () => import("../llm/types.js").StallTimeouts | undefined;
+    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

@@ -68,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";
@@ -99,7 +93,6 @@ export interface ToolCall {
     id: string;
     name: string;
     arguments: Record<string, unknown>;
-    thoughtSignature?: string;
     executionMode?: "sequential" | "parallel";
 }
 export interface Usage {
@@ -259,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";
@@ -288,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;
@@ -357,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.js

@@ -208,6 +208,7 @@ async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
     finally {
         await executor.settle();
     }
+    raiseFatalCancellation(executor);
     {
         if (ptl) {
             const detect = ptlDetect;
@@ -245,6 +246,7 @@ async function runSingleTurn(state, signal, emit, streamFn, runtime, trace) {
                 finally {
                     await executor.settle();
                 }
+                raiseFatalCancellation(executor);
             }
         }
     }
@@ -495,8 +497,7 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
             };
         }
         else {
-            const executed = await executePreparedToolCall(preparation, signal, emit);
-            finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, preparation, executed, config, signal);
+            finalized = await executePreparedWithDisclosure(currentContext, assistantMessage, preparation, config, signal, emit);
         }
         await emitToolExecutionEnd(finalized, emit);
         const toolResultMessage = createToolResultMessage(finalized);
@@ -559,15 +560,25 @@ function resolveToolConcurrency(configured) {
 }
 async function runCapped(thunks, limit) {
     const results = new Array(thunks.length);
+    const failures = new Array(thunks.length);
     let next = 0;
     const width = Number.isFinite(limit) ? Math.max(1, Math.min(limit, thunks.length)) : 1;
     const workers = Array.from({ length: width }, async () => {
         while (next < thunks.length) {
             const i = next++;
-            results[i] = await thunks[i]();
+            try {
+                results[i] = await thunks[i]();
+            }
+            catch (error) {
+                failures[i] = { error };
+            }
         }
     });
     await Promise.all(workers);
+    const firstFailure = failures.find((failure) => failure !== undefined);
+    if (firstFailure !== undefined) {
+        throw firstFailure.error;
+    }
     return results;
 }
 async function executeToolCallsPartitioned(currentContext, assistantMessage, toolCalls, config, signal, emit, executor) {
@@ -625,8 +636,11 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     return { messages, terminate: shouldTerminateToolBatch(allFinalized) };
     async function settleBatch(entries, concurrent) {
         const runOne = (entry) => async () => {
-            const executed = await executePreparedToolCall(entry.prepared, signal, emit);
-            const finalized = await finalizeExecutedToolCall(currentContext, assistantMessage, entry.prepared, executed, config, signal);
+            const prepared = entry.prepared;
+            if (!prepared) {
+                throw new Error(`tool call ${entry.toolCall.id} reached execution without a preparation`);
+            }
+            const finalized = await executePreparedWithDisclosure(currentContext, assistantMessage, prepared, config, signal, emit);
             await emitToolExecutionEnd(finalized, emit);
             return finalized;
         };
@@ -662,6 +676,7 @@ class StreamToolExecutor {
     admittedOrder = [];
     barrier = false;
     inFlight = 0;
+    fatalCancellation;
     constructor(context, config, signal, emit) {
         this.context = context;
         this.config = config;
@@ -707,9 +722,11 @@ class StreamToolExecutor {
                 return;
             }
             entry.prepared = preparation;
-            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit);
+            entry.executed = await executePreparedToolCall(preparation, this.signal, this.emit, this.config.abortResultDetails, (error) => this.retainCancellation(error));
         }
         catch (error) {
+            if (isAbortSemanticsError(error))
+                this.retainCancellation(error);
             entry.immediate = {
                 kind: "immediate",
                 result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
@@ -724,6 +741,15 @@ class StreamToolExecutor {
         this.barrier = true;
         await Promise.all([...this.entries.values()].map((e) => e.promise));
     }
+    retainCancellation(error) {
+        this.fatalCancellation ??= error;
+        this.barrier = true;
+    }
+    takeFatalCancellation() {
+        const cancellation = this.fatalCancellation;
+        this.fatalCancellation = undefined;
+        return cancellation;
+    }
     take(id) {
         const entry = this.entries.get(id);
         if (entry)
@@ -829,7 +855,7 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
             if (signal?.aborted) {
                 return {
                     kind: "immediate",
-                    result: createErrorToolResult("Operation aborted"),
+                    result: createErrorToolResult("Operation aborted", { details: safeAbortDetails(config.abortResultDetails) }),
                     isError: true,
                 };
             }
@@ -869,44 +895,134 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
         };
     }
 }
-async function executePreparedToolCall(prepared, signal, emit) {
+async function executePreparedToolCall(prepared, signal, emit, abortResultDetails, onLateCancellation) {
     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: safeAbortDetails(abortResultDetails) }), isError: true };
     }
     const work = (async () => {
+        let outcome;
         try {
             const result = await prepared.tool.execute(prepared.toolCall.id, prepared.args, signal, (partialResult) => {
                 if (!acceptingUpdates) {
                     return;
                 }
-                updateEvents.push(Promise.resolve(emit({
-                    type: "tool_execution_update",
-                    toolCallId: prepared.toolCall.id,
-                    toolName: prepared.toolCall.name,
-                    args: prepared.toolCall.arguments,
-                    partialResult,
-                })));
+                let delivery;
+                try {
+                    delivery = Promise.resolve(emit({
+                        type: "tool_execution_update",
+                        toolCallId: prepared.toolCall.id,
+                        toolName: prepared.toolCall.name,
+                        args: prepared.toolCall.arguments,
+                        partialResult,
+                    }));
+                }
+                catch (error) {
+                    delivery = Promise.reject(error);
+                }
+                void delivery.catch((reason) => {
+                    if (isAbortSemanticsError(reason))
+                        onLateCancellation?.(reason);
+                });
+                updateEvents.push(delivery);
             });
-            acceptingUpdates = false;
-            await Promise.all(updateEvents);
-            return { result, isError: result.isError === true };
+            outcome = { result, isError: result.isError === true };
         }
         catch (error) {
-            acceptingUpdates = false;
-            await Promise.all(updateEvents);
-            return {
+            outcome = {
                 result: createErrorToolResult(error instanceof Error ? error.message : String(error), error),
                 isError: true,
             };
         }
+        acceptingUpdates = false;
+        const deliveryFailure = await settleUpdateDeliveries(updateEvents);
+        if (!deliveryFailure)
+            return outcome;
+        const reason = deliveryFailure.reason;
+        const details = annotateDeliveryFailure(outcome.result, {
+            message: reason instanceof Error ? reason.message : String(reason),
+        });
+        return details === UNANNOTATED ? outcome : { result: { ...outcome.result, details }, isError: outcome.isError };
     })();
     return work;
 }
+const TOOL_PROGRESS_DELIVERY_FAILED = "toolProgressDeliveryFailed";
+const UNANNOTATED = Symbol("unannotated");
+function annotateDeliveryFailure(result, mark) {
+    try {
+        const raw = result.details;
+        const prior = raw === undefined ? {} : raw;
+        const proto = prior === null || typeof prior !== "object" ? undefined : Object.getPrototypeOf(prior);
+        if (proto !== Object.prototype && proto !== null)
+            return UNANNOTATED;
+        const details = { ...prior };
+        if (TOOL_PROGRESS_DELIVERY_FAILED in details)
+            return UNANNOTATED;
+        details[TOOL_PROGRESS_DELIVERY_FAILED] = mark;
+        return details;
+    }
+    catch {
+        return UNANNOTATED;
+    }
+}
+function readDeliveryFailureMark(details) {
+    try {
+        if (details === null || typeof details !== "object")
+            return undefined;
+        const mark = details[TOOL_PROGRESS_DELIVERY_FAILED];
+        return mark;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function settleUpdateDeliveries(updateEvents) {
+    if (updateEvents.length === 0)
+        return undefined;
+    let reportFailure;
+    const firstFailure = new Promise((resolve) => {
+        reportFailure = resolve;
+    });
+    for (const delivery of updateEvents) {
+        void delivery.catch((reason) => reportFailure({ reason }));
+    }
+    const allSettled = Promise.allSettled(updateEvents).then((entries) => {
+        for (const entry of entries) {
+            if (entry.status === "rejected")
+                return { reason: entry.reason };
+        }
+        return undefined;
+    });
+    const failure = await Promise.race([firstFailure, allSettled]);
+    if (failure && isAbortSemanticsError(failure.reason))
+        throw failure.reason;
+    return failure;
+}
+function raiseFatalCancellation(executor) {
+    const cancellation = executor.takeFatalCancellation();
+    if (cancellation !== undefined)
+        throw cancellation;
+}
+async function executePreparedWithDisclosure(currentContext, assistantMessage, prepared, config, signal, emit) {
+    let executed;
+    try {
+        executed = await executePreparedToolCall(prepared, signal, emit, config.abortResultDetails);
+    }
+    catch (error) {
+        if (isAbortSemanticsError(error))
+            throw error;
+        executed = {
+            result: createErrorToolResult(`[tool execution harness failed: ${error instanceof Error ? error.message : String(error)}]`, error),
+            isError: true,
+        };
+    }
+    return finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal);
+}
 async function finalizeExecutedToolCall(currentContext, assistantMessage, prepared, executed, config, signal) {
     let result = executed.result;
     let isError = executed.isError;
+    const deliveryMark = readDeliveryFailureMark(executed.result.details);
     if (config.afterToolCall) {
         try {
             const afterResult = await config.afterToolCall({
@@ -930,6 +1046,11 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
             const note = `[post-tool processing failed (the tool already executed): ${error instanceof Error ? error.message : String(error)}]`;
             result = { ...result, content: [...result.content, { type: "text", text: note }] };
         }
+        if (deliveryMark !== undefined && readDeliveryFailureMark(result.details) === undefined) {
+            const details = annotateDeliveryFailure(result, deliveryMark);
+            if (details !== UNANNOTATED)
+                result = { ...result, details };
+        }
     }
     return {
         toolCall: prepared.toolCall,
@@ -937,6 +1058,31 @@ async function finalizeExecutedToolCall(currentContext, assistantMessage, prepar
         isError,
     };
 }
+function safeAbortDetails(fn) {
+    try {
+        return fn?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+function isAbortSemanticsError(error) {
+    try {
+        let cursor = error;
+        for (let depth = 0; depth < 8 && cursor instanceof Error; depth++) {
+            if (cursor.name === "AbortError")
+                return true;
+            const next = cursor.cause;
+            if (next === cursor)
+                break;
+            cursor = next;
+        }
+    }
+    catch {
+        return false;
+    }
+    return false;
+}
 function createErrorToolResult(message, source) {
     let details = {};
     if (source !== null && typeof source === "object") {

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

@@ -85,6 +85,7 @@ export interface AgentLoopConfig extends SimpleStreamOptions {
     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";