Provider / Model

export type Model = {
  id: string
  name: string
  family?: string
  release_date: string
  attachment: boolean
  reasoning: boolean
  temperature: boolean
  tool_call: boolean
  interleaved?:
    | boolean
    | {
        field: "reasoning_content" | "reasoning_details"
      }
  cost?: {
    input: number
    output: number
    cache_read?: number
    cache_write?: number
    context_over_200k?: {
      input: number
      output: number
      cache_read?: number
      cache_write?: number
    }
  }
  limit: {
    context: number
    input?: number
    output: number
  }
  modalities?: {
    input: Array<"text" | "audio" | "image" | "video" | "pdf">
    output: Array<"text" | "audio" | "image" | "video" | "pdf">
  }
  experimental?: boolean
  status?: "alpha" | "beta" | "deprecated"
  options?: Record<string, any>
  headers?: Record<string, string>
  provider?: {
    npm: string
  }
  variants?: Record<string, Record<string, any>>
}

export type Provider = {
  api?: string
  name: string
  env: string[]
  id: string
  npm?: string
  models: Record<string, Model>
}

const providers = await ModelsDev.get()

for (const [providerId, provider] of Object.entries(providers)) {
  console.log(`Provider: ${provider.name}`)
  console.log(`  Models: ${Object.keys(provider.models).length}`)
}

const providers = await ModelsDev.get()
const anthropic = providers["anthropic"]

console.log(anthropic.name) // "Anthropic"
console.log(anthropic.models) // 模型映射

const providers = await ModelsDev.get()
const anthropic = providers["anthropic"]
const model = anthropic.models["claude-3-5-sonnet"]

console.log(model.name) // "Claude 3.5 Sonnet"
console.log(model.limit.context) // 200000
console.log(model.cost.input) // 3.0 (每百万 Token）

const model = anthropic.models["claude-3-5-sonnet"]
const costInfo = model.cost

const inputCost = (inputTokens / 1_000_000) * costInfo.input
const outputCost = (outputTokens / 1_000_000) * costInfo.output
const cacheCost = (cacheReadTokens / 1_000_000) * (costInfo.cache_read || 0)

const totalCost = inputCost + outputCost + cacheCost

const model = getModel("claude-3-5-sonnet")

if (model.reasoning) {
  console.log("此模型支持推理")
}

if (model.attachment.tool_call) {
  console.log("此模型支持文件输入")
}

if (model.tool_call) {
  console.log("此模型支持工具调用")
}

const model = getModel("claude-3-5-sonnet")
const totalTokens = inputTokens + outputTokens + cacheTokens

const costInfo = totalTokens > 200_000 ? model.cost.context_over_200k : model.cost

const cost = calculateCost(costInfo, tokens)

// 从 models.dev API 获取最新数据
await ModelsDev.refresh()

const json = await fetch("https://models.dev/api.json").then((x) => x.text())
return JSON.parse(json) as Record<string, Provider>

const filepath = path.join(Global.Path.cache, "models.json")

// 读取缓存
const cached = await Bun.file(filepath)
  .json()
  .catch(() => {})

// 写入缓存
await Bun.write(filepath, await response.text())

function supportsToolCall(model: Model): boolean {
  return model.tool_call && model.attachment
}

function supportsReasoning(model: Model): boolean {
  return model.reasoning
}

function supportsModality(model: Model, inputModality: string, outputModality: string): boolean {
  if (!model.modalities) return false
  return model.modalities.input.includes(inputModality) && model.modalities.output.includes(outputModality)
}

const model = providers["anthropic"].models["claude-3-5-sonnet"]

if (model.variants) {
  console.log("Available variants:")
  for (const [variantName, variantConfig] of Object.entries(model.variants)) {
    console.log(`  ${variantName}:`)
    console.log(`    Context: ${variantConfig.limit.context}`)
  }
}