@ultrakit/ultrakit 0.0.0

package/dist/template/.opencode/plugin/sdk/copilot/chat/convert-to-openai-compatible-chat-messages.ts

@@ -0,0 +1,172 @@
+import {
+  type LanguageModelV3Prompt,
+  type SharedV3ProviderOptions,
+  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?: SharedV3ProviderOptions }) {
+  return message?.providerOptions?.copilot ?? {};
+}
+
+export function convertToOpenAICompatibleChatMessages(
+  prompt: LanguageModelV3Prompt,
+): OpenAICompatibleChatPrompt {
+  const messages: OpenAICompatibleChatPrompt = [];
+  for (const { role, content, ...message } of prompt) {
+    const metadata = getOpenAIMetadata({ ...message });
+    switch (role) {
+      case "system": {
+        messages.push({
+          role: "system",
+          content: 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": {
+              if (part.text) 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: reasoningOpaque ? reasoningText : undefined,
+          reasoning_opaque: reasoningOpaque,
+          ...metadata,
+        });
+
+        break;
+      }
+
+      case "tool": {
+        for (const toolResponse of content) {
+          if (toolResponse.type === "tool-approval-response") {
+            continue;
+          }
+          const output = toolResponse.output;
+
+          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;
+          }
+
+          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/plugin/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/plugin/sdk/copilot/chat/map-openai-compatible-finish-reason.ts

@@ -0,0 +1,19 @@
+import type { LanguageModelV3FinishReason } from "@ai-sdk/provider";
+
+export function mapOpenAICompatibleFinishReason(
+  finishReason: string | null | undefined,
+): LanguageModelV3FinishReason["unified"] {
+  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 "other";
+  }
+}

package/dist/template/.opencode/plugin/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;
+}