@rowan-agent/agent 0.10.1 → 0.11.0

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 && "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 && !decision.allow) {
+  if (decision && "allow" in decision && !decision.allow) {
     const result = toolResult({
       context: input.toolContext,
       toolName: tool.name,
@@ -660,7 +677,18 @@ function createReadTool(context) {
           error: invalidLimit
         });
       }
-      const fileStat = await stat(resolved.absolutePath);
+      let fileStat;
+      try {
+        fileStat = await stat(resolved.absolutePath);
+      } catch (error) {
+        return toolResult({
+          context: toolContext,
+          toolName: "read",
+          ok: false,
+          content: null,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
       if (!fileStat.isFile()) {
         return toolResult({
           context: toolContext,
@@ -670,7 +698,18 @@ function createReadTool(context) {
           error: `Not a file: ${resolved.relativePath}`
         });
       }
-      const bytes = await readFile2(resolved.absolutePath);
+      let bytes;
+      try {
+        bytes = await readFile2(resolved.absolutePath);
+      } catch (error) {
+        return toolResult({
+          context: toolContext,
+          toolName: "read",
+          ok: false,
+          content: null,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
       const source = new TextDecoder().decode(bytes);
       const sourceLines = source.split(/\r\n|\n|\r/);
       const requestedOffset = parsed.offset ?? 1;
@@ -1363,6 +1402,8 @@ function createPhaseInteractionDriver(state, phase, signal) {
         kind: input.kind,
         prompt: input.prompt,
         ...input.payload === void 0 ? {} : { payload: input.payload },
+        ...input.origin === void 0 ? {} : { origin: input.origin },
+        ...input.toolCallId === void 0 ? {} : { toolCallId: input.toolCallId },
         createdAt: createTimestamp(),
         status: "pending"
       };
@@ -1377,6 +1418,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 +2536,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 +3053,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 +3080,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 +3179,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 +3202,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);
@@ -4222,12 +4288,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 +4957,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 +6328,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 +6337,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 +6349,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 +6358,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,19 +6404,20 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "input_required") {
-        const output = latestAssistant(
+        const isToolCallInteraction = result.interactions?.some((i) => i.origin === "tool_call");
+        const output = result.interactions && result.interactions.length > 0 ? void 0 : latestAssistant(
           run,
           result.messages.slice(modelMessages.length),
           modelMessages.length
         );
-        const prompt = output ?? promptMessage(run, result.request.prompt, result.messages.length);
+        const prompt = isToolCallInteraction ? void 0 : output ?? promptMessage(run, result.request.prompt, result.messages.length);
         await this.owned.commitInputRequired({
           runId: run.id,
           execution: claim.execution,
           expectedRevision: executionRevision,
           requestId: createId("input"),
           phase: result.request.phase,
-          prompt,
+          ...prompt ? { prompt } : {},
           checkpoint: result.checkpoint,
           interactions: result.interactions,
           interactionAnswers: claim.run.interactionAnswers
@@ -6387,109 +6489,421 @@ 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,
+              origin: "tool_call",
+              toolCallId
+            });
+            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);
@@ -6668,7 +7082,7 @@ function boundaryFromSnapshot(snapshot) {
         type: "input_required",
         requestId: snapshot.request.id,
         phase: snapshot.request.phase,
-        prompt: snapshot.request.prompt,
+        ...snapshot.request.prompt ? { prompt: snapshot.request.prompt } : {},
         interactions: snapshot.interactions,
         answers: snapshot.answers
       };
@@ -7243,24 +7657,28 @@ var InMemoryStore = class _InMemoryStore {
     const requestId = input.requestId ?? createId("input");
     const operationKey = `input_required:${requestId}`;
     const interactions = input.interactions ?? [];
-    const operationPayload = canonicalJson([input.runId, input.expectedRevision, input.phase, input.prompt.id, input.checkpoint, interactions, input.interactionAnswers ?? null]);
+    const operationPayload = canonicalJson([input.runId, input.expectedRevision, input.phase, input.prompt ? input.prompt.id : null, input.checkpoint, interactions, input.interactionAnswers ?? null]);
     const replay = this.replayOperation(operationKey, operationPayload);
     if (replay) return clone(replay);
     const run = this.requireRun(input.runId);
     this.assertExecution(run, input.execution, input.expectedRevision);
     this.assertState(run, ["running"]);
     this.assertNoOpenTools(run);
-    const prompt = {
-      ...clone(input.prompt),
-      sequenceWithinRun: this.nextMessageSequence(run.id)
-    };
+    const isToolCallInteraction = interactions.length > 0 && interactions.some((interaction) => interaction.origin === "tool_call");
+    let prompt;
+    if (input.prompt && !isToolCallInteraction) {
+      prompt = {
+        ...clone(input.prompt),
+        sequenceWithinRun: this.nextMessageSequence(run.id)
+      };
+      this.messages.set(prompt.id, prompt);
+    }
     const request = {
       id: requestId,
       phase: input.phase,
-      messageId: prompt.id,
+      ...prompt ? { messageId: prompt.id } : {},
       createdAt: createTimestamp()
     };
-    this.messages.set(prompt.id, prompt);
     run.state = "input_required";
     run.checkpoint = clone(input.checkpoint);
     run.openInputRequest = request;
@@ -7275,9 +7693,16 @@ var InMemoryStore = class _InMemoryStore {
     delete run.execution;
     run.revision += 1;
     run.updatedAt = createTimestamp();
-    this.appendMessage(run, prompt);
+    if (prompt) {
+      this.appendMessage(run, prompt);
+    }
     this.appendTransition(run, "running", "input_required", request, prompt, void 0, void 0, void 0, interactions, run.interactionAnswers ?? {});
-    const result = { run: clone(run), prompt: clone(prompt), request: clone(request), interactions: clone(interactions) };
+    const result = {
+      run: clone(run),
+      ...prompt ? { prompt: clone(prompt) } : {},
+      request: clone(request),
+      interactions: clone(interactions)
+    };
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
@@ -7330,28 +7755,33 @@ var InMemoryStore = class _InMemoryStore {
     this.assertRevision(run, input.expectedRevision);
     this.assertState(run, ["input_required"]);
     const openInteractions = run.openInteractions ?? [];
-    if (!openInteractions.some((interaction) => interaction.id === input.interactionId)) {
+    const targetInteraction = openInteractions.find((interaction) => interaction.id === input.interactionId);
+    if (!targetInteraction) {
       throw new RuntimeError("input_request_conflict", { runId: run.id, requestId: input.interactionId, reason: "not_found" });
     }
-    const message = {
-      id: createId("msg"),
-      agentId: run.agentId,
-      runId: run.id,
-      role: "user",
-      content: typeof input.input === "string" ? input.input : JSON.stringify(input.input),
-      metadata: { kind: "phase_interaction", interactionId: input.interactionId },
-      sequenceWithinRun: this.nextMessageSequence(run.id),
-      createdAt: createTimestamp()
-    };
-    this.messages.set(message.id, message);
+    const isToolCall = targetInteraction.origin === "tool_call";
+    const now = createTimestamp();
+    if (!isToolCall) {
+      const message = {
+        id: createId("msg"),
+        agentId: run.agentId,
+        runId: run.id,
+        role: "user",
+        content: typeof input.input === "string" ? input.input : JSON.stringify(input.input),
+        metadata: { kind: "phase_interaction", interactionId: input.interactionId },
+        sequenceWithinRun: this.nextMessageSequence(run.id),
+        createdAt: now
+      };
+      this.messages.set(message.id, message);
+      this.appendMessage(run, message);
+    }
     run.openInteractions = openInteractions.filter((interaction) => interaction.id !== input.interactionId);
     run.interactionAnswers = {
       ...run.interactionAnswers ?? {},
       [input.interactionId]: clone(input.input)
     };
     run.revision += 1;
-    run.updatedAt = message.createdAt;
-    this.appendMessage(run, message);
+    run.updatedAt = now;
     if (run.openInteractions.length === 0) {
       delete run.openInteractions;
       delete run.openInputRequest;
@@ -7652,12 +8082,16 @@ var InMemoryStore = class _InMemoryStore {
         return { ...base, state: run.state };
       case "input_required": {
         const request = run.openInputRequest;
-        const prompt = request && this.messages.get(request.messageId);
-        if (!prompt || prompt.role !== "assistant") throw new Error(`Run ${run.id} has an invalid input prompt.`);
+        const prompt = request?.messageId ? this.messages.get(request.messageId) : void 0;
+        if (request?.messageId && (!prompt || prompt.role !== "assistant")) throw new Error(`Run ${run.id} has an invalid input prompt.`);
         return {
           ...base,
           state: "input_required",
-          request: { id: request.id, phase: request.phase, prompt: clone(prompt) },
+          request: {
+            id: request?.id ?? "",
+            phase: request?.phase ?? "",
+            ...prompt ? { prompt: clone(prompt) } : {}
+          },
           interactions: clone(run.openInteractions ?? []),
           answers: clone(run.interactionAnswers ?? {})
         };
@@ -7979,7 +8413,13 @@ ${record.summary}`,
       kind: "run_state_changed",
       from,
       to,
-      ...to === "input_required" && request && prompt ? { request: { id: request.id, phase: request.phase, prompt } } : {},
+      ...to === "input_required" && request ? {
+        request: {
+          id: request.id,
+          phase: request.phase,
+          ...prompt ? { prompt } : {}
+        }
+      } : {},
       ...to === "input_required" ? { interactions: clone(interactions ?? []), answers: clone(answers ?? {}) } : {},
       ...to === "completed" && outcome ? { outcome } : {},
       ...to === "failed" && failure ? { failure } : {},