@rowan-agent/agent 0.12.1 → 0.13.1

package/dist/index.js

@@ -1326,25 +1326,25 @@ function createExtensionAPI(hooks, options, runtime, eventBus) {
 }
 
 // src/harness/phases/interactions.ts
-var PhaseInteractionCancelledError = class extends Error {
-  code = "phase_interaction_cancelled";
+var RunInteractionCancelledError = class extends Error {
+  code = "run_interaction_cancelled";
   constructor() {
-    super("Phase interaction work was cancelled.");
-    this.name = "PhaseInteractionCancelledError";
+    super("Run interaction work was cancelled.");
+    this.name = "RunInteractionCancelledError";
   }
 };
-var PhaseInteractionBoundary = class extends Error {
+var RunInteractionBoundary = class extends Error {
   constructor(state, interactions) {
-    super("Phase interactions require host input.");
+    super("Run interactions require host input.");
     this.state = state;
     this.interactions = interactions;
-    this.name = "PhaseInteractionBoundary";
+    this.name = "RunInteractionBoundary";
   }
   state;
   interactions;
 };
-function createPhaseInteractionDriver(state, phase, signal) {
-  const stored = state.phaseInteractions;
+function createRunInteractionDriver(state, phase, signal) {
+  const stored = state.runInteractions ?? state.phaseInteractions;
   const requests = new Map(
     stored?.requests.map((request) => [request.id, { ...request }]) ?? []
   );
@@ -1360,10 +1360,10 @@ function createPhaseInteractionDriver(state, phase, signal) {
     ...checkpoint === void 0 ? {} : { checkpoint }
   });
   const sync = () => {
-    state.phaseInteractions = snapshot();
+    state.runInteractions = snapshot();
   };
   const assertActive = () => {
-    if (signal?.aborted) throw new PhaseInteractionCancelledError();
+    if (signal?.aborted) throw new RunInteractionCancelledError();
   };
   const matchingStoredRequest = (input) => {
     const fingerprint = interactionFingerprint(input);
@@ -1374,21 +1374,21 @@ function createPhaseInteractionDriver(state, phase, signal) {
     request(input) {
       assertActive();
       if (input.id !== void 0 && input.id.trim().length === 0) {
-        throw new TypeError("Phase interaction id must be non-empty.");
+        throw new TypeError("Run interaction id must be non-empty.");
       }
       if (input.prompt.trim().length === 0) {
-        throw new TypeError("Phase interaction prompt must be non-empty.");
+        throw new TypeError("Run interaction prompt must be non-empty.");
       }
-      if (!PHASE_INTERACTION_KINDS.includes(input.kind)) {
-        throw new TypeError(`Unsupported Phase interaction kind: ${String(input.kind)}.`);
+      if (!RUN_INTERACTION_KINDS.includes(input.kind)) {
+        throw new TypeError(`Unsupported Run interaction kind: ${String(input.kind)}.`);
       }
-      if (input.payload !== void 0) assertJsonValue(input.payload, "Phase interaction payload");
+      if (input.payload !== void 0) assertJsonValue(input.payload, "Run interaction payload");
       const matched = input.id === void 0 ? matchingStoredRequest(input) : void 0;
       const id = input.id ?? matched?.id ?? createId("interaction");
       const existing = requests.get(id);
       if (existing) {
         if (interactionFingerprint(existing) !== interactionFingerprint(input)) {
-          throw new Error(`Phase interaction ${id} was requested with different metadata.`);
+          throw new Error(`Run interaction ${id} was requested with different metadata.`);
         }
         usedRequestIds.add(id);
         return {
@@ -1402,8 +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 },
+        ...input.result === void 0 ? {} : { result: input.result },
         createdAt: createTimestamp(),
         status: "pending"
       };
@@ -1428,15 +1428,15 @@ function createPhaseInteractionDriver(state, phase, signal) {
     suspend(input = {}) {
       assertActive();
       const pending = this.pending();
-      if (pending.length === 0) throw new Error("Cannot suspend without pending Phase interactions.");
+      if (pending.length === 0) throw new Error("Cannot suspend without pending Run interactions.");
       if (input.checkpoint !== void 0) checkpoint = input.checkpoint;
       state.status = "suspended";
       sync();
-      throw new PhaseInteractionBoundary(state, pending);
+      throw new RunInteractionBoundary(state, pending);
     }
   };
 }
-var PHASE_INTERACTION_KINDS = [
+var RUN_INTERACTION_KINDS = [
   "user_input",
   "permission",
   "elicitation",
@@ -2697,6 +2697,7 @@ async function runPhaseLoop(config, state, registry) {
     }
     state.attempt++;
     state.metrics.iterations++;
+    await config.onPhaseEntered?.(currentPhaseId);
     const phase = registry.phases.get(currentPhaseId);
     if (!phase) {
       throw new Error(`Phase "${currentPhaseId}" not found`);
@@ -3097,7 +3098,7 @@ async function executeToolCalls(input) {
   return results;
 }
 function createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry) {
-  const interaction = createPhaseInteractionDriver(state, phase.name, config.signal);
+  const interaction = createRunInteractionDriver(state, phase.name, config.signal);
   return {
     interaction,
     messages: messageManager,
@@ -3324,12 +3325,13 @@ function encodeExecutionCheckpoint(state) {
     ...state.continuation.pendingInstruction !== void 0 ? { pendingInstruction: state.continuation.pendingInstruction } : {},
     ...state.continuation.previousPhaseMessageId !== void 0 ? { previousPhaseMessageId: state.continuation.previousPhaseMessageId } : {}
   } : void 0;
+  const runInteractions = state.runInteractions ?? state.phaseInteractions;
   const data = {
     currentPhase: state.currentPhase,
     attempt: state.attempt,
     metrics,
     ...continuation ? { continuation } : {},
-    ...state.phaseInteractions === void 0 ? {} : { phaseInteractions: state.phaseInteractions }
+    ...runInteractions === void 0 ? {} : { runInteractions }
   };
   assertJsonValue(data, "execution checkpoint");
   return {
@@ -3347,6 +3349,7 @@ function decodeExecutionCheckpoint(checkpoint) {
   if (!isCheckpointData(checkpoint.data)) {
     throw new ExecutionCheckpointError("Execution checkpoint payload is invalid.");
   }
+  const restoredInteractions = checkpoint.data.runInteractions ?? checkpoint.data.phaseInteractions;
   return {
     currentPhase: checkpoint.data.currentPhase,
     attempt: checkpoint.data.attempt,
@@ -3361,11 +3364,11 @@ function decodeExecutionCheckpoint(checkpoint) {
         previousResults: checkpoint.data.continuation.previousResults.map((result) => ({ ...result }))
       }
     } : {},
-    ...checkpoint.data.phaseInteractions ? {
-      phaseInteractions: {
-        requests: checkpoint.data.phaseInteractions.requests.map((request) => ({ ...request })),
-        answers: { ...checkpoint.data.phaseInteractions.answers },
-        ...checkpoint.data.phaseInteractions.checkpoint === void 0 ? {} : { checkpoint: checkpoint.data.phaseInteractions.checkpoint }
+    ...restoredInteractions ? {
+      runInteractions: {
+        requests: restoredInteractions.requests.map((request) => ({ ...request })),
+        answers: { ...restoredInteractions.answers },
+        ...restoredInteractions.checkpoint === void 0 ? {} : { checkpoint: restoredInteractions.checkpoint }
       }
     } : {}
   };
@@ -3393,13 +3396,14 @@ async function executeOnce(input) {
     metrics: createMetrics()
   };
   if (input.interactionAnswers) {
-    state.phaseInteractions = {
-      requests: state.phaseInteractions?.requests ?? [],
+    const existing = state.runInteractions ?? state.phaseInteractions;
+    state.runInteractions = {
+      requests: existing?.requests ?? [],
       answers: {
-        ...state.phaseInteractions?.answers ?? {},
+        ...existing?.answers ?? {},
         ...input.interactionAnswers
       },
-      ...state.phaseInteractions?.checkpoint === void 0 ? {} : { checkpoint: state.phaseInteractions.checkpoint }
+      ...existing?.checkpoint === void 0 ? {} : { checkpoint: existing.checkpoint }
     };
   }
   const config = {
@@ -3420,6 +3424,7 @@ async function executeOnce(input) {
     onThinkingDelta: input.onThinkingDelta,
     onOutcome: input.onOutcome,
     onModelTranscript: input.onModelTranscript,
+    onPhaseEntered: input.onPhaseEntered,
     onPhaseStatus: input.onPhaseStatus,
     runtime: input.runtime,
     waitForInput: async (nextState, request) => {
@@ -3436,22 +3441,24 @@ async function executeOnce(input) {
     };
   } catch (error) {
     if (error instanceof InputRequiredBoundary) {
+      const interaction = {
+        id: createId("input"),
+        kind: "user_input",
+        phase: error.request.phase,
+        prompt: error.request.prompt,
+        status: "pending",
+        createdAt: error.request.requestedAt
+      };
       return {
         type: "input_required",
-        request: error.request,
-        interactions: [],
+        interactions: [interaction],
         checkpoint: encodeExecutionCheckpoint(error.state),
         messages: snapshotMessages(context.messages)
       };
     }
-    if (error instanceof PhaseInteractionBoundary) {
+    if (error instanceof RunInteractionBoundary) {
       return {
         type: "input_required",
-        request: {
-          phase: error.interactions[0]?.phase ?? state.currentPhase,
-          prompt: error.interactions.map((interaction) => interaction.prompt).join("\n"),
-          requestedAt: error.interactions[0]?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-        },
         interactions: error.interactions,
         checkpoint: encodeExecutionCheckpoint(error.state),
         messages: snapshotMessages(context.messages)
@@ -3482,14 +3489,15 @@ function isCheckpointData(value) {
   if (!isRecord2(value) || typeof value.currentPhase !== "string" || !Number.isInteger(value.attempt)) return false;
   if (!isMetrics(value.metrics)) return false;
   if (value.continuation !== void 0 && !isContinuation(value.continuation)) return false;
-  if (value.phaseInteractions !== void 0 && !isPhaseInteractionState(value.phaseInteractions)) return false;
+  if (value.runInteractions !== void 0 && !isRunInteractionState(value.runInteractions)) return false;
+  if (value.phaseInteractions !== void 0 && !isRunInteractionState(value.phaseInteractions)) return false;
   return true;
 }
-function isPhaseInteractionState(value) {
+function isRunInteractionState(value) {
   if (!isRecord2(value) || !Array.isArray(value.requests) || !isRecord2(value.answers)) return false;
   if (!Object.values(value.answers).every((answer) => isJsonValue(answer))) return false;
   if (value.checkpoint !== void 0 && !isJsonValue(value.checkpoint)) return false;
-  return value.requests.every((request) => isRecord2(request) && typeof request.id === "string" && typeof request.phase === "string" && ["user_input", "permission", "elicitation", "confirmation"].includes(request.kind) && typeof request.prompt === "string" && typeof request.createdAt === "string" && ["pending", "answered", "denied", "cancelled", "expired"].includes(request.status) && (request.payload === void 0 || isJsonValue(request.payload)));
+  return value.requests.every((request) => isRecord2(request) && typeof request.id === "string" && typeof request.phase === "string" && ["user_input", "permission", "elicitation", "confirmation"].includes(request.kind) && typeof request.prompt === "string" && typeof request.createdAt === "string" && ["pending", "answered", "replied", "cancelled"].includes(request.status) && (request.payload === void 0 || isJsonValue(request.payload)) && (request.result === void 0 || isRecord2(request.result)) && (request.answer === void 0 || isJsonValue(request.answer)) && (request.reply === void 0 || typeof request.reply === "string"));
 }
 function isMetrics(value) {
   if (!isRecord2(value)) return false;
@@ -4180,10 +4188,71 @@ function invalidCursor(cursorType, reason) {
 }
 
 // src/runtime/model-context.ts
+var DEFAULT_INTERACTION_TEMPLATES = {
+  user_input: {
+    answered: 'The user answered "{{prompt}}": {{answer}}',
+    replied: "The user replied instead: {{reply}}",
+    cancelled: "The user cancelled input: {{prompt}}"
+  },
+  permission: {
+    answered: "The user granted permission: {{prompt}}",
+    replied: "The user replied instead: {{reply}}",
+    cancelled: "The user did not grant permission: {{prompt}}"
+  },
+  elicitation: {
+    answered: 'The user answered "{{prompt}}": {{answer}}',
+    replied: "The user replied instead: {{reply}}",
+    cancelled: "The user cancelled elicitation: {{prompt}}"
+  },
+  confirmation: {
+    answered: "The user confirmed: {{prompt}}",
+    replied: "The user replied instead: {{reply}}",
+    cancelled: "The user cancelled: {{prompt}}"
+  }
+};
+function renderInteractionText(record) {
+  const template = record.result?.[record.status] ?? DEFAULT_INTERACTION_TEMPLATES[record.kind]?.[record.status] ?? "{{prompt}}";
+  const answerStr = typeof record.answer === "string" ? record.answer : record.answer !== void 0 ? JSON.stringify(record.answer) : "";
+  const replyStr = record.reply ?? "";
+  return template.replaceAll("{{prompt}}", record.prompt).replaceAll("{{answer}}", answerStr).replaceAll("{{reply}}", replyStr);
+}
 function projectModelContext(input) {
+  const toolInteractionTexts = /* @__PURE__ */ new Map();
+  for (const message of input.messages) {
+    if (message.role === "interaction" && message.toolCallId !== void 0) {
+      const text = renderInteractionText(message);
+      const existing = toolInteractionTexts.get(String(message.toolCallId));
+      if (existing) {
+        existing.push(text);
+      } else {
+        toolInteractionTexts.set(String(message.toolCallId), [text]);
+      }
+    }
+  }
+  const projectedMessages = [];
+  for (const message of input.messages) {
+    if (message.role === "interaction") {
+      if (message.toolCallId !== void 0) {
+        continue;
+      }
+      projectedMessages.push({
+        id: message.id,
+        role: "user",
+        content: renderInteractionText(message),
+        createdAt: message.createdAt,
+        ...message.metadata ? { metadata: message.metadata } : {}
+      });
+      continue;
+    }
+    if (message.role === "tool") {
+      projectedMessages.push(projectToolMessage(message, toolInteractionTexts));
+      continue;
+    }
+    projectedMessages.push(projectMessage(message));
+  }
   return {
     systemPrompt: input.context.systemPrompt,
-    messages: input.messages.map(projectMessage),
+    messages: projectedMessages,
     tools: input.context.tools.map((tool) => projectTool(tool, input.agentId, input.runId)),
     skills: [...input.context.skills],
     ...input.context.phases ? { phases: input.context.phases } : {}
@@ -4214,8 +4283,35 @@ function projectMessage(message) {
       return { id: message.id, role: message.role, content: projectAssistantContent(message.content), createdAt: message.createdAt, ...message.metadata ? { metadata: message.metadata } : {} };
     case "tool":
       return { id: message.id, role: message.role, content: projectToolContent(message.content), createdAt: message.createdAt, ...message.metadata ? { metadata: message.metadata } : {} };
+    case "interaction":
+      return { id: message.id, role: "user", content: renderInteractionText(message), createdAt: message.createdAt, ...message.metadata ? { metadata: message.metadata } : {} };
   }
 }
+function projectToolMessage(message, toolInteractionTexts) {
+  return {
+    id: message.id,
+    role: message.role,
+    content: message.content.map((part) => {
+      const rawResult = jsonText(part.result.content);
+      const interactionTexts = toolInteractionTexts.get(String(part.toolCallId));
+      let content = rawResult;
+      if (interactionTexts && interactionTexts.length > 0) {
+        const prefix = interactionTexts.join("\n\n");
+        content = rawResult === "null" || rawResult.length === 0 ? prefix : `${prefix}
+
+${rawResult}`;
+      }
+      return {
+        type: "tool_result",
+        toolUseId: part.providerToolCallId ?? String(part.toolCallId),
+        content,
+        ...part.result.ok ? {} : { isError: true }
+      };
+    }),
+    createdAt: message.createdAt,
+    ...message.metadata ? { metadata: message.metadata } : {}
+  };
+}
 function durableAssistantContent(content) {
   if (typeof content === "string") return content;
   const projected = [];
@@ -4248,6 +4344,25 @@ function projectToolContent(content) {
     ...part.result.ok ? {} : { isError: true }
   }));
 }
+function inertRunInteraction(signal) {
+  const controller = signal ? void 0 : new AbortController();
+  const state = {
+    currentPhase: "default",
+    attempt: 0,
+    status: "running",
+    metrics: { iterations: 0, phaseTransitions: [], compactionCount: 0, retryCount: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), startedAtMs: Date.now() }
+  };
+  const driver = createRunInteractionDriver(state, "default", signal ?? controller.signal);
+  return {
+    ...driver,
+    request: () => {
+      throw new Error("Run interactions require an active interaction driver.");
+    },
+    suspend: () => {
+      throw new Error("Run interactions require an active interaction driver.");
+    }
+  };
+}
 function projectTool(tool, agentId, runId) {
   return {
     name: tool.name,
@@ -4259,7 +4374,8 @@ function projectTool(tool, agentId, runId) {
         agentId,
         runId,
         toolCallId: context.toolCallId,
-        reportProgress: () => void 0
+        reportProgress: () => void 0,
+        interaction: context.interaction ?? inertRunInteraction(signal)
       }, signal ?? new AbortController().signal);
       return { toolCallId: context.toolCallId, toolName: tool.name, ...result };
     }
@@ -5817,7 +5933,7 @@ function adaptExtensionTool(input) {
     description: definition.description,
     parameters: definition.parameters,
     execute: async (args, context, signal) => {
-      const result = await definition.execute(args, signal);
+      const result = await definition.execute(args, context, signal);
       const content = JSON.parse(JSON.stringify(result.content));
       return result.isError ? { ok: false, content, error: "Extension Tool failed." } : { ok: true, content };
     }
@@ -5832,6 +5948,46 @@ var RUN_STATE_CHECK_INTERVAL_MS = 1e3;
 var OWNER_LEASE_MS = 3e4;
 var OWNER_RENEWAL_MS = 1e4;
 var MAX_INLINE_TOOL_RESULT_BYTES = 16 * 1024;
+function createToolInteractionDriver(driver, input) {
+  const requestedIds = /* @__PURE__ */ new Set();
+  const stored = driver.checkpoint();
+  const checkpointRecord = stored && typeof stored === "object" && !Array.isArray(stored) ? stored : void 0;
+  const resumed = checkpointRecord?.kind === "tool_call_suspension" && checkpointRecord.toolCallId === input.toolCallId ? checkpointRecord : void 0;
+  return {
+    signal: driver.signal,
+    request(request) {
+      const interaction = driver.request({ ...request, toolCallId: input.toolCallId });
+      requestedIds.add(interaction.id);
+      return interaction;
+    },
+    pending: () => driver.pending(),
+    answers: () => driver.answers(),
+    checkpoint: () => resumed ? resumed.toolCheckpoint : stored,
+    clearCheckpoint: () => driver.clearCheckpoint(),
+    suspend(options = {}) {
+      const interactionIds = [.../* @__PURE__ */ new Set([
+        ...requestedIds,
+        ...driver.pending().filter((interaction) => interaction.toolCallId === input.toolCallId).map(({ id }) => id)
+      ])];
+      const pendingToolCallIds = [...new Set([
+        ...input.toolCallIds ?? [],
+        ...input.toolCalls.slice(0, input.pendingIndex + 1).map((_, index) => index === input.pendingIndex ? input.toolCallId : void 0)
+      ].filter((id) => id !== void 0))];
+      driver.suspend({
+        checkpoint: {
+          kind: "tool_call_suspension",
+          toolCalls: input.toolCalls,
+          pendingIndex: input.pendingIndex,
+          toolCallId: input.toolCallId,
+          toolCallIds: pendingToolCallIds,
+          interactionIds,
+          ...options.checkpoint === void 0 ? {} : { toolCheckpoint: options.checkpoint },
+          completedResults: input.completedResults
+        }
+      });
+    }
+  };
+}
 async function spillLargeToolResult(result, archiveDir, toolName) {
   if (!archiveDir) return result;
   const serialized = typeof result.content === "string" ? result.content : JSON.stringify(result.content, null, 2);
@@ -6090,22 +6246,13 @@ var AgentRuntime = class _AgentRuntime {
     this.assertOpen();
     return this.owned.history(agentId);
   }
-  async respond(runId, input) {
-    this.assertOpen();
-    const snapshot = await this.owned.snapshotRun(runId);
-    if (snapshot.state !== "input_required" || snapshot.request.id !== input.requestId) {
-      throw new RuntimeError("input_request_conflict", { runId, requestId: input.requestId, reason: "not_found" });
-    }
-    await this.owned.answerInput({ runId, requestId: input.requestId, expectedRevision: snapshot.revision, input: input.input });
-    void this.pump();
-  }
   async respondInteraction(runId, input) {
     this.assertOpen();
     const snapshot = await this.owned.snapshotRun(runId);
     if (snapshot.state !== "input_required" || !snapshot.interactions.some((interaction) => interaction.id === input.interactionId)) {
-      throw new RuntimeError("input_request_conflict", { runId, requestId: input.interactionId, reason: "not_found" });
+      throw new RuntimeError("input_request_conflict", { runId, interactionId: input.interactionId, reason: "not_found" });
     }
-    await this.owned.answerInteraction({ runId, interactionId: input.interactionId, expectedRevision: snapshot.revision, input: input.input });
+    await this.owned.answerInteraction({ runId, interactionId: input.interactionId, expectedRevision: snapshot.revision, input: input.input, cancel: input.cancel });
     void this.pump();
   }
   async cancel(runId, reason) {
@@ -6266,6 +6413,7 @@ var AgentRuntime = class _AgentRuntime {
         beforeToolCall: assembly.beforeToolCall,
         afterToolCall: assembly.afterToolCall
       };
+      let phaseVisit = (await this.owned.listEvents()).filter((event) => event.runId === run.id && event.kind === "phase_entered").length;
       const executeModel = (context) => executeOnce({
         canonicalMessages: context.messages,
         context,
@@ -6287,6 +6435,18 @@ var AgentRuntime = class _AgentRuntime {
         beforePhase: assembly.beforePhase,
         afterPhase: assembly.afterPhase,
         beforePrompt: assembly.beforePrompt,
+        onPhaseEntered: async (phaseId) => {
+          const active = this.executions.get(run.id);
+          if (active?.executionId !== claim.execution.executionId) return;
+          const entered = await this.owned.commitPhaseEntered({
+            runId: run.id,
+            execution: claim.execution,
+            expectedRevision: executionRevision,
+            phaseId,
+            visit: ++phaseVisit
+          });
+          executionRevision = entered.revision;
+        },
         onPhaseStatus: (phaseId, status) => {
           const active = this.executions.get(run.id);
           if (active?.executionId !== claim.execution.executionId) return;
@@ -6404,23 +6564,30 @@ var AgentRuntime = class _AgentRuntime {
         return;
       }
       if (result.type === "input_required") {
-        const isToolCallInteraction = result.interactions?.some((i) => i.origin === "tool_call");
-        const output = result.interactions && result.interactions.length > 0 ? void 0 : latestAssistant(
+        const resultData = result.checkpoint.data && typeof result.checkpoint.data === "object" && !Array.isArray(result.checkpoint.data) ? result.checkpoint.data : void 0;
+        const interactionData = resultData?.runInteractions && typeof resultData.runInteractions === "object" && !Array.isArray(resultData.runInteractions) ? resultData.runInteractions : void 0;
+        const interactionCheckpoint = interactionData?.checkpoint && typeof interactionData.checkpoint === "object" && !Array.isArray(interactionData.checkpoint) ? interactionData.checkpoint : void 0;
+        let pendingToolCallIds = Array.isArray(interactionCheckpoint?.toolCallIds) ? interactionCheckpoint.toolCallIds : [];
+        if (pendingToolCallIds.length === 0 && result.interactions.length > 0 && result.interactions.every(({ toolCallId }) => toolCallId !== void 0)) {
+          pendingToolCallIds = result.interactions.map(({ toolCallId }) => toolCallId);
+        }
+        const isToolCallInteraction = result.interactions?.some((i) => i.toolCallId !== void 0);
+        const output = isToolCallInteraction ? void 0 : latestAssistant(
           run,
           result.messages.slice(modelMessages.length),
           modelMessages.length
         );
-        const prompt = isToolCallInteraction ? void 0 : output ?? promptMessage(run, result.request.prompt, result.messages.length);
+        const prompt = isToolCallInteraction ? void 0 : output ?? (result.interactions[0]?.prompt ? promptMessage(run, result.interactions[0].prompt, result.messages.length) : void 0);
         await this.owned.commitInputRequired({
           runId: run.id,
           execution: claim.execution,
           expectedRevision: executionRevision,
-          requestId: createId("input"),
-          phase: result.request.phase,
+          phase: result.interactions[0]?.phase ?? "default",
           ...prompt ? { prompt } : {},
           checkpoint: result.checkpoint,
           interactions: result.interactions,
-          interactionAnswers: claim.run.interactionAnswers
+          interactionAnswers: claim.run.interactionAnswers,
+          ...pendingToolCallIds.length === 0 ? {} : { pendingToolCallIds }
         });
         this.transientEvents.clear(run.id, claim.execution.executionId);
         return;
@@ -6515,6 +6682,12 @@ var AgentRuntime = class _AgentRuntime {
           ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
           ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
           toolCallId,
+          interaction: createRunInteractionDriver({
+            currentPhase: "default",
+            attempt: 0,
+            status: "running",
+            metrics: { iterations: 0, phaseTransitions: [], compactionCount: 0, retryCount: 0, startedAt: (/* @__PURE__ */ new Date()).toISOString(), startedAtMs: Date.now() }
+          }, "default", input.signal),
           reportProgress: () => {
           }
         };
@@ -6595,6 +6768,13 @@ var AgentRuntime = class _AgentRuntime {
             ...input.agentMetadata === void 0 ? {} : { agentMetadata: input.agentMetadata },
             ...input.run.metadata === void 0 ? {} : { runMetadata: input.run.metadata },
             toolCallId,
+            interaction: createToolInteractionDriver(input.driver, {
+              toolCallId,
+              toolCallIds,
+              toolCalls: input.toolCalls,
+              pendingIndex: i,
+              completedResults: results2
+            }),
             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;
@@ -6649,12 +6829,24 @@ var AgentRuntime = class _AgentRuntime {
               result
             });
             setRevision(committed.run.revision);
+            const projectedResult = await this.foldToolInteractionRecords(result, toolCallId, input.run.agentId);
             results2.push({
               toolCallId: providerToolCallId,
               toolName: toolCall.name,
-              ...result
+              ...projectedResult
             });
           } catch (error) {
+            if (error instanceof RunInteractionBoundary) {
+              const suspended = await this.owned.suspendToolCall({
+                runId: input.run.id,
+                execution: input.execution,
+                expectedRevision: revision,
+                toolCallId
+              });
+              setRevision(suspended.run.revision);
+              throw error;
+            }
+            if (error instanceof RunInteractionCancelledError) throw error;
             const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
             const indeterminate = await this.owned.commitToolResult({
               runId: input.run.id,
@@ -6681,7 +6873,7 @@ var AgentRuntime = class _AgentRuntime {
       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 toolCallId = suspension && index >= suspension.pendingIndex && suspension.toolCallIds?.[index] ? suspension.toolCallIds[index] : suspension && index === suspension.pendingIndex && suspension.toolCallId ? suspension.toolCallId : createId("tool");
       const protocolFailure = (error) => ({
         toolCallId: providerToolCallId,
         toolName: toolCall.name,
@@ -6716,12 +6908,26 @@ var AgentRuntime = class _AgentRuntime {
         continue;
       }
       let progressActive = false;
+      const resumedStart = suspension && index === suspension.pendingIndex ? await this.owned.startToolCall({
+        runId: input.run.id,
+        execution: input.execution,
+        expectedRevision: revision,
+        toolCallId
+      }) : void 0;
+      if (resumedStart) setRevision(resumedStart.run.revision);
       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,
+        interaction: createToolInteractionDriver(input.driver, {
+          toolCallId,
+          ...suspension?.toolCallIds === void 0 ? {} : { toolCallIds: suspension.toolCallIds },
+          toolCalls: input.toolCalls,
+          pendingIndex: index,
+          completedResults: results
+        }),
         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;
@@ -6742,7 +6948,7 @@ var AgentRuntime = class _AgentRuntime {
           });
         }
       };
-      const answer = suspension && index === suspension.pendingIndex && suspension.interactionId ? input.driver?.answers().get(suspension.interactionId) : void 0;
+      const answer = suspension && index === suspension.pendingIndex ? suspension.interactionIds?.map((id) => input.driver?.answers().get(id)).find((value) => value !== void 0) : void 0;
       try {
         if (input.toolConfig.beforeToolCall) {
           const decision = await input.toolConfig.beforeToolCall({
@@ -6756,39 +6962,30 @@ var AgentRuntime = class _AgentRuntime {
             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
-              }
-            });
+            context.interaction.request(decision.interaction);
+            if (!(suspension && index === suspension.pendingIndex)) {
+              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);
+            }
+            context.interaction.suspend();
           }
           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);
+            if (!(suspension && index === suspension.pendingIndex)) {
+              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,
@@ -6803,23 +7000,20 @@ var AgentRuntime = class _AgentRuntime {
           }
         }
       } catch (error) {
-        if (error instanceof PhaseInteractionBoundary || error instanceof PhaseInteractionCancelledError) {
+        if (error instanceof RunInteractionBoundary || error instanceof RunInteractionCancelledError) {
           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);
+        if (!(suspension && index === suspension.pendingIndex)) {
+          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,
@@ -6832,26 +7026,23 @@ var AgentRuntime = class _AgentRuntime {
         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);
+      const reserved = resumedStart ?? await (async () => {
+        const committed = 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(committed.run.revision);
+        return this.owned.startToolCall({
+          runId: input.run.id,
+          execution: input.execution,
+          expectedRevision: revision,
+          toolCallId
+        });
+      })();
+      if (reserved) setRevision(reserved.run.revision);
       progressActive = true;
       try {
         let result = await durableTool.execute(toJsonValue(toolCall.args), context, input.signal);
@@ -6879,12 +7070,24 @@ var AgentRuntime = class _AgentRuntime {
           result
         });
         setRevision(committed.run.revision);
+        const projectedResult = await this.foldToolInteractionRecords(result, toolCallId, input.run.agentId);
         results.push({
           toolCallId: providerToolCallId,
           toolName: toolCall.name,
-          ...result
+          ...projectedResult
         });
       } catch (error) {
+        if (error instanceof RunInteractionBoundary) {
+          const suspended = await this.owned.suspendToolCall({
+            runId: input.run.id,
+            execution: input.execution,
+            expectedRevision: revision,
+            toolCallId
+          });
+          setRevision(suspended.run.revision);
+          throw error;
+        }
+        if (error instanceof RunInteractionCancelledError) throw error;
         const reason = error instanceof Error ? error.message : "Tool execution outcome is indeterminate.";
         const indeterminate = await this.owned.commitToolResult({
           runId: input.run.id,
@@ -6905,6 +7108,20 @@ var AgentRuntime = class _AgentRuntime {
     input.driver?.clearCheckpoint();
     return { results, revision };
   }
+  async foldToolInteractionRecords(result, toolCallId, agentId) {
+    const interactionMessages = (await this.owned.history(agentId)).filter(
+      (message) => message.role === "interaction" && message.toolCallId === toolCallId
+    );
+    if (interactionMessages.length === 0) return result;
+    const interactionText = interactionMessages.filter((message) => message.role === "interaction").map(renderInteractionText).join("\n\n");
+    const content = typeof result.content === "string" ? result.content : JSON.stringify(result.content) ?? "null";
+    return {
+      ...result,
+      content: content === "null" || content.length === 0 ? interactionText : `${interactionText}
+
+${content}`
+    };
+  }
   async requireAgent(agentId) {
     const agent = (await this.owned.listAgents()).find((candidate) => candidate.id === agentId);
     if (!agent) throw new RuntimeError("agent_not_found", { agentId });
@@ -6975,7 +7192,17 @@ var AgentRuntime = class _AgentRuntime {
           }
         }
         const events = await this.owned.listEvents(cursor ? { after: cursor } : {});
+        const transientBeforeDurable = subscription.shift();
+        if (transientBeforeDurable) {
+          yield transientBeforeDurable;
+          continue;
+        }
         for (const event of events) {
+          const transientBeforeEvent = subscription.shift();
+          if (transientBeforeEvent) {
+            yield transientBeforeEvent;
+            continue;
+          }
           cursor = event.cursor;
           if (event.runId !== runId) continue;
           if (event.kind === "message_committed") {
@@ -7046,9 +7273,6 @@ var DurableRun = class {
   wait(options) {
     return this.runtime.wait(this.id, options);
   }
-  respond(input) {
-    return this.runtime.respond(this.id, input);
-  }
   respondInteraction(input) {
     return this.runtime.respondInteraction(this.id, input);
   }
@@ -7080,9 +7304,6 @@ function boundaryFromSnapshot(snapshot) {
     case "input_required":
       return {
         type: "input_required",
-        requestId: snapshot.request.id,
-        phase: snapshot.request.phase,
-        ...snapshot.request.prompt ? { prompt: snapshot.request.prompt } : {},
         interactions: snapshot.interactions,
         answers: snapshot.answers
       };
@@ -7215,7 +7436,24 @@ var InMemoryStore = class _InMemoryStore {
   static fromState(state) {
     const store = new _InMemoryStore({ incarnation: state.incarnation });
     for (const agent of state.agents) store.agents.set(agent.id, clone(agent));
-    for (const run of state.runs) store.runs.set(run.id, clone(run));
+    for (const run of state.runs) {
+      const clonedRun = clone(run);
+      if (clonedRun.openInputRequest) {
+        delete clonedRun.openInputRequest;
+        delete clonedRun.checkpoint;
+        delete clonedRun.execution;
+        delete clonedRun.openInteractions;
+        delete clonedRun.interactionAnswers;
+        clonedRun.state = "cancelled";
+        clonedRun.cancellationReason = "Input Request retired in v0.13";
+        clonedRun.revision += 1;
+        clonedRun.updatedAt = createTimestamp();
+        store.runs.set(clonedRun.id, clonedRun);
+        store.appendTransition(clonedRun, "input_required", "cancelled", { reason: clonedRun.cancellationReason });
+      } else {
+        store.runs.set(clonedRun.id, clonedRun);
+      }
+    }
     for (const message of state.messages) store.messages.set(message.id, clone(message));
     for (const toolCall of state.toolCalls ?? []) store.toolCalls.set(toolCall.id, clone(toolCall));
     store.events.push(...clone(state.events));
@@ -7274,7 +7512,7 @@ var InMemoryStore = class _InMemoryStore {
       delete run.execution;
       run.revision += 1;
       run.updatedAt = createTimestamp();
-      this.appendTransition(run, "running", "failed", void 0, void 0, void 0, failure);
+      this.appendTransition(run, "running", "failed", { failure });
     }
   }
   async openOwner(input) {
@@ -7498,7 +7736,8 @@ var InMemoryStore = class _InMemoryStore {
           const openToolCalls = [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running"));
           for (const toolCall of openToolCalls) this.interruptToolCall(run, toolCall, "Run superseded by Message revision.");
         } else {
-          delete run.openInputRequest;
+          delete run.openInteractions;
+          delete run.interactionAnswers;
           delete run.checkpoint;
         }
         this.dropClaimReceipt(run.execution);
@@ -7507,7 +7746,7 @@ var InMemoryStore = class _InMemoryStore {
         run.cancellationReason = "Run superseded by Message revision.";
         run.revision += 1;
         run.updatedAt = timestamp;
-        this.appendTransition(run, previousState, "cancelled", void 0, void 0, void 0, void 0, run.cancellationReason);
+        this.appendTransition(run, previousState, "cancelled", { reason: run.cancellationReason });
       } else {
         run.revision += 1;
         run.updatedAt = timestamp;
@@ -7551,6 +7790,29 @@ var InMemoryStore = class _InMemoryStore {
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return clone(result);
   }
+  commitInteractionRecord(run, interaction, status, answer, reply) {
+    const now = createTimestamp();
+    const record = {
+      id: interaction.id,
+      agentId: run.agentId,
+      runId: run.id,
+      role: "interaction",
+      interactionId: interaction.id,
+      kind: interaction.kind,
+      prompt: interaction.prompt,
+      phase: interaction.phase,
+      status,
+      ...answer !== void 0 ? { answer: clone(answer) } : {},
+      ...reply !== void 0 ? { reply } : {},
+      ...interaction.toolCallId !== void 0 ? { toolCallId: interaction.toolCallId } : {},
+      ...interaction.result !== void 0 ? { result: clone(interaction.result) } : {},
+      sequenceWithinRun: this.nextMessageSequence(run.id),
+      createdAt: now
+    };
+    this.messages.set(record.id, record);
+    this.appendMessage(run, record);
+    return record;
+  }
   createRun(lease, input) {
     this.assertOwner(lease);
     this.requireAgent(input.agentId);
@@ -7559,6 +7821,45 @@ var InMemoryStore = class _InMemoryStore {
     const payload = canonicalStartRunRequest(normalizedInput, input.metadata);
     const replay = this.replay(scope, payload);
     if (replay) return clone(replay);
+    const waitingRun = isControlMetadata(input.metadata) ? void 0 : [...this.runs.values()].find((candidate) => candidate.agentId === input.agentId && candidate.state === "input_required");
+    if (waitingRun) {
+      const replyText = typeof normalizedInput === "string" ? normalizedInput : typeof normalizedInput.content === "string" ? normalizedInput.content : normalizedInput.content.map((c) => c.type === "text" ? c.text : "").join(" ");
+      const openInteractions = waitingRun.openInteractions ?? [];
+      for (const interaction of openInteractions) {
+        this.commitInteractionRecord(waitingRun, interaction, "replied", void 0, replyText);
+      }
+      delete waitingRun.openInteractions;
+      delete waitingRun.interactionAnswers;
+      if (waitingRun.checkpoint?.data && typeof waitingRun.checkpoint.data === "object") {
+        const stored = waitingRun.checkpoint.data.runInteractions ?? waitingRun.checkpoint.data.phaseInteractions;
+        if (stored?.requests && Array.isArray(stored.requests)) {
+          for (const req of stored.requests) {
+            req.status = "replied";
+            req.reply = replyText;
+          }
+        }
+      }
+      const now = createTimestamp();
+      const message = {
+        id: createId("msg"),
+        agentId: waitingRun.agentId,
+        runId: waitingRun.id,
+        role: "user",
+        content: userInputContent(normalizedInput),
+        ...userInputMetadata(normalizedInput) ? { metadata: clone(userInputMetadata(normalizedInput)) } : {},
+        sequenceWithinRun: this.nextMessageSequence(waitingRun.id),
+        createdAt: now
+      };
+      this.messages.set(message.id, message);
+      this.appendMessage(waitingRun, message);
+      waitingRun.readySequence = this.nextReady(waitingRun.agentId);
+      waitingRun.state = "queued";
+      waitingRun.revision += 1;
+      waitingRun.updatedAt = now;
+      this.appendTransition(waitingRun, "input_required", "queued");
+      this.writeReceipt(scope, payload, waitingRun);
+      return clone(waitingRun);
+    }
     const timestamp = createTimestamp();
     const run = {
       id: createId("run"),
@@ -7646,7 +7947,26 @@ var InMemoryStore = class _InMemoryStore {
     run.failure = clone(input.failure);
     run.revision += 1;
     run.updatedAt = createTimestamp();
-    this.appendTransition(run, "queued", "failed", void 0, void 0, void 0, input.failure);
+    this.appendTransition(run, "queued", "failed", { failure: input.failure });
+    const result = clone(run);
+    this.writeOperationReceipt(operationKey, operationPayload, result);
+    return result;
+  }
+  commitPhaseEntered(lease, input) {
+    this.assertOwner(lease);
+    if (input.phaseId.length === 0) throw new TypeError("phaseId must be non-empty");
+    const operationKey = `phase_entered:${input.runId}:${input.execution.executionId}:${input.visit}`;
+    const operationPayload = canonicalJson([input.phaseId, input.expectedRevision]);
+    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"]);
+    run.currentPhaseId = input.phaseId;
+    run.revision += 1;
+    run.updatedAt = createTimestamp();
+    const visit2 = this.events.filter((event) => event.runId === run.id && event.kind === "phase_entered").length + 1;
+    this.events.push(this.baseEvent(run, { kind: "phase_entered", executionId: input.execution.executionId, phaseId: input.phaseId, visit: visit2 }));
     const result = clone(run);
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
@@ -7654,8 +7974,7 @@ var InMemoryStore = class _InMemoryStore {
   commitInputRequired(lease, input) {
     this.assertOwner(lease);
     if (typeof input.phase !== "string" || input.phase.length === 0) throw new TypeError("phase must be non-empty");
-    const requestId = input.requestId ?? createId("input");
-    const operationKey = `input_required:${requestId}`;
+    const operationKey = `input_required:${input.runId}:${input.execution.executionId}`;
     const interactions = input.interactions ?? [];
     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);
@@ -7663,8 +7982,8 @@ var InMemoryStore = class _InMemoryStore {
     const run = this.requireRun(input.runId);
     this.assertExecution(run, input.execution, input.expectedRevision);
     this.assertState(run, ["running"]);
-    this.assertNoOpenTools(run);
-    const isToolCallInteraction = interactions.length > 0 && interactions.some((interaction) => interaction.origin === "tool_call");
+    this.assertNoOpenTools(run, input.pendingToolCallIds ?? []);
+    const isToolCallInteraction = interactions.length > 0 && interactions.some((interaction) => interaction.toolCallId !== void 0);
     let prompt;
     if (input.prompt && !isToolCallInteraction) {
       prompt = {
@@ -7673,15 +7992,8 @@ var InMemoryStore = class _InMemoryStore {
       };
       this.messages.set(prompt.id, prompt);
     }
-    const request = {
-      id: requestId,
-      phase: input.phase,
-      ...prompt ? { messageId: prompt.id } : {},
-      createdAt: createTimestamp()
-    };
     run.state = "input_required";
     run.checkpoint = clone(input.checkpoint);
-    run.openInputRequest = request;
     if (interactions.length > 0) {
       run.openInteractions = clone(interactions);
       run.interactionAnswers = clone(input.interactionAnswers ?? run.interactionAnswers ?? {});
@@ -7696,50 +8008,7 @@ var InMemoryStore = class _InMemoryStore {
     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 ? { prompt: clone(prompt) } : {},
-      request: clone(request),
-      interactions: clone(interactions)
-    };
-    this.writeOperationReceipt(operationKey, operationPayload, result);
-    return result;
-  }
-  answerInput(lease, input) {
-    this.assertOwner(lease);
-    const normalizedInput = normalizeUserInput(input.input);
-    const operationKey = `answer:${input.runId}:${input.requestId}`;
-    const operationPayload = canonicalStartRunRequest(normalizedInput);
-    const replay = this.replayOperation(operationKey, operationPayload);
-    if (replay) return clone(replay);
-    const run = this.requireRun(input.runId);
-    this.assertRevision(run, input.expectedRevision);
-    this.assertState(run, ["input_required"]);
-    if (!run.openInputRequest || run.openInputRequest.id !== input.requestId) {
-      throw new RuntimeError("input_request_conflict", { runId: run.id, requestId: input.requestId, reason: "not_found" });
-    }
-    if (run.openInteractions && run.openInteractions.length > 0) {
-      throw new RuntimeError("input_request_conflict", { runId: run.id, requestId: input.requestId, reason: "not_found" });
-    }
-    const message = {
-      id: input.messageId ?? createId("msg"),
-      agentId: run.agentId,
-      runId: run.id,
-      role: "user",
-      content: userInputContent(normalizedInput),
-      ...userInputMetadata(normalizedInput) ? { metadata: clone(userInputMetadata(normalizedInput)) } : {},
-      sequenceWithinRun: this.nextMessageSequence(run.id),
-      createdAt: createTimestamp()
-    };
-    this.messages.set(message.id, message);
-    delete run.openInputRequest;
-    run.readySequence = this.nextReady(run.agentId);
-    run.state = "queued";
-    run.revision += 1;
-    run.updatedAt = createTimestamp();
-    this.appendMessage(run, message);
-    this.appendTransition(run, "input_required", "queued");
+    this.appendTransition(run, "running", "input_required", { prompt, interactions, answers: run.interactionAnswers ?? {} });
     const result = clone(run);
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
@@ -7747,8 +8016,9 @@ var InMemoryStore = class _InMemoryStore {
   answerInteraction(lease, input) {
     this.assertOwner(lease);
     if (input.interactionId.trim().length === 0) throw new TypeError("interactionId must be non-empty");
+    if (!input.cancel && input.input === void 0) throw new TypeError("respondInteraction requires input or cancel: true");
     const operationKey = `interaction_answer:${input.runId}:${input.interactionId}`;
-    const operationPayload = canonicalJson(input.input);
+    const operationPayload = canonicalJson([input.input ?? null, input.cancel ?? false]);
     const replay = this.replayOperation(operationKey, operationPayload);
     if (replay) return clone(replay);
     const run = this.requireRun(input.runId);
@@ -7757,34 +8027,33 @@ var InMemoryStore = class _InMemoryStore {
     const openInteractions = run.openInteractions ?? [];
     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" });
+      throw new RuntimeError("input_request_conflict", { runId: run.id, interactionId: input.interactionId, reason: "not_found" });
     }
-    const isToolCall = targetInteraction.origin === "tool_call";
+    const isCancel = input.cancel === true;
+    const status = isCancel ? "cancelled" : "answered";
     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);
+    this.commitInteractionRecord(run, targetInteraction, status, isCancel ? void 0 : input.input);
+    if (run.checkpoint?.data && typeof run.checkpoint.data === "object") {
+      const stored = run.checkpoint.data.runInteractions ?? run.checkpoint.data.phaseInteractions;
+      if (stored?.requests && Array.isArray(stored.requests)) {
+        const req = stored.requests.find((r) => r.id === input.interactionId);
+        if (req) {
+          req.status = status;
+          if (!isCancel && input.input !== void 0) req.answer = clone(input.input);
+        }
+      }
     }
     run.openInteractions = openInteractions.filter((interaction) => interaction.id !== input.interactionId);
-    run.interactionAnswers = {
-      ...run.interactionAnswers ?? {},
-      [input.interactionId]: clone(input.input)
-    };
+    if (!isCancel && input.input !== void 0) {
+      run.interactionAnswers = {
+        ...run.interactionAnswers ?? {},
+        [input.interactionId]: clone(input.input)
+      };
+    }
     run.revision += 1;
     run.updatedAt = now;
     if (run.openInteractions.length === 0) {
       delete run.openInteractions;
-      delete run.openInputRequest;
       run.readySequence = this.nextReady(run.agentId);
       run.state = "queued";
       this.appendTransition(run, "input_required", "queued");
@@ -7884,7 +8153,7 @@ var InMemoryStore = class _InMemoryStore {
   }
   startToolCall(lease, input) {
     this.assertOwner(lease);
-    const operationKey = `tool_start:${input.toolCallId}`;
+    const operationKey = `tool_start:${input.toolCallId}:${input.execution.executionId}`;
     const operationPayload = canonicalJson([input.runId, input.expectedRevision, input.execution.executionId]);
     const replay = this.replayOperation(operationKey, operationPayload);
     if (replay) return clone(replay);
@@ -7892,8 +8161,9 @@ var InMemoryStore = class _InMemoryStore {
     this.assertExecution(run, input.execution, input.expectedRevision);
     const toolCall = this.requireToolCall(input.toolCallId, run);
     if (toolCall.state !== "pending") throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
-    if (toolCall.executionId !== input.execution.executionId) throw new RuntimeError("runtime_ownership_lost", { reason: "epoch_advanced", expectedEpoch: input.execution.ownerEpoch, actualEpoch: this.ownerEpoch });
     toolCall.state = "running";
+    toolCall.executionId = input.execution.executionId;
+    toolCall.executionId = input.execution.executionId;
     toolCall.updatedAt = createTimestamp();
     run.revision += 1;
     run.updatedAt = toolCall.updatedAt;
@@ -7902,6 +8172,27 @@ var InMemoryStore = class _InMemoryStore {
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
   }
+  suspendToolCall(lease, input) {
+    this.assertOwner(lease);
+    const operationKey = `tool_suspend:${input.toolCallId}:${input.execution.executionId}`;
+    const operationPayload = canonicalJson([input.runId, input.expectedRevision, input.execution.executionId]);
+    const replay = this.replayOperation(operationKey, operationPayload);
+    if (replay) return clone(replay);
+    const run = this.requireRun(input.runId);
+    this.assertExecution(run, input.execution, input.expectedRevision);
+    const toolCall = this.requireToolCall(input.toolCallId, run);
+    if (toolCall.state !== "running" || toolCall.executionId !== input.execution.executionId) {
+      throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
+    }
+    toolCall.state = "pending";
+    toolCall.updatedAt = createTimestamp();
+    run.revision += 1;
+    run.updatedAt = toolCall.updatedAt;
+    this.appendToolTransition(run, { from: "running", to: "pending" }, toolCall);
+    const result = { run: clone(run), toolCall: clone(toolCall) };
+    this.writeOperationReceipt(operationKey, operationPayload, result);
+    return result;
+  }
   commitToolResult(lease, input) {
     this.assertOwner(lease);
     assertToolExecutionResult(input.result);
@@ -7960,7 +8251,7 @@ var InMemoryStore = class _InMemoryStore {
       delete run.execution;
       run.revision += 1;
       run.updatedAt = createTimestamp();
-      this.appendTransition(run, "running", "failed", void 0, void 0, void 0, failure);
+      this.appendTransition(run, "running", "failed", { failure });
     }
     const result = { run: clone(run), toolCall: clone(toolCall) };
     this.writeOperationReceipt(operationKey, operationPayload, result);
@@ -7993,7 +8284,7 @@ var InMemoryStore = class _InMemoryStore {
     delete run.interactionAnswers;
     run.revision += 1;
     run.updatedAt = createTimestamp();
-    this.appendTransition(run, "running", nextState, void 0, output, input.outcome, input.failure);
+    this.appendTransition(run, "running", nextState, { outcome: input.outcome, failure: input.failure, output });
     const result = clone(run);
     this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
@@ -8017,7 +8308,13 @@ var InMemoryStore = class _InMemoryStore {
       return result2;
     }
     const from = run.state;
-    const activeToolCalls = run.execution ? [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running")) : [];
+    const activeToolCalls = run.execution ? [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.executionId === run.execution?.executionId && (toolCall.state === "pending" || toolCall.state === "running")) : run.state === "input_required" && run.checkpoint?.data && typeof run.checkpoint.data === "object" && !Array.isArray(run.checkpoint.data) ? (() => {
+      const interactionState = run.checkpoint.data.runInteractions;
+      const interactionCheckpoint = interactionState && typeof interactionState === "object" && !Array.isArray(interactionState) ? interactionState.checkpoint : void 0;
+      const ids = interactionCheckpoint && typeof interactionCheckpoint === "object" && !Array.isArray(interactionCheckpoint) ? interactionCheckpoint.toolCallIds : void 0;
+      const allowed = new Set(Array.isArray(ids) ? ids : []);
+      return [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id && toolCall.state === "pending" && allowed.has(toolCall.id));
+    })() : [];
     const indeterminateToolCallIds = activeToolCalls.filter((toolCall) => toolCall.state === "running").map((toolCall) => toolCall.id);
     for (const toolCall of activeToolCalls) this.interruptToolCall(run, toolCall, input.reason ?? "The Run was cancelled.");
     if (input.output && (typeof input.output.content === "string" ? input.output.content.length > 0 : input.output.content.length > 0)) {
@@ -8025,6 +8322,11 @@ var InMemoryStore = class _InMemoryStore {
       this.messages.set(output.id, output);
       this.appendMessage(run, output);
     }
+    if (run.openInteractions && run.openInteractions.length > 0) {
+      for (const interaction of run.openInteractions) {
+        this.commitInteractionRecord(run, interaction, "cancelled");
+      }
+    }
     if (indeterminateToolCallIds.length > 0) {
       const failure = {
         code: "tool_indeterminate",
@@ -8036,12 +8338,11 @@ var InMemoryStore = class _InMemoryStore {
       delete run.cancellationReason;
       this.dropClaimReceipt(run.execution);
       delete run.execution;
-      delete run.openInputRequest;
       delete run.openInteractions;
       delete run.interactionAnswers;
       run.revision += 1;
       run.updatedAt = createTimestamp();
-      this.appendTransition(run, from, "failed", void 0, void 0, void 0, failure);
+      this.appendTransition(run, from, "failed", { failure });
       const result2 = clone(run);
       if (input.expectedRevision !== void 0) this.writeOperationReceipt(operationKey, operationPayload, result2);
       return result2;
@@ -8050,12 +8351,11 @@ var InMemoryStore = class _InMemoryStore {
     run.cancellationReason = input.reason;
     this.dropClaimReceipt(run.execution);
     delete run.execution;
-    delete run.openInputRequest;
     delete run.openInteractions;
     delete run.interactionAnswers;
     run.revision += 1;
     run.updatedAt = createTimestamp();
-    this.appendTransition(run, from, "cancelled", void 0, void 0, void 0, void 0, input.reason);
+    this.appendTransition(run, from, "cancelled", { reason: input.reason });
     const result = clone(run);
     if (input.expectedRevision !== void 0) this.writeOperationReceipt(operationKey, operationPayload, result);
     return result;
@@ -8072,6 +8372,7 @@ var InMemoryStore = class _InMemoryStore {
       ...run.metadata ? { metadata: clone(run.metadata) } : {},
       messageCount: this.messagesForRun(run.id).length,
       toolCallCount: [...this.toolCalls.values()].filter((toolCall) => toolCall.runId === run.id).length,
+      ...run.currentPhaseId === void 0 ? {} : { currentPhaseId: run.currentPhaseId },
       createdAt: run.createdAt,
       updatedAt: run.updatedAt,
       cursor: this.cursorForRun(run.id)
@@ -8081,17 +8382,9 @@ var InMemoryStore = class _InMemoryStore {
       case "running":
         return { ...base, state: run.state };
       case "input_required": {
-        const request = run.openInputRequest;
-        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 ? { prompt: clone(prompt) } : {}
-          },
           interactions: clone(run.openInteractions ?? []),
           answers: clone(run.interactionAnswers ?? {})
         };
@@ -8266,8 +8559,9 @@ var InMemoryStore = class _InMemoryStore {
     if (!toolCall || toolCall.runId !== run.id) throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     return toolCall;
   }
-  assertNoOpenTools(run) {
-    if ([...this.toolCalls.values()].some((toolCall) => toolCall.runId === run.id && (toolCall.state === "pending" || toolCall.state === "running"))) {
+  assertNoOpenTools(run, allowedPendingToolCallIds = []) {
+    const allowed = new Set(allowedPendingToolCallIds);
+    if ([...this.toolCalls.values()].some((toolCall) => toolCall.runId === run.id && (toolCall.state === "running" || toolCall.state === "pending" && !allowed.has(toolCall.id)))) {
       throw new RuntimeError("run_state_conflict", { runId: run.id, expected: ["running"], actual: run.state });
     }
   }
@@ -8407,23 +8701,16 @@ ${record.summary}`,
       message
     }));
   }
-  appendTransition(run, from, to, request, prompt, outcome, failure, reason, interactions, answers) {
+  appendTransition(run, from, to, options) {
     const transition = {
       ...this.baseEvent(run),
       kind: "run_state_changed",
       from,
       to,
-      ...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 } : {},
-      ...to === "cancelled" && reason ? { reason } : {}
+      ...to === "input_required" ? { interactions: clone(options?.interactions ?? []), answers: clone(options?.answers ?? {}) } : {},
+      ...to === "completed" && options?.outcome ? { outcome: options.outcome, ...options.output ? { output: options.output } : {} } : {},
+      ...to === "failed" && options?.failure ? { failure: options.failure } : {},
+      ...to === "cancelled" && options?.reason ? { reason: options.reason } : {}
     };
     this.events.push(transition);
   }
@@ -8501,12 +8788,12 @@ var MemoryOwnedStore = class {
   async failQueuedRun(input) {
     return this.store.failQueuedRun(this.lease, input);
   }
+  async commitPhaseEntered(input) {
+    return this.store.commitPhaseEntered(this.lease, input);
+  }
   async commitInputRequired(input) {
     return this.store.commitInputRequired(this.lease, input);
   }
-  async answerInput(input) {
-    return this.store.answerInput(this.lease, input);
-  }
   async answerInteraction(input) {
     return this.store.answerInteraction(this.lease, input);
   }
@@ -8522,6 +8809,9 @@ var MemoryOwnedStore = class {
   async startToolCall(input) {
     return this.store.startToolCall(this.lease, input);
   }
+  async suspendToolCall(input) {
+    return this.store.suspendToolCall(this.lease, input);
+  }
   async commitToolResult(input) {
     return this.store.commitToolResult(this.lease, input);
   }
@@ -8585,26 +8875,37 @@ function hasUserInput(input) {
 function userInputMetadata(input) {
   return typeof input === "string" ? void 0 : input.metadata;
 }
-function isControlRun(run) {
-  const rowan = run.metadata?.rowan;
+function isControlMetadata(metadata) {
+  const rowan = metadata?.rowan;
   return typeof rowan === "object" && rowan !== null && typeof rowan.kind === "string" && rowan.kind.length > 0;
 }
+function isControlRun(run) {
+  return isControlMetadata(run.metadata);
+}
 function estimateMessageTokens(messages) {
   let characters = 0;
   for (const message of messages) {
-    characters += messageContentText2(message.content).length;
+    if (message.role === "interaction") {
+      characters += (message.prompt?.length ?? 0) + (message.answer !== void 0 ? JSON.stringify(message.answer).length : 0) + (message.reply?.length ?? 0);
+    } else {
+      characters += messageContentText2(message.content).length;
+    }
     characters += 20;
   }
   return Math.ceil(characters / 4);
 }
 function messageContentText2(content) {
+  if (!content) return "";
   if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
   return content.map((part) => {
-    if (part.type === "text") return part.text;
-    if (part.type === "thinking") return part.thinking;
-    if (part.type === "tool_use") return JSON.stringify(part.input);
-    if (part.type === "tool_result") return JSON.stringify(part.result);
-    if (part.type === "image") return `[image:${part.mimeType}]`;
+    if (part && typeof part === "object") {
+      if (part.type === "text") return part.text ?? "";
+      if (part.type === "thinking") return part.thinking ?? "";
+      if (part.type === "tool_use") return JSON.stringify(part.input);
+      if (part.type === "tool_result") return JSON.stringify(part.result);
+      if (part.type === "image") return `[image:${part.mimeType}]`;
+    }
     return "";
   }).join("\n");
 }
@@ -8616,6 +8917,16 @@ function materializeHistorySeed(agentId, source) {
   const seedRunId = createId("seed");
   const toolIds = /* @__PURE__ */ new Map();
   return source.map((message, sequenceWithinRun) => {
+    if (message.role === "interaction") {
+      return {
+        ...clone(message),
+        id: createId("msg"),
+        agentId,
+        runId: seedRunId,
+        sequenceWithinRun,
+        createdAt: createTimestamp()
+      };
+    }
     const content = remapSeedContent(message.content, toolIds);
     return {
       ...clone(message),
@@ -8854,12 +9165,12 @@ var SqliteStore = class {
   async failQueuedRun(lease, input) {
     return this.invoke(lease, (store, current) => store.failQueuedRun(current, input));
   }
+  async commitPhaseEntered(lease, input) {
+    return this.invoke(lease, (store, current) => store.commitPhaseEntered(current, input));
+  }
   async commitInputRequired(lease, input) {
     return this.invoke(lease, (store, current) => store.commitInputRequired(current, input));
   }
-  async answerInput(lease, input) {
-    return this.invoke(lease, (store, current) => store.answerInput(current, input));
-  }
   async answerInteraction(lease, input) {
     return this.invoke(lease, (store, current) => store.answerInteraction(current, input));
   }
@@ -8875,6 +9186,9 @@ var SqliteStore = class {
   async startToolCall(lease, input) {
     return this.invoke(lease, (store, current) => store.startToolCall(current, input));
   }
+  async suspendToolCall(lease, input) {
+    return this.invoke(lease, (store, current) => store.suspendToolCall(current, input));
+  }
   async commitToolResult(lease, input) {
     return this.invoke(lease, (store, current) => store.commitToolResult(current, input));
   }
@@ -9244,12 +9558,12 @@ var SqliteOwnedStore = class {
   failQueuedRun(input) {
     return this.store.failQueuedRun(this.lease, input);
   }
+  commitPhaseEntered(input) {
+    return this.store.commitPhaseEntered(this.lease, input);
+  }
   commitInputRequired(input) {
     return this.store.commitInputRequired(this.lease, input);
   }
-  answerInput(input) {
-    return this.store.answerInput(this.lease, input);
-  }
   answerInteraction(input) {
     return this.store.answerInteraction(this.lease, input);
   }
@@ -9265,6 +9579,9 @@ var SqliteOwnedStore = class {
   startToolCall(input) {
     return this.store.startToolCall(this.lease, input);
   }
+  suspendToolCall(input) {
+    return this.store.suspendToolCall(this.lease, input);
+  }
   commitToolResult(input) {
     return this.store.commitToolResult(this.lease, input);
   }
@@ -9349,10 +9666,10 @@ export {
   ExtensionLifetimeError,
   InMemoryConfigProvider,
   InMemoryStore,
-  PhaseInteractionBoundary,
-  PhaseInteractionCancelledError,
   ResourceRegistry,
   ResourceRegistryError,
+  RunInteractionBoundary,
+  RunInteractionCancelledError,
   RuntimeBootstrapRegistry,
   RuntimeError,
   RuntimeExtensionLifetime,