Keep Mothership resource panels and activity groups in sync

Author: Sg312

apps/sim/app/api/mothership/sandbox/[token]/api/v2/[...path]/route.ts

@@ -0,0 +1,27 @@
+import type { NextRequest } from 'next/server'
+import {
+  type MothershipSandboxParams,
+  mothershipSandboxParamsSchema,
+} from '@/lib/api/contracts/mothership-sandbox'
+import { validationErrorResponse } from '@/lib/api/server'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { proxySandboxResourceRequest } from '@/lib/mothership/tools/sandbox-resource-transport'
+
+export const dynamic = 'force-dynamic'
+
+/** Raw transport boundary preserves v2 JSON, multipart and binary bodies; v2 owns operation authorization. */
+const handler = withRouteHandler(
+  async (request: NextRequest, context: { params: Promise<MothershipSandboxParams> }) => {
+    const params = mothershipSandboxParamsSchema.safeParse(await context.params)
+    if (!params.success) return validationErrorResponse(params.error)
+    return proxySandboxResourceRequest(request, params.data.token)
+  }
+)
+
+export const GET = handler
+export const HEAD = handler
+export const POST = handler
+export const PUT = handler
+export const PATCH = handler
+export const DELETE = handler
+export const OPTIONS = handler

apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.test.ts

@@ -161,6 +161,43 @@ describe('top-level activity groups', () => {
     expect(groups[1].items).toMatchObject([{ type: 'tool', data: { id: 'b1' } }])
   })
 
+  it('keeps parallel activities open through thinking gaps until their batch closes', () => {
+    const completed = [
+      activityCall('a1', 'Checking invoice inputs'),
+      activityCall('b1', 'Checking customer inputs'),
+      activityReference('a2', 'Checking invoice inputs'),
+    ].map(
+      (block): ContentBlock => ({
+        ...block,
+        toolCall: { ...block.toolCall!, status: 'success' },
+      })
+    )
+    const open = parseBlocks(completed, true)
+    expect(open).toHaveLength(2)
+    expect(open).toMatchObject([
+      { isOpen: true, items: [{ data: { id: 'a1' } }, { data: { id: 'a2' } }] },
+      { isOpen: true, items: [{ data: { id: 'b1' } }] },
+    ])
+    const settled = parseBlocks(completed, false)
+    expect(settled).toHaveLength(1)
+    expect(settled[0]).toMatchObject({ isOpen: false, completedGroupCount: 2 })
+    const proseClosed = parseBlocks([...completed, mainText('The inputs are ready.')], true)
+    expect(proseClosed[0]).toMatchObject({ isOpen: false, completedGroupCount: 2 })
+  })
+
+  it('closes at prose and reopens a reused activity below it during the same turn', () => {
+    const first = activityCall('a1', 'Checking invoice inputs')
+    first.toolCall!.status = 'success'
+    const reused = activityReference('a2', 'Checking invoice inputs')
+    reused.toolCall!.status = 'success'
+    const segments = parseBlocks([first, mainText('Checking the updated inputs.'), reused], true)
+    expect(segments).toMatchObject([
+      { type: 'agent_group', isOpen: false, activity: { id: 'Checking invoice inputs' } },
+      { type: 'text' },
+      { type: 'agent_group', isOpen: true, activity: { id: 'Checking invoice inputs' } },
+    ])
+  })
+
   it('does not merge activities across prose or absorb a subagent into the main activity', () => {
     const segments = parseBlocks([
       activityCall('a1', 'Checking invoice inputs'),

apps/sim/app/workspace/[workspaceId]/home/components/message-content/message-content.tsx

@@ -558,7 +558,7 @@ function parseBlocksWithSpanTree(blocks: ContentBlock[]): MessageSegment[] {
 }
 
 /** Each explicit activity owns a top-level group, including interleaved parallel calls. */
-function groupByActivity(segments: MessageSegment[]): MessageSegment[] {
+function groupByActivity(segments: MessageSegment[], isStreaming: boolean): MessageSegment[] {
   const labels = new Map<string, ToolActivity>()
   for (const segment of segments) {
     if (segment.type !== 'agent_group' || segment.agentName !== 'mothership') continue
@@ -569,8 +569,10 @@ function groupByActivity(segments: MessageSegment[]): MessageSegment[] {
         labels.set(activity.id, activity)
     }
   }
-  return segments.flatMap((segment): MessageSegment[] => {
+  return segments.flatMap((segment, index): MessageSegment[] => {
     if (segment.type !== 'agent_group' || segment.agentName !== 'mothership') return [segment]
+    /** A quiet model round can append calls to any activity in this visible batch. */
+    const isOpen = isStreaming && index === segments.length - 1
     const groups: AgentGroupSegment[] = []
     const byActivity = new Map<string, AgentGroupSegment>()
     let current: AgentGroupSegment | undefined
@@ -584,6 +586,7 @@ function groupByActivity(segments: MessageSegment[]): MessageSegment[] {
       else if (!current || activity || currentActivityId) {
         current = {
           ...segment,
+          isOpen,
           activity: activity ? labels.get(activity.id) : undefined,
           id:
             groups.length === 0
@@ -601,6 +604,7 @@ function groupByActivity(segments: MessageSegment[]): MessageSegment[] {
     const summaryActivity = [...groups].reverse().find((group) => group.activity)?.activity
     if (
       groups.length > 1 &&
+      !isOpen &&
       summaryActivity &&
       segment.items.every((item) => item.type === 'tool') &&
       isAgentGroupResolved(segment.items)
@@ -611,11 +615,12 @@ function groupByActivity(segments: MessageSegment[]): MessageSegment[] {
   })
 }
 
-export function parseBlocks(blocks: ContentBlock[]): MessageSegment[] {
+export function parseBlocks(blocks: ContentBlock[], isStreaming = false): MessageSegment[] {
   return groupByActivity(
     blocks.some((block) => Boolean(block.spanId))
       ? parseBlocksWithSpanTree(blocks)
-      : parseBlocksLegacy(blocks)
+      : parseBlocksLegacy(blocks),
+    isStreaming
   )
 }
 
@@ -1005,8 +1010,8 @@ function MessageContentInner({
   )
   const titledBlocks = useToolResourceTitles(cited.blocks)
   const parsed = useMemo(
-    () => (titledBlocks.length > 0 ? parseBlocks(titledBlocks) : []),
-    [titledBlocks, blockOverlayVersion]
+    () => (titledBlocks.length > 0 ? parseBlocks(titledBlocks, isStreaming) : []),
+    [titledBlocks, blockOverlayVersion, isStreaming]
   )
 
   const [trailingRevealing, setTrailingRevealing] = useState(false)

apps/sim/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content.test.tsx

@@ -1,10 +1,11 @@
 /**
  * @vitest-environment jsdom
  */
-import { act, type ReactNode, useImperativeHandle } from 'react'
+import { act, type ReactNode, StrictMode, useEffect, useImperativeHandle } from 'react'
+import { QueryClient, QueryClientProvider, useQueryClient } from '@tanstack/react-query'
 import { createRoot, type Root } from 'react-dom/client'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import type { FilePreviewSession } from '@/lib/copilot/request/session'
+import type { FilePreviewSession } from '@/lib/mothership/request/session'
 import type { FileDownloadSource } from '@/lib/uploads/client/download'
 import type { WorkspaceFileRecord } from '@/lib/uploads/contexts/workspace'
 
@@ -43,6 +44,33 @@ vi.mock('@/app/workspace/[workspaceId]/files/components/file-viewer', () => ({
   },
 }))
 
+const logQueries = vi.hoisted(() => ({
+  detail: vi.fn(() => ({ data: undefined, isLoading: true, error: null })),
+  execution: vi.fn(() => ({ data: undefined, isLoading: true, error: null })),
+}))
+vi.mock('@/hooks/queries/logs', () => ({
+  useLogDetail: logQueries.detail,
+  useLogByExecutionId: logQueries.execution,
+}))
+const canvasHydration = vi.hoisted(() => ({ enabled: false, query: vi.fn(), failed: vi.fn() }))
+vi.mock('@/app/workspace/[workspaceId]/w/[workflowId]/workflow', () => ({
+  default: ({ workflowId }: { workflowId: string }) => {
+    const client = useQueryClient()
+    useEffect(() => {
+      if (canvasHydration.enabled) {
+        void client
+          .fetchQuery({
+            queryKey: workflowKeys.state(workflowId),
+            queryFn: canvasHydration.query,
+            staleTime: 0,
+          })
+          .catch(canvasHydration.failed)
+      }
+    }, [client, workflowId])
+    return <div>Verified workflow canvas</div>
+  },
+}))
+
 vi.mock('@/app/workspace/[workspaceId]/tables/[tableId]/table', () => ({
   Table: () => null,
 }))
@@ -60,35 +88,42 @@ import {
   ResourceContent,
 } from '@/app/workspace/[workspaceId]/home/components/mothership-view/components/resource-content/resource-content'
 import type { MothershipResource } from '@/app/workspace/[workspaceId]/home/types'
+import { workflowKeys } from '@/hooks/queries/utils/workflow-keys'
 import { useTableViewPinStore } from '@/stores/table/view-pin/store'
 
 describe('ResourceContent handoff', () => {
   let container: HTMLDivElement
   let root: Root
+  let client: QueryClient
 
   beforeEach(() => {
+    vi.clearAllMocks()
+    canvasHydration.enabled = false
     ;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
     useTableViewPinStore.getState().reset()
-    vi.clearAllMocks()
     files.length = 0
     container = document.createElement('div')
     root = createRoot(container)
+    client = new QueryClient({ defaultOptions: { queries: { retry: false } } })
   })
 
   afterEach(() => {
     act(() => root.unmount())
     useTableViewPinStore.getState().reset()
+    client.clear()
   })
 
   function render(resource: MothershipResource) {
     act(() => {
       root.render(
         (
-          <ResourceContent
-            workspaceId='workspace-1'
-            desktopScopeId='chat:chat-1'
-            resource={resource}
-          />
+          <QueryClientProvider client={client}>
+            <ResourceContent
+              workspaceId='workspace-1'
+              desktopScopeId='chat:chat-1'
+              resource={resource}
+            />
+          </QueryClientProvider>
         ) as ReactNode
       )
     })
@@ -103,6 +138,89 @@ describe('ResourceContent handoff', () => {
     expect(useTableViewPinStore.getState().pins['table-1']?.viewId).toBe('view-restored')
   })
 
+  it('opens a CLI log by its execution ID instead of querying it as a storage row', () => {
+    render({ type: 'log', id: 'run-1', executionId: 'run-1', title: 'Workflow run' })
+    expect(logQueries.detail).toHaveBeenCalledWith('run-1', 'workspace-1', { enabled: false })
+    expect(logQueries.execution).toHaveBeenCalledWith('workspace-1', 'run-1')
+  })
+
+  it('keeps existing log row IDs on their ordinary detail path', () => {
+    render({ type: 'log', id: 'row-1', title: 'Workflow run' })
+    expect(logQueries.detail).toHaveBeenCalledWith('row-1', 'workspace-1', { enabled: true })
+    expect(logQueries.execution).toHaveBeenCalledWith('workspace-1', undefined)
+  })
+
+  it('opens a foreign-workspace read without adding it to this workspace sidebar', () => {
+    client.setQueryData(workflowKeys.list('workspace-1'), [])
+    client.setQueryData(workflowKeys.state('foreign'), {
+      id: 'foreign',
+      workspaceId: 'workspace-2',
+      name: 'Other workspace workflow',
+    })
+    render({ type: 'workflow', id: 'foreign', title: 'Other workspace workflow' })
+    expect(container.textContent).toContain('Other workspace workflow')
+    expect(container.textContent).toContain('Open in its workspace')
+    expect(client.getQueryData(workflowKeys.list('workspace-1'))).toEqual([])
+  })
+
+  it('uses authorized same-workspace metadata, including folder and order, for a missing inventory entry', async () => {
+    client.setQueryData(workflowKeys.list('workspace-1'), [])
+    client.setQueryData(workflowKeys.state('verified'), {
+      id: 'verified',
+      workspaceId: 'workspace-1',
+      name: 'Verified name',
+      folderId: 'actual-folder',
+      sortOrder: 42,
+      createdAt: new Date('2026-09-01'),
+      updatedAt: new Date('2026-09-02'),
+      archivedAt: null,
+    })
+    render({ type: 'workflow', id: 'verified', title: 'Untrusted placeholder' })
+    await act(async () => {})
+    expect(client.getQueryData(workflowKeys.list('workspace-1'))).toEqual([
+      expect.objectContaining({
+        id: 'verified',
+        name: 'Verified name',
+        folderId: 'actual-folder',
+        sortOrder: 42,
+        workspaceId: 'workspace-1',
+      }),
+    ])
+  })
+
+  it('does not cancel canvas hydration when StrictMode replays panel effects', async () => {
+    client.setQueryData(workflowKeys.list('workspace-1'), [{ id: 'verified' }])
+    canvasHydration.enabled = true
+    let resolveHydration!: (value: object) => void
+    let hydrationSignal: AbortSignal | undefined
+    canvasHydration.query.mockImplementation(({ signal }: { signal: AbortSignal }) => {
+      hydrationSignal = signal
+      return new Promise((resolve) => {
+        resolveHydration = resolve
+      })
+    })
+    await act(async () => {
+      root.render(
+        <StrictMode>
+          <QueryClientProvider client={client}>
+            <ResourceContent
+              workspaceId='workspace-1'
+              desktopScopeId='chat:chat-1'
+              resource={{ type: 'workflow', id: 'verified', title: 'Verified workflow' }}
+            />
+          </QueryClientProvider>
+        </StrictMode>
+      )
+    })
+    expect(canvasHydration.failed).not.toHaveBeenCalled()
+    expect(hydrationSignal?.aborted).toBe(false)
+    await act(async () => {
+      resolveHydration({ id: 'verified' })
+    })
+    expect(canvasHydration.failed).not.toHaveBeenCalled()
+    expect(container.textContent).toContain('Verified workflow canvas')
+  })
+
   it('does not pin a table opened without a saved view', () => {
     render({ type: 'table', id: 'table-1', title: 'Invoices' })