@oar-sh/oar 0.9.0

package/server/grok-worker/acp-host-services.mjs

@@ -0,0 +1,277 @@
+/**
+ * Client-side ACP host services for the Grok worker: the `terminal/*` and
+ * `fs/*` request handlers backing the client capabilities advertised in
+ * `AcpClient.initialize()`.
+ *
+ * Advertising a capability is a contract to answer the agent's requests for
+ * it — an advertised-but-unanswered request deadlocks the agent's turn: it
+ * waits forever on the reply, streaming nothing further, while the worker
+ * process stays healthy and heartbeating (the 2026-08-12 stall, where a
+ * `terminal/create` went unanswered for 9 minutes until the user hit Stop).
+ * If a capability is dropped here, drop it from the initialize payload too.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+
+const DEFAULT_OUTPUT_BYTE_LIMIT = 1024 * 1024;
+const MAX_OUTPUT_BYTE_LIMIT = 8 * 1024 * 1024;
+// How long a running terminal's silence still counts as "the agent is
+// waiting on us" for the prompt watchdog. See hasPendingWork.
+const TERMINAL_ACTIVITY_WINDOW_MS = 5 * 60_000;
+
+function envArrayToObject(env) {
+  const out = {};
+  if (!Array.isArray(env)) return out;
+  for (const entry of env) {
+    const name = String(entry?.name || '').trim();
+    if (name) out[name] = String(entry?.value ?? '');
+  }
+  return out;
+}
+
+export function createAcpHostServices({
+  cwd = process.cwd(),
+  env = process.env,
+  platform = process.platform,
+  spawnImpl = spawn,
+  spawnSyncImpl = spawnSync,
+  fsImpl = fs,
+  dbg = () => {},
+} = {}) {
+  const terminals = new Map();
+  let nextTerminalId = 1;
+  let inflightRequests = 0;
+  let cachedWindowsShell = '';
+  let disposed = false;
+
+  // Grok emits PowerShell-flavored command lines on Windows hosts
+  // ("pwd; Get-Location"), so cmd.exe is not an option. Prefer pwsh (7+),
+  // fall back to Windows PowerShell.
+  function resolveWindowsShell() {
+    if (cachedWindowsShell) return cachedWindowsShell;
+    try {
+      const probe = spawnSyncImpl('pwsh', ['-NoProfile', '-Command', '$null'], {
+        windowsHide: true,
+        timeout: 10_000,
+        stdio: 'ignore',
+      });
+      cachedWindowsShell = probe && probe.status === 0 ? 'pwsh' : 'powershell';
+    } catch {
+      cachedWindowsShell = 'powershell';
+    }
+    return cachedWindowsShell;
+  }
+
+  function buildSpawnPlan(command, args) {
+    if (Array.isArray(args) && args.length) {
+      return { file: command, args: args.map((value) => String(value)) };
+    }
+    if (platform === 'win32') {
+      return {
+        file: resolveWindowsShell(),
+        args: ['-NoProfile', '-NonInteractive', '-Command', command],
+      };
+    }
+    const shell = String(env.SHELL || '').trim() || '/bin/sh';
+    return { file: shell, args: ['-c', command] };
+  }
+
+  function appendOutput(entry, chunk) {
+    const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk), 'utf8');
+    entry.lastActivityAt = Date.now();
+    entry.chunks.push(buf);
+    entry.byteLength += buf.length;
+    // ACP truncates from the start of the output: the most recent bytes win.
+    while (entry.byteLength > entry.outputByteLimit && entry.chunks.length) {
+      const head = entry.chunks[0];
+      const excess = entry.byteLength - entry.outputByteLimit;
+      if (head.length <= excess) {
+        entry.chunks.shift();
+        entry.byteLength -= head.length;
+      } else {
+        entry.chunks[0] = head.subarray(excess);
+        entry.byteLength -= excess;
+      }
+      entry.truncated = true;
+    }
+  }
+
+  function settleExit(entry, exitStatus) {
+    if (entry.exitStatus) return;
+    entry.exitStatus = exitStatus;
+    for (const resolve of entry.exitWaiters.splice(0)) resolve(exitStatus);
+  }
+
+  function getTerminal(terminalId) {
+    const entry = terminals.get(String(terminalId || ''));
+    if (!entry) throw new Error(`unknown terminalId: ${terminalId}`);
+    return entry;
+  }
+
+  async function terminalCreate(params = {}) {
+    if (disposed) throw new Error('host services disposed');
+    const command = String(params.command || '').trim();
+    if (!command) throw new Error('terminal/create requires a command');
+    const requestedLimit = Number(params.outputByteLimit);
+    const outputByteLimit = Number.isFinite(requestedLimit) && requestedLimit > 0
+      ? Math.min(Math.round(requestedLimit), MAX_OUTPUT_BYTE_LIMIT)
+      : DEFAULT_OUTPUT_BYTE_LIMIT;
+    const plan = buildSpawnPlan(command, params.args);
+    const proc = spawnImpl(plan.file, plan.args, {
+      cwd: String(params.cwd || '').trim() || cwd,
+      env: { ...env, ...envArrayToObject(params.env) },
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: true,
+      shell: false,
+    });
+    const terminalId = `term-${nextTerminalId++}`;
+    const entry = {
+      terminalId,
+      proc,
+      chunks: [],
+      byteLength: 0,
+      truncated: false,
+      outputByteLimit,
+      exitStatus: null,
+      exitWaiters: [],
+      lastActivityAt: Date.now(),
+    };
+    proc.stdout?.on('data', (chunk) => appendOutput(entry, chunk));
+    proc.stderr?.on('data', (chunk) => appendOutput(entry, chunk));
+    proc.on('error', (error) => {
+      // Spawn failures (ENOENT etc.) surface as output + a synthetic exit so
+      // the agent's wait_for_exit settles instead of hanging.
+      appendOutput(entry, `[terminal spawn error] ${error?.message || String(error)}\n`);
+      settleExit(entry, { exitCode: -1, signal: null });
+    });
+    proc.on('exit', (code, signal) => {
+      settleExit(entry, {
+        exitCode: Number.isInteger(code) ? code : null,
+        signal: signal || null,
+      });
+    });
+    terminals.set(terminalId, entry);
+    dbg('terminal/create', terminalId, command.slice(0, 160));
+    return { terminalId };
+  }
+
+  function terminalOutput(params = {}) {
+    const entry = getTerminal(params.terminalId);
+    return {
+      output: Buffer.concat(entry.chunks, entry.byteLength).toString('utf8'),
+      truncated: entry.truncated,
+      ...(entry.exitStatus ? { exitStatus: entry.exitStatus } : {}),
+    };
+  }
+
+  function terminalWaitForExit(params = {}) {
+    const entry = getTerminal(params.terminalId);
+    if (entry.exitStatus) return Promise.resolve(entry.exitStatus);
+    return new Promise((resolve) => entry.exitWaiters.push(resolve));
+  }
+
+  function killEntryProcess(entry) {
+    if (!entry.proc || entry.exitStatus) return;
+    try {
+      entry.proc.kill();
+    } catch { /* ignore */ }
+    if (platform === 'win32' && entry.proc.pid) {
+      // proc.kill() only reaches the shell; shells leave grandchildren behind.
+      try {
+        spawnImpl('taskkill', ['/pid', String(entry.proc.pid), '/t', '/f'], {
+          stdio: 'ignore',
+          windowsHide: true,
+        });
+      } catch { /* ignore */ }
+    }
+  }
+
+  function terminalKill(params = {}) {
+    killEntryProcess(getTerminal(params.terminalId));
+    return null;
+  }
+
+  function terminalRelease(params = {}) {
+    const entry = terminals.get(String(params?.terminalId || ''));
+    if (!entry) return null;
+    killEntryProcess(entry);
+    terminals.delete(entry.terminalId);
+    return null;
+  }
+
+  async function fsReadTextFile(params = {}) {
+    const filePath = String(params.path || '').trim();
+    if (!filePath) throw new Error('fs/read_text_file requires a path');
+    const content = await fsImpl.readFile(filePath, 'utf8');
+    const line = Number(params.line);
+    const limit = Number(params.limit);
+    const hasLine = Number.isFinite(line) && line > 0;
+    const hasLimit = Number.isFinite(limit) && limit > 0;
+    if (!hasLine && !hasLimit) return { content };
+    const lines = content.split('\n');
+    const start = hasLine ? line - 1 : 0;
+    const count = hasLimit ? limit : lines.length - start;
+    return { content: lines.slice(start, start + count).join('\n') };
+  }
+
+  async function fsWriteTextFile(params = {}) {
+    const filePath = String(params.path || '').trim();
+    if (!filePath) throw new Error('fs/write_text_file requires a path');
+    await fsImpl.writeFile(filePath, String(params.content ?? ''), 'utf8');
+    return null;
+  }
+
+  const handlers = {
+    'terminal/create': terminalCreate,
+    'terminal/output': terminalOutput,
+    'terminal/wait_for_exit': terminalWaitForExit,
+    'terminal/kill': terminalKill,
+    'terminal/release': terminalRelease,
+    'fs/read_text_file': fsReadTextFile,
+    'fs/write_text_file': fsWriteTextFile,
+  };
+
+  function attach(client) {
+    // wait_for_exit is a passive park, not active servicing: counting it as
+    // inflight would defer the stall watchdog forever for a process that
+    // never exits. Its pending-ness is represented by the unfinished
+    // terminal entry below instead.
+    const passiveWaits = new Set(['terminal/wait_for_exit']);
+    for (const [method, handler] of Object.entries(handlers)) {
+      const passive = passiveWaits.has(method);
+      client.setRequestHandler(method, async (params) => {
+        if (!passive) inflightRequests += 1;
+        try {
+          return await handler(params);
+        } finally {
+          if (!passive) inflightRequests -= 1;
+        }
+      });
+    }
+  }
+
+  /**
+   * True while the agent is legitimately waiting on us: a handler request is
+   * being serviced, or a terminal process is running AND recently active. A
+   * long-quiet background command (a dev server, a hung build) stops
+   * deferring the stall watchdog after the activity window — otherwise one
+   * `npm run dev` made every turn immune to stall detection forever.
+   */
+  function hasPendingWork() {
+    if (inflightRequests > 0) return true;
+    const now = Date.now();
+    for (const entry of terminals.values()) {
+      if (entry.exitStatus) continue;
+      if (now - entry.lastActivityAt <= TERMINAL_ACTIVITY_WINDOW_MS) return true;
+    }
+    return false;
+  }
+
+  function disposeAll() {
+    disposed = true;
+    for (const entry of terminals.values()) killEntryProcess(entry);
+    terminals.clear();
+  }
+
+  return { attach, hasPendingWork, disposeAll, handlers };
+}

package/server/grok-worker/grok-context-usage.mjs

@@ -0,0 +1,77 @@
+import { resolveFallbackContextLimitTokens } from '../../shared/context-window-fallbacks.mjs';
+/**
+ * Maps a normalized Grok turn usage blob (per-prompt `_meta` tokens from
+ * `normalizeGrokTurnUsage`) onto the payload shape the relay already persists
+ * for Claude/Cursor sessions, so the existing context view renders it
+ * unchanged. Mirrors `buildCursorContextUsage`.
+ *
+ * ACP reports no per-category breakdown, so `categories` is always empty.
+ */
+
+// Best-effort fallbacks when ACP model discovery reports no window size come
+// from the shared static table (shared/context-window-fallbacks.mjs), which
+// exists precisely so per-provider copies cannot drift. Unknown models get no
+// fill metric (token totals only, like Cursor's partial state).
+export function resolveGrokContextWindow(model = '', contextWindowsByModel = {}) {
+  const key = String(model || '').trim().toLowerCase();
+  if (!key) return null;
+  const discovered = Number(contextWindowsByModel?.[key]);
+  if (Number.isFinite(discovered) && discovered > 0) return Math.round(discovered);
+  return resolveFallbackContextLimitTokens(key);
+}
+
+function tokenCount(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
+}
+
+export function buildGrokContextUsage({ usage, model = '', contextWindow = null } = {}) {
+  if (!usage || typeof usage !== 'object') return null;
+
+  const inputTokens = tokenCount(usage.inputTokens);
+  const outputTokens = tokenCount(usage.outputTokens);
+  const cacheReadTokens = tokenCount(usage.cachedReadTokens);
+  const cacheWriteTokens = tokenCount(usage.cacheCreationTokens);
+  if (inputTokens === null && outputTokens === null
+    && cacheReadTokens === null && cacheWriteTokens === null) {
+    return null;
+  }
+
+  // Context occupancy approximates what the next request re-sends: fresh
+  // input + cache reads + cache writes + the reply. The blob's `totalTokens`
+  // may be cumulative across the turn's model calls, so it is not used.
+  const totalTokens = (inputTokens || 0) + (cacheReadTokens || 0)
+    + (cacheWriteTokens || 0) + (outputTokens || 0);
+  const maxTokens = (typeof contextWindow === 'number' && Number.isFinite(contextWindow)
+    && contextWindow > 0)
+    ? Math.round(contextWindow)
+    : null;
+
+  const contextUsage = {
+    model,
+    totalTokens,
+    ...(maxTokens !== null
+      ? { maxTokens, percentage: Math.round((totalTokens / maxTokens) * 10000) / 100 }
+      : {}),
+    categories: [],
+    apiUsage: {
+      input_tokens: inputTokens || 0,
+      output_tokens: outputTokens || 0,
+      cache_read_input_tokens: cacheReadTokens || 0,
+      cache_creation_input_tokens: cacheWriteTokens || 0,
+    },
+  };
+
+  const modelUsage = {
+    [model]: {
+      ...(maxTokens !== null ? { contextWindow: maxTokens } : {}),
+      inputTokens: inputTokens || 0,
+      outputTokens: outputTokens || 0,
+      cacheReadInputTokens: cacheReadTokens || 0,
+      cacheCreationInputTokens: cacheWriteTokens || 0,
+    },
+  };
+
+  return { contextUsage, modelUsage };
+}

package/server/grok-worker/grok-sdk-adapter.mjs

@@ -0,0 +1,334 @@
+/**
+ * Thin adapter around the Grok CLI ACP surface. One long-lived agent process
+ * per worker; sessions are created/loaded and prompts streamed via AcpClient.
+ */
+import { AcpClient, extractGrokModelsFromInitialize, pickAllowOnceOptionId } from './acp-client.mjs';
+import { createAcpHostServices } from './acp-host-services.mjs';
+import { createSdkMessageNormalizer } from './sdk-message-normalizer.mjs';
+
+export { extractGrokModelsFromInitialize };
+
+export function classifyGrokError(error) {
+  const message = String(error?.message || error || '').trim();
+  const lower = message.toLowerCase();
+  // No bare 'auth' token: it would match unrelated words ("author…") in
+  // arbitrary agent error text and misclassify them as login failures.
+  if (
+    lower.includes('authentication')
+    || lower.includes('not logged in')
+    || lower.includes('not authenticated')
+    || lower.includes('unauthorized')
+    || lower.includes('api key')
+  ) {
+    return {
+      code: 'grok.authentication_failed',
+      // Points at the relay's own UI, which renders a Sign in button for this
+      // stable code (relay-error-ctas.mjs); the host-shell advice stays as the
+      // fallback for anyone reading this outside a browser.
+      message: 'Grok authentication failed. Sign in from Settings → Providers → Grok, '
+        + 'or run `grok login` on the relay host / set XAI_API_KEY.',
+      isAuth: true,
+      isBusy: false,
+    };
+  }
+  if (lower.includes('already has an active') || lower.includes('busy')) {
+    return {
+      code: 'grok.agent_busy',
+      message: message || 'Grok agent is busy',
+      isAuth: false,
+      isBusy: true,
+    };
+  }
+  // Watchdog trips from AcpClient.sessionPrompt (inactivity or turn ceiling).
+  if (lower.includes('turn stalled') || lower.includes('turn exceeded')) {
+    return {
+      code: 'grok.turn-stalled',
+      message: message || 'Grok turn stalled',
+      isAuth: false,
+      isBusy: false,
+      isStalled: true,
+    };
+  }
+  if (lower.includes('enoent') || lower.includes('not found') || lower.includes('spawn')) {
+    return {
+      code: 'grok.cli_missing',
+      // The dead end this plan exists for: the only fix used to be a shell on
+      // the host. The relay now installs it, and this stable code renders an
+      // Install button (relay-error-ctas.mjs).
+      message: 'Grok CLI was not found on PATH. Install it from Settings → Providers → Grok.',
+      isAuth: false,
+      isBusy: false,
+    };
+  }
+  return {
+    code: 'grok.turn-error',
+    message: message || 'Grok turn failed',
+    isAuth: false,
+    isBusy: false,
+  };
+}
+
+/**
+ * Create or resume a Grok ACP session handle for one conversation worker.
+ */
+export async function createGrokAgentHandle({
+  command = 'grok',
+  args = ['agent', '--no-leader', 'stdio'],
+  cwd = process.cwd(),
+  env = process.env,
+  alwaysApprove = true,
+  nativeSessionId = '',
+  model = '',
+  AcpClientImpl = AcpClient,
+  createHostServicesImpl = createAcpHostServices,
+  dbg = () => {},
+} = {}) {
+  const client = new AcpClientImpl({
+    command,
+    args,
+    cwd,
+    env,
+    alwaysApprove,
+  });
+
+  // Without any 'error' listener, a spawn failure (ENOENT when the Grok CLI
+  // is not installed) would make the emitter throw ERR_UNHANDLED_ERROR and
+  // crash the process. The pending-request rejection already surfaces the
+  // failure to the awaiting caller, so the listener only needs to exist.
+  client.on('error', () => {});
+
+  client.on('stderr', (text) => {
+    const line = String(text || '').trim();
+    if (line) dbg('grok stderr', line.slice(0, 400));
+  });
+
+  // The terminal/fs handlers backing the capabilities initialize() advertises.
+  // They must be attached before the first prompt, or the agent's first shell
+  // command deadlocks the turn waiting on terminal/create.
+  const hostServices = createHostServicesImpl({ cwd, env, dbg });
+  hostServices.attach(client);
+
+  await client.initialize();
+  const discovered = extractGrokModelsFromInitialize(client.initializeResult);
+
+  let sessionId = '';
+  let resumeFailed = false;
+  const resumeId = String(nativeSessionId || '').trim();
+  if (resumeId) {
+    // Attempting session/load against an agent that never advertised the
+    // capability is a guaranteed failure; either way a fresh session is a
+    // silent history loss the caller must be able to surface.
+    const capabilities = client.initializeResult?.agentCapabilities
+      || client.initializeResult?.capabilities
+      || {};
+    const supportsLoad = capabilities.loadSession === true || capabilities.load_session === true;
+    if (!supportsLoad) {
+      resumeFailed = true;
+      dbg('grok agent does not advertise loadSession; starting fresh');
+    } else {
+      try {
+        const loaded = await client.sessionLoad(resumeId, cwd);
+        sessionId = String(loaded?.sessionId || loaded?.session_id || resumeId).trim();
+      } catch (error) {
+        resumeFailed = true;
+        dbg('grok session/load failed, creating new session', error?.message || String(error));
+      }
+    }
+  }
+  if (!sessionId) {
+    const extra = {};
+    const modelId = String(model || '').trim();
+    if (modelId) {
+      // Best-effort: some Grok builds accept model via _meta on session/new.
+      extra._meta = { modelId };
+    }
+    const created = await client.sessionNew(cwd, extra);
+    sessionId = String(created?.sessionId || created?.session_id || '').trim();
+  }
+  if (!sessionId) {
+    hostServices.disposeAll();
+    await client.dispose();
+    throw new Error('Grok session/new did not return sessionId');
+  }
+
+  return {
+    client,
+    sessionId,
+    model: String(model || discovered.defaultModel || '').trim(),
+    discovered,
+    hostServices,
+    resumeFailed,
+    async close() {
+      hostServices.disposeAll();
+      await client.dispose();
+    },
+  };
+}
+
+/**
+ * Stream-friendly turn starter used by the turn runner. Yields the same
+ * channel actions the normalizer produces, draining pending actions interleaved
+ * by polling a queue that the ACP update handler fills.
+ */
+export function startGrokTurn({
+  handle,
+  text = '',
+  reasoningEffort = '',
+  abortSignal = null,
+  watchdog = null,
+  createNormalizerImpl = createSdkMessageNormalizer,
+  dbg = () => {},
+} = {}) {
+  if (!handle?.client || !handle?.sessionId) {
+    throw new Error('missing grok agent handle');
+  }
+
+  const normalizer = createNormalizerImpl();
+  const queue = [];
+  let done = false;
+  let settleError = null;
+  let resolveWait = null;
+
+  function wake() {
+    if (resolveWait) {
+      const r = resolveWait;
+      resolveWait = null;
+      r();
+    }
+  }
+
+  function enqueue(action) {
+    queue.push(action);
+    wake();
+  }
+
+  enqueue({
+    channel: 'init',
+    payload: {
+      sessionId: handle.sessionId,
+      model: handle.model || '',
+    },
+  });
+
+  let cancelled = false;
+  const onAbort = () => {
+    cancelled = true;
+    try {
+      handle.client.sessionCancel(handle.sessionId);
+    } catch (error) {
+      dbg('session/cancel failed', error?.message || String(error));
+    }
+  };
+  if (abortSignal) {
+    if (abortSignal.aborted) onAbort();
+    else abortSignal.addEventListener('abort', onAbort, { once: true });
+  }
+
+  const onPermission = (msg) => {
+    // Prefer a one-shot allow: a blanket "allow always" would grant more than
+    // the relay's per-request approval parity intends.
+    const optionId = pickAllowOnceOptionId(msg?.params?.options);
+    try {
+      handle.client.respond(msg.id, {
+        outcome: { outcome: 'selected', optionId },
+      });
+    } catch (error) {
+      dbg('permission respond failed', error?.message || String(error));
+    }
+  };
+  handle.client.on('permission', onPermission);
+
+  // Best-effort per-turn reasoning effort: forwarded on the prompt `_meta`
+  // the same way the model is passed on session/new. Unknown _meta keys are
+  // ignored by agent builds that do not support them.
+  const effort = String(reasoningEffort || '').trim().toLowerCase();
+  const promptExtra = effort && effort !== 'none'
+    ? { _meta: { reasoningEffort: effort } }
+    : {};
+
+  const promptPromise = handle.client.sessionPrompt(
+    handle.sessionId,
+    [{ type: 'text', text: String(text || '') }],
+    (update) => {
+      for (const action of normalizer.normalizeAcpUpdate(update)) {
+        enqueue(action);
+      }
+    },
+    promptExtra,
+    {
+      // A running client-hosted terminal (or an in-flight terminal/fs request)
+      // means the agent is waiting on us, not stalled.
+      hasPendingWork: () => handle.hostServices?.hasPendingWork?.() === true,
+      ...(watchdog || {}),
+    },
+  ).then((promptResult) => {
+    const stopReason = String(promptResult?.stopReason || promptResult?.stop_reason || '').trim();
+    const isError = stopReason.toLowerCase() === 'error' || promptResult?.isError === true;
+    // Per-prompt usage lives on the result `_meta` (tokens + costUsdTicks).
+    // Prefer that over any mid-stream usage_update the normalizer may have seen.
+    const meta = promptResult?._meta && typeof promptResult._meta === 'object'
+      ? promptResult._meta
+      : null;
+    const usage = meta
+      ? {
+        ...meta,
+        usage: meta.usage,
+        modelId: meta.modelId || handle.model || '',
+      }
+      : null;
+    for (const action of normalizer.finalizeResult({
+      stopReason: cancelled ? 'cancelled' : stopReason,
+      text: normalizer.finalStreamText(),
+      isError: cancelled ? false : isError,
+      errorMessage: isError ? String(promptResult?.error || promptResult?.message || stopReason) : '',
+      model: String(meta?.modelId || handle.model || '').trim(),
+      usage,
+    })) {
+      enqueue(action);
+    }
+  }).catch((error) => {
+    if (cancelled || abortSignal?.aborted) {
+      for (const action of normalizer.finalizeResult({
+        stopReason: 'cancelled',
+        text: normalizer.finalStreamText(),
+      })) {
+        enqueue(action);
+      }
+      return;
+    }
+    settleError = error;
+  }).finally(() => {
+    done = true;
+    wake();
+    handle.client.off('permission', onPermission);
+    if (abortSignal) {
+      try {
+        abortSignal.removeEventListener('abort', onAbort);
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+
+  async function* iterator() {
+    while (true) {
+      while (queue.length) {
+        yield queue.shift();
+      }
+      if (done) {
+        if (settleError) throw settleError;
+        return;
+      }
+      await new Promise((resolve) => {
+        resolveWait = resolve;
+      });
+    }
+  }
+
+  const iter = iterator();
+  iter.cancel = async () => {
+    onAbort();
+    await promptPromise.catch(() => {});
+  };
+  return iter;
+}