fix(executor): preserve actors for actorless tool calls

Author: TheodoreSpeaks

apps/sim/executor/handlers/credential-group/credential-group-handler.test.ts

@@ -8,8 +8,7 @@ import type { ExecutionContext } from '@/executor/types'
 import type { SerializedBlock } from '@/serializer/types'
 
 const mocks = vi.hoisted(() => ({
-  authenticate: vi.fn(),
-  buildHeaders: vi.fn(),
+  createPrincipal: vi.fn(),
   createInviteLink: vi.fn(),
   enforceInviteRateLimit: vi.fn(),
   listCredentials: vi.fn(),
@@ -22,10 +21,6 @@ vi.mock('@/lib/credential-groups/application/create-invite-link', () => ({
   createCredentialGroupInviteLink: { execute: mocks.createInviteLink },
 }))
 
-vi.mock('@/lib/credential-groups/application/delegation', () => ({
-  authenticateCredentialGroupDelegation: mocks.authenticate,
-}))
-
 vi.mock('@/lib/credential-groups/application/list-credentials', () => ({
   listCredentialGroupCredentials: { execute: mocks.listCredentials },
 }))
@@ -53,8 +48,8 @@ vi.mock('@/lib/credential-groups/rate-limit', () => ({
   enforceCredentialGroupInvitationExecutionRateLimit: mocks.enforceInviteRateLimit,
 }))
 
-vi.mock('@/executor/utils/http', () => ({
-  buildExecutorDelegationHeaders: mocks.buildHeaders,
+vi.mock('@/lib/internal/principals/executor', () => ({
+  createExecutorPrincipalFromExecutionContext: mocks.createPrincipal,
 }))
 
 import { CredentialGroupBlockHandler } from '@/executor/handlers/credential-group/credential-group-handler'
@@ -92,8 +87,7 @@ const block = { metadata: { id: BlockType.CREDENTIAL_GROUP } } as SerializedBloc
 describe('CredentialGroupBlockHandler', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    mocks.buildHeaders.mockResolvedValue({ Authorization: 'Bearer executor-token' })
-    mocks.authenticate.mockResolvedValue(principal)
+    mocks.createPrincipal.mockResolvedValue(principal)
   })
 
   it('recognizes only Credential Group blocks', () => {
@@ -122,7 +116,11 @@ describe('CredentialGroupBlockHandler', () => {
       cursor: ' credential-1 ',
     })
 
-    expect(mocks.authenticate).toHaveBeenCalledWith('Bearer executor-token', 'group-1')
+    expect(mocks.createPrincipal).toHaveBeenCalledWith({
+      context,
+      audience: 'sim:credential-groups',
+      resourceScope: { credentialGroupId: 'group-1' },
+    })
     expect(mocks.listCredentials).toHaveBeenCalledWith({
       principal,
       input: {
@@ -136,6 +134,73 @@ describe('CredentialGroupBlockHandler', () => {
     expect(result).toEqual({ credentials: [], count: 0, hasMore: false, nextCursor: null })
   })
 
+  it('lists credentials for an actorless workflow execution', async () => {
+    const executionPrincipal = {
+      kind: 'system' as const,
+      serviceId: 'schedule' as const,
+      workspaceId: 'workspace-1',
+      workflowId: 'workflow-1',
+    }
+    const actorlessPrincipal: WorkflowExecutionDelegatedPrincipal = {
+      kind: 'delegated',
+      serviceId: 'executor',
+      workspaceId: 'workspace-1',
+      delegationId: 'delegation-actorless',
+      audience: 'sim:credential-groups',
+      issuedAt: new Date(Date.now() - 1_000),
+      expiresAt: new Date(Date.now() + 60_000),
+      resourceScope: { credentialGroupId: 'group-1' },
+      delegationContext: {
+        kind: 'workflow_execution',
+        workflowId: 'workflow-1',
+        principal: executionPrincipal,
+        currentWorkflow: {
+          workflowId: 'workflow-1',
+          mode: 'deployment',
+          deploymentVersionId: 'deployment-version-1',
+        },
+      },
+    }
+    const actorlessContext = {
+      ...context,
+      userId: undefined,
+      principal: executionPrincipal,
+      executorDelegationOrigin: {
+        workflowId: 'workflow-1',
+        principal: executionPrincipal,
+        currentWorkflow: actorlessPrincipal.delegationContext.currentWorkflow,
+      },
+    } as ExecutionContext
+    mocks.createPrincipal.mockResolvedValueOnce(actorlessPrincipal)
+    mocks.listCredentials.mockResolvedValue({
+      credentials: [],
+      count: 0,
+      hasMore: false,
+      nextCursor: null,
+    })
+
+    await new CredentialGroupBlockHandler().execute(actorlessContext, block, {
+      operation: 'list_credentials',
+      credentialGroupId: 'group-1',
+    })
+
+    expect(mocks.createPrincipal).toHaveBeenCalledWith({
+      context: actorlessContext,
+      audience: 'sim:credential-groups',
+      resourceScope: { credentialGroupId: 'group-1' },
+    })
+    expect(mocks.listCredentials).toHaveBeenCalledWith({
+      principal: actorlessPrincipal,
+      input: {
+        credentialGroupId: 'group-1',
+        limit: 100,
+        cursor: undefined,
+        email: undefined,
+        credentialProviderIds: undefined,
+      },
+    })
+  })
+
   it('lists groups under workspace-scoped delegation', async () => {
     mocks.listGroups.mockResolvedValue({
       credentialGroups: [],
@@ -149,7 +214,10 @@ describe('CredentialGroupBlockHandler', () => {
       limit: 10,
     })
 
-    expect(mocks.authenticate).toHaveBeenCalledWith('Bearer executor-token', undefined)
+    expect(mocks.createPrincipal).toHaveBeenCalledWith({
+      context,
+      audience: 'sim:credential-groups',
+    })
     expect(mocks.listGroups).toHaveBeenCalledWith({
       principal,
       input: { workspaceId: 'workspace-1', limit: 10, cursor: undefined },
@@ -201,7 +269,11 @@ describe('CredentialGroupBlockHandler', () => {
       email: ' person@example.com ',
     })
 
-    expect(mocks.authenticate).toHaveBeenCalledWith('Bearer executor-token', 'group-1')
+    expect(mocks.createPrincipal).toHaveBeenCalledWith({
+      context,
+      audience: 'sim:credential-groups',
+      resourceScope: { credentialGroupId: 'group-1' },
+    })
     expect(mocks.enforceInviteRateLimit).toHaveBeenCalledWith('workspace-1')
     expect(mocks.enforceInviteRateLimit.mock.invocationCallOrder[0]).toBeLessThan(
       mocks.createInviteLink.mock.invocationCallOrder[0]!
@@ -236,7 +308,6 @@ describe('CredentialGroupBlockHandler', () => {
     await expect(
       new CredentialGroupBlockHandler().execute(context, block, { operation: 'unknown' })
     ).rejects.toThrow('Unsupported Credential Group operation: unknown')
-    expect(mocks.buildHeaders).not.toHaveBeenCalled()
-    expect(mocks.authenticate).not.toHaveBeenCalled()
+    expect(mocks.createPrincipal).not.toHaveBeenCalled()
   })
 })

apps/sim/executor/handlers/credential-group/credential-group-handler.ts

@@ -1,6 +1,6 @@
 import { createLogger } from '@sim/logger'
+import { CREDENTIAL_GROUP_DELEGATION_AUDIENCE } from '@/lib/credential-groups/application/authorization'
 import { createCredentialGroupInviteLink } from '@/lib/credential-groups/application/create-invite-link'
-import { authenticateCredentialGroupDelegation } from '@/lib/credential-groups/application/delegation'
 import { listCredentialGroupCredentials } from '@/lib/credential-groups/application/list-credentials'
 import { listCredentialGroupsForWorkflow } from '@/lib/credential-groups/application/list-groups'
 import {
@@ -11,10 +11,10 @@ import { sendCredentialGroupInvite } from '@/lib/credential-groups/application/s
 import { MAX_CREDENTIAL_GROUP_CREDENTIAL_PAGE_SIZE } from '@/lib/credential-groups/credentials'
 import type { CredentialGroupEnrollmentStatus } from '@/lib/credential-groups/enrollments'
 import { enforceCredentialGroupInvitationExecutionRateLimit } from '@/lib/credential-groups/rate-limit'
+import { createExecutorPrincipalFromExecutionContext } from '@/lib/internal/principals/executor'
 import type { BlockOutput } from '@/blocks/types'
 import { BlockType } from '@/executor/constants'
-import type { BlockHandler, ExecutionContext, ExecutorDelegationOrigin } from '@/executor/types'
-import { buildExecutorDelegationHeaders } from '@/executor/utils/http'
+import type { BlockHandler, ExecutionContext } from '@/executor/types'
 import type { SerializedBlock } from '@/serializer/types'
 
 const logger = createLogger('CredentialGroupBlockHandler')
@@ -84,13 +84,6 @@ function requireString(value: unknown, label: string): string {
   return parsed
 }
 
-function delegationOrigin(ctx: ExecutionContext): ExecutorDelegationOrigin {
-  if (!ctx.executorDelegationOrigin) {
-    throw new Error('Credential Group operations require an authenticated workflow execution')
-  }
-  return ctx.executorDelegationOrigin
-}
-
 export class CredentialGroupBlockHandler implements BlockHandler {
   canHandle(block: SerializedBlock): boolean {
     return block.metadata?.id === BlockType.CREDENTIAL_GROUP
@@ -103,14 +96,18 @@ export class CredentialGroupBlockHandler implements BlockHandler {
   ): Promise<BlockOutput> {
     if (!ctx.workspaceId) throw new Error('workspaceId is required for Credential Group operations')
     const operation = parseOperation(inputs.operation)
+    if (!ctx.executorDelegationOrigin) {
+      throw new Error('Credential Group operations require an authenticated workflow execution')
+    }
     const credentialGroupId =
       operation === 'list_groups'
         ? undefined
         : requireString(inputs.credentialGroupId, 'Credential Group')
-    const headers = await buildExecutorDelegationHeaders(delegationOrigin(ctx))
-    const authorization = headers.Authorization
-    if (!authorization) throw new Error('Executor delegation authorization is missing')
-    const principal = await authenticateCredentialGroupDelegation(authorization, credentialGroupId)
+    const principal = await createExecutorPrincipalFromExecutionContext({
+      context: ctx,
+      audience: CREDENTIAL_GROUP_DELEGATION_AUDIENCE,
+      ...(credentialGroupId ? { resourceScope: { credentialGroupId } } : {}),
+    })
 
     switch (operation) {
       case 'list_credentials': {

apps/sim/lib/copilot/tools/handlers/deployment/manage.ts

@@ -395,6 +395,7 @@ export async function executeLoadDeployment(
       workflowId,
       assertedWorkspaceId: context.workspaceId,
       version: target.version,
+      executionActorUserId: context.userId,
     })
 
     const label = target.version === 'active' ? 'the live deployment' : `version ${target.version}`

apps/sim/lib/copilot/tools/handlers/oauth.test.ts

@@ -53,6 +53,7 @@ describe('executeOAuthGetAuthLink', () => {
       workspaceId: 'workspace-1',
       providerName: 'gmail',
       credentialId: undefined,
+      executionActorUserId: 'user-1',
     })
     const url = new URL((result.output as { oauth_url: string }).oauth_url)
     expect(url.pathname).toBe('/api/auth/oauth2/authorize')

apps/sim/lib/copilot/tools/handlers/oauth.ts

@@ -39,6 +39,7 @@ export async function executeOAuthGetAuthLink(
       workspaceId,
       providerName,
       credentialId,
+      executionActorUserId: context.userId,
     })
     const callbackURL = context.workflowId
       ? `${baseUrl}/workspace/${workspaceId}/w/${context.workflowId}`

apps/sim/lib/core/orchestration/types.ts

@@ -110,10 +110,11 @@ export function asOrchestrationError(error: unknown): OrchestrationError | null
 }
 
 /**
- * The slice of an HTTP request the audit log reads for client IP and user-agent
- * capture. Optional on every orchestration function so the non-HTTP callers —
- * copilot tools, background jobs — can omit what they do not have.
+ * Transport metadata available to an application operation. HTTP callers carry
+ * headers for audit capture; executor adapters may also preserve the legacy
+ * execution actor used by pre-application-boundary internal routes.
  */
 export interface OrchestrationRequestContext {
   headers: { get(name: string): string | null }
+  executionActorUserId?: string
 }

apps/sim/lib/credential-groups/application/delegation.ts

@@ -1,5 +1,6 @@
-import type { Principal } from '@sim/auth/principal'
+import { type Principal, resolvePrincipalSubjectUserId } from '@sim/auth/principal'
 import type { WorkspaceDelegationPolicy } from '@/lib/core/application'
+import { OrchestrationError } from '@/lib/core/orchestration/types'
 import type { ManagedOAuthCredentialApplicationContext } from '@/lib/credentials/managed-oauth'
 
 export const CREDENTIAL_DELEGATION_AUDIENCE = 'sim:credentials'
@@ -21,3 +22,24 @@ export const managedOAuthCredentialDelegationPolicy = {
     context: ManagedOAuthCredentialApplicationContext
   ) => principal.resourceScope?.credentialId === context.credentialId,
 } satisfies WorkspaceDelegationPolicy<ManagedOAuthCredentialApplicationContext>
+
+/**
+ * Resolves the user whose credential grants an operation evaluates.
+ *
+ * `executionActorUserId` is the user the legacy internal route authenticated as.
+ * Workspace authorization remains principal-based, and a principal subject
+ * always takes precedence over this compatibility value.
+ */
+export function requireCredentialExecutionUserId(
+  principal: Principal,
+  executionActorUserId?: string
+): string {
+  const userId = resolvePrincipalSubjectUserId(principal) ?? executionActorUserId
+  if (!userId) {
+    throw new OrchestrationError(
+      'forbidden',
+      'Credential access requires a user subject or execution actor'
+    )
+  }
+  return userId
+}

apps/sim/lib/credentials/application/authorization.ts

@@ -1,5 +1,4 @@
 import type { Principal } from '@sim/auth/principal'
-import { requirePrincipalSubjectUserId } from '@sim/auth/principal'
 import {
   type AuthorizedWorkspaceUseCaseDefinition,
   defineAuthorizedWorkspaceUseCase,
@@ -9,7 +8,10 @@ import {
 import { OrchestrationError } from '@/lib/core/orchestration/types'
 import type { CredentialActorContext } from '@/lib/credentials/access'
 import { getCredentialActorContext } from '@/lib/credentials/access'
-import { credentialDelegationPolicy } from '@/lib/credentials/application/authorization'
+import {
+  credentialDelegationPolicy,
+  requireCredentialExecutionUserId,
+} from '@/lib/credentials/application/authorization'
 import type { CredentialOperation } from '@/lib/credentials/application/operations'
 import type { CredentialRow } from '@/lib/credentials/queries'
 
@@ -74,7 +76,9 @@ type AuthorizedCredentialUseCaseDefinition<
 > = Omit<
   AuthorizedWorkspaceUseCaseDefinition<O, I, C, R>,
   'authorizationOptions' | 'authorizeResource'
->
+> & {
+  resolveExecutionActorUserId?: (input: I) => string | undefined
+}
 
 export function defineAuthorizedCredentialUseCase<
   const O extends CredentialOperation,
@@ -85,11 +89,10 @@ export function defineAuthorizedCredentialUseCase<
   return defineAuthorizedWorkspaceUseCase({
     ...definition,
     authorizationOptions: { delegation: credentialDelegationPolicy },
-    async authorizeResource({ principal, context }) {
+    async authorizeResource({ principal, input, context }) {
       const actor = await getCredentialActorContext(
         context.credential.id,
-        // actorless-unsupported: credential access is decided per person; an actorless run has no credential grants
-        requirePrincipalSubjectUserId(principal)
+        requireCredentialExecutionUserId(principal, definition.resolveExecutionActorUserId?.(input))
       )
       if (
         !actor.credential ||