github-issue-tower-defence-management 1.80.0 → 1.81.0

package/src/adapter/proxy/RateLimitCache.test.ts

@@ -5,6 +5,8 @@ import {
   cacheDir,
   cachePathForToken,
   hashToken,
+  HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS,
+  HEADERLESS_429_MAX_COOLDOWN_SECONDS,
   parseModelRateLimitsFromBody,
   readRateLimit,
   writeModelRateLimit,
@@ -446,6 +448,107 @@ describe('RateLimitCache', () => {
     });
   });
 
+  describe('writeRateLimit records a cooldown on a 429 with no anthropic-ratelimit-* headers', () => {
+    it('should set blockedUntilEpoch using the default cooldown when no Retry-After header is present', () => {
+      const token = '429-no-headers-default-cooldown-token';
+      const before = Date.now() / 1000;
+      writeRateLimit(token, { 'content-type': 'application/json' }, 429);
+      const after = Date.now() / 1000;
+      const snapshot = readRateLimit(token);
+      expect(snapshot).not.toBeNull();
+      expect(snapshot?.blockedUntilEpoch).toBeGreaterThanOrEqual(
+        before + HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS,
+      );
+      expect(snapshot?.blockedUntilEpoch).toBeLessThanOrEqual(
+        after + HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS,
+      );
+    });
+
+    it('should honor the Retry-After header when present', () => {
+      const token = '429-no-headers-retry-after-token';
+      const retryAfterSeconds = 120;
+      const before = Date.now() / 1000;
+      writeRateLimit(
+        token,
+        { 'content-type': 'application/json', 'retry-after': '120' },
+        429,
+      );
+      const after = Date.now() / 1000;
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.blockedUntilEpoch).toBeGreaterThanOrEqual(
+        before + retryAfterSeconds,
+      );
+      expect(snapshot?.blockedUntilEpoch).toBeLessThanOrEqual(
+        after + retryAfterSeconds,
+      );
+    });
+
+    it('should clamp the cooldown to the maximum when Retry-After is very large', () => {
+      const token = '429-no-headers-clamp-token';
+      const before = Date.now() / 1000;
+      writeRateLimit(
+        token,
+        { 'content-type': 'application/json', 'retry-after': '99999' },
+        429,
+      );
+      const after = Date.now() / 1000;
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.blockedUntilEpoch).toBeGreaterThanOrEqual(
+        before + HEADERLESS_429_MAX_COOLDOWN_SECONDS,
+      );
+      expect(snapshot?.blockedUntilEpoch).toBeLessThanOrEqual(
+        after + HEADERLESS_429_MAX_COOLDOWN_SECONDS,
+      );
+    });
+
+    it('should preserve the previous last-good snapshot while adding the cooldown', () => {
+      const token = '429-no-headers-preserve-snapshot-token';
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '42',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '17',
+      });
+      writeRateLimit(token, { 'content-type': 'application/json' }, 429);
+      const snapshot = readRateLimit(token);
+      expect(snapshot?.fiveHourUtilization).toBe(42);
+      expect(snapshot?.fiveHourReset).toBe(1700000000);
+      expect(snapshot?.sevenDayUtilization).toBe(17);
+      expect(snapshot?.sevenDayReset).toBe(1700100000);
+      expect(snapshot?.rejected).toBe(false);
+      expect(snapshot?.blocked).toBe(false);
+      expect(snapshot?.blockedUntilEpoch).toBeGreaterThan(Date.now() / 1000);
+    });
+
+    it('should clear the cooldown when a later header-bearing response arrives', () => {
+      const token = '429-then-normal-clears-cooldown-token';
+      writeRateLimit(token, { 'content-type': 'application/json' }, 429);
+      expect(readRateLimit(token)?.blockedUntilEpoch).toBeGreaterThan(
+        Date.now() / 1000,
+      );
+      writeRateLimit(token, {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': '1700000000',
+        'anthropic-ratelimit-unified-5h-utilization': '30',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '20',
+      });
+      expect(readRateLimit(token)?.blockedUntilEpoch).toBe(0);
+    });
+
+    it('should not write any cooldown for a headerless response that is not a 429', () => {
+      const token = '500-no-headers-no-cooldown-token';
+      writeRateLimit(token, { 'content-type': 'application/json' }, 500);
+      expect(fs.existsSync(cachePathForToken(token))).toBe(false);
+      expect(readRateLimit(token)).toBeNull();
+    });
+  });
+
   describe('parseModelRateLimitsFromBody', () => {
     it('should extract a rejected seven_day_sonnet limit from a rate_limit event body', () => {
       const body =

package/src/adapter/proxy/RateLimitCache.ts

@@ -20,12 +20,17 @@ export interface RateLimitSnapshot {
   sevenDayRejected: boolean;
   modelWeeklyLimits: Record<string, ModelWeeklyLimit>;
   lastUpdatedEpoch: number;
+  blockedUntilEpoch: number;
 }
 
 export const PROXY_PORT = 8787;
 
 const HASH_ALGORITHM = 'sha256';
 
+export const HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS = 90;
+
+export const HEADERLESS_429_MAX_COOLDOWN_SECONDS = 600;
+
 export const cacheDir = (): string => {
   const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
   return path.join(base, 'tdpm', 'ratelimit');
@@ -68,9 +73,21 @@ const readModelWeeklyLimits = (
   return result;
 };
 
+const cooldownEndFromRetryAfter = (
+  retryAfterSeconds: number | null,
+  nowEpochSeconds: number,
+): number => {
+  const cooldownSeconds =
+    retryAfterSeconds !== null && retryAfterSeconds > 0
+      ? Math.min(retryAfterSeconds, HEADERLESS_429_MAX_COOLDOWN_SECONDS)
+      : HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS;
+  return nowEpochSeconds + cooldownSeconds;
+};
+
 export const writeRateLimit = (
   token: string,
   headers: Record<string, string | string[] | undefined>,
+  statusCode: number | null = null,
 ): void => {
   const pick = (key: string): string | undefined => {
     const value = headers[key];
@@ -86,14 +103,35 @@ export const writeRateLimit = (
       }
     }
   }
+  const dir = cacheDir();
+  const filePath = path.join(dir, `${hashToken(token)}.json`);
   if (Object.keys(rateLimitHeaders).length === 0) {
+    if (statusCode !== 429) {
+      return;
+    }
+    const existing = readPayload(filePath);
+    const retryAfterRaw = pick('retry-after');
+    const retryAfterSeconds =
+      retryAfterRaw !== undefined && Number.isFinite(Number(retryAfterRaw))
+        ? Number(retryAfterRaw)
+        : null;
+    const blockedUntilEpoch = cooldownEndFromRetryAfter(
+      retryAfterSeconds,
+      Date.now() / 1000,
+    );
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const payload = {
+      ...existing,
+      blockedUntilEpoch,
+    };
+    fs.writeFileSync(filePath, JSON.stringify(payload));
     return;
   }
-  const dir = cacheDir();
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-  const filePath = path.join(dir, `${hashToken(token)}.json`);
   const existing = readPayload(filePath);
   const payload = {
     ts: Date.now() / 1000,
@@ -186,6 +224,9 @@ export const readRateLimit = (token: string): RateLimitSnapshot | null => {
     const sevenDayRejected = sevenDayStatus === 'rejected';
     const storedTs = parsed.ts;
     const lastUpdatedEpoch = typeof storedTs === 'number' ? storedTs : 0;
+    const storedBlockedUntil = parsed.blockedUntilEpoch;
+    const blockedUntilEpoch =
+      typeof storedBlockedUntil === 'number' ? storedBlockedUntil : 0;
     return {
       fiveHourUtilization: num('anthropic-ratelimit-unified-5h-utilization'),
       fiveHourReset: num('anthropic-ratelimit-unified-5h-reset'),
@@ -201,6 +242,7 @@ export const readRateLimit = (token: string): RateLimitSnapshot | null => {
       sevenDayRejected,
       modelWeeklyLimits: readModelWeeklyLimits(parsed),
       lastUpdatedEpoch,
+      blockedUntilEpoch,
     };
   } catch {
     return null;

package/src/adapter/proxy/proxyEntry.test.ts

@@ -291,6 +291,23 @@ describe('startProxy', () => {
     expect(writeModelRateLimitSpy).toHaveBeenCalledTimes(1);
   });
 
+  it('should forward the upstream status code to writeRateLimit on a 429 response', async () => {
+    upstreamHandler = (_request, response) => {
+      response.writeHead(429, { 'content-type': 'application/json' });
+      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
+    };
+
+    const response = await requestThroughProxy('POST', '/v1/messages', '{}');
+
+    expect(response.statusCode).toBe(429);
+    expect(writeRateLimitSpy).toHaveBeenCalledTimes(1);
+    expect(writeRateLimitSpy).toHaveBeenCalledWith(
+      TOKEN,
+      expect.objectContaining({ 'content-type': 'application/json' }),
+      429,
+    );
+  });
+
   it('should forward non-SSE responses without crashing', async () => {
     upstreamHandler = (_request, response) => {
       response.writeHead(200, { 'content-type': 'application/json' });

package/src/adapter/proxy/proxyEntry.ts

@@ -50,7 +50,11 @@ const startProxy = (
       (upstreamResponse) => {
         if (token !== null) {
           try {
-            writeRateLimit(token, upstreamResponse.headers);
+            writeRateLimit(
+              token,
+              upstreamResponse.headers,
+              upstreamResponse.statusCode ?? null,
+            );
           } catch (error) {
             console.error('Failed to write rate limit cache:', error);
           }

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.test.ts

@@ -109,6 +109,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -120,6 +121,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {},
         },
       ]);
@@ -153,6 +155,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: true,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -188,6 +191,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: true,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -223,6 +227,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 30,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -258,6 +263,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -293,6 +299,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -328,6 +335,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {},
         },
       ]);
@@ -361,6 +369,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: true,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -396,6 +405,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 100,
           blocked: false,
           rejected: true,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: true, resetsAt: futureReset },
           },
@@ -431,6 +441,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day: { rejected: false, resetsAt: futureReset },
           },
@@ -455,6 +466,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 0,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {},
         },
       ]);
@@ -490,6 +502,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 10,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day_sonnet: { rejected: true, resetsAt: futureReset },
           },
@@ -527,6 +540,7 @@ describe('ProxyClaudeTokenUsageRepository', () => {
           sevenDayUtilization: 10,
           blocked: false,
           rejected: false,
+          blockedUntilEpoch: 0,
           modelWeeklyLimits: {
             seven_day_sonnet: { rejected: false, resetsAt: pastReset },
           },

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.ts

@@ -36,6 +36,7 @@ export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageReposito
           blocked: false,
           rejected: false,
           modelWeeklyLimits: {},
+          blockedUntilEpoch: 0,
         };
       }
       const fiveHourExpired = nowEpochSeconds > snapshot.fiveHourReset;
@@ -83,6 +84,7 @@ export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageReposito
           resetsAt: snapshot.sevenDayReset,
         };
       }
+      const cooldownActive = snapshot.blockedUntilEpoch > nowEpochSeconds;
       return {
         name,
         token,
@@ -91,6 +93,7 @@ export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageReposito
         blocked: snapshot.blocked,
         rejected,
         modelWeeklyLimits,
+        blockedUntilEpoch: cooldownActive ? snapshot.blockedUntilEpoch : 0,
       };
     });
   };

package/src/domain/entities/ClaudeTokenUsage.ts

@@ -11,4 +11,5 @@ export type ClaudeTokenUsage = {
   blocked: boolean;
   rejected: boolean;
   modelWeeklyLimits: Record<string, ClaudeModelWeeklyLimit>;
+  blockedUntilEpoch: number;
 };