@code-yeongyu/senpi-ai 2026.10.18 → 2026.10.19-1

package/dist/api/anthropic-messages.js

@@ -10,6 +10,7 @@ import { splitDeferredTools } from "../utils/deferred-tools.js";
 import { appendAssistantMessageDiagnostic } from "../utils/diagnostics.js";
 import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { formatGitHubCopilotToolLimitError, limitGitHubCopilotTools, recordGitHubCopilotToolLimit, } from "../utils/github-copilot-tool-limit.js";
+import { withGzipRequestBodies } from "../utils/gzip-request-body.js";
 import { headersToRecord, providerHeadersToRecord } from "../utils/headers.js";
 import { parseJsonWithRepair, parseStreamingJson } from "../utils/json-parse.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
@@ -28,6 +29,7 @@ import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.
 import { resolveRootObjectSchema } from "../utils/tool-schema-compat.js";
 import { getCurrentTools, getDeclaredTools, getInitialSystemMessage, hasToolRedefinitions, normalizeContext, resolveTranscript, } from "../utils/transcript.js";
 import { isAnthropicWebSearchReplayBlock, isReplayableAnthropicProviderNativeBlock, } from "./anthropic-native-replay-blocks.js";
+import { logAnthropicRequestShape } from "./anthropic-request-shape-log.js";
 import { sanitizeAnthropicToolPairs } from "./anthropic-tool-pairs.js";
 import { demoteToolReferenceReplay, demoteUnavailableToolReferences } from "./anthropic-tool-references.js";
 import { demoteExpiredWebSearchReplay, expiredWebSearchReplayIds, isExpiredWebSearchContentError, } from "./anthropic-web-search-expiry.js";
@@ -959,7 +961,9 @@ export const stream = (model, context, options) => {
                 const cacheRetention = resolveCacheRetention(options?.cacheRetention ?? model.cacheRetention, options?.env, "short");
                 const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
                 openClient = () => {
-                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined && configuredBetaHeader(model, options) !== null, optionsHeaders, options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
+                    const created = createClient(model, apiKey, options?.interleavedThinking ?? true, shouldUseFineGrainedToolStreamingBeta(model, normalizedContext), options?.refusalFallbacks !== undefined && configuredBetaHeader(model, options) !== null, optionsHeaders, getAnthropicCompat(model).supportsGzipRequestBody
+                        ? withGzipRequestBodies(options?.fetch)
+                        : options?.fetch, copilotDynamicHeaders, cacheSessionId, options?.env, federation);
                     client = created.client;
                     isOAuth = created.isOAuthToken;
                     advertisedClaudeCodeVersion = created.claudeCodeVersion;
@@ -1032,7 +1036,11 @@ export const stream = (model, context, options) => {
                     maxRetries: 0,
                     ...(payloadRequestMetadata.headers ? { headers: payloadRequestMetadata.headers } : {}),
                 };
-                const send = (body) => awaitProviderTransport(() => client.beta.messages.create({ ...body, stream: true }, requestOptions).asResponse(), anthropicProviderDiagnosticFromError);
+                // Logged before the call: the SDK throws on a non-2xx, and a rejected attempt is the one worth rebuilding.
+                const send = (body) => {
+                    logAnthropicRequestShape(model, body);
+                    return awaitProviderTransport(() => client.beta.messages.create({ ...body, stream: true }, requestOptions).asResponse(), anthropicProviderDiagnosticFromError);
+                };
                 const sent = await sendWithForcedToolChoiceFallback({
                     target: model,
                     params,

package/dist/api/anthropic-request-shape-log.d.ts

@@ -0,0 +1,24 @@
+/** Debug-only request skeleton: roles, block types and tool ids per index, never content (senpi#3727). */
+export declare const REQUEST_SHAPE_LOG_ENV = "SENPI_DEBUG_REQUEST_SHAPE";
+interface BlockSkeleton {
+    readonly type: string;
+    readonly id?: string;
+    readonly toolUseId?: string;
+}
+interface MessageSkeleton {
+    readonly index: number;
+    readonly role: string;
+    readonly blocks: readonly BlockSkeleton[] | "string";
+}
+export declare function anthropicRequestSkeleton(params: {
+    readonly messages?: unknown;
+}): MessageSkeleton[];
+type AppendFile = (path: string, data: string) => void;
+export declare function logAnthropicRequestShape(model: {
+    readonly provider: string;
+    readonly id: string;
+}, params: {
+    readonly messages?: unknown;
+}, env?: Readonly<Record<string, string | undefined>>, appendFile?: AppendFile | undefined): void;
+export {};
+//# sourceMappingURL=anthropic-request-shape-log.d.ts.map

package/dist/api/anthropic-request-shape-log.js

@@ -0,0 +1,50 @@
+/** Debug-only request skeleton: roles, block types and tool ids per index, never content (senpi#3727). */
+export const REQUEST_SHAPE_LOG_ENV = "SENPI_DEBUG_REQUEST_SHAPE";
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function skeletonBlock(block) {
+    if (!isRecord(block))
+        return { type: typeof block };
+    const type = typeof block.type === "string" ? block.type : "unknown";
+    return {
+        type,
+        ...(typeof block.id === "string" ? { id: block.id } : {}),
+        ...(typeof block.tool_use_id === "string" ? { toolUseId: block.tool_use_id } : {}),
+    };
+}
+export function anthropicRequestSkeleton(params) {
+    const messages = Array.isArray(params.messages) ? params.messages : [];
+    return messages.map((message, index) => {
+        if (!isRecord(message))
+            return { index, role: "unknown", blocks: [] };
+        const role = typeof message.role === "string" ? message.role : "unknown";
+        const blocks = Array.isArray(message.content) ? message.content.map(skeletonBlock) : "string";
+        return { index, role, blocks };
+    });
+}
+function resolveAppendFile() {
+    if (typeof process === "undefined")
+        return undefined;
+    const fs = process.getBuiltinModule?.("node:fs");
+    return fs ? (path, data) => fs.appendFileSync(path, data, { mode: 0o600 }) : undefined;
+}
+function processEnv() {
+    return typeof process === "undefined" ? {} : process.env;
+}
+export function logAnthropicRequestShape(model, params, env = processEnv(), appendFile = undefined) {
+    const path = env[REQUEST_SHAPE_LOG_ENV];
+    if (path === undefined || path.length === 0)
+        return;
+    const append = appendFile ?? resolveAppendFile();
+    if (append === undefined)
+        return;
+    const record = {
+        ts: new Date().toISOString(),
+        provider: model.provider,
+        model: model.id,
+        messages: anthropicRequestSkeleton(params),
+    };
+    append(path, `${JSON.stringify(record)}\n`);
+}
+//# sourceMappingURL=anthropic-request-shape-log.js.map

package/dist/api/chatgpt-usage-limit.d.ts

@@ -0,0 +1,26 @@
+/**
+ * User-facing wording for a ChatGPT sign-in refusal past the plan's usage limit (senpi#3615).
+ *
+ * Codex CLI sends no flag to spend credits: the backend decides from the account, and when it
+ * refuses it explains which limit applies through `x-codex-rate-limit-reached-type` and
+ * `x-codex-credits-has-credits` next to the body's `plan_type` and `resets_at` (openai/codex
+ * `codex-rs/protocol/src/error.rs`). This mirrors those cases and always ends on a next step. The
+ * text keeps the "You have hit your ChatGPT usage limit" opening every usage-limit classifier
+ * already matches, and never says "model": a model word would make the fallback layer treat an
+ * account-wide limit as one model's limit. Codex's free-form `x-codex-promo-message` is left out
+ * for that reason, since its wording is the backend's and can name models.
+ */
+export declare const CHATGPT_USAGE_LIMIT_PREFIX = "You have hit your ChatGPT usage limit";
+export interface ChatGptUsageLimitInput {
+    readonly planType?: string;
+    /** Reset as Unix seconds, from the error body. */
+    readonly resetsAt?: number;
+    readonly header: (name: string) => string | undefined;
+    readonly nowMs?: number;
+}
+/** HTTP refusal: a usage-limit code or any 429 whose JSON body carries an `error` object. */
+export declare function describeChatGptUsageLimitResponse(status: number, body: unknown, headers: Headers): string | undefined;
+/** WebSocket `error` event, which carries the HTTP status and headers inline (openai/codex `WrappedWebsocketErrorEvent`). */
+export declare function describeChatGptUsageLimitEvent(event: Record<string, unknown>): string | undefined;
+export declare function describeChatGptUsageLimit(input: ChatGptUsageLimitInput): string;
+//# sourceMappingURL=chatgpt-usage-limit.d.ts.map

package/dist/api/chatgpt-usage-limit.js

@@ -0,0 +1,103 @@
+/**
+ * User-facing wording for a ChatGPT sign-in refusal past the plan's usage limit (senpi#3615).
+ *
+ * Codex CLI sends no flag to spend credits: the backend decides from the account, and when it
+ * refuses it explains which limit applies through `x-codex-rate-limit-reached-type` and
+ * `x-codex-credits-has-credits` next to the body's `plan_type` and `resets_at` (openai/codex
+ * `codex-rs/protocol/src/error.rs`). This mirrors those cases and always ends on a next step. The
+ * text keeps the "You have hit your ChatGPT usage limit" opening every usage-limit classifier
+ * already matches, and never says "model": a model word would make the fallback layer treat an
+ * account-wide limit as one model's limit. Codex's free-form `x-codex-promo-message` is left out
+ * for that reason, since its wording is the backend's and can name models.
+ */
+import { ACCOUNT_LIMIT_NEXT_STEP_LEAD } from "../utils/provider-failure-description.js";
+export const CHATGPT_USAGE_LIMIT_PREFIX = "You have hit your ChatGPT usage limit";
+const OTHER_ROUTES = `${ACCOUNT_LIMIT_NEXT_STEP_LEAD}add an OpenAI API key, sign in with another ChatGPT account, or switch providers.`;
+const USAGE_PAGE = "https://chatgpt.com/settings/usage";
+const REACHED_TYPE_ADVICE = {
+    workspace_owner_credits_depleted: `Your workspace is out of credits: add credits at ${USAGE_PAGE}.`,
+    workspace_member_credits_depleted: "Your workspace is out of credits: ask your workspace owner to add more.",
+    workspace_owner_usage_limit_reached: "You hit the spend cap set for your workspace: raise it to continue.",
+    workspace_member_usage_limit_reached: "You hit the spend cap your workspace owner set: ask an owner to raise it to continue.",
+};
+const PLAN_ADVICE = {
+    plus: `Upgrade to Pro, or buy credits at ${USAGE_PAGE}.`,
+    pro: `Buy credits at ${USAGE_PAGE}.`,
+    prolite: `Buy credits at ${USAGE_PAGE}.`,
+    promax: `Buy credits at ${USAGE_PAGE}.`,
+    free: "Upgrade to ChatGPT Plus to continue.",
+    go: "Upgrade to ChatGPT Plus to continue.",
+    team: "Ask your workspace admin for more access.",
+    business: "Ask your workspace admin for more access.",
+    self_serve_business_usage_based: "Ask your workspace admin for more access.",
+    enterprise_cbp_usage_based: "Ask your workspace admin for more access.",
+};
+function headerBool(value) {
+    const raw = value?.trim().toLowerCase();
+    if (raw === "true" || raw === "1")
+        return true;
+    if (raw === "false" || raw === "0")
+        return false;
+    return undefined;
+}
+function limitAdvice(input, plan) {
+    const reachedType = input.header("x-codex-rate-limit-reached-type")?.trim().toLowerCase();
+    const reached = reachedType ? REACHED_TYPE_ADVICE[reachedType] : undefined;
+    if (reached)
+        return reached;
+    if (headerBool(input.header("x-codex-credits-has-credits")) === true) {
+        return "This account has ChatGPT credits, but ChatGPT did not apply them to this request.";
+    }
+    return plan ? PLAN_ADVICE[plan] : undefined;
+}
+const USAGE_LIMIT_CODE = /usage_limit_reached|usage_not_included/i;
+const HTTP_LIMIT_CODE = /usage_limit_reached|usage_not_included|rate_limit_exceeded/i;
+function asUsageLimitError(value) {
+    return value !== null && typeof value === "object" ? value : undefined;
+}
+function fromError(error, header) {
+    return describeChatGptUsageLimit({
+        ...(typeof error.plan_type === "string" ? { planType: error.plan_type } : {}),
+        ...(typeof error.resets_at === "number" ? { resetsAt: error.resets_at } : {}),
+        header,
+    });
+}
+function hasCode(error, pattern) {
+    const code = typeof error.code === "string" && error.code ? error.code : error.type;
+    return typeof code === "string" && pattern.test(code);
+}
+/** HTTP refusal: a usage-limit code or any 429 whose JSON body carries an `error` object. */
+export function describeChatGptUsageLimitResponse(status, body, headers) {
+    const container = asUsageLimitError(body);
+    const error = container ? asUsageLimitError(Reflect.get(container, "error")) : undefined;
+    if (!error || !(hasCode(error, HTTP_LIMIT_CODE) || status === 429))
+        return undefined;
+    return fromError(error, (name) => headers.get(name) ?? undefined);
+}
+/** WebSocket `error` event, which carries the HTTP status and headers inline (openai/codex `WrappedWebsocketErrorEvent`). */
+export function describeChatGptUsageLimitEvent(event) {
+    const error = asUsageLimitError(event.error);
+    if (!error || !hasCode(error, USAGE_LIMIT_CODE))
+        return undefined;
+    const headers = asUsageLimitError(event.headers);
+    return fromError(error, (name) => {
+        if (!headers)
+            return undefined;
+        const entry = Object.entries(headers).find(([key]) => key.toLowerCase() === name);
+        return typeof entry?.[1] === "string" ? entry[1] : undefined;
+    });
+}
+export function describeChatGptUsageLimit(input) {
+    const plan = input.planType?.trim().toLowerCase() || undefined;
+    const sentences = [`${CHATGPT_USAGE_LIMIT_PREFIX}${plan ? ` (${plan} plan)` : ""}.`];
+    const advice = limitAdvice(input, plan);
+    if (advice)
+        sentences.push(advice);
+    sentences.push(OTHER_ROUTES);
+    if (input.resetsAt !== undefined && Number.isFinite(input.resetsAt)) {
+        const mins = Math.max(0, Math.round((input.resetsAt * 1000 - (input.nowMs ?? Date.now())) / 60000));
+        sentences.push(`Try again in ~${mins} min.`);
+    }
+    return sentences.join(" ");
+}
+//# sourceMappingURL=chatgpt-usage-limit.js.map

package/dist/api/openai-codex-responses.js

@@ -20,6 +20,7 @@ import { appendRetryAfterMsMarker, extract429RetryAfterMs } from "../utils/retry
 import { getSystemMessageText } from "../utils/text.js";
 import { getDeclaredTools, getInitialSystemMessage, normalizeContext, resolveTranscript } from "../utils/transcript.js";
 import { uuidv7 } from "../utils/uuid.js";
+import { describeChatGptUsageLimitEvent, describeChatGptUsageLimitResponse } from "./chatgpt-usage-limit.js";
 import { createGrammarToolInputProperties } from "./constrained-sampling.js";
 import { clearWebSocketFallbackState, getOrCreateWebSocketDebugStats, getWebSocketDebugStats, isWebSocketSseFallbackActive, recordWebSocketFailure, recordWebSocketSseFallback, recordWebSocketSuccess, } from "./openai-codex-responses/fallback-state.js";
 import { buildCodexReasoning } from "./openai-codex-responses/reasoning.js";
@@ -304,7 +305,7 @@ export const stream = (model, context, options) => {
                         status: response.status,
                         statusText: response.statusText,
                     });
-                    const info = await parseErrorResponse(fakeResponse);
+                    const info = await parseErrorResponse(fakeResponse, response.headers);
                     let errorMessage = info.friendlyMessage || info.message;
                     if (response.status === 429) {
                         const hintMs = extract429RetryAfterMs({
@@ -450,16 +451,17 @@ function buildRequestBody(model, context, options, cacheSessionId, grammarToolIn
     return body;
 }
 function getServiceTierCostMultiplier(model, serviceTier) {
+    // This lane spends a ChatGPT plan's included usage, which OpenAI meters at 2.5x Standard for
+    // Fast and 8x for GPT-6 Astra / GPT-6.1 Sol Ultrafast (https://developers.openai.com/codex/pricing).
+    // The 2x / 6x figures are the purchased-credit and API rates; the openai-responses lane keeps those.
     switch (serviceTier) {
         case "ultrafast":
-            // OpenAI prices GPT-6 Astra and GPT-6.1 Sol Ultrafast at 6x Standard on every
-            // token class and context tier. Any other model keeps its base rate.
-            return ["gpt-6-astra", "gpt-6.1-sol"].includes(model.upstreamModelId ?? model.id) ? 6 : 1;
+            return ["gpt-6-astra", "gpt-6.1-sol"].includes(model.upstreamModelId ?? model.id) ? 8 : 1;
         case "flex":
             return 0.5;
         case "priority":
         case "fast":
-            return model.id === "gpt-5.5" ? 2.5 : 2;
+            return 2.5;
         default:
             return 1;
     }
@@ -586,7 +588,7 @@ async function* mapCodexEvents(events, output, model, onProviderStreamEvent) {
         if (type === "error") {
             const code = getCodexEventErrorCode(event);
             const message = getCodexEventErrorMessage(event);
-            let errorText = `Codex error: ${message || code || JSON.stringify(event)}`;
+            let errorText = describeChatGptUsageLimitEvent(event) ?? `Codex error: ${message || code || JSON.stringify(event)}`;
             const hintMs = extract429RetryAfterMs({ bodyText: JSON.stringify(event) });
             if (hintMs !== undefined) {
                 errorText = appendRetryAfterMsMarker(errorText, hintMs);
@@ -1282,23 +1284,15 @@ async function processWebSocketStream(url, body, headers, output, stream, model,
 // ============================================================================
 // Error Handling
 // ============================================================================
-async function parseErrorResponse(response) {
+async function parseErrorResponse(response, headers) {
     const raw = await response.text();
     let message = raw || response.statusText || "Request failed";
     let friendlyMessage;
     try {
         const parsed = JSON.parse(raw);
+        friendlyMessage = describeChatGptUsageLimitResponse(response.status, parsed, headers);
         const err = parsed?.error;
         if (err) {
-            const code = err.code || err.type || "";
-            if (/usage_limit_reached|usage_not_included|rate_limit_exceeded/i.test(code) || response.status === 429) {
-                const plan = err.plan_type ? ` (${err.plan_type.toLowerCase()} plan)` : "";
-                const mins = err.resets_at
-                    ? Math.max(0, Math.round((err.resets_at * 1000 - Date.now()) / 60000))
-                    : undefined;
-                const when = mins !== undefined ? ` Try again in ~${mins} min.` : "";
-                friendlyMessage = `You have hit your ChatGPT usage limit${plan}.${when}`.trim();
-            }
             message = err.message || friendlyMessage || message;
         }
     }

package/dist/api/openai-images.js

@@ -1,6 +1,8 @@
 import OpenAI from "openai";
+import { readProviderDiagnostic } from "../provider-diagnostic.js";
 import { formatProviderError, normalizeProviderError } from "../utils/error-body.js";
 import { headersToRecord } from "../utils/headers.js";
+import { awaitProviderTransport, openAICompatibleProviderDiagnosticFromError, } from "../utils/provider-diagnostic-sources.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
 import { buildEditParams } from "./openai-images-edit.js";
@@ -46,9 +48,9 @@ export const generateImages = async (model, context, options) => {
         const { data: response, response: rawResponse } = await retryProviderRequest(() => {
             // openai SDK pinned at 6.26.0 predates gpt-image-2.5 quality tiers
             const sdkParams = params;
-            return (method === "edit"
+            return awaitProviderTransport(() => (method === "edit"
                 ? client.images.edit(sdkParams, requestOptions)
-                : client.images.generate(sdkParams, requestOptions)).withResponse();
+                : client.images.generate(sdkParams, requestOptions)).withResponse(), openAICompatibleProviderDiagnosticFromError);
         }, {
             maxRetries: options?.maxRetries,
             maxRetryDelayMs: options?.maxRetryDelayMs,
@@ -75,6 +77,9 @@ export const generateImages = async (model, context, options) => {
     catch (error) {
         output.stopReason = options?.signal?.aborted ? "aborted" : "error";
         output.errorMessage = formatProviderError(normalizeProviderError(error));
+        const providerDiagnostic = output.stopReason === "error" ? readProviderDiagnostic(error) : undefined;
+        if (providerDiagnostic !== undefined)
+            output.providerDiagnostic = providerDiagnostic;
         return output;
     }
 };

package/dist/api/warm-prompt-cache.js

@@ -1,5 +1,6 @@
+import { withGzipRequestBodies } from "../utils/gzip-request-body.js";
 import { providerHeadersToRecord } from "../utils/headers.js";
-import { isAnthropicApiBaseUrl } from "../utils/prompt-cache-ttl.js";
+import { getAnthropicCompat, isAnthropicApiBaseUrl } from "../utils/prompt-cache-ttl.js";
 import { isOpenAIResponsesPromptCacheModel } from "./openai-responses-prompt-cache.js";
 import { getPromptCacheWarmer } from "./prompt-cache-warmers.js";
 export async function warmPromptCache(model, context, options = {}) {
@@ -38,7 +39,9 @@ export async function warmPromptCache(model, context, options = {}) {
         apiKey: options.apiKey ?? null,
         baseURL: anthropicModel.baseUrl,
         dangerouslyAllowBrowser: true,
-        fetch: options.fetch,
+        fetch: getAnthropicCompat(anthropicModel).supportsGzipRequestBody
+            ? withGzipRequestBodies(options.fetch)
+            : options.fetch,
         defaultHeaders: { ...anthropicModel.headers, ...headers },
     });
     let params = buildAnthropicWarmPromptCacheParams(anthropicModel, context, options);

package/dist/auth/oauth/callback-server.d.ts

@@ -17,6 +17,11 @@ export interface OAuthCallbackServerOptions<T> {
     redirectHost?: string;
     /** Expected `state` parameter. Omit when the provider does not send one. */
     state?: string;
+    /**
+     * Path a newer login on this machine requests to take the port over (Codex CLI's `/cancel`). The
+     * listener stops waiting for the browser and frees the port; its login keeps the paste prompt.
+     */
+    cancelPath?: string;
     /**
      * Finishes the sign-in with the received code before the browser page is sent, so the page can
      * show exchange failures. Pass `async (code) => code` to exchange the code later.
@@ -36,6 +41,13 @@ export interface OAuthCallbackServer<T> {
     cancel(): void;
     close(): void;
 }
+/**
+ * Header a newer login on this machine sends with its takeover request. A web page cannot send it:
+ * a custom header on a cross-origin request needs a CORS preflight this server never approves, and a
+ * plain GET (an `<img>` tag) or form POST cannot carry it. Requests that carry `Origin` came from a
+ * page and are refused outright (senpi#3623 review).
+ */
+export declare const OAUTH_CANCEL_HEADER = "x-oauth-callback-cancel";
 export declare function startOAuthCallbackServer<T>(options: OAuthCallbackServerOptions<T>): Promise<OAuthCallbackServer<T>>;
 /**
  * Wait for the browser callback, or for the user to paste the code or redirect URL when the browser

package/dist/auth/oauth/callback-server.js

@@ -6,6 +6,16 @@
  */
 import { createServer } from "node:http";
 import { oauthErrorHtml, oauthSuccessHtml } from "../../utils/oauth-page.js";
+/**
+ * Header a newer login on this machine sends with its takeover request. A web page cannot send it:
+ * a custom header on a cross-origin request needs a CORS preflight this server never approves, and a
+ * plain GET (an `<img>` tag) or form POST cannot carry it. Requests that carry `Origin` came from a
+ * page and are refused outright (senpi#3623 review).
+ */
+export const OAUTH_CANCEL_HEADER = "x-oauth-callback-cancel";
+function isLocalCancelRequest(request) {
+    return (request.method === "POST" && request.headers[OAUTH_CANCEL_HEADER] === "1" && request.headers.origin === undefined);
+}
 function sendPage(response, status, html) {
     response.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
     response.end(html);
@@ -41,12 +51,24 @@ export async function startOAuthCallbackServer(options) {
     const server = createServer((request, response) => {
         void (async () => {
             const url = new URL(request.url ?? "/", "http://localhost");
+            if (options.cancelPath !== undefined && url.pathname === options.cancelPath) {
+                if (!isLocalCancelRequest(request)) {
+                    sendPage(response, 403, oauthErrorHtml("Not allowed."));
+                    return;
+                }
+                sendPage(response, 200, oauthErrorHtml("This sign-in was replaced by a newer one."));
+                if (!claimed) {
+                    finish({ value: undefined });
+                    server.close();
+                }
+                return;
+            }
             if (request.method !== "GET" || url.pathname !== options.path) {
                 sendPage(response, 404, oauthErrorHtml("Callback route not found."));
                 return;
             }
             if (options.state !== undefined && url.searchParams.get("state") !== options.state) {
-                sendPage(response, 400, oauthErrorHtml("State mismatch."));
+                sendPage(response, 400, oauthErrorHtml("State mismatch.", "This page belongs to a different sign-in than the one listening here. Copy this page's address and paste it into the session that is waiting for it, or start the sign-in again."));
                 return;
             }
             if (claimed || settled) {

package/dist/auth/oauth/chatgpt-subscription-callback.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Loopback listener for the ChatGPT subscription browser login (senpi#3623).
+ *
+ * OpenAI registers only ports 1455 and 1457 for this client, so the port cannot be ephemeral. When
+ * another login on this machine (a second session, an abandoned RPC prompt, the desktop engine, or
+ * Codex CLI) still holds 1455, this asks it to let go with a `POST /cancel` carrying a header no web page can send (Codex CLI's server answers any method on `/cancel`) and retries briefly, then
+ * falls back to 1457, the same order as Codex CLI's `bind_server`. The authorize URL must name the
+ * port actually bound, so callers build it from the returned `redirectUri`.
+ *
+ * NOTE: uses node:http; reached only through the lazily loaded ChatGPT OAuth flow.
+ */
+import { type OAuthCallbackServer } from "./callback-server.ts";
+export declare const CHATGPT_CALLBACK_PORTS: readonly number[];
+export interface ChatGptCallback {
+    readonly server: OAuthCallbackServer<string>;
+    readonly redirectUri: string;
+}
+export interface ChatGptCallbackOptions {
+    readonly host: string;
+    readonly state: string;
+    readonly signal: AbortSignal;
+    readonly ports?: readonly number[];
+}
+export declare function startChatGptCallback(options: ChatGptCallbackOptions): Promise<ChatGptCallback | undefined>;
+//# sourceMappingURL=chatgpt-subscription-callback.d.ts.map

package/dist/auth/oauth/chatgpt-subscription-callback.js

@@ -0,0 +1,94 @@
+/**
+ * Loopback listener for the ChatGPT subscription browser login (senpi#3623).
+ *
+ * OpenAI registers only ports 1455 and 1457 for this client, so the port cannot be ephemeral. When
+ * another login on this machine (a second session, an abandoned RPC prompt, the desktop engine, or
+ * Codex CLI) still holds 1455, this asks it to let go with a `POST /cancel` carrying a header no web page can send (Codex CLI's server answers any method on `/cancel`) and retries briefly, then
+ * falls back to 1457, the same order as Codex CLI's `bind_server`. The authorize URL must name the
+ * port actually bound, so callers build it from the returned `redirectUri`.
+ *
+ * NOTE: uses node:http; reached only through the lazily loaded ChatGPT OAuth flow.
+ */
+import { request } from "node:http";
+import { getProviderEnvValue } from "../../utils/provider-env.js";
+import { sleep } from "../../utils/sleep.js";
+import { OAUTH_CANCEL_HEADER, startOAuthCallbackServer } from "./callback-server.js";
+export const CHATGPT_CALLBACK_PORTS = [1455, 1457];
+const PORTS_ENV = "PI_CHATGPT_OAUTH_CALLBACK_PORTS";
+const CALLBACK_PATH = "/auth/callback";
+const CANCEL_PATH = "/cancel";
+const PRIMARY_BIND_ATTEMPTS = 10;
+const RETRY_DELAY_MS = 200;
+const CANCEL_TIMEOUT_MS = 2_000;
+function configuredPorts() {
+    const ports = (getProviderEnvValue(PORTS_ENV) ?? "")
+        .split(",")
+        .map((value) => Number.parseInt(value.trim(), 10))
+        .filter((port) => Number.isInteger(port) && port > 0 && port < 65536);
+    return ports.length > 0 ? ports : CHATGPT_CALLBACK_PORTS;
+}
+function isAddressInUse(error) {
+    return error instanceof Error && "code" in error && error.code === "EADDRINUSE";
+}
+function askHolderToCancel(host, port) {
+    return new Promise((resolve) => {
+        const outgoing = request({
+            host,
+            port,
+            path: CANCEL_PATH,
+            method: "POST",
+            headers: { [OAUTH_CANCEL_HEADER]: "1" },
+            timeout: CANCEL_TIMEOUT_MS,
+        }, (response) => {
+            response.resume();
+            response.on("end", resolve);
+            response.on("error", () => resolve());
+        });
+        outgoing.on("timeout", () => outgoing.destroy());
+        outgoing.on("error", () => resolve());
+        outgoing.end();
+    });
+}
+function listen(options, port) {
+    return startOAuthCallbackServer({
+        providerName: "OpenAI",
+        host: options.host,
+        port,
+        path: CALLBACK_PATH,
+        redirectHost: "localhost",
+        cancelPath: CANCEL_PATH,
+        state: options.state,
+        complete: async (code) => code,
+        signal: options.signal,
+    });
+}
+export async function startChatGptCallback(options) {
+    const [primary, ...fallbacks] = options.ports ?? configuredPorts();
+    if (primary === undefined)
+        return undefined;
+    for (let attempt = 0; attempt < PRIMARY_BIND_ATTEMPTS; attempt++) {
+        try {
+            const server = await listen(options, primary);
+            return { server, redirectUri: server.redirectUri };
+        }
+        catch (error) {
+            if (!isAddressInUse(error))
+                return undefined;
+            if (attempt === 0)
+                await askHolderToCancel(options.host, primary);
+            await sleep(RETRY_DELAY_MS, options.signal);
+        }
+    }
+    for (const port of fallbacks) {
+        try {
+            const server = await listen(options, port);
+            return { server, redirectUri: server.redirectUri };
+        }
+        catch (error) {
+            if (!isAddressInUse(error))
+                return undefined;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=chatgpt-subscription-callback.js.map