opencode-copilot-account-switcher 0.11.0 → 0.12.0

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

@@ -0,0 +1 @@
+export { COPILOT_RETRYABLE_MESSAGES, createCopilotRetryPolicy, isCopilotUrl, isRetryableApiCallError, isRetryableCopilotTransportError, toRetryableApiCallError, type CopilotRetryPolicy, type RetryableErrorGroup, } from "./retry/copilot-policy.js";

package/dist/copilot-retry-policy.js

@@ -0,0 +1 @@
+export { COPILOT_RETRYABLE_MESSAGES, createCopilotRetryPolicy, isCopilotUrl, isRetryableApiCallError, isRetryableCopilotTransportError, toRetryableApiCallError, } from "./retry/copilot-policy.js";

package/dist/model-account-map.js

@@ -75,7 +75,9 @@ export function rewriteModelAccountAssignments(store, rename) {
         const seen = new Set();
         const resolvedNames = [];
         for (const originalName of accountNames) {
-            const mappedName = rename[originalName] ?? originalName;
+            const mappedName = Object.prototype.hasOwnProperty.call(rename, originalName)
+                ? rename[originalName]
+                : originalName;
             if (typeof mappedName !== "string" || !store.accounts[mappedName] || seen.has(mappedName))
                 continue;
             seen.add(mappedName);

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

@@ -0,0 +1,33 @@
+export type NetworkRetryRequest = {
+    url: string;
+    method?: string;
+    body?: string;
+    headers?: Record<string, string>;
+};
+export type NetworkRetryClassification = {
+    retryable: boolean;
+    category: string;
+};
+export type NetworkRetryPolicy = {
+    matchesRequest: (request: Request | URL | string) => boolean;
+    classifyFailure: (input: {
+        error: unknown;
+        request: NetworkRetryRequest;
+    }) => Promise<NetworkRetryClassification>;
+    handleResponse?: (input: {
+        response: Response;
+        request: NetworkRetryRequest;
+    }) => Promise<Response>;
+    normalizeFailure?: (input: {
+        error: unknown;
+        classification: NetworkRetryClassification;
+        request: NetworkRetryRequest;
+    }) => unknown;
+    buildRepairPlan: (input: {
+        request: NetworkRetryRequest;
+        classification: NetworkRetryClassification;
+    }) => Promise<unknown>;
+};
+export declare function createNetworkRetryEngine(input: {
+    policy: NetworkRetryPolicy;
+}): (baseFetch: (request: Request | URL | string, init?: RequestInit) => Promise<Response>) => (request: Request | URL | string, init?: RequestInit) => Promise<Response>;

package/dist/network-retry-engine.js

@@ -0,0 +1,62 @@
+function toHeaderRecord(headers) {
+    if (!headers)
+        return undefined;
+    return Object.fromEntries(new Headers(headers).entries());
+}
+async function tryGetRequestBodyString(request, init) {
+    if (typeof init?.body === "string")
+        return init.body;
+    if (!(request instanceof Request))
+        return undefined;
+    try {
+        return await request.clone().text();
+    }
+    catch {
+        return undefined;
+    }
+}
+async function toNetworkRetryRequest(request, init) {
+    const url = request instanceof Request ? request.url : request instanceof URL ? request.href : String(request);
+    const method = init?.method ?? (request instanceof Request ? request.method : undefined);
+    const headers = toHeaderRecord(init?.headers) ?? (request instanceof Request ? toHeaderRecord(request.headers) : undefined);
+    const body = await tryGetRequestBodyString(request, init);
+    return { url, method, headers, body };
+}
+export function createNetworkRetryEngine(input) {
+    return function wrapNetworkFetch(baseFetch) {
+        return async function retryingNetworkFetch(request, init) {
+            if (!input.policy.matchesRequest(request)) {
+                return baseFetch(request, init);
+            }
+            const normalizedRequest = await toNetworkRetryRequest(request, init);
+            try {
+                const response = await baseFetch(request, init);
+                if (!input.policy.handleResponse)
+                    return response;
+                return input.policy.handleResponse({
+                    response,
+                    request: normalizedRequest,
+                });
+            }
+            catch (error) {
+                const classification = await input.policy.classifyFailure({
+                    error,
+                    request: normalizedRequest,
+                });
+                if (!classification.retryable)
+                    throw error;
+                await input.policy.buildRepairPlan({
+                    request: normalizedRequest,
+                    classification,
+                });
+                if (!input.policy.normalizeFailure)
+                    throw error;
+                throw input.policy.normalizeFailure({
+                    error,
+                    classification,
+                    request: normalizedRequest,
+                });
+            }
+        };
+    };
+}

package/dist/plugin-hooks.d.ts

@@ -5,6 +5,7 @@ import { type StoreFile, type StoreWriteDebugMeta } from "./store.js";
 import { type CopilotAuthState, type CopilotProviderConfig, type OfficialCopilotConfig, type OfficialChatHeadersHook } from "./upstream/copilot-loader-adapter.js";
 import { type RefreshActiveAccountQuotaResult } from "./active-account-quota.js";
 import { handleStatusCommand } from "./status-command.js";
+import { handleCodexStatusCommand } from "./codex-status-command.js";
 import { handleCompactCommand, handleStopToolCommand } from "./session-control-command.js";
 import { type AppendSessionTouchEventInput, type RouteDecisionEvent, type RoutingSnapshot, type RoutingEvent } from "./routing-state.js";
 type ChatHeadersHook = (input: {
@@ -32,6 +33,7 @@ type CopilotPluginHooksWithChatHeaders = CopilotPluginHooks & {
     "chat.headers"?: ChatHeadersHook;
 };
 type StatusCommandHandler = typeof handleStatusCommand;
+type CodexStatusCommandHandler = typeof handleCodexStatusCommand;
 type CompactCommandHandler = typeof handleCompactCommand;
 type StopToolCommandHandler = typeof handleStopToolCommand;
 type RefreshQuota = (store: StoreFile) => Promise<RefreshActiveAccountQuotaResult>;
@@ -82,6 +84,7 @@ export declare function buildPluginHooks(input: {
     now?: () => number;
     refreshQuota?: RefreshQuota;
     handleStatusCommandImpl?: StatusCommandHandler;
+    handleCodexStatusCommandImpl?: CodexStatusCommandHandler;
     handleCompactCommandImpl?: CompactCommandHandler;
     handleStopToolCommandImpl?: StopToolCommandHandler;
     loadCandidateAccountLoads?: (input: {

package/dist/plugin-hooks.js

@@ -1,6 +1,7 @@
 import { appendFileSync } from "node:fs";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createCompactionLoopSafetyBypass, createLoopSafetySystemTransform, getLoopSafetyProviderScope, isCopilotProvider, } from "./loop-safety-plugin.js";
+import { createCompactionLoopSafetyBypass, createLoopSafetySystemTransform, getLoopSafetyProviderScope, } from "./loop-safety-plugin.js";
+import { COPILOT_PROVIDER_DESCRIPTOR } from "./providers/descriptor.js";
 import { createCopilotRetryingFetch, cleanupLongIdsForAccountSwitch, detectRateLimitEvidence, INTERNAL_SESSION_CONTEXT_KEY, } from "./copilot-network-retry.js";
 import { createCopilotRetryNotifier } from "./copilot-retry-notifier.js";
 import { resolveCopilotModelAccounts } from "./model-account-map.js";
@@ -11,6 +12,7 @@ import { createNotifyTool } from "./notify-tool.js";
 import { createWaitTool } from "./wait-tool.js";
 import { refreshActiveAccountQuota } from "./active-account-quota.js";
 import { handleStatusCommand, showStatusToast } from "./status-command.js";
+import { handleCodexStatusCommand } from "./codex-status-command.js";
 import { handleCompactCommand, handleStopToolCommand, } from "./session-control-command.js";
 import { appendRoutingEvent, appendRouteDecisionEvent, appendSessionTouchEvent, buildCandidateAccountLoads, isAccountRateLimitCooledDown, readRoutingState, routingStatePath, } from "./routing-state.js";
 const SESSION_BINDING_IDLE_TTL_MS = 30 * 60 * 1000;
@@ -33,6 +35,9 @@ export class PolicyScopeCommandHandledError extends Error {
         this.name = "PolicyScopeCommandHandledError";
     }
 }
+function isCopilotProviderID(providerID) {
+    return COPILOT_PROVIDER_DESCRIPTOR.providerIDs.includes(providerID);
+}
 function isDebugEnabled() {
     return process.env.OPENCODE_COPILOT_RETRY_DEBUG === "1";
 }
@@ -176,6 +181,35 @@ function getMergedRequestHeader(request, init, name) {
     }
     return headers.get(name);
 }
+function getMergedRequestHeadersRecord(request, init) {
+    const headers = new Headers(request instanceof Request ? request.headers : undefined);
+    for (const [headerName, value] of new Headers(init?.headers).entries()) {
+        headers.set(headerName, value);
+    }
+    return Object.fromEntries(headers.entries());
+}
+function getFinalSentRequestHeadersRecord(request, init) {
+    const headers = new Headers(request instanceof Request ? request.headers : undefined);
+    for (const [headerName, value] of new Headers(init?.headers).entries()) {
+        headers.set(headerName, value);
+    }
+    headers.delete("x-opencode-session-id");
+    headers.delete(INTERNAL_DEBUG_LINK_HEADER);
+    return sanitizeLoggedRequestHeadersRecord(Object.fromEntries(headers.entries()));
+}
+function sanitizeLoggedRequestHeadersRecord(headers) {
+    const sanitized = { ...headers };
+    if (typeof sanitized.authorization === "string" && sanitized.authorization.length > 0) {
+        sanitized.authorization = "Bearer [redacted]";
+    }
+    if (typeof sanitized.Authorization === "string" && sanitized.Authorization.length > 0) {
+        sanitized.Authorization = "Bearer [redacted]";
+    }
+    if (typeof sanitized["x-api-key"] === "string" && sanitized["x-api-key"].length > 0) {
+        sanitized["x-api-key"] = "[redacted]";
+    }
+    return sanitized;
+}
 function getInternalSessionID(request, init) {
     const headerValue = getMergedRequestHeader(request, init, "x-opencode-session-id");
     if (typeof headerValue === "string" && headerValue.length > 0)
@@ -365,6 +399,7 @@ export function buildPluginHooks(input) {
     };
     const refreshQuota = input.refreshQuota ?? ((store) => refreshActiveAccountQuota({ store }));
     const handleStatusCommandImpl = input.handleStatusCommandImpl ?? handleStatusCommand;
+    const handleCodexStatusCommandImpl = input.handleCodexStatusCommandImpl ?? handleCodexStatusCommand;
     const handleCompactCommandImpl = input.handleCompactCommandImpl ?? handleCompactCommand;
     const handleStopToolCommandImpl = input.handleStopToolCommandImpl ?? handleStopToolCommand;
     const loadOfficialConfig = input.loadOfficialConfig ?? loadOfficialCopilotConfig;
@@ -496,11 +531,20 @@ export function buildPluginHooks(input) {
     });
     const loader = async (getAuth, provider) => {
         const authOverride = new AsyncLocalStorage();
+        const finalHeaderCapture = new AsyncLocalStorage();
         const getScopedAuth = async () => authOverride.getStore() ?? getAuth();
         const providerConfig = provider;
         const config = await loadOfficialConfig({
             getAuth: getScopedAuth,
             provider: providerConfig,
+            ...(input.loadOfficialConfig == null
+                ? {
+                    baseFetch: async (nextRequest, nextInit) => {
+                        finalHeaderCapture.getStore()?.(getFinalSentRequestHeadersRecord(nextRequest, nextInit));
+                        return fetch(nextRequest, nextInit);
+                    },
+                }
+                : {}),
         });
         if (!config)
             return {};
@@ -559,7 +603,7 @@ export function buildPluginHooks(input) {
             const initiator = getMergedRequestHeader(selectionRequest, selectionInit, "x-initiator");
             const candidates = latestStore ? resolveCopilotModelAccounts(latestStore, modelID) : [];
             if (candidates.length === 0) {
-                const outbound = stripInternalSessionHeader(request, init);
+                const outbound = stripInternalSessionHeader(selectionRequest, selectionInit);
                 return config.fetch(outbound.request, outbound.init);
             }
             const hasExistingBinding = sessionID.length > 0 && sessionAccountBindings.has(sessionID);
@@ -603,7 +647,7 @@ export function buildPluginHooks(input) {
                 })
                 : undefined;
             if (!resolved) {
-                const outbound = stripInternalSessionHeader(request, init);
+                const outbound = stripInternalSessionHeader(selectionRequest, selectionInit);
                 return config.fetch(outbound.request, outbound.init);
             }
             const candidateNames = candidates.map((item) => item.name);
@@ -617,6 +661,7 @@ export function buildPluginHooks(input) {
             let decisionTouchWriteOutcome = "skipped-missing-session";
             let decisionTouchWriteError;
             let finalChosenAccount = resolved.name;
+            let finalRequestHeaders = getFinalSentRequestHeadersRecord(selectionRequest, selectionInit);
             const previousBindingAccount = sessionID.length > 0 ? sessionAccountBindings.get(sessionID)?.accountName : undefined;
             if (sessionID.length > 0) {
                 sessionAccountBindings.set(sessionID, {
@@ -642,13 +687,13 @@ export function buildPluginHooks(input) {
             if (isFirstUse) {
                 modelAccountFirstUse.add(resolved.name);
             }
-            let nextRequest = request;
-            let nextInit = init;
-            const currentInitiator = getMergedRequestHeader(request, init, "x-initiator");
+            let nextRequest = selectionRequest;
+            let nextInit = selectionInit;
+            const currentInitiator = getMergedRequestHeader(selectionRequest, selectionInit, "x-initiator");
             const shouldStripAgentInitiator = classification.reason === "unbound-fallback"
                 || (isFirstUse && currentInitiator === "agent");
             if (shouldStripAgentInitiator && currentInitiator === "agent") {
-                const rewritten = mergeAndRewriteRequestHeaders(request, init, (headers) => {
+                const rewritten = mergeAndRewriteRequestHeaders(selectionRequest, selectionInit, (headers) => {
                     headers.delete("x-initiator");
                 });
                 nextRequest = rewritten.request;
@@ -686,7 +731,9 @@ export function buildPluginHooks(input) {
                     enterpriseUrl: candidate.entry.enterpriseUrl,
                 };
                 const outbound = stripInternalSessionHeader(requestValue, initValue);
-                return authOverride.run(candidateAuth, () => config.fetch(rewriteRequestForAccount(outbound.request, candidate.entry.enterpriseUrl), outbound.init));
+                return finalHeaderCapture.run((headers) => {
+                    finalRequestHeaders = headers;
+                }, () => authOverride.run(candidateAuth, () => config.fetch(rewriteRequestForAccount(outbound.request, candidate.entry.enterpriseUrl), outbound.init)));
             };
             const response = await sendWithAccount(resolved, nextRequest, nextInit);
             const observedAt = now();
@@ -782,6 +829,7 @@ export function buildPluginHooks(input) {
                                     // keep fail-open on payload parse failures
                                 }
                             }
+                            finalRequestHeaders = getFinalSentRequestHeadersRecord(retriedRequest, retriedInit);
                             if (sessionID.length > 0) {
                                 sessionAccountBindings.set(sessionID, {
                                     accountName: replacement.name,
@@ -847,6 +895,7 @@ export function buildPluginHooks(input) {
                                     touchWriteError: decisionTouchWriteError,
                                     rateLimitMatched: decisionRateLimitMatched,
                                     retryAfterMs: decisionRetryAfterMs,
+                                    finalRequestHeaders,
                                 },
                             }).catch(() => undefined);
                             return sendWithAccount(replacement, retriedRequest, retriedInit);
@@ -878,6 +927,7 @@ export function buildPluginHooks(input) {
                     touchWriteError: decisionTouchWriteError,
                     rateLimitMatched: decisionRateLimitMatched,
                     retryAfterMs: decisionRetryAfterMs,
+                    finalRequestHeaders,
                 },
             }).catch(() => undefined);
             if (shouldShowConsumptionToast({ reason: decisionReason, isFirstUse })) {
@@ -925,7 +975,7 @@ export function buildPluginHooks(input) {
         directory: input.directory,
     });
     const chatHeaders = async (hookInput, output) => {
-        if (!isCopilotProvider(hookInput.model.providerID))
+        if (!isCopilotProviderID(hookInput.model.providerID))
             return;
         const headersBeforeOfficial = { ...output.headers };
         await (await officialChatHeaders)(hookInput, output);
@@ -1023,7 +1073,7 @@ export function buildPluginHooks(input) {
     return {
         auth: {
             ...input.auth,
-            provider: input.auth.provider ?? "github-copilot",
+            provider: input.auth.provider ?? COPILOT_PROVIDER_DESCRIPTOR.providerIDs[0] ?? "github-copilot",
             methods: input.auth.methods,
             loader,
         },
@@ -1031,8 +1081,13 @@ export function buildPluginHooks(input) {
             if (!config.command)
                 config.command = {};
             const store = loadStoreSync();
-            if (!areExperimentalSlashCommandsEnabled(store))
+            if (!areExperimentalSlashCommandsEnabled(store)) {
                 return;
+            }
+            config.command["codex-status"] = {
+                template: "Show the current Codex status and usage snapshot via the experimental status path.",
+                description: "Experimental Codex status command",
+            };
             config.command["copilot-status"] = {
                 template: "Show the current GitHub Copilot quota status via the experimental workaround path.",
                 description: "Experimental Copilot quota status workaround",
@@ -1083,6 +1138,13 @@ export function buildPluginHooks(input) {
                     refreshQuota,
                 });
             }
+            if (hookInput.command === "codex-status") {
+                if (!areExperimentalSlashCommandsEnabled(store))
+                    return;
+                await handleCodexStatusCommandImpl({
+                    client: input.client,
+                });
+            }
             if (hookInput.command === "copilot-compact") {
                 if (!areExperimentalSlashCommandsEnabled(store))
                     return;

package/dist/provider-descriptor.d.ts

@@ -0,0 +1,2 @@
+export { CODEX_PROVIDER_DESCRIPTOR, COPILOT_PROVIDER_DESCRIPTOR, createCodexProviderDescriptor, createCopilotProviderDescriptor, } from "./providers/descriptor.js";
+export type { AssembledProviderDescriptor, ProviderCapability, ProviderDescriptor, } from "./providers/descriptor.js";

package/dist/provider-descriptor.js

@@ -0,0 +1 @@
+export { CODEX_PROVIDER_DESCRIPTOR, COPILOT_PROVIDER_DESCRIPTOR, createCodexProviderDescriptor, createCopilotProviderDescriptor, } from "./providers/descriptor.js";

package/dist/provider-registry.d.ts

@@ -0,0 +1 @@
+export { createProviderRegistry, getProviderDescriptorByKey, getProviderDescriptorByProviderID, isProviderIDSupportedByAnyDescriptor, listProviderDescriptors, } from "./providers/registry.js";

package/dist/provider-registry.js

@@ -0,0 +1 @@
+export { createProviderRegistry, getProviderDescriptorByKey, getProviderDescriptorByProviderID, isProviderIDSupportedByAnyDescriptor, listProviderDescriptors, } from "./providers/registry.js";

package/dist/providers/descriptor.d.ts

@@ -0,0 +1,28 @@
+import type { buildPluginHooks as buildPluginHooksFn } from "../plugin-hooks.js";
+export type ProviderCapability = "auth" | "chat-headers" | "model-routing" | "network-retry" | "slash-commands" | "loop-safety";
+export type ProviderDescriptor = {
+    key: string;
+    providerIDs: string[];
+    storeNamespace: string;
+    commands: string[];
+    menuEntries: string[];
+    capabilities: ProviderCapability[];
+};
+type BuildPluginHooks = typeof buildPluginHooksFn;
+export type AssembledProviderDescriptor = {
+    key: string;
+    auth: {
+        provider: string;
+    };
+    buildPluginHooks: BuildPluginHooks;
+    enabledByDefault: boolean;
+};
+export declare const COPILOT_PROVIDER_DESCRIPTOR: ProviderDescriptor;
+export declare const CODEX_PROVIDER_DESCRIPTOR: ProviderDescriptor;
+export declare function createCopilotProviderDescriptor(input: {
+    buildPluginHooks: BuildPluginHooks;
+}): AssembledProviderDescriptor;
+export declare function createCodexProviderDescriptor(input?: {
+    enabled?: boolean;
+}): Omit<AssembledProviderDescriptor, "buildPluginHooks">;
+export {};

package/dist/providers/descriptor.js

@@ -0,0 +1,66 @@
+export const COPILOT_PROVIDER_DESCRIPTOR = {
+    key: "copilot",
+    providerIDs: [
+        "github-copilot",
+        "github-copilot-enterprise",
+    ],
+    storeNamespace: "copilot",
+    commands: [
+        "copilot-status",
+        "copilot-compact",
+        "copilot-stop-tool",
+        "copilot-inject",
+        "copilot-policy-all-models",
+    ],
+    menuEntries: [
+        "switch-account",
+        "add-account",
+        "import-auth",
+        "quota-refresh",
+        "configure-default-account-group",
+        "assign-model-account",
+        "toggle-loop-safety",
+        "toggle-network-retry",
+    ],
+    capabilities: [
+        "auth",
+        "chat-headers",
+        "model-routing",
+        "network-retry",
+        "slash-commands",
+        "loop-safety",
+    ],
+};
+export const CODEX_PROVIDER_DESCRIPTOR = {
+    key: "codex",
+    providerIDs: [
+        "openai",
+    ],
+    storeNamespace: "codex",
+    commands: [
+        "codex-status",
+    ],
+    menuEntries: [],
+    capabilities: [
+        "slash-commands",
+    ],
+};
+export function createCopilotProviderDescriptor(input) {
+    return {
+        key: "copilot",
+        auth: {
+            provider: "github-copilot",
+        },
+        buildPluginHooks: input.buildPluginHooks,
+        enabledByDefault: true,
+    };
+}
+export function createCodexProviderDescriptor(input = {}) {
+    return {
+        key: "codex",
+        auth: {
+            provider: "openai",
+        },
+        enabledByDefault: input.enabled === true,
+    };
+}

package/dist/providers/registry.d.ts

@@ -0,0 +1,18 @@
+import { type ProviderDescriptor } from "./descriptor.js";
+import type { buildPluginHooks as buildPluginHooksFn } from "../plugin-hooks.js";
+export declare function listProviderDescriptors(): ProviderDescriptor[];
+export declare function getProviderDescriptorByKey(key: string): ProviderDescriptor | undefined;
+export declare function getProviderDescriptorByProviderID(providerID: string): ProviderDescriptor | undefined;
+export declare function isProviderIDSupportedByAnyDescriptor(providerID: string): boolean;
+type BuildPluginHooks = typeof buildPluginHooksFn;
+export declare function createProviderRegistry(input: {
+    buildPluginHooks: BuildPluginHooks;
+}): {
+    copilot: {
+        descriptor: import("./descriptor.js").AssembledProviderDescriptor;
+    };
+    codex: {
+        descriptor: Omit<import("./descriptor.js").AssembledProviderDescriptor, "buildPluginHooks">;
+    };
+};
+export {};

package/dist/providers/registry.js

@@ -0,0 +1,27 @@
+import { COPILOT_PROVIDER_DESCRIPTOR } from "./descriptor.js";
+import { createCodexProviderDescriptor, createCopilotProviderDescriptor } from "./descriptor.js";
+const PROVIDER_DESCRIPTORS = [
+    COPILOT_PROVIDER_DESCRIPTOR,
+];
+export function listProviderDescriptors() {
+    return [...PROVIDER_DESCRIPTORS];
+}
+export function getProviderDescriptorByKey(key) {
+    return PROVIDER_DESCRIPTORS.find((descriptor) => descriptor.key === key);
+}
+export function getProviderDescriptorByProviderID(providerID) {
+    return PROVIDER_DESCRIPTORS.find((descriptor) => descriptor.providerIDs.includes(providerID));
+}
+export function isProviderIDSupportedByAnyDescriptor(providerID) {
+    return getProviderDescriptorByProviderID(providerID) !== undefined;
+}
+export function createProviderRegistry(input) {
+    return {
+        copilot: {
+            descriptor: createCopilotProviderDescriptor({ buildPluginHooks: input.buildPluginHooks }),
+        },
+        codex: {
+            descriptor: createCodexProviderDescriptor({ enabled: false }),
+        },
+    };
+}

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

@@ -0,0 +1,61 @@
+import type { NetworkRetryPolicy } from "../network-retry-engine.js";
+export declare const COPILOT_RETRYABLE_MESSAGES: string[];
+export type RetryableErrorGroup = "transport" | "status" | "stream";
+type RetryableApiCallError = Error & {
+    url: string;
+    requestBodyValues: unknown;
+    statusCode?: number;
+    responseHeaders?: Record<string, string>;
+    responseBody?: string;
+    isRetryable: boolean;
+    cause: unknown;
+    [key: symbol]: unknown;
+};
+type CopilotStreamErrorInput = {
+    error: unknown;
+    request: Request | URL | string;
+    statusCode?: number;
+    responseHeaders?: Headers;
+};
+type JsonRecord = Record<string, unknown>;
+export type CopilotRepairDecision = {
+    kind: "skip";
+} | {
+    kind: "connection-mismatch";
+    responseText: string;
+    shouldAttemptSessionRepair: boolean;
+} | {
+    kind: "input-id-too-long";
+    responseText: string;
+    serverReportedIndex?: number;
+    reportedLength?: number;
+    shouldAttemptSessionRepair: boolean;
+};
+export type CopilotRetryPolicy = NetworkRetryPolicy & {
+    shouldRunResponseRepair: (request: Request | URL | string) => boolean;
+    decideResponseRepair: (input: {
+        request: Request | URL | string;
+        response: Response;
+        requestPayload: JsonRecord | undefined;
+        sessionID?: string;
+    }) => Promise<CopilotRepairDecision>;
+    normalizeStreamError: (input: CopilotStreamErrorInput) => unknown;
+};
+type CreateCopilotRetryPolicyOptions = {
+    extraRetryableClassifier?: (error: unknown) => boolean;
+};
+export declare function isCopilotUrl(request: Request | URL | string): boolean;
+export declare function isRetryableCopilotTransportError(error: unknown): boolean;
+export declare function toRetryableApiCallError(error: unknown, request: {
+    url: string;
+    body?: string;
+}, options?: {
+    group?: RetryableErrorGroup;
+    requestBodyValues?: unknown;
+    statusCode?: number;
+    responseHeaders?: Headers | Record<string, string>;
+    responseBody?: string;
+}): RetryableApiCallError;
+export declare function isRetryableApiCallError(error: unknown): error is RetryableApiCallError;
+export declare function createCopilotRetryPolicy(options?: CreateCopilotRetryPolicyOptions): CopilotRetryPolicy;
+export {};