opencodekit 0.18.14 → 0.18.16

package/dist/template/.opencode/plugin/copilot-auth.ts

@@ -84,9 +84,108 @@ const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 const RATE_LIMIT_CONFIG = {
 	maxRetries: 3,
 	baseDelayMs: 2000, // Start with 2 seconds
-	maxDelayMs: 30000, // Cap at 30 seconds
+	maxDelayMs: 60000, // Cap at 60 seconds
+	defaultCooldownMs: 60000, // Default cooldown when Retry-After header is missing
+	maxFallbacks: 4, // Max model fallback switches per request
 };
 
+// Per-model rate limit state (in-memory, resets on restart)
+interface RateLimitEntry {
+	rateLimitedUntil: number; // Unix timestamp (ms)
+}
+const rateLimitState = new Map<string, RateLimitEntry>();
+
+// Model fallback chains: same-family alternatives when a model is rate-limited
+const MODEL_FALLBACK_CHAINS: Record<string, string[]> = {
+	// Claude family
+	"claude-opus-4.6": [
+		"claude-opus-4.5",
+		"claude-sonnet-4.6",
+		"claude-sonnet-4.5",
+	],
+	"claude-opus-4.5": [
+		"claude-opus-4.6",
+		"claude-sonnet-4.5",
+		"claude-sonnet-4.6",
+	],
+	"claude-sonnet-4.6": [
+		"claude-sonnet-4.5",
+		"claude-opus-4.6",
+		"claude-opus-4.5",
+	],
+	"claude-sonnet-4.5": [
+		"claude-sonnet-4.6",
+		"claude-opus-4.5",
+		"claude-opus-4.6",
+	],
+};
+
+/**
+ * Parse the Retry-After header from a 429 response.
+ * Returns cooldown in milliseconds, or null if header is missing/unparseable.
+ */
+function parseRetryAfter(response: Response): number | null {
+	const header = response.headers.get("retry-after");
+	if (!header) return null;
+	// Try as seconds first (most common)
+	const seconds = parseInt(header, 10);
+	if (!isNaN(seconds) && seconds > 0) return seconds * 1000;
+	// Try as HTTP date
+	const date = Date.parse(header);
+	if (!isNaN(date)) return Math.max(0, date - Date.now());
+	return null;
+}
+
+function isModelRateLimited(model: string): boolean {
+	const entry = rateLimitState.get(model);
+	if (!entry) return false;
+	if (Date.now() >= entry.rateLimitedUntil) {
+		rateLimitState.delete(model);
+		return false;
+	}
+	return true;
+}
+
+function markModelRateLimited(model: string, cooldownMs: number): void {
+	rateLimitState.set(model, {
+		rateLimitedUntil: Date.now() + cooldownMs,
+	});
+	log(
+		"info",
+		`Marked ${model} as rate-limited for ${Math.round(cooldownMs / 1000)}s`,
+	);
+}
+
+/**
+ * Find the next available fallback model in the same family.
+ * Skips models that are themselves rate-limited.
+ */
+function getNextFallbackModel(model: string): string | null {
+	const chain = MODEL_FALLBACK_CHAINS[model];
+	if (!chain) return null;
+	for (const fallback of chain) {
+		if (!isModelRateLimited(fallback)) return fallback;
+	}
+	return null;
+}
+
+/**
+ * Swap the model field in a fetch RequestInit body.
+ */
+function swapModelInBody(
+	init: RequestInit | undefined,
+	newModel: string,
+): RequestInit | undefined {
+	if (!init?.body || typeof init.body !== "string") return init;
+	try {
+		const body = JSON.parse(init.body);
+		body.model = newModel;
+		return { ...init, body: JSON.stringify(body) };
+	} catch {
+		return init;
+	}
+}
+
 // Maximum length for item IDs in the OpenAI Responses API
 const MAX_RESPONSE_API_ID_LENGTH = 64;
 /**
@@ -117,10 +216,16 @@ function sanitizeResponseInputIds(input: any[]): any[] {
 	return input.map((item: any) => {
 		if (!item || typeof item !== "object") return item;
 		const sanitized = { ...item };
-		if (typeof sanitized.id === "string" && sanitized.id.length > MAX_RESPONSE_API_ID_LENGTH) {
+		if (
+			typeof sanitized.id === "string" &&
+			sanitized.id.length > MAX_RESPONSE_API_ID_LENGTH
+		) {
 			sanitized.id = sanitizeResponseId(sanitized.id);
 		}
-		if (typeof sanitized.call_id === "string" && sanitized.call_id.length > MAX_RESPONSE_API_ID_LENGTH) {
+		if (
+			typeof sanitized.call_id === "string" &&
+			sanitized.call_id.length > MAX_RESPONSE_API_ID_LENGTH
+		) {
 			sanitized.call_id = sanitizeResponseId(sanitized.call_id);
 		}
 		return sanitized;
@@ -131,7 +236,7 @@ function sanitizeResponseInputIds(input: any[]): any[] {
  * Retries: 2s, 4s, 8s (with jitter)
  */
 function calculateRetryDelay(attempt: number): number {
-	const exponentialDelay = RATE_LIMIT_CONFIG.baseDelayMs * Math.pow(2, attempt);
+	const exponentialDelay = RATE_LIMIT_CONFIG.baseDelayMs * 2 ** attempt;
 	const jitter = Math.random() * 1000; // Add 0-1s random jitter
 	const delay = Math.min(
 		exponentialDelay + jitter,
@@ -185,7 +290,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 
 						let isAgentCall = false;
 						let isVisionRequest = false;
-						let modifiedBody: any = undefined;
+						let modifiedBody: any;
 						let isClaudeModel = false;
 
 						try {
@@ -333,15 +438,18 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 								// Sanitize long IDs from Copilot backend (can be 400+ chars)
 								// OpenAI Responses API enforces a 64-char max on item IDs
 								const sanitizedInput = sanitizeResponseInputIds(body.input);
-								const inputWasSanitized = sanitizedInput !== body.input &&
+								const inputWasSanitized =
+									sanitizedInput !== body.input &&
 									JSON.stringify(sanitizedInput) !== JSON.stringify(body.input);
 
 								if (inputWasSanitized) {
 									log("info", "Sanitized long IDs in Responses API input", {
 										original_count: body.input.filter(
 											(item: any) =>
-												(typeof item?.id === "string" && item.id.length > MAX_RESPONSE_API_ID_LENGTH) ||
-												(typeof item?.call_id === "string" && item.call_id.length > MAX_RESPONSE_API_ID_LENGTH),
+												(typeof item?.id === "string" &&
+													item.id.length > MAX_RESPONSE_API_ID_LENGTH) ||
+												(typeof item?.call_id === "string" &&
+													item.call_id.length > MAX_RESPONSE_API_ID_LENGTH),
 										).length,
 									});
 									modifiedBody = {
@@ -410,34 +518,105 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 							...(modifiedBody ? { body: JSON.stringify(modifiedBody) } : {}),
 						};
 
-						// Retry logic with exponential backoff for rate limiting
+						// Extract model from request body for rate limit tracking
+						let currentModel = "";
+						try {
+							const bodyObj =
+								typeof finalInit.body === "string"
+									? JSON.parse(finalInit.body)
+									: finalInit.body;
+							currentModel = bodyObj?.model || "";
+						} catch {}
+
+						// Pre-flight: if current model is already known rate-limited, switch to fallback
+						let activeFinalInit: RequestInit = finalInit;
+						if (currentModel && isModelRateLimited(currentModel)) {
+							const fallback = getNextFallbackModel(currentModel);
+							if (fallback) {
+								log(
+									"info",
+									`Model ${currentModel} is rate-limited, pre-switching to ${fallback}`,
+								);
+								activeFinalInit =
+									swapModelInBody(finalInit, fallback) || finalInit;
+								currentModel = fallback;
+							}
+						}
+
+						// Retry logic with model fallback and exponential backoff for rate limiting
 						let lastError: Error | undefined;
-						for (
-							let attempt = 0;
-							attempt <= RATE_LIMIT_CONFIG.maxRetries;
-							attempt++
-						) {
+						let fallbacksUsed = 0;
+						let attempt = 0;
+
+						while (attempt <= RATE_LIMIT_CONFIG.maxRetries) {
 							try {
-								const response = await fetch(input, finalInit);
+								const response = await fetch(input, activeFinalInit);
 
-								// If we get a 429, retry with backoff
-								if (
-									response.status === 429 &&
-									attempt < RATE_LIMIT_CONFIG.maxRetries
-								) {
-									const delay = calculateRetryDelay(attempt);
-									log("warn", `Rate limited (429), retrying`, {
-										delay_ms: delay,
-										attempt: attempt + 1,
-										max_retries: RATE_LIMIT_CONFIG.maxRetries,
-									});
-									await sleep(delay);
-									continue;
+								if (response.status === 429) {
+									// Parse Retry-After header for server-suggested cooldown
+									const retryAfterMs = parseRetryAfter(response);
+									const cooldownMs =
+										retryAfterMs ?? RATE_LIMIT_CONFIG.defaultCooldownMs;
+
+									// Mark this model as rate-limited
+									if (currentModel) {
+										markModelRateLimited(currentModel, cooldownMs);
+									}
+
+									// Try fallback model (doesn't count against retry budget)
+									if (
+										currentModel &&
+										fallbacksUsed < RATE_LIMIT_CONFIG.maxFallbacks
+									) {
+										const fallback = getNextFallbackModel(currentModel);
+										if (fallback) {
+											log(
+												"warn",
+												`Rate limited on ${currentModel}, switching to ${fallback}`,
+												{
+													retry_after_ms: retryAfterMs,
+													cooldown_ms: cooldownMs,
+													fallbacks_used: fallbacksUsed + 1,
+												},
+											);
+											activeFinalInit =
+												swapModelInBody(activeFinalInit, fallback) ||
+												activeFinalInit;
+											currentModel = fallback;
+											fallbacksUsed++;
+											continue; // Retry immediately with new model, no delay
+										}
+									}
+
+									// No fallback available — use exponential backoff on same model
+									if (attempt < RATE_LIMIT_CONFIG.maxRetries) {
+										const delay =
+											retryAfterMs != null
+												? Math.min(retryAfterMs, RATE_LIMIT_CONFIG.maxDelayMs)
+												: calculateRetryDelay(attempt);
+										log(
+											"warn",
+											`Rate limited (429), no fallback available, waiting ${delay}ms`,
+											{
+												delay_ms: delay,
+												attempt: attempt + 1,
+												max_retries: RATE_LIMIT_CONFIG.maxRetries,
+												fallbacks_exhausted: true,
+											},
+										);
+										await sleep(delay);
+										attempt++;
+										continue;
+									}
+
+									// Exhausted retries and fallbacks
+									throw new Error(
+										`[Copilot] Rate limited. Tried ${fallbacksUsed} fallback model(s) and ${attempt} retries. Model: ${currentModel}`,
+									);
 								}
 
-								// Response transformation is now handled by the custom SDK at
-								// .opencode/plugin/sdk/copilot/ which properly parses reasoning_text/reasoning_opaque
-								// and converts them to AI SDK's reasoning content parts
+								// Response transformation is handled by the custom SDK at
+								// .opencode/plugin/sdk/copilot/
 								return response;
 							} catch (error) {
 								lastError = error as Error;
@@ -452,20 +631,19 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 										error: lastError.message,
 									});
 									await sleep(delay);
+									attempt++;
 									continue;
 								}
 								throw error;
 							}
 						}
 
-						// If we've exhausted all retries, throw the last error
+						// Exhausted all retries
 						if (lastError) {
 							throw new Error(
 								`[Copilot] Max retries (${RATE_LIMIT_CONFIG.maxRetries}) exceeded. Last error: ${lastError.message}`,
 							);
 						}
-
-						// This should not be reached, but just in case
 						throw new Error(
 							`[Copilot] Max retries (${RATE_LIMIT_CONFIG.maxRetries}) exceeded`,
 						);
@@ -626,7 +804,6 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 									await sleep(
 										deviceData.interval * 1000 + OAUTH_POLLING_SAFETY_MARGIN_MS,
 									);
-									continue;
 								}
 							},
 						};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.18.14",
+	"version": "0.18.16",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": [
 		"agents",