copillm 0.1.4 → 0.2.0

package/dist/translation/streamingOpenAIToAnthropic.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { isBenignSocketError } from "../server/requestLifecycle.js";
 const PING_INTERVAL_MS = 1000;
 export async function translateOpenAIStreamToAnthropic(options) {
     const { upstream, downstream } = options;
@@ -16,11 +17,37 @@ export async function translateOpenAIStreamToAnthropic(options) {
     let nextAnthropicIndex = 0;
     let streamErrored = false;
     let pingTimer = null;
+    let downstreamGone = false;
+    function isDownstreamAlive() {
+        if (downstreamGone)
+            return false;
+        return downstream.writable && !downstream.writableEnded && !downstream.destroyed;
+    }
+    function markDownstreamGone() {
+        if (downstreamGone)
+            return;
+        downstreamGone = true;
+        stopPings();
+        // Best-effort: also stop reading upstream so we don't pull a megabyte
+        // of SSE we'll never deliver.
+        try {
+            upstream.destroy();
+        }
+        catch {
+            // ignore
+        }
+    }
+    downstream.on("close", markDownstreamGone);
+    downstream.on("error", markDownstreamGone);
     function startPings() {
         if (pingTimer !== null) {
             return;
         }
         pingTimer = setInterval(() => {
+            if (!isDownstreamAlive()) {
+                stopPings();
+                return;
+            }
             writeEvent("ping", { type: "ping" });
         }, PING_INTERVAL_MS);
         if (typeof pingTimer.unref === "function") {
@@ -34,7 +61,20 @@ export async function translateOpenAIStreamToAnthropic(options) {
         }
     }
     function writeEvent(eventName, data) {
-        downstream.write(`event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`);
+        if (!isDownstreamAlive()) {
+            markDownstreamGone();
+            return;
+        }
+        try {
+            downstream.write(`event: ${eventName}\ndata: ${JSON.stringify(data)}\n\n`);
+        }
+        catch (error) {
+            if (isBenignSocketError(error)) {
+                markDownstreamGone();
+                return;
+            }
+            throw error;
+        }
     }
     function emitMessageStart() {
         if (messageStarted) {
@@ -198,6 +238,10 @@ export async function translateOpenAIStreamToAnthropic(options) {
     startPings();
     try {
         for await (const chunk of upstream) {
+            if (!isDownstreamAlive()) {
+                markDownstreamGone();
+                return;
+            }
             const text = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
             buffer += text;
             let newlineIndex;
@@ -213,8 +257,15 @@ export async function translateOpenAIStreamToAnthropic(options) {
         }
     }
     catch (error) {
-        streamErrored = true;
         stopPings();
+        if (!isDownstreamAlive() || isBenignSocketError(error)) {
+            // Either we destroyed the upstream because downstream went away, or
+            // the upstream rejected with a benign socket error. Either way, no
+            // recovery write is possible — just stop.
+            markDownstreamGone();
+            return;
+        }
+        streamErrored = true;
         emitMessageStart();
         closeAllBlocks();
         writeEvent("message_delta", {
@@ -227,13 +278,16 @@ export async function translateOpenAIStreamToAnthropic(options) {
             error: { type: "api_error", message: error instanceof Error ? error.message : "upstream stream error" }
         });
         writeEvent("message_stop", { type: "message_stop" });
-        downstream.end();
+        safeEndDownstream();
         return;
     }
     if (streamErrored) {
         return;
     }
     stopPings();
+    if (!isDownstreamAlive()) {
+        return;
+    }
     emitMessageStart();
     closeAllBlocks();
     writeEvent("message_delta", {
@@ -242,7 +296,18 @@ export async function translateOpenAIStreamToAnthropic(options) {
         usage: { input_tokens: inputTokens, output_tokens: outputTokens, cache_read_input_tokens: cacheReadTokens }
     });
     writeEvent("message_stop", { type: "message_stop" });
-    downstream.end();
+    safeEndDownstream();
+    function safeEndDownstream() {
+        if (downstream.writableEnded || downstream.destroyed)
+            return;
+        try {
+            downstream.end();
+        }
+        catch (error) {
+            if (!isBenignSocketError(error))
+                throw error;
+        }
+    }
 }
 /**
  * Write the Anthropic `message_start` event (and an initial ping) to the
@@ -269,8 +334,14 @@ export function writeAnthropicPrelude(downstream, model) {
             usage: { input_tokens: 0, cache_read_input_tokens: 0, output_tokens: 0 }
         }
     };
-    downstream.write(`event: message_start\ndata: ${JSON.stringify(messageStart)}\n\n`);
-    downstream.write(`event: ping\ndata: ${JSON.stringify({ type: "ping" })}\n\n`);
+    try {
+        downstream.write(`event: message_start\ndata: ${JSON.stringify(messageStart)}\n\n`);
+        downstream.write(`event: ping\ndata: ${JSON.stringify({ type: "ping" })}\n\n`);
+    }
+    catch (error) {
+        if (!isBenignSocketError(error))
+            throw error;
+    }
     return { messageId };
 }
 function mapFinishReason(reason) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",