axusage 2.0.0

package/dist/services/create-auth-context.js

@@ -0,0 +1,34 @@
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { getAuthMetaPathFor, getStorageStatePathFor, } from "./auth-storage-path.js";
+/**
+ * Load the stored userAgent from the auth meta file for a service.
+ * Returns undefined if meta file doesn't exist or is invalid.
+ */
+export async function loadStoredUserAgent(dataDirectory, service) {
+    try {
+        const metaPath = getAuthMetaPathFor(dataDirectory, service);
+        const metaRaw = await readFile(metaPath, "utf8");
+        const meta = JSON.parse(metaRaw);
+        // Validate the parsed structure at runtime
+        if (meta &&
+            typeof meta === "object" &&
+            "userAgent" in meta &&
+            typeof meta.userAgent === "string") {
+            return meta.userAgent;
+        }
+        return undefined;
+    }
+    catch {
+        // Meta file missing, unreadable, or contains invalid JSON
+        return undefined;
+    }
+}
+export async function createAuthContext(browser, dataDirectory, service) {
+    const storageStatePath = getStorageStatePathFor(dataDirectory, service);
+    if (!existsSync(storageStatePath)) {
+        throw new Error(`No saved authentication for ${service}. Run 'axusage auth setup ${service}' first.`);
+    }
+    const userAgent = await loadStoredUserAgent(dataDirectory, service);
+    return browser.newContext({ storageState: storageStatePath, userAgent });
+}

package/dist/services/do-setup-auth.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserContext } from "playwright";
+import type { SupportedService } from "./supported-service.js";
+export declare function doSetupAuth(service: SupportedService, context: BrowserContext, storagePath: string, instructions: string): Promise<void>;

package/dist/services/do-setup-auth.js

@@ -0,0 +1,25 @@
+import { setupAuthInContext } from "./setup-auth-flow.js";
+import { writeFile, chmod } from "node:fs/promises";
+import path from "node:path";
+import { getAuthMetaPathFor } from "./auth-storage-path.js";
+export async function doSetupAuth(service, context, storagePath, instructions) {
+    console.error(`\n${instructions}`);
+    console.error("Waiting for login to complete (or press Enter to continue)\n");
+    const userAgent = await setupAuthInContext(service, context, storagePath);
+    try {
+        if (userAgent) {
+            const metaPath = getAuthMetaPathFor(path.dirname(storagePath), service);
+            await writeFile(metaPath, JSON.stringify({ userAgent }), "utf8");
+            try {
+                await chmod(metaPath, 0o600);
+            }
+            catch {
+                // best effort
+            }
+        }
+    }
+    catch {
+        // ignore errors when writing meta; not critical
+    }
+    console.error(`\n✓ Authentication saved for ${service}. You can now close the browser.`);
+}

package/dist/services/fetch-json-with-context.d.ts

@@ -0,0 +1,5 @@
+import type { BrowserContext } from "playwright";
+/**
+ * Fetch JSON using the page's fetch API so cookies/session are included without navigation.
+ */
+export declare function fetchJsonWithContext(context: BrowserContext, url: string): Promise<string>;

package/dist/services/fetch-json-with-context.js

@@ -0,0 +1,37 @@
+/**
+ * Fetch JSON using the page's fetch API so cookies/session are included without navigation.
+ */
+export async function fetchJsonWithContext(context, url) {
+    const page = await context.newPage();
+    try {
+        const origin = new URL(url).origin;
+        await page.goto(origin + "/", { waitUntil: "domcontentloaded" });
+        const result = await page.evaluate(async (targetUrl) => {
+            const response = await fetch(targetUrl, {
+                credentials: "include",
+                headers: {
+                    Accept: "application/json, text/plain, */*",
+                    "X-Requested-With": "XMLHttpRequest",
+                },
+            });
+            const text = await response.text();
+            return {
+                ok: response.ok,
+                status: response.status,
+                statusText: response.statusText,
+                contentType: response.headers.get("content-type") || "",
+                text,
+            };
+        }, url);
+        if (!result.ok) {
+            throw new Error(`Request failed: ${String(result.status)} ${result.statusText}`);
+        }
+        if (!result.contentType.toLowerCase().startsWith("application/json")) {
+            throw new Error(`Expected JSON response, got ${result.contentType}`);
+        }
+        return result.text;
+    }
+    finally {
+        await page.close();
+    }
+}

package/dist/services/gemini-api.d.ts

@@ -0,0 +1,11 @@
+import type { Result } from "../types/domain.js";
+import { ApiError } from "../types/domain.js";
+import type { GeminiQuotaResponse } from "../types/gemini.js";
+/**
+ * Discover the Gemini project ID for more accurate quota retrieval
+ */
+export declare function fetchGeminiProject(accessToken: string): Promise<string | undefined>;
+/**
+ * Fetch quota data from Gemini API
+ */
+export declare function fetchGeminiQuota(accessToken: string, projectId?: string): Promise<Result<GeminiQuotaResponse, ApiError>>;

package/dist/services/gemini-api.js

@@ -0,0 +1,109 @@
+import { ApiError } from "../types/domain.js";
+import { GeminiQuotaResponse as GeminiQuotaResponseSchema, GeminiProjectsResponse as GeminiProjectsResponseSchema, } from "../types/gemini.js";
+// NOTE: This is an undocumented internal Google API used by Gemini CLI.
+// It may change without notice. Last verified: December 2024.
+const QUOTA_API_URL = "https://cloudcode-pa.googleapis.com/v1internal:retrieveUserQuota";
+const PROJECTS_API_URL = "https://cloudresourcemanager.googleapis.com/v1/projects";
+const REQUEST_TIMEOUT_MS = 10_000;
+/**
+ * Discover the Gemini project ID for more accurate quota retrieval
+ */
+export async function fetchGeminiProject(accessToken) {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        const response = await fetch(PROJECTS_API_URL, {
+            method: "GET",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+            },
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            return undefined;
+        }
+        const data = await response.json();
+        const parseResult = GeminiProjectsResponseSchema.safeParse(data);
+        if (!parseResult.success || !parseResult.data.projects) {
+            return undefined;
+        }
+        // Find Gemini CLI project (starts with gen-lang-client or has generative-language label)
+        for (const project of parseResult.data.projects) {
+            if (project.projectId.startsWith("gen-lang-client")) {
+                return project.projectId;
+            }
+            if (project.labels?.["generative-language"] === "true") {
+                return project.projectId;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Fetch quota data from Gemini API
+ */
+export async function fetchGeminiQuota(accessToken, projectId) {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => {
+            controller.abort();
+        }, REQUEST_TIMEOUT_MS);
+        const body = projectId ? JSON.stringify({ project: projectId }) : "{}";
+        const response = await fetch(QUOTA_API_URL, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "Content-Type": "application/json",
+            },
+            body,
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (response.status === 401) {
+            return {
+                ok: false,
+                error: new ApiError("Gemini authentication expired. Run 'gemini' to re-authenticate.", 401),
+            };
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                ok: false,
+                error: new ApiError(`Gemini API error: ${String(response.status)} ${errorText}`, response.status),
+            };
+        }
+        const data = await response.json();
+        const parseResult = GeminiQuotaResponseSchema.safeParse(data);
+        if (!parseResult.success) {
+            return {
+                ok: false,
+                error: new ApiError(`Invalid Gemini quota response: ${parseResult.error.message}`, undefined, data),
+            };
+        }
+        if (parseResult.data.buckets.length === 0) {
+            return {
+                ok: false,
+                error: new ApiError("No quota data available. Token may be invalid or expired."),
+            };
+        }
+        return { ok: true, value: parseResult.data };
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            return {
+                ok: false,
+                error: new ApiError("Gemini quota API request timed out."),
+            };
+        }
+        return {
+            ok: false,
+            error: new ApiError(`Failed to fetch Gemini quota: ${error instanceof Error ? error.message : String(error)}`),
+        };
+    }
+}

package/dist/services/launch-chromium.d.ts

@@ -0,0 +1,6 @@
+import type { Browser } from "playwright";
+/**
+ * Launch Chromium with automation indicators disabled to reduce Cloudflare bot detection
+ * during the authentication flow.
+ */
+export declare function launchChromium(headless: boolean): Promise<Browser>;

package/dist/services/launch-chromium.js

@@ -0,0 +1,20 @@
+import { chromium } from "playwright";
+/**
+ * Launch Chromium with automation indicators disabled to reduce Cloudflare bot detection
+ * during the authentication flow.
+ */
+export async function launchChromium(headless) {
+    try {
+        return await chromium.launch({
+            headless,
+            args: ["--disable-blink-features=AutomationControlled"],
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/Executable doesn't exist|playwright\s+install/iu.test(message)) {
+            throw new Error("Playwright browsers are not installed. This is usually handled automatically by the postinstall script in package.json. Please try reinstalling the package or check if the postinstall script ran successfully. If the problem persists, you can manually run `pnpm exec playwright install chromium` or `npx playwright install chromium`, then retry.");
+        }
+        throw error;
+    }
+}

package/dist/services/persist-storage-state.d.ts

@@ -0,0 +1,6 @@
+import type { BrowserContext } from "playwright";
+/**
+ * Persist context storage state to disk with secure permissions (0o600).
+ * Errors are silently ignored to avoid blocking the main operation.
+ */
+export declare function persistStorageState(context: BrowserContext, storagePath: string): Promise<void>;

package/dist/services/persist-storage-state.js

@@ -0,0 +1,16 @@
+import { chmod } from "node:fs/promises";
+/**
+ * Persist context storage state to disk with secure permissions (0o600).
+ * Errors are silently ignored to avoid blocking the main operation.
+ */
+export async function persistStorageState(context, storagePath) {
+    try {
+        await context.storageState({ path: storagePath });
+        await chmod(storagePath, 0o600).catch(() => {
+            // best effort: permissions may already be correct or OS may ignore
+        });
+    }
+    catch {
+        // ignore persistence errors; do not block request completion
+    }
+}

package/dist/services/request-service.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserContext } from "playwright";
+import type { SupportedService } from "./supported-service.js";
+export declare function requestService(service: SupportedService, url: string, getContext: () => Promise<BrowserContext>): Promise<string>;

package/dist/services/request-service.js

@@ -0,0 +1,4 @@
+import { fetchJsonWithContext } from "./fetch-json-with-context.js";
+export async function requestService(service, url, getContext) {
+    return await fetchJsonWithContext(await getContext(), url);
+}

package/dist/services/service-adapter-registry.d.ts

@@ -0,0 +1,18 @@
+import type { ServiceAdapter } from "../types/domain.js";
+/**
+ * Registry of available service adapters
+ */
+export declare const SERVICE_ADAPTERS: {
+    readonly claude: ServiceAdapter;
+    readonly chatgpt: ServiceAdapter;
+    readonly "github-copilot": ServiceAdapter;
+    readonly gemini: ServiceAdapter;
+};
+/**
+ * Get a service adapter by name
+ */
+export declare function getServiceAdapter(name: string): ServiceAdapter | undefined;
+/**
+ * Get all available service names
+ */
+export declare function getAvailableServices(): string[];

package/dist/services/service-adapter-registry.js

@@ -0,0 +1,26 @@
+import { chatGPTAdapter } from "../adapters/chatgpt.js";
+import { claudeAdapter } from "../adapters/claude.js";
+import { geminiAdapter } from "../adapters/gemini.js";
+import { githubCopilotAdapter } from "../adapters/github-copilot.js";
+/**
+ * Registry of available service adapters
+ */
+export const SERVICE_ADAPTERS = {
+    claude: claudeAdapter,
+    chatgpt: chatGPTAdapter,
+    "github-copilot": githubCopilotAdapter,
+    gemini: geminiAdapter,
+};
+/**
+ * Get a service adapter by name
+ */
+export function getServiceAdapter(name) {
+    const key = name.toLowerCase();
+    return SERVICE_ADAPTERS[key];
+}
+/**
+ * Get all available service names
+ */
+export function getAvailableServices() {
+    return Object.keys(SERVICE_ADAPTERS);
+}

package/dist/services/service-auth-configs.d.ts

@@ -0,0 +1,15 @@
+import type { SupportedService } from "./supported-service.js";
+import type { BrowserContext } from "playwright";
+/**
+ * Service-specific configuration for authentication
+ */
+type ServiceAuthConfig = {
+    readonly url: string;
+    readonly waitForSelector?: string;
+    readonly waitForSelectors?: readonly string[];
+    readonly verifyUrl?: string;
+    readonly verifyFunction?: (context: BrowserContext, url: string) => Promise<boolean>;
+    readonly instructions: string;
+};
+export declare function getServiceAuthConfig(service: SupportedService): ServiceAuthConfig;
+export {};

package/dist/services/service-auth-configs.js

@@ -0,0 +1,26 @@
+const SERVICE_AUTH_CONFIGS = {
+    // Claude uses CLI-based auth via Claude Code credentials
+    claude: {
+        url: "",
+        instructions: "Claude uses Claude Code authentication. Run 'claude' in your terminal to authenticate.",
+    },
+    // ChatGPT uses CLI-based auth via Codex credentials
+    chatgpt: {
+        url: "",
+        instructions: "ChatGPT uses Codex CLI authentication. Run 'codex' in your terminal to authenticate.",
+    },
+    "github-copilot": {
+        url: "https://github.com/login",
+        waitForSelector: 'img[alt*="@"]',
+        verifyUrl: "https://github.com/github-copilot/chat/entitlement",
+        instructions: "Please log in to your GitHub account in the browser window.",
+    },
+    // Gemini uses CLI-based auth, not browser auth. This entry exists only to satisfy the Record type.
+    gemini: {
+        url: "",
+        instructions: "Gemini uses CLI-based authentication. Run 'gemini' in your terminal.",
+    },
+};
+export function getServiceAuthConfig(service) {
+    return SERVICE_AUTH_CONFIGS[service];
+}

package/dist/services/setup-auth-flow.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserContext } from "playwright";
+import type { SupportedService } from "./supported-service.js";
+export declare function setupAuthInContext(service: SupportedService, context: BrowserContext, storagePath: string): Promise<string | undefined>;

package/dist/services/setup-auth-flow.js

@@ -0,0 +1,40 @@
+import { getServiceAuthConfig } from "./service-auth-configs.js";
+import { waitForLogin } from "./wait-for-login.js";
+import { verifySessionByFetching } from "./verify-session.js";
+import { chmod } from "node:fs/promises";
+export async function setupAuthInContext(service, context, storagePath) {
+    const page = await context.newPage();
+    try {
+        const config = getServiceAuthConfig(service);
+        await page.goto(config.url);
+        const selectors = config.waitForSelectors ??
+            (config.waitForSelector ? [config.waitForSelector] : []);
+        await waitForLoginForService(page, selectors);
+        if (config.verifyUrl) {
+            const ok = config.verifyFunction
+                ? await config.verifyFunction(context, config.verifyUrl)
+                : await verifySessionByFetching(context, config.verifyUrl);
+            if (!ok) {
+                console.warn(`\n⚠ Unable to verify session via ${config.verifyUrl}. Saving state anyway...`);
+            }
+        }
+        // Capture user agent for future headless contexts
+        const userAgent = await page.evaluate(() => navigator.userAgent);
+        await context.storageState({ path: storagePath });
+        try {
+            await chmod(storagePath, 0o600);
+        }
+        catch {
+            // best effort to restrict sensitive storage state
+        }
+        return userAgent;
+    }
+    finally {
+        await page.close();
+    }
+}
+async function waitForLoginForService(page, selectors) {
+    if (selectors.length > 0) {
+        await waitForLogin(page, selectors);
+    }
+}

package/dist/services/shared-browser-auth-manager.d.ts

@@ -0,0 +1,4 @@
+import { BrowserAuthManager } from "./browser-auth-manager.js";
+export declare function acquireAuthManager(): BrowserAuthManager;
+export declare function releaseAuthManager(): Promise<void>;
+export declare function installAuthManagerCleanup(): void;

package/dist/services/shared-browser-auth-manager.js

@@ -0,0 +1,80 @@
+import { BrowserAuthManager } from "./browser-auth-manager.js";
+let manager;
+let references = 0;
+let cleanupInstalled = false;
+let closing = false;
+let exitInitiated = false;
+export function acquireAuthManager() {
+    if (!manager)
+        manager = new BrowserAuthManager();
+    references++;
+    return manager;
+}
+export async function releaseAuthManager() {
+    if (references <= 0) {
+        // Over-release guard: ignore unmatched release
+        if (references === 0) {
+            console.warn("releaseAuthManager() called without a matching acquire; ignoring");
+        }
+        // Avoid closing the manager in an over-release state
+        return;
+    }
+    references -= 1;
+    if (references === 0 && manager) {
+        await manager.close();
+        manager = undefined;
+    }
+}
+async function forceClose() {
+    if (closing)
+        return;
+    closing = true;
+    references = 0;
+    if (manager) {
+        try {
+            await manager.close();
+        }
+        catch {
+            // ignore
+        }
+        finally {
+            manager = undefined;
+        }
+    }
+}
+export function installAuthManagerCleanup() {
+    if (cleanupInstalled)
+        return;
+    cleanupInstalled = true;
+    /* eslint-disable unicorn/no-process-exit */
+    const safeExit = (code) => {
+        if (exitInitiated)
+            return;
+        exitInitiated = true;
+        process.exit(code);
+    };
+    /* eslint-enable unicorn/no-process-exit */
+    process.on("SIGINT", () => {
+        // Ensure browser is actually closed before exiting
+        void forceClose().finally(() => {
+            safeExit(130);
+        });
+    });
+    process.on("SIGTERM", () => {
+        // Ensure browser is actually closed before exiting
+        void forceClose().finally(() => {
+            safeExit(143);
+        });
+    });
+    process.on("beforeExit", () => {
+        // Best-effort cleanup on natural process exit; ensure we schedule a macrotask
+        // so the event loop stays alive until the async close finishes.
+        if (process.exitCode === undefined)
+            process.exitCode = 0;
+        setImmediate(() => {
+            void forceClose().finally(() => {
+                safeExit(Number(process.exitCode ?? 0));
+            });
+        });
+    });
+}

package/dist/services/supported-service.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Supported service names for usage tracking
+ */
+export type SupportedService = "claude" | "chatgpt" | "github-copilot" | "gemini";
+export declare const SUPPORTED_SERVICES: SupportedService[];
+export declare function validateService(service: string | undefined): SupportedService;

package/dist/services/supported-service.js

@@ -0,0 +1,16 @@
+export const SUPPORTED_SERVICES = [
+    "claude",
+    "chatgpt",
+    "github-copilot",
+    "gemini",
+];
+export function validateService(service) {
+    if (!service) {
+        throw new Error(`Service is required. Supported services: ${SUPPORTED_SERVICES.join(", ")}`);
+    }
+    const normalizedService = service.toLowerCase();
+    if (!SUPPORTED_SERVICES.includes(normalizedService)) {
+        throw new Error(`Unsupported service: ${service}. Supported services: ${SUPPORTED_SERVICES.join(", ")}`);
+    }
+    return normalizedService;
+}

package/dist/services/verify-session.d.ts

@@ -0,0 +1,2 @@
+import type { BrowserContext } from "playwright";
+export declare function verifySessionByFetching(context: BrowserContext, url: string, maxAttempts?: number, delayMs?: number): Promise<boolean>;

package/dist/services/verify-session.js

@@ -0,0 +1,25 @@
+import { fetchJsonWithContext } from "./fetch-json-with-context.js";
+/**
+ * Tries to fetch the given URL within the authenticated context.
+ * Returns true if the request succeeds, false if it keeps failing.
+ */
+const DEFAULT_MAX_ATTEMPTS = 5;
+const DEFAULT_RETRY_DELAY_MS = 1500;
+export async function verifySessionByFetching(context, url, maxAttempts = DEFAULT_MAX_ATTEMPTS, delayMs = DEFAULT_RETRY_DELAY_MS) {
+    // Try up to `maxAttempts` times; some providers need a brief
+    // delay for session cookies/tokens to settle after login.
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            await fetchJsonWithContext(context, url);
+            return true;
+        }
+        catch {
+            // Wait a bit and try again; tokens/cookies may not be settled yet
+            // Skip the delay after the final attempt to avoid unnecessary wait
+            if (attempt < maxAttempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+    return false;
+}

package/dist/services/wait-for-login.d.ts

@@ -0,0 +1,5 @@
+import type { Page } from "playwright";
+/**
+ * Waits until one of the selectors appears on the page, or the user presses Enter to continue.
+ */
+export declare function waitForLogin(page: Page, selectors: readonly string[]): Promise<void>;

package/dist/services/wait-for-login.js

@@ -0,0 +1,44 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { LOGIN_TIMEOUT_MS } from "./auth-timeouts.js";
+/**
+ * Waits until one of the selectors appears on the page, or the user presses Enter to continue.
+ */
+export async function waitForLogin(page, selectors) {
+    const reader = createInterface({ input, output });
+    const manual = reader.question("Press Enter to continue without waiting for login... ");
+    // Absorb rejection when the interface is closed to prevent
+    // unhandled promise rejection (AbortError) after a selector wins.
+    const manualSilenced = manual.catch(() => { });
+    const timeoutMs = LOGIN_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    // Prevent unhandled rejections if the page closes before all waiters finish
+    const waiters = selectors.map((sel) => page.waitForSelector(sel, { timeout: timeoutMs }).catch(() => {
+        // Intentionally ignored: the page may navigate/close before selector resolves
+    }));
+    const shouldShowCountdown = process.stderr.isTTY;
+    let interval;
+    if (shouldShowCountdown) {
+        interval = setInterval(() => {
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                // Stop logging once timeout elapses to avoid confusing "0 minute(s)" spam
+                if (interval)
+                    clearInterval(interval);
+                console.error("Login wait timed out; finishing up...");
+                return;
+            }
+            // Round up to the next minute for clearer UX, ensure at least 1
+            const minutes = Math.max(1, Math.ceil(remaining / 60_000));
+            console.error(`Still waiting for login... ${String(minutes)} minute(s) remaining`);
+        }, 60_000);
+    }
+    try {
+        await Promise.race([manualSilenced, ...waiters]);
+    }
+    finally {
+        if (interval)
+            clearInterval(interval);
+        reader.close();
+    }
+}

package/dist/types/chatgpt.d.ts

@@ -0,0 +1,32 @@
+import { z } from "zod";
+/**
+ * ChatGPT API response schemas
+ */
+export declare const ChatGPTRateLimitWindow: z.ZodObject<{
+    used_percent: z.ZodNumber;
+    limit_window_seconds: z.ZodNumber;
+    reset_after_seconds: z.ZodNumber;
+    reset_at: z.ZodNumber;
+}, z.core.$strip>;
+export type ChatGPTRateLimitWindow = z.infer<typeof ChatGPTRateLimitWindow>;
+export declare const ChatGPTUsageResponse: z.ZodObject<{
+    plan_type: z.ZodString;
+    rate_limit: z.ZodObject<{
+        allowed: z.ZodBoolean;
+        limit_reached: z.ZodBoolean;
+        primary_window: z.ZodObject<{
+            used_percent: z.ZodNumber;
+            limit_window_seconds: z.ZodNumber;
+            reset_after_seconds: z.ZodNumber;
+            reset_at: z.ZodNumber;
+        }, z.core.$strip>;
+        secondary_window: z.ZodObject<{
+            used_percent: z.ZodNumber;
+            limit_window_seconds: z.ZodNumber;
+            reset_after_seconds: z.ZodNumber;
+            reset_at: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    credits: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>;
+export type ChatGPTUsageResponse = z.infer<typeof ChatGPTUsageResponse>;