fix(credentials): reject managed OAuth kind mismatches before resolution

Author: waleedlatif1

apps/sim/lib/internal/oracle-fusion-financials/operations.ts

@@ -120,6 +120,7 @@ type OracleFusionFinancialsToolId = (typeof ORACLE_FUSION_FINANCIALS_TOOL_IDS)[n
 
 const TOOL_ID_SET = new Set<string>(ORACLE_FUSION_FINANCIALS_TOOL_IDS)
 
+/** Narrows a tool ID to one of the supported Oracle Fusion Financials operations. */
 export function isOracleFusionFinancialsToolId(
   value: string
 ): value is OracleFusionFinancialsToolId {
@@ -571,6 +572,11 @@ async function getOracleFusionGlJournalBatch(rawInput: unknown, signal?: AbortSi
   )
 }
 
+/**
+ * Validates raw inputs and runs a Financials operation with optional cancellation.
+ * Returns projected tool output, including unsuccessful Oracle action outcomes.
+ * Input validation, provider, and cancellation errors propagate to the caller.
+ */
 export async function executeOracleFusionFinancialsOperation(
   toolId: OracleFusionFinancialsToolId,
   rawInput: unknown,

apps/sim/lib/oauth/token-resolution.test.ts

@@ -220,6 +220,7 @@ describe('resolveCredentialAccessToken', () => {
   const resolveManagedPrincipal = vi.fn()
 
   beforeEach(() => {
+    mockExecuteManagedToken.mockReset()
     mockResolveOAuthAccountId.mockResolvedValue(null)
     authenticate.mockResolvedValue(INTERNAL_AUTH)
     resolveManagedPrincipal.mockResolvedValue(EXECUTOR_PRINCIPAL)
@@ -309,6 +310,40 @@ describe('resolveCredentialAccessToken', () => {
     expect(mockExecuteManagedToken).not.toHaveBeenCalled()
   })
 
+  it('rejects a managed OAuth credential for a service-account-only tool before token resolution', async () => {
+    mockResolveOAuthAccountId.mockResolvedValueOnce({
+      ...MANAGED_RESOLVED,
+      providerId: 'slack',
+    })
+    mockGetToolMetadata.mockReturnValueOnce({
+      id: 'slack_add_bookmark',
+      params: {},
+      oauth: {
+        required: true,
+        provider: 'slack',
+        requiredScopes: ['bookmarks:write'],
+        credentialKind: 'service-account',
+      },
+    })
+    mockExecuteManagedToken.mockResolvedValueOnce({ accessToken: 'managed-token' })
+
+    const result = await resolveCredentialAccessToken({
+      requestId: 'req-1',
+      credentialId: 'cred-1',
+      toolId: 'slack_add_bookmark',
+      authenticate,
+      resolveManagedPrincipal,
+    })
+
+    expect(result).toEqual({
+      ok: false,
+      status: 400,
+      code: 'CREDENTIAL_TYPE_MISMATCH',
+      error: 'The selected credential type is not supported by this tool',
+    })
+    expect(mockExecuteManagedToken).not.toHaveBeenCalled()
+  })
+
   it('rejects tools whose scope policy is empty', async () => {
     mockResolveOAuthAccountId.mockResolvedValue(MANAGED_RESOLVED)
     mockGetToolMetadata.mockReturnValue({

apps/sim/lib/oauth/token-resolution.ts

@@ -35,6 +35,7 @@ import {
 } from '@/lib/oauth/utils'
 import { captureServerEvent } from '@/lib/posthog/server'
 import { getToolMetadata } from '@/tools/metadata'
+import type { OAuthConfig } from '@/tools/types'
 import { extractZohoDeskBaseFromScope } from '@/tools/zoho_desk/host-allowlist'
 
 const logger = createLogger('OAuthTokenResolution')
@@ -233,21 +234,29 @@ export async function completeOAuthCredentialToken(params: {
   }
 }
 
-function validateToolCredentialBinding(
-  toolId: string | undefined,
-  providerId: string | null | undefined,
-  credentialKind: 'oauth' | 'service-account'
+function validateToolCredentialKind(
+  requiredKind: OAuthConfig['credentialKind'],
+  actualKind: NonNullable<OAuthConfig['credentialKind']>
 ): Extract<ResolveCredentialTokenResult, { ok: false }> | undefined {
-  if (!toolId) return
-  const policy = getToolMetadata(toolId)?.oauth
-  if (policy?.credentialKind && policy.credentialKind !== credentialKind) {
+  if (requiredKind && requiredKind !== actualKind) {
     return {
       ok: false,
       status: 400,
       code: 'CREDENTIAL_TYPE_MISMATCH',
       error: 'The selected credential type is not supported by this tool',
     }
   }
+}
+
+function validateToolCredentialBinding(
+  toolId: string | undefined,
+  providerId: string | null | undefined,
+  credentialKind: NonNullable<OAuthConfig['credentialKind']>
+): Extract<ResolveCredentialTokenResult, { ok: false }> | undefined {
+  if (!toolId) return
+  const policy = getToolMetadata(toolId)?.oauth
+  const kindError = validateToolCredentialKind(policy?.credentialKind, credentialKind)
+  if (kindError) return kindError
   const service = policy?.required
     ? (getServiceConfigByServiceId(policy.provider) ??
       getServiceConfigByProviderId(policy.provider))
@@ -509,6 +518,9 @@ export async function resolveCredentialAccessToken(
       error: 'This tool is not configured to use managed credentials',
     }
   }
+  const kindError = validateToolCredentialKind(toolMetadata.oauth.credentialKind, 'oauth')
+  if (kindError) return kindError
+
   const requiredScopes =
     toolMetadata.oauth.requiredScopes ?? getCanonicalScopesForProvider(toolMetadata.oauth.provider)
   if (requiredScopes.length === 0 && toolMetadata.oauth.requiredScopes === undefined) {