agent-tank 0.9.9 → 0.9.11

package/src/agents/api-response-parser.js

@@ -102,22 +102,22 @@ function parseWeeklyAllModels(apiResponse, now) {
 }
 
 /**
- * Parse weekly Sonnet only limit from API response
+ * Parse weekly Fable allowance from API response
  * @param {Object} apiResponse - Raw API response
  * @param {Date} now - Current date/time
- * @returns {Object|null} Parsed weekly Sonnet data
+ * @returns {Object|null} Parsed weekly Fable data
  */
-function parseWeeklySonnet(apiResponse, now) {
-  const ws = apiResponse.weeklySonnet || apiResponse.weeklySonnetOnly;
-  if (!ws) return null;
+function parseWeeklyFable(apiResponse, now) {
+  const wf = apiResponse.weeklyFable;
+  if (!wf) return null;
 
-  const percent = ws.percentUsed ?? (ws.used && ws.limit ? Math.round((ws.used / ws.limit) * 100) : null);
+  const percent = wf.percentUsed ?? (wf.used != null && wf.limit > 0 ? Math.round((wf.used / wf.limit) * 100) : null);
 
   if (percent === null) return null;
 
-  const resetInfo = parseResetTimestamp(ws.resetsAt, now);
-  const weeklySonnet = { label: 'Current week (Sonnet only)', percent, ...resetInfo };
-  return addPaceData(weeklySonnet, 'weekly');
+  const resetInfo = parseResetTimestamp(wf.resetsAt, now);
+  const weeklyFable = { label: 'Current week (Fable)', percent, ...resetInfo };
+  return addPaceData(weeklyFable, 'weekly');
 }
 
 /**
@@ -174,8 +174,8 @@ function parseFlatPercentageFields(apiResponse, usage, now) {
 
 /**
  * Normalize the OAuth usage API response to the parser's expected schema.
- * The API returns: five_hour, seven_day, seven_day_sonnet, extra_usage
- * The parser expects: sessionLimit, weeklyAllModels, weeklySonnet, extraUsage
+ * The API returns: five_hour, seven_day, seven_day_fable, extra_usage
+ * The parser expects: sessionLimit, weeklyAllModels, weeklyFable, extraUsage
  * @param {Object} raw - Raw API response
  * @returns {Object} Normalized response
  */
@@ -194,10 +194,10 @@ function normalizeOAuthResponse(raw) {
       resetsAt: raw.seven_day.resets_at,
     };
   }
-  if (raw.seven_day_sonnet) {
-    norm.weeklySonnet = {
-      percentUsed: Math.round(raw.seven_day_sonnet.utilization),
-      resetsAt: raw.seven_day_sonnet.resets_at,
+  if (raw.seven_day_fable) {
+    norm.weeklyFable = {
+      percentUsed: Math.round(raw.seven_day_fable.utilization),
+      resetsAt: raw.seven_day_fable.resets_at,
     };
   }
   if (raw.extra_usage?.is_enabled) {
@@ -219,7 +219,7 @@ function normalizeOAuthResponse(raw) {
  * @returns {Object} The parsed usage object matching the PTY format
  */
 function parseApiResponse(apiResponse) {
-  const usage = { session: null, weeklyAll: null, weeklySonnet: null };
+  const usage = { session: null, weeklyAll: null, weeklyFable: null };
 
   if (!apiResponse) return usage;
 
@@ -236,7 +236,7 @@ function parseApiResponse(apiResponse) {
   // Parse each section
   usage.session = parseSessionLimit(normalized, now);
   usage.weeklyAll = parseWeeklyAllModels(normalized, now);
-  usage.weeklySonnet = parseWeeklySonnet(normalized, now);
+  usage.weeklyFable = parseWeeklyFable(normalized, now);
 
   const extraUsage = parseExtraUsage(normalized, now);
   if (extraUsage) {

package/src/agents/base.js

@@ -134,14 +134,6 @@ class BaseAgent {
         return;
       }
 
-      if (/rate.?limited|rate_limit_error/i.test(cleanOutput)) {
-        logger.agent(this.name, 'Rate limited, preserving last known usage data');
-        this.error = 'Rate limited — using cached data';
-        this.lastUpdated = new Date().toISOString();
-        // Don't overwrite this.usage — keep the last known good data
-        return;
-      }
-
       // Check for session/auth errors — preserve cached data if available
       const sessionErrorMatch = cleanOutput.match(/session.?expired|session.?error|invalid.?session|authentication.?error|auth.?failed|Unable to (?:load|fetch)|Error loading|could not (?:load|fetch)|Failed to load usage|not authenticated|login required|sign.?in required/i);
       if (sessionErrorMatch) {
@@ -152,12 +144,7 @@ class BaseAgent {
         return;
       }
 
-      const parsed = this.parseOutput(output);
-
-      // Only update usage if we got meaningful data (not all-null)
-      const hasData = parsed && Object.values(parsed).some(v => v !== null && v !== undefined && (typeof v !== 'object' || (Array.isArray(v) ? v.length > 0 : Object.keys(v).length > 0)));
-      if (hasData) { this.usage = parsed; this.lastUpdated = new Date().toISOString(); } else if (this.usage) { logger.agent(this.name, 'Parse returned no data, preserving last known usage'); this.error = 'Failed to parse — using cached data'; } else { this.usage = parsed; this.lastUpdated = new Date().toISOString(); }
-      logger.agent(this.name, 'Parsed usage:', logger.json(this.usage));
+      this._applyParsedUsage(this.parseOutput(output), cleanOutput);
     } catch (err) {
       if (this.isStopping() && err.message === 'Agent stopping') {
         logger.agent(this.name, 'Refresh cancelled during shutdown');
@@ -171,6 +158,34 @@ class BaseAgent {
     }
   }
 
+  // Decide what to do with freshly parsed usage, given the raw (cleaned) output.
+  // Prefers fresh data; treats rate-limit notices as an error only when no
+  // usable data came back (a partial rate limit — e.g. Claude's per-model /
+  // Fable breakdown — still yields session/weekly data, and the rate-limited
+  // section simply parses to null and is omitted by the formatter).
+  _applyParsedUsage(parsed, cleanOutput) {
+    const hasData = parsed && Object.values(parsed).some(v =>
+      v !== null && v !== undefined &&
+      (typeof v !== 'object' || (Array.isArray(v) ? v.length > 0 : Object.keys(v).length > 0)));
+
+    if (hasData) {
+      this.usage = parsed;
+      this.lastUpdated = new Date().toISOString();
+    } else if (/rate.?limited|rate_limit_error/i.test(cleanOutput)) {
+      logger.agent(this.name, 'Rate limited with no usable data, preserving last known usage');
+      this.error = this.usage ? 'Rate limited — using cached data' : 'Rate limited';
+      this.lastUpdated = new Date().toISOString();
+      return;
+    } else if (this.usage) {
+      logger.agent(this.name, 'Parse returned no data, preserving last known usage');
+      this.error = 'Failed to parse — using cached data';
+    } else {
+      this.usage = parsed;
+      this.lastUpdated = new Date().toISOString();
+    }
+    logger.agent(this.name, 'Parsed usage:', logger.json(this.usage));
+  }
+
   async runCommand() {
     if (this.isStopping()) {
       throw this._createStopError();

package/src/agents/claude.js

@@ -1,8 +1,21 @@
+/* eslint-disable max-lines -- Claude PTY and API integrations share one provider implementation. */
+
 const { BaseAgent } = require('./base.js');
 const logger = require('../logger.js');
 const { pingKeepalive } = require('./keepalive-helper.js');
 const { parseApiResponse } = require('./api-response-parser.js');
-const { parsePtyOutput } = require('./pty-output-parser.js');
+const { parsePtyOutput, FABLE_SECTION_START } = require('./pty-output-parser.js');
+
+// Matches the Fable allowance header alone, before its "N% used" row has rendered.
+const FABLE_SECTION_HEADER = new RegExp(FABLE_SECTION_START, 'i');
+const USAGE_SETTLE_TIMEOUT_MS = 2500;
+const USAGE_SETTLE_POLL_MS = 50;
+// A healthy Claude /usage dialog starts returning its core rows almost
+// immediately. Persistent PTYs occasionally swallow the slash command and emit
+// only terminal-mode control bytes; retry once instead of waiting 30 seconds
+// for the generic command timeout to tear down the process.
+const USAGE_COMMAND_RETRY_MS = 2500;
+const USAGE_COMMAND_RESET_MS = 200;
 const https = require('https');
 const {
   readCredentials, isTokenExpired, refreshOAuthToken, persistRefreshedTokens,
@@ -14,6 +27,7 @@ const API_RESPONSE_SENTINEL = '__API_RESPONSE__';
 class ClaudeAgent extends BaseAgent {
   constructor(options = {}) {
     super('claude', 'claude');
+    this.configPath = options.configPath || null;
     this._statusSent = false;
     this.useApi = options.useApi || false;
     this._apiResponse = null; // Stores the API response when using direct API
@@ -30,7 +44,7 @@ class ClaudeAgent extends BaseAgent {
    * @returns {Promise<string|null>} The OAuth token or null
    */
   async _getAuthToken() {
-    const creds = readCredentials();
+    const creds = readCredentials(this.configPath);
     if (!creds) {
       logger.agent(this.name, 'No OAuth token found in any credential source');
       return null;
@@ -133,7 +147,7 @@ class ClaudeAgent extends BaseAgent {
    * @returns {Promise<string|null>}
    */
   async _refreshAndGetToken() {
-    const creds = readCredentials();
+    const creds = readCredentials(this.configPath);
     if (!creds?.refreshToken) {
       logger.agent(this.name, 'No refresh token available');
       return null;
@@ -148,7 +162,7 @@ class ClaudeAgent extends BaseAgent {
     logger.agent(this.name, 'OAuth token refreshed successfully');
     if (creds.source === 'credentials_file') {
       try {
-        persistRefreshedTokens(refreshed);
+        persistRefreshedTokens(refreshed, this.configPath);
         logger.agent(this.name, 'Refreshed tokens persisted to credentials file');
       } catch (err) {
         logger.agent(this.name, 'Failed to persist refreshed tokens:', err.message);
@@ -182,6 +196,7 @@ class ClaudeAgent extends BaseAgent {
   getEnv() {
     const env = { ...process.env, TERM: 'dumb', NO_COLOR: '1' };
     delete env.CLAUDECODE; // Allow spawning inside a Claude Code session
+    if (this.configPath) env.CLAUDE_CONFIG_DIR = this.configPath;
     return env;
   }
 
@@ -209,19 +224,23 @@ class ClaudeAgent extends BaseAgent {
     const hasSessionData = parsed.session && typeof parsed.session.percent === 'number';
     const hasLegacyWeekly = parsed.weekly && typeof parsed.weekly.percent === 'number';
     const hasAllModelsWeekly = parsed.weeklyAll && typeof parsed.weeklyAll.percent === 'number';
-    const hasSonnetWeekly = parsed.weeklySonnet && typeof parsed.weeklySonnet.percent === 'number';
+    const hasFableWeekly = parsed.weeklyFable && typeof parsed.weeklyFable.percent === 'number';
+
+    // Only Max accounts get a Fable allowance row, so never block on it unless the
+    // dialog has actually started drawing one — otherwise Pro accounts would wait
+    // out the full command timeout for a section that is never coming.
+    if (hasAllModelsWeekly && FABLE_SECTION_HEADER.test(clean) && !hasFableWeekly) return false;
 
     // Newer Claude builds often emit usable session/weekly data before the UI fully settles.
-    // For the all-model weekly format, wait for the separate Sonnet section too.
-    return Boolean(hasSessionData && (hasLegacyWeekly || (hasAllModelsWeekly && hasSonnetWeekly)));
+    return Boolean(hasSessionData && (hasLegacyWeekly || hasAllModelsWeekly));
   }
 
-  sendCommands(shell, _output) {
+  sendCommands(shell, _output, canWrite = () => true) {
     logger.agent(this.name, 'Sending /usage command...');
     // Claude keeps slash-command suggestions open for /usage on newer builds.
     // Confirm the command selection, then submit the actual command execution.
     const writeIfActive = (value) => {
-      if (!shell) return;
+      if (!shell || !canWrite()) return;
       try {
         shell.write(value);
       } catch (_err) {
@@ -233,9 +252,76 @@ class ClaudeAgent extends BaseAgent {
     setTimeout(() => writeIfActive('\r'), 900);
   }
 
-  // After getting /usage output, dismiss dialog so next refresh starts with clean prompt
+  _isUsageDialogSettled(output) {
+    const clean = this.stripAnsi(output);
+    const usage = parsePtyOutput(clean);
+    if (!usage.weeklyAll || usage.weeklyFable) return true;
+
+    // A visible Fable header without its percentage is still mid-render.
+    if (FABLE_SECTION_HEADER.test(clean)) return false;
+
+    // Claude renders the usage footer after its asynchronous local-session scan.
+    // Reaching it without a Fable row means this account has no Fable allowance.
+    const weeklyIndex = clean.search(/Current\s*week\s*\(?\s*all\s*models/i);
+    const afterWeekly = weeklyIndex === -1 ? clean : clean.slice(weeklyIndex);
+    return /Usage\s*credits\s+are|Extra\s+usage/i.test(afterWeekly);
+  }
+
+  async _waitForUsageDialogSettlement(initialOutput) {
+    const deadline = Date.now() + USAGE_SETTLE_TIMEOUT_MS;
+    let latestOutput = this.output || initialOutput;
+
+    while (!this._isUsageDialogSettled(latestOutput) && Date.now() < deadline) {
+      await new Promise(resolve => setTimeout(resolve, USAGE_SETTLE_POLL_MS));
+      latestOutput = this.output || latestOutput;
+    }
+
+    return latestOutput;
+  }
+
+  _hasParseableUsageRows(output) {
+    const parsed = parsePtyOutput(this.stripAnsi(output));
+    return [parsed.session, parsed.weekly, parsed.weeklyAll, parsed.weeklyFable]
+      .some(row => row && typeof row.percent === 'number');
+  }
+
+  _retryStalledUsageCommand() {
+    const shell = this.shell;
+    const commandCallback = this._onDataCallback;
+    // Rows can arrive during either the reset delay or delayed submission while
+    // the Fable allowance is still rendering. Retry only the original waiter
+    // with no parseable rows, and continue to respect completed error responses.
+    const canRetry = () => shell && this.shell === shell && this._commandInFlight &&
+      this._onDataCallback === commandCallback && !this._hasParseableUsageRows(this.output) &&
+      !this.hasCompleteOutput(this.output);
+    if (!canRetry()) return;
+
+    logger.agent(this.name, 'No usage rows after 2.5s; resetting prompt and retrying /usage...');
+    try {
+      // Dismiss a half-open dialog or suggestion menu before resubmitting.
+      shell.write('\x1b');
+    } catch (_err) {
+      return;
+    }
+
+    setTimeout(() => {
+      if (!canRetry()) return;
+      this.output = '';
+      this.sendCommands(shell, '', canRetry);
+    }, USAGE_COMMAND_RESET_MS);
+  }
+
+  // After getting /usage output, let Claude finish its asynchronous allowance
+  // rows, then dismiss the dialog so the next refresh starts with a clean prompt.
   async sendCommandAndWait() {
-    const result = await super.sendCommandAndWait();
+    const retryTimer = setTimeout(() => this._retryStalledUsageCommand(), USAGE_COMMAND_RETRY_MS);
+    let result;
+    try {
+      result = await super.sendCommandAndWait();
+    } finally {
+      clearTimeout(retryTimer);
+    }
+    result = await this._waitForUsageDialogSettlement(result);
     if (this.shell) { this.shell.write('\x1b'); await new Promise(r => setTimeout(r, 1000)); this.output = ''; }
     return result;
   }
@@ -352,17 +438,54 @@ class ClaudeAgent extends BaseAgent {
   _parseStatusOutput(output) {
     const clean = this.stripAnsi(output);
     const metadata = {};
-    const patterns = [
-      ['sessionId', /Session(?:\s+ID)?:\s*([a-f0-9-]+)/i],
-      ['cwd', /(?:Working directory|Cwd|Current directory|Directory):\s*([^\n│]+)/i],
-      ['organization', /(?:Organization|Org):\s*([^\n│]+)/i],
-      ['email', /(?:Email|Account|User|Logged in as):\s*(\S+@\S+)/i],
-      ['model', /(?:Model|Using model):\s*(claude[-\w.]+)/i],
-      ['version', /(?:Version|Claude Code):\s*v?([\d.]+)/i],
-    ];
-    for (const [key, regex] of patterns) {
-      const match = clean.match(regex);
-      if (match) metadata[key] = this.stripBoxChars(match[1]);
+
+    // Claude 2.1.284 redraws the /status table in-place. Once terminal control
+    // sequences are removed, several fields can share one logical line, so a
+    // newline-only value boundary consumes every field that follows it. Keep
+    // line and box boundaries too, including before prompts or unknown labels.
+    const fieldStart = [
+      'Version', 'Claude\\s*Code', 'Session\\s*name', 'Session\\s*ID', 'Session\\s*kind',
+      'Peer\\s*address', 'Working\\s*directory', 'Cwd', 'Current\\s*directory', 'Directory',
+      'Login\\s*method', 'Organization', 'Org', 'Email', 'Account', 'User', 'Logged\\s*in\\s*as',
+      'Cloud\\s*sessions', 'Model', 'Using\\s*model', 'MCP\\s*servers', 'Setting\\s*sources',
+      'Auto\\s*mode\\s*server',
+    ].join('|');
+    const readField = (labels) => {
+      const match = clean.match(new RegExp(
+        `(?:${labels})\\s*:\\s*(.*?)(?=\\s*(?:(?:${fieldStart})\\s*:|Esc\\s*to\\s*cancel)|[\\r\\n│]|$)`,
+        'i'
+      ));
+      return match ? this.stripBoxChars(match[1]).trim() : null;
+    };
+
+    const sessionId = readField('Session(?:\\s*ID)?');
+    if (sessionId) {
+      const match = sessionId.match(/[a-f0-9-]+/i);
+      if (match) metadata.sessionId = match[0];
+    }
+
+    const cwd = readField('Working\\s*directory|Cwd|Current\\s*directory|Directory');
+    if (cwd) metadata.cwd = cwd;
+
+    const organization = readField('Organization|Org');
+    if (organization) metadata.organization = organization;
+
+    const email = readField('Email|Account|User|Logged\\s*in\\s*as');
+    if (email) {
+      const match = email.match(/\S+@\S+/);
+      if (match) metadata.email = match[0];
+    }
+
+    const model = readField('Model|Using\\s*model');
+    if (model) {
+      const claudeModel = model.match(/claude[-\w.]+/i);
+      metadata.model = claudeModel ? claudeModel[0] : model.replace(/\[\d+m/g, '').trim();
+    }
+
+    const version = readField('Version|Claude\\s*Code');
+    if (version) {
+      const match = version.match(/v?([\d.]+)/i);
+      if (match) metadata.version = match[1];
     }
     return Object.keys(metadata).length > 0 ? metadata : null;
   }
@@ -370,6 +493,10 @@ class ClaudeAgent extends BaseAgent {
   /** Lightweight keepalive to prevent session expiration. @returns {Promise<boolean>} True if keepalive succeeded */
   async keepalive() {
     if (this.freshProcess) { console.log(`[${this.name}] Keepalive skipped (fresh process mode)`); return true; }
+    if (this.isRefreshing || this._commandInFlight) {
+      console.log(`[${this.name}] Keepalive skipped (command in flight)`);
+      return true;
+    }
     if (!this.shell || !this.processReady) { console.log(`[${this.name}] Keepalive: spawning process...`); await this.spawnProcess(); }
     if (this.shell) { console.log(`[${this.name}] Keepalive: sending ping...`); this.shell.write('\x1b'); return true; }
     return false;

package/src/agents/codex-rpc-helpers.js

@@ -13,12 +13,20 @@ function formatRpcResponseAsOutput(rateLimits) {
     throw new Error('Empty rate limits response');
   }
 
-  // Check if we got a structured response we can use directly
+  // Current app-server responses include a backwards-compatible single bucket
+  // plus an optional map of model-specific buckets. Keep the entire response so
+  // the parser can use both views.
+  if (isRateLimitBucket(rateLimits) || isRateLimitBucket(rateLimits.rateLimits) ||
+      isObject(rateLimits.rateLimitsByLimitId)) {
+    return { marker: '__RPC_RESPONSE__', data: rateLimits };
+  }
+
+  // Legacy structured response.
   if (rateLimits.fiveHour || rateLimits.weekly || rateLimits.limits) {
     return { marker: '__RPC_RESPONSE__', data: rateLimits };
   }
 
-  // Handle different response formats
+  // Legacy nested response.
   if (rateLimits.rateLimits) {
     return { marker: '__RPC_RESPONSE__', data: rateLimits.rateLimits };
   }
@@ -39,13 +47,19 @@ function parseRpcRateLimits(rateLimits, context = {}) {
     weekly: null,
     version: context.versionInfo || null,
   };
+  const metadataUpdates = {};
 
-  // Parse five hour limit
+  if (isCurrentRateLimitsResponse(rateLimits)) {
+    parseCurrentRateLimits(rateLimits, usage, metadataUpdates, context);
+    return { usage, metadataUpdates };
+  }
+
+  // Parse legacy five hour limit.
   if (rateLimits.fiveHour) {
     usage.fiveHour = parseRpcLimitEntry(rateLimits.fiveHour, '5h limit', 'fiveHour', context);
   }
 
-  // Parse weekly limit
+  // Parse legacy weekly limit.
   if (rateLimits.weekly) {
     usage.weekly = parseRpcLimitEntry(rateLimits.weekly, 'Weekly limit', 'weekly', context);
   }
@@ -71,8 +85,6 @@ function parseRpcRateLimits(rateLimits, context = {}) {
     usage.account = rateLimits.account || rateLimits.email;
   }
 
-  // Build metadata updates
-  const metadataUpdates = {};
   if (rateLimits.model) {
     metadataUpdates.model = rateLimits.model;
   }
@@ -86,6 +98,89 @@ function parseRpcRateLimits(rateLimits, context = {}) {
   return { usage, metadataUpdates };
 }
 
+function parseCurrentRateLimits(rateLimits, usage, metadataUpdates, context) {
+  const bucketsById = isObject(rateLimits.rateLimitsByLimitId)
+    ? rateLimits.rateLimitsByLimitId
+    : {};
+  const mainBucket = findMainBucket(rateLimits, bucketsById);
+
+  if (mainBucket) {
+    Object.assign(usage, parseRateLimitBucket(mainBucket, context));
+    if (mainBucket.planType) metadataUpdates.planType = mainBucket.planType;
+  }
+
+  const modelLimits = parseModelLimitBuckets(bucketsById, mainBucket, context);
+  if (modelLimits.length > 0) usage.modelLimits = modelLimits;
+}
+
+function findMainBucket(rateLimits, bucketsById) {
+  if (isRateLimitBucket(rateLimits.rateLimits)) return rateLimits.rateLimits;
+  if (isRateLimitBucket(rateLimits)) return rateLimits;
+  if (isRateLimitBucket(bucketsById.codex)) return bucketsById.codex;
+  return Object.values(bucketsById).find(bucket =>
+    isRateLimitBucket(bucket) && !bucket.limitName
+  ) || null;
+}
+
+function parseModelLimitBuckets(bucketsById, mainBucket, context) {
+  const modelLimits = [];
+  for (const [limitId, bucket] of Object.entries(bucketsById)) {
+    if (isMainBucketEntry(bucket, limitId, mainBucket)) continue;
+
+    const parsed = parseRateLimitBucket(bucket, context);
+    if (!parsed.fiveHour && !parsed.weekly) continue;
+    modelLimits.push({
+      name: bucket.limitName || bucket.limitId || limitId,
+      ...parsed,
+    });
+  }
+  return modelLimits;
+}
+
+function isMainBucketEntry(bucket, limitId, mainBucket) {
+  if (!isRateLimitBucket(bucket) || bucket === mainBucket) return true;
+  return Boolean(mainBucket?.limitId && (bucket.limitId || limitId) === mainBucket.limitId);
+}
+
+function parseRateLimitBucket(bucket, context) {
+  const parsed = { fiveHour: null, weekly: null };
+  const windows = [
+    { data: bucket.primary, fallbackCycle: 'fiveHour' },
+    { data: bucket.secondary, fallbackCycle: 'weekly' },
+  ];
+
+  for (const { data, fallbackCycle } of windows) {
+    if (!isObject(data)) continue;
+    const cycle = classifyWindow(data.windowDurationMins) || fallbackCycle;
+    if (parsed[cycle]) continue;
+    const label = cycle === 'weekly' ? 'Weekly limit' : '5h limit';
+    parsed[cycle] = parseRpcLimitEntry(data, label, cycle, context);
+  }
+
+  return parsed;
+}
+
+function classifyWindow(windowDurationMins) {
+  const duration = Number(windowDurationMins);
+  if (!Number.isFinite(duration)) return null;
+  if (duration === CYCLE_DURATIONS.fiveHour / 60) return 'fiveHour';
+  if (duration === CYCLE_DURATIONS.weekly / 60) return 'weekly';
+  return null;
+}
+
+function isCurrentRateLimitsResponse(rateLimits) {
+  return isRateLimitBucket(rateLimits) || isRateLimitBucket(rateLimits?.rateLimits) ||
+    isObject(rateLimits?.rateLimitsByLimitId);
+}
+
+function isRateLimitBucket(value) {
+  return isObject(value) && ('primary' in value || 'secondary' in value);
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
 /**
  * Parse a single limit entry from RPC response
  * @param {Object} limit - Limit data from RPC
@@ -95,42 +190,29 @@ function parseRpcRateLimits(rateLimits, context = {}) {
  * @returns {Object} - Parsed limit entry
  */
 function parseRpcLimitEntry(limit, label, cycleType, context = {}) {
-  // Handle different possible structures
-  const percentLeft = limit.percentLeft ?? limit.remaining ?? limit.percent ?? 100;
-  const percentUsed = 100 - percentLeft;
-
-  // Handle reset time
-  let resetsAt = limit.resetsAt || limit.resetAt || limit.reset || null;
-  let resetsInSeconds = limit.resetsInSeconds || limit.secondsUntilReset || null;
-  let resetsIn = null;
-
-  // If we have seconds, calculate text
-  if (resetsInSeconds !== null) {
-    resetsIn = formatDuration(resetsInSeconds);
-  } else if (resetsAt && context.parseResetTime) {
-    // Try to parse the reset time
-    const resetData = context.parseResetTime(resetsAt);
-    if (resetData) {
-      resetsIn = resetData.text;
-      resetsInSeconds = resetData.seconds;
-    }
-  }
+  if (!isObject(limit)) return null;
+
+  const percentages = parsePercentages(limit);
+  if (!percentages) return null;
+  const resetInfo = parseRpcResetInfo(limit, context);
 
   const entry = {
-    percentLeft,
-    resetsAt,
+    ...percentages,
+    resetsAt: resetInfo.resetsAt,
     label,
-    percentUsed,
-    resetsIn,
-    resetsInSeconds,
+    resetsIn: resetInfo.resetsIn,
+    resetsInSeconds: resetInfo.resetsInSeconds,
   };
+  if (limit.windowDurationMins != null) {
+    entry.windowDurationMins = limit.windowDurationMins;
+  }
 
   // Calculate pace if we have the necessary data
   const cycleDuration = CYCLE_DURATIONS[cycleType];
-  if (cycleDuration && resetsInSeconds != null) {
+  if (cycleDuration && resetInfo.resetsInSeconds != null) {
     const paceData = calculatePace({
-      usagePercent: percentUsed,
-      resetsInSeconds,
+      usagePercent: percentages.percentUsed,
+      resetsInSeconds: resetInfo.resetsInSeconds,
       cycleDurationSeconds: cycleDuration,
     });
     if (paceData) entry.pace = paceData;
@@ -139,6 +221,56 @@ function parseRpcLimitEntry(limit, label, cycleType, context = {}) {
   return entry;
 }
 
+function parsePercentages(limit) {
+  const usedValue = toFiniteNumber(limit.usedPercent ?? limit.percentUsed);
+  const leftValue = toFiniteNumber(limit.percentLeft ?? limit.remaining ?? limit.percent);
+  if (usedValue === null && leftValue === null) return null;
+
+  const percentUsed = usedValue ?? (100 - leftValue);
+  return {
+    percentUsed,
+    percentLeft: leftValue ?? (100 - percentUsed),
+  };
+}
+
+function parseRpcResetInfo(limit, context) {
+  const resetsAt = limit.resetsAt || limit.resetAt || limit.reset || null;
+  const suppliedSeconds = toFiniteNumber(limit.resetsInSeconds ?? limit.secondsUntilReset);
+  if (suppliedSeconds !== null) {
+    return { resetsAt, resetsIn: formatDuration(suppliedSeconds), resetsInSeconds: suppliedSeconds };
+  }
+  if (isUnixTimestamp(resetsAt)) return parseUnixResetTime(resetsAt);
+
+  const parsed = resetsAt && context.parseResetTime ? context.parseResetTime(resetsAt) : null;
+  return {
+    resetsAt,
+    resetsIn: parsed?.text || null,
+    resetsInSeconds: parsed?.seconds ?? null,
+  };
+}
+
+function parseUnixResetTime(resetsAt) {
+  const timestamp = Number(resetsAt);
+  const resetTimeMs = timestamp < 1e12 ? timestamp * 1000 : timestamp;
+  const resetsInSeconds = Math.max(0, Math.floor((resetTimeMs - Date.now()) / 1000));
+  return {
+    resetsAt,
+    resetsIn: resetsInSeconds === 0 ? 'soon' : formatDuration(resetsInSeconds),
+    resetsInSeconds,
+  };
+}
+
+function isUnixTimestamp(value) {
+  if (typeof value === 'number') return Number.isFinite(value);
+  return typeof value === 'string' && /^\d+(?:\.\d+)?$/.test(value.trim());
+}
+
+function toFiniteNumber(value) {
+  if (value === null || value === undefined || value === '') return null;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : null;
+}
+
 /**
  * Format seconds as duration string
  * @param {number} seconds - Seconds to format