fix(copilot): trust compacted workflow completion

icecrasher321 · icecrasher321 · commit ea06a77388e3 · 2026-08-02T01:30:30.000-07:00
diff --git a/apps/sim/app/api/copilot/confirm/route.test.ts b/apps/sim/app/api/copilot/confirm/route.test.ts
@@ -910,13 +910,18 @@ describe('Copilot Confirm API Route', () => {
     })
   })
 
-  it('derives workflow outcome from the terminal server execution', async () => {
+  it('derives workflow outcome from a content-unavailable trusted terminal execution', async () => {
     getAsyncToolCall.mockResolvedValue({
       ...existingRow,
       toolName: 'run_workflow',
       args: { workflowId: 'workflow-1' },
     })
-    getTrustedWorkflowToolExecution.mockResolvedValueOnce({ status: 'failed' })
+    getTrustedWorkflowToolExecution.mockResolvedValueOnce({
+      executionId: 'execution-1',
+      workflowId: 'workflow-1',
+      status: 'failed',
+      contentAvailable: false,
+    })
 
     const response = await POST(
       createMockPostRequest({
diff --git a/apps/sim/lib/copilot/request/tools/client.test.ts b/apps/sim/lib/copilot/request/tools/client.test.ts
@@ -79,6 +79,7 @@ function trustedExecution(executionId: string) {
     executionId,
     workflowId: 'workflow-1',
     status: 'completed' as const,
+    contentAvailable: true as const,
     finalOutput: { value: `child read parent-secret-value from ${executionId}` },
     blockLogs: [],
     provenance: {
@@ -169,6 +170,39 @@ describe('workflow client tool completion', () => {
     expect(JSON.stringify(completion)).not.toContain('untrusted')
   })
 
+  it('uses compacted terminal status without exposing unavailable execution content', async () => {
+    const registry = createParentRegistry()
+    waitForToolConfirmation.mockResolvedValue({
+      status: 'success',
+      data: { workflowId: 'workflow-1', executionId: 'execution-1' },
+    })
+    getTrustedWorkflowToolExecution.mockResolvedValue({
+      executionId: 'execution-1',
+      workflowId: 'workflow-1',
+      status: 'failed',
+      contentAvailable: false,
+    })
+
+    const completion = await waitForWorkflowToolCompletion({
+      toolCallId: 'tool-1',
+      workflowId: 'workflow-1',
+      timeoutMs: 1_000,
+      registry,
+    })
+
+    expect(completion).toEqual({
+      status: 'error',
+      message: 'Workflow execution failed.',
+      data: {
+        success: false,
+        workflowId: 'workflow-1',
+        executionId: 'execution-1',
+      },
+    })
+    expect(registry.isComplete()).toBe(false)
+    expect(replaceTerminalAsyncToolCallResult).not.toHaveBeenCalled()
+  })
+
   it('preserves cancellation when the bound terminal execution is not yet readable', async () => {
     const registry = createParentRegistry()
     waitForToolConfirmation.mockResolvedValue({
@@ -271,6 +305,7 @@ describe('workflow client tool completion', () => {
       executionId: 'execution-1',
       workflowId: 'workflow-1',
       status: 'completed',
+      contentAvailable: true,
       finalOutput: { value: 'child-secret-value' },
       blockLogs: [],
       provenance: {
@@ -309,6 +344,7 @@ describe('workflow client tool completion', () => {
       executionId: 'execution-1',
       workflowId: 'workflow-1',
       status: 'failed',
+      contentAvailable: true,
       error: 'trusted failure',
       blockLogs: [],
       provenance: { version: 1, complete: true, entries: [], scope: TRACE_SCOPE },
diff --git a/apps/sim/lib/copilot/request/tools/client.ts b/apps/sim/lib/copilot/request/tools/client.ts
@@ -245,6 +245,15 @@ export async function waitForWorkflowToolCompletion({
       return structuralWorkflowCompletion(completion.status, workflowId, executionId)
     }
 
+    if (!trustedExecution.contentAvailable) {
+      registry?.markIncomplete()
+      return structuralWorkflowCompletion(
+        getWorkflowToolConfirmationStatus(trustedExecution.status),
+        workflowId,
+        executionId
+      )
+    }
+
     if (!registry || registry.isPermanentlyIncomplete() || !trustedExecution.provenance.complete) {
       if (!trustedExecution.provenance.complete) registry?.markIncomplete()
       return structuralWorkflowCompletion(
diff --git a/apps/sim/lib/logs/execution/logger.test.ts b/apps/sim/lib/logs/execution/logger.test.ts
@@ -380,6 +380,42 @@ describe('ExecutionLogger', () => {
       expect(compacted.traceSpans?.[0]?.children?.[0]).not.toHaveProperty('input')
     })
 
+    test('retains the trusted Copilot binding in metadata-only compaction', () => {
+      const loggerInstance = new ExecutionLogger() as unknown as {
+        compactExecutionDataForStorage(
+          executionData: WorkflowExecutionLog['executionData'],
+          executionId: string
+        ): WorkflowExecutionLog['executionData']
+      }
+      const correlation = {
+        executionId: 'execution-metadata-only',
+        requestId: 'request-1',
+        source: 'workflow' as const,
+        workflowId: 'workflow-1',
+        copilotToolCallId: 'tool-call-1',
+      }
+
+      const compacted = loggerInstance.compactExecutionDataForStorage(
+        {
+          environment: {
+            variables: { OVERSIZED: 'x'.repeat(3.5 * 1024 * 1024) },
+            workflowId: 'workflow-1',
+            executionId: 'execution-metadata-only',
+            userId: 'user-1',
+            workspaceId: 'workspace-1',
+          },
+          correlation,
+          hasTraceSpans: false,
+          traceSpanCount: 0,
+        },
+        'execution-metadata-only'
+      )
+
+      expect(compacted.executionDataTruncated).toBe(true)
+      expect(compacted.correlation).toEqual(correlation)
+      expect(compacted).not.toHaveProperty('environment')
+    })
+
     test('retains tool-call structure when aggregate trace content exceeds the compaction cap', () => {
       const loggerInstance = new ExecutionLogger() as unknown as {
         compactExecutionDataForStorage(
diff --git a/apps/sim/lib/logs/execution/logger.ts b/apps/sim/lib/logs/execution/logger.ts
@@ -491,6 +491,7 @@ export class ExecutionLogger implements IExecutionLoggerService {
         ...(executionData.billingAttribution
           ? { billingAttribution: executionData.billingAttribution }
           : {}),
+        ...(executionData.correlation ? { correlation: executionData.correlation } : {}),
         hasTraceSpans: executionData.hasTraceSpans,
         traceSpanCount: executionData.traceSpanCount,
         tokens: executionData.tokens,
diff --git a/apps/sim/lib/logs/execution/trace-store.test.ts b/apps/sim/lib/logs/execution/trace-store.test.ts
@@ -3,15 +3,27 @@
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
-const { decryptSecretMock } = vi.hoisted(() => ({
+const { decryptSecretMock, materializeLargeValueRefMock, storeLargeValueMock } = vi.hoisted(() => ({
   decryptSecretMock: vi.fn(),
+  materializeLargeValueRefMock: vi.fn(),
+  storeLargeValueMock: vi.fn(),
 }))
 
 vi.mock('@/lib/core/security/encryption', () => ({
   decryptSecret: decryptSecretMock,
 }))
 
-import { projectExecutionDataForDisplay } from '@/lib/logs/execution/trace-store'
+vi.mock('@/lib/execution/payloads/store', () => ({
+  materializeLargeValueRef: materializeLargeValueRefMock,
+  storeLargeValue: storeLargeValueMock,
+}))
+
+import {
+  externalizeExecutionData,
+  materializeExecutionData,
+  projectExecutionDataForDisplay,
+  TRACE_STORE_REF_KEY,
+} from '@/lib/logs/execution/trace-store'
 
 const CONTEXT = {
   workspaceId: 'workspace-1',
@@ -25,6 +37,55 @@ beforeEach(() => {
   decryptSecretMock.mockResolvedValue({ decrypted: '1234' })
 })
 
+describe('execution data storage', () => {
+  it('keeps the trusted Copilot binding when an externalized payload is unavailable', async () => {
+    const correlation = { copilotToolCallId: 'tool-call-1' }
+    const ref = {
+      __simLargeValueRef: true,
+      version: 1,
+      id: 'lv_bbbbbbbbbbbb',
+      kind: 'object',
+      size: 128,
+      key: 'execution/workspace-1/workflow-1/execution-1/large-value-lv_bbbbbbbbbbbb.json',
+      executionId: 'execution-1',
+      preview: { unsafe: 'must-not-remain-inline' },
+    } as const
+    storeLargeValueMock.mockResolvedValue(ref)
+    materializeLargeValueRefMock.mockRejectedValue(new Error('object unavailable'))
+
+    const slim = await externalizeExecutionData(
+      {
+        correlation,
+        hasTraceSpans: true,
+        traceSpanCount: 2,
+        finalOutput: { unsafe: 'must-not-remain-inline' },
+      },
+      CONTEXT
+    )
+
+    expect(slim).toEqual({
+      [TRACE_STORE_REF_KEY]: {
+        __simLargeValueRef: true,
+        version: 1,
+        id: 'lv_bbbbbbbbbbbb',
+        kind: 'object',
+        size: 128,
+        key: 'execution/workspace-1/workflow-1/execution-1/large-value-lv_bbbbbbbbbbbb.json',
+        executionId: 'execution-1',
+      },
+      correlation,
+      hasTraceSpans: true,
+      traceSpanCount: 2,
+    })
+
+    await expect(materializeExecutionData(slim, CONTEXT)).resolves.toEqual({
+      correlation,
+      hasTraceSpans: true,
+      traceSpanCount: 2,
+    })
+  })
+})
+
 describe('projectExecutionDataForDisplay', () => {
   it('projects persisted output, input, errors, and spans from trusted provenance', async () => {
     const executionData = {
diff --git a/apps/sim/lib/logs/execution/trace-store.ts b/apps/sim/lib/logs/execution/trace-store.ts
@@ -20,14 +20,13 @@ export const TRACE_STORE_REF_KEY = 'traceStoreRef'
 
 /**
  * The only metadata kept inline on the slim row (everything else lives in the
- * externalized object). These two describe trace presence/count and uniquely
- * survive object expiry — so a reader can still report "trace data expired (N
- * spans)" after retention without an object fetch. All other fields
+ * externalized object). Trace presence/count survives object expiry for log
+ * diagnostics, while correlation preserves the server-issued binding used to
+ * authenticate terminal Copilot workflow-tool executions. All other fields
  * (environment, trigger, tokens, models, truncation flags, and of course the
- * heavy payloads) are in the stored object and recovered on materialize, so
- * keeping them inline too would just be duplication.
+ * heavy payloads) are recovered from the stored object.
  */
-const INLINE_MARKER_KEYS = ['hasTraceSpans', 'traceSpanCount'] as const
+const INLINE_MARKER_KEYS = ['hasTraceSpans', 'traceSpanCount', 'correlation'] as const
 
 /**
  * Read-path context. Resolves an externalized payload by storage key, authorized
diff --git a/apps/sim/lib/workflows/executor/execution-state.test.ts b/apps/sim/lib/workflows/executor/execution-state.test.ts
@@ -104,6 +104,7 @@ describe('execution state lookup', () => {
       executionId: 'execution-1',
       workflowId: 'workflow-1',
       status: 'completed',
+      contentAvailable: true,
       finalOutput: { token: 'raw-secret' },
       blockLogs: [],
       provenance,
@@ -157,7 +158,7 @@ describe('execution state lookup', () => {
     })
   })
 
-  it('rejects mismatched bindings, malformed provenance, and nonterminal rows', async () => {
+  it('trusts compacted terminal status while withholding unavailable execution content', async () => {
     queueTableRows(schemaMock.workflowExecutionLogs, [
       {
         executionId: 'execution-1',
@@ -168,20 +169,31 @@ describe('execution state lookup', () => {
       },
     ])
     mockMaterializeExecutionData.mockResolvedValueOnce({
-      correlation: { copilotToolCallId: 'another-tool-call' },
-      executionState: {
-        ...EXECUTION_STATE,
-        resolvedSecretTraceProvenance: { version: 1, complete: true, entries: [] },
+      correlation: { copilotToolCallId: 'tool-call-1' },
+      executionStateSummary: {
+        executedBlockCount: 1,
+        blockLogCount: 1,
+        completedLoopCount: 0,
+        activeExecutionPathLength: 0,
+        pendingQueueLength: 0,
       },
+      finalOutput: { token: 'must-not-cross' },
     })
 
     await expect(
       getTrustedWorkflowToolExecution('execution-1', 'workflow-1', 'tool-call-1')
-    ).resolves.toBeNull()
+    ).resolves.toEqual({
+      executionId: 'execution-1',
+      workflowId: 'workflow-1',
+      status: 'completed',
+      contentAvailable: false,
+    })
+  })
 
+  it('withholds execution content when persisted provenance is malformed', async () => {
     queueTableRows(schemaMock.workflowExecutionLogs, [
       {
-        executionId: 'execution-2',
+        executionId: 'execution-1',
         workflowId: 'workflow-1',
         workspaceId: 'workspace-1',
         status: 'completed',
@@ -190,19 +202,48 @@ describe('execution state lookup', () => {
     ])
     mockMaterializeExecutionData.mockResolvedValueOnce({
       correlation: { copilotToolCallId: 'tool-call-1' },
+      finalOutput: { token: 'must-not-cross' },
       executionState: {
         ...EXECUTION_STATE,
         resolvedSecretTraceProvenance: { version: 2, complete: true, entries: [] },
       },
     })
 
     await expect(
-      getTrustedWorkflowToolExecution('execution-2', 'workflow-1', 'tool-call-1')
+      getTrustedWorkflowToolExecution('execution-1', 'workflow-1', 'tool-call-1')
+    ).resolves.toEqual({
+      executionId: 'execution-1',
+      workflowId: 'workflow-1',
+      status: 'completed',
+      contentAvailable: false,
+    })
+  })
+
+  it('rejects mismatched bindings and nonterminal rows', async () => {
+    queueTableRows(schemaMock.workflowExecutionLogs, [
+      {
+        executionId: 'execution-1',
+        workflowId: 'workflow-1',
+        workspaceId: 'workspace-1',
+        status: 'completed',
+        executionData: {},
+      },
+    ])
+    mockMaterializeExecutionData.mockResolvedValueOnce({
+      correlation: { copilotToolCallId: 'another-tool-call' },
+      executionState: {
+        ...EXECUTION_STATE,
+        resolvedSecretTraceProvenance: { version: 1, complete: true, entries: [] },
+      },
+    })
+
+    await expect(
+      getTrustedWorkflowToolExecution('execution-1', 'workflow-1', 'tool-call-1')
     ).resolves.toBeNull()
 
     queueTableRows(schemaMock.workflowExecutionLogs, [
       {
-        executionId: 'execution-3',
+        executionId: 'execution-2',
         workflowId: 'workflow-1',
         workspaceId: 'workspace-1',
         status: 'running',
@@ -211,7 +252,7 @@ describe('execution state lookup', () => {
     ])
 
     await expect(
-      getTrustedWorkflowToolExecution('execution-3', 'workflow-1', 'tool-call-1')
+      getTrustedWorkflowToolExecution('execution-2', 'workflow-1', 'tool-call-1')
     ).resolves.toBeNull()
   })
 
diff --git a/apps/sim/lib/workflows/executor/execution-state.ts b/apps/sim/lib/workflows/executor/execution-state.ts
