codex-overleaf-link 2.4.1 → 2.5.1

package/native-host/src/nativeQuotas.js

@@ -1,5 +1,12 @@
 'use strict';
 
+const { REFERENCE_LIMITS } = require('../../extension/src/shared/writingStyle');
+const WRITING_STYLE_ATTACHMENT_QUOTAS = Object.freeze({
+  maxAttachmentCount: REFERENCE_LIMITS.maxSources,
+  maxAttachmentBytes: REFERENCE_LIMITS.maxPdfBytes,
+  maxAttachmentTotalBytes: REFERENCE_LIMITS.maxAttachmentTotalBytes
+});
+
 const NATIVE_REQUEST_QUOTAS = Object.freeze({
   maxProjectFiles: 1000,
   maxProjectTextBytes: 32 * 1024 * 1024,
@@ -21,7 +28,7 @@ function validateNativeRequestQuotas(request = {}) {
         validateOperationListQuota(params.fileOverlays, 'fileOverlays'),
         validateFilePayloadQuota(params.fileOverlays, 'fileOverlays'),
         validateCompileLogQuota(params),
-        validateAttachmentQuota(params.attachments),
+        validateAttachmentQuota(params.attachments, params.writingStyleBuild ? WRITING_STYLE_ATTACHMENT_QUOTAS : NATIVE_REQUEST_QUOTAS),
         validateSkillContentQuota(params.skillContent)
       ]);
     case 'mirror.sync':
@@ -211,27 +218,27 @@ function validateCompileLogQuota(params = {}) {
     : null;
 }
 
-function validateAttachmentQuota(attachments) {
+function validateAttachmentQuota(attachments, quotas = NATIVE_REQUEST_QUOTAS) {
   const items = Array.isArray(attachments) ? attachments : [];
-  if (items.length > NATIVE_REQUEST_QUOTAS.maxAttachmentCount) {
-    return quotaViolation('attachments', NATIVE_REQUEST_QUOTAS.maxAttachmentCount, items.length, 'too many attachments');
+  if (items.length > quotas.maxAttachmentCount) {
+    return quotaViolation('attachments', quotas.maxAttachmentCount, items.length, 'too many attachments');
   }
 
   let totalBytes = 0;
   for (const item of items) {
     const bytes = getDeclaredOrEstimatedBinaryBytes(item);
-    if (bytes > NATIVE_REQUEST_QUOTAS.maxAttachmentBytes) {
+    if (bytes > quotas.maxAttachmentBytes) {
       return quotaViolation(
         'attachments.contentBase64',
-        NATIVE_REQUEST_QUOTAS.maxAttachmentBytes,
+        quotas.maxAttachmentBytes,
         bytes,
         'attachment payload is too large'
       );
     }
     totalBytes += bytes;
   }
-  return totalBytes > NATIVE_REQUEST_QUOTAS.maxAttachmentTotalBytes
-    ? quotaViolation('attachments', NATIVE_REQUEST_QUOTAS.maxAttachmentTotalBytes, totalBytes, 'attachment payload is too large')
+  return totalBytes > quotas.maxAttachmentTotalBytes
+    ? quotaViolation('attachments', quotas.maxAttachmentTotalBytes, totalBytes, 'attachment payload is too large')
     : null;
 }
 

package/native-host/src/nativeRunLifecycle.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const processStopBarrier = require('./processStopBarrier');
+const { logDebug } = require('./debugLog');
+const active = new Set();
+let closingError;
+
+// Shutdown ownership is independent of RPC ids: absent/reused ids must not
+// hide a live run from transport shutdown or its durable quarantine.
+function register({ controller, projectKey, rootDir }) {
+  let resolveDone;
+  const entry = { controller, projectKey, rootDir, processes: [], done: new Promise(resolve => { resolveDone = resolve; }) };
+  active.add(entry);
+  if (closingError) controller.abort(closingError);
+  return {
+    trackProcess(identity) {
+      if (!Number.isInteger(identity?.processId) || identity.processId <= 0) return;
+      entry.processes.push(identity);
+      if (closingError) quarantine(entry, identity);
+    },
+    complete() {
+      active.delete(entry);
+      try {
+        if (entry.processes.some(identity => identity.quarantined)) processStopBarrier.isBlocked(projectKey, rootDir);
+      } catch (error) { logDebug('native_transport.quarantine_cleanup_failed', { projectKey, message: error.message }); }
+      finally { resolveDone(); }
+    }
+  };
+}
+
+function abortAllActiveOperations(reason = 'Native messaging transport disconnected.') {
+  closingError = new Error(String(reason || 'Native messaging transport disconnected.'));
+  closingError.code = 'native_transport_closed';
+  const entries = Array.from(active);
+  for (const entry of entries) {
+    if (!entry.controller.signal.aborted) entry.controller.abort(closingError);
+  }
+  return Promise.all(entries.map(entry => entry.done));
+}
+
+function quarantineActiveOperations() {
+  const failures = [];
+  for (const entry of active) {
+    // A preparing run has no process to quarantine. Its aborted signal is
+    // checked again after provider preparation and immediately before spawn.
+    for (const identity of entry.processes) {
+      const failure = quarantine(entry, identity);
+      if (failure) failures.push(failure);
+    }
+  }
+  return failures;
+}
+
+function quarantine(entry, identity) {
+  if (identity.quarantined) return null;
+  const error = Object.assign(new Error('Native transport closed before run settlement.'), identity, {
+    code: 'codex_process_stop_unconfirmed'
+  });
+  try {
+    processStopBarrier.record(entry.projectKey, entry.rootDir, error);
+    if (error.stopBarrierPersistenceError) throw new Error(error.stopBarrierPersistenceError);
+    identity.quarantined = true;
+    return null;
+  } catch (failure) {
+    const detail = { projectKey: entry.projectKey, message: failure.message };
+    logDebug('native_transport.quarantine_failed', detail);
+    return detail;
+  }
+}
+
+module.exports = { register, abortAllActiveOperations, quarantineActiveOperations };

package/native-host/src/overleafWorkspaceRules.js

@@ -0,0 +1,16 @@
+'use strict';
+
+// Shared by project turns and broker workers. Skill-install turns run outside
+// the project mirror and retain their existing installer command policy.
+function formatOverleafWorkspaceRules() {
+  return [
+    'Overleaf workspace rules (also apply to delegated subagents):',
+    '- This directory is a synchronized Overleaf project mirror without .git metadata.',
+    '- Do not run Git commands in this mirror, including git status, git diff, git rev-parse, or git init. Do not create .git metadata or search parent directories for a repository.',
+    '- Verify changes through direct file reads and searches. Run compilation checks only when needed and permitted by the current task and mode; never compile solely to replace an unavailable Git check.',
+    '- The plugin compares the workspace against its synchronized baseline, collects file changes, and handles writeback to Overleaf. No Git-based diff, staging, or commit is required.',
+    '- Include these workspace rules in every delegated subagent task so workers follow the same constraints.'
+  ].join('\n');
+}
+
+module.exports = { formatOverleafWorkspaceRules };

package/native-host/src/processStopBarrier.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// A stop acknowledgement is not proof of process exit. This quarantine survives
+// Native Host restarts and only permits work after positive exit evidence.
+const fs = require('node:fs');
+const path = require('node:path');
+const { getProjectMirror, getDefaultMirrorRoot } = require('./mirrorWorkspace');
+const pending = new Map();
+
+function location(projectId, rootDir) {
+  const mirror = getProjectMirror(projectId, { rootDir });
+  return path.join(path.dirname(mirror.workspacePath), '.codex-stop-barrier.json');
+}
+
+function load(file) {
+  let records = [];
+  try {
+    if (fs.statSync(file).size > 65536) throw new Error('Oversized stop barrier');
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!Array.isArray(value) || value.length > 64) throw new Error('Invalid stop barrier');
+    records = value.map(record => record && typeof record === 'object' ? record : { unknown: true });
+  } catch (error) {
+    if (error.code !== 'ENOENT') records = [{ unknown: true }];
+  }
+  // Other Hosts can publish a barrier while this Host is already alive. Keep
+  // in-memory callbacks and failed writes, but never cache an empty disk read.
+  const key = ({ isStopped, ...record }) => JSON.stringify(record);
+  const merged = new Map(records.map(record => [key(record), record]));
+  for (const record of pending.get(file) || []) {
+    if (typeof record.isStopped === 'function' || record.persistenceFailed) merged.set(key(record), record);
+  }
+  records = Array.from(merged.values());
+  pending.set(file, records);
+  return records;
+}
+
+function persist(file, records) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = file + '.' + process.pid + '.tmp';
+  const fd = fs.openSync(temp, 'w', 0o600);
+  try {
+    fs.writeFileSync(fd, JSON.stringify(records.map(({ isStopped, ...record }) => record)));
+    fs.fsyncSync(fd);
+  } finally { fs.closeSync(fd); }
+  fs.renameSync(temp, file);
+}
+
+function stopped(record) {
+  if (typeof record.isStopped === 'function') {
+    try { return record.isStopped() === true; } catch (_) { return false; }
+  }
+  // Recovered POSIX process-group identities can be checked without signalling
+  // or killing anything. Unknown/Windows trees remain quarantined.
+  if (record.processGroup !== true || record.platform !== process.platform
+    || !Number.isInteger(record.processId) || record.processId <= 0) return false;
+  try { process.kill(-record.processId, 0); return false; }
+  catch (error) { return error.code === 'ESRCH'; }
+}
+
+function record(projectId, rootDir, error) {
+  const file = location(projectId, rootDir);
+  const records = load(file);
+  const entry = {
+    processId: error.processId, processGroup: error.processGroup === true,
+    platform: process.platform, createdAt: new Date().toISOString(),
+    isStopped: error.isStopped
+  };
+  records.push(entry);
+  try { persist(file, records); }
+  catch (failure) {
+    Object.defineProperty(entry, 'persistenceFailed', { value: true });
+    error.stopBarrierPersistenceError = failure.message;
+  }
+}
+
+function isBlocked(projectId, rootDir) {
+  const file = location(projectId, rootDir);
+  const records = load(file);
+  if (!records.length) return false;
+  const remaining = records.filter(value => !stopped(value));
+  if (remaining.length !== records.length) {
+    try {
+      persist(file, remaining);
+      pending.set(file, remaining);
+    } catch (_) { return true; }
+  }
+  return remaining.length > 0;
+}
+
+// Update safety observes the existing project quarantine. It neither searches
+// unrelated OS processes nor mutates a project's recovery records.
+function getBlockedProjectCount(rootDir, options = {}) {
+  const root = path.resolve(rootDir || getDefaultMirrorRoot(options));
+  const files = new Set();
+  let unknown = 0;
+  try {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+      if (entry.isDirectory()) files.add(path.join(root, entry.name, '.codex-stop-barrier.json'));
+      else if (entry.isSymbolicLink()) unknown += 1;
+    }
+  } catch (error) {
+    if (error.code !== 'ENOENT') unknown += 1;
+  }
+  // Include failed persistence owned by this Host, even if its directory was
+  // never created. A disk inventory alone cannot release that quarantine.
+  for (const file of pending.keys()) {
+    if (path.dirname(path.dirname(file)) === root) files.add(file);
+  }
+  for (const file of files) {
+    if (load(file).some(value => !stopped(value))) unknown += 1;
+  }
+  return unknown;
+}
+
+module.exports = { record, isBlocked, getBlockedProjectCount };

package/native-host/src/projectPathPlatform.js

@@ -0,0 +1,30 @@
+'use strict';
+
+// Canonical project names stay literal. Reject names the local filesystem would
+// reinterpret instead of attempting to escape, trim or rename them.
+function isRepresentableProjectPath(value, platform = process.platform) {
+  if (typeof value !== 'string' || !value) return false;
+  if (platform !== 'win32') return true;
+  return value.split('/').every(part => part && part !== '.' && part !== '..'
+    && part.length <= 255 && !/[<>:"\\|?*\u0000-\u001f]/.test(part) && !/[ .]$/.test(part)
+    && !/^(?:con|prn|aux|nul|conin\$|conout\$|com[1-9¹²³]|lpt[1-9¹²³])(?:\.|$)/i.test(part));
+}
+
+function assertProjectPathsForPlatform(paths, platform = process.platform) {
+  const identities = new Map();
+  for (const value of paths) {
+    let valid = isRepresentableProjectPath(value, platform);
+    if (valid && platform === 'win32') {
+      const parts = value.split('/');
+      for (let index = 1; index <= parts.length; index += 1) {
+        const literal = parts.slice(0, index).join('/'), key = literal.toLowerCase();
+        if (identities.has(key) && identities.get(key) !== literal) valid = false;
+        identities.set(key, literal);
+      }
+    }
+    if (!valid) throw Object.assign(new Error(`Project path cannot be represented faithfully on ${platform}: ${value}`),
+      { code: 'project_path_unrepresentable', path: value });
+  }
+}
+
+module.exports = { isRepresentableProjectPath, assertProjectPathsForPlatform };

package/native-host/src/providerHttp.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const { providerError } = require('./providerProfile');
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+const BODY_HEADERS = ['content-encoding', 'content-language', 'content-location', 'content-type', 'content-length'];
+
+function carriesEndpointCredentials(headers, launch) {
+  const namedHeader = String(launch.apiKeyHeaderName || '').toLowerCase();
+  return [...headers].some(([name, value]) => value && (
+    name === namedHeader
+    || /(?:^|[-_])(?:authorization|auth|api[-_]?key|token|secret|cookie|credential|password|signature)(?:$|[-_])/i.test(name)
+    || launch.apiKey && value.includes(launch.apiKey)
+  ));
+}
+
+// Fetch's method/body redirect rules remain intact. Credentials configured for
+// this endpoint never authorize a request to a different origin.
+async function fetchProvider(url, options, launch = {}) {
+  let current = new URL(url);
+  let method = String(options.method || 'GET').toUpperCase();
+  let body = options.body;
+  const headers = new Headers(options.headers);
+  const credentialed = carriesEndpointCredentials(headers, launch);
+  for (let redirects = 0; ; redirects += 1) {
+    const response = await fetch(current, { ...options, method, body, headers, redirect: 'manual' });
+    const location = response.headers.get('location');
+    if (!REDIRECT_STATUSES.has(response.status) || location === null) return response;
+    await response.body?.cancel().catch(() => {});
+    if (redirects >= 20) throw providerError('provider_upstream_error', 'The provider exceeded the redirect limit.');
+    let next;
+    try { next = new URL(location, current); }
+    catch (_) { throw providerError('provider_upstream_error', 'The provider returned an invalid redirect.'); }
+    if (!['http:', 'https:'].includes(next.protocol) || next.username || next.password) {
+      throw providerError('provider_upstream_error', 'The provider returned an unsupported redirect.');
+    }
+    if (credentialed && next.origin !== current.origin) {
+      throw providerError('provider_upstream_error', 'The provider redirected to a different origin; endpoint credentials were not forwarded.');
+    }
+    if ((response.status === 301 || response.status === 302) && method === 'POST'
+      || response.status === 303 && method !== 'GET' && method !== 'HEAD') {
+      method = 'GET';
+      body = undefined;
+      for (const name of BODY_HEADERS) headers.delete(name);
+    }
+    current = next;
+  }
+}
+
+// Preserve ordinary Response.text()/json() capacity and UTF-8 semantics while
+// reporting each body chunk to the existing idle lifecycle. Compact/SSE limits
+// remain in their own readers; this does not introduce a new response cap.
+async function readProviderText(response, onActivity = () => {}) {
+  if (!response.body) return '';
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let complete = false;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      onActivity();
+      chunks.push(decoder.decode(value, { stream: true }));
+    }
+    complete = true;
+    chunks.push(decoder.decode());
+    return chunks.join('');
+  } finally {
+    if (!complete) await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+}
+
+async function readProviderJson(response, onActivity) {
+  const text = await readProviderText(response, onActivity);
+  try { return JSON.parse(text); }
+  catch (_) { throw providerError('provider_response_invalid', 'The provider returned an invalid JSON response.'); }
+}
+
+module.exports = { fetchProvider, readProviderText, readProviderJson };

package/native-host/src/providerModelCatalog.js

@@ -79,9 +79,10 @@ function buildModelEntry(model, launch, index) {
 }
 
 function normalizeEfforts(...values) {
-  const allowed = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
-  const normalized = values
-    .flatMap(value => Array.isArray(value) ? value : [])
+  const allowed = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+  // Explicit model capabilities must not inherit the selected model's levels.
+  const configured = values.find(value => Array.isArray(value) && value.length) || [];
+  const normalized = configured
     .map(value => String(value || '').trim().toLowerCase())
     .filter(value => allowed.has(value));
   return Array.from(new Set(normalized.length ? normalized : ['none']));

package/native-host/src/providerProfile.js

@@ -7,7 +7,7 @@ const {
 } = require('./providerReasoning');
 
 const ALLOWED_WIRE_APIS = new Set(['auto', 'responses', 'chat', 'anthropic']);
-const ALLOWED_REASONING_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
+const ALLOWED_REASONING_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
 const ALLOWED_UPSTREAM_RESPONSE_MODES = new Set(['auto', 'streaming', 'buffered']);
 const ALLOWED_AUTH_MODES = new Set(['bearer', 'x-api-key', 'api-key', 'custom', 'none']);
 const ALLOWED_INPUT_MODALITIES = new Set(['text', 'image']);
@@ -65,7 +65,8 @@ function normalizeProviderDraft(value = {}) {
     anthropicThinkingMode: normalizeAnthropicThinkingMode(value.anthropicThinkingMode),
     anthropicPromptCaching: value.anthropicPromptCaching === true,
     impersonateClaudeCode: value.impersonateClaudeCode === true,
-    maxOutputTokens: normalizeMaxOutputTokens(value.maxOutputTokens)
+    maxOutputTokens: normalizeMaxOutputTokens(value.maxOutputTokens),
+    outputBudgetVersion: 1
   };
 }
 
@@ -93,6 +94,9 @@ function normalizeModels(values) {
       upstreamResponseMode: normalizeUpstreamResponseMode(value?.upstreamResponseMode, true),
       resolvedUpstreamResponseMode: normalizeUpstreamResponseMode(value?.resolvedUpstreamResponseMode, false),
       contextWindow: normalizeContextWindow(value?.contextWindow),
+      maxOutputTokens: normalizeModelOutputTokens(value?.maxOutputTokens),
+      reasoningAdapter: value?.reasoningAdapter ? normalizeReasoningAdapter(value.reasoningAdapter) : '',
+      reasoningCapability: value?.reasoningCapability ? normalizeReasoningCapability(value.reasoningCapability) : '',
       supportsParallelToolCalls: value?.supportsParallelToolCalls === true,
       inputModalities: normalizeInputModalities(value?.inputModalities),
       baseInstructions: normalizeOptionalText(value?.baseInstructions, 8000)
@@ -101,6 +105,15 @@ function normalizeModels(values) {
   return result;
 }
 
+function normalizeModelOutputTokens(value) {
+  if (value === undefined || value === null || value === '') return null;
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number < 256 || number > 65536) {
+    throw providerError('provider_configuration_invalid', 'Model output limit must be an integer between 256 and 65536.');
+  }
+  return number;
+}
+
 function normalizeBaseUrl(value) {
   const text = normalizeRequiredText(value, 'provider_base_url_invalid', 'Base URL is required.', 2048);
   let parsed;
@@ -233,6 +246,7 @@ function sanitizeProfile(profile, hasSecret) {
     anthropicPromptCaching: profile.anthropicPromptCaching === true,
     impersonateClaudeCode: profile.impersonateClaudeCode === true,
     maxOutputTokens: normalizeMaxOutputTokens(profile.maxOutputTokens),
+    outputBudgetVersion: 1,
     hasSecret: Boolean(hasSecret),
     secretUpdatedAt: profile.secretUpdatedAt || 0,
     endpointDisclosureHost: profile.endpointDisclosureHost || '',
@@ -407,7 +421,7 @@ function normalizeUpstreamResponseMode(value, allowAuto) {
 
 function normalizeMaxOutputTokens(value) {
   const number = Number(value);
-  if (!Number.isFinite(number) || number === 8192 || number === 32768) return 65536;
+  if (!Number.isFinite(number)) return 65536;
   return Math.min(65536, Math.max(256, Math.floor(number)));
 }
 

package/native-host/src/providerReasoning.js

@@ -12,8 +12,7 @@ const REASONING_ADAPTERS = new Set([
   'reasoning_split'
 ]);
 const REASONING_CAPABILITIES = new Set(['auto', 'none', 'toggle', 'effort']);
-const REASONING_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh']);
-const DEEPSEEK_MAX_REASONING_OUTPUT_TOKENS = 65536;
+const REASONING_EFFORTS = new Set(['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
 
 function normalizeReasoningAdapter(value) {
   const normalized = String(value || '').trim().toLowerCase();
@@ -67,6 +66,10 @@ function getSupportedReasoningEfforts(profile = {}, model = {}) {
 }
 
 function getReasoningControl(profile = {}, model = {}) {
+  profile = { ...profile,
+    reasoningAdapter: model.reasoningAdapter || profile.reasoningAdapter,
+    reasoningCapability: model.reasoningCapability || profile.reasoningCapability
+  };
   const explicit = Array.isArray(model.reasoningEfforts)
     ? model.reasoningEfforts.map(normalizeEffort).filter(Boolean)
     : [];
@@ -85,7 +88,7 @@ function getReasoningControl(profile = {}, model = {}) {
   }
   if (adapter === 'deepseek') {
     return {
-      efforts: ['none', 'high', 'xhigh'],
+      efforts: ['none', 'high', 'max'],
       defaultEffort: 'high',
       presentation: 'deepseek'
     };
@@ -134,11 +137,11 @@ function applyReasoningControl(chatBody, responsesRequest = {}, launch = {}) {
   if (adapter === 'deepseek') {
     chatBody.thinking = { type: enabled ? 'enabled' : 'disabled' };
     if (enabled) {
-      chatBody.reasoning_effort = requested === 'xhigh' ? 'max' : 'high';
+      chatBody.reasoning_effort = ['xhigh', 'max'].includes(requested) ? 'max' : 'high';
     }
   } else if (adapter === 'reasoning_effort') {
     if (enabled) {
-      chatBody.reasoning_effort = clampEffort(requested, false);
+      chatBody.reasoning_effort = clampEffort(requested, true);
     }
   } else if (adapter === 'openrouter') {
     chatBody.reasoning = { effort: clampEffort(requested, true) };
@@ -161,12 +164,8 @@ function resolveReasoningMaxOutputTokens(value, responsesRequest = {}, launch =
   if (!Number.isFinite(number)) {
     return value;
   }
-  const normalized = Math.max(1, Math.floor(number));
-  const effort = resolveRequestedReasoningEffort(responsesRequest, launch);
-  const adapter = resolveReasoningAdapter(launch, modelId || launch.modelId);
-  return adapter === 'deepseek' && effort === 'xhigh'
-    ? Math.max(normalized, DEEPSEEK_MAX_REASONING_OUTPUT_TOKENS)
-    : normalized;
+  // Reasoning effort cannot silently increase the configured output maximum.
+  return Math.max(1, Math.floor(number));
 }
 
 function requiresReasoningContentReplay(launch = {}, modelId = '') {

package/native-host/src/providerRuntime.js

@@ -92,6 +92,7 @@ async function testProvider(params, env, emit = () => {}, externalSignal = null)
   }, totalBudgetMs);
   const onExternalAbort = () => controller.abort();
   externalSignal?.addEventListener?.('abort', onExternalAbort, { once: true });
+  if (externalSignal?.aborted) onExternalAbort();
   activeTests.get(operationId)?.abort?.();
   activeTests.set(operationId, controller);
   const protocols = draft.wireApiPreference === 'auto'