codex-overleaf-link 2.2.1 → 2.3.1

package/extension/src/content/pageBridgeClient.js

@@ -0,0 +1,224 @@
+(function initCodexOverleafPageBridgeClient(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafPageBridgeClient = api;
+})(typeof window !== 'undefined' ? window : globalThis, function pageBridgeClientFactory() {
+  'use strict';
+
+  const PAGE_WORLD_SCRIPTS = Object.freeze([
+    ['src/shared/reviewing.js', 'codex-overleaf-reviewing-script'],
+    ['src/shared/projectFiles.js', 'codex-overleaf-project-files-script'],
+    ['src/shared/compatibility.js', 'codex-overleaf-compatibility-page-script'],
+    ['src/shared/pageRpcContract.js', 'codex-overleaf-page-rpc-contract-script'],
+    ['src/shared/staleGuard.js', 'codex-overleaf-stale-guard-script'],
+    ['src/shared/compileAdapter.js', 'codex-overleaf-compile-adapter-script'],
+    ['src/shared/sensitiveScan.js', 'codex-overleaf-sensitive-scan-script'],
+    ['src/shared/auditRecords.js', 'codex-overleaf-audit-records-script'],
+    ['src/page/saveState.js', 'codex-overleaf-save-state-script', true],
+    ['src/page/overleafCapabilities.js', 'codex-overleaf-capabilities-script'],
+    ['src/page/compileBridge.js', 'codex-overleaf-compile-bridge-script'],
+    ['src/page/overleafEditor.js', 'codex-overleaf-editor-script'],
+    ['src/page/overleafProjectSnapshot.js', 'codex-overleaf-project-snapshot-script'],
+    ['src/page/pageBridgeCapability.js', 'codex-overleaf-page-bridge-capability-script'],
+    ['src/page/treeOperations.js', 'codex-overleaf-tree-operations-script', true],
+    ['src/page/snapshotRouter.js', 'codex-overleaf-snapshot-router-script'],
+    ['src/page/writeGuard.js', 'codex-overleaf-write-guard-script', true],
+    ['src/page/trackedChangesLifecycle.js', 'codex-overleaf-tracked-changes-lifecycle-script', true],
+    ['src/page/writebackRouter.js', 'codex-overleaf-writeback-router-script', true],
+    ['src/pageBridge.js', 'codex-overleaf-page-bridge-script', true]
+  ]);
+  const OPTIONAL_OT_SCRIPTS = Object.freeze([
+    ['src/shared/otText.js', 'codex-overleaf-ot-text-script'],
+    ['src/page/overleafRealtimeObserver.js', 'codex-overleaf-realtime-observer-script']
+  ]);
+
+  function create(options = {}) {
+    const windowRef = options.window || globalThis.window;
+    const documentRef = options.document || windowRef?.document;
+    const chromeApi = options.chromeApi || globalThis.chrome;
+    const cryptoImpl = options.crypto || globalThis.crypto;
+    const runtimeRoot = options.root || windowRef;
+    const Contract = options.contract;
+    const Compatibility = options.compatibility;
+    const timeoutOverrides = { ...(options.timeoutOverrides || {}) };
+    const revision = Contract.REVISION;
+    const capability = createCapability(cryptoImpl);
+    const activeCancellationHandlers = new Map();
+    let readyPromise = null;
+
+    function start() {
+      if (!readyPromise) readyPromise = injectPageBridge();
+      return readyPromise;
+    }
+
+    async function call(method, params) {
+      try {
+        await start();
+      } catch (error) {
+        return { ok: false, error: `Page bridge unavailable: ${error.message}` };
+      }
+      return send(method, params, Contract.resolveDispatchPolicy(method, timeoutOverrides));
+    }
+
+    function send(method, params, policy = {}) {
+      const id = cryptoImpl.randomUUID();
+      return new Promise((resolve, reject) => {
+        const timeoutMs = Number.isFinite(Number(policy.timeoutMs))
+          ? Number(policy.timeoutMs)
+          : Contract.resolveTimeoutMs(method, timeoutOverrides);
+        const cancellable = policy.cancellation === 'content_abort';
+        let settled = false;
+        let timeout = null;
+        function cleanup() {
+          if (timeout !== null) windowRef.clearTimeout(timeout);
+          windowRef.removeEventListener('message', onMessage);
+          if (cancellable) activeCancellationHandlers.delete(id);
+        }
+        function resolveOnce(value) {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve(value);
+        }
+        function rejectOnce(error) {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(error);
+        }
+        function cancelRequest() {
+          const error = new Error('Codex run was cancelled by the user');
+          error.code = 'codex_cancelled';
+          error.cancelled = true;
+          rejectOnce(error);
+        }
+        timeout = windowRef.setTimeout(() => {
+          resolveOnce({ ok: false, error: 'Page bridge timed out' });
+        }, timeoutMs);
+        function onMessage(event) {
+          if (event.source !== windowRef
+            || event.origin !== windowRef.location.origin
+            || event.data?.source !== 'codex-overleaf/page'
+            || event.data?.pageBridgeVersion !== Compatibility?.BUILD_TARGET_VERSION
+            || event.data?.pageBridgeRevision !== revision
+            || event.data.id !== id) {
+            return;
+          }
+          resolveOnce(event.data.result);
+        }
+        if (cancellable) {
+          activeCancellationHandlers.set(id, cancelRequest);
+          if (options.isCancellationRequested?.()) windowRef.queueMicrotask(cancelRequest);
+        }
+        windowRef.addEventListener('message', onMessage);
+        // Every low-level request remains one attempt. Higher layers must opt
+        // into replay so a document mutation is never duplicated implicitly.
+        windowRef.postMessage({
+          source: 'codex-overleaf/content',
+          id,
+          method,
+          params,
+          capability
+        }, windowRef.location.origin);
+      });
+    }
+
+    function cancelActiveRequests() {
+      const handlers = Array.from(activeCancellationHandlers.values());
+      activeCancellationHandlers.clear();
+      handlers.forEach(cancel => cancel());
+    }
+
+    function resolveTimeoutMs(method) {
+      return Contract.resolveTimeoutMs(method, timeoutOverrides);
+    }
+
+    async function injectPageBridge() {
+      const splitAt = PAGE_WORLD_SCRIPTS.findIndex(([src]) =>
+        src === 'src/page/pageBridgeCapability.js'
+      );
+      for (const [src, id, force] of PAGE_WORLD_SCRIPTS.slice(0, splitAt)) {
+        await injectScriptOnce(src, id, { force });
+      }
+      await injectOptionalOtDependencies();
+      for (const [src, id, force] of PAGE_WORLD_SCRIPTS.slice(splitAt)) {
+        await injectScriptOnce(src, id, { force });
+      }
+      await initializeCapability();
+    }
+
+    async function injectOptionalOtDependencies() {
+      try {
+        for (const [src, id] of OPTIONAL_OT_SCRIPTS) await injectScriptOnce(src, id);
+      } catch (_error) {
+        // The page bridge keeps its read-only unavailable fallback.
+      }
+    }
+
+    function injectScriptOnce(src, id, injectOptions = {}) {
+      return new Promise((resolve, reject) => {
+        const existing = documentRef.getElementById(id);
+        if (existing && injectOptions.force !== true) {
+          resolve();
+          return;
+        }
+        existing?.remove?.();
+        const script = documentRef.createElement('script');
+        const timeout = windowRef.setTimeout(() => {
+          cleanup();
+          reject(new Error(`Timed out loading ${src}`));
+        }, 8000);
+        function cleanup() {
+          windowRef.clearTimeout(timeout);
+          script.onload = null;
+          script.onerror = null;
+          script.remove();
+        }
+        script.id = id;
+        const runtimePrefix = String(runtimeRoot.__CODEX_OVERLEAF_RUNTIME_PREFIX__ || '');
+        script.src = chromeApi.runtime.getURL(runtimePrefix + src);
+        script.onload = () => {
+          cleanup();
+          resolve();
+        };
+        script.onerror = () => {
+          cleanup();
+          reject(new Error(`Failed to load ${src}`));
+        };
+        (documentRef.head || documentRef.documentElement).append(script);
+      });
+    }
+
+    async function initializeCapability() {
+      const result = await send(
+        'initializeCapability',
+        {},
+        Contract.resolveDispatchPolicy('initializeCapability', timeoutOverrides)
+      );
+      if (!result?.ok) {
+        throw new Error(result?.error || result?.reason || 'Page bridge capability initialization failed');
+      }
+    }
+
+    return Object.freeze({
+      call,
+      cancelActiveRequests,
+      resolveTimeoutMs,
+      send,
+      start
+    });
+  }
+
+  function createCapability(cryptoImpl) {
+    if (cryptoImpl?.randomUUID) return cryptoImpl.randomUUID();
+    const bytes = new Uint8Array(24);
+    cryptoImpl.getRandomValues(bytes);
+    return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
+  }
+
+  return Object.freeze({
+    OPTIONAL_OT_SCRIPTS,
+    PAGE_WORLD_SCRIPTS,
+    create
+  });
+});

package/extension/src/content/panelMaintenance.js

@@ -29,6 +29,7 @@
       setState,
       getCurrentRunView,
       getSettingsPanelInstance,
+      StorageDb
     } = deps;
 
   // --- Change history (v1.7.5): the audit log finally gets a read path. ---
@@ -48,7 +49,6 @@
     list.textContent = tx('Loading\u2026', '正在加载…');
     let records = [];
     try {
-      const StorageDb = window.CodexOverleafStorageDb;
       records = StorageDb?.getAllByIndex
         ? await StorageDb.getAllByIndex('auditLogs', 'projectId', getCurrentProjectId())
         : [];
@@ -171,7 +171,7 @@
       return;
     }
     try {
-      await window.CodexOverleafStorageDb?.clearAllStores?.();
+      await StorageDb?.clearAllStores?.();
       // v1.8.1: the dashboard's project-name cache lives in
       // chrome.storage.local, outside the IndexedDB stores — clear it too so
       // no (potentially sensitive) project titles outlive the wipe.
@@ -244,7 +244,12 @@
       return;
     }
     try {
-      await callPageBridge('jumpToPosition', { path: target, from: 0, to: 0 });
+      await callPageBridge('jumpToPosition', {
+        path: target,
+        from: 0,
+        to: 0,
+        runProjectId: getCurrentProjectId()
+      });
     } catch (error) {
       showPluginToast(tx(`Could not open ${target}: ${error.message}`, `无法打开 ${target}：${error.message}`));
     }

package/extension/src/content/postNavigationSettlementPersistence.js

@@ -0,0 +1,100 @@
+(function initPostNavigationSettlementPersistence(root, factory) {
+  const api = factory();
+  if (typeof module === 'object' && module.exports) module.exports = api;
+  if (root) root.CodexOverleafPostNavigationSettlementPersistence = api;
+})(typeof window !== 'undefined' ? window : globalThis, function postNavigationSettlementPersistenceFactory() {
+  'use strict';
+
+  async function persist(options = {}) {
+    if (options.__insideScopedTransaction !== true) {
+      const accountScopeId = String(options.accountScopeId || '').trim();
+      const projectId = String(options.projectId || '').trim();
+      if (!accountScopeId) {
+        return { ok: false, reason: 'account_scope_unavailable' };
+      }
+      if (!projectId) {
+        return { ok: false, reason: 'project_scope_unavailable' };
+      }
+      if (!options.PersistenceCoordinator
+        || typeof options.PersistenceCoordinator.commitDetached !== 'function') {
+        return { ok: false, reason: 'scoped_persistence_unavailable' };
+      }
+      const committed = await options.PersistenceCoordinator.commitDetached(
+        projectId,
+        accountScopeId,
+        { rebase: true },
+        () => persist({
+          ...options,
+          __insideScopedTransaction: true
+        })
+      );
+      if (!committed || typeof committed !== 'object') {
+        return { ok: false, reason: 'scoped_persistence_invalid_result' };
+      }
+      if (committed.ok !== true) return committed;
+      if (!Object.prototype.hasOwnProperty.call(committed, 'value')) return committed;
+      return committed.value && typeof committed.value === 'object'
+        ? committed.value
+        : { ok: false, reason: 'scoped_persistence_action_result_unavailable' };
+    }
+    const {
+      StorageDb,
+      WritebackSettlement,
+      sessionId,
+      runId,
+      status,
+      statusText,
+      finishedAt,
+      settlementResult
+    } = options;
+    if (!StorageDb || !WritebackSettlement || !sessionId || !runId || !status) {
+      return { ok: false, reason: 'invalid_post_navigation_settlement' };
+    }
+    const record = await StorageDb.getRecord('sessions', sessionId);
+    if (!record) return { ok: false, reason: 'session_not_found' };
+    if (String(record.accountScopeId || '').trim() !== String(options.accountScopeId || '').trim()) {
+      return { ok: false, reason: 'account_scope_mismatch' };
+    }
+    if (String(record.projectId || '').trim() !== String(options.projectId || '').trim()) {
+      return { ok: false, reason: 'project_scope_mismatch' };
+    }
+    const runs = Array.isArray(record.runs) ? [...record.runs] : [];
+    const runIndex = runs.findIndex(run => run && run.id === runId);
+    if (runIndex < 0) return { ok: false, reason: 'run_not_found' };
+
+    let transitioned = settlementResult
+      ? WritebackSettlement.applySettlementTransition(runs[runIndex], settlementResult)
+      : { ...runs[runIndex] };
+    transitioned = WritebackSettlement.applySettlementTransition(
+      transitioned,
+      WritebackSettlement.transitionPostNavigationStatus({
+        status,
+        statusText,
+        finishedAt: finishedAt || transitioned.finishedAt || new Date().toISOString()
+      })
+    );
+    runs[runIndex] = transitioned;
+
+    const now = options.now || new Date().toISOString();
+    record.runs = runs;
+    record.lastActivityAt = now;
+    record.updatedAt = now;
+    await StorageDb.putRecord('sessions', record);
+    return { ok: true, run: transitioned };
+  }
+
+  async function persistRequired(options = {}) {
+    const result = await persist(options);
+    if (result?.ok === true) return result;
+    const reason = String(result?.reason || 'unknown_failure');
+    throw Object.assign(
+      new Error(`Post-navigation settlement persistence failed: ${reason}`),
+      {
+        code: 'post_navigation_settlement_persistence_failed',
+        reason
+      }
+    );
+  }
+
+  return Object.freeze({ persist, persistRequired });
+});

package/extension/src/content/projectProviderSelection.js

@@ -30,24 +30,16 @@
       const nextSpeedTier = deps.readSelectedSpeed?.() || state.speedTier;
       const runSelection = deps.getRunSelection?.(nextProviderId);
       const nextProviderRevision = Number(runSelection?.providerRevision || 0);
+      const providerConfigurationChanged = nextProviderId === (state.providerId || 'builtin')
+        && nextProviderRevision !== Number(state.providerRevision || 0);
+      const resetProviderThread = providerChanged || providerConfigurationChanged;
       const sessions = (state.sessions || []).map(session => ({
         ...session,
         providerId: nextProviderId,
         model: nextModel,
         reasoningEffort: nextReasoningEffort,
         speedTier: nextSpeedTier,
-        codexThreadId: providerChanged ? '' : session.codexThreadId,
-        pendingInputs: (session.pendingInputs || []).map(item => ({
-          ...item,
-          payload: {
-            ...(item.payload || {}),
-            providerId: nextProviderId,
-            providerRevision: nextProviderRevision,
-            model: nextModel,
-            reasoningEffort: nextReasoningEffort,
-            speedTier: nextSpeedTier
-          }
-        }))
+        codexThreadId: resetProviderThread ? '' : session.codexThreadId
       }));
       deps.setState?.(deps.normalizeState({
         ...state,

package/extension/src/content/projectSessionCleanup.js

@@ -23,8 +23,8 @@
     }
 
     async function clearProjectSessions(projectId, projectName) {
-      const StorageDb = window.CodexOverleafStorageDb;
-      const SessionState = window.CodexOverleafSessionState;
+      const StorageDb = deps.StorageDb;
+      const SessionState = deps.SessionState;
       if (!StorageDb || !SessionState) {
         return;
       }
@@ -49,7 +49,7 @@
       if (!approved) {
         return;
       }
-      const Migration = window.CodexOverleafStorageMigration;
+      const Migration = deps.StorageMigration;
       if (Migration?.addSessionTombstones) {
         await Migration.addSessionTombstones(projectId, records.map(record => record.id));
       }

package/extension/src/content/providerSettingsCoordinator.js

@@ -2,8 +2,13 @@
   'use strict';
 
   function create(options = {}) {
-    const Profiles = window.CodexOverleafProviderProfiles;
+    const Profiles = options.ProviderProfiles;
+    const Dialog = options.ProviderSettingsDialog;
+    if (!Profiles || !Dialog?.create) {
+      throw new Error('Provider settings require explicit profile and dialog dependencies.');
+    }
     const instance = {
+      Profiles,
       tx: options.tx || ((english) => english),
       sendBackgroundNative: options.sendBackgroundNative,
       getSettingsPanelInstance: options.getSettingsPanelInstance || (() => null),
@@ -21,12 +26,24 @@
       channel: null,
       dialog: null
     };
-    instance.onProviderChanged = options.onProviderChanged
+    const projectProviderChanged = options.onProviderChanged
       || ((catalog, change) => reconcileProviderSelection(instance, catalog, change));
-    instance.dialog = window.CodexOverleafProviderSettingsDialog.create({
+    instance.onProviderChanged = async (catalog, change) => {
+      const previousProviderId = instance.getSelectedProviderId() || 'builtin';
+      const result = await projectProviderChanged(catalog, change);
+      const nextProviderId = instance.getSelectedProviderId() || 'builtin';
+      updateSettingsSummary(instance);
+      if (previousProviderId !== nextProviderId && instance.dialog?.isOpen?.()) {
+        instance.dialog.setCatalog(instance.catalog, nextProviderId);
+      }
+      return result;
+    };
+    instance.dialog = Dialog.create({
       document: options.document || document,
       tx: instance.tx,
+      ProviderProfiles: Profiles,
       callbacks: {
+        getCurrentProjectProviderId: () => instance.getSelectedProviderId() || 'builtin',
         onTest: context => testProvider(instance, context),
         onCancelTest: () => cancelProviderTest(instance),
         onSave: (context, action) => saveProvider(instance, context, action),
@@ -135,7 +152,7 @@
       await ensureLoadedWithRetry(instance);
     } catch (_error) {
       return instance.refreshModelOptions(
-        window.CodexOverleafProviderProfiles.buildRunSelection(instance.catalog, instance.getSelectedProviderId())
+        instance.Profiles.buildRunSelection(instance.catalog, instance.getSelectedProviderId())
       );
     }
     return reconcileProviderSelection(instance, instance.catalog, { forceSessionRefresh: true });
@@ -143,12 +160,18 @@
 
   async function reconcileProviderSelection(instance, catalog, change = {}) {
     const previousProviderId = instance.getSelectedProviderId() || 'builtin';
-    const requestedProviderId = typeof change.sessionProviderId === 'string' && change.sessionProviderId
+    let requestedProviderId = typeof change.sessionProviderId === 'string' && change.sessionProviderId
       ? change.sessionProviderId
       : previousProviderId;
+    const requestedProviderAvailable = requestedProviderId === 'builtin'
+      || Boolean(instance.Profiles.getProviderById(catalog, requestedProviderId));
+    const selectedProviderWasRemoved = !requestedProviderAvailable;
+    if (selectedProviderWasRemoved) {
+      requestedProviderId = 'builtin';
+    }
     const projectProviderChanged = requestedProviderId !== previousProviderId;
-    if (projectProviderChanged && change.providerSwitchApproved !== true) {
-      const requestedProvider = window.CodexOverleafProviderProfiles.getProviderById(catalog, requestedProviderId);
+    if (projectProviderChanged && !selectedProviderWasRemoved && change.providerSwitchApproved !== true) {
+      const requestedProvider = instance.Profiles.getProviderById(catalog, requestedProviderId);
       const approved = await instance.confirmProviderSwitch({
         providerId: requestedProviderId,
         providerName: requestedProvider?.name || requestedProviderId
@@ -158,13 +181,14 @@
       }
     }
     const changedProviderIds = Array.isArray(change.changedProviderIds) ? change.changedProviderIds : [];
-    if (!change.forceSessionRefresh && !projectProviderChanged && !changedProviderIds.includes(requestedProviderId)) {
+    const providerConfigurationChanged = changedProviderIds.includes(requestedProviderId);
+    if (!change.forceSessionRefresh && !projectProviderChanged && !providerConfigurationChanged) {
       return;
     }
     const loadResult = change.modelsPreloaded === true
       ? { stale: false, selectedModel: change.preloadedModelId || '' }
       : await instance.refreshModelOptions(
-        window.CodexOverleafProviderProfiles.buildRunSelection(catalog, requestedProviderId),
+        instance.Profiles.buildRunSelection(catalog, requestedProviderId),
         { persist: false }
       );
     if (loadResult?.stale || loadResult?.error) {
@@ -175,7 +199,7 @@
       error.details = loadResult?.error || {};
       throw error;
     }
-    if (projectProviderChanged) {
+    if (projectProviderChanged || providerConfigurationChanged) {
       await instance.setSelectedProviderId(requestedProviderId, loadResult?.selectedModel || '');
     }
     await instance.persistInputs();
@@ -185,7 +209,7 @@
 
   async function prepareProviderActivation(instance, providerId) {
     const previousProviderId = instance.getSelectedProviderId() || 'builtin';
-    const provider = window.CodexOverleafProviderProfiles.getProviderById(instance.catalog, providerId);
+    const provider = instance.Profiles.getProviderById(instance.catalog, providerId);
     if (providerId !== previousProviderId) {
       const approved = await instance.confirmProviderSwitch({
         providerId,
@@ -196,13 +220,13 @@
       }
     }
     const result = await instance.refreshModelOptions(
-      window.CodexOverleafProviderProfiles.buildRunSelection(instance.catalog, providerId),
+      instance.Profiles.buildRunSelection(instance.catalog, providerId),
       { persist: false }
     );
     if (result?.stale || result?.error) {
       if (providerId !== previousProviderId) {
         await instance.refreshModelOptions(
-          window.CodexOverleafProviderProfiles.buildRunSelection(instance.catalog, previousProviderId),
+          instance.Profiles.buildRunSelection(instance.catalog, previousProviderId),
           { persist: false }
         ).catch(() => {});
       }
@@ -293,7 +317,11 @@
         selectedId: result.savedProviderId
       });
       await notifyChanged(instance, applied.change, action.activate === true
-        ? { sessionProviderId: result.savedProviderId }
+        ? {
+          sessionProviderId: result.savedProviderId,
+          providerSwitchApproved: true,
+          requireProjection: true
+        }
         : {});
       instance.dialog.setBusy('', '');
       const fellBackToBuiltin = previousCatalog.activeProviderId === result.savedProviderId
@@ -389,7 +417,7 @@
     } catch (error) {
       if (preparation?.previousProviderId && preparation.previousProviderId !== context.profileId) {
         await instance.refreshModelOptions(
-          window.CodexOverleafProviderProfiles.buildRunSelection(instance.catalog, preparation.previousProviderId),
+          instance.Profiles.buildRunSelection(instance.catalog, preparation.previousProviderId),
           { persist: false }
         ).catch(() => {});
       }
@@ -423,7 +451,7 @@
     } catch (error) {
       if (preparation?.previousProviderId && preparation.previousProviderId !== 'builtin') {
         await instance.refreshModelOptions(
-          window.CodexOverleafProviderProfiles.buildRunSelection(instance.catalog, preparation.previousProviderId),
+          instance.Profiles.buildRunSelection(instance.catalog, preparation.previousProviderId),
           { persist: false }
         ).catch(() => {});
       }
@@ -448,7 +476,7 @@
   }
 
   function applyCatalog(instance, result, options = {}) {
-    const nextCatalog = window.CodexOverleafProviderProfiles.normalizeCatalog(result);
+    const nextCatalog = instance.Profiles.normalizeCatalog(result);
     if (instance.loaded && nextCatalog.storeRevision < instance.catalog.storeRevision) {
       return { applied: false, change: emptyCatalogChange() };
     }
@@ -463,19 +491,19 @@
         instance.dialog.setCatalog(instance.catalog, options.selectedId);
       }
     }
-    return { applied: true, change: describeCatalogChange(previousCatalog, nextCatalog) };
+    return { applied: true, change: describeCatalogChange(instance, previousCatalog, nextCatalog) };
   }
 
   function updateSettingsSummary(instance, override = {}) {
     const selectedProviderId = instance.getSelectedProviderId() || 'builtin';
-    const catalogProvider = window.CodexOverleafProviderProfiles.getProviderById(
+    const catalogProvider = instance.Profiles.getProviderById(
       instance.catalog,
       selectedProviderId
     );
     const selectedProvider = catalogProvider?.id === selectedProviderId
       ? catalogProvider
       : (selectedProviderId === 'builtin'
-        ? window.CodexOverleafProviderProfiles.getActiveProvider(instance.catalog)
+        ? instance.Profiles.getActiveProvider(instance.catalog)
         : {
           id: selectedProviderId,
           name: selectedProviderId,
@@ -528,16 +556,16 @@
     }
   }
 
-  function describeCatalogChange(previous, next) {
-    const previousActive = window.CodexOverleafProviderProfiles.getActiveProvider(previous);
-    const nextActive = window.CodexOverleafProviderProfiles.getActiveProvider(next);
+  function describeCatalogChange(instance, previous, next) {
+    const previousActive = instance.Profiles.getActiveProvider(previous);
+    const nextActive = instance.Profiles.getActiveProvider(next);
     const providerIds = new Set([
       ...(previous.providers || []).map(provider => provider.id),
       ...(next.providers || []).map(provider => provider.id)
     ]);
     const changedProviderIds = Array.from(providerIds).filter(providerId => {
-      const previousProvider = window.CodexOverleafProviderProfiles.getProviderById(previous, providerId);
-      const nextProvider = window.CodexOverleafProviderProfiles.getProviderById(next, providerId);
+      const previousProvider = instance.Profiles.getProviderById(previous, providerId);
+      const nextProvider = instance.Profiles.getProviderById(next, providerId);
       return modelCatalogSignature(previousProvider) !== modelCatalogSignature(nextProvider);
     });
     return {
@@ -548,8 +576,13 @@
   }
 
   function modelCatalogSignature(provider = {}) {
+    provider = provider || {};
     return JSON.stringify({
       id: provider.id || '',
+      revision: Number(provider.revision || 0),
+      baseUrl: provider.baseUrl || '',
+      wireApiPreference: provider.wireApiPreference || '',
+      resolvedWireApi: provider.resolvedWireApi || '',
       defaultModelId: provider.defaultModelId || '',
       reasoningAdapter: provider.reasoningAdapter || '',
       reasoningCapability: provider.reasoningCapability || '',
@@ -567,7 +600,7 @@
 
   function getProviderSnapshot(instance, providerId) {
     const requestedId = providerId || instance.getSelectedProviderId() || 'builtin';
-    const provider = window.CodexOverleafProviderProfiles.getProviderById(instance.catalog, requestedId);
+    const provider = instance.Profiles.getProviderById(instance.catalog, requestedId);
     if (!provider) {
       return {
         providerId: requestedId,