feat(server): 添加对Lingma提供商的支持并重构聊天完成服务

- 添加新的Provider类型定义，支持copilot和lingma两种提供商
- 实现Lingma提供商的连接、初始化和聊天完成功能
- 重构createChatCompletions服务以支持多提供商架构
- 在start命令中添加provider参数和相关配置选项
- 为Lingma提供商实现模型缓存和配置解析功能
- 添加APIError类用于更精确的错误处理
- 在各个路由中添加提供商特定的功能限制检查
- 实现Lingma聊天完成的验证和渲染逻辑
- 更新状态管理以支持新的提供商模式

Author: 202226442

src/lib/error.ts

@@ -12,9 +12,36 @@ export class HTTPError extends Error {
   }
 }
 
+export class APIError extends Error {
+  status: ContentfulStatusCode
+  type: string
+
+  constructor(
+    message: string,
+    status: ContentfulStatusCode = 500,
+    type = "error",
+  ) {
+    super(message)
+    this.status = status
+    this.type = type
+  }
+}
+
 export async function forwardError(c: Context, error: unknown) {
   consola.error("Error occurred:", error)
 
+  if (error instanceof APIError) {
+    return c.json(
+      {
+        error: {
+          message: error.message,
+          type: error.type,
+        },
+      },
+      error.status,
+    )
+  }
+
   if (error instanceof HTTPError) {
     const errorText = await error.response.text()
     let errorJson: unknown

src/lib/state.ts

@@ -1,8 +1,13 @@
 import type { ModelsResponse } from "~/services/copilot/get-models"
+import type { LingmaRpcClient } from "~/services/lingma/json-rpc"
+
+export type Provider = "copilot" | "lingma"
 
 export interface State {
+  provider: Provider
   githubToken?: string
   copilotToken?: string
+  lingmaClient?: LingmaRpcClient
 
   accountType: string
   models?: ModelsResponse
@@ -18,6 +23,7 @@ export interface State {
 }
 
 export const state: State = {
+  provider: "copilot",
   accountType: "individual",
   manualApprove: false,
   rateLimitWait: false,

src/lib/utils.ts

@@ -2,6 +2,10 @@ import consola from "consola"
 
 import { getModels } from "~/services/copilot/get-models"
 import { getVSCodeVersion } from "~/services/get-vscode-version"
+import {
+  createLingmaModels,
+  parseLingmaModelIds,
+} from "~/services/lingma/models"
 
 import { state } from "./state"
 
@@ -18,6 +22,15 @@ export async function cacheModels(): Promise<void> {
   state.models = models
 }
 
+export async function cacheProviderModels(): Promise<void> {
+  if (state.provider === "lingma") {
+    state.models = createLingmaModels(parseLingmaModelIds())
+    return
+  }
+
+  await cacheModels()
+}
+
 export const cacheVSCodeVersion = async () => {
   const response = await getVSCodeVersion()
   state.vsCodeVersion = response

src/routes/chat-completions/handler.ts

@@ -12,7 +12,7 @@ import {
   createChatCompletions,
   type ChatCompletionResponse,
   type ChatCompletionsPayload,
-} from "~/services/copilot/create-chat-completions"
+} from "~/services/create-chat-completions"
 
 export async function handleCompletion(c: Context) {
   await checkRateLimit(state)

src/routes/embeddings/route.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono"
 
-import { forwardError } from "~/lib/error"
+import { APIError, forwardError } from "~/lib/error"
+import { state } from "~/lib/state"
 import {
   createEmbeddings,
   type EmbeddingRequest,
@@ -10,6 +11,14 @@ export const embeddingRoutes = new Hono()
 
 embeddingRoutes.post("/", async (c) => {
   try {
+    if (state.provider === "lingma") {
+      throw new APIError(
+        "Embeddings are not supported by the Lingma provider in V1",
+        501,
+        "unsupported_feature",
+      )
+    }
+
     const paylod = await c.req.json<EmbeddingRequest>()
     const response = await createEmbeddings(paylod)
 

src/routes/messages/route.ts

@@ -1,6 +1,7 @@
 import { Hono } from "hono"
 
-import { forwardError } from "~/lib/error"
+import { APIError, forwardError } from "~/lib/error"
+import { state } from "~/lib/state"
 
 import { handleCountTokens } from "./count-tokens-handler"
 import { handleCompletion } from "./handler"
@@ -9,6 +10,14 @@ export const messageRoutes = new Hono()
 
 messageRoutes.post("/", async (c) => {
   try {
+    if (state.provider === "lingma") {
+      throw new APIError(
+        "Anthropic messages are not supported by the Lingma provider in V1",
+        501,
+        "unsupported_feature",
+      )
+    }
+
     return await handleCompletion(c)
   } catch (error) {
     return await forwardError(c, error)
@@ -17,6 +26,14 @@ messageRoutes.post("/", async (c) => {
 
 messageRoutes.post("/count_tokens", async (c) => {
   try {
+    if (state.provider === "lingma") {
+      throw new APIError(
+        "Token counting is not supported by the Lingma provider in V1",
+        501,
+        "unsupported_feature",
+      )
+    }
+
     return await handleCountTokens(c)
   } catch (error) {
     return await forwardError(c, error)

src/routes/models/route.ts

@@ -2,15 +2,15 @@ import { Hono } from "hono"
 
 import { forwardError } from "~/lib/error"
 import { state } from "~/lib/state"
-import { cacheModels } from "~/lib/utils"
+import { cacheProviderModels } from "~/lib/utils"
 
 export const modelRoutes = new Hono()
 
 modelRoutes.get("/", async (c) => {
   try {
     if (!state.models) {
       // This should be handled by startup logic, but as a fallback.
-      await cacheModels()
+      await cacheProviderModels()
     }
 
     const models = state.models?.data.map((model) => ({

src/routes/token/route.ts

@@ -1,16 +1,24 @@
 import { Hono } from "hono"
 
+import { APIError, forwardError } from "~/lib/error"
 import { state } from "~/lib/state"
 
 export const tokenRoute = new Hono()
 
 tokenRoute.get("/", (c) => {
   try {
+    if (state.provider === "lingma") {
+      throw new APIError(
+        "Token inspection is not supported by the Lingma provider in V1",
+        501,
+        "unsupported_feature",
+      )
+    }
+
     return c.json({
       token: state.copilotToken,
     })
   } catch (error) {
-    console.error("Error fetching token:", error)
-    return c.json({ error: "Failed to fetch token", token: null }, 500)
+    return forwardError(c, error)
   }
 })

src/routes/usage/route.ts

@@ -1,15 +1,24 @@
 import { Hono } from "hono"
 
+import { APIError, forwardError } from "~/lib/error"
+import { state } from "~/lib/state"
 import { getCopilotUsage } from "~/services/github/get-copilot-usage"
 
 export const usageRoute = new Hono()
 
 usageRoute.get("/", async (c) => {
   try {
+    if (state.provider === "lingma") {
+      throw new APIError(
+        "Usage is not supported by the Lingma provider in V1",
+        501,
+        "unsupported_feature",
+      )
+    }
+
     const usage = await getCopilotUsage()
     return c.json(usage)
   } catch (error) {
-    console.error("Error fetching Copilot usage:", error)
-    return c.json({ error: "Failed to fetch Copilot usage" }, 500)
+    return await forwardError(c, error)
   }
 })

src/services/create-chat-completions.ts

@@ -0,0 +1,28 @@
+import { state } from "~/lib/state"
+
+import type { ChatCompletionsPayload } from "./copilot/create-chat-completions"
+
+import { createChatCompletions as createCopilotChatCompletions } from "./copilot/create-chat-completions"
+import { createLingmaChatCompletions } from "./lingma/create-chat-completions"
+
+export type {
+  ChatCompletionChunk,
+  ChatCompletionResponse,
+  ChatCompletionsPayload,
+  ContentPart,
+  ImagePart,
+  Message,
+  TextPart,
+  Tool,
+  ToolCall,
+} from "./copilot/create-chat-completions"
+
+export const createChatCompletions = async (
+  payload: ChatCompletionsPayload,
+) => {
+  if (state.provider === "lingma") {
+    return await createLingmaChatCompletions(payload)
+  }
+
+  return await createCopilotChatCompletions(payload)
+}