@mono-agent/agent-runtime 0.20.11 → 0.21.0

package/src/ai/providers/pi-native/stream-subscriber.js

@@ -32,12 +32,30 @@ function toolResultOutcome(result) {
     code: "code",
     backend: "backend",
     signal: "signal",
+    contentKind: "content_kind",
+    charset: "charset",
+    charsetSource: "charset_source",
+    extractionStage: "extraction_stage",
+    renderReason: "render_reason",
+    retryAt: "retry_at",
+    nextAction: "next_action",
   };
   const numbers = {
     attempts: "attempts",
+    queueWaitMs: "queue_wait_ms",
+    backendDurationMs: "backend_duration_ms",
+    retryAfterMs: "retry_after_ms",
+    maxRequestsPerRun: "max_requests_per_run",
+    requestsThisCall: "requests_this_call",
+    requestsUsed: "requests_used",
+    requestsRemaining: "requests_remaining",
+    cooldownSkipCount: "cooldown_skip_count",
+    quotaSkipCount: "quota_skip_count",
     bytes: "bytes",
     exitCode: "exit_code",
     statusCode: "status_code",
+    redirectCount: "redirect_count",
+    parserFailureCount: "parser_failure_count",
   };
   const booleans = {
     retryable: "retryable",
@@ -45,6 +63,11 @@ function toolResultOutcome(result) {
     truncated: "truncated",
     timedOut: "timed_out",
     rendered: "rendered",
+    renderFailed: "render_failed",
+    browserRecommended: "browser_recommended",
+    retryInRun: "retry_in_run",
+    fallbackUsed: "fallback_used",
+    hadDecodingReplacement: "had_decoding_replacement",
   };
   for (const [input, output] of Object.entries(strings)) {
     if (typeof source[input] === "string") bounded[output] = source[input].slice(0, 120);
@@ -76,8 +99,8 @@ function toolResultOutcome(result) {
 
 /**
  * Build the harness subscribe handler. `harness` is passed for the maxTurns
- * abort; it is already constructed when this is wired (subscribe follows the
- * AgentHarness constructor).
+ * abort; it is already constructed when this is wired (subscribe follows
+ * AgentHarness.create()).
  * @param {StreamSubscriberState} runState
  * @param {{onEvent: (event: any) => void, options: any, toolLimits: any, harness: any, sdk: string, model: string}} deps
  * @returns {(event: any) => void}
@@ -107,21 +130,44 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
           onEvent({ type: "assistant", message: { content: [{ type: "thinking", text: streamEvent.content }] } });
         }
       }
-    } else if (event.type === "message_end") {
+    } else if (event.type === "message_end" && event.message?.role === "assistant") {
       const contextUsage = contextUsageFromAssistantMessage(event.message);
       if (contextUsage) {
+        const { costUsd, ...contextTokens } = contextUsage;
         const contextWindow = Number(harness?.getModel?.()?.contextWindow) || 0;
         const measurementId = typeof event.message?.id === "string" && event.message.id.trim().length > 0
           ? event.message.id
           : undefined;
         onEvent({
           type: "context_usage",
+          ...harness?.getPromptCacheRequest?.(),
           sdk,
           model,
           timestamp: Date.now(),
           ...(measurementId === undefined ? {} : { measurementId }),
           ...(contextWindow > 0 ? { contextWindow } : {}),
-          tokens: contextUsage,
+          tokens: contextTokens,
+          costUsd,
+          providerCostUsd: typeof event.message.usage?.cost?.total === "number" && Number.isFinite(event.message.usage.cost.total) && event.message.usage.cost.total >= 0 ? event.message.usage.cost.total : null,
+          costSource: "pi_usage",
+        });
+      }
+      const hasVisibleContent = Array.isArray(event.message?.content)
+        && event.message.content.some((block) => block
+          && typeof block === "object"
+          && ((block.type === "text"
+            && typeof block.text === "string"
+            && block.text.length > 0)
+            || (block.type === "thinking"
+              && ((typeof block.thinking === "string" && block.thinking.length > 0)
+                || (typeof block.text === "string" && block.text.length > 0)))));
+      if (hasVisibleContent) {
+        const messageId = typeof event.message?.id === "string" && event.message.id.trim().length > 0
+          ? event.message.id
+          : undefined;
+        onEvent({
+          type: "assistant_message_boundary",
+          ...(messageId === undefined ? {} : { messageId }),
         });
       }
     } else if (event.type === "tool_execution_start") {
@@ -198,7 +244,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
       });
     } else if (event.type === "turn_end") {
       runState.turnCount += 1;
-      // NON-DELEGABLE (verified against @earendil-works/pi-agent-core 0.80.3).
+      // NON-DELEGABLE (verified against @earendil-works/pi-agent-core 0.85.1).
       // pi's only after-turn stop hook is `shouldStopAfterTurn` on the LOW-LEVEL
       // `AgentLoopConfig` (dist/types.d.ts) — the config passed to the raw
       // `agentLoop`. It is NOT surfaced on `AgentHarnessOptions`
@@ -217,7 +263,7 @@ export function createStreamSubscriber(runState, { onEvent, options, toolLimits,
         && runState.turnCount >= Number(options.maxTurns)
         && event.message?.stopReason === "toolUse") {
         runState.maxTurnsHit = true;
-        harness.abort();
+        void Promise.resolve(harness.abort()).catch(() => {});
       }
     }
   };

package/src/ai/providers/pi-native/terminal-recovery.js

@@ -0,0 +1,40 @@
+// @ts-check
+import { transformMessages } from "@earendil-works/pi-ai/api/transform-messages";
+
+/** Validate the effective provider projection; Pi supplies honest missing results. */
+export function validRecoveryProjection(messages, model) {
+  try {
+    const projected = transformMessages(messages, model);
+    const seen = new Set();
+    const pending = new Map();
+    for (const message of projected) {
+      if (!["user", "assistant", "toolResult"].includes(message?.role)) return false;
+      if (message.role !== "toolResult" && pending.size) return false;
+      if (message.role === "user" && typeof message.content === "string") continue;
+      if (!Array.isArray(message.content)) return false;
+      if (message.role === "toolResult") {
+        if (!pending.has(message.toolCallId) || pending.get(message.toolCallId) !== message.toolName) return false;
+        pending.delete(message.toolCallId);
+      }
+      if (message.role === "assistant" && ["error", "aborted", "deferred"].includes(message.stopReason)) return false;
+      for (const block of message.content) {
+        if (block?.type === "text") { if (typeof block.text !== "string") return false; }
+        else if (block?.type === "image") { if (typeof block.data !== "string" || typeof block.mimeType !== "string") return false; }
+        else if (block?.type === "thinking") {
+          if (message.role !== "assistant" || typeof block.thinking !== "string"
+            || (block.thinkingSignature !== undefined && (typeof block.thinkingSignature !== "string" || !block.thinkingSignature))) return false;
+          if (block.thinkingSignature && String(model.api).includes("responses")) {
+            const signature = JSON.parse(block.thinkingSignature);
+            if (signature?.type !== "reasoning" || typeof signature.id !== "string" || !Array.isArray(signature.summary)) return false;
+          }
+        } else if (block?.type === "toolCall") {
+          if (message.role !== "assistant" || typeof block.id !== "string" || !block.id || seen.has(block.id)
+            || typeof block.name !== "string" || !block.name || !block.arguments || typeof block.arguments !== "object") return false;
+          seen.add(block.id);
+          pending.set(block.id, block.name);
+        } else return false;
+      }
+    }
+    return pending.size === 0;
+  } catch { return false; }
+}

package/src/ai/providers/pi-native/turn-runner.js

@@ -7,7 +7,6 @@
 // state; run state (harness, removeAbortHandler, externalAbort) lives on the
 // caller-owned runState.
 
-import { AgentHarness } from "@earendil-works/pi-agent-core";
 import {
   createStructuredOutputTool,
   getPiBuiltinTools,
@@ -17,6 +16,7 @@ import { createNodeReplController } from "../../../agent/tools/node-repl.js";
 import { createWebToolController } from "../../../agent/tools/web-controller.js";
 import { readToolRuntime } from "../../../agent/tools/shared/runtime-context.js";
 import { formatLiveInputGuidance } from "../../live-input-prompt.js";
+import { createPiHarnessAdapter } from "./harness-adapter.js";
 import { appendStructuredOutputInstruction } from "./structured-output.js";
 import { createStreamSubscriber } from "./stream-subscriber.js";
 
@@ -78,6 +78,8 @@ export async function buildTurnTools(runState, {
     ? null
     : createWebToolController({
       searchConfig: options.webSearchConfig,
+      searchState: options.webSearchState,
+      coordinator: options.webRequestCoordinator,
       fetchConfig: options.webFetchConfig,
       sandboxPolicy: options.sandboxPolicy,
       sandboxEngine,
@@ -121,13 +123,14 @@ export async function buildTurnTools(runState, {
       nodeReplController,
       webController,
       processJobsController: options.processJobs,
+      processJobsAvailability: options.processJobsAvailability,
+      monitorsController: options.monitors,
       toolExecutionMode,
       subagents: options.subagents,
       // The child inherits the parent's route and workspace unless its profile
       // pins a model; the tool closure reads these to build each child request.
       subagentContext: {
         model: options.model,
-        executionMode: options.executionMode,
         cwd: options.cwd,
         parentRunId: runCtx?.runId,
         // Same policy + engine this turn's own tools are confined by, so a
@@ -143,6 +146,9 @@ export async function buildTurnTools(runState, {
         skills: options.skills,
         skillsRoot: options.skillsRoot,
         toolEnvironment: options.toolEnvironment,
+        webSearchConfig: options.webSearchConfig,
+        webRequestCoordinator: options.webRequestCoordinator,
+        webFetchConfig: options.webFetchConfig,
       },
       ctx: runCtx,
     }));
@@ -163,6 +169,7 @@ export async function buildTurnTools(runState, {
       qaOutputDir,
       onTruncate,
       limits: toolLimits,
+      mcpCallNoTotalTimeoutTools: options.mcpCallNoTotalTimeoutTools,
       toolPayloadMaxBytes: toolLimits.toolPayloadMaxBytes,
       sandboxPolicy: options.sandboxPolicy,
       sandboxEngine,
@@ -251,7 +258,7 @@ export function toolResultErrorOverride(details) {
   return failed ? { isError: true } : undefined;
 }
 
-export function buildTurnHarness(runState, {
+export async function buildTurnHarness(runState, {
   session,
   piModels,
   model,
@@ -263,18 +270,9 @@ export function buildTurnHarness(runState, {
   maxRetries,
   maxRetryDelayMs,
   steeringMode,
-  onEvent,
   options,
-  toolLimits,
-  sdk,
-  reference,
 }) {
-  // pi-agent-core 0.83.0 removed `env` from AgentHarnessOptions: an
-  // ExecutionEnv now reaches tools through the generic per-turn `toolContext`
-  // instead. mono-agent needs neither — it uses none of pi's built-in
-  // file/shell tools, and its own tools close over what they need — so the
-  // option is dropped rather than migrated.
-  const harness = new AgentHarness({
+  const harness = await createPiHarnessAdapter(session, {
     session,
     models: piModels,
     model,
@@ -284,6 +282,8 @@ export function buildTurnHarness(runState, {
     streamOptions: { transport, maxRetries, maxRetryDelayMs },
     steeringMode,
     followUpMode: steeringMode,
+    promptCacheDiagnostics: options.promptCacheDiagnostics,
+    onEvent: options.onEvent,
   });
   // MCP `CallToolResult.isError` is a successful protocol response, so pi's
   // execute() promise resolves. The bridge records that bit in result details;
@@ -297,8 +297,37 @@ export function buildTurnHarness(runState, {
   // every resolved execute(), so without this the model would be told a failed,
   // timed-out, or empty delegation succeeded.
   harness.on("tool_result", (event) => toolResultErrorOverride(event?.details));
+  // Pi 0.85 records in-flight work durably. mono-agent tools do not yet use the
+  // new replay-memo contract, so abort an interrupted operation instead of
+  // risking a duplicate external effect. Do this before subscribing so stale
+  // recovery events cannot contaminate the new run's transcript counters.
+  try {
+    await harness.abortOpenOperations();
+  } catch (error) {
+    try { await harness.close(); } catch { /* best-effort */ }
+    throw error;
+  }
+
   runState.harness = harness;
 
+  return harness;
+}
+
+/**
+ * Subscribe only after prior history has been seeded. Pi emits message
+ * lifecycle events for manual appendMessage() calls; subscribing earlier makes
+ * restored assistant messages look like fresh output boundaries.
+ * @param {any} runState
+ * @param {{harness: any, onEvent: (event: any) => void, options: any, toolLimits: any, sdk: string, reference: string}} deps
+ */
+export function activateTurnHarness(runState, {
+  harness,
+  onEvent,
+  options,
+  toolLimits,
+  sdk,
+  reference,
+}) {
   harness.subscribe(createStreamSubscriber(runState, {
     onEvent,
     options,
@@ -310,13 +339,12 @@ export function buildTurnHarness(runState, {
 
   const abortHandler = () => {
     runState.externalAbort = true;
-    harness.abort();
+    void harness.abort().catch(() => {});
   };
   if (options.abortSignal) {
     options.abortSignal.addEventListener("abort", abortHandler, { once: true });
     runState.removeAbortHandler = () => options.abortSignal.removeEventListener?.("abort", abortHandler);
   }
-  return harness;
 }
 
 /**
@@ -324,10 +352,10 @@ export function buildTurnHarness(runState, {
  * the harness mid-run; the consumer is tied to run completion (an internal
  * runComplete flag) so it stops steering once the run finishes and does not
  * swallow a follow-up meant for a later turn. Returns a `stop()` teardown.
- * @param {{harness: any, options: any, onEvent: (event: any) => void}} deps
+ * @param {{harness: any, options: any, onEvent: (event: any) => void, promptEpoch?: any}} deps
  * @returns {{stop: () => Promise<void>}}
  */
-export function startLiveInput({ harness, options, onEvent }) {
+export function startLiveInput({ harness, options, onEvent, promptEpoch }) {
   if (!options.liveInput) return { stop: async () => {} };
   const iterator = typeof options.liveInput[Symbol.asyncIterator] === "function"
     ? options.liveInput[Symbol.asyncIterator]()
@@ -336,6 +364,8 @@ export function startLiveInput({ harness, options, onEvent }) {
   /** @type {() => void} */
   let signalStop = () => {};
   const stopped = new Promise((resolve) => { signalStop = () => resolve(); });
+  /** @type {Array<{entryId: string, message: any}>} */
+  const acceptedEntries = [];
   const task = (async () => {
     try {
       while (!runComplete && !options.abortSignal?.aborted) {
@@ -345,8 +375,19 @@ export function startLiveInput({ harness, options, onEvent }) {
         ]);
         if (next.done || runComplete || options.abortSignal?.aborted) break;
         try {
-          await harness.steer(formatLiveInputGuidance(next.value.body, options.prompts));
-          next.value.acknowledge?.();
+          const entryId = await harness.steer(formatLiveInputGuidance(next.value.body, options.prompts));
+          if (typeof entryId !== "string" || entryId.length === 0) {
+            next.value.accepted?.();
+            next.value.uncertain?.({ reason: "delivery_uncertain" });
+            continue;
+          }
+          const evidence = {
+            providerEntryId: entryId,
+            ...(promptEpoch?.ownedRunId() === undefined ? {} : { providerRunId: promptEpoch.ownedRunId() }),
+          };
+          acceptedEntries.push({ entryId, message: next.value });
+          next.value.accepted?.(evidence);
+          promptEpoch?.register(entryId, next.value);
         } catch (err) {
           next.value.reject?.(err);
           throw err;
@@ -360,6 +401,8 @@ export function startLiveInput({ harness, options, onEvent }) {
       });
     }
   })();
+  /** @type {Promise<void>|undefined} */
+  let stopPromise;
   return {
     // The run is done: stop the live-steering consumer so it cannot steer a
     // finished harness or swallow a follow-up meant for the next turn. We signal
@@ -367,15 +410,214 @@ export function startLiveInput({ harness, options, onEvent }) {
     // race releases the task even when a third-party iterator's return() does
     // not unblock its pending next(); awaiting the task still closes any steer
     // acknowledgement already in progress.
-    stop: async () => {
+    stop: () => {
+      stopPromise ??= performStop();
+      return stopPromise;
+    },
+  };
+
+  async function performStop() {
       runComplete = true;
       signalStop();
       if (iterator && typeof iterator.return === "function") {
         try { void Promise.resolve(iterator.return()).catch(() => {}); } catch { /* best-effort */ }
       }
       await task;
+      for (const accepted of acceptedEntries) {
+        if (promptEpoch?.isConsumed(accepted.entryId)) continue;
+        try {
+          if (typeof harness.cancelQueued !== "function") {
+            accepted.message.uncertain?.({
+              reason: "delivery_uncertain",
+              providerEntryId: accepted.entryId,
+              ...(promptEpoch?.ownedRunId() === undefined ? {} : { providerRunId: promptEpoch.ownedRunId() }),
+            });
+            continue;
+          }
+          const cancellation = await harness.cancelQueued(accepted.entryId);
+          if (cancellation?.kind === "cancelled") {
+            accepted.message.reject?.({ code: "native_queue_removed" });
+          } else if (!promptEpoch?.isConsumed(accepted.entryId)) {
+            accepted.message.uncertain?.({
+              reason: "delivery_uncertain",
+              providerEntryId: accepted.entryId,
+              ...(promptEpoch?.ownedRunId() === undefined ? {} : { providerRunId: promptEpoch.ownedRunId() }),
+            });
+          }
+        } catch {
+          accepted.message.uncertain?.({
+            reason: "delivery_uncertain",
+            providerEntryId: accepted.entryId,
+            ...(promptEpoch?.ownedRunId() === undefined ? {} : { providerRunId: promptEpoch.ownedRunId() }),
+          });
+          onEvent({
+            type: "runtime_warning",
+            warning_kind: "live_input_cancellation_failed",
+            message: "Unable to prove whether queued live input was removed.",
+          });
+        }
+      }
+  }
+}
+
+/**
+ * Own exact Pi run/entry correlation for the one main prompt in this Mono run.
+ * @param {{harness: any, onEvent: (event: any) => void}} deps
+ */
+export function createLiveInputPromptEpoch({ harness, onEvent }) {
+  const BUFFER_LIMIT = 101;
+  /** @type {string|undefined} */
+  let runId;
+  let eventWindowClosed = false;
+  let invalid = false;
+  /** @type {Array<{entryId: string, runId: string}>} */
+  const buffered = [];
+  /** @type {Map<string, {message: any, observed: boolean, consumed: boolean}>} */
+  const entries = new Map();
+  // The operation id Pi admitted for the main prompt (via confirm) or that the
+  // settled prompt reported (via finish). Consumption is only acknowledged once
+  // the observed main-lane run_start carries this exact id.
+  /** @type {string|undefined} */
+  let admittedOperationId;
+  let operationConfirmed = false;
+
+  const remove = harness.subscribe((event) => {
+    if (!event || event.lane !== "main") return;
+    if (event.type === "run_start" && typeof event.runId === "string" && event.runId.length > 0) {
+      if (runId === undefined) {
+        runId = event.runId;
+        if (admittedOperationId !== undefined && admittedOperationId !== runId) {
+          invalidate("operation_mismatch");
+          return;
+        }
+        if (admittedOperationId !== undefined) operationConfirmed = true;
+        consumeBuffered();
+      } else if (runId !== event.runId) {
+        invalidate("multiple_run_start");
+      }
+      return;
+    }
+    if (event.type === "run_end" && event.runId === runId) {
+      eventWindowClosed = true;
+      return;
+    }
+    if (
+      event.type !== "message_end"
+      || eventWindowClosed
+      || event.message?.role !== "user"
+      || typeof event.entryId !== "string"
+      || event.entryId.length === 0
+      || typeof event.runId !== "string"
+      || event.runId.length === 0
+    ) return;
+    if (buffered.some((item) => item.entryId === event.entryId && item.runId === event.runId)) {
+      consumeBuffered();
+      return;
+    }
+    if (buffered.length >= BUFFER_LIMIT) {
+      invalidate("event_buffer_overflow");
+      return;
+    }
+    buffered.push({ entryId: event.entryId, runId: event.runId });
+    consumeBuffered();
+  });
+
+  return {
+    ownedRunId: () => runId,
+    consumedInputIds: () => invalid ? null : [...entries.values()].filter((entry) => entry.consumed).map((entry) => entry.message.id),
+    register(entryId, message) {
+      if (!entries.has(entryId)) entries.set(entryId, { message, observed: false, consumed: false });
+      if (invalid) {
+        settleUncertain(entries.get(entryId), entryId);
+        return;
+      }
+      consumeBuffered();
+    },
+    isConsumed: (entryId) => entries.get(entryId)?.consumed === true,
+    /**
+     * Own the admitted operation as soon as Pi reports its id, before the run
+     * settles, so entries consumed mid-run are acknowledged when their
+     * message_end arrives rather than in one batch at the end of the run.
+     * Safe in either order with run_start; a conflicting id invalidates.
+     */
+    confirm(operationId) {
+      if (invalid) return;
+      if (
+        typeof operationId !== "string"
+        || operationId.length === 0
+        || (admittedOperationId !== undefined && admittedOperationId !== operationId)
+        || (runId !== undefined && runId !== operationId)
+      ) {
+        invalidate("operation_mismatch");
+        return;
+      }
+      admittedOperationId = operationId;
+      if (runId === undefined) return;
+      operationConfirmed = true;
+      confirmObserved();
+    },
+    finish(operationId) {
+      if (
+        typeof operationId !== "string"
+        || operationId.length === 0
+        || runId === undefined
+        || operationId !== runId
+        || (admittedOperationId !== undefined && admittedOperationId !== operationId)
+      ) {
+        invalidate("operation_mismatch");
+        return;
+      }
+      admittedOperationId = operationId;
+      operationConfirmed = true;
+      confirmObserved();
+    },
+    close() {
+      remove?.();
     },
   };
+
+  function consumeBuffered() {
+    if (invalid || runId === undefined) return;
+    for (const evidence of buffered) {
+      if (evidence.runId !== runId) continue;
+      const entry = entries.get(evidence.entryId);
+      if (entry === undefined || entry.consumed) continue;
+      entry.observed = true;
+    }
+    if (operationConfirmed) confirmObserved();
+  }
+
+  function confirmObserved() {
+    if (!operationConfirmed || runId === undefined || invalid) return;
+    for (const [entryId, entry] of entries) {
+      if (!entry.observed || entry.consumed) continue;
+      entry.consumed = true;
+      entry.message.acknowledge?.({ providerEntryId: entryId, providerRunId: runId });
+    }
+  }
+
+  function invalidate(reason) {
+    if (invalid) return;
+    invalid = true;
+    try {
+      onEvent({
+        type: "runtime_warning",
+        warning_kind: "live_input_correlation_invalid",
+        message: "Live-input consumption could not be correlated to exactly one provider operation.",
+        reason,
+      });
+    } catch { /* diagnostics do not alter settlement */ }
+    for (const [entryId, entry] of entries) settleUncertain(entry, entryId);
+  }
+
+  function settleUncertain(entry, entryId) {
+    if (entry === undefined || entry.consumed) return;
+    entry.message.uncertain?.({
+      reason: "delivery_uncertain",
+      providerEntryId: entryId,
+      ...(runId === undefined ? {} : { providerRunId: runId }),
+    });
+  }
 }
 
 /**
@@ -385,23 +627,32 @@ export function startLiveInput({ harness, options, onEvent }) {
  * @param {any} harness
  * @param {string} promptText
  * @param {Array<any>} promptImages
- * @returns {Promise<{runError: any}>}
+ * @param {{onOperationAdmitted?: (operationId: string) => void}} [hooks]
+ *   `onOperationAdmitted` fires as soon as Pi admits the run, before any
+ *   provider request, so the live-input epoch can own the operation up front.
+ * @returns {Promise<{runError: any, operationId?: string}>}
  */
-export async function runHarnessPrompt(harness, promptText, promptImages) {
+export async function runHarnessPrompt(harness, promptText, promptImages, hooks) {
   let runError = null;
+  let operationId;
   try {
     // Pass structured images (when present) so multimodal input reaches the
     // model as image blocks rather than stringified text. AgentHarness.prompt
     // takes them under an options object (`{ images }`); a bare array would be
     // read as `options` and silently dropped (options?.images === undefined).
-    if (Array.isArray(promptImages) && promptImages.length > 0) {
-      await harness.prompt(promptText, { images: promptImages });
-    } else {
-      await harness.prompt(promptText);
-    }
+    const promptOptions = {
+      ...(Array.isArray(promptImages) && promptImages.length > 0 ? { images: promptImages } : {}),
+      ...(typeof hooks?.onOperationAdmitted === "function"
+        ? { onOperationAdmitted: hooks.onOperationAdmitted }
+        : {}),
+    };
+    const result = Object.keys(promptOptions).length > 0
+      ? await harness.prompt(promptText, promptOptions)
+      : await harness.prompt(promptText);
+    operationId = result?.operationId;
   } catch (err) {
     runError = err;
   }
   await harness.waitForIdle();
-  return { runError };
+  return { runError, ...(operationId === undefined ? {} : { operationId }) };
 }