axusage 3.7.0 → 3.8.0

package/dist/adapters/parse-codex-usage.d.ts

@@ -1,5 +1,5 @@
-import type { ServiceUsageData } from "../types/domain.js";
-import type { CodexUsageResponse, CodexRateLimitWindow } from "../types/codex.js";
+import type { UsageWindow, ServiceUsageData } from "../types/domain.js";
+import type { CodexUsageResponse, CodexRateLimitWindow, CodexAdditionalRateLimit } from "../types/codex.js";
 /**
  * Converts a ChatGPT rate limit window to common usage window
  */
@@ -9,6 +9,10 @@ export declare function toUsageWindow(name: string, window: CodexRateLimitWindow
     resetsAt: Date;
     periodDurationMs: number;
 };
+/**
+ * Converts an additional rate limit entry to usage windows
+ */
+export declare function toAdditionalWindows(limit: CodexAdditionalRateLimit): readonly UsageWindow[];
 /**
  * Converts ChatGPT response to common domain model
  */

package/dist/adapters/parse-codex-usage.js

@@ -9,18 +9,47 @@ export function toUsageWindow(name, window) {
         periodDurationMs: window.limit_window_seconds * 1000,
     };
 }
+/**
+ * Formats a human-readable label from the limit_name or metered_feature
+ */
+function formatAdditionalLimitLabel(limit) {
+    return limit.limit_name || limit.metered_feature;
+}
+/**
+ * Converts an additional rate limit entry to usage windows
+ */
+export function toAdditionalWindows(limit) {
+    const label = formatAdditionalLimitLabel(limit);
+    const rateLimit = limit.rate_limit;
+    if (!rateLimit)
+        return [];
+    const windows = [];
+    if (rateLimit.primary_window) {
+        windows.push(toUsageWindow(`${label} (primary)`, rateLimit.primary_window));
+    }
+    if (rateLimit.secondary_window) {
+        windows.push(toUsageWindow(`${label} (secondary)`, rateLimit.secondary_window));
+    }
+    return windows;
+}
 /**
  * Converts ChatGPT response to common domain model
  */
 export function toServiceUsageData(response) {
+    const windows = [
+        toUsageWindow("Primary Window (~5 hours)", response.rate_limit.primary_window),
+        toUsageWindow("Secondary Window (~7 days)", response.rate_limit.secondary_window),
+    ];
+    if (response.additional_rate_limits) {
+        for (const limit of response.additional_rate_limits) {
+            windows.push(...toAdditionalWindows(limit));
+        }
+    }
     return {
         service: "ChatGPT",
         serviceType: "codex",
         planType: response.plan_type,
-        windows: [
-            toUsageWindow("Primary Window (~5 hours)", response.rate_limit.primary_window),
-            toUsageWindow("Secondary Window (~7 days)", response.rate_limit.secondary_window),
-        ],
+        windows,
         metadata: {
             allowed: response.rate_limit.allowed,
             limitReached: response.rate_limit.limit_reached,

package/dist/adapters/parse-gemini-usage.js

@@ -104,7 +104,7 @@ export function groupByQuotaPool(modelQuotas) {
     }
     // Sort model IDs within each pool for consistent ordering
     for (const pool of poolMap.values()) {
-        pool.modelIds.sort();
+        pool.modelIds = pool.modelIds.toSorted();
     }
     return [...poolMap.values()];
 }

package/dist/types/codex.d.ts

@@ -9,6 +9,27 @@ export declare const CodexRateLimitWindow: z.ZodObject<{
     reset_at: z.ZodNumber;
 }, z.core.$strip>;
 export type CodexRateLimitWindow = z.infer<typeof CodexRateLimitWindow>;
+declare const CodexAdditionalRateLimit: z.ZodObject<{
+    limit_name: z.ZodString;
+    metered_feature: z.ZodString;
+    rate_limit: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        allowed: z.ZodBoolean;
+        limit_reached: z.ZodBoolean;
+        primary_window: z.ZodOptional<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.ZodOptional<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>>>;
+}, z.core.$strip>;
+export type CodexAdditionalRateLimit = z.infer<typeof CodexAdditionalRateLimit>;
 export declare const CodexUsageResponse: z.ZodObject<{
     plan_type: z.ZodString;
     rate_limit: z.ZodObject<{
@@ -28,5 +49,26 @@ export declare const CodexUsageResponse: z.ZodObject<{
         }, z.core.$strip>;
     }, z.core.$strip>;
     credits: z.ZodNullable<z.ZodUnknown>;
+    additional_rate_limits: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        limit_name: z.ZodString;
+        metered_feature: z.ZodString;
+        rate_limit: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            allowed: z.ZodBoolean;
+            limit_reached: z.ZodBoolean;
+            primary_window: z.ZodOptional<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.ZodOptional<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>>>;
+    }, z.core.$strip>>>>;
 }, z.core.$strip>;
 export type CodexUsageResponse = z.infer<typeof CodexUsageResponse>;
+export {};

package/dist/types/codex.js

@@ -14,8 +14,25 @@ const CodexRateLimit = z.object({
     primary_window: CodexRateLimitWindow,
     secondary_window: CodexRateLimitWindow,
 });
+const CodexAdditionalRateLimit = z.object({
+    limit_name: z.string(),
+    metered_feature: z.string(),
+    rate_limit: z
+        .object({
+        allowed: z.boolean(),
+        limit_reached: z.boolean(),
+        primary_window: CodexRateLimitWindow.optional(),
+        secondary_window: CodexRateLimitWindow.optional(),
+    })
+        .nullable()
+        .optional(),
+});
 export const CodexUsageResponse = z.object({
     plan_type: z.string(),
     rate_limit: CodexRateLimit,
     credits: z.unknown().nullable(),
+    additional_rate_limits: z
+        .array(CodexAdditionalRateLimit)
+        .nullable()
+        .optional(),
 });

package/package.json

@@ -2,7 +2,7 @@
   "name": "axusage",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "3.7.0",
+  "version": "3.8.0",
   "description": "Monitor API usage across Claude, ChatGPT, GitHub Copilot, and Gemini from a single CLI",
   "repository": {
     "type": "git",