copillm 0.2.3 → 0.2.5

package/dist/server/upstream/streaming.js

@@ -0,0 +1,146 @@
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { openAIToAnthropic, ProtocolTranslationError } from "../../translation/openaiAnthropic.js";
+import { translateOpenAIStreamToAnthropic } from "../../translation/streamingOpenAIToAnthropic.js";
+import { isBenignSocketError, safeSendJson } from "../requestLifecycle.js";
+import { buildUpstreamErrorPayload, formatUpstreamErrorMessage, readUpstreamError, upstreamStatusCategory, writeAnthropicSseError } from "../errors.js";
+export function isEventStream(upstream) {
+    const contentType = upstream.headers.get("content-type");
+    return typeof contentType === "string" && contentType.toLowerCase().includes("text/event-stream");
+}
+export function isStreamingRequestBody(body) {
+    return typeof body === "object" && body !== null && body.stream === true;
+}
+export function beginAnthropicSseResponse(res, req) {
+    if (res.headersSent) {
+        return;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    if (typeof res.flushHeaders === "function") {
+        res.flushHeaders();
+    }
+    const socket = res.socket ?? req?.socket;
+    if (socket && typeof socket.setNoDelay === "function") {
+        socket.setNoDelay(true);
+    }
+}
+export async function forwardResponse(upstream, anthroShape, res, diagnostics) {
+    if (!upstream.ok) {
+        const upstreamError = await readUpstreamError(upstream);
+        const category = upstreamStatusCategory(upstream.status);
+        diagnostics.logger.warn({
+            event: "upstream_non_ok",
+            request_id: diagnostics.requestId,
+            status_code: upstream.status,
+            error: category,
+            upstream_content_type: upstreamError.contentType,
+            upstream_error_code: upstreamError.code,
+            upstream_error_type: upstreamError.type,
+            upstream_error_message: upstreamError.message,
+            upstream_response_bytes: upstreamError.responseBytes
+        }, "upstream request failed");
+        const message = formatUpstreamErrorMessage(category, upstreamError);
+        const prelude = diagnostics.prelude ?? null;
+        if (prelude) {
+            writeAnthropicSseError(res, prelude, message);
+            return;
+        }
+        safeSendJson(res, upstream.status, buildUpstreamErrorPayload(category, upstream.status, diagnostics.requestId, upstreamError, anthroShape));
+        return;
+    }
+    if (isEventStream(upstream)) {
+        if (anthroShape) {
+            if (!upstream.body) {
+                if (diagnostics.prelude) {
+                    writeAnthropicSseError(res, diagnostics.prelude, "invalid_upstream_response");
+                    return;
+                }
+                safeSendJson(res, 502, { error: "invalid_upstream_response", detail: "Upstream stream body is missing." });
+                return;
+            }
+            if (!diagnostics.prelude) {
+                beginAnthropicSseResponse(res);
+            }
+            const upstreamReadable = Readable.fromWeb(upstream.body);
+            await translateOpenAIStreamToAnthropic({
+                upstream: upstreamReadable,
+                downstream: res,
+                fallbackModel: diagnostics.requestedModel,
+                preEmittedMessageId: diagnostics.prelude?.messageId
+            });
+            return;
+        }
+        await pipeEventStream(upstream, res);
+        return;
+    }
+    if (diagnostics.prelude) {
+        writeAnthropicSseError(res, diagnostics.prelude, "invalid_upstream_response");
+        return;
+    }
+    let json;
+    try {
+        json = (await upstream.json());
+    }
+    catch {
+        safeSendJson(res, 502, { error: "invalid_upstream_response" });
+        return;
+    }
+    let payload = json;
+    if (anthroShape) {
+        try {
+            payload = openAIToAnthropic(json);
+        }
+        catch (error) {
+            if (error instanceof ProtocolTranslationError) {
+                safeSendJson(res, 502, { error: error.code, detail: error.message });
+                return;
+            }
+            throw error;
+        }
+    }
+    safeSendJson(res, 200, payload);
+}
+async function pipeEventStream(upstream, res) {
+    if (!upstream.body) {
+        safeSendJson(res, 502, { error: "invalid_upstream_response", detail: "Upstream stream body is missing." });
+        return;
+    }
+    res.statusCode = upstream.status;
+    res.setHeader("Content-Type", "text/event-stream");
+    const cacheControl = upstream.headers.get("cache-control");
+    if (cacheControl) {
+        res.setHeader("Cache-Control", cacheControl);
+    }
+    else {
+        res.setHeader("Cache-Control", "no-cache");
+    }
+    const connection = upstream.headers.get("connection");
+    if (connection) {
+        res.setHeader("Connection", connection);
+    }
+    else {
+        res.setHeader("Connection", "keep-alive");
+    }
+    res.setHeader("X-Accel-Buffering", "no");
+    if (typeof res.flushHeaders === "function") {
+        res.flushHeaders();
+    }
+    if (res.socket && typeof res.socket.setNoDelay === "function") {
+        res.socket.setNoDelay(true);
+    }
+    try {
+        await pipeline(Readable.fromWeb(upstream.body), res);
+    }
+    catch (error) {
+        if (isBenignSocketError(error)) {
+            // Client went away mid-stream — normal for SSE consumers (Codex,
+            // Claude Code, pi) that cancel pending responses on user input.
+            return;
+        }
+        throw error;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copillm",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Local Copilot proxy CLI (OpenAI/Anthropic-compatible)",
   "license": "MIT",
   "type": "module",
@@ -26,7 +26,8 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/cli.ts",
-    "lint": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.tests.json --noEmit",
+    "lint": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.tests.json --noEmit && eslint src",
+    "lint:boundaries": "eslint src",
     "test": "vitest run",
     "test:e2e:pr": "npm run build && tsx tests/e2e/pr-gate-runner.ts",
     "test:e2e:release": "npm run build && tsx tests/e2e/release-runner.ts",
@@ -44,6 +45,10 @@
   },
   "devDependencies": {
     "@types/node": "^20",
+    "@typescript-eslint/parser": "^8.60.0",
+    "eslint": "^10.4.1",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-boundaries": "^6.0.2",
     "tsx": "^4.19.1",
     "typescript": "^5.6.2",
     "vitest": "^2.1.2"