codex-overleaf-link 1.9.13 → 2.1.0

package/extension/src/page/trackedChangesLifecycle.js

@@ -88,7 +88,9 @@
         skipped
       };
     }
-    const snapshotUndo = await restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles);
+    const snapshotUndo = await restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles, {
+      runProjectId: params.runProjectId
+    });
     if (snapshotUndo.attempted) {
       applied.push(...snapshotUndo.applied);
       skipped.push(...snapshotUndo.skipped);
@@ -291,6 +293,7 @@
       .filter(file => file?.path && typeof file.content === 'string')
       .map(file => [normalizeSafeProjectPath(file.path), file.content])
       .filter(([path]) => path));
+    let snapshotContextRebased = false;
     const paths = Array.from(expectedByPath.keys()).filter(path => postByPath.has(path));
     if (!paths.length) {
       return {
@@ -313,30 +316,63 @@
     // the reject path relies on (its primary path).
     const appliedBeforeUndo = applied.length;
     const editorUndo = await rejectTrackedChangesViaEditorUndo(expectedFiles, postFiles, applied);
+    let undoReady = editorUndo.ok === true;
+    let snapshotUndo = null;
+    // A page refresh preserves the run checkpoint but clears CodeMirror's
+    // in-memory undo history. When the native editor undo made no progress,
+    // reuse Undo's guarded snapshot path: it first verifies that every file is
+    // still exactly at this run's post-write content, then restores the
+    // persisted pre-write content with Track Changes disabled. The normal
+    // Accept replay below can then apply the post-write patch untracked.
+    if (!undoReady && applied.length === appliedBeforeUndo) {
+      snapshotUndo = await restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles, {
+        runProjectId: params.runProjectId
+      });
+      if (snapshotUndo.ok) {
+        applied.push(...snapshotUndo.applied);
+        for (const file of snapshotUndo.rebasedExpectedFiles || []) {
+          expectedByPath.set(file.path, file.content);
+        }
+        for (const file of snapshotUndo.rebasedPostFiles || []) {
+          if (postByPath.get(file.path) !== file.content) {
+            snapshotContextRebased = true;
+          }
+          postByPath.set(file.path, file.content);
+        }
+        undoReady = true;
+      }
+    }
     pushDiagnostic('editorUndo', {
-      ok: editorUndo.ok === true,
+      ok: undoReady,
       attempted: editorUndo.attempted === true,
       code: editorUndo.code || '',
       reason: editorUndo.reason || '',
-      pathsProcessed: applied.length - appliedBeforeUndo
+      pathsProcessed: applied.length - appliedBeforeUndo,
+      snapshotFallbackAttempted: snapshotUndo?.attempted === true,
+      snapshotFallbackOk: snapshotUndo?.ok === true,
+      snapshotFallbackApplied: snapshotUndo?.applied?.length || 0,
+      snapshotFallbackSkipped: snapshotUndo?.skipped?.length || 0
     });
-    if (!editorUndo.ok) {
-      // Drift bail: the editor-undo could not reach the pre-write state. Do NOT
-      // re-write — that would only make the document worse. Return not-ok so the
-      // run stays pending and the user can retry, same as Undo.
+    if (!undoReady) {
+      // Drift or a partial editor undo still bails. The snapshot fallback is
+      // allowed only when editor undo made no progress, and its own post-state
+      // verification prevents overwriting edits made after this run.
+      const snapshotFailure = snapshotUndo?.skipped?.[0]?.result;
       return {
         ok: false,
-        applied: [],
-        skipped: [{
-          trackedChange: null,
-          result: editorUndo.attempted || editorUndo.code
-            ? editorUndo
-            : {
-              ok: false,
-              code: 'accept_editor_undo_unavailable',
-              reason: '没有可执行的 Overleaf 原生撤销来清掉本轮留痕；Codex 没有接受这轮改动。'
-            }
-        }],
+        applied: snapshotUndo?.applied || [],
+        skipped: snapshotUndo?.skipped?.length
+          ? snapshotUndo.skipped
+          : [{
+            trackedChange: null,
+            result: snapshotFailure || (editorUndo.attempted || editorUndo.code
+              ? editorUndo
+              : {
+                ok: false,
+                code: 'accept_editor_undo_unavailable',
+                reason: '没有可执行的 Overleaf 原生撤销或安全快照回滚来清掉本轮留痕；Codex 没有接受这轮改动。'
+              })
+          }],
         diagnostics
       };
     }
@@ -417,7 +453,12 @@
     // applyOperationsCore — never a whole-file replaceAll, which would clobber
     // any unrelated content and produce one giant tracked change if anything
     // about the mode switch were imperfect.
-    const operationsResult = buildAcceptReplayOperations(paths, expectedByPath, postByPath, params.appliedOperations);
+    const operationsResult = buildAcceptReplayOperations(
+      paths,
+      expectedByPath,
+      postByPath,
+      snapshotContextRebased ? [] : params.appliedOperations
+    );
     if (!operationsResult.ok) {
       if (weToggledOff) {
         await setReviewingEnabled(true, { waitMs: 1800 });
@@ -975,7 +1016,7 @@
     return { ok: true, attempted: true };
   }
 
-  async function restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles) {
+  async function restoreExpectedFilesWithNoTraceUndo(expectedFiles, postFiles, options = {}) {
     const expectedByPath = new Map((expectedFiles || [])
       .filter(file => file?.path && typeof file.content === 'string')
       .map(file => [normalizeSafeProjectPath(file.path), file.content])
@@ -985,12 +1026,16 @@
       .map(file => [normalizeSafeProjectPath(file.path), file.content])
       .filter(([path]) => path));
     const paths = Array.from(expectedByPath.keys()).filter(path => postByPath.has(path));
+    const rebasedExpectedByPath = new Map();
+    const rebasedPostByPath = new Map();
     if (!paths.length) {
       return {
         ok: false,
         attempted: false,
         applied: [],
-        skipped: []
+        skipped: [],
+        rebasedExpectedFiles: [],
+        rebasedPostFiles: []
       };
     }
 
@@ -1008,30 +1053,40 @@
           };
         }
       }
-      const ready = await waitForActiveEditorExpectedText(path, postByPath.get(path), 1500);
+      const ready = await waitForActiveEditorCheckpoint(
+        path,
+        expectedByPath.get(path),
+        postByPath.get(path),
+        1500
+      );
       if (!ready.ok) {
         return {
           ok: false,
           attempted: false,
           applied: [],
           skipped: [],
+          rebasedExpectedFiles: [],
+          rebasedPostFiles: [],
           code: 'snapshot_undo_current_mismatch',
           reason: `${path} 当前内容已经不是本轮写入后的内容；为避免覆盖你的后续修改，Codex 不执行快照撤销。`
         };
       }
+      rebasedExpectedByPath.set(path, ready.expectedContent);
+      rebasedPostByPath.set(path, ready.postContent);
     }
 
     const operations = paths.map(path => ({
       type: 'edit',
       path,
-      replaceAll: expectedByPath.get(path),
+      replaceAll: rebasedExpectedByPath.get(path),
       reason: 'Undo tracked edit'
     }));
     const result = await applyOperationsWithNoTraceUndo(operations, {
       baseFiles: paths.map(path => ({
         path,
-        content: postByPath.get(path)
-      }))
+        content: rebasedPostByPath.get(path)
+      })),
+      runProjectId: typeof options.runProjectId === 'string' ? options.runProjectId : ''
     });
     const toTrackedResult = item => ({
       trackedChange: {
@@ -1046,7 +1101,66 @@
       ok: !(result.skipped || []).length,
       attempted: true,
       applied: (result.applied || []).map(toTrackedResult),
-      skipped: (result.skipped || []).map(toTrackedResult)
+      skipped: (result.skipped || []).map(toTrackedResult),
+      rebasedExpectedFiles: paths.map(path => ({
+        path,
+        content: rebasedExpectedByPath.get(path)
+      })),
+      rebasedPostFiles: paths.map(path => ({
+        path,
+        content: rebasedPostByPath.get(path)
+      }))
+    };
+  }
+
+  async function waitForActiveEditorCheckpoint(filePath, expectedContent, postContent, timeoutMs) {
+    const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0);
+    let actual = readActiveEditorText();
+    while (Date.now() < deadline) {
+      const activeFileMatches = !filePath || getActiveFilePath() === filePath;
+      actual = readActiveEditorText();
+      if (activeFileMatches) {
+        const rebased = rebaseCheckpointPair(actual, expectedContent, postContent);
+        if (rebased.ok) {
+          return rebased;
+        }
+      }
+      await delay(60);
+    }
+    return {
+      ok: false,
+      text: actual
+    };
+  }
+
+  function rebaseCheckpointPair(actualContent, expectedContent, postContent) {
+    const actual = String(actualContent ?? '');
+    const expected = String(expectedContent ?? '');
+    const post = String(postContent ?? '');
+    if (actual === post) {
+      return {
+        ok: true,
+        expectedContent: expected,
+        postContent: post,
+        prefixLength: 0,
+        suffixLength: 0
+      };
+    }
+    if (!post) {
+      return { ok: false };
+    }
+    const matchIndex = actual.indexOf(post);
+    if (matchIndex < 0 || actual.indexOf(post, matchIndex + 1) >= 0) {
+      return { ok: false };
+    }
+    const prefix = actual.slice(0, matchIndex);
+    const suffix = actual.slice(matchIndex + post.length);
+    return {
+      ok: true,
+      expectedContent: prefix + expected + suffix,
+      postContent: actual,
+      prefixLength: prefix.length,
+      suffixLength: suffix.length
     };
   }
 
@@ -1319,6 +1433,20 @@
 
 
 
+  function diffTrackedChangeRefs(before = [], after = []) {
+    const beforeKeys = new Set((before || []).map(ref => ref.key).filter(Boolean));
+    const seen = new Set();
+    const added = [];
+    for (const ref of after || []) {
+      if (!ref?.key || beforeKeys.has(ref.key) || seen.has(ref.key)) {
+        continue;
+      }
+      seen.add(ref.key);
+      added.push(ref);
+    }
+    return added;
+  }
+
   async function waitForTrackedChangeDiff(trackedBefore, paths, options = {}) {
     const waitMs = Number.isFinite(Number(options.waitMs)) ? Number(options.waitMs) : 3000;
     const intervalMs = Number.isFinite(Number(options.intervalMs)) ? Number(options.intervalMs) : 180;

package/extension/src/page/writebackRouter.js

@@ -791,19 +791,17 @@
     }
     const trackedChanges = [];
     if (observeTrackedChanges) {
-      const trackedDiff = forbidTrackedChanges
-        ? await waitForTrackedChangeDiff(trackedBefore, operationPaths, {
-          waitMs: 3600,
-          intervalMs: 180
-        })
-        : (() => null)();
-      if (trackedDiff) {
-        trackedChanges.push(...trackedDiff.trackedChanges);
-      } else {
-        await delay(120);
-        const trackedAfter = collectTrackedChangeRefsForPaths(operationPaths);
-        trackedChanges.push(...diffTrackedChangeRefs(trackedBefore, trackedAfter));
-      }
+      // Overleaf renders review markers asynchronously after the editor text
+      // has already changed. A single 120 ms snapshot intermittently missed
+      // those markers, leaving a Reviewing write with Undo but no Accept.
+      // Poll both paths: normal Reviewing writes get a shorter capture window,
+      // while Accept replay keeps the longer safety window used to prove that
+      // it did not create fresh tracked changes.
+      const trackedDiff = await waitForTrackedChangeDiff(trackedBefore, operationPaths, {
+        waitMs: forbidTrackedChanges ? 3600 : 1800,
+        intervalMs: 180
+      });
+      trackedChanges.push(...trackedDiff.trackedChanges);
       if (forbidTrackedChanges && trackedChanges.length > 0) {
         return {
           ok: false,
@@ -881,55 +879,42 @@
     const previousEditorIdentity = getActiveEditorIdentity();
     const previousSignature = contentSignature(currentText);
 
-    // §9.1 target_file_not_found: if the target path is not visible in the
-    // Overleaf project file tree, refuse the write before attempting to open.
-    // openFileByPath itself would fail anyway, but emitting the canonical
-    // path-not-found code (rather than a generic open failure) gives the run
-    // card / final report a more actionable presentation per §17.3.1.
-    // Only fires when the tree-operations layer actually exposes a
-    // projectPathExists hook; older harnesses without the hook fall through
-    // to the openFileByPath path and surface a generic open failure.
-    if (operation?.type === 'edit' && hasProjectPathExistsHook() && !projectPathExists(filePath)) {
-      return {
-        ok: false,
-        code: 'path_not_found',
-        reason: `Cannot edit ${filePath}; the path is not in the Overleaf project file tree.`,
-        failure: buildPageFailure('target_file_not_found', {
-          file: filePath,
-          activeFile: initialActivePath || '',
-          operationType: operation?.type || 'edit',
-          changedDocument: false,
-          userMessage: `Codex could not find ${filePath} in this Overleaf project.`,
-          evidence: {
-            originalCode: 'path_not_found',
-            initialActivePath: initialActivePath || '',
-            writeStarted: false
-          }
-        })
-      };
-    }
-
     const opened = await openFileByPath(filePath, { force: initialActivePath === filePath });
     if (!opened.ok) {
-      const reasonText = `Cannot edit ${filePath}; active file is ${initialActivePath || 'unknown'}; ${opened.reason}`;
+      // A collapsed folder can make a real nested file temporarily invisible
+      // to projectPathExists(). openFileByPath() owns the side-effecting
+      // expand-and-open attempt, so only classify the path as missing after
+      // that attempt has failed and the path still cannot be observed.
+      const pathMissing = operation?.type === 'edit'
+        && hasProjectPathExistsHook()
+        && !projectPathExists(filePath);
+      const resultCode = pathMissing ? 'path_not_found' : 'file_open_failed';
+      const failureCode = pathMissing ? 'target_file_not_found' : 'target_file_open_failed';
+      const reasonText = pathMissing
+        ? `Cannot edit ${filePath}; the path was not found after Overleaf tried to open it.`
+        : `Cannot edit ${filePath}; active file is ${initialActivePath || 'unknown'}; ${opened.reason}`;
       return {
         ok: false,
-        code: 'file_open_failed',
-        debug: buildWritebackDebug('open_file_failed', operation, baseFileLookup, currentText, {
+        code: resultCode,
+        debug: buildWritebackDebug(pathMissing ? 'open_file_path_not_found' : 'open_file_failed', operation, baseFileLookup, currentText, {
           initialActivePath,
           opened
         }),
         reason: reasonText,
-        failure: buildPageFailure('target_file_open_failed', {
+        failure: buildPageFailure(failureCode, {
           file: filePath,
           activeFile: initialActivePath || '',
           operationType: operation?.type || 'edit',
           changedDocument: false,
-          userMessage: `Codex could not open ${filePath} in Overleaf.`,
+          userMessage: pathMissing
+            ? `Codex could not find ${filePath} in this Overleaf project.`
+            : `Codex could not open ${filePath} in Overleaf.`,
           technicalMessage: opened.reason || '',
           evidence: {
+            originalCode: resultCode,
             initialActivePath: initialActivePath || '',
             openMethod: opened.method || '',
+            openAttempted: true,
             writeStarted: false
           }
         })
@@ -1707,20 +1692,6 @@
   }
 
 
-  function diffTrackedChangeRefs(before = [], after = []) {
-    const beforeKeys = new Set((before || []).map(ref => ref.key).filter(Boolean));
-    const seen = new Set();
-    const added = [];
-    for (const ref of after || []) {
-      if (!ref?.key || beforeKeys.has(ref.key) || seen.has(ref.key)) {
-        continue;
-      }
-      seen.add(ref.key);
-      added.push(ref);
-    }
-    return added;
-  }
-
   function mergeTrackedChangeRefs(refs = []) {
     return normalizeTrackedChangeRefs(refs);
   }

package/extension/src/pageBridge.js

@@ -202,7 +202,7 @@
       return projectSnapshotBridge.getProjectFileList(params);
     }
     if (method === 'invalidateProjectSnapshot') {
-      projectSnapshotBridge.invalidateProjectSnapshot();
+      projectSnapshotBridge.invalidateProjectSnapshot(params);
       return { ok: true };
     }
     if (method === 'createCheckpoint') {

package/extension/src/shared/agentTranscript.js

@@ -584,6 +584,132 @@
     };
   }
 
+  function translateProviderError(text, locale) {
+    const rules = [
+      {
+        pattern: /provider_revision_conflict|active provider changed|provider changed in another tab/i,
+        conclusionZh: '这轮没有启动：模型服务配置已在另一个标签页发生变化。',
+        conclusionEn: 'This run did not start: the model provider configuration changed in another tab.',
+        nextZh: '请刷新模型服务配置，然后重新运行任务。',
+        nextEn: 'Refresh the provider configuration, then run the task again.',
+        code: 'provider_revision_conflict'
+      },
+      {
+        pattern: /provider_auth_rejected|rejected the API key|denied access for this credential/i,
+        conclusionZh: '这轮没有继续：第三方模型服务拒绝了当前 API 密钥。',
+        conclusionEn: 'This run did not continue: the third-party provider rejected the current API key.',
+        nextZh: '请在 Settings 的模型服务配置中替换 API 密钥并测试连接。',
+        nextEn: 'Replace the API key in Model Providers and run Test connection.',
+        code: 'provider_auth_rejected'
+      },
+      {
+        pattern: /provider_model_not_found|configured model was not found/i,
+        conclusionZh: '这轮没有继续：第三方模型服务中找不到所选模型。',
+        conclusionEn: 'This run did not continue: the selected model was not found by the third-party provider.',
+        nextZh: '请检查模型 ID，测试连接后重试。',
+        nextEn: 'Check the model ID, test the connection, and retry.',
+        code: 'provider_model_not_found'
+      },
+      {
+        pattern: /provider_model_not_configured|selected model is not configured|at least one model ID is required/i,
+        conclusionZh: '这轮没有启动：当前模型没有配置在启用的模型服务中。',
+        conclusionEn: 'This run did not start: the current model is not configured for the active provider.',
+        nextZh: '请打开模型服务配置，添加或选择一个可用模型。',
+        nextEn: 'Open Model Providers and add or select an available model.',
+        code: 'provider_model_not_configured'
+      },
+      {
+        pattern: /provider_protocol_unverified|test connection before (activating|using)/i,
+        conclusionZh: '这轮没有启动：自动 API 协议尚未完成验证。',
+        conclusionEn: 'This run did not start: the automatic API protocol has not been verified.',
+        nextZh: '请在模型服务配置中运行“测试连接”，保存后重试。',
+        nextEn: 'Run Test connection in Model Providers, save, and retry.',
+        code: 'provider_protocol_unverified'
+      },
+      {
+        pattern: /provider_protocol_incompatible|incompatible with this API protocol/i,
+        conclusionZh: '这轮没有继续：端点与所选 API 协议不兼容。',
+        conclusionEn: 'This run did not continue: the endpoint is incompatible with the selected API protocol.',
+        nextZh: '请切换 Responses 或 Chat Completions，或使用自动检测重新测试。',
+        nextEn: 'Switch between Responses and Chat Completions, or test again with Auto detection.',
+        code: 'provider_protocol_incompatible'
+      },
+      {
+        pattern: /provider_rate_limited|rate limit was reached/i,
+        conclusionZh: '这轮没有完成：第三方模型服务触发了限流。',
+        conclusionEn: 'This run did not finish: the third-party provider rate limit was reached.',
+        nextZh: '请等待限流窗口恢复后重试。',
+        nextEn: 'Wait for the provider rate-limit window to recover, then retry.',
+        code: 'provider_rate_limited'
+      },
+      {
+        pattern: /provider_connection_timeout|provider connection.*timed out/i,
+        conclusionZh: '这轮没有完成：连接第三方模型服务超时。',
+        conclusionEn: 'This run did not finish: the third-party provider connection timed out.',
+        nextZh: '请检查端点和网络，或提高模型服务的请求超时后重试。',
+        nextEn: 'Check the endpoint and network, or increase the provider timeout before retrying.',
+        code: 'provider_connection_timeout'
+      },
+      {
+        pattern: /provider_dns_failed|hostname could not be resolved/i,
+        conclusionZh: '这轮没有启动：无法解析第三方模型服务的主机名。',
+        conclusionEn: 'This run did not start: the third-party provider hostname could not be resolved.',
+        nextZh: '请检查 Base URL 和本机 DNS 后重试。',
+        nextEn: 'Check the Base URL and local DNS, then retry.',
+        code: 'provider_dns_failed'
+      },
+      {
+        pattern: /provider_tls_failed|TLS verification failed/i,
+        conclusionZh: '这轮没有启动：第三方模型服务的 TLS 验证失败。',
+        conclusionEn: 'This run did not start: TLS verification failed for the third-party provider.',
+        nextZh: '请检查端点证书和 Base URL，修复后重试。',
+        nextEn: 'Check the endpoint certificate and Base URL, then retry.',
+        code: 'provider_tls_failed'
+      },
+      {
+        pattern: /provider_not_found|active provider no longer exists/i,
+        conclusionZh: '这轮没有启动：启用的模型服务已经不存在。',
+        conclusionEn: 'This run did not start: the active model provider no longer exists.',
+        nextZh: '请在 Settings 中选择内置 Codex 或另一个模型服务。',
+        nextEn: 'Select Built-in Codex or another provider in Settings.',
+        code: 'provider_not_found'
+      },
+      {
+        pattern: /provider_store_corrupt|provider stores are out of sync|provider store.*invalid/i,
+        conclusionZh: '这轮没有启动：本地模型服务配置存储已损坏或不同步。',
+        conclusionEn: 'This run did not start: the local provider configuration store is corrupt or out of sync.',
+        nextZh: '请打开技术详情，修复或重建本地模型服务配置。',
+        nextEn: 'Open Technical Details and repair or rebuild the local provider configuration.',
+        code: 'provider_store_corrupt'
+      },
+      {
+        pattern: /provider_store_unavailable|provider settings could not be saved/i,
+        conclusionZh: '模型服务操作失败：Native Host 无法访问本地配置存储。',
+        conclusionEn: 'The provider operation failed: the Native Host could not access local provider storage.',
+        nextZh: '请检查本地目录权限和 Native Host 状态后重试。',
+        nextEn: 'Check local directory permissions and Native Host status, then retry.',
+        code: 'provider_store_unavailable'
+      },
+      {
+        pattern: /provider_response_invalid|provider connection test failed/i,
+        conclusionZh: '这轮没有继续：第三方模型服务返回了不兼容或无效的响应。',
+        conclusionEn: 'This run did not continue: the third-party provider returned an incompatible or invalid response.',
+        nextZh: '请测试连接并确认服务兼容所选 API 协议。',
+        nextEn: 'Test the connection and confirm that the endpoint supports the selected API protocol.',
+        code: 'provider_response_invalid'
+      }
+    ];
+    const rule = rules.find(candidate => candidate.pattern.test(text));
+    if (!rule) {
+      return null;
+    }
+    return {
+      conclusion: textFor(locale, rule.conclusionZh, rule.conclusionEn),
+      nextStep: textFor(locale, rule.nextZh, rule.nextEn),
+      failureCode: rule.code
+    };
+  }
+
   function translateRawError(message, context = {}) {
     const locale = normalizeLocale(context);
     const text = String(message || '');
@@ -594,6 +720,10 @@
     // failure data alongside the human-readable text. The string text is kept
     // verbatim because it has mode-aware nuance (e.g. "No files were written"
     // vs "This run did not start") the catalog's fallback strings don't capture.
+    const providerError = translateProviderError(text, locale);
+    if (providerError) {
+      return providerError;
+    }
     if (/Mode must be "confirm" or "auto"/i.test(text)) {
       return {
         conclusion: textFor(locale, '这轮没有写入：当前是“只问不改”，但这个任务需要写入权限。', 'No files were written: this task needs write access, but the current mode is Ask.'),

package/extension/src/shared/compatibility.js

@@ -7,12 +7,12 @@
 })(typeof globalThis !== 'undefined' ? globalThis : window, function compatibilityFactory() {
   'use strict';
 
-  const EXTENSION_PROTOCOL_VERSION = 1;
-  const SUPPORTED_NATIVE_PROTOCOL = Object.freeze({ min: 1, max: 1 });
+  const EXTENSION_PROTOCOL_VERSION = 2;
+  const SUPPORTED_NATIVE_PROTOCOL = Object.freeze({ min: 1, max: 2 });
   const MIN_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_NATIVE_VERSION = '1.0.0';
   const MIN_COMPATIBLE_EXTENSION_VERSION = '1.0.0';
-  const BUILD_TARGET_VERSION = '1.9.13';
+  const BUILD_TARGET_VERSION = '2.1.0';
   const DEFAULT_CHROME_EXTENSION_ID = 'illdpneeeopfffmiepaejglgmhpmdhdc';
   const REQUIRED_CAPABILITIES = Object.freeze([
     'bridgePing',
@@ -24,7 +24,8 @@
     'codexModels',
     'historyClearPlugin',
     'localSkills',
-    'mirrorSensitiveScan'
+    'mirrorSensitiveScan',
+    'providerProfiles'
   ]);
   const UPDATE_AVAILABLE_CAPABILITIES = Object.freeze([
     'bridgePing',
@@ -153,7 +154,7 @@
       return { status: 'native_too_old', classification: 'incompatible' };
     }
 
-    if (!reportsProtocolOne(native)) {
+    if (!reportsSupportedProtocol(native)) {
       return { status: 'protocol_unsupported', classification: 'incompatible' };
     }
 
@@ -233,8 +234,10 @@
     return requiredCapabilities.filter(capability => capabilities[capability] !== true);
   }
 
-  function reportsProtocolOne(native) {
-    if (native.protocolVersion !== EXTENSION_PROTOCOL_VERSION) {
+  function reportsSupportedProtocol(native) {
+    if (!Number.isInteger(native.protocolVersion) ||
+        native.protocolVersion < SUPPORTED_NATIVE_PROTOCOL.min ||
+        native.protocolVersion > SUPPORTED_NATIVE_PROTOCOL.max) {
       return false;
     }
     if (native.supportedProtocol === undefined || native.supportedProtocol === null) {