@jeffusion/bungee-core 5.4.1 → 5.4.3

package/dist/plugins/chatgpt-oauth/index.js

@@ -14823,15 +14823,47 @@ function definePlugin(plugin) {
   return plugin;
 }
 
+// plugins/chatgpt-oauth/server/error-diagnostics.ts
+var MAX_MESSAGE_CHARS = 1024;
+function errorDiagnostic(value, source, fallback, redact) {
+  const object = value !== null && typeof value === "object" ? value : {};
+  const clean = (value) => {
+    let text = value.slice(0, 16384);
+    text = redact?.(text) ?? text;
+    text = text.replace(/\bBearer\s+[^\s,;"'<>]+/gi, "Bearer [REDACTED]").replace(/\b(?:sk-[\w-]+|eyJ[\w-]+\.[\w-]+\.[\w-]+)/g, "[REDACTED]").replace(/((?:authorization|access_token|refresh_token|id_token|api[_-]?key|cookie)["']?\s*[=:]\s*["']?)[^\s,;&"'<>]+/gi, "$1[REDACTED]").replace(/[\x00-\x1f\x7f]+/g, " ");
+    return text.slice(0, MAX_MESSAGE_CHARS).trim();
+  };
+  const identifier = (value) => {
+    if (typeof value !== "string")
+      return;
+    const text = clean(value);
+    return /^[a-zA-Z0-9_.-]{1,128}$/.test(text) ? text : undefined;
+  };
+  const cause = source === "transport" && object.cause !== null && typeof object.cause === "object" ? object.cause : {};
+  const message = clean([
+    typeof object.message === "string" ? object.message : "",
+    typeof cause.message === "string" ? cause.message : ""
+  ].filter(Boolean).join("; "));
+  const code = identifier(object.code ?? cause.code);
+  const type = identifier(source === "transport" ? object.name ?? object.type : object.type);
+  return { source, message: message || fallback, ...code ? { code } : {}, ...type ? { type } : {} };
+}
+function upstreamErrorDiagnostic(value, fallback, redact) {
+  const object = value !== null && typeof value === "object" ? value : {};
+  return errorDiagnostic(object.response?.error ?? object.error ?? object, "upstream", fallback, redact);
+}
+
 // plugins/chatgpt-oauth/server/codex-protocol.ts
 class CodexProtocolError extends Error {
   kind;
   reason;
-  constructor(kind, message, reason) {
+  diagnostic;
+  constructor(kind, message, reason, diagnostic) {
     super(message);
     this.name = "CodexProtocolError";
     this.kind = kind;
     this.reason = reason;
+    this.diagnostic = diagnostic;
   }
 }
 var UNSUPPORTED_RESPONSES_FIELDS = [
@@ -15349,9 +15381,11 @@ class CodexResponseProcessor {
   toolIndex = 0;
   outputOrder = 0;
   sawDone = false;
+  redactDiagnostic;
   constructor(options = {}) {
     this.includeUsage = options.includeUsage ?? (options.request ? streamIncludesUsage(options.request) : false);
     this.target = options.target ?? "chat";
+    this.redactDiagnostic = options.redactDiagnostic;
   }
   validateOutputItem(item) {
     if (this.target === "responses")
@@ -15456,18 +15490,18 @@ class CodexResponseProcessor {
       return [];
     }
     if (type === "response.failed" || data.response?.status === "failed")
-      throw new CodexProtocolError("failed", "Codex response failed");
+      throw new CodexProtocolError("failed", "Codex response failed", undefined, upstreamErrorDiagnostic(data, "Codex response failed", this.redactDiagnostic));
     if (this.sawDone && !this.terminal)
       throw new CodexProtocolError("incomplete", "Codex emitted an event after [DONE] without a terminal response");
     if (this.terminal) {
       if (type === "error" || type === "response.failed")
-        throw new CodexProtocolError("failed", "Codex response failed after terminal event");
+        throw new CodexProtocolError("failed", "Codex response failed after terminal event", undefined, upstreamErrorDiagnostic(data, "Codex response failed after terminal event", this.redactDiagnostic));
       if (type === "response.completed" || type === "response.incomplete")
         return [];
       return [];
     }
     if (type === "error")
-      throw new CodexProtocolError("failed", "Codex response contained an error event");
+      throw new CodexProtocolError("failed", "Codex response contained an error event", undefined, upstreamErrorDiagnostic(data, "Codex response contained an error event", this.redactDiagnostic));
     if (type === "response.created" || type === "response.in_progress") {
       const response = data.response ?? {};
       this.responseId ||= String(response.id ?? "");
@@ -15861,10 +15895,10 @@ function responseHeaders(response, contentType) {
   headers.set("content-type", contentType);
   return headers;
 }
-function safeErrorBody() {
-  return JSON.stringify({ error: { message: "Upstream response could not be adapted", type: "upstream_error", code: "upstream_error" } });
+function errorBody(error, fallbackCode = "upstream_error") {
+  return { message: error?.message ?? "Upstream response could not be adapted", type: error?.type ?? "upstream_error", code: error?.code ?? fallbackCode };
 }
-function completionFromError(error) {
+function completionFromError(error, redact) {
   if (error instanceof CodexProtocolError) {
     if (error.kind === "cancelled")
       return { status: "cancelled" };
@@ -15872,12 +15906,54 @@ function completionFromError(error) {
       return { status: "incomplete", code: "incomplete" };
     if (error.kind === "unexpected_eof")
       return { status: "failed", code: "unexpected_eof" };
-    return { status: "failed", code: error.kind };
+    return { status: "failed", code: error.kind, ...error.diagnostic ? {
+      error: errorDiagnostic(error.diagnostic, error.diagnostic.source, error.message, redact)
+    } : {} };
   }
   if (error instanceof CodexModelsError) {
     return error.kind === "aborted" ? { status: "cancelled" } : { status: "failed", code: error.kind };
   }
-  return { status: "failed", code: "body_error" };
+  return { status: "failed", code: "body_error", error: errorDiagnostic(error, "transport", "Upstream response body could not be read", redact) };
+}
+async function readHttpError(response, context) {
+  if (!response.body)
+    return { status: "failed", code: "upstream_http_error" };
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder;
+  const signal = AbortSignal.any([context.signal, AbortSignal.timeout(1000)]);
+  let text = "";
+  let bytes = 0;
+  try {
+    for (;; ) {
+      const next = await readWithSignal(reader, signal);
+      if (next.done)
+        break;
+      bytes += next.value?.byteLength ?? 0;
+      if (bytes > MAX_DISCARD_BYTES) {
+        reader.cancel("body_limit").catch(() => {
+          return;
+        });
+        return { status: "failed", code: "body_limit" };
+      }
+      text += decoder.decode(next.value, { stream: true });
+    }
+    const body = JSON.parse(text + decoder.decode());
+    const error = body?.error;
+    if (error && typeof error === "object" && !Array.isArray(error)) {
+      return { status: "failed", code: "upstream_http_error", error: errorDiagnostic(error, "upstream", "Upstream returned an HTTP error", context.redactDiagnostic) };
+    }
+  } catch (error) {
+    reader.cancel("error capture stopped").catch(() => {
+      return;
+    });
+    if (context.signal.aborted)
+      return { status: "cancelled" };
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+  return { status: "failed", code: "upstream_http_error" };
 }
 function joinCompletion(upstream, body, signal) {
   const safe = (promise) => promise.catch(() => ({ status: "failed", code: "upstream_completion" }));
@@ -15995,7 +16071,7 @@ function serialize(event) {
 
 `;
 }
-function protocolStreamBody(source, target, includeUsage, signal) {
+function protocolStreamBody(source, target, includeUsage, signal, redact) {
   const protocolController = new AbortController;
   const onAbort = () => protocolController.abort(signal.reason ?? "cancelled");
   if (signal.aborted)
@@ -16013,7 +16089,7 @@ function protocolStreamBody(source, target, includeUsage, signal) {
   const completion = new Promise((resolve) => {
     resolveCompletion = resolve;
   });
-  const processor = new CodexResponseProcessor({ target, includeUsage });
+  const processor = new CodexResponseProcessor({ target, includeUsage, redactDiagnostic: redact });
   let terminalOutcome;
   const events = parseCodexSSE(source, { signal: protocolController.signal });
   const iterator = async function* () {
@@ -16040,8 +16116,18 @@ function protocolStreamBody(source, target, includeUsage, signal) {
 `;
       settle(outcome);
     } catch (error) {
-      const outcome = completionFromError(error);
+      const outcome = completionFromError(error, redact);
       settle(outcome.status === "cancelled" ? terminalOutcome ?? outcome : outcome);
+      if (outcome.status === "failed" && outcome.error) {
+        const safe = errorBody(outcome.error, outcome.code);
+        yield target === "responses" ? `event: error
+data: ${JSON.stringify({ type: "error", code: safe.code, message: safe.message, param: null, error: safe })}
+
+` : `data: ${JSON.stringify({ error: safe })}
+
+`;
+        return;
+      }
       throw error;
     } finally {
       signal.removeEventListener("abort", onAbort);
@@ -16152,8 +16238,8 @@ class ChatgptOauthAdapter {
       current.adaptedResponses.add(response);
       return response;
     };
-    const errorResponse = (status, completion) => {
-      const response = mark(new Response(safeErrorBody(), {
+    const errorResponse = (status, completion, error) => {
+      const response = mark(new Response(JSON.stringify({ error: errorBody(error) }), {
         status,
         statusText: result.response.statusText,
         headers: responseHeaders(result.response, "application/json; charset=utf-8")
@@ -16162,8 +16248,8 @@ class ChatgptOauthAdapter {
       return { response, completion };
     };
     if (!result.response.ok) {
-      const bodyCompletion = discardBody(result.response, context.signal).then((outcome) => outcome.status === "completed" ? { status: "failed", code: "upstream_http_error" } : outcome);
-      return errorResponse(result.response.status, joinCompletion(result.completion, bodyCompletion, context.signal));
+      const failure = await readHttpError(result.response, context);
+      return errorResponse(result.response.status, joinCompletion(result.completion, Promise.resolve(failure), context.signal), "error" in failure ? failure.error : undefined);
     }
     if (state.target === "models") {
       if (!isJsonContentType(result.response)) {
@@ -16188,7 +16274,8 @@ class ChatgptOauthAdapter {
         completion.then(cleanup, cleanup);
         return { response, completion };
       } catch (error) {
-        return errorResponse(502, joinCompletion(result.completion, Promise.resolve(completionFromError(error)), context.signal));
+        const failure = completionFromError(error, context.redactDiagnostic);
+        return errorResponse(502, joinCompletion(result.completion, Promise.resolve(failure), context.signal), "error" in failure ? failure.error : undefined);
       }
     }
     const contentType = result.response.headers.get("content-type");
@@ -16199,7 +16286,7 @@ class ChatgptOauthAdapter {
       return errorResponse(502, joinCompletion(result.completion, bodyCompletion, context.signal));
     }
     if (state.stream) {
-      const converted = protocolStreamBody(result.response.body, state.target, state.includeUsage, context.signal);
+      const converted = protocolStreamBody(result.response.body, state.target, state.includeUsage, context.signal, context.redactDiagnostic);
       const streamCompletion = joinCompletion(result.completion, converted.completion, context.signal);
       streamCompletion.then(cleanup, cleanup);
       return {
@@ -16211,7 +16298,8 @@ class ChatgptOauthAdapter {
       const stateResult = await consumeCodexResponse(result.response.body, {
         signal: context.signal,
         request: { stream_options: { include_usage: state.includeUsage } },
-        target: state.target
+        target: state.target,
+        redactDiagnostic: context.redactDiagnostic
       });
       const body = state.target === "chat" ? responsesToChatCompletion(stateResult.response) : stateResult.response;
       const protocolCompletion = Promise.resolve(stateResult.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" });
@@ -16219,9 +16307,9 @@ class ChatgptOauthAdapter {
       nonStreamCompletion.then(cleanup, cleanup);
       return { response: mark(new Response(JSON.stringify(body), { status: result.response.status, statusText: result.response.statusText, headers: responseHeaders(result.response, "application/json; charset=utf-8") })), completion: nonStreamCompletion };
     } catch (error) {
-      const failure = completionFromError(error);
+      const failure = completionFromError(error, context.redactDiagnostic);
       const failedCompletion = joinCompletion(result.completion, Promise.resolve(failure), context.signal);
-      return errorResponse(502, failedCompletion);
+      return errorResponse(502, failedCompletion, "error" in failure ? failure.error : undefined);
     }
   }
 }
@@ -16252,4 +16340,4 @@ export {
   server_default as default
 };
 
-//# debugId=A763904920EABC5C64756E2164756E21
+//# debugId=D19FB0DB9863C8D864756E2164756E21