@springbrand/agent-runtime 0.3.0-alpha.25 → 0.3.0-alpha.27

package/src/tools/codemode/executor.ts

@@ -0,0 +1,173 @@
+/// <reference lib="esnext.disposable" />
+import {
+  DynamicWorkerExecutor,
+  type ConnectorBinding,
+  type DynamicWorkerExecutorOptions,
+  type ExecuteResult,
+  type Executor,
+  type ResolvedProvider,
+} from "@cloudflare/codemode";
+import { RpcTarget } from "cloudflare:workers";
+
+const CONTROL = "__springbrand_execution_control";
+const SETUP = "__springbrand_execution_setup";
+const CANCELLED = "Code execution cancelled";
+
+interface AbortHandle {
+  abort(): Promise<void>;
+  dup(): AbortHandle;
+  [Symbol.dispose](): void;
+}
+
+function isAbortHandle(value: unknown): value is AbortHandle {
+  return (typeof value === "object" && value !== null || typeof value === "function") &&
+    typeof Reflect.get(value, "abort") === "function" &&
+    typeof Reflect.get(value, "dup") === "function" &&
+    typeof Reflect.get(value, Symbol.dispose) === "function";
+}
+
+class ExecutionControl extends RpcTarget {
+  #handle?: AbortHandle;
+  #registered = false;
+  #requested = false;
+  #aborting?: Promise<void>;
+  failure?: unknown;
+
+  constructor(readonly abortMessage: string) {
+    super();
+  }
+
+  async callTool(method: string, value: unknown): Promise<void> {
+    if (method !== "register" || this.#registered || !isAbortHandle(value)) {
+      throw new Error("Invalid Code Mode cancellation registration");
+    }
+    this.#registered = true;
+    this.#handle = value.dup();
+    if (this.#requested) {
+      this.abort();
+      await this.#aborting;
+    }
+  }
+
+  abort(): void {
+    this.#requested = true;
+    const handle = this.#handle;
+    if (!handle || this.#aborting) return;
+    this.#aborting = Promise.resolve().then(() => handle.abort()).then(
+      () => undefined,
+      (error: unknown) => {
+        if (!(error instanceof Error && error.message === this.abortMessage)) {
+          this.failure = error;
+        }
+      },
+    );
+  }
+
+  async close(): Promise<void> {
+    this.abort();
+    await this.#aborting;
+    try {
+      this.#handle?.[Symbol.dispose]();
+    } catch (error) {
+      this.failure = error;
+    } finally {
+      this.#handle = undefined;
+    }
+  }
+}
+
+class GuardedConnector extends RpcTarget {
+  constructor(
+    readonly binding: ConnectorBinding["binding"],
+    readonly check: () => void,
+  ) {
+    super();
+  }
+
+  async callTool(method: string, args: unknown): Promise<unknown> {
+    this.check();
+    return await this.binding.callTool(method, args);
+  }
+}
+
+function setup(abortMessage: string): string {
+  return `await (async () => {
+    const { RpcTarget } = await import("cloudflare:workers");
+    const context = this.ctx;
+    if (typeof context.abort !== "function") throw new Error("Native Code Mode cancellation is unavailable");
+    const abort = context.abort.bind(context);
+    const reason = new Error(${JSON.stringify(abortMessage)});
+    class Cancellation extends RpcTarget {
+      abort() { abort(reason); }
+    }
+    await ${CONTROL}.register(new Cancellation());
+  })();`;
+}
+
+/** Cancels a native sandbox pass, not its Host effects or the loaded Worker isolate. */
+export function createCodeExecutionExecutor(
+  options: DynamicWorkerExecutorOptions,
+  signal?: AbortSignal,
+): Executor {
+  const executor = new DynamicWorkerExecutor(options);
+  return {
+    async execute(code, providersOrFns, executeOptions): Promise<ExecuteResult> {
+      if (signal?.aborted) return { result: undefined, error: CANCELLED };
+      const providers: ResolvedProvider[] = Array.isArray(providersOrFns)
+        ? providersOrFns
+        : [{ name: "codemode", fns: providersOrFns }];
+      const connectors = executeOptions?.connectors ?? [];
+      if ([...providers, ...connectors].some(({ name }) => name === CONTROL || name === SETUP)) {
+        return { result: undefined, error: "Code execution uses a reserved namespace" };
+      }
+      const control = new ExecutionControl(`Code Mode pass aborted (${crypto.randomUUID()})`);
+      let ended = false;
+      const check = () => {
+        if (signal?.aborted || ended) throw new Error(CANCELLED);
+      };
+      const onAbort = () => control.abort();
+      signal?.addEventListener("abort", onAbort, { once: true });
+      let result: ExecuteResult;
+      try {
+        if (signal?.aborted) return { result: undefined, error: CANCELLED };
+        result = await executor.execute(code, [{
+          name: SETUP,
+          fns: {},
+          prelude: setup(control.abortMessage),
+        }, ...providers.map((provider) => ({
+          ...provider,
+          fns: Object.fromEntries(Object.entries(provider.fns).map(([name, fn]) => [
+            name,
+            async (...args: unknown[]) => {
+              check();
+              return await fn(...args);
+            },
+          ])),
+        }))], {
+          ...executeOptions,
+          connectors: [{
+            name: CONTROL,
+            binding: control,
+          }, ...connectors.map((connector) => ({
+            ...connector,
+            binding: new GuardedConnector(connector.binding, check),
+          }))],
+        });
+      } catch (error) {
+        result = {
+          result: undefined,
+          error: error instanceof Error && error.message === control.abortMessage
+            ? CANCELLED
+            : error instanceof Error ? error.message : String(error),
+        };
+      } finally {
+        ended = true;
+        signal?.removeEventListener("abort", onAbort);
+        // A returned SDK timeout is only a soft race; stop the native pass too.
+        await control.close();
+      }
+      if (control.failure) return { result: undefined, error: "Failed to stop the Code Mode pass" };
+      return signal?.aborted ? { result: undefined, error: CANCELLED } : result;
+    },
+  };
+}

package/src/tools/codemode/index.ts

@@ -1,3 +1,4 @@
+import { truncateResult } from "@cloudflare/codemode";
 import type { AgentTool, AgentToolResult } from "@earendil-works/pi-agent-core";
 import { Type } from "@earendil-works/pi-ai";
 import type { RuntimeCodeExecutionPort } from "../../config/ports";
@@ -86,17 +87,18 @@ function browserResult(details: unknown): AgentToolResult<unknown> {
   }
 
   const image = record(inner?.image);
+  const nativeImage = inner?.type === "browser_screenshot" ? inner : undefined;
   const screenshotArgs = record(screenshotCall?.args);
   const screenshotResult = record(screenshotCall?.result);
   const format = record(screenshotArgs?.params)?.format;
   const data = typeof image?.data === "string"
     ? image.data
-    : screenshotResult?.data;
+    : nativeImage ? nativeImage.data : screenshotResult?.data;
   const mimeType = typeof image?.mimeType === "string"
     ? image.mimeType
-    : screenshotMimeType(format);
-  if (!(inner && "image" in inner) && typeof data !== "string") {
-    return result(details);
+    : nativeImage ? nativeImage.mediaType : screenshotMimeType(format);
+  if (!(inner && "image" in inner) && !nativeImage && typeof data !== "string") {
+    return result("result" in outer ? { ...outer, result: truncateResult(rawResult) } : details);
   }
   const projectedImage = browserImageMetadata(data, mimeType);
 
@@ -127,10 +129,9 @@ function browserResult(details: unknown): AgentToolResult<unknown> {
   const projectedDetails = {
     ...outer,
     result: inner
-      ? {
-        ...inner,
-        image: projectedImage,
-      }
+      ? nativeImage
+        ? { ...inner, data: projectedImage }
+        : { ...inner, image: projectedImage }
       : {
         image: projectedImage,
         note: "Screenshot recovered from the Page.captureScreenshot result.",
@@ -172,30 +173,18 @@ function runCodemode(
 ): AgentTool<typeof executeParameters>["execute"] {
   return async (_toolCallId, input, signal) => {
     signal?.throwIfAborted();
-    // ponytail: 外层截止只保证 Agent 继续；Codemode 支持 AbortSignal 或宿主 dispose 后再终止底层执行。
-    let timeout: ReturnType<typeof setTimeout> | undefined;
-    const deadline = new Promise<{
-      status: "error";
-      code: "timeout";
-      error: string;
-      retryable: false;
-      outcome: "unknown";
-    }>((resolve) => {
-      timeout = setTimeout(() => resolve({
-        status: "error",
-        code: "timeout",
-        error:
-          `${label} exceeded ${CODEMODE_EXECUTE_TIMEOUT_MS} ms; ` +
-          "use existing results and state the missing evidence.",
-        retryable: false,
-        outcome: "unknown",
-      }), CODEMODE_EXECUTE_TIMEOUT_MS);
-    });
+    const execution = new AbortController();
+    const cancel = () => execution.abort(signal?.reason);
+    signal?.addEventListener("abort", cancel, { once: true });
+    // The first abort reason distinguishes a parent cancellation from our deadline.
+    const timeout = setTimeout(() => execution.abort(new Error(
+      `${label} exceeded ${CODEMODE_EXECUTE_TIMEOUT_MS} ms; ` +
+      "use existing results and state the missing evidence.",
+    )), CODEMODE_EXECUTE_TIMEOUT_MS);
     try {
-      const output = await Promise.race([
-        runtime.execute(input),
-        deadline.then(result),
-      ]);
+      // The Port settles only after the executor and connector cleanup finish.
+      const output = await runtime.execute(input, { signal: execution.signal });
+      execution.signal.throwIfAborted();
       const details = output.details as { status?: unknown; error?: unknown } | null;
       if (details?.status === "error") {
         throw new Error(typeof details.error === "string"
@@ -203,8 +192,12 @@ function runCodemode(
           : `${label} failed`);
       }
       return project(output);
+    } catch (error) {
+      execution.signal.throwIfAborted();
+      throw error;
     } finally {
-      if (timeout !== undefined) clearTimeout(timeout);
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", cancel);
     }
   };
 }

package/src/tools/runtime/compiler.ts

@@ -146,6 +146,9 @@ export function compileHarnessTools(
   options: CompileHarnessToolsOptions = {},
 ): ToolRegistration<any, any>[] {
   return candidates.map((candidate) => {
+    if (candidate.interaction && candidate.prerequisite) {
+      throw new Error(`Tool ${candidate.tool.name} cannot declare both interaction and prerequisite`);
+    }
     const source = candidate.tool;
     const tool = source.constrainedSampling === false
       ? source
@@ -182,6 +185,11 @@ export function compileHarnessTools(
         const signal = context.abortSignal ?? new AbortController().signal;
         let result: AgentToolResult<unknown>;
         try {
+          // A declined prerequisite must not recheck account authorization or dispatch an effect.
+          if (candidate.prerequisite) {
+            const decided = await options.resolveReplay?.(candidate, toolCallId, args);
+            if (decided) return durableResult(decided, candidate, options.workspace);
+          }
           await options.authorize?.(candidate, args, {
             toolCallId,
             signal,

package/src/tools/runtime/contracts.ts

@@ -4,6 +4,15 @@ import type { ApprovalReceipt } from "../../submission/contracts";
 import { type BudgetPolicy } from "../../context/memory/budget/gate";
 import { type SpillWorkspace } from "../../lib/artifacts";
 import { type ExecutionLevel } from "../../lib/execution-level";
+import type { ToolPrerequisitePresentation } from "./prerequisite-contracts";
+
+export type {
+  ToolPrerequisiteDecision,
+  ToolPrerequisiteIdentity,
+  ToolPrerequisitePresentation,
+  ToolPrerequisiteRequest,
+  ToolPrerequisiteResponse,
+} from "./prerequisite-contracts";
 
 // 本文件沿用 `src/index.ts` 入口定义的 Tool Candidate 和 Tool Settlement 术语。
 
@@ -28,6 +37,51 @@ export interface PiToolInteractionSpec {
   ) => Omit<AgentToolResult<unknown>, "terminate">;
 }
 
+export interface PiToolPrerequisiteContext {
+  readonly submissionId: string;
+  readonly requestId: string;
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly signal: AbortSignal;
+}
+
+export type PiToolPrerequisiteCheck =
+  | {
+      readonly status: "ready";
+      /** Optional bounded verification receipt, in epoch milliseconds (at most 60s). */
+      readonly validUntil?: number;
+    }
+  | {
+      readonly status: "needs-input";
+      readonly presentation: ToolPrerequisitePresentation;
+    };
+
+/**
+ * A separate, pre-effect condition, NOT a client-settled answer.
+ * Callbacks close over trusted Host dependencies. They never start authorization
+ * or the business effect, and receive independent copies of validated input.
+ * Host checkers own cache/in-flight reuse.
+ */
+export interface PiToolPrerequisiteSpec {
+  /** Derive before live checking. Null means this input has no prerequisite. */
+  readonly scope: (
+    input: unknown,
+    context: PiToolPrerequisiteContext,
+  ) => string | null | Promise<string | null>;
+  readonly check: (
+    input: unknown,
+    context: PiToolPrerequisiteContext & {
+      readonly scopeKey: string;
+      readonly reason: "initial" | "recheck" | "continuation";
+    },
+  ) => PiToolPrerequisiteCheck | Promise<PiToolPrerequisiteCheck>;
+  /** Optional domain-specific English non-execution result, from trusted metadata. */
+  readonly declinedResult?: (
+    input: unknown,
+    presentation: ToolPrerequisitePresentation,
+  ) => Omit<AgentToolResult<unknown>, "terminate">;
+}
+
 /** Trusted Tool metadata used to evaluate a scheduled task grant. */
 export interface PiToolUnattendedExecutionSpec {
   readonly capability: string;
@@ -89,6 +143,8 @@ export interface PiToolCandidate<
   readonly summary?: string;
   readonly source?: ApprovalReceipt["source"];
   readonly interaction?: PiToolInteractionSpec;
+  /** Conditions resume the original execute; cannot coexist with interaction. */
+  readonly prerequisite?: PiToolPrerequisiteSpec;
   /** Large payloads spill by default; protocol-shaped results opt into structure. */
   readonly outputBudget?: BudgetPolicy;
   /**

package/src/tools/runtime/decision-gate.ts

@@ -10,6 +10,8 @@ import type { ApprovalRepository } from "./approval";
 import type { PiToolCandidate } from "./contracts";
 import type { ToolInteractionRepository } from "./interaction";
 import { UnattendedExecutionError } from "./unattended-error";
+import { HarnessPrerequisiteGate } from "./prerequisite-gate";
+import { declinedPrerequisiteResult } from "./prerequisites";
 
 export interface HarnessDecisionSubmission {
   readonly submissionId: string;
@@ -28,6 +30,7 @@ export interface HarnessDecisionGateOptions {
   readonly approvals: ApprovalRepository;
   readonly interactions: ToolInteractionRepository;
   readonly transaction: <T>(run: () => T) => T;
+  readonly isSubmissionActive?: () => boolean;
   readonly release: (reason: "approval" | "interaction") => void;
   readonly telemetry?: Pick<RuntimeTelemetryCoordinator, "capture">;
   readonly onChanged?: (
@@ -79,11 +82,20 @@ function interactionResult(
 /** Durable policy facts around Pi's before_tool hook; Pi owns execution state. */
 export class HarnessDecisionGate {
   private readonly candidates: ReadonlyMap<string, PiToolCandidate>;
+  private readonly prerequisites: HarnessPrerequisiteGate;
 
   constructor(private readonly options: HarnessDecisionGateOptions) {
     this.candidates = new Map(
       options.candidates.map((candidate) => [candidate.tool.name, candidate]),
     );
+    this.prerequisites = new HarnessPrerequisiteGate({
+      submission: options.submission, interactions: options.interactions,
+      transaction: options.transaction, isSubmissionActive: options.isSubmissionActive,
+      onChanged: (id) => options.onChanged?.("interaction", id),
+      ...(options.submission.origin === "scheduled" ? {
+        onNeedsInput: (name: string) => this.denyUnattended(`SCHEDULED_EXECUTION_REQUIRES_INTERACTION: ${name}`),
+      } : {}),
+    });
   }
 
   readonly beforeTool = async (event: { toolName: string; toolCallId: string; args: unknown }, context: import("@earendil-works/chord").Context): Promise<{ block: string } | undefined> => {
@@ -118,6 +130,27 @@ export class HarnessDecisionGate {
     if (existing?.status === "rejected") {
       return { block: existing.reason ?? "Tool execution denied by user" };
     }
+    if (candidate.prerequisite || this.options.interactions.find(executionId)?.purpose === "prerequisite") {
+      try {
+        const condition = await this.prerequisites.beforeTool(candidate, event.args, {
+          toolCallId: event.toolCallId, signal: operationSignal(context.abortSignal),
+        });
+        if (condition === "pending") {
+          if (this.options.submission.origin === "scheduled") {
+            await this.denyUnattended(`SCHEDULED_EXECUTION_REQUIRES_INTERACTION: ${candidate.tool.name}`);
+          }
+          this.options.release("interaction");
+          return waitForRelease(operationSignal(context.abortSignal));
+        }
+        // A refusal is a non-execution Tool result, not approval of the business effect.
+        if (condition === "decided") return undefined;
+      } catch (error) {
+        if (error instanceof UnattendedExecutionError) return { block: error.message };
+        if (this.options.submission.origin !== "scheduled") throw error;
+        const reason = error instanceof Error ? error.message : String(error);
+        await this.denyUnattended(`SCHEDULED_EXECUTION_PREREQUISITE_CHECK_FAILED: ${candidate.tool.name}: ${reason}`);
+      }
+    }
     if (needsApproval && !unattendedAuthorized && existing?.status !== "approved") {
       if (!existing) {
         const prepared = candidate.confirmation
@@ -221,6 +254,16 @@ export class HarnessDecisionGate {
       );
     }
     this.assertUnattendedActive();
+    if (candidate.prerequisite) {
+      try {
+        await this.prerequisites.authorize(candidate, args, invocation);
+      } catch (error) {
+        if (this.options.submission.origin !== "scheduled") throw error;
+        await this.denyUnattended(`SCHEDULED_EXECUTION_PREREQUISITE_CHECK_FAILED: ${candidate.tool.name}`);
+      }
+    }
+    invocation.signal.throwIfAborted();
+    if (this.options.isSubmissionActive?.() === false) throw new Error("Tool Submission is no longer active");
   }
 
   private assertUnattendedActive(): void {
@@ -308,10 +351,22 @@ export class HarnessDecisionGate {
     toolCallId: string,
     args: unknown,
   ): AgentToolResult<unknown> | undefined {
-    if (!candidate.interaction) return undefined;
     const interaction = this.options.interactions.find(
       `${this.options.submission.submissionId}:${toolCallId}`,
     );
+    if (interaction?.purpose === "prerequisite") {
+      if (interaction.requestId !== this.options.submission.requestId ||
+        interaction.toolName !== candidate.tool.name || interaction.inputJson !== stableInput(args)) {
+        throw new Error(`Conflicting durable Tool prerequisite: ${toolCallId}`);
+      }
+      if (interaction.status === "declined") return declinedPrerequisiteResult(interaction, args, candidate.prerequisite);
+      if (interaction.status === "cancelled") return {
+        content: [{ type: "text", text: "The prerequisite wait was cancelled. This operation was not executed." }],
+        details: { cancelled: true, executed: false },
+      };
+      return undefined;
+    }
+    if (!candidate.interaction) return undefined;
     if (!interaction || interaction.status === "pending") return undefined;
     if (interaction.inputJson !== stableInput(args)) {
       throw new Error(`Conflicting durable Tool interaction: ${toolCallId}`);

package/src/tools/runtime/human-decisions.ts

@@ -1,8 +1,9 @@
 import type { ApprovalDecision } from "../../submission/contracts";
 import type { RuntimeTelemetryCoordinator } from "../../telemetry/coordinator";
 import type { ApprovalRepository } from "./approval/repository";
-import type { PiToolInteractionSpec } from "./contracts";
+import type { PiToolInteractionSpec, PiToolPrerequisiteSpec, ToolPrerequisiteResponse } from "./contracts";
 import type { StoredToolInteraction, ToolInteractionRepository } from "./interaction/repository";
+import { matchesPrerequisite, normalizePrerequisiteCheck, parsePrerequisiteResponse } from "./prerequisites";
 
 /** Human decisions own validation and durable facts; the caller resumes Pi. */
 export class HarnessHumanDecisions {
@@ -33,7 +34,7 @@ export class HarnessHumanDecisions {
       response: unknown;
     }) => Promise<unknown | null>,
   ): Promise<boolean> {
-    if (!this.options.isSubmissionActive(pending.submissionId) ||
+    if (pending.purpose !== "answer" || !this.options.isSubmissionActive(pending.submissionId) ||
       this.options.interactions.find(pending.interactionId)?.status !== "pending") return false;
     let input: unknown;
     try { input = JSON.parse(pending.inputJson); } catch { return false; }
@@ -63,6 +64,70 @@ export class HarnessHumanDecisions {
     });
   }
 
+  /** Control decisions never pass through the answer/attachment preparation hook. */
+  async respondPrerequisite(
+    pending: StoredToolInteraction,
+    spec: PiToolPrerequisiteSpec | undefined,
+    response: ToolPrerequisiteResponse,
+    signal: AbortSignal = new AbortController().signal,
+  ): Promise<{ ok: boolean; resume: boolean }> {
+    const denied = { ok: false, resume: false };
+    const identity = parsePrerequisiteResponse(response);
+    const current = identity ? this.options.interactions.find(identity.id) : null;
+    if (!identity || !matchesPrerequisite(pending, identity) || !matchesPrerequisite(current, identity) ||
+      current.status !== "pending" || !this.options.isSubmissionActive(current.submissionId)) return denied;
+    let scopeKey = identity.scopeKey;
+    let check: ReturnType<typeof normalizePrerequisiteCheck> | undefined;
+    let declined = identity.decision === "declined";
+    if (!declined) {
+      if (!spec) return denied;
+      const input: unknown = JSON.parse(current.inputJson);
+      const context = {
+        submissionId: current.submissionId, requestId: current.requestId,
+        toolCallId: current.toolCallId, toolName: current.toolName, signal,
+      };
+      const derived = await spec.scope(structuredClone(input), context);
+      signal.throwIfAborted();
+      const stillPending = this.options.interactions.find(identity.id);
+      if (!matchesPrerequisite(stillPending, identity) || stillPending.status !== "pending" ||
+        !this.options.isSubmissionActive(stillPending.submissionId)) return denied;
+      if (derived !== null && (typeof derived !== "string" || !derived.trim())) {
+        throw new Error("Invalid trusted Tool prerequisite scope");
+      }
+      scopeKey = derived ?? identity.scopeKey;
+      declined = Boolean(this.options.interactions.findDeclinedScope(current.submissionId, scopeKey));
+      if (!declined) check = normalizePrerequisiteCheck(derived === null ? { status: "ready" } :
+        await spec.check(structuredClone(input), { ...context, scopeKey, reason: "recheck" }));
+      signal.throwIfAborted();
+    }
+    return this.options.transaction(() => {
+      const latest = this.options.interactions.find(identity.id);
+      if (!matchesPrerequisite(latest, identity) || latest.status !== "pending" ||
+        !this.options.isSubmissionActive(latest.submissionId) || signal.aborted) return denied;
+      const refused = this.options.interactions.findDeclinedScope(latest.submissionId, scopeKey);
+      const status = declined || refused ? "declined" : check!.status;
+      const sameScope = scopeKey === identity.scopeKey;
+      // Include same-scope calls that parked while the Host verification was in flight.
+      const group = sameScope
+        ? this.options.interactions.listPendingForScope(latest.submissionId, scopeKey) : [latest];
+      for (const sibling of group) {
+        const row = this.options.interactions.find(sibling.interactionId);
+        if (row?.status !== "pending" || row.version !== sibling.version || row.scopeKey !== sibling.scopeKey) continue;
+        this.options.interactions.updatePrerequisite(row.interactionId, { status: row.status, version: row.version }, {
+          status, scopeKey,
+          presentationJson: refused?.presentationJson ?? check?.presentationJson ?? row.presentationJson,
+          verifiedUntil: status === "ready" ? check!.verifiedUntil : null,
+          renew: !sameScope || status === "pending",
+        });
+        if (status !== "pending") this.options.telemetry.capture("interactionResponded", {
+          submissionId: row.submissionId, toolCallId: row.toolCallId,
+          interactionId: row.interactionId, response: { decision: status }, occurredAt: Date.now(),
+        });
+      }
+      return { ok: true, resume: status !== "pending" };
+    });
+  }
+
   approve(executionId: string, decision: ApprovalDecision): { ok: boolean; submissionId?: string } {
     if (decision.decision === "allow_level") {
       throw new Error("allow_level must be applied by the User Agent Host before resuming the Tool");
@@ -122,6 +187,7 @@ export class HarnessHumanDecisions {
         });
       }
       this.cancelInteractions(submissionId, reason);
+      this.options.interactions.cancelReadyPrerequisites(submissionId);
     });
   }
 }