@rowan-agent/agent 0.19.0 → 0.20.0

package/dist/index.js

@@ -1922,6 +1922,19 @@ function createRunInteractionDriver(state, phase, signal) {
       checkpoint = void 0;
       sync();
     },
+    answer(id, value) {
+      answers.set(id, value);
+      const req = requests.get(id);
+      if (req) {
+        requests.set(id, { ...req, status: "answered", answer: value });
+      }
+      sync();
+    },
+    clearAnswer(id) {
+      answers.delete(id);
+      requests.delete(id);
+      sync();
+    },
     suspend(input = {}) {
       assertActive();
       const pending = this.pending();
@@ -2667,6 +2680,16 @@ function serializeSkills(skills) {
 function conversationMessages(messages) {
   return messages.flatMap((message) => {
     if (message.role === "user") {
+      if (message.contexts && message.contexts.length > 0) {
+        const turnContextText = `<turn_context>
+${buildContextDescription(message.contexts)}
+</turn_context>`;
+        const contentParts = [
+          { type: "text", text: turnContextText },
+          ...typeof message.content === "string" ? [{ type: "text", text: message.content }] : message.content
+        ];
+        return [{ role: "user", content: contentParts }];
+      }
       return [{ role: "user", content: message.content }];
     }
     if (message.role === "assistant") {
@@ -2701,6 +2724,7 @@ function buildModelRequest(input, options) {
   return {
     model: options?.model ?? { provider: "", id: "" },
     ...options?.thinkingLevel === void 0 ? {} : { thinkingLevel: options.thinkingLevel },
+    ...options?.providerOptions === void 0 ? {} : { providerOptions: options.providerOptions },
     system: systemText,
     messages,
     tools: modelTools.length > 0 ? modelTools : void 0
@@ -3607,7 +3631,8 @@ async function executeToolCall(input) {
       toolCall: input.toolCall,
       contentBlocks: input.contentBlocks,
       driver: input.driver,
-      options: input.options
+      options: input.options,
+      ...input.providerInitiated ? { providerInitiated: true } : {}
     });
   } else {
     const toolContext = {
@@ -3652,7 +3677,7 @@ async function executeToolCalls(input) {
 }
 function createPhaseExecution(config, state, phase, messageManager, toolExecutionManager, registry) {
   const interaction = createRunInteractionDriver(state, phase.name, config.signal);
-  const executePhaseTool = async (phaseContext, toolCall, options) => {
+  const executePhaseTool = async (phaseContext, toolCall, options, providerInitiated = false) => {
     return runTurn(async () => {
       await toolExecutionManager.start(toolCall.id, toolCall.name, toolCall.args);
       const tools = phaseContext.tools.filter((tool) => tool.name !== PhaseRouteTool);
@@ -3668,7 +3693,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
         tools,
         toolCall,
         driver: interaction,
-        options
+        options,
+        providerInitiated
       });
       await toolExecutionManager.end(result.toolCallId, result.toolName, result, !result.ok);
       return result;
@@ -3706,7 +3732,8 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
         appendSystemPrompt: phaseContext.appendSystemPrompt
       }, {
         model: phase.model ?? config.model,
-        ...config.thinkingLevel === void 0 ? {} : { thinkingLevel: config.thinkingLevel }
+        ...config.thinkingLevel === void 0 ? {} : { thinkingLevel: config.thinkingLevel },
+        ...config.providerOptions === void 0 ? {} : { providerOptions: config.providerOptions }
       });
       if (!request.tools) {
         if (phaseContext.tools.length > 0) {
@@ -3751,7 +3778,7 @@ function createPhaseExecution(config, state, phase, messageManager, toolExecutio
               name,
               args
             };
-            const res = await executePhaseTool(phaseContext, toolCall, options2);
+            const res = await executePhaseTool(phaseContext, toolCall, options2, true);
             return res.ok ? { ok: true, content: res.content } : { ok: false, error: res.error ?? "Tool execution failed", ...res.content !== void 0 ? { content: res.content } : {} };
           },
           report: (update) => {
@@ -4046,6 +4073,7 @@ async function executeOnce(input) {
     execution: input.execution,
     model: input.model,
     ...input.thinkingLevel === void 0 ? {} : { thinkingLevel: input.thinkingLevel },
+    ...input.providerOptions === void 0 ? {} : { providerOptions: input.providerOptions },
     stream: input.stream,
     maxAttempts: input.maxAttempts,
     signal: input.signal,
@@ -4209,6 +4237,9 @@ var THINKING_LEVELS = [
 function thinkingLevelFromUserInput(input) {
   return typeof input === "string" ? void 0 : input.thinkingLevel;
 }
+function providerOptionsFromUserInput(input) {
+  return typeof input === "string" ? void 0 : input.providerOptions;
+}
 var METADATA_LIMIT = 64 * 1024;
 var IDENTITY_LIMIT = 256;
 function isRecord3(value) {
@@ -4263,13 +4294,16 @@ function isAssistantContent(value) {
 }
 function normalizeUserInput(input) {
   const normalized = typeof input === "string" ? { content: input } : input;
-  if (!isRecord3(normalized) || !hasOnlyKeys(normalized, ["content", "metadata", "thinkingLevel"]) || !isUserContent(normalized.content)) {
+  if (!isRecord3(normalized) || !hasOnlyKeys(normalized, ["content", "metadata", "thinkingLevel", "providerOptions"]) || !isUserContent(normalized.content)) {
     throw new TypeError("input must contain only valid UserContent");
   }
   if (normalized.metadata !== void 0) assertMetadata(normalized.metadata, "input.metadata");
   if (normalized.thinkingLevel !== void 0 && !THINKING_LEVELS.includes(normalized.thinkingLevel)) {
     throw new TypeError("input.thinkingLevel must be a valid ThinkingLevel");
   }
+  if (normalized.providerOptions !== void 0 && (!isRecord3(normalized.providerOptions) || !isJsonValue(normalized.providerOptions))) {
+    throw new TypeError("input.providerOptions must be a JSON object");
+  }
   assertJsonValue(normalized, "input");
   return normalized;
 }
@@ -5000,7 +5034,14 @@ function durableInterruptedAssistantContent(content) {
 function projectMessage(message) {
   switch (message.role) {
     case "user":
-      return { id: message.id, role: message.role, content: projectUserContent(message.content), createdAt: message.createdAt, ...message.metadata ? { metadata: message.metadata } : {} };
+      return {
+        id: message.id,
+        role: message.role,
+        content: projectUserContent(message.content),
+        createdAt: message.createdAt,
+        ...message.metadata ? { metadata: message.metadata } : {},
+        ...message.contexts && message.contexts.length > 0 ? { contexts: message.contexts } : {}
+      };
     case "assistant":
       return { id: message.id, role: message.role, content: projectAssistantContent(message.content), createdAt: message.createdAt, ...message.metadata ? { metadata: message.metadata } : {} };
     case "tool":
@@ -5185,10 +5226,7 @@ function resolveDefinitionContext(snapshot, assembled) {
     selectNamedResources(snapshot.resources.skills, snapshot.definition.skills, "Skill"),
     snapshot.definition.bundledSkills
   );
-  const contexts = [
-    ...selectNamedResources(snapshot.contexts, snapshot.definition.contexts, "Context"),
-    ...snapshot.additionalContexts
-  ];
+  const contexts = selectNamedResources(snapshot.contexts, snapshot.definition.contexts, "Context");
   const phaseCandidates = [...snapshot.resources.phases?.phases.values() ?? []];
   const corePhases = phaseCandidates.filter((phase) => phase.core);
   const authoredPhases = phaseCandidates.filter((phase) => !phase.core);
@@ -5340,7 +5378,6 @@ var TransientRunEventSubscription = class {
   stop() {
     if (this.stopped) return;
     this.stopped = true;
-    this.queue.length = 0;
     this.notify();
   }
   notify() {
@@ -7217,6 +7254,8 @@ function createToolInteractionDriver(driver, input) {
     answers: () => driver.answers(),
     checkpoint: () => resumed ? resumed.toolCheckpoint : stored,
     clearCheckpoint: () => driver.clearCheckpoint(),
+    answer: (id, val) => driver.answer?.(id, val),
+    clearAnswer: (id) => driver.clearAnswer?.(id),
     suspend(options = {}) {
       const interactionIds = [.../* @__PURE__ */ new Set([
         ...requestedIds,
@@ -7357,14 +7396,26 @@ var AgentRuntime = class _AgentRuntime {
       throw error;
     }
   }
-  async handleRunEnd(runId, agentId, outcome) {
+  publishLiveInteraction(runId, interaction) {
+    this.transientEvents.publish({
+      kind: "live_interaction",
+      durability: "transient",
+      runId,
+      executionId: this.executions.get(runId)?.executionId,
+      interaction
+    });
+  }
+  cancelLiveInteractions(runId, reason) {
     const runLive = this.liveInteractions.get(runId);
-    if (runLive) {
-      for (const live of runLive.values()) {
-        live.reject(new RunInteractionCancelledError("Run ended."));
-      }
-      this.liveInteractions.delete(runId);
+    if (!runLive) return;
+    this.liveInteractions.delete(runId);
+    for (const live of runLive.values()) {
+      this.publishLiveInteraction(runId, { ...live.interaction, status: "cancelled" });
+      live.reject(new RunInteractionCancelledError(reason));
     }
+  }
+  async handleRunEnd(runId, agentId, outcome) {
+    this.cancelLiveInteractions(runId, "Run ended.");
     if (this.startedRuns.has(runId)) {
       this.startedRuns.delete(runId);
       try {
@@ -7631,11 +7682,13 @@ var AgentRuntime = class _AgentRuntime {
       runLive = /* @__PURE__ */ new Map();
       this.liveInteractions.set(runId, runLive);
     }
+    this.publishLiveInteraction(runId, interaction);
     return new Promise((resolve9, reject) => {
       const onAbort = () => {
         runLive?.delete(interactionId);
         if (runLive && runLive.size === 0) this.liveInteractions.delete(runId);
         signal.removeEventListener("abort", onAbort);
+        this.publishLiveInteraction(runId, { ...interaction, status: "cancelled" });
         reject(signal.reason ?? new Error("Run aborted"));
       };
       signal.addEventListener("abort", onAbort, { once: true });
@@ -7658,12 +7711,9 @@ var AgentRuntime = class _AgentRuntime {
     if (this.heartbeat) clearInterval(this.heartbeat);
     for (const execution of this.executions.values()) execution.controller.abort();
     this.executions.clear();
-    for (const runLive of this.liveInteractions.values()) {
-      for (const live of runLive.values()) {
-        live.reject(new RunInteractionCancelledError("Runtime closed."));
-      }
+    for (const runId of [...this.liveInteractions.keys()]) {
+      this.cancelLiveInteractions(runId, "Runtime closed.");
     }
-    this.liveInteractions.clear();
     this.transientEvents.close();
     for (const subscription of this.consumers.values()) subscription.controller.abort();
     await this.resources.closeExtensions();
@@ -7693,8 +7743,10 @@ var AgentRuntime = class _AgentRuntime {
       runLive.delete(input.interactionId);
       if (runLive.size === 0) this.liveInteractions.delete(runId);
       if (input.cancel) {
+        this.publishLiveInteraction(runId, { ...live.interaction, status: "cancelled" });
         live.reject(new RunInteractionCancelledError("Run interaction cancelled."));
       } else if (input.input !== void 0) {
+        this.publishLiveInteraction(runId, { ...live.interaction, status: "answered", answer: input.input });
         live.resolve(input.input);
       } else {
         live.reject(new TypeError("respondInteraction requires input or cancel: true"));
@@ -7710,13 +7762,7 @@ var AgentRuntime = class _AgentRuntime {
   }
   async cancel(runId, reason) {
     this.assertOpen();
-    const runLive = this.liveInteractions.get(runId);
-    if (runLive) {
-      for (const live of runLive.values()) {
-        live.reject(new RunInteractionCancelledError(reason ?? "Agent run stopped."));
-      }
-      this.liveInteractions.delete(runId);
-    }
+    this.cancelLiveInteractions(runId, reason ?? "Agent run stopped.");
     const done = this.executionDone.get(runId);
     if (done) {
       this.cancellationRequested.add(runId);
@@ -7841,11 +7887,18 @@ var AgentRuntime = class _AgentRuntime {
         runId: run.id,
         expectedRevision: run.revision,
         executionId,
-        configToken: token
+        configToken: token,
+        ...config.additionalContexts && config.additionalContexts.length > 0 ? { additionalContexts: config.additionalContexts } : {}
       });
       executionRevision = claim.run.revision;
       const controller = new AbortController();
-      this.executions.set(run.id, { controller, executionId });
+      this.executions.set(run.id, {
+        controller,
+        executionId,
+        reservedToolCalls: /* @__PURE__ */ new Set(),
+        startedToolCalls: /* @__PURE__ */ new Set(),
+        providerToolCalls: /* @__PURE__ */ new Map()
+      });
       if (this.cancellationRequested.has(run.id)) controller.abort();
       if (!this.startedRuns.has(run.id)) {
         this.startedRuns.add(run.id);
@@ -7908,6 +7961,7 @@ var AgentRuntime = class _AgentRuntime {
         },
         model,
         thinkingLevel: thinkingLevelFromUserInput(run.input),
+        providerOptions: providerOptionsFromUserInput(run.input),
         stream,
         maxAttempts: config.maxAttempts,
         checkpoint: claim.run.checkpoint,
@@ -8077,25 +8131,130 @@ var AgentRuntime = class _AgentRuntime {
         onContext: assembly.setContext,
         runtime: {
           interact: (request) => this.liveInteract(run.id, request, controller.signal),
-          tools: ({ toolCall, contentBlocks, driver, options }) => {
+          tools: ({ toolCall, contentBlocks, driver, options, providerInitiated }) => {
             const task = toolQueue.then(async () => {
-              const execution = await this.executeToolBatch({
-                run,
-                agentMetadata: agent.metadata,
-                execution: claim.execution,
-                expectedRevision: executionRevision,
-                toolConfig: executionTools,
-                toolCalls: [toolCall],
-                contentBlocks,
-                signal: controller.signal,
-                driver,
-                options,
-                onRevision: (rev) => {
-                  executionRevision = rev;
+              if (!providerInitiated) {
+                const execution = await this.executeToolBatch({
+                  run,
+                  agentMetadata: agent.metadata,
+                  execution: claim.execution,
+                  expectedRevision: executionRevision,
+                  toolConfig: executionTools,
+                  toolCalls: [toolCall],
+                  contentBlocks,
+                  signal: controller.signal,
+                  driver,
+                  options,
+                  onRevision: (rev) => {
+                    executionRevision = rev;
+                  }
+                });
+                executionRevision = execution.revision;
+                return execution.results[0];
+              }
+              const interactionIds = [];
+              try {
+                while (true) {
+                  try {
+                    const execution = await this.executeToolBatch({
+                      run,
+                      agentMetadata: agent.metadata,
+                      execution: claim.execution,
+                      expectedRevision: executionRevision,
+                      toolConfig: executionTools,
+                      toolCalls: [toolCall],
+                      contentBlocks,
+                      signal: controller.signal,
+                      driver,
+                      options,
+                      providerInitiated: true,
+                      interactionIds,
+                      onRevision: (rev) => {
+                        executionRevision = rev;
+                      }
+                    });
+                    executionRevision = execution.revision;
+                    return execution.results[0];
+                  } catch (error) {
+                    if (error instanceof RunInteractionBoundary) {
+                      try {
+                        for (const interaction of error.interactions) {
+                          interactionIds.push(interaction.id);
+                          const answer = await this.liveInteract(run.id, interaction, controller.signal);
+                          driver?.answer?.(interaction.id, answer);
+                        }
+                        driver?.clearCheckpoint();
+                        continue;
+                      } catch (waitError) {
+                        const active2 = this.executions.get(run.id);
+                        const toolCallId2 = active2?.providerToolCalls.get(toolCall.id) ?? error.interactions[0]?.toolCallId;
+                        const isCancel = waitError instanceof RunInteractionCancelledError;
+                        const reason = isCancel ? waitError.message : "Tool execution aborted.";
+                        if (toolCallId2) {
+                          const committed2 = await this.owned.commitToolResult({
+                            runId: run.id,
+                            execution: claim.execution,
+                            expectedRevision: executionRevision,
+                            toolCallId: toolCallId2,
+                            state: "failed",
+                            result: { ok: false, content: null, error: reason },
+                            title: toolCall.name,
+                            kind: "other"
+                          });
+                          executionRevision = committed2.run.revision;
+                          if (options?.onUpdate) {
+                            try {
+                              options.onUpdate(createMergedToolCall(
+                                toolCallId2,
+                                "failed",
+                                { rawInput: toJsonValue(toolCall.args) },
+                                toolCall.name,
+                                "other"
+                              ));
+                            } catch (err) {
+                              console.warn("Error in tool call onUpdate callback:", err);
+                            }
+                          }
+                        }
+                        if (!controller.signal.aborted && isCancel) {
+                          return {
+                            toolCallId: toolCall.id,
+                            toolName: toolCall.name,
+                            ok: false,
+                            content: null,
+                            error: reason
+                          };
+                        }
+                        throw waitError;
+                      }
+                    }
+                    const active = this.executions.get(run.id);
+                    const toolCallId = active?.providerToolCalls.get(toolCall.id);
+                    if (toolCallId && (active?.reservedToolCalls.has(toolCallId) || active?.startedToolCalls.has(toolCallId))) {
+                      try {
+                        const committed2 = await this.owned.commitToolResult({
+                          runId: run.id,
+                          execution: claim.execution,
+                          expectedRevision: executionRevision,
+                          toolCallId,
+                          state: "failed",
+                          result: { ok: false, content: null, error: error instanceof Error ? error.message : "Tool execution failed." },
+                          title: toolCall.name,
+                          kind: "other"
+                        });
+                        executionRevision = committed2.run.revision;
+                      } catch {
+                      }
+                    }
+                    throw error;
+                  }
                 }
-              });
-              executionRevision = execution.revision;
-              return execution.results[0];
+              } finally {
+                driver?.clearCheckpoint();
+                for (const id of interactionIds) driver?.clearAnswer?.(id);
+                const active = this.executions.get(run.id);
+                active?.providerToolCalls.delete(toolCall.id);
+              }
             });
             toolQueue = task.then(() => void 0, () => void 0);
             return task;
@@ -8136,6 +8295,9 @@ var AgentRuntime = class _AgentRuntime {
           result = await executeModel(executionContext);
         }
       }
+      if (result.type !== "input_required") {
+        this.cancelLiveInteractions(run.id, result.type === "failed" ? result.error instanceof Error ? result.error.message : "Model execution failed." : "Run ended.");
+      }
       await toolQueue;
       if (this.cancellationRequested.has(run.id) || controller.signal.aborted) {
         const output2 = latestAssistant(run, result.messages, executionContext.messages.length, true);
@@ -8209,6 +8371,7 @@ var AgentRuntime = class _AgentRuntime {
     } catch (error) {
       if (!claim && error instanceof RuntimeError && ["run_state_conflict", "runtime_ownership_lost", "run_not_found"].includes(error.code)) return;
       if (claim) {
+        this.cancelLiveInteractions(run.id, error instanceof Error ? error.message : "Execution failed.");
         await toolQueue;
         if (this.cancellationRequested.has(run.id)) {
           const reason = this.cancellationReasons.get(run.id) ?? "Agent run stopped.";
@@ -8445,11 +8608,17 @@ var AgentRuntime = class _AgentRuntime {
     }
     const results = suspension ? [...suspension.completedResults] : [];
     const startIndex = suspension ? suspension.pendingIndex : 0;
+    const active = this.executions.get(input.run.id);
     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.toolCallIds?.[index] ? suspension.toolCallIds[index] : suspension && index === suspension.pendingIndex && suspension.toolCallId ? suspension.toolCallId : createId("tool");
+      const toolCallId = input.providerInitiated && active?.providerToolCalls.has(providerToolCallId) ? active.providerToolCalls.get(providerToolCallId) : suspension && index >= suspension.pendingIndex && suspension.toolCallIds?.[index] ? suspension.toolCallIds[index] : suspension && index === suspension.pendingIndex && suspension.toolCallId ? suspension.toolCallId : createId("tool");
+      if (input.providerInitiated && !active?.providerToolCalls.has(providerToolCallId)) {
+        active?.providerToolCalls.set(providerToolCallId, toolCallId);
+      }
+      const isReserved = Boolean(active?.reservedToolCalls.has(toolCallId));
+      const isStarted = Boolean(active?.startedToolCalls.has(toolCallId));
       const protocolFailure = (error) => ({
         toolCallId: providerToolCallId,
         toolName: toolCall.name,
@@ -8458,20 +8627,23 @@ var AgentRuntime = class _AgentRuntime {
         error
       });
       if (!durableTool) {
-        const reserved = await this.owned.reserveToolCalls({
-          runId: input.run.id,
-          execution: input.execution,
-          expectedRevision: revision,
-          requestMessageId: createId("msg"),
-          contentBlocks: input.contentBlocks,
-          calls: [{
-            toolCallId,
-            providerToolCallId,
-            name: toolCall.name,
-            args: toJsonValue(toolCall.args)
-          }]
-        });
-        setRevision(reserved.run.revision);
+        if (!isReserved) {
+          const reserved = await this.owned.reserveToolCalls({
+            runId: input.run.id,
+            execution: input.execution,
+            expectedRevision: revision,
+            requestMessageId: createId("msg"),
+            contentBlocks: input.contentBlocks,
+            calls: [{
+              toolCallId,
+              providerToolCallId,
+              name: toolCall.name,
+              args: toJsonValue(toolCall.args)
+            }]
+          });
+          setRevision(reserved.run.revision);
+          active?.reservedToolCalls.add(toolCallId);
+        }
         const failed = await this.owned.commitToolResult({
           runId: input.run.id,
           execution: input.execution,
@@ -8537,7 +8709,7 @@ var AgentRuntime = class _AgentRuntime {
         reportProgress: () => {
         }
       };
-      const answer = suspension && index === suspension.pendingIndex ? suspension.interactionIds?.map((id) => input.driver?.answers().get(id)).find((value) => value !== void 0) : void 0;
+      const answer = suspension && index === suspension.pendingIndex ? suspension.interactionIds?.map((id) => input.driver?.answers().get(id)).find((value) => value !== void 0) : input.providerInitiated && input.interactionIds ? input.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({
@@ -8552,7 +8724,7 @@ var AgentRuntime = class _AgentRuntime {
               throw new Error("Tool call requested interaction but no interaction driver is active.");
             }
             interactionDriver.request(decision.interaction);
-            if (!resumedStart) {
+            if (!resumedStart && !isReserved) {
               const reserved = await this.owned.reserveToolCalls({
                 runId: input.run.id,
                 execution: input.execution,
@@ -8568,11 +8740,12 @@ var AgentRuntime = class _AgentRuntime {
                 }]
               });
               setRevision(reserved.run.revision);
+              active?.reservedToolCalls.add(toolCallId);
             }
             interactionDriver.suspend();
           }
           if ("allow" in decision && !decision.allow) {
-            if (!resumedStart) {
+            if (!resumedStart && !isReserved) {
               const reserved = await this.owned.reserveToolCalls({
                 runId: input.run.id,
                 execution: input.execution,
@@ -8588,6 +8761,7 @@ var AgentRuntime = class _AgentRuntime {
                 }]
               });
               setRevision(reserved.run.revision);
+              active?.reservedToolCalls.add(toolCallId);
             }
             const failed = await this.owned.commitToolResult({
               runId: input.run.id,
@@ -8625,7 +8799,7 @@ var AgentRuntime = class _AgentRuntime {
           throw error;
         }
         const reason = error instanceof Error ? error.message : "Tool policy rejected the call.";
-        if (!resumedStart) {
+        if (!resumedStart && !isReserved) {
           const reserved = await this.owned.reserveToolCalls({
             runId: input.run.id,
             execution: input.execution,
@@ -8641,6 +8815,7 @@ var AgentRuntime = class _AgentRuntime {
             }]
           });
           setRevision(reserved.run.revision);
+          active?.reservedToolCalls.add(toolCallId);
         }
         const failed = await this.owned.commitToolResult({
           runId: input.run.id,
@@ -8672,22 +8847,25 @@ var AgentRuntime = class _AgentRuntime {
         results.push(protocolFailure(reason));
         continue;
       }
-      if (!resumedStart) {
-        const reserved = await this.owned.reserveToolCalls({
-          runId: input.run.id,
-          execution: input.execution,
-          expectedRevision: revision,
-          requestMessageId: createId("msg"),
-          contentBlocks: input.contentBlocks,
-          calls: [{
-            toolCallId,
-            providerToolCallId,
-            name: toolCall.name,
-            args: toJsonValue(toolCall.args),
-            ...pendingPres
-          }]
-        });
-        setRevision(reserved.run.revision);
+      if (!resumedStart && !isStarted) {
+        if (!isReserved) {
+          const reserved = await this.owned.reserveToolCalls({
+            runId: input.run.id,
+            execution: input.execution,
+            expectedRevision: revision,
+            requestMessageId: createId("msg"),
+            contentBlocks: input.contentBlocks,
+            calls: [{
+              toolCallId,
+              providerToolCallId,
+              name: toolCall.name,
+              args: toJsonValue(toolCall.args),
+              ...pendingPres
+            }]
+          });
+          setRevision(reserved.run.revision);
+          active?.reservedToolCalls.add(toolCallId);
+        }
         const inProgressPres = await presentToolCall(durableTool, {
           status: "in_progress",
           args: toJsonValue(toolCall.args)
@@ -8705,6 +8883,7 @@ var AgentRuntime = class _AgentRuntime {
           ...currentToolState._meta !== void 0 ? { _meta: currentToolState._meta } : {}
         });
         setRevision(started.run.revision);
+        active?.startedToolCalls.add(toolCallId);
       }
       const toolResult2 = await this.executeAndCommitTool({
         runId: input.run.id,
@@ -8729,7 +8908,8 @@ var AgentRuntime = class _AgentRuntime {
         signal: input.signal,
         afterToolCall: input.toolConfig.afterToolCall,
         currentToolState,
-        options: input.options
+        options: input.options,
+        providerInitiated: input.providerInitiated
       });
       results.push(toolResult2);
     }
@@ -8901,13 +9081,15 @@ var AgentRuntime = class _AgentRuntime {
       };
     } catch (error) {
       if (error instanceof RunInteractionBoundary) {
-        const suspended = await this.owned.suspendToolCall({
-          runId: input.runId,
-          execution: input.execution,
-          expectedRevision: input.revision,
-          toolCallId: input.toolCallId
-        });
-        input.setRevision(suspended.run.revision);
+        if (!input.providerInitiated) {
+          const suspended = await this.owned.suspendToolCall({
+            runId: input.runId,
+            execution: input.execution,
+            expectedRevision: input.revision,
+            toolCallId: input.toolCallId
+          });
+          input.setRevision(suspended.run.revision);
+        }
         throw error;
       }
       if (error instanceof RunInteractionCancelledError) throw error;
@@ -9936,7 +10118,8 @@ var InMemoryStore = class _InMemoryStore {
       input.runId,
       input.expectedRevision,
       input.messageId ?? null,
-      input.configToken ?? null
+      input.configToken ?? null,
+      input.additionalContexts ?? null
     ]);
     const replay = this.replayOperation(operationKey, operationPayload);
     if (replay) return clone(replay);
@@ -9956,6 +10139,7 @@ var InMemoryStore = class _InMemoryStore {
     const committedMessages = [];
     if (!run.checkpoint && !run.initialMessageId && (!isControlRun(run) || hasUserInput(run.input))) {
       const userInput = normalizeUserInput(run.input);
+      const turnContexts = input.additionalContexts ?? [];
       const message = {
         id: input.messageId ?? createId("msg"),
         agentId: run.agentId,
@@ -9963,6 +10147,7 @@ var InMemoryStore = class _InMemoryStore {
         role: "user",
         content: userInputContent(userInput),
         ...userInputMetadata(userInput) ? { metadata: clone(userInputMetadata(userInput)) } : {},
+        ...turnContexts.length > 0 ? { contexts: clone(turnContexts) } : {},
         sequenceWithinRun: this.nextMessageSequence(run.id),
         createdAt: createTimestamp()
       };