aisubs 0.1.0

package/dist/providers/copilot.js

@@ -0,0 +1,466 @@
+import { copilotPlanName, parseCopilotUsage } from "../usage.js";
+import { abortableDelay, bearerRequest, isRecord, numberValue, requireAllowedHost, responseJson, stringArray, stringValue, } from "../utils.js";
+const DEFAULT_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const EXPIRY_SKEW_MS = 5 * 60_000;
+const AUTO_API_VERSION = "2025-10-01";
+const HEADERS = {
+    "user-agent": "GitHubCopilotChat/0.35.0",
+    "editor-version": "vscode/1.107.0",
+    "editor-plugin-version": "copilot-chat/0.35.0",
+    "copilot-integration-id": "vscode-chat",
+    "x-github-api-version": "2026-06-01",
+};
+class CopilotTokenError extends Error {
+    status;
+    constructor(status) {
+        super(`Copilot token exchange failed (${status})`);
+        this.status = status;
+    }
+}
+function isAutoModel(id) {
+    return id === "auto" || id.endsWith("-free-auto");
+}
+function promptText(value, out) {
+    if (typeof value === "string")
+        out.push(value);
+    else if (Array.isArray(value)) {
+        for (const item of value) {
+            if (isRecord(item))
+                promptText(item.text ?? item.content ?? item.input, out);
+        }
+    }
+}
+function normalizeResponsesStream(body) {
+    const ids = new Map();
+    let currentTextId;
+    let currentReasoningId;
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const normalize = (frame) => frame.replace(/^(\s*data:\s*)(.+)$/gm, (line, prefix, data) => {
+        if (data.trim() === "[DONE]")
+            return line;
+        try {
+            const value = JSON.parse(data);
+            if (!isRecord(value))
+                return line;
+            const outputIndex = numberValue(value.output_index);
+            const item = isRecord(value.item) ? value.item : undefined;
+            if (value.type === "response.output_item.added" &&
+                outputIndex != null &&
+                typeof item?.id === "string") {
+                ids.set(outputIndex, item.id);
+                if (item.type === "message")
+                    currentTextId = item.id;
+                if (item.type === "reasoning")
+                    currentReasoningId = item.id;
+            }
+            const type = stringValue(value.type) ?? "";
+            const canonicalId = (outputIndex == null ? undefined : ids.get(outputIndex)) ??
+                (type.startsWith("response.reasoning_summary_")
+                    ? currentReasoningId
+                    : type.startsWith("response.output_text.") ||
+                        type.startsWith("response.content_part.") ||
+                        type.startsWith("response.refusal.")
+                        ? currentTextId
+                        : undefined);
+            if (canonicalId && typeof value.item_id === "string")
+                value.item_id = canonicalId;
+            if (canonicalId &&
+                value.type === "response.output_item.done" &&
+                item &&
+                typeof item.id === "string") {
+                item.id = canonicalId;
+            }
+            return `${prefix}${JSON.stringify(value)}`;
+        }
+        catch {
+            return line;
+        }
+    });
+    return body
+        .pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            controller.enqueue(decoder.decode(chunk, { stream: true }));
+        },
+        flush(controller) {
+            const rest = decoder.decode();
+            if (rest)
+                controller.enqueue(rest);
+        },
+    }))
+        .pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+            buffer += chunk;
+            let match = buffer.match(/\r?\n\r?\n/);
+            while (match?.index != null) {
+                const end = match.index + match[0].length;
+                controller.enqueue(normalize(buffer.slice(0, end)));
+                buffer = buffer.slice(end);
+                match = buffer.match(/\r?\n\r?\n/);
+            }
+        },
+        flush(controller) {
+            if (buffer)
+                controller.enqueue(normalize(buffer));
+        },
+    }))
+        .pipeThrough(new TextEncoderStream());
+}
+function normalizeModel(value) {
+    if (!isRecord(value))
+        return null;
+    const id = stringValue(value.id);
+    if (!id)
+        return null;
+    const isAuto = id.endsWith("-free-auto");
+    const policy = isRecord(value.policy) ? value.policy : {};
+    if (policy.state === "disabled")
+        return null;
+    const selectable = value.model_picker_enabled === true || isAuto;
+    if (policy.state !== "enabled" && !selectable)
+        return null;
+    const capabilities = isRecord(value.capabilities) ? value.capabilities : {};
+    const limits = isRecord(capabilities.limits) ? capabilities.limits : {};
+    const supports = isRecord(capabilities.supports) ? capabilities.supports : {};
+    if (supports.tool_calls === false)
+        return null;
+    const modalities = ["text"];
+    if (supports.vision === true || isRecord(limits.vision))
+        modalities.push("image");
+    return {
+        id,
+        name: isAuto ? "Auto" : stringValue(value.name),
+        contextWindow: numberValue(limits.max_context_window_tokens) ?? numberValue(limits.max_prompt_tokens),
+        maxOutputTokens: numberValue(limits.max_output_tokens),
+        reasoningEfforts: stringArray(supports.reasoning_effort),
+        inputModalities: modalities,
+        endpoints: stringArray(value.supported_endpoints)?.map((endpoint) => endpoint.replace(/^\//, "")),
+        ...(supports.tool_calls === true || isAuto ? { supportsToolCall: true } : {}),
+        available: true,
+        selectable,
+    };
+}
+function normalizeDomain(input) {
+    if (typeof input !== "string" || !input.trim())
+        return "github.com";
+    let hostname;
+    try {
+        hostname = new URL(input.includes("://") ? input : `https://${input}`).hostname;
+    }
+    catch {
+        throw new Error("Invalid GitHub Enterprise domain");
+    }
+    if (hostname !== "github.com" && !hostname.endsWith(".ghe.com")) {
+        throw new Error("Only github.com and GitHub Enterprise Cloud data-residency hosts (*.ghe.com) are supported");
+    }
+    return hostname;
+}
+function endpoints(domain) {
+    return {
+        deviceCode: `https://${domain}/login/device/code`,
+        accessToken: `https://${domain}/login/oauth/access_token`,
+        copilotToken: `https://api.${domain}/copilot_internal/v2/token`,
+        user: `https://api.${domain}/copilot_internal/user`,
+    };
+}
+function baseUrlFromToken(token, enterpriseDomain) {
+    const proxyHost = token.match(/proxy-ep=([^;]+)/)?.[1];
+    if (proxyHost)
+        return `https://${proxyHost.replace(/^proxy\./, "api.")}`;
+    if (enterpriseDomain && enterpriseDomain !== "github.com") {
+        return `https://copilot-api.${enterpriseDomain}`;
+    }
+    return "https://api.individual.githubcopilot.com";
+}
+export function copilotProvider(options = {}) {
+    const clientId = options.clientId ?? DEFAULT_CLIENT_ID;
+    const fetcher = options.fetch ?? globalThis.fetch;
+    const autoSessions = new Map();
+    async function routeAuto(body, credential, signal) {
+        const baseUrl = stringValue(credential.metadata?.baseUrl);
+        if (!baseUrl)
+            throw new Error("Copilot API base URL is missing");
+        const key = `${baseUrl}:${credential.account?.id ?? credential.account?.label ?? "default"}`;
+        let session = autoSessions.get(key);
+        if (!session ||
+            (session.expiresAt != null && Date.now() >= session.expiresAt * 1000 - 60_000)) {
+            const raw = await responseJson(await fetcher(`${baseUrl}/models/session`, {
+                method: "POST",
+                headers: {
+                    ...HEADERS,
+                    authorization: `Bearer ${credential.accessToken}`,
+                    "content-type": "application/json",
+                    "x-github-api-version": AUTO_API_VERSION,
+                },
+                body: JSON.stringify({ auto_mode: { model_hints: ["auto"] } }),
+                signal,
+            }), "Copilot Auto session setup");
+            const token = stringValue(raw.session_token);
+            const selectedModel = stringValue(raw.selected_model);
+            if (!token || !selectedModel)
+                throw new Error("Copilot Auto session response is incomplete");
+            session = {
+                token,
+                selectedModel,
+                availableModels: stringArray(raw.available_models) ?? [],
+                previousModel: null,
+                turnNumber: 0,
+                expiresAt: numberValue(raw.expires_at),
+            };
+        }
+        const prompt = [];
+        promptText(body.instructions, prompt);
+        promptText(body.input ?? body.messages, prompt);
+        const intentResponse = await fetcher(`${baseUrl}/models/session/intent`, {
+            method: "POST",
+            headers: {
+                ...HEADERS,
+                authorization: `Bearer ${credential.accessToken}`,
+                "content-type": "application/json",
+                "copilot-session-token": session.token,
+                "x-github-api-version": AUTO_API_VERSION,
+            },
+            body: JSON.stringify({
+                prompt: prompt.join("\n"),
+                available_models: session.availableModels,
+                turn_number: session.turnNumber + 1,
+                previous_model: session.previousModel,
+                reference_count: 0,
+                prompt_char_count: prompt.join("\n").length,
+            }),
+            signal,
+        });
+        let selectedModel = session.selectedModel;
+        if (intentResponse.ok) {
+            const intent = await responseJson(intentResponse, "Copilot Auto intent");
+            selectedModel =
+                stringValue(intent.chosen_model) ??
+                    stringValue(intent.selected_model) ??
+                    stringValue(intent.model) ??
+                    selectedModel;
+        }
+        session = {
+            ...session,
+            selectedModel,
+            previousModel: selectedModel,
+            turnNumber: session.turnNumber + 1,
+        };
+        autoSessions.set(key, session);
+        body.model = selectedModel;
+        return session;
+    }
+    async function exchange(githubToken, domain, signal) {
+        const response = await fetcher(endpoints(domain).copilotToken, {
+            headers: { accept: "application/json", authorization: `Bearer ${githubToken}`, ...HEADERS },
+            signal,
+        });
+        if (!response.ok)
+            throw new CopilotTokenError(response.status);
+        const raw = await responseJson(response, "Copilot token exchange");
+        const accessToken = stringValue(raw.token);
+        const expiresAt = numberValue(raw.expires_at);
+        if (!accessToken || !expiresAt)
+            throw new Error("Copilot token response is incomplete");
+        let user = null;
+        try {
+            const userResponse = await fetcher(endpoints(domain).user, {
+                headers: { accept: "application/json", authorization: `token ${githubToken}`, ...HEADERS },
+                signal,
+            });
+            if (userResponse.ok)
+                user = await responseJson(userResponse, "Copilot account details");
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+        }
+        const login = stringValue(user?.login);
+        const plan = copilotPlanName(user);
+        return {
+            accessToken,
+            refreshToken: githubToken,
+            expiresAt: expiresAt * 1000 - EXPIRY_SKEW_MS,
+            account: login || plan ? { id: login, label: login, plan } : undefined,
+            metadata: {
+                enterpriseDomain: domain,
+                baseUrl: baseUrlFromToken(accessToken, domain),
+            },
+        };
+    }
+    return {
+        id: "copilot",
+        name: "GitHub Copilot",
+        description: "GitHub Copilot access with automatic plan and organization detection.",
+        homepage: "https://github.com/features/copilot",
+        allowedHosts: ["api.github.com", "*.githubcopilot.com", "*.ghe.com"],
+        proxyBaseUrl: (credential) => stringValue(credential.metadata?.baseUrl),
+        loginModes: ["device"],
+        async startLogin(signal, options) {
+            const domain = normalizeDomain(options?.enterpriseDomain);
+            const response = await fetcher(endpoints(domain).deviceCode, {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/x-www-form-urlencoded",
+                    ...HEADERS,
+                },
+                body: new URLSearchParams({ client_id: clientId, scope: "read:user" }),
+                signal,
+            });
+            const raw = await responseJson(response, "Copilot device login");
+            const deviceCode = stringValue(raw.device_code);
+            const userCode = stringValue(raw.user_code);
+            const verificationUri = stringValue(raw.verification_uri);
+            if (!deviceCode || !userCode || !verificationUri) {
+                throw new Error("Copilot device response is incomplete");
+            }
+            let interval = Math.max(1, numberValue(raw.interval) ?? 5) * 1000;
+            const expiresIn = numberValue(raw.expires_in) ?? 900;
+            const complete = (async () => {
+                const deadline = Date.now() + expiresIn * 1000;
+                while (Date.now() < deadline) {
+                    await abortableDelay(interval, signal);
+                    const tokenResponse = await fetcher(endpoints(domain).accessToken, {
+                        method: "POST",
+                        headers: {
+                            accept: "application/json",
+                            "content-type": "application/x-www-form-urlencoded",
+                            ...HEADERS,
+                        },
+                        body: new URLSearchParams({
+                            client_id: clientId,
+                            device_code: deviceCode,
+                            grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                        }),
+                        signal,
+                    });
+                    const token = await responseJson(tokenResponse, "Copilot device authorization");
+                    const githubToken = stringValue(token.access_token);
+                    if (githubToken)
+                        return exchange(githubToken, domain, signal);
+                    const error = stringValue(token.error);
+                    if (error === "authorization_pending")
+                        continue;
+                    if (error === "slow_down") {
+                        interval += 5000;
+                        continue;
+                    }
+                    throw new Error(`Copilot device authorization failed${error ? `: ${error}` : ""}`);
+                }
+                throw new Error("Copilot device authorization timed out");
+            })();
+            return {
+                prompt: {
+                    mode: "device",
+                    verificationUri,
+                    userCode,
+                    expiresAt: Date.now() + expiresIn * 1000,
+                },
+                complete,
+            };
+        },
+        async refresh(credential, signal) {
+            if (!credential.refreshToken)
+                throw new Error("GitHub token is missing");
+            const domain = normalizeDomain(credential.metadata?.enterpriseDomain);
+            return exchange(credential.refreshToken, domain, signal);
+        },
+        async authorize(request, credential) {
+            const baseUrl = stringValue(credential.metadata?.baseUrl);
+            if (!baseUrl)
+                throw new Error("Copilot API base URL is missing");
+            requireAllowedHost(request, [new URL(baseUrl).hostname]);
+            const raw = request.method === "POST"
+                ? await request
+                    .clone()
+                    .json()
+                    .catch(() => null)
+                : null;
+            const authorized = bearerRequest(request, credential, HEADERS);
+            if (!isRecord(raw))
+                return authorized;
+            const pathname = new URL(request.url).pathname;
+            const isResponses = pathname.endsWith("/responses");
+            const auto = typeof raw.model === "string" && isAutoModel(raw.model);
+            const session = auto ? await routeAuto(raw, credential, request.signal) : null;
+            if (isResponses && raw.store === undefined)
+                raw.store = false;
+            if (isResponses && raw.store !== true && Array.isArray(raw.input)) {
+                raw.input = raw.input.flatMap((item) => {
+                    if (!isRecord(item))
+                        return [item];
+                    if (item.type === "item_reference")
+                        return [];
+                    const { id: _id, ...withoutId } = item;
+                    return [withoutId];
+                });
+            }
+            const entries = Array.isArray(raw.messages)
+                ? raw.messages
+                : Array.isArray(raw.input)
+                    ? raw.input
+                    : [];
+            const last = entries.at(-1);
+            const headers = new Headers(authorized.headers);
+            headers.set("x-initiator", isRecord(last) && last.role !== "user" ? "agent" : "user");
+            headers.set("openai-intent", "conversation-edits");
+            if (session) {
+                headers.set("copilot-session-token", session.token);
+                headers.set("x-github-api-version", AUTO_API_VERSION);
+            }
+            if (/"(?:image_url|input_image|image)"/.test(JSON.stringify(raw))) {
+                headers.set("copilot-vision-request", "true");
+            }
+            if (pathname.endsWith("/messages") && !headers.has("anthropic-beta")) {
+                headers.set("anthropic-beta", "interleaved-thinking-2025-05-14");
+            }
+            return new Request(authorized, { method: "POST", headers, body: JSON.stringify(raw) });
+        },
+        normalizeResponse(request, response) {
+            if (!new URL(request.url).pathname.endsWith("/responses") ||
+                !response.body ||
+                !response.headers.get("content-type")?.includes("text/event-stream")) {
+                return response;
+            }
+            const headers = new Headers(response.headers);
+            headers.delete("content-length");
+            return new Response(normalizeResponsesStream(response.body), {
+                status: response.status,
+                statusText: response.statusText,
+                headers,
+            });
+        },
+        async getUsage({ credential, signal }) {
+            if (!credential.refreshToken)
+                throw new Error("GitHub token is missing");
+            const domain = normalizeDomain(credential.metadata?.enterpriseDomain);
+            const response = await fetcher(endpoints(domain).user, {
+                headers: {
+                    accept: "application/json",
+                    authorization: `token ${credential.refreshToken}`,
+                    ...HEADERS,
+                },
+                signal,
+            });
+            return parseCopilotUsage(await responseJson(response, "Copilot usage"));
+        },
+        async getModels({ credential, fetch, signal }) {
+            const baseUrl = stringValue(credential.metadata?.baseUrl);
+            if (!baseUrl)
+                throw new Error("Copilot API base URL is missing");
+            const response = await fetch(`${baseUrl}/models`, {
+                headers: {
+                    accept: "application/json",
+                    "x-github-api-version": "2026-06-01",
+                },
+                signal,
+            });
+            const raw = await responseJson(response, "Copilot models");
+            const values = Array.isArray(raw.data) ? raw.data : [];
+            return values.map(normalizeModel).filter((model) => Boolean(model));
+        },
+        isPermanentRefreshError(error) {
+            return error instanceof CopilotTokenError && (error.status === 401 || error.status === 403);
+        },
+    };
+}

package/dist/providers/grok.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderAdapter } from "../types.js";
+export interface GrokProviderOptions {
+    clientId?: string;
+    compatibilityVersion?: string;
+    fetch?: typeof globalThis.fetch;
+}
+export declare function grokProvider(options?: GrokProviderOptions): ProviderAdapter;

package/dist/providers/grok.js

@@ -0,0 +1,215 @@
+import { parseGrokUsage } from "../usage.js";
+import { abortableDelay, bearerRequest, isRecord, numberValue, requireAllowedHost, responseJson, stringValue, } from "../utils.js";
+const DEFAULT_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+const DEVICE_URL = "https://auth.x.ai/oauth2/device/code";
+const TOKEN_URL = "https://auth.x.ai/oauth2/token";
+const USAGE_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+const USER_URL = "https://cli-chat-proxy.grok.com/v1/user?include=subscription";
+const SETTINGS_URL = "https://cli-chat-proxy.grok.com/v1/settings";
+const MODELS_URL = "https://cli-chat-proxy.grok.com/v1/models";
+const SCOPE = "openid profile email offline_access grok-cli:access api:access";
+const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+const EXPIRY_SKEW_MS = 2 * 60_000;
+const DEFAULT_COMPATIBILITY_VERSION = "1.0.3";
+class GrokTokenError extends Error {
+    status;
+    code;
+    constructor(status, code) {
+        super(`Grok token refresh failed (${code ?? status})`);
+        this.status = status;
+        this.code = code;
+    }
+}
+function credentialFromTokens(raw, previous) {
+    const accessToken = stringValue(raw.access_token);
+    const refreshToken = stringValue(raw.refresh_token) ?? previous?.refreshToken;
+    if (!accessToken || !refreshToken)
+        throw new Error("Grok token response is incomplete");
+    const lifetime = Math.max(60, numberValue(raw.expires_in) ?? 3600) * 1000;
+    return {
+        accessToken,
+        refreshToken,
+        expiresAt: Date.now() + Math.max(0, lifetime - EXPIRY_SKEW_MS),
+    };
+}
+export function grokProvider(options = {}) {
+    const clientId = options.clientId ?? DEFAULT_CLIENT_ID;
+    const compatibilityVersion = options.compatibilityVersion ?? DEFAULT_COMPATIBILITY_VERSION;
+    const fetcher = options.fetch ?? globalThis.fetch;
+    return {
+        id: "grok",
+        name: "Grok",
+        description: "xAI Grok and linked X subscription access through device authorization.",
+        homepage: "https://grok.com",
+        allowedHosts: ["cli-chat-proxy.grok.com"],
+        proxyBaseUrl: "https://cli-chat-proxy.grok.com/v1",
+        loginModes: ["device"],
+        async startLogin(signal) {
+            const response = await fetcher(DEVICE_URL, {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({ client_id: clientId, scope: SCOPE }),
+                signal,
+            });
+            const raw = await responseJson(response, "Grok device login");
+            const deviceCode = stringValue(raw.device_code);
+            const userCode = stringValue(raw.user_code);
+            const verificationUri = stringValue(raw.verification_uri_complete) ?? stringValue(raw.verification_uri);
+            if (!deviceCode || !userCode || !verificationUri) {
+                throw new Error("Grok device response is incomplete");
+            }
+            let interval = Math.max(1, numberValue(raw.interval) ?? 5) * 1000;
+            const expiresIn = Math.max(60, numberValue(raw.expires_in) ?? 300);
+            const complete = (async () => {
+                const deadline = Date.now() + expiresIn * 1000;
+                while (Date.now() < deadline) {
+                    await abortableDelay(interval, signal);
+                    const tokenResponse = await fetcher(TOKEN_URL, {
+                        method: "POST",
+                        headers: {
+                            accept: "application/json",
+                            "content-type": "application/x-www-form-urlencoded",
+                        },
+                        body: new URLSearchParams({
+                            grant_type: DEVICE_GRANT,
+                            client_id: clientId,
+                            device_code: deviceCode,
+                        }),
+                        signal,
+                    });
+                    const token = await tokenResponse.json().catch(() => ({}));
+                    const tokenRecord = isRecord(token) ? token : {};
+                    if (tokenResponse.ok)
+                        return credentialFromTokens(tokenRecord);
+                    const error = stringValue(tokenRecord.error);
+                    if (error === "authorization_pending")
+                        continue;
+                    if (error === "slow_down") {
+                        interval += 5000;
+                        continue;
+                    }
+                    throw new Error(`Grok device authorization failed${error ? `: ${error}` : ""}`);
+                }
+                throw new Error("Grok device authorization timed out");
+            })();
+            return {
+                prompt: {
+                    mode: "device",
+                    verificationUri,
+                    userCode,
+                    expiresAt: Date.now() + expiresIn * 1000,
+                },
+                complete,
+            };
+        },
+        async refresh(credential, signal) {
+            if (!credential.refreshToken)
+                throw new Error("Grok refresh token is missing");
+            const response = await fetcher(TOKEN_URL, {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/x-www-form-urlencoded",
+                },
+                body: new URLSearchParams({
+                    grant_type: "refresh_token",
+                    refresh_token: credential.refreshToken,
+                    client_id: clientId,
+                }),
+                signal,
+            });
+            if (!response.ok) {
+                const raw = (await response.json().catch(() => ({})));
+                throw new GrokTokenError(response.status, stringValue(raw.error));
+            }
+            return credentialFromTokens(await responseJson(response, "Grok token refresh"), credential);
+        },
+        async authorize(request, credential) {
+            requireAllowedHost(request, ["cli-chat-proxy.grok.com"]);
+            const raw = request.method === "POST"
+                ? await request
+                    .clone()
+                    .json()
+                    .catch(() => null)
+                : null;
+            const authorized = bearerRequest(request, credential, {
+                "x-xai-token-auth": "xai-grok-cli",
+                "x-grok-client-version": compatibilityVersion,
+                "x-grok-client-identifier": "grok-shell",
+                "user-agent": "xai-grok-cli",
+            });
+            if (request.method !== "POST")
+                return authorized;
+            const model = isRecord(raw) ? stringValue(raw.model) : undefined;
+            if (!model)
+                return authorized;
+            const headers = new Headers(authorized.headers);
+            headers.set("x-grok-model-override", model);
+            return new Request(authorized, { headers });
+        },
+        async getUsage({ fetch, signal }) {
+            const headers = { accept: "application/json" };
+            const user = await responseJson(await fetch(USER_URL, { headers, signal }), "Grok account");
+            const identityHeaders = {
+                ...headers,
+                ...(stringValue(user.userId) ? { "x-userid": stringValue(user.userId) } : {}),
+                ...(stringValue(user.email) ? { "x-email": stringValue(user.email) } : {}),
+            };
+            const [usageResponse, settingsResponse] = await Promise.all([
+                fetch(USAGE_URL, { headers: identityHeaders, signal }),
+                fetch(SETTINGS_URL, { headers: identityHeaders, signal }).catch(() => null),
+            ]);
+            const usage = await responseJson(usageResponse, "Grok usage");
+            const settings = settingsResponse?.ok
+                ? await settingsResponse.json().catch(() => null)
+                : null;
+            return parseGrokUsage(usage, user, settings);
+        },
+        async getModels({ fetch, signal }) {
+            const response = await fetch(MODELS_URL, {
+                headers: { accept: "application/json" },
+                signal,
+            });
+            const raw = await responseJson(response, "Grok models");
+            const models = Array.isArray(raw.data) ? raw.data : [];
+            return models.flatMap((value) => {
+                if (!isRecord(value))
+                    return [];
+                const id = stringValue(value.id) ?? stringValue(value.model);
+                if (!id)
+                    return [];
+                const efforts = Array.isArray(value.reasoning_efforts)
+                    ? value.reasoning_efforts.flatMap((effort) => {
+                        if (typeof effort === "string")
+                            return [effort];
+                        if (!isRecord(effort))
+                            return [];
+                        const name = stringValue(effort.value) ?? stringValue(effort.id);
+                        return name ? [name] : [];
+                    })
+                    : undefined;
+                const backend = stringValue(value.api_backend);
+                return [
+                    {
+                        id,
+                        name: stringValue(value.name),
+                        description: stringValue(value.description),
+                        contextWindow: numberValue(value.context_window) ?? numberValue(value.contextWindow),
+                        maxOutputTokens: numberValue(value.max_output_tokens) ?? numberValue(value.max_completion_tokens),
+                        reasoningEfforts: efforts?.length ? efforts : undefined,
+                        endpoints: backend ? [backend] : undefined,
+                        available: true,
+                        selectable: true,
+                    },
+                ];
+            });
+        },
+        isPermanentRefreshError(error) {
+            return (error instanceof GrokTokenError &&
+                (error.status === 401 || error.status === 403 || error.code === "invalid_grant"));
+        },
+    };
+}