fix(oci-compute): align retries and selectors with Oracle schemas

Author: Bill Leoutsakos

apps/docs/content/docs/integrations/oci_compute.mdx

@@ -239,7 +239,6 @@ import { MSSQLBlock, MSSQLBlockMeta } from '@/blocks/blocks/mssql'
 import { MySQLBlock, MySQLBlockMeta } from '@/blocks/blocks/mysql'
 import { Neo4jBlock, Neo4jBlockMeta } from '@/blocks/blocks/neo4j'
 import { NetSuiteBlock, NetSuiteBlockMeta } from '@/blocks/blocks/netsuite'
-import { OciComputeBlock, OciComputeBlockMeta } from '@/blocks/blocks/oci_compute'
 import { NeverBounceBlock, NeverBounceBlockMeta } from '@/blocks/blocks/neverbounce'
 import { NewRelicBlock, NewRelicBlockMeta } from '@/blocks/blocks/new_relic'
 import { NoteBlock } from '@/blocks/blocks/note'
@@ -250,6 +249,7 @@ import {
   NotionV2BlockMeta,
 } from '@/blocks/blocks/notion'
 import { ObsidianBlock, ObsidianBlockMeta } from '@/blocks/blocks/obsidian'
+import { OciComputeBlock, OciComputeBlockMeta } from '@/blocks/blocks/oci_compute'
 import { OktaBlock, OktaBlockMeta } from '@/blocks/blocks/okta'
 import { OneDriveBlock, OneDriveBlockMeta } from '@/blocks/blocks/onedrive'
 import { OnePasswordBlock, OnePasswordBlockMeta } from '@/blocks/blocks/onepassword'

apps/sim/blocks/blocks/oci_compute.ts

@@ -5,13 +5,17 @@ import { beforeEach, describe, expect, it, vi } from 'vitest'
 import type { InternalToolOperationCall } from '@/lib/internal/tool-operations/types'
 
 const mocks = vi.hoisted(() => ({
-  authorize: vi.fn(), createClient: vi.fn(), execute: vi.fn(),
+  authorize: vi.fn(),
+  createClient: vi.fn(),
+  execute: vi.fn(),
 }))
 vi.mock('@/lib/auth/credential-access', () => ({ authorizeCredentialUseForAuth: mocks.authorize }))
 vi.mock('@/lib/auth/hybrid', () => ({ AuthType: { INTERNAL_JWT: 'internal_jwt' } }))
 vi.mock('@/lib/api/server', () => ({ getValidationErrorMessage: () => 'Invalid input' }))
 vi.mock('@/lib/internal/oci/client.server', () => ({ createOciClient: mocks.createClient }))
-vi.mock('@/lib/internal/oci-compute/operations', () => ({ executeOciComputeOperation: mocks.execute }))
+vi.mock('@/lib/internal/oci-compute/operations', () => ({
+  executeOciComputeOperation: mocks.execute,
+}))
 
 import { executeOciComputeTool } from '@/lib/internal/oci-compute/execute-tool'
 
@@ -28,7 +32,10 @@ function call(overrides: Partial<InternalToolOperationCall> = {}): InternalToolO
 beforeEach(() => {
   vi.clearAllMocks()
   mocks.authorize.mockResolvedValue({
-    ok: true, resolvedCredentialId: 'authoritative', credentialType: 'service_account', workspaceId: 'workspace',
+    ok: true,
+    resolvedCredentialId: 'authoritative',
+    credentialType: 'service_account',
+    workspaceId: 'workspace',
   })
   mocks.createClient.mockResolvedValue({ bound: true })
   mocks.execute.mockResolvedValue({ success: true, output: { status: 200, requestId: 'request' } })
@@ -39,10 +46,16 @@ describe('OCI Compute trusted execution wiring', () => {
     const signal = new AbortController().signal
     expect((await executeOciComputeTool(call({ signal }))).status).toBe(200)
     expect(mocks.createClient).toHaveBeenCalledWith({
-      credentialId: 'authoritative', workspaceId: 'workspace', serviceId: 'oci_compute', region: 'us-ashburn-1',
+      credentialId: 'authoritative',
+      workspaceId: 'workspace',
+      serviceId: 'oci_compute',
+      region: 'us-ashburn-1',
     })
     expect(mocks.execute).toHaveBeenCalledWith(
-      { bound: true }, 'get_instance', expect.objectContaining({ instanceId: 'instance' }), signal
+      { bound: true },
+      'get_instance',
+      expect.objectContaining({ instanceId: 'instance' }),
+      signal
     )
   })
 

apps/sim/blocks/registry-maps.ts

@@ -5,10 +5,7 @@ import { authorizeCredentialUseForAuth } from '@/lib/auth/credential-access'
 import { AuthType } from '@/lib/auth/hybrid'
 import { createOciClient } from '@/lib/internal/oci/client.server'
 import { executeOciComputeOperation } from '@/lib/internal/oci-compute/operations'
-import {
-  type OciComputeOperation,
-  ociComputeSchemas,
-} from '@/lib/internal/oci-compute/schema'
+import { type OciComputeOperation, ociComputeSchemas } from '@/lib/internal/oci-compute/schema'
 import type { InternalToolOperationHandler } from '@/lib/internal/tool-operations/types'
 import { OCI_COMPUTE_SERVICE_ID } from '@/tools/oci_compute/types'
 
@@ -19,15 +16,24 @@ export const executeOciComputeTool: InternalToolOperationHandler = async (reques
   }
   const operation = request.toolId.slice('oci_compute_'.length)
   if (!Object.hasOwn(ociComputeSchemas, operation)) {
-    return Response.json({ success: false, error: 'Unsupported OCI Compute operation' }, { status: 400 })
+    return Response.json(
+      { success: false, error: 'Unsupported OCI Compute operation' },
+      { status: 400 }
+    )
   }
   const { userId, workspaceId, workflowId } = request.context
   if (!userId || !workspaceId) {
-    return Response.json({ success: false, error: 'Trusted execution scope is required' }, { status: 401 })
+    return Response.json(
+      { success: false, error: 'Trusted execution scope is required' },
+      { status: 401 }
+    )
   }
   try {
     if (Buffer.byteLength(JSON.stringify(request.input) ?? '') > DEFAULT_MAX_JSON_BODY_BYTES) {
-      return Response.json({ success: false, error: 'OCI Compute input is too large' }, { status: 413 })
+      return Response.json(
+        { success: false, error: 'OCI Compute input is too large' },
+        { status: 413 }
+      )
     }
   } catch {
     return Response.json({ success: false, error: 'Invalid OCI Compute input' }, { status: 400 })
@@ -36,7 +42,10 @@ export const executeOciComputeTool: InternalToolOperationHandler = async (reques
   const parsed = ociComputeSchemas[key].safeParse(request.input)
   if (!parsed.success) {
     return Response.json(
-      { success: false, error: getValidationErrorMessage(parsed.error, 'Invalid OCI Compute input') },
+      {
+        success: false,
+        error: getValidationErrorMessage(parsed.error, 'Invalid OCI Compute input'),
+      },
       { status: 400 }
     )
   }
@@ -68,9 +77,7 @@ export const executeOciComputeTool: InternalToolOperationHandler = async (reques
       serviceId: OCI_COMPUTE_SERVICE_ID,
       region: parsed.data.region,
     })
-    return Response.json(
-      await executeOciComputeOperation(client, key, parsed.data, request.signal)
-    )
+    return Response.json(await executeOciComputeOperation(client, key, parsed.data, request.signal))
   } catch (error) {
     request.signal?.throwIfAborted()
     return Response.json(

apps/sim/lib/internal/oci-compute/execute-tool.test.ts

@@ -8,12 +8,13 @@ import {
   executeOciComputeOperation,
   resolveOciComputeRetryToken,
 } from '@/lib/internal/oci-compute/operations'
-import { ociComputeSchemas, type OciComputeOperation } from '@/lib/internal/oci-compute/schema'
+import { type OciComputeOperation, ociComputeSchemas } from '@/lib/internal/oci-compute/schema'
 
 const auth = { oauthCredential: 'credential', region: 'us-ashburn-1' }
 function harness(data: unknown = {}, status = 200, headers: Record<string, string> = {}) {
   const request = vi.fn().mockResolvedValue({
-    status, headers: { 'opc-request-id': 'request', ...headers },
+    status,
+    headers: { 'opc-request-id': 'request', ...headers },
     body: new TextEncoder().encode(status === 204 ? '' : JSON.stringify(data)),
   })
   const client = {
@@ -24,7 +25,9 @@ function harness(data: unknown = {}, status = 200, headers: Record<string, strin
 }
 async function run(operation: OciComputeOperation, input: Record<string, unknown>, h = harness()) {
   const result = await executeOciComputeOperation(
-    h.client, operation, ociComputeSchemas[operation].parse({ ...auth, ...input })
+    h.client,
+    operation,
+    ociComputeSchemas[operation].parse({ ...auth, ...input })
   )
   return { ...h, result }
 }
@@ -33,21 +36,69 @@ function body(request: OciRequest) {
 }
 
 describe('OCI Compute requests', () => {
+  it('preserves token and payload across re-entry of a lifecycle invocation', async () => {
+    const input = {
+      instanceId: 'instance', action: 'STOP',
+      deliveryIdentity: { executionId: 'execution', blockId: 'block', invocationId: 'call' },
+    }
+    const first = await run('instance_action', input)
+    const second = await run('instance_action', input)
+    expect(first.request.mock.calls[0][0].retry).toEqual(second.request.mock.calls[0][0].retry)
+    expect(body(first.request.mock.calls[0][0])).toEqual(body(second.request.mock.calls[0][0]))
+  })
+
+  it('builds configuration creation and deferred launch overrides distinctly', async () => {
+    const created = await run('create_instance_configuration', {
+      compartmentId: 'destination', configurationSource: 'INSTANCE', instanceId: 'source',
+    })
+    expect(body(created.request.mock.calls[0][0])).toEqual({
+      compartmentId: 'destination', source: 'INSTANCE', instanceId: 'source',
+    })
+    const launched = await run('launch_instance_configuration', {
+      instanceConfigurationId: 'configuration',
+      instanceDetails: { instanceType: 'compute', blockVolumes: [{ volumeId: 'existing' }] },
+    })
+    expect(body(launched.request.mock.calls[0][0])).toEqual({
+      instanceType: 'compute', blockVolumes: [{ volumeId: 'existing' }],
+    })
+  })
+
+  it('returns optional work headers and sends explicit member-detachment choices', async () => {
+    const { request, result } = await run('detach_instance_pool_instance', {
+      instancePoolId: 'pool', instanceId: 'instance', isAutoTerminate: false, isDecrementSize: false,
+      retryToken: 'member-delivery',
+    }, harness(undefined, 202, { 'opc-work-request-id': 'work' }))
+    expect(body(request.mock.calls[0][0])).toEqual({
+      instanceId: 'instance', isAutoTerminate: false, isDecrementSize: false,
+    })
+    expect(result.output).toMatchObject({ workRequestId: 'work', retryToken: 'member-delivery' })
+  })
+
   it.each([
     ['image', { imageId: 'image' }, { sourceType: 'image', imageId: 'image' }],
-    ['imageFilter', { imageFilter: { compartmentId: 'images' } }, {
-      sourceType: 'image', instanceSourceImageFilterDetails: { compartmentId: 'images' },
-    }],
+    [
+      'imageFilter',
+      { imageFilter: { compartmentId: 'images' } },
+      {
+        sourceType: 'image',
+        instanceSourceImageFilterDetails: { compartmentId: 'images' },
+      },
+    ],
     ['bootVolume', { bootVolumeId: 'boot' }, { sourceType: 'bootVolume', bootVolumeId: 'boot' }],
   ])('builds the %s launch source and retains its token', async (sourceMode, source, expected) => {
     const { request, result } = await run('launch_instance', {
-      compartmentId: 'compartment', availabilityDomain: 'AD', shape: 'shape',
+      compartmentId: 'compartment',
+      availabilityDomain: 'AD',
+      shape: 'shape',
       createVnicDetails: { subnetId: 'subnet', assignPublicIp: false },
-      sourceMode, ...source, retryToken: 'explicit-token',
+      sourceMode,
+      ...source,
+      retryToken: 'explicit-token',
     })
     expect(body(request.mock.calls[0][0])).toMatchObject({ sourceDetails: expected })
     expect(request.mock.calls[0][0]).toMatchObject({
-      method: 'POST', encodedPath: '/20160918/instances/',
+      method: 'POST',
+      encodedPath: '/20160918/instances/',
       retry: { kind: 'tokenized', maxAttempts: 2, retryToken: 'explicit-token' },
       maxResponseBytes: 2_000_000,
     })
@@ -57,45 +108,84 @@ describe('OCI Compute requests', () => {
 
   it.each([
     ['START', {}, undefined],
-    ['RESET', { allowDenseRebootMigration: false }, { actionType: 'reset', allowDenseRebootMigration: false }],
-    ['SOFTRESET', { allowDenseRebootMigration: true }, { actionType: 'softreset', allowDenseRebootMigration: true }],
-    ['REBOOTMIGRATE', { deleteLocalStorage: false }, { actionType: 'rebootMigrate', deleteLocalStorage: false }],
+    [
+      'RESET',
+      { allowDenseRebootMigration: false },
+      { actionType: 'reset', allowDenseRebootMigration: false },
+    ],
+    [
+      'SOFTRESET',
+      { allowDenseRebootMigration: true },
+      { actionType: 'softreset', allowDenseRebootMigration: true },
+    ],
+    [
+      'REBOOTMIGRATE',
+      { deleteLocalStorage: false },
+      { actionType: 'rebootMigrate', deleteLocalStorage: false },
+    ],
   ])('discriminates the %s lifecycle body', async (action, fields, expected) => {
-    const { request } = await run('instance_action', { instanceId: 'instance', action, ...fields, ifMatch: 'etag' })
+    const { request } = await run('instance_action', {
+      instanceId: 'instance',
+      action,
+      ...fields,
+      ifMatch: 'etag',
+    })
     expect(body(request.mock.calls[0][0])).toEqual(expected)
     expect(request.mock.calls[0][0]).toMatchObject({
-      queryPairs: [['action', action]], headers: { 'if-match': 'etag' },
+      queryPairs: [['action', action]],
+      headers: { 'if-match': 'etag' },
     })
-    expect(request.mock.calls[0][0].retry).toBeUndefined()
+    expect(request.mock.calls[0][0].retry).toMatchObject({ kind: 'tokenized', maxAttempts: 2 })
   })
 
   it('uses a pool action path and a single attempt', async () => {
-    const { request } = await run('instance_pool_action', { instancePoolId: 'pool', action: 'SOFTSTOP' })
+    const { request } = await run('instance_pool_action', {
+      instancePoolId: 'pool',
+      action: 'SOFTSTOP',
+    })
     expect(request.mock.calls[0][0]).toMatchObject({
-      method: 'POST', encodedPath: '/20160918/instancePools/pool/actions/softstop',
+      method: 'POST',
+      encodedPath: '/20160918/instancePools/pool/actions/softstop',
     })
     expect(body(request.mock.calls[0][0])).toBeUndefined()
-    expect(request.mock.calls[0][0].retry).toBeUndefined()
+    expect(request.mock.calls[0][0].retry).toMatchObject({ kind: 'tokenized', maxAttempts: 2 })
   })
 
   it('terminates once with explicit preservation choices and accepts an empty response', async () => {
-    const { request, result } = await run('terminate_instance', {
-      instanceId: 'instance', preserveBootVolume: false, preserveDataVolumesCreatedAtLaunch: true,
-      ifMatch: 'etag',
-    }, harness(undefined, 204))
+    const { request, result } = await run(
+      'terminate_instance',
+      {
+        instanceId: 'instance',
+        preserveBootVolume: false,
+        preserveDataVolumesCreatedAtLaunch: true,
+        ifMatch: 'etag',
+      },
+      harness(undefined, 204)
+    )
     expect(result.success).toBe(true)
     expect(request.mock.calls[0][0]).toMatchObject({
-      method: 'DELETE', headers: { 'if-match': 'etag' },
-      queryPairs: [['preserveBootVolume', 'false'], ['preserveDataVolumesCreatedAtLaunch', 'true']],
+      method: 'DELETE',
+      headers: { 'if-match': 'etag' },
+      queryPairs: [
+        ['preserveBootVolume', 'false'],
+        ['preserveDataVolumesCreatedAtLaunch', 'true'],
+      ],
     })
     expect(request.mock.calls[0][0].retry).toBeUndefined()
     expect(request).toHaveBeenCalledTimes(1)
   })
 
   it('retains pagination on an empty page and encodes opaque IDs once', async () => {
-    const { request, result } = await run('list_instance_pool_instances', {
-      instancePoolId: 'pool/a', compartmentId: 'compartment', page: 'opaque+/=', limit: 50,
-    }, harness([], 200, { 'opc-next-page': 'next' }))
+    const { request, result } = await run(
+      'list_instance_pool_instances',
+      {
+        instancePoolId: 'pool/a',
+        compartmentId: 'compartment',
+        page: 'opaque+/=',
+        limit: 50,
+      },
+      harness([], 200, { 'opc-next-page': 'next' })
+    )
     expect(result.output).toMatchObject({ poolInstances: [], nextPage: 'next' })
     expect(request.mock.calls[0][0]).toMatchObject({
       encodedPath: '/20160918/instancePools/pool%2Fa/instances',
@@ -108,7 +198,11 @@ describe('OCI Compute requests', () => {
     const h = harness()
     h.request.mockRejectedValue(new OciClientError('request_failed'))
     const { result } = await run('terminate_instance', { instanceId: 'instance' }, h)
-    expect(result).toMatchObject({ success: false, retryable: false, output: { outcome: 'unknown' } })
+    expect(result).toMatchObject({
+      success: false,
+      retryable: false,
+      output: { outcome: 'unknown' },
+    })
     expect(h.request).toHaveBeenCalledTimes(1)
   })