codex-overleaf-link 2.5.1 → 2.6.0

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.',
@@ -232,6 +237,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.',
@@ -363,6 +373,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.',
@@ -616,6 +631,7 @@
       nextAction: catalog.fallbackNextAction,
       evidence: {}
     };
+    if (canonicalCode === 'reviewing_unavailable') failure.changedDocument = false;
     if (legacyReason) {
       failure.technicalMessage = legacyReason;
     }
@@ -791,8 +807,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 +857,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 +867,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 +987,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 +1027,7 @@
     selectPrimaryFailure,
     localizeFailureReason,
     formatFailureReasonForDisplay,
-    localizeFailureMessage
+    localizeFailureMessage,
+    isContextLimitError
   };
 });