opencodekit 0.18.16 → 0.18.18

package/dist/index.js

@@ -20,7 +20,7 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
 //#region package.json
-var version = "0.18.16";
+var version = "0.18.18";
 
 //#endregion
 //#region src/utils/license.ts

package/dist/template/.opencode/opencode.json

@@ -161,8 +161,8 @@
 				"claude-haiku-4.5": {
 					"attachment": true,
 					"limit": {
-						"context": 200000,
-						"output": 64000
+						"context": 144000,
+						"output": 32000
 					},
 					"options": {
 						"thinking_budget": 10000,
@@ -174,13 +174,13 @@
 					"variants": {
 						"high": {
 							"options": {
-								"thinking_budget": 8000,
+								"thinking_budget": 16000,
 								"type": "enabled"
 							}
 						},
 						"max": {
 							"options": {
-								"thinking_budget": 16000,
+								"thinking_budget": 32000,
 								"type": "enabled"
 							}
 						}
@@ -189,8 +189,8 @@
 				"claude-opus-4.5": {
 					"attachment": true,
 					"limit": {
-						"context": 200000,
-						"output": 64000
+						"context": 160000,
+						"output": 32000
 					},
 					"options": {
 						"thinking_budget": 10000
@@ -201,12 +201,12 @@
 					"variants": {
 						"high": {
 							"options": {
-								"thinking_budget": 8000
+								"thinking_budget": 16000
 							}
 						},
 						"max": {
 							"options": {
-								"thinking_budget": 16000
+								"thinking_budget": 32000
 							}
 						}
 					}
@@ -214,7 +214,7 @@
 				"claude-opus-4.6": {
 					"attachment": true,
 					"limit": {
-						"context": 200000,
+						"context": 144000,
 						"output": 64000
 					},
 					"options": {
@@ -259,21 +259,33 @@
 				"claude-sonnet-4": {
 					"attachment": true,
 					"limit": {
-						"context": 200000,
-						"output": 64000
+						"context": 216000,
+						"output": 16000
 					},
 					"options": {
 						"thinking_budget": 10000
 					},
 					"reasoning": true,
 					"temperature": true,
-					"tool_call": true
+					"tool_call": true,
+					"variants": {
+						"high": {
+							"options": {
+								"thinking_budget": 16000
+							}
+						},
+						"max": {
+							"options": {
+								"thinking_budget": 32000
+							}
+						}
+					}
 				},
 				"claude-sonnet-4.5": {
 					"attachment": true,
 					"limit": {
-						"context": 200000,
-						"output": 64000
+						"context": 144000,
+						"output": 32000
 					},
 					"options": {
 						"thinking_budget": 10000
@@ -284,12 +296,12 @@
 					"variants": {
 						"high": {
 							"options": {
-								"thinking_budget": 8000
+								"thinking_budget": 16000
 							}
 						},
 						"max": {
 							"options": {
-								"thinking_budget": 16000
+								"thinking_budget": 32000
 							}
 						}
 					}
@@ -298,7 +310,7 @@
 					"attachment": true,
 					"limit": {
 						"context": 200000,
-						"output": 64000
+						"output": 32000
 					},
 					"options": {
 						"thinking": {

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

@@ -89,11 +89,31 @@ const RATE_LIMIT_CONFIG = {
 	maxFallbacks: 4, // Max model fallback switches per request
 };
 
+// Local request shaping to smooth bursts before they hit Copilot limits
+const REQUEST_SHAPING_CONFIG = {
+	tokensPerSecond: 1,
+	burstCapacity: 2,
+	maxQueueDelayMs: 15000,
+};
+
+const CIRCUIT_BREAKER_CONFIG = {
+	maxInlineWaitMs: 30000,
+	maxRecoveryCycles: 3,
+};
+
 // Per-model rate limit state (in-memory, resets on restart)
 interface RateLimitEntry {
 	rateLimitedUntil: number; // Unix timestamp (ms)
 }
 const rateLimitState = new Map<string, RateLimitEntry>();
+const familyCircuitBreakerState = new Map<string, number>();
+
+interface TokenBucketState {
+	tokens: number;
+	lastRefillAt: number;
+}
+const modelTokenBuckets = new Map<string, TokenBucketState>();
+const modelQueueTail = new Map<string, Promise<void>>();
 
 // Model fallback chains: same-family alternatives when a model is rate-limited
 const MODEL_FALLBACK_CHAINS: Record<string, string[]> = {
@@ -146,6 +166,144 @@ function isModelRateLimited(model: string): boolean {
 	return true;
 }
 
+function getRateLimitRemainingMs(model: string): number | null {
+	const entry = rateLimitState.get(model);
+	if (!entry) return null;
+	const remaining = entry.rateLimitedUntil - Date.now();
+	if (remaining <= 0) {
+		rateLimitState.delete(model);
+		return null;
+	}
+	return remaining;
+}
+
+function getModelFamily(model: string): string[] {
+	const family = new Set<string>([
+		model,
+		...(MODEL_FALLBACK_CHAINS[model] || []),
+	]);
+	return [...family];
+}
+
+function getFamilyCircuitKey(model: string): string {
+	return getModelFamily(model).sort().join("|");
+}
+
+function getFamilyCircuitRemainingMs(model: string): number {
+	const key = getFamilyCircuitKey(model);
+	const until = familyCircuitBreakerState.get(key);
+	if (!until) return 0;
+	const remaining = until - Date.now();
+	if (remaining <= 0) {
+		familyCircuitBreakerState.delete(key);
+		return 0;
+	}
+	return remaining;
+}
+
+function openFamilyCircuitBreaker(model: string, cooldownMs: number): void {
+	const key = getFamilyCircuitKey(model);
+	familyCircuitBreakerState.set(
+		key,
+		Date.now() + Math.min(cooldownMs, RATE_LIMIT_CONFIG.maxDelayMs),
+	);
+}
+
+function getFamilyMaxCooldownRemainingMs(model: string): number {
+	let maxRemaining = 0;
+	for (const candidate of getModelFamily(model)) {
+		const remaining = getRateLimitRemainingMs(candidate) ?? 0;
+		if (remaining > maxRemaining) maxRemaining = remaining;
+	}
+	return maxRemaining;
+}
+
+function isEntireModelFamilyCoolingDown(model: string): boolean {
+	const family = getModelFamily(model);
+	return (
+		family.length > 0 &&
+		family.every((candidate) => isModelRateLimited(candidate))
+	);
+}
+
+function formatRetryAfter(seconds: number): string {
+	if (seconds < 60) return `${seconds}s`;
+	const mins = Math.floor(seconds / 60);
+	const secs = seconds % 60;
+	return secs > 0 ? `${mins}m ${secs}s` : `${mins}m`;
+}
+
+async function shapeRequestForModel(model: string): Promise<void> {
+	if (!model) return;
+
+	const previousTail = modelQueueTail.get(model) ?? Promise.resolve();
+	let releaseQueue: (() => void) | undefined;
+	const currentGate = new Promise<void>((resolve) => {
+		releaseQueue = resolve;
+	});
+	const currentTail = previousTail.then(() => currentGate);
+	modelQueueTail.set(model, currentTail);
+
+	let queueTimeout: ReturnType<typeof setTimeout> | undefined;
+	try {
+		await Promise.race([
+			previousTail,
+			new Promise<void>((_, reject) => {
+				queueTimeout = setTimeout(() => {
+					reject(
+						new Error(
+							`[Copilot] Local request queue saturated for ${model}. Retry in ${formatRetryAfter(Math.ceil(REQUEST_SHAPING_CONFIG.maxQueueDelayMs / 1000))}.`,
+						),
+					);
+				}, REQUEST_SHAPING_CONFIG.maxQueueDelayMs);
+			}),
+		]);
+
+		const now = Date.now();
+		const bucket = modelTokenBuckets.get(model) ?? {
+			tokens: REQUEST_SHAPING_CONFIG.burstCapacity,
+			lastRefillAt: now,
+		};
+
+		const elapsedMs = Math.max(0, now - bucket.lastRefillAt);
+		const refillTokens =
+			(elapsedMs / 1000) * REQUEST_SHAPING_CONFIG.tokensPerSecond;
+		bucket.tokens = Math.min(
+			REQUEST_SHAPING_CONFIG.burstCapacity,
+			bucket.tokens + refillTokens,
+		);
+		bucket.lastRefillAt = now;
+
+		if (bucket.tokens < 1) {
+			const deficit = 1 - bucket.tokens;
+			const waitMs = Math.ceil(
+				(deficit / REQUEST_SHAPING_CONFIG.tokensPerSecond) * 1000,
+			);
+			if (waitMs > REQUEST_SHAPING_CONFIG.maxQueueDelayMs) {
+				throw new Error(
+					`[Copilot] Local request queue saturated for ${model}. Retry in ${formatRetryAfter(Math.ceil(waitMs / 1000))}.`,
+				);
+			}
+			log("info", `Local request shaping wait for ${model}`, {
+				wait_ms: waitMs,
+			});
+			await sleep(waitMs);
+			bucket.tokens = 0;
+			bucket.lastRefillAt = Date.now();
+		} else {
+			bucket.tokens -= 1;
+		}
+
+		modelTokenBuckets.set(model, bucket);
+	} finally {
+		if (queueTimeout) clearTimeout(queueTimeout);
+		releaseQueue?.();
+		if (modelQueueTail.get(model) === currentTail) {
+			modelQueueTail.delete(model);
+		}
+	}
+}
+
 function markModelRateLimited(model: string, cooldownMs: number): void {
 	rateLimitState.set(model, {
 		rateLimitedUntil: Date.now() + cooldownMs,
@@ -160,11 +318,16 @@ function markModelRateLimited(model: string, cooldownMs: number): void {
  * Find the next available fallback model in the same family.
  * Skips models that are themselves rate-limited.
  */
-function getNextFallbackModel(model: string): string | null {
+function getNextFallbackModel(
+	model: string,
+	attemptedModels: Set<string>,
+): string | null {
 	const chain = MODEL_FALLBACK_CHAINS[model];
 	if (!chain) return null;
 	for (const fallback of chain) {
-		if (!isModelRateLimited(fallback)) return fallback;
+		if (!attemptedModels.has(fallback) && !isModelRateLimited(fallback)) {
+			return fallback;
+		}
 	}
 	return null;
 }
@@ -192,20 +355,29 @@ const MAX_RESPONSE_API_ID_LENGTH = 64;
  * Sanitize an ID to fit within the Responses API 64-char limit.
  * GitHub Copilot returns proprietary long IDs (400+ chars) that violate
  * the OpenAI spec. We hash them to a deterministic 64-char string.
+ * Preserves the original prefix (e.g., "fc_", "msg_", "call_") so that
+ * OpenAI's prefix validation passes.
  * See: https://github.com/vercel/ai/issues/5171
  */
 function sanitizeResponseId(id: string): string {
 	if (!id || id.length <= MAX_RESPONSE_API_ID_LENGTH) return id;
-	// Use a simple hash: take first 8 chars + hash of full string for uniqueness
-	// Format: "h_" + first 8 chars + "_" + base36 hash (up to ~50 chars total)
+	// Detect and preserve the original prefix (e.g., "fc_", "msg_", "call_", "resp_")
+	// The OpenAI Responses API validates that IDs start with specific prefixes
+	const prefixMatch = id.match(/^([a-z]+_)/);
+	const prefix = prefixMatch ? prefixMatch[1] : "";
+	// Hash the full ID for deterministic uniqueness
 	let hash = 0;
 	for (let i = 0; i < id.length; i++) {
 		hash = ((hash << 5) - hash + id.charCodeAt(i)) | 0;
 	}
 	const hashStr = Math.abs(hash).toString(36);
-	const prefix = id.slice(0, 8);
-	// Ensure total length <= 64: "h_" (2) + prefix (8) + "_" (1) + hash
-	return `h_${prefix}_${hashStr}`.slice(0, MAX_RESPONSE_API_ID_LENGTH);
+	// Take some chars from after the prefix for additional uniqueness
+	const afterPrefix = id.slice(prefix.length);
+	const maxMiddleLen =
+		MAX_RESPONSE_API_ID_LENGTH - prefix.length - hashStr.length - 1;
+	const middle = afterPrefix.slice(0, Math.max(0, maxMiddleLen));
+	// Format: prefix + middle + "_" + hash (ensure total <= 64)
+	return `${prefix}${middle}_${hashStr}`.slice(0, MAX_RESPONSE_API_ID_LENGTH);
 }
 
 /**
@@ -350,7 +522,12 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 												return cleanedMsg;
 											}
 
-											// If content is an array, check for thinking blocks
+											// If content is an array, strip ALL thinking blocks.
+											// Reasoning is communicated via reasoning_text/reasoning_opaque
+											// fields, not via thinking blocks in the content array.
+											// Even thinking blocks WITH signatures can cause
+											// "Invalid signature in thinking block" errors when
+											// signatures are expired or from a different context.
 											if (Array.isArray(msg.content)) {
 												const hasThinkingBlock = msg.content.some(
 													(part: any) => part.type === "thinking",
@@ -358,22 +535,10 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 												if (hasThinkingBlock) {
 													log(
 														"debug",
-														`Message ${idx} has thinking blocks in content array`,
+														`Stripping all thinking blocks from message ${idx}`,
 													);
-													// Filter out thinking blocks without signatures
 													const cleanedContent = msg.content.filter(
-														(part: any) => {
-															if (part.type === "thinking") {
-																if (!part.signature) {
-																	log(
-																		"warn",
-																		`Removing thinking block without signature`,
-																	);
-																	return false;
-																}
-															}
-															return true;
-														},
+														(part: any) => part.type !== "thinking",
 													);
 													return {
 														...msg,
@@ -530,8 +695,33 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 
 						// Pre-flight: if current model is already known rate-limited, switch to fallback
 						let activeFinalInit: RequestInit = finalInit;
+						const attemptedModels = new Set<string>();
+						if (currentModel) attemptedModels.add(currentModel);
+						const requestedModel = currentModel;
+						if (currentModel) {
+							const circuitRemainingMs =
+								getFamilyCircuitRemainingMs(currentModel);
+							if (circuitRemainingMs > 0) {
+								if (
+									circuitRemainingMs <= CIRCUIT_BREAKER_CONFIG.maxInlineWaitMs
+								) {
+									log(
+										"info",
+										`Family circuit open for ${currentModel}, waiting ${circuitRemainingMs}ms`,
+									);
+									await sleep(circuitRemainingMs);
+								} else {
+									throw new Error(
+										`[Copilot] All fallback models cooling down. Retry in ${formatRetryAfter(Math.ceil(circuitRemainingMs / 1000))}.`,
+									);
+								}
+							}
+						}
 						if (currentModel && isModelRateLimited(currentModel)) {
-							const fallback = getNextFallbackModel(currentModel);
+							const fallback = getNextFallbackModel(
+								currentModel,
+								attemptedModels,
+							);
 							if (fallback) {
 								log(
 									"info",
@@ -540,6 +730,26 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 								activeFinalInit =
 									swapModelInBody(finalInit, fallback) || finalInit;
 								currentModel = fallback;
+								attemptedModels.add(fallback);
+							} else {
+								const familyCooldownMs =
+									getFamilyMaxCooldownRemainingMs(currentModel);
+								openFamilyCircuitBreaker(currentModel, familyCooldownMs);
+								if (
+									familyCooldownMs <= CIRCUIT_BREAKER_CONFIG.maxInlineWaitMs
+								) {
+									log(
+										"info",
+										`All fallback models cooling down for ${currentModel}, waiting ${familyCooldownMs}ms`,
+									);
+									await sleep(familyCooldownMs);
+									attemptedModels.clear();
+									if (currentModel) attemptedModels.add(currentModel);
+								} else {
+									throw new Error(
+										`[Copilot] All fallback models cooling down. Retry in ${formatRetryAfter(Math.ceil(familyCooldownMs / 1000))}.`,
+									);
+								}
 							}
 						}
 
@@ -547,12 +757,20 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 						let lastError: Error | undefined;
 						let fallbacksUsed = 0;
 						let attempt = 0;
+						let recoveryCyclesUsed = 0;
 
 						while (attempt <= RATE_LIMIT_CONFIG.maxRetries) {
 							try {
+								if (currentModel) {
+									await shapeRequestForModel(currentModel);
+								}
 								const response = await fetch(input, activeFinalInit);
 
 								if (response.status === 429) {
+									try {
+										await response.body?.cancel();
+									} catch {}
+
 									// Parse Retry-After header for server-suggested cooldown
 									const retryAfterMs = parseRetryAfter(response);
 									const cooldownMs =
@@ -568,7 +786,10 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 										currentModel &&
 										fallbacksUsed < RATE_LIMIT_CONFIG.maxFallbacks
 									) {
-										const fallback = getNextFallbackModel(currentModel);
+										const fallback = getNextFallbackModel(
+											currentModel,
+											attemptedModels,
+										);
 										if (fallback) {
 											log(
 												"warn",
@@ -583,6 +804,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 												swapModelInBody(activeFinalInit, fallback) ||
 												activeFinalInit;
 											currentModel = fallback;
+											attemptedModels.add(fallback);
 											fallbacksUsed++;
 											continue; // Retry immediately with new model, no delay
 										}
@@ -590,10 +812,41 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 
 									// 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);
+										if (
+											currentModel &&
+											isEntireModelFamilyCoolingDown(currentModel)
+										) {
+											const familyCooldownMs =
+												getFamilyMaxCooldownRemainingMs(currentModel);
+											openFamilyCircuitBreaker(currentModel, familyCooldownMs);
+											if (
+												familyCooldownMs <=
+												CIRCUIT_BREAKER_CONFIG.maxInlineWaitMs
+											) {
+												log(
+													"info",
+													`All fallback models cooling down for ${currentModel}, waiting ${familyCooldownMs}ms before retry`,
+												);
+												await sleep(familyCooldownMs);
+												attemptedModels.clear();
+												if (currentModel) attemptedModels.add(currentModel);
+												attempt++;
+												continue;
+											}
+											throw new Error(
+												`[Copilot] All fallback models cooling down. Retry in ${formatRetryAfter(Math.ceil(familyCooldownMs / 1000))}.`,
+											);
+										}
+
+										const modelCooldownMs = currentModel
+											? getRateLimitRemainingMs(currentModel)
+											: null;
+										const delay = Math.min(
+											modelCooldownMs ??
+												retryAfterMs ??
+												calculateRetryDelay(attempt),
+											RATE_LIMIT_CONFIG.maxDelayMs,
+										);
 										log(
 											"warn",
 											`Rate limited (429), no fallback available, waiting ${delay}ms`,
@@ -605,11 +858,47 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 											},
 										);
 										await sleep(delay);
+										attemptedModels.clear();
+										if (currentModel) attemptedModels.add(currentModel);
 										attempt++;
 										continue;
 									}
 
 									// Exhausted retries and fallbacks
+									if (currentModel) {
+										const familyCooldownMs =
+											getFamilyMaxCooldownRemainingMs(currentModel);
+										const recoveryDelayMs =
+											familyCooldownMs > 0
+												? Math.min(
+														familyCooldownMs,
+														CIRCUIT_BREAKER_CONFIG.maxInlineWaitMs,
+													)
+												: calculateRetryDelay(0);
+										if (
+											recoveryDelayMs > 0 &&
+											recoveryCyclesUsed <
+												CIRCUIT_BREAKER_CONFIG.maxRecoveryCycles
+										) {
+											recoveryCyclesUsed++;
+											log(
+												"info",
+												`Rate-limit budget exhausted for ${currentModel}, waiting ${recoveryDelayMs}ms for recovery cycle ${recoveryCyclesUsed}`,
+											);
+											await sleep(recoveryDelayMs);
+											attempt = 0;
+											fallbacksUsed = 0;
+											if (requestedModel) {
+												currentModel = requestedModel;
+												activeFinalInit =
+													swapModelInBody(finalInit, requestedModel) ||
+													finalInit;
+											}
+											attemptedModels.clear();
+											if (currentModel) attemptedModels.add(currentModel);
+											continue;
+										}
+									}
 									throw new Error(
 										`[Copilot] Rate limited. Tried ${fallbacksUsed} fallback model(s) and ${attempt} retries. Model: ${currentModel}`,
 									);
@@ -621,6 +910,15 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 							} catch (error) {
 								lastError = error as Error;
 
+								if (
+									lastError.message.includes(
+										"All fallback models cooling down",
+									) ||
+									lastError.message.includes("Local request queue saturated")
+								) {
+									throw lastError;
+								}
+
 								// Network errors might be transient, retry
 								if (attempt < RATE_LIMIT_CONFIG.maxRetries) {
 									const delay = calculateRetryDelay(attempt);

package/dist/template/.opencode/plugin/lib/memory-hooks.ts

@@ -90,24 +90,51 @@ export function createHooks(deps: HookDeps) {
 				}
 			}
 
-			// --- Session error: show actual error details ---
+			// --- Session error: classify and guide ---
 			if (event.type === "session.error") {
 				const props = event.properties as Record<string, unknown> | undefined;
 				const errorMsg = props?.error
-					? String(props.error).slice(0, 120)
+					? String(props.error).slice(0, 200)
 					: props?.message
-						? String(props.message).slice(0, 120)
+						? String(props.message).slice(0, 200)
 						: "Unknown error";
 
-				// Classify: match the specific AI SDK error pattern
-				const isTokenOverflow =
+				// Log full error for debugging
+				await log(`Session error: ${errorMsg}`, "warn");
+
+				// Classify error and provide specific guidance
+				let guidance: string;
+				if (
 					/token.{0,20}(exceed|limit)/i.test(errorMsg) ||
-					errorMsg.includes("context_length_exceeded");
-				const guidance = isTokenOverflow
-					? "Context too large — use /compact or start a new session"
-					: "Save important learnings with observation tool";
+					errorMsg.includes("context_length_exceeded")
+				) {
+					guidance = "Context too large — use /compact or start a new session";
+				} else if (
+					/rate.?limit|429|too many requests/i.test(errorMsg)
+				) {
+					guidance = "Rate limited — wait a moment and retry";
+				} else if (
+					/unauthorized|401|403|auth/i.test(errorMsg)
+				) {
+					guidance = "Auth error — check API key or token";
+				} else if (
+					/timeout|ETIMEDOUT|ECONNRESET|network|fetch failed/i.test(errorMsg)
+				) {
+					guidance = "Network error — check connection and retry";
+				} else if (
+					/invalid.*signature|thinking block/i.test(errorMsg)
+				) {
+					guidance = "API format error — try starting a new session";
+				} else if (
+					/500|502|503|504|internal server|service unavailable/i.test(errorMsg)
+				) {
+					guidance = "Server error — retry in a few seconds";
+				} else {
+					guidance = "Unexpected error — save work with observation tool if needed";
+				}
 
-				await showToast("Session Error", `${guidance} (${errorMsg})`, "warning");
+				const short = errorMsg.length > 80 ? `${errorMsg.slice(0, 80)}…` : errorMsg;
+				await showToast("Session Error", `${guidance} (${short})`, "warning");
 			}
 		},
 

package/package.json

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