refactor: Simplify error handling and remove unused logging features

Author: ericc-ch

src/routes/chat-completions/handler.ts

@@ -1,107 +1,34 @@
 import type { Context } from "hono"
 
-import consola from "consola"
 import { streamSSE, type SSEMessage } from "hono/streaming"
 
 import type { ChatCompletionsPayload } from "~/services/copilot/chat-completions/types"
-import type { ChatCompletionChunk } from "~/services/copilot/chat-completions/types-streaming"
 
 import { isNullish } from "~/lib/is-nullish"
-import { logger } from "~/lib/logger"
-import { modelsCache } from "~/lib/models"
+import { state } from "~/lib/state"
 import { createChatCompletions } from "~/services/copilot/chat-completions/service"
 import { chatCompletionsStream } from "~/services/copilot/chat-completions/service-streaming"
 
-function createCondensedStreamingResponse(
-  finalChunk: ChatCompletionChunk,
-  collectedContent: string,
-) {
-  return {
-    id: finalChunk.id,
-    model: finalChunk.model,
-    created: finalChunk.created,
-    object: "chat.completion",
-    system_fingerprint: finalChunk.system_fingerprint,
-    usage: finalChunk.usage,
-    choices: [
-      {
-        index: 0,
-        finish_reason: finalChunk.choices[0].finish_reason,
-        message: {
-          role: "assistant",
-          content: collectedContent,
-        },
-        content_filter_results: finalChunk.choices[0].content_filter_results,
-      },
-    ],
-  }
-}
-
 function handleStreaming(c: Context, payload: ChatCompletionsPayload) {
   return streamSSE(c, async (stream) => {
     const response = await chatCompletionsStream(payload)
 
-    // For collecting the complete streaming response
-    let collectedContent = ""
-    let finalChunk: ChatCompletionChunk | null = null
-
     for await (const chunk of response) {
       await stream.writeSSE(chunk as SSEMessage)
-
-      if (!logger.options.enabled) continue
-
-      // Check if chunk data is "DONE" or not a valid JSON string
-      if (!chunk.data || chunk.data === "[DONE]") {
-        continue // Skip processing this chunk for logging
-      }
-
-      try {
-        const data = JSON.parse(chunk.data) as ChatCompletionChunk
-
-        // Keep track of the latest chunk for metadata
-        finalChunk = data
-
-        // Accumulate content from each delta
-        if (typeof data.choices[0].delta.content === "string") {
-          collectedContent += data.choices[0].delta.content
-        }
-      } catch (error) {
-        // Handle JSON parsing errors gracefully
-        consola.error(`Error parsing SSE chunk data`, error)
-        // Continue processing other chunks
-      }
-    }
-
-    // After streaming completes, log the condensed response
-    if (finalChunk) {
-      const condensedResponse = createCondensedStreamingResponse(
-        finalChunk,
-        collectedContent,
-      )
-
-      await logger.logResponse("/chat/completions", condensedResponse, {})
     }
   })
 }
 
 async function handleNonStreaming(c: Context, payload: ChatCompletionsPayload) {
   const response = await createChatCompletions(payload)
-
-  // Get response headers if any
-  const responseHeaders = {} // Empty placeholder for response headers
-
-  // Log the non-streaming response with headers
-  await logger.logResponse("/chat/completions", response, responseHeaders)
-
   return c.json(response)
 }
 
 export async function handleCompletion(c: Context) {
-  const models = modelsCache.getModels()
   let payload = await c.req.json<ChatCompletionsPayload>()
 
   if (isNullish(payload.max_tokens)) {
-    const selectedModel = models?.data.find(
+    const selectedModel = state.models?.data.find(
       (model) => model.id === payload.model,
     )
 
@@ -111,12 +38,6 @@ export async function handleCompletion(c: Context) {
     }
   }
 
-  // Convert request headers to a regular object from Headers
-  const requestHeaders = c.req.header()
-
-  // Log the request at the beginning for both streaming and non-streaming cases
-  await logger.logRequest("/chat/completions", "POST", payload, requestHeaders)
-
   if (payload.stream) {
     return handleStreaming(c, payload)
   }

src/routes/chat-completions/route.ts

@@ -1,11 +1,6 @@
-import type { BlankEnv, BlankInput } from "hono/types"
-import type { ContentfulStatusCode } from "hono/utils/http-status"
-
 import consola from "consola"
-import { Hono, type Context } from "hono"
-import { FetchError } from "ofetch"
+import { Hono } from "hono"
 
-import { logger } from "../../lib/logger"
 import { handleCompletion } from "./handler"
 
 export const completionRoutes = new Hono()
@@ -15,149 +10,27 @@ completionRoutes.post("/", async (c) => {
     return await handleCompletion(c)
   } catch (error) {
     consola.error("Error occurred:", error)
-    return handleError(c, error)
-  }
-})
-
-// Handle different error types with specific handlers
-async function handleError(
-  c: Context<BlankEnv, "/", BlankInput>,
-  error: unknown,
-) {
-  if (error instanceof FetchError) {
-    return handleFetchError(c, error)
-  }
-
-  if (error instanceof Response) {
-    return await handleResponseError(c, error)
-  }
-
-  if (error instanceof Error) {
-    return handleGenericError(c, error)
-  }
-
-  // Fallback for unknown error types
-  void logger.logResponse("/v1/chat/completions", {
-    error: {
-      message: "An unknown error occurred",
-      type: "unknown_error",
-    },
-  })
-
-  return c.json(
-    {
-      error: {
-        message: "An unknown error occurred",
-        type: "unknown_error",
-      },
-    },
-    500,
-  )
-}
-
-function handleFetchError(
-  c: Context<BlankEnv, "/", BlankInput>,
-  error: FetchError,
-) {
-  const status = error.response?.status ?? 500
-  const responseData = error.response?._data as unknown
-  const headers: Record<string, string> = {}
-
-  // Forward all headers from the error response
-  for (const [key, value] of error.response?.headers.entries()) {
-    c.header(key, value)
-    headers[key] = value
-  }
-
-  // Log the error response
-  void logger.logResponse(
-    "/v1/chat/completions",
-    {
-      error: {
-        message: error.message,
-        type: "fetch_error",
-        data: responseData,
-        status,
-      },
-    },
-    headers,
-  )
 
-  return c.json(
-    {
-      error: {
-        message: error.message,
-        type: "fetch_error",
-        data: responseData,
+    if (error instanceof Response) {
+      return c.json(
+        {
+          error: {
+            message: error.message,
+            type: "error",
+          },
+        },
+        500,
+      )
+    }
+
+    return c.json(
+      {
+        error: {
+          message: error.message,
+          type: "error",
+        },
       },
-    },
-    status as ContentfulStatusCode,
-  )
-}
-
-async function handleResponseError(
-  c: Context<BlankEnv, "/", BlankInput>,
-  error: Response,
-) {
-  const errorText = await error.text()
-  consola.error(
-    `Request failed: ${error.status} ${error.statusText}: ${errorText}`,
-  )
-
-  const headers: Record<string, string> = {}
-
-  // Forward all headers from the error response
-  for (const [key, value] of error.headers.entries()) {
-    c.header(key, value)
-    headers[key] = value
+      500,
+    )
   }
-
-  // Log the error response
-  void logger.logResponse(
-    "/v1/chat/completions",
-    {
-      error: {
-        message: error.statusText || "Request failed",
-        type: "response_error",
-        status: error.status,
-        details: errorText,
-      },
-    },
-    headers,
-  )
-
-  return c.json(
-    {
-      error: {
-        message: error.statusText || "Request failed",
-        type: "response_error",
-        status: error.status,
-        details: errorText,
-      },
-    },
-    error.status as ContentfulStatusCode,
-  )
-}
-
-function handleGenericError(
-  c: Context<BlankEnv, "/", BlankInput>,
-  error: Error,
-) {
-  // Log the error response
-  void logger.logResponse("/v1/chat/completions", {
-    error: {
-      message: error.message,
-      type: "error",
-    },
-  })
-
-  return c.json(
-    {
-      error: {
-        message: error.message,
-        type: "error",
-      },
-    },
-    500,
-  )
-}
+})