opencodekit 0.15.19 → 0.15.21

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

@@ -11,10 +11,10 @@
     "type-check": "tsc --noEmit"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "1.1.44"
+    "@opencode-ai/plugin": "1.1.48"
   },
   "devDependencies": {
-    "@types/node": "^25.0.3",
+    "@types/node": "^25.1.0",
     "typescript": "^5.9.3"
   }
 }

package/dist/template/.opencode/{plugins → plugin}/copilot-auth.ts

@@ -1,12 +1,43 @@
 /**
  * GitHub Copilot Auth Plugin
  * Simplified auth provider without token expiration checks
+ *
+ * Claude Reasoning Support:
+ * This plugin adds `thinking_budget` to the request body for Claude models.
+ * The Copilot API accepts this parameter and returns reasoning in the response.
+ *
+ * NOTE: Response parsing for reasoning_text/reasoning_opaque is handled by
+ * the custom SDK at .opencode/plugin/sdk/copilot/ which properly converts
+ * these fields to AI SDK's reasoning content parts.
  */
 
 import type { Plugin } from "@opencode-ai/plugin";
 
 const CLIENT_ID = "Ov23li8tweQw6odWQebz";
 
+// Logger function that will be set by the plugin
+let log: (
+	level: "debug" | "info" | "warn" | "error",
+	message: string,
+	extra?: Record<string, any>,
+) => void = () => {};
+
+/**
+ * Set the logger function from the plugin context
+ */
+function setLogger(client: any) {
+	log = (level, message, extra) => {
+		client.app
+			.log({
+				service: "copilot-auth",
+				level,
+				message,
+				extra,
+			})
+			.catch(() => {}); // Fire and forget, don't block on logging
+	};
+}
+
 // Add a small safety buffer when polling to avoid hitting the server
 // slightly too early due to clock skew / timer drift.
 const OAUTH_POLLING_SAFETY_MARGIN_MS = 3000; // 3 seconds
@@ -70,7 +101,10 @@ function calculateRetryDelay(attempt: number): number {
 	return Math.round(delay);
 }
 
-export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
+export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
+	// Initialize logger with the SDK client
+	setLogger(sdk);
+
 	return {
 		auth: {
 			provider: "github-copilot",
@@ -78,8 +112,14 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 				const info = await getAuth();
 				if (!info || info.type !== "oauth") return {};
 
+				// Enterprise URL support for baseURL
+				const enterpriseUrl = (info as any).enterpriseUrl;
+				const baseURL = enterpriseUrl
+					? `https://copilot-api.${normalizeDomain(enterpriseUrl)}`
+					: undefined;
+
 				if (provider && provider.models) {
-					for (const model of Object.values(provider.models)) {
+					for (const [_modelId, model] of Object.entries(provider.models)) {
 						model.cost = {
 							input: 0,
 							output: 0,
@@ -89,23 +129,16 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 							},
 						};
 
-						// TODO: re-enable once messages api has higher rate limits
-						// Claude routing is disabled to avoid "Not Found" errors and rate limits
-						// const base = baseURL ?? model.api.url ?? "https://api.githubcopilot.com";
-						// const isClaude = model.id.includes("claude");
-						// let url = base;
-						// if (isClaude) {
-						// 	if (!url.endsWith("/v1")) {
-						// 		url = url.endsWith("/") ? `${url}v1` : `${url}/v1`;
-						// 	}
-						// }
-						// model.api.url = url;
-						// model.api.npm = isClaude ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot";
+						// All models use the standard github-copilot SDK
+						// Reasoning support for Claude models is handled via:
+						// 1. The fetch wrapper adds thinking_budget to request body
+						// 2. The fetch wrapper strips invalid thinking blocks from messages
 						model.api.npm = "@ai-sdk/github-copilot";
 					}
 				}
 
 				return {
+					baseURL,
 					apiKey: "",
 					async fetch(input, init) {
 						const info = await getAuth();
@@ -113,6 +146,9 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 
 						let isAgentCall = false;
 						let isVisionRequest = false;
+						let modifiedBody: any = undefined;
+						let isClaudeModel = false;
+
 						try {
 							const body =
 								typeof init?.body === "string"
@@ -121,6 +157,10 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 
 							const url = input.toString();
 
+							// Check if this is a Claude model request
+							const modelId = body?.model || "";
+							isClaudeModel = modelId.toLowerCase().includes("claude");
+
 							// Completions API
 							if (body?.messages && url.includes("completions")) {
 								// Keep local logic: detect if any message is assistant/tool
@@ -132,6 +172,121 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 										Array.isArray(msg.content) &&
 										msg.content.some((part: any) => part.type === "image_url"),
 								);
+
+								// 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 cleanedMessages = body.messages.map(
+										(msg: any, idx: number) => {
+											if (msg.role !== "assistant") return msg;
+
+											// Log message structure for debugging
+											log("debug", `Processing assistant message ${idx}`, {
+												has_reasoning_text: !!msg.reasoning_text,
+												has_reasoning_opaque: !!msg.reasoning_opaque,
+												content_type: typeof msg.content,
+												content_is_array: Array.isArray(msg.content),
+											});
+
+											// If message has reasoning_text but no/invalid reasoning_opaque, remove reasoning
+											if (msg.reasoning_text && !msg.reasoning_opaque) {
+												log(
+													"warn",
+													`Removing reasoning_text without reasoning_opaque from message ${idx}`,
+												);
+												const { reasoning_text: _unused, ...cleanedMsg } = msg;
+												return cleanedMsg;
+											}
+
+											// If content is an array, check for thinking blocks
+											if (Array.isArray(msg.content)) {
+												const hasThinkingBlock = msg.content.some(
+													(part: any) => part.type === "thinking",
+												);
+												if (hasThinkingBlock) {
+													log(
+														"debug",
+														`Message ${idx} has thinking blocks in content array`,
+													);
+													// 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;
+														},
+													);
+													return {
+														...msg,
+														content:
+															cleanedContent.length > 0 ? cleanedContent : null,
+													};
+												}
+											}
+
+											return msg;
+										},
+									);
+
+									modifiedBody = {
+										...body,
+										messages: cleanedMessages,
+										thinking_budget: thinkingBudget,
+									};
+									log("info", `Adding thinking_budget for Claude model`, {
+										model: modelId,
+										thinking_budget: thinkingBudget,
+									});
+								}
+
+								// For GPT models (o1, gpt-5, etc.), add reasoning parameter
+								const isGptModel =
+									modelId.toLowerCase().includes("gpt") ||
+									modelId.toLowerCase().includes("o1") ||
+									modelId.toLowerCase().includes("o3") ||
+									modelId.toLowerCase().includes("o4");
+
+								if (isGptModel && !isClaudeModel) {
+									// Get reasoning effort from body options or default to "medium"
+									const reasoningEffort =
+										body.reasoning?.effort ||
+										body.reasoningEffort ||
+										body.reasoning_effort ||
+										"medium";
+
+									modifiedBody = {
+										...(modifiedBody || body),
+										reasoning: {
+											effort: reasoningEffort,
+										},
+									};
+
+									// Also pass through other reasoning options if present
+									if (body.reasoningSummary || body.reasoning?.summary) {
+										modifiedBody.reasoning.summary =
+											body.reasoningSummary || body.reasoning?.summary;
+									}
+
+									log("info", `Adding reasoning for GPT model`, {
+										model: modelId,
+										reasoning_effort: reasoningEffort,
+									});
+								}
 							}
 
 							// Responses API
@@ -189,6 +344,13 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 						delete headers["x-api-key"];
 						delete headers["authorization"];
 
+						// Prepare the final init object with potentially modified body
+						const finalInit = {
+							...init,
+							headers,
+							...(modifiedBody ? { body: JSON.stringify(modifiedBody) } : {}),
+						};
+
 						// Retry logic with exponential backoff for rate limiting
 						let lastError: Error | undefined;
 						for (
@@ -197,10 +359,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 							attempt++
 						) {
 							try {
-								const response = await fetch(input, {
-									...init,
-									headers,
-								});
+								const response = await fetch(input, finalInit);
 
 								// If we get a 429, retry with backoff
 								if (
@@ -208,13 +367,18 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 									attempt < RATE_LIMIT_CONFIG.maxRetries
 								) {
 									const delay = calculateRetryDelay(attempt);
-									console.log(
-										`[Copilot] Rate limited (429), retrying in ${delay}ms... (attempt ${attempt + 1}/${RATE_LIMIT_CONFIG.maxRetries})`,
-									);
+									log("warn", `Rate limited (429), retrying`, {
+										delay_ms: delay,
+										attempt: attempt + 1,
+										max_retries: RATE_LIMIT_CONFIG.maxRetries,
+									});
 									await sleep(delay);
 									continue;
 								}
 
+								// 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
 								return response;
 							} catch (error) {
 								lastError = error as Error;
@@ -222,9 +386,12 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 								// Network errors might be transient, retry
 								if (attempt < RATE_LIMIT_CONFIG.maxRetries) {
 									const delay = calculateRetryDelay(attempt);
-									console.log(
-										`[Copilot] Request failed, retrying in ${delay}ms... (attempt ${attempt + 1}/${RATE_LIMIT_CONFIG.maxRetries})`,
-									);
+									log("warn", `Request failed, retrying`, {
+										delay_ms: delay,
+										attempt: attempt + 1,
+										max_retries: RATE_LIMIT_CONFIG.maxRetries,
+										error: lastError.message,
+									});
 									await sleep(delay);
 									continue;
 								}
@@ -408,5 +575,33 @@ export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
 				},
 			],
 		},
+		// Hook to add custom headers for Claude reasoning support
+		"chat.headers": async (input: any, output: any) => {
+			// Only apply to GitHub Copilot provider
+			if (!input.model?.providerID?.includes("github-copilot")) return;
+
+			// Add Anthropic beta header for interleaved thinking (extended reasoning)
+			// This is required for Claude models to return thinking blocks
+			if (input.model?.api?.npm === "@ai-sdk/anthropic") {
+				output.headers["anthropic-beta"] = "interleaved-thinking-2025-05-14";
+			}
+
+			// Mark subagent sessions as agent-initiated (matching standard Copilot tools)
+			try {
+				const session = await sdk.session
+					.get({
+						path: {
+							id: input.sessionID,
+						},
+						throwOnError: true,
+					})
+					.catch(() => undefined);
+				if (session?.data?.parentID) {
+					output.headers["x-initiator"] = "agent";
+				}
+			} catch {
+				// Ignore errors from session lookup
+			}
+		},
 	};
 };

package/dist/template/.opencode/plugin/sdk/copilot/chat/convert-to-openai-compatible-chat-messages.ts

@@ -0,0 +1,181 @@
+import {
+	type LanguageModelV2Prompt,
+	type SharedV2ProviderMetadata,
+	UnsupportedFunctionalityError,
+} from "@ai-sdk/provider";
+import { convertToBase64 } from "@ai-sdk/provider-utils";
+import type { OpenAICompatibleChatPrompt } from "./openai-compatible-api-types.js";
+
+function getOpenAIMetadata(message: {
+	providerOptions?: SharedV2ProviderMetadata;
+}) {
+	return message?.providerOptions?.copilot ?? {};
+}
+
+export function convertToOpenAICompatibleChatMessages(
+	prompt: LanguageModelV2Prompt,
+): OpenAICompatibleChatPrompt {
+	const messages: OpenAICompatibleChatPrompt = [];
+	for (const { role, content, ...message } of prompt) {
+		const metadata = getOpenAIMetadata({ ...message });
+		switch (role) {
+			case "system": {
+				messages.push({
+					role: "system",
+					content: [
+						{
+							type: "text",
+							text: content,
+						},
+					],
+					...metadata,
+				});
+				break;
+			}
+
+			case "user": {
+				if (content.length === 1 && content[0].type === "text") {
+					messages.push({
+						role: "user",
+						content: content[0].text,
+						...getOpenAIMetadata(content[0]),
+					});
+					break;
+				}
+
+				messages.push({
+					role: "user",
+					content: content.map((part) => {
+						const partMetadata = getOpenAIMetadata(part);
+						switch (part.type) {
+							case "text": {
+								return {
+									type: "text" as const,
+									text: part.text,
+									...partMetadata,
+								};
+							}
+							case "file": {
+								if (part.mediaType.startsWith("image/")) {
+									const mediaType =
+										part.mediaType === "image/*"
+											? "image/jpeg"
+											: part.mediaType;
+
+									return {
+										type: "image_url" as const,
+										image_url: {
+											url:
+												part.data instanceof URL
+													? part.data.toString()
+													: `data:${mediaType};base64,${convertToBase64(part.data)}`,
+										},
+										...partMetadata,
+									};
+								} else {
+									throw new UnsupportedFunctionalityError({
+										functionality: `file part media type ${part.mediaType}`,
+									});
+								}
+							}
+						}
+					}),
+					...metadata,
+				});
+
+				break;
+			}
+
+			case "assistant": {
+				let text = "";
+				let reasoningText: string | undefined;
+				let reasoningOpaque: string | undefined;
+				const toolCalls: Array<{
+					id: string;
+					type: "function";
+					function: { name: string; arguments: string };
+				}> = [];
+
+				for (const part of content) {
+					const partMetadata = getOpenAIMetadata(part);
+					// Check for reasoningOpaque on any part (may be attached to text/tool-call)
+					const partOpaque = (
+						part.providerOptions as { copilot?: { reasoningOpaque?: string } }
+					)?.copilot?.reasoningOpaque;
+					if (partOpaque && !reasoningOpaque) {
+						reasoningOpaque = partOpaque;
+					}
+
+					switch (part.type) {
+						case "text": {
+							text += part.text;
+							break;
+						}
+						case "reasoning": {
+							reasoningText = part.text;
+							break;
+						}
+						case "tool-call": {
+							toolCalls.push({
+								id: part.toolCallId,
+								type: "function",
+								function: {
+									name: part.toolName,
+									arguments: JSON.stringify(part.input),
+								},
+								...partMetadata,
+							});
+							break;
+						}
+					}
+				}
+
+				messages.push({
+					role: "assistant",
+					content: text || null,
+					tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+					reasoning_text: reasoningText,
+					reasoning_opaque: reasoningOpaque,
+					...metadata,
+				});
+
+				break;
+			}
+
+			case "tool": {
+				for (const toolResponse of content) {
+					const output = toolResponse.output;
+
+					let contentValue: string;
+					switch (output.type) {
+						case "text":
+						case "error-text":
+							contentValue = output.value;
+							break;
+						case "content":
+						case "json":
+						case "error-json":
+							contentValue = JSON.stringify(output.value);
+							break;
+					}
+
+					const toolResponseMetadata = getOpenAIMetadata(toolResponse);
+					messages.push({
+						role: "tool",
+						tool_call_id: toolResponse.toolCallId,
+						content: contentValue,
+						...toolResponseMetadata,
+					});
+				}
+				break;
+			}
+
+			default: {
+				const _exhaustiveCheck: never = role;
+				throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
+			}
+		}
+	}
+
+	return messages;
+}

package/dist/template/.opencode/plugin/sdk/copilot/chat/get-response-metadata.ts

@@ -0,0 +1,15 @@
+export function getResponseMetadata({
+	id,
+	model,
+	created,
+}: {
+	id?: string | undefined | null;
+	created?: number | undefined | null;
+	model?: string | undefined | null;
+}) {
+	return {
+		id: id ?? undefined,
+		modelId: model ?? undefined,
+		timestamp: created != null ? new Date(created * 1000) : undefined,
+	};
+}

package/dist/template/.opencode/plugin/sdk/copilot/chat/map-openai-compatible-finish-reason.ts

@@ -0,0 +1,19 @@
+import type { LanguageModelV2FinishReason } from "@ai-sdk/provider";
+
+export function mapOpenAICompatibleFinishReason(
+	finishReason: string | null | undefined,
+): LanguageModelV2FinishReason {
+	switch (finishReason) {
+		case "stop":
+			return "stop";
+		case "length":
+			return "length";
+		case "content_filter":
+			return "content-filter";
+		case "function_call":
+		case "tool_calls":
+			return "tool-calls";
+		default:
+			return "unknown";
+	}
+}

package/dist/template/.opencode/plugin/sdk/copilot/chat/openai-compatible-api-types.ts

@@ -0,0 +1,72 @@
+import type { JSONValue } from "@ai-sdk/provider";
+
+export type OpenAICompatibleChatPrompt = Array<OpenAICompatibleMessage>;
+
+export type OpenAICompatibleMessage =
+	| OpenAICompatibleSystemMessage
+	| OpenAICompatibleUserMessage
+	| OpenAICompatibleAssistantMessage
+	| OpenAICompatibleToolMessage;
+
+// Allow for arbitrary additional properties for general purpose
+// provider-metadata-specific extensibility.
+type JsonRecord<T = never> = Record<
+	string,
+	JSONValue | JSONValue[] | T | T[] | undefined
+>;
+
+export interface OpenAICompatibleSystemMessage
+	extends JsonRecord<OpenAICompatibleSystemContentPart> {
+	role: "system";
+	content: string | Array<OpenAICompatibleSystemContentPart>;
+}
+
+export interface OpenAICompatibleSystemContentPart extends JsonRecord {
+	type: "text";
+	text: string;
+}
+
+export interface OpenAICompatibleUserMessage
+	extends JsonRecord<OpenAICompatibleContentPart> {
+	role: "user";
+	content: string | Array<OpenAICompatibleContentPart>;
+}
+
+export type OpenAICompatibleContentPart =
+	| OpenAICompatibleContentPartText
+	| OpenAICompatibleContentPartImage;
+
+export interface OpenAICompatibleContentPartImage extends JsonRecord {
+	type: "image_url";
+	image_url: { url: string };
+}
+
+export interface OpenAICompatibleContentPartText extends JsonRecord {
+	type: "text";
+	text: string;
+}
+
+export interface OpenAICompatibleAssistantMessage
+	extends JsonRecord<OpenAICompatibleMessageToolCall> {
+	role: "assistant";
+	content?: string | null;
+	tool_calls?: Array<OpenAICompatibleMessageToolCall>;
+	// Copilot-specific reasoning fields
+	reasoning_text?: string;
+	reasoning_opaque?: string;
+}
+
+export interface OpenAICompatibleMessageToolCall extends JsonRecord {
+	type: "function";
+	id: string;
+	function: {
+		arguments: string;
+		name: string;
+	};
+}
+
+export interface OpenAICompatibleToolMessage extends JsonRecord {
+	role: "tool";
+	content: string;
+	tool_call_id: string;
+}