Function executeCode

packages/ai-isolate-cloudflare/src/worker/index.ts:87–203

* Execute code in a freshly loaded child Worker isolate.

(
  request: ExecuteRequest,
  env: Env,
)

 * Execute code in a freshly loaded child Worker isolate.
 */
async function executeCode(
  request: ExecuteRequest,
  env: Env,
): Promise<ExecuteResponse> {
  const { code, tools, toolResults, timeout = 30000 } = request

  if (!env.LOADER) {
    return {
      status: 'error',
      error: {
        name: 'WorkerLoaderNotAvailable',
        message:
          'LOADER binding is not available. ' +
          'This Worker requires the worker_loader (Dynamic Workers) binding. ' +
          'Declare it in wrangler.toml under [[worker_loaders]] with ' +
          'binding = "LOADER" (Workers Paid plan required).',
      },
    }
  }

  try {
    const wrappedCode = wrapCode(code, tools, toolResults)
    const moduleSource = wrapAsSandboxModule(wrappedCode)

    // AbortController propagates into the loaded Worker via Request.signal so
    // a timeout actually cancels the in-flight fetch instead of leaking the
    // child isolate. The Promise.race remains as a belt-and-suspenders guard
    // for runtimes that ignore the signal.
    const controller = new AbortController()
    let timeoutId: ReturnType<typeof setTimeout> | undefined
    const TIMEOUT_SENTINEL = '__SANDBOX_TIMEOUT__'
    const timeoutPromise = new Promise<never>((_resolve, reject) => {
      timeoutId = setTimeout(() => {
        controller.abort()
        reject(new Error(TIMEOUT_SENTINEL))
      }, timeout)
    })

    try {
      const loaded = env.LOADER.load({
        compatibilityDate: SANDBOX_COMPAT_DATE,
        mainModule: 'main.js',
        modules: { 'main.js': moduleSource },
        globalOutbound: null,
        env: {},
      })
      const entrypoint = loaded.getEntrypoint()
      const fetchPromise = entrypoint.fetch(
        new Request('https://sandbox.invalid/', { signal: controller.signal }),
      )
      const response = await Promise.race([fetchPromise, timeoutPromise])
      if (timeoutId) clearTimeout(timeoutId)

      const result: {
        status: string
        success?: boolean
        value?: unknown
        error?: { name: string; message: string; stack?: string }