opencode-copilot-account-switcher 0.13.4 → 0.13.6

package/dist/plugin-hooks.js

@@ -3,12 +3,15 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
 import { createCompactionLoopSafetyBypass, createLoopSafetySystemTransform, getLoopSafetyProviderScope, } from "./loop-safety-plugin.js";
 import { COPILOT_PROVIDER_DESCRIPTOR } from "./providers/descriptor.js";
+import { CODEX_PROVIDER_DESCRIPTOR } from "./providers/descriptor.js";
 import { createCopilotRetryingFetch, cleanupLongIdsForAccountSwitch, detectRateLimitEvidence, INTERNAL_SESSION_CONTEXT_KEY, } from "./copilot-network-retry.js";
+import { createCodexRetryingFetch } from "./codex-network-retry.js";
 import { createCopilotRetryNotifier } from "./copilot-retry-notifier.js";
 import { resolveCopilotModelAccounts } from "./model-account-map.js";
 import { normalizeDomain } from "./copilot-api-helpers.js";
 import { readStoreSafe, readStoreSafeSync, writeStore } from "./store.js";
 import { loadOfficialCopilotConfig, loadOfficialCopilotChatHeaders, } from "./upstream/copilot-loader-adapter.js";
+import { loadOfficialCodexConfig, loadOfficialCodexChatHeaders, } from "./upstream/codex-loader-adapter.js";
 import { createNotifyTool } from "./notify-tool.js";
 import { createWaitTool } from "./wait-tool.js";
 import { refreshActiveAccountQuota } from "./active-account-quota.js";
@@ -39,6 +42,9 @@ export class PolicyScopeCommandHandledError extends Error {
 function isCopilotProviderID(providerID) {
     return COPILOT_PROVIDER_DESCRIPTOR.providerIDs.includes(providerID);
 }
+function isCodexProviderID(providerID) {
+    return CODEX_PROVIDER_DESCRIPTOR.providerIDs.includes(providerID);
+}
 function isDebugEnabled() {
     return process.env.OPENCODE_COPILOT_RETRY_DEBUG === "1";
 }
@@ -81,6 +87,25 @@ function areExperimentalSlashCommandsEnabled(store) {
         return false;
     return true;
 }
+function mergeStoreWithCommonSettings(store, common) {
+    if (!store && !common)
+        return undefined;
+    return {
+        ...(store ?? { accounts: {} }),
+        ...(common?.loopSafetyEnabled === true || common?.loopSafetyEnabled === false
+            ? { loopSafetyEnabled: common.loopSafetyEnabled }
+            : {}),
+        ...(common?.loopSafetyProviderScope
+            ? { loopSafetyProviderScope: common.loopSafetyProviderScope }
+            : {}),
+        ...(common?.networkRetryEnabled === true || common?.networkRetryEnabled === false
+            ? { networkRetryEnabled: common.networkRetryEnabled }
+            : {}),
+        ...(common?.experimentalSlashCommandsEnabled === true || common?.experimentalSlashCommandsEnabled === false
+            ? { experimentalSlashCommandsEnabled: common.experimentalSlashCommandsEnabled }
+            : {}),
+    };
+}
 async function readRequestBody(request, init) {
     try {
         if (typeof init?.body === "string")
@@ -422,10 +447,16 @@ function pruneTouchWriteCache(input) {
 }
 export function buildPluginHooks(input) {
     const authProvider = input.auth.provider ?? COPILOT_PROVIDER_DESCRIPTOR.providerIDs[0] ?? "github-copilot";
-    const enableCopilotAuthLoader = isCopilotProviderID(authProvider);
+    const authLoaderMode = input.authLoaderMode
+        ?? (isCopilotProviderID(authProvider) ? "copilot" : isCodexProviderID(authProvider) ? "codex" : "none");
+    const enableCopilotAuthLoader = authLoaderMode === "copilot";
+    const enableCodexAuthLoader = authLoaderMode === "codex";
+    const enableModelRouting = input.enableModelRouting ?? enableCopilotAuthLoader;
     const compactionLoopSafetyBypass = createCompactionLoopSafetyBypass();
     const loadStore = input.loadStore ?? readStoreSafe;
     const loadStoreSync = input.loadStoreSync ?? readStoreSafeSync;
+    const loadCommonSettings = input.loadCommonSettings;
+    const loadCommonSettingsSync = input.loadCommonSettingsSync;
     const persistStore = (store, meta) => {
         if (input.writeStore)
             return input.writeStore(store, meta);
@@ -436,9 +467,30 @@ export function buildPluginHooks(input) {
     const handleCodexStatusCommandImpl = input.handleCodexStatusCommandImpl ?? handleCodexStatusCommand;
     const handleCompactCommandImpl = input.handleCompactCommandImpl ?? handleCompactCommand;
     const handleStopToolCommandImpl = input.handleStopToolCommandImpl ?? handleStopToolCommand;
-    const loadOfficialConfig = input.loadOfficialConfig ?? loadOfficialCopilotConfig;
-    const loadOfficialChatHeaders = input.loadOfficialChatHeaders ?? loadOfficialCopilotChatHeaders;
-    const createRetryFetch = input.createRetryFetch ?? createCopilotRetryingFetch;
+    const loadOfficialConfigForCopilot = (args) => {
+        if (input.loadOfficialConfig) {
+            return input.loadOfficialConfig(args);
+        }
+        return loadOfficialCopilotConfig(args);
+    };
+    const loadOfficialConfigForCodex = (args) => {
+        if (input.loadOfficialConfig) {
+            return input.loadOfficialConfig(args);
+        }
+        return loadOfficialCodexConfig({
+            getAuth: args.getAuth,
+            baseFetch: args.baseFetch,
+            version: args.version,
+            client: input.client,
+        });
+    };
+    const resolveOfficialChatHeaders = enableCopilotAuthLoader
+        ? input.loadOfficialChatHeaders ?? loadOfficialCopilotChatHeaders
+        : enableCodexAuthLoader
+            ? loadOfficialCodexChatHeaders
+            : (async () => async () => { });
+    const createRetryFetch = input.createRetryFetch
+        ?? (enableCodexAuthLoader ? createCodexRetryingFetch : createCopilotRetryingFetch);
     const now = input.now ?? (() => Date.now());
     const random = input.random ?? Math.random;
     let injectArmed = false;
@@ -464,6 +516,27 @@ export function buildPluginHooks(input) {
         });
     });
     const getPolicyScope = (store) => getLoopSafetyProviderScope(store, policyScopeOverride);
+    const loadMergedStore = async () => {
+        const [store, common] = await Promise.all([
+            loadStore().catch(() => undefined),
+            loadCommonSettings?.().catch(() => undefined),
+        ]);
+        return mergeStoreWithCommonSettings(store, common);
+    };
+    const loadMergedStoreSync = () => mergeStoreWithCommonSettings(loadStoreSync(), loadCommonSettingsSync?.());
+    const isNetworkRetryEnabled = async (retryStore) => {
+        if (loadCommonSettings) {
+            const common = await loadCommonSettings().catch(() => undefined);
+            if (common?.networkRetryEnabled === true)
+                return true;
+            if (common?.networkRetryEnabled === false)
+                return false;
+        }
+        if (retryStore)
+            return retryStore.networkRetryEnabled === true;
+        const store = readRetryStoreContext(await loadStore().catch(() => undefined));
+        return store?.networkRetryEnabled === true;
+    };
     const showInjectToast = async (message, variant = "info") => {
         await showStatusToast({
             client: input.client,
@@ -568,6 +641,7 @@ export function buildPluginHooks(input) {
         const finalHeaderCapture = new AsyncLocalStorage();
         const getScopedAuth = async () => authOverride.getStore() ?? getAuth();
         const providerConfig = provider;
+        const loadOfficialConfig = enableCodexAuthLoader ? loadOfficialConfigForCodex : loadOfficialConfigForCopilot;
         const config = await loadOfficialConfig({
             getAuth: getScopedAuth,
             provider: providerConfig,
@@ -997,35 +1071,67 @@ export function buildPluginHooks(input) {
             }
             return response;
         };
-        if (retryStore?.networkRetryEnabled !== true)
+        const providerFetch = enableModelRouting
+            ? fetchWithModelAccount
+            : async (request, init) => {
+                const outbound = stripInternalSessionHeader(request, init);
+                return config.fetch(outbound.request, outbound.init);
+            };
+        const networkRetryEnabled = await isNetworkRetryEnabled(retryStore);
+        if (networkRetryEnabled !== true)
             return {
                 ...config,
-                fetch: fetchWithModelAccount,
+                fetch: providerFetch,
             };
         return {
             ...config,
-            fetch: createRetryFetch(fetchWithModelAccount, {
+            fetch: createRetryFetch(providerFetch, {
                 client: input.client,
                 directory: input.directory,
                 serverUrl: input.serverUrl,
-                lastAccountSwitchAt: retryStore.lastAccountSwitchAt,
+                lastAccountSwitchAt: retryStore?.lastAccountSwitchAt,
                 notifier: createCopilotRetryNotifier({
                     client: input.client,
-                    lastAccountSwitchAt: retryStore.lastAccountSwitchAt,
+                    lastAccountSwitchAt: retryStore?.lastAccountSwitchAt,
                     getLastAccountSwitchAt: getLatestLastAccountSwitchAt,
                     clearAccountSwitchContext,
                     now: input.now,
                 }),
-                clearAccountSwitchContext: async () => clearAccountSwitchContext(retryStore.lastAccountSwitchAt),
+                clearAccountSwitchContext: async () => clearAccountSwitchContext(retryStore?.lastAccountSwitchAt),
             }),
         };
     };
-    const officialChatHeaders = loadOfficialChatHeaders({
-        client: input.client,
-        directory: input.directory,
-    });
+    const codexLoader = async (getAuth) => {
+        const config = await loadOfficialConfigForCodex({
+            getAuth: getAuth,
+        }).catch(() => undefined);
+        if (!config || typeof config.fetch !== "function")
+            return {};
+        if (await isNetworkRetryEnabled()) {
+            return {
+                ...config,
+                fetch: createRetryFetch(config.fetch),
+            };
+        }
+        return {
+            ...config,
+            fetch: config.fetch,
+        };
+    };
+    const officialChatHeaders = (enableCopilotAuthLoader || enableCodexAuthLoader)
+        ? resolveOfficialChatHeaders({
+            client: input.client,
+            directory: input.directory,
+        })
+        : Promise.resolve(async () => { });
     const chatHeaders = async (hookInput, output) => {
-        if (!isCopilotProviderID(hookInput.model.providerID))
+        if (enableCodexAuthLoader) {
+            if (hookInput.model.providerID !== authProvider)
+                return;
+            await (await officialChatHeaders)(hookInput, output);
+            return;
+        }
+        if (!enableCopilotAuthLoader || !isCopilotProviderID(hookInput.model.providerID))
             return;
         const headersBeforeOfficial = { ...output.headers };
         await (await officialChatHeaders)(hookInput, output);
@@ -1125,43 +1231,49 @@ export function buildPluginHooks(input) {
             ...input.auth,
             provider: authProvider,
             methods: input.auth.methods,
-            loader: enableCopilotAuthLoader ? loader : undefined,
+            loader: enableCopilotAuthLoader ? loader : (enableCodexAuthLoader ? codexLoader : undefined),
         },
         config: async (config) => {
             if (!config.command)
                 config.command = {};
-            const store = loadStoreSync();
+            const store = loadMergedStoreSync();
             if (!areExperimentalSlashCommandsEnabled(store)) {
                 return;
             }
-            config.command["codex-status"] = {
-                template: "Show the current Codex status and usage snapshot via the experimental status path.",
-                description: "Experimental Codex status command",
-            };
-            config.command["copilot-status"] = {
-                template: "Show the current GitHub Copilot quota status via the experimental workaround path.",
-                description: "Experimental Copilot quota status workaround",
-            };
-            config.command["copilot-compact"] = {
-                template: "Summarize the current session via real session compacting flow.",
-                description: "Experimental compact command for Copilot sessions",
-            };
-            config.command["copilot-stop-tool"] = {
-                template: "Interrupt the current session tool flow, annotate the interrupted result, and append a synthetic continue.",
-                description: "Experimental interrupt-and-annotate recovery with synthetic continue for Copilot sessions",
-            };
-            config.command["copilot-inject"] = {
-                template: "Arm an immediate tool-output inject marker flow that drives model to question.",
-                description: "Experimental force-intervene hook for Copilot workflows",
-            };
-            config.command["copilot-policy-all-models"] = {
-                template: "Toggle the current OpenCode instance policy injection scope between Copilot-only and all providers/models.",
-                description: "Experimental policy scope toggle for all providers",
-            };
+            if (enableCodexAuthLoader) {
+                config.command["codex-status"] = {
+                    template: "Show the current Codex status and usage snapshot via the experimental status path.",
+                    description: "Experimental Codex status command",
+                };
+            }
+            if (enableCopilotAuthLoader) {
+                config.command["copilot-status"] = {
+                    template: "Show the current GitHub Copilot quota status via the experimental workaround path.",
+                    description: "Experimental Copilot quota status workaround",
+                };
+                config.command["copilot-compact"] = {
+                    template: "Summarize the current session via real session compacting flow.",
+                    description: "Experimental compact command for Copilot sessions",
+                };
+                config.command["copilot-stop-tool"] = {
+                    template: "Interrupt the current session tool flow, annotate the interrupted result, and append a synthetic continue.",
+                    description: "Experimental interrupt-and-annotate recovery with synthetic continue for Copilot sessions",
+                };
+                config.command["copilot-inject"] = {
+                    template: "Arm an immediate tool-output inject marker flow that drives model to question.",
+                    description: "Experimental force-intervene hook for Copilot workflows",
+                };
+                config.command["copilot-policy-all-models"] = {
+                    template: "Toggle the current OpenCode instance policy injection scope between Copilot-only and all providers/models.",
+                    description: "Experimental policy scope toggle for all providers",
+                };
+            }
         },
         "command.execute.before": async (hookInput) => {
-            const store = await loadStore().catch(() => undefined);
+            const store = await loadMergedStore();
             if (hookInput.command === "copilot-inject") {
+                if (!enableCopilotAuthLoader)
+                    return;
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;
                 injectArmed = true;
@@ -1169,6 +1281,8 @@ export function buildPluginHooks(input) {
                 throw new InjectCommandHandledError();
             }
             if (hookInput.command === "copilot-policy-all-models") {
+                if (!enableCopilotAuthLoader)
+                    return;
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;
                 const next = getPolicyScope(store) === "all-models" ? "copilot-only" : "all-models";
@@ -1179,6 +1293,8 @@ export function buildPluginHooks(input) {
                 throw new PolicyScopeCommandHandledError();
             }
             if (hookInput.command === "copilot-status") {
+                if (!enableCopilotAuthLoader)
+                    return;
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;
                 await handleStatusCommandImpl({
@@ -1189,6 +1305,8 @@ export function buildPluginHooks(input) {
                 });
             }
             if (hookInput.command === "codex-status") {
+                if (!enableCodexAuthLoader)
+                    return;
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;
                 await handleCodexStatusCommandImpl({
@@ -1196,6 +1314,8 @@ export function buildPluginHooks(input) {
                 });
             }
             if (hookInput.command === "copilot-compact") {
+                if (!enableCopilotAuthLoader)
+                    return;
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;
                 await handleCompactCommandImpl({
@@ -1205,6 +1325,8 @@ export function buildPluginHooks(input) {
                 });
             }
             if (hookInput.command === "copilot-stop-tool") {
+                if (!enableCopilotAuthLoader)
+                    return;
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;
                 await handleStopToolCommandImpl({
@@ -1267,7 +1389,7 @@ export function buildPluginHooks(input) {
             }
         },
         "chat.headers": chatHeaders,
-        "experimental.chat.system.transform": createLoopSafetySystemTransform(loadStore, compactionLoopSafetyBypass.consume, lookupSessionAncestry, getPolicyScope),
+        "experimental.chat.system.transform": createLoopSafetySystemTransform(loadMergedStore, compactionLoopSafetyBypass.consume, lookupSessionAncestry, getPolicyScope),
         "experimental.session.compacting": compactionLoopSafetyBypass.hook,
     };
 }

package/dist/plugin.js

@@ -3,8 +3,10 @@ import { listAssignableAccountsForModel, listKnownCopilotModels, rewriteModelAcc
 import { runProviderMenu } from "./menu-runtime.js";
 import { persistAccountSwitch } from "./plugin-actions.js";
 import { buildPluginHooks } from "./plugin-hooks.js";
+import { readCommonSettingsStore, readCommonSettingsStoreSync, writeCommonSettingsStore, } from "./common-settings-store.js";
 import { createCodexMenuAdapter } from "./providers/codex-menu-adapter.js";
 import { createCopilotMenuAdapter } from "./providers/copilot-menu-adapter.js";
+import { createProviderRegistry } from "./providers/registry.js";
 import { isTTY } from "./ui/ansi.js";
 import { showMenu } from "./ui/menu.js";
 import { select, selectMany } from "./ui/select.js";
@@ -12,6 +14,27 @@ import { readAuth, readStore, writeStore } from "./store.js";
 function now() {
     return Date.now();
 }
+function toSharedRuntimeAction(action) {
+    if (action.type === "cancel")
+        return { type: "cancel" };
+    if (action.type === "add")
+        return { type: "add" };
+    if (action.type === "remove-all")
+        return { type: "remove-all" };
+    if (action.type === "switch")
+        return { type: "switch", account: action.account };
+    if (action.type === "remove")
+        return { type: "remove", account: action.account };
+    if (action.type === "toggle-loop-safety")
+        return { type: "provider", name: "toggle-loop-safety" };
+    if (action.type === "toggle-loop-safety-provider-scope")
+        return { type: "provider", name: "toggle-loop-safety-provider-scope" };
+    if (action.type === "toggle-experimental-slash-commands")
+        return { type: "provider", name: "toggle-experimental-slash-commands" };
+    if (action.type === "toggle-network-retry")
+        return { type: "provider", name: "toggle-network-retry" };
+    return undefined;
+}
 export async function configureDefaultAccountGroup(store, selectors) {
     const accountEntries = Object.entries(store.accounts);
     if (accountEntries.length === 0) {
@@ -253,24 +276,28 @@ async function createAccountSwitcherPlugin(input, provider) {
             logSwitchHint: () => {
                 console.log("Switched account. If a later Copilot session hits input[*].id too long after switching, enable Copilot Network Retry from the menu.");
             },
+            readCommonSettings: readCommonSettingsStore,
+            writeCommonSettings: async (settings) => {
+                await writeCommonSettingsStore(settings);
+            },
         });
         const toRuntimeAction = async (accounts, store) => {
+            const common = await readCommonSettingsStore().catch(() => undefined);
             const action = await showMenu(accounts, {
                 provider: "copilot",
                 refresh: { enabled: store.autoRefresh === true, minutes: store.refreshMinutes ?? 15 },
                 lastQuotaRefresh: store.lastQuotaRefresh,
                 modelAccountAssignmentCount: Object.keys(store.modelAccountAssignments ?? {}).length,
                 defaultAccountGroupCount: store.activeAccountNames?.length ?? (store.active ? 1 : 0),
-                loopSafetyEnabled: store.loopSafetyEnabled === true,
-                loopSafetyProviderScope: store.loopSafetyProviderScope,
-                experimentalSlashCommandsEnabled: store.experimentalSlashCommandsEnabled,
-                networkRetryEnabled: store.networkRetryEnabled === true,
+                loopSafetyEnabled: common?.loopSafetyEnabled ?? store.loopSafetyEnabled === true,
+                loopSafetyProviderScope: common?.loopSafetyProviderScope ?? store.loopSafetyProviderScope,
+                experimentalSlashCommandsEnabled: common?.experimentalSlashCommandsEnabled ?? store.experimentalSlashCommandsEnabled,
+                networkRetryEnabled: common?.networkRetryEnabled ?? store.networkRetryEnabled === true,
                 syntheticAgentInitiatorEnabled: store.syntheticAgentInitiatorEnabled === true,
             });
-            if (action.type === "cancel")
-                return { type: "cancel" };
-            if (action.type === "add")
-                return { type: "add" };
+            const shared = toSharedRuntimeAction(action);
+            if (shared)
+                return shared;
             if (action.type === "import")
                 return { type: "provider", name: "import-auth" };
             if (action.type === "refresh-identity")
@@ -287,20 +314,6 @@ async function createAccountSwitcherPlugin(input, provider) {
                 return { type: "provider", name: "configure-default-group" };
             if (action.type === "assign-models")
                 return { type: "provider", name: "assign-models" };
-            if (action.type === "remove-all")
-                return { type: "remove-all" };
-            if (action.type === "switch")
-                return { type: "switch", account: action.account };
-            if (action.type === "remove")
-                return { type: "remove", account: action.account };
-            if (action.type === "toggle-loop-safety")
-                return { type: "provider", name: "toggle-loop-safety" };
-            if (action.type === "toggle-loop-safety-provider-scope")
-                return { type: "provider", name: "toggle-loop-safety-provider-scope" };
-            if (action.type === "toggle-experimental-slash-commands")
-                return { type: "provider", name: "toggle-experimental-slash-commands" };
-            if (action.type === "toggle-network-retry")
-                return { type: "provider", name: "toggle-network-retry" };
             if (action.type === "toggle-synthetic-agent-initiator")
                 return { type: "provider", name: "toggle-synthetic-agent-initiator" };
             return { type: "cancel" };
@@ -318,28 +331,30 @@ async function createAccountSwitcherPlugin(input, provider) {
         }
         const adapter = createCodexMenuAdapter({
             client: codexClient,
+            readCommonSettings: readCommonSettingsStore,
+            writeCommonSettings: async (settings) => {
+                await writeCommonSettingsStore(settings);
+            },
         });
         const toRuntimeAction = async (accounts, store) => {
+            const common = await readCommonSettingsStore().catch(() => undefined);
             const action = await showMenu(accounts, {
                 provider: "codex",
                 refresh: { enabled: store.autoRefresh === true, minutes: store.refreshMinutes ?? 15 },
+                loopSafetyEnabled: common?.loopSafetyEnabled ?? true,
+                loopSafetyProviderScope: common?.loopSafetyProviderScope,
+                experimentalSlashCommandsEnabled: common?.experimentalSlashCommandsEnabled,
+                networkRetryEnabled: common?.networkRetryEnabled === true,
             });
-            if (action.type === "cancel")
-                return { type: "cancel" };
-            if (action.type === "add")
-                return { type: "add" };
+            const shared = toSharedRuntimeAction(action);
+            if (shared)
+                return shared;
             if (action.type === "quota")
                 return { type: "provider", name: "refresh-snapshot" };
             if (action.type === "toggle-refresh")
                 return { type: "provider", name: "toggle-refresh" };
             if (action.type === "set-interval")
                 return { type: "provider", name: "set-interval" };
-            if (action.type === "remove-all")
-                return { type: "remove-all" };
-            if (action.type === "switch")
-                return { type: "switch", account: action.account };
-            if (action.type === "remove")
-                return { type: "remove", account: action.account };
             return { type: "cancel" };
         };
         return runProviderMenu({
@@ -348,7 +363,11 @@ async function createAccountSwitcherPlugin(input, provider) {
             now,
         });
     }
-    return buildPluginHooks({
+    const registry = createProviderRegistry({
+        buildPluginHooks,
+    });
+    const assembled = provider === "github-copilot" ? registry.copilot.descriptor : registry.codex.descriptor;
+    return assembled.buildPluginHooks({
         auth: {
             provider,
             methods: provider === "github-copilot" ? copilotMethods : codexMethods,
@@ -356,6 +375,8 @@ async function createAccountSwitcherPlugin(input, provider) {
         client,
         directory,
         serverUrl,
+        loadCommonSettings: readCommonSettingsStore,
+        loadCommonSettingsSync: readCommonSettingsStoreSync,
     });
 }
 export const CopilotAccountSwitcher = async (input) => {

package/dist/providers/codex-menu-adapter.d.ts

@@ -3,9 +3,10 @@ import { type CodexOAuthAccount } from "../codex-oauth.js";
 import { type CodexAccountEntry, type CodexStoreFile } from "../codex-store.js";
 import type { ProviderMenuAdapter } from "../menu-runtime.js";
 import { type AccountEntry } from "../store.js";
+import { type CommonSettingsStore } from "../common-settings-store.js";
 type WriteMeta = {
-    reason: string;
-    source: string;
+    reason?: string;
+    source?: string;
     actionType?: string;
 };
 type AuthClient = {
@@ -42,6 +43,8 @@ type AdapterDependencies = {
         accountId?: string;
     }) => Promise<CodexStatusFetcherResult>;
     runCodexOAuth?: () => Promise<CodexOAuthAccount | undefined>;
+    readCommonSettings?: () => Promise<CommonSettingsStore>;
+    writeCommonSettings?: (settings: CommonSettingsStore, meta?: WriteMeta) => Promise<void>;
 };
 export declare function createCodexMenuAdapter(inputDeps: AdapterDependencies): ProviderMenuAdapter<CodexStoreFile, CodexAccountEntry>;
 export {};

package/dist/providers/codex-menu-adapter.js

@@ -5,6 +5,8 @@ import { runCodexOAuth } from "../codex-oauth.js";
 import { getActiveCodexAccount, readCodexStore, writeCodexStore, } from "../codex-store.js";
 import { recoverInvalidCodexAccount } from "../codex-invalid-account.js";
 import { readAuth } from "../store.js";
+import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
+import { applyCommonSettingsAction } from "../common-settings-actions.js";
 function pickName(input) {
     const accountId = input.accountId?.trim();
     if (accountId)
@@ -72,6 +74,14 @@ export function createCodexMenuAdapter(inputDeps) {
     const loadAuth = inputDeps.readAuthEntries ?? readAuth;
     const fetchStatus = inputDeps.fetchStatus ?? ((input) => fetchCodexStatus(input));
     const authorizeOpenAIOAuth = inputDeps.runCodexOAuth ?? runCodexOAuth;
+    const readCommonSettings = inputDeps.readCommonSettings ?? readCommonSettingsStore;
+    const writeCommonSettings = async (settings, meta) => {
+        if (inputDeps.writeCommonSettings) {
+            await inputDeps.writeCommonSettings(settings, meta);
+            return;
+        }
+        await writeCommonSettingsStore(settings);
+    };
     const refreshSnapshots = async (store) => {
         const names = Object.keys(store.accounts);
         const pendingRecoveryWarnings = new Map();
@@ -357,6 +367,17 @@ export function createCodexMenuAdapter(inputDeps) {
                 store.refreshMinutes = Math.max(1, Math.min(180, value));
                 return true;
             }
+            if (action.name === "toggle-loop-safety"
+                || action.name === "toggle-loop-safety-provider-scope"
+                || action.name === "toggle-experimental-slash-commands"
+                || action.name === "toggle-network-retry") {
+                await applyCommonSettingsAction({
+                    action: { type: action.name },
+                    readSettings: readCommonSettings,
+                    writeSettings: writeCommonSettings,
+                });
+                return false;
+            }
             return false;
         },
     };

package/dist/providers/copilot-menu-adapter.d.ts

@@ -1,4 +1,5 @@
 import type { ProviderMenuAdapter } from "../menu-runtime.js";
+import { type CommonSettingsStore } from "../common-settings-store.js";
 import { type AccountEntry, type StoreFile, type StoreWriteDebugMeta } from "../store.js";
 type AuthClient = {
     auth: {
@@ -60,6 +61,8 @@ type AdapterDependencies = {
         now?: () => number;
     }) => Promise<void>;
     logSwitchHint?: () => void;
+    readCommonSettings?: () => Promise<CommonSettingsStore>;
+    writeCommonSettings?: (settings: CommonSettingsStore, meta?: DebugMeta) => Promise<void>;
 };
 export declare function createCopilotMenuAdapter(inputDeps: AdapterDependencies): ProviderMenuAdapter<StoreFile, AccountEntry>;
 export {};

package/dist/providers/copilot-menu-adapter.js

@@ -4,6 +4,7 @@ import { fetchQuota } from "../active-account-quota.js";
 import { getGitHubToken, normalizeDomain } from "../copilot-api-helpers.js";
 import { listAssignableAccountsForModel, listKnownCopilotModels, rewriteModelAccountAssignments, } from "../model-account-map.js";
 import { applyMenuAction, persistAccountSwitch } from "../plugin-actions.js";
+import { readCommonSettingsStore, writeCommonSettingsStore, } from "../common-settings-store.js";
 import { select, selectMany } from "../ui/select.js";
 import { authPath, readAuth, readStore } from "../store.js";
 const CLIENT_ID = "Ov23li8tweQw6odWQebz";
@@ -387,6 +388,8 @@ export function createCopilotMenuAdapter(inputDeps) {
     const fetchUserFn = inputDeps.fetchUser ?? fetchUserDefault;
     const fetchModelsFn = inputDeps.fetchModels ?? fetchModelsDefault;
     const fetchQuotaFn = inputDeps.fetchQuota ?? fetchQuota;
+    const readCommonSettings = inputDeps.readCommonSettings ?? readCommonSettingsStore;
+    const writeCommonSettings = inputDeps.writeCommonSettings ?? writeCommonSettingsStore;
     let nextAutoRefreshAt = 0;
     async function maybeAutoRefresh(store) {
         if (store.autoRefresh !== true || now() < nextAutoRefreshAt)
@@ -728,6 +731,8 @@ export function createCopilotMenuAdapter(inputDeps) {
                     action: { type: action.name },
                     store,
                     writeStore: persistStore,
+                    readCommonSettings,
+                    writeCommonSettings,
                 });
                 return false;
             }

package/dist/providers/descriptor.d.ts

@@ -22,7 +22,8 @@ export declare const CODEX_PROVIDER_DESCRIPTOR: ProviderDescriptor;
 export declare function createCopilotProviderDescriptor(input: {
     buildPluginHooks: BuildPluginHooks;
 }): AssembledProviderDescriptor;
-export declare function createCodexProviderDescriptor(input?: {
+export declare function createCodexProviderDescriptor(input: {
+    buildPluginHooks: BuildPluginHooks;
     enabled?: boolean;
-}): Omit<AssembledProviderDescriptor, "buildPluginHooks">;
+}): AssembledProviderDescriptor;
 export {};

package/dist/providers/descriptor.js

@@ -47,6 +47,8 @@ export const CODEX_PROVIDER_DESCRIPTOR = {
     ],
     capabilities: [
         "auth",
+        "chat-headers",
+        "network-retry",
         "slash-commands",
     ],
 };
@@ -60,12 +62,13 @@ export function createCopilotProviderDescriptor(input) {
         enabledByDefault: true,
     };
 }
-export function createCodexProviderDescriptor(input = {}) {
+export function createCodexProviderDescriptor(input) {
     return {
         key: "codex",
         auth: {
             provider: "openai",
         },
+        buildPluginHooks: input.buildPluginHooks,
         enabledByDefault: input.enabled !== false,
     };
 }

package/dist/providers/registry.d.ts

@@ -12,7 +12,7 @@ export declare function createProviderRegistry(input: {
         descriptor: import("./descriptor.js").AssembledProviderDescriptor;
     };
     codex: {
-        descriptor: Omit<import("./descriptor.js").AssembledProviderDescriptor, "buildPluginHooks">;
+        descriptor: import("./descriptor.js").AssembledProviderDescriptor;
     };
 };
 export {};