refactor: Refactor error handling and copilot API calls

Author: ericc-ch

bun.lock

@@ -43,9 +43,7 @@
     "consola": "^3.4.0",
     "fetch-event-stream": "^0.1.5",
     "hono": "^4.7.4",
-    "ofetch": "^1.4.1",
-    "srvx": "^0.2.5",
-    "zod": "^3.24.2"
+    "srvx": "^0.2.5"
   },
   "devDependencies": {
     "@echristian/eslint-config": "^0.0.32",

package.json

@@ -12,7 +12,14 @@ export const COPILOT_API_CONFIG = {
 export const COPILOT_API_BASE_URL = "https://api.individual.githubcopilot.com"
 export const copilotHeaders = (state: State) => ({
   Authorization: `Bearer ${state.copilotToken}`,
+  "content-type": "application/json",
   "copilot-integration-id": "vscode-chat",
+  "editor-version": `vscode/${state.vsCodeVersion}`,
+  "editor-plugin-version": "copilot-chat/0.24.1",
+  "openai-intent": "conversation-panel",
+  "x-github-api-version": "2024-12-15",
+  "x-request-id": globalThis.crypto.randomUUID(),
+  "x-vscode-user-agent-library-version": "electron-fetch",
 })
 
 export const GITHUB_API_BASE_URL = "https://api.github.com"

src/lib/api-config.ts

@@ -0,0 +1,32 @@
+import type { Context } from "hono"
+import type { ContentfulStatusCode } from "hono/utils/http-status"
+
+import consola from "consola"
+
+import { HTTPError } from "./http-error"
+
+export async function forwardError(c: Context, error: unknown) {
+  consola.error("Error occurred:", error)
+
+  if (error instanceof HTTPError) {
+    return c.json(
+      {
+        error: {
+          message: await error.response.text(),
+          type: "error",
+        },
+      },
+      error.response.status as ContentfulStatusCode,
+    )
+  }
+
+  return c.json(
+    {
+      error: {
+        message: (error as Error).message,
+        type: "error",
+      },
+    },
+    500,
+  )
+}

src/lib/forward-error.ts

@@ -0,0 +1,8 @@
+export class HTTPError extends Error {
+  response: Response
+
+  constructor(message: string, response: Response) {
+    super(message)
+    this.response = response
+  }
+}

src/lib/http-error.ts

@@ -2,27 +2,14 @@ import type { Context } from "hono"
 
 import { streamSSE, type SSEMessage } from "hono/streaming"
 
-import type { ChatCompletionsPayload } from "~/services/copilot/chat-completions/types"
+import type {
+  ChatCompletionResponse,
+  ChatCompletionsPayload,
+} from "~/services/copilot/chat-completions/types"
 
 import { isNullish } from "~/lib/is-nullish"
 import { state } from "~/lib/state"
-import { createChatCompletions } from "~/services/copilot/chat-completions/service"
-import { chatCompletionsStream } from "~/services/copilot/chat-completions/service-streaming"
-
-function handleStreaming(c: Context, payload: ChatCompletionsPayload) {
-  return streamSSE(c, async (stream) => {
-    const response = await chatCompletionsStream(payload)
-
-    for await (const chunk of response) {
-      await stream.writeSSE(chunk as SSEMessage)
-    }
-  })
-}
-
-async function handleNonStreaming(c: Context, payload: ChatCompletionsPayload) {
-  const response = await createChatCompletions(payload)
-  return c.json(response)
-}
+import { createChatCompletions } from "~/services/copilot/create-chat-completions"
 
 export async function handleCompletion(c: Context) {
   let payload = await c.req.json<ChatCompletionsPayload>()
@@ -38,9 +25,19 @@ export async function handleCompletion(c: Context) {
     }
   }
 
-  if (payload.stream) {
-    return handleStreaming(c, payload)
+  const response = await createChatCompletions(payload)
+
+  if (isNonStreaming(response)) {
+    return c.json(response)
   }
 
-  return handleNonStreaming(c, payload)
+  return streamSSE(c, async (stream) => {
+    for await (const chunk of response) {
+      await stream.writeSSE(chunk as SSEMessage)
+    }
+  })
 }
+
+const isNonStreaming = (
+  response: Awaited<ReturnType<typeof createChatCompletions>>,
+): response is ChatCompletionResponse => Object.hasOwn(response, "choices")

src/routes/chat-completions/handler.ts

@@ -1,6 +1,7 @@
-import consola from "consola"
 import { Hono } from "hono"
 
+import { forwardError } from "~/lib/forward-error"
+
 import { handleCompletion } from "./handler"
 
 export const completionRoutes = new Hono()
@@ -9,28 +10,6 @@ completionRoutes.post("/", async (c) => {
   try {
     return await handleCompletion(c)
   } catch (error) {
-    consola.error("Error occurred:", error)
-
-    if (error instanceof Response) {
-      return c.json(
-        {
-          error: {
-            message: error.message,
-            type: "error",
-          },
-        },
-        500,
-      )
-    }
-
-    return c.json(
-      {
-        error: {
-          message: error.message,
-          type: "error",
-        },
-      },
-      500,
-    )
+    return forwardError(c, error)
   }
 })

src/routes/chat-completions/route.ts

@@ -1,23 +1,20 @@
-import consola from "consola"
 import { Hono } from "hono"
-import { FetchError } from "ofetch"
 
-import type { EmbeddingRequest } from "~/services/copilot/embedding/types"
-
-import { createEmbeddings } from "~/services/copilot/create-embeddings"
+import { forwardError } from "~/lib/forward-error"
+import {
+  createEmbeddings,
+  type EmbeddingRequest,
+} from "~/services/copilot/create-embeddings"
 
 export const embeddingRoutes = new Hono()
 
 embeddingRoutes.post("/", async (c) => {
   try {
-    const embeddings = await createEmbeddings(
-      await c.req.json<EmbeddingRequest>(),
-    )
-    return c.json(embeddings)
+    const paylod = await c.req.json<EmbeddingRequest>()
+    const response = await createEmbeddings(paylod)
+
+    return c.json(response)
   } catch (error) {
-    if (error instanceof FetchError) {
-      consola.error(`Request failed: ${error.message}`, error.response?._data)
-    }
-    throw error
+    return forwardError(c, error)
   }
 })