@howaboua/opencode-usage-plugin 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 @howaboua
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+# OpenCode Usage Plugin
+
+Track AI provider rate limits and quotas in real-time.
+
+## Features
+
+- **Live rate limits** – See Codex/OpenAI hourly/weekly limits at a glance
+- **Proxy quota stats** – Monitor Mirrowel Proxy credentials and tier usage
+- **Inline status** – Results appear directly in your chat, no context switching
+- **Zero setup** – Auto-detects providers from your existing config
+
+## Installation
+
+Add to your `opencode.json`:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": ["@howaboua/opencode-usage-plugin"]
+}
+```
+
+OpenCode installs dependencies automatically on next launch.
+
+## Usage
+
+### Check all providers
+
+```
+/usage
+```
+
+### Check specific provider
+
+```
+/usage codex
+/usage proxy
+```
+
+### Support the proxy
+
+```
+/usage support
+```
+
+## Supported Providers
+
+| Provider | Source |
+|----------|--------|
+| **Codex / OpenAI** | Auth tokens + `/wham/usage` endpoint |
+| **Mirrowel Proxy** | Local `/v1/quota-stats` endpoint |
+
+## Configuration
+
+Optional config at `~/.config/opencode/usage-config.jsonc`:
+
+```jsonc
+{
+  // Proxy server endpoint
+  "endpoint": "http://localhost:8000",
+
+  // API key for proxy auth
+  "apiKey": "your-key",
+
+  // Request timeout (ms)
+  "timeout": 10000,
+
+  // Show/hide providers in /usage output
+  "providers": {
+    "openai": true,
+    "proxy": true
+  }
+}
+```
+
+If missing, the plugin creates a default template on first run.
+
+## Development
+
+```bash
+# Check DB contents
+bun run debug-db.ts
+
+# Verify path resolution
+bun run debug-path.ts
+```
+
+See `AGENTS.md` for internal architecture.

package/dist/hooks/command.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Implements /usage command handling and config registration.
+ * Fetches live usage snapshots and renders a status message.
+ */
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+import type { UsageState } from "../state";
+type UsageClient = PluginInput["client"];
+export declare function commandHooks(options: {
+    client: UsageClient;
+    state: UsageState;
+}): Pick<Hooks, "command.execute.before" | "config">;
+export {};
+//# sourceMappingURL=command.d.ts.map

package/dist/hooks/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/hooks/command.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAI1C,KAAK,WAAW,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;AAWxC,wBAAgB,YAAY,CAAC,OAAO,EAAE;IACpC,MAAM,EAAE,WAAW,CAAA;IACnB,KAAK,EAAE,UAAU,CAAA;CAClB,GAAG,IAAI,CAAC,KAAK,EAAE,wBAAwB,GAAG,QAAQ,CAAC,CAmDnD"}

package/dist/hooks/command.js

@@ -0,0 +1,53 @@
+/**
+ * Implements /usage command handling and config registration.
+ * Fetches live usage snapshots and renders a status message.
+ */
+import { fetchUsageSnapshots, resolveProviderFilter } from "../usage";
+import { renderUsageStatus, sendStatusMessage } from "../ui";
+export function commandHooks(options) {
+    return {
+        config: async (input) => {
+            const config = input;
+            config.command ??= {};
+            config.command["usage"] = {
+                template: "/usage",
+                description: "Show API usage and rate limits (codex/proxy or all)",
+            };
+        },
+        "command.execute.before": async (input) => {
+            if (input.command !== "usage")
+                return;
+            const args = input.arguments?.trim() || "";
+            if (args === "support") {
+                await sendStatusMessage({
+                    client: options.client,
+                    state: options.state,
+                    sessionID: input.sessionID,
+                    text: "▣ Support Mirrowel Proxy\n\nSupport our lord and savior: https://ko-fi.com/mirrowel",
+                });
+                throw new Error("__USAGE_SUPPORT_HANDLED__");
+            }
+            const filter = args || undefined;
+            const targetProvider = resolveProviderFilter(filter);
+            let effectiveFilter = targetProvider ? filter : undefined;
+            const snapshots = await fetchUsageSnapshots(effectiveFilter);
+            const filteredSnapshots = snapshots.filter(s => {
+                if (targetProvider)
+                    return true; // User explicitly asked for it
+                if (s.provider === "codex")
+                    return options.state.availableProviders.codex;
+                if (s.provider === "proxy")
+                    return options.state.availableProviders.proxy;
+                return true;
+            });
+            await renderUsageStatus({
+                client: options.client,
+                state: options.state,
+                sessionID: input.sessionID,
+                snapshots: filteredSnapshots,
+                filter: effectiveFilter,
+            });
+            throw new Error("__USAGE_COMMAND_HANDLED__");
+        },
+    };
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { commandHooks } from "./command";
+export { sessionHooks } from "./session";
+export { proxyHooks, markSilent } from "./proxy";
+//# sourceMappingURL=index.d.ts.map

package/dist/hooks/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/hooks/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA"}

package/dist/hooks/index.js

@@ -0,0 +1,3 @@
+export { commandHooks } from "./command";
+export { sessionHooks } from "./session";
+export { proxyHooks, markSilent } from "./proxy";

package/dist/hooks/proxy.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Hooks for proxy-limits functionality.
+ * Manages silent responses after tool execution.
+ */
+export declare function markSilent(sessionID: string, messageID: string): void;
+export declare function proxyHooks(): {
+    "experimental.text.complete": (input: {
+        sessionID: string;
+        messageID: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+};
+//# sourceMappingURL=proxy.d.ts.map

package/dist/hooks/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../../src/hooks/proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,wBAAgB,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,QAI9D;AAWD,wBAAgB,UAAU;0CAGb;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,UACvC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE;EAM7B"}

package/dist/hooks/proxy.js

@@ -0,0 +1,31 @@
+/**
+ * Hooks for proxy-limits functionality.
+ * Manages silent responses after tool execution.
+ */
+const silence = new Map();
+export function markSilent(sessionID, messageID) {
+    const current = silence.get(sessionID) ?? new Set();
+    current.add(messageID);
+    if (!silence.has(sessionID))
+        silence.set(sessionID, current);
+}
+function shouldSilence(sessionID, messageID) {
+    const current = silence.get(sessionID);
+    if (!current)
+        return false;
+    if (!current.has(messageID))
+        return false;
+    current.delete(messageID);
+    if (current.size === 0)
+        silence.delete(sessionID);
+    return true;
+}
+export function proxyHooks() {
+    return {
+        "experimental.text.complete": async (input, output) => {
+            if (!shouldSilence(input.sessionID, input.messageID))
+                return;
+            output.text = "";
+        },
+    };
+}

package/dist/hooks/session.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Captures active session context for usage notifications.
+ * Updates the shared state on every chat parameter update.
+ */
+import type { Hooks } from "@opencode-ai/plugin";
+import type { UsageState } from "../state";
+export declare function sessionHooks(state: UsageState): Pick<Hooks, "chat.params">;
+//# sourceMappingURL=session.d.ts.map

package/dist/hooks/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/hooks/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAChD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAW1E"}

package/dist/hooks/session.js

@@ -0,0 +1,16 @@
+/**
+ * Captures active session context for usage notifications.
+ * Updates the shared state on every chat parameter update.
+ */
+export function sessionHooks(state) {
+    return {
+        "chat.params": async (input) => {
+            state.sessionID = input.sessionID;
+            state.agent = input.agent;
+            state.model = {
+                providerID: input.model.providerID,
+                modelID: input.model.id,
+            };
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Plugin entry point for Usage Tracking.
+ * Wires hooks and tools for live usage snapshots.
+ */
+import type { Plugin } from "@opencode-ai/plugin";
+export declare const UsagePlugin: Plugin;
+export default UsagePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAOjD,eAAO,MAAM,WAAW,EAAE,MA+CzB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/index.js

@@ -0,0 +1,53 @@
+/**
+ * Plugin entry point for Usage Tracking.
+ * Wires hooks and tools for live usage snapshots.
+ */
+import { commandHooks, sessionHooks, proxyHooks, markSilent } from "./hooks";
+import { createUsageState } from "./state";
+import { usageTool, createProxyLimitsTool } from "./tools";
+import { loadAuths } from "./usage/fetch";
+import { loadProxyConfig } from "./providers/proxy/config";
+export const UsagePlugin = async ({ client }) => {
+    const state = createUsageState();
+    try {
+        const [auths, proxyConfig] = await Promise.all([
+            loadAuths().catch(() => ({})),
+            loadProxyConfig().catch(() => null),
+        ]);
+        state.availableProviders.codex =
+            proxyConfig?.providers?.openai !== undefined
+                ? proxyConfig.providers.openai
+                : Boolean("codex" in auths && auths["codex"] || "openai" in auths && auths["openai"]);
+        state.availableProviders.proxy =
+            proxyConfig?.providers?.proxy !== undefined ? proxyConfig.providers.proxy : Boolean(proxyConfig?.endpoint);
+    }
+    catch { }
+    async function sendStatusMessage(sessionID, text) {
+        await client.session.prompt({
+            path: { id: sessionID },
+            body: {
+                noReply: true,
+                parts: [
+                    {
+                        type: "text",
+                        text,
+                        ignored: true,
+                    },
+                ],
+            },
+        });
+    }
+    const proxyHookHandlers = proxyHooks();
+    const commandHookHandlers = commandHooks({ client, state });
+    return {
+        config: commandHookHandlers.config,
+        "command.execute.before": commandHookHandlers["command.execute.before"],
+        ...sessionHooks(state),
+        ...proxyHookHandlers,
+        tool: {
+            "usage.get": usageTool(),
+            "proxy-limits": createProxyLimitsTool(sendStatusMessage, markSilent),
+        },
+    };
+};
+export default UsagePlugin;

package/dist/providers/base.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Provider interface for fetching and parsing usage snapshots.
+ * Each provider encapsulates its own auth and response logic.
+ */
+import type { UsageSnapshot } from "../types";
+export interface UsageProvider<TAuth = unknown> {
+    id: string;
+    displayName: string;
+    usageEndpoint?: string;
+    parseRateLimitHeaders?: (headers: Record<string, string>) => UsageSnapshot | null;
+    fetchUsage?: (auth: TAuth) => Promise<UsageSnapshot | null>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/providers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/providers/base.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7C,MAAM,WAAW,aAAa,CAAC,KAAK,GAAG,OAAO;IAC5C,EAAE,EAAE,MAAM,CAAA;IACV,WAAW,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,qBAAqB,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,aAAa,GAAG,IAAI,CAAA;IACjF,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC,CAAA;CAC5D"}

package/dist/providers/base.js

@@ -0,0 +1,5 @@
+/**
+ * Provider interface for fetching and parsing usage snapshots.
+ * Each provider encapsulates its own auth and response logic.
+ */
+export {};

package/dist/providers/codex/headers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Codex header parsing helpers for rate limits and credits.
+ * Uses shared header utilities for safe parsing.
+ */
+export declare function parseWindow(headers: Headers, prefix: "primary" | "secondary"): {
+    usedPercent: number;
+    windowMinutes: number | null;
+    resetsAt: number | null;
+} | null;
+export declare function parseCredits(headers: Headers): {
+    hasCredits: boolean;
+    unlimited: boolean;
+    balance: string | null;
+} | null;
+//# sourceMappingURL=headers.d.ts.map

package/dist/providers/codex/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/headers.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,WAAW;;;;SAQ5E;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO;;;;SAQ5C"}

package/dist/providers/codex/headers.js

@@ -0,0 +1,25 @@
+/**
+ * Codex header parsing helpers for rate limits and credits.
+ * Uses shared header utilities for safe parsing.
+ */
+import { parseBooleanHeader, parseIntegerHeader, parseNumberHeader } from "../../utils";
+export function parseWindow(headers, prefix) {
+    const usedPercent = parseNumberHeader(headers, `x-codex-${prefix}-used-percent`);
+    if (usedPercent === null)
+        return null;
+    return {
+        usedPercent,
+        windowMinutes: parseIntegerHeader(headers, `x-codex-${prefix}-window-minutes`),
+        resetsAt: parseIntegerHeader(headers, `x-codex-${prefix}-reset-at`),
+    };
+}
+export function parseCredits(headers) {
+    const hasCredits = parseBooleanHeader(headers, "x-codex-credits-has-credits");
+    if (hasCredits === null)
+        return null;
+    return {
+        hasCredits,
+        unlimited: parseBooleanHeader(headers, "x-codex-credits-unlimited") ?? false,
+        balance: headers.get("x-codex-credits-balance"),
+    };
+}

package/dist/providers/codex/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OpenAI/Codex usage provider for plan and rate-limit snapshots.
+ * Uses the /wham/usage endpoint plus rate-limit headers for fallback.
+ */
+import type { UsageProvider } from "../base";
+type CodexAuth = {
+    access?: string;
+    accountId?: string;
+};
+export declare const CodexProvider: UsageProvider<CodexAuth>;
+export type { CodexAuth };
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/codex/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AAI5C,KAAK,SAAS,GAAG;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,aAAa,EAAE,aAAa,CAAC,SAAS,CA0DlD,CAAA;AAED,YAAY,EAAE,SAAS,EAAE,CAAA"}

package/dist/providers/codex/index.js

@@ -0,0 +1,66 @@
+/**
+ * OpenAI/Codex usage provider for plan and rate-limit snapshots.
+ * Uses the /wham/usage endpoint plus rate-limit headers for fallback.
+ */
+import { parseCredits, parseWindow } from "./headers";
+import { toCreditsSnapshot, toPlanType, toRateLimitWindow, usageResponseSchema } from "./response";
+export const CodexProvider = {
+    id: "codex",
+    displayName: "OpenAI",
+    usageEndpoint: "https://chatgpt.com/backend-api/wham/usage",
+    parseRateLimitHeaders: (headers) => {
+        const parsedHeaders = new Headers(headers);
+        const primary = parseWindow(parsedHeaders, "primary");
+        const secondary = parseWindow(parsedHeaders, "secondary");
+        const credits = parseCredits(parsedHeaders);
+        if (!primary && !secondary && !credits)
+            return null;
+        return {
+            timestamp: Date.now(),
+            updatedAt: Date.now(),
+            provider: "codex",
+            planType: null,
+            primary,
+            secondary,
+            codeReview: null,
+            credits,
+        };
+    },
+    fetchUsage: async (auth) => {
+        const accessToken = auth.access;
+        if (!accessToken)
+            return null;
+        const response = await fetch("https://chatgpt.com/backend-api/wham/usage", {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                ...(auth.accountId ? { "ChatGPT-Account-Id": auth.accountId } : {}),
+            },
+        }).catch(() => null);
+        if (!response?.ok)
+            return null;
+        const data = await response.json().catch(() => null);
+        if (!data)
+            return null;
+        const parsed = usageResponseSchema.safeParse(data);
+        if (!parsed.success)
+            return null;
+        const rateLimit = parsed.data.rate_limit;
+        const primary = toRateLimitWindow(rateLimit.primary_window);
+        const secondary = toRateLimitWindow(rateLimit.secondary_window);
+        const credits = toCreditsSnapshot(parsed.data.credits);
+        const codeReview = parsed.data.code_review_rate_limit?.primary_window
+            ? toRateLimitWindow(parsed.data.code_review_rate_limit.primary_window)
+            : null;
+        const planType = toPlanType(parsed.data.plan_type);
+        return {
+            timestamp: Date.now(),
+            updatedAt: Date.now(),
+            provider: "codex",
+            planType,
+            primary,
+            secondary,
+            codeReview,
+            credits,
+        };
+    },
+};

package/dist/providers/codex/response.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Codex usage response schemas and transformations.
+ * Keeps API-specific shapes out of provider logic.
+ */
+import z from "zod";
+import { type PlanType } from "../../types";
+type UsageResponseWindow = {
+    used_percent: number;
+    limit_window_seconds: number;
+    reset_after_seconds: number;
+    reset_at: number;
+};
+type UsageResponse = {
+    plan_type: string | null;
+    rate_limit: {
+        allowed: boolean;
+        limit_reached: boolean;
+        primary_window: UsageResponseWindow | null;
+        secondary_window: UsageResponseWindow | null;
+    };
+    code_review_rate_limit?: {
+        primary_window: UsageResponseWindow | null;
+    } | null;
+    credits: {
+        has_credits: boolean;
+        unlimited: boolean;
+        balance: string | null;
+    } | null;
+};
+export declare const usageResponseSchema: z.ZodObject<{
+    plan_type: z.ZodNullable<z.ZodString>;
+    rate_limit: z.ZodObject<{
+        allowed: z.ZodBoolean;
+        limit_reached: z.ZodBoolean;
+        primary_window: z.ZodNullable<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.ZodNullable<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>;
+    code_review_rate_limit: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        primary_window: z.ZodNullable<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.ZodObject<{
+        has_credits: z.ZodBoolean;
+        unlimited: z.ZodBoolean;
+        balance: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ParsedUsageResponse = z.infer<typeof usageResponseSchema>;
+export declare function toRateLimitWindow(window: UsageResponseWindow | null): {
+    usedPercent: number;
+    windowMinutes: number;
+    resetsAt: number;
+} | null;
+export declare function toCreditsSnapshot(credits: UsageResponse["credits"]): {
+    hasCredits: boolean;
+    unlimited: boolean;
+    balance: string | null;
+} | null;
+export declare function toPlanType(value: UsageResponse["plan_type"]): PlanType | null;
+export {};
+//# sourceMappingURL=response.d.ts.map

package/dist/providers/codex/response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.d.ts","sourceRoot":"","sources":["../../../src/providers/codex/response.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,CAAC,MAAM,KAAK,CAAA;AACnB,OAAO,EAAa,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAA;AAEtD,KAAK,mBAAmB,GAAG;IACzB,YAAY,EAAE,MAAM,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;IAC5B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,KAAK,aAAa,GAAG;IACnB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,UAAU,EAAE;QACV,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,OAAO,CAAA;QACtB,cAAc,EAAE,mBAAmB,GAAG,IAAI,CAAA;QAC1C,gBAAgB,EAAE,mBAAmB,GAAG,IAAI,CAAA;KAC7C,CAAA;IACD,sBAAsB,CAAC,EAAE;QACvB,cAAc,EAAE,mBAAmB,GAAG,IAAI,CAAA;KAC3C,GAAG,IAAI,CAAA;IACR,OAAO,EAAE;QACP,WAAW,EAAE,OAAO,CAAA;QACpB,SAAS,EAAE,OAAO,CAAA;QAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;KACvB,GAAG,IAAI,CAAA;CACT,CAAA;AASD,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqBK,CAAA;AAErC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI;;;;SAOnE;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC;;;;SAOlE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,GAAG,IAAI,CAI7E"}

package/dist/providers/codex/response.js

@@ -0,0 +1,59 @@
+/**
+ * Codex usage response schemas and transformations.
+ * Keeps API-specific shapes out of provider logic.
+ */
+import z from "zod";
+import { PlanTypes } from "../../types";
+const usageResponseWindowSchema = z.object({
+    used_percent: z.number(),
+    limit_window_seconds: z.number(),
+    reset_after_seconds: z.number(),
+    reset_at: z.number(),
+});
+export const usageResponseSchema = z.object({
+    plan_type: z.string().nullable(),
+    rate_limit: z.object({
+        allowed: z.boolean(),
+        limit_reached: z.boolean(),
+        primary_window: usageResponseWindowSchema.nullable(),
+        secondary_window: usageResponseWindowSchema.nullable(),
+    }),
+    code_review_rate_limit: z
+        .object({
+        primary_window: usageResponseWindowSchema.nullable(),
+    })
+        .nullable()
+        .optional(),
+    credits: z
+        .object({
+        has_credits: z.boolean(),
+        unlimited: z.boolean(),
+        balance: z.string().nullable(),
+    })
+        .nullable(),
+});
+export function toRateLimitWindow(window) {
+    if (!window)
+        return null;
+    return {
+        usedPercent: window.used_percent,
+        windowMinutes: Math.round(window.limit_window_seconds / 60),
+        resetsAt: window.reset_at,
+    };
+}
+export function toCreditsSnapshot(credits) {
+    if (!credits)
+        return null;
+    return {
+        hasCredits: credits.has_credits,
+        unlimited: credits.unlimited,
+        balance: credits.balance,
+    };
+}
+export function toPlanType(value) {
+    if (!value)
+        return null;
+    if (!PlanTypes.includes(value))
+        return null;
+    return value;
+}

package/dist/providers/index.d.ts

@@ -0,0 +1,6 @@
+import type { UsageProvider } from "./base";
+export declare const providers: Record<string, UsageProvider<unknown>>;
+export { CodexProvider } from "./codex";
+export { ProxyProvider } from "./proxy";
+export type { UsageProvider } from "./base";
+//# sourceMappingURL=index.d.ts.map

package/dist/providers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/providers/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA;AAI3C,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,OAAO,CAAC,CAG5D,CAAA;AAED,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAA;AACvC,YAAY,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAA"}

package/dist/providers/index.js

@@ -0,0 +1,8 @@
+import { CodexProvider } from "./codex";
+import { ProxyProvider } from "./proxy";
+export const providers = {
+    [CodexProvider.id]: CodexProvider,
+    [ProxyProvider.id]: ProxyProvider,
+};
+export { CodexProvider } from "./codex";
+export { ProxyProvider } from "./proxy";