@code-yeongyu/senpi-ai 2026.9.21-2 → 2026.9.22-2

package/README.md

@@ -458,7 +458,7 @@ Built-in providers resolve these env vars (Node.js; in browsers pass `apiKey` ex
 | Moonshot AI / Moonshot AI (China) | `MOONSHOT_API_KEY` |
 | Hugging Face | `HF_TOKEN` |
 | OpenCode Zen / OpenCode Go | `OPENCODE_API_KEY` |
-| Kimi For Coding | `KIMI_API_KEY` |
+| Kimi For Coding | `KIMI_API_KEY` (+ `KIMI_CODE_REGION`) |
 | Qwen Token Plan (existing catalog) | `QWEN_TOKEN_PLAN_API_KEY` |
 | Qwen Token Plan (Individual) | `QWEN_TOKEN_PLAN_API_KEY` |
 | Qwen Token Plan (China) | `QWEN_TOKEN_PLAN_CN_API_KEY` |

package/dist/api/openai-codex-responses.js

@@ -26,6 +26,7 @@ import { applyOpenAICodexCacheAffinityHeaders, clampOpenAIPromptCacheKey } from
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream } from "./openai-responses-shared.js";
 import { applyExtraBody, buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS, } from "./simple-options.js";
 import { startWebSocketLiveness } from "./websocket-liveness.js";
+import { createWebSocketTransportFailure } from "./websocket-transport-failure.js";
 // ============================================================================
 // Configuration
 // ============================================================================
@@ -38,7 +39,6 @@ const DEFAULT_WEBSOCKET_CONNECT_TIMEOUT_MS = 15_000;
 // endpoint (the same endpoint the official Codex client compresses against).
 const REQUEST_COMPRESSION_ZSTD_LEVEL = 3;
 const CODEX_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
-const WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE = 1009;
 const CODEX_PREVIOUS_RESPONSE_STALE_CODES = new Set(["codex_previous_response_stale"]);
 const WEBSOCKET_CONNECTION_LIMIT_REACHED_CODE = "websocket_connection_limit_reached";
 const PREVIOUS_RESPONSE_NOT_FOUND_CODE = "previous_response_not_found";
@@ -756,15 +756,6 @@ async function getWebSocketConstructor(env) {
 function isWebSocketConstructor(value) {
     return typeof value === "function";
 }
-class WebSocketCloseError extends Error {
-    constructor(message, options) {
-        super(message);
-        this.name = "WebSocketCloseError";
-        this.code = options?.code;
-        this.reason = options?.reason;
-        this.wasClean = options?.wasClean;
-    }
-}
 function getWebSocketReadyState(socket) {
     const readyState = socket.readyState;
     return typeof readyState === "number" ? readyState : undefined;
@@ -849,6 +840,7 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
                 clearTimeout(timeout);
                 timeout = undefined;
             }
+            transportFailure.dispose();
             socket.removeEventListener("open", onOpen);
             socket.removeEventListener("error", onError);
             socket.removeEventListener("close", onClose);
@@ -864,6 +856,7 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
             }
             reject(error);
         };
+        const transportFailure = createWebSocketTransportFailure((error) => fail(error));
         const onOpen = () => {
             if (settled)
                 return;
@@ -872,10 +865,10 @@ async function connectWebSocket(url, headers, signal, connectTimeoutMs = DEFAULT
             resolve(socket);
         };
         const onError = (event) => {
-            fail(extractWebSocketError(event));
+            transportFailure.onError(event);
         };
         const onClose = (event) => {
-            fail(extractWebSocketCloseError(event));
+            transportFailure.onClose(event);
         };
         const onAbort = () => {
             fail(new Error("Request was aborted"), "aborted");
@@ -978,43 +971,6 @@ async function acquireWebSocket(url, headers, sessionId, accountId, signal, conn
         },
     };
 }
-function extractWebSocketError(event) {
-    if (event && typeof event === "object") {
-        const message = "message" in event ? event.message : undefined;
-        if (typeof message === "string" && message.length > 0) {
-            return new Error(message);
-        }
-        const nestedError = "error" in event ? event.error : undefined;
-        if (nestedError instanceof Error && nestedError.message.length > 0) {
-            return nestedError;
-        }
-        if (nestedError && typeof nestedError === "object" && "message" in nestedError) {
-            const nestedMessage = nestedError.message;
-            if (typeof nestedMessage === "string" && nestedMessage.length > 0) {
-                return new Error(nestedMessage);
-            }
-        }
-    }
-    return new Error("WebSocket error");
-}
-function extractWebSocketCloseError(event) {
-    if (event && typeof event === "object") {
-        const code = "code" in event ? event.code : undefined;
-        const reason = "reason" in event ? event.reason : undefined;
-        const wasClean = "wasClean" in event ? event.wasClean : undefined;
-        const codeText = typeof code === "number" ? ` ${code}` : "";
-        let reasonText = typeof reason === "string" && reason.length > 0 ? ` ${reason}` : "";
-        if (!reasonText && code === WEBSOCKET_MESSAGE_TOO_BIG_CLOSE_CODE) {
-            reasonText = " message too big";
-        }
-        return new WebSocketCloseError(`WebSocket closed${codeText}${reasonText}`.trim(), {
-            code: typeof code === "number" ? code : undefined,
-            reason: typeof reason === "string" && reason.length > 0 ? reason : undefined,
-            wasClean: typeof wasClean === "boolean" ? wasClean : undefined,
-        });
-    }
-    return new Error("WebSocket closed");
-}
 async function decodeWebSocketData(data) {
     if (typeof data === "string")
         return data;
@@ -1080,22 +1036,23 @@ async function* parseWebSocket(socket, signal, idleTimeoutMs) {
             }
         })();
     };
-    const onError = (event) => {
-        failed = extractWebSocketError(event);
+    const transportFailure = createWebSocketTransportFailure((error) => {
+        if (!failed)
+            failed = error;
         done = true;
         wake();
+    });
+    const onError = (event) => {
+        transportFailure.onError(event);
     };
     const onClose = (event) => {
         if (sawCompletion) {
+            transportFailure.dispose();
             done = true;
             wake();
             return;
         }
-        if (!failed) {
-            failed = extractWebSocketCloseError(event);
-        }
-        done = true;
-        wake();
+        transportFailure.onClose(event);
     };
     const onAbort = () => {
         failed = new Error("Request was aborted");
@@ -1145,6 +1102,7 @@ async function* parseWebSocket(socket, signal, idleTimeoutMs) {
     }
     finally {
         liveness.stop();
+        transportFailure.dispose();
         socket.removeEventListener("message", onMessage);
         socket.removeEventListener("error", onError);
         socket.removeEventListener("close", onClose);