@tt-a1i/openpi 0.6.0 → 0.6.1

package/extensions/workflows/dashboard.ts

@@ -143,18 +143,54 @@ export function readPersistedWorkflowDetails(
   runId: string,
   options: ReadPersistedRunOptions = {},
 ): WorkflowDetails | undefined {
-  let details: WorkflowDetails | undefined;
+  const details = normalizeReadRecord(
+    runId,
+    readPersistedWorkflowRecord(runId),
+  );
+  if (!details) return undefined;
+  if (options.hydrateArtifacts) hydrateRunArtifacts(runId, details);
+  return details;
+}
+
+function normalizeReadRecord(runId: string, raw: unknown) {
+  try {
+    return normalizePersistedWorkflowDetails(runId, raw);
+  } catch {
+    return undefined;
+  }
+}
+
+function readPersistedWorkflowRecord(runId: string) {
   try {
     const raw: unknown = JSON.parse(
       fs.readFileSync(path.join(runsDir(), runId, "workflow.json"), "utf8"),
     );
-    details = normalizePersistedWorkflowDetails(runId, raw);
+    return raw && typeof raw === "object"
+      ? (raw as Record<string, unknown>)
+      : undefined;
   } catch {
     return undefined;
   }
-  if (!details) return undefined;
-  if (options.hydrateArtifacts) hydrateRunArtifacts(runId, details);
-  return details;
+}
+
+function matchesRunScope(
+  record: { startedAt?: unknown; finishedAt?: unknown; sessionId?: unknown },
+  runId: string,
+  sessionId: string,
+  referencedRunIds: ReadonlySet<string>,
+  startedSince: number,
+  fromRetention = false,
+) {
+  const touchedAt = Math.max(
+    typeof record.startedAt === "number" ? record.startedAt : 0,
+    typeof record.finishedAt === "number" ? record.finishedAt : 0,
+  );
+  return (
+    touchedAt >= startedSince &&
+    (fromRetention ||
+      record.sessionId === sessionId ||
+      referencedRunIds.has(runId))
+  );
 }
 
 function isWorktreeCleanup(
@@ -581,27 +617,41 @@ export function loadRunEntries(
   retained: ReadonlyMap<string, WorkflowDetails> = new Map(),
 ): RunEntry[] {
   const entries: RunEntry[] = [];
-  const runIds = new Set([...listPersistedRunIds(), ...retained.keys()]);
+  const runIds = new Set([
+    ...listPersistedRunIds(),
+    ...retained.keys(),
+    ...active.keys(),
+  ]);
   for (const runId of runIds) {
     const live = active.get(runId);
     if (live) {
       entries.push({ runId, details: live, live: true });
       continue;
     }
-    const persisted = readPersistedWorkflowDetails(runId, {
-      hydrateArtifacts: true,
-    });
+    // Reject unrelated history before normalizing potentially large inline
+    // transcripts. Side artifacts belong to explicit detail navigation.
+    const raw = readPersistedWorkflowRecord(runId);
+    if (
+      raw &&
+      !matchesRunScope(raw, runId, sessionId, referencedRunIds, startedSince)
+    ) {
+      continue;
+    }
+    const persisted = normalizeReadRecord(runId, raw);
     const retainedDetails = retained.get(runId);
     const details = persisted ?? retainedDetails;
     if (!details) continue;
     const fromRetention =
       persisted === undefined && retainedDetails !== undefined;
-    const touchedAt = Math.max(details.startedAt, details.finishedAt ?? 0);
     if (
-      touchedAt < startedSince ||
-      (!fromRetention &&
-        details.sessionId !== sessionId &&
-        !referencedRunIds.has(runId))
+      !matchesRunScope(
+        details,
+        runId,
+        sessionId,
+        referencedRunIds,
+        startedSince,
+        fromRetention,
+      )
     ) {
       continue;
     }
@@ -718,6 +768,9 @@ type DetailFocus = "phases" | "agents";
 export class WorkflowDashboard {
   private view: View = "list";
   private entries: RunEntry[] = [];
+  private historyLoaded = false;
+  private seenRetainedRunIds = new Set<string>();
+  private hydratedRunIds = new Set<string>();
   private listIndex = 0;
   private phaseIndex = 0;
   private agentIndex = 0;
@@ -826,13 +879,68 @@ export class WorkflowDashboard {
 
   private refresh() {
     const selected = this.entries[this.listIndex]?.runId;
-    this.entries = loadRunEntries(
-      this.getActive(),
-      this.sessionId,
-      this.referencedRunIds,
-      this.startedSince,
-      this.getRetained(),
-    );
+    const active = this.getActive();
+    const retained = this.getRetained();
+    if (!this.historyLoaded) {
+      this.entries = loadRunEntries(
+        active,
+        this.sessionId,
+        this.referencedRunIds,
+        this.startedSince,
+        retained,
+      );
+      this.historyLoaded = true;
+    } else {
+      // Animation ticks reuse historical projections. Only a newly settled run
+      // needs one canonical read; stable frames never scan or reread history.
+      const entries = new Map(
+        this.entries.map((entry) => [entry.runId, entry]),
+      );
+      const settledIds = new Set([
+        ...this.entries
+          .filter((entry) => entry.live && !active.has(entry.runId))
+          .map((entry) => entry.runId),
+        ...[...retained.keys()].filter(
+          (runId) =>
+            !this.seenRetainedRunIds.has(runId) &&
+            !entries.has(runId) &&
+            !active.has(runId),
+        ),
+      ]);
+      for (const runId of settledIds) {
+        const persisted = readPersistedWorkflowDetails(runId);
+        const details =
+          persisted ?? retained.get(runId) ?? entries.get(runId)?.details;
+        if (!details) continue;
+        if (
+          !matchesRunScope(
+            details,
+            runId,
+            this.sessionId,
+            this.referencedRunIds,
+            this.startedSince,
+            !persisted,
+          )
+        ) {
+          entries.delete(runId);
+          continue;
+        }
+        // Recovery operates on a projection, never on the former live owner.
+        const recovered = recoverStaleWorkflowDetails({
+          ...details,
+          agents: details.agents.map((agent) => ({ ...agent })),
+        });
+        entries.set(runId, { runId, details: recovered, live: false });
+        this.hydratedRunIds.delete(runId);
+      }
+      for (const [runId, details] of active) {
+        entries.set(runId, { runId, details, live: true });
+      }
+      this.entries = [...entries.values()].sort(
+        (a, b) => b.details.startedAt - a.details.startedAt,
+      );
+    }
+    for (const runId of retained.keys()) this.seenRetainedRunIds.add(runId);
     if (selected) {
       const index = this.entries.findIndex((e) => e.runId === selected);
       if (index >= 0) this.listIndex = index;
@@ -847,6 +955,7 @@ export class WorkflowDashboard {
       );
       if (refreshed) this.current = refreshed;
     }
+    if (this.view === "transcript") this.hydrateCurrent();
     if (this.notice && Date.now() - this.noticeAt > NOTICE_TTL_MS)
       this.notice = undefined;
   }
@@ -882,7 +991,15 @@ export class WorkflowDashboard {
     this.agentIndex = Math.min(this.agentIndex, Math.max(0, agents.length - 1));
   }
 
+  private hydrateCurrent() {
+    const entry = this.current;
+    if (!entry || entry.live || this.hydratedRunIds.has(entry.runId)) return;
+    hydrateRunArtifacts(entry.runId, entry.details);
+    this.hydratedRunIds.add(entry.runId);
+  }
+
   private saveReport() {
+    this.hydrateCurrent();
     const entry = this.current;
     if (!entry) return;
     const target = path.join(runsDir(), entry.runId, "report.md");
@@ -1023,6 +1140,7 @@ export class WorkflowDashboard {
   }
 
   private openTranscriptPage() {
+    this.hydrateCurrent();
     const transcriptAdapter = new WorkflowTranscriptAdapter();
     this.view = "transcript";
     this.transcriptPage = new AgentSessionPage(

package/extensions/workflows/index.ts

@@ -53,7 +53,11 @@ import {
   formatActivityStatus,
 } from "../shared/activity-status.ts";
 import { fitNavigationSides } from "../shared/below-editor-navigation.ts";
-import { waitBounded } from "../shared/child-session.ts";
+import {
+  inheritedChildToolAllowlist,
+  resolveStandaloneChildProjectTrust,
+  waitBounded,
+} from "../shared/child-session.ts";
 import { contextPercent } from "../shared/context-utilization.ts";
 import { completionOwnerFor } from "../shared/completion-inbox.ts";
 import {
@@ -544,6 +548,7 @@ interface ScriptAgentResult {
 }
 
 interface AgentCallOptions {
+  working_dir?: unknown;
   agent_type?: unknown;
   label?: unknown;
   phase?: unknown;
@@ -1339,11 +1344,12 @@ export default function workflows(
         structured: boolean,
         cwd: string,
         agentTypePrompt?: string,
+        childProjectTrusted = projectTrusted,
       ) =>
         createWorkflowResources(
           cwd,
           structured ? "structured" : "plain",
-          projectTrusted,
+          childProjectTrusted,
           agentTypePrompt,
         );
 
@@ -1638,6 +1644,36 @@ export default function workflows(
           );
         }
 
+        const childTools = inheritedChildToolAllowlist(
+          pi.getActiveTools(),
+          agentType?.tools,
+        );
+        if (
+          opts.working_dir !== undefined &&
+          (typeof opts.working_dir !== "string" || !opts.working_dir.trim())
+        ) {
+          return fail(
+            `agent "${label}": working_dir must be a non-empty string`,
+          );
+        }
+        const requestedCwd = path.resolve(
+          ctx.cwd,
+          typeof opts.working_dir === "string" ? opts.working_dir : ".",
+        );
+        try {
+          if (!fs.statSync(requestedCwd).isDirectory())
+            throw new Error("not a directory");
+        } catch {
+          return fail(
+            `agent "${label}": working_dir is not a directory: ${requestedCwd}`,
+          );
+        }
+        const childProjectTrusted = resolveStandaloneChildProjectTrust({
+          parentCwd: ctx.cwd,
+          childCwd: requestedCwd,
+          parentTrusted: projectTrusted,
+        });
+
         const explicitModel =
           typeof opts.model === "string" && opts.model.trim()
             ? opts.model.trim()
@@ -1708,11 +1744,14 @@ export default function workflows(
         const operatorFingerprint = operatorKey
           ? agentCallKey("workflow-operator", {
               execution: {
+                cwd: requestedCwd,
+                projectTrusted: childProjectTrusted,
+                tools: childTools,
                 agentType: agentType
                   ? {
                       name: agentType.name,
                       body: agentType.body,
-                      tools: agentType.tools,
+                      tools: childTools,
                     }
                   : undefined,
                 model: model ? `${model.provider}/${model.id}` : undefined,
@@ -1732,7 +1771,7 @@ export default function workflows(
         const replaySafe =
           operatorKey === undefined &&
           isReplaySafeAgentCall({
-            tools: agentType?.tools,
+            tools: agentType?.tools === undefined ? undefined : childTools,
             isolation: opts.isolation,
           });
         const replayLease = beginProcessReplayWorkspaceLease(replaySafe);
@@ -1744,13 +1783,14 @@ export default function workflows(
           try {
             replayResources = await getResources(
               effectiveSchema !== undefined,
-              ctx.cwd,
+              requestedCwd,
               agentType?.body,
+              childProjectTrusted,
             );
             replayIdentity = createReplayIdentity(
-              ctx.cwd,
+              requestedCwd,
               replayResources.loader,
-              projectTrusted,
+              childProjectTrusted,
             );
           } catch {
             // Fingerprinting is an optimization boundary. If resources cannot
@@ -1768,7 +1808,7 @@ export default function workflows(
                 ? {
                     name: agentType.name,
                     body: agentType.body,
-                    tools: agentType.tools,
+                    tools: childTools,
                   }
                 : undefined,
               model: model ? `${model.provider}/${model.id}` : undefined,
@@ -1925,7 +1965,7 @@ export default function workflows(
                 );
               }
               const created = await createWorktree({
-                cwd: ctx.cwd,
+                cwd: requestedCwd,
                 label,
                 id: `${details.runId}-${record.index}`,
               });
@@ -1937,18 +1977,19 @@ export default function workflows(
               worktree = created.worktree;
               if (!runSettled) record.worktreeBranch = worktree.branch;
             }
-            if (runSignal.aborted || runSettled) {
-              throw runSignal.reason instanceof Error
-                ? runSignal.reason
-                : new Error("Workflow was aborted");
-            }
-            const agentCwd = worktree?.path ?? ctx.cwd;
+            const agentCwd = worktree?.path ?? requestedCwd;
 
             // Inside the try, not before it: building resources can throw
             // (bad settings, an unreadable skills dir), and a throw out here
             // would skip the finally and leak the worktree permanently —
             // nothing sweeps `.git/pi-worktrees/` afterwards.
             try {
+              if (runSignal.aborted || runSettled) {
+                throw runSignal.reason instanceof Error
+                  ? runSignal.reason
+                  : new Error("Workflow was aborted");
+              }
+
               let rejectResourceLoad: (() => void) | undefined;
               const resourceAbort = new Promise<never>((_resolve, reject) => {
                 rejectResourceLoad = () =>
@@ -1968,6 +2009,7 @@ export default function workflows(
                     effectiveSchema !== undefined,
                     agentCwd,
                     agentType?.body,
+                    childProjectTrusted,
                   ),
                 resourceAbort,
               ]).finally(() => {
@@ -1992,7 +2034,7 @@ export default function workflows(
                   settingsManager: resources.settingsManager,
                   ...(sessionManager ? { sessionManager } : {}),
                   modelRegistry: ctx.modelRegistry,
-                  ...(agentType?.tools ? { tools: agentType.tools } : {}),
+                  tools: childTools,
                   ...(testAgentSessionFactory
                     ? { sessionFactory: testAgentSessionFactory }
                     : {}),
@@ -2108,9 +2150,9 @@ export default function workflows(
               // unfingerprintable calls always run for real.
               const completedIdentity = callKey
                 ? createReplayIdentity(
-                    ctx.cwd,
+                    requestedCwd,
                     resources.loader,
-                    projectTrusted,
+                    childProjectTrusted,
                   )
                 : undefined;
               const completedKey = completedIdentity
@@ -2157,7 +2199,7 @@ export default function workflows(
                   runId: details.runId,
                   agentIndex: record.index,
                   agentLabel: record.label,
-                  repoCwd: ctx.cwd,
+                  repoCwd: requestedCwd,
                   worktree,
                 });
                 let cleanup: WorktreeCleanup;
@@ -2174,7 +2216,7 @@ export default function workflows(
                   const reclaimer =
                     workflowLifecycleTestHooks?.reclaimWorktree ??
                     reclaimWorktree;
-                  cleanup = await reclaimer(ctx.cwd, worktree).catch(
+                  cleanup = await reclaimer(requestedCwd, worktree).catch(
                     (error): WorktreeCleanup => ({
                       removed: false,
                       branchDeleted: false,

package/extensions/workflows/progress-projection.ts

@@ -250,8 +250,11 @@ export class AgentProgressProjection {
   snapshot(
     toolTimings: ReadonlyMap<string, ProgressToolTiming> = new Map(),
   ): AgentProgressProjectionSnapshot {
+    // Reserve the initial task, then spend the remaining byte budget on the
+    // newest evidence. Forward selection would silently discard final errors
+    // after enough large tool results, even below the entry-count limit.
     const selected = this.firstEntry
-      ? [this.firstEntry, ...this.tailEntries]
+      ? [this.firstEntry, ...this.tailEntries.slice().reverse()]
       : [];
     const transcript: TranscriptEntry[] = [];
     let totalBytes = 0;
@@ -277,6 +280,9 @@ export class AgentProgressProjection {
           : { timestamp: entry.timestamp }),
       });
     }
+    // Budgeting order is not display order: keep the retained tail chronological.
+    const newestFirstTail = transcript.splice(1);
+    transcript.push(...newestFirstTail.reverse());
     if (transcript.length < this.totalEntries) {
       transcript.push({
         role: "toolResult",

package/extensions/workflows/runner.ts

@@ -50,7 +50,6 @@ import { truncateUtf8 } from "./serialization.ts";
 import { bindWorkflowToolRenderer } from "./tool-renderer.ts";
 
 const AGENT_OUTPUT_MAX_BYTES = 64 * 1024;
-export const MODEL_PROGRESS_TIMEOUT_MS = 45_000;
 
 export type WorkflowModel = NonNullable<ExtensionContext["model"]>;
 export type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
@@ -111,8 +110,6 @@ export interface RunAgentOptions {
   replayFilesystemBoundary?: ReplayFilesystemBoundaryOptions;
   /** Test-only override for the per-tool execution timeout. */
   toolCallTimeoutMs?: number;
-  /** Test-only override for the per-provider-turn model-progress timeout. */
-  modelProgressTimeoutMs?: number;
   /** Test-only override for the end-to-end abort/shutdown deadline. */
   shutdownTimeoutMs?: number;
   /** Test seam for lifecycle races; production always uses createAgentSession. */
@@ -245,119 +242,6 @@ function errorText(error: unknown): string {
   );
 }
 
-function formatTimeout(timeoutMs: number) {
-  return timeoutMs % 1_000 === 0
-    ? `${timeoutMs / 1_000} seconds`
-    : `${timeoutMs} ms`;
-}
-
-export function resolveModelProgressTimeoutMs(
-  settingsManager: SettingsManager,
-  override?: number,
-) {
-  if (override !== undefined) return override;
-  const configured =
-    settingsManager.getProjectSettings().httpIdleTimeoutMs ??
-    settingsManager.getGlobalSettings().httpIdleTimeoutMs;
-  return typeof configured === "number" && Number.isFinite(configured)
-    ? Math.max(MODEL_PROGRESS_TIMEOUT_MS, Math.floor(configured))
-    : MODEL_PROGRESS_TIMEOUT_MS;
-}
-
-/** Abort any provider turn that stops producing model-visible progress. */
-export function createModelProgressWatchdog(
-  onTimeout: (error: Error) => Promise<unknown>,
-  options: { timeoutMs?: number; model?: string } = {},
-) {
-  const timeoutMs = options.timeoutMs ?? MODEL_PROGRESS_TIMEOUT_MS;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let activeTurn = false;
-  let closed = false;
-  let rejectTimeout!: (error: Error) => void;
-  const timeout = new Promise<never>((_resolve, reject) => {
-    rejectTimeout = reject;
-  });
-
-  const clear = () => {
-    if (timer) clearTimeout(timer);
-    timer = undefined;
-  };
-  const schedule = () => {
-    clear();
-    if (!activeTurn || closed) return;
-    // This timer owns the awaited watchdog outcome. Keep it referenced so a
-    // short-lived Node 22 process cannot exit with the promise still pending.
-    timer = setTimeout(() => {
-      timer = undefined;
-      activeTurn = false;
-      closed = true;
-      const model = options.model ? ` for ${options.model}` : "";
-      const error = new Error(
-        `Agent provider turn${model} produced no model-visible progress for ${formatTimeout(timeoutMs)}; the provider request may be stalled. Retry the workflow.`,
-      );
-      rejectTimeout(error);
-      try {
-        void onTimeout(error).catch(() => {});
-      } catch {
-        // The timeout result remains authoritative even if abort throws before
-        // returning its promise; bounded shutdown below gets another chance.
-      }
-    }, timeoutMs);
-  };
-  const armTurn = () => {
-    if (closed) return;
-    activeTurn = true;
-    schedule();
-  };
-  const markProgress = () => {
-    if (!activeTurn || closed) return;
-    schedule();
-  };
-  const completeTurn = () => {
-    activeTurn = false;
-    clear();
-  };
-  const cancel = () => {
-    closed = true;
-    activeTurn = false;
-    clear();
-  };
-
-  return {
-    armTurn,
-    markProgress,
-    completeTurn,
-    cancel,
-    async waitFor<T>(operation: Promise<T>) {
-      try {
-        return await Promise.race([operation, timeout]);
-      } finally {
-        cancel();
-      }
-    },
-  };
-}
-
-function isModelVisibleProgress(event: AgentSessionEvent) {
-  if (event.type !== "message_update" || event.message.role !== "assistant") {
-    return false;
-  }
-  // Raw transport heartbeats never become AgentSession events. Empty stream,
-  // text, and thinking starts likewise cannot keep a provider turn alive.
-  const update = event.assistantMessageEvent;
-  if (
-    update.type === "text_delta" ||
-    update.type === "thinking_delta" ||
-    update.type === "toolcall_delta"
-  ) {
-    return update.delta.length > 0;
-  }
-  if (update.type === "text_end" || update.type === "thinking_end") {
-    return update.content.length > 0;
-  }
-  return update.type === "toolcall_start" || update.type === "toolcall_end";
-}
-
 export async function runAgent(
   options: RunAgentOptions,
 ): Promise<AgentOutcome> {
@@ -367,8 +251,6 @@ export async function runAgent(
   let session: AgentSession | undefined;
   let unsubscribeToolGuards: (() => void) | undefined;
   let aborted = false;
-  let terminalCause: "abort" | "model-progress-timeout" | undefined;
-  let modelProgressTimeoutMessage: string | undefined;
   let abortOperation: Promise<unknown> | undefined;
   let rejectForAbort: ((error: Error) => void) | undefined;
   let rejectForProjectionFailure: ((error: Error) => void) | undefined;
@@ -389,7 +271,6 @@ export async function runAgent(
   const onAbort = () => {
     if (aborted) return;
     aborted = true;
-    terminalCause ??= "abort";
     if (session) {
       try {
         abortOperation ??= session.abort();
@@ -594,10 +475,6 @@ export async function runAgent(
     });
   };
 
-  let armModelProgress = () => {};
-  let markModelProgress = () => {};
-  let completeModelTurn = () => {};
-  let cancelModelProgressWatchdog = () => {};
   let compactionReconcileQueued = false;
   const queueCompactionReconcile = () => {
     if (compactionReconcileQueued) return;
@@ -625,7 +502,6 @@ export async function runAgent(
   };
   const unsubscribe = childSession.subscribe((event) => {
     if (settled) return;
-    if (event.type === "turn_start") armModelProgress();
     if (event.type === "tool_execution_start") {
       toolRenderer.start(
         event.toolCallId,
@@ -648,10 +524,6 @@ export async function runAgent(
         event.isError,
       );
     }
-    if (isModelVisibleProgress(event)) markModelProgress();
-    if (event.type === "message_end" && event.message.role === "assistant") {
-      completeModelTurn();
-    }
     if (event.type === "message_end") {
       assistantSettlement = observeAssistantSettlement(
         assistantSettlement,
@@ -686,32 +558,10 @@ export async function runAgent(
     captureToolRenderData(childSession.messages);
     snapshotProjection();
     if (!aborted) {
-      const watchdog = createModelProgressWatchdog(
-        (error) => {
-          terminalCause ??= "model-progress-timeout";
-          if (terminalCause === "model-progress-timeout") {
-            modelProgressTimeoutMessage ??= error.message;
-          }
-          abortOperation ??= childSession.abort();
-          void abortOperation.catch(() => {});
-          return abortOperation;
-        },
-        {
-          timeoutMs: resolveModelProgressTimeoutMs(
-            options.settingsManager,
-            options.modelProgressTimeoutMs,
-          ),
-          model: modelId,
-        },
-      );
-      armModelProgress = watchdog.armTurn;
-      markModelProgress = watchdog.markProgress;
-      completeModelTurn = watchdog.completeTurn;
-      cancelModelProgressWatchdog = watchdog.cancel;
+      // Pi owns transport liveness and retries. Quiet model output is not
+      // evidence of a stalled request (thinking and retry backoff can be silent).
       await Promise.race([
-        watchdog.waitFor(
-          childSession.prompt(buildWorkflowAgentPrompt(options.prompt)),
-        ),
+        childSession.prompt(buildWorkflowAgentPrompt(options.prompt)),
         abortRace,
         projectionFailureRace,
       ]);
@@ -719,7 +569,6 @@ export async function runAgent(
   } catch (error) {
     promptErrorMessage ??= errorText(error);
   } finally {
-    cancelModelProgressWatchdog();
     options.signal?.removeEventListener("abort", onAbort);
     settled = true;
     unsubscribe();
@@ -758,11 +607,7 @@ export async function runAgent(
       ? `Cleanup failed: ${cleanupErrors.join("; ")}`
       : undefined;
 
-  if (
-    terminalCause === "abort" ||
-    (terminalCause === undefined &&
-      assistantSettlement?.stopReason === "aborted")
-  ) {
+  if (aborted || assistantSettlement?.stopReason === "aborted") {
     return {
       ok: false,
       output,
@@ -779,9 +624,7 @@ export async function runAgent(
   }
 
   const failureMessage =
-    (terminalCause === "model-progress-timeout"
-      ? modelProgressTimeoutMessage
-      : agentFailureMessage(assistantSettlement, promptErrorMessage)) ??
+    agentFailureMessage(assistantSettlement, promptErrorMessage) ??
     cleanupError;
   if (failureMessage !== undefined) {
     return {