opencode-copilot-account-switcher 0.2.7 → 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 MAX_INPUT_ID_REPAIR_ATTEMPTS = 3;
 const INTERNAL_SESSION_HEADER = "x-opencode-session-id";
 const defaultDebugLogFile = (() => {
     const tmp = process.env.TEMP || process.env.TMP || "/tmp";
@@ -70,6 +69,9 @@ function parseInputIdTooLongDetails(text) {
 function buildIdPreview(id) {
     return `${id.slice(0, 12)}...`;
 }
+function buildMessagePreview(message) {
+    return message.slice(0, 160);
+}
 function getPayloadCandidates(payload) {
     const input = payload.input;
     if (!Array.isArray(input))
@@ -89,33 +91,82 @@ function hasLongInputIds(payload) {
         return false;
     return input.some((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
 }
-function getTargetedLongInputId(payload, reportedLength) {
+function countLongInputIdCandidates(payload) {
+    const input = payload?.input;
+    if (!Array.isArray(input))
+        return 0;
+    return input.filter((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64)
+        .length;
+}
+function collectLongInputIdCandidates(payload) {
     const input = payload.input;
     if (!Array.isArray(input))
-        return undefined;
-    const matches = input.filter((item) => typeof item?.id === "string" && (item.id?.length ?? 0) > 64);
-    if (matches.length === 0)
-        return undefined;
+        return [];
+    return input.flatMap((item, payloadIndex) => {
+        const id = item?.id;
+        if (typeof id !== "string" || id.length <= 64)
+            return [];
+        return [{ item: item, payloadIndex, idLength: id.length }];
+    });
+}
+function getTargetedLongInputIdSelection(payload, serverReportedIndex, reportedLength) {
+    const matches = collectLongInputIdCandidates(payload);
+    if (matches.length === 0) {
+        return {
+            strategy: "ambiguous",
+            candidates: [],
+            reportedLengthMatched: reportedLength === undefined,
+        };
+    }
     const lengthMatches = reportedLength
-        ? matches.filter((item) => String(item.id ?? "").length === reportedLength)
+        ? matches.filter((item) => item.idLength === reportedLength)
         : matches;
-    if (lengthMatches.length === 1)
-        return lengthMatches[0];
-    if (lengthMatches.length > 1)
-        return lengthMatches[0];
-    if (matches.length === 1)
-        return matches[0];
-    return matches.reduce((best, item) => {
-        const bestLength = String(best.id ?? "").length;
-        const itemLength = String(item.id ?? "").length;
-        return itemLength > bestLength ? item : best;
-    }, matches[0]);
-}
-function stripTargetedLongInputId(payload, reportedLength) {
+    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") {
+        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 {
+        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, reportedLength);
+    const target = getTargetedLongInputIdSelection(payload, serverReportedIndex, reportedLength).candidate?.item;
     if (!target)
         return payload;
     let changed = false;
@@ -159,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;
@@ -177,13 +243,19 @@ function getHeader(request, init, name) {
         return request.headers.get(name) ?? undefined;
     return undefined;
 }
-function getTargetedInputId(payload, reportedLength) {
-    const target = getTargetedLongInputId(payload, reportedLength);
+function getTargetedInputId(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")
@@ -247,30 +319,72 @@ async function repairSessionPart(sessionID, failingId, ctx) {
         body: JSON.stringify(body),
     };
     if (ctx?.patchPart) {
-        await ctx.patchPart({ url: url.href, init });
+        try {
+            await ctx.patchPart({ url: url.href, init });
+            debugLog("input-id retry session repair", {
+                partID: match.partID,
+                messageID: match.messageID,
+                sessionID,
+            });
+            return true;
+        }
+        catch (error) {
+            debugLog("input-id retry session repair failed", {
+                partID: match.partID,
+                messageID: match.messageID,
+                sessionID,
+                error: String(error instanceof Error ? error.message : error),
+            });
+            return false;
+        }
+    }
+    try {
+        const response = await fetch(url, init);
         debugLog("input-id retry session repair", {
             partID: match.partID,
             messageID: match.messageID,
             sessionID,
+            ok: response.ok,
         });
-        return true;
+        if (!response.ok) {
+            debugLog("input-id retry session repair failed", {
+                partID: match.partID,
+                messageID: match.messageID,
+                sessionID,
+                status: response.status,
+            });
+        }
+        return response.ok;
+    }
+    catch (error) {
+        debugLog("input-id retry session repair failed", {
+            partID: match.partID,
+            messageID: match.messageID,
+            sessionID,
+            error: String(error instanceof Error ? error.message : error),
+        });
+        return false;
     }
-    const response = await fetch(url, init);
-    debugLog("input-id retry session repair", {
-        partID: match.partID,
-        messageID: match.messageID,
-        sessionID,
-        ok: response.ok,
-    });
-    return response.ok;
 }
-async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx, sessionID) {
-    if (response.status !== 400)
-        return { response, retried: false, nextInit: init };
-    const requestPayload = parseJsonBody(init);
+async function maybeRetryInputIdTooLong(request, init, response, baseFetch, requestPayload, ctx, sessionID, startedNotified = false) {
+    if (response.status !== 400) {
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
+    }
     if (!requestPayload || !hasLongInputIds(requestPayload)) {
         debugLog("skip input-id retry: request has no long ids");
-        return { response, retried: false, nextInit: init };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
     }
     debugLog("input-id retry candidate", {
         status: response.status,
@@ -282,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 };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: undefined,
+        };
     }
     let parsed = parseInputIdTooLongDetails(responseText);
     let matched = parsed.matched;
@@ -307,36 +427,81 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
         serverReportedIndex: parsed.serverReportedIndex,
         reportedLength: parsed.reportedLength,
     });
-    if (!matched)
-        return { response, retried: false, nextInit: init };
-    if (parsed.serverReportedIndex === undefined) {
-        debugLog("skip input-id retry: missing server input index", {
-            reportedLength: parsed.reportedLength,
-        });
-        return { response, retried: false, nextInit: init };
+    if (!matched) {
+        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.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 failingId = getTargetedInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
+    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.reportedLength);
+    const sanitized = stripTargetedLongInputId(requestPayload, parsed.serverReportedIndex, parsed.reportedLength);
     if (sanitized === requestPayload) {
         debugLog("skip input-id retry: sanitize made no changes");
-        return { response, retried: false, nextInit: init };
+        return {
+            response,
+            retried: false,
+            nextInit: init,
+            nextPayload: requestPayload,
+            retryState: {
+                previousServerReportedIndex: parsed.serverReportedIndex,
+                previousErrorMessagePreview: buildMessagePreview(responseText),
+                remainingLongIdCandidatesBefore: remainingBefore,
+                remainingLongIdCandidatesAfter: remainingBefore,
+                previousReportedLength: parsed.reportedLength,
+                notifiedStarted,
+                repairFailed,
+            },
+        };
     }
     debugLog("input-id retry triggered", {
         removedLongIds: true,
@@ -344,11 +509,20 @@ async function maybeRetryInputIdTooLong(request, init, response, baseFetch, ctx,
     });
     const nextInit = buildRetryInit(init, sanitized);
     const retried = await baseFetch(request, nextInit);
+    const retryState = {
+        previousServerReportedIndex: parsed.serverReportedIndex,
+        previousErrorMessagePreview: buildMessagePreview(responseText),
+        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 };
+    return { response: retried, retried: true, nextInit, nextPayload: sanitized, retryState };
 }
 function toRetryableSystemError(error) {
     const base = error instanceof Error ? error : new Error(String(error));
@@ -370,6 +544,57 @@ function isCopilotUrl(request) {
         return false;
     }
 }
+async function getInputIdRetryErrorDetails(response) {
+    if (response.status !== 400)
+        return undefined;
+    const responseText = await response
+        .clone()
+        .text()
+        .catch(() => "");
+    if (!responseText)
+        return undefined;
+    let parsed = parseInputIdTooLongDetails(responseText);
+    let matched = parsed.matched;
+    let message = responseText;
+    if (!matched) {
+        try {
+            const bodyPayload = JSON.parse(responseText);
+            const error = bodyPayload.error;
+            message = String(error?.message ?? "");
+            parsed = parseInputIdTooLongDetails(message);
+            matched = parsed.matched || isInputIdTooLongErrorBody(bodyPayload);
+        }
+        catch {
+            matched = false;
+        }
+    }
+    if (!matched)
+        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;
@@ -418,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);
@@ -434,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", {
@@ -443,12 +669,90 @@ export function createCopilotRetryingFetch(baseFetch, options) {
             if (isCopilotUrl(safeRequest)) {
                 let currentResponse = response;
                 let currentInit = effectiveInit;
-                for (let attempt = 0; attempt < MAX_INPUT_ID_REPAIR_ATTEMPTS; attempt += 1) {
-                    const result = await maybeRetryInputIdTooLong(safeRequest, currentInit, currentResponse, baseFetch, options, sessionID);
+                let attempts = 0;
+                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;
-                    if (!result.retried)
+                    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 = result.retryState.stopReason;
+                        const madeProgress = result.retryState.remainingLongIdCandidatesAfter < result.retryState.remainingLongIdCandidatesBefore;
+                        if (!stopReason && result.retryState.remainingLongIdCandidatesAfter >= result.retryState.remainingLongIdCandidatesBefore) {
+                            stopReason = "remaining-candidates-not-reduced";
+                        }
+                        if (!stopReason &&
+                            currentError &&
+                            result.retryState.remainingLongIdCandidatesAfter > 0 &&
+                            result.retryState.previousServerReportedIndex === currentError.serverReportedIndex &&
+                            result.retryState.previousReportedLength === currentError.reportedLength) {
+                            stopReason = "same-server-item-persists";
+                        }
+                        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,
+                                currentServerReportedIndex: currentError?.serverReportedIndex,
+                                serverIndexChanged: result.retryState.previousServerReportedIndex !== currentError?.serverReportedIndex,
+                                previousErrorMessagePreview: result.retryState.previousErrorMessagePreview,
+                                currentErrorMessagePreview: currentError?.errorMessagePreview,
+                                remainingLongIdCandidatesBefore: result.retryState.remainingLongIdCandidatesBefore,
+                                remainingLongIdCandidatesAfter: result.retryState.remainingLongIdCandidatesAfter,
+                                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 (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/loop-safety-plugin.d.ts

@@ -1,6 +1,6 @@
 import type { Hooks } from "@opencode-ai/plugin";
 import { type StoreFile } from "./store.js";
-export declare const LOOP_SAFETY_POLICY = "Guided Loop Safety Policy\n- Continue working on any remaining non-blocked task before stopping to report or wait for more instructions.\n- If you are not fully blocked, do not stop just because you feel ready to pause; finish the work that can still be done safely.\n- MANDATORY: When the question tool is available and permitted in the current session, ALL user-facing reports MUST be delivered through the question tool.\n- MANDATORY: Treat progress updates, status reports, summaries, explanations, completion notes, and next-step choices as user-facing reports.\n- MANDATORY: In this workflow, the question tool is both the question channel and the report channel for user-visible communication.\n- MANDATORY: Do not reinterpret \"keep working unless blocked\" as permission to send direct assistant text. If you need to report, report through the question tool.\n- MANDATORY: Do not reinterpret \"don't ask unnecessary questions\" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.\n- MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.\n- MANDATORY: When reflecting on mistakes, check report-channel violations before any secondary critique.\n- MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.\n- MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.\n- NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.\n- The question tool is considered available and permitted when it appears in the active tool list and the current session has not denied its use.\n- Direct assistant text is allowed only when the question tool is unavailable, denied, or absent from the current session.\n- If a report would otherwise be sent as direct text, convert it into one question batch or a short sequence of question batches instead.\n- IMPORTANT: A report-mode violation usually means the wrong tool was used, not that the report was too long.\n- IMPORTANT: Do not reinterpret a tool-usage violation as a verbosity problem.\n- Long reports are allowed. Use pagination or sequential question batches when needed; do not fall back to direct assistant text.\n- A single question tool call may contain multiple well-grouped questions. Prefer that over multiple small interruptions when it keeps the report clear.\n- Group related items into explicit batches such as current progress, key findings, decisions, and next-step choices.\n- Present the highest-priority information first and defer secondary details to later question batches when needed.\n- Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.\n- Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.\n- MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.\n- MANDATORY: Never send assistant text as a post-report fallback in either branch.\n- MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.\n- When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.\n- When the user says \"stop\", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.\n- Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.\n- Materially improves the result means clearly beneficial cases such as parallel analysis of independent areas; it does not include routine local searches, small file reads, or straightforward edits.\n- If task or subagent delegation is used, keep the number minimal and explain the reason briefly through the question tool when available.";
+export declare const LOOP_SAFETY_POLICY = "Guided Loop Safety Policy\n- Continue working on any remaining non-blocked task before stopping to report or wait for more instructions.\n- If you are not fully blocked, do not stop just because you feel ready to pause; finish the work that can still be done safely.\n- MANDATORY: When the question tool is available and permitted in the current session, ALL user-facing reports MUST be delivered through the question tool.\n- MANDATORY: Treat progress updates, status reports, summaries, explanations, completion notes, and next-step choices as user-facing reports.\n- MANDATORY: In this workflow, the question tool is both the question channel and the report channel for user-visible communication.\n- MANDATORY: Do not reinterpret \"keep working unless blocked\" as permission to send direct assistant text. If you need to report, report through the question tool.\n- MANDATORY: Do not reinterpret \"don't ask unnecessary questions\" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.\n- MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.\n- MANDATORY: When reflecting on report-delivery or tool-usage mistakes, first check report-channel violations before any secondary critique.\n- MANDATORY: Do not reinterpret those report-channel violations as a problem with the report policy itself.\n- MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.\n- MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.\n- NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.\n- The question tool is considered available and permitted when it appears in the active tool list and the current session has not denied its use.\n- Direct assistant text is allowed only when the question tool is unavailable, denied, or absent from the current session.\n- If a report would otherwise be sent as direct text, convert it into one question batch or a short sequence of question batches instead.\n- IMPORTANT: A report-mode violation usually means the wrong tool was used, not that the report was too long.\n- IMPORTANT: Do not reinterpret a tool-usage violation as a verbosity problem.\n- Long reports are allowed. Use pagination or sequential question batches when needed; do not fall back to direct assistant text.\n- A single question tool call may contain multiple well-grouped questions. Prefer that over multiple small interruptions when it keeps the report clear.\n- Group related items into explicit batches such as current progress, key findings, decisions, and next-step choices.\n- Present the highest-priority information first and defer secondary details to later question batches when needed.\n- Even when no explicit decision is required, use brief question-tool status updates instead of direct assistant text whenever the tool is available.\n- Avoid unnecessary question frequency; combine small related updates when a single question call can cover them clearly.\n- MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.\n- MANDATORY: Never send assistant text as a post-report fallback in either branch.\n- MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.\n- MANDATORY: When idle or waiting for the next task, continue using the question tool to maintain user control of the session.\n- MANDATORY: Repeated waiting for the next task is not a reason to stop using the question tool.\n- When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.\n- When the user says \"stop\", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.\n- Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.\n- Materially improves the result means clearly beneficial cases such as parallel analysis of independent areas; it does not include routine local searches, small file reads, or straightforward edits.\n- If task or subagent delegation is used, keep the number minimal and explain the reason briefly through the question tool when available.";
 export type ExperimentalChatSystemTransformHook = (input: {
     sessionID: string;
     model: {

package/dist/loop-safety-plugin.js

@@ -8,7 +8,8 @@ export const LOOP_SAFETY_POLICY = `Guided Loop Safety Policy
 - MANDATORY: Do not reinterpret "keep working unless blocked" as permission to send direct assistant text. If you need to report, report through the question tool.
 - MANDATORY: Do not reinterpret "don't ask unnecessary questions" as permission to skip the question tool. Use fewer question batches, not a different reporting channel.
 - MANDATORY: If the user says a report was sent the wrong way, first check whether you used the wrong channel before analyzing verbosity, timing, or wording.
-- MANDATORY: When reflecting on mistakes, check report-channel violations before any secondary critique.
+- MANDATORY: When reflecting on report-delivery or tool-usage mistakes, first check report-channel violations before any secondary critique.
+- MANDATORY: Do not reinterpret those report-channel violations as a problem with the report policy itself.
 - MANDATORY: Do not turn a pure report into a preference question, permission question, or route-selection question just to satisfy the question tool requirement.
 - MANDATORY: When no user decision is needed, use the question tool as a report container with the smallest sensible option set.
 - NO EXCEPTIONS: Do not switch to direct assistant text just because the report is long, detailed, complex, or contains multiple related items.
@@ -26,6 +27,8 @@ export const LOOP_SAFETY_POLICY = `Guided Loop Safety Policy
 - MANDATORY: After any successful question-tool report, immediately choose between (a) continue unfinished non-blocked work, or (b) issue a question-tool wait-for-instruction message when no such work remains.
 - MANDATORY: Never send assistant text as a post-report fallback in either branch.
 - MANDATORY: If a post-report branch has no content, suppress assistant output and re-enter question-tool flow.
+- MANDATORY: When idle or waiting for the next task, continue using the question tool to maintain user control of the session.
+- MANDATORY: Repeated waiting for the next task is not a reason to stop using the question tool.
 - When no further action can be taken safely and no non-blocked work remains, use the question tool to ask for the next task or clarification instead of ending with direct assistant text.
 - When the user says "stop", do not send assistant text to acknowledge the stop. Use the question tool only if more user-visible communication is still required by policy.
 - Dispatching task or subagent work is expensive and should be avoided unless it materially improves the result.

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.7",
+  "version": "0.3.0",
   "description": "GitHub Copilot account switcher plugin for OpenCode",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",