fix(copilot): release failed workflow claims

Author: icecrasher321

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

@@ -43,6 +43,7 @@ const {
   mockInitializeExecutionStreamMeta,
   mockReleaseExecutionIdClaim,
   mockReleaseExecutionSlot,
+  mockReleaseWorkflowToolExecutionClaim,
   mockRequireBillingAttributionHeader,
   mockValidatePublicApiAllowed,
 } = vi.hoisted(() => ({
@@ -67,6 +68,7 @@ const {
   mockInitializeExecutionStreamMeta: vi.fn(),
   mockReleaseExecutionIdClaim: vi.fn(),
   mockReleaseExecutionSlot: vi.fn(),
+  mockReleaseWorkflowToolExecutionClaim: vi.fn(),
   mockRequireBillingAttributionHeader: vi.fn(),
   mockValidatePublicApiAllowed: vi.fn(),
 }))
@@ -119,6 +121,7 @@ vi.mock('@/lib/copilot/async-runs/repository', () => ({
   claimWorkflowToolExecution: mockClaimWorkflowToolExecution,
   getAsyncToolCall: mockGetAsyncToolCall,
   getRunSegment: mockGetRunSegment,
+  releaseWorkflowToolExecutionClaim: mockReleaseWorkflowToolExecutionClaim,
 }))
 
 vi.mock('@/lib/execution/event-buffer', () => ({
@@ -435,6 +438,7 @@ describe('workflow execute async route', () => {
     expect(response.status).toBe(200)
     expect(streamCompleted).toBe(false)
     expect(mockClaimWorkflowToolExecution).toHaveBeenCalledWith('copilot-tool-1', 'execution-123')
+    expect(mockReleaseWorkflowToolExecutionClaim).not.toHaveBeenCalled()
     expect(loggingSessionMockFns.mockSetTrustedExecutionCorrelation).toHaveBeenCalledWith({
       executionId: 'execution-123',
       requestId: 'req-12345678',
@@ -466,9 +470,44 @@ describe('workflow execute async route', () => {
     expect(loggingSessionMockFns.mockSetTrustedExecutionCorrelation).not.toHaveBeenCalled()
     expect(mockPreprocessExecution).not.toHaveBeenCalled()
     expect(mockExecuteWorkflowCore).not.toHaveBeenCalled()
+    expect(mockReleaseWorkflowToolExecutionClaim).not.toHaveBeenCalled()
     expect(mockReleaseExecutionIdClaim).toHaveBeenCalled()
   })
 
+  it('releases a bound Copilot workflow claim when preprocessing rejects the run', async () => {
+    mockPreprocessExecution.mockResolvedValueOnce({
+      success: false,
+      error: { message: 'Not admitted', statusCode: 402 },
+    })
+
+    const response = await POST(createBoundCopilotExecutionRequest(), {
+      params: Promise.resolve({ id: 'workflow-1' }),
+    })
+
+    expect(response.status).toBe(402)
+    expect(mockReleaseWorkflowToolExecutionClaim).toHaveBeenCalledWith(
+      'copilot-tool-1',
+      'execution-123'
+    )
+    expect(mockReleaseExecutionIdClaim).toHaveBeenCalled()
+  })
+
+  it('retains a bound Copilot workflow claim when preprocessing created a durable error log', async () => {
+    mockPreprocessExecution.mockResolvedValueOnce({
+      success: false,
+      error: { message: 'Not admitted', statusCode: 402 },
+    })
+    mockHasDurableExecutionOwner.mockResolvedValueOnce(true)
+
+    const response = await POST(createBoundCopilotExecutionRequest(), {
+      params: Promise.resolve({ id: 'workflow-1' }),
+    })
+
+    expect(response.status).toBe(402)
+    expect(mockReleaseWorkflowToolExecutionClaim).not.toHaveBeenCalled()
+    expect(mockReleaseExecutionIdClaim).not.toHaveBeenCalled()
+  })
+
   it('binds a workflow execution after its page-hide confirmation detached the waiter', async () => {
     mockGetAsyncToolCall.mockResolvedValueOnce({
       toolCallId: 'copilot-tool-1',

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

@@ -24,6 +24,7 @@ import {
   claimWorkflowToolExecution,
   getAsyncToolCall,
   getRunSegment,
+  releaseWorkflowToolExecutionClaim,
 } from '@/lib/copilot/async-runs/repository'
 import { isWorkflowToolName, resolveWorkflowToolTargetId } from '@/lib/copilot/tools/workflow-tools'
 import { admissionRejectedResponse, tryAdmit } from '@/lib/core/admission/gate'
@@ -621,6 +622,8 @@ async function handleExecutePost(
   let executionId = ''
   let executionIdClaim: ExecutionIdClaim | null = null
   let executionIdClaimCommitted = false
+  let workflowToolClaimAcquired = false
+  let copilotToolCallId: string | undefined
 
   try {
     const auth = await checkHybridAuth(req, { requireWorkflowId: false })
@@ -758,13 +761,14 @@ async function handleExecutePost(
       workflowStateOverride,
       deploymentVersionId: admittedDeploymentVersionId,
       executionId: rawBodyExecutionId,
-      copilotToolCallId,
+      copilotToolCallId: parsedCopilotToolCallId,
       triggerBlockId: parsedTriggerBlockId,
       startBlockId,
       stopAfterBlockId,
       runFromBlock: rawRunFromBlock,
       parentWorkspaceId,
     } = validation.data
+    copilotToolCallId = parsedCopilotToolCallId
     const triggerBlockId = parsedTriggerBlockId ?? startBlockId
     const streamHeader = req.headers.get('X-Stream-Response') === 'true'
     const enableSSE = streamHeader || streamParam === true
@@ -1160,6 +1164,7 @@ async function handleExecutePost(
           { status: 409 }
         )
       }
+      workflowToolClaimAcquired = true
     }
 
     const loggingSession = new LoggingSession(
@@ -2387,6 +2392,18 @@ async function handleExecutePost(
       }
     }
 
+    if (copilotToolCallId && workflowToolClaimAcquired && !executionIdClaimCommitted) {
+      try {
+        await releaseWorkflowToolExecutionClaim(copilotToolCallId, executionId)
+      } catch (error) {
+        reqLogger.warn('Failed to release pre-start Copilot workflow tool claim', {
+          error: toError(error).message,
+          executionId,
+          copilotToolCallId,
+        })
+      }
+    }
+
     if (executionIdClaim && !executionIdClaimCommitted) {
       try {
         await releaseExecutionIdClaim(executionIdClaim)

apps/sim/lib/copilot/async-runs/repository.test.ts

@@ -12,6 +12,7 @@ import {
   detachAsyncToolCall,
   getClaimedWorkflowExecutionId,
   recordToolPermissionDecision,
+  releaseWorkflowToolExecutionClaim,
   replaceTerminalAsyncToolCallResult,
   upsertAsyncToolCall,
 } from './repository'
@@ -161,6 +162,29 @@ describe('async tool repository single-row semantics', () => {
     await expect(claimWorkflowToolExecution('workflow-tool', 'execution-2')).resolves.toBeNull()
   })
 
+  it('releases a matching pre-start workflow claim without changing its lifecycle status', async () => {
+    dbChainMockFns.returning.mockResolvedValueOnce([
+      {
+        toolCallId: 'workflow-tool',
+        status: 'delivered',
+        claimedBy: null,
+      },
+    ])
+
+    const result = await releaseWorkflowToolExecutionClaim('workflow-tool', 'execution-1')
+
+    expect(result).toMatchObject({
+      toolCallId: 'workflow-tool',
+      status: 'delivered',
+      claimedBy: null,
+    })
+    expect(dbChainMockFns.set).toHaveBeenCalledWith({
+      claimedBy: null,
+      claimedAt: null,
+      updatedAt: expect.any(Date),
+    })
+  })
+
   it('detaches a bound workflow waiter without releasing its execution claim', async () => {
     dbChainMockFns.returning.mockResolvedValueOnce([
       {

apps/sim/lib/copilot/async-runs/repository.ts

@@ -424,6 +424,40 @@ export async function claimWorkflowToolExecution(toolCallId: string, executionId
   )
 }
 
+export async function releaseWorkflowToolExecutionClaim(toolCallId: string, executionId: string) {
+  const claimedBy = `${WORKFLOW_EXECUTION_CLAIM_PREFIX}${executionId}`
+  return withDbSpan(
+    TraceSpan.CopilotAsyncRunsReleaseClaim,
+    'UPDATE',
+    'copilot_async_tool_calls',
+    {
+      [TraceAttr.ToolCallId]: toolCallId,
+      [TraceAttr.CopilotAsyncToolClaimedBy]: claimedBy,
+    },
+    async () => {
+      const [row] = await db
+        .update(copilotAsyncToolCalls)
+        .set({
+          claimedBy: null,
+          claimedAt: null,
+          updatedAt: new Date(),
+        })
+        .where(
+          and(
+            eq(copilotAsyncToolCalls.toolCallId, toolCallId),
+            eq(copilotAsyncToolCalls.claimedBy, claimedBy),
+            inArray(copilotAsyncToolCalls.status, [
+              ASYNC_TOOL_STATUS.running,
+              ASYNC_TOOL_STATUS.delivered,
+            ])
+          )
+        )
+        .returning()
+      return row ?? null
+    }
+  )
+}
+
 /**
  * Atomically claims a pending client tool exactly once. Native browser actions
  * use this before crossing the Electron boundary so a replayed renderer event