@rowan-agent/agent 0.19.0 → 0.19.2

package/dist/index.d.ts

@@ -1689,6 +1689,8 @@ type RunInteractionDriver = Readonly<{
     answers(): ReadonlyMap<string, JsonValue>;
     checkpoint(): JsonValue | undefined;
     clearCheckpoint(): void;
+    answer?(id: string, value: JsonValue): void;
+    clearAnswer?(id: string): void;
     suspend(input?: Readonly<{
         checkpoint?: JsonValue;
     }>): never;
@@ -2029,7 +2031,14 @@ type ModelRetry = Readonly<{
     delayMs: number;
     error: string;
 }>;
-type RunEvent = DurableRunEvent | MessageDelta | ThinkingDelta | ToolCallDelta | PhaseStatusEvent | ModelRetry | Extract<ToolStateChanged, {
+type LiveInteractionEvent = Readonly<{
+    kind: "live_interaction";
+    durability: "transient";
+    runId: RunId;
+    executionId?: ExecutionId;
+    interaction: RunInteraction;
+}>;
+type RunEvent = DurableRunEvent | MessageDelta | ThinkingDelta | ToolCallDelta | PhaseStatusEvent | ModelRetry | LiveInteractionEvent | Extract<ToolStateChanged, {
     durability: "transient";
 }>;
 
@@ -2408,6 +2417,8 @@ declare class AgentRuntime implements AgentRuntime$1 {
     private readonly retryDelayMs?;
     private constructor();
     static init(options: AgentRuntimeOptions): Promise<AgentRuntime>;
+    private publishLiveInteraction;
+    private cancelLiveInteractions;
     private handleRunEnd;
     loadAgents(input: LoadInput<AgentDefinition>): Promise<LoadResult>;
     loadSkills(input: LoadInput<Skill>): Promise<LoadResult>;
@@ -3292,4 +3303,4 @@ declare function parseFrontmatter<T = Record<string, unknown>>(raw: string): Fro
 
 declare function createCoreTools(input?: CoreToolContext): Tool$1[];
 
-export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EntryPhaseSpec, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionCapability, type ExtensionCapabilityContribution, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, type ExtensionHost, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type ExtensionStateStore, type ExtensionToolContribution, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, type HostContribution, InMemoryConfigProvider, InMemoryExtensionHost, InMemoryStore, type InteractionRecord, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type ModelRetry, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEndEvent, type RunEvent, type RunFailure, type RunId, type RunInteraction, RunInteractionBoundary, RunInteractionCancelledError, type RunInteractionDriver, type RunInteractionKind, type RunInteractionRequest, type RunInteractionState, type RunInteractionStatus, type RunListCursor, type RunRecord, type RunSnapshot, type RunStartEvent, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type SettingsBadge, type SettingsControl, type SettingsDefinition, type SettingsItem, type SettingsOption, type SettingsSection, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool$1 as Tool, type ToolCallContext, type ToolCallDelta, type ToolCallId, type ToolCallPresentationInput, type ToolCallPresentationOutput, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, type WithdrawnUserInput, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhases, loadSkill, loadSkills, mergeToolCall, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };
+export { type AfterToolCall, type AgentConfiguration, type AgentDefinition, type AgentId, type AgentListCursor, type AgentRecord, type AgentRun, AgentRuntime, type AgentRuntimeOptions, type AgentSummary, type AnyRuntimeError, type AssistantContent, type AssistantMessage, type BeforeToolCall, COMPACT_PHASE_ID, type ConfigProvider, type ConfigPutResult, type ConfigResolution, type ConfigToken, type ConfigurationSnapshot, type ContextCandidate, type ContextCompactionRecord, type ContextStatus, type CoreToolContext, DEFAULT_PHASE_ID, type DefinitionLayer, type DurableConsumer, type DurableRunEvent, type DurableStore, type DurableToolResult, type EntryPhaseSpec, type EventCursor, type EventId, type ExecutionCheckpoint, type ExecutionId, type ExecutionToken, type ExtensionAPI, type ExtensionActivationError, type ExtensionActivationResult, type ExtensionCapability, type ExtensionCapabilityContribution, type ExtensionContribution, type ExtensionDisposer, type ExtensionFactory, type ExtensionFactoryResult, type ExtensionHost, ExtensionLifetimeError, type ExtensionLifetimeErrorCode, type ExtensionLoadInput, type ExtensionStateStore, type ExtensionToolContribution, type FrontmatterResult, type HistorySeed, type HookEvent, type HookEventType, type HookHandler, type HostContribution, InMemoryConfigProvider, InMemoryExtensionHost, InMemoryStore, type InteractionRecord, type InvocationCatalogEntry, type InvocationSource, type JsonObject, type JsonPrimitive, type JsonValue, type LiveInteractionEvent, type LoadExtensionsResult, type LoadInput, type LoadResult, type LoadedExtension, type Message, type MessageBase, type MessageCommitted, type MessageContent, type MessageDelta, type MessageId, type MessageRevised, type MessageRevisionResult, type Metadata, type ModelRetry, type OpaqueId, type Outcome, type OwnerLease, type OwnerToken, type Page, type Phase, type PhaseContext, type PhaseContribution, type PhaseExecution, type PhaseExecutionIdentity, type PhaseInput, type PhaseInvocation, type PhaseMessageManager, type PhaseOutput, type PhaseRegistry, type PhaseRegistrySelection, type PhaseState, type PhaseStatus, type PhaseStatusState, type ResolvedResourceView, type ResourceDiagnostic, type ResourceKind, type ResourceRef, ResourceRegistry, ResourceRegistryError, type ResourceRegistryErrorCode, type ResourceSourceId, type ResourceView, type RetentionResult, type RunBoundary, type RunClaim, type RunEndEvent, type RunEvent, type RunFailure, type RunId, type RunInteraction, RunInteractionBoundary, RunInteractionCancelledError, type RunInteractionDriver, type RunInteractionKind, type RunInteractionRequest, type RunInteractionState, type RunInteractionStatus, type RunListCursor, type RunRecord, type RunSnapshot, type RunStartEvent, type RunState, type RunStateChanged, type RunSummary, RuntimeBootstrapRegistry, RuntimeError, type RuntimeErrorCode, type RuntimeErrorDetails, RuntimeExtensionLifetime, STOP_PHASE_ID, type SettingsBadge, type SettingsControl, type SettingsDefinition, type SettingsItem, type SettingsOption, type SettingsSection, type Skill, SqliteStore, type TextContent, type ThinkingContent, type ThinkingDelta, type Tool$1 as Tool, type ToolCallContext, type ToolCallDelta, type ToolCallId, type ToolCallPresentationInput, type ToolCallPresentationOutput, type ToolCallSnapshot, type ToolCallState, type ToolContribution, type ToolDefinition, type ToolExecutionResult, type ToolInvocationContext, type ToolMessage, type ToolMessageContent, type ToolResultContent, type ToolStateChanged, type ToolUseContent, type UserContent, type UserInput, type UserMessage, type WithdrawnUserInput, brandConfigToken, createCompactPhase, createCorePhases, createCoreTools, createDefaultPhase, createStopPhase, isConfigurationSnapshot, isRuntimeError, loadExtensionsFromPath as loadExtensions, loadPhase, loadPhases, loadSkill, loadSkills, mergeToolCall, parseAgentDefinition, parseFrontmatter, resolveConfigurationSnapshot };

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();
@@ -3607,7 +3620,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 +3666,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 +3682,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;
@@ -3751,7 +3766,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) => {
@@ -5340,7 +5355,6 @@ var TransientRunEventSubscription = class {
   stop() {
     if (this.stopped) return;
     this.stopped = true;
-    this.queue.length = 0;
     this.notify();
   }
   notify() {
@@ -7217,6 +7231,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 +7373,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 +7659,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 +7688,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 +7720,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 +7739,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);
@@ -7845,7 +7868,13 @@ var AgentRuntime = class _AgentRuntime {
       });
       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);
@@ -8077,25 +8106,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 +8270,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 +8346,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 +8583,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 +8602,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 +8684,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 +8699,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 +8715,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 +8736,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 +8774,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 +8790,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 +8822,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 +8858,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 +8883,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 +9056,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;

package/package.json

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