opencode-copilot-account-switcher 0.2.8 → 0.3.0

package/dist/copilot-network-retry.d.ts

@@ -1,4 +1,21 @@
 export type FetchLike = (request: Request | URL | string, init?: RequestInit) => Promise<Response>;
+export type CopilotRetryNotifier = {
+    started: (state: {
+        remaining: number;
+    }) => Promise<void>;
+    progress: (state: {
+        remaining: number;
+    }) => Promise<void>;
+    repairWarning: (state: {
+        remaining: number;
+    }) => Promise<void>;
+    completed: (state: {
+        remaining: number;
+    }) => Promise<void>;
+    stopped: (state: {
+        remaining: number;
+    }) => Promise<void>;
+};
 type JsonRecord = Record<string, unknown>;
 export type CopilotRetryContext = {
     client?: {
@@ -27,14 +44,28 @@ export type CopilotRetryContext = {
                 };
             }>;
         };
+        tui?: {
+            showToast?: (options: {
+                body: {
+                    title?: string;
+                    message: string;
+                    variant: "info" | "success" | "warning" | "error";
+                    duration?: number;
+                };
+                query?: undefined;
+            }) => Promise<unknown>;
+        };
     };
     directory?: string;
     serverUrl?: URL;
+    lastAccountSwitchAt?: number;
+    clearAccountSwitchContext?: () => Promise<void>;
     wait?: (ms: number) => Promise<void>;
     patchPart?: (request: {
         url: string;
         init: RequestInit;
     }) => Promise<unknown>;
+    notifier?: CopilotRetryNotifier;
 };
 export declare function isRetryableCopilotFetchError(error: unknown): boolean;
 export declare function createCopilotRetryingFetch(baseFetch: FetchLike, options?: CopilotRetryContext): (request: Request | URL | string, init?: RequestInit) => Promise<Response>;

package/dist/copilot-network-retry.js

@@ -13,7 +13,6 @@ const RETRYABLE_MESSAGES = [
     "unable to verify the first certificate",
     "self-signed certificate in certificate chain",
 ];
-const INPUT_ID_REPAIR_HARD_LIMIT = 64;
 const INTERNAL_SESSION_HEADER = "x-opencode-session-id";
 const defaultDebugLogFile = (() => {
     const tmp = process.env.TEMP || process.env.TMP || "/tmp";
@@ -110,34 +109,64 @@ function collectLongInputIdCandidates(payload) {
         return [{ item: item, payloadIndex, idLength: id.length }];
     });
 }
-function pickCandidateByServerIndexHint(candidates, serverReportedIndex) {
-    const hintedPayloadIndex = serverReportedIndex - 1;
-    return candidates
-        .filter((candidate) => candidate.payloadIndex >= hintedPayloadIndex)
-        .sort((left, right) => left.payloadIndex - right.payloadIndex)[0];
-}
-function getTargetedLongInputId(payload, serverReportedIndex, reportedLength) {
+function getTargetedLongInputIdSelection(payload, serverReportedIndex, reportedLength) {
     const matches = collectLongInputIdCandidates(payload);
-    if (matches.length === 0)
-        return undefined;
+    if (matches.length === 0) {
+        return {
+            strategy: "ambiguous",
+            candidates: [],
+            reportedLengthMatched: reportedLength === undefined,
+        };
+    }
     const lengthMatches = reportedLength
         ? matches.filter((item) => item.idLength === reportedLength)
         : matches;
-    if (lengthMatches.length === 1)
-        return lengthMatches[0].item;
-    if (matches.length === 1)
-        return matches[0].item;
+    if (reportedLength !== undefined && lengthMatches.length === 0) {
+        return {
+            strategy: "ambiguous",
+            candidates: [],
+            reportedLengthMatched: false,
+        };
+    }
+    if (lengthMatches.length === 1) {
+        return {
+            candidate: lengthMatches[0],
+            strategy: reportedLength !== undefined && matches.length > 1 ? "reported-length" : "single-long-id",
+            candidates: lengthMatches,
+            reportedLengthMatched: true,
+        };
+    }
+    if (matches.length === 1) {
+        return {
+            candidate: matches[0],
+            strategy: "single-long-id",
+            candidates: matches,
+            reportedLengthMatched: reportedLength === undefined,
+        };
+    }
     const narrowedCandidates = lengthMatches.length > 0 ? lengthMatches : matches;
     if (typeof serverReportedIndex === "number") {
-        return pickCandidateByServerIndexHint(narrowedCandidates, serverReportedIndex)?.item;
+        const hintedCandidates = narrowedCandidates.filter((candidate) => candidate.payloadIndex === serverReportedIndex || candidate.payloadIndex + 1 === serverReportedIndex);
+        if (hintedCandidates.length === 1) {
+            return {
+                candidate: hintedCandidates[0],
+                strategy: "index-hint",
+                candidates: narrowedCandidates,
+                reportedLengthMatched: true,
+            };
+        }
     }
-    return undefined;
+    return {
+        strategy: "ambiguous",
+        candidates: narrowedCandidates,
+        reportedLengthMatched: true,
+    };
 }
 function stripTargetedLongInputId(payload, serverReportedIndex, reportedLength) {
     const input = payload.input;
     if (!Array.isArray(input))
         return payload;
-    const target = getTargetedLongInputId(payload, serverReportedIndex, reportedLength);
+    const target = getTargetedLongInputIdSelection(payload, serverReportedIndex, reportedLength).candidate?.item;
     if (!target)
         return payload;
     let changed = false;
@@ -181,6 +210,21 @@ function buildRetryInit(init, payload) {
         body: JSON.stringify(payload),
     };
 }
+const noopNotifier = {
+    started: async () => { },
+    progress: async () => { },
+    repairWarning: async () => { },
+    completed: async () => { },
+    stopped: async () => { },
+};
+async function notify(notifier, event, remaining) {
+    try {
+        await notifier[event]({ remaining });
+    }
+    catch (error) {
+        console.warn(`[copilot-network-retry] notifier ${event} failed`, error);
+    }
+}
 function stripInternalSessionHeaderFromRequest(request) {
     if (!(request instanceof Request))
         return request;
@@ -200,12 +244,18 @@ function getHeader(request, init, name) {
     return undefined;
 }
 function getTargetedInputId(payload, serverReportedIndex, reportedLength) {
-    const target = getTargetedLongInputId(payload, serverReportedIndex, reportedLength);
+    const target = getTargetedLongInputIdSelection(payload, serverReportedIndex, reportedLength).candidate?.item;
     const id = target?.id;
     if (typeof id !== "string")
         return undefined;
     return id;
 }
+function logCleanupStopped(reason, details) {
+    debugLog("input-id retry cleanup-stopped", {
+        reason,
+        ...(details ?? {}),
+    });
+}
 function stripOpenAIItemId(part) {
     const metadata = part.metadata;
     if (!metadata || typeof metadata !== "object")
@@ -316,14 +366,25 @@ async function repairSessionPart(sessionID, failingId, ctx) {
         return false;
     }
 }
-async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx, sessionID) {
+async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requestPayload, ctx, sessionID, startedNotified = false) {
     if (response.status !== 400) {
-        return { response, retried: false, nextInit: init, retryState: undefined };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
     }
-    const requestPayload = parseJsonBody(init);
     if (!requestPayload || !hasLongInputIds(requestPayload)) {
         debugLog("skip input-id retry: request has no long ids");
-        return { response, retried: false, nextInit: init, retryState: undefined };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
     }
     debugLog("input-id retry candidate", {
         status: response.status,
@@ -335,7 +396,13 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
         .catch(() => "");
     if (!responseText) {
         debugLog("skip input-id retry: empty response body");
-        return { response, retried: false, nextInit: init, retryState: undefined };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
     }
     let parsed = parseInputIdTooLongDetails(responseText);
     let matched = parsed.matched;
@@ -361,31 +428,61 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
         reportedLength: parsed.reportedLength,
     });
     if (!matched) {
-        return { response, retried: false, nextInit: init, retryState: undefined };
-    }
-    if (parsed.serverReportedIndex === undefined) {
-        debugLog("skip input-id retry: missing server input index", {
-            reportedLength: parsed.reportedLength,
-        });
-        return { response, retried: false, nextInit: init, retryState: undefined };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
     }
     const payloadCandidates = getPayloadCandidates(requestPayload);
+    const targetSelection = getTargetedLongInputIdSelection(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     debugLog("input-id retry payload candidates", {
         serverReportedIndex: parsed.serverReportedIndex,
         candidates: payloadCandidates,
     });
     const failingId = getTargetedInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
-    const targetedPayload = payloadCandidates.find((item) => item.idLength === parsed.reportedLength) ?? payloadCandidates[0];
-    if (targetedPayload) {
-        debugLog("input-id retry payload target", {
-            targetedPayloadIndex: targetedPayload.payloadIndex,
-            itemKind: targetedPayload.itemKind,
-            idLength: targetedPayload.idLength,
-            idPreview: targetedPayload.idPreview,
+    const targetedPayload = targetSelection.candidate
+        ? payloadCandidates.find((item) => item.payloadIndex === targetSelection.candidate?.payloadIndex)
+        : undefined;
+    debugLog("input-id retry payload target", {
+        serverReportedIndex: parsed.serverReportedIndex,
+        targetedPayloadIndex: targetedPayload?.payloadIndex,
+        itemKind: targetedPayload?.itemKind,
+        idLength: targetedPayload?.idLength,
+        idPreview: targetedPayload?.idPreview,
+        strategy: targetSelection.strategy,
+    });
+    const remainingBefore = countLongInputIdCandidates(requestPayload);
+    if (!targetSelection.candidate) {
+        logCleanupStopped("evidence-insufficient", {
+            serverReportedIndex: parsed.serverReportedIndex,
+            reportedLength: parsed.reportedLength,
+            candidateCount: targetSelection.candidates.length,
+            reportedLengthMatched: targetSelection.reportedLengthMatched,
         });
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: {
+                previousServerReportedIndex: parsed.serverReportedIndex,
+                previousErrorMessagePreview: buildMessagePreview(responseText),
+                remainingLongIdCandidatesBefore: remainingBefore,
+                remainingLongIdCandidatesAfter: remainingBefore,
+                previousReportedLength: parsed.reportedLength,
+                notifiedStarted: startedNotified || remainingBefore > 0,
+                repairFailed: false,
+                stopReason: "evidence-insufficient",
+            },
+        };
     }
+    const notifiedStarted = startedNotified || remainingBefore > 0;
+    let repairFailed = false;
     if (sessionID && failingId) {
-        await repairSessionPart(sessionID, failingId, ctx).catch(() => false);
+        repairFailed = !(await repairSessionPart(sessionID, failingId, ctx).catch(() => false));
     }
     const sanitized = stripTargetedLongInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     if (sanitized === requestPayload) {
@@ -394,11 +491,15 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
             response,
             retried: false,
             nextInit: init,
+            nextPayload: requestPayload,
             retryState: {
                 previousServerReportedIndex: parsed.serverReportedIndex,
                 previousErrorMessagePreview: buildMessagePreview(responseText),
-                remainingLongIdCandidatesBefore: countLongInputIdCandidates(requestPayload),
-                remainingLongIdCandidatesAfter: countLongInputIdCandidates(requestPayload),
+                remainingLongIdCandidatesBefore: remainingBefore,
+                remainingLongIdCandidatesAfter: remainingBefore,
+                previousReportedLength: parsed.reportedLength,
+                notifiedStarted,
+                repairFailed,
             },
         };
     }
@@ -411,14 +512,17 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
     const retryState = {
         previousServerReportedIndex: parsed.serverReportedIndex,
         previousErrorMessagePreview: buildMessagePreview(responseText),
-        remainingLongIdCandidatesBefore: countLongInputIdCandidates(requestPayload),
+        remainingLongIdCandidatesBefore: remainingBefore,
         remainingLongIdCandidatesAfter: countLongInputIdCandidates(parseJsonBody(nextInit)),
+        previousReportedLength: parsed.reportedLength,
+        notifiedStarted,
+        repairFailed,
     };
     debugLog("input-id retry response", {
         status: retried.status,
         contentType: retried.headers.get("content-type") ?? undefined,
     });
-    return { response: retried, retried: true, nextInit, retryState };
+    return { response: retried, retried: true, nextInit, nextPayload: sanitized, retryState };
 }
 function toRetryableSystemError(error) {
     const base = error instanceof Error ? error : new Error(String(error));
@@ -468,9 +572,29 @@ async function getInputIdRetryErrorDetails(response) {
         return undefined;
     return {
         serverReportedIndex: parsed.serverReportedIndex,
+        reportedLength: parsed.reportedLength,
         errorMessagePreview: buildMessagePreview(message),
     };
 }
+async function parseJsonRequestPayload(request, init) {
+    const initPayload = parseJsonBody(init);
+    if (initPayload)
+        return initPayload;
+    if (!(request instanceof Request))
+        return undefined;
+    try {
+        const body = await request.clone().text();
+        if (!body)
+            return undefined;
+        const parsed = JSON.parse(body);
+        if (!parsed || typeof parsed !== "object")
+            return undefined;
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
 function withStreamDebugLogs(response, request) {
     if (!isDebugEnabled())
         return response;
@@ -519,7 +643,7 @@ export function isRetryableCopilotFetchError(error) {
     return RETRYABLE_MESSAGES.some((part) => message.includes(part));
 }
 export function createCopilotRetryingFetch(baseFetch, options) {
-    void options;
+    const notifier = options?.notifier ?? noopNotifier;
     return async function retryingFetch(request, init) {
         const sessionID = getHeader(request, init, INTERNAL_SESSION_HEADER);
         const safeRequest = stripInternalSessionHeaderFromRequest(request);
@@ -535,6 +659,7 @@ export function createCopilotRetryingFetch(baseFetch, options) {
             url: safeRequest instanceof Request ? safeRequest.url : safeRequest instanceof URL ? safeRequest.href : String(safeRequest),
             isCopilot: isCopilotUrl(safeRequest),
         });
+        let currentPayload = await parseJsonRequestPayload(safeRequest, effectiveInit);
         try {
             const response = await baseFetch(safeRequest, effectiveInit);
             debugLog("fetch resolved", {
@@ -545,27 +670,42 @@ export function createCopilotRetryingFetch(baseFetch, options) {
                 let currentResponse = response;
                 let currentInit = effectiveInit;
                 let attempts = 0;
-                while (attempts < INPUT_ID_REPAIR_HARD_LIMIT) {
-                    const remainingCandidates = countLongInputIdCandidates(parseJsonBody(currentInit));
-                    if (remainingCandidates === 0)
-                        break;
-                    const result = await maybeRetryInputIdTooLong(safeRequest, currentInit, currentResponse, baseFetch, options, sessionID);
+                let shouldContinueInputIdRepair = countLongInputIdCandidates(currentPayload) > 0;
+                let startedNotified = false;
+                let finishedNotified = false;
+                let repairWarningNotified = false;
+                while (shouldContinueInputIdRepair) {
+                    shouldContinueInputIdRepair = false;
+                    const result = await maybeRetryInputIdTooLong(safeRequest, currentInit, currentResponse, baseFetch, currentPayload, options, sessionID, startedNotified);
                     currentResponse = result.response;
                     currentInit = result.nextInit;
+                    currentPayload = result.nextPayload;
                     if (result.retryState) {
+                        if (!startedNotified && result.retryState.notifiedStarted) {
+                            startedNotified = true;
+                            await notify(notifier, "started", result.retryState.remainingLongIdCandidatesBefore);
+                        }
+                        if (result.retryState.repairFailed && !repairWarningNotified) {
+                            await notify(notifier, "repairWarning", result.retryState.remainingLongIdCandidatesBefore);
+                            repairWarningNotified = true;
+                        }
                         const currentError = await getInputIdRetryErrorDetails(currentResponse);
-                        let stopReason;
-                        if (result.retryState.remainingLongIdCandidatesAfter >= result.retryState.remainingLongIdCandidatesBefore) {
+                        let stopReason = result.retryState.stopReason;
+                        const madeProgress = result.retryState.remainingLongIdCandidatesAfter < result.retryState.remainingLongIdCandidatesBefore;
+                        if (!stopReason && result.retryState.remainingLongIdCandidatesAfter >= result.retryState.remainingLongIdCandidatesBefore) {
                             stopReason = "remaining-candidates-not-reduced";
                         }
-                        else if (currentError) {
-                            const serverIndexChanged = result.retryState.previousServerReportedIndex !== currentError.serverReportedIndex;
-                            const errorMessageChanged = result.retryState.previousErrorMessagePreview !== currentError.errorMessagePreview;
-                            if (!serverIndexChanged && !errorMessageChanged) {
-                                stopReason = "server-error-unchanged";
-                            }
+                        if (!stopReason &&
+                            currentError &&
+                            result.retryState.remainingLongIdCandidatesAfter > 0 &&
+                            result.retryState.previousServerReportedIndex === currentError.serverReportedIndex &&
+                            result.retryState.previousReportedLength === currentError.reportedLength) {
+                            stopReason = "same-server-item-persists";
                         }
-                        if (currentError || stopReason) {
+                        if (!stopReason && currentError && result.retryState.remainingLongIdCandidatesAfter === 0) {
+                            stopReason = "local-candidates-exhausted";
+                        }
+                        if ((currentError || stopReason) && stopReason !== "evidence-insufficient") {
                             debugLog("input-id retry progress", {
                                 attempt: attempts + 1,
                                 previousServerReportedIndex: result.retryState.previousServerReportedIndex,
@@ -578,11 +718,40 @@ export function createCopilotRetryingFetch(baseFetch, options) {
                                 stopReason,
                             });
                         }
-                        if (stopReason)
+                        if (stopReason === "local-candidates-exhausted") {
+                            logCleanupStopped("local-candidates-exhausted", {
+                                attempt: attempts + 1,
+                                previousServerReportedIndex: result.retryState.previousServerReportedIndex,
+                                currentServerReportedIndex: currentError?.serverReportedIndex,
+                            });
+                        }
+                        if (stopReason) {
+                            await notify(notifier, "stopped", result.retryState.remainingLongIdCandidatesAfter);
+                            finishedNotified = true;
                             break;
+                        }
+                        if (result.retried && madeProgress && result.retryState.remainingLongIdCandidatesAfter > 0) {
+                            await notify(notifier, "progress", result.retryState.remainingLongIdCandidatesAfter);
+                        }
+                        if (result.retried && result.retryState.remainingLongIdCandidatesAfter === 0 && currentResponse.ok) {
+                            await notify(notifier, "completed", 0);
+                            finishedNotified = true;
+                        }
+                        if (result.retried && result.retryState.remainingLongIdCandidatesAfter === 0 && !currentResponse.ok) {
+                            await notify(notifier, "stopped", 0);
+                            finishedNotified = true;
+                        }
+                        if (result.retried && madeProgress && result.retryState.remainingLongIdCandidatesAfter > 0) {
+                            shouldContinueInputIdRepair = true;
+                        }
                     }
-                    if (!result.retried)
+                    if (!result.retried) {
+                        if (startedNotified && !finishedNotified) {
+                            await notify(notifier, "stopped", countLongInputIdCandidates(currentPayload));
+                            finishedNotified = true;
+                        }
                         break;
+                    }
                     attempts += 1;
                 }
                 return withStreamDebugLogs(currentResponse, safeRequest);

package/dist/copilot-retry-notifier.d.ts

@@ -0,0 +1,33 @@
+export declare const ACCOUNT_SWITCH_TTL_MS: number;
+type ToastVariant = "info" | "success" | "warning" | "error";
+type RetryToastState = {
+    remaining: number;
+};
+type RetryToastClient = {
+    tui?: {
+        showToast?: (options: {
+            body: {
+                title?: string;
+                message: string;
+                variant: ToastVariant;
+                duration?: number;
+            };
+            query?: undefined;
+        }) => Promise<unknown>;
+    };
+};
+type RetryNotifierContext = {
+    client?: RetryToastClient;
+    lastAccountSwitchAt?: number;
+    getLastAccountSwitchAt?: () => Promise<number | undefined> | number | undefined;
+    clearAccountSwitchContext?: (lastAccountSwitchAt?: number) => Promise<void>;
+    now?: () => number;
+};
+export declare function createCopilotRetryNotifier(ctx: RetryNotifierContext): {
+    started: (state: RetryToastState) => Promise<void>;
+    progress: (state: RetryToastState) => Promise<void>;
+    repairWarning: (state: RetryToastState) => Promise<void>;
+    completed: (state: RetryToastState) => Promise<void>;
+    stopped: (state: RetryToastState) => Promise<void>;
+};
+export {};

package/dist/copilot-retry-notifier.js

@@ -0,0 +1,69 @@
+export const ACCOUNT_SWITCH_TTL_MS = 30 * 60 * 1000;
+function buildPrefix(lastAccountSwitchAt) {
+    if (typeof lastAccountSwitchAt !== "number")
+        return "Copilot 输入 ID 自动清理中";
+    return "正在清理可能因账号切换遗留的非法输入 ID";
+}
+async function resolveToastAccountSwitchAt(ctx) {
+    if (ctx.lastAccountSwitchAt !== undefined && ctx.lastAccountSwitchAt !== null) {
+        return ctx.lastAccountSwitchAt;
+    }
+    return ctx.getLastAccountSwitchAt?.();
+}
+function isAccountSwitchContextExpired(lastAccountSwitchAt, now) {
+    if (typeof lastAccountSwitchAt !== "number")
+        return false;
+    return now() - lastAccountSwitchAt >= ACCOUNT_SWITCH_TTL_MS;
+}
+async function clearContext(ctx) {
+    try {
+        await ctx.clearAccountSwitchContext?.();
+    }
+    catch (error) {
+        console.warn("[copilot-retry-notifier] failed to clear account-switch context", error);
+    }
+}
+export function createCopilotRetryNotifier(ctx) {
+    let lastExpiredContextClearedAt;
+    async function send(variant, detail, state, clear = false) {
+        const now = ctx.now ?? Date.now;
+        const lastAccountSwitchAt = await resolveToastAccountSwitchAt(ctx);
+        try {
+            await ctx.client?.tui?.showToast?.({
+                body: {
+                    variant,
+                    message: `${buildPrefix(lastAccountSwitchAt)}：${detail}，剩余 ${state.remaining} 项。`,
+                },
+            });
+        }
+        catch (error) {
+            console.warn("[copilot-retry-notifier] failed to show toast", error);
+        }
+        if (!clear
+            && isAccountSwitchContextExpired(lastAccountSwitchAt, now)
+            && lastAccountSwitchAt !== lastExpiredContextClearedAt) {
+            lastExpiredContextClearedAt = lastAccountSwitchAt;
+            await clearContext({
+                ...ctx,
+                clearAccountSwitchContext: async () => {
+                    await ctx.clearAccountSwitchContext?.(lastAccountSwitchAt);
+                },
+            });
+        }
+        if (!clear)
+            return;
+        await clearContext({
+            ...ctx,
+            clearAccountSwitchContext: async () => {
+                await ctx.clearAccountSwitchContext?.(lastAccountSwitchAt);
+            },
+        });
+    }
+    return {
+        started: async (state) => send("info", "已开始自动清理", state),
+        progress: async (state) => send("info", "自动清理仍在继续", state),
+        repairWarning: async (state) => send("warning", "会话回写失败，继续尝试仅清理请求体", state),
+        completed: async (state) => send("success", "自动清理已完成", state, true),
+        stopped: async (state) => send("warning", "自动清理已停止", state, true),
+    };
+}

package/dist/plugin-actions.d.ts

@@ -1,5 +1,11 @@
 import type { StoreFile } from "./store.js";
 import type { MenuAction } from "./ui/menu.js";
+export declare function persistAccountSwitch(input: {
+    store: StoreFile;
+    name: string;
+    at: number;
+    writeStore: (store: StoreFile) => Promise<void>;
+}): Promise<void>;
 export declare function applyMenuAction(input: {
     action: MenuAction;
     store: StoreFile;

package/dist/plugin-actions.js

@@ -1,3 +1,9 @@
+export async function persistAccountSwitch(input) {
+    input.store.active = input.name;
+    input.store.accounts[input.name].lastUsed = input.at;
+    input.store.lastAccountSwitchAt = input.at;
+    await input.writeStore(input.store);
+}
 export async function applyMenuAction(input) {
     if (input.action.type === "toggle-loop-safety") {
         input.store.loopSafetyEnabled = input.store.loopSafetyEnabled !== true;

package/dist/plugin-hooks.d.ts

@@ -25,6 +25,7 @@ type CopilotPluginHooksWithChatHeaders = CopilotPluginHooks & {
 export declare function buildPluginHooks(input: {
     auth: NonNullable<CopilotPluginHooks["auth"]>;
     loadStore?: () => Promise<StoreFile | undefined>;
+    writeStore?: (store: StoreFile) => Promise<void>;
     loadOfficialConfig?: (input: {
         getAuth: () => Promise<CopilotAuthState | undefined>;
         provider?: CopilotProviderConfig;
@@ -33,5 +34,7 @@ export declare function buildPluginHooks(input: {
     client?: CopilotRetryContext["client"];
     directory?: CopilotRetryContext["directory"];
     serverUrl?: CopilotRetryContext["serverUrl"];
+    clearAccountSwitchContext?: (lastAccountSwitchAt?: number) => Promise<void>;
+    now?: () => number;
 }): CopilotPluginHooksWithChatHeaders;
 export {};

package/dist/plugin-hooks.js

@@ -1,11 +1,42 @@
 import { createLoopSafetySystemTransform, isCopilotProvider, } from "./loop-safety-plugin.js";
 import { createCopilotRetryingFetch, } from "./copilot-network-retry.js";
-import { readStoreSafe } from "./store.js";
+import { createCopilotRetryNotifier } from "./copilot-retry-notifier.js";
+import { readStoreSafe, writeStore } from "./store.js";
 import { loadOfficialCopilotConfig, } from "./upstream/copilot-loader-adapter.js";
+function readRetryStoreContext(store) {
+    if (!store)
+        return undefined;
+    const maybeLastAccountSwitchAt = store.lastAccountSwitchAt;
+    return {
+        networkRetryEnabled: store.networkRetryEnabled,
+        lastAccountSwitchAt: typeof maybeLastAccountSwitchAt === "number" ? maybeLastAccountSwitchAt : undefined,
+    };
+}
 export function buildPluginHooks(input) {
     const loadStore = input.loadStore ?? readStoreSafe;
+    const persistStore = input.writeStore ?? writeStore;
     const loadOfficialConfig = input.loadOfficialConfig ?? loadOfficialCopilotConfig;
     const createRetryFetch = input.createRetryFetch ?? createCopilotRetryingFetch;
+    const getLatestLastAccountSwitchAt = async () => {
+        const store = readRetryStoreContext(await loadStore().catch(() => undefined));
+        return store?.lastAccountSwitchAt;
+    };
+    const clearAccountSwitchContext = input.clearAccountSwitchContext ?? (async (capturedLastAccountSwitchAt) => {
+        if (capturedLastAccountSwitchAt === undefined)
+            return;
+        try {
+            const latestStore = await loadStore().catch(() => undefined);
+            if (!latestStore)
+                return;
+            if (latestStore.lastAccountSwitchAt !== capturedLastAccountSwitchAt)
+                return;
+            delete latestStore.lastAccountSwitchAt;
+            await persistStore(latestStore);
+        }
+        catch (error) {
+            console.warn("[plugin-hooks] failed to clear account-switch context", error);
+        }
+    });
     const loader = async (getAuth, provider) => {
         const config = await loadOfficialConfig({
             getAuth: getAuth,
@@ -13,7 +44,7 @@ export function buildPluginHooks(input) {
         });
         if (!config)
             return {};
-        const store = await loadStore().catch(() => undefined);
+        const store = readRetryStoreContext(await loadStore().catch(() => undefined));
         if (store?.networkRetryEnabled !== true) {
             return config;
         }
@@ -23,6 +54,15 @@ export function buildPluginHooks(input) {
                 client: input.client,
                 directory: input.directory,
                 serverUrl: input.serverUrl,
+                lastAccountSwitchAt: store.lastAccountSwitchAt,
+                notifier: createCopilotRetryNotifier({
+                    client: input.client,
+                    lastAccountSwitchAt: store.lastAccountSwitchAt,
+                    getLastAccountSwitchAt: getLatestLastAccountSwitchAt,
+                    clearAccountSwitchContext,
+                    now: input.now,
+                }),
+                clearAccountSwitchContext: async () => clearAccountSwitchContext(store.lastAccountSwitchAt),
             }),
         };
     };

package/dist/plugin.d.ts

@@ -1,2 +1,10 @@
 import type { Plugin } from "@opencode-ai/plugin";
+import { type StoreFile } from "./store.js";
+export declare function activateAddedAccount(input: {
+    store: StoreFile;
+    name: string;
+    switchAccount: () => Promise<void>;
+    writeStore: (store: StoreFile) => Promise<void>;
+    now?: () => number;
+}): Promise<void>;
 export declare const CopilotAccountSwitcher: Plugin;

package/dist/plugin.js

@@ -1,6 +1,6 @@
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { applyMenuAction } from "./plugin-actions.js";
+import { applyMenuAction, persistAccountSwitch } from "./plugin-actions.js";
 import { buildPluginHooks } from "./plugin-hooks.js";
 import { isTTY } from "./ui/ansi.js";
 import { showAccountActions, showMenu } from "./ui/menu.js";
@@ -443,6 +443,16 @@ async function switchAccount(client, entry) {
         body: payload,
     });
 }
+export async function activateAddedAccount(input) {
+    await input.writeStore(input.store);
+    await input.switchAccount();
+    await persistAccountSwitch({
+        store: input.store,
+        name: input.name,
+        at: (input.now ?? now)(),
+        writeStore: input.writeStore,
+    });
+}
 export const CopilotAccountSwitcher = async (input) => {
     const client = input.client;
     const directory = input.directory;
@@ -487,8 +497,12 @@ export const CopilotAccountSwitcher = async (input) => {
             const { name, entry } = await promptAccountEntry([]);
             store.accounts[name] = entry;
             store.active = name;
-            await writeStore(store);
-            await switchAccount(client, entry);
+            await activateAddedAccount({
+                store,
+                name,
+                switchAccount: () => switchAccount(client, entry),
+                writeStore,
+            });
             // fallthrough to menu
         }
         if (!Object.values(store.accounts).some((entry) => entry.user || entry.email || (entry.orgs && entry.orgs.length > 0))) {
@@ -590,9 +604,17 @@ export const CopilotAccountSwitcher = async (input) => {
                     entry.name = buildName(entry, user?.login);
                     store.accounts[entry.name] = entry;
                     store.active = store.active ?? entry.name;
-                    await writeStore(store);
-                    if (store.active === entry.name)
-                        await switchAccount(client, entry);
+                    if (store.active === entry.name) {
+                        await activateAddedAccount({
+                            store,
+                            name: entry.name,
+                            switchAccount: () => switchAccount(client, entry),
+                            writeStore,
+                        });
+                    }
+                    else {
+                        await writeStore(store);
+                    }
                     continue;
                 }
                 const manual = await promptAccountEntry(Object.keys(store.accounts));
@@ -606,9 +628,17 @@ export const CopilotAccountSwitcher = async (input) => {
                 manual.entry.name = buildName(manual.entry, user?.login);
                 store.accounts[manual.entry.name] = manual.entry;
                 store.active = store.active ?? manual.entry.name;
-                await writeStore(store);
-                if (store.active === manual.entry.name)
-                    await switchAccount(client, manual.entry);
+                if (store.active === manual.entry.name) {
+                    await activateAddedAccount({
+                        store,
+                        name: manual.entry.name,
+                        switchAccount: () => switchAccount(client, manual.entry),
+                        writeStore,
+                    });
+                }
+                else {
+                    await writeStore(store);
+                }
                 continue;
             }
             if (action.type === "import") {
@@ -700,9 +730,12 @@ export const CopilotAccountSwitcher = async (input) => {
                     continue;
                 }
                 await switchAccount(client, entry);
-                store.active = name;
-                store.accounts[name].lastUsed = now();
-                await writeStore(store);
+                await persistAccountSwitch({
+                    store,
+                    name,
+                    at: now(),
+                    writeStore,
+                });
                 console.log("Switched account. If a later Copilot session hits input[*].id too long after switching, enable Copilot Network Retry from the menu.");
                 continue;
             }

package/dist/store.d.ts

@@ -53,6 +53,7 @@ export type StoreFile = {
     accounts: Record<string, AccountEntry>;
     autoRefresh?: boolean;
     refreshMinutes?: number;
+    lastAccountSwitchAt?: number;
     lastQuotaRefresh?: number;
     loopSafetyEnabled?: boolean;
     networkRetryEnabled?: boolean;

package/dist/store.js

@@ -16,6 +16,9 @@ export function parseStore(raw) {
     const data = raw ? JSON.parse(raw) : { accounts: {} };
     if (!data.accounts)
         data.accounts = {};
+    if (typeof data.lastAccountSwitchAt !== "number" || Number.isNaN(data.lastAccountSwitchAt)) {
+        delete data.lastAccountSwitchAt;
+    }
     if (data.loopSafetyEnabled !== false)
         data.loopSafetyEnabled = true;
     if (data.networkRetryEnabled !== true)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-copilot-account-switcher",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",