fix(mothership): end refused replay turns cleanly and bound oversized stream events (#8450)

* fix(mothership): bound replay frames and end refused turns instead of handing them off

A leased Chat stream persists every event to its Redis replay buffer before
delivering or dispatching it. When the buffer refused a write (a frame over
the 1 MiB single-write ceiling, or a stream past its 32 MiB budget), the
writer threw a generic error, the controller classified it as a takeover and
released its lock without finalizing, and every reconnect started a recovery
controller that re-received and re-refused the same event until the run
deadline. The refused tool call was never dispatched, so the worker waited.

Refusals:
- The writer throws StreamReplayBudgetExhaustedError and rejects later
  publishes the same way, but still delivers the turn's terminal error and
  complete events unpersisted; flush no longer rethrows the refusal.
- The controller aborts with that error rather than a supersession, the
  lifecycle classifies it as an error (not a user cancel), the run is
  finalized as an error with code replay_budget_exhausted, and the worker is
  told to stop. Reconnects then see a terminal run and start no controller.
- Only a genuine StreamControllerSupersededError still hands the run off.

Compaction, applied only to the copy the writer delivers and persists:
- Payloads over 256 KiB have long string leaves cut to an 8 KiB head in
  place, then medium strings to 500 characters, and only then the largest
  unprotected subtrees replaced by { omitted, bytes }, targeting 128 KiB.
  A payload-level streamTruncation marker lists every changed field.
- Identity fields, UI-read keys, arguments of client-executable calls, file
  preview events, and generate_api_key results are never compacted; such a
  frame that stays too large is refused and ends the turn cleanly.
- Oversized assistant text splits into contiguous exact pieces, and each tool
  call forwards only the head of its argument deltas.

* fix(mothership): render stream-omitted tool values honestly

A call frame whose whole argument object was omitted by stream compaction no longer replaces a tool node's arguments, and the permission card and generic tool output render omitted values as "Too large to show (N KB)" instead of raw marker JSON.

* refactor(mothership): replace replay compaction with one string-truncation pass

Compaction is now a single linear walk: when a payload's strings could
serialize past 256 KiB, string leaves longer than 8K units are cut to their
head with an inline "…[truncated, N total]" note, copying only what changes.
Identity and UI-read keys, file previews, generate_api_key results, and the
arguments of calls the browser executes are never cut; anything still over
the write ceiling is refused and ends the turn. The subtree omission, second
cut pass, truncation marker, text splitting, argument-delta cap, and the UI
stub handling are removed.

One predicate, isClientExecutedToolCall, now names the tool calls the browser
starts from the call frame; both the stream compaction and the client
dispatch use it, and the workflow tool names move beside it.

Also fixes three defects in the refusal path:
- A superseded controller that is refused an oversized frame no longer
  expires its successor's stream or clears its abort marker; teardown keys on
  whether this controller handed off, not on the abort reason.
- A refusal after a user Stop stays a cancellation: the abort reason decides.
- The per-user hourly ceiling gets its own message instead of telling the
  user to continue immediately.

* fix(mothership): stop stale approval cards, raw backend bodies, and errored-turn spinners

- A replayed call frame is history and never gates anything, so Sim now clears
  the worker's awaiting_approval stamp on it as it already does for live
  frames. Replays no longer render Allow/Skip cards when approvals are off.
- Stop settles every unfinished tool row (pending, executing, or awaiting
  approval) through one shared predicate, isUnsettledToolState, on the
  persisted, live, and pending-message paths.
- An errored turn settles its unfinished tool rows as errored when it is
  persisted, so they no longer reload as spinners.
- A failed backend response no longer puts the upstream body in the error
  shown to users: 5xx and non-JSON bodies say the service is temporarily
  unavailable, 4xx uses the worker's displayMessage or a generic message.
  The status and body stay on the error for logs.

* fix(mothership): never forward an approval stamp on a frame that cannot be gated

The worker stamps awaiting_approval on resolved integration calls and relies
on Sim to keep or clear it. Sim cleared it on live complete frames that were
not gated, but a partial frame returned before that decision and kept the
stamp. Only a live, complete call frame can be held behind a prompt, so every
replayed or partial frame now drops the stamp at the one point each frame
passes through before it is persisted and delivered. With approvals off, no
frame, replay, snapshot, or persisted row can carry the stamp to the client.

* fix(mothership): keep retrying an unreachable worker through a task replacement

A worker task replacement leaves the load balancer answering 502/504 for
about a minute. Stream retries stopped after three attempts, about four
seconds, and ended the turn with an error. While no worker answers (a 5xx or
no connection), retries now continue with the existing backoff for up to two
minutes from the first failure, still bounded by the run deadline and by
Stop. Each attempt re-sends the same message identity, which the worker
treats as a reattach rather than a second run. Streams that end without a
terminal keep the three-retry limit.

* fix(mothership): settle runs whose terminal events fail, and tighten compaction and cleanup

- A controller that lost its lock while handling an ordinary failure no
  longer expires its successor's stream or clears its abort marker: teardown
  skips cleanup when this controller handed off or was superseded.
- The terminal run status is now written even when publishing the terminal
  events fails. The write stays scoped to this controller's token and never
  replaces a terminal status, so a successor's run is left alone. Before, such
  a failure left the run non-terminal with nothing to settle it.
- A failed backend response is described by its status alone: 5xx says the
  service is temporarily unavailable, anything else that the request could
  not be processed.
- Compaction no longer exempts whole subtrees by key name. Every string the
  UI reads for identity, status, titles, or targets is far shorter than the
  cut, and long text keeps its head, so only client-executed call arguments,
  file previews, and generate_api_key results are left whole.

* fix(mothership): settle tool rows left unfinished by any finished turn

- A completed turn now persists its unfinished tool rows settled as the live
  view settled them at complete, so they no longer reload as spinners.
- A stored message's unfinished tool rows render as interrupted, which settles
  rows persisted before these fixes; the live streaming message is unchanged.
- The client's error finalize settles pending and awaiting-approval rows too:
  finalizeResidualToolCalls reports whether it settled anything, and that
  decides whether the snapshot is rewritten.

* fix(mothership): harden replay compaction, stream retries, teardown, and backend errors

- Assistant text is never compacted: its length is part of the text receipt a
  replacement controller and the worker check. When cutting strings alone
  cannot bound an event, long arrays keep their first 100 items and a count.
- Only a gateway error page (502/503/504 without a JSON body) or a failed
  connection counts as an unreachable worker for the two-minute window; a
  JSON 5xx from a reachable worker keeps the three-retry limit. A retry that
  streams again resets the budget for the next outage.
- A controller cleans up its stream's buffer and abort marker only while it
  still holds the chat lock, checked just before cleanup and before releasing
  the lock, instead of inferring ownership from flags.
- A controller superseded while publishing its terminal events leaves the run
  to its successor; other publish failures still settle the run.
- A 4xx shows the worker's own short, plain reason (rate limit, BYOK, plan
  mode, model selection, version skew) and hides internal identifiers.
- File preview snapshots are spaced by size, so a large file's patch preview
  can no longer fill the stream's replay budget; small files keep their pace.

* fix(mothership): separate retry budgets, cap preview totals, and clean up only ended turns

- An unreachable worker and a reachable one now have independent retry
  budgets. Any answer from the worker restarts only the two-minute
  unreachable window; the three-retry, 30 s budget for failures of a worker
  that answered keeps its original semantics, so a failure that repeats
  after every reattach still stops, and a long outage no longer spends the
  replacement's retries.
- Intermediate file preview content is capped at 8M characters per edit;
  past it the preview holds until the final snapshot, which is always sent.
- A controller cleans up its stream only when it finalized the turn and
  still holds the lock, so a run it leaves recoverable keeps its buffer and
  any pending Stop.
- Remove the unreachable generate_api_key compaction exemption, avoid a
  second copy of trimmed arrays, and correct the size-estimate comment.

* fix(mothership): clean up turns whose terminal publish failed and cap previews per turn in bytes

- A controller that ended its turn but could not publish the terminal events
  still cleans up its stream: the run is settled either way, so the buffer no
  longer lingers for its full TTL. Only a superseded controller skips cleanup,
  and the lease check still protects a successor.
- The intermediate file preview cap is now 8 MiB of UTF-8 per stream loop,
  across all of its edits, instead of characters per edit. Each edit's final
  snapshot is still always sent.

* fix(mothership): bound preview frames per write and per turn, and narrow unreachable retries

- A file preview frame whose content would not fit one replay write, or that
  would exceed the turn's preview budget, is skipped instead of sent: the
  preview holds its last content and the client loads the stored file on
  completion. A completion too large to send whole drops its tool output.
  The per-frame limit derives from the replay buffer's single-write ceiling,
  and the 8 MiB budget now covers every preview frame in the turn, finals
  included, across all legs. A large file preview no longer ends the turn.
- Only a request that fails before any response headers counts as an
  unreachable worker. A TypeError raised after the response began, including
  one from handling delivered events, keeps the three-retry budget, so a
  deterministic failure can no longer retry until the run deadline.
- A worker that cannot be reached is reported with the generic "temporarily
  unavailable" message; the network error stays on the error's cause.
- Retry logs and spans count retries from both budgets.

* fix(mothership): omit the largest field of an event no cut can bound, and persist closed lanes

- An event whose many short values survive every string and array cut, such
  as an object with thousands of keys, now has its largest bulk field
  replaced by a size note when it would still exceed one replay write,
  instead of ending the turn. Identity fields and client-executed arguments
  are never replaced; such an event is still refused cleanly.
- finalizeResidualToolCalls reports closing an open subagent lane as a
  change, so the error finalizer persists it instead of leaving a stale lane.

* fix(mothership): keep sibling fields when omitting bulk, and never cache a skipped preview as file content

- The last-resort omission for an event no cut can bound now walks down from
  the largest field while one child holds most of its parent's bytes and
  replaces only that node, so the ids, resources, and status fields beside
  the bulk keep driving the UI's resource updates.
- On completion the client seeds the file content cache from preview text
  only when it received the completed version. When the server skipped the
  final content frame, the text is an earlier draft, so the stored file loads
  instead.

* fix(mothership): keep omitting bulk until an event fits one replay write

A result with more than one large object of short fields left the second
one over the write limit after the first was omitted, so the event was
refused and the turn ended. Omission now repeats until the event fits or
nothing large enough is left; each pass removes at least 64 KiB, so it
always terminates.

* fix(mothership): shed oversized replay events in one pass and retry mid-body stream cuts

- Replace the replay-compaction omit loop with one bounded pass over memoized
  exact serialized sizes: recurse into the smallest child that covers the
  overage, otherwise drop the largest children whole, keeping small siblings
- Map a non-abort body-read failure from the worker stream to a retryable
  WorkerStreamInterruptedError on the reachable budget, with the generic
  message and the original error on cause
- Log the cause message on retry warnings and orchestration failures
- Count replayed file preview content toward a restored turn's preview budget

* refactor(mothership): tidy replay compaction and stream retry after review

- Share the replay write ceiling between compaction and file previews
- Scan for the smallest sufficient child only once one can cover the need,
  and reuse one size memo across every compaction step
- Stop retrying a raw TypeError; fetch and body-read failures are already
  wrapped as WorkerUnreachableError and WorkerStreamInterruptedError
- Use absolute imports, a private retry counter, a typed unsettled-state set,
  and hasUnsettledTool naming
- Cover a timed-out body read and the preview completion edge cases

* fix(mothership): bound preview metadata frames and settle stopped rows on every save

- Compact every preview phase except content and completion, which the preview
  adapter already bounds; a model-written patch search string could otherwise
  exceed one replay write in an edit_meta frame
- Settle unfinished tool rows as stopped in buildPersistedAssistantMessage for a
  cancelled turn, so background and API callers that persist the result
  directly never save pending, executing, or awaiting-approval rows

Author: waleedlatif1

apps/sim/app/api/copilot/confirm/route.ts

@@ -42,13 +42,13 @@ import {
   retainSealedClientToolContext,
   sealClientToolCompletion,
 } from '@/lib/mothership/request/tools/client-completion-seal.server'
+import { isWorkflowToolName } from '@/lib/mothership/tools/client-executed-tools'
 import {
   createStructuralWorkflowToolCompletionData,
   getWorkflowToolCompletionExecutionId,
   getWorkflowToolCompletionMessage,
   getWorkflowToolConfirmationStatus,
   getWorkflowToolLaunchError,
-  isWorkflowToolName,
   resolveWorkflowToolTargetId,
   WORKFLOW_EXECUTION_BUSY,
   type WorkflowToolLaunchError,

apps/sim/app/workspace/[workspaceId]/home/hooks/message-reconcile.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest'
+import type { PersistedMessage } from '@/lib/mothership/chat/persisted-message'
+import { markMessageStopped } from '@/app/workspace/[workspaceId]/home/hooks/message-reconcile'
+
+describe('markMessageStopped', () => {
+  it.each(['executing', 'pending', 'awaiting_approval'] as const)(
+    'settles a %s tool row as stopped',
+    (state) => {
+      const message: PersistedMessage = {
+        id: 'assistant-1',
+        role: 'assistant',
+        content: '',
+        timestamp: '2026-09-29T00:00:00.000Z',
+        contentBlocks: [
+          {
+            type: 'tool',
+            endedAt: 1,
+            toolCall: { id: 'call-1', name: 'gmail_read_v2', state },
+          },
+        ],
+      }
+
+      const stopped = markMessageStopped(message)
+
+      expect(stopped.contentBlocks?.[0].toolCall?.state).toBe('cancelled')
+    }
+  )
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/message-reconcile.ts

@@ -8,7 +8,11 @@
 import { isBrowserToolName } from '@sim/browser-protocol'
 import type { PersistedContentBlock } from '@/lib/api/contracts/copilot-messages'
 import type { PersistedMessage } from '@/lib/mothership/chat/persisted-message'
-import { normalizeMessage, withBlockTiming } from '@/lib/mothership/chat/persisted-message'
+import {
+  isUnsettledToolState,
+  normalizeMessage,
+  withBlockTiming,
+} from '@/lib/mothership/chat/persisted-message'
 import {
   MothershipStreamV1CompletionStatus,
   MothershipStreamV1EventType,
@@ -18,7 +22,7 @@ import {
   MothershipStreamV1ToolPhase,
 } from '@/lib/mothership/generated/mothership-stream-v1'
 import type { StreamBatchEvent } from '@/lib/mothership/request/session/types'
-import { isWorkflowToolName } from '@/lib/mothership/tools/workflow-tools'
+import { isWorkflowToolName } from '@/lib/mothership/tools/client-executed-tools'
 import type { ContentBlock } from '@/app/workspace/[workspaceId]/home/types'
 import type { MothershipChatHistory } from '@/hooks/queries/mothership-chats'
 import { isZeroStreamCursor } from './stream-protocol'
@@ -142,18 +146,18 @@ export function buildAssistantSnapshotMessage(params: {
 }
 
 export function markMessageStopped(message: PersistedMessage): PersistedMessage {
-  const hasExecutingTool = message.contentBlocks?.some(
-    (block) => block.toolCall?.state === 'executing'
+  const hasUnsettledTool = message.contentBlocks?.some((block) =>
+    isUnsettledToolState(block.toolCall?.state)
   )
   const hasOpenBlock = message.contentBlocks?.some((block) => block.endedAt === undefined)
-  if (!hasExecutingTool && !hasOpenBlock) {
+  if (!hasUnsettledTool && !hasOpenBlock) {
     return message
   }
 
   const stopTs = Date.now()
   const nextBlocks = (message.contentBlocks ?? []).map((block) => {
     const stamped = block.endedAt === undefined ? { ...block, endedAt: stopTs } : block
-    if (stamped.toolCall?.state !== 'executing') {
+    if (!stamped.toolCall || !isUnsettledToolState(stamped.toolCall.state)) {
       return stamped
     }
     return {

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it } from 'vitest'
 import type { FilePreviewSession } from '@/lib/mothership/request/session'
-import { deriveFilePreviewSession } from './apply-file-preview-phase'
+import {
+  deriveFilePreviewSession,
+  previewHoldsFinalContent,
+} from '@/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase'
 
 const NOW = '2026-06-08T00:00:00.000Z'
 
@@ -94,3 +97,40 @@ describe('deriveFilePreviewSession', () => {
     expect(third?.previewText).toBe('ABC')
   })
 })
+
+describe('previewHoldsFinalContent', () => {
+  const complete = (previewVersion?: number) => ({
+    previewPhase: 'file_preview_complete' as const,
+    toolCallId: 'tool-1',
+    toolName: 'prepare_file_edit' as const,
+    ...(previewVersion !== undefined ? { previewVersion } : {}),
+  })
+
+  it('holds the final content when the last content received is the completed version', () => {
+    const prev = session({ previewText: 'final text', previewVersion: 7 })
+
+    expect(previewHoldsFinalContent(prev, complete(7))).toBe(true)
+  })
+
+  it('does not hold it when later versions were never received, so the stored file must load', () => {
+    const prev = session({ previewText: 'an earlier draft', previewVersion: 5 })
+
+    expect(previewHoldsFinalContent(prev, complete(7))).toBe(false)
+  })
+
+  it('does not hold it when no content was received at all', () => {
+    expect(previewHoldsFinalContent(undefined, complete(7))).toBe(false)
+  })
+
+  it('does not hold it when the session exists but received no text', () => {
+    const prev = session({ previewText: '', previewVersion: 7 })
+
+    expect(previewHoldsFinalContent(prev, complete(7))).toBe(false)
+  })
+
+  it('holds the received text when the completion carries no version to compare', () => {
+    const prev = session({ previewText: 'final text', previewVersion: 3 })
+
+    expect(previewHoldsFinalContent(prev, complete())).toBe(true)
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase.ts

@@ -99,3 +99,17 @@ export function deriveFilePreviewSession(
       }
   }
 }
+
+/**
+ * Whether the preview text the client holds is the edit's final content. The
+ * server skips a content frame too large for the stream, so a completion whose
+ * version is newer than the last content received means the text is an earlier
+ * draft, and only the stored file is the saved result.
+ */
+export function previewHoldsFinalContent(
+  prev: FilePreviewSession | undefined,
+  completion: Extract<SyntheticFilePreviewPayload, { previewPhase: 'file_preview_complete' }>
+): boolean {
+  if (!prev || prev.previewText.length === 0) return false
+  return completion.previewVersion === undefined || prev.previewVersion >= completion.previewVersion
+}

apps/sim/app/workspace/[workspaceId]/home/hooks/preview/use-file-preview-controller.ts

@@ -12,7 +12,10 @@ import { useQueryClient } from '@tanstack/react-query'
 import type { SyntheticFilePreviewPayload } from '@/lib/mothership/request/session'
 import type { FilePreviewSession } from '@/lib/mothership/request/session/file-preview-session-contract'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
-import { deriveFilePreviewSession } from '@/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase'
+import {
+  deriveFilePreviewSession,
+  previewHoldsFinalContent,
+} from '@/app/workspace/[workspaceId]/home/hooks/preview/apply-file-preview-phase'
 import {
   buildCompletedPreviewSessions,
   type FilePreviewSessionsState,
@@ -381,7 +384,7 @@ export function useFilePreviewController({
           sessionId: nextSession.id,
           suppressActivation: !shouldActivateOnComplete,
         })
-        if (hasRenderableFilePreviewContent(nextSession)) {
+        if (previewHoldsFinalContent(prevSession, payload)) {
           seedCompletedPreviewContentCache(fileId, nextSession.previewText)
         }
         if (workspaceId) invalidateResourceQueries(queryClient, workspaceId, 'file', fileId)

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.test.ts

@@ -4,9 +4,6 @@ vi.mock('@/lib/mothership/resources/extraction', () => ({
   isResourceToolName: vi.fn(() => false),
   extractResourcesFromToolResult: vi.fn(() => []),
 }))
-vi.mock('@/lib/mothership/tools/workflow-tools', () => ({
-  isWorkflowToolName: vi.fn(() => false),
-}))
 vi.mock(
   '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry',
   () => ({ invalidateResourceQueries: vi.fn() })

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/handle-tool-event.ts

@@ -14,8 +14,10 @@ import {
   extractResourcesFromToolResult,
   isResourceToolName,
 } from '@/lib/mothership/resources/extraction'
-import { isNativeFileTool, isUserLocalVfsToolCall } from '@/lib/mothership/tools/local-filesystem'
-import { isWorkflowToolName } from '@/lib/mothership/tools/workflow-tools'
+import {
+  isClientExecutedToolCall,
+  isWorkflowToolName,
+} from '@/lib/mothership/tools/client-executed-tools'
 import { invalidateResourceQueries } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-registry'
 import type { StreamLoopContext } from '@/app/workspace/[workspaceId]/home/hooks/stream/stream-context'
 import {
@@ -188,56 +190,23 @@ export function handleToolEvent(ctx: StreamLoopContext, parsed: ToolEvent): void
   const name = payload.toolName
   const isPartial =
     payload.partial === true || payload.status === MothershipStreamV1ToolStatus.generating
-  if (isWorkflowToolName(name) && !isPartial) {
-    const shouldStartWorkflowTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartWorkflowTool) {
-      const args = payload.arguments as Record<string, unknown> | undefined
+  const args = payload.arguments as Record<string, unknown> | undefined
+  const shouldStartClientTool =
+    isClientExecutedToolCall(name, args) &&
+    !isPartial &&
+    !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
+    node?.kind === 'tool' &&
+    node.status === 'running' &&
+    !node.result
+  if (shouldStartClientTool) {
+    if (isWorkflowToolName(name)) {
       deps.startClientWorkflowTool(rawId, name, args ?? {})
-    }
-  }
-  const localFilesystemArgs = payload.arguments as Record<string, unknown> | undefined
-  if ((isNativeFileTool(name) || isUserLocalVfsToolCall(name, localFilesystemArgs)) && !isPartial) {
-    const shouldStartLocalFilesystemTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartLocalFilesystemTool) {
-      deps.startClientLocalFilesystemTool(rawId, name, localFilesystemArgs ?? {})
-    }
-  }
-  if (isCurrentBrowserToolName(name) && !isPartial) {
-    const shouldStartBrowserTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartBrowserTool) {
-      deps.startClientBrowserTool(
-        rawId,
-        name,
-        (payload.arguments as Record<string, unknown> | undefined) ?? {},
-        parsed.ts
-      )
-    }
-  }
-  if (isTerminalToolName(name) && !isPartial) {
-    const shouldStartTerminalTool =
-      !deps.options.suppressedWorkflowToolStartIds?.has(rawId) &&
-      node?.kind === 'tool' &&
-      node.status === 'running' &&
-      !node.result
-    if (shouldStartTerminalTool) {
-      deps.startClientTerminalTool(
-        rawId,
-        name,
-        (payload.arguments as Record<string, unknown> | undefined) ?? {},
-        parsed.ts
-      )
+    } else if (isCurrentBrowserToolName(name)) {
+      deps.startClientBrowserTool(rawId, name, args ?? {}, parsed.ts)
+    } else if (isTerminalToolName(name)) {
+      deps.startClientTerminalTool(rawId, name, args ?? {}, parsed.ts)
+    } else {
+      deps.startClientLocalFilesystemTool(rawId, name, args ?? {})
     }
   }
   ops.flush()

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { finalizeResidualToolCalls } from '@/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers'
+import type { ContentBlock } from '@/app/workspace/[workspaceId]/home/types'
+
+describe('finalizeResidualToolCalls', () => {
+  it.each(['executing', 'awaiting_approval'] as const)(
+    'settles a %s tool row with the turn outcome on Stop',
+    (status) => {
+      const blocks: ContentBlock[] = [
+        { type: 'tool_call', toolCall: { id: 'call-1', name: 'gmail_read_v2', status } },
+      ]
+
+      finalizeResidualToolCalls(blocks, 'cancelled')
+
+      expect(blocks[0].toolCall?.status).toBe('cancelled')
+    }
+  )
+
+  it('reports whether any tool row was left to settle', () => {
+    const open: ContentBlock[] = [
+      { type: 'tool_call', toolCall: { id: 'call-1', name: 'read', status: 'awaiting_approval' } },
+    ]
+    const settled: ContentBlock[] = [
+      { type: 'tool_call', toolCall: { id: 'call-2', name: 'read', status: 'success' } },
+    ]
+
+    expect(finalizeResidualToolCalls(open, 'error')).toBe(true)
+    expect(finalizeResidualToolCalls(settled, 'error')).toBe(false)
+  })
+
+  it('reports closing an open subagent lane as a change to persist', () => {
+    const blocks: ContentBlock[] = [{ type: 'subagent', content: 'research' }]
+
+    expect(finalizeResidualToolCalls(blocks, 'error')).toBe(true)
+    expect(blocks[0].endedAt).toEqual(expect.any(Number))
+  })
+})

apps/sim/app/workspace/[workspaceId]/home/hooks/stream/stream-helpers.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { isRecordLike } from '@sim/utils/object'
+import { isUnsettledToolState } from '@/lib/mothership/chat/persisted-message'
 import {
   CallIntegrationTool,
   CreateEmptyFile,
@@ -68,17 +69,17 @@ export function asPayloadRecord(value: unknown): StreamPayload | undefined {
 }
 
 /**
- * Settles any tool row still `executing` at a turn terminal by propagating the
- * turn's outcome — the deterministic replacement for the old `interrupted`
- * invention. A clean `complete` means the turn succeeded, so a straggler is
- * settled `success` (with explicit tool/span terminals from the backend there
- * are normally none); a stop settles `cancelled`; an error settles `error`.
+ * Settles every unfinished tool row (running, pending, or awaiting approval) at
+ * a turn terminal by propagating the turn's outcome: a clean `complete` settles
+ * a straggler `success`, a stop `cancelled`, an error `error`. Also closes any
+ * open subagent lane. Returns whether it settled a row or closed a lane.
  */
 export function finalizeResidualToolCalls(
   blocks: ContentBlock[],
   turnTerminal: 'complete' | 'cancelled' | 'error'
-): void {
+): boolean {
   const endedAt = Date.now()
+  let settled = false
   const propagated =
     turnTerminal === 'cancelled'
       ? ToolCallStatus.cancelled
@@ -93,10 +94,12 @@ export function finalizeResidualToolCalls(
     // transport-based gating.
     if (block.type === 'subagent' && block.endedAt === undefined) {
       block.endedAt = endedAt
+      settled = true
       continue
     }
     const tc = block.toolCall
-    if (!tc || tc.status !== ToolCallStatus.executing) continue
+    if (!tc || !isUnsettledToolState(tc.status)) continue
+    settled = true
     tc.status = propagated
     if (propagated === ToolCallStatus.cancelled) {
       tc.displayTitle = 'Stopped by user'
@@ -105,6 +108,7 @@ export function finalizeResidualToolCalls(
       block.endedAt = endedAt
     }
   }
+  return settled
 }
 
 function stringParam(value: unknown): string | undefined {