fix(apify): give the sync runs headroom, route polling through the transport

Renaming the reserved timeout param in this branch removed the only thing that
was setting a fetch deadline for Apify, so every sync run began riding the bare
300000ms default -- and Apify's sync endpoint returns 408 at exactly 300s. A run
near the boundary was a coin flip between Apify's structured 408 and Sim's
generic timeout, which loses the provider's diagnosis. The two sync operations
now get a deliberate 330s transport deadline, mirroring the 30s headroom the
executor already applies to internal routes.

run_actor_async polled with bare global fetch, so the dataset read bypassed the
response-size cap entirely. It now re-enters executeTool -- the pattern luma and
google_docs already use -- reusing apify_get_run and apify_get_dataset_items
rather than new request code, so the read is byte-bounded. The loop also checked
status before its first sleep, and its exhaustion message no longer hardcodes a
duration that the configurable ceiling can contradict.

An explicit 0 was dropped by a truthy guard while Apify documents 0 as 'no
timeout', so an unbounded run was inexpressible. Note the value that was being
dropped is a numeric 0 from a block-output reference; a subBlock string '0' was
always truthy.

run_actor_sync fabricated runId: 'sync-execution'. The endpoint returns only
pagination headers and no run id, so any downstream get_run wired to it was a
guaranteed 404. The field is omitted rather than invented.

Two limits remain and are documented in the code: the agent path bypasses the
block mapper, and executeNestedTool does not forward the abort signal.

Author: waleedlatif1

apps/sim/blocks/blocks/apify.ts

@@ -1,11 +1,14 @@
 import { ApifyIcon } from '@/components/icons'
 import type { BlockConfig, BlockMeta } from '@/blocks/types'
 import { AuthMode, IntegrationType } from '@/blocks/types'
-import type { RunActorResult } from '@/tools/apify/types'
+import { APIFY_SYNC_TRANSPORT_TIMEOUT_MS, type RunActorResult } from '@/tools/apify/types'
 
 const RUN_OPERATIONS = ['apify_run_actor_sync', 'apify_run_actor_async']
 const RUN_OR_TASK_OPERATIONS = [...RUN_OPERATIONS, 'apify_run_task']
 
+/** Operations that call a `run-sync-get-dataset-items` endpoint and inherit its 300s/408 contract. */
+const SYNC_RUN_OPERATIONS = new Set(['apify_run_actor_sync', 'apify_run_task'])
+
 export const ApifyBlock: BlockConfig<RunActorResult> = {
   type: 'apify',
   name: 'Apify',
@@ -234,10 +237,18 @@ Return ONLY the valid JSON object - no explanations, no markdown.`,
         /**
          * `timeout` is reserved by the tool request transport as the outbound fetch
          * deadline in milliseconds, so the seconds-valued subBlock is remapped onto a
-         * tool-specific parameter and cleared here to keep it off the transport.
+         * tool-specific parameter and never forwarded as-is.
+         *
+         * The sync endpoints then get a deliberate transport deadline of their own:
+         * without one they ride the transport's bare 300000ms fallback, which is the
+         * same number as Apify's documented 300s sync cap, so a boundary run races a
+         * structured 408 against a generic transport timeout. See
+         * `APIFY_SYNC_TRANSPORT_TIMEOUT_MS`.
          */
-        result.timeout = undefined
-        if (rest.timeout) {
+        result.timeout = SYNC_RUN_OPERATIONS.has(operation)
+          ? APIFY_SYNC_TRANSPORT_TIMEOUT_MS
+          : undefined
+        if (rest.timeout != null && rest.timeout !== '') {
           const timeoutSeconds = Number(rest.timeout)
           if (operation === 'apify_run_task') result.taskTimeout = timeoutSeconds
           else result.actorTimeout = timeoutSeconds

apps/sim/tools/apify/apify.test.ts

@@ -0,0 +1,222 @@
+/**
+ * @vitest-environment node
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { DEFAULT_EXECUTION_TIMEOUT_MS } from '@/lib/core/execution-limits'
+import { ApifyBlock } from '@/blocks/blocks/apify'
+import { apifyRunActorAsyncTool } from '@/tools/apify/run_actor_async'
+import { apifyRunActorSyncTool } from '@/tools/apify/run_actor_sync'
+import { apifyRunTaskTool } from '@/tools/apify/run_task'
+import { APIFY_SYNC_TRANSPORT_TIMEOUT_MS } from '@/tools/apify/types'
+import type { ToolConfig, ToolResponse } from '@/tools/types'
+
+vi.mock('@sim/utils/helpers', () => ({
+  sleep: vi.fn(async () => {}),
+}))
+
+function mapBlockParams(params: Record<string, unknown>): Record<string, unknown> {
+  const build = ApifyBlock.tools.config?.params
+  if (!build) throw new Error('apify tools.config.params is not defined')
+  return build(params) as Record<string, unknown>
+}
+
+function buildUrl(tool: ToolConfig<any, any>, params: Record<string, unknown>): string {
+  const { url } = tool.request
+  return typeof url === 'function' ? url(params as any) : url
+}
+
+function jsonResponse(body: unknown): Response {
+  return {
+    ok: true,
+    json: async () => body,
+  } as unknown as Response
+}
+
+describe('apify sync transport deadline', () => {
+  it('sits above the 300s Apify sync cap so the documented 408 wins the race', () => {
+    expect(APIFY_SYNC_TRANSPORT_TIMEOUT_MS).toBeGreaterThan(300_000)
+  })
+
+  it('arms a deliberate transport deadline for run_actor_sync', () => {
+    const result = mapBlockParams({
+      operation: 'apify_run_actor_sync',
+      apiKey: 'k',
+      actorId: 'me/actor',
+    })
+    expect(result.timeout).toBe(APIFY_SYNC_TRANSPORT_TIMEOUT_MS)
+  })
+
+  it('arms a deliberate transport deadline for run_task', () => {
+    const result = mapBlockParams({ operation: 'apify_run_task', apiKey: 'k', taskId: 'me/task' })
+    expect(result.timeout).toBe(APIFY_SYNC_TRANSPORT_TIMEOUT_MS)
+  })
+
+  it('never derives the transport deadline from the user-facing seconds value', () => {
+    const result = mapBlockParams({
+      operation: 'apify_run_actor_sync',
+      apiKey: 'k',
+      actorId: 'me/actor',
+      timeout: '3600',
+    })
+    expect(result.actorTimeout).toBe(3600)
+    expect(result.timeout).toBe(APIFY_SYNC_TRANSPORT_TIMEOUT_MS)
+    expect(result.timeout).not.toBe(3600)
+    expect(result.timeout).not.toBe(3_600_000)
+  })
+
+  it('leaves non-sync operations on no transport deadline', () => {
+    for (const operation of ['apify_run_actor_async', 'apify_get_run', 'apify_get_dataset_items']) {
+      const result = mapBlockParams({ operation, apiKey: 'k', actorId: 'a', runId: 'r' })
+      expect(Object.hasOwn(result, 'timeout')).toBe(true)
+      expect(result.timeout).toBeUndefined()
+    }
+  })
+})
+
+describe('apify explicit zero timeout', () => {
+  it('forwards timeout=0 (Apify: no timeout) on every run tool', () => {
+    expect(buildUrl(apifyRunActorSyncTool, { actorId: 'me/actor', actorTimeout: 0 })).toContain(
+      'timeout=0'
+    )
+    expect(buildUrl(apifyRunActorAsyncTool, { actorId: 'me/actor', actorTimeout: 0 })).toContain(
+      'timeout=0'
+    )
+    expect(buildUrl(apifyRunTaskTool, { taskId: 'me/task', taskTimeout: 0 })).toContain('timeout=0')
+  })
+
+  it('maps an explicit 0 subBlock value through the block mapper', () => {
+    for (const zero of ['0', 0]) {
+      expect(
+        mapBlockParams({
+          operation: 'apify_run_actor_sync',
+          apiKey: 'k',
+          actorId: 'me/actor',
+          timeout: zero,
+        }).actorTimeout
+      ).toBe(0)
+      expect(
+        mapBlockParams({
+          operation: 'apify_run_task',
+          apiKey: 'k',
+          taskId: 'me/task',
+          timeout: zero,
+        }).taskTimeout
+      ).toBe(0)
+    }
+  })
+
+  it('still drops an untouched (empty string) subBlock value', () => {
+    const result = mapBlockParams({
+      operation: 'apify_run_actor_sync',
+      apiKey: 'k',
+      actorId: 'me/actor',
+      timeout: '',
+    })
+    expect(result.actorTimeout).toBeUndefined()
+    expect(result.taskTimeout).toBeUndefined()
+  })
+})
+
+describe('apify run_actor_sync response contract', () => {
+  it('emits no fabricated run id — the sync endpoint returns none', async () => {
+    const result = await apifyRunActorSyncTool.transformResponse!(jsonResponse([{ a: 1 }]))
+    expect(Object.hasOwn(result.output, 'runId')).toBe(false)
+    expect(result.output.items).toEqual([{ a: 1 }])
+    expect(apifyRunActorSyncTool.outputs?.runId).toBeUndefined()
+  })
+
+  it('guards a non-array response body', async () => {
+    const result = await apifyRunActorSyncTool.transformResponse!(jsonResponse({ error: 'nope' }))
+    expect(result.output.items).toEqual([])
+  })
+})
+
+describe('apify run_actor_async polling', () => {
+  const fetchSpy = vi.fn(() => {
+    throw new Error('global fetch must not be used inside postProcess')
+  })
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.stubGlobal('fetch', fetchSpy)
+  })
+
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  function startedResult(): ToolResponse {
+    return {
+      success: true,
+      output: { success: true, runId: 'run-1', status: 'RUNNING' },
+    }
+  }
+
+  it('routes both follow-up requests through the guarded tool transport', async () => {
+    const executeTool = vi.fn(async (toolId: string) => {
+      if (toolId === 'apify_get_run') {
+        return {
+          success: true,
+          output: { success: true, runId: 'run-1', status: 'SUCCEEDED', datasetId: 'ds-1' },
+        }
+      }
+      return { success: true, output: { success: true, items: [{ a: 1 }], count: 1 } }
+    })
+
+    const result = await apifyRunActorAsyncTool.postProcess!(
+      startedResult() as any,
+      { apiKey: 'k', actorId: 'me/actor' } as any,
+      executeTool as any
+    )
+
+    expect(fetchSpy).not.toHaveBeenCalled()
+    expect(executeTool.mock.calls.map(([toolId]) => toolId)).toEqual([
+      'apify_get_run',
+      'apify_get_dataset_items',
+    ])
+    expect(result.output.items).toEqual([{ a: 1 }])
+    expect(result.output.status).toBe('SUCCEEDED')
+  })
+
+  it('checks the run status before paying the first poll interval', async () => {
+    const { sleep } = await import('@sim/utils/helpers')
+    const order: string[] = []
+    vi.mocked(sleep).mockImplementation(async () => {
+      order.push('sleep')
+    })
+    const executeTool = vi.fn(async () => {
+      order.push('status')
+      return {
+        success: true,
+        output: { success: true, runId: 'run-1', status: 'SUCCEEDED' },
+      }
+    })
+
+    await apifyRunActorAsyncTool.postProcess!(
+      startedResult() as any,
+      { apiKey: 'k', actorId: 'me/actor' } as any,
+      executeTool as any
+    )
+
+    expect(order[0]).toBe('status')
+    expect(order).not.toContain('sleep')
+  })
+
+  it('reports the real polling window rather than a hardcoded five minutes', async () => {
+    const executeTool = vi.fn(async () => ({
+      success: true,
+      output: { success: true, runId: 'run-1', status: 'RUNNING' },
+    }))
+
+    const result = await apifyRunActorAsyncTool.postProcess!(
+      startedResult() as any,
+      { apiKey: 'k', actorId: 'me/actor' } as any,
+      executeTool as any
+    )
+
+    expect(result.success).toBe(false)
+    expect(result.output.status).toBe('TIMEOUT')
+    expect(result.error).not.toContain('5 minutes')
+    expect(result.error).toContain(`${DEFAULT_EXECUTION_TIMEOUT_MS / 1000}s`)
+  })
+})