@neurocode-ai/core 1.18.8

package/src/github-copilot/README.md

@@ -0,0 +1,5 @@
+This is a temporary package used primarily for GitHub Copilot compatibility.
+
+These DO NOT apply for openai-compatible providers or majority of providers supporting completions/responses apis. THIS IS ONLY FOR GITHUB COPILOT!!!
+
+Avoid making edits to these files

package/src/github-copilot/chat/convert-to-openai-compatible-chat-messages.ts

@@ -0,0 +1,170 @@
+import {
+  type LanguageModelV3Prompt,
+  type SharedV3ProviderOptions,
+  UnsupportedFunctionalityError,
+} from "@ai-sdk/provider"
+import type { OpenAICompatibleChatPrompt } from "./openai-compatible-api-types"
+import { convertToBase64 } from "@ai-sdk/provider-utils"
+
+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", text: part.text, ...partMetadata }
+              }
+              case "file": {
+                if (part.mediaType.startsWith("image/")) {
+                  const mediaType = part.mediaType === "image/*" ? "image/jpeg" : part.mediaType
+
+                  return {
+                    type: "image_url",
+                    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/src/github-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/src/github-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/src/github-copilot/chat/openai-compatible-api-types.ts

@@ -0,0 +1,64 @@
+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
+}