chad-code 1.3.1 → 1.3.3

package/src/provider/provider.ts

@@ -1,516 +0,0 @@
-import z from "zod"
-import { Config } from "../config/config"
-import { mapValues, mergeDeep } from "remeda"
-import { NoSuchModelError, type Provider as SDK } from "ai"
-import { Log } from "../util/log"
-import { NamedError } from "@opencode-ai/util/error"
-import { Env } from "../env"
-import { Instance } from "../project/instance"
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible"
-import type { LanguageModelV2 } from "@ai-sdk/provider"
-import { Auth } from "../auth"
-
-export namespace Provider {
-  const log = Log.create({ service: "provider" })
-
-  // Corethink API configuration
-  const CORETHINK_API_URL = "https://api.corethink.ai/v1/code"
-  const CORETHINK_ENV_KEY = "CORETHINK_API_KEY"
-
-  export const Model = z
-    .object({
-      id: z.string(),
-      providerID: z.string(),
-      api: z.object({
-        id: z.string(),
-        url: z.string(),
-        npm: z.string(),
-      }),
-      name: z.string(),
-      family: z.string().optional(),
-      capabilities: z.object({
-        temperature: z.boolean(),
-        reasoning: z.boolean(),
-        attachment: z.boolean(),
-        toolcall: z.boolean(),
-        input: z.object({
-          text: z.boolean(),
-          audio: z.boolean(),
-          image: z.boolean(),
-          video: z.boolean(),
-          pdf: z.boolean(),
-        }),
-        output: z.object({
-          text: z.boolean(),
-          audio: z.boolean(),
-          image: z.boolean(),
-          video: z.boolean(),
-          pdf: z.boolean(),
-        }),
-        interleaved: z.union([
-          z.boolean(),
-          z.object({
-            field: z.enum(["reasoning_content", "reasoning_details"]),
-          }),
-        ]),
-      }),
-      cost: z.object({
-        input: z.number(),
-        output: z.number(),
-        cache: z.object({
-          read: z.number(),
-          write: z.number(),
-        }),
-        experimentalOver200K: z
-          .object({
-            input: z.number(),
-            output: z.number(),
-            cache: z.object({
-              read: z.number(),
-              write: z.number(),
-            }),
-          })
-          .optional(),
-      }),
-      limit: z.object({
-        context: z.number(),
-        output: z.number(),
-      }),
-      status: z.enum(["alpha", "beta", "deprecated", "active"]),
-      options: z.record(z.string(), z.any()),
-      headers: z.record(z.string(), z.string()),
-      release_date: z.string(),
-      variants: z.record(z.string(), z.record(z.string(), z.any())).optional(),
-    })
-    .meta({
-      ref: "Model",
-    })
-  export type Model = z.infer<typeof Model>
-
-  export const Info = z
-    .object({
-      id: z.string(),
-      name: z.string(),
-      source: z.enum(["env", "config", "custom", "api"]),
-      env: z.string().array(),
-      key: z.string().optional(),
-      options: z.record(z.string(), z.any()),
-      models: z.record(z.string(), Model),
-    })
-    .meta({
-      ref: "Provider",
-    })
-  export type Info = z.infer<typeof Info>
-
-  // Stub function for compatibility with server.ts
-  export function fromModelsDevProvider(provider: any): Info {
-    return {
-      id: provider.id,
-      source: "custom",
-      name: provider.name,
-      env: provider.env ?? [],
-      options: {},
-      models: {},
-    }
-  }
-
-  // Create the corethink model definition
-  function createCorethinkModel(): Model {
-    return {
-      id: "corethink",
-      providerID: "corethink",
-      name: "Chadcode",
-      api: {
-        id: "corethink",
-        url: CORETHINK_API_URL,
-        npm: "@ai-sdk/openai-compatible",
-      },
-      status: "active",
-      headers: {},
-      options: {},
-      cost: {
-        input: 1.5, // $1.50 per 1M input tokens
-        output: 2.0, // $2.00 per 1M output tokens
-        cache: {
-          read: 0,
-          write: 0,
-        },
-      },
-      limit: {
-        context: 200000,
-        output: 8000,
-      },
-      capabilities: {
-        temperature: true,
-        reasoning: false,
-        attachment: true,
-        toolcall: true,
-        input: {
-          text: true,
-          audio: false,
-          image: true,
-          video: false,
-          pdf: true,
-        },
-        output: {
-          text: true,
-          audio: false,
-          image: false,
-          video: false,
-          pdf: false,
-        },
-        interleaved: false,
-      },
-      release_date: "2025-01-01",
-      variants: {},
-    }
-  }
-
-  // Create the corethink provider definition
-  function createCorethinkProvider(apiKey?: string): Info {
-    return {
-      id: "corethink",
-      name: "Chadcode",
-      source: apiKey ? "env" : "config",
-      env: [CORETHINK_ENV_KEY],
-      key: apiKey,
-      options: {
-        baseURL: CORETHINK_API_URL,
-      },
-      models: {
-        corethink: createCorethinkModel(),
-      },
-    }
-  }
-
-  const state = Instance.state(async () => {
-    using _ = log.time("state")
-    const config = await Config.get()
-
-    const providers: { [providerID: string]: Info } = {}
-    const languages = new Map<string, LanguageModelV2>()
-    const sdk = new Map<number, SDK>()
-
-    log.info("init")
-
-    // Get API key from multiple sources (in order of priority):
-    // 1. Environment variable
-    // 2. Auth storage (from UI input)
-    // 3. Config file
-    let apiKey = Env.get(CORETHINK_ENV_KEY)
-
-    // Check auth storage if no env var
-    if (!apiKey) {
-      const authData = await Auth.get("corethink")
-      if (authData?.type === "api") {
-        apiKey = authData.key
-        log.info("found API key in auth storage")
-      }
-    }
-
-    if (!apiKey) {
-      log.warn("CORETHINK_API_KEY not set - corethink provider will not be available")
-    }
-
-    // Create the corethink provider
-    const corethinkProvider = createCorethinkProvider(apiKey)
-
-    // Apply any config overrides
-    if (config.provider?.corethink) {
-      const configProvider = config.provider.corethink
-      if (configProvider.options) {
-        corethinkProvider.options = mergeDeep(corethinkProvider.options, configProvider.options)
-      }
-      if (configProvider.options?.apiKey) {
-        corethinkProvider.key = configProvider.options.apiKey
-      }
-    }
-
-    // Only add provider if we have an API key
-    if (corethinkProvider.key) {
-      providers["corethink"] = corethinkProvider
-      log.info("found", { providerID: "corethink" })
-    }
-
-    return {
-      models: languages,
-      providers,
-      sdk,
-    }
-  })
-
-  export async function list() {
-    return state().then((state) => state.providers)
-  }
-
-  async function getSDK(model: Model) {
-    try {
-      using _ = log.time("getSDK", {
-        providerID: model.providerID,
-      })
-      const s = await state()
-      const provider = s.providers[model.providerID]
-      const options: Record<string, any> = { ...provider.options }
-
-      // Enable usage tracking for OpenAI-compatible providers
-      options["includeUsage"] = true
-
-      if (!options["baseURL"]) options["baseURL"] = model.api.url
-      if (options["apiKey"] === undefined && provider.key) options["apiKey"] = provider.key
-      if (model.headers) {
-        options["headers"] = {
-          ...options["headers"],
-          ...model.headers,
-        }
-      }
-
-      const key = Bun.hash.xxHash32(JSON.stringify({ npm: model.api.npm, options }))
-      const existing = s.sdk.get(key)
-      if (existing) return existing
-
-      options["fetch"] = async (input: any, init?: BunFetchRequestInit) => {
-        const opts = init ?? {}
-
-        if (options["timeout"] !== undefined && options["timeout"] !== null) {
-          const signals: AbortSignal[] = []
-          if (opts.signal) signals.push(opts.signal)
-          if (options["timeout"] !== false) signals.push(AbortSignal.timeout(options["timeout"]))
-
-          const combined = signals.length > 1 ? AbortSignal.any(signals) : signals[0]
-
-          opts.signal = combined
-        }
-
-        // Clean up messages for API compatibility
-        if (opts.body) {
-          try {
-            const bodyStr = typeof opts.body === "string" ? opts.body : new TextDecoder().decode(opts.body as ArrayBuffer)
-            const parsed = JSON.parse(bodyStr)
-
-            if (parsed.messages) {
-              for (const msg of parsed.messages) {
-                // When assistant has tool_calls, set empty content to null (some APIs require this)
-                if (msg.role === "assistant" && msg.tool_calls && msg.tool_calls.length > 0) {
-                  if (msg.content && msg.content.trim() === "") {
-                    msg.content = null
-                  }
-                }
-              }
-              opts.body = JSON.stringify(parsed)
-            }
-          } catch {
-            // Ignore parse errors
-          }
-        }
-
-        const response = await fetch(input, {
-          ...opts,
-          // @ts-ignore see here: https://github.com/oven-sh/bun/issues/16682
-          timeout: false,
-        })
-
-
-        // For streaming responses, we need to filter out usage-only events that CoreThink sends
-        // These events don't have 'choices' and cause validation errors in the AI SDK
-        const contentType = response.headers.get("content-type") || ""
-        if (contentType.includes("text/event-stream") && response.body) {
-          const reader = response.body.getReader()
-          const encoder = new TextEncoder()
-
-          const transformedStream = new ReadableStream({
-            async start(controller) {
-              const decoder = new TextDecoder()
-              let buffer = ""
-
-              while (true) {
-                const { done, value } = await reader.read()
-                if (done) {
-                  controller.close()
-                  break
-                }
-
-                buffer += decoder.decode(value, { stream: true })
-                const lines = buffer.split("\n")
-                buffer = lines.pop() || ""
-
-                for (const line of lines) {
-                  const trimmed = line.trim()
-                  if (!trimmed) {
-                    controller.enqueue(encoder.encode("\n"))
-                    continue
-                  }
-
-                  if (trimmed.startsWith("data:")) {
-                    const data = trimmed.slice(5).trim()
-                    if (data === "[DONE]") {
-                      controller.enqueue(encoder.encode(line + "\n"))
-                      continue
-                    }
-
-                    try {
-                      const parsed = JSON.parse(data)
-                      // Skip events that only have usage (no choices) - these cause validation errors
-                      if (parsed.usage && !parsed.choices) {
-                        continue
-                      }
-                      // CoreThink uses 'reasoning' field - map it to 'content' for compatibility
-                      if (parsed.choices?.[0]?.delta?.reasoning && !parsed.choices?.[0]?.delta?.content) {
-                        parsed.choices[0].delta.content = parsed.choices[0].delta.reasoning
-                        delete parsed.choices[0].delta.reasoning
-                        controller.enqueue(encoder.encode("data: " + JSON.stringify(parsed) + "\n"))
-                        continue
-                      }
-                    } catch {
-                      // If JSON parsing fails, pass through as-is
-                    }
-                  }
-
-                  controller.enqueue(encoder.encode(line + "\n"))
-                }
-              }
-            },
-          })
-
-          return new Response(transformedStream, {
-            status: response.status,
-            statusText: response.statusText,
-            headers: response.headers,
-          })
-        }
-
-        return response
-      }
-
-      log.info("creating corethink provider", { providerID: model.providerID })
-      const loaded = createOpenAICompatible({
-        name: model.providerID,
-        baseURL: options["baseURL"],
-        apiKey: options["apiKey"],
-        headers: options["headers"],
-        fetch: options["fetch"],
-      })
-      s.sdk.set(key, loaded)
-      return loaded as SDK
-    } catch (e) {
-      throw new InitError({ providerID: model.providerID }, { cause: e })
-    }
-  }
-
-  export async function getProvider(providerID: string) {
-    return state().then((s) => s.providers[providerID])
-  }
-
-  export async function getModel(providerID: string, modelID: string) {
-    const s = await state()
-    const provider = s.providers[providerID]
-    if (!provider) {
-      throw new ModelNotFoundError({ providerID, modelID, suggestions: ["corethink"] })
-    }
-
-    const info = provider.models[modelID]
-    if (!info) {
-      const availableModels = Object.keys(provider.models)
-      throw new ModelNotFoundError({ providerID, modelID, suggestions: availableModels })
-    }
-    return info
-  }
-
-  export async function getLanguage(model: Model): Promise<LanguageModelV2> {
-    const s = await state()
-    const key = `${model.providerID}/${model.id}`
-    if (s.models.has(key)) return s.models.get(key)!
-
-    const sdk = await getSDK(model)
-
-    try {
-      const language = sdk.languageModel(model.api.id) as LanguageModelV2
-      s.models.set(key, language)
-      return language
-    } catch (e) {
-      if (e instanceof NoSuchModelError)
-        throw new ModelNotFoundError(
-          {
-            modelID: model.id,
-            providerID: model.providerID,
-          },
-          { cause: e },
-        )
-      throw e
-    }
-  }
-
-  export async function closest(providerID: string, query: string[]) {
-    const s = await state()
-    const provider = s.providers[providerID]
-    if (!provider) return undefined
-    for (const item of query) {
-      for (const modelID of Object.keys(provider.models)) {
-        if (modelID.includes(item))
-          return {
-            providerID,
-            modelID,
-          }
-      }
-    }
-  }
-
-  export async function getSmallModel(providerID: string) {
-    const cfg = await Config.get()
-
-    if (cfg.small_model) {
-      const parsed = parseModel(cfg.small_model)
-      return getModel(parsed.providerID, parsed.modelID)
-    }
-
-    // For corethink, just return the main model
-    const provider = await state().then((state) => state.providers[providerID])
-    if (provider && provider.models["corethink"]) {
-      return provider.models["corethink"]
-    }
-
-    return undefined
-  }
-
-  export function sort(models: Model[]) {
-    // For corethink, just return as-is since there's only one model
-    return models
-  }
-
-  export async function defaultModel() {
-    const cfg = await Config.get()
-    if (cfg.model) return parseModel(cfg.model)
-
-    const providers = await list()
-    const provider = providers["corethink"]
-    if (!provider) throw new Error("Chad provider not found. Please set CORETHINK_API_KEY environment variable.")
-
-    return {
-      providerID: "corethink",
-      modelID: "corethink",
-    }
-  }
-
-  export function parseModel(model: string) {
-    const [providerID, ...rest] = model.split("/")
-    return {
-      providerID: providerID,
-      modelID: rest.join("/"),
-    }
-  }
-
-  export const ModelNotFoundError = NamedError.create(
-    "ProviderModelNotFoundError",
-    z.object({
-      providerID: z.string(),
-      modelID: z.string(),
-      suggestions: z.array(z.string()).optional(),
-    }),
-  )
-
-  export const InitError = NamedError.create(
-    "ProviderInitError",
-    z.object({
-      providerID: z.string(),
-    }),
-  )
-}

package/src/provider/transform.ts

@@ -1,114 +0,0 @@
-import type { APICallError, ModelMessage } from "ai"
-import type { JSONSchema } from "zod/v4/core"
-import type { Provider } from "./provider"
-
-export namespace ProviderTransform {
-  function unsupportedParts(msgs: ModelMessage[], model: Provider.Model): ModelMessage[] {
-    return msgs.map((msg) => {
-      if (msg.role !== "user" || !Array.isArray(msg.content)) return msg
-
-      const filtered = msg.content.map((part) => {
-        if (part.type !== "file" && part.type !== "image") return part
-
-        // Check for empty base64 image data
-        if (part.type === "image") {
-          const imageStr = part.image.toString()
-          if (imageStr.startsWith("data:")) {
-            const match = imageStr.match(/^data:([^;]+);base64,(.*)$/)
-            if (match && (!match[2] || match[2].length === 0)) {
-              return {
-                type: "text" as const,
-                text: "ERROR: Image file is empty or corrupted. Please provide a valid image.",
-              }
-            }
-          }
-        }
-
-        const mime = part.type === "image" ? part.image.toString().split(";")[0].replace("data:", "") : part.mediaType
-        const filename = part.type === "file" ? part.filename : undefined
-        const modality = mimeToModality(mime)
-        if (!modality) return part
-        if (model.capabilities.input[modality]) return part
-
-        const name = filename ? `"${filename}"` : modality
-        return {
-          type: "text" as const,
-          text: `ERROR: Cannot read ${name} (this model does not support ${modality} input). Inform the user.`,
-        }
-      })
-
-      return { ...msg, content: filtered }
-    })
-  }
-
-  function mimeToModality(mime: string): "image" | "audio" | "video" | "pdf" | undefined {
-    if (mime.startsWith("image/")) return "image"
-    if (mime.startsWith("audio/")) return "audio"
-    if (mime.startsWith("video/")) return "video"
-    if (mime === "application/pdf") return "pdf"
-    return undefined
-  }
-
-  export function message(msgs: ModelMessage[], model: Provider.Model) {
-    msgs = unsupportedParts(msgs, model)
-    return msgs
-  }
-
-  export function temperature(_model: Provider.Model) {
-    // Default temperature for corethink
-    return undefined
-  }
-
-  export function topP(_model: Provider.Model) {
-    return undefined
-  }
-
-  export function topK(_model: Provider.Model) {
-    return undefined
-  }
-
-  export function variants(_model: Provider.Model): Record<string, Record<string, any>> {
-    // Corethink doesn't have reasoning variants
-    return {}
-  }
-
-  export function options(
-    _model: Provider.Model,
-    _sessionID: string,
-    _providerOptions?: Record<string, any>,
-  ): Record<string, any> {
-    return {}
-  }
-
-  export function smallOptions(_model: Provider.Model) {
-    return {}
-  }
-
-  export function providerOptions(model: Provider.Model, options: { [x: string]: any }) {
-    return {
-      [model.providerID]: options,
-    }
-  }
-
-  export function maxOutputTokens(
-    _npm: string,
-    _options: Record<string, any>,
-    modelLimit: number,
-    globalLimit: number,
-  ): number {
-    return Math.min(modelLimit || globalLimit, globalLimit)
-  }
-
-  export function schema(_model: Provider.Model, schema: JSONSchema.BaseSchema) {
-    // Strip fields that some APIs don't handle well
-    const cleaned = { ...schema } as Record<string, any>
-    delete cleaned["$schema"]
-    // Some APIs don't like strict additionalProperties
-    delete cleaned["additionalProperties"]
-    return cleaned as JSONSchema.BaseSchema
-  }
-
-  export function error(_providerID: string, error: APICallError) {
-    return error.message
-  }
-}