@wlv-zedd/dsh-chatgpt-web 1.0.0 → 1.0.2

package/src/native-passthrough.ts

@@ -1,261 +1,261 @@
-import { readJsonRequestBody } from "./http-body";
-import {
-  BRIDGE_COMPACTION_PREFIX,
-  SUMMARY_PREFIX,
-  decodeCompactionSummary,
-} from "./responses/compaction";
-import { BRIDGE_REASONING_PREFIX } from "./responses/reasoning-envelope";
-
-const CODEX_BACKEND = "https://chatgpt.com/backend-api/codex";
-const FIRST_PARTY_CODEX_ORIGINATORS = new Set([
-  "codex_cli_rs",
-  "codex-tui",
-  "codex_vscode",
-  "codex_atlas",
-  "codex_chatgpt_desktop",
-]);
-const HOP_BY_HOP_HEADERS = new Set([
-  "connection",
-  "keep-alive",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade",
-  "host",
-]);
-
-export type NativeFetch = (request: Request) => Promise<Response>;
-export type NativeCodexEndpoint = "models" | "responses" | "responses/compact" | "alpha/search";
-
-type JsonObject = Record<string, unknown>;
-type BridgeCompactionItem = JsonObject & { type: "compaction"; encrypted_content: string };
-
-function firstPartyCodexOriginator(value: string): boolean {
-  return FIRST_PARTY_CODEX_ORIGINATORS.has(value)
-    || /^Codex [A-Za-z0-9][A-Za-z0-9._ -]{0,63}$/.test(value);
-}
-
-/**
- * Current Codex clients identify themselves as `<originator>/<cargo semver> (...)`. The models
- * backend requires the release-only `major.minor.patch` value even when the client is an alpha.
- * Derive it only from the documented first-party Codex prefix; an arbitrary browser or proxy
- * User-Agent is not evidence of a Codex version and leaves the original request untouched.
- */
-export function codexClientVersionFromUserAgent(userAgent: string | null): string | undefined {
-  if (!userAgent) return undefined;
-  const separator = userAgent.indexOf("/");
-  if (separator < 1) return undefined;
-  const originator = userAgent.slice(0, separator);
-  if (!firstPartyCodexOriginator(originator)) return undefined;
-  const version = /^(\d{1,6})\.(\d{1,6})\.(\d{1,6})(?:[-+][0-9A-Za-z.-]+)?(?:\s|$)/
-    .exec(userAgent.slice(separator + 1));
-  return version ? `${version[1]}.${version[2]}.${version[3]}` : undefined;
-}
-
-function isObject(value: unknown): value is JsonObject {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function isBridgeReasoningItem(value: unknown): value is JsonObject {
-  if (!isObject(value) || value.type !== "reasoning") return false;
-  const encrypted = value.encrypted_content;
-  if (typeof encrypted === "string" && encrypted.startsWith(BRIDGE_REASONING_PREFIX)) return true;
-  return typeof value.id === "string"
-    && /^rs_[0-9a-f]{32}$/i.test(value.id)
-    && (encrypted === undefined || encrypted === null)
-    && (Array.isArray(value.summary) || Array.isArray(value.content));
-}
-
-function isBridgeCompactionItem(value: unknown): value is BridgeCompactionItem {
-  return isObject(value)
-    && value.type === "compaction"
-    && typeof value.encrypted_content === "string"
-    && value.encrypted_content.startsWith(BRIDGE_COMPACTION_PREFIX);
-}
-
-/**
- * Response item ids are scoped to the backend that created them. A ChatGPT Web response is
- * generated locally, so replaying its `rs_*` id after switching back to native Codex makes the
- * official backend try to load an item it has never stored. The same boundary applies to local
- * `ocx1:` compaction checkpoints: preserve their decoded summary as a normal input message rather
- * than asking the official backend to decrypt a bridge-owned envelope. Once either artifact proves
- * that the history crossed providers, send the complete item content without provider-local ids.
- */
-export function scrubBridgeArtifactsForNative(value: unknown): { value: unknown; changed: boolean } {
-  if (!isObject(value)
-    || !Array.isArray(value.input)
-    || !value.input.some(item => isBridgeReasoningItem(item) || isBridgeCompactionItem(item))) {
-    return { value, changed: false };
-  }
-
-  const input = value.input.flatMap(item => {
-    if (!isObject(item)) return [item];
-    const clean = { ...item };
-    delete clean.id;
-    if (isBridgeCompactionItem(clean)) {
-      const summary = decodeCompactionSummary(clean.encrypted_content);
-      if (summary === null) throw new Error("Invalid ChatGPT Web compaction checkpoint");
-      return [{
-        type: "message",
-        role: "user",
-        content: [{ type: "input_text", text: `${SUMMARY_PREFIX}\n\n${summary}` }],
-      }];
-    }
-    if (clean.type !== "reasoning") return [clean];
-
-    if (typeof clean.encrypted_content === "string"
-      && clean.encrypted_content.startsWith(BRIDGE_REASONING_PREFIX)) {
-      delete clean.encrypted_content;
-    } else if (clean.encrypted_content === null) {
-      delete clean.encrypted_content;
-    }
-
-    const hasSummary = Array.isArray(clean.summary) && clean.summary.length > 0;
-    const hasContent = Array.isArray(clean.content) && clean.content.length > 0;
-    const hasNativeEncryptedContent = typeof clean.encrypted_content === "string";
-    return hasSummary || hasContent || hasNativeEncryptedContent ? [clean] : [];
-  });
-  const clean: JsonObject = { ...value, input };
-  delete clean.previous_response_id;
-  return { value: clean, changed: true };
-}
-
-function endToEndHeaders(source: Headers): Headers {
-  const headers = new Headers();
-  for (const [name, value] of source) {
-    if (!HOP_BY_HOP_HEADERS.has(name.toLowerCase())) headers.append(name, value);
-  }
-  headers.delete("content-length");
-  return headers;
-}
-
-/** Terminator every Responses SSE stream ends with; nothing after it carries meaning. */
-const SSE_TERMINATOR = "data: [DONE]";
-
-/**
- * ChatGPT's backend routinely resets the native Codex connection instead of closing it cleanly,
- * which Bun surfaces as ECONNRESET while reading the body. Passed through untouched that reaches
- * Codex as a truncated HTTP body and the opaque "error decoding response body".
- *
- * A reset that arrives after the stream already delivered `data: [DONE]` is an unclean TCP close on
- * a turn that finished: every byte the protocol defines has been forwarded, so the stream is closed
- * normally rather than failed. A reset before that genuinely truncated the turn and is still raised,
- * because inventing a terminal event there would tell Codex a turn ended when it did not.
- */
-function withUncleanCloseTolerance(
-  body: ReadableStream<Uint8Array>,
-  isEventStream: boolean,
-  onUncleanClose?: (bytes: number) => void,
-): ReadableStream<Uint8Array> {
-  if (!isEventStream) return body;
-  const reader = body.getReader();
-  const decoder = new TextDecoder();
-  let lineBuffer = "";
-  let completed = false;
-  let bytes = 0;
-  const inspectLines = (text: string): void => {
-    lineBuffer += text;
-    let newline = lineBuffer.indexOf("\n");
-    while (newline >= 0) {
-      const line = lineBuffer.slice(0, newline).replace(/\r$/, "");
-      lineBuffer = lineBuffer.slice(newline + 1);
-      if (line === SSE_TERMINATOR) completed = true;
-      newline = lineBuffer.indexOf("\n");
-    }
-  };
-  const inspectTrailingLine = (): void => {
-    // A reset can arrive before the final line separator. Treat only an exact unterminated
-    // terminator line as complete; text embedded in a JSON data payload must not qualify.
-    if (lineBuffer.replace(/\r$/, "") === SSE_TERMINATOR) completed = true;
-  };
-  return new ReadableStream<Uint8Array>({
-    async pull(controller) {
-      try {
-        const chunk = await reader.read();
-        if (chunk.done) {
-          inspectLines(decoder.decode());
-          inspectTrailingLine();
-          controller.close();
-          return;
-        }
-        bytes += chunk.value.byteLength;
-        inspectLines(decoder.decode(chunk.value, { stream: true }));
-        controller.enqueue(chunk.value);
-      } catch (error) {
-        inspectTrailingLine();
-        if (!completed) {
-          controller.error(error);
-          return;
-        }
-        onUncleanClose?.(bytes);
-        controller.close();
-      }
-    },
-    cancel(reason) {
-      return reader.cancel(reason);
-    },
-  });
-}
-
-export async function forwardNativeCodexRequest(
-  request: Request,
-  endpoint: NativeCodexEndpoint,
-  fetchUpstream: NativeFetch = fetch,
-  decodedBody?: unknown,
-): Promise<Response> {
-  const authorization = request.headers.get("authorization") ?? "";
-  if (!authorization.startsWith("Bearer ") || authorization.length <= "Bearer ".length) {
-    throw new Error("Native Codex passthrough requires the incoming Bearer authorization");
-  }
-
-  const incomingUrl = new URL(request.url);
-  if (endpoint === "models" && !incomingUrl.searchParams.has("client_version")) {
-    const clientVersion = codexClientVersionFromUserAgent(request.headers.get("user-agent"));
-    if (clientVersion) incomingUrl.searchParams.set("client_version", clientVersion);
-  }
-  const headers = endToEndHeaders(request.headers);
-  if (endpoint === "models") headers.delete("if-none-match");
-  const method = endpoint === "models" ? "GET" : "POST";
-  let body: BodyInit | undefined;
-  if (method === "POST") {
-    const parseRequest = decodedBody === undefined ? request.clone() : undefined;
-    const originalBody = await request.arrayBuffer();
-    const scrubbed = scrubBridgeArtifactsForNative(
-      decodedBody === undefined ? await readJsonRequestBody(parseRequest!) : decodedBody,
-    );
-    if (scrubbed.changed) {
-      headers.delete("content-encoding");
-      body = JSON.stringify(scrubbed.value);
-    } else {
-      body = originalBody;
-    }
-  }
-  const upstreamRequest = new Request(`${CODEX_BACKEND}/${endpoint}${incomingUrl.search}`, {
-    method,
-    headers,
-    ...(body ? { body } : {}),
-    signal: request.signal,
-  });
-  const upstream = await fetchUpstream(upstreamRequest);
-  const responseHeaders = endToEndHeaders(upstream.headers);
-  const isEventStream = (upstream.headers.get("content-type") ?? "")
-    .toLowerCase()
-    .includes("text/event-stream");
-  return new Response(
-    upstream.body
-      ? withUncleanCloseTolerance(upstream.body, isEventStream, bytes => {
-        console.warn(
-          `[codex-chatgpt-web] native_upstream_unclean_close endpoint=${endpoint} bytes=${bytes}`
-          + " (turn had already completed; closing the client stream normally)",
-        );
-      })
-      : upstream.body,
-    {
-      status: upstream.status,
-      statusText: upstream.statusText,
-      headers: responseHeaders,
-    },
-  );
-}
+import { readJsonRequestBody } from "./http-body";
+import {
+  BRIDGE_COMPACTION_PREFIX,
+  SUMMARY_PREFIX,
+  decodeCompactionSummary,
+} from "./responses/compaction";
+import { BRIDGE_REASONING_PREFIX } from "./responses/reasoning-envelope";
+
+const CODEX_BACKEND = "https://chatgpt.com/backend-api/codex";
+const FIRST_PARTY_CODEX_ORIGINATORS = new Set([
+  "codex_cli_rs",
+  "codex-tui",
+  "codex_vscode",
+  "codex_atlas",
+  "codex_chatgpt_desktop",
+]);
+const HOP_BY_HOP_HEADERS = new Set([
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "host",
+]);
+
+export type NativeFetch = (request: Request) => Promise<Response>;
+export type NativeCodexEndpoint = "models" | "responses" | "responses/compact" | "alpha/search";
+
+type JsonObject = Record<string, unknown>;
+type BridgeCompactionItem = JsonObject & { type: "compaction"; encrypted_content: string };
+
+function firstPartyCodexOriginator(value: string): boolean {
+  return FIRST_PARTY_CODEX_ORIGINATORS.has(value)
+    || /^Codex [A-Za-z0-9][A-Za-z0-9._ -]{0,63}$/.test(value);
+}
+
+/**
+ * Current Codex clients identify themselves as `<originator>/<cargo semver> (...)`. The models
+ * backend requires the release-only `major.minor.patch` value even when the client is an alpha.
+ * Derive it only from the documented first-party Codex prefix; an arbitrary browser or proxy
+ * User-Agent is not evidence of a Codex version and leaves the original request untouched.
+ */
+export function codexClientVersionFromUserAgent(userAgent: string | null): string | undefined {
+  if (!userAgent) return undefined;
+  const separator = userAgent.indexOf("/");
+  if (separator < 1) return undefined;
+  const originator = userAgent.slice(0, separator);
+  if (!firstPartyCodexOriginator(originator)) return undefined;
+  const version = /^(\d{1,6})\.(\d{1,6})\.(\d{1,6})(?:[-+][0-9A-Za-z.-]+)?(?:\s|$)/
+    .exec(userAgent.slice(separator + 1));
+  return version ? `${version[1]}.${version[2]}.${version[3]}` : undefined;
+}
+
+function isObject(value: unknown): value is JsonObject {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function isBridgeReasoningItem(value: unknown): value is JsonObject {
+  if (!isObject(value) || value.type !== "reasoning") return false;
+  const encrypted = value.encrypted_content;
+  if (typeof encrypted === "string" && encrypted.startsWith(BRIDGE_REASONING_PREFIX)) return true;
+  return typeof value.id === "string"
+    && /^rs_[0-9a-f]{32}$/i.test(value.id)
+    && (encrypted === undefined || encrypted === null)
+    && (Array.isArray(value.summary) || Array.isArray(value.content));
+}
+
+function isBridgeCompactionItem(value: unknown): value is BridgeCompactionItem {
+  return isObject(value)
+    && value.type === "compaction"
+    && typeof value.encrypted_content === "string"
+    && value.encrypted_content.startsWith(BRIDGE_COMPACTION_PREFIX);
+}
+
+/**
+ * Response item ids are scoped to the backend that created them. A ChatGPT Web response is
+ * generated locally, so replaying its `rs_*` id after switching back to native Codex makes the
+ * official backend try to load an item it has never stored. The same boundary applies to local
+ * `ocx1:` compaction checkpoints: preserve their decoded summary as a normal input message rather
+ * than asking the official backend to decrypt a bridge-owned envelope. Once either artifact proves
+ * that the history crossed providers, send the complete item content without provider-local ids.
+ */
+export function scrubBridgeArtifactsForNative(value: unknown): { value: unknown; changed: boolean } {
+  if (!isObject(value)
+    || !Array.isArray(value.input)
+    || !value.input.some(item => isBridgeReasoningItem(item) || isBridgeCompactionItem(item))) {
+    return { value, changed: false };
+  }
+
+  const input = value.input.flatMap(item => {
+    if (!isObject(item)) return [item];
+    const clean = { ...item };
+    delete clean.id;
+    if (isBridgeCompactionItem(clean)) {
+      const summary = decodeCompactionSummary(clean.encrypted_content);
+      if (summary === null) throw new Error("Invalid ChatGPT Web compaction checkpoint");
+      return [{
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text: `${SUMMARY_PREFIX}\n\n${summary}` }],
+      }];
+    }
+    if (clean.type !== "reasoning") return [clean];
+
+    if (typeof clean.encrypted_content === "string"
+      && clean.encrypted_content.startsWith(BRIDGE_REASONING_PREFIX)) {
+      delete clean.encrypted_content;
+    } else if (clean.encrypted_content === null) {
+      delete clean.encrypted_content;
+    }
+
+    const hasSummary = Array.isArray(clean.summary) && clean.summary.length > 0;
+    const hasContent = Array.isArray(clean.content) && clean.content.length > 0;
+    const hasNativeEncryptedContent = typeof clean.encrypted_content === "string";
+    return hasSummary || hasContent || hasNativeEncryptedContent ? [clean] : [];
+  });
+  const clean: JsonObject = { ...value, input };
+  delete clean.previous_response_id;
+  return { value: clean, changed: true };
+}
+
+function endToEndHeaders(source: Headers): Headers {
+  const headers = new Headers();
+  for (const [name, value] of source) {
+    if (!HOP_BY_HOP_HEADERS.has(name.toLowerCase())) headers.append(name, value);
+  }
+  headers.delete("content-length");
+  return headers;
+}
+
+/** Terminator every Responses SSE stream ends with; nothing after it carries meaning. */
+const SSE_TERMINATOR = "data: [DONE]";
+
+/**
+ * ChatGPT's backend routinely resets the native Codex connection instead of closing it cleanly,
+ * which Bun surfaces as ECONNRESET while reading the body. Passed through untouched that reaches
+ * Codex as a truncated HTTP body and the opaque "error decoding response body".
+ *
+ * A reset that arrives after the stream already delivered `data: [DONE]` is an unclean TCP close on
+ * a turn that finished: every byte the protocol defines has been forwarded, so the stream is closed
+ * normally rather than failed. A reset before that genuinely truncated the turn and is still raised,
+ * because inventing a terminal event there would tell Codex a turn ended when it did not.
+ */
+function withUncleanCloseTolerance(
+  body: ReadableStream<Uint8Array>,
+  isEventStream: boolean,
+  onUncleanClose?: (bytes: number) => void,
+): ReadableStream<Uint8Array> {
+  if (!isEventStream) return body;
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let lineBuffer = "";
+  let completed = false;
+  let bytes = 0;
+  const inspectLines = (text: string): void => {
+    lineBuffer += text;
+    let newline = lineBuffer.indexOf("\n");
+    while (newline >= 0) {
+      const line = lineBuffer.slice(0, newline).replace(/\r$/, "");
+      lineBuffer = lineBuffer.slice(newline + 1);
+      if (line === SSE_TERMINATOR) completed = true;
+      newline = lineBuffer.indexOf("\n");
+    }
+  };
+  const inspectTrailingLine = (): void => {
+    // A reset can arrive before the final line separator. Treat only an exact unterminated
+    // terminator line as complete; text embedded in a JSON data payload must not qualify.
+    if (lineBuffer.replace(/\r$/, "") === SSE_TERMINATOR) completed = true;
+  };
+  return new ReadableStream<Uint8Array>({
+    async pull(controller) {
+      try {
+        const chunk = await reader.read();
+        if (chunk.done) {
+          inspectLines(decoder.decode());
+          inspectTrailingLine();
+          controller.close();
+          return;
+        }
+        bytes += chunk.value.byteLength;
+        inspectLines(decoder.decode(chunk.value, { stream: true }));
+        controller.enqueue(chunk.value);
+      } catch (error) {
+        inspectTrailingLine();
+        if (!completed) {
+          controller.error(error);
+          return;
+        }
+        onUncleanClose?.(bytes);
+        controller.close();
+      }
+    },
+    cancel(reason) {
+      return reader.cancel(reason);
+    },
+  });
+}
+
+export async function forwardNativeCodexRequest(
+  request: Request,
+  endpoint: NativeCodexEndpoint,
+  fetchUpstream: NativeFetch = fetch,
+  decodedBody?: unknown,
+): Promise<Response> {
+  const authorization = request.headers.get("authorization") ?? "";
+  if (!authorization.startsWith("Bearer ") || authorization.length <= "Bearer ".length) {
+    throw new Error("Native Codex passthrough requires the incoming Bearer authorization");
+  }
+
+  const incomingUrl = new URL(request.url);
+  if (endpoint === "models" && !incomingUrl.searchParams.has("client_version")) {
+    const clientVersion = codexClientVersionFromUserAgent(request.headers.get("user-agent"));
+    if (clientVersion) incomingUrl.searchParams.set("client_version", clientVersion);
+  }
+  const headers = endToEndHeaders(request.headers);
+  if (endpoint === "models") headers.delete("if-none-match");
+  const method = endpoint === "models" ? "GET" : "POST";
+  let body: BodyInit | undefined;
+  if (method === "POST") {
+    const parseRequest = decodedBody === undefined ? request.clone() : undefined;
+    const originalBody = await request.arrayBuffer();
+    const scrubbed = scrubBridgeArtifactsForNative(
+      decodedBody === undefined ? await readJsonRequestBody(parseRequest!) : decodedBody,
+    );
+    if (scrubbed.changed) {
+      headers.delete("content-encoding");
+      body = JSON.stringify(scrubbed.value);
+    } else {
+      body = originalBody;
+    }
+  }
+  const upstreamRequest = new Request(`${CODEX_BACKEND}/${endpoint}${incomingUrl.search}`, {
+    method,
+    headers,
+    ...(body ? { body } : {}),
+    signal: request.signal,
+  });
+  const upstream = await fetchUpstream(upstreamRequest);
+  const responseHeaders = endToEndHeaders(upstream.headers);
+  const isEventStream = (upstream.headers.get("content-type") ?? "")
+    .toLowerCase()
+    .includes("text/event-stream");
+  return new Response(
+    upstream.body
+      ? withUncleanCloseTolerance(upstream.body, isEventStream, bytes => {
+        console.warn(
+          `[codex-chatgpt-web] native_upstream_unclean_close endpoint=${endpoint} bytes=${bytes}`
+          + " (turn had already completed; closing the client stream normally)",
+        );
+      })
+      : upstream.body,
+    {
+      status: upstream.status,
+      statusText: upstream.statusText,
+      headers: responseHeaders,
+    },
+  );
+}