Fix regression

Author: Sg312

apps/sim/app/api/workflows/[id]/route.test.ts

@@ -20,6 +20,7 @@ import {
 } from '@sim/testing'
 import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { getWorkflowResponseDataSchema } from '@/lib/api/contracts/workflows'
 
 const mockLoadWorkflowFromNormalizedTables =
   workflowsPersistenceUtilsMockFns.mockLoadWorkflowFromNormalizedTables
@@ -183,6 +184,55 @@ describe('Workflow By ID API Route', () => {
       expect(data.data.id).toBe('workflow-123')
     })
 
+    it('omits null workflow description from state metadata so response validates', async () => {
+      const mockWorkflow = {
+        id: 'workflow-null-description',
+        userId: 'user-123',
+        name: 'No Description Workflow',
+        description: null,
+        workspaceId: 'workspace-456',
+        folderId: null,
+        sortOrder: 0,
+        color: '#3972F6',
+        lastSynced: new Date(),
+        createdAt: new Date(),
+        updatedAt: new Date(),
+        isDeployed: false,
+        deployedAt: null,
+        isPublicApi: false,
+        locked: false,
+        runCount: 0,
+        lastRunAt: null,
+        archivedAt: null,
+        variables: {},
+      }
+
+      mockGetSession({ user: { id: 'user-123' } })
+      mockGetWorkflowById.mockResolvedValue(mockWorkflow)
+      mockAuthorizeWorkflowByWorkspacePermission.mockResolvedValue({
+        allowed: true,
+        status: 200,
+        workflow: mockWorkflow,
+        workspacePermission: 'admin',
+      })
+      mockLoadWorkflowFromNormalizedTables.mockResolvedValue({
+        blocks: {},
+        edges: [],
+        loops: {},
+        parallels: {},
+      })
+
+      const req = new NextRequest('http://localhost:3000/api/workflows/workflow-null-description')
+      const params = Promise.resolve({ id: 'workflow-null-description' })
+
+      const response = await GET(req, { params })
+      const data = await response.json()
+
+      expect(response.status).toBe(200)
+      expect(data.data.state.metadata).toEqual({ name: 'No Description Workflow' })
+      expect(getWorkflowResponseDataSchema.safeParse(data.data).success).toBe(true)
+    })
+
     it.concurrent('should allow access when user has workspace permissions', async () => {
       const mockWorkflow = {
         id: 'workflow-123',

apps/sim/app/api/workflows/[id]/route.ts

@@ -108,6 +108,12 @@ export const GET = withRouteHandler(
           stampedVariables[variableId] = { ...variable, workflowId }
         }
       }
+      const workflowStateMetadata = {
+        name: responseWorkflowData.name,
+        ...(typeof responseWorkflowData.description === 'string'
+          ? { description: responseWorkflowData.description }
+          : {}),
+      }
 
       if (snapshot.normalizedData) {
         const finalWorkflowData = {
@@ -120,10 +126,7 @@ export const GET = withRouteHandler(
             lastSaved: Date.now(),
             isDeployed: responseWorkflowData.isDeployed || false,
             deployedAt: responseWorkflowData.deployedAt,
-            metadata: {
-              name: responseWorkflowData.name,
-              description: responseWorkflowData.description,
-            },
+            metadata: workflowStateMetadata,
           },
           variables: stampedVariables,
         }
@@ -145,10 +148,7 @@ export const GET = withRouteHandler(
           lastSaved: Date.now(),
           isDeployed: responseWorkflowData.isDeployed || false,
           deployedAt: responseWorkflowData.deployedAt,
-          metadata: {
-            name: responseWorkflowData.name,
-            description: responseWorkflowData.description,
-          },
+          metadata: workflowStateMetadata,
         },
         variables: stampedVariables,
       }

apps/sim/lib/copilot/request/handlers/handlers.test.ts

@@ -12,10 +12,16 @@ const { isSimExecuted, executeTool, ensureHandlersRegistered } = vi.hoisted(() =
   ensureHandlersRegistered: vi.fn(),
 }))
 
-const { upsertAsyncToolCall, markAsyncToolRunning, completeAsyncToolCall } = vi.hoisted(() => ({
-  upsertAsyncToolCall: vi.fn(),
-  markAsyncToolRunning: vi.fn(),
-  completeAsyncToolCall: vi.fn(),
+const { upsertAsyncToolCall, markAsyncToolRunning, completeAsyncToolCall, markAsyncToolDelivered } =
+  vi.hoisted(() => ({
+    upsertAsyncToolCall: vi.fn(),
+    markAsyncToolRunning: vi.fn(),
+    completeAsyncToolCall: vi.fn(),
+    markAsyncToolDelivered: vi.fn(),
+  }))
+
+const { waitForToolCompletion } = vi.hoisted(() => ({
+  waitForToolCompletion: vi.fn(),
 }))
 
 vi.mock('@/lib/copilot/tool-executor', () => ({
@@ -34,16 +40,20 @@ vi.mock('@/lib/copilot/async-runs/repository', () => ({
   createRunCheckpoint: vi.fn(),
   getAsyncToolCall: vi.fn(),
   markAsyncToolStatus: vi.fn(),
-  markAsyncToolDelivered: vi.fn(),
   listAsyncToolCallsForRun: vi.fn(),
   getAsyncToolCalls: vi.fn(),
   claimCompletedAsyncToolCall: vi.fn(),
   releaseCompletedAsyncToolClaim: vi.fn(),
   upsertAsyncToolCall,
   markAsyncToolRunning,
+  markAsyncToolDelivered,
   completeAsyncToolCall,
 }))
 
+vi.mock('@/lib/copilot/request/tools/client', () => ({
+  waitForToolCompletion,
+}))
+
 import {
   MothershipStreamV1AsyncToolRecordStatus,
   MothershipStreamV1EventType,
@@ -68,6 +78,8 @@ describe('sse-handlers tool lifecycle', () => {
     upsertAsyncToolCall.mockResolvedValue(null)
     markAsyncToolRunning.mockResolvedValue(null)
     completeAsyncToolCall.mockResolvedValue(null)
+    markAsyncToolDelivered.mockResolvedValue(null)
+    waitForToolCompletion.mockResolvedValue(null)
     context = {
       chatId: undefined,
       messageId: 'msg-1',
@@ -236,6 +248,51 @@ describe('sse-handlers tool lifecycle', () => {
     expect(updated?.result?.output).toBe('done')
   })
 
+  it('marks background client workflow tools delivered after synthetic result emission', async () => {
+    waitForToolCompletion.mockResolvedValueOnce({
+      status: 'background',
+      data: { detached: true },
+    })
+    const onEvent = vi.fn()
+
+    await sseHandlers.tool(
+      {
+        type: MothershipStreamV1EventType.tool,
+        payload: {
+          toolCallId: 'tool-background',
+          toolName: 'run_workflow',
+          arguments: { workflowId: 'workflow-1' },
+          executor: MothershipStreamV1ToolExecutor.client,
+          mode: MothershipStreamV1ToolMode.async,
+          phase: MothershipStreamV1ToolPhase.call,
+        },
+      } satisfies StreamEvent,
+      context,
+      execContext,
+      { onEvent, interactive: true, timeout: 1000 }
+    )
+
+    await sleep(0)
+    await Promise.allSettled(context.pendingToolPromises.values())
+
+    expect(markAsyncToolDelivered).toHaveBeenCalledWith('tool-background')
+    expect(onEvent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: MothershipStreamV1EventType.tool,
+        payload: expect.objectContaining({
+          toolCallId: 'tool-background',
+          phase: MothershipStreamV1ToolPhase.result,
+          status: MothershipStreamV1ToolOutcome.skipped,
+          success: true,
+          output: { detached: true },
+        }),
+      })
+    )
+    expect(context.toolCalls.get('tool-background')?.status).toBe(
+      MothershipStreamV1ToolOutcome.skipped
+    )
+  })
+
   it('does not add hidden tool calls to content blocks', async () => {
     executeTool.mockResolvedValueOnce({ success: true, output: { skill: 'ok' } })
 

apps/sim/lib/copilot/request/handlers/tool.ts

@@ -1,6 +1,7 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage, toError } from '@sim/utils/errors'
-import { upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
+import { ASYNC_TOOL_CONFIRMATION_STATUS } from '@/lib/copilot/async-runs/lifecycle'
+import { markAsyncToolDelivered, upsertAsyncToolCall } from '@/lib/copilot/async-runs/repository'
 import { STREAM_TIMEOUT_MS } from '@/lib/copilot/constants'
 import {
   MothershipStreamV1AsyncToolRecordStatus,
@@ -457,6 +458,15 @@ async function dispatchToolExecution(
             span.setAttribute(TraceAttr.ToolOutcome, completion.status)
           }
           handleClientCompletion(toolCall, toolCallId, completion)
+          if (completion?.status === ASYNC_TOOL_CONFIRMATION_STATUS.background) {
+            await markAsyncToolDelivered(toolCallId).catch((err) => {
+              logger.warn(`Failed to mark background ${scopeLabel}tool delivered`, {
+                toolCallId,
+                toolName,
+                error: toError(err).message,
+              })
+            })
+          }
           await emitSyntheticToolResult(toolCallId, toolCall.name, completion, options)
           return (
             completion ?? {