opencodekit 0.15.19 → 0.15.21

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

@@ -0,0 +1,30 @@
+import { z } from "zod/v4";
+
+export type OpenAICompatibleChatModelId = string;
+
+export const openaiCompatibleProviderOptions = z.object({
+	/**
+	 * A unique identifier representing your end-user, which can help the provider to
+	 * monitor and detect abuse.
+	 */
+	user: z.string().optional(),
+
+	/**
+	 * Reasoning effort for reasoning models. Defaults to `medium`.
+	 */
+	reasoningEffort: z.string().optional(),
+
+	/**
+	 * Controls the verbosity of the generated text. Defaults to `medium`.
+	 */
+	textVerbosity: z.string().optional(),
+
+	/**
+	 * Copilot thinking_budget used for Anthropic models.
+	 */
+	thinking_budget: z.number().optional(),
+});
+
+export type OpenAICompatibleProviderOptions = z.infer<
+	typeof openaiCompatibleProviderOptions
+>;

package/dist/template/.opencode/plugin/sdk/copilot/chat/openai-compatible-metadata-extractor.ts

@@ -0,0 +1,48 @@
+import type { SharedV2ProviderMetadata } from "@ai-sdk/provider";
+
+/**
+Extracts provider-specific metadata from API responses.
+Used to standardize metadata handling across different LLM providers while allowing
+provider-specific metadata to be captured.
+*/
+export type MetadataExtractor = {
+	/**
+	 * Extracts provider metadata from a complete, non-streaming response.
+	 *
+	 * @param parsedBody - The parsed response JSON body from the provider's API.
+	 *
+	 * @returns Provider-specific metadata or undefined if no metadata is available.
+	 *          The metadata should be under a key indicating the provider id.
+	 */
+	extractMetadata: ({
+		parsedBody,
+	}: {
+		parsedBody: unknown;
+	}) => Promise<SharedV2ProviderMetadata | undefined>;
+
+	/**
+	 * Creates an extractor for handling streaming responses. The returned object provides
+	 * methods to process individual chunks and build the final metadata from the accumulated
+	 * stream data.
+	 *
+	 * @returns An object with methods to process chunks and build metadata from a stream
+	 */
+	createStreamExtractor: () => {
+		/**
+		 * Process an individual chunk from the stream. Called for each chunk in the response stream
+		 * to accumulate metadata throughout the streaming process.
+		 *
+		 * @param parsedChunk - The parsed JSON response chunk from the provider's API
+		 */
+		processChunk(parsedChunk: unknown): void;
+
+		/**
+		 * Builds the metadata object after all chunks have been processed.
+		 * Called at the end of the stream to generate the complete provider metadata.
+		 *
+		 * @returns Provider-specific metadata or undefined if no metadata is available.
+		 *          The metadata should be under a key indicating the provider id.
+		 */
+		buildMetadata(): SharedV2ProviderMetadata | undefined;
+	};
+};

package/dist/template/.opencode/plugin/sdk/copilot/chat/openai-compatible-prepare-tools.ts

@@ -0,0 +1,92 @@
+import {
+	type LanguageModelV2CallOptions,
+	type LanguageModelV2CallWarning,
+	UnsupportedFunctionalityError,
+} from "@ai-sdk/provider";
+
+export function prepareTools({
+	tools,
+	toolChoice,
+}: {
+	tools: LanguageModelV2CallOptions["tools"];
+	toolChoice?: LanguageModelV2CallOptions["toolChoice"];
+}): {
+	tools:
+		| undefined
+		| Array<{
+				type: "function";
+				function: {
+					name: string;
+					description: string | undefined;
+					parameters: unknown;
+				};
+		  }>;
+	toolChoice:
+		| { type: "function"; function: { name: string } }
+		| "auto"
+		| "none"
+		| "required"
+		| undefined;
+	toolWarnings: LanguageModelV2CallWarning[];
+} {
+	// when the tools array is empty, change it to undefined to prevent errors:
+	tools = tools?.length ? tools : undefined;
+
+	const toolWarnings: LanguageModelV2CallWarning[] = [];
+
+	if (tools == null) {
+		return { tools: undefined, toolChoice: undefined, toolWarnings };
+	}
+
+	const openaiCompatTools: Array<{
+		type: "function";
+		function: {
+			name: string;
+			description: string | undefined;
+			parameters: unknown;
+		};
+	}> = [];
+
+	for (const tool of tools) {
+		if (tool.type === "provider-defined") {
+			toolWarnings.push({ type: "unsupported-tool", tool });
+		} else {
+			openaiCompatTools.push({
+				type: "function",
+				function: {
+					name: tool.name,
+					description: tool.description,
+					parameters: tool.inputSchema,
+				},
+			});
+		}
+	}
+
+	if (toolChoice == null) {
+		return { tools: openaiCompatTools, toolChoice: undefined, toolWarnings };
+	}
+
+	const type = toolChoice.type;
+
+	switch (type) {
+		case "auto":
+		case "none":
+		case "required":
+			return { tools: openaiCompatTools, toolChoice: type, toolWarnings };
+		case "tool":
+			return {
+				tools: openaiCompatTools,
+				toolChoice: {
+					type: "function",
+					function: { name: toolChoice.toolName },
+				},
+				toolWarnings,
+			};
+		default: {
+			const _exhaustiveCheck: never = type;
+			throw new UnsupportedFunctionalityError({
+				functionality: `tool choice type: ${_exhaustiveCheck}`,
+			});
+		}
+	}
+}

package/dist/template/.opencode/plugin/sdk/copilot/copilot-provider.ts

@@ -0,0 +1,94 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import {
+	type FetchFunction,
+	withUserAgentSuffix,
+	withoutTrailingSlash,
+} from "@ai-sdk/provider-utils";
+import { OpenAICompatibleChatLanguageModel } from "./chat/openai-compatible-chat-language-model";
+
+// Import the version or define it
+const VERSION = "0.1.0";
+
+export type OpenaiCompatibleModelId = string;
+
+export interface OpenaiCompatibleProviderSettings {
+	/**
+	 * API key for authenticating requests.
+	 */
+	apiKey?: string;
+
+	/**
+	 * Base URL for the OpenAI Compatible API calls.
+	 */
+	baseURL?: string;
+
+	/**
+	 * Name of the provider.
+	 */
+	name?: string;
+
+	/**
+	 * Custom headers to include in the requests.
+	 */
+	headers?: Record<string, string>;
+
+	/**
+	 * Custom fetch implementation.
+	 */
+	fetch?: FetchFunction;
+}
+
+export interface OpenaiCompatibleProvider {
+	(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+	chat(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+	languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV2;
+}
+
+/**
+ * Create an OpenAI Compatible provider instance for GitHub Copilot.
+ * This custom provider handles Claude reasoning tokens (thinking_budget).
+ */
+export function createOpenaiCompatible(
+	options: OpenaiCompatibleProviderSettings = {},
+): OpenaiCompatibleProvider {
+	const baseURL = withoutTrailingSlash(
+		options.baseURL ?? "https://api.openai.com/v1",
+	);
+
+	if (!baseURL) {
+		throw new Error("baseURL is required");
+	}
+
+	// Merge headers: defaults first, then user overrides
+	const headers = {
+		// Default OpenAI Compatible headers (can be overridden by user)
+		...(options.apiKey && { Authorization: `Bearer ${options.apiKey}` }),
+		...options.headers,
+	};
+
+	const getHeaders = () =>
+		withUserAgentSuffix(headers, `ai-sdk/openai-compatible/${VERSION}`);
+
+	const createChatModel = (modelId: OpenaiCompatibleModelId) => {
+		return new OpenAICompatibleChatLanguageModel(modelId, {
+			provider: `${options.name ?? "openai-compatible"}.chat`,
+			headers: getHeaders,
+			url: ({ path }) => `${baseURL}${path}`,
+			fetch: options.fetch,
+		});
+	};
+
+	const createLanguageModel = (modelId: OpenaiCompatibleModelId) =>
+		createChatModel(modelId);
+
+	const provider = (modelId: OpenaiCompatibleModelId) =>
+		createChatModel(modelId);
+
+	provider.languageModel = createLanguageModel;
+	provider.chat = createChatModel;
+
+	return provider as OpenaiCompatibleProvider;
+}
+
+// Default OpenAI Compatible provider instance
+export const openaiCompatible = createOpenaiCompatible();

package/dist/template/.opencode/plugin/sdk/copilot/index.ts

@@ -0,0 +1,5 @@
+export { createOpenaiCompatible, openaiCompatible } from "./copilot-provider";
+export type {
+	OpenaiCompatibleProvider,
+	OpenaiCompatibleProviderSettings,
+} from "./copilot-provider";

package/dist/template/.opencode/plugin/sdk/copilot/openai-compatible-error.ts

@@ -0,0 +1,30 @@
+import { type ZodType, z } from "zod/v4";
+
+export const openaiCompatibleErrorDataSchema = z.object({
+	error: z.object({
+		message: z.string(),
+
+		// The additional information below is handled loosely to support
+		// OpenAI-compatible providers that have slightly different error
+		// responses:
+		type: z.string().nullish(),
+		param: z.any().nullish(),
+		code: z.union([z.string(), z.number()]).nullish(),
+	}),
+});
+
+export type OpenAICompatibleErrorData = z.infer<
+	typeof openaiCompatibleErrorDataSchema
+>;
+
+export type ProviderErrorStructure<T> = {
+	errorSchema: ZodType<T>;
+	errorToMessage: (error: T) => string;
+	isRetryable?: (response: Response, error?: T) => boolean;
+};
+
+export const defaultOpenAICompatibleErrorStructure: ProviderErrorStructure<OpenAICompatibleErrorData> =
+	{
+		errorSchema: openaiCompatibleErrorDataSchema,
+		errorToMessage: (data) => data.error.message,
+	};

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