Bug fix random

Author: Sg312

apps/sim/lib/copilot/request/lifecycle/run.test.ts

@@ -0,0 +1,168 @@
+/**
+ * @vitest-environment node
+ */
+
+import { loggerMock } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+vi.mock('@sim/logger', () => loggerMock)
+
+const { runStreamLoop, BillingLimitError, CopilotBackendError } = vi.hoisted(() => {
+  class MockBillingLimitError extends Error {
+    constructor(public readonly userId: string) {
+      super('Usage limit reached')
+      this.name = 'BillingLimitError'
+    }
+  }
+
+  class MockCopilotBackendError extends Error {
+    status?: number
+    body?: string
+
+    constructor(message: string, options?: { status?: number; body?: string }) {
+      super(message)
+      this.name = 'CopilotBackendError'
+      this.status = options?.status
+      this.body = options?.body
+    }
+  }
+
+  return {
+    runStreamLoop: vi.fn(),
+    BillingLimitError: MockBillingLimitError,
+    CopilotBackendError: MockCopilotBackendError,
+  }
+})
+
+const { createRunSegment, updateRunStatus } = vi.hoisted(() => ({
+  createRunSegment: vi.fn(),
+  updateRunStatus: vi.fn(),
+}))
+
+const { prepareExecutionContext, getEffectiveDecryptedEnv, handleBillingLimitResponse } = vi.hoisted(
+  () => ({
+    prepareExecutionContext: vi.fn(),
+    getEffectiveDecryptedEnv: vi.fn(),
+    handleBillingLimitResponse: vi.fn(),
+  })
+)
+
+const { executeToolAndReport } = vi.hoisted(() => ({
+  executeToolAndReport: vi.fn(),
+}))
+
+vi.mock('@/lib/copilot/request/go/stream', () => ({
+  runStreamLoop,
+  BillingLimitError,
+  CopilotBackendError,
+}))
+
+vi.mock('@/lib/copilot/async-runs/repository', () => ({
+  createRunSegment,
+  updateRunStatus,
+}))
+
+vi.mock('@/lib/copilot/tools/handlers/context', () => ({
+  prepareExecutionContext,
+}))
+
+vi.mock('@/lib/environment/utils', () => ({
+  getEffectiveDecryptedEnv,
+}))
+
+vi.mock('@/lib/copilot/request/tools/billing', () => ({
+  handleBillingLimitResponse,
+}))
+
+vi.mock('@/lib/copilot/request/tools/executor', () => ({
+  executeToolAndReport,
+}))
+
+import { MothershipStreamV1ToolOutcome } from '@/lib/copilot/generated/mothership-stream-v1'
+import type { ExecutionContext } from '@/lib/copilot/request/types'
+import { runCopilotLifecycle } from './run'
+
+describe('runCopilotLifecycle', () => {
+  beforeEach(() => {
+    vi.resetAllMocks()
+    createRunSegment.mockResolvedValue(null)
+    updateRunStatus.mockResolvedValue(null)
+  })
+
+  it('recovers missing checkpointed tool state from settled error completions', async () => {
+    const execContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+      abortSignal: undefined,
+    }
+
+    runStreamLoop.mockImplementationOnce(async (_url, _init, context) => {
+      context.toolCalls.set('tool-1', {
+        id: 'tool-1',
+        name: 'read',
+        status: 'executing',
+        startTime: Date.now(),
+      })
+      context.pendingToolPromises.set(
+        'tool-1',
+        Promise.resolve({
+          status: MothershipStreamV1ToolOutcome.error,
+          message: 'boom',
+          data: { error: 'boom' },
+        })
+      )
+      context.awaitingAsyncContinuation = {
+        checkpointId: 'cp-1',
+        executionId: 'exec-1',
+        runId: 'run-1',
+        pendingToolCallIds: ['tool-1'],
+      }
+      context.streamComplete = true
+    })
+
+    runStreamLoop.mockImplementationOnce(async (url, init, context) => {
+      expect(url).toContain('/api/tools/resume')
+      const body = JSON.parse(String(init.body))
+      expect(body).toEqual(
+        expect.objectContaining({
+          checkpointId: 'cp-1',
+          results: [
+            {
+              callId: 'tool-1',
+              name: 'read',
+              data: { error: 'boom' },
+              success: false,
+            },
+          ],
+        })
+      )
+      context.streamComplete = true
+    })
+
+    const result = await runCopilotLifecycle(
+      {
+        message: 'hello',
+        messageId: 'msg-1',
+      },
+      {
+        userId: 'user-1',
+        executionId: 'exec-1',
+        runId: 'run-1',
+        goRoute: '/api/copilot',
+        executionContext: execContext,
+      }
+    )
+
+    expect(runStreamLoop).toHaveBeenCalledTimes(2)
+    expect(result.toolCalls).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'tool-1',
+          status: MothershipStreamV1ToolOutcome.error,
+          error: 'boom',
+          result: { error: 'boom' },
+        }),
+      ])
+    )
+  })
+})