feat(oracle-epm): add Profitability and Cost Management integration

Author: Bill Leoutsakos

apps/docs/components/ui/icon-mapping.ts

@@ -482,6 +482,7 @@ export const blockTypeToIconMap: Record<string, IconComponent> = {
   onedrive: MicrosoftOneDriveIcon,
   onepassword: OnePasswordIcon,
   openai: OpenAIIcon,
+  oracle_epm_profitability: NetSuiteIcon,
   outlook: OutlookIcon,
   pagerduty: PagerDutyIcon,
   parallel_ai: ParallelIcon,

apps/docs/content/docs/integrations/meta.json

@@ -188,6 +188,7 @@
     "onedrive",
     "onepassword",
     "openai",
+    "oracle_epm_profitability",
     "outlook",
     "pagerduty",
     "parallel_ai",

apps/docs/content/docs/integrations/oracle_epm_profitability.mdx

@@ -252,6 +252,7 @@ import { OktaBlock, OktaBlockMeta } from '@/blocks/blocks/okta'
 import { OneDriveBlock, OneDriveBlockMeta } from '@/blocks/blocks/onedrive'
 import { OnePasswordBlock, OnePasswordBlockMeta } from '@/blocks/blocks/onepassword'
 import { OpenAIBlock, OpenAIBlockMeta } from '@/blocks/blocks/openai'
+import { OraclePcmBlock, OraclePcmBlockMeta } from '@/blocks/blocks/oracle_epm_profitability'
 import { OutlookBlock, OutlookBlockMeta } from '@/blocks/blocks/outlook'
 import { PagerDutyBlock, PagerDutyBlockMeta } from '@/blocks/blocks/pagerduty'
 import { ParallelBlock, ParallelBlockMeta } from '@/blocks/blocks/parallel'
@@ -595,6 +596,7 @@ export const BLOCK_REGISTRY: Record<string, BlockConfig> = {
   onedrive: OneDriveBlock,
   onepassword: OnePasswordBlock,
   openai: OpenAIBlock,
+  oracle_epm_profitability: OraclePcmBlock,
   outlook: OutlookBlock,
   pagerduty: PagerDutyBlock,
   parallel_ai: ParallelBlock,
@@ -917,6 +919,7 @@ export const BLOCK_META_REGISTRY: Record<string, BlockMeta> = {
   onedrive: OneDriveBlockMeta,
   onepassword: OnePasswordBlockMeta,
   openai: OpenAIBlockMeta,
+  oracle_epm_profitability: OraclePcmBlockMeta,
   outlook: OutlookBlockMeta,
   pagerduty: PagerDutyBlockMeta,
   parallel_ai: ParallelBlockMeta,

apps/sim/blocks/blocks/oracle_epm_profitability.ts

@@ -245,6 +245,7 @@ export const DOCS_MANIFEST: readonly string[] = [
   'integrations/onedrive.mdx',
   'integrations/onepassword.mdx',
   'integrations/openai.mdx',
+  'integrations/oracle_epm_profitability.mdx',
   'integrations/outlook.mdx',
   'integrations/pagerduty.mdx',
   'integrations/parallel_ai.mdx',

apps/sim/blocks/registry-maps.ts

@@ -65,6 +65,7 @@ const EXPECTED_COVERAGE: Record<string, string[]> = {
   'linear-service-account': ['linear'],
   'monday-service-account': ['monday'],
   'notion-service-account': ['notion'],
+  'oracle-epm-service-account': [],
   // NetSuite remains an API-key catalog integration, like Snowflake, while its
   // block uses the shared reusable-credential selector.
   'netsuite-service-account': [],
@@ -110,6 +111,28 @@ describe('service-account coverage', () => {
     })
   })
 
+  it('binds PCM to the existing reusable Oracle EPM credential', () => {
+    expect(
+      OAUTH_PROVIDERS['oracle-epm-profitability'].services['oracle-epm-profitability']
+    ).toMatchObject({
+      providerId: 'oracle-epm-profitability',
+      serviceAccountProviderId: 'oracle-epm-service-account',
+      authType: 'service_account',
+    })
+    expect(
+      credentialProviderMatchesService(
+        'oracle-epm-service-account',
+        OAUTH_PROVIDERS['oracle-epm-profitability'].services['oracle-epm-profitability']
+      )
+    ).toBe(true)
+    expect(
+      credentialProviderMatchesService(
+        'netsuite-service-account',
+        OAUTH_PROVIDERS['oracle-epm-profitability'].services['oracle-epm-profitability']
+      )
+    ).toBe(false)
+  })
+
   it('pins the table to exactly the registered service-account provider ids', () => {
     expect(REGISTERED_SERVICE_ACCOUNT_IDS).toEqual(Object.keys(EXPECTED_COVERAGE).sort())
   })

apps/sim/lib/copilot/generated/docs-manifest.ts

@@ -464,6 +464,7 @@ export const blockTypeToIconMap: Record<string, IconComponent> = {
   okta: OktaIcon,
   onedrive: MicrosoftOneDriveIcon,
   onepassword: OnePasswordIcon,
+  oracle_epm_profitability: NetSuiteIcon,
   outlook: OutlookIcon,
   pagerduty: PagerDutyIcon,
   parallel_ai: ParallelIcon,

apps/sim/lib/integrations/credential-display.test.ts

@@ -0,0 +1,125 @@
+/** @vitest-environment node */
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const mocks = vi.hoisted(() => ({ operation: vi.fn(), job: vi.fn(), file: vi.fn() }))
+vi.mock('@/lib/internal/oracle-epm-profitability/operations', () => ({
+  executeOraclePcmOperation: mocks.operation,
+}))
+vi.mock('@/lib/internal/oracle-epm-profitability/jobs', () => ({
+  executeOraclePcmJobOperation: mocks.job,
+}))
+vi.mock('@/lib/internal/oracle-epm-profitability/files.server', () => ({
+  executeOraclePcmFileOperation: mocks.file,
+}))
+vi.mock('@/lib/internal/oracle-epm/files.server', () => ({
+  openOracleEpmSourceFile: vi.fn(),
+  storeOracleEpmDownload: vi.fn(),
+}))
+
+import { oracleEpmLocalError } from '@/lib/internal/oracle-epm/errors'
+import { executeOraclePcmTool } from '@/lib/internal/oracle-epm-profitability/execute-tool'
+import { OraclePcmOperationError } from '@/lib/internal/oracle-epm-profitability/normalizers'
+import type { InternalToolOperationCall } from '@/lib/internal/tool-operations/types'
+
+function call(operation: string): InternalToolOperationCall {
+  return {
+    toolId: `oracle_epm_profitability_${operation}`,
+    input: {
+      oauthCredential: 'credential-1',
+      accessToken: 'injected-token',
+      instanceUrl: 'https://epm.example.com',
+      userId: 'untrusted',
+    },
+    context: { workflowId: 'workflow-1', userId: 'trusted-user' },
+    headers: new Headers(),
+    requestId: 'request-1',
+    signal: new AbortController().signal,
+  }
+}
+describe('Oracle PCM direct tool handler', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    for (const mock of Object.values(mocks)) mock.mockResolvedValue({ success: true, output: {} })
+  })
+  it.each([
+    'create_application',
+    'enable_application',
+    'deploy_cube',
+    'update_dimensions',
+    'load_data',
+    'run_calculation',
+    'copy_pov',
+    'clear_pov',
+    'get_rule_balancing',
+    'generate_program_documentation',
+    'export_query_results',
+    'import_template',
+    'apply_data_grants',
+    'merge_slices',
+    'optimize_cube',
+  ])('dispatches %s without an internal HTTP hop', async (operation) => {
+    const request = call(operation)
+    expect((await executeOraclePcmTool(request)).status).toBe(200)
+    expect(mocks.operation).toHaveBeenCalledWith(operation, request.input, request.signal)
+  })
+  it.each(['get_task_status', 'wait_for_task'])(
+    'forwards cancellation for %s',
+    async (operation) => {
+      const request = call(operation)
+      await executeOraclePcmTool(request)
+      expect(mocks.job).toHaveBeenCalledWith(operation, request.input, request.signal)
+    }
+  )
+  it.each(['list_files', 'upload_file', 'download_file'])(
+    'forwards trusted context for %s',
+    async (operation) => {
+      const request = call(operation)
+      await executeOraclePcmTool(request)
+      expect(mocks.file).toHaveBeenCalledWith(
+        operation,
+        request.input,
+        request.signal,
+        request.context
+      )
+    }
+  )
+  it.each([
+    [new OraclePcmOperationError('Invalid application', 400), 400, 'Invalid application'],
+    [oracleEpmLocalError('invalid_response'), 502, 'Oracle EPM returned an invalid response'],
+    [oracleEpmLocalError('timeout'), 408, 'The Oracle EPM request timed out'],
+    [
+      oracleEpmLocalError('payload_too_large'),
+      413,
+      'The Oracle EPM payload exceeded the allowed size',
+    ],
+    [new Error('credential-secret-canary'), 500, 'Oracle PCM operation failed'],
+  ])(
+    'returns safe failures and disallows automatic resubmission',
+    async (error, status, message) => {
+      mocks.operation.mockRejectedValue(error)
+      const response = await executeOraclePcmTool(call('run_calculation'))
+      expect(response.status).toBe(status)
+      expect(await response.json()).toEqual({
+        success: false,
+        output: {},
+        error: message,
+        retryable: false,
+      })
+    }
+  )
+  it('distinguishes local timeout from remote cancellation', async () => {
+    mocks.job.mockRejectedValue(new DOMException('deadline', 'TimeoutError'))
+    const response = await executeOraclePcmTool(call('wait_for_task'))
+    expect(response.status).toBe(408)
+    expect((await response.json()).error).toContain('remote task was not cancelled')
+  })
+  it('propagates aborts and rejects other tool namespaces', async () => {
+    const request = call('run_calculation')
+    request.signal = AbortSignal.abort()
+    await expect(executeOraclePcmTool(request)).rejects.toThrow()
+    expect(mocks.operation).not.toHaveBeenCalled()
+    expect(
+      (await executeOraclePcmTool({ ...call('list_files'), toolId: 'unrelated_tool' })).status
+    ).toBe(400)
+  })
+})

apps/sim/lib/integrations/icon-mapping.ts

@@ -0,0 +1,64 @@
+import { isPayloadSizeLimitError } from '@/lib/core/utils/stream-limits'
+import { OracleEpmError } from '@/lib/internal/oracle-epm'
+import { executeOraclePcmFileOperation } from '@/lib/internal/oracle-epm-profitability/files.server'
+import { executeOraclePcmJobOperation } from '@/lib/internal/oracle-epm-profitability/jobs'
+import { OraclePcmOperationError } from '@/lib/internal/oracle-epm-profitability/normalizers'
+import { executeOraclePcmOperation } from '@/lib/internal/oracle-epm-profitability/operations'
+import type { InternalToolOperationHandler } from '@/lib/internal/tool-operations/types'
+
+const PREFIX = 'oracle_epm_profitability_'
+const JOB_OPERATIONS = new Set(['get_task_status', 'wait_for_task'])
+const FILE_OPERATIONS = new Set(['list_files', 'upload_file', 'download_file'])
+
+export const executeOraclePcmTool: InternalToolOperationHandler = async (request) => {
+  request.signal?.throwIfAborted()
+  if (!request.toolId.startsWith(PREFIX)) {
+    return Response.json(
+      { success: false, output: {}, error: 'Unsupported Oracle PCM tool', retryable: false },
+      { status: 400 }
+    )
+  }
+  const operation = request.toolId.slice(PREFIX.length)
+  try {
+    const result = FILE_OPERATIONS.has(operation)
+      ? await executeOraclePcmFileOperation(
+          operation,
+          request.input,
+          request.signal,
+          request.context
+        )
+      : JOB_OPERATIONS.has(operation)
+        ? await executeOraclePcmJobOperation(operation, request.input, request.signal)
+        : await executeOraclePcmOperation(operation, request.input, request.signal)
+    return Response.json(result)
+  } catch (error) {
+    request.signal?.throwIfAborted()
+    const timeout = error instanceof Error && error.name === 'TimeoutError'
+    const status = isPayloadSizeLimitError(error)
+      ? 413
+      : error instanceof OraclePcmOperationError
+        ? error.status
+        : error instanceof OracleEpmError
+          ? (error.status ??
+            (error.category === 'timeout'
+              ? 408
+              : error.category === 'payload_too_large'
+                ? 413
+                : 502))
+          : timeout
+            ? 408
+            : 500
+    const message =
+      error instanceof OraclePcmOperationError || error instanceof OracleEpmError
+        ? error.message
+        : timeout
+          ? 'Oracle PCM wait timed out; the remote task was not cancelled. Resume with the same processName.'
+          : isPayloadSizeLimitError(error)
+            ? 'Oracle PCM payload exceeded its allowed size'
+            : 'Oracle PCM operation failed'
+    return Response.json(
+      { success: false, output: {}, error: message, retryable: false },
+      { status }
+    )
+  }
+}