opencode-copilot-account-switcher 0.11.0 → 0.12.0

package/dist/retry/copilot-policy.js

@@ -0,0 +1,240 @@
+const AI_ERROR_MARKER = Symbol.for("vercel.ai.error");
+const API_CALL_ERROR_MARKER = Symbol.for("vercel.ai.error.AI_APICallError");
+export const COPILOT_RETRYABLE_MESSAGES = [
+    "load failed",
+    "failed to fetch",
+    "network request failed",
+    "unable to connect",
+    "econnreset",
+    "etimedout",
+    "socket hang up",
+    "unknown certificate",
+    "self signed certificate",
+    "unable to verify the first certificate",
+    "self-signed certificate in certificate chain",
+];
+function toRequestUrl(request) {
+    return request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
+}
+function getErrorMessage(error) {
+    return String(error instanceof Error ? error.message : error).toLowerCase();
+}
+function isAbortError(error) {
+    return error instanceof Error && error.name === "AbortError";
+}
+function isSseReadTimeoutError(error) {
+    return getErrorMessage(error).includes("sse read timed out");
+}
+function isCopilotResponsesPath(request) {
+    const raw = toRequestUrl(request);
+    try {
+        const url = new URL(raw);
+        return url.pathname === "/responses";
+    }
+    catch {
+        return false;
+    }
+}
+function hasLongInputIds(payload) {
+    const input = payload?.input;
+    if (!Array.isArray(input))
+        return false;
+    return input.some((item) => {
+        const id = item?.id;
+        return typeof id === "string" && id.length > 64;
+    });
+}
+function collectInputItemIds(payload) {
+    const input = payload?.input;
+    if (!Array.isArray(input))
+        return [];
+    return [...new Set(input.flatMap((item) => {
+            const id = item?.id;
+            return typeof id === "string" && id.length > 0 ? [id] : [];
+        }))];
+}
+function isInputIdTooLongMessage(text) {
+    const message = text.toLowerCase();
+    return message.includes("string too long") && (message.includes("input id") || message.includes(".id'"));
+}
+function isConnectionMismatchInputIdMessage(text) {
+    const message = text.toLowerCase();
+    return message.includes("does not belong to this connection") && /item(?:\s+with)?\s+id/.test(message);
+}
+function isInputIdTooLongErrorBody(payload) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const error = payload.error;
+    const message = String(error?.message ?? "").toLowerCase();
+    return message.includes("string too long") && (message.includes("input id") || message.includes(".id'"));
+}
+function isConnectionMismatchInputIdErrorBody(payload) {
+    if (!payload || typeof payload !== "object")
+        return false;
+    const error = payload.error;
+    return isConnectionMismatchInputIdMessage(String(error?.message ?? ""));
+}
+function parseInputIdTooLongDetails(text) {
+    const matched = isInputIdTooLongMessage(text);
+    if (!matched)
+        return { matched };
+    const index = text.match(/input\[(\d+)\]\.id/i);
+    const length = text.match(/got a string with length\s+(\d+)/i) ?? text.match(/length\s+(\d+)/i);
+    return {
+        matched,
+        serverReportedIndex: index ? Number(index[1]) : undefined,
+        reportedLength: length ? Number(length[1]) : undefined,
+    };
+}
+export function isCopilotUrl(request) {
+    const raw = toRequestUrl(request);
+    try {
+        const url = new URL(raw);
+        return url.hostname === "api.githubcopilot.com" || url.hostname.startsWith("copilot-api.");
+    }
+    catch {
+        return false;
+    }
+}
+export function isRetryableCopilotTransportError(error) {
+    if (!error || isAbortError(error))
+        return false;
+    const message = getErrorMessage(error);
+    return COPILOT_RETRYABLE_MESSAGES.some((part) => message.includes(part));
+}
+function buildRetryableApiCallMessage(group, detail) {
+    return `Copilot retryable error [${group}]: ${detail}`;
+}
+export function toRetryableApiCallError(error, request, options) {
+    const base = error instanceof Error ? error : new Error(String(error));
+    const wrapped = new Error(buildRetryableApiCallMessage(options?.group ?? "transport", base.message));
+    wrapped.name = "AI_APICallError";
+    wrapped.url = request.url;
+    wrapped.requestBodyValues = options?.requestBodyValues ?? (() => {
+        if (!request.body)
+            return {};
+        try {
+            return JSON.parse(request.body);
+        }
+        catch {
+            return {};
+        }
+    })();
+    wrapped.statusCode = options?.statusCode;
+    wrapped.responseHeaders = options?.responseHeaders instanceof Headers
+        ? Object.fromEntries(options.responseHeaders.entries())
+        : options?.responseHeaders;
+    wrapped.responseBody = options?.responseBody;
+    wrapped.isRetryable = true;
+    wrapped.cause = error;
+    wrapped[AI_ERROR_MARKER] = true;
+    wrapped[API_CALL_ERROR_MARKER] = true;
+    return wrapped;
+}
+export function isRetryableApiCallError(error) {
+    return Boolean(error
+        && typeof error === "object"
+        && error[AI_ERROR_MARKER] === true
+        && error[API_CALL_ERROR_MARKER] === true);
+}
+function normalizeRetryableStatusResponse(response, request) {
+    if (response.status !== 499)
+        return response;
+    return response.clone().text().catch(() => "").then((responseBody) => {
+        throw toRetryableApiCallError(new Error(responseBody || `status code ${response.status}`), request, {
+            group: "status",
+            statusCode: response.status,
+            responseHeaders: response.headers,
+            responseBody: responseBody || undefined,
+        });
+    });
+}
+export function createCopilotRetryPolicy(options) {
+    const policy = {
+        matchesRequest: (request) => isCopilotUrl(request),
+        classifyFailure: async ({ error }) => {
+            if (isRetryableApiCallError(error)) {
+                return { retryable: false, category: "already-normalized" };
+            }
+            if (isRetryableCopilotTransportError(error) || options?.extraRetryableClassifier?.(error) === true) {
+                return { retryable: true, category: "transport" };
+            }
+            return { retryable: false, category: "none" };
+        },
+        handleResponse: async ({ response, request }) => normalizeRetryableStatusResponse(response, request),
+        normalizeFailure: ({ error, classification, request }) => {
+            if (classification.retryable && classification.category === "transport") {
+                return toRetryableApiCallError(error, request);
+            }
+            return error;
+        },
+        buildRepairPlan: async () => undefined,
+        shouldRunResponseRepair: (request) => isCopilotUrl(request) && isCopilotResponsesPath(request),
+        decideResponseRepair: async ({ request, response, requestPayload, sessionID }) => {
+            if (!isCopilotUrl(request) || !isCopilotResponsesPath(request)) {
+                return { kind: "skip" };
+            }
+            if (response.ok)
+                return { kind: "skip" };
+            const responseText = await response.clone().text().catch(() => "");
+            if (!responseText)
+                return { kind: "skip" };
+            const removableIds = collectInputItemIds(requestPayload);
+            let isConnectionMismatch = isConnectionMismatchInputIdMessage(responseText);
+            if (!isConnectionMismatch) {
+                try {
+                    const bodyPayload = JSON.parse(responseText);
+                    isConnectionMismatch = isConnectionMismatchInputIdErrorBody(bodyPayload);
+                }
+                catch {
+                    isConnectionMismatch = false;
+                }
+            }
+            if (isConnectionMismatch && removableIds.length > 0) {
+                return {
+                    kind: "connection-mismatch",
+                    responseText,
+                    shouldAttemptSessionRepair: Boolean(sessionID) && removableIds.length > 0,
+                };
+            }
+            if (!hasLongInputIds(requestPayload))
+                return { kind: "skip" };
+            let parsed = parseInputIdTooLongDetails(responseText);
+            let matched = parsed.matched;
+            if (!matched) {
+                try {
+                    const bodyPayload = JSON.parse(responseText);
+                    const error = bodyPayload.error;
+                    parsed = parseInputIdTooLongDetails(String(error?.message ?? ""));
+                    matched = parsed.matched || isInputIdTooLongErrorBody(bodyPayload);
+                }
+                catch {
+                    matched = false;
+                }
+            }
+            if (!matched)
+                return { kind: "skip" };
+            return {
+                kind: "input-id-too-long",
+                responseText,
+                serverReportedIndex: parsed.serverReportedIndex,
+                reportedLength: parsed.reportedLength,
+                shouldAttemptSessionRepair: Boolean(sessionID) && hasLongInputIds(requestPayload),
+            };
+        },
+        normalizeStreamError: ({ error, request, statusCode, responseHeaders }) => {
+            if (isSseReadTimeoutError(error))
+                return error;
+            if (!isRetryableCopilotTransportError(error))
+                return error;
+            return toRetryableApiCallError(error, {
+                url: toRequestUrl(request),
+            }, {
+                group: "stream",
+                statusCode,
+                responseHeaders,
+            });
+        },
+    };
+    return policy;
+}

package/dist/retry/shared-engine.d.ts

@@ -0,0 +1,50 @@
+export type SharedRetryNotifier = {
+    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>;
+};
+export declare const noopSharedRetryNotifier: SharedRetryNotifier;
+export declare function notifySharedRetryEvent(notifier: SharedRetryNotifier, event: keyof SharedRetryNotifier, remaining: number): Promise<void>;
+export type SharedRetryErrorContainer = {
+    retryableMessages: string[];
+    isAbortError?: (error: unknown) => boolean;
+};
+export declare function getSharedErrorMessage(error: unknown): string;
+export declare function isRetryableErrorByContainer(error: unknown, container: SharedRetryErrorContainer): boolean;
+export type SharedFailOpenResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: unknown;
+};
+export declare function runSharedFailOpenBoundary<T>(options: {
+    action: () => Promise<T>;
+    isFailOpenError: (error: unknown) => boolean;
+    onFailOpen?: (error: unknown) => void;
+}): Promise<SharedFailOpenResult<T>>;
+export type SharedRetryIterationResult = {
+    handled: boolean;
+    stop: boolean;
+    shouldContinue: boolean;
+};
+export declare function runSharedRetryScheduler(options: {
+    initialShouldContinue: boolean;
+    runIteration: (input: {
+        attempts: number;
+    }) => Promise<SharedRetryIterationResult>;
+}): Promise<{
+    attempts: number;
+}>;

package/dist/retry/shared-engine.js

@@ -0,0 +1,56 @@
+export const noopSharedRetryNotifier = {
+    started: async () => { },
+    progress: async () => { },
+    repairWarning: async () => { },
+    completed: async () => { },
+    stopped: async () => { },
+};
+export async function notifySharedRetryEvent(notifier, event, remaining) {
+    try {
+        await notifier[event]({ remaining });
+    }
+    catch (error) {
+        console.warn(`[copilot-network-retry] notifier ${event} failed`, error);
+    }
+}
+export function getSharedErrorMessage(error) {
+    return String(error instanceof Error ? error.message : error).toLowerCase();
+}
+export function isRetryableErrorByContainer(error, container) {
+    if (!error)
+        return false;
+    if (container.isAbortError?.(error))
+        return false;
+    const message = getSharedErrorMessage(error);
+    return container.retryableMessages.some((part) => message.includes(part));
+}
+export async function runSharedFailOpenBoundary(options) {
+    try {
+        return {
+            ok: true,
+            value: await options.action(),
+        };
+    }
+    catch (error) {
+        if (!options.isFailOpenError(error))
+            throw error;
+        options.onFailOpen?.(error);
+        return {
+            ok: false,
+            error,
+        };
+    }
+}
+export async function runSharedRetryScheduler(options) {
+    let attempts = 0;
+    let shouldContinue = options.initialShouldContinue;
+    while (shouldContinue) {
+        shouldContinue = false;
+        const result = await options.runIteration({ attempts });
+        if (!result.handled || result.stop)
+            break;
+        attempts += 1;
+        shouldContinue = result.shouldContinue;
+    }
+    return { attempts };
+}

package/dist/routing-state.d.ts

@@ -77,6 +77,7 @@ export type RouteDecisionEvent = {
     touchWriteError?: string;
     rateLimitMatched: boolean;
     retryAfterMs?: number;
+    finalRequestHeaders?: Record<string, string>;
 };
 export type RoutingEvent = SessionTouchEvent | RateLimitFlaggedEvent;
 export declare function appendRouteDecisionEvent(input: {

package/dist/status-command.js

@@ -59,25 +59,6 @@ function renderAccountGrid(cells) {
     }
     return rows;
 }
-function formatActiveGroup(store) {
-    const names = Array.isArray(store.activeAccountNames) ? store.activeAccountNames : [];
-    if (names.length > 0)
-        return names.join(", ");
-    return "none";
-}
-function formatRoutingGroup(store) {
-    const assignments = store.modelAccountAssignments ?? {};
-    const modelIDs = Object.keys(assignments).sort((a, b) => a.localeCompare(b));
-    const mapped = modelIDs
-        .map((modelID) => {
-        const names = assignments[modelID] ?? [];
-        if (names.length === 0)
-            return undefined;
-        return `${modelID} -> ${names.join(", ")}`;
-    })
-        .filter((line) => Boolean(line));
-    return mapped.length > 0 ? mapped.join("; ") : "none";
-}
 function buildSuccessMessage(store, _name) {
     const defaultNames = Array.isArray(store.activeAccountNames) && store.activeAccountNames.length > 0
         ? store.activeAccountNames
@@ -110,8 +91,6 @@ function buildSuccessMessage(store, _name) {
         lines.push("[routes]");
         lines.push("(none)");
     }
-    lines.push(`活跃组: ${formatActiveGroup(store)}`);
-    lines.push(`路由组: ${formatRoutingGroup(store)}`);
     return lines.join("\n");
 }
 function buildMissingActiveMessage() {

package/package.json

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