opencodekit 0.19.6 → 0.20.1

package/dist/index.js

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

package/dist/template/.opencode/dcp-prompts/defaults/compress-message.md

@@ -39,3 +39,4 @@ During general cleanup, compress all medium and high-priority messages that are
 Optimize for reducing context footprint, not for grouping messages by topic.
 Do not compress away still-active instructions, unresolved questions, or constraints that are likely to matter soon.
 Prioritize the earliest messages in the context as they will be the least relevant to the active task.
+General cleanup should be done periodically between other normal compression tool passes, not as the primary form of compression.

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

@@ -85,8 +85,8 @@
     ".opencode/context/git-context.md"
   ],
   "keybinds": {
-    "leader": "`",
-    "session_parent": "<leader>up"
+    "leader": "ctrl+x",
+    "session_parent": "up"
   },
   "mcp": {
     "tilth": {

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

@@ -94,6 +94,51 @@ function getUrls(domain: string) {
 
 const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
 
+function getRequestUrl(input: RequestInfo | URL): string {
+	if (typeof input === "string") return input;
+	if (input instanceof URL) return input.toString();
+	if (typeof Request !== "undefined" && input instanceof Request) {
+		return input.url;
+	}
+	return input.toString();
+}
+
+function extractClaudeThinkingBudget(body: any): number | undefined {
+	const candidates = [body?.thinking_budget, body?.thinking?.budget_tokens];
+
+	for (const candidate of candidates) {
+		if (typeof candidate === "number" && Number.isFinite(candidate)) {
+			const normalized = Math.trunc(candidate);
+			if (normalized > 0) return normalized;
+		}
+	}
+
+	return undefined;
+}
+
+function getErrorMessage(error: unknown): string {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	try {
+		return JSON.stringify(error);
+	} catch {
+		return String(error);
+	}
+}
+
+function isTransientUpstreamTimeoutError(error: unknown): boolean {
+	const message = getErrorMessage(error).toLowerCase();
+	return (
+		message.includes("upstream idle timeout") ||
+		message.includes("mid_stream") ||
+		message.includes("sse read timed out") ||
+		message.includes("socket connection was closed unexpectedly") ||
+		message.includes("connection reset") ||
+		message.includes("econnreset") ||
+		message.includes("etimedout")
+	);
+}
+
 // Rate limit handling configuration
 const RATE_LIMIT_CONFIG = {
 	maxDelayMs: 60000, // Cap at 60 seconds
@@ -553,7 +598,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 									? JSON.parse(init.body)
 									: init?.body;
 
-							const url = input.toString();
+							const url = getRequestUrl(input);
 
 							// Check if this is a Claude model request
 							const modelId = body?.model || "";
@@ -574,18 +619,34 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 								// For Claude models, add thinking_budget to enable reasoning
 								// The Copilot API accepts this parameter and returns reasoning_text/reasoning_opaque
 								if (isClaudeModel) {
-									// Use configured thinking_budget from model options, or default to 10000
-									const thinkingBudget = body.thinking_budget || 10000;
-
-									// Fix for "Invalid signature in thinking block" error:
-									// The Copilot API uses reasoning_text/reasoning_opaque format for thinking
-									// When these are passed back without proper signature, it causes errors
-									// Solution: Ensure reasoning_opaque is present when reasoning_text exists,
-									// or remove reasoning content entirely if signature is invalid/missing
+									const thinkingBudget = extractClaudeThinkingBudget(body);
+									const isThinkingEnabled = thinkingBudget != null;
+
 									const cleanedMessages = body.messages.map(
 										(msg: any, idx: number) => {
 											if (msg.role !== "assistant") return msg;
 
+											// If thinking is disabled, strip all reasoning metadata to prevent
+											// stale reasoning context from continuing across turns.
+											if (!isThinkingEnabled) {
+												const {
+													reasoning_text: _reasoningText,
+													reasoning_opaque: _reasoningOpaque,
+													...baseMsg
+												} = msg;
+												if (!Array.isArray(baseMsg.content)) return baseMsg;
+
+												const cleanedContent = baseMsg.content.filter(
+													(part: any) => part.type !== "thinking",
+												);
+
+												return {
+													...baseMsg,
+													content:
+														cleanedContent.length > 0 ? cleanedContent : null,
+												};
+											}
+
 											// Log message structure for debugging
 											log("debug", `Processing assistant message ${idx}`, {
 												has_reasoning_text: !!msg.reasoning_text,
@@ -605,11 +666,6 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 											}
 
 											// 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",
@@ -634,15 +690,31 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 										},
 									);
 
-									modifiedBody = {
-										...body,
+									const nextBody: Record<string, any> = {
+										...(modifiedBody || body),
 										messages: cleanedMessages,
-										thinking_budget: thinkingBudget,
 									};
-									log("info", `Adding thinking_budget for Claude model`, {
-										model: modelId,
-										thinking_budget: thinkingBudget,
-									});
+
+									if (isThinkingEnabled) {
+										nextBody.thinking_budget = thinkingBudget;
+										log("info", `Adding thinking_budget for Claude model`, {
+											model: modelId,
+											thinking_budget: thinkingBudget,
+										});
+									} else {
+										delete nextBody.thinking_budget;
+										log(
+											"info",
+											`Claude thinking disabled for this request (no thinking budget set)`,
+											{ model: modelId },
+										);
+									}
+
+									// Copilot OpenAI-compatible endpoint expects `thinking_budget`.
+									// Remove Anthropic-style `thinking` object to avoid mixed payloads.
+									delete nextBody.thinking;
+
+									modifiedBody = nextBody;
 								}
 
 								// For GPT models (o1, gpt-5, etc.), add reasoning parameter
@@ -839,46 +911,82 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 							}
 						}
 
-						try {
-							if (currentModel) {
-								await shapeRequestForModel(currentModel);
-							}
-							const response = await fetch(input, activeFinalInit);
+						const maxFetchAttempts = 2;
 
-							if (response.status === 429) {
-								try {
-									await response.body?.cancel();
-								} catch {}
+						for (let attempt = 1; attempt <= maxFetchAttempts; attempt++) {
+							try {
+								if (currentModel) {
+									await shapeRequestForModel(currentModel);
+								}
+								const response = await fetch(input, activeFinalInit);
 
-								const retryAfterMs = parseRetryAfter(response);
-								const cooldownMs = clampCooldownMs(
-									retryAfterMs,
-									RATE_LIMIT_CONFIG.defaultCooldownMs,
-								);
+								if (response.status === 429) {
+									try {
+										await response.body?.cancel();
+									} catch {}
 
-								if (currentModel) {
-									markModelRateLimited(currentModel, cooldownMs);
-									openFamilyCircuitBreaker(currentModel, cooldownMs);
+									const retryAfterMs = parseRetryAfter(response);
+									const cooldownMs = clampCooldownMs(
+										retryAfterMs,
+										RATE_LIMIT_CONFIG.defaultCooldownMs,
+									);
+
+									if (currentModel) {
+										markModelRateLimited(currentModel, cooldownMs);
+										openFamilyCircuitBreaker(currentModel, cooldownMs);
+									}
+
+									throw new Error(
+										`[Copilot] Rate limited: ${currentModel || "model"} cooling down. Retry in ${formatRetryAfter(Math.ceil(cooldownMs / 1000))}.`,
+									);
 								}
 
-								throw new Error(
-									`[Copilot] Rate limited: ${currentModel || "model"} cooling down. Retry in ${formatRetryAfter(Math.ceil(cooldownMs / 1000))}.`,
-								);
-							}
+								// Response transformation is handled by the custom SDK at
+								// .opencode/plugin/sdk/copilot/
+								return response;
+							} catch (error) {
+								const errorMessage = getErrorMessage(error);
+								if (
+									errorMessage.includes("Rate limited") ||
+									errorMessage.includes("Local request queue saturated")
+								) {
+									throw error instanceof Error
+										? error
+										: new Error(errorMessage);
+								}
+
+								if (
+									attempt < maxFetchAttempts &&
+									isTransientUpstreamTimeoutError(error)
+								) {
+									const retryDelayMs = 750 * attempt;
+									log(
+										"warn",
+										`Transient upstream timeout from Copilot, retrying request`,
+										{
+											model: currentModel || undefined,
+											attempt,
+											retry_delay_ms: retryDelayMs,
+											error: errorMessage,
+										},
+									);
+									await sleep(retryDelayMs);
+									continue;
+								}
 
-							// Response transformation is handled by the custom SDK at
-							// .opencode/plugin/sdk/copilot/
-							return response;
-						} catch (error) {
-							const lastError = error as Error;
-							if (
-								lastError.message.includes("Rate limited") ||
-								lastError.message.includes("Local request queue saturated")
-							) {
-								throw lastError;
+								if (isTransientUpstreamTimeoutError(error)) {
+									throw new Error(
+										`[Copilot] Upstream idle timeout while streaming ${currentModel || "request"}. Retry with a lower thinking budget or switch to a lower-latency Claude variant.`,
+									);
+								}
+
+								throw error;
 							}
-							throw error;
 						}
+
+						throw new Error(
+							`[Copilot] Failed request after ${maxFetchAttempts} attempts.`,
+						);
 					},
 				};
 			},

package/dist/template/.opencode/skill/chrome-devtools/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: chrome-devtools
-description: Chrome DevTools for debugging, performance analysis, and browser automation. Use when debugging web apps, analyzing performance, inspecting network requests, or automating browser interactions.
+description: Use when debugging web apps in Chrome — performance profiling, network inspection, DOM debugging, or console automation. MUST load before any Chrome DevTools-based debugging session.
 version: 1.0.0
 tags: [automation, debugging]
 dependencies: []

package/dist/template/.opencode/skill/cloudflare/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: cloudflare
-description: Comprehensive Cloudflare platform skill covering Workers, Pages, storage (KV, D1, R2), AI (Workers AI, Vectorize, Agents SDK), networking (Tunnel, Spectrum), security (WAF, DDoS), and infrastructure-as-code (Terraform, Pulumi). Use for any Cloudflare development task.
+description: Use when deploying to or configuring ANY Cloudflare service — Workers, Pages, KV, D1, R2, AI, Tunnel, WAF. MUST load before writing Cloudflare Workers code, wrangler configs, or infrastructure-as-code for Cloudflare.
 references:
   - workers
   - pages