Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
chatgpt-web: address PR #1593 review feedback
Paynefc80a986f2e5
diff --git a/open-sse/executors/chatgpt-web.ts b/open-sse/executors/chatgpt-web.tsindex b3e1463660..673495449d 100644--- a/open-sse/executors/chatgpt-web.ts+++ b/open-sse/executors/chatgpt-web.ts@@ -39,8 +39,30 @@ const CHATGPT_USER_AGENT =const OAI_CLIENT_VERSION = "prod-81e0c5cdf6140e8c5db714d613337f4aeab94029";const OAI_CLIENT_BUILD_NUMBER = "6128297";-// Stable per-process device ID (matches the browser's persistent oai-did cookie behaviour).-const DEVICE_ID = randomUUID();+// Per-cookie device ID. The browser stores a persistent `oai-did` cookie that+// uniquely identifies the device for OpenAI's risk model — we derive a stable+// UUID from a hash of the session cookie so that each account/connection gets+// its own device id, but it doesn't change between requests.+const deviceIdCache = new Map<string, string>();+function deviceIdFor(cookie: string): string {+ const key = cookieKey(cookie);+ let id = deviceIdCache.get(key);+ if (!id) {+ // Synthesize a UUID v4-shaped string from a SHA-256 of the cookie. Stable,+ // deterministic per cookie, no PII (the cookie's already secret).+ const h = createHash("sha256").update(cookie).digest("hex");+ id =+ `${h.slice(0, 8)}-${h.slice(8, 12)}-4${h.slice(13, 16)}-` ++ `${((parseInt(h.slice(16, 17), 16) & 0x3) | 0x8).toString(16)}${h.slice(17, 20)}-` ++ h.slice(20, 32);+ if (deviceIdCache.size >= 200) {+ const first = deviceIdCache.keys().next().value;+ if (first) deviceIdCache.delete(first);+ }+ deviceIdCache.set(key, id);+ }+ return id;+}// OmniRoute model ID → ChatGPT internal slug. ChatGPT's web routes use// dash-separated IDs (e.g. "gpt-5-3" not "gpt-5.3-instant").@@ -67,10 +89,10 @@ function browserHeaders(): Record<string, string> {}/** Headers ChatGPT's web client sends on backend-api requests. */-function oaiHeaders(sessionId: string): Record<string, string> {+function oaiHeaders(sessionId: string, deviceId: string): Record<string, string> {return {"OAI-Language": "en-US",- "OAI-Device-Id": DEVICE_ID,+ "OAI-Device-Id": deviceId,"OAI-Client-Version": OAI_CLIENT_VERSION,"OAI-Client-Build-Number": OAI_CLIENT_BUILD_NUMBER,"OAI-Session-Id": sessionId,@@ -117,71 +139,11 @@ function tokenStore(cookie: string, entry: TokenEntry): void {}}-// ─── Conversation continuity cache ──────────────────────────────────────────-// Keyed by FNV hash of message history → { conversationId, lastMessageId }.-// Same pattern as perplexity-web.ts:50-99.--interface ConvEntry {- conversationId: string;- lastMessageId: string;- ts: number;-}--const CONV_TTL_MS = 60 * 60 * 1000;-const CONV_MAX = 200;-const convCache = new Map<string, ConvEntry>();--function historyKey(history: Array<{ role: string; content: string }>): string {- const parts = history.map((h) => `${h.role}:${h.content}`).join("\n");- let hash = 0x811c9dc5;- for (let i = 0; i < parts.length; i++) {- hash ^= parts.charCodeAt(i);- hash = (hash * 0x01000193) >>> 0;- }- return hash.toString(16).padStart(8, "0");-}--function convLookup(- history: Array<{ role: string; content: string }>-): { conversationId: string; lastMessageId: string } | null {- if (history.length === 0) return null;- const key = historyKey(history);- const entry = convCache.get(key);- if (!entry) return null;- if (Date.now() - entry.ts > CONV_TTL_MS) {- convCache.delete(key);- return null;- }- return { conversationId: entry.conversationId, lastMessageId: entry.lastMessageId };-}--function convStore(- history: Array<{ role: string; content: string }>,- currentMsg: string,- responseText: string,- conversationId: string,- lastMessageId: string-): void {- if (!conversationId || !lastMessageId) return;- const full = [- ...history,- { role: "user", content: currentMsg },- { role: "assistant", content: responseText },- ];- const key = historyKey(full);- convCache.set(key, { conversationId, lastMessageId, ts: Date.now() });- if (convCache.size > CONV_MAX) {- let oldestKey: string | null = null;- let oldestTs = Infinity;- for (const [k, v] of convCache) {- if (v.ts < oldestTs) {- oldestTs = v.ts;- oldestKey = k;- }- }- if (oldestKey) convCache.delete(oldestKey);- }-}+// Conversation continuity is intentionally not cached. The conversation body+// sets `history_and_training_disabled: true` (Temporary Chat mode), and+// chatgpt.com expires those conversation_ids quickly — re-using them returns+// 404. Open WebUI and most OpenAI-API-style clients send the full history+// each turn anyway, so each request just starts a fresh conversation.// ─── /api/auth/session — exchange cookie for JWT ────────────────────────────@@ -305,11 +267,13 @@ interface ChatRequirements {const warmupCache = new Map<string, number>();const WARMUP_TTL_MS = 60_000;+const WARMUP_CACHE_MAX = 200;async function runSessionWarmup(accessToken: string,accountId: string | null,sessionId: string,+ deviceId: string,cookie: string,signal: AbortSignal | null | undefined,log: { debug?: (tag: string, msg: string) => void } | null | undefined@@ -318,11 +282,17 @@ async function runSessionWarmup(const now = Date.now();const last = warmupCache.get(key);if (last && now - last < WARMUP_TTL_MS) return;+ // Bound the cache: drop the oldest entry once we hit the cap. Map iteration+ // order is insertion order, so the first key is the oldest.+ if (warmupCache.size >= WARMUP_CACHE_MAX && !warmupCache.has(key)) {+ const first = warmupCache.keys().next().value;+ if (first) warmupCache.delete(first);+ }warmupCache.set(key, now);const headers: Record<string, string> = {...browserHeaders(),- ...oaiHeaders(sessionId),+ ...oaiHeaders(sessionId, deviceId),Accept: "*/*",Authorization: `Bearer ${accessToken}`,Cookie: buildSessionCookieHeader(cookie),@@ -358,16 +328,17 @@ async function prepareChatRequirements(accessToken: string,accountId: string | null,sessionId: string,+ deviceId: string,cookie: string,dplInfo: { dpl: string; scriptSrc: string },signal: AbortSignal | null | undefined): Promise<ChatRequirements> {const config = buildPrekeyConfig(CHATGPT_USER_AGENT, dplInfo.dpl, dplInfo.scriptSrc);- const prekey = buildPrepareToken(config);+ const prekey = await buildPrepareToken(config);const headers: Record<string, string> = {...browserHeaders(),- ...oaiHeaders(sessionId),+ ...oaiHeaders(sessionId, deviceId),"Content-Type": "application/json",Authorization: `Bearer ${accessToken}`,Cookie: buildSessionCookieHeader(cookie),@@ -567,10 +538,22 @@ function buildPrekeyConfig(userAgent: string, dpl: string, scriptSrc: string): u* (difficulty "0fffff") mutating config[3] to find a hash whose hex prefix* is ≤ the difficulty. Mirrors chat2api / openai-sentinel.*/-function buildPrepareToken(config: unknown[]): string {+// PoW solvers run up to 100k–500k SHA3-512 hashes. To avoid blocking the+// Node event loop on a busy server, we yield with `setImmediate` every+// POW_YIELD_EVERY iterations — roughly every ~5ms of work — so concurrent+// requests and I/O still get scheduled. Wall time is approximately the same+// as the synchronous version; what changes is fairness, not throughput.+const POW_YIELD_EVERY = 1000;++function yieldToEventLoop(): Promise<void> {+ return new Promise((resolve) => setImmediate(resolve));+}++async function buildPrepareToken(config: unknown[]): Promise<string> {const target = "0fffff";const cfg = [...config];for (let i = 0; i < 100_000; i++) {+ if (i > 0 && i % POW_YIELD_EVERY === 0) await yieldToEventLoop();cfg[3] = i;const json = JSON.stringify(cfg);const b64 = Buffer.from(json).toString("base64");@@ -584,12 +567,17 @@ function buildPrepareToken(config: unknown[]): string {return `gAAAAAC${b64}`;}-function solveProofOfWork(seed: string, difficulty: string, config: unknown[]): string {+async function solveProofOfWork(+ seed: string,+ difficulty: string,+ config: unknown[]+): Promise<string> {const target = (difficulty || "").toLowerCase();const cfg = [...config];const maxIter = 500_000;for (let i = 0; i < maxIter; i++) {+ if (i > 0 && i % POW_YIELD_EVERY === 0) await yieldToEventLoop();cfg[3] = i;const json = JSON.stringify(cfg);const b64 = Buffer.from(json).toString("base64");@@ -972,10 +960,12 @@ function buildStreamingResponse());controller.enqueue(encoder.encode("data: [DONE]\n\n"));-- if (respConversationId && respMessageId) {- convStore(history, currentMsg, fullAnswer, respConversationId, respMessageId);- }+ // Conversation continuity intentionally not persisted (Temporary Chat+ // mode — see comment near the top of the file).+ void respConversationId;+ void respMessageId;+ void history;+ void currentMsg;} catch (err) {controller.enqueue(encoder.encode(@@ -1037,9 +1027,10 @@ async function buildNonStreamingResponse(if (chunk.answer) fullAnswer = chunk.answer;}- if (respConversationId && respMessageId) {- convStore(history, currentMsg, fullAnswer, respConversationId, respMessageId);- }+ // Conversation continuity intentionally not persisted (Temporary Chat mode).+ void respConversationId;+ void respMessageId;+ void history;fullAnswer = cleanChatGptText(fullAnswer);const promptTokens = Math.ceil(currentMsg.length / 4);@@ -1190,10 +1181,12 @@ export class ChatGptWebExecutor extends BaseExecutor {// browser does on page load. Failures here are non-fatal; the worst case// is Sentinel still escalates to Turnstile.const sessionId = randomUUID();+ const deviceId = deviceIdFor(cookie);await runSessionWarmup(tokenEntry.accessToken,tokenEntry.accountId,sessionId,+ deviceId,cookie,signal,log@@ -1206,6 +1199,7 @@ export class ChatGptWebExecutor extends BaseExecutor {tokenEntry.accessToken,tokenEntry.accountId,sessionId,+ deviceId,cookie,dplInfo,signal@@ -1258,7 +1252,11 @@ export class ChatGptWebExecutor extends BaseExecutor {let proofToken: string | null = null;if (reqs.proofofwork?.required && reqs.proofofwork.seed && reqs.proofofwork.difficulty) {const powConfig = buildPrekeyConfig(CHATGPT_USER_AGENT, dplInfo.dpl, dplInfo.scriptSrc);- proofToken = solveProofOfWork(reqs.proofofwork.seed, reqs.proofofwork.difficulty, powConfig);+ proofToken = await solveProofOfWork(+ reqs.proofofwork.seed,+ reqs.proofofwork.difficulty,+ powConfig+ );}// 4. Build conversation request@@ -1272,13 +1270,11 @@ export class ChatGptWebExecutor extends BaseExecutor {};}- // Conversation continuity is intentionally disabled here. The conversation- // body sets `history_and_training_disabled: true` (Temporary Chat mode),- // and chatgpt.com expires those conversation_ids quickly — re-using them- // returns 404. Open WebUI and most OpenAI-API clients send the full- // history each turn anyway, so we just always start a fresh conversation.- // (The convCache is kept around in case we re-enable persistent chats- // later, but lookups are skipped here.)+ // Conversation continuity is intentionally disabled. The body sets+ // `history_and_training_disabled: true` (Temporary Chat mode) and+ // chatgpt.com expires those conversation_ids quickly — re-using them+ // returns 404. Each request starts a fresh conversation; clients (Open+ // WebUI, OpenAI-API-style) send the full history each turn anyway.const conversationId: string | null = null;const parentMessageId = randomUUID();@@ -1287,7 +1283,7 @@ export class ChatGptWebExecutor extends BaseExecutor {const headers: Record<string, string> = {...browserHeaders(),- ...oaiHeaders(sessionId),+ ...oaiHeaders(sessionId, deviceId),"Content-Type": "application/json",Accept: "text/event-stream",Authorization: `Bearer ${tokenEntry.accessToken}`,@@ -1313,6 +1309,11 @@ export class ChatGptWebExecutor extends BaseExecutor {body: JSON.stringify(cgptBody),timeoutMs: 120_000, // generations can take a whilesignal,+ // For real-time streaming, ask the TLS client to write the body to+ // a temp file and surface it as a ReadableStream as it arrives —+ // otherwise long generations buffer entirely before the client sees+ // anything (and the downstream HTTP request can time out).+ stream,});} catch (err) {log?.error?.("CGPT-WEB", `Fetch failed: ${err instanceof Error ? err.message : String(err)}`);@@ -1331,10 +1332,10 @@ export class ChatGptWebExecutor extends BaseExecutor {if (response.status >= 400) {const status = response.status;- // Always log the upstream body on 4xx/5xx — error responses are small- // and the upstream message is much more useful than our wrapper.-- console.log(`[CGPT-WEB] conv ${status}: ${(response.text || "").slice(0, 400)}`);+ // Log the upstream body on 4xx/5xx — error responses are small and the+ // upstream message is much more useful than our wrapper. Goes through+ // the executor logger so it respects the application's log config.+ log?.warn?.("CGPT-WEB", `conv ${status}: ${(response.text || "").slice(0, 400)}`);let errMsg = `ChatGPT returned HTTP ${status}`;if (status === 401 || status === 403) {errMsg =@@ -1342,10 +1343,7 @@ export class ChatGptWebExecutor extends BaseExecutor {tokenCache.delete(cookieKey(cookie));} else if (status === 404) {errMsg =- "ChatGPT returned 404 — usually a stale conversation_id or the model is no longer available on this account. The next request will start a fresh conversation.";- // Clear conv cache so any stale ids are dropped (defensive — we don't- // currently use the cache, but this also clears anything left over).- convCache.clear();+ "ChatGPT returned 404 — usually the model is no longer available on this account or the chat-requirements-token expired. Retry will start a fresh conversation.";} else if (status === 429) {errMsg = "ChatGPT rate limited. Wait a moment and retry.";}@@ -1358,9 +1356,16 @@ export class ChatGptWebExecutor extends BaseExecutor {};}- // The TLS client buffers the full response body for non-streaming requests.- // Wrap it in a ReadableStream so the existing SSE parser can consume it.- if (!response.text) {+ // For streaming requests the TLS client returns a ReadableStream that+ // tails the temp file as it's written. For non-streaming requests, it+ // returns the full body as text — wrap that in a one-shot stream so the+ // existing SSE parser can consume it uniformly.+ let bodyStream: ReadableStream<Uint8Array>;+ if (response.body) {+ bodyStream = response.body;+ } else if (response.text) {+ bodyStream = stringToStream(response.text);+ } else {return {response: errorResponse(502, "ChatGPT returned empty response body"),url: CONV_URL,@@ -1369,8 +1374,6 @@ export class ChatGptWebExecutor extends BaseExecutor {};}- const bodyStream = stringToStream(response.text);-const cid = `chatcmpl-cgpt-${crypto.randomUUID().slice(0, 12)}`;const created = Math.floor(Date.now() / 1000);@@ -1433,5 +1436,7 @@ function stringToStream(text: string): ReadableStream<Uint8Array> {// Test-only: clear caches between testsexport function __resetChatGptWebCachesForTesting(): void {tokenCache.clear();- convCache.clear();+ warmupCache.clear();+ deviceIdCache.clear();+ dplCache = null;}diff --git a/open-sse/services/chatgptTlsClient.ts b/open-sse/services/chatgptTlsClient.tsindex a71aeedb11..c42a0dfbf8 100644--- a/open-sse/services/chatgptTlsClient.ts+++ b/open-sse/services/chatgptTlsClient.ts@@ -61,14 +61,14 @@ async function getClient(): Promise<{request: (url: string, opts: Record<string, unknown>) => Promise<TlsResponseLike>;};await client.start();-+console.log("[CGPT-TLS] Native runtime ready (Firefox 148 fingerprint).");installExitHook();return client;} catch (err) {clientPromise = null;const msg = err instanceof Error ? err.message : String(err);-+console.log(`[CGPT-TLS] FAILED to start: ${msg}`);throw new TlsClientUnavailableError(`TLS impersonation client failed to start: ${msg}. ` +@@ -143,7 +143,18 @@ export async function tlsFetchChatGpt(options: TlsFetchOptions = {}): Promise<TlsFetchResult> {if (testOverride) return testOverride(url, options);+ // Honor abort signals up-front. tls-client-node's koffi binding doesn't+ // accept an AbortSignal mid-flight (the binary call is opaque), so the best+ // we can do is bail before issuing the call. We also re-check after — if+ // the caller aborted while the upstream was running, throw rather than+ // returning a stale response so the caller doesn't try to use it.+ if (options.signal?.aborted) {+ throw makeAbortError(options.signal);+ }const client = await getClient();+ if (options.signal?.aborted) {+ throw makeAbortError(options.signal);+ }const requestOptions: Record<string, unknown> = {method: options.method || "GET",@@ -156,10 +167,19 @@ export async function tlsFetchChatGpt(};if (options.stream) {- return await tlsFetchStreaming(client, url, requestOptions, options.streamEofSymbol);+ return await tlsFetchStreaming(+ client,+ url,+ requestOptions,+ options.streamEofSymbol,+ options.signal ?? null+ );}const tlsResponse = await client.request(url, requestOptions);+ if (options.signal?.aborted) {+ throw makeAbortError(options.signal);+ }return {status: tlsResponse.status,headers: toHeaders(tlsResponse.headers),@@ -168,6 +188,14 @@ export async function tlsFetchChatGpt(};}+function makeAbortError(signal: AbortSignal): Error {+ const reason = signal.reason;+ if (reason instanceof Error) return reason;+ const err = new Error(typeof reason === "string" ? reason : "The operation was aborted");+ err.name = "AbortError";+ return err;+}+function toHeaders(raw: Record<string, string[]>): Headers {const h = new Headers();for (const [k, vs] of Object.entries(raw || {})) {@@ -185,7 +213,8 @@ async function tlsFetchStreaming(client: { request: (url: string, opts: Record<string, unknown>) => Promise<TlsResponseLike> },url: string,requestOptions: Record<string, unknown>,- eofSymbol = "[DONE]"+ eofSymbol = "[DONE]",+ signal: AbortSignal | null = null): Promise<TlsFetchResult> {const dir = await mkdtemp(join(tmpdir(), "cgpt-stream-"));const path = join(dir, `${randomUUID()}.sse`);@@ -197,14 +226,34 @@ async function tlsFetchStreaming(streamOutputEOFSymbol: eofSymbol,};- // Kick off the request in the background — we don't await it because- // tls-client returns headers eagerly but the body keeps writing to the file.+ // Kick off the request without awaiting — tls-client writes the body to+ // `path` chunk-by-chunk while the call runs. The Promise resolves when the+ // request fully completes (full body written).const requestPromise = client.request(url, streamOpts);- // Wait for the file to exist, then build a tailing reader.+ // Wait briefly for the file to appear so we can detect early errors.const ready = await waitForFile(path, 5_000);if (!ready) {- // If the file never appeared, the request likely errored out — surface that.+ // File never appeared — request must have errored out before any body+ // bytes. Wait for it to settle and surface as a non-streaming response.+ const r = await requestPromise.catch(+ (e) => ({ status: 502, headers: {}, body: String(e) }) as TlsResponseLike+ );+ return {+ status: r.status,+ headers: toHeaders(r.headers),+ text: r.body,+ body: null,+ };+ }++ // Peek the first bytes to distinguish a JSON error envelope from an SSE+ // body. Errors typically come back as `{"detail":"..."}`; SSE bodies start+ // with `data:` or empty lines. If it looks like an error, wait for the+ // full body and return non-streaming so the executor can read response.text.+ const peek = await readFirstBytes(path, 256);+ const trimmedPeek = peek.replace(/^[\s\r\n]+/, "");+ if (trimmedPeek.startsWith("{")) {const r = await requestPromise.catch((e) => ({ status: 502, headers: {}, body: String(e) }) as TlsResponseLike);@@ -216,29 +265,26 @@ async function tlsFetchStreaming(};}- // Tail the file. requestPromise resolves with status/headers once Cloudflare- // accepts and the body finishes streaming.- const stream = tailFile(- path,- eofSymbol,- requestPromise.then((r) => r)- );- // We don't have headers/status until the request resolves, so resolve- // asynchronously but expose a sentinel for callers that only care about body.- const meta = await Promise.race([- requestPromise,- new Promise<never>((_, rej) => setTimeout(() => rej(new Error("stream meta timeout")), 30_000)),- ]).catch((e) => ({ status: 502, headers: {}, body: String(e) }) as TlsResponseLike);-- // Cleanup of the temp file/dir happens inside tailFile when EOF is reached.- void dir; // keep ref for type-checker+ // Tail the file as a real-time stream. We assume HTTP 200 here — if the+ // upstream errored, we'd have caught it via the JSON-peek above. The+ // request promise is still tracked so cleanup can run after it settles.+ const stream = tailFile(path, eofSymbol, requestPromise, signal);+ const headers = new Headers({+ "Content-Type": "text/event-stream",+ "Cache-Control": "no-cache",+ });+ return { status: 200, headers, text: null, body: stream };+}- return {- status: meta.status,- headers: toHeaders(meta.headers),- text: null,- body: stream,- };+async function readFirstBytes(path: string, n: number): Promise<string> {+ const fd = await open(path, "r");+ try {+ const buf = Buffer.alloc(n);+ const { bytesRead } = await fd.read(buf, 0, n, 0);+ return buf.subarray(0, bytesRead).toString("utf8");+ } finally {+ await fd.close().catch(() => {});+ }}async function waitForFile(path: string, timeoutMs: number): Promise<boolean> {@@ -257,7 +303,8 @@ async function waitForFile(path: string, timeoutMs: number): Promise<boolean> {function tailFile(path: string,eofSymbol: string,- done: Promise<TlsResponseLike>+ done: Promise<TlsResponseLike>,+ signal: AbortSignal | null = null): ReadableStream<Uint8Array> {return new ReadableStream<Uint8Array>({async start(controller) {@@ -265,14 +312,24 @@ function tailFile(const buf = Buffer.alloc(64 * 1024);let offset = 0;let finished = false;+ let aborted = false;// Mark when the request completes so we know to drain the rest.done.finally(() => {finished = true;});+ // If the caller aborts, stop tailing immediately.+ const onAbort = () => {+ aborted = true;+ };+ if (signal) {+ if (signal.aborted) aborted = true;+ else signal.addEventListener("abort", onAbort, { once: true });+ }+try {- while (true) {+ while (!aborted) {const { bytesRead } = await fd.read(buf, 0, buf.length, offset);if (bytesRead > 0) {const chunk = buf.subarray(0, bytesRead);@@ -294,6 +351,7 @@ function tailFile(} catch (err) {controller.error(err);} finally {+ if (signal) signal.removeEventListener("abort", onAbort);await fd.close().catch(() => {});await unlink(path).catch(() => {});const dir = path.substring(0, path.lastIndexOf("/"));diff --git a/tests/unit/chatgpt-web.test.ts b/tests/unit/chatgpt-web.test.tsindex d06048638f..081e9b42fe 100644--- a/tests/unit/chatgpt-web.test.ts+++ b/tests/unit/chatgpt-web.test.ts@@ -326,7 +326,8 @@ test("Sentinel: chat-requirements token forwarded on conv request", async () =>signal: AbortSignal.timeout(10_000),log: null,});- const convHeaders = m.calls.headers[2];+ const convIdx = m.calls.urls.findIndex((u) => u.endsWith("/backend-api/f/conversation"));+ const convHeaders = m.calls.headers[convIdx];assert.equal(convHeaders["openai-sentinel-chat-requirements-token"], "REQ-TOKEN-XYZ");} finally {m.restore();@@ -354,7 +355,8 @@ test("PoW: when required, proof token is sent with valid prefix", async () => {signal: AbortSignal.timeout(15_000),log: null,});- const convHeaders = m.calls.headers[2];+ const convIdx = m.calls.urls.findIndex((u) => u.endsWith("/backend-api/f/conversation"));+ const convHeaders = m.calls.headers[convIdx];const proof = convHeaders["openai-sentinel-proof-token"];assert.ok(proof, "proof token should be present");assert.match(proof, /^[gw]AAAAAB/);@@ -797,7 +799,11 @@ test("Session continuity: each call starts a fresh conversation (Temporary Chat});assert.equal(m.calls.conv, 2);- const secondBody = JSON.parse(m.calls.bodies[4]);+ const convIndices = m.calls.urls+ .map((u, i) => (u.endsWith("/backend-api/f/conversation") ? i : -1))+ .filter((i) => i >= 0);+ assert.equal(convIndices.length, 2);+ const secondBody = JSON.parse(m.calls.bodies[convIndices[1]]);assert.equal(secondBody.conversation_id, null, "should start a fresh conversation");// The full history should be replayed in the messages array.const userMessages = secondBody.messages.filter((m) => m.author?.role === "user");@@ -823,8 +829,9 @@ test("Request: conversation POST has correct browser-like headers", async () =>log: null,});- assert.equal(m.calls.urls[2], "https://chatgpt.com/backend-api/f/conversation");- const convHeaders = m.calls.headers[2];+ const convIdx = m.calls.urls.findIndex((u) => u.endsWith("/backend-api/f/conversation"));+ assert.equal(m.calls.urls[convIdx], "https://chatgpt.com/backend-api/f/conversation");+ const convHeaders = m.calls.headers[convIdx];assert.match(convHeaders["User-Agent"], /Mozilla/);assert.equal(convHeaders["Origin"], "https://chatgpt.com");assert.equal(convHeaders["Sec-Fetch-Site"], "same-origin");@@ -852,7 +859,8 @@ test("Request: payload has correct ChatGPT shape", async () => {signal: AbortSignal.timeout(10_000),log: null,});- const body = JSON.parse(m.calls.bodies[2]);+ const convIdx = m.calls.urls.findIndex((u) => u.endsWith("/backend-api/f/conversation"));+ const body = JSON.parse(m.calls.bodies[convIdx]);assert.equal(body.action, "next");assert.equal(body.model, "gpt-5-3");assert.equal(body.history_and_training_disabled, true);