alchemylab-opencode 1.0.6 → 1.0.8

package/packages/opencode/src/provider/sdk/copilot/chat/openai-compatible-chat-options.ts

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

@@ -1,44 +0,0 @@
-import type { SharedV3ProviderMetadata } 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<SharedV3ProviderMetadata | 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(): SharedV3ProviderMetadata | undefined
-  }
-}

package/packages/opencode/src/provider/sdk/copilot/chat/openai-compatible-prepare-tools.ts

@@ -1,83 +0,0 @@
-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/packages/opencode/src/provider/sdk/copilot/copilot-provider.ts

@@ -1,100 +0,0 @@
-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"
-import { OpenAIResponsesLanguageModel } from "./responses/openai-responses-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): LanguageModelV3
-  chat(modelId: OpenaiCompatibleModelId): LanguageModelV3
-  responses(modelId: OpenaiCompatibleModelId): LanguageModelV3
-  languageModel(modelId: OpenaiCompatibleModelId): LanguageModelV3
-
-  // embeddingModel(modelId: any): EmbeddingModelV2
-
-  // imageModel(modelId: any): ImageModelV2
-}
-
-/**
- * Create an OpenAI Compatible provider instance.
- */
-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 }) => `${baseURL}${path}`,
-      fetch: options.fetch,
-    })
-  }
-
-  const createLanguageModel = (modelId: OpenaiCompatibleModelId) => createChatModel(modelId)
-
-  const provider = function (modelId: OpenaiCompatibleModelId) {
-    return 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/packages/opencode/src/provider/sdk/copilot/index.ts

@@ -1,2 +0,0 @@
-export { createOpenaiCompatible, openaiCompatible } from "./copilot-provider"
-export type { OpenaiCompatibleProvider, OpenaiCompatibleProviderSettings } from "./copilot-provider"

package/packages/opencode/src/provider/sdk/copilot/openai-compatible-error.ts

@@ -1,27 +0,0 @@
-import { z, type ZodType } 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/packages/opencode/src/provider/sdk/copilot/responses/convert-to-openai-responses-input.ts

@@ -1,335 +0,0 @@
-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"
-import { localShellInputSchema, localShellOutputSchema } from "./tool/local-shell"
-
-/**
- * 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/packages/opencode/src/provider/sdk/copilot/responses/map-openai-responses-finish-reason.ts

@@ -1,22 +0,0 @@
-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/packages/opencode/src/provider/sdk/copilot/responses/openai-config.ts

@@ -1,18 +0,0 @@
-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[]
-}

package/packages/opencode/src/provider/sdk/copilot/responses/openai-error.ts

@@ -1,22 +0,0 @@
-import { z } from "zod/v4"
-import { createJsonErrorResponseHandler } from "@ai-sdk/provider-utils"
-
-export const openaiErrorDataSchema = 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 OpenAIErrorData = z.infer<typeof openaiErrorDataSchema>
-
-export const openaiFailedResponseHandler: any = createJsonErrorResponseHandler({
-  errorSchema: openaiErrorDataSchema,
-  errorToMessage: (data) => data.error.message,
-})