@code-yeongyu/senpi-ai 2026.11.3-3 → 2026.11.5-1

package/dist/api/openai-completions.js

@@ -239,6 +239,17 @@ function parseLegacyEncryptedReasoningDetail(signature) {
         return undefined;
     }
 }
+/**
+ * Replays a thought signature that an OpenAI-compatible proxy returned in a tool call's
+ * `provider_specific_fields` (LiteLLM serving Gemini) on the same field, so the replayed call
+ * keeps it even though its id is normalized. A legacy encrypted reasoning detail sharing the
+ * `thoughtSignature` slot travels through `reasoning_details` instead.
+ */
+function withProviderThoughtSignature(call, thoughtSignature) {
+    if (!thoughtSignature || parseLegacyEncryptedReasoningDetail(thoughtSignature) !== undefined)
+        return call;
+    return { ...call, provider_specific_fields: { thought_signature: thoughtSignature } };
+}
 function fillMissingCommonReasoningDetailFields(target, source) {
     target.id ??= source.id;
     target.format ||= source.format;
@@ -713,6 +724,10 @@ export const stream = (model, context, options) => {
                             if (!block.name && name) {
                                 block.name = name;
                             }
+                            const thoughtSignature = toolCall.provider_specific_fields?.thought_signature;
+                            if (typeof thoughtSignature === "string" && thoughtSignature.length > 0) {
+                                block.thoughtSignature = thoughtSignature;
+                            }
                             let delta = "";
                             if (toolCall.function?.arguments) {
                                 delta = toolCall.function.arguments;
@@ -1377,23 +1392,23 @@ export function convertMessages(model, context, compat, options = {}) {
                 assistantMsg.tool_calls = toolCalls.map((tc) => {
                     const customInputProperty = options?.grammarToolInputProperties?.get(tc.name);
                     if (customInputProperty !== undefined) {
-                        return {
+                        return withProviderThoughtSignature({
                             id: tc.id,
                             type: "custom",
                             custom: {
                                 name: tc.name,
                                 input: sanitizeSurrogates(getGrammarToolInput(tc.name, tc.arguments, customInputProperty)),
                             },
-                        };
+                        }, tc.thoughtSignature);
                     }
-                    return {
+                    return withProviderThoughtSignature({
                         id: tc.id,
                         type: "function",
                         function: {
                             name: tc.name,
                             arguments: JSON.stringify(tc.arguments),
                         },
-                    };
+                    }, tc.thoughtSignature);
                 });
             }
             if (preservedReasoningDetails) {

package/dist/api/openai-responses-prompt-cache.d.ts

@@ -9,6 +9,8 @@ export interface OpenAIPromptCacheOptionsPayload {
     prewarm?: boolean;
     comparison_response_id?: string;
 }
+/** SIWC plan usage cannot opt into explicit prompt caching through inherited catalog compat. */
+export declare function supportsOpenAIResponsesExplicitPromptCacheMode(model: Model<"openai-responses">): boolean;
 /** Explicit prompt-cache models (GPT-5.6+) on the first-party api.openai.com endpoint. */
 export declare function isOpenAIResponsesPromptCacheModel(model: Model<any>): boolean;
 /**

package/dist/api/openai-responses-prompt-cache.js

@@ -1,9 +1,11 @@
+/** SIWC plan usage cannot opt into explicit prompt caching through inherited catalog compat. */
+export function supportsOpenAIResponsesExplicitPromptCacheMode(model) {
+    const compat = model.compat;
+    return !compat?.siwc && compat?.supportsExplicitPromptCacheMode === true;
+}
 /** Explicit prompt-cache models (GPT-5.6+) on the first-party api.openai.com endpoint. */
 export function isOpenAIResponsesPromptCacheModel(model) {
-    if (model.api !== "openai-responses")
-        return false;
-    const compat = model.compat;
-    if (compat?.supportsExplicitPromptCacheMode !== true)
+    if (model.api !== "openai-responses" || !supportsOpenAIResponsesExplicitPromptCacheMode(model))
         return false;
     try {
         return new URL(model.baseUrl || "https://api.openai.com/v1").hostname === "api.openai.com";

package/dist/api/openai-responses-shared.d.ts

@@ -41,6 +41,7 @@ export type ResponsesDeferredToolsMode = "additional-tools" | "tool-search";
 export declare function resolveResponsesDeferredToolsMode(compat: {
     supportsAdditionalTools?: boolean;
     supportsToolSearch?: boolean;
+    siwc?: boolean;
 } | undefined): ResponsesDeferredToolsMode | undefined;
 export interface ResponsesToolPlacement {
     /** Tools sent in the top-level `tools` field. */

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

@@ -122,6 +122,8 @@ function withContextProvenance(item, message, seal) {
 export function resolveResponsesDeferredToolsMode(compat) {
     if (compat?.supportsAdditionalTools)
         return "additional-tools";
+    if (compat?.siwc)
+        return undefined;
     return compat?.supportsToolSearch ? "tool-search" : undefined;
 }
 /**
@@ -217,7 +219,10 @@ export function convertResponsesMessages(model, context, allowedToolCallProvider
     };
     const includeInitialSystemMessage = options?.includeSystemPrompt ?? true;
     const compat = model.compat;
-    const instructionRole = model.reasoning && compat?.supportsDeveloperRole !== false ? "developer" : "system";
+    const instructionRole = model.compat?.siwc ||
+        (model.reasoning && compat?.supportsDeveloperRole !== false)
+        ? "developer"
+        : "system";
     let msgIndex = 0;
     let sourceIndex = 0;
     for (const msg of transformedMessages) {

package/dist/api/openai-responses.js

@@ -19,7 +19,7 @@ import { buildCopilotDynamicHeaders, hasCopilotVisionInput } from "./github-copi
 import { resolveOpenAIClientAuth } from "./openai-client-auth.js";
 import { deriveOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
 import { applyAllowedToolsChoice, hasRefusedAllowedToolsChoice, isAllowedToolsChoiceRefusal, rememberAllowedToolsChoiceRefusal, restrictToAllowedTools, } from "./openai-responses-allowed-tools.js";
-import { findPromptCacheComparisonResponseId, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
+import { findPromptCacheComparisonResponseId, supportsOpenAIResponsesExplicitPromptCacheMode, withPromptCacheComparison, } from "./openai-responses-prompt-cache.js";
 import { convertResponsesMessages, convertResponsesTools, processResponsesStream, resolveResponsesDeferredToolsMode, resolveResponsesToolPlacement, } from "./openai-responses-shared.js";
 import { buildBaseOptions, clampMaxForOpenAI, OPENAI_RESPONSES_RESERVED_BODY_KEYS } from "./simple-options.js";
 import { startWebSocketLiveness } from "./websocket-liveness.js";
@@ -69,8 +69,8 @@ function getCompat(model, env) {
         supportsStrictMode: model.compat?.supportsStrictMode ?? false,
         supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
         supportsAdditionalTools: model.compat?.supportsAdditionalTools ?? false,
-        supportsToolSearch: model.compat?.supportsToolSearch ?? false,
-        supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false,
+        supportsToolSearch: !model.compat?.siwc && (model.compat?.supportsToolSearch ?? false),
+        supportsExplicitPromptCacheMode: supportsOpenAIResponsesExplicitPromptCacheMode(model),
         supportsConfigurationUpdate: model.compat?.supportsConfigurationUpdate ?? false,
         supportsMaxOutputTokens: model.compat?.supportsMaxOutputTokens ?? true,
         supportsForcedToolChoice: model.compat?.supportsForcedToolChoice ?? true,
@@ -160,6 +160,73 @@ function formatOpenAIResponsesError(error, provider, siwc = false) {
         ? `${errorMessage}\nCheck your ChatGPT usage: ${CHATGPT_USAGE_URL}`
         : errorMessage;
 }
+/**
+ * SIWC preview restrictions apply after hooks and sampling overrides too.
+ * https://developers.openai.com/siwc/token-sharing-open-source/preview-limitations
+ */
+function shapeSiwcRequest(params) {
+    const body = { ...params, store: false, stream: true };
+    for (const key of [
+        "background",
+        "conversation",
+        "max_output_tokens",
+        "max_tool_calls",
+        "metadata",
+        "moderation",
+        "multi_agent",
+        "prompt",
+        "prompt_cache_retention",
+        "safety_identifier",
+        "temperature",
+        "top_logprobs",
+        "top_p",
+        "truncation",
+        "user",
+        "previous_response_id",
+        "prompt_cache_options",
+    ])
+        delete body[key];
+    body.input =
+        typeof body.input === "string"
+            ? [{ role: "user", content: body.input }]
+            : body.input?.map((item) => "role" in item && item.role === "system" ? { ...item, role: "developer" } : item);
+    const tools = body.tools
+        ?.filter((tool) => tool.type === "function" ||
+        tool.type === "custom" ||
+        tool.type === "namespace" ||
+        tool.type === "web_search")
+        .map((tool) => tool.type === "namespace"
+        ? {
+            ...tool,
+            tools: tool.tools.filter((nested) => nested.type === "function" || nested.type === "custom"),
+        }
+        : tool);
+    // SIWC accepts local tools in namespaces or additional_tools, not flat top-level definitions.
+    const eagerTools = tools?.filter((tool) => tool.type === "function" || tool.type === "custom") ?? [];
+    body.tools = tools?.filter((tool) => tool.type !== "function" && tool.type !== "custom");
+    if (eagerTools.length > 0) {
+        Reflect.set(body, "input", [
+            { type: "additional_tools", role: "developer", tools: eagerTools },
+            ...(body.input ?? []),
+        ]);
+    }
+    const choice = body.tool_choice;
+    if (isRecord(choice)) {
+        if (choice.type === "allowed_tools" && Array.isArray(choice.tools)) {
+            const tools = choice.tools.filter((tool) => isRecord(tool) && (tool.type === "function" || tool.type === "custom" || tool.type === "web_search"));
+            Reflect.set(body, "tool_choice", tools.length > 0
+                ? {
+                    ...choice,
+                    tools,
+                }
+                : "none");
+        }
+        else if (choice.type !== "function" && choice.type !== "custom" && choice.type !== "web_search") {
+            delete body.tool_choice;
+        }
+    }
+    return body;
+}
 /**
  * Generate function for OpenAI Responses API
  */
@@ -206,7 +273,9 @@ export const stream = (model, context, options) => {
                 params = { ...params, tools: limitedTools.tools };
                 recordGitHubCopilotToolLimit(output, limitedTools.omittedCount);
             }
-            const transport = options?.transport ?? "sse";
+            if (compat.siwc)
+                params = shapeSiwcRequest(params);
+            const transport = compat.siwc ? "sse" : (options?.transport ?? "sse");
             let refusedAllowedToolsOverWebSocket = false;
             if (transport !== "sse" && compat.supportsWebSocket) {
                 let websocketStarted = false;
@@ -346,6 +415,8 @@ function resolveSimpleOptions(model, context, options) {
  * prefix matches the reasoning effort, service tier, and cache options that turn sends.
  */
 export async function warmOpenAIResponsesPromptCache(model, context, options) {
+    if (model.compat?.siwc)
+        throw new Error("SIWC requires streaming inference; prompt-cache prewarm is unsupported");
     const prefix = normalizeContext({ ...context, messages: [] });
     const resolved = resolveSimpleOptions(model, prefix, options);
     const clientAuth = resolveOpenAIClientAuth(model.provider, resolved.apiKey, resolved.headers);

package/dist/auth/oauth/openai-chatgpt.d.ts

@@ -5,17 +5,37 @@
  * access token directly to api.openai.com.
  */
 import type { LoginOptions, LogoutOptions, OAuthCredential, OAuthRevocationResult, ProviderAuthInteraction } from "../types.ts";
-declare function refreshAccessToken(credential: OAuthCredential, signal: AbortSignal): Promise<OAuthCredential>;
+import { type OpenAIIdTokenDependencies } from "./openai-id-token.ts";
 declare function revokeSession(credential: OAuthCredential, options?: LogoutOptions): Promise<OAuthRevocationResult>;
-declare function loginOpenAIChatGPT(interaction: ProviderAuthInteraction, options?: LoginOptions & {
-    readonly preferredCallbackPort?: number;
-}): Promise<OAuthCredential>;
+export declare function createOpenAIChatGPTOAuth(dependencies?: Partial<OpenAIIdTokenDependencies>): {
+    name: string;
+    isSubscription: true;
+    loginLabel: string;
+    login: (interaction: ProviderAuthInteraction, options?: LoginOptions & {
+        readonly preferredCallbackPort?: number;
+    }) => Promise<OAuthCredential>;
+    refresh: (credential: OAuthCredential, signal: AbortSignal) => Promise<OAuthCredential>;
+    revoke: typeof revokeSession;
+    check({ credential }: {
+        ctx: import("../types.ts").AuthContext;
+        credential?: OAuthCredential;
+        signal: AbortSignal;
+    }): Promise<{
+        type: "oauth";
+        source: string;
+    } | undefined>;
+    toAuth(credential: OAuthCredential): Promise<{
+        apiKey: string;
+    }>;
+};
 export declare const openaiChatGPTOAuth: {
     name: string;
     isSubscription: true;
     loginLabel: string;
-    login: typeof loginOpenAIChatGPT;
-    refresh: typeof refreshAccessToken;
+    login: (interaction: ProviderAuthInteraction, options?: LoginOptions & {
+        readonly preferredCallbackPort?: number;
+    }) => Promise<OAuthCredential>;
+    refresh: (credential: OAuthCredential, signal: AbortSignal) => Promise<OAuthCredential>;
     revoke: typeof revokeSession;
     check({ credential }: {
         ctx: import("../types.ts").AuthContext;

package/dist/auth/oauth/openai-chatgpt.js

@@ -7,10 +7,11 @@
 import { randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import { configuredOAuthBrandName, oauthErrorHtml, oauthSuccessHtml } from "../../utils/oauth-page.js";
-import { OAuthTokenEndpointError } from "../../utils/oauth-refresh-error.js";
+import { classifyOAuthRefreshFailure, OAuthClientConfigurationError, OAuthReauthorizationRequiredError, OAuthTokenEndpointError, } from "../../utils/oauth-refresh-error.js";
+import { createOpenAIIdTokenVerifier } from "./openai-id-token.js";
 import { getWireIdentity } from "../../wire-identity.js";
 import { generatePKCE } from "./pkce.js";
-// every login registers a new client with this ID; OpenAI returns the issued client ID in the callback
+// Only first-time registration uses this entrypoint; returning accounts keep their issued ID.
 const DYNAMIC_CLIENT_ID = "dynamic_agent_client";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 const AUTHORIZE_URL = "https://auth.openai.com/api/accounts/authorize";
@@ -25,24 +26,65 @@ const DIRECT_TOKEN_SCOPE = "chatgpt.tokens.use.direct";
 const SCOPE = `openid profile email offline_access resource.invoke ${DIRECT_TOKEN_SCOPE}`;
 // Refresh this long before the real expiry so a request never starts with a token about to expire.
 const EXPIRY_MARGIN_MS = 3 * 60 * 1000;
+class OpenAIReauthorizationError extends Error {
+    constructor(code) {
+        super(code === "invalid_account"
+            ? "The selected ChatGPT account needs an issued client ID and verified subject"
+            : code === "client_mismatch"
+                ? "ChatGPT reauthorization returned a different client ID"
+                : "ChatGPT reauthorization returned a different account");
+        this.name = "OpenAIReauthorizationError";
+        this.code = code;
+    }
+}
+class OpenAIConsentDeclinedError extends Error {
+    constructor() {
+        super("ChatGPT consent declined");
+        this.code = "consent_declined";
+        this.name = "OpenAIConsentDeclinedError";
+    }
+}
+class OpenAIPlanUsageNotEnabledError extends Error {
+    constructor() {
+        super("ChatGPT plan usage is not enabled. Enable ChatGPT plan usage or use an API key.");
+        this.code = "plan_usage_not_enabled";
+        this.recovery = ["enable_plan_usage", "use_api_key"];
+        this.name = "OpenAIPlanUsageNotEnabledError";
+    }
+}
 function randomValue() {
     return randomBytes(32).toString("base64url");
 }
-function authorizationResultFromCallback(url, expectedState) {
-    const code = url.searchParams.get("code");
-    if (!code)
-        throw new Error("Missing authorization code");
+function authorizationResultFromCallback(url, expectedState, knownClient) {
     const state = url.searchParams.get("state");
     if (!state)
         throw new Error("Missing OAuth state");
     if (state !== expectedState)
         throw new Error("OAuth state mismatch");
-    const clientId = url.searchParams.get("client_id")?.trim();
+    const error = url.searchParams.get("error");
+    if (error === "access_denied")
+        throw new OpenAIConsentDeclinedError();
+    if (error)
+        throw new Error(`ChatGPT authorization failed: ${error}`);
+    const code = url.searchParams.get("code");
+    if (!code)
+        throw new Error("Missing authorization code");
+    const suppliedClientId = url.searchParams.get("client_id");
+    if (knownClient?.purpose === "reauthorize" &&
+        suppliedClientId !== null &&
+        suppliedClientId !== knownClient.clientId) {
+        throw new OpenAIReauthorizationError("client_mismatch");
+    }
+    const callbackClientId = suppliedClientId?.trim();
+    if (knownClient?.purpose === "consent" && callbackClientId && callbackClientId !== knownClient.clientId) {
+        throw new Error("ChatGPT consent callback client ID mismatch");
+    }
+    const clientId = knownClient?.clientId ?? callbackClientId;
     if (!clientId)
         throw new Error("OpenAI OAuth registration callback did not contain an issued client ID");
     return { code, clientId };
 }
-function authorizationResultFromManualInput(input, expectedState, redirectUri) {
+function authorizationResultFromManualInput(input, expectedState, redirectUri, knownClient) {
     let url;
     try {
         url = new URL(input.trim());
@@ -54,16 +96,13 @@ function authorizationResultFromManualInput(input, expectedState, redirectUri) {
     if (url.origin !== expected.origin || url.pathname !== expected.pathname) {
         throw new Error(`The pasted callback URL must start with ${redirectUri}`);
     }
-    const error = url.searchParams.get("error");
-    if (error)
-        throw new Error(`ChatGPT authorization failed: ${error}`);
-    return authorizationResultFromCallback(url, expectedState);
+    return authorizationResultFromCallback(url, expectedState, knownClient);
 }
 function sendHtml(response, status, body) {
     response.writeHead(status, { "Content-Type": "text/html; charset=utf-8" });
     response.end(body);
 }
-function startCallbackServer(expectedState, preferredPort) {
+function startCallbackServer(expectedState, preferredPort, knownClient) {
     return new Promise((resolve, reject) => {
         let redirectUri = REDIRECT_URI;
         let resolveResult;
@@ -79,19 +118,18 @@ function startCallbackServer(expectedState, preferredPort) {
                     sendHtml(response, 404, oauthErrorHtml("Callback route not found."));
                     return;
                 }
-                const error = url.searchParams.get("error");
-                if (error) {
-                    sendHtml(response, 400, oauthErrorHtml("ChatGPT was not connected.", `Error: ${error}`));
-                    rejectResult(new Error(`ChatGPT authorization failed: ${error}`));
-                    return;
-                }
                 let authorizationResult;
                 try {
-                    authorizationResult = authorizationResultFromCallback(url, expectedState);
+                    authorizationResult = authorizationResultFromCallback(url, expectedState, knownClient);
                 }
                 catch (error) {
                     const message = error instanceof Error ? error.message : "Invalid callback";
                     sendHtml(response, 400, oauthErrorHtml(message));
+                    // Unrelated callbacks must not stop the pending login attempt.
+                    if (error instanceof OpenAIReauthorizationError ||
+                        (url.searchParams.get("state") === expectedState && url.searchParams.has("error"))) {
+                        rejectResult(error instanceof Error ? error : new Error(message));
+                    }
                     return;
                 }
                 sendHtml(response, 200, oauthSuccessHtml("ChatGPT authentication completed. You can close this window."));
@@ -127,8 +165,21 @@ function startCallbackServer(expectedState, preferredPort) {
         server.listen(preferredPort, CALLBACK_HOST, onListening);
     });
 }
-async function requestToken(body, signal) {
-    const response = await fetch(TOKEN_URL, {
+/** Read machine codes only; error_description is diagnostic text, not a recovery signal. */
+function tokenErrorCode(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const error = Reflect.get(value, "error");
+    if (typeof error === "string")
+        return error;
+    const code = Reflect.get(value, "code");
+    if (typeof code === "string")
+        return code;
+    const type = Reflect.get(value, "type");
+    return tokenErrorCode(error) ?? (typeof type === "string" ? type : undefined);
+}
+async function requestToken(body, signal, fetchToken) {
+    const response = await fetchToken(TOKEN_URL, {
         method: "POST",
         headers: {
             accept: "application/json",
@@ -139,7 +190,29 @@ async function requestToken(body, signal) {
     });
     if (!response.ok) {
         const responseBody = await response.text().catch(() => "");
-        throw new OAuthTokenEndpointError(`OpenAI OAuth token request failed (${response.status}): ${responseBody || response.statusText}`, response.status);
+        const error = new OAuthTokenEndpointError(`OpenAI OAuth token request failed (${response.status}): ${responseBody || response.statusText}`, response.status);
+        if (body.get("grant_type") === "refresh_token" && classifyOAuthRefreshFailure(error) === "permanent") {
+            let code;
+            try {
+                const parsed = JSON.parse(responseBody);
+                code = tokenErrorCode(parsed);
+            }
+            catch {
+                // Non-JSON errors retain the HTTP status and diagnostic below.
+            }
+            switch (code) {
+                case "invalid_grant":
+                case "invalid_refresh_token":
+                case "token_expired":
+                case "refresh_token_expired":
+                case "refresh_token_invalidated":
+                case "refresh_token_reused":
+                    throw new OAuthReauthorizationRequiredError(code, response.status);
+                case "invalid_client":
+                    throw new OAuthClientConfigurationError(response.status);
+            }
+        }
+        throw error;
     }
     const data = await response.json();
     if (typeof data !== "object" || data === null || Array.isArray(data)) {
@@ -153,7 +226,7 @@ function requireTokenString(value, field) {
     }
     return value;
 }
-function credentialFromTokenResponse(token, clientId) {
+function credentialFromTokenResponse(token, clientId, now) {
     const access = requireTokenString(token.access_token, "access_token");
     const refresh = requireTokenString(token.refresh_token, "refresh_token");
     const scope = requireTokenString(token.scope, "scope");
@@ -161,19 +234,17 @@ function credentialFromTokenResponse(token, clientId) {
         throw new Error("OpenAI OAuth token response has invalid expires_in");
     }
     const scopes = scope.trim().split(/\s+/).filter(Boolean);
-    if (!scopes.includes(DIRECT_TOKEN_SCOPE)) {
-        throw new Error(`OpenAI OAuth grant did not include ${DIRECT_TOKEN_SCOPE}`);
-    }
     return {
         type: "oauth",
         access,
         refresh,
-        expires: Date.now() + token.expires_in * 1000 - EXPIRY_MARGIN_MS,
+        expires: now() + token.expires_in * 1000 - EXPIRY_MARGIN_MS,
         clientId,
         scopes,
+        planUsageEnabled: scopes.includes(DIRECT_TOKEN_SCOPE),
     };
 }
-async function exchangeAuthorizationCode(code, verifier, clientId, redirectUri, signal) {
+async function exchangeAuthorizationCode(code, verifier, clientId, redirectUri, signal, nonce, deps, verifyIdToken) {
     const token = await requestToken(new URLSearchParams({
         grant_type: "authorization_code",
         client_id: clientId,
@@ -181,15 +252,11 @@ async function exchangeAuthorizationCode(code, verifier, clientId, redirectUri,
         code_verifier: verifier,
         redirect_uri: redirectUri,
         resource: RESOURCE,
-    }), signal);
-    // Pi does not use the ID token to identify the user or read profile data.
-    // Keep the presence check as part of the token-response contract.
-    if (typeof token.id_token !== "string" || token.id_token.trim().length === 0) {
-        throw new Error("OpenAI OAuth token response did not contain an ID token");
-    }
-    return credentialFromTokenResponse(token, clientId);
+    }), signal, deps.fetch);
+    const identity = await verifyIdToken(token.id_token, clientId, nonce, signal);
+    return { ...credentialFromTokenResponse(token, clientId, deps.now), ...identity, idToken: token.id_token };
 }
-async function refreshAccessToken(credential, signal) {
+async function refreshAccessToken(credential, signal, deps) {
     const clientId = credential.clientId;
     if (typeof clientId !== "string" || clientId.trim().length === 0) {
         throw new Error("Stored OpenAI OAuth credential does not contain an issued client ID; reconnect ChatGPT");
@@ -199,8 +266,8 @@ async function refreshAccessToken(credential, signal) {
         client_id: clientId,
         refresh_token: credential.refresh,
         resource: RESOURCE,
-    }), signal);
-    return credentialFromTokenResponse(token, clientId);
+    }), signal, deps.fetch);
+    return { ...credential, ...credentialFromTokenResponse(token, clientId, deps.now) };
 }
 async function revokeSession(credential, options) {
     const unconfirmed = { status: "remote_revocation_unconfirmed" };
@@ -278,14 +345,33 @@ function agentHostId(deviceId) {
     }
     return `urn:uuid:${deviceId.toLowerCase()}`;
 }
-async function loginOpenAIChatGPT(interaction, options) {
+async function loginOpenAIChatGPT(interaction, options, deps, verifyIdToken) {
+    const existing = options?.reauthorize;
+    if (existing &&
+        (typeof existing.clientId !== "string" ||
+            !existing.clientId.trim() ||
+            existing.clientId === DYNAMIC_CLIENT_ID ||
+            typeof existing.subject !== "string" ||
+            !existing.subject.trim())) {
+        throw new OpenAIReauthorizationError("invalid_account");
+    }
+    const pendingClientId = existing?.clientId;
     const hostId = agentHostId(options?.getDeviceId?.());
+    const consentClientId = options?.planUsageConsent?.clientId;
+    if (options?.planUsageConsent && (!consentClientId?.trim() || consentClientId === DYNAMIC_CLIENT_ID)) {
+        throw new Error("Enabling ChatGPT plan usage requires the saved issued client ID");
+    }
+    const knownClient = pendingClientId
+        ? { clientId: pendingClientId, purpose: "reauthorize" }
+        : consentClientId
+            ? { clientId: consentClientId, purpose: "consent" }
+            : undefined;
     const { verifier, challenge } = await generatePKCE();
     const state = randomValue();
     const nonce = randomValue();
     let callback;
     try {
-        callback = await startCallbackServer(state, options?.preferredCallbackPort ?? CALLBACK_PORT);
+        callback = await startCallbackServer(state, options?.preferredCallbackPort ?? CALLBACK_PORT, knownClient);
     }
     catch (error) {
         interaction.notify({
@@ -296,9 +382,7 @@ async function loginOpenAIChatGPT(interaction, options) {
     const redirectUri = callback?.redirectUri ?? REDIRECT_URI;
     const authorizationUrl = new URL(AUTHORIZE_URL);
     authorizationUrl.search = new URLSearchParams({
-        client_id: DYNAMIC_CLIENT_ID,
-        // Display metadata on OpenAI's consent screen (the user can edit it); not tied to the issued client ID.
-        agent_name_hint: options?.appName ?? configuredOAuthBrandName() ?? getWireIdentity(),
+        client_id: pendingClientId ?? DYNAMIC_CLIENT_ID,
         ext_agent_host_id: hostId,
         response_type: "code",
         redirect_uri: redirectUri,
@@ -309,6 +393,20 @@ async function loginOpenAIChatGPT(interaction, options) {
         code_challenge_method: "S256",
         nonce,
     }).toString();
+    if (existing) {
+        if (existing.idToken)
+            authorizationUrl.searchParams.set("id_token_hint", existing.idToken);
+        if (existing.email)
+            authorizationUrl.searchParams.set("login_hint", existing.email);
+    }
+    else {
+        // Display metadata on OpenAI's consent screen (the user can edit it); not tied to the issued client ID.
+        authorizationUrl.searchParams.set("agent_name_hint", options?.appName ?? configuredOAuthBrandName() ?? getWireIdentity());
+    }
+    if (consentClientId) {
+        authorizationUrl.searchParams.set("client_id", consentClientId);
+        authorizationUrl.searchParams.set("prompt", "consent");
+    }
     interaction.notify({
         type: "auth_url",
         url: authorizationUrl.toString(),
@@ -322,11 +420,15 @@ async function loginOpenAIChatGPT(interaction, options) {
         placeholder: redirectUri,
         signal: AbortSignal.any([manualAbort.signal, interaction.signal]),
     })
-        .then((input) => authorizationResultFromManualInput(input, state, redirectUri));
+        .then((input) => authorizationResultFromManualInput(input, state, redirectUri, knownClient));
     try {
         const result = await (callback ? Promise.race([callback.result, manualCode]) : manualCode);
         interaction.notify({ type: "progress", message: "Exchanging authorization code for tokens..." });
-        return await exchangeAuthorizationCode(result.code, verifier, result.clientId, redirectUri, interaction.signal);
+        const credential = await exchangeAuthorizationCode(result.code, verifier, result.clientId, redirectUri, interaction.signal, nonce, deps, verifyIdToken);
+        if (existing && credential.subject !== existing.subject) {
+            throw new OpenAIReauthorizationError("subject_mismatch");
+        }
+        return credential;
     }
     catch (error) {
         if (interaction.signal.aborted)
@@ -344,20 +446,31 @@ async function loginOpenAIChatGPT(interaction, options) {
         callback?.server.closeAllConnections();
     }
 }
-export const openaiChatGPTOAuth = {
-    name: "OpenAI (ChatGPT subscription)",
-    isSubscription: true,
-    loginLabel: "Sign in with ChatGPT",
-    login: loginOpenAIChatGPT,
-    refresh: refreshAccessToken,
-    revoke: revokeSession,
-    async check({ credential }) {
-        if (!credential?.access || !credential.refresh || credential.signedOut === true)
-            return undefined;
-        return { type: "oauth", source: "OAuth" };
-    },
-    async toAuth(credential) {
-        return { apiKey: credential.access };
-    },
-};
+export function createOpenAIChatGPTOAuth(dependencies = {}) {
+    const deps = {
+        fetch: dependencies.fetch ?? ((url, init) => fetch(url, init)),
+        now: dependencies.now ?? (() => Date.now()),
+    };
+    const verifyIdToken = createOpenAIIdTokenVerifier(deps);
+    return {
+        name: "OpenAI (ChatGPT subscription)",
+        isSubscription: true,
+        loginLabel: "Sign in with ChatGPT",
+        login: (interaction, options) => loginOpenAIChatGPT(interaction, options, deps, verifyIdToken),
+        refresh: (credential, signal) => refreshAccessToken(credential, signal, deps),
+        revoke: revokeSession,
+        async check({ credential }) {
+            if (!credential?.access || !credential.refresh || credential.signedOut === true)
+                return undefined;
+            return { type: "oauth", source: "OAuth" };
+        },
+        async toAuth(credential) {
+            if (credential.planUsageEnabled === false || !credential.scopes?.includes(DIRECT_TOKEN_SCOPE)) {
+                throw new OpenAIPlanUsageNotEnabledError();
+            }
+            return { apiKey: credential.access };
+        },
+    };
+}
+export const openaiChatGPTOAuth = createOpenAIChatGPTOAuth();
 //# sourceMappingURL=openai-chatgpt.js.map