fix

Author: icecrasher321

apps/sim/lib/copilot/chat/post.test.ts

@@ -13,7 +13,6 @@ import { NextRequest } from 'next/server'
 import { beforeEach, describe, expect, it, vi } from 'vitest'
 
 const resolveWorkflowIdForUser = workflowsUtilsMockFns.mockResolveWorkflowIdForUser
-const getWorkflowById = workflowsUtilsMockFns.mockGetWorkflowById
 const getUserEntityPermissions = permissionsMockFns.mockGetUserEntityPermissions
 
 const {
@@ -138,9 +137,9 @@ describe('handleUnifiedChatPost', () => {
     resolveWorkflowIdForUser.mockResolvedValue({
       status: 'resolved',
       workflowId: 'wf-1',
+      workspaceId: 'ws-1',
       workflowName: 'Workflow One',
     })
-    getWorkflowById.mockResolvedValue({ workspaceId: 'ws-1' })
     getUserEntityPermissions.mockResolvedValue('write')
     getEffectiveDecryptedEnv.mockResolvedValue({ API_KEY: 'secret' })
     generateWorkspaceContext.mockResolvedValue('workspace context')

apps/sim/lib/copilot/chat/post.ts

@@ -44,7 +44,7 @@ import { persistChatResources } from '@/lib/copilot/resources/persistence'
 import { taskPubSub } from '@/lib/copilot/tasks'
 import { prepareExecutionContext } from '@/lib/copilot/tools/handlers/context'
 import { getEffectiveDecryptedEnv } from '@/lib/environment/utils'
-import { getWorkflowById, resolveWorkflowIdForUser } from '@/lib/workflows/utils'
+import { resolveWorkflowIdForUser } from '@/lib/workflows/utils'
 import {
   getUserEntityPermissions,
   isWorkspaceAccessDeniedError,
@@ -563,13 +563,7 @@ async function resolveBranch(params: {
     }
 
     const resolvedWorkflowId = resolved.workflowId
-    let resolvedWorkspaceId: string | undefined
-    try {
-      const workflow = await getWorkflowById(resolvedWorkflowId)
-      resolvedWorkspaceId = workflow?.workspaceId ?? requestedWorkspaceId
-    } catch {
-      resolvedWorkspaceId = requestedWorkspaceId
-    }
+    const resolvedWorkspaceId = resolved.workspaceId
 
     const selectedModel = model || DEFAULT_MODEL
     return {
@@ -1015,7 +1009,7 @@ export async function handleUnifiedChatPost(req: NextRequest) {
         orchestrateOptions: {
           userId: authenticatedUserId,
           ...(branch.kind === 'workflow' ? { workflowId: branch.workflowId } : {}),
-          ...(branch.kind === 'workspace' ? { workspaceId: branch.workspaceId } : {}),
+          ...(workspaceId ? { workspaceId } : {}),
           chatId: actualChatId,
           executionId,
           runId,

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

@@ -343,6 +343,92 @@ describe('runCopilotLifecycle', () => {
     )
   })
 
+  it('normalizes the initial request body with workspaceId from lifecycle options', async () => {
+    let requestBody: Record<string, unknown> | undefined
+    mockGetEffectiveDecryptedEnv.mockResolvedValueOnce({})
+    mockRunStreamLoop.mockImplementationOnce(
+      async (_fetchUrl: string, fetchOptions: RequestInit): Promise<void> => {
+        requestBody = JSON.parse(String(fetchOptions.body))
+      }
+    )
+
+    await runCopilotLifecycle(
+      { message: 'hello', messageId: 'stream-1' },
+      {
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+        chatId: 'chat-1',
+      }
+    )
+
+    expect(requestBody).toEqual(
+      expect.objectContaining({
+        workspaceId: 'ws-1',
+      })
+    )
+  })
+
+  it('uses the lifecycle workspaceId for async tool resume requests', async () => {
+    const requestBodies: Record<string, unknown>[] = []
+    const fetchUrls: string[] = []
+    const executionContext: ExecutionContext = {
+      userId: 'user-1',
+      workflowId: 'workflow-1',
+      workspaceId: 'ws-1',
+      chatId: 'chat-1',
+      decryptedEnvVars: {},
+    }
+
+    mockRunStreamLoop.mockImplementationOnce(
+      async (
+        fetchUrl: string,
+        fetchOptions: RequestInit,
+        context: StreamingContext
+      ): Promise<void> => {
+        fetchUrls.push(fetchUrl)
+        requestBodies.push(JSON.parse(String(fetchOptions.body)))
+        context.toolCalls.set('tool-1', {
+          id: 'tool-1',
+          name: 'read',
+          status: MothershipStreamV1ToolOutcome.success,
+          result: { success: true, output: { content: 'file contents' } },
+        })
+        context.awaitingAsyncContinuation = {
+          checkpointId: 'ckpt-1',
+          pendingToolCallIds: ['tool-1'],
+        }
+      }
+    )
+    mockRunStreamLoop.mockImplementationOnce(
+      async (fetchUrl: string, fetchOptions: RequestInit): Promise<void> => {
+        fetchUrls.push(fetchUrl)
+        requestBodies.push(JSON.parse(String(fetchOptions.body)))
+      }
+    )
+
+    await runCopilotLifecycle(
+      { message: 'hello', messageId: 'stream-1' },
+      {
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+        workflowId: 'workflow-1',
+        chatId: 'chat-1',
+        executionId: 'exec-1',
+        runId: 'run-1',
+        executionContext,
+      }
+    )
+
+    expect(fetchUrls[1]).toBe('http://mothership.test/api/tools/resume')
+    expect(requestBodies[1]).toEqual(
+      expect.objectContaining({
+        checkpointId: 'ckpt-1',
+        userId: 'user-1',
+        workspaceId: 'ws-1',
+      })
+    )
+  })
+
   it('finalizes as success when a resume fails with a retryable error then the retry succeeds', async () => {
     const executionContext: ExecutionContext = {
       userId: 'user-1',

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

@@ -44,6 +44,12 @@ const logger = createLogger('CopilotLifecycle')
 const MAX_RESUME_ATTEMPTS = 3
 const RESUME_BACKOFF_MS = [250, 500, 1000] as const
 
+function nonBlankString(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : undefined
+}
+
 function resultContent(context: StreamingContext, options: CopilotLifecycleOptions): string {
   if (options.interactive === false && context.sawMainToolCall) {
     return context.finalAssistantContent
@@ -220,11 +226,21 @@ async function runCheckpointLoop(
   let resumeAttempt = 0
   const callerOnEvent = options.onEvent
   const mothershipBaseURL = await getMothershipBaseURL({ userId: options.userId })
+  const lifecycleWorkspaceId = nonBlankString(options.workspaceId)
+
+  // Go's auth middleware re-validates every Sim -> Go request by reading
+  // workspaceId from the JSON body and forwarding it to Sim's validate route,
+  // where it is required for the per-member usage gate. Normalize the initial
+  // leg from the lifecycle option so callers that only set the option (not the
+  // raw payload) still send it on the first request.
+  if (lifecycleWorkspaceId && !nonBlankString(payload.workspaceId)) {
+    payload = { ...payload, workspaceId: lifecycleWorkspaceId }
+  }
 
   // Enterprise BYOK eligibility hint: set once on the initial mothership request
   // so Go only attempts a BYOK lookup for entitled workspaces. This is only a
   // gate — Go re-confirms entitlement authoritatively before using any key.
-  payload = await withByokEligibilityHint(payload, route, options.workspaceId)
+  payload = await withByokEligibilityHint(payload, route, lifecycleWorkspaceId)
 
   for (;;) {
     context.streamComplete = false
@@ -458,7 +474,7 @@ async function runCheckpointLoop(
       streamId: context.messageId,
       checkpointId: continuation.checkpointId,
       userId: options.userId,
-      ...(options.workspaceId ? { workspaceId: options.workspaceId } : {}),
+      ...(lifecycleWorkspaceId ? { workspaceId: lifecycleWorkspaceId } : {}),
       results,
     }
 

apps/sim/lib/workflows/utils.ts

@@ -108,6 +108,7 @@ export type WorkflowResolutionResult =
   | {
       status: 'resolved'
       workflowId: string
+      workspaceId: string
       workflowName?: string
     }
   | {
@@ -143,7 +144,18 @@ export async function resolveWorkflowIdForUser(
       }
     }
     const wf = await getWorkflowById(workflowId)
-    return { status: 'resolved', workflowId, workflowName: wf?.name || undefined }
+    if (!wf?.workspaceId) {
+      return {
+        status: 'not_found',
+        message: 'No workflows found. Create a workflow first or provide a valid workflowId.',
+      }
+    }
+    return {
+      status: 'resolved',
+      workflowId,
+      workspaceId: wf.workspaceId,
+      workflowName: wf.name || undefined,
+    }
   }
 
   const workspaceIds = await db
@@ -189,6 +201,7 @@ export async function resolveWorkflowIdForUser(
       return {
         status: 'resolved',
         workflowId: match.id,
+        workspaceId: match.workspaceId,
         workflowName: match.name || undefined,
       }
     }
@@ -213,6 +226,7 @@ export async function resolveWorkflowIdForUser(
     return {
       status: 'resolved',
       workflowId: workflows[0].id,
+      workspaceId: workflows[0].workspaceId,
       workflowName: workflows[0].name || undefined,
     }
   }