opencode-copilot-account-switcher 0.13.6 → 0.14.1

package/dist/common-settings-actions.d.ts

@@ -1,5 +1,5 @@
 import type { CommonSettingsStore } from "./common-settings-store.js";
-export type CommonSettingsActionType = "toggle-loop-safety" | "toggle-loop-safety-provider-scope" | "toggle-experimental-slash-commands" | "toggle-network-retry";
+export type CommonSettingsActionType = "toggle-loop-safety" | "toggle-loop-safety-provider-scope" | "toggle-experimental-slash-commands" | "toggle-network-retry" | "wechat-bind" | "wechat-rebind" | "wechat-unbind" | "toggle-wechat-notifications" | "toggle-wechat-question-notify" | "toggle-wechat-permission-notify" | "toggle-wechat-session-error-notify";
 type WriteMeta = {
     reason?: string;
     source?: string;

package/dist/common-settings-actions.js

@@ -1,5 +1,20 @@
 export async function applyCommonSettingsAction(input) {
     const settings = await input.readSettings();
+    const existingNotifications = settings.wechat?.notifications;
+    const notifications = {
+        enabled: existingNotifications?.enabled !== false,
+        question: existingNotifications?.question !== false,
+        permission: existingNotifications?.permission !== false,
+        sessionError: existingNotifications?.sessionError !== false,
+    };
+    if (!settings.wechat) {
+        settings.wechat = {
+            notifications,
+        };
+    }
+    else if (!settings.wechat.notifications) {
+        settings.wechat.notifications = notifications;
+    }
     if (input.action.type === "toggle-loop-safety") {
         settings.loopSafetyEnabled = settings.loopSafetyEnabled !== true;
         await input.writeSettings(settings, {
@@ -38,5 +53,44 @@ export async function applyCommonSettingsAction(input) {
         });
         return true;
     }
+    if (input.action.type === "toggle-wechat-notifications") {
+        settings.wechat.notifications.enabled = settings.wechat.notifications.enabled !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-wechat-notifications",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-wechat-notifications",
+        });
+        return true;
+    }
+    if (input.action.type === "toggle-wechat-question-notify") {
+        settings.wechat.notifications.question = settings.wechat.notifications.question !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-wechat-question-notify",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-wechat-question-notify",
+        });
+        return true;
+    }
+    if (input.action.type === "toggle-wechat-permission-notify") {
+        settings.wechat.notifications.permission = settings.wechat.notifications.permission !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-wechat-permission-notify",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-wechat-permission-notify",
+        });
+        return true;
+    }
+    if (input.action.type === "toggle-wechat-session-error-notify") {
+        settings.wechat.notifications.sessionError = settings.wechat.notifications.sessionError !== true;
+        await input.writeSettings(settings, {
+            reason: "toggle-wechat-session-error-notify",
+            source: "applyCommonSettingsAction",
+            actionType: "toggle-wechat-session-error-notify",
+        });
+        return true;
+    }
+    if (input.action.type === "wechat-bind" || input.action.type === "wechat-rebind" || input.action.type === "wechat-unbind") {
+        return true;
+    }
     return false;
 }

package/dist/common-settings-store.d.ts

@@ -4,6 +4,31 @@ export type CommonSettingsStore = {
     networkRetryEnabled?: boolean;
     experimentalSlashCommandsEnabled?: boolean;
     experimentalStatusSlashCommandEnabled?: boolean;
+    wechat?: WechatMenuSettings;
+    wechatNotificationsEnabled?: boolean;
+    wechatQuestionNotifyEnabled?: boolean;
+    wechatPermissionNotifyEnabled?: boolean;
+    wechatSessionErrorNotifyEnabled?: boolean;
+};
+export type WechatBinding = {
+    accountId: string;
+    userId?: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt?: number;
+};
+export type WechatMenuSettings = {
+    primaryBinding?: WechatBinding;
+    notifications: {
+        enabled: boolean;
+        question: boolean;
+        permission: boolean;
+        sessionError: boolean;
+    };
+    future?: {
+        accounts?: WechatBinding[];
+    };
 };
 export declare function parseCommonSettingsStore(raw: string): CommonSettingsStore;
 export declare function commonSettingsPath(): string;

package/dist/common-settings-store.js

@@ -3,9 +3,68 @@ import { promises as fs } from "node:fs";
 import { readFileSync } from "node:fs";
 import { commonSettingsPath as defaultCommonSettingsPath, legacyCopilotStorePath } from "./store-paths.js";
 import { parseStore } from "./store.js";
+function normalizeWechatBinding(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const value = input;
+    if (typeof value.accountId !== "string" || value.accountId.length === 0)
+        return undefined;
+    const binding = { accountId: value.accountId };
+    if (typeof value.userId === "string")
+        binding.userId = value.userId;
+    if (typeof value.name === "string")
+        binding.name = value.name;
+    if (typeof value.enabled === "boolean")
+        binding.enabled = value.enabled;
+    if (typeof value.configured === "boolean")
+        binding.configured = value.configured;
+    if (typeof value.boundAt === "number" && Number.isFinite(value.boundAt))
+        binding.boundAt = value.boundAt;
+    return binding;
+}
+function normalizeWechatSettings(source) {
+    const wechatValue = source.wechat && typeof source.wechat === "object"
+        ? source.wechat
+        : undefined;
+    const notificationsValue = wechatValue?.notifications && typeof wechatValue.notifications === "object"
+        ? wechatValue.notifications
+        : undefined;
+    const futureValue = wechatValue?.future && typeof wechatValue.future === "object"
+        ? wechatValue.future
+        : undefined;
+    const enabled = typeof notificationsValue?.enabled === "boolean"
+        ? notificationsValue.enabled
+        : source.wechatNotificationsEnabled !== false;
+    const question = typeof notificationsValue?.question === "boolean"
+        ? notificationsValue.question
+        : source.wechatQuestionNotifyEnabled !== false;
+    const permission = typeof notificationsValue?.permission === "boolean"
+        ? notificationsValue.permission
+        : source.wechatPermissionNotifyEnabled !== false;
+    const sessionError = typeof notificationsValue?.sessionError === "boolean"
+        ? notificationsValue.sessionError
+        : source.wechatSessionErrorNotifyEnabled !== false;
+    const primaryBinding = normalizeWechatBinding(wechatValue?.primaryBinding);
+    const accounts = Array.isArray(futureValue?.accounts)
+        ? futureValue.accounts
+            .map((account) => normalizeWechatBinding(account))
+            .filter((account) => Boolean(account))
+        : undefined;
+    return {
+        ...(primaryBinding ? { primaryBinding } : {}),
+        notifications: {
+            enabled,
+            question,
+            permission,
+            sessionError,
+        },
+        ...(accounts ? { future: { accounts } } : {}),
+    };
+}
 function normalizeCommonSettingsStore(input) {
     const source = input ?? {};
     const legacySlashCommandsEnabled = source.experimentalStatusSlashCommandEnabled;
+    const wechat = normalizeWechatSettings(source);
     return {
         ...(source.loopSafetyEnabled !== false ? { loopSafetyEnabled: true } : { loopSafetyEnabled: false }),
         loopSafetyProviderScope: source.loopSafetyProviderScope === "all-models" ? "all-models" : "copilot-only",
@@ -15,6 +74,7 @@ function normalizeCommonSettingsStore(input) {
             : legacySlashCommandsEnabled === false
                 ? false
                 : true,
+        wechat,
     };
 }
 function parsePartialCommonSettingsStore(raw) {
@@ -35,6 +95,21 @@ function parsePartialCommonSettingsStore(raw) {
     if (parsed.experimentalStatusSlashCommandEnabled === true || parsed.experimentalStatusSlashCommandEnabled === false) {
         partial.experimentalStatusSlashCommandEnabled = parsed.experimentalStatusSlashCommandEnabled;
     }
+    if (parsed.wechat && typeof parsed.wechat === "object") {
+        partial.wechat = parsed.wechat;
+    }
+    if (parsed.wechatNotificationsEnabled === true || parsed.wechatNotificationsEnabled === false) {
+        partial.wechatNotificationsEnabled = parsed.wechatNotificationsEnabled;
+    }
+    if (parsed.wechatQuestionNotifyEnabled === true || parsed.wechatQuestionNotifyEnabled === false) {
+        partial.wechatQuestionNotifyEnabled = parsed.wechatQuestionNotifyEnabled;
+    }
+    if (parsed.wechatPermissionNotifyEnabled === true || parsed.wechatPermissionNotifyEnabled === false) {
+        partial.wechatPermissionNotifyEnabled = parsed.wechatPermissionNotifyEnabled;
+    }
+    if (parsed.wechatSessionErrorNotifyEnabled === true || parsed.wechatSessionErrorNotifyEnabled === false) {
+        partial.wechatSessionErrorNotifyEnabled = parsed.wechatSessionErrorNotifyEnabled;
+    }
     return partial;
 }
 function readLegacyCommonSettings(store) {
@@ -55,6 +130,11 @@ function mergeCommonSettings(current, legacy) {
         networkRetryEnabled: current.networkRetryEnabled ?? legacy.networkRetryEnabled,
         experimentalSlashCommandsEnabled: current.experimentalSlashCommandsEnabled ?? legacy.experimentalSlashCommandsEnabled,
         experimentalStatusSlashCommandEnabled: current.experimentalStatusSlashCommandEnabled ?? legacy.experimentalStatusSlashCommandEnabled,
+        wechat: current.wechat,
+        wechatNotificationsEnabled: current.wechatNotificationsEnabled ?? legacy.wechatNotificationsEnabled,
+        wechatQuestionNotifyEnabled: current.wechatQuestionNotifyEnabled ?? legacy.wechatQuestionNotifyEnabled,
+        wechatPermissionNotifyEnabled: current.wechatPermissionNotifyEnabled ?? legacy.wechatPermissionNotifyEnabled,
+        wechatSessionErrorNotifyEnabled: current.wechatSessionErrorNotifyEnabled ?? legacy.wechatSessionErrorNotifyEnabled,
     });
 }
 export function parseCommonSettingsStore(raw) {
@@ -116,6 +196,7 @@ export async function writeCommonSettingsStore(store, options) {
         loopSafetyProviderScope: normalized.loopSafetyProviderScope,
         networkRetryEnabled: normalized.networkRetryEnabled,
         experimentalSlashCommandsEnabled: normalized.experimentalSlashCommandsEnabled,
+        wechat: normalized.wechat,
     };
     await fs.mkdir(path.dirname(file), { recursive: true });
     await fs.writeFile(file, JSON.stringify(persisted, null, 2), { mode: 0o600 });

package/dist/menu-runtime.js

@@ -10,6 +10,15 @@ function parseSharedActionResult(result) {
         persistHandled: false,
     };
 }
+function providerActionReason(name) {
+    if (name.startsWith("wechat-")) {
+        return `wechat-action:${name}`;
+    }
+    return `provider-action:${name}`;
+}
+function isNonPersistentProviderAction(name) {
+    return name === "wechat-bind";
+}
 export async function runProviderMenu(input) {
     const now = input.now ?? Date.now;
     const store = await input.adapter.loadStore();
@@ -99,8 +108,10 @@ export async function runProviderMenu(input) {
             continue;
         if (!await input.adapter.applyAction(store, action))
             continue;
+        if (isNonPersistentProviderAction(action.name))
+            continue;
         await input.adapter.writeStore(store, {
-            reason: `provider-action:${action.name}`,
+            reason: providerActionReason(action.name),
             source: "menu-runtime",
             actionType: action.name,
         });

package/dist/plugin-hooks.d.ts

@@ -9,6 +9,7 @@ import { handleStatusCommand } from "./status-command.js";
 import { handleCodexStatusCommand } from "./codex-status-command.js";
 import { handleCompactCommand, handleStopToolCommand } from "./session-control-command.js";
 import { type AppendSessionTouchEventInput, type RouteDecisionEvent, type RoutingSnapshot, type RoutingEvent } from "./routing-state.js";
+import { type WechatBridgeLifecycleInput } from "./wechat/bridge.js";
 type ChatHeadersHook = (input: {
     sessionID: string;
     agent: string;
@@ -81,8 +82,15 @@ export declare function buildPluginHooks(input: {
     }) => Promise<OfficialChatHeadersHook>;
     createRetryFetch?: (fetch: FetchLike, ctx?: CopilotRetryContext) => FetchLike;
     client?: CopilotRetryContext["client"];
+    project?: {
+        id?: string;
+        name?: string;
+    };
     directory?: CopilotRetryContext["directory"];
     serverUrl?: CopilotRetryContext["serverUrl"];
+    createWechatBridgeLifecycleImpl?: (input: WechatBridgeLifecycleInput) => Promise<{
+        close: () => Promise<void>;
+    }>;
     clearAccountSwitchContext?: (lastAccountSwitchAt?: number) => Promise<void>;
     now?: () => number;
     refreshQuota?: RefreshQuota;

package/dist/plugin-hooks.js

@@ -19,6 +19,7 @@ import { handleStatusCommand, showStatusToast } from "./status-command.js";
 import { handleCodexStatusCommand } from "./codex-status-command.js";
 import { handleCompactCommand, handleStopToolCommand, } from "./session-control-command.js";
 import { appendRoutingEvent, appendRouteDecisionEvent, appendSessionTouchEvent, buildCandidateAccountLoads, isAccountRateLimitCooledDown, readRoutingState, routingStatePath, } from "./routing-state.js";
+import { createWechatBridgeLifecycle, } from "./wechat/bridge.js";
 const SESSION_BINDING_IDLE_TTL_MS = 30 * 60 * 1000;
 const RATE_LIMIT_WINDOW_MS = 5 * 60 * 1000;
 const RATE_LIMIT_HIT_THRESHOLD = 3;
@@ -27,6 +28,70 @@ const MAX_SESSION_BINDINGS = 256;
 const TOUCH_WRITE_CACHE_IDLE_TTL_MS = 30 * 60 * 1000;
 const MAX_TOUCH_WRITE_CACHE_ENTRIES = 2048;
 const INTERNAL_DEBUG_LINK_HEADER = "x-opencode-debug-link-id";
+let wechatBridgeLifecycleState;
+let wechatBridgeAutoCloseAttached = false;
+function buildWechatBridgeLifecycleKey(input) {
+    const projectName = typeof input.project?.name === "string" ? input.project.name : "";
+    const projectId = typeof input.project?.id === "string" ? input.project.id : "";
+    const directory = typeof input.directory === "string" ? input.directory : "";
+    const serverUrl = input.serverUrl?.href ?? "";
+    return `${serverUrl}|${directory}|${projectName}|${projectId}`;
+}
+function attachWechatBridgeAutoClose() {
+    if (wechatBridgeAutoCloseAttached) {
+        return;
+    }
+    wechatBridgeAutoCloseAttached = true;
+    const closeLifecycle = () => {
+        const state = wechatBridgeLifecycleState;
+        if (!state)
+            return;
+        closeWechatBridgeLifecycleState(state);
+    };
+    process.once("beforeExit", closeLifecycle);
+    process.once("SIGINT", closeLifecycle);
+    process.once("SIGTERM", closeLifecycle);
+}
+function closeWechatBridgeLifecycleState(state) {
+    if (state.closeRequested) {
+        return;
+    }
+    state.closeRequested = true;
+    void state.promise
+        .then((lifecycle) => lifecycle.close().catch(() => { }))
+        .catch(() => { });
+}
+function ensureWechatBridgeLifecycle(input) {
+    if (wechatBridgeLifecycleState?.key === input.key) {
+        return wechatBridgeLifecycleState.promise;
+    }
+    const previous = wechatBridgeLifecycleState;
+    const promise = input.create();
+    const state = {
+        key: input.key,
+        promise,
+        closeRequested: false,
+    };
+    wechatBridgeLifecycleState = state;
+    if (previous) {
+        closeWechatBridgeLifecycleState(previous);
+    }
+    void promise
+        .then((lifecycle) => {
+        if (wechatBridgeLifecycleState !== state) {
+            closeWechatBridgeLifecycleState(state);
+            return;
+        }
+        state.lifecycle = lifecycle;
+    })
+        .catch((error) => {
+        if (wechatBridgeLifecycleState === state) {
+            wechatBridgeLifecycleState = undefined;
+        }
+        console.warn("[plugin-hooks] failed to initialize wechat bridge lifecycle", error);
+    });
+    return promise;
+}
 export class InjectCommandHandledError extends Error {
     constructor() {
         super("copilot-inject-handled");
@@ -249,6 +314,17 @@ function getFinalSentRequestHeadersRecord(request, init) {
     headers.delete(INTERNAL_DEBUG_LINK_HEADER);
     return sanitizeLoggedRequestHeadersRecord(Object.fromEntries(headers.entries()));
 }
+function hasWechatBridgeClientShape(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const client = value;
+    return typeof client.session?.list === "function"
+        && typeof client.session?.status === "function"
+        && typeof client.session?.todo === "function"
+        && typeof client.session?.messages === "function"
+        && typeof client.question?.list === "function"
+        && typeof client.permission?.list === "function";
+}
 function sanitizeLoggedRequestHeadersRecord(headers) {
     const sanitized = { ...headers };
     if (typeof sanitized.authorization === "string" && sanitized.authorization.length > 0) {
@@ -507,6 +583,26 @@ export function buildPluginHooks(input) {
     const appendRouteDecisionEventImpl = input.appendRouteDecisionEventImpl ?? appendRouteDecisionEvent;
     const readRoutingStateImpl = input.readRoutingStateImpl ?? readRoutingState;
     const triggerBillingCompensation = input.triggerBillingCompensation ?? (async () => { });
+    const createWechatBridgeLifecycleImpl = input.createWechatBridgeLifecycleImpl ?? createWechatBridgeLifecycle;
+    if (input.serverUrl && hasWechatBridgeClientShape(input.client)) {
+        const wechatBridgeClient = input.client;
+        const lifecycleKey = buildWechatBridgeLifecycleKey({
+            directory: input.directory,
+            serverUrl: input.serverUrl,
+            project: input.project,
+        });
+        attachWechatBridgeAutoClose();
+        void ensureWechatBridgeLifecycle({
+            key: lifecycleKey,
+            create: () => createWechatBridgeLifecycleImpl({
+                client: wechatBridgeClient,
+                project: input.project,
+                directory: input.directory,
+                serverUrl: input.serverUrl,
+                statusCollectionEnabled: true,
+            }),
+        }).catch(() => { });
+    }
     const loadCandidateAccountLoads = input.loadCandidateAccountLoads ?? (async (ctx) => {
         const snapshot = await readRoutingStateImpl(routingDirectory);
         return buildCandidateAccountLoads({

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

@@ -7,6 +7,7 @@ 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";
+import { runWechatBindFlow } from "../wechat/bind-flow.js";
 function pickName(input) {
     const accountId = input.accountId?.trim();
     if (accountId)
@@ -370,7 +371,11 @@ export function createCodexMenuAdapter(inputDeps) {
             if (action.name === "toggle-loop-safety"
                 || action.name === "toggle-loop-safety-provider-scope"
                 || action.name === "toggle-experimental-slash-commands"
-                || action.name === "toggle-network-retry") {
+                || action.name === "toggle-network-retry"
+                || action.name === "toggle-wechat-notifications"
+                || action.name === "toggle-wechat-question-notify"
+                || action.name === "toggle-wechat-permission-notify"
+                || action.name === "toggle-wechat-session-error-notify") {
                 await applyCommonSettingsAction({
                     action: { type: action.name },
                     readSettings: readCommonSettings,
@@ -378,6 +383,14 @@ export function createCodexMenuAdapter(inputDeps) {
                 });
                 return false;
             }
+            if (action.name === "wechat-bind" || action.name === "wechat-rebind") {
+                await runWechatBindFlow({
+                    action: action.name,
+                    readCommonSettings,
+                    writeCommonSettings,
+                });
+                return false;
+            }
             return false;
         },
     };

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

@@ -5,6 +5,7 @@ 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 { runWechatBindFlow } from "../wechat/bind-flow.js";
 import { select, selectMany } from "../ui/select.js";
 import { authPath, readAuth, readStore } from "../store.js";
 const CLIENT_ID = "Ov23li8tweQw6odWQebz";
@@ -726,6 +727,10 @@ export function createCopilotMenuAdapter(inputDeps) {
                 || action.name === "toggle-loop-safety-provider-scope"
                 || action.name === "toggle-experimental-slash-commands"
                 || action.name === "toggle-network-retry"
+                || action.name === "toggle-wechat-notifications"
+                || action.name === "toggle-wechat-question-notify"
+                || action.name === "toggle-wechat-permission-notify"
+                || action.name === "toggle-wechat-session-error-notify"
                 || action.name === "toggle-synthetic-agent-initiator") {
                 await applyMenuAction({
                     action: { type: action.name },
@@ -736,6 +741,14 @@ export function createCopilotMenuAdapter(inputDeps) {
                 });
                 return false;
             }
+            if (action.name === "wechat-bind" || action.name === "wechat-rebind") {
+                await runWechatBindFlow({
+                    action: action.name,
+                    readCommonSettings,
+                    writeCommonSettings,
+                });
+                return false;
+            }
             if (action.name === "list-models") {
                 const modelID = await select([
                     { label: "Back", value: "" },

package/dist/store-paths.d.ts

@@ -2,5 +2,6 @@ export declare function accountSwitcherConfigDir(): string;
 export declare function commonSettingsPath(): string;
 export declare function copilotAccountsPath(): string;
 export declare function codexAccountsPath(): string;
+export declare function wechatConfigDir(): string;
 export declare function legacyCopilotStorePath(): string;
 export declare function legacyCodexStorePath(): string;

package/dist/store-paths.js

@@ -16,6 +16,9 @@ export function copilotAccountsPath() {
 export function codexAccountsPath() {
     return path.join(accountSwitcherConfigDir(), "codex-accounts.json");
 }
+export function wechatConfigDir() {
+    return path.join(accountSwitcherConfigDir(), "wechat");
+}
 export function legacyCopilotStorePath() {
     return path.join(configBaseDir(), "opencode", "copilot-accounts.json");
 }

package/dist/ui/menu.d.ts

@@ -1,5 +1,7 @@
 import { select, type MenuItem } from "./select.js";
 import { confirm } from "./confirm.js";
+import { type CommonSettingsStore } from "../common-settings-store.js";
+import { type OperatorBinding } from "../wechat/operator-store.js";
 export type AccountStatus = "active" | "expired" | "unknown";
 export interface AccountInfo {
     name: string;
@@ -69,6 +71,20 @@ export type MenuAction = {
     type: "toggle-experimental-slash-commands";
 } | {
     type: "toggle-network-retry";
+} | {
+    type: "wechat-menu";
+} | {
+    type: "wechat-bind";
+} | {
+    type: "wechat-rebind";
+} | {
+    type: "toggle-wechat-notifications";
+} | {
+    type: "toggle-wechat-question-notify";
+} | {
+    type: "toggle-wechat-permission-notify";
+} | {
+    type: "toggle-wechat-session-error-notify";
 } | {
     type: "toggle-synthetic-agent-initiator";
 } | {
@@ -84,6 +100,42 @@ export type MenuAction = {
 };
 export type MenuLanguage = "zh" | "en";
 export type MenuProvider = "copilot" | "codex";
+export type MenuWechatPrimaryBinding = {
+    accountId: string;
+    userId?: string;
+    name?: string;
+    enabled?: boolean;
+    configured?: boolean;
+    boundAt?: number;
+};
+export type MenuWechatOperatorBinding = {
+    wechatAccountId: string;
+    userId: string;
+    boundAt: number;
+};
+export type ShowMenuInput = {
+    provider?: MenuProvider;
+    refresh?: {
+        enabled: boolean;
+        minutes: number;
+    };
+    lastQuotaRefresh?: number;
+    modelAccountAssignmentCount?: number;
+    defaultAccountGroupCount?: number;
+    loopSafetyEnabled?: boolean;
+    loopSafetyProviderScope?: "copilot-only" | "all-models";
+    networkRetryEnabled?: boolean;
+    wechatNotificationsEnabled?: boolean;
+    wechatQuestionNotifyEnabled?: boolean;
+    wechatPermissionNotifyEnabled?: boolean;
+    wechatSessionErrorNotifyEnabled?: boolean;
+    wechatPrimaryBinding?: MenuWechatPrimaryBinding;
+    wechatOperatorBinding?: MenuWechatOperatorBinding;
+    syntheticAgentInitiatorEnabled?: boolean;
+    experimentalSlashCommandsEnabled?: boolean;
+    capabilities?: Partial<MenuCapabilities>;
+    language?: MenuLanguage;
+};
 type MenuCapabilities = {
     importAuth: boolean;
     quota: boolean;
@@ -96,6 +148,7 @@ type MenuCapabilities = {
     experimentalSlashCommands: boolean;
     networkRetry: boolean;
     syntheticAgentInitiator: boolean;
+    wechatNotificationsMenu: boolean;
 };
 export declare function getMenuCopy(language?: MenuLanguage, provider?: MenuProvider): {
     menuTitle: string;
@@ -130,6 +183,16 @@ export declare function getMenuCopy(language?: MenuLanguage, provider?: MenuProv
     syntheticInitiatorOn: string;
     syntheticInitiatorOff: string;
     syntheticInitiatorHint: string;
+    wechatNotificationsHeading: string;
+    wechatBind: string;
+    wechatNotificationsOn: string;
+    wechatNotificationsOff: string;
+    wechatQuestionNotifyOn: string;
+    wechatQuestionNotifyOff: string;
+    wechatPermissionNotifyOn: string;
+    wechatPermissionNotifyOff: string;
+    wechatSessionErrorNotifyOn: string;
+    wechatSessionErrorNotifyOff: string;
     accountsHeading: string;
     dangerHeading: string;
     removeAll: string;
@@ -147,48 +210,24 @@ export declare function buildMenuItems(input: {
     loopSafetyEnabled: boolean;
     loopSafetyProviderScope?: "copilot-only" | "all-models";
     networkRetryEnabled: boolean;
+    wechatNotificationsEnabled?: boolean;
+    wechatQuestionNotifyEnabled?: boolean;
+    wechatPermissionNotifyEnabled?: boolean;
+    wechatSessionErrorNotifyEnabled?: boolean;
+    wechatPrimaryBinding?: MenuWechatPrimaryBinding;
+    wechatOperatorBinding?: MenuWechatOperatorBinding;
     syntheticAgentInitiatorEnabled?: boolean;
     experimentalSlashCommandsEnabled?: boolean;
     capabilities?: Partial<MenuCapabilities>;
     language?: MenuLanguage;
 }): MenuItem<MenuAction>[];
-export declare function showMenu(accounts: AccountInfo[], input?: {
-    provider?: MenuProvider;
-    refresh?: {
-        enabled: boolean;
-        minutes: number;
-    };
-    lastQuotaRefresh?: number;
-    modelAccountAssignmentCount?: number;
-    defaultAccountGroupCount?: number;
-    loopSafetyEnabled?: boolean;
-    loopSafetyProviderScope?: "copilot-only" | "all-models";
-    networkRetryEnabled?: boolean;
-    syntheticAgentInitiatorEnabled?: boolean;
-    experimentalSlashCommandsEnabled?: boolean;
-    capabilities?: Partial<MenuCapabilities>;
-    language?: MenuLanguage;
-}): Promise<MenuAction>;
-export declare function showMenuWithDeps(accounts: AccountInfo[], input?: {
-    provider?: MenuProvider;
-    refresh?: {
-        enabled: boolean;
-        minutes: number;
-    };
-    lastQuotaRefresh?: number;
-    modelAccountAssignmentCount?: number;
-    defaultAccountGroupCount?: number;
-    loopSafetyEnabled?: boolean;
-    loopSafetyProviderScope?: "copilot-only" | "all-models";
-    networkRetryEnabled?: boolean;
-    syntheticAgentInitiatorEnabled?: boolean;
-    experimentalSlashCommandsEnabled?: boolean;
-    capabilities?: Partial<MenuCapabilities>;
-    language?: MenuLanguage;
-}, deps?: {
+export declare function showMenu(accounts: AccountInfo[], input?: ShowMenuInput): Promise<MenuAction>;
+export declare function showMenuWithDeps(accounts: AccountInfo[], input?: ShowMenuInput, deps?: {
     select?: typeof select;
     confirm?: typeof confirm;
     showAccountActions?: typeof showAccountActions;
+    readCommonSettings?: () => Promise<CommonSettingsStore>;
+    readOperatorBinding?: () => Promise<OperatorBinding | undefined>;
 }): Promise<MenuAction>;
 export declare function buildAccountActionItems(account: AccountInfo, input?: {
     provider?: MenuProvider;