@sema-agent/core 5.50.0 → 5.51.0

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

@@ -490,12 +490,14 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         });
         const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
         let finalized;
+        let halt;
         if (preparation.kind === "immediate") {
             finalized = {
                 toolCall,
                 result: preparation.result,
                 isError: preparation.isError,
             };
+            halt = preparation.halt;
         }
         else {
             finalized = await executePreparedWithDisclosure(currentContext, assistantMessage, preparation, config, signal, emit);
@@ -505,6 +507,16 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         await emitToolResultMessage(toolResultMessage, emit);
         finalizedCalls.push(finalized);
         messages.push(toolResultMessage);
+        if (halt !== undefined) {
+            for (const remaining of toolCalls.slice(i + 1)) {
+                if (signal?.aborted)
+                    break;
+                const settled = await settleHaltedToolCall(remaining, halt, emit);
+                finalizedCalls.push(settled.finalized);
+                messages.push(settled.message);
+            }
+            return { messages, terminate: true };
+        }
         if (signal?.aborted) {
             break;
         }
@@ -514,6 +526,33 @@ async function executeToolCallsSequential(currentContext, assistantMessage, tool
         terminate: shouldTerminateToolBatch(finalizedCalls),
     };
 }
+async function settleHaltedToolCall(toolCall, halt, emit) {
+    await emit({
+        type: "tool_execution_start",
+        toolCallId: toolCall.id,
+        toolName: toolCall.name,
+        args: toolCall.arguments,
+    });
+    const finalized = {
+        toolCall,
+        result: {
+            content: [{ type: "text", text: truncateError(halt.reason) }],
+            details: halt.details !== undefined ? { ...halt.details } : {},
+        },
+        isError: true,
+    };
+    await emit({
+        type: "tool_execution_end",
+        toolCallId: finalized.toolCall.id,
+        toolName: finalized.toolCall.name,
+        result: finalized.result,
+        isError: true,
+        notExecuted: true,
+    });
+    const message = createToolResultMessage(finalized);
+    await emitToolResultMessage(message, emit);
+    return { finalized, message };
+}
 function isCallConcurrencySafe(tool, args) {
     if (!tool)
         return false;
@@ -587,6 +626,7 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
     const allFinalized = [];
     const messages = [];
     const remainingCalls = [];
+    let halt;
     for (const toolCall of toolCalls) {
         const held = executor?.take(toolCall.id);
         if (!held) {
@@ -599,6 +639,8 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
         await emitToolResultMessage(toolResultMessage, emit);
         allFinalized.push(finalized);
         messages.push(toolResultMessage);
+        if (held.immediate?.halt !== undefined)
+            halt ??= held.immediate.halt;
     }
     if (executor) {
         for (const orphan of executor.remaining()) {
@@ -606,33 +648,54 @@ async function executeToolCallsPartitioned(currentContext, assistantMessage, too
             await closeOrphanedStreamEntry(orphan, emit);
         }
     }
-    const batches = partitionToolCalls(remainingCalls, currentContext.tools);
-    outer: for (const batch of batches) {
-        if (signal?.aborted)
-            break;
-        const entries = [];
-        for (const toolCall of batch.calls) {
-            await emit({
-                type: "tool_execution_start",
-                toolCallId: toolCall.id,
-                toolName: toolCall.name,
-                args: toolCall.arguments,
-            });
-            const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
-            if (preparation.kind === "immediate") {
-                const finalized = { toolCall, result: preparation.result, isError: preparation.isError };
-                await emitToolExecutionEnd(finalized, emit);
-                entries.push({ finalized, toolCall });
-            }
-            else {
-                entries.push({ prepared: preparation, toolCall });
-            }
-            if (signal?.aborted) {
-                await settleBatch(entries, true);
-                break outer;
+    if (halt === undefined) {
+        const batches = partitionToolCalls(remainingCalls, currentContext.tools);
+        outer: for (const batch of batches) {
+            if (signal?.aborted)
+                break;
+            const entries = [];
+            for (const toolCall of batch.calls) {
+                await emit({
+                    type: "tool_execution_start",
+                    toolCallId: toolCall.id,
+                    toolName: toolCall.name,
+                    args: toolCall.arguments,
+                });
+                const preparation = await prepareToolCall(currentContext, assistantMessage, toolCall, config, signal);
+                if (preparation.kind === "immediate") {
+                    const finalized = { toolCall, result: preparation.result, isError: preparation.isError };
+                    await emitToolExecutionEnd(finalized, emit);
+                    entries.push({ finalized, toolCall });
+                    if (preparation.halt !== undefined) {
+                        halt = preparation.halt;
+                        break;
+                    }
+                }
+                else {
+                    entries.push({ prepared: preparation, toolCall });
+                }
+                if (signal?.aborted) {
+                    await settleBatch(entries, true);
+                    break outer;
+                }
             }
+            await settleBatch(entries, batch.safe);
+            if (halt !== undefined)
+                break;
         }
-        await settleBatch(entries, batch.safe);
+    }
+    if (halt !== undefined && !signal?.aborted) {
+        const settledIds = new Set(messages.map((m) => m.toolCallId));
+        for (const toolCall of toolCalls) {
+            if (settledIds.has(toolCall.id))
+                continue;
+            if (signal?.aborted)
+                break;
+            const settled = await settleHaltedToolCall(toolCall, halt, emit);
+            allFinalized.push(settled.finalized);
+            messages.push(settled.message);
+        }
+        return { messages, terminate: true };
     }
     return { messages, terminate: shouldTerminateToolBatch(allFinalized) };
     async function settleBatch(entries, concurrent) {
@@ -720,6 +783,8 @@ class StreamToolExecutor {
             const preparation = await prepareToolCall(this.context, partialAssistant, entry.toolCall, this.config, this.signal);
             if (preparation.kind === "immediate") {
                 entry.immediate = preparation;
+                if (preparation.halt !== undefined)
+                    this.barrier = true;
                 return;
             }
             entry.prepared = preparation;
@@ -873,11 +938,11 @@ async function prepareToolCall(currentContext, assistantMessage, toolCall, confi
                 };
             }
             if (beforeResult?.block) {
-                return {
-                    kind: "immediate",
-                    result: createErrorToolResult(beforeResult.reason || "Tool execution was blocked"),
-                    isError: true,
-                };
+                const blocked = createErrorToolResult(beforeResult.reason || "Tool execution was blocked");
+                if (beforeResult.haltRemaining !== undefined) {
+                    return { kind: "immediate", result: blocked, isError: true, halt: beforeResult.haltRemaining };
+                }
+                return { kind: "immediate", result: blocked, isError: true };
             }
             if (beforeResult?.updatedInput !== undefined) {
                 finalArgs = validateToolArguments(tool, {

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

@@ -48,11 +48,34 @@ export type AgentToolCall = Extract<AssistantMessage["content"][number], {
  *
  * Keep in sync with the harness hook result `ToolCallResult` (harness/types.ts), which the harness's
  * `beforeToolCall` callback returns verbatim.
+ *
+ * `haltRemaining` (additive) makes the block a CONTROL-FLOW BOUNDARY for the whole assistant batch:
+ * honored only beside `block: true`, it tells the loop that every tool call of the same assistant
+ * message whose preparation had not yet begun must NOT begin — each settles as an error tool result
+ * built from the directive (so the transcript still answers every tool call), and the batch votes
+ * terminate (the loop starts no further assistant turn; queued follow-up/steering messages still
+ * run — they are the input the boundary is waiting for). Calls already executing when the block
+ * lands run to completion and settle with their real outcomes; preparation/adjudication is strictly
+ * source-ordered in every lane, so "not yet begun" is exactly "after the blocked call". The loop
+ * stays policy-agnostic: WHY a block halts the batch (e.g. a person's bare rejection) is entirely
+ * the gate owner's judgment, made once, at the site that returns this.
  */
 export interface BeforeToolCallResult {
     block?: boolean;
     reason?: string;
     updatedInput?: unknown;
+    haltRemaining?: HaltRemainingDirective;
+}
+/**
+ * The settlement {@link BeforeToolCallResult.haltRemaining} instructs the loop to apply to each
+ * same-batch tool call that never started: `reason` is the model-facing error text (bounded by the
+ * loop's standard error truncator), `details` is attached to each settled result verbatim (shallow-
+ * copied per call) so a machine-readable mark (e.g. `{ code }`) reaches every not-executed sibling's
+ * end frame and transcript entry.
+ */
+export interface HaltRemainingDirective {
+    reason: string;
+    details?: Record<string, unknown>;
 }
 /**
  * Partial override returned from `afterToolCall`.
@@ -629,4 +652,13 @@ export type AgentEvent = {
     toolName: string;
     result: unknown;
     isError: boolean;
+    /**
+     * Present (`true`) exactly when this end frame closes a call the loop settled WITHOUT
+     * executing it — a never-started sibling under a batch-halt directive (see
+     * {@link BeforeToolCallResult.haltRemaining}). LOOP-AUTHORED: it rides the event, never the
+     * tool result, so a tool cannot claim it about itself; a consumer that scopes
+     * post-execution machinery to executed calls (batch observers, execution audits) keys on
+     * this the way it keys on its own blocked-call records. Absent on every executed call.
+     */
+    notExecuted?: true;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sema-agent/core",
-  "version": "5.50.0",
+  "version": "5.51.0",
   "description": "Stateless, task-oriented AI agent core",
   "type": "module",
   "license": "BUSL-1.1",