alchemylab-opencode 1.0.6 → 1.0.8

package/packages/opencode/src/provider/schema.ts

@@ -1,38 +0,0 @@
-import { Schema } from "effect"
-import z from "zod"
-
-import { withStatics } from "@/util/schema"
-
-const providerIdSchema = Schema.String.pipe(Schema.brand("ProviderID"))
-
-export type ProviderID = typeof providerIdSchema.Type
-
-export const ProviderID = providerIdSchema.pipe(
-  withStatics((schema: typeof providerIdSchema) => ({
-    make: (id: string) => schema.makeUnsafe(id),
-    zod: z.string().pipe(z.custom<ProviderID>()),
-    // Well-known providers
-    opencode: schema.makeUnsafe("opencode"),
-    anthropic: schema.makeUnsafe("anthropic"),
-    openai: schema.makeUnsafe("openai"),
-    google: schema.makeUnsafe("google"),
-    googleVertex: schema.makeUnsafe("google-vertex"),
-    githubCopilot: schema.makeUnsafe("github-copilot"),
-    amazonBedrock: schema.makeUnsafe("amazon-bedrock"),
-    azure: schema.makeUnsafe("azure"),
-    openrouter: schema.makeUnsafe("openrouter"),
-    mistral: schema.makeUnsafe("mistral"),
-    gitlab: schema.makeUnsafe("gitlab"),
-  })),
-)
-
-const modelIdSchema = Schema.String.pipe(Schema.brand("ModelID"))
-
-export type ModelID = typeof modelIdSchema.Type
-
-export const ModelID = modelIdSchema.pipe(
-  withStatics((schema: typeof modelIdSchema) => ({
-    make: (id: string) => schema.makeUnsafe(id),
-    zod: z.string().pipe(z.custom<ModelID>()),
-  })),
-)

package/packages/opencode/src/provider/sdk/copilot/README.md

@@ -1,5 +0,0 @@
-This is a temporary package used primarily for GitHub Copilot compatibility.
-
-Avoid making changes to these files unless you only want to affect the Copilot provider.
-
-Also, this should ONLY be used for the Copilot provider.

package/packages/opencode/src/provider/sdk/copilot/chat/convert-to-openai-compatible-chat-messages.ts

@@ -1,170 +0,0 @@
-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/packages/opencode/src/provider/sdk/copilot/chat/get-response-metadata.ts

@@ -1,15 +0,0 @@
-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/packages/opencode/src/provider/sdk/copilot/chat/map-openai-compatible-finish-reason.ts

@@ -1,19 +0,0 @@
-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/packages/opencode/src/provider/sdk/copilot/chat/openai-compatible-api-types.ts

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