opencodekit 0.15.19 → 0.15.20

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+
+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/plugins/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/plugins/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/plugins/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/plugins/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/plugins/sdk/copilot/openai-compatible-error.ts

@@ -0,0 +1,30 @@
+import { type ZodType, z } from "zod";
+
+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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencodekit",
-	"version": "0.15.19",
+	"version": "0.15.20",
 	"description": "CLI tool for bootstrapping and managing OpenCodeKit projects",
 	"keywords": ["agents", "cli", "mcp", "opencode", "opencodekit", "template"],
 	"license": "MIT",