feat: 模型消耗管理与智能匹配 | Model consumption management and intelligent matching

bun.lock

@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "copilot-api",

src/lib/model-consumption.json

@@ -0,0 +1,44 @@
+{
+  "models": [
+    {
+      "name": "GPT-4.1",
+      "consumption": "0x"
+    },
+    {
+      "name": "GPT-4o",
+      "consumption": "0x"
+    },
+    {
+      "name": "GPT-5 mini",
+      "consumption": "0x"
+    },
+    {
+      "name": "Grok Code Fast 1",
+      "consumption": "0x"
+    },
+    {
+      "name": "Claude Haiku 4.5",
+      "consumption": "0.33x"
+    },
+    {
+      "name": "Claude Sonnet 4",
+      "consumption": "1x"
+    },
+    {
+      "name": "Claude Sonnet 4.5",
+      "consumption": "1x"
+    },
+    {
+      "name": "Gemini 2.5 Pro",
+      "consumption": "1x"
+    },
+    {
+      "name": "GPT-5",
+      "consumption": "1x"
+    },
+    {
+      "name": "GPT-5-Codex (Preview)",
+      "consumption": "1x"
+    }
+  ]
+}

src/lib/model-matcher.ts

@@ -0,0 +1,139 @@
+import consola from "consola"
+
+import { state } from "./state"
+
+/**
+ * Find a matching model from available models
+ * If exact match exists, return it
+ * If no exact match, try to find by prefix (e.g., claude-haiku-4-5-xxx -> claude-haiku-4.5)
+ */
+export function findMatchingModel(requestedModel: string): string | null {
+  const availableModels = state.models?.data.filter(
+    (m) => typeof m.capabilities?.limits?.max_context_window_tokens === "number",
+  )
+
+  if (!availableModels || availableModels.length === 0) {
+    return null
+  }
+
+  const availableModelIds = availableModels.map((m) => m.id)
+
+  consola.debug(`Looking for match for: ${requestedModel}`)
+  consola.debug(`Available models: ${availableModelIds.join(", ")}`)
+
+  // Try exact match first
+  if (availableModelIds.includes(requestedModel)) {
+    return requestedModel
+  }
+
+  // Normalize the requested model
+  // 1. Replace underscores with hyphens
+  // 2. Remove date suffix (8 digits at the end)
+  // 3. Replace version numbers: 4-5 -> 4.5
+  let normalizedRequested = requestedModel
+    .toLowerCase()
+    .replace(/_/g, "-")
+    .replace(/-(\d{8})$/, "") // Remove -20251001 style suffix
+    .replace(/(\d)-(\d)/g, "$1.$2") // Replace 4-5 with 4.5
+
+  consola.debug(`Normalized requested: ${normalizedRequested}`)
+
+  // Try exact match after normalization
+  for (const availableId of availableModelIds) {
+    if (availableId.toLowerCase() === normalizedRequested) {
+      consola.info(
+        `🔄 Model normalized match: '${requestedModel}' -> '${availableId}'`,
+      )
+      return availableId
+    }
+  }
+
+  // Try prefix matching
+  for (const availableId of availableModelIds) {
+    const normalizedAvailable = availableId.toLowerCase()
+
+    // Check if they start with each other
+    if (
+      normalizedAvailable.startsWith(normalizedRequested) ||
+      normalizedRequested.startsWith(normalizedAvailable)
+    ) {
+      consola.info(
+        `🔄 Model prefix match: '${requestedModel}' -> '${availableId}'`,
+      )
+      return availableId
+    }
+  }
+
+  // Try fuzzy matching by comparing main parts
+  const requestedParts = normalizedRequested.split("-")
+  for (const availableId of availableModelIds) {
+    const normalizedAvailable = availableId.toLowerCase()
+    const availableParts = normalizedAvailable.split("-")
+
+    // Match by comparing first N-1 parts (everything except version)
+    if (requestedParts.length >= 3 && availableParts.length >= 3) {
+      const requestedBase = requestedParts.slice(0, -1).join("-")
+      const availableBase = availableParts.slice(0, -1).join("-")
+
+      if (requestedBase === availableBase) {
+        consola.info(
+          `🔄 Model base match: '${requestedModel}' -> '${availableId}'`,
+        )
+        return availableId
+      }
+    }
+  }
+
+  consola.debug(`No match found for: ${requestedModel}`)
+  return null
+}
+
+/**
+ * Validate and potentially replace the requested model
+ * Returns the validated model ID or throws/returns error info
+ */
+export function validateAndReplaceModel(requestedModel: string): {
+  success: boolean
+  model?: string
+  error?: {
+    message: string
+    code: string
+    param: string
+    type: string
+  }
+} {
+  const availableModels = state.models?.data.filter(
+    (m) => typeof m.capabilities?.limits?.max_context_window_tokens === "number",
+  )
+  const availableModelIds = availableModels?.map((m) => m.id) || []
+
+  const matchedModel = findMatchingModel(requestedModel)
+
+  if (!matchedModel) {
+    consola.error(`❌ Model not available: ${requestedModel}`)
+    consola.error(`Available models: ${availableModelIds.join(", ")}`)
+
+    return {
+      success: false,
+      error: {
+        message: `The requested model '${requestedModel}' is not supported. Available models: ${availableModelIds.join(", ")}`,
+        code: "model_not_supported",
+        param: "model",
+        type: "invalid_request_error",
+      },
+    }
+  }
+
+  if (matchedModel !== requestedModel) {
+    consola.success(
+      `✓ Model matched and replaced: ${requestedModel} -> ${matchedModel}`,
+    )
+  } else {
+    consola.success(`✓ Model validated: ${matchedModel}`)
+  }
+
+  return {
+    success: true,
+    model: matchedModel,
+  }
+}

src/routes/chat-completions/handler.ts

@@ -4,6 +4,7 @@ import consola from "consola"
 import { streamSSE, type SSEMessage } from "hono/streaming"
 
 import { awaitApproval } from "~/lib/approval"
+import { validateAndReplaceModel } from "~/lib/model-matcher"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
 import { getTokenCount } from "~/lib/tokenizer"
@@ -20,6 +21,19 @@ export async function handleCompletion(c: Context) {
   let payload = await c.req.json<ChatCompletionsPayload>()
   consola.debug("Request payload:", JSON.stringify(payload).slice(-400))
 
+  // Log the requested model
+  consola.info(`Requested model: ${payload.model}`)
+
+  // Validate and potentially replace model
+  const validation = validateAndReplaceModel(payload.model)
+
+  if (!validation.success) {
+    return c.json({ error: validation.error }, 400)
+  }
+
+  // Replace model if a match was found
+  payload.model = validation.model!
+
   // Find the selected model
   const selectedModel = state.models?.data.find(
     (model) => model.id === payload.model,

src/routes/messages/handler.ts

@@ -4,6 +4,7 @@ import consola from "consola"
 import { streamSSE } from "hono/streaming"
 
 import { awaitApproval } from "~/lib/approval"
+import { validateAndReplaceModel } from "~/lib/model-matcher"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
 import {
@@ -34,6 +35,19 @@ export async function handleCompletion(c: Context) {
     JSON.stringify(openAIPayload),
   )
 
+  // Log the requested model
+  consola.info(`Requested model: ${openAIPayload.model}`)
+
+  // Validate and potentially replace model
+  const validation = validateAndReplaceModel(openAIPayload.model)
+
+  if (!validation.success) {
+    return c.json({ error: validation.error }, 400)
+  }
+
+  // Replace model if a match was found
+  openAIPayload.model = validation.model!
+
   if (state.manualApprove) {
     await awaitApproval()
   }

src/routes/models/route.ts

@@ -3,6 +3,7 @@ import { Hono } from "hono"
 import { forwardError } from "~/lib/error"
 import { state } from "~/lib/state"
 import { cacheModels } from "~/lib/utils"
+import modelConsumptionData from "~/lib/model-consumption.json"
 
 export const modelRoutes = new Hono()
 
@@ -13,15 +14,39 @@ modelRoutes.get("/", async (c) => {
       await cacheModels()
     }
 
-    const models = state.models?.data.map((model) => ({
-      id: model.id,
-      object: "model",
-      type: "model",
-      created: 0, // No date available from source
-      created_at: new Date(0).toISOString(), // No date available from source
-      owned_by: model.vendor,
-      display_name: model.name,
-    }))
+    // Create a map for quick consumption lookup
+    const consumptionMap = new Map(
+      modelConsumptionData.models.map((m) => [m.name, m.consumption]),
+    )
+
+    // Helper function to convert consumption string to number for sorting
+    const consumptionToNumber = (consumption: string): number => {
+      if (consumption === "N/A") return 999 // Put N/A at the end
+      const match = consumption.match(/^([\d.]+)x$/)
+      return match ? Number.parseFloat(match[1]) : 999
+    }
+
+    // Filter to only include models with context window information (Available models)
+    const models = state.models?.data
+      .filter((model) => {
+        const maxTokens = model.capabilities?.limits?.max_context_window_tokens
+        return typeof maxTokens === "number"
+      })
+      .map((model) => ({
+        model,
+        consumption: consumptionMap.get(model.name) || "N/A",
+      }))
+      .sort((a, b) => consumptionToNumber(a.consumption) - consumptionToNumber(b.consumption))
+      .map((item) => ({
+        id: item.model.id,
+        object: "model",
+        type: "model",
+        created: 0, // No date available from source
+        created_at: new Date(0).toISOString(), // No date available from source
+        owned_by: item.model.vendor,
+        display_name: item.model.name,
+        max_context_length: item.model.capabilities?.limits?.max_context_window_tokens,
+      }))
 
     return c.json({
       object: "list",

src/server.ts

@@ -27,5 +27,10 @@ server.route("/v1/chat/completions", completionRoutes)
 server.route("/v1/models", modelRoutes)
 server.route("/v1/embeddings", embeddingRoutes)
 
+// Compatibility with tools that expect api/v0/ prefix
+server.route("/api/v0/models", modelRoutes)
+server.route("/api/v0/chat/completions", completionRoutes)
+server.route("/api/v0/embeddings", embeddingRoutes)
+
 // Anthropic compatible endpoints
 server.route("/v1/messages", messageRoutes)

src/services/copilot/create-chat-completions.ts

@@ -35,7 +35,29 @@ export const createChatCompletions = async (
   })
 
   if (!response.ok) {
-    consola.error("Failed to create chat completions", response)
+    const errorBody = await response.text()
+    consola.error(`Failed to create chat completions for model: ${payload.model}`)
+    consola.error(`Response status: ${response.status} ${response.statusText}`)
+    consola.error(`Response body: ${errorBody}`)
+
+    // Try to parse error details
+    try {
+      const errorJson = JSON.parse(errorBody)
+      if (errorJson.error?.message) {
+        consola.error(`Error message: ${errorJson.error.message}`)
+
+        // If model not supported, list available models
+        if (errorJson.error.code === "model_not_supported") {
+          const availableModels = state.models?.data
+            .filter((m) => typeof m.capabilities?.limits?.max_context_window_tokens === "number")
+            .map((m) => m.id)
+          consola.error(`Available models: ${availableModels?.join(", ")}`)
+        }
+      }
+    } catch {
+      // If parsing fails, we already logged the raw body
+    }
+
     throw new HTTPError("Failed to create chat completions", response)
   }
 

src/services/copilot/get-models.ts

@@ -9,7 +9,12 @@ export const getModels = async () => {
 
   if (!response.ok) throw new HTTPError("Failed to get models", response)
 
-  return (await response.json()) as ModelsResponse
+  const result = await response.json() as ModelsResponse
+  result.data = result.data.filter(
+    (model: any) =>
+      model.model_picker_category !== undefined && model.model_picker_enabled === true
+  )
+  return result
 }
 
 export interface ModelsResponse {
@@ -48,6 +53,7 @@ export interface Model {
   preview: boolean
   vendor: string
   version: string
+  model_picker_category?: string
   policy?: {
     state: string
     terms: string