import z from "zod"

import os from "os"

import fuzzysort from "fuzzysort"

import { Config } from "../config/config"

import { mapValues, mergeDeep, omit, pickBy, sortBy } from "remeda"

import { NoSuchModelError, type Provider as SDK } from "ai"

import { Log } from "../util/log"

import { Npm } from "../npm"

import { Hash } from "../util/hash"

import { Plugin } from "../plugin"

import { NamedError } from "@opencode-ai/util/error"

import { type LanguageModelV3 } from "@ai-sdk/provider"

import { ModelsDev } from "./models"

import { Auth } from "../auth"

import { Env } from "../env"

import { Instance } from "../project/instance"

import { Flag } from "../flag/flag"

import { iife } from "@/util/iife"

import { Global } from "../global"

import path from "path"

import { Filesystem } from "../util/filesystem"

import { Effect, Layer, ServiceMap } from "effect"

import { InstanceState } from "@/effect/instance-state"

import { makeRuntime } from "@/effect/run-service"

// Direct imports for bundled providers

import { createAmazonBedrock, type AmazonBedrockProviderSettings } from "@ai-sdk/amazon-bedrock"

import { createAnthropic } from "@ai-sdk/anthropic"

import { createAzure } from "@ai-sdk/azure"

import { createGoogleGenerativeAI } from "@ai-sdk/google"

import { createVertex } from "@ai-sdk/google-vertex"

import { createVertexAnthropic } from "@ai-sdk/google-vertex/anthropic"

import { createOpenAI } from "@ai-sdk/openai"

import { createOpenAICompatible } from "@ai-sdk/openai-compatible"

import { createOpenRouter } from "@openrouter/ai-sdk-provider"

import { createOpenaiCompatible as createGitHubCopilotOpenAICompatible } from "./sdk/copilot"

import { createXai } from "@ai-sdk/xai"

import { createMistral } from "@ai-sdk/mistral"

import { createGroq } from "@ai-sdk/groq"

import { createDeepInfra } from "@ai-sdk/deepinfra"

import { createCerebras } from "@ai-sdk/cerebras"

import { createCohere } from "@ai-sdk/cohere"

import { createGateway } from "@ai-sdk/gateway"

import { createTogetherAI } from "@ai-sdk/togetherai"

import { createPerplexity } from "@ai-sdk/perplexity"

import { createVercel } from "@ai-sdk/vercel"

import {

createGitLab,

VERSION as GITLAB_PROVIDER_VERSION,

isWorkflowModel,

discoverWorkflowModels,

} from "gitlab-ai-provider"

import { fromNodeProviderChain } from "@aws-sdk/credential-providers"

import { GoogleAuth } from "google-auth-library"

import { ProviderTransform } from "./transform"

import { Installation } from "../installation"

import { ModelID, ProviderID } from "./schema"

export namespace Provider {

const log = Log.create({ service: "provider" })

function shouldUseCopilotResponsesApi(modelID: string): boolean {

const match = /^gpt-(\d+)/.exec(modelID)

if (!match) return false

return Number(match[1]) >= 5 && !modelID.startsWith("gpt-5-mini")

}

function wrapSSE(res: Response, ms: number, ctl: AbortController) {

if (typeof ms !== "number" || ms <= 0) return res

if (!res.body) return res

if (!res.headers.get("content-type")?.includes("text/event-stream")) return res

const reader = res.body.getReader()

const body = new ReadableStream<Uint8Array>({

async pull(ctrl) {

const part = await new Promise<Awaited<ReturnType<typeof reader.read>>>((resolve, reject) => {

const id = setTimeout(() => {

const err = new Error("SSE read timed out")

ctl.abort(err)

void reader.cancel(err)

reject(err)

}, ms)

reader.read().then(

(part) => {

clearTimeout(id)

resolve(part)

},

(err) => {

clearTimeout(id)

reject(err)

},

)

})

if (part.done) {

ctrl.close()

return

}

ctrl.enqueue(part.value)

},

async cancel(reason) {

ctl.abort(reason)

await reader.cancel(reason)

},

})

return new Response(body, {

headers: new Headers(res.headers),

status: res.status,

statusText: res.statusText,

})

}

type BundledSDK = {

languageModel(modelId: string): LanguageModelV3

}

const BUNDLED_PROVIDERS: Record<string, (options: any) => BundledSDK> = {

"@ai-sdk/amazon-bedrock": createAmazonBedrock,

"@ai-sdk/anthropic": createAnthropic,

"@ai-sdk/azure": createAzure,

"@ai-sdk/google": createGoogleGenerativeAI,

"@ai-sdk/google-vertex": createVertex,

"@ai-sdk/google-vertex/anthropic": createVertexAnthropic,

"@ai-sdk/openai": createOpenAI,

"@ai-sdk/openai-compatible": createOpenAICompatible,

"@openrouter/ai-sdk-provider": createOpenRouter,

"@ai-sdk/xai": createXai,

"@ai-sdk/mistral": createMistral,

"@ai-sdk/groq": createGroq,

"@ai-sdk/deepinfra": createDeepInfra,

"@ai-sdk/cerebras": createCerebras,

"@ai-sdk/cohere": createCohere,

"@ai-sdk/gateway": createGateway,

"@ai-sdk/togetherai": createTogetherAI,

"@ai-sdk/perplexity": createPerplexity,

"@ai-sdk/vercel": createVercel,

"gitlab-ai-provider": createGitLab,

"@ai-sdk/github-copilot": createGitHubCopilotOpenAICompatible,

}

type CustomModelLoader = (sdk: any, modelID: string, options?: Record<string, any>) => Promise<any>

type CustomVarsLoader = (options: Record<string, any>) => Record<string, string>

type CustomDiscoverModels = () => Promise<Record<string, Model>>

type CustomLoader = (provider: Info) => Promise<{

autoload: boolean

getModel?: CustomModelLoader

vars?: CustomVarsLoader

options?: Record<string, any>

discoverModels?: CustomDiscoverModels

}>

function useLanguageModel(sdk: any) {

return sdk.responses === undefined && sdk.chat === undefined

}

const CUSTOM_LOADERS: Record<string, CustomLoader> = {

async anthropic() {

return {

autoload: false,

options: {

headers: {

"anthropic-beta": "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",

},

},

}

},

async opencode(input) {

const hasKey = await (async () => {

const env = Env.all()

if (input.env.some((item) => env[item])) return true

if (await Auth.get(input.id)) return true

const config = await Config.get()

if (config.provider?.["opencode"]?.options?.apiKey) return true

return false

})()

if (!hasKey) {

for (const [key, value] of Object.entries(input.models)) {

if (value.cost.input === 0) continue

delete input.models[key]

}

}

return {

autoload: Object.keys(input.models).length > 0,

options: hasKey ? {} : { apiKey: "public" },

}

},

openai: async () => {

return {

autoload: false,

async getModel(sdk: any, modelID: string, _options?: Record<string, any>) {

return sdk.responses(modelID)

},

options: {},

}

},

xai: async () => {

return {

autoload: false,

async getModel(sdk: any, modelID: string, _options?: Record<string, any>) {

return sdk.responses(modelID)

},

options: {},

}

},

"github-copilot": async () => {

return {

autoload: false,

async getModel(sdk: any, modelID: string, _options?: Record<string, any>) {

if (useLanguageModel(sdk)) return sdk.languageModel(modelID)

return shouldUseCopilotResponsesApi(modelID) ? sdk.responses(modelID) : sdk.chat(modelID)

},

options: {},

}

},

azure: async (provider) => {

const resource = iife(() => {

const name = provider.options?.resourceName

if (typeof name === "string" && name.trim() !== "") return name

return Env.get("AZURE_RESOURCE_NAME")

})

return {

autoload: false,

async getModel(sdk: any, modelID: string, options?: Record<string, any>) {

if (useLanguageModel(sdk)) return sdk.languageModel(modelID)

if (options?.["useCompletionUrls"]) {

return sdk.chat(modelID)

} else {

return sdk.responses(modelID)

}

},

options: {},

vars(_options) {

return {

...(resource && { AZURE_RESOURCE_NAME: resource }),

}

},

}

},

"azure-cognitive-services": async () => {

const resourceName = Env.get("AZURE_COGNITIVE_SERVICES_RESOURCE_NAME")

return {

autoload: false,

async getModel(sdk: any, modelID: string, options?: Record<string, any>) {

if (useLanguageModel(sdk)) return sdk.languageModel(modelID)

if (options?.["useCompletionUrls"]) {

return sdk.chat(modelID)

} else {

return sdk.responses(modelID)

}

},

options: {

baseURL: resourceName ? `https://${resourceName}.cognitiveservices.azure.com/openai` : undefined,

},

}

},

"amazon-bedrock": async () => {

const config = await Config.get()

const providerConfig = config.provider?.["amazon-bedrock"]

const auth = await Auth.get("amazon-bedrock")

// Region precedence: 1) config file, 2) env var, 3) default

const configRegion = providerConfig?.options?.region

const envRegion = Env.get("AWS_REGION")

const defaultRegion = configRegion ?? envRegion ?? "us-east-1"

// Profile: config file takes precedence over env var

const configProfile = providerConfig?.options?.profile

const envProfile = Env.get("AWS_PROFILE")

const profile = configProfile ?? envProfile

const awsAccessKeyId = Env.get("AWS_ACCESS_KEY_ID")

// TODO: Using process.env directly because Env.set only updates a process.env shallow copy,

// until the scope of the Env API is clarified (test only or runtime?)

const awsBearerToken = iife(() => {

const envToken = process.env.AWS_BEARER_TOKEN_BEDROCK

if (envToken) return envToken

if (auth?.type === "api") {

process.env.AWS_BEARER_TOKEN_BEDROCK = auth.key

return auth.key

}

return undefined

})

const awsWebIdentityTokenFile = Env.get("AWS_WEB_IDENTITY_TOKEN_FILE")

const containerCreds = Boolean(

process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI,

)

if (!profile && !awsAccessKeyId && !awsBearerToken && !awsWebIdentityTokenFile && !containerCreds)

return { autoload: false }

const providerOptions: AmazonBedrockProviderSettings = {

region: defaultRegion,

}

// Only use credential chain if no bearer token exists

// Bearer token takes precedence over credential chain (profiles, access keys, IAM roles, web identity tokens)

if (!awsBearerToken) {

// Build credential provider options (only pass profile if specified)

const credentialProviderOptions = profile ? { profile } : {}

providerOptions.credentialProvider = fromNodeProviderChain(credentialProviderOptions)

}

// Add custom endpoint if specified (endpoint takes precedence over baseURL)

const endpoint = providerConfig?.options?.endpoint ?? providerConfig?.options?.baseURL

if (endpoint) {

providerOptions.baseURL = endpoint

}

return {

autoload: true,

options: providerOptions,

async getModel(sdk: any, modelID: string, options?: Record<string, any>) {

// Skip region prefixing if model already has a cross-region inference profile prefix

// Models from models.dev may already include prefixes like us., eu., global., etc.

const crossRegionPrefixes = ["global.", "us.", "eu.", "jp.", "apac.", "au."]

if (crossRegionPrefixes.some((prefix) => modelID.startsWith(prefix))) {

return sdk.languageModel(modelID)

}

// Region resolution precedence (highest to lowest):

// 1. options.region from opencode.json provider config

// 2. defaultRegion from AWS_REGION environment variable

// 3. Default "us-east-1" (baked into defaultRegion)

const region = options?.region ?? defaultRegion

let regionPrefix = region.split("-")[0]

switch (regionPrefix) {

case "us": {

const modelRequiresPrefix = [

"nova-micro",

"nova-lite",

"nova-pro",

"nova-premier",

"nova-2",

"claude",

"deepseek",

].some((m) => modelID.includes(m))

const isGovCloud = region.startsWith("us-gov")

if (modelRequiresPrefix && !isGovCloud) {

modelID = `${regionPrefix}.${modelID}`

}

break

}

case "eu": {

const regionRequiresPrefix = [

"eu-west-1",

"eu-west-2",

"eu-west-3",

"eu-north-1",

"eu-central-1",

"eu-south-1",

"eu-south-2",

].some((r) => region.includes(r))

const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "llama3", "pixtral"].some((m) =>

modelID.includes(m),

)

if (regionRequiresPrefix && modelRequiresPrefix) {

modelID = `${regionPrefix}.${modelID}`

}

break

}

case "ap": {

const isAustraliaRegion = ["ap-southeast-2", "ap-southeast-4"].includes(region)

const isTokyoRegion = region === "ap-northeast-1"

if (

isAustraliaRegion &&

["anthropic.claude-sonnet-4-5", "anthropic.claude-haiku"].some((m) => modelID.includes(m))

) {

regionPrefix = "au"

modelID = `${regionPrefix}.${modelID}`

} else if (isTokyoRegion) {

// Tokyo region uses jp. prefix for cross-region inference

const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) =>

modelID.includes(m),

)

if (modelRequiresPrefix) {

regionPrefix = "jp"

modelID = `${regionPrefix}.${modelID}`

}

} else {

// Other APAC regions use apac. prefix

const modelRequiresPrefix = ["claude", "nova-lite", "nova-micro", "nova-pro"].some((m) =>

modelID.includes(m),

)

if (modelRequiresPrefix) {

regionPrefix = "apac"

modelID = `${regionPrefix}.${modelID}`

}

}

break

}

}

return sdk.languageModel(modelID)

},

}

},

openrouter: async () => {

return {

autoload: false,

options: {

headers: {

"HTTP-Referer": "https://opencode.ai/",

"X-Title": "opencode",

},

},

}

},

vercel: async () => {

return {

autoload: false,

options: {

headers: {

"http-referer": "https://opencode.ai/",

"x-title": "opencode",

},

},

}

},

"google-vertex": async (provider) => {

const project =

provider.options?.project ??

Env.get("GOOGLE_CLOUD_PROJECT") ??

Env.get("GCP_PROJECT") ??

Env.get("GCLOUD_PROJECT")

const location = String(

provider.options?.location ??

Env.get("GOOGLE_VERTEX_LOCATION") ??

Env.get("GOOGLE_CLOUD_LOCATION") ??

Env.get("VERTEX_LOCATION") ??

"us-central1",

)

const autoload = Boolean(project)

if (!autoload) return { autoload: false }

return {

autoload: true,

vars(_options: Record<string, any>) {

const endpoint = location === "global" ? "aiplatform.googleapis.com" : `${location}-aiplatform.googleapis.com`

return {

...(project && { GOOGLE_VERTEX_PROJECT: project }),

GOOGLE_VERTEX_LOCATION: location,

GOOGLE_VERTEX_ENDPOINT: endpoint,

}

},

options: {

project,

location,

fetch: async (input: RequestInfo | URL, init?: RequestInit) => {

const auth = new GoogleAuth()

const client = await auth.getApplicationDefault()

const token = await client.credential.getAccessToken()

const headers = new Headers(init?.headers)

headers.set("Authorization", `Bearer ${token.token}`)

return fetch(input, { ...init, headers })

},

},

async getModel(sdk: any, modelID: string) {

const id = String(modelID).trim()

return sdk.languageModel(id)

},

}

},

"google-vertex-anthropic": async () => {

const project = Env.get("GOOGLE_CLOUD_PROJECT") ?? Env.get("GCP_PROJECT") ?? Env.get("GCLOUD_PROJECT")

const location = Env.get("GOOGLE_CLOUD_LOCATION") ?? Env.get("VERTEX_LOCATION") ?? "global"

const autoload = Boolean(project)

if (!autoload) return { autoload: false }

return {

autoload: true,

options: {

project,

location,

},

async getModel(sdk: any, modelID) {

const id = String(modelID).trim()

return sdk.languageModel(id)

},

}

},

"sap-ai-core": async () => {

const auth = await Auth.get("sap-ai-core")

// TODO: Using process.env directly because Env.set only updates a shallow copy (not process.env),

// until the scope of the Env API is clarified (test only or runtime?)

const envServiceKey = iife(() => {

const envAICoreServiceKey = process.env.AICORE_SERVICE_KEY

if (envAICoreServiceKey) return envAICoreServiceKey

if (auth?.type === "api") {

process.env.AICORE_SERVICE_KEY = auth.key

return auth.key

}

return undefined

})

const deploymentId = process.env.AICORE_DEPLOYMENT_ID

const resourceGroup = process.env.AICORE_RESOURCE_GROUP

return {

autoload: !!envServiceKey,

options: envServiceKey ? { deploymentId, resourceGroup } : {},

async getModel(sdk: any, modelID: string) {

return sdk(modelID)

},

}

},

zenmux: async () => {

return {

autoload: false,

options: {

headers: {

"HTTP-Referer": "https://opencode.ai/",

"X-Title": "opencode",

},

},

}

},

gitlab: async (input) => {

const instanceUrl = Env.get("GITLAB_INSTANCE_URL") || "https://gitlab.com"

const auth = await Auth.get(input.id)

const apiKey = await (async () => {

if (auth?.type === "oauth") return auth.access

if (auth?.type === "api") return auth.key

return Env.get("GITLAB_TOKEN")

})()

const config = await Config.get()

const providerConfig = config.provider?.["gitlab"]

const aiGatewayHeaders = {

"User-Agent": `opencode/${Installation.VERSION} gitlab-ai-provider/${GITLAB_PROVIDER_VERSION} (${os.platform()} ${os.release()}; ${os.arch()})`,

"anthropic-beta": "context-1m-2025-08-07",

...(providerConfig?.options?.aiGatewayHeaders || {}),

}

const featureFlags = {

duo_agent_platform_agentic_chat: true,

duo_agent_platform: true,

...(providerConfig?.options?.featureFlags || {}),

}

return {

autoload: !!apiKey,

options: {

instanceUrl,

apiKey,

aiGatewayHeaders,

featureFlags,

},

async getModel(sdk: ReturnType<typeof createGitLab>, modelID: string, options?: Record<string, any>) {

if (modelID.startsWith("duo-workflow-")) {

const workflowRef = options?.workflowRef as string | undefined

// Use the static mapping if it exists, otherwise use duo-workflow with selectedModelRef

const sdkModelID = isWorkflowModel(modelID) ? modelID : "duo-workflow"

const model = sdk.workflowChat(sdkModelID, {

featureFlags,

})

if (workflowRef) {

model.selectedModelRef = workflowRef

}

return model

}

return sdk.agenticChat(modelID, {

aiGatewayHeaders,

featureFlags,

})

},

async discoverModels(): Promise<Record<string, Model>> {

if (!apiKey) {

log.info("gitlab model discovery skipped: no apiKey")

return {}

}

try {

const token = apiKey

const getHeaders = (): Record<string, string> =>

auth?.type === "api" ? { "PRIVATE-TOKEN": token } : { Authorization: `Bearer ${token}` }

log.info("gitlab model discovery starting", { instanceUrl })

const result = await discoverWorkflowModels(

{ instanceUrl, getHeaders },

{ workingDirectory: Instance.directory },

)

if (!result.models.length) {

log.info("gitlab model discovery skipped: no models found", {

project: result.project

? {

id: result.project.id,

path: result.project.pathWithNamespace,

}

: null,

})

return {}

}

const models: Record<string, Model> = {}

for (const m of result.models) {

if (!input.models[m.id]) {

models[m.id] = {

id: ModelID.make(m.id),

providerID: ProviderID.make("gitlab"),

name: `Agent Platform (${m.name})`,

family: "",

api: {

id: m.id,

url: instanceUrl,

npm: "gitlab-ai-provider",

},

status: "active",

headers: {},

options: { workflowRef: m.ref },

cost: { input: 0, output: 0, cache: { read: 0, write: 0 } },

limit: { context: m.context, output: m.output },

capabilities: {

temperature: false,

reasoning: true,

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: "",

variants: {},

}

}

}

log.info("gitlab model discovery complete", {

count: Object.keys(models).length,

models: Object.keys(models),

})

return models

} catch (e) {

log.warn("gitlab model discovery failed", { error: e })

return {}

}

},

}

},

"cloudflare-workers-ai": async (input) => {

const accountId = Env.get("CLOUDFLARE_ACCOUNT_ID")

if (!accountId) return { autoload: false }

const apiKey = await iife(async () => {

const envToken = Env.get("CLOUDFLARE_API_KEY")

if (envToken) return envToken

const auth = await Auth.get(input.id)

if (auth?.type === "api") return auth.key

return undefined

})

return {

autoload: !!apiKey,

options: {

apiKey,

},

async getModel(sdk: any, modelID: string) {

return sdk.languageModel(modelID)

},

vars(_options) {

return {

CLOUDFLARE_ACCOUNT_ID: accountId,

}

},

}

},

"cloudflare-ai-gateway": async (input) => {

const accountId = Env.get("CLOUDFLARE_ACCOUNT_ID")

const gateway = Env.get("CLOUDFLARE_GATEWAY_ID")

if (!accountId || !gateway) return { autoload: false }

// Get API token from env or auth - required for authenticated gateways

const apiToken = await (async () => {

const envToken = Env.get("CLOUDFLARE_API_TOKEN") || Env.get("CF_AIG_TOKEN")

if (envToken) return envToken

const auth = await Auth.get(input.id)

if (auth?.type === "api") return auth.key

return undefined

})()

if (!apiToken) {

throw new Error(

"CLOUDFLARE_API_TOKEN (or CF_AIG_TOKEN) is required for Cloudflare AI Gateway. " +

"Set it via environment variable or run `opencode auth cloudflare-ai-gateway`.",

)

}

// Use official ai-gateway-provider package (v2.x for AI SDK v5 compatibility)

const { createAiGateway } = await import("ai-gateway-provider")

const { createUnified } = await import("ai-gateway-provider/providers/unified")

const metadata = iife(() => {

if (input.options?.metadata) return input.options.metadata

try {

return JSON.parse(input.options?.headers?.["cf-aig-metadata"])

} catch {

return undefined

}

})

const opts = {

metadata,

cacheTtl: input.options?.cacheTtl,

cacheKey: input.options?.cacheKey,

skipCache: input.options?.skipCache,

collectLog: input.options?.collectLog,

}

const aigateway = createAiGateway({

accountId,

gateway,

apiKey: apiToken,

...(Object.values(opts).some((v) => v !== undefined) ? { options: opts } : {}),

})

const unified = createUnified()

return {

autoload: true,

async getModel(_sdk: any, modelID: string, _options?: Record<string, any>) {

// Model IDs use Unified API format: provider/model (e.g., "anthropic/claude-sonnet-4-5")

return aigateway(unified(modelID))

},

options: {},

}

},

cerebras: async () => {

return {

autoload: false,

options: {

headers: {

"X-Cerebras-3rd-Party-Integration": "opencode",

},

},

}

},

kilo: async () => {

return {

autoload: false,

options: {

headers: {

"HTTP-Referer": "https://opencode.ai/",

"X-Title": "opencode",

},

},

}

},

}

export const Model = z

.object({

id: ModelID.zod,

providerID: ProviderID.zod,

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(),

input: z.number().optional(),

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: ProviderID.zod,

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>

export interface Interface {

readonly list: () => Effect.Effect<Record<ProviderID, Info>>

readonly getProvider: (providerID: ProviderID) => Effect.Effect<Info>

readonly getModel: (providerID: ProviderID, modelID: ModelID) => Effect.Effect<Model>

readonly getLanguage: (model: Model) => Effect.Effect<LanguageModelV3>

readonly closest: (

providerID: ProviderID,

query: string[],

) => Effect.Effect<{ providerID: ProviderID; modelID: string } | undefined>

readonly getSmallModel: (providerID: ProviderID) => Effect.Effect<Model | undefined>

readonly defaultModel: () => Effect.Effect<{ providerID: ProviderID; modelID: ModelID }>

}

interface State {

models: Map<string, LanguageModelV3>

providers: Record<ProviderID, Info>

sdk: Map<string, BundledSDK>

modelLoaders: Record<string, CustomModelLoader>

varsLoaders: Record<string, CustomVarsLoader>

}

export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Provider") {}

function fromModelsDevModel(provider: ModelsDev.Provider, model: ModelsDev.Model): Model {

const m: Model = {

id: ModelID.make(model.id),

providerID: ProviderID.make(provider.id),

name: model.name,

family: model.family,

api: {

id: model.id,

url: model.provider?.api ?? provider.api!,

npm: model.provider?.npm ?? provider.npm ?? "@ai-sdk/openai-compatible",

},

status: model.status ?? "active",

headers: model.headers ?? {},

options: model.options ?? {},

cost: {

input: model.cost?.input ?? 0,

output: model.cost?.output ?? 0,

cache: {

read: model.cost?.cache_read ?? 0,

write: model.cost?.cache_write ?? 0,

},

experimentalOver200K: model.cost?.context_over_200k

? {

cache: {

read: model.cost.context_over_200k.cache_read ?? 0,

write: model.cost.context_over_200k.cache_write ?? 0,

},

input: model.cost.context_over_200k.input,

output: model.cost.context_over_200k.output,

}

: undefined,

},

limit: {

context: model.limit.context,

input: model.limit.input,

output: model.limit.output,

},

capabilities: {

temperature: model.temperature,

reasoning: model.reasoning,

attachment: model.attachment,

toolcall: model.tool_call,

input: {

text: model.modalities?.input?.includes("text") ?? false,

audio: model.modalities?.input?.includes("audio") ?? false,

image: model.modalities?.input?.includes("image") ?? false,

video: model.modalities?.input?.includes("video") ?? false,

pdf: model.modalities?.input?.includes("pdf") ?? false,

},

output: {

text: model.modalities?.output?.includes("text") ?? false,

audio: model.modalities?.output?.includes("audio") ?? false,

image: model.modalities?.output?.includes("image") ?? false,

video: model.modalities?.output?.includes("video") ?? false,

pdf: model.modalities?.output?.includes("pdf") ?? false,

},

interleaved: model.interleaved ?? false,

},

release_date: model.release_date,

variants: {},

}

m.variants = mapValues(ProviderTransform.variants(m), (v) => v)

return m

}

export function fromModelsDevProvider(provider: ModelsDev.Provider): Info {

return {

id: ProviderID.make(provider.id),

source: "custom",

name: provider.name,

env: provider.env ?? [],

options: {},

models: mapValues(provider.models, (model) => fromModelsDevModel(provider, model)),

}

}

const layer: Layer.Layer<Service, never, Config.Service | Auth.Service | Plugin.Service> = Layer.effect(

Service,

Effect.gen(function* () {

const config = yield* Config.Service

const auth = yield* Auth.Service

const plugin = yield* Plugin.Service

const state = yield* InstanceState.make<State>(() =>

Effect.gen(function* () {

using _ = log.time("state")

const cfg = yield* config.get()

const modelsDev = yield* Effect.promise(() => ModelsDev.get())

const database = mapValues(modelsDev, fromModelsDevProvider)

const disabled = new Set(cfg.disabled_providers ?? [])

const enabled = cfg.enabled_providers ? new Set(cfg.enabled_providers) : null

function isProviderAllowed(providerID: ProviderID): boolean {

if (enabled && !enabled.has(providerID)) return false

if (disabled.has(providerID)) return false

return true

}

const providers: Record<ProviderID, Info> = {} as Record<ProviderID, Info>

const languages = new Map<string, LanguageModelV3>()

const modelLoaders: {

[providerID: string]: CustomModelLoader

} = {}

const varsLoaders: {

[providerID: string]: CustomVarsLoader

} = {}

const sdk = new Map<string, BundledSDK>()

const discoveryLoaders: {

[providerID: string]: CustomDiscoverModels

} = {}

log.info("init")