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 #1596 review feedback (#1597)
Payne99331f777e62
diff --git a/open-sse/executors/chatgpt-web.ts b/open-sse/executors/chatgpt-web.tsindex d7592e7048..f8df8ebbc9 100644--- a/open-sse/executors/chatgpt-web.ts+++ b/open-sse/executors/chatgpt-web.ts@@ -152,6 +152,16 @@ interface SessionResponse {user?: { id?: string };}+// Session-token family — NextAuth uses one of these depending on token size:+// __Secure-next-auth.session-token (unchunked, < 4KB)+// __Secure-next-auth.session-token.0 (chunked, first piece)+// __Secure-next-auth.session-token.N (chunked, additional pieces)+// Rotation can change the shape (unchunked → chunked or vice versa). When+// that happens, every old family member must be dropped — keeping the stale+// variant alongside the new one would send both, and depending on parser+// precedence the server could read the stale value and fail auth.+const SESSION_TOKEN_FAMILY_RE = /^__Secure-next-auth\.session-token(?:\.\d+)?$/;+/*** Merge any rotated session-token chunks from a Set-Cookie response into the* original cookie blob, preserving every other cookie the caller pasted@@ -186,9 +196,9 @@ function mergeRefreshedCookie(}const pairs = blob.split(/;\s*/).filter(Boolean);- const replaced = new Set<string>();const result: string[] = [];let mutated = false;+ let droppedStale = false;for (const pair of pairs) {const eqIdx = pair.indexOf("=");if (eqIdx < 0) {@@ -197,23 +207,22 @@ function mergeRefreshedCookie(}const name = pair.slice(0, eqIdx).trim();const value = pair.slice(eqIdx + 1);- if (refreshed.has(name)) {- const newValue = refreshed.get(name)!;- if (newValue !== value) mutated = true;- result.push(`${name}=${newValue}`);- replaced.add(name);- } else {- result.push(`${name}=${value}`);+ // Drop ALL session-token-family members from the original — we'll+ // append the refreshed set below. This handles unchunked→chunked and+ // chunked→unchunked rotations, where keeping the old name would leave+ // the stale token visible alongside the new one.+ if (SESSION_TOKEN_FAMILY_RE.test(name)) {+ if (!refreshed.has(name) || refreshed.get(name) !== value) mutated = true;+ droppedStale = true;+ continue;}+ result.push(`${name}=${value}`);}- // Append any rotated chunks that weren't in the original (e.g., the user- // pasted only `.0` but rotation returned `.0` and `.1`).+ // Append the full refreshed family.for (const [name, value] of refreshed) {- if (!replaced.has(name)) {- result.push(`${name}=${value}`);- mutated = true;- }+ result.push(`${name}=${value}`);}+ if (!droppedStale) mutated = true; // refreshed chunks were entirely newreturn mutated ? result.join("; ") : null;}diff --git a/open-sse/services/chatgptTlsClient.ts b/open-sse/services/chatgptTlsClient.tsindex 9d66d44323..a7e5c1c603 100644--- a/open-sse/services/chatgptTlsClient.ts+++ b/open-sse/services/chatgptTlsClient.ts@@ -228,8 +228,16 @@ async function tlsFetchStreaming(// request fully completes (full body written).const requestPromise = client.request(url, streamOpts);- // Wait briefly for the file to appear so we can detect early errors.- const ready = await waitForFile(path, 5_000);+ // Wait for the file to exist AND have at least one byte. tls-client-node+ // creates the output file when the request starts, but the file can be+ // empty for a brief window before the first body chunk lands — peeking+ // during that window would return "" and misclassify the response as+ // non-SSE, dropping us into the buffered-wait branch and silently turning+ // a streaming request into a buffered one. Waiting for content avoids+ // that race; if the request actually fails before producing any bytes,+ // the timeout falls through to the requestPromise drain below (returning+ // the real upstream status).+ const ready = await waitForContent(path, 5_000, requestPromise);if (!ready) {const r = await requestPromise.catch((e) => ({ status: 502, headers: {}, body: String(e) }) as TlsResponseLike@@ -305,15 +313,39 @@ async function readFirstBytes(path: string, n: number): Promise<string> {}}-async function waitForFile(path: string, timeoutMs: number): Promise<boolean> {+/**+ * Wait for the streaming output file to exist AND contain at least one byte.+ * Returns false if the request settles before any bytes arrive (so the caller+ * can drain `requestPromise` and surface the real upstream status). Returns+ * true as soon as the file has data — even one byte is enough for the SSE+ * heuristic to give a useful answer.+ */+async function waitForContent(+ path: string,+ timeoutMs: number,+ requestPromise: Promise<TlsResponseLike>+): Promise<boolean> {+ let requestSettled = false;+ requestPromise.then(+ () => {+ requestSettled = true;+ },+ () => {+ requestSettled = true;+ }+ );const start = Date.now();while (Date.now() - start < timeoutMs) {try {- await stat(path);- return true;+ const s = await stat(path);+ if (s.size > 0) return true;} catch {- await sleep(25);+ // file doesn't exist yet}+ // If the request finished without producing any bytes, no point waiting+ // out the rest of the timeout — let the caller drain it.+ if (requestSettled) return false;+ await sleep(25);}return false;}diff --git a/tests/unit/chatgpt-web.test.ts b/tests/unit/chatgpt-web.test.tsindex 4a16192145..5a489a897a 100644--- a/tests/unit/chatgpt-web.test.ts+++ b/tests/unit/chatgpt-web.test.ts@@ -949,6 +949,102 @@ test("Cookie rotation: full DevTools blob keeps cf_clearance/__cf_bm/_cfuvid", a}});+test("Cookie rotation: unchunked → chunked drops stale unchunked variant", async () => {+ // When the original was unchunked (< 4KB session token) and rotation+ // returns chunked (.0/.1), the stale unchunked entry must NOT survive in+ // the merged blob — otherwise both old and new session-token cookies are+ // sent on the next request and depending on parser precedence the server+ // could read the stale value.+ reset();+ const m = installMockFetch({+ session: {+ status: 200,+ body: {+ accessToken: "jwt-abc",+ expires: new Date(Date.now() + 3600_000).toISOString(),+ user: { id: "user-1" },+ },+ setCookie:+ "__Secure-next-auth.session-token.0=NEW0; Path=/; HttpOnly, " ++ "__Secure-next-auth.session-token.1=NEW1; Path=/; HttpOnly",+ },+ });+ try {+ let refreshed = null;+ const executor = new ChatGptWebExecutor();+ await executor.execute({+ model: "gpt-5.3-instant",+ body: { messages: [{ role: "user", content: "hi" }] },+ stream: false,+ credentials: {+ apiKey: "__Secure-next-auth.session-token=UNCHUNKED_OLD; cf_clearance=CFCLEAR",+ },+ signal: AbortSignal.timeout(10_000),+ log: null,+ onCredentialsRefreshed: (creds) => {+ refreshed = creds;+ },+ });+ assert.ok(refreshed);+ // Stale unchunked variant must NOT appear (whole or in part).+ assert.doesNotMatch(+ refreshed.apiKey,+ /__Secure-next-auth\.session-token=UNCHUNKED_OLD/,+ "stale unchunked session-token must be dropped"+ );+ // Non-session-token cookies preserved.+ assert.match(refreshed.apiKey, /cf_clearance=CFCLEAR/);+ // New chunks present.+ assert.match(refreshed.apiKey, /session-token\.0=NEW0/);+ assert.match(refreshed.apiKey, /session-token\.1=NEW1/);+ } finally {+ m.restore();+ }+});++test("Cookie rotation: chunked → unchunked drops stale chunks", async () => {+ // Reverse case: original is chunked, rotation goes back to unchunked.+ reset();+ const m = installMockFetch({+ session: {+ status: 200,+ body: {+ accessToken: "jwt-abc",+ expires: new Date(Date.now() + 3600_000).toISOString(),+ user: { id: "user-1" },+ },+ setCookie: "__Secure-next-auth.session-token=NEW_UNCHUNKED; Path=/; HttpOnly",+ },+ });+ try {+ let refreshed = null;+ const executor = new ChatGptWebExecutor();+ await executor.execute({+ model: "gpt-5.3-instant",+ body: { messages: [{ role: "user", content: "hi" }] },+ stream: false,+ credentials: {+ apiKey:+ "__Secure-next-auth.session-token.0=OLD0; " ++ "__Secure-next-auth.session-token.1=OLD1; " ++ "cf_clearance=CFCLEAR",+ },+ signal: AbortSignal.timeout(10_000),+ log: null,+ onCredentialsRefreshed: (creds) => {+ refreshed = creds;+ },+ });+ assert.ok(refreshed);+ assert.doesNotMatch(refreshed.apiKey, /OLD0/, "stale chunk .0 dropped");+ assert.doesNotMatch(refreshed.apiKey, /OLD1/, "stale chunk .1 dropped");+ assert.match(refreshed.apiKey, /session-token=NEW_UNCHUNKED/);+ assert.match(refreshed.apiKey, /cf_clearance=CFCLEAR/);+ } finally {+ m.restore();+ }+});+test("Cookie rotation: returns null when Set-Cookie has no session-token", async () => {// When NextAuth doesn't rotate (Set-Cookie sets only unrelated cookies, or// returns the same session-token value), the callback shouldn't fire.