openmausbot 0.1.90 → 0.1.92

package/dist-server/server/drivers/boatagent.js

@@ -1,10 +1,9 @@
 import { newEventId, newId } from "../contracts.js";
+import { boatCredential, boatProviderApi } from "../included-services.js";
 import { appendNative } from "./native.js";
 import { OMB_ASK_TOOL, answerWithoutPreamble, askQuestionSummary, capAnswerEcho, ombAskProtocolPrompt, parseOmbAskQuestions, questionChoices, stripOmbAskBlock, } from "../../shared/ask-question.js";
 // "boxAgent" is Boat's historical driver kind (catalog and wire); keep it.
 const DRIVER_KIND = "boxAgent";
-// overridable so tests and a dev backend can be pointed at instead of the live provider
-const BOAT_API = process.env.OMB_BOX_API || "https://ascii.dev/api/box/v1";
 const MODELS = {
     default: "claude-fable-5",
     options: [
@@ -20,10 +19,15 @@ const ASK_FENCE_ANY = /(^|\n)[ \t]{0,3}(`{3,}|~{3,})[ \t]*omb-ask\b/;
  * prime-agent, kimi). Which one a model id belongs to comes from the public
  * catalog, `GET /api/provider-models` at the API root: an object keyed by
  * harness, each with its `models`. A bot that arrives here from another engine
- * carries that engine's model id, so this is what lets it keep its model. */
+ * carries that engine's model id, so this is what lets it keep its model. The
+ * root is the API in use (Boat, or Cloud Pro's relay), so it is cached per root. */
 let catalog = null;
-async function loadCatalog() {
-    const root = BOAT_API.replace(/\/api\/box\/v1\/?$/, "");
+let catalogRoot = "";
+async function loadCatalog(api) {
+    const root = api.replace(/\/api\/box\/v1\/?$/, "");
+    if (catalog && catalogRoot === root)
+        return;
+    catalogRoot = root;
     catalog = await fetch(`${root}/api/provider-models`, { signal: AbortSignal.timeout(15_000) })
         .then((res) => (res.ok ? res.json() : null))
         .catch(() => null);
@@ -53,7 +57,11 @@ export const BoatAgentDriver = {
     defaultConfig: () => decodeConfig({}),
     async create(input) {
         const { instanceId, config } = input;
-        const token = input.environment.BOX_TOKEN ?? process.env.BOX_TOKEN ?? "";
+        // The person's own token (instanceConfigs injects it), else Cloud Pro's
+        // included one, with the one base URL each may be sent to. Resolved per
+        // request, like every other Boat call.
+        const ownToken = input.environment.BOX_TOKEN ?? process.env.BOX_TOKEN;
+        const account = () => boatCredential(ownToken);
         const listeners = new Set();
         const active = new Map();
         /** One open ask per thread: the turn-held transport's pending card. The
@@ -75,9 +83,10 @@ export const BoatAgentDriver = {
             createdAt: new Date().toISOString(),
         });
         const api = async (path, opts = {}) => {
-            const res = await fetch(`${BOAT_API}${path}`, {
+            const credential = account();
+            const res = await fetch(`${credential?.api ?? boatProviderApi()}${path}`, {
                 ...opts,
-                headers: { authorization: `Bearer ${token}`, "content-type": "application/json", ...opts.headers },
+                headers: { authorization: `Bearer ${credential?.token ?? ""}`, "content-type": "application/json", ...opts.headers },
                 signal: opts.signal ?? AbortSignal.timeout(30_000),
             });
             const body = await res.json().catch(() => null);
@@ -90,7 +99,7 @@ export const BoatAgentDriver = {
             const { threadId } = turn;
             const computer = turn.integrations?.computer;
             const boxId = computer && (!computer.kind || computer.kind === "box") ? computer.boxId : undefined;
-            if (!token)
+            if (!account())
                 throw new Error('box not configured — add {"box":{"token":"…"}} to ~/.openmausbot/config.json');
             if (!boxId) {
                 throw new Error("this bot has no computer yet — open the Computer panel and provision one");
@@ -113,8 +122,7 @@ export const BoatAgentDriver = {
                 .filter((s) => s !== undefined)
                 .join("\n");
             const postPrompt = async (promptText) => {
-                if (!catalog)
-                    await loadCatalog();
+                await loadCatalog(account()?.api ?? boatProviderApi());
                 const started = await api(`/boxes/${boxId}/prompt`, {
                     method: "POST",
                     body: JSON.stringify({ ...providerFor(model), prompt: promptText }),
@@ -355,7 +363,7 @@ export const BoatAgentDriver = {
             return { turnId };
         };
         const snapshot = async () => {
-            if (!token) {
+            if (!account()) {
                 return { state: "unavailable", reason: 'no Boat token — add {"box":{"token":"…"}} to ~/.openmausbot/config.json' };
             }
             try {

package/dist-server/server/drivers/chatgpt-plan-auth.js

@@ -0,0 +1,481 @@
+import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { chmodSync, closeSync, lstatSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { dirname, isAbsolute, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { createLocalJWKSet, jwtVerify } from "jose";
+import { writeFileAtomic } from "../atomic.js";
+const ISSUER = "https://auth.openai.com";
+const RESOURCE = "https://api.openai.com/v1";
+const DIRECT_SCOPE = "chatgpt.tokens.use.direct";
+const SCOPES = `openid profile email offline_access resource.invoke ${DIRECT_SCOPE}`;
+const LIFETIME = 15 * 60_000;
+const TERMINAL_REFRESH = new Set(["invalid_grant", "invalid_refresh_token", "token_expired", "refresh_token_expired", "refresh_token_invalidated", "refresh_token_reused"]);
+const SIGN_IN = "Continue with ChatGPT in Settings to use your ChatGPT plan.";
+const CONSENT = "ChatGPT plan usage is not enabled. Continue with ChatGPT in Settings and allow plan usage, or explicitly choose another provider.";
+function object(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid ChatGPT response.");
+    return value;
+}
+function string(value, max = 65_536) {
+    return typeof value === "string" && value.length > 0 && value.length <= max;
+}
+function privateDirectory(path) {
+    mkdirSync(path, { recursive: true, mode: 0o700 });
+    if (!lstatSync(path).isDirectory() || lstatSync(path).isSymbolicLink())
+        throw new Error("ChatGPT credential storage must be a private directory.");
+    chmodSync(path, 0o700);
+}
+function readJson(path) {
+    try {
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 512_000)
+            throw new Error("Invalid credential storage.");
+        chmodSync(path, 0o600);
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw new Error("ChatGPT credential storage could not be read safely. Check its permissions before signing in.");
+    }
+}
+// A file lock protects rotating refresh tokens across processes as well as instances.
+// Fail closed on an abandoned lock: never risk reusing a refresh token while its
+// previous owner might still be exchanging it. The safe recovery is reauthorization
+// after an administrator confirms the old process has stopped and removes the lock.
+async function locked(directory, operation) {
+    const path = join(directory, ".credentials.lock");
+    const deadline = Date.now() + 30_000;
+    let fd;
+    for (;;) {
+        try {
+            fd = openSync(path, "wx", 0o600);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw new Error("ChatGPT credentials could not be locked safely.");
+            if (Date.now() >= deadline)
+                throw new Error("ChatGPT credentials are busy. If another app process crashed, stop it and remove its abandoned credential lock before trying again.");
+            await delay(50);
+        }
+    }
+    try {
+        writeFileSync(fd, String(process.pid));
+        return await operation();
+    }
+    finally {
+        closeSync(fd);
+        unlinkSync(path);
+    }
+}
+/** Server-owned OAuth credentials. Only safe status and the one-time authorization URL reach the renderer. */
+export class ChatGptPlanAuthController {
+    options;
+    issuer;
+    resource;
+    flow = null;
+    disposed = false;
+    starting = null;
+    retryClientId = null;
+    constructor(options) {
+        if (!isAbsolute(options.directory))
+            throw new Error("ChatGPT credential storage must use an absolute path.");
+        if (options.testServerUrl) {
+            const url = new URL(options.testServerUrl);
+            if (url.protocol !== "http:" || url.hostname !== "127.0.0.1" || url.username || url.password || url.search || url.hash || url.pathname !== "/") {
+                throw new Error("ChatGPT test endpoints must be a loopback origin.");
+            }
+            this.issuer = url.origin;
+            this.resource = `${url.origin}/v1`;
+        }
+        else {
+            this.issuer = ISSUER;
+            this.resource = RESOURCE;
+        }
+        this.options = options;
+    }
+    prepare() {
+        privateDirectory(dirname(this.options.directory));
+        privateDirectory(this.options.directory);
+    }
+    read() {
+        const raw = readJson(join(this.options.directory, "credentials.json"));
+        if (raw === null)
+            return null;
+        const record = object(raw);
+        if (!string(record.clientId, 256) || record.clientId === "dynamic_agent_client" || !string(record.subject, 512) || !string(record.hostId, 128)
+            || (record.email !== undefined && !string(record.email, 320)))
+            throw new Error("Saved ChatGPT registration is invalid. Check credential storage before signing in.");
+        if (record.tokens !== undefined) {
+            const tokens = object(record.tokens);
+            if (!string(tokens.access) || typeof tokens.refresh !== "string" || tokens.refresh.length > 65_536 || !string(tokens.id) || !Array.isArray(tokens.scopes)
+                || !tokens.scopes.every((scope) => string(scope, 256)) || typeof tokens.expiresAt !== "number" || !Number.isFinite(tokens.expiresAt)
+                || (tokens.scopes.includes(DIRECT_SCOPE) && !tokens.refresh)
+                || (tokens.earliestRefreshAt !== undefined && (typeof tokens.earliestRefreshAt !== "number" || !Number.isFinite(tokens.earliestRefreshAt)))) {
+                throw new Error("Saved ChatGPT credentials are invalid. Continue with ChatGPT again.");
+            }
+        }
+        return record;
+    }
+    save(record) {
+        writeFileAtomic(join(this.options.directory, "credentials.json"), JSON.stringify(record), { mode: 0o600 });
+    }
+    async hostId() {
+        const parent = dirname(this.options.directory);
+        return locked(parent, async () => {
+            const path = join(parent, "host-id.json");
+            const saved = readJson(path);
+            if (saved !== null) {
+                const value = object(saved).hostId;
+                if (!string(value) || !/^urn:uuid:[0-9a-f-]{36}$/i.test(value))
+                    throw new Error("Saved ChatGPT host identity is invalid.");
+                return value;
+            }
+            const value = `urn:uuid:${randomUUID()}`;
+            writeFileAtomic(path, JSON.stringify({ hostId: value }), { mode: 0o600 });
+            return value;
+        });
+    }
+    async request(url, init = {}) {
+        try {
+            const response = await fetch(url, { ...init, redirect: "error", signal: init.signal ? AbortSignal.any([init.signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000) });
+            if (Number(response.headers.get("content-length")) > 1_048_576)
+                throw new Error("Oversized response.");
+            const reader = response.body?.getReader();
+            let size = 0;
+            const chunks = [];
+            if (reader) {
+                for (;;) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        break;
+                    size += value.byteLength;
+                    if (size > 1_048_576) {
+                        await reader.cancel();
+                        throw new Error("Oversized response.");
+                    }
+                    chunks.push(value);
+                }
+            }
+            const text = Buffer.concat(chunks).toString("utf8");
+            return { response, body: text ? object(JSON.parse(text)) : {} };
+        }
+        catch {
+            throw new Error("Could not securely contact ChatGPT. Check your connection and try again; your saved account has not been removed.");
+        }
+    }
+    async exchange(params, signal) {
+        return this.request(`${this.issuer}/api/accounts/oauth/token`, { method: "POST", body: params, signal });
+    }
+    tokenSet(body, previous) {
+        if (!string(body.access_token) || typeof body.token_type !== "string" || body.token_type.toLowerCase() !== "bearer"
+            || typeof body.expires_in !== "number" || !Number.isFinite(body.expires_in) || body.expires_in <= 0 || body.expires_in > 86_400
+            || (body.scope !== undefined && typeof body.scope !== "string")
+            || (body.id_token !== undefined && !string(body.id_token)))
+            throw new Error("ChatGPT returned incomplete credentials. Continue with ChatGPT again.");
+        const id = string(body.id_token) ? body.id_token : previous?.id;
+        if (!id)
+            throw new Error("ChatGPT did not return a verifiable identity. Continue with ChatGPT again.");
+        const scopes = typeof body.scope === "string" ? body.scope.split(/\s+/).filter(Boolean) : previous?.scopes;
+        if (!scopes)
+            throw new Error("ChatGPT did not confirm granted permissions. Continue with ChatGPT again.");
+        if (scopes.includes(DIRECT_SCOPE) && !string(body.refresh_token))
+            throw new Error("ChatGPT did not provide renewable plan access. Continue with ChatGPT again.");
+        return { access: body.access_token, refresh: string(body.refresh_token) ? body.refresh_token : "", id, scopes, expiresAt: Date.now() + body.expires_in * 1000,
+            ...(typeof body.earliest_refresh_at === "number" && Number.isFinite(body.earliest_refresh_at) ? { earliestRefreshAt: body.earliest_refresh_at * 1000 } : {}) };
+    }
+    async identityKeys(signal) {
+        const { response, body } = await this.request(`${this.issuer}/.well-known/jwks.json`, { signal });
+        if (!response.ok)
+            throw new Error("ChatGPT identity keys are unavailable. Try signing in again later.");
+        try {
+            if (!Array.isArray(body.keys) || body.keys.length === 0)
+                throw new Error("Empty identity keys.");
+            return createLocalJWKSet(body);
+        }
+        catch {
+            throw new Error("ChatGPT identity keys could not be verified. Try signing in again later.");
+        }
+    }
+    async identity(id, clientId, keys, nonce) {
+        try {
+            const { payload } = await jwtVerify(id, keys, {
+                issuer: this.issuer, audience: clientId, algorithms: ["RS256", "ES256"], requiredClaims: ["sub", "exp", "iat"], clockTolerance: 30,
+            });
+            if (!string(payload.sub, 512) || typeof payload.iat !== "number" || payload.iat > Date.now() / 1000 + 30
+                || (Array.isArray(payload.aud) && payload.aud.length > 1 && payload.azp !== clientId)
+                || (nonce !== undefined && payload.nonce !== nonce))
+                throw new Error("Identity mismatch.");
+            return { subject: payload.sub, ...(string(payload.email, 320) ? { email: payload.email } : {}) };
+        }
+        catch {
+            throw new Error("ChatGPT identity could not be verified. No account was replaced. Start sign-in again.");
+        }
+    }
+    async start() {
+        if (this.starting)
+            return this.starting;
+        this.starting = this.begin();
+        try {
+            return await this.starting;
+        }
+        finally {
+            this.starting = null;
+        }
+    }
+    async begin() {
+        if (this.disposed)
+            throw new Error("This provider was removed. Refresh Settings before signing in.");
+        if (this.flow?.status.phase === "waiting")
+            return { ...this.flow.status, phase: "waiting" };
+        this.prepare();
+        const previous = this.read();
+        const clientId = previous?.clientId ?? this.retryClientId;
+        const hostId = await this.hostId();
+        if (previous && previous.hostId !== hostId)
+            throw new Error("This ChatGPT registration belongs to another host. Sign in using a new account entry on this host.");
+        const state = randomBytes(32).toString("base64url");
+        const nonce = randomBytes(32).toString("base64url");
+        const verifier = randomBytes(32).toString("base64url");
+        const server = createServer((request, response) => {
+            response.setHeader("Cache-Control", "no-store");
+            response.setHeader("Content-Type", "text/plain; charset=utf-8");
+            response.setHeader("Referrer-Policy", "no-referrer");
+            const flow = this.flow;
+            let callback;
+            try {
+                if (!flow || request.headers.host !== new URL(flow.redirectUri).host || !request.url?.startsWith("/"))
+                    throw new Error("Unexpected callback host.");
+                callback = new URL(request.url, flow.redirectUri);
+                if (callback.origin !== new URL(flow.redirectUri).origin)
+                    throw new Error("Unexpected callback origin.");
+            }
+            catch {
+                response.writeHead(400).end("Invalid sign-in callback. Return to OpenMausBot and try again.");
+                return;
+            }
+            const actual = callback.searchParams.get("state") ?? "";
+            if (request.method !== "GET" || callback.pathname !== "/auth/callback" || !flow || flow.server !== server || flow.consumed || flow.status.phase !== "waiting"
+                || Buffer.byteLength(actual) !== Buffer.byteLength(flow.state) || !timingSafeEqual(Buffer.from(actual), Buffer.from(flow.state))
+                || [...callback.searchParams.keys()].some((key) => callback.searchParams.getAll(key).length !== 1)) {
+                response.writeHead(400).end("Invalid or expired sign-in. Return to OpenMausBot and try again.");
+                return;
+            }
+            flow.consumed = true;
+            response.end("Finishing sign-in. You can return to OpenMausBot.");
+            server.close();
+            void this.complete(flow, callback.searchParams);
+        });
+        await new Promise((resolve, reject) => { server.once("error", reject); server.listen(0, "127.0.0.1", resolve); });
+        if (this.disposed) {
+            server.close();
+            throw new Error("This provider was removed.");
+        }
+        const address = server.address();
+        if (!address || typeof address === "string") {
+            server.close();
+            throw new Error("ChatGPT sign-in listener could not start.");
+        }
+        const redirectUri = `http://127.0.0.1:${address.port}/auth/callback`;
+        const url = new URL(`${this.issuer}/api/accounts/authorize`);
+        url.search = new URLSearchParams({ client_id: clientId ?? "dynamic_agent_client", ext_agent_host_id: hostId,
+            ...(clientId ? {} : { agent_name_hint: "openmausbot" }), ...(previous?.email ? { login_hint: previous.email } : {}),
+            ...(previous?.tokens && !previous.tokens.scopes.includes(DIRECT_SCOPE) ? { prompt: "consent" } : {}),
+            response_type: "code", redirect_uri: redirectUri, scope: SCOPES, resource: this.resource, state, nonce,
+            code_challenge_method: "S256", code_challenge: createHash("sha256").update(verifier).digest("base64url"),
+        }).toString();
+        const status = { phase: "waiting", flowId: randomUUID(), authorizationUrl: url.href, expiresAt: new Date(Date.now() + LIFETIME).toISOString() };
+        const flow = { status, state, nonce, verifier, redirectUri, previous, clientId, hostId, consumed: false, server, abort: new AbortController(),
+            expiry: setTimeout(() => this.finish(flow, "expired", "ChatGPT sign-in expired. Start again."), LIFETIME) };
+        flow.expiry.unref();
+        this.flow = flow;
+        return { ...status, phase: "waiting" };
+    }
+    finish(flow, phase, message) {
+        if (flow.status.phase !== "waiting")
+            return;
+        clearTimeout(flow.expiry);
+        flow.server.close();
+        flow.abort.abort();
+        flow.status = { ...flow.status, phase, authorizationUrl: null, ...(message ? { message } : {}) };
+    }
+    async complete(flow, params) {
+        try {
+            if (params.has("error"))
+                throw new Error("ChatGPT sign-in was not approved. You can try again in Settings.");
+            const clientId = params.get("client_id") ?? flow.clientId;
+            const code = params.get("code");
+            if (!string(clientId, 256) || clientId === "dynamic_agent_client" || (flow.clientId && flow.clientId !== clientId) || !string(code, 4096)) {
+                throw new Error("ChatGPT registration was incomplete or did not match the selected account. Start sign-in again.");
+            }
+            const keys = await this.identityKeys(flow.abort.signal);
+            const { response, body } = await this.exchange(new URLSearchParams({ grant_type: "authorization_code", client_id: clientId, code,
+                code_verifier: flow.verifier, redirect_uri: flow.redirectUri, resource: this.resource }), flow.abort.signal);
+            if (!response.ok) {
+                // A used/expired code must not create another client on retry. Keep
+                // this issued ID only in the pending attempt until identity is verified.
+                if (!flow.previous && body.error === "invalid_grant")
+                    this.retryClientId = clientId;
+                throw new Error("ChatGPT could not finish this sign-in. Start again with a fresh authorization.");
+            }
+            const tokens = this.tokenSet(body);
+            const identity = await this.identity(tokens.id, clientId, keys, flow.nonce);
+            if (flow.previous && identity.subject !== flow.previous.subject)
+                throw new Error("ChatGPT returned a different account. Use a separate account entry; the saved account was not replaced.");
+            await locked(this.options.directory, async () => {
+                if (this.disposed || flow.status.phase !== "waiting" || flow.abort.signal.aborted)
+                    return;
+                if (JSON.stringify(this.read()) !== JSON.stringify(flow.previous))
+                    throw new Error("The selected ChatGPT account changed during sign-in. Start again.");
+                this.save({ clientId, hostId: flow.hostId, ...identity, tokens });
+                this.retryClientId = null;
+                this.finish(flow, tokens.scopes.includes(DIRECT_SCOPE) ? "succeeded" : "failed", tokens.scopes.includes(DIRECT_SCOPE) ? undefined : CONSENT);
+            });
+            if (flow.status.phase === "succeeded")
+                await this.options.onAuthenticated?.().catch(() => { });
+        }
+        catch (error) {
+            this.finish(flow, "failed", error instanceof Error ? error.message : "ChatGPT sign-in could not finish. Try again.");
+        }
+    }
+    async get(flowId) {
+        if (!flowId || this.flow?.status.flowId !== flowId)
+            throw new Error("This sign-in is no longer available. Start again.");
+        return { ...this.flow.status };
+    }
+    async cancel() {
+        await this.starting?.catch(() => { });
+        if (this.flow)
+            this.finish(this.flow, "cancelled", "ChatGPT sign-in cancelled.");
+    }
+    async dispose() { this.disposed = true; await this.cancel(); this.flow = null; }
+    async snapshot() {
+        const record = this.read();
+        return { authenticated: !!record?.tokens?.scopes.includes(DIRECT_SCOPE),
+            ...(record ? { account: { method: "login", ...(record.email ? { email: record.email } : {}), organization: `ChatGPT · ${record.clientId.slice(-8)}` } } : {}),
+            ...(!record?.tokens ? { reason: SIGN_IN } : !record.tokens.scopes.includes(DIRECT_SCOPE) ? { reason: CONSENT } : {}), };
+    }
+    async accessToken() {
+        if (this.disposed)
+            throw new Error("This ChatGPT provider was removed.");
+        this.prepare();
+        return locked(this.options.directory, async () => {
+            if (this.disposed)
+                throw new Error("This ChatGPT provider was removed.");
+            const record = this.read();
+            if (!record?.tokens)
+                throw new Error(SIGN_IN);
+            if (!record.tokens.scopes.includes(DIRECT_SCOPE))
+                throw new Error(CONSENT);
+            if (record.tokens.expiresAt > Date.now() + 60_000)
+                return record.tokens.access;
+            if ((record.tokens.earliestRefreshAt ?? 0) > Date.now()) {
+                if (record.tokens.expiresAt > Date.now())
+                    return record.tokens.access;
+                throw new Error("ChatGPT credentials cannot refresh yet. Please try again shortly.");
+            }
+            // Fetch validation keys before consuming a rotating refresh token. There
+            // must be no fallible network dependency between receiving and saving its successor.
+            const keys = await this.identityKeys();
+            const { response, body } = await this.exchange(new URLSearchParams({ grant_type: "refresh_token", client_id: record.clientId,
+                refresh_token: record.tokens.refresh, resource: this.resource }));
+            if (!response.ok) {
+                const code = typeof body.error === "string" ? body.error : (body.error && typeof body.error === "object" ? body.error.code : undefined);
+                if (typeof code === "string" && TERMINAL_REFRESH.has(code)) {
+                    delete record.tokens;
+                    this.save(record);
+                    throw new Error(SIGN_IN);
+                }
+                if (code === "invalid_client")
+                    throw new Error("ChatGPT did not accept this app registration. Check the integration configuration before trying again.");
+                throw new Error("ChatGPT could not renew access right now. Try again later; your saved account has not been removed.");
+            }
+            let tokens;
+            try {
+                tokens = this.tokenSet(body, record.tokens);
+                if (body.id_token !== undefined) {
+                    const identity = await this.identity(tokens.id, record.clientId, keys);
+                    if (identity.subject !== record.subject)
+                        throw new Error("ChatGPT returned a different account during renewal.");
+                }
+            }
+            catch {
+                // The old refresh token was consumed. Never retry it after an invalid
+                // successor, even though the selected account/client mapping is retained.
+                delete record.tokens;
+                this.save(record);
+                throw new Error("ChatGPT renewal could not be verified. Continue with ChatGPT again in Settings.");
+            }
+            this.save({ ...record, tokens });
+            if (this.disposed)
+                throw new Error("This ChatGPT provider was removed.");
+            if (!tokens.scopes.includes(DIRECT_SCOPE))
+                throw new Error(CONSENT);
+            return tokens.access;
+        });
+    }
+    async models() {
+        if (!this.read()?.tokens?.scopes.includes(DIRECT_SCOPE))
+            return { default: "", options: [] };
+        const token = await this.accessToken();
+        const { response, body } = await this.request(`${this.resource}/models`, { headers: { Authorization: `Bearer ${token}` } });
+        if (!response.ok)
+            throw new Error(response.status === 401 || response.status === 403
+                ? "ChatGPT did not authorize model access. Check this account's plan permissions in ChatGPT Settings."
+                : "ChatGPT models are unavailable right now. Try refreshing later.");
+        if (!Array.isArray(body.models))
+            throw new Error("ChatGPT returned an invalid model catalog. No fallback models were selected.");
+        const options = [];
+        for (const entry of body.models) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const row = entry;
+            if (row.visibility !== "list" || !string(row.slug, 256) || /[\s\p{Cc}]/u.test(row.slug) || !string(row.display_name, 256) || options.some((item) => item.id === row.slug))
+                continue;
+            options.push({ id: row.slug, label: row.display_name });
+        }
+        return { default: options[0]?.id ?? "", options };
+    }
+    async signOut() {
+        if (this.disposed)
+            throw new Error("This provider was removed.");
+        await this.cancel();
+        this.prepare();
+        await locked(this.options.directory, async () => {
+            const record = this.read();
+            if (!record?.tokens)
+                return;
+            let revoked = !record.tokens.refresh;
+            try {
+                if (!record.tokens.refresh) {
+                    delete record.tokens;
+                    this.save(record);
+                    return;
+                }
+                const discovery = await this.request(`${this.issuer}/.well-known/openid-configuration`);
+                const endpoint = discovery.body.revocation_endpoint;
+                if (discovery.response.ok && discovery.body.issuer === this.issuer && typeof endpoint === "string" && new URL(endpoint).origin === this.issuer) {
+                    for (let attempt = 0; attempt < 2 && !revoked; attempt++) {
+                        try {
+                            const result = await this.request(endpoint, { method: "POST", body: new URLSearchParams({ token: record.tokens.refresh, token_type_hint: "refresh_token", client_id: record.clientId }) });
+                            revoked = result.response.status === 200;
+                            if (result.response.status < 500)
+                                break;
+                        }
+                        catch { /* A network failure still clears local credentials below. */ }
+                        if (!revoked && attempt === 0)
+                            await delay(250);
+                    }
+                }
+            }
+            catch { /* Sign-out is local even if OpenAI is temporarily unavailable. */ }
+            delete record.tokens;
+            this.save(record);
+            if (!revoked)
+                throw Object.assign(new Error("Signed out locally, but remote revocation was not confirmed. Disconnect OpenMausBot in ChatGPT Settings → Usage to end access there."), { code: "chatgpt_revocation_unconfirmed" });
+        });
+    }
+}