@ultrakit/ultrakit 0.0.0

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 LanguageModelV3CallOptions,
+  type SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider";
+
+export function prepareTools({
+  tools,
+  toolChoice,
+}: {
+  tools: LanguageModelV3CallOptions["tools"];
+  toolChoice?: LanguageModelV3CallOptions["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: SharedV3Warning[];
+} {
+  // when the tools array is empty, change it to undefined to prevent errors:
+  tools = tools?.length ? tools : undefined;
+
+  const toolWarnings: SharedV3Warning[] = [];
+
+  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") {
+      toolWarnings.push({ type: "unsupported", feature: `tool type: ${tool.type}` });
+    } 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,101 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import {
+  type FetchFunction,
+  withoutTrailingSlash,
+  withUserAgentSuffix,
+} from "@ai-sdk/provider-utils";
+import { OpenAICompatibleChatLanguageModel } from "./chat/openai-compatible-chat-language-model.js";
+import { OpenAIResponsesLanguageModel } from "./responses/openai-responses-language-model.js";
+
+// 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): LanguageModelV3;
+  chat(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+  responses(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+  languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV3;
+}
+
+/**
+ * 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 createResponsesModel = (modelId: OpenaiCompatibleModelId) => {
+    return new OpenAIResponsesLanguageModel(modelId, {
+      provider: `${options.name ?? "openai-compatible"}.responses`,
+      headers: getHeaders,
+      url: ({ path, modelId: _modelId }) => `${baseURL}${path}`,
+      fetch: options.fetch,
+    });
+  };
+
+  const createLanguageModel = (modelId: OpenaiCompatibleModelId) => createChatModel(modelId);
+
+  const provider = (modelId: OpenaiCompatibleModelId) => createChatModel(modelId);
+
+  provider.languageModel = createLanguageModel;
+  provider.chat = createChatModel;
+  provider.responses = createResponsesModel;
+
+  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.js";
+export type {
+	OpenaiCompatibleProvider,
+	OpenaiCompatibleProviderSettings,
+} from "./copilot-provider.js";

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/plugin/sdk/copilot/responses/convert-to-openai-responses-input.ts

@@ -0,0 +1,335 @@
+import {
+  type LanguageModelV3Prompt,
+  type LanguageModelV3ToolCallPart,
+  type SharedV3Warning,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
+import { convertToBase64, parseProviderOptions } from "@ai-sdk/provider-utils"
+import { z } from "zod/v4"
+import type { OpenAIResponsesInput, OpenAIResponsesReasoning } from "./openai-responses-api-types.js"
+import { localShellInputSchema, localShellOutputSchema } from "./tool/local-shell.js"
+
+/**
+ * Check if a string is a file ID based on the given prefixes
+ * Returns false if prefixes is undefined (disables file ID detection)
+ */
+function isFileId(data: string, prefixes?: readonly string[]): boolean {
+  if (!prefixes) return false
+  return prefixes.some((prefix) => data.startsWith(prefix))
+}
+
+export async function convertToOpenAIResponsesInput({
+  prompt,
+  systemMessageMode,
+  fileIdPrefixes,
+  store,
+  hasLocalShellTool = false,
+}: {
+  prompt: LanguageModelV3Prompt
+  systemMessageMode: "system" | "developer" | "remove"
+  fileIdPrefixes?: readonly string[]
+  store: boolean
+  hasLocalShellTool?: boolean
+}): Promise<{
+  input: OpenAIResponsesInput
+  warnings: Array<SharedV3Warning>
+}> {
+  const input: OpenAIResponsesInput = []
+  const warnings: Array<SharedV3Warning> = []
+  const processedApprovalIds = new Set<string>()
+
+  for (const { role, content } of prompt) {
+    switch (role) {
+      case "system": {
+        switch (systemMessageMode) {
+          case "system": {
+            input.push({ role: "system", content })
+            break
+          }
+          case "developer": {
+            input.push({ role: "developer", content })
+            break
+          }
+          case "remove": {
+            warnings.push({
+              type: "other",
+              message: "system messages are removed for this model",
+            })
+            break
+          }
+          default: {
+            const _exhaustiveCheck: never = systemMessageMode
+            throw new Error(`Unsupported system message mode: ${_exhaustiveCheck}`)
+          }
+        }
+        break
+      }
+
+      case "user": {
+        input.push({
+          role: "user",
+          content: content.map((part, index) => {
+            switch (part.type) {
+              case "text": {
+                return { type: "input_text", text: part.text }
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType
+
+                  return {
+                    type: "input_image",
+                    ...(part.data instanceof URL
+                      ? { image_url: part.data.toString() }
+                      : typeof part.data === "string" && isFileId(part.data, fileIdPrefixes)
+                        ? { file_id: part.data }
+                        : {
+                            image_url: `data:${mediaType};base64,${convertToBase64(part.data)}`,
+                          }),
+                    detail: part.providerOptions?.openai?.imageDetail,
+                  }
+                } else if (part.mediaType === "application/pdf") {
+                  if (part.data instanceof URL) {
+                    return {
+                      type: "input_file",
+                      file_url: part.data.toString(),
+                    }
+                  }
+                  return {
+                    type: "input_file",
+                    ...(typeof part.data === "string" && isFileId(part.data, fileIdPrefixes)
+                      ? { file_id: part.data }
+                      : {
+                          filename: part.filename ?? `part-${index}.pdf`,
+                          file_data: `data:application/pdf;base64,${convertToBase64(part.data)}`,
+                        }),
+                  }
+                } else {
+                  throw new UnsupportedFunctionalityError({
+                    functionality: `file part media type ${part.mediaType}`,
+                  })
+                }
+              }
+            }
+          }),
+        })
+
+        break
+      }
+
+      case "assistant": {
+        const reasoningMessages: Record<string, OpenAIResponsesReasoning> = {}
+        const toolCallParts: Record<string, LanguageModelV3ToolCallPart> = {}
+
+        for (const part of content) {
+          switch (part.type) {
+            case "text": {
+              input.push({
+                role: "assistant",
+                content: [{ type: "output_text", text: part.text }],
+                id: (part.providerOptions?.openai?.itemId as string) ?? undefined,
+              })
+              break
+            }
+            case "tool-call": {
+              toolCallParts[part.toolCallId] = part
+
+              if (part.providerExecuted) {
+                break
+              }
+
+              if (hasLocalShellTool && part.toolName === "local_shell") {
+                const parsedInput = localShellInputSchema.parse(part.input)
+                input.push({
+                  type: "local_shell_call",
+                  call_id: part.toolCallId,
+                  id: (part.providerOptions?.openai?.itemId as string) ?? undefined,
+                  action: {
+                    type: "exec",
+                    command: parsedInput.action.command,
+                    timeout_ms: parsedInput.action.timeoutMs,
+                    user: parsedInput.action.user,
+                    working_directory: parsedInput.action.workingDirectory,
+                    env: parsedInput.action.env,
+                  },
+                })
+
+                break
+              }
+
+              input.push({
+                type: "function_call",
+                call_id: part.toolCallId,
+                name: part.toolName,
+                arguments: JSON.stringify(part.input),
+                id: (part.providerOptions?.openai?.itemId as string) ?? undefined,
+              })
+              break
+            }
+
+            // assistant tool result parts are from provider-executed tools:
+            case "tool-result": {
+              if (store) {
+                // use item references to refer to tool results from built-in tools
+                input.push({ type: "item_reference", id: part.toolCallId })
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Results for OpenAI tool ${part.toolName} are not sent to the API when store is false`,
+                })
+              }
+
+              break
+            }
+
+            case "reasoning": {
+              const providerOptions = await parseProviderOptions({
+                provider: "copilot",
+                providerOptions: part.providerOptions,
+                schema: openaiResponsesReasoningProviderOptionsSchema,
+              })
+
+              const reasoningId = providerOptions?.itemId
+
+              if (reasoningId != null) {
+                const reasoningMessage = reasoningMessages[reasoningId]
+
+                if (store) {
+                  if (reasoningMessage === undefined) {
+                    // use item references to refer to reasoning (single reference)
+                    input.push({ type: "item_reference", id: reasoningId })
+
+                    // store unused reasoning message to mark id as used
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      summary: [],
+                    }
+                  }
+                } else {
+                  const summaryParts: Array<{
+                    type: "summary_text"
+                    text: string
+                  }> = []
+
+                  if (part.text.length > 0) {
+                    summaryParts.push({
+                      type: "summary_text",
+                      text: part.text,
+                    })
+                  } else if (reasoningMessage !== undefined) {
+                    warnings.push({
+                      type: "other",
+                      message: `Cannot append empty reasoning part to existing reasoning sequence. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                    })
+                  }
+
+                  if (reasoningMessage === undefined) {
+                    reasoningMessages[reasoningId] = {
+                      type: "reasoning",
+                      id: reasoningId,
+                      encrypted_content: providerOptions?.reasoningEncryptedContent,
+                      summary: summaryParts,
+                    }
+                    input.push(reasoningMessages[reasoningId])
+                  } else {
+                    reasoningMessage.summary.push(...summaryParts)
+                  }
+                }
+              } else {
+                warnings.push({
+                  type: "other",
+                  message: `Non-OpenAI reasoning parts are not supported. Skipping reasoning part: ${JSON.stringify(part)}.`,
+                })
+              }
+              break
+            }
+          }
+        }
+
+        break
+      }
+
+      case "tool": {
+        for (const part of content) {
+          if (part.type === "tool-approval-response") {
+            if (processedApprovalIds.has(part.approvalId)) {
+              continue
+            }
+            processedApprovalIds.add(part.approvalId)
+
+            if (store) {
+              input.push({
+                type: "item_reference",
+                id: part.approvalId,
+              })
+            }
+
+            input.push({
+              type: "mcp_approval_response",
+              approval_request_id: part.approvalId,
+              approve: part.approved,
+            })
+            continue
+          }
+          const output = part.output
+
+          if (output.type === "execution-denied") {
+            const approvalId = (output.providerOptions?.openai as { approvalId?: string } | undefined)?.approvalId
+
+            if (approvalId) {
+              continue
+            }
+          }
+
+          if (hasLocalShellTool && part.toolName === "local_shell" && output.type === "json") {
+            input.push({
+              type: "local_shell_call_output",
+              call_id: part.toolCallId,
+              output: localShellOutputSchema.parse(output.value).output,
+            })
+            break
+          }
+
+          let contentValue: string
+          switch (output.type) {
+            case "text":
+            case "error-text":
+              contentValue = output.value
+              break
+            case "execution-denied":
+              contentValue = output.reason ?? "Tool execution denied."
+              break
+            case "content":
+            case "json":
+            case "error-json":
+              contentValue = JSON.stringify(output.value)
+              break
+          }
+
+          input.push({
+            type: "function_call_output",
+            call_id: part.toolCallId,
+            output: contentValue,
+          })
+        }
+
+        break
+      }
+
+      default: {
+        const _exhaustiveCheck: never = role
+        throw new Error(`Unsupported role: ${_exhaustiveCheck}`)
+      }
+    }
+  }
+
+  return { input, warnings }
+}
+
+const openaiResponsesReasoningProviderOptionsSchema = z.object({
+  itemId: z.string().nullish(),
+  reasoningEncryptedContent: z.string().nullish(),
+})
+
+export type OpenAIResponsesReasoningProviderOptions = z.infer<typeof openaiResponsesReasoningProviderOptionsSchema>

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

@@ -0,0 +1,22 @@
+import type { LanguageModelV3FinishReason } from "@ai-sdk/provider"
+
+export function mapOpenAIResponseFinishReason({
+  finishReason,
+  hasFunctionCall,
+}: {
+  finishReason: string | null | undefined
+  // flag that checks if there have been client-side tool calls (not executed by openai)
+  hasFunctionCall: boolean
+}): LanguageModelV3FinishReason["unified"] {
+  switch (finishReason) {
+    case undefined:
+    case null:
+      return hasFunctionCall ? "tool-calls" : "stop"
+    case "max_output_tokens":
+      return "length"
+    case "content_filter":
+      return "content-filter"
+    default:
+      return hasFunctionCall ? "tool-calls" : "other"
+  }
+}

package/dist/template/.opencode/plugin/sdk/copilot/responses/openai-config.ts

@@ -0,0 +1,18 @@
+import type { FetchFunction } from "@ai-sdk/provider-utils"
+
+export type OpenAIConfig = {
+  provider: string
+  url: (options: { modelId: string; path: string }) => string
+  headers: () => Record<string, string | undefined>
+  fetch?: FetchFunction
+  generateId?: () => string
+  /**
+   * File ID prefixes used to identify file IDs in Responses API.
+   * When undefined, all file data is treated as base64 content.
+   *
+   * Examples:
+   * - OpenAI: ['file-'] for IDs like 'file-abc123'
+   * - Azure OpenAI: ['assistant-'] for IDs like 'assistant-abc123'
+   */
+  fileIdPrefixes?: readonly string[]
+}