@mono-agent/agent-runtime 0.20.11 → 0.21.0

package/src/agent/tools/codex-subscription-search.js

@@ -4,12 +4,14 @@ import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { createCodexAppServerClient } from "../../ai/providers/codex-app.js";
+import { createCodexAppServerClient } from "../../ai/providers/codex/app-server-client.js";
+import { boundWebSearchSnippet, sliceWellFormedCodePoints, toWellFormedText } from "./web-search-output.js";
 
 export const DEFAULT_CODEX_SEARCH_MODEL = "gpt-5.6-luna";
 
 const REQUEST_TIMEOUT_MS = 30_000;
-const IDLE_CLOSE_MS = 1_000;
+const IDLE_CLOSE_MS = 30_000;
+let quotaSnapshot;
 const MAX_MODEL_PAGES = 10;
 const MAX_RESULTS = 100;
 const SEARCH_ONLY_INSTRUCTIONS = [
@@ -59,16 +61,23 @@ export async function inspectCodexSubscriptionSearch(options = {}) {
  * turns or cross-wire app-server notifications between requests.
  *
  * @param {string} query
- * @param {{model?: string, signal?: AbortSignal, clientFactory?: typeof createCodexAppServerClient}} [options]
+ * @param {{model?: string, signal?: AbortSignal, clientFactory?: typeof createCodexAppServerClient, coordinator?: any, language?: string, timeRange?: string, claimRequest?: () => void}} [options]
  */
 export function searchCodexSubscription(query, options = {}) {
-  return enqueue(async () => {
+  let executing = false;
+  const pending = enqueue(async () => {
+    executing = true;
     if (options.signal?.aborted) return abortedResult();
     const model = normalizeModel(options.model);
     let current;
     try {
-      current = await getBroker(model, options.clientFactory);
-      const result = await runSearch(current, query, model, options.signal);
+      current = await getBroker(model, options.clientFactory, options.signal);
+      options.signal?.throwIfAborted();
+      await checkQuota(current, options.coordinator, options.signal);
+      options.signal?.throwIfAborted();
+      const quotaBefore = quotaSnapshot?.checkedAt;
+      const result = await runSearch(current, query, model, options.signal, options);
+      if (quotaSnapshot && quotaSnapshot.checkedAt !== quotaBefore) await options.coordinator?.writeQuota(quotaSnapshot.value);
       scheduleIdleClose();
       return result;
     } catch (error) {
@@ -78,9 +87,70 @@ export function searchCodexSubscription(query, options = {}) {
         backend: "codex",
         message: `Codex subscription search unavailable: ${publicReason(error)}`,
         retryable: isRetryable(error),
+        code: options.signal?.aborted ? (options.signal.reason?.code === "deadline_exceeded" ? "deadline_exceeded" : "aborted") : error?.code,
+        quotaSkipped: ["quota_reserved", "quota_unavailable"].includes(error?.code),
+        retryAfterMs: error?.retryAfterMs,
       };
     }
   });
+  return abortable(pending, options.signal, () => executing);
+}
+
+function abortable(pending, signal, executing) {
+  if (!signal) return pending;
+  return new Promise((resolve, reject) => {
+    const aborted = () => { if (!executing()) reject(signal.reason || Object.assign(new Error("WebSearch was aborted."), { name: "AbortError" })); };
+    if (signal.aborted) aborted();
+    else signal.addEventListener("abort", aborted, { once: true });
+    pending.then(resolve, reject).finally(() => signal.removeEventListener("abort", aborted));
+  });
+}
+
+async function checkQuota(current, coordinator, signal) {
+  const shared = coordinator ? await coordinator.readQuota() : quotaSnapshot;
+  let snapshot = shared;
+  if (!snapshot || Date.now() - snapshot.checkedAt > 60_000 || snapshot.checkedAt > Date.now()) {
+    let response;
+    try { response = await searchRequest(current.client, "account/rateLimits/read", {}, { timeoutMs: 5000 }, signal); }
+    catch { throw Object.assign(new Error("Codex quota information is unavailable."), { code: "quota_unavailable" }); }
+    snapshot = { checkedAt: Date.now(), value: quotaValue(response) };
+    quotaSnapshot = snapshot;
+    await coordinator?.writeQuota(snapshot.value);
+  }
+  quotaSnapshot = snapshot;
+  const windows = snapshot.value?.windows;
+  if (!Array.isArray(windows) || windows.length === 0 || !windows.every((w) =>
+    Number.isFinite(w.usedPercent) && w.usedPercent >= 0 && w.usedPercent <= 100
+      && Number.isSafeInteger(w.resetsAt) && w.resetsAt * 1000 > Date.now())) {
+    throw Object.assign(new Error("Codex quota information is unavailable."), { code: "quota_unavailable" });
+  }
+  const reserved = windows.filter((w) => w.usedPercent >= 90);
+  if (reserved.length) throw Object.assign(new Error("Codex search preserves the remaining subscription allowance."), {
+    code: "quota_reserved", retryAfterMs: Math.max(...reserved.map((w) => w.resetsAt * 1000 - Date.now())),
+  });
+}
+
+function quotaValue(response) {
+  const bucket = response?.rateLimitsByLimitId?.codex ?? response?.rateLimits;
+  return { windows: [bucket?.primary, bucket?.secondary].filter(Boolean).map((w) => ({ usedPercent: w.usedPercent, resetsAt: w.resetsAt })) };
+}
+
+// Close the transport before releasing admission on abort, including startup
+// and thread/start. A queued or late request cannot launch a new search turn.
+async function searchRequest(client, method, params, options, signal) {
+  signal?.throwIfAborted();
+  if (!signal) return await client.request(method, params, options);
+  let abort;
+  const cancelled = new Promise((_, reject) => {
+    abort = () => {
+      Promise.resolve(client.close()).then(
+        () => reject(signal.reason), () => reject(signal.reason),
+      );
+    };
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  try { return await Promise.race([client.request(method, params, options), cancelled]); }
+  finally { signal.removeEventListener("abort", abort); }
 }
 
 function enqueue(task) {
@@ -89,14 +159,16 @@ function enqueue(task) {
   return result;
 }
 
-async function getBroker(model, clientFactory) {
+async function getBroker(model, clientFactory, signal) {
   clearIdleTimer();
   if (broker?.models.has(model)) return broker;
   if (broker && !broker.models.has(model)) await closeBroker();
   if (!brokerOpening) {
     brokerOpening = (async () => {
-      const owned = await openBroker(clientFactory);
-      const ready = await inspectClient(owned.client, model);
+      const owned = await openBroker(clientFactory, signal);
+      let ready;
+      try { ready = await inspectClient(owned.client, model, signal); }
+      catch (error) { await closeOwnedBroker(owned); throw error; }
       if (!ready.ok) {
         await closeOwnedBroker(owned);
         throw new Error(ready.reason);
@@ -109,7 +181,7 @@ async function getBroker(model, clientFactory) {
   return await brokerOpening;
 }
 
-async function openBroker(clientFactory = createCodexAppServerClient) {
+async function openBroker(clientFactory = createCodexAppServerClient, signal) {
   const directory = await mkdtemp(join(tmpdir(), "mono-agent-codex-search-"));
   /** @type {{handler: (message: any) => void}} */
   const target = { handler: () => {} };
@@ -117,16 +189,19 @@ async function openBroker(clientFactory = createCodexAppServerClient) {
   try {
     client = clientFactory({
       cwd: directory,
-      onNotification: (message) => target.handler(message),
+      onNotification: (message) => {
+        if (message?.method === "account/rateLimits/updated") quotaSnapshot = { checkedAt: Date.now(), value: quotaValue(message.params) };
+        target.handler(message);
+      },
       onServerRequest: (message) => {
         target.handler(message);
         throw new Error("Codex subscription search rejected an unexpected server request.");
       },
     });
-    await client.request("initialize", {
+    await searchRequest(client, "initialize", {
       clientInfo: { name: "mono-agent-web-search", title: "mono-agent WebSearch", version: "0" },
       capabilities: { experimentalApi: true },
-    }, { timeoutMs: REQUEST_TIMEOUT_MS });
+    }, { timeoutMs: REQUEST_TIMEOUT_MS }, signal);
     return { client, directory, models: new Set(), target };
   } catch (error) {
     await Promise.resolve(client?.close?.()).catch(() => {});
@@ -135,8 +210,8 @@ async function openBroker(clientFactory = createCodexAppServerClient) {
   }
 }
 
-async function inspectClient(client, model) {
-  const account = await client.request("account/read", { refreshToken: false }, { timeoutMs: REQUEST_TIMEOUT_MS });
+async function inspectClient(client, model, signal) {
+  const account = await searchRequest(client, "account/read", { refreshToken: false }, { timeoutMs: REQUEST_TIMEOUT_MS }, signal);
   if (account?.account?.type !== "chatgpt") {
     return {
       ok: false,
@@ -146,10 +221,10 @@ async function inspectClient(client, model) {
       models: new Set(),
     };
   }
-  const capabilities = await client.request(
+  const capabilities = await searchRequest(client,
     "modelProvider/capabilities/read",
     {},
-    { timeoutMs: REQUEST_TIMEOUT_MS },
+    { timeoutMs: REQUEST_TIMEOUT_MS }, signal,
   );
   if (capabilities?.webSearch !== true) {
     return {
@@ -160,7 +235,7 @@ async function inspectClient(client, model) {
       models: new Set(),
     };
   }
-  const models = await readModels(client);
+  const models = await readModels(client, signal);
   if (!models.has(model)) {
     return {
       ok: false,
@@ -179,15 +254,15 @@ async function inspectClient(client, model) {
   };
 }
 
-async function readModels(client) {
+async function readModels(client, signal) {
   const models = new Set();
   let cursor = null;
   for (let page = 0; page < MAX_MODEL_PAGES; page += 1) {
-    const response = await client.request("model/list", {
+    const response = await searchRequest(client, "model/list", {
       includeHidden: false,
       limit: 100,
       ...(cursor === null ? {} : { cursor }),
-    }, { timeoutMs: REQUEST_TIMEOUT_MS });
+    }, { timeoutMs: REQUEST_TIMEOUT_MS }, signal);
     if (!Array.isArray(response?.data)) throw new Error("Codex returned an invalid model catalog.");
     for (const row of response.data) {
       if (typeof row?.id === "string" && row.id.trim()) models.add(row.id.trim());
@@ -198,7 +273,8 @@ async function readModels(client) {
   throw new Error("Codex model catalog exceeded the pagination bound.");
 }
 
-async function runSearch(current, query, model, signal) {
+async function runSearch(current, query, model, signal, preferences = {}) {
+  signal?.throwIfAborted();
   const state = /** @type {any} */ ({
     threadId: "",
     turnId: "",
@@ -221,7 +297,7 @@ async function runSearch(current, query, model, signal) {
   };
   signal?.addEventListener?.("abort", onAbort, { once: true });
   try {
-    const thread = await current.client.request("thread/start", {
+    const thread = await searchRequest(current.client, "thread/start", {
       model,
       modelProvider: "openai",
       allowProviderModelFallback: false,
@@ -234,17 +310,21 @@ async function runSearch(current, query, model, signal) {
         project_doc_max_bytes: 0,
         mcp_servers: {},
       },
-      developerInstructions: SEARCH_ONLY_INSTRUCTIONS,
+      developerInstructions: SEARCH_ONLY_INSTRUCTIONS + (
+        preferences.language || preferences.timeRange
+          ? ` Search preferences (keep query text unchanged): language=${JSON.stringify(preferences.language || "default")}; time range=${JSON.stringify(preferences.timeRange || "any")}. Use supported search filters; do not invent dates.` : ""
+      ),
       ephemeral: true,
       sessionStartSource: "startup",
       environments: [],
       dynamicTools: [],
       selectedCapabilityRoots: [],
       experimentalRawEvents: false,
-    }, { timeoutMs: REQUEST_TIMEOUT_MS });
+    }, { timeoutMs: REQUEST_TIMEOUT_MS }, signal);
     state.threadId = thread?.thread?.id || "";
     if (!state.threadId) throw new Error("Codex did not return a search thread id.");
-    const turn = await current.client.request("turn/start", {
+    preferences.claimRequest?.();
+    const turn = await searchRequest(current.client, "turn/start", {
       threadId: state.threadId,
       input: [{ type: "text", text: String(query), text_elements: [] }],
       cwd: current.directory,
@@ -255,7 +335,7 @@ async function runSearch(current, query, model, signal) {
       effort: "low",
       summary: "none",
       environments: [],
-    }, { timeoutMs: REQUEST_TIMEOUT_MS });
+    }, { timeoutMs: REQUEST_TIMEOUT_MS }, signal);
     state.turnId = turn?.turn?.id || state.turnId;
     if (state.violation && state.turnId) {
       await current.client.request("turn/interrupt", {
@@ -276,6 +356,9 @@ async function runSearch(current, query, model, signal) {
     if (actualQuery !== String(query)) {
       throw new Error("Codex changed the exact web search query.");
     }
+    if (!Array.isArray(item.results) || item.results.some((row) => !row || typeof row.url !== "string" || !validResultUrl(row.url))) {
+      throw new Error("Codex returned malformed structured search results.");
+    }
     const results = normalizeResults(item.results);
     return {
       ok: true,
@@ -329,15 +412,24 @@ function handleNotification(message, state, client) {
   }
 }
 
+function validResultUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol) && Boolean(url.hostname) && !url.username && !url.password;
+  } catch { return false; }
+}
+
 function normalizeResults(rows) {
   if (!Array.isArray(rows)) return [];
   const results = [];
   for (const row of rows) {
     if (!row || typeof row !== "object" || typeof row.url !== "string") continue;
+    const snippet = boundWebSearchSnippet(row.snippet);
     results.push({
       title: boundedText(row.title, 500),
       url: row.url,
-      snippet: boundedText(row.snippet, 4_000),
+      snippet: snippet.text,
+      snippetTruncated: snippet.truncated,
       provenance: boundedText(row.domain || row.ref_id || row.type, 300),
       backend: "codex",
     });
@@ -391,7 +483,8 @@ function normalizeModel(value) {
 }
 
 function boundedText(value, max) {
-  return typeof value === "string" ? value.replace(/\s+/gu, " ").trim().slice(0, max) : "";
+  const text = typeof value === "string" ? toWellFormedText(value).replace(/\s+/gu, " ").trim() : "";
+  return sliceWellFormedCodePoints(text, max);
 }
 
 function safeReason(error) {
@@ -430,6 +523,7 @@ function abortedResult() {
 
 /** Test hook for process-shared broker state. */
 export async function __resetCodexSubscriptionSearchForTests() {
+  quotaSnapshot = undefined;
   await enqueue(async () => { await closeBroker(); });
   brokerOpening = null;
 }

package/src/agent/tools/exec.js

@@ -25,7 +25,7 @@ const MAX_EXEC_ARGS = 256;
 /** @typedef {import("./shared/process-jobs.js").ProcessJobsController} ProcessJobsController */
 
 /**
- * @param {{executable: string, args?: string[], workdir?: string, description?: string, timeout_ms?: number, max_output_chars?: number, background?: boolean}} params
+ * @param {{executable: string, args?: string[], workdir?: string, description?: string, timeout_ms?: number, max_output_chars?: number, background?: boolean, wake_on_completion?: boolean}} params
  * @param {{signal?: AbortSignal, sandboxPolicy?: any, sandboxEngine?: any, ctx?: any, processJobsController?: ProcessJobsController}} [options]
  */
 export async function execToolImpl(params, options = {}) {
@@ -35,7 +35,7 @@ export async function execToolImpl(params, options = {}) {
 /**
  * Execute an argv vector directly, without shell parsing.
  *
- * @param {{executable: string, args?: string[], workdir?: string, description?: string, timeout_ms?: number, max_output_chars?: number, background?: boolean}} params
+ * @param {{executable: string, args?: string[], workdir?: string, description?: string, timeout_ms?: number, max_output_chars?: number, background?: boolean, wake_on_completion?: boolean}} params
  * @param {{signal?: AbortSignal, sandboxPolicy?: any, sandboxEngine?: any, ctx?: any, processJobsController?: ProcessJobsController}} [options]
  */
 export async function execToolRun(
@@ -47,6 +47,7 @@ export async function execToolRun(
     timeout_ms,
     max_output_chars,
     background,
+    wake_on_completion,
   },
   {
     signal,
@@ -57,6 +58,12 @@ export async function execToolRun(
   } = {},
 ) {
   const startedAt = Date.now();
+  if (wake_on_completion !== undefined && (background !== true || typeof wake_on_completion !== "boolean")) {
+    return failed("Error: wake_on_completion requires background=true and a boolean value.", "process_job_invalid", startedAt);
+  }
+  if (background === true && !processJobsController) {
+    return failed("Error: Background process jobs are unavailable for this request.", "background_unsupported", startedAt);
+  }
   const executableProblem = validateExecutable(executable);
   if (executableProblem) return failed(executableProblem, "invalid_executable", startedAt);
   const argsProblem = validateArgs(args);
@@ -103,6 +110,7 @@ export async function execToolRun(
       prepared,
       summary: `Exec command (${args.length} argument${args.length === 1 ? "" : "s"}; values redacted)`,
       description,
+      wakeOnCompletion: wake_on_completion,
       // Re-derived from the raw param: `timeoutMs` carries the foreground
       // ceiling, and a background job is bounded by processJobs instead.
       timeoutMs: timeout_ms === undefined ? undefined : normalizeBackgroundTimeoutMs(timeout_ms),

package/src/agent/tools/index.js

@@ -18,6 +18,13 @@ export {
   normalizeProcessTimeoutMs,
 } from "./bash.js";
 export { execToolImpl, execToolRun } from "./exec.js";
+export {
+  DEFAULT_MONITOR_TIMEOUT_MS,
+  MIN_MONITOR_TIMEOUT_MS,
+  monitorStopToolRun,
+  monitorToolRun,
+  normalizeMonitorTimeoutMs,
+} from "./monitor.js";
 export { webFetchToolImpl, performWebFetch } from "./web-fetch.js";
 export { webSearchToolImpl, performWebSearch } from "./web-search.js";
 export {

package/src/agent/tools/monitor.js

@@ -0,0 +1,149 @@
+// @ts-check
+
+import { existsSync } from "node:fs";
+import { passthroughSandbox } from "../sandbox-seam.js";
+import {
+  isPathAllowed,
+  isWorkdirAllowed,
+  workspaceRoot,
+} from "./shared/path-resolver.js";
+import { handOffMonitor, handOffMonitorStop } from "./shared/monitors.js";
+import { readToolRuntime } from "./shared/runtime-context.js";
+import { requestToolProcessEnvironment, resolveSandboxPolicy } from "./shared/tool-context.js";
+import { cleanBashEnvironment } from "./shared/bash-environment.js";
+
+/** Claude-Code-compatible defaults: 5 minutes, never below one second. */
+export const DEFAULT_MONITOR_TIMEOUT_MS = 300_000;
+export const MIN_MONITOR_TIMEOUT_MS = 1_000;
+
+/**
+ * Normalize `timeout_ms` for a monitor. Unlike Bash there is no
+ * seconds-vs-milliseconds heuristic — this field is new, so it is exact
+ * milliseconds only. `undefined`/invalid falls back to the documented default;
+ * the host's own ceiling clamps the result on its side and reports what it
+ * actually granted.
+ */
+export function normalizeMonitorTimeoutMs(value, fallback = DEFAULT_MONITOR_TIMEOUT_MS) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number <= 0) return fallback;
+  return Math.max(MIN_MONITOR_TIMEOUT_MS, Math.floor(number));
+}
+
+/**
+ * Structured Monitor execution used by the Pi bridge.
+ *
+ * Command preparation is deliberately byte-identical to Bash: the same
+ * `/bin/bash --noprofile --norc -c` shape, the same workdir rules, the same
+ * cleaned startup environment, and the same sandbox `prepareCommand` seam. A
+ * monitor must never be a way to run a command Bash could not.
+ *
+ * @param {{command?: string, description?: string, timeout_ms?: number, persistent?: boolean, workdir?: string, wake_on?: "batch"|"exit", dedupe?: "none"|"batch", min_wake_interval_ms?: number}} params
+ * @param {{signal?: AbortSignal, sandboxPolicy?: any, sandboxEngine?: any, ctx?: any, monitorsController?: import("./shared/monitors.js").MonitorsController}} [options]
+ */
+export async function monitorToolRun(
+  { command, description, timeout_ms, persistent, workdir, wake_on = "batch", dedupe = "none", min_wake_interval_ms = 0 },
+  { sandboxPolicy, sandboxEngine, ctx, monitorsController } = {},
+) {
+  const startedAt = Date.now();
+  if (!monitorsController) {
+    return failed("Error: Monitors are unsupported for this tool call.", "monitor_unsupported", startedAt);
+  }
+  if (typeof command !== "string") {
+    return failed("Error: Monitor command must be a string.", "monitor_invalid", startedAt);
+  }
+  if (command.includes("\0")) {
+    return failed("Error: Monitor command must not contain NUL characters.", "monitor_invalid", startedAt);
+  }
+  if (typeof description !== "string" || description.trim().length === 0) {
+    return failed("Error: Monitor description is required.", "monitor_invalid", startedAt);
+  }
+  if (!["batch", "exit"].includes(wake_on)
+    || !["none", "batch"].includes(dedupe)
+    || !Number.isSafeInteger(min_wake_interval_ms) || min_wake_interval_ms < 0
+    || (wake_on === "exit" && (dedupe !== "none" || min_wake_interval_ms !== 0))) {
+    return failed("Error: Invalid Monitor wake policy; exit-only requires dedupe none and interval 0.", "monitor_invalid", startedAt);
+  }
+  const resolvedCtx = ctx ?? readToolRuntime();
+  const sandbox = resolvedCtx.sandbox ?? passthroughSandbox;
+  const policy = resolveSandboxPolicy(resolvedCtx, sandboxPolicy);
+  const pathOptions = { sandboxPolicy: policy, ctx: resolvedCtx };
+  if (workdir && !isWorkdirAllowed(workdir, pathOptions)) {
+    return failed(`Error: Working directory not allowed: ${workdir}`, "workdir_denied", startedAt);
+  }
+  const cwd = workspaceRoot(workdir, resolvedCtx);
+  if (!isPathAllowed(cwd, workdir, pathOptions)) {
+    return failed(`Error: Working directory not allowed: ${cwd}`, "workdir_denied", startedAt);
+  }
+  if (!existsSync(cwd)) {
+    return failed(`Error: Working directory not found: ${cwd}`, "workdir_not_found", startedAt);
+  }
+
+  let prepared;
+  try {
+    prepared = await sandbox.prepareCommand({
+      policy,
+      engine: sandboxEngine ?? resolvedCtx.sandboxEngine ?? undefined,
+      command: {
+        command: "/bin/bash",
+        args: ["--noprofile", "--norc", "-c", command],
+        cwd,
+        env: requestToolProcessEnvironment(resolvedCtx, cleanBashEnvironment()),
+      },
+    });
+  } catch (error) {
+    return failed(`Error: ${error?.message || String(error)}`, "sandbox_prepare_failed", startedAt);
+  }
+
+  const isPersistent = persistent === true;
+  return await handOffMonitor({
+    controller: monitorsController,
+    prepared,
+    summary: `Monitor command (${command.length} characters; content redacted)`,
+    description,
+    // A persistent monitor has no timed deadline; sending one anyway would let
+    // an ignored field look honoured in the durable record.
+    ...(isPersistent ? {} : { timeoutMs: normalizeMonitorTimeoutMs(timeout_ms) }),
+    persistent: isPersistent,
+    wakeOn: wake_on,
+    dedupe,
+    minWakeIntervalMs: min_wake_interval_ms,
+    startedAt,
+    failed,
+  });
+}
+
+/**
+ * @param {{monitor_id?: string}} params
+ * @param {{monitorsController?: import("./shared/monitors.js").MonitorsController}} [options]
+ */
+export async function monitorStopToolRun({ monitor_id }, { monitorsController } = {}) {
+  const startedAt = Date.now();
+  if (!monitorsController) {
+    return failed("Error: Monitors are unsupported for this tool call.", "monitor_unsupported", startedAt);
+  }
+  return await handOffMonitorStop({
+    controller: monitorsController,
+    monitorId: monitor_id,
+    startedAt,
+    failed,
+  });
+}
+
+function failed(text, code, startedAt) {
+  return {
+    text,
+    outcome: {
+      status: "error",
+      code,
+      retryable: false,
+      attempts: 1,
+      durationMs: Date.now() - startedAt,
+      bytes: 0,
+      truncated: false,
+      exitCode: null,
+      signal: null,
+      timedOut: false,
+    },
+    error: true,
+  };
+}