opencodekit 0.15.19 → 0.15.20

package/dist/template/.opencode/plugins/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 @ai-sdk/github-copilot SDK if it supports it, or will need additional
+ * response transformation.
  */
 
 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,155 @@ function calculateRetryDelay(attempt: number): number {
 	return Math.round(delay);
 }
 
-export const CopilotAuthPlugin: Plugin = async ({ client: _client }) => {
+/**
+ * Transform a streaming SSE response to convert reasoning_text/reasoning_opaque
+ * to proper reasoning content parts that the AI SDK can understand.
+ *
+ * Copilot returns reasoning in these fields:
+ * - reasoning_text: The actual reasoning content (visible thinking)
+ * - reasoning_opaque: Encrypted/opaque reasoning data
+ *
+ * We convert these to OpenAI-style content parts with type "reasoning"
+ */
+function transformStreamingResponse(
+	body: ReadableStream<Uint8Array>,
+): ReadableStream<Uint8Array> {
+	const reader = body.getReader();
+	const encoder = new TextEncoder();
+	const decoder = new TextDecoder();
+
+	let buffer = "";
+
+	return new ReadableStream({
+		async pull(controller) {
+			try {
+				const { done, value } = await reader.read();
+
+				if (done) {
+					// Process any remaining buffer
+					if (buffer.trim()) {
+						const transformed = transformSSEChunk(buffer);
+						if (transformed) {
+							controller.enqueue(encoder.encode(transformed));
+						}
+					}
+					controller.close();
+					return;
+				}
+
+				// Decode and add to buffer
+				buffer += decoder.decode(value, { stream: true });
+
+				// Process complete SSE events (separated by double newlines)
+				const events = buffer.split("\n\n");
+				buffer = events.pop() || ""; // Keep incomplete event in buffer
+
+				for (const event of events) {
+					if (event.trim()) {
+						const transformed = transformSSEChunk(event);
+						if (transformed) {
+							controller.enqueue(encoder.encode(transformed + "\n\n"));
+						}
+					}
+				}
+			} catch (error) {
+				controller.error(error);
+			}
+		},
+		cancel() {
+			reader.cancel();
+		},
+	});
+}
+
+/**
+ * Transform a single SSE chunk to include reasoning content
+ */
+function transformSSEChunk(chunk: string): string {
+	// Parse the SSE event
+	const lines = chunk.split("\n");
+	let eventType = "";
+	let data = "";
+
+	for (const line of lines) {
+		if (line.startsWith("event:")) {
+			eventType = line.slice(6).trim();
+		} else if (line.startsWith("data:")) {
+			data = line.slice(5).trim();
+		}
+	}
+
+	// Skip non-data events or [DONE] marker
+	if (!data || data === "[DONE]") {
+		return chunk;
+	}
+
+	try {
+		const json = JSON.parse(data);
+
+		// Check if this chunk has reasoning data
+		if (json.choices && json.choices.length > 0) {
+			const choice = json.choices[0];
+			const delta = choice.delta || {};
+
+			// Extract reasoning fields from Copilot response
+			const reasoningText = delta.reasoning_text || json.reasoning_text;
+
+			if (reasoningText) {
+				log("debug", "Found reasoning_text in streaming response");
+
+				// The AI SDK expects "reasoning" to be a plain string, not an object
+				delta.reasoning = reasoningText;
+
+				// Remove the original reasoning_text field to avoid confusion
+				delete delta.reasoning_text;
+				delete json.reasoning_text;
+
+				// Rebuild the SSE event
+				const newData = JSON.stringify(json);
+				return eventType
+					? `event: ${eventType}\ndata: ${newData}`
+					: `data: ${newData}`;
+			}
+		}
+	} catch {
+		// Not valid JSON, return as-is
+	}
+
+	return chunk;
+}
+
+/**
+ * Transform a non-streaming JSON response to include reasoning content
+ */
+function transformNonStreamingResponse(json: any): any {
+	if (!json.choices || json.choices.length === 0) {
+		return json;
+	}
+
+	// Check for reasoning in the response
+	const reasoningText = json.reasoning_text;
+
+	if (reasoningText) {
+		log("debug", "Found reasoning_text in non-streaming response");
+
+		// Add reasoning as a plain string to the message
+		const choice = json.choices[0];
+		if (choice.message) {
+			choice.message.reasoning = reasoningText;
+		}
+
+		// Remove original field
+		delete json.reasoning_text;
+	}
+
+	return json;
+}
+
+export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
+	// Initialize logger with the SDK client
+	setLogger(sdk);
+
 	return {
 		auth: {
 			provider: "github-copilot",
@@ -78,8 +257,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 +274,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. Response parsing extracts reasoning_text/reasoning_opaque fields
 						model.api.npm = "@ai-sdk/github-copilot";
 					}
 				}
 
 				return {
+					baseURL,
 					apiKey: "",
 					async fetch(input, init) {
 						const info = await getAuth();
@@ -113,6 +291,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 +302,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 +317,21 @@ 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;
+									modifiedBody = {
+										...body,
+										thinking_budget: thinkingBudget,
+									};
+									log("info", `Adding thinking_budget for Claude model`, {
+										model: modelId,
+										thinking_budget: thinkingBudget,
+									});
+								}
 							}
 
 							// Responses API
@@ -189,6 +389,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 +404,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 +412,43 @@ 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;
 								}
 
+								// For Claude models with streaming, transform the response to include reasoning
+								if (isClaudeModel && response.ok && response.body) {
+									const contentType =
+										response.headers.get("content-type") || "";
+									const isStreaming = contentType.includes("text/event-stream");
+
+									if (isStreaming) {
+										// Transform streaming response to convert reasoning_text to reasoning content
+										const transformedBody = transformStreamingResponse(
+											response.body,
+										);
+										return new Response(transformedBody, {
+											status: response.status,
+											statusText: response.statusText,
+											headers: response.headers,
+										});
+									} else {
+										// Non-streaming: transform JSON response
+										const json = await response.json();
+										const transformedJson = transformNonStreamingResponse(json);
+										return new Response(JSON.stringify(transformedJson), {
+											status: response.status,
+											statusText: response.statusText,
+											headers: response.headers,
+										});
+									}
+								}
+
 								return response;
 							} catch (error) {
 								lastError = error as Error;
@@ -222,9 +456,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 +645,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/plugins/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/plugins/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/plugins/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/plugins/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;
+}