@jeffusion/bungee-core 5.23.0 → 5.23.2

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

@@ -1455,6 +1455,7 @@ var MAX_PROFILE_HEADER_VALUE_BYTES = 8192;
 var CHATGPT_ORIGIN = "https://chatgpt.com";
 var SIWC_ORIGIN = "https://api.openai.com";
 var CODEX_ROUTING_HINT_HEADER = "X-Codex-Routing-Hint";
+var convertedCompletions = new WeakSet;
 var SIWC_FORBIDDEN_FIELDS = [
   "background",
   "conversation",
@@ -1629,6 +1630,13 @@ function responseHeaders(response, contentType) {
   headers.set("content-type", contentType);
   return headers;
 }
+function nativeResponseHeaders(response) {
+  const headers = new Headers(response.headers);
+  for (const name of ["content-encoding", "content-length", "transfer-encoding"])
+    headers.delete(name);
+  headers.set("content-type", "text/event-stream");
+  return headers;
+}
 function errorBody2(error, fallbackCode = "upstream_error") {
   return { message: error?.message ?? "Upstream response could not be adapted", type: error?.type ?? "upstream_error", code: error?.code ?? fallbackCode };
 }
@@ -1725,14 +1733,34 @@ function serialize(event) {
   if (envelope?.retry !== undefined)
     lines.push(`retry: ${envelope.retry}`);
   const data = event.type === "done" ? "[DONE]" : envelope?.data ?? JSON.stringify(event.data);
-  lines.push(...data.split(`
+  if (envelope?.hasData !== false)
+    lines.push(...data.split(`
 `).map((line) => `data: ${line}`));
   return `${lines.join(`
 `)}
 
 `;
 }
-function protocolStreamBody(handle, target, includeUsage, signal, redact, preserveCustomTools = false) {
+async function* nativeCodexEvents(handle, signal) {
+  for await (const envelope of handle.events(bodyConsumer(signal))) {
+    const data = envelope.json && typeof envelope.json === "object" && !Array.isArray(envelope.json) ? envelope.json : {};
+    yield { type: typeof data.type === "string" ? data.type : undefined, data, envelope };
+  }
+}
+function nativeTerminal(event) {
+  if (event.envelope?.truncated || event.envelope?.hasData === false)
+    return;
+  if (event.type === "error")
+    return { status: "failed", code: "upstream_error" };
+  const status = event.type === "response.completed" ? "completed" : event.type === "response.incomplete" ? "incomplete" : event.type === "response.failed" ? "failed" : undefined;
+  if (!status)
+    return;
+  const response = event.data.response;
+  if (!response || typeof response !== "object" || Array.isArray(response) || response.status !== status || !Array.isArray(response.output) || status === "completed" && response.error != null)
+    return { status: "failed", code: "invalid_response" };
+  return status === "completed" ? { status } : { status, code: status === "failed" ? "upstream_error" : "incomplete" };
+}
+function protocolStreamBody(handle, target, includeUsage, signal, redact, preserveCustomTools = false, native = false) {
   const protocolController = new AbortController;
   const onAbort = () => protocolController.abort(signal.reason ?? "cancelled");
   if (signal.aborted)
@@ -1750,14 +1778,20 @@ function protocolStreamBody(handle, target, includeUsage, signal, redact, preser
   const completion = new Promise((resolve) => {
     resolveCompletion = resolve;
   });
-  const processor = new CodexResponseProcessor({ target, includeUsage, redactDiagnostic: redact, preserveCustomTools });
+  const processor = native ? undefined : new CodexResponseProcessor({ target, includeUsage, redactDiagnostic: redact, preserveCustomTools });
   let terminalOutcome;
-  const events = parseCodexSSE(handle.events(bodyConsumer(protocolController.signal)), { signal: protocolController.signal });
+  const events = native ? nativeCodexEvents(handle, protocolController.signal) : parseCodexSSE(handle.events(bodyConsumer(protocolController.signal)), { signal: protocolController.signal });
   const iterator = async function* () {
     try {
       for await (const event of events) {
-        const output = processor.process(event);
-        if (event.type === "response.completed" || event.type === "response.incomplete") {
+        const output = processor?.process(event) ?? [];
+        if (native) {
+          const outcome = nativeTerminal(event);
+          if (outcome) {
+            terminalOutcome = outcome;
+            settle(outcome);
+          }
+        } else if (event.type === "response.completed" || event.type === "response.incomplete") {
           const final = processor.finish();
           terminalOutcome = final.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" };
           settle(terminalOutcome);
@@ -1770,8 +1804,8 @@ function protocolStreamBody(handle, target, includeUsage, signal, redact, preser
 
 `;
       }
-      const final = processor.finish();
-      const outcome = final.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" };
+      const final = processor?.finish();
+      const outcome = native ? terminalOutcome ?? { status: "failed", code: "unexpected_eof" } : final.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" };
       if (target === "chat")
         yield `data: [DONE]
 
@@ -1780,7 +1814,7 @@ function protocolStreamBody(handle, target, includeUsage, signal, redact, preser
     } catch (error) {
       const outcome = completionFromError(error, redact);
       settle(outcome.status === "cancelled" ? terminalOutcome ?? outcome : outcome);
-      if (outcome.status === "failed" && outcome.error) {
+      if (!native && outcome.status === "failed" && outcome.error) {
         const safe = errorBody2(outcome.error, outcome.code);
         yield target === "responses" ? `event: error
 data: ${JSON.stringify({ type: "error", code: safe.code, message: safe.message, param: null, error: safe })}
@@ -1814,12 +1848,13 @@ data: ${JSON.stringify({ type: "error", code: safe.code, message: safe.message,
         return;
       });
     }
-  });
+  }, { highWaterMark: 0 });
   return { body, completion };
 }
 
 class ChatgptOauthAdapter {
   requests = new Map;
+  nativeResponses = new WeakSet;
   constructor() {}
   beforeRequest(context) {
     assertResponsesEntryPath(context.url.pathname);
@@ -1915,10 +1950,31 @@ class ChatgptOauthAdapter {
     return context;
   }
   async rawResponse(result, context) {
-    const current = this.requests.get(context.requestId);
+    if (convertedCompletions.has(result.completion)) {
+      const pending = this.requests.get(context.requestId);
+      const cleanup = () => {
+        if (this.requests.get(context.requestId) === pending)
+          this.requests.delete(context.requestId);
+      };
+      result.completion.then(cleanup, cleanup);
+      return result;
+    }
+    if (this.nativeResponses.has(result.response))
+      return result;
+    const upstreamUrl = context.upstreamUrl ? new URL(context.upstreamUrl) : undefined;
+    const current = this.requests.get(context.requestId) ?? (upstreamUrl?.origin === CHATGPT_ORIGIN && upstreamUrl.pathname === CODEX_RESPONSES_PATH && context.method.toUpperCase() === "POST" ? Object.freeze({
+      target: "responses",
+      stream: true,
+      includeUsage: false,
+      allowMissingContentType: true,
+      native: true,
+      adaptedResponses: new WeakSet
+    }) : undefined);
     if (current === undefined || current.adaptedResponses.has(result.response))
       return result;
     current.adaptedResponses.add(result.response);
+    if (current.native)
+      this.nativeResponses.add(result.response);
     const state = current.attemptId === undefined ? Object.freeze({ ...current, attemptId: context.attemptId }) : current;
     if (state !== current && this.requests.get(context.requestId) === current)
       this.requests.set(context.requestId, state);
@@ -1926,8 +1982,15 @@ class ChatgptOauthAdapter {
       if (this.requests.get(context.requestId) === state)
         this.requests.delete(context.requestId);
     };
+    const trackCompletion = (completion) => {
+      if (!state.native)
+        convertedCompletions.add(completion);
+      completion.then(cleanup, cleanup);
+    };
     const mark = (response) => {
       current.adaptedResponses.add(response);
+      if (current.native)
+        this.nativeResponses.add(response);
       return response;
     };
     const errorResponse = (status, completion, error) => {
@@ -1936,9 +1999,13 @@ class ChatgptOauthAdapter {
         statusText: result.response.statusText,
         headers: responseHeaders(result.response, "application/json; charset=utf-8")
       }));
-      completion.then(cleanup, cleanup);
+      trackCompletion(completion);
       return { response, completion };
     };
+    if (state.native && !result.response.ok) {
+      result.completion.then(cleanup, cleanup);
+      return result;
+    }
     if (!context.bodyHandle) {
       return errorResponse(502, Promise.resolve({ status: "failed", code: "body_view_missing" }));
     }
@@ -1969,7 +2036,7 @@ class ChatgptOauthAdapter {
           statusText: result.response.statusText,
           headers: responseHeaders(result.response, "application/json; charset=utf-8")
         }));
-        completion.then(cleanup, cleanup);
+        trackCompletion(completion);
         return { response, completion };
       } catch (error) {
         const failure = completionFromError(error, context.redactDiagnostic);
@@ -1977,21 +2044,26 @@ class ChatgptOauthAdapter {
       }
     }
     const contentType = result.response.headers.get("content-type");
-    const hasEventStream = contentType?.split(";", 1)[0].trim().toLowerCase() === "text/event-stream";
+    const media = contentType?.split(";", 1)[0].trim().toLowerCase();
+    const hasEventStream = media === "text/event-stream" || state.native === true && media === "application/octet-stream";
     const allowMissingContentType = state.allowMissingContentType && contentType === null;
     if (!hasEventStream && !allowMissingContentType || !result.response.body) {
       const bodyCompletion = !hasEventStream && !allowMissingContentType ? discardBody(context.bodyHandle, context.signal).then((outcome) => outcome.status === "completed" ? { status: "failed", code: "invalid_content_type" } : outcome) : Promise.resolve({ status: "failed", code: "invalid_response" });
       return errorResponse(502, joinCompletion(result.completion, bodyCompletion, context.signal));
     }
     if (state.stream) {
-      const converted = protocolStreamBody(context.bodyHandle, state.target, state.includeUsage, context.signal, context.redactDiagnostic, state.siwc);
+      const converted = protocolStreamBody(context.bodyHandle, state.target, state.includeUsage, context.signal, context.redactDiagnostic, state.siwc, state.native);
       const streamCompletion = Promise.race([
         converted.completion,
         result.completion.then((upstream) => upstream.status === "failed" ? upstream : converted.completion, () => ({ status: "failed", code: "upstream_completion" }))
       ]);
-      streamCompletion.then(cleanup, cleanup);
+      trackCompletion(streamCompletion);
       return {
-        response: mark(new Response(converted.body, { status: result.response.status, statusText: result.response.statusText, headers: responseHeaders(result.response, "text/event-stream") })),
+        response: mark(new Response(converted.body, {
+          status: result.response.status,
+          statusText: result.response.statusText,
+          headers: state.native ? nativeResponseHeaders(result.response) : responseHeaders(result.response, "text/event-stream")
+        })),
         completion: streamCompletion
       };
     }
@@ -2005,7 +2077,7 @@ class ChatgptOauthAdapter {
       const body = state.target === "chat" ? responsesToChatCompletion(stateResult.response, state.siwc) : stateResult.response;
       const protocolCompletion = Promise.resolve(stateResult.terminal === "completed" ? { status: "completed" } : { status: "incomplete", code: "incomplete" });
       const nonStreamCompletion = joinCompletion(result.completion, protocolCompletion, context.signal);
-      nonStreamCompletion.then(cleanup, cleanup);
+      trackCompletion(nonStreamCompletion);
       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, context.redactDiagnostic);
@@ -2034,7 +2106,7 @@ var ChatgptOauthPlugin = definePlugin(class {
     const path = context.url.pathname;
     if (path === "/v1/models" && context.method.toUpperCase() === "GET")
       return { request: "none", response: ["json"] };
-    return context.method.toUpperCase() === "POST" && (isResponsesRequest(context.url) || ["/v1/chat/completions", "/backend-api/codex/responses"].includes(path)) ? { request: "json-write", response: path === "/backend-api/codex/responses" ? [] : ["json", "sse-json"] } : { request: "none" };
+    return context.method.toUpperCase() === "POST" && (isResponsesRequest(context.url) || ["/v1/chat/completions", "/backend-api/codex/responses"].includes(path)) ? { request: "json-write", response: ["json", "sse-json"] } : { request: "none" };
   }
   register(hooks) {
     hooks.onWebSocketHandshake.tap("chatgpt-oauth", (context) => {
@@ -2056,4 +2128,4 @@ export {
   server_default as default
 };
 
-//# debugId=F44D362B53E644C964756E2164756E21
+//# debugId=E48A263F3FBDCAF664756E2164756E21