codex-overleaf-link 2.5.1 → 2.6.5

package/extension/src/shared/compileAdapter.js

@@ -11,31 +11,46 @@
   const COMPILABLE_EXTENSIONS = new Set(['.tex', '.bib', '.sty', '.cls', '.bst', '.bbx', '.cbx']);
   function parseCompileResponse(response) {
     if (!response || typeof response !== 'object') return { ok: false, reason: 'Invalid compile response: not an object' };
-    if (!Array.isArray(response.outputFiles)) return { ok: false, reason: 'Invalid compile response: outputFiles is not an array' };
-    const logFile = response.outputFiles.find(function (file) {
+    if (!Array.isArray(response.outputFiles)) return { ok: false, status: response.status, reason: 'Invalid compile response: outputFiles is not an array' };
+    const logFile = response.outputFiles.find(file => /(^|\/)output\.log$/.test(file?.path || '')) || response.outputFiles.find(function (file) {
       if (!file) return false;
       if (file.type === 'log') return true;
       if (typeof file.path === 'string' && file.path.endsWith('.log')) return true;
       return false;
     });
-    if (!logFile) return { ok: false, reason: 'No log file found in compile output' };
-    var logUrl = logFile.url || null;
-    if (!logUrl) return { ok: false, reason: 'Log file has no URL' };
+    if (!logFile) return { ok: false, status: response.status, reason: 'No log file found in compile output' };
+    var logUrl = typeof logFile.url === 'string' ? logFile.url : null;
+    if (!logUrl) return { ok: false, status: response.status, reason: 'Log file has no URL' };
     return {
       ok: true,
       status: response.status,
+      fromCache: response.fromCache === true,
       logUrl: logUrl,
-      logPath: logFile.path || null
+      logPath: logFile.path || null,
+      build: logFile.build || null,
+      pdfDownloadDomain: normalizePdfDownloadDomain(response.pdfDownloadDomain),
+      clsiServerId: typeof response.clsiServerId === 'string' && /^[A-Za-z0-9_-]{1,128}$/.test(response.clsiServerId)
+        ? response.clsiServerId : null
     };
   }
 
+  function normalizePdfDownloadDomain(value) {
+    if (typeof value !== 'string' || !/^https:\/\/[^\s\\]+$/i.test(value)) return null;
+    try {
+      const url = new URL(value);
+      return url.protocol === 'https:' && !url.username && !url.password && !url.search && !url.hash ? value : null;
+    } catch (_error) {
+      return null;
+    }
+  }
+
   function extractErrorBlocks(lines) {
     var blocks = [];
     var i = 0;
 
     while (i < lines.length && blocks.length < 20) {
       var line = lines[i];
-      if (line.startsWith('!') || /^l\.\d+/.test(line)) {
+      if (isLogErrorLine(line) || /^l\.\d+/.test(line)) {
         var block = [];
         // Collect surrounding context: go back up to 2 lines for pre-context
         var start = Math.max(0, i - 2);
@@ -106,6 +121,12 @@
     return COMPILABLE_EXTENSIONS.has(ext);
   }
 
+  function isLogErrorLine(line) {
+    // TeX's -file-line-error output (used by Overleaf) has no leading '!'.
+    return line.startsWith('!') || /^Runaway argument/.test(line)
+      || (/^(?:\.{0,2}\/|[A-Za-z]:[\\/])?.+?:\d+:\s+\S/.test(line) && !/\bWarning\b/i.test(line));
+  }
+
   function parseLogErrors(logContent) {
     var result = { errors: [], warnings: [] };
 
@@ -115,20 +136,23 @@
 
     var lines = logContent.split('\n');
 
-    // Extract errors: lines starting with '!' plus up to 3 following context lines
+    // Retain the bounded error list; consumers limit displayed snippets separately.
     for (var i = 0; i < lines.length && result.errors.length < 50; i++) {
-      if (lines[i].startsWith('!')) {
+      if (isLogErrorLine(lines[i])) {
         var errorLines = [lines[i]];
         for (var j = 1; j <= 3 && (i + j) < lines.length; j++) {
+          if (!lines[i + j].trim() || isLogErrorLine(lines[i + j])) break;
           errorLines.push(lines[i + j]);
         }
         result.errors.push(errorLines.join('\n'));
       }
     }
 
-    // Extract warnings: lines matching /Warning/i that don't start with whitespace
+    // Count only the warning forms Overleaf's own log parser reports, so
+    // informational lines such as "Package: infwarerr … info/warning/error
+    // messages" are not shown as warnings.
     for (var k = 0; k < lines.length && result.warnings.length < 50; k++) {
-      if (/Warning/i.test(lines[k]) && !/^\s/.test(lines[k])) {
+      if (/^LaTeX(?:3| Font)? Warning: /.test(lines[k]) || /^(?:Package|Class|Module) \b.+\b Warning:/.test(lines[k])) {
         result.warnings.push(lines[k]);
       }
     }
@@ -137,18 +161,35 @@
   }
 
   function buildPostWriteCompileSummary({ result = null, logResult = null, error = null } = {}) {
-    const logAvailable = logResult?.ok === true;
+    const captured = result?.ok === true && result.resultCaptured === true
+      && Number.isSafeInteger(result.compile?.captureId) && result.compile.captureId > 0;
+    const logAvailable = captured && logResult?.ok === true && logResult.fresh === true
+      && result.compile?.captureId === logResult.captureId;
     const errors = logAvailable && Array.isArray(logResult.errors)
-      ? logResult.errors.slice(0, 5).map(formatCompileDiagnosticForSummary)
+      ? logResult.errors.map(formatCompileDiagnosticForSummary)
       : [];
     const warnings = logAvailable && Array.isArray(logResult.warnings)
       ? logResult.warnings.slice(0, 5).map(formatCompileDiagnosticForSummary)
       : [];
-    const failed = Boolean(error) || !result?.ok;
+    const compilerFailed = captured && logResult?.fresh !== false
+      && ['failed', 'failure', 'error', 'timedout', 'timeout'].includes(result.compile?.status);
+    if (compilerFailed && !errors.length) errors.push('Post-write compile failed.');
+    const failed = compilerFailed || errors.length > 0;
+    const success = captured && result.compile?.ok === true && result.compile.status === 'success'
+      && result.compile.fromCache !== true && logAvailable;
+    const status = failed ? 'failed' : success ? 'success' : result?.ok && !captured ? 'triggered' : 'unconfirmed';
+    let reason = error ? error?.message || 'Post-write compile failed.'
+      : !result?.ok ? result?.reason || 'Post-write compile did not succeed.' : result.reason || '';
+    if (status === 'unconfirmed' || status === 'triggered') {
+      // Technical evidence belongs in the existing activity output, not the outcome label.
+      reason ||= logResult?.reason || (!captured ? 'compile_capture_missing'
+        : result.compile?.reason || (result.compile.fromCache ? 'compile_response_from_cache'
+          : logResult?.captureId !== result.compile.captureId ? 'compile_log_capture_mismatch'
+            : logResult?.fresh === false ? 'compile_log_stale' : 'compile_result_unconfirmed'));
+    }
     return {
-      status: failed ? 'failed' : result.compile?.status || 'triggered',
-      reason: error ? error?.message || 'Post-write compile failed.'
-        : !result?.ok ? result?.reason || 'Post-write compile did not succeed.' : result.reason || '',
+      status,
+      reason,
       errors,
       warnings,
       logAvailable

package/extension/src/shared/composerAttachmentDraft.js

@@ -5,6 +5,13 @@
   'use strict';
   const EPOCH_KEY = 'composer-attachment-draft:clear-epoch';
   const normalize = value => SessionState.normalizeComposerAttachmentsForPersistence(value);
+  function normalizeOmitted(value) {
+    const names = (Array.isArray(value?.names) ? value.names : [])
+      .filter(name => typeof name === 'string')
+      .map(name => name.replace(/\0/g, '').trim().slice(0, 180))
+      .filter(Boolean).slice(0, 8);
+    return { count: names.length, names };
+  }
   const scopeKey = scope => JSON.stringify([scope?.accountScopeId || '', scope?.projectId || '']);
   function checkedScope(scope) {
     const accountScopeId = String(scope?.accountScopeId || '').trim();
@@ -42,20 +49,28 @@
                 throw failure('account_scope_unavailable');
               }
               const revision = Number(previous?.revision) || 0;
-              result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments) };
+              result = { epoch, clearedAt, revision, attachments: normalize(previous?.attachments), omittedAttachments: normalizeOmitted(previous?.omittedAttachments) };
               if (!value) return;
               const attachments = normalize(value.attachments);
+              const omittedAttachments = normalizeOmitted(value.omittedAttachments);
+              const hasDraft = attachments.length || omittedAttachments.count;
               if (value.epoch !== epoch) {
                 // A clear performed by this page also invalidates its old base.
                 // Its empty draft needs no write; an old nonempty draft cannot return.
-                if (!attachments.length) return;
+                if (!hasDraft) return;
                 throw failure('composer_draft_cleared');
               }
-              if (value.revision !== revision) throw failure('composer_draft_conflict');
-              if (attachments.length && value.unbased && clearedAt && value.changedAt <= clearedAt) {
+              if (value.revision !== revision) {
+                // Writing what another tab already stored changes nothing (for example
+                // both tabs clearing an empty draft on send); only a real edit conflicts.
+                if (JSON.stringify(attachments) === JSON.stringify(result.attachments)
+                  && JSON.stringify(omittedAttachments) === JSON.stringify(result.omittedAttachments)) return;
+                throw failure('composer_draft_conflict');
+              }
+              if (hasDraft && value.unbased && clearedAt && value.changedAt <= clearedAt) {
                 throw failure('composer_draft_cleared');
               }
-              result = { epoch, clearedAt, revision: revision + 1, attachments };
+              result = { epoch, clearedAt, revision: revision + 1, attachments, omittedAttachments };
               store.put({ id, type: 'composer-attachment-draft', ...scope, ...result });
             } catch (caught) { error = caught; tx.abort(); }
           };
@@ -115,7 +130,11 @@
       syncScope();
       if (hydrated) return;
       // Loading is allowed to finish after a local add/remove. Local edits win.
-      if (!changedVersion && !options.getAttachments().length) options.restore(normalize(attachments));
+      if (!changedVersion && !options.getAttachments().length) {
+        options.restore(normalize(attachments));
+        const omitted = normalizeOmitted(base?.omittedAttachments);
+        if (omitted.count) options.onRestoreOmittedAttachments?.(omitted);
+      }
       hydrated = true; publish();
     }
     function changed() {
@@ -133,10 +152,11 @@
         if (captured !== generation || scopeKey(options.getScope()) !== key || changedVersion === savedVersion) return;
         const version = changedVersion;
         const attachments = normalize(options.getAttachments());
+        const omittedAttachments = normalizeOmitted({ names: options.getOmittedAttachmentNames?.() });
         const unbased = dirtyUnbased, changedAt = dirtySince;
         if (!base) await load(scope);
         if (captured !== generation || scopeKey(options.getScope()) !== key) return;
-        const written = await options.write(checkedScope(scope), { ...base, attachments, unbased, changedAt });
+        const written = await options.write(checkedScope(scope), { ...base, attachments, omittedAttachments, unbased, changedAt });
         if (captured !== generation) return;
         base = written; savedVersion = version;
         if (changedVersion === version) { dirtySince = 0; dirtyUnbased = false; }

package/extension/src/shared/contextUsage.js

@@ -0,0 +1,125 @@
+(function initContextUsage(root, factory) {
+  if (typeof module === 'object' && module.exports) module.exports = factory();
+  else root.CodexOverleafModuleRegistry.define('ContextUsage', [], factory);
+})(typeof globalThis !== 'undefined' ? globalThis : window, function contextUsageFactory() {
+  'use strict';
+
+  const count = value => Number.isSafeInteger(value) && value >= 0 ? value : null;
+  const identity = value => typeof value === 'string' && value.trim() && value.length <= 512
+    && !/[\0\r\n]/.test(value) ? value.trim() : '';
+  const timestamp = value => typeof value === 'string' && Number.isFinite(Date.parse(value))
+    ? new Date(value).toISOString() : '';
+
+  // Store a bounded fact from one model response, never the cumulative billed
+  // token total. The last reported response is an estimate of context occupancy;
+  // tool output added since then is not included until the next server update.
+  function normalize(value) {
+    if (!value || value.v !== 1) return null;
+    const threadId = identity(value.threadId), turnId = identity(value.turnId);
+    const runId = identity(value.runId), providerId = identity(value.providerId), model = identity(value.model);
+    const usedTokens = count(value.usedTokens), providerRevision = count(value.providerRevision);
+    const observedAt = timestamp(value.observedAt);
+    if (!threadId || !turnId || !runId || !providerId || !model || usedTokens === null
+      || providerRevision === null || !observedAt) return null;
+    const capacity = count(value.contextWindow);
+    const eventSeq = count(value.eventSeq);
+    const inputTokens = count(value.inputTokens), outputTokens = count(value.outputTokens);
+    const cachedInput = count(value.cachedInputTokens);
+    // Cache reads are a subset of input, never an additional category. Older
+    // snapshots and providers without these counters retain unknown values.
+    const cachedInputTokens = inputTokens !== null && cachedInput !== null && cachedInput <= inputTokens
+      ? cachedInput : null;
+    return { v: 1, threadId, turnId, runId, providerId, providerRevision, model,
+      usedTokens, contextWindow: capacity > 0 ? capacity : null,
+      inputTokens, outputTokens, cachedInputTokens,
+      eventSeq: eventSeq > 0 ? eventSeq : null, observedAt };
+  }
+
+  function matches(value, scope = {}) {
+    const snapshot = normalize(value);
+    return Boolean(snapshot && snapshot.threadId === identity(scope.threadId || scope.codexThreadId)
+      && snapshot.providerId === identity(scope.providerId)
+      && snapshot.providerRevision === count(scope.providerRevision)
+      && snapshot.model === identity(scope.model));
+  }
+
+  // The caller supplies the captured run owner, after its Native thread/turn
+  // binding is known. Reject worker, previous-turn and unbound notifications.
+  function fromEvent(event, owner = {}) {
+    if (!event || (event.type && event.type !== 'codex.session.event') || event.subagent === true) return null;
+    const notification = event.detail || event;
+    if (notification.method !== 'thread/tokenUsage/updated') return null;
+    const params = notification.params || {};
+    const threadId = identity(params.threadId), turnId = identity(params.turnId);
+    if (!threadId || !turnId || threadId !== identity(owner.threadId || owner.codexThreadId)
+      || turnId !== identity(owner.turnId || owner.codexTurnId) || owner.forkSnapshot === true) return null;
+    const last = params.tokenUsage?.last;
+    const usedTokens = count(last?.totalTokens);
+    if (usedTokens === null) return null;
+    return normalize({ v: 1, threadId, turnId, runId: owner.runId || owner.id,
+      providerId: owner.providerId, providerRevision: owner.providerRevision, model: owner.model,
+      usedTokens, contextWindow: params.tokenUsage?.modelContextWindow,
+      inputTokens: last?.inputTokens, outputTokens: last?.outputTokens, cachedInputTokens: last?.cachedInputTokens,
+      eventSeq: event.nativeEventSeq ?? event.eventSeq ?? event.seq ?? owner.eventSeq,
+      observedAt: timestamp(event.timestamp || event.at) || timestamp(owner.observedAt) || new Date().toISOString() });
+  }
+
+  function isNewer(next, previous) {
+    next = normalize(next); previous = normalize(previous);
+    if (!next) return false;
+    if (!previous) return true;
+    if (next.runId === previous.runId && next.threadId === previous.threadId && next.turnId === previous.turnId
+      && next.eventSeq !== null && previous.eventSeq !== null)
+      return next.eventSeq > previous.eventSeq;
+    return Date.parse(next.observedAt) > Date.parse(previous.observedAt);
+  }
+
+  // `scope.compactedAt` (epoch ms) carries an automatic compaction completed
+  // inside a normal turn; manual compact runs are read from the session.
+  // `pending` means the old sample is invalid; `compacted` additionally requires
+  // successful completion of the most recent compaction that invalidated it.
+  function status(session, scope = {}) {
+    if (!session || session.forkSnapshot === true) return { usage: null, pending: false, compacted: false };
+    const inThread = value => value && value.threadId === identity(scope.threadId || scope.codexThreadId)
+      && value.providerId === identity(scope.providerId)
+      && value.providerRevision === count(scope.providerRevision);
+    // A dispatched compaction can change this thread even when its completion
+    // is lost on reload. Do not re-display a pre-compaction sample as current.
+    const runs = Array.isArray(session.runs) ? session.runs : [];
+    let invalidatedAfter = Number.isFinite(scope.compactedAt) && scope.compactedAt > 0 ? scope.compactedAt : 0;
+    let completedAfter = invalidatedAfter;
+    for (const run of runs) {
+      if (run?.operation !== 'compact' || run.forkSnapshot
+        || run.codexThreadId !== identity(scope.threadId || scope.codexThreadId)) continue;
+      const startedAt = Date.parse(run.startedAt || '') || 0;
+      invalidatedAfter = Math.max(invalidatedAfter, startedAt);
+      if (run.status === 'completed') completedAfter = Math.max(completedAfter, startedAt);
+    }
+    let selected = normalize(session.contextUsage);
+    if (!inThread(selected)) selected = null;
+    for (const run of runs) {
+      if (run?.forkSnapshot === true) continue;
+      const candidate = normalize(run.contextUsage);
+      if (!inThread(candidate) || candidate.runId !== run.id) continue;
+      if (isNewer(candidate, selected)) selected = candidate;
+    }
+    const beforeCompaction = !selected || Date.parse(selected.observedAt) < invalidatedAfter;
+    // A later turn can grow this thread using another model. Selecting an older
+    // model again must not resurrect its obsolete, smaller context estimate.
+    const usage = selected?.model === identity(scope.model) && !beforeCompaction ? selected : null;
+    const pending = !usage && invalidatedAfter > 0 && beforeCompaction;
+    return { usage, pending, compacted: pending && completedAfter >= invalidatedAfter };
+  }
+
+  function select(session, scope = {}) {
+    return status(session, scope).usage;
+  }
+
+  // Presentation level of a reported share of the window, in percent.
+  function level(percent) {
+    if (typeof percent !== 'number' || !Number.isFinite(percent)) return '';
+    return percent >= 90 ? 'near-limit' : percent >= 70 ? 'high' : 'normal';
+  }
+
+  return { normalize, fromEvent, matches, isNewer, select, status, level };
+});

package/extension/src/shared/failureReasons.js

@@ -106,6 +106,11 @@
     },
 
     // 9.2 Preflight
+    sensitive_content_blocked: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: 'Sensitive content was found before sending, so Codex did not receive this request.',
+      fallbackNextAction: 'Remove the sensitive content, narrow @context, or enable explicit sensitive confirmation in Project Settings.'
+    },
     governance_blocked: {
       stage: 'preflight', severity: 'blocked', defaultRetryable: false,
       fallbackUserMessage: 'Project file rules blocked this write. Codex did not write the affected path.',
@@ -131,6 +136,11 @@
       fallbackUserMessage: 'The file changed while Codex was working.',
       fallbackNextAction: 'Review the current file, then rerun the task.'
     },
+    document_identity_mismatch: {
+      stage: 'preflight', severity: 'blocked', defaultRetryable: true,
+      fallbackUserMessage: 'Codex could not confirm that the editor content belongs to the target file, so it was not used.',
+      fallbackNextAction: 'Wait for the target file to open and settle, then retry. Reload Overleaf if this continues.'
+    },
     patch_anchor_not_found: {
       stage: 'preflight', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'The edit anchor no longer matches current Overleaf content.',
@@ -232,6 +242,11 @@
     },
 
     // 9.4 Reviewing
+    reviewing_unavailable: {
+      stage: 'reviewing', severity: 'blocked', defaultRetryable: false,
+      fallbackUserMessage: "Track Changes is unavailable for this project. It depends on the project owner's Overleaf plan.",
+      fallbackNextAction: 'Turn off Track in the composer to write without tracked changes. Codex still records each change so you can undo it.'
+    },
     reviewing_state_unknown: {
       stage: 'reviewing', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'Codex could not determine whether Reviewing/Track Changes is enabled.',
@@ -348,6 +363,11 @@
       fallbackUserMessage: 'Native host request failed.',
       fallbackNextAction: 'Open diagnostics and retry.'
     },
+    native_request_timeout: {
+      stage: 'native', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The local service did not respond.',
+      fallbackNextAction: 'Retry, or open Diagnostics to check the local connection.'
+    },
     native_protocol_incompatible: {
       stage: 'native', severity: 'blocked', defaultRetryable: true,
       fallbackUserMessage: 'Native host version or capabilities do not match the extension.',
@@ -363,6 +383,11 @@
       fallbackUserMessage: 'Local Codex skills could not be loaded. This run did not start.',
       fallbackNextAction: 'Open Skills to reload the local catalog, then submit again.'
     },
+    codex_context_limit: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'This run stopped because the model context limit was exceeded.',
+      fallbackNextAction: 'Retry the task. If the context limit is reached again, use /compact or start a new conversation with less context.'
+    },
     codex_no_usable_result: {
       stage: 'codex', severity: 'error', defaultRetryable: true,
       fallbackUserMessage: 'Local Codex returned no usable final report or operations.',
@@ -413,6 +438,11 @@
       fallbackUserMessage: 'The provider rate limit was reached.',
       fallbackNextAction: 'Wait for the rate-limit window to recover and retry.'
     },
+    provider_quota_exceeded: {
+      stage: 'codex', severity: 'error', defaultRetryable: true,
+      fallbackUserMessage: 'The model provider quota or billing limit was reached.',
+      fallbackNextAction: 'Check the provider account and plan, or switch model or provider before retrying.'
+    },
     provider_connection_timeout: {
       stage: 'codex', severity: 'error', defaultRetryable: true,
       fallbackUserMessage: 'The provider connection timed out.',
@@ -616,6 +646,7 @@
       nextAction: catalog.fallbackNextAction,
       evidence: {}
     };
+    if (canonicalCode === 'reviewing_unavailable') failure.changedDocument = false;
     if (legacyReason) {
       failure.technicalMessage = legacyReason;
     }
@@ -791,8 +822,20 @@
     return !path.startsWith('/') && !/^[A-Za-z]:/.test(path) && !path.split('/').includes('..') ? path : '';
   }
 
+  function isContextLimitError(message, code) {
+    const text = String(message || '');
+    return ['codex_context_limit', 'context_length_exceeded', 'context_window_exceeded'].includes(code)
+      || /\b(?:codex_context_limit|context_length_exceeded|context_window_exceeded)\b/i.test(text)
+      || /Codex ran out of room in the model['’]s context window/i.test(text)
+      || /maximum context length is \d+ tokens[\s\S]*?(?:you requested|resulted in) \d+ tokens/i.test(text);
+  }
+
   function recoverDisplayFailure(failure, allowFilePrefix = true) {
     if (!failure || typeof failure !== 'object') return failure;
+    if (failure.code === 'codex_no_usable_result' && failure.stage === 'codex'
+      && isContextLimitError(failure.technicalMessage)) return { ...failure, code: 'codex_context_limit',
+        userMessage: FAILURE_CODE_CATALOG.codex_context_limit.fallbackUserMessage,
+        nextAction: FAILURE_CODE_CATALOG.codex_context_limit.fallbackNextAction };
     const originalCode = failure.evidence?.originalCode;
     const displayCodeAllowed = code => REVIEW_DISPLAY_CODES.has(code)
       && (code !== 'native_untracked_undo_pending_changes'
@@ -829,7 +872,8 @@
   function formatFailureReasonForDisplay(failure, locale, i18nLookup) {
     const display = recoverDisplayFailure(failure);
     const lookup = typeof i18nLookup === 'function' ? i18nLookup : () => undefined;
-    const key = display?.code ? 'failureReason_' + display.code + '_user' : '';
+    const messageCode = getFailureMessageCode(display);
+    const key = messageCode ? 'failureReason_' + messageCode + '_user' : '';
     const template = key ? lookup(key) : '';
     const file = safeDisplayProjectPath(display?.file);
     const localized = localizeFailureReason(display ? { ...display, file } : display, locale, lookup);
@@ -838,6 +882,15 @@
     return { ...localized, code: display?.code, message, file, localized: Boolean(template && template !== key) };
   }
 
+  function getFailureMessageCode(failure) {
+    // Reload recovery retains its historical retry code. Only its presentation
+    // identifies the page interruption instead of a failed bridge request.
+    if (failure?.code === 'native_request_failed' && failure.source === 'panel_reload') {
+      return 'panel_reload_interrupted';
+    }
+    return typeof failure?.code === 'string' ? failure.code : '';
+  }
+
   function localizeFailureMessage(message, locale, i18nLookup) {
     return formatFailureReasonForDisplay({ code: 'unknown_legacy_failure', userMessage: message }, locale, i18nLookup).message;
   }
@@ -949,7 +1002,7 @@
       const value = typeof i18nLookup === 'function' ? i18nLookup(key) : undefined;
       return value && value !== key ? value : undefined;
     };
-    const code = failure && typeof failure.code === 'string' ? failure.code : '';
+    const code = getFailureMessageCode(failure);
     const userTemplate = code ? lookup('failureReason_' + code + '_user') : undefined;
     const nextTemplate = (code ? lookup('failureReason_' + code + '_next') : undefined)
       || (REVIEW_DISPLAY_CODES.has(code) ? lookup('failureReason_review_detail_next') : undefined);
@@ -989,6 +1042,7 @@
     selectPrimaryFailure,
     localizeFailureReason,
     formatFailureReasonForDisplay,
-    localizeFailureMessage
+    localizeFailureMessage,
+    isContextLimitError
   };
 });