Function evaluateInQuickJs

packages/kernel/runtime-quickjs/src/index.ts:417–528

(
  options: QuickJsExecutorOptions,
  code: string,
  toolInvoker: SandboxToolInvoker,
  runPromise: RunPromise,
)

};

const evaluateInQuickJs = async (
  options: QuickJsExecutorOptions,
  code: string,
  toolInvoker: SandboxToolInvoker,
  runPromise: RunPromise,
): Promise<ExecuteResult> => {
  const timeoutMs = Math.max(100, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
  const deadline = makeDeadlineTracker(timeoutMs);
  const logs: string[] = [];
  const pendingDeferreds = new Set<QuickJSDeferredPromise>();
  const QuickJS = await resolveQuickJS();
  const runtime = QuickJS.newRuntime();

  try {
    runtime.setMemoryLimit(options.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES);
    runtime.setMaxStackSize(options.maxStackSizeBytes ?? DEFAULT_MAX_STACK_SIZE_BYTES);

    runtime.setInterruptHandler(shouldInterruptAfterDeadline(deadline));

    const context = runtime.newContext();
    try {
      const logBridge = createLogBridge(context, logs);
      context.setProp(context.global, "__executor_log", logBridge);
      logBridge.dispose();

      const toolBridge = createToolBridge(
        context,
        toolInvoker,
        pendingDeferreds,
        runPromise,
        deadline,
      );
      context.setProp(context.global, "__executor_invokeTool", toolBridge);
      toolBridge.dispose();

      const evaluated = context.evalCode(buildExecutionSource(code), EXECUTION_FILENAME);
      if (evaluated.error) {
        const error = context.dump(evaluated.error);
        evaluated.error.dispose();
        return {
          result: null,
          error: normalizeExecutionError(error, deadline, timeoutMs),
          logs,
        } satisfies ExecuteResult;
      }

      context.setProp(context.global, "__executor_result", evaluated.value);
      evaluated.value.dispose();

      const stateResult = context.evalCode(
        "(function(p){ var s = { v: void 0, e: void 0, settled: false }; var formatError = function(e){ if (e && typeof e === 'object') { var message = typeof e.message === 'string' ? e.message : ''; var stack = typeof e.stack === 'string' ? e.stack : ''; if (message && stack) { return stack.indexOf(message) === -1 ? message + '\\n' + stack : stack; } if (message) return message; if (stack) return stack; } return String(e); }; p.then(function(v){ s.v = v; s.settled = true; }, function(e){ s.e = formatError(e); s.settled = true; }); return s; })(__executor_result)",
      );
      if (stateResult.error) {
        const error = context.dump(stateResult.error);
        stateResult.error.dispose();
        return {
          result: null,
          error: normalizeExecutionError(error, deadline, timeoutMs),