add bun idleTimeout = 0 and revert "fix stream event idle for 10s, claude code will retry the request with stream=false"

Author: caozhiyuan

src/lib/utils.ts

@@ -24,25 +24,3 @@ export const cacheVSCodeVersion = async () => {
 
   consola.info(`Using VSCode version: ${response}`)
 }
-
-export const setupPingInterval = (
-  stream: {
-    writeSSE: (data: { event: string; data: string }) => Promise<void>
-  },
-  intervalMs: number = 3000,
-) => {
-  const pingInterval = setInterval(async () => {
-    try {
-      await stream.writeSSE({
-        event: "ping",
-        data: "",
-      })
-      consola.debug("Sent ping")
-    } catch (error) {
-      consola.warn("Failed to send ping:", error)
-      clearInterval(pingInterval)
-    }
-  }, intervalMs)
-
-  return pingInterval
-}

src/routes/chat-completions/handler.ts

@@ -7,7 +7,6 @@ import { awaitApproval } from "~/lib/approval"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
 import { getTokenCount } from "~/lib/tokenizer"
-import { setupPingInterval } from "~/lib/utils"
 import { isNullish } from "~/lib/utils"
 import {
   createChatCompletions,
@@ -57,15 +56,9 @@ export async function handleCompletion(c: Context) {
 
   consola.debug("Streaming response")
   return streamSSE(c, async (stream) => {
-    const pingInterval = setupPingInterval(stream)
-
-    try {
-      for await (const chunk of response) {
-        consola.debug("Streaming chunk:", JSON.stringify(chunk))
-        await stream.writeSSE(chunk as SSEMessage)
-      }
-    } finally {
-      clearInterval(pingInterval)
+    for await (const chunk of response) {
+      consola.debug("Streaming chunk:", JSON.stringify(chunk))
+      await stream.writeSSE(chunk as SSEMessage)
     }
   })
 }

src/routes/messages/handler.ts

@@ -6,7 +6,6 @@ import { streamSSE } from "hono/streaming"
 import { awaitApproval } from "~/lib/approval"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
-import { setupPingInterval } from "~/lib/utils"
 import {
   createResponsesStreamState,
   translateResponsesStreamEvent,
@@ -85,39 +84,33 @@ const handleWithChatCompletions = async (
 
   consola.debug("Streaming response from Copilot")
   return streamSSE(c, async (stream) => {
-    const pingInterval = setupPingInterval(stream)
-
     const streamState: AnthropicStreamState = {
       messageStartSent: false,
       contentBlockIndex: 0,
       contentBlockOpen: false,
       toolCalls: {},
     }
 
-    try {
-      for await (const rawEvent of response) {
-        consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent))
-        if (rawEvent.data === "[DONE]") {
-          break
-        }
+    for await (const rawEvent of response) {
+      consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent))
+      if (rawEvent.data === "[DONE]") {
+        break
+      }
 
-        if (!rawEvent.data) {
-          continue
-        }
+      if (!rawEvent.data) {
+        continue
+      }
 
-        const chunk = JSON.parse(rawEvent.data) as ChatCompletionChunk
-        const events = translateChunkToAnthropicEvents(chunk, streamState)
+      const chunk = JSON.parse(rawEvent.data) as ChatCompletionChunk
+      const events = translateChunkToAnthropicEvents(chunk, streamState)
 
-        for (const event of events) {
-          consola.debug("Translated Anthropic event:", JSON.stringify(event))
-          await stream.writeSSE({
-            event: event.type,
-            data: JSON.stringify(event),
-          })
-        }
+      for (const event of events) {
+        consola.debug("Translated Anthropic event:", JSON.stringify(event))
+        await stream.writeSSE({
+          event: event.type,
+          data: JSON.stringify(event),
+        })
       }
-    } finally {
-      clearInterval(pingInterval)
     }
   })
 }
@@ -142,51 +135,45 @@ const handleWithResponsesApi = async (
   if (responsesPayload.stream && isAsyncIterable(response)) {
     consola.debug("Streaming response from Copilot (Responses API)")
     return streamSSE(c, async (stream) => {
-      const pingInterval = setupPingInterval(stream)
-
       const streamState = createResponsesStreamState()
 
-      try {
-        for await (const chunk of response) {
-          const eventName = chunk.event
-          if (eventName === "ping") {
-            await stream.writeSSE({ event: "ping", data: "" })
-            continue
-          }
-
-          const data = chunk.data
-          if (!data) {
-            continue
-          }
-
-          consola.debug("Responses raw stream event:", data)
-
-          const events = translateResponsesStreamEvent(
-            JSON.parse(data) as ResponseStreamEvent,
-            streamState,
-          )
-          for (const event of events) {
-            const eventData = JSON.stringify(event)
-            consola.debug("Translated Anthropic event:", eventData)
-            await stream.writeSSE({
-              event: event.type,
-              data: eventData,
-            })
-          }
+      for await (const chunk of response) {
+        const eventName = chunk.event
+        if (eventName === "ping") {
+          await stream.writeSSE({ event: "ping", data: "" })
+          continue
+        }
+
+        const data = chunk.data
+        if (!data) {
+          continue
         }
 
-        if (!streamState.messageCompleted) {
-          consola.warn(
-            "Responses stream ended without completion; sending fallback message_stop",
-          )
-          const fallback = { type: "message_stop" as const }
+        consola.debug("Responses raw stream event:", data)
+
+        const events = translateResponsesStreamEvent(
+          JSON.parse(data) as ResponseStreamEvent,
+          streamState,
+        )
+        for (const event of events) {
+          const eventData = JSON.stringify(event)
+          consola.debug("Translated Anthropic event:", eventData)
           await stream.writeSSE({
-            event: fallback.type,
-            data: JSON.stringify(fallback),
+            event: event.type,
+            data: eventData,
           })
         }
-      } finally {
-        clearInterval(pingInterval)
+      }
+
+      if (!streamState.messageCompleted) {
+        consola.warn(
+          "Responses stream ended without completion; sending fallback message_stop",
+        )
+        const fallback = { type: "message_stop" as const }
+        await stream.writeSSE({
+          event: fallback.type,
+          data: JSON.stringify(fallback),
+        })
       }
     })
   }

src/routes/responses/handler.ts

@@ -6,7 +6,6 @@ import { streamSSE } from "hono/streaming"
 import { awaitApproval } from "~/lib/approval"
 import { checkRateLimit } from "~/lib/rate-limit"
 import { state } from "~/lib/state"
-import { setupPingInterval } from "~/lib/utils"
 import {
   createResponses,
   type ResponsesPayload,
@@ -53,7 +52,17 @@ export const handleResponses = async (c: Context) => {
   if (isStreamingRequested(payload) && isAsyncIterable(response)) {
     consola.debug("Forwarding native Responses stream")
     return streamSSE(c, async (stream) => {
-      const pingInterval = setupPingInterval(stream)
+      const pingInterval = setInterval(async () => {
+        try {
+          await stream.writeSSE({
+            event: "ping",
+            data: JSON.stringify({ timestamp: Date.now() }),
+          })
+        } catch (error) {
+          consola.warn("Failed to send ping:", error)
+          clearInterval(pingInterval)
+        }
+      }, 3000)
 
       try {
         for await (const chunk of response) {