@rowan-agent/agent 0.10.0 → 0.10.2

package/dist/index.d.ts

@@ -55,78 +55,6 @@ type ToolResult = {
     error?: string;
 };
 
-interface BeforePhaseEvent {
-    type: "before_phase";
-    phaseId: string;
-    input: PhaseContext;
-}
-interface AfterPhaseEvent {
-    type: "after_phase";
-    phaseId: string;
-    output: PhaseOutput;
-}
-interface BeforePromptEvent {
-    type: "before_prompt";
-    phaseId: string;
-    input: PhaseContext;
-}
-interface BeforeToolCallEvent {
-    type: "before_tool_call";
-    tool: Tool$1;
-    args: unknown;
-}
-interface AfterToolCallEvent {
-    type: "after_tool_call";
-    tool: Tool$1;
-    result: ToolResult;
-}
-type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
-interface BeforePhaseResult {
-    abort?: Outcome$1;
-    skip?: {
-        route: string;
-        message: string;
-    };
-    input?: PhaseContext;
-}
-interface AfterPhaseResult {
-    abort?: Outcome$1;
-    retry?: PhaseContext;
-    output?: PhaseOutput;
-}
-interface BeforePromptResult {
-    input?: PhaseContext;
-}
-interface BeforeToolCallResult {
-    allow: boolean;
-    reason?: string;
-}
-interface AfterToolCallResult {
-    result?: ToolResult;
-}
-interface HookResultMap {
-    before_phase: BeforePhaseResult | undefined;
-    after_phase: AfterPhaseResult | undefined;
-    before_prompt: BeforePromptResult | undefined;
-    before_tool_call: BeforeToolCallResult | undefined;
-    after_tool_call: AfterToolCallResult | undefined;
-}
-type HookEventType = HookEvent["type"];
-type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
-    type: K;
-}>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
-declare class HooksManager {
-    private handlers;
-    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
-    emit<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
-        type: K;
-    }>): Promise<void>;
-    emitFirst<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
-        type: K;
-    }>): Promise<HookResultMap[K] | undefined>;
-}
-
 type LoopMetrics = {
     /** Number of phase iterations executed. */
     iterations: number;
@@ -194,6 +122,8 @@ type PhaseInteractionDriver = Readonly<{
     }>): PhaseInteraction;
     pending(): readonly PhaseInteraction[];
     answers(): ReadonlyMap<string, JsonValue>;
+    checkpoint(): JsonValue | undefined;
+    clearCheckpoint(): void;
     suspend(input?: Readonly<{
         checkpoint?: JsonValue;
     }>): never;
@@ -1115,6 +1045,95 @@ interface PhaseRegistry {
     entryPhaseId: string | null;
 }
 
+type ToolCallInteractionKind = PhaseInteractionKind;
+interface ToolCallInteractionRequest$1 {
+    id?: string;
+    kind: ToolCallInteractionKind;
+    prompt: string;
+    payload?: JsonValue;
+}
+interface BeforePhaseEvent {
+    type: "before_phase";
+    phaseId: string;
+    input: PhaseContext;
+}
+interface AfterPhaseEvent {
+    type: "after_phase";
+    phaseId: string;
+    output: PhaseOutput;
+}
+interface BeforePromptEvent {
+    type: "before_prompt";
+    phaseId: string;
+    input: PhaseContext;
+}
+interface BeforeToolCallEvent {
+    type: "before_tool_call";
+    tool: Tool$1;
+    args: unknown;
+    readonly runId?: string;
+    readonly agentId?: string;
+    readonly toolCallId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+    readonly answer?: unknown;
+}
+interface AfterToolCallEvent {
+    type: "after_tool_call";
+    tool: Tool$1;
+    result: ToolResult;
+    readonly runId?: string;
+    readonly agentId?: string;
+    readonly toolCallId?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+type HookEvent = BeforePhaseEvent | AfterPhaseEvent | BeforePromptEvent | BeforeToolCallEvent | AfterToolCallEvent;
+interface BeforePhaseResult {
+    abort?: Outcome$1;
+    skip?: {
+        route: string;
+        message: string;
+    };
+    input?: PhaseContext;
+}
+interface AfterPhaseResult {
+    abort?: Outcome$1;
+    retry?: PhaseContext;
+    output?: PhaseOutput;
+}
+interface BeforePromptResult {
+    input?: PhaseContext;
+}
+interface BeforeToolCallResult {
+    allow?: boolean;
+    reason?: string;
+    interaction?: ToolCallInteractionRequest$1;
+}
+interface AfterToolCallResult {
+    result?: ToolResult;
+}
+interface HookResultMap {
+    before_phase: BeforePhaseResult | undefined;
+    after_phase: AfterPhaseResult | undefined;
+    before_prompt: BeforePromptResult | undefined;
+    before_tool_call: BeforeToolCallResult | undefined;
+    after_tool_call: AfterToolCallResult | undefined;
+}
+type HookEventType = HookEvent["type"];
+type HookHandler<K extends HookEventType> = (event: Extract<HookEvent, {
+    type: K;
+}>) => HookResultMap[K] | Promise<HookResultMap[K]> | void | Promise<void>;
+declare class HooksManager {
+    private handlers;
+    on<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    off<K extends HookEventType>(eventType: K, handler: HookHandler<K>): void;
+    emit<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
+        type: K;
+    }>): Promise<void>;
+    emitFirst<K extends HookEventType>(eventType: K, event: Extract<HookEvent, {
+        type: K;
+    }>): Promise<HookResultMap[K] | undefined>;
+}
+
 type ToolContext = Pick<AgentContext, "skills"> & {
     toolCallId: string;
 };
@@ -1406,11 +1425,19 @@ declare class ExtensionRunner {
         output?: PhaseOutput;
     }>;
     emitBeforePrompt(phaseId: string, input: PhaseContext): Promise<PhaseContext>;
-    emitBeforeToolCall(tool: Tool$1, args: unknown): Promise<{
-        allow: boolean;
-        reason?: string;
-    }>;
-    emitAfterToolCall(tool: Tool$1, result: ToolResult): Promise<ToolResult>;
+    emitBeforeToolCall(tool: Tool$1, args: unknown, context?: {
+        runId?: string;
+        agentId?: string;
+        toolCallId?: string;
+        metadata?: Readonly<Record<string, unknown>>;
+        answer?: unknown;
+    }): Promise<BeforeToolCallResult>;
+    emitAfterToolCall(tool: Tool$1, result: ToolResult, context?: {
+        runId?: string;
+        agentId?: string;
+        toolCallId?: string;
+        metadata?: Readonly<Record<string, unknown>>;
+    }): Promise<ToolResult>;
     /**
      * Create an ExtensionAPI for a specific extension.
      * Registration methods write to the extension tracking object.
@@ -1574,22 +1601,27 @@ type ContextCandidate = Readonly<{
     name: string;
     value: JsonValue;
 }>;
-type BeforeToolCall = (input: Readonly<{
-    tool: Tool;
-    args: JsonValue;
-    context: ToolInvocationContext;
-    signal: AbortSignal;
-}>) => Readonly<{
+type ToolCallInteractionRequest = Readonly<{
+    id?: string;
+    kind: PhaseInteractionKind;
+    prompt: string;
+    payload?: JsonValue;
+}>;
+type BeforeToolCallDecision = Readonly<{
     allow: true;
 }> | Readonly<{
     allow: false;
     reason: string;
-}> | Promise<Readonly<{
-    allow: true;
 }> | Readonly<{
-    allow: false;
-    reason: string;
-}>>;
+    interaction: ToolCallInteractionRequest;
+}>;
+type BeforeToolCall = (input: Readonly<{
+    tool: Tool;
+    args: JsonValue;
+    context: ToolInvocationContext;
+    signal: AbortSignal;
+    answer?: JsonValue;
+}>) => BeforeToolCallDecision | Promise<BeforeToolCallDecision>;
 type AfterToolCall = (input: Readonly<{
     tool: Tool;
     result: ToolExecutionResult$1;
@@ -2169,7 +2201,6 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private resolveContextWindow;
     private executeTool;
     private executeToolBatch;
-    private executeReservedTool;
     private requireAgent;
     private archiveDirFor;
     private runConsumer;
@@ -2782,4 +2813,4 @@ declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): Fro
 
 declare function createCoreTools(input?: CoreToolContext): Tool[];
 
-export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInteraction, PhaseInteractionBoundary, PhaseInteractionCancelledError, type PhaseInteractionDriver, type PhaseInteractionKind, type PhaseInteractionState, type PhaseInteractionStatus, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseSettingsBadge, type PhaseSettingsContext, type PhaseSettingsControl, type PhaseSettingsDefinition, type PhaseSettingsItem, type PhaseSettingsOption, type PhaseSettingsProvider, type PhaseSettingsSection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool, type ToolCallId, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult$1 as ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };
+export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, InMemoryConfigProvider, InMemoryStore, type InputRequest, type InputRequestId, type InputRequiredCommit, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInteraction, PhaseInteractionBoundary, PhaseInteractionCancelledError, type PhaseInteractionDriver, type PhaseInteractionKind, type PhaseInteractionState, type PhaseInteractionStatus, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseSettingsBadge, type PhaseSettingsContext, type PhaseSettingsControl, type PhaseSettingsDefinition, type PhaseSettingsItem, type PhaseSettingsOption, type PhaseSettingsProvider, type PhaseSettingsSection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEvent, type RunFailure, type RunId, type RunListCursor, type RunRecord, type RunSnapshot, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool, type ToolCallId, type ToolCallInteractionRequest, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult$1 as ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolProgress, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhaseSettings, loadPhases, loadSkill, loadSkills, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };

package/dist/index.js

@@ -518,15 +518,32 @@ async function executeRuntimeToolCall(input) {
   let decision;
   if (input.beforeToolCall) {
     await input.observe?.({ type: "approval_requested", tool, args });
-    decision = await input.beforeToolCall({ tool, args });
-    await input.observe?.({
-      type: "approval_result",
+    decision = await input.beforeToolCall({
       tool,
       args,
-      decision: decision ?? { allow: true }
+      toolCallId: input.toolCall.id
     });
+    if (decision && "allow" in decision) {
+      await input.observe?.({
+        type: "approval_result",
+        tool,
+        args,
+        decision
+      });
+    }
   }
-  if (decision && !decision.allow) {
+  if (decision && "interaction" in decision) {
+    const result = toolResult({
+      context: input.toolContext,
+      toolName: tool.name,
+      ok: false,
+      content: null,
+      error: `Tool interaction required: ${decision.interaction.prompt}`
+    });
+    await input.observe?.({ type: "tool_blocked", tool, reason: decision.interaction.prompt });
+    return result;
+  }
+  if (decision && "allow" in decision && !decision.allow) {
     const result = toolResult({
       context: input.toolContext,
       toolName: tool.name,
@@ -1377,6 +1394,13 @@ function createPhaseInteractionDriver(state, phase, signal) {
     answers() {
       return new Map(answers);
     },
+    checkpoint() {
+      return checkpoint;
+    },
+    clearCheckpoint() {
+      checkpoint = void 0;
+      sync();
+    },
     suspend(input = {}) {
       assertActive();
       const pending = this.pending();
@@ -2488,34 +2512,48 @@ async function executePhaseWithModel(ctx) {
       ...ctx.context,
       messages: ctx.messageManager.visible()
     };
-    const collected = await ctx.execution.invokeModel(roundContext);
-    output = {
-      message: collected.text,
-      phase: ctx.phase.name,
-      // A route decision sharing a model response with an ordinary Tool is
-      // rejected for this round. Keep ordinary calls visible so they can run,
-      // but do not let the route escape the error/re-decision boundary.
-      toolCalls: collected.toolCalls.some((candidate) => candidate.name === PhaseRouteTool) && collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? collected.toolCalls.filter((candidate) => candidate.name !== PhaseRouteTool) : collected.toolCalls
-    };
-    for (const toolCall of collected.toolCalls) {
-      if (toolCall.name !== PhaseRouteTool) continue;
-      const messageId = ctx.messageManager.start(
-        "tool",
-        createRouteToolResultContent(
-          toolCall,
-          collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? "Route must be called separately after ordinary tools finish; this route decision was ignored." : void 0
-        ),
-        {
-          phase: ctx.phase.name
-        }
+    let executableToolCalls;
+    const checkpoint = ctx.execution.interaction.checkpoint();
+    if (checkpoint && typeof checkpoint === "object" && checkpoint.kind === "tool_call_suspension") {
+      const toolSuspension = checkpoint;
+      executableToolCalls = toolSuspension.toolCalls.filter(
+        (toolCall) => executableToolNames.has(toolCall.name)
       );
-      await ctx.messageManager.end(messageId);
-    }
-    const executableToolCalls = collected.toolCalls.filter(
-      (toolCall) => executableToolNames.has(toolCall.name)
-    );
-    if (executableToolCalls.length === 0) {
-      return output;
+      output = {
+        message: "",
+        phase: ctx.phase.name,
+        toolCalls: [...toolSuspension.toolCalls]
+      };
+    } else {
+      const collected = await ctx.execution.invokeModel(roundContext);
+      output = {
+        message: collected.text,
+        phase: ctx.phase.name,
+        // A route decision sharing a model response with an ordinary Tool is
+        // rejected for this round. Keep ordinary calls visible so they can run,
+        // but do not let the route escape the error/re-decision boundary.
+        toolCalls: collected.toolCalls.some((candidate) => candidate.name === PhaseRouteTool) && collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? collected.toolCalls.filter((candidate) => candidate.name !== PhaseRouteTool) : collected.toolCalls
+      };
+      for (const toolCall of collected.toolCalls) {
+        if (toolCall.name !== PhaseRouteTool) continue;
+        const messageId = ctx.messageManager.start(
+          "tool",
+          createRouteToolResultContent(
+            toolCall,
+            collected.toolCalls.some((candidate) => candidate.name !== PhaseRouteTool) ? "Route must be called separately after ordinary tools finish; this route decision was ignored." : void 0
+          ),
+          {
+            phase: ctx.phase.name
+          }
+        );
+        await ctx.messageManager.end(messageId);
+      }
+      executableToolCalls = collected.toolCalls.filter(
+        (toolCall) => executableToolNames.has(toolCall.name)
+      );
+      if (executableToolCalls.length === 0) {
+        return output;
+      }
     }
     const results = await ctx.execution.executeTools(roundContext, executableToolCalls);
     for (const result of results) {
@@ -2991,7 +3029,8 @@ async function executeToolCall(input) {
   if (input.config.runtime?.tools) {
     result = await input.config.runtime.tools({
       config: input.config,
-      toolCall: input.toolCall
+      toolCall: input.toolCall,
+      driver: input.driver
     });
   } else {
     const toolContext = {
@@ -3017,7 +3056,8 @@ async function executeToolCalls(input) {
   if (input.config.runtime?.toolsBatch) {
     const results2 = await input.config.runtime.toolsBatch({
       config: input.config,
-      toolCalls: input.toolCalls
+      toolCalls: input.toolCalls,
+      driver: input.driver
     });
     if (results2.length !== input.toolCalls.length) throw new Error("Runtime returned an invalid Tool batch result");
     return results2.map((result, index) => ({
@@ -3115,7 +3155,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
             }
           },
           tools,
-          toolCall
+          toolCall,
+          driver: interaction
         });
         await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
         return result;
@@ -3137,7 +3178,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
             }
           },
           tools,
-          toolCalls
+          toolCalls,
+          driver: interaction
         });
         for (const result of results) {
           await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
@@ -3447,9 +3489,9 @@ var THINKING_LEVELS = [
 ];
 function thinkingLevelFromMetadata(metadata) {
   const record = isRecord3(metadata) ? metadata : void 0;
-  const everyield = record?.everyield;
-  if (!isRecord3(everyield)) return void 0;
-  const level = everyield.thinkingLevel;
+  const mori = record?.mori;
+  if (!isRecord3(mori)) return void 0;
+  const level = mori.thinkingLevel;
   return typeof level === "string" && THINKING_LEVELS.includes(level) ? level : void 0;
 }
 function thinkingLevelFromMessages(messages) {
@@ -4222,12 +4264,30 @@ function assembleRegisteredExtensions(snapshot, runner, options = {}) {
     beforePrompt: (phaseId, input) => runner.emitBeforePrompt(phaseId, input),
     beforeToolCall: async (input) => {
       const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
-      const decision = await runner.emitBeforeToolCall(tool, input.args);
+      const decision = await runner.emitBeforeToolCall(tool, input.args, {
+        runId: input.context.runId,
+        agentId: input.context.agentId,
+        toolCallId: input.context.toolCallId,
+        metadata: input.context.runMetadata,
+        answer: input.answer
+      });
+      if (decision.interaction !== void 0) {
+        return { interaction: decision.interaction };
+      }
       return decision.allow ? { allow: true } : { allow: false, reason: decision.reason ?? "Extension hook rejected the Tool." };
     },
     afterToolCall: async (input) => {
       const tool = projectTool(input.tool, input.context.agentId, input.context.runId);
-      const result = await runner.emitAfterToolCall(tool, toLoopResult(input.result, input.context.toolCallId, input.tool.name));
+      const result = await runner.emitAfterToolCall(
+        tool,
+        toLoopResult(input.result, input.context.toolCallId, input.tool.name),
+        {
+          runId: input.context.runId,
+          agentId: input.context.agentId,
+          toolCallId: input.context.toolCallId,
+          metadata: input.context.runMetadata
+        }
+      );
       return fromLoopResult(result);
     },
     setContext: (context2) => {
@@ -4873,19 +4933,28 @@ var ExtensionRunner = class {
     });
     return result?.input ?? input;
   }
-  async emitBeforeToolCall(tool, args) {
+  async emitBeforeToolCall(tool, args, context) {
     const result = await this.emitHook("before_tool_call", {
       type: "before_tool_call",
       tool,
-      args
+      args,
+      ...context?.runId !== void 0 ? { runId: context.runId } : {},
+      ...context?.agentId !== void 0 ? { agentId: context.agentId } : {},
+      ...context?.toolCallId !== void 0 ? { toolCallId: context.toolCallId } : {},
+      ...context?.metadata !== void 0 ? { metadata: context.metadata } : {},
+      ...context?.answer !== void 0 ? { answer: context.answer } : {}
     });
     return result ?? { allow: true };
   }
-  async emitAfterToolCall(tool, result) {
+  async emitAfterToolCall(tool, result, context) {
     const hookResult = await this.emitHook("after_tool_call", {
       type: "after_tool_call",
       tool,
-      result
+      result,
+      ...context?.runId !== void 0 ? { runId: context.runId } : {},
+      ...context?.agentId !== void 0 ? { agentId: context.agentId } : {},
+      ...context?.toolCallId !== void 0 ? { toolCallId: context.toolCallId } : {},
+      ...context?.metadata !== void 0 ? { metadata: context.metadata } : {}
     });
     return hookResult?.result ?? result;
   }
@@ -6235,7 +6304,7 @@ var AgentRuntime = class _AgentRuntime {
         },
         onContext: assembly.setContext,
         runtime: {
-          tools: ({ toolCall }) => {
+          tools: ({ toolCall, driver }) => {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
@@ -6244,7 +6313,11 @@ var AgentRuntime = class _AgentRuntime {
                 expectedRevision: executionRevision,
                 toolConfig: executionTools,
                 toolCalls: [toolCall],
-                signal: controller.signal
+                signal: controller.signal,
+                driver,
+                onRevision: (rev) => {
+                  executionRevision = rev;
+                }
               });
               executionRevision = execution.revision;
               return execution.results[0];
@@ -6252,7 +6325,7 @@ var AgentRuntime = class _AgentRuntime {
             toolQueue = task.then(() => void 0, () => void 0);
             return task;
           },
-          toolsBatch: ({ toolCalls }) => {
+          toolsBatch: ({ toolCalls, driver }) => {
             const task = toolQueue.then(async () => {
               const execution = await this.executeToolBatch({
                 run,
@@ -6261,7 +6334,11 @@ var AgentRuntime = class _AgentRuntime {
                 expectedRevision: executionRevision,
                 toolConfig: executionTools,
                 toolCalls,
-                signal: controller.signal
+                signal: controller.signal,
+                driver,
+                onRevision: (rev) => {
+                  executionRevision = rev;
+                }
               });
               executionRevision = execution.revision;
               return execution.results;
@@ -6303,7 +6380,7 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "input_required") {
-        const output = latestAssistant(
+        const output = result.interactions && result.interactions.length > 0 ? void 0 : latestAssistant(
           run,
           result.messages.slice(modelMessages.length),
           modelMessages.length
@@ -6387,109 +6464,419 @@ var AgentRuntime = class _AgentRuntime {
     return { result: batch.results[0], revision: batch.revision };
   }
   async executeToolBatch(input) {
-    const reserved = await this.owned.reserveToolCalls({
-      runId: input.run.id,
-      execution: input.execution,
-      expectedRevision: input.expectedRevision,
-      requestMessageId: createId("msg"),
-      calls: input.toolCalls.map((toolCall) => ({
-        providerToolCallId: toolCall.id,
-        name: toolCall.name,
-        args: toJsonValue(toolCall.args)
-      }))
-    });
-    let revision = reserved.run.revision;
-    const results = [];
-    for (let index = 0; index < input.toolCalls.length; index += 1) {
-      const toolCall = input.toolCalls[index];
-      const tool = reserved.toolCalls[index];
-      const execution = await this.executeReservedTool({
-        ...input,
-        toolCall,
-        tool,
-        expectedRevision: revision
-      });
-      revision = execution.revision;
-      results.push(execution.result);
-    }
-    return { results, revision };
-  }
-  async executeReservedTool(input) {
-    const durableTool = input.toolConfig.tools.find((candidate) => candidate.name === input.toolCall.name);
-    const providerToolCallId = input.toolCall.id;
-    const toolCallId = input.tool.id;
+    const checkpoint = input.driver?.checkpoint();
+    const isSuspensionResume = checkpoint && typeof checkpoint === "object" && checkpoint.kind === "tool_call_suspension";
+    const suspension = isSuspensionResume ? checkpoint : void 0;
     let revision = input.expectedRevision;
-    const protocolFailure = (error) => ({ toolCallId: providerToolCallId, toolName: input.toolCall.name, ok: false, content: null, error });
-    if (!durableTool) {
-      const failed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "failed", result: { ok: false, content: null, error: `Tool ${input.toolCall.name} is not available.` } });
-      return { result: protocolFailure(`Tool ${input.toolCall.name} is not available.`), revision: failed.run.revision };
-    }
-    let progressActive = false;
-    const context = {
-      agentId: input.run.agentId,
-      runId: input.run.id,
-      ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
-      ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
-      toolCallId,
-      reportProgress: (progress) => {
-        const active = this.executions.get(input.run.id);
-        if (!progressActive || this.closed || input.signal.aborted || active?.executionId !== input.execution.executionId || !isJsonValue(progress)) return;
-        let copy;
+    const setRevision = (newRevision) => {
+      revision = newRevision;
+      input.onRevision?.(revision);
+    };
+    if (!suspension && input.toolCalls.length > 1) {
+      let hasInteraction = false;
+      const preDecisions = [];
+      const toolCallIds = input.toolCalls.map(() => createId("tool"));
+      for (let i = 0; i < input.toolCalls.length; i++) {
+        const toolCall = input.toolCalls[i];
+        const durableTool = input.toolConfig.tools.find((c) => c.name === toolCall.name);
+        if (!durableTool || !input.toolConfig.beforeToolCall) {
+          preDecisions.push({ allow: true });
+          continue;
+        }
+        const toolCallId = toolCallIds[i];
+        const context = {
+          agentId: input.run.agentId,
+          runId: input.run.id,
+          ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
+          ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
+          toolCallId,
+          reportProgress: () => {
+          }
+        };
         try {
-          if (JSON.stringify(progress).length > 64 * 1024) return;
-          copy = structuredClone(progress);
+          const decision = await input.toolConfig.beforeToolCall({
+            tool: durableTool,
+            args: toJsonValue(toolCall.args),
+            context,
+            signal: input.signal
+          });
+          if ("interaction" in decision && decision.interaction !== void 0) {
+            hasInteraction = true;
+            break;
+          }
+          preDecisions.push(decision);
         } catch {
-          return;
+          preDecisions.push({ allow: true });
         }
-        this.transientEvents.publish({
-          kind: "tool_progress",
-          durability: "transient",
+      }
+      if (!hasInteraction) {
+        const reserved = await this.owned.reserveToolCalls({
           runId: input.run.id,
-          executionId: input.execution.executionId,
-          toolCallId,
-          progress: copy
+          execution: input.execution,
+          expectedRevision: revision,
+          requestMessageId: createId("msg"),
+          calls: input.toolCalls.map((tc, i) => ({
+            toolCallId: toolCallIds[i],
+            providerToolCallId: tc.id,
+            name: tc.name,
+            args: toJsonValue(tc.args)
+          }))
         });
-      }
-    };
-    try {
-      if (input.toolConfig.beforeToolCall) {
-        const decision = await input.toolConfig.beforeToolCall({ tool: durableTool, args: toJsonValue(input.toolCall.args), context, signal: input.signal });
-        if (!decision.allow) {
-          const failed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "failed", result: { ok: false, content: null, error: decision.reason } });
-          return { result: protocolFailure(decision.reason), revision: failed.run.revision };
+        setRevision(reserved.run.revision);
+        const results2 = [];
+        for (let i = 0; i < input.toolCalls.length; i++) {
+          const toolCall = input.toolCalls[i];
+          const durableTool = input.toolConfig.tools.find((c) => c.name === toolCall.name);
+          const providerToolCallId = toolCall.id;
+          const toolCallId = toolCallIds[i];
+          const protocolFailure = (error) => ({
+            toolCallId: providerToolCallId,
+            toolName: toolCall.name,
+            ok: false,
+            content: null,
+            error
+          });
+          if (!durableTool) {
+            const failed = await this.owned.commitToolResult({
+              runId: input.run.id,
+              execution: input.execution,
+              expectedRevision: revision,
+              toolCallId,
+              state: "failed",
+              result: { ok: false, content: null, error: `Tool ${toolCall.name} is not available.` }
+            });
+            setRevision(failed.run.revision);
+            results2.push(protocolFailure(`Tool ${toolCall.name} is not available.`));
+            continue;
+          }
+          const decision = preDecisions[i] ?? { allow: true };
+          if ("allow" in decision && !decision.allow) {
+            const failed = await this.owned.commitToolResult({
+              runId: input.run.id,
+              execution: input.execution,
+              expectedRevision: revision,
+              toolCallId,
+              state: "failed",
+              result: { ok: false, content: null, error: decision.reason }
+            });
+            setRevision(failed.run.revision);
+            results2.push(protocolFailure(decision.reason));
+            continue;
+          }
+          let progressActive = false;
+          const context = {
+            agentId: input.run.agentId,
+            runId: input.run.id,
+            ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
+            ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
+            toolCallId,
+            reportProgress: (progress) => {
+              const active = this.executions.get(input.run.id);
+              if (!progressActive || this.closed || input.signal.aborted || active?.executionId !== input.execution.executionId || !isJsonValue(progress)) return;
+              let copy;
+              try {
+                if (JSON.stringify(progress).length > 64 * 1024) return;
+                copy = structuredClone(progress);
+              } catch {
+                return;
+              }
+              this.transientEvents.publish({
+                kind: "tool_progress",
+                durability: "transient",
+                runId: input.run.id,
+                executionId: input.execution.executionId,
+                toolCallId,
+                progress: copy
+              });
+            }
+          };
+          const started = await this.owned.startToolCall({
+            runId: input.run.id,
+            execution: input.execution,
+            expectedRevision: revision,
+            toolCallId
+          });
+          setRevision(started.run.revision);
+          progressActive = true;
+          try {
+            let result = await durableTool.execute(toJsonValue(toolCall.args), context, input.signal);
+            assertToolExecutionResult(result);
+            if (input.toolConfig.afterToolCall) {
+              result = await input.toolConfig.afterToolCall({
+                tool: durableTool,
+                result,
+                context,
+                signal: input.signal
+              });
+            }
+            assertToolExecutionResult(result);
+            result = await spillLargeToolResult(
+              result,
+              this.archiveDirFor(input.run.agentId),
+              toolCall.name
+            );
+            const committed = await this.owned.commitToolResult({
+              runId: input.run.id,
+              execution: input.execution,
+              expectedRevision: revision,
+              toolCallId,
+              state: result.ok ? "completed" : "failed",
+              result
+            });
+            setRevision(committed.run.revision);
+            results2.push({
+              toolCallId: providerToolCallId,
+              toolName: toolCall.name,
+              ...result
+            });
+          } catch (error) {
+            const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
+            const indeterminate = await this.owned.commitToolResult({
+              runId: input.run.id,
+              execution: input.execution,
+              expectedRevision: revision,
+              toolCallId,
+              state: "indeterminate",
+              reason,
+              result: { ok: false, content: null, error: reason }
+            });
+            setRevision(indeterminate.run.revision);
+            results2.push(protocolFailure(reason));
+          } finally {
+            progressActive = false;
+            this.transientEvents.clearTool(input.run.id, toolCallId);
+          }
         }
+        return { results: results2, revision };
       }
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "Tool policy rejected the call.";
-      const failed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "failed", result: { ok: false, content: null, error: reason } });
-      return { result: protocolFailure(reason), revision: failed.run.revision };
     }
-    const started = await this.owned.startToolCall({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId });
-    revision = started.run.revision;
-    progressActive = true;
-    try {
-      let result = await durableTool.execute(toJsonValue(input.toolCall.args), context, input.signal);
-      assertToolExecutionResult(result);
-      if (input.toolConfig.afterToolCall) result = await input.toolConfig.afterToolCall({ tool: durableTool, result, context, signal: input.signal });
-      assertToolExecutionResult(result);
-      result = await spillLargeToolResult(
-        result,
-        this.archiveDirFor(input.run.agentId),
-        input.toolCall.name
-      );
-      const committed = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: result.ok ? "completed" : "failed", result });
-      return {
-        result: { toolCallId: providerToolCallId, toolName: input.toolCall.name, ...result },
-        revision: committed.run.revision
+    const results = suspension ? [...suspension.completedResults] : [];
+    const startIndex = suspension ? suspension.pendingIndex : 0;
+    for (let index = startIndex; index < input.toolCalls.length; index += 1) {
+      const toolCall = input.toolCalls[index];
+      const durableTool = input.toolConfig.tools.find((candidate) => candidate.name === toolCall.name);
+      const providerToolCallId = toolCall.id;
+      const toolCallId = suspension && index === suspension.pendingIndex && suspension.toolCallId ? suspension.toolCallId : createId("tool");
+      const protocolFailure = (error) => ({
+        toolCallId: providerToolCallId,
+        toolName: toolCall.name,
+        ok: false,
+        content: null,
+        error
+      });
+      if (!durableTool) {
+        const reserved2 = await this.owned.reserveToolCalls({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          requestMessageId: createId("msg"),
+          calls: [{
+            toolCallId,
+            providerToolCallId,
+            name: toolCall.name,
+            args: toJsonValue(toolCall.args)
+          }]
+        });
+        setRevision(reserved2.run.revision);
+        const failed = await this.owned.commitToolResult({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          toolCallId,
+          state: "failed",
+          result: { ok: false, content: null, error: `Tool ${toolCall.name} is not available.` }
+        });
+        setRevision(failed.run.revision);
+        results.push(protocolFailure(`Tool ${toolCall.name} is not available.`));
+        continue;
+      }
+      let progressActive = false;
+      const context = {
+        agentId: input.run.agentId,
+        runId: input.run.id,
+        ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
+        ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
+        toolCallId,
+        reportProgress: (progress) => {
+          const active = this.executions.get(input.run.id);
+          if (!progressActive || this.closed || input.signal.aborted || active?.executionId !== input.execution.executionId || !isJsonValue(progress)) return;
+          let copy;
+          try {
+            if (JSON.stringify(progress).length > 64 * 1024) return;
+            copy = structuredClone(progress);
+          } catch {
+            return;
+          }
+          this.transientEvents.publish({
+            kind: "tool_progress",
+            durability: "transient",
+            runId: input.run.id,
+            executionId: input.execution.executionId,
+            toolCallId,
+            progress: copy
+          });
+        }
       };
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
-      const indeterminate = await this.owned.commitToolResult({ runId: input.run.id, execution: input.execution, expectedRevision: revision, toolCallId, state: "indeterminate", reason, result: { ok: false, content: null, error: reason } });
-      return { result: protocolFailure(reason), revision: indeterminate.run.revision };
-    } finally {
-      progressActive = false;
-      this.transientEvents.clearTool(input.run.id, toolCallId);
+      const answer = suspension && index === suspension.pendingIndex && suspension.interactionId ? input.driver?.answers().get(suspension.interactionId) : void 0;
+      try {
+        if (input.toolConfig.beforeToolCall) {
+          const decision = await input.toolConfig.beforeToolCall({
+            tool: durableTool,
+            args: toJsonValue(toolCall.args),
+            context,
+            signal: input.signal,
+            answer
+          });
+          if ("interaction" in decision && decision.interaction !== void 0) {
+            if (!input.driver) {
+              throw new Error("Tool call requested interaction but no interaction driver is active.");
+            }
+            const interactionRequest = input.driver.request({
+              id: decision.interaction.id,
+              kind: decision.interaction.kind,
+              prompt: decision.interaction.prompt,
+              payload: decision.interaction.payload
+            });
+            input.driver.suspend({
+              checkpoint: {
+                kind: "tool_call_suspension",
+                toolCalls: input.toolCalls,
+                pendingIndex: index,
+                toolCallId,
+                interactionId: interactionRequest.id,
+                completedResults: results
+              }
+            });
+          }
+          if ("allow" in decision && !decision.allow) {
+            const reserved2 = await this.owned.reserveToolCalls({
+              runId: input.run.id,
+              execution: input.execution,
+              expectedRevision: revision,
+              requestMessageId: createId("msg"),
+              calls: [{
+                toolCallId,
+                providerToolCallId,
+                name: toolCall.name,
+                args: toJsonValue(toolCall.args)
+              }]
+            });
+            setRevision(reserved2.run.revision);
+            const failed = await this.owned.commitToolResult({
+              runId: input.run.id,
+              execution: input.execution,
+              expectedRevision: revision,
+              toolCallId,
+              state: "failed",
+              result: { ok: false, content: null, error: decision.reason }
+            });
+            setRevision(failed.run.revision);
+            results.push(protocolFailure(decision.reason));
+            continue;
+          }
+        }
+      } catch (error) {
+        if (error instanceof PhaseInteractionBoundary || error instanceof PhaseInteractionCancelledError) {
+          throw error;
+        }
+        const reason = error instanceof Error ? error.message : "Tool policy rejected the call.";
+        const reserved2 = await this.owned.reserveToolCalls({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          requestMessageId: createId("msg"),
+          calls: [{
+            toolCallId,
+            providerToolCallId,
+            name: toolCall.name,
+            args: toJsonValue(toolCall.args)
+          }]
+        });
+        setRevision(reserved2.run.revision);
+        const failed = await this.owned.commitToolResult({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          toolCallId,
+          state: "failed",
+          result: { ok: false, content: null, error: reason }
+        });
+        setRevision(failed.run.revision);
+        results.push(protocolFailure(reason));
+        continue;
+      }
+      const reserved = await this.owned.reserveToolCalls({
+        runId: input.run.id,
+        execution: input.execution,
+        expectedRevision: revision,
+        requestMessageId: createId("msg"),
+        calls: [{
+          toolCallId,
+          providerToolCallId,
+          name: toolCall.name,
+          args: toJsonValue(toolCall.args)
+        }]
+      });
+      setRevision(reserved.run.revision);
+      const started = await this.owned.startToolCall({
+        runId: input.run.id,
+        execution: input.execution,
+        expectedRevision: revision,
+        toolCallId
+      });
+      setRevision(started.run.revision);
+      progressActive = true;
+      try {
+        let result = await durableTool.execute(toJsonValue(toolCall.args), context, input.signal);
+        assertToolExecutionResult(result);
+        if (input.toolConfig.afterToolCall) {
+          result = await input.toolConfig.afterToolCall({
+            tool: durableTool,
+            result,
+            context,
+            signal: input.signal
+          });
+        }
+        assertToolExecutionResult(result);
+        result = await spillLargeToolResult(
+          result,
+          this.archiveDirFor(input.run.agentId),
+          toolCall.name
+        );
+        const committed = await this.owned.commitToolResult({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          toolCallId,
+          state: result.ok ? "completed" : "failed",
+          result
+        });
+        setRevision(committed.run.revision);
+        results.push({
+          toolCallId: providerToolCallId,
+          toolName: toolCall.name,
+          ...result
+        });
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
+        const indeterminate = await this.owned.commitToolResult({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          toolCallId,
+          state: "indeterminate",
+          reason,
+          result: { ok: false, content: null, error: reason }
+        });
+        setRevision(indeterminate.run.revision);
+        results.push(protocolFailure(reason));
+      } finally {
+        progressActive = false;
+        this.transientEvents.clearTool(input.run.id, toolCallId);
+      }
     }
+    input.driver?.clearCheckpoint();
+    return { results, revision };
   }
   async requireAgent(agentId) {
     const agent = (await this.owned.listAgents()).find((candidate) => candidate.id === agentId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rowan-agent/agent",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "license": "MIT",
   "repository": {
     "type": "git",