opencodekit 0.15.20 → 0.16.0

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

@@ -7,8 +7,8 @@
  * 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.
+ * 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";
@@ -101,151 +101,6 @@ function calculateRetryDelay(attempt: number): number {
 	return Math.round(delay);
 }
 
-/**
- * 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);
@@ -264,7 +119,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 					: undefined;
 
 				if (provider && provider.models) {
-					for (const [modelId, model] of Object.entries(provider.models)) {
+					for (const [_modelId, model] of Object.entries(provider.models)) {
 						model.cost = {
 							input: 0,
 							output: 0,
@@ -277,7 +132,7 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 						// 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
+						// 2. The fetch wrapper strips invalid thinking blocks from messages
 						model.api.npm = "@ai-sdk/github-copilot";
 					}
 				}
@@ -323,8 +178,74 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 								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`, {
@@ -332,6 +253,40 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 										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
@@ -421,34 +376,9 @@ export const CopilotAuthPlugin: Plugin = async ({ client: sdk }) => {
 									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,
-										});
-									}
-								}
-
+								// 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;

package/dist/template/.opencode/{plugins → plugin}/sdk/copilot/chat/openai-compatible-chat-language-model.ts

@@ -21,7 +21,7 @@ import {
 	parseProviderOptions,
 	postJsonToApi,
 } from "@ai-sdk/provider-utils";
-import { z } from "zod";
+import { z } from "zod/v4";
 import {
 	type ProviderErrorStructure,
 	defaultOpenAICompatibleErrorStructure,
@@ -397,6 +397,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 						controller.enqueue({ type: "stream-start", warnings });
 					},
 
+					// TODO we lost type safety on Chunk, most likely due to the error schema. MUST FIX
 					transform(chunk, controller) {
 						// Emit raw chunk if requested (before anything else)
 						if (options.includeRawChunks) {
@@ -512,6 +513,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 
 						if (delta.content) {
 							// If reasoning was active and we're starting text, end reasoning first
+							// This handles the case where reasoning_opaque and content come in the same chunk
 							if (isActiveReasoning && !isActiveText) {
 								controller.enqueue({
 									type: "reasoning-end",
@@ -537,6 +539,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 
 						if (delta.tool_calls != null) {
 							// If reasoning was active and we're starting tool calls, end reasoning first
+							// This handles the case where reasoning goes directly to tool calls with no content
 							if (isActiveReasoning) {
 								controller.enqueue({
 									type: "reasoning-end",
@@ -597,6 +600,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 										}
 
 										// check if tool call is complete
+										// (some providers send the full tool call in one chunk):
 										if (isParsableJson(toolCall.function.arguments)) {
 											controller.enqueue({
 												type: "tool-input-end",
@@ -663,6 +667,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 							controller.enqueue({
 								type: "reasoning-end",
 								id: "reasoning-0",
+								// Include reasoning_opaque for Copilot multi-turn reasoning
 								providerMetadata: reasoningOpaque
 									? { copilot: { reasoningOpaque } }
 									: undefined,
@@ -692,6 +697,7 @@ export class OpenAICompatibleChatLanguageModel implements LanguageModelV2 {
 
 						const providerMetadata: SharedV2ProviderMetadata = {
 							[providerOptionsName]: {},
+							// Include reasoning_opaque for Copilot multi-turn reasoning
 							...(reasoningOpaque ? { copilot: { reasoningOpaque } } : {}),
 							...metadataExtractor?.buildMetadata(),
 						};
@@ -752,6 +758,7 @@ const openaiCompatibleTokenUsageSchema = z
 	.nullish();
 
 // limited version of the schema, focussed on what is needed for the implementation
+// this approach limits breakages when the API changes and increases efficiency
 const OpenAICompatibleChatResponseSchema = z.object({
 	id: z.string().nullish(),
 	created: z.number().nullish(),
@@ -783,7 +790,10 @@ const OpenAICompatibleChatResponseSchema = z.object({
 });
 
 // limited version of the schema, focussed on what is needed for the implementation
-const createOpenAICompatibleChatChunkSchema = <ERROR_SCHEMA extends z.ZodType>(
+// this approach limits breakages when the API changes and increases efficiency
+const createOpenAICompatibleChatChunkSchema = <
+	ERROR_SCHEMA extends z.core.$ZodType,
+>(
 	errorSchema: ERROR_SCHEMA,
 ) =>
 	z.union([

package/dist/template/.opencode/{plugins → plugin}/sdk/copilot/chat/openai-compatible-chat-options.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v4";
 
 export type OpenAICompatibleChatModelId = string;
 

package/dist/template/.opencode/{plugins → plugin}/sdk/copilot/openai-compatible-error.ts

@@ -1,4 +1,4 @@
-import { type ZodType, z } from "zod";
+import { type ZodType, z } from "zod/v4";
 
 export const openaiCompatibleErrorDataSchema = z.object({
 	error: z.object({

package/dist/template/.opencode/{plugins → plugin}/swarm-enforcer.ts

@@ -71,13 +71,6 @@ function isIgnoredPath(repoDir: string, filePath: string): boolean {
 	);
 }
 
-function summarizeIssues(issues: BeadsIssue[], limit = 5): string {
-	return issues
-		.slice(0, limit)
-		.map((i) => `${i.id}${i.title ? `: ${i.title}` : ""}`)
-		.join("\n");
-}
-
 async function readIssuesJsonl(repoDir: string): Promise<BeadsIssue[]> {
 	const issuesPath = path.join(repoDir, BEADS_DIR, ISSUES_FILE);
 
@@ -135,27 +128,29 @@ function buildNudge(params: {
 	if (inProgress.length === 0) {
 		return `
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-⚡ [SWARM PROTOCOL]
+⚡ [BEADS PROTOCOL]
 
-Beads is the swarm board. Before any code changes:
+Pick a task before code changes:
 
-1) Pick a task: \`bd ready\` (or \`bd list\`)
-2) Inspect: \`bd show <id>\`
-3) Claim: \`bd update <id> --status=in_progress\`
+1) \`bd ready\` → find unblocked work
+2) \`bd show <id>\` → inspect task
+3) \`bd update <id> --status=in_progress\` → claim it
 
-Then proceed with work and collect verification evidence.
+For parallel work, use the Task tool to spawn subagents.
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 `;
 	}
 
 	if (missingSpec.length > 0) {
+		const ids = missingSpec
+			.slice(0, 3)
+			.map((i) => i.id)
+			.join(", ");
 		return `
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-⚡ [SWARM PROTOCOL]
-
-In-progress Beads exist, but \`spec.md\` is missing for:
+⚡ [BEADS PROTOCOL]
 
-${summarizeIssues(missingSpec)}
+Missing \`spec.md\` for: ${ids}
 
 Create \`.beads/artifacts/<id>/spec.md\` before implementation.
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -232,7 +227,7 @@ export const SwarmEnforcer: Plugin = async ({ client, directory }) => {
 			if (!nudge) return;
 
 			parts.push({
-				id: `swarm-nudge-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+				id: `beads-nudge-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
 				sessionID,
 				messageID: messageID || "",
 				type: "text",
@@ -257,8 +252,8 @@ export const SwarmEnforcer: Plugin = async ({ client, directory }) => {
 
 			if (cachedInProgress.length === 0) {
 				await showToast(
-					"Swarm: No task claimed",
-					"Beads is the board. Claim a task before code edits (bd ready/show/update).",
+					"Beads: No task claimed",
+					"Run bd ready/show/update to claim a task before edits.",
 					"warning",
 				);
 				return;
@@ -266,7 +261,7 @@ export const SwarmEnforcer: Plugin = async ({ client, directory }) => {
 
 			if (cachedMissingSpec.length > 0) {
 				await showToast(
-					"Swarm: Missing spec.md",
+					"Beads: Missing spec.md",
 					`Create .beads/artifacts/<id>/spec.md for: ${cachedMissingSpec
 						.slice(0, 3)
 						.map((i) => i.id)
@@ -286,8 +281,8 @@ export const SwarmEnforcer: Plugin = async ({ client, directory }) => {
 				.map((i) => i.id)
 				.join(", ");
 			await showToast(
-				"Swarm: Work still in progress",
-				`In-progress Beads: ${list}. Close with bd close + bd sync when done.`,
+				"Beads: Work still in progress",
+				`In-progress: ${list}. Close with bd close + bd sync when done.`,
 				"info",
 			);
 		},

package/dist/template/.opencode/{skills → skill}/beads/SKILL.md

@@ -497,6 +497,47 @@ bd_inbox({ unread: true });
 bd_claim(); // Gets frontend task that was waiting on API
 ```
 
+## Multi-Agent Coordination (Swarm Mode)
+
+For parallel execution with multiple subagents, use the **beads-bridge** skill:
+
+```typescript
+skill({ name: "beads-bridge" });
+```
+
+**beads-bridge** provides:
+
+- `beads-sync` - Sync Beads tasks to OpenCode todos for subagent visibility
+- `swarm-monitor` - Real-time progress tracking and visualization
+- `swarm-plan` - Task classification and dependency analysis
+- `swarm-delegate` - Create delegation packets for workers
+
+**When to use beads vs beads-bridge:**
+
+| Scenario                       | Use                              |
+| ------------------------------ | -------------------------------- |
+| Single agent, linear work      | `beads` skill only               |
+| Multiple agents in parallel    | `beads-bridge` + `beads`         |
+| Need subagents to see tasks    | `beads-bridge` (beads-sync push) |
+| Track worker progress visually | `beads-bridge` (swarm-monitor)   |
+
+**Example swarm workflow:**
+
+```typescript
+// 1. Push beads to OpenCode todos (subagents can see via todoread)
+beads_sync({ operation: "push" });
+
+// 2. Spawn workers in parallel using Task tool
+Task({ subagent_type: "general", description: "Worker 1", prompt: "..." });
+Task({ subagent_type: "general", description: "Worker 2", prompt: "..." });
+
+// 3. Monitor progress
+swarm_monitor({ operation: "render_block", team_name: "my-swarm" });
+
+// 4. Pull completed work back to beads
+beads_sync({ operation: "pull" });
+```
+
 ## Rules
 
 1. **Always `bd_init()` first** - Required before any other bd\_\* tool