refactor: organize init

Author: ericc-ch

src/main.ts

@@ -9,47 +9,66 @@ import { getModels } from "./services/copilot/get-models/service"
 import { getCopilotToken } from "./services/copilot/get-token/copilot-token"
 import { getGitHubToken } from "./services/copilot/get-token/github-token"
 
-if (!fs.existsSync(PATHS.PATH_CACHE_FILE)) {
-  fs.mkdirSync(PATHS.DIR_CACHE, { recursive: true })
-  await CACHE._write({})
+async function initializeGithubToken() {
+  const EIGHT_HOURS = 8 * 60 * 60 * 1000
+  const cachedGithubToken = await CACHE.get("github-token")
+
+  // If exists and at most 8 hours old
+  if (
+    cachedGithubToken &&
+    Date.now() - cachedGithubToken.createdAt < EIGHT_HOURS
+  ) {
+    return cachedGithubToken.value
+  }
+
+  const newToken = await getGitHubToken()
+  await CACHE.set("github-token", newToken)
+  return newToken
 }
 
-let githubToken: string
+async function initializeCopilotToken() {
+  const { token, refresh_in } = await getCopilotToken()
+  TOKENS.COPILOT_TOKEN = token
 
-const cachedGithubToken = await CACHE.get("github-token")
+  // refresh_in is in minutes
+  // we're refreshing 100 minutes early
+  const refreshInterval = (refresh_in - 100) * 60 * 1000
 
-const EIGHT_HOURS = 8 * 60 * 60 * 1000
+  setInterval(async () => {
+    consola.start("Refreshing copilot token")
+    const { token: newToken } = await getCopilotToken()
+    TOKENS.COPILOT_TOKEN = newToken
+  }, refreshInterval)
 
-// If exists and at most 8 hours old
-if (
-  cachedGithubToken &&
-  Date.now() - cachedGithubToken.createdAt < EIGHT_HOURS
-) {
-  githubToken = cachedGithubToken.value
-} else {
-  githubToken = await getGitHubToken()
-  await CACHE.set("github-token", githubToken)
+  return token
 }
 
-TOKENS.GITHUB_TOKEN = githubToken
+async function initializeCache() {
+  if (!fs.existsSync(PATHS.PATH_CACHE_FILE)) {
+    fs.mkdirSync(PATHS.DIR_CACHE, { recursive: true })
+    await CACHE._write({})
+  }
+}
 
-const { token: copilotToken, refresh_in } = await getCopilotToken()
-TOKENS.COPILOT_TOKEN = copilotToken
+async function logAvailableModels() {
+  const models = await getModels()
+  consola.info(
+    `Available models: \n${models.data.map((model) => `- ${model.id}`).join("\n")}`,
+  )
+}
 
-// refresh_in is in minutes
-// we're refreshing 100 minutes early
-const refreshInterval = (refresh_in - 100) * 60 * 1000
+async function initialize() {
+  await initializeCache()
 
-setInterval(async () => {
-  consola.start("Refreshing copilot token")
-  const { token: copilotToken } = await getCopilotToken()
-  TOKENS.COPILOT_TOKEN = copilotToken
-}, refreshInterval)
+  // Initialize tokens
+  TOKENS.GITHUB_TOKEN = await initializeGithubToken()
+  await initializeCopilotToken()
 
-const models = await getModels()
+  // Log available models
+  await logAvailableModels()
+}
 
-consola.info(
-  `Available models: \n${models.data.map((model) => `- ${model.id}`).join("\n")}`,
-)
+// Initialize the application
+await initialize()
 
 export default server

src/routes/chat-completions/route.ts

@@ -15,7 +15,7 @@ chatCompletionsRoutes.post("/chat/completions", async (c) => {
 
   payload.stream = false
 
-  consola.info(`Received request: ${JSON.stringify(payload).slice(0, 100)}`)
+  consola.info(`Received request: ${JSON.stringify(payload).slice(0, 500)}`)
 
   const response = await chatCompletions(payload).catch((error: unknown) => {
     if (error instanceof FetchError) {
@@ -36,9 +36,10 @@ chatCompletionsRoutes.post("/chat/completions", async (c) => {
     response.choices[0].message.content,
   )
 
-  let chunks: Array<ChatCompletionsChunk> = Array.from(segmentedMessages).map(
+  const chunks: Array<ChatCompletionsChunk> = Array.from(segmentedMessages).map(
     (segment) => ({
       data: {
+        object: "chat.completion.chunk",
         choices: [
           {
             delta: {
@@ -50,31 +51,16 @@ chatCompletionsRoutes.post("/chat/completions", async (c) => {
         ],
         created: response.created,
         id: response.id,
-        // Aider expects the model to be the same as the one used in the request
         model: payload.model,
-        usage: response.usage,
+        usage: null,
+        system_fingerprint: "fp_44709d6fcb",
       },
     }),
   )
 
-  const usagePerChunk: ChatCompletionsChunk["data"]["usage"] = {
-    completion_tokens: Math.round(
-      response.usage.completion_tokens / chunks.length,
-    ),
-    prompt_tokens: Math.round(response.usage.prompt_tokens / chunks.length),
-    total_tokens: Math.round(response.usage.total_tokens / chunks.length),
-  }
-
-  chunks = chunks.map((chunk) => ({
-    ...chunk,
-    data: {
-      ...chunk.data,
-      usage: usagePerChunk,
-    },
-  }))
-
   chunks.push({
     data: {
+      object: "chat.completion.chunk",
       choices: [
         {
           delta: {},
@@ -84,17 +70,13 @@ chatCompletionsRoutes.post("/chat/completions", async (c) => {
       ],
       created: response.created,
       id: response.id,
-      // Aider expects the model to be the same as the one used in the request
       model: payload.model,
-      usage: {
-        completion_tokens: 0,
-        prompt_tokens: 0,
-        total_tokens: 0,
-      },
+      usage: response.usage,
+      system_fingerprint: "fp_44709d6fcb",
     },
   })
 
-  console.info(
+  consola.info(
     `Streaming response, first chunk: ${JSON.stringify(chunks.at(0))}`,
   )
 

src/services/copilot/chat-completions/types.streaming.ts

@@ -54,11 +54,12 @@ interface Usage {
 interface ChatCompletionResponse {
   choices: [Choice]
   created: number
+  object: "chat.completion.chunk"
   id: string
   model: string
   system_fingerprint?: string
   prompt_filter_results?: Array<PromptFilterResult>
-  usage?: Usage
+  usage?: Usage | null
 }
 
 export interface ChatCompletionsChunk {