@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/plugins/providers/desktop-host.mjs

@@ -0,0 +1,63 @@
+import { clientRequestSchema } from '@deepseek-ai/dsh-client-connection';
+import { assertUsableApiKey } from '@deepseek-ai/dsh-llm';
+
+const keyRef = 'OPENROUTER_API_KEY';
+const facts = value => ({ configured: value?.configured === true, writable: value?.writable === true, source: value?.source });
+
+/** A fixed account surface; clients cannot choose arbitrary credential references. */
+export async function providerAccountRequest(ctx, payload) {
+  const credentials = ctx.get('credentials'), login = ctx.get('dscodeOpenCodeLogin');
+  if (!credentials || !login) throw Error('DSCODE accounts are unavailable.');
+  let notice;
+  switch (payload?.action) {
+    case 'status': break;
+    case 'save-openrouter': {
+      if ((await credentials.describe(keyRef)).writable !== true) throw Error('OpenRouter credentials are controlled by the launching environment.');
+      if (typeof payload.key !== 'string' || payload.key.length > 4096) throw Error('Invalid API key.');
+      const key = assertUsableApiKey(payload.key.trim(), 'DSCODE OpenRouter', keyRef);
+      await credentials.set(keyRef, key);
+      notice = 'OpenRouter key saved. Select a model under DSCODE OpenRouter.';
+      break;
+    }
+    case 'remove-openrouter':
+      if ((await credentials.describe(keyRef)).writable !== true) throw Error('OpenRouter credentials are controlled by the launching environment.');
+      await credentials.unset(keyRef); notice = 'Saved OpenRouter key removed.'; break;
+    case 'login-opencode': {
+      const result = await login.login('en');
+      if (!result.ok) throw Error(result.lines.join('\n'));
+      notice = result.lines.join('\n');
+      break;
+    }
+    case 'cancel-opencode': notice = login.cancel('en'); break;
+    case 'logout-opencode': notice = await login.logout('en'); break;
+    default: throw Error('Unknown DSCODE account action.');
+  }
+  return {
+    openrouter: facts(await credentials.describe(keyRef)),
+    grok: facts(await credentials.describe('GROK_CLI_TOKEN')),
+    opencode: { ...facts(await credentials.describe('OPENCODE_OAUTH')), pending: login.attempt !== undefined, lines: await login.status('en') },
+    ...(notice ? { notice } : {}),
+  };
+}
+
+export function apply(ctx) {
+  ctx.inject(['connection'], scope => {
+    scope.effect(() => scope.connection.fetch.register({ path: '/api/dscode-accounts', methods: ['POST'], requestBody: 'buffered',
+      fetch: async request => {
+        let body;
+        try { body = await request.json(); } catch { return new Response('Invalid JSON', { status: 400 }); }
+        const parsed = clientRequestSchema.safeParse(body);
+        if (!parsed.success || parsed.data.method !== 'dscode-accounts') return new Response('Invalid account request', { status: 400 });
+        const { rpcId, payload } = parsed.data;
+        let result;
+        try { result = { ok: true, value: await providerAccountRequest(ctx, payload) }; }
+        catch (error) {
+          const secret = typeof payload?.key === 'string' ? payload.key.trim() : '';
+          const message = String(error.message ?? 'Account request failed.');
+          result = { ok: false, error: { code: 'dscode-accounts', message: secret ? message.replaceAll(secret, '[redacted]') : message, details: {} } };
+        }
+        return Response.json({ type: 'server-response', rpcId, result }, { headers: { 'Cache-Control': 'no-store' } });
+      },
+    }), 'dscode-accounts.rpc');
+  }).then(undefined, error => { ctx.logger.error(`Account transport failed: ${error.message}`); });
+}

package/plugins/providers/effort.mjs

@@ -0,0 +1,35 @@
+// Reasoning levels differ per model: DeepSeek offers low/high/max, GPT models
+// minimal through high, and many OpenRouter models none at all. Auxiliary calls
+// name the level they would like and send the nearest one the model offers, or no
+// effort when the model offers no levels.
+
+/** Standard reasoning levels, lowest first. */
+export const EFFORT_LEVELS = Object.freeze(['minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+
+/**
+ * The level to request from a model.
+ * @param offered - the model's effort ids, or `undefined` when its capability is unknown.
+ * @param wanted - the level the caller would like.
+ * @returns `wanted` when offered or when the capability is unknown; otherwise the nearest
+ *   offered level at or above it, else the highest below; `undefined` when the model offers
+ *   no standard level.
+ */
+export function chooseEffort(offered, wanted) {
+  if (wanted === undefined || offered === undefined || offered.includes(wanted)) return wanted;
+  const rank = EFFORT_LEVELS.indexOf(wanted);
+  const levels = EFFORT_LEVELS.filter(level => offered.includes(level));
+  if (rank < 0 || levels.length === 0) return undefined;
+  return levels.find(level => EFFORT_LEVELS.indexOf(level) >= rank) ?? levels.at(-1);
+}
+
+/**
+ * {@link chooseEffort} for a route, reading the model's levels from the LLM service.
+ * A service without model metadata, or a failed lookup, keeps `wanted`.
+ */
+export async function effortFor(llm, route, wanted, signal) {
+  if (wanted === undefined || typeof llm?.resolveModelInfo !== 'function' || !route?.provider || !route?.model) return wanted;
+  let info;
+  try { info = await llm.resolveModelInfo(route.provider, route.model, signal); }
+  catch { return wanted; }
+  return chooseEffort(info?.reasoning?.efforts?.map(effort => effort.id) ?? [], wanted);
+}

package/plugins/providers/http-errors.mjs

@@ -0,0 +1,50 @@
+import { CONTEXT_WINDOW_EXCEEDED_CODE, QUOTA_EXCEEDED_CODE, isContextWindowExceededError, isQuotaExceededError } from '@deepseek-ai/dsh-llm';
+
+// OpenRouter's typed `metadata.error_type`, which it asks clients to route on before the status.
+const ERROR_TYPES = Object.freeze({
+  context_length_exceeded: CONTEXT_WINDOW_EXCEEDED_CODE, token_limit_exceeded: CONTEXT_WINDOW_EXCEEDED_CODE,
+  payment_required: QUOTA_EXCEEDED_CODE, authentication: 'AUTH', permission_denied: 'AUTH',
+  rate_limit_exceeded: 'RATE_LIMIT', provider_overloaded: 'SERVER', provider_unavailable: 'SERVER', server: 'SERVER', unmapped: 'SERVER',
+  timeout: 'TIMEOUT', content_policy_violation: 'CONTENT_POLICY', refusal: 'CONTENT_POLICY',
+});
+
+/**
+ * Harness failure code for an OpenRouter error.
+ * @param status - HTTP status of a rejected request, or undefined for an error inside a 200 stream.
+ * @param error - the `error` object (`code`, `message`, `metadata`).
+ */
+export function errorCode(status, error) {
+  const type = error?.metadata?.error_type;
+  if (typeof type === 'string' && Object.hasOwn(ERROR_TYPES, type)) return ERROR_TYPES[type];
+  const code = Number.isInteger(status) ? status : Number(error?.code);
+  // A 402 names token counts ("fewer max_tokens"); its status decides before any wording does.
+  if (code === 402) return QUOTA_EXCEEDED_CODE;
+  // OpenRouter can reject a replay before generation without typed metadata.
+  // Keep this narrow: an ordinary permission-denied 403 still means AUTH.
+  if (code === 403 && typeof error?.message === 'string' && /^Request blocked by content filter\b/i.test(error.message)) return 'CONTENT_POLICY';
+  const detail = [error?.message, error?.metadata?.raw].filter(value => typeof value === 'string').join(' ');
+  if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
+  if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;
+  if (code === 401 || code === 403) return 'AUTH';
+  if (code === 429) return 'RATE_LIMIT';
+  if (code === 408 || code === 504) return 'TIMEOUT';
+  if (code >= 500) return 'SERVER';
+  if (code >= 400) return 'INVALID_REQUEST';
+  // A stream that failed after its 200 without a numeric code is an upstream failure worth retrying.
+  return 'SERVER';
+}
+
+/** Human-readable message for an OpenRouter error object. */
+export function errorMessage(error, fallback) {
+  const message = typeof error?.message === 'string' && error.message.length > 0 ? error.message : fallback;
+  const provider = error?.metadata?.provider_name;
+  return typeof provider === 'string' && provider.length > 0 ? `${message} (provider: ${provider})` : message;
+}
+
+/** Retry-After as milliseconds (seconds or an HTTP date), when valid. */
+export function retryAfterMs(value) {
+  if (value === null || value === undefined) return undefined;
+  const delay = /^\d+$/.test(value) ? Number(value) * 1e3 : Date.parse(value) - Date.now();
+  return Number.isFinite(delay) && delay > 0 ? delay : undefined;
+}
+

package/plugins/providers/openrouter-account.mjs

@@ -0,0 +1,171 @@
+// OpenRouter account facts for /openrouter and the footer balance. The inference key
+// reads the account credits and its own limit and usage; an optional management key,
+// which cannot call models, adds every key's usage and the last 30 days of spend.
+// This directory also ships beside the TUI, so the module imports nothing.
+export const OPENROUTER_API = 'https://openrouter.ai/api/v1';
+export const MANAGEMENT_REF = 'OPENROUTER_MANAGEMENT_KEY';
+
+const finite = value => {
+  const number = Number(value);
+  return value !== null && value !== undefined && value !== '' && Number.isFinite(number) ? number : undefined;
+};
+
+export class OpenRouterAccountError extends Error {
+  constructor(message, status) {
+    super(message);
+    this.name = 'OpenRouterAccountError';
+    this.status = status;
+  }
+}
+
+async function get(path, key, { fetch: fetchImpl = globalThis.fetch, signal } = {}) {
+  let response;
+  try {
+    response = await fetchImpl(`${OPENROUTER_API}${path}`, { headers: { authorization: `Bearer ${key}`, accept: 'application/json' }, signal });
+  } catch (error) {
+    throw new OpenRouterAccountError(`OpenRouter is unreachable: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  let body;
+  try { body = await response.json(); } catch { body = undefined; }
+  if (!response.ok) throw new OpenRouterAccountError(typeof body?.error?.message === 'string' ? body.error.message : `HTTP ${response.status}`, response.status);
+  return body;
+}
+
+/** Account credits from a `/credits` body, or undefined when it carries none. */
+export function creditsOf(body) {
+  const total = finite(body?.data?.total_credits), used = finite(body?.data?.total_usage);
+  if (total === undefined || used === undefined || total < 0 || used < 0) return undefined;
+  return { total, used, remaining: Math.max(0, total - used) };
+}
+
+/** Remaining USD account credits from a `/credits` body: purchased minus used. */
+export function parseOpenRouterCredits(body) {
+  return creditsOf(body)?.remaining ?? null;
+}
+
+/** Remaining USD credit limit from a `/key` body; null when the key has no limit. */
+export function parseOpenRouterKeyRemaining(body) {
+  const remaining = body?.data?.limit_remaining;
+  if (remaining == null) return null;
+  const value = Number(remaining);
+  return Number.isFinite(value) ? Math.max(0, value) : null;
+}
+
+function keyOf(raw) {
+  return {
+    label: typeof raw?.label === 'string' ? raw.label : undefined,
+    name: typeof raw?.name === 'string' && raw.name.length > 0 ? raw.name : undefined,
+    disabled: raw?.disabled === true,
+    limit: finite(raw?.limit),
+    limitRemaining: finite(raw?.limit_remaining),
+    usage: finite(raw?.usage),
+    usageDaily: finite(raw?.usage_daily),
+    usageWeekly: finite(raw?.usage_weekly),
+    usageMonthly: finite(raw?.usage_monthly),
+  };
+}
+
+/**
+ * Verify a management key before it is stored. Account activity is the reading OpenRouter
+ * refuses an inference key; `/credits`, though documented as management-only, serves both.
+ * @throws OpenRouterAccountError with a message fit for the key prompt.
+ */
+export async function verifyManagementKey(key, options) {
+  try {
+    await get('/activity', key, options);
+  } catch (error) {
+    if (error instanceof OpenRouterAccountError && (error.status === 401 || error.status === 403)) {
+      throw new OpenRouterAccountError('This is not a management key: OpenRouter refused it for account data. Create one under Settings → Management keys.', error.status);
+    }
+    throw error;
+  }
+}
+
+/** The `/activity` rows (last 30 completed UTC days) as totals and the top models with the providers that served them. */
+export function summarizeActivity(rows, top = 5) {
+  const models = new Map(), days = new Set();
+  let usage = 0, requests = 0;
+  for (const row of Array.isArray(rows) ? rows : []) {
+    if (typeof row?.model !== 'string') continue;
+    const cost = finite(row.usage) ?? 0, count = finite(row.requests) ?? 0;
+    usage += cost;
+    requests += count;
+    if (typeof row.date === 'string') days.add(row.date);
+    const entry = models.get(row.model) ?? { model: row.model, usage: 0, requests: 0, providers: new Map() };
+    entry.usage += cost;
+    entry.requests += count;
+    const name = typeof row.provider_name === 'string' && row.provider_name.length > 0 ? row.provider_name : 'unknown';
+    const served = entry.providers.get(name) ?? { name, usage: 0, requests: 0 };
+    served.usage += cost;
+    served.requests += count;
+    entry.providers.set(name, served);
+    models.set(row.model, entry);
+  }
+  const ranked = [...models.values()].sort((left, right) => right.usage - left.usage || right.requests - left.requests).slice(0, top)
+    .map(entry => ({ ...entry, providers: [...entry.providers.values()].sort((left, right) => right.usage - left.usage) }));
+  return { usage, requests, days: days.size, modelCount: models.size, models: ranked };
+}
+
+/**
+ * Everything /openrouter shows. Each section settles on its own: `{ value }`, `{ error }`,
+ * or undefined when the key it needs is missing.
+ */
+export async function loadOpenRouterAccount({ apiKey, managementKey, fetch, signal } = {}) {
+  const options = { fetch, signal };
+  const section = (key, run) => key ? run().then(value => ({ value }), error => ({ error: error instanceof Error ? error.message : String(error) })) : Promise.resolve(undefined);
+  const [key, credits, keys, activity] = await Promise.all([
+    section(apiKey, async () => keyOf((await get('/key', apiKey, options))?.data)),
+    section(managementKey ?? apiKey, async () => {
+      const credits = creditsOf(await get('/credits', managementKey ?? apiKey, options));
+      if (!credits) throw new Error('OpenRouter returned no account credits');
+      return credits;
+    }),
+    section(managementKey, async () => {
+      const body = await get('/keys', managementKey, options);
+      return (Array.isArray(body?.data) ? body.data : []).map(keyOf);
+    }),
+    section(managementKey, async () => summarizeActivity((await get('/activity', managementKey, options))?.data)),
+  ]);
+  return { hasApiKey: Boolean(apiKey), hasManagementKey: Boolean(managementKey), key, credits, keys, activity };
+}
+
+const money = value => Number.isFinite(value) ? `$${value.toFixed(2)}` : '$--';
+const limitText = key => key.limit === undefined ? 'no limit' : `limit ${money(key.limit)}, ${money(key.limitRemaining)} left`;
+
+/**
+ * The panel's lines for a loaded account.
+ * @returns `{ text, tone }` rows; tone is `title`, `value`, `dim` or `error`.
+ */
+export function openRouterAccountLines(account, { maxKeys = 5 } = {}) {
+  const lines = [];
+  const push = (text, tone = 'value') => lines.push({ text, tone });
+  if (!account.hasApiKey) push('No OpenRouter API key: run /login openrouter.', 'error');
+  if (account.credits?.value) {
+    const { remaining, total, used } = account.credits.value;
+    push(`Account balance  ${money(remaining)} · credits ${money(total)} · used ${money(used)}`, 'title');
+  } else if (account.credits?.error) push(`Account balance unavailable: ${account.credits.error}`, 'error');
+  else push('Account balance  $--', 'dim');
+  if (account.key?.value) {
+    const key = account.key.value;
+    push(`This key  ${key.label ?? 'unnamed'} · ${limitText(key)}`, 'title');
+    push(`  today ${money(key.usageDaily)} · week ${money(key.usageWeekly)} · month ${money(key.usageMonthly)}`, 'dim');
+  } else if (account.key?.error) push(`This key unavailable: ${account.key.error}`, 'error');
+  if (!account.hasManagementKey) push('API keys and 30-day spend  press m to add a management key', 'dim');
+  if (account.keys?.value) {
+    const keys = [...account.keys.value].sort((left, right) => (right.usageMonthly ?? 0) - (left.usageMonthly ?? 0));
+    push(`API keys (${keys.length})`, 'title');
+    for (const key of keys.slice(0, maxKeys)) {
+      const current = account.key?.value?.label !== undefined && key.label === account.key.value.label;
+      push(`  ${key.name ?? key.label ?? 'unnamed'}${current ? ' (this key)' : ''}${key.disabled ? ' · disabled' : ''} · today ${money(key.usageDaily)} · month ${money(key.usageMonthly)} · ${limitText(key)}`, key.disabled ? 'dim' : 'value');
+    }
+    if (keys.length > maxKeys) push(`  +${keys.length - maxKeys} more`, 'dim');
+  } else if (account.keys?.error) push(`API keys unavailable: ${account.keys.error}`, 'error');
+  if (account.activity?.value) {
+    const activity = account.activity.value;
+    push(`Last 30 days  ${money(activity.usage)} · ${activity.requests} requests · ${activity.modelCount} models`, 'title');
+    for (const model of activity.models) {
+      push(`  ${model.model} · ${money(model.usage)} · ${model.requests} req · ${model.providers.map(provider => `${provider.name} ${money(provider.usage)}`).join(', ')}`);
+    }
+  } else if (account.activity?.error) push(`Activity unavailable: ${account.activity.error}`, 'error');
+  return lines;
+}

package/plugins/session-bridge/client.mjs

@@ -0,0 +1,106 @@
+import { createConnection } from 'node:net';
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { socketDirectory } from './paths.mjs';
+
+export const CLIENT_COMMANDS = ['sessions', 'send', 'reply', 'read', 'watch', 'mailbox', 'watch-mailbox', 'cancel', 'new-task'];
+export async function* exchange(path, request, { signal } = {}) {
+  const socket = createConnection({ path });
+  socket.setEncoding('utf8');
+  socket.setTimeout(10000, () => socket.destroy(Error('DSCODE endpoint timed out')));
+  const abort = () => socket.destroy();
+  signal?.addEventListener('abort', abort, { once: true });
+  try {
+    signal?.throwIfAborted();
+    socket.write(JSON.stringify(request) + '\n');
+    let buffer = '';
+    for await (const chunk of socket) {
+      buffer += chunk;
+      if (Buffer.byteLength(buffer) > 16 * 1024 * 1024) throw Error('DSCODE response exceeds limit');
+      let index;
+      while ((index = buffer.indexOf('\n')) >= 0) {
+        const value = JSON.parse(buffer.slice(0, index)); buffer = buffer.slice(index + 1);
+        if (value.error) throw Object.assign(Error(value.error), { code: value.code });
+        if (value.type === 'ready') socket.setTimeout(0);
+        yield value;
+      }
+    }
+    if (buffer.trim()) throw Error('Incomplete DSCODE response; retry with the same requestId/cursor');
+  } finally { signal?.removeEventListener('abort', abort); socket.destroy(); }
+}
+export async function request(path, payload) {
+  for await (const value of exchange(path, payload)) return value.result;
+  throw Error('DSCODE connection closed before acknowledgement; retry with the same requestId');
+}
+export async function discover(home) {
+  let directory;
+  try { directory = socketDirectory(home); } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  const endpoints = readdirSync(directory).filter(n => /^\d+-[a-f0-9]{8}\.sock$/.test(n));
+  const results = await Promise.all(endpoints.map(async name => {
+    const path = join(directory, name);
+    try { return (await request(path, { method: 'list' })).map(session => ({ ...session, socket: path })); }
+    catch (error) { if (['ECONNREFUSED', 'ENOENT'].includes(error.code)) return []; throw error; }
+  }));
+  return results.flat();
+}
+export function resolveSession(sessions, id) {
+  const exact = sessions.filter(s => s.id === id);
+  const matches = exact.length ? exact : sessions.filter(s => s.id.startsWith(id));
+  if (matches.length !== 1) throw Error(matches.length ? 'Ambiguous session; use its complete ID' : 'No active session found. Run dscode sessions or open the session in dscode first.');
+  return matches[0];
+}
+export function parseClientArgs(argv) {
+  const [command, ...args] = argv;
+  const result = { command, mode: 'queue', source: 'cli', after: command.includes('mailbox') ? 0 : -1, limit: 100, requestId: randomUUID() };
+  if (!CLIENT_COMMANDS.includes(command)) throw Error('Unknown session command');
+  if (command !== 'sessions') { result.sessionId = args.shift(); if (!result.sessionId || result.sessionId.startsWith('-')) throw Error(`Usage: dscode ${command} SESSION_ID`); }
+  const text = []; let modeSet = false;
+  while (args.length) {
+    const arg = args.shift();
+    if (arg === '--') { text.push(...args); break; }
+    if (['--steer', '--defer'].includes(arg) && ['send', 'reply'].includes(command)) {
+      if (modeSet) throw Error('Choose only one of --steer and --defer');
+      modeSet = true; result.mode = arg === '--steer' ? 'steer' : 'defer'; continue;
+    }
+    const names = { '--source': 'source', '--title': 'title', '--kind': 'kind', '--reply-to': 'inReplyTo', '--request-id': 'requestId', '--after': 'after', '--limit': 'limit', '--home': 'home' };
+    if (names[arg]) {
+      const allowed = arg === '--home' || command === 'send' && ['--source', '--title', '--request-id', '--kind'].includes(arg) || command === 'reply' && ['--reply-to', '--request-id'].includes(arg) || ['read', 'watch', 'mailbox', 'watch-mailbox'].includes(command) && arg === '--after' || ['read', 'mailbox'].includes(command) && arg === '--limit';
+      if (!allowed || !args.length) throw Error(`Invalid ${arg} option`);
+      const value = args.shift(); result[names[arg]] = ['--after', '--limit'].includes(arg) ? Number(value) : value;
+    } else if (arg.startsWith('-')) throw Error(`Unknown option ${arg}`);
+    else text.push(arg);
+  }
+  if (['send', 'reply'].includes(command)) { result.text = text.join(' '); if (!result.text.trim()) throw Error('Send requires message text'); }
+  else if (command === 'cancel' && text.length === 1) result.messageId = text[0];
+  else if (text.length) throw Error('Unexpected arguments');
+  if (command === 'reply' && !result.inReplyTo) throw Error('Reply requires --reply-to REQUEST_MESSAGE_ID');
+  if (command === 'cancel' && !result.messageId) throw Error('Cancel requires MESSAGE_ID');
+  if (result.kind && !['request', 'notify'].includes(result.kind)) throw Error('Kind must be request or notify');
+  return result;
+}
+export async function runClient(argv, defaultHome) {
+  const options = parseClientArgs(argv);
+  const sessions = await discover(options.home ?? defaultHome);
+  if (options.command === 'sessions') { console.log(JSON.stringify(sessions, null, 2)); return; }
+  const session = resolveSession(sessions, options.sessionId);
+  const payload = { method: options.command, sessionId: session.id, after: options.after, limit: options.limit,
+    text: options.text, title: options.title, mode: options.mode, source: options.source, requestId: options.requestId,
+    kind: options.kind, inReplyTo: options.inReplyTo, messageId: options.messageId };
+  if (!['watch', 'watch-mailbox'].includes(options.command)) {
+    // Print the identity before dispatch so even a lost ACK can be retried.
+    if (['send', 'reply'].includes(options.command)) process.stderr.write(`requestId: ${options.requestId}\n`);
+    console.log(JSON.stringify(await request(session.socket, payload), null, 2)); return;
+  }
+  const controller = new AbortController();
+  const abort = () => controller.abort(); process.once('SIGINT', abort);
+  let closed = false;
+  try {
+    for await (const value of exchange(session.socket, payload, { signal: controller.signal })) {
+      await new Promise((resolve, reject) => process.stdout.write(JSON.stringify(value) + '\n', error => error ? reject(error) : resolve()));
+      if (value.type === 'closed') closed = true;
+    }
+    if (!closed && !controller.signal.aborted) throw Error('Stream disconnected. Reconnect with --after set to the last received event seq.');
+  } catch (error) { if (!controller.signal.aborted) throw error; }
+  finally { process.off('SIGINT', abort); }
+}