@code-yeongyu/senpi-ai 2026.10.31-2 → 2026.11.2-1

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

@@ -2,6 +2,8 @@ import type { Tool as OpenAITool, ResponseCreateParamsStreaming, ResponseInput,
 import type { Api, AssistantMessage, Message, Model, StreamOptions, Tool, TranscriptContext, Usage } from "../types.ts";
 import type { AssistantMessageEventStream } from "../utils/event-stream.ts";
 export interface OpenAIResponsesStreamOptions {
+    /** SIWC succeeds only on response.completed, never on a finished tool alone. */
+    siwc?: boolean;
     onProviderStreamEvent?: StreamOptions["onProviderStreamEvent"];
     serviceTier?: ResponseCreateParamsStreaming["service_tier"] | "fast" | "ultrafast";
     grammarToolInputProperties?: ReadonlyMap<string, string>;

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

@@ -1029,12 +1029,22 @@ export async function processResponsesStream(openaiStream, output, stream, model
         }
         else if (event.type === "response.completed" || event.type === "response.incomplete") {
             finalizeResponse(event.response);
+            if (options?.siwc && event.type === "response.incomplete") {
+                throw new Error(`Response incomplete: ${event.response.incomplete_details?.reason ?? "unknown reason"}`);
+            }
         }
         else if (event.type === "error") {
             const errorEvent = event;
             const code = errorEvent.error?.code ?? errorEvent.code ?? errorEvent.status;
             const message = errorEvent.error?.message || errorEvent.message || "Unknown error";
-            throw new Error(code == null ? message : `Error Code ${code}: ${message}`);
+            const failure = new Error(code == null ? message : `Error Code ${code}: ${message}`);
+            throw options?.siwc
+                ? Object.assign(failure, {
+                    code: typeof code === "string" ? code : undefined,
+                    status: errorEvent.status,
+                    param: errorEvent.error?.param ?? errorEvent.param,
+                })
+                : failure;
         }
         else if (event.type === "response.failed") {
             sawTerminalResponseEvent = true;
@@ -1046,11 +1056,17 @@ export async function processResponsesStream(openaiStream, output, stream, model
                 : details?.reason
                     ? `incomplete: ${details.reason}`
                     : "Unknown error (no error details in response)";
-            throw new Error(msg);
+            const failure = new Error(msg);
+            throw options?.siwc
+                ? Object.assign(failure, {
+                    code: error?.code,
+                    param: error && "param" in error ? error.param : undefined,
+                })
+                : failure;
         }
     }
     const hasFinalizedToolCall = output.content.some((block) => block.type === "toolCall" && !("partialJson" in block));
-    if (!sawTerminalResponseEvent && !hasFinalizedToolCall) {
+    if (!sawTerminalResponseEvent && (options?.siwc || !hasFinalizedToolCall)) {
         throw new Error("OpenAI Responses stream ended before a terminal response event");
     }
     // The agent runs every tool call in the final message. Refuse to hand over calls whose

package/dist/api/openai-responses.js

@@ -7,7 +7,7 @@ import { AssistantMessageEventStream } from "../utils/event-stream.js";
 import { formatGitHubCopilotToolLimitError, limitGitHubCopilotTools, recordGitHubCopilotToolLimit, } from "../utils/github-copilot-tool-limit.js";
 import { headersToRecord } from "../utils/headers.js";
 import { getPiUserAgent } from "../utils/pi-user-agent.js";
-import { awaitProviderTransport, openAICompatibleProviderDiagnosticFromError, } from "../utils/provider-diagnostic-sources.js";
+import { awaitProviderTransport, openAICompatibleProviderDiagnosticFromError, siwcProviderDiagnosticFromError, } from "../utils/provider-diagnostic-sources.js";
 import { getProviderEnvValue } from "../utils/provider-env.js";
 import { retryProviderRequest } from "../utils/provider-retry.js";
 import { sendWithForcedToolChoiceFallback } from "../utils/tool-choice-fallback.js";
@@ -56,6 +56,7 @@ function resolveCacheRetention(cacheRetention, env) {
 function getCompat(model, env) {
     const isNativeEndpoint = isOpenAIResponsesNativeEndpoint(model, env);
     return {
+        siwc: model.compat?.siwc ?? false,
         supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
         supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
         sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? detectSessionAffinityFormat(model),
@@ -147,8 +148,13 @@ function sanitizeUnsupportedNativeTools(params, compat) {
     }
     return sanitized ? sanitized : params;
 }
-function formatOpenAIResponsesError(error, provider) {
-    const errorMessage = formatProviderError(normalizeProviderError(error), `${provider === "openai" ? "OpenAI" : provider} API error`);
+function formatOpenAIResponsesError(error, provider, siwc = false) {
+    let errorMessage = formatProviderError(normalizeProviderError(error), `${provider === "openai" ? "OpenAI" : provider} API error`);
+    if (siwc && error instanceof Error && Reflect.get(error, "code") === "subscription_sharing_unsupported_capability") {
+        const param = Reflect.get(error, "param");
+        if (typeof param === "string")
+            errorMessage += `\nUnsupported parameter: ${param}`;
+    }
     // Sign in with ChatGPT shares the subscription's usage limit with other apps.
     return errorMessage.includes("subscription_sharing_usage_limit_exceeded")
         ? `${errorMessage}\nCheck your ChatGPT usage: ${CHATGPT_USAGE_URL}`
@@ -239,8 +245,8 @@ export const stream = (model, context, options) => {
                     params: body,
                     acceptsForcedToolChoice: compat.supportsForcedToolChoice,
                     isForced: isForcedOpenAIResponsesToolChoice,
-                    send: (request) => model.provider === "github-copilot"
-                        ? awaitProviderTransport(() => client.responses.create(request, requestOptions).withResponse(), openAICompatibleProviderDiagnosticFromError)
+                    send: (request) => model.provider === "github-copilot" || compat.siwc
+                        ? awaitProviderTransport(() => client.responses.create(request, requestOptions).withResponse(), compat.siwc ? siwcProviderDiagnosticFromError : openAICompatibleProviderDiagnosticFromError)
                         : client.responses.create(request, requestOptions).withResponse(),
                 });
                 params = sent.params;
@@ -274,6 +280,7 @@ export const stream = (model, context, options) => {
             if (!refusedAllowedToolsOverWebSocket)
                 stream.push({ type: "start", partial: output });
             await processResponsesStream(openaiStream, output, stream, model, {
+                siwc: compat.siwc,
                 onProviderStreamEvent: options?.onProviderStreamEvent,
                 serviceTier: options?.serviceTier,
                 grammarToolInputProperties,
@@ -299,12 +306,15 @@ export const stream = (model, context, options) => {
                 delete block.customInput;
             }
             output.stopReason = options?.signal?.aborted ? "aborted" : "error";
-            const providerDiagnostic = model.provider === "github-copilot" && output.stopReason === "error"
-                ? (readProviderDiagnostic(error) ?? openAICompatibleProviderDiagnosticFromError(error))
+            const providerDiagnostic = (model.provider === "github-copilot" || model.compat?.siwc) && output.stopReason === "error"
+                ? (readProviderDiagnostic(error) ??
+                    (model.compat?.siwc
+                        ? siwcProviderDiagnosticFromError(error)
+                        : openAICompatibleProviderDiagnosticFromError(error)))
                 : undefined;
             if (providerDiagnostic !== undefined)
                 output.providerDiagnostic = providerDiagnostic;
-            output.errorMessage = withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, formatOpenAIResponsesError(error, model.provider)), model.provider, error);
+            output.errorMessage = withGitHubCopilotFailureNote(formatGitHubCopilotToolLimitError(output, formatOpenAIResponsesError(error, model.provider, model.compat?.siwc)), model.provider, error);
             stream.push({ type: "error", reason: output.stopReason, error: output });
             stream.end();
         }
@@ -377,6 +387,15 @@ export async function warmOpenAIResponsesPromptCache(model, context, options) {
     applyServiceTierPricing(usage, response.service_tier ?? resolved.serviceTier, model);
     return { usage, usageRaw };
 }
+/** The SDK discards nonstandard admission bodies when it selects errorResponse.error. */
+class SiwcOpenAI extends OpenAI {
+    makeStatusError(status, body, message, headers) {
+        if (isRecord(body) && Object.hasOwn(body, "detail") && !Object.hasOwn(body, "error")) {
+            return new OpenAI.APIError(status, body, message, headers);
+        }
+        return super.makeStatusError(status, body, message, headers);
+    }
+}
 function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId, env) {
     const compat = getCompat(model, env);
     const headers = { "User-Agent": getPiUserAgent(), ...model.headers };
@@ -403,7 +422,8 @@ function createClient(model, context, apiKey, optionsHeaders, fetch, sessionId,
     if (optionsHeaders) {
         Object.assign(headers, optionsHeaders);
     }
-    return new OpenAI({
+    const Client = compat.siwc ? SiwcOpenAI : OpenAI;
+    return new Client({
         apiKey,
         baseURL: isCloudflareProvider(model.provider) ? resolveCloudflareBaseUrl(model, env) : model.baseUrl,
         dangerouslyAllowBrowser: true,
@@ -779,6 +799,7 @@ async function processWebSocketStream(url, params, headers, output, stream, mode
         await options?.onResponse?.({ status: 101, headers: {} }, model);
         stream.push({ type: "start", partial: output });
         await processResponsesStream(parseWebSocket(socket, options?.signal), output, stream, model, {
+            siwc: model.compat?.siwc,
             serviceTier: options?.serviceTier,
             grammarToolInputProperties,
             applyServiceTierPricing: (usage, serviceTier) => applyServiceTierPricing(usage, serviceTier, model),

package/dist/auth/credential-store.d.ts

@@ -1,4 +1,6 @@
-import type { AuthOperationOptions, Credential, CredentialInfo, CredentialStore } from "./types.ts";
+import type { AuthOperationOptions, Credential, CredentialInfo, CredentialStore, LogoutOptions, OAuthAuth, OAuthRevocationResult } from "./types.ts";
+/** Capture and clear atomically before network work, so later logins are not cleared. */
+export declare function revokeStoredOAuth(credentials: CredentialStore, providerId: string, oauth: OAuthAuth, options?: LogoutOptions): Promise<OAuthRevocationResult | undefined>;
 /**
  * Default in-memory credential store. Apps inject persistent stores.
  * Keyed by `Provider.id`, one entry per provider (possibly a pooled one);

package/dist/auth/credential-store.js

@@ -1,4 +1,82 @@
 import { operationSignal, raceWithAbortSignal } from "../utils/abort.js";
+import { captureOAuthRefreshes } from "./oauth-refresh.js";
+import { listSlots, projectSlot } from "./pool/slots.js";
+/** Clear session secrets without discarding the registration's non-secret metadata. */
+function clearTokens(credential) {
+    const cleared = { ...credential, access: "", refresh: "", expires: 0, signedOut: true };
+    Reflect.deleteProperty(cleared, "idToken");
+    return cleared;
+}
+/** Capture and clear atomically before network work, so later logins are not cleared. */
+export async function revokeStoredOAuth(credentials, providerId, oauth, options) {
+    const revoke = oauth.revoke;
+    if (!revoke)
+        return undefined;
+    let handled = false;
+    const targets = [];
+    let refreshes = Promise.resolve(true);
+    const settleRefreshes = captureOAuthRefreshes(credentials, providerId);
+    // Deliberately not cancellable: even an interrupted remote revoke must clear locally.
+    // Slot selection and its token snapshot share the same lock as refresh writes.
+    await credentials
+        .modify(providerId, async (current) => {
+        if (current?.type !== "oauth")
+            return undefined;
+        handled = true;
+        const slots = listSlots(current).filter((slot) => options?.slotId === undefined || slot.name === options.slotId);
+        if (!slots.length)
+            return undefined;
+        for (const slot of slots) {
+            const projected = projectSlot(current, slot.name);
+            if (projected?.type === "oauth")
+                targets.push({ ...projected, ...slot });
+        }
+        const names = new Set(slots.map((slot) => slot.name));
+        const accounts = Array.isArray(current.accounts)
+            ? current.accounts.map((slot) => (names.has(slot.name) ? clearTokens(slot) : slot))
+            : undefined;
+        let next = options?.slotId === undefined ||
+            slots.some((slot) => slot.refresh === current.refresh && slot.access === current.access)
+            ? clearTokens(current)
+            : { ...current };
+        if (accounts) {
+            next = { ...next, accounts };
+            // Keep the legacy flat projection on a surviving signed-in sibling, if one exists.
+            const active = accounts.find((slot) => slot.access && slot.refresh);
+            if (next.signedOut === true && active) {
+                next = { ...next, ...active, signedOut: false };
+            }
+        }
+        return next;
+    })
+        .finally(() => {
+        // Include exchanges admitted until the store publishes the cleared slot.
+        // Later exchanges re-read the clear; earlier ones lose their CAS.
+        refreshes = settleRefreshes();
+    });
+    if (!handled)
+        return undefined;
+    let result = {
+        status: targets.length ? "revoked" : "remote_revocation_unconfirmed",
+    };
+    for (const target of targets) {
+        if (!target.refresh) {
+            result = { status: "remote_revocation_unconfirmed" };
+            continue;
+        }
+        try {
+            const revoked = await revoke(target, options);
+            if (revoked.status !== "revoked")
+                result = revoked;
+        }
+        catch {
+            result = { status: "remote_revocation_unconfirmed" };
+        }
+    }
+    if (!(await refreshes))
+        result = { status: "remote_revocation_unconfirmed" };
+    return result;
+}
 /**
  * Default in-memory credential store. Apps inject persistent stores.
  * Keyed by `Provider.id`, one entry per provider (possibly a pooled one);

package/dist/auth/oauth/kimi-coding.js

@@ -206,17 +206,19 @@ async function refreshToken(oauthHost, refreshTokenValue, signal) {
         if (response.ok) {
             return parseTokenResponse(json, "refresh");
         }
-        // Unauthorized: the stored credential is dead; Models clears it and prompts re-login.
-        if (response.status === 401 || response.status === 403 || json?.error === "invalid_grant") {
+        const oauthError = typeof json?.error === "string" ? json.error : undefined;
+        // Unauthorized: the stored credential is dead; Models clears it and prompts re-login. The decision
+        // and the OAuth code travel on the error, so the credential pool never has to read this prose.
+        if (response.status === 401 || response.status === 403 || oauthError === "invalid_grant") {
             const description = typeof json?.error_description === "string" ? `: ${json.error_description}` : "";
-            throw new OAuthTokenEndpointError(`Kimi Code token refresh unauthorized (status ${response.status})${description}`, response.status);
+            throw new OAuthTokenEndpointError(`Kimi Code token refresh unauthorized (status ${response.status})${description}`, response.status, { oauthError, credentialRefused: true });
         }
         if (isRetryableRefreshFailure(response) && attempt < REFRESH_MAX_RETRIES) {
             lastError = new OAuthTokenEndpointError(`Kimi Code token refresh failed with status ${response.status}`, response.status);
             continue;
         }
         const text = JSON.stringify(json);
-        throw new OAuthTokenEndpointError(`Kimi Code token refresh failed with status ${response.status}${text ? `: ${text}` : ""}`, response.status);
+        throw new OAuthTokenEndpointError(`Kimi Code token refresh failed with status ${response.status}${text ? `: ${text}` : ""}`, response.status, { oauthError });
     }
     throw lastError ?? new Error("Kimi Code token refresh failed");
 }

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

@@ -0,0 +1,36 @@
+import type { Model } from "../../types.ts";
+import { ModelsError } from "../../utils/models-error.ts";
+/** Verified identity, not email, slot label, or a rotating bearer token. */
+export interface OpenAIChatGptModelIdentity {
+    sub: string;
+    clientId: string;
+}
+export interface OpenAIChatGptModelAccount extends OpenAIChatGptModelIdentity {
+    /** Supply the access token after the runtime's shared OAuth refresh has completed. */
+    access: string;
+}
+/**
+ * Picker entries are not full inference Models: /v1/models supplies no capability
+ * metadata for unknown slugs. W11's slot adapter must preserve that distinction.
+ */
+export type OpenAIChatGptCatalogModel = Pick<Model<"openai-responses">, "id" | "name"> & Partial<Pick<Model<"openai-responses">, "contextWindow" | "maxTokens" | "reasoning" | "thinkingLevelMap" | "input" | "cost">>;
+export declare class OpenAIChatGptModelCatalogError extends ModelsError {
+    readonly status?: number;
+    constructor(message: string, status?: number);
+}
+/**
+ * Last-known, account-scoped catalogs with transactional refresh, like provider
+ * refreshModels. This owns neither OAuth refresh nor provider registration.
+ * Keep one instance per provider runtime; activate the selected slot on account
+ * changes, or call refresh after explicit model refresh/token renewal.
+ */
+export declare class OpenAIChatGptModelCatalog {
+    private readonly catalogs;
+    private readonly generations;
+    private activeKey?;
+    private activeNeedsRefresh;
+    getModels(identity?: OpenAIChatGptModelIdentity): readonly OpenAIChatGptCatalogModel[];
+    activate(account: OpenAIChatGptModelAccount, signal: AbortSignal): Promise<readonly OpenAIChatGptCatalogModel[]>;
+    refresh(account: OpenAIChatGptModelAccount, signal: AbortSignal): Promise<readonly OpenAIChatGptCatalogModel[]>;
+}
+//# sourceMappingURL=openai-chatgpt-model-catalog.d.ts.map

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

@@ -0,0 +1,104 @@
+import { CHATGPT_SUBSCRIPTION_MODELS } from "../../providers/chatgpt-subscription.models.js";
+import { ModelsError } from "../../utils/models-error.js";
+export class OpenAIChatGptModelCatalogError extends ModelsError {
+    constructor(message, status) {
+        super("model_source", message);
+        this.name = "OpenAIChatGptModelCatalogError";
+        this.status = status;
+    }
+}
+function identityKey(identity) {
+    return JSON.stringify([identity.sub, identity.clientId]);
+}
+function parseCatalog(raw) {
+    const models = raw && typeof raw === "object" && "models" in raw ? raw.models : undefined;
+    if (!Array.isArray(models)) {
+        throw new OpenAIChatGptModelCatalogError("Invalid SIWC models response");
+    }
+    return models.flatMap((item) => {
+        if (!item || typeof item !== "object" || !("visibility" in item) || item.visibility !== "list")
+            return [];
+        if (!("slug" in item) ||
+            typeof item.slug !== "string" ||
+            !item.slug ||
+            !("display_name" in item) ||
+            typeof item.display_name !== "string" ||
+            !item.display_name) {
+            throw new OpenAIChatGptModelCatalogError("Invalid listed SIWC model");
+        }
+        const known = Object.values(CHATGPT_SUBSCRIPTION_MODELS).find((model) => model.id === item.slug);
+        return [
+            {
+                id: item.slug,
+                name: item.display_name,
+                ...(known
+                    ? {
+                        contextWindow: known.contextWindow,
+                        maxTokens: known.maxTokens,
+                        reasoning: known.reasoning,
+                        ...(known.thinkingLevelMap ? { thinkingLevelMap: known.thinkingLevelMap } : {}),
+                        input: known.input,
+                        cost: known.cost,
+                    }
+                    : {}),
+            },
+        ];
+    });
+}
+/**
+ * Last-known, account-scoped catalogs with transactional refresh, like provider
+ * refreshModels. This owns neither OAuth refresh nor provider registration.
+ * Keep one instance per provider runtime; activate the selected slot on account
+ * changes, or call refresh after explicit model refresh/token renewal.
+ */
+export class OpenAIChatGptModelCatalog {
+    constructor() {
+        this.catalogs = new Map();
+        this.generations = new Map();
+        this.activeNeedsRefresh = true;
+    }
+    getModels(identity) {
+        const key = identity ? identityKey(identity) : this.activeKey;
+        return key === undefined ? [] : (this.catalogs.get(key) ?? []);
+    }
+    async activate(account, signal) {
+        const key = identityKey(account);
+        if (key !== this.activeKey) {
+            this.activeKey = key;
+            this.activeNeedsRefresh = true;
+        }
+        if (!this.activeNeedsRefresh)
+            return this.getModels(account);
+        const models = await this.refresh(account, signal);
+        if (this.activeKey === key)
+            this.activeNeedsRefresh = false;
+        return models;
+    }
+    async refresh(account, signal) {
+        signal.throwIfAborted();
+        const key = identityKey(account);
+        const generation = (this.generations.get(key) ?? 0) + 1;
+        this.generations.set(key, generation);
+        const response = await fetch("https://api.openai.com/v1/models", {
+            method: "GET",
+            headers: { Authorization: `Bearer ${account.access}` },
+            signal,
+        });
+        if (!response.ok) {
+            throw new OpenAIChatGptModelCatalogError(`SIWC model catalog request failed (HTTP ${response.status})`, response.status);
+        }
+        let raw;
+        try {
+            raw = await response.json();
+        }
+        catch {
+            throw new OpenAIChatGptModelCatalogError("Invalid SIWC models response");
+        }
+        const models = parseCatalog(raw);
+        signal.throwIfAborted();
+        if (this.generations.get(key) === generation)
+            this.catalogs.set(key, models);
+        return models;
+    }
+}
+//# sourceMappingURL=openai-chatgpt-model-catalog.js.map

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

@@ -16,6 +16,7 @@ const AGENT_NAME_HINT = "Pi";
 const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const AUTHORIZE_URL = "https://auth.openai.com/api/accounts/authorize";
 const TOKEN_URL = "https://auth.openai.com/api/accounts/oauth/token";
+const DISCOVERY_URL = "https://auth.openai.com/.well-known/openid-configuration";
 const RESOURCE = "https://api.openai.com/v1";
 const CALLBACK_HOST = getProviderEnvValue("PI_OAUTH_CALLBACK_HOST") || "127.0.0.1";
 const CALLBACK_PORT = 1455;
@@ -183,6 +184,75 @@ async function refreshAccessToken(credential, signal) {
     }), signal);
     return credentialFromTokenResponse(token, clientId);
 }
+async function revokeSession(credential, options) {
+    const unconfirmed = { status: "remote_revocation_unconfirmed" };
+    if (!credential.refresh || typeof credential.clientId !== "string" || !credential.clientId.trim()) {
+        return unconfirmed;
+    }
+    const signal = AbortSignal.any([...(options?.signal ? [options.signal] : []), AbortSignal.timeout(15_000)]);
+    const sleep = options?.sleep ??
+        ((milliseconds) => new Promise((resolve, reject) => {
+            signal.throwIfAborted();
+            const onAbort = () => {
+                clearTimeout(timer);
+                reject(signal.reason);
+            };
+            const timer = setTimeout(() => {
+                signal.removeEventListener("abort", onAbort);
+                resolve();
+            }, milliseconds);
+            signal.addEventListener("abort", onAbort, { once: true });
+        }));
+    let endpoint;
+    const delays = [250, 1000];
+    for (let attempt = 0; attempt <= delays.length; attempt++) {
+        try {
+            signal.throwIfAborted();
+            if (attempt > 0)
+                await sleep(delays[attempt - 1]);
+            if (!endpoint) {
+                const discovery = await fetch(DISCOVERY_URL, { signal, redirect: "error" });
+                if (!discovery.ok) {
+                    if (discovery.status >= 500)
+                        continue;
+                    return unconfirmed;
+                }
+                const metadata = await discovery.json();
+                if (typeof metadata !== "object" ||
+                    metadata === null ||
+                    !("revocation_endpoint" in metadata) ||
+                    typeof metadata.revocation_endpoint !== "string") {
+                    return unconfirmed;
+                }
+                const url = new URL(metadata.revocation_endpoint);
+                if (url.protocol !== "https:" || url.username || url.password)
+                    return unconfirmed;
+                endpoint = url.href;
+            }
+            const response = await fetch(endpoint, {
+                method: "POST",
+                headers: { "content-type": "application/x-www-form-urlencoded" },
+                body: new URLSearchParams({
+                    token: credential.refresh,
+                    token_type_hint: "refresh_token",
+                    client_id: credential.clientId,
+                }),
+                signal,
+                redirect: "error",
+            });
+            // RFC 7009 returns an empty 200 for both revoked and already-invalid tokens.
+            if (response.status === 200)
+                return { status: "revoked" };
+            if (response.status < 500)
+                return unconfirmed;
+        }
+        catch {
+            if (signal.aborted)
+                return unconfirmed;
+        }
+    }
+    return unconfirmed;
+}
 /** OpenAI identifies each installation ("agent host") by a stable URI such as `urn:uuid:<uuid>`. */
 function agentHostId(deviceId) {
     if (!deviceId || !UUID_PATTERN.test(deviceId)) {
@@ -260,6 +330,12 @@ export const openaiChatGPTOAuth = {
     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 };
     },

package/dist/auth/oauth/radius.js

@@ -44,8 +44,7 @@ class OAuthResponseError extends OAuthTokenEndpointError {
                 ? `${oauthError}: ${description}`
                 : oauthError
             : description || String(status);
-        super(`${message}: ${detail}`, status);
-        this.oauthError = oauthError;
+        super(`${message}: ${detail}`, status, { oauthError });
     }
 }
 async function readOAuthResponseError(response, message) {

package/dist/auth/oauth-refresh.d.ts

@@ -37,6 +37,8 @@ export declare class OAuthRefreshExchangeError extends Error {
 export declare class OAuthRefreshStoreError extends Error {
     constructor(cause: unknown);
 }
+/** Collect exchanges through the clear's publication, then wait for discarded-token revocation too. */
+export declare function captureOAuthRefreshes(credentials: CredentialStore, providerId: string): () => Promise<boolean>;
 export declare function projectOAuthSlot(credential: OAuthCredential, name: string): OAuthCredential | undefined;
 /**
  * Resolves with the post-refresh stored credential (the whole provider entry),

package/dist/auth/oauth-refresh.js

@@ -33,6 +33,31 @@ export class OAuthRefreshStoreError extends Error {
     }
 }
 const inflightByStore = new WeakMap();
+const refreshObserversByStore = new WeakMap();
+/** Collect exchanges through the clear's publication, then wait for discarded-token revocation too. */
+export function captureOAuthRefreshes(credentials, providerId) {
+    const pending = [];
+    let observers = refreshObserversByStore.get(credentials);
+    if (!observers) {
+        observers = new Set();
+        refreshObserversByStore.set(credentials, observers);
+    }
+    const observe = (id, promise) => {
+        if (id === providerId)
+            pending.push(promise.then(() => true, () => false));
+    };
+    observers.add(observe);
+    const prefix = `${providerId}\u0000`;
+    for (const [key, refresh] of inflightByStore.get(credentials) ?? []) {
+        if (key.startsWith(prefix))
+            observe(providerId, refresh.promise);
+    }
+    return async () => {
+        observers.delete(observe);
+        const results = await Promise.all(pending);
+        return results.every(Boolean);
+    };
+}
 export function projectOAuthSlot(credential, name) {
     const projected = projectSlot(credential, name);
     return projected?.type === "oauth" ? projected : undefined;
@@ -58,6 +83,9 @@ export function refreshOAuthCredential(request) {
                 registry.delete(key);
         });
         registry.set(key, created);
+        for (const observe of refreshObserversByStore.get(request.credentials) ?? []) {
+            observe(request.providerId, created.promise);
+        }
         inflight = created;
     }
     join(inflight, request.signal, request.owning);
@@ -82,7 +110,10 @@ async function exchangeAndStore(request, signal) {
     const view = (credential) => {
         if (credential?.type !== "oauth")
             return undefined;
-        return slotName === undefined ? credential : projectOAuthSlot(credential, slotName);
+        const projected = slotName === undefined ? credential : projectOAuthSlot(credential, slotName);
+        if (projected?.signedOut === true || (!projected?.access && !projected?.refresh))
+            return undefined;
+        return projected;
     };
     let latest;
     try {
@@ -101,7 +132,8 @@ async function exchangeAndStore(request, signal) {
         const exchangeSignal = AbortSignal.any([signal, AbortSignal.timeout(DEFAULT_OAUTH_REFRESH_TIMEOUT_MS)]);
         refreshed = await oauth.refresh(current, exchangeSignal);
         // A result that arrives after every owning waiter left is not persisted.
-        signal.throwIfAborted();
+        if (!oauth.revoke)
+            signal.throwIfAborted();
     }
     catch (error) {
         signal.throwIfAborted();
@@ -115,15 +147,20 @@ async function exchangeAndStore(request, signal) {
         }
         throw new OAuthRefreshExchangeError(error);
     }
+    let discarded = false;
+    let post;
     try {
         // The write is not cancellable: the exchange consumed `current.refresh`, so
         // dropping the rotated token here would strand the account.
-        return await credentials.modify(providerId, async (stored) => {
-            if (stored?.type !== "oauth")
-                return undefined; // logged out meanwhile
+        post = await credentials.modify(providerId, async (stored) => {
             const slot = view(stored);
-            if (!slot || slot.refresh !== current.refresh)
-                return undefined; // rotated meanwhile: adopt the stored value
+            if (stored?.type !== "oauth" ||
+                !slot ||
+                slot.refresh !== current.refresh ||
+                (oauth.revoke && signal.aborted)) {
+                discarded = true;
+                return undefined; // logged out, rotated, or cancelled meanwhile
+            }
             return slotName === undefined
                 ? mergeRefreshed(stored, refreshed)
                 : mergeRefreshedSlot(stored, slotName, refreshed);
@@ -132,5 +169,14 @@ async function exchangeAndStore(request, signal) {
     catch (error) {
         throw new OAuthRefreshStoreError(error);
     }
+    // A refresh that lost ownership must not leave a renewable remote session.
+    // Do not revoke material another writer already stored as the current token.
+    if (discarded && oauth.revoke && refreshed.type === "oauth" && view(post)?.refresh !== refreshed.refresh) {
+        const result = await oauth.revoke({ ...current, ...refreshed });
+        if (result.status !== "revoked") {
+            throw new OAuthRefreshExchangeError(new Error("Discarded refresh revocation was not confirmed"));
+        }
+    }
+    return view(post) ? post : undefined;
 }
 //# sourceMappingURL=oauth-refresh.js.map