github-issue-tower-defence-management 1.58.2 → 1.59.0

package/src/adapter/proxy/RateLimitCache.ts

@@ -3,12 +3,22 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 
+export interface ModelWeeklyLimit {
+  rejected: boolean;
+  resetsAt: number;
+}
+
 export interface RateLimitSnapshot {
   fiveHourUtilization: number;
   fiveHourReset: number;
   sevenDayUtilization: number;
   sevenDayReset: number;
   blocked: boolean;
+  rejected: boolean;
+  unifiedRejected: boolean;
+  fiveHourRejected: boolean;
+  sevenDayRejected: boolean;
+  modelWeeklyLimits: Record<string, ModelWeeklyLimit>;
 }
 
 export const PROXY_PORT = 8787;
@@ -26,6 +36,37 @@ export const hashToken = (token: string): string =>
 export const cachePathForToken = (token: string): string =>
   path.join(cacheDir(), `${hashToken(token)}.json`);
 
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const readPayload = (filePath: string): Record<string, unknown> => {
+  if (!fs.existsSync(filePath)) return {};
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed: unknown = JSON.parse(raw);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+};
+
+const readModelWeeklyLimits = (
+  payload: Record<string, unknown>,
+): Record<string, ModelWeeklyLimit> => {
+  const stored = payload.modelWeeklyLimits;
+  const result: Record<string, ModelWeeklyLimit> = {};
+  if (!isRecord(stored)) return result;
+  for (const [limitType, value] of Object.entries(stored)) {
+    if (!isRecord(value)) continue;
+    const rejected = value.rejected;
+    const resetsAt = value.resetsAt;
+    if (typeof rejected === 'boolean' && typeof resetsAt === 'number') {
+      result[limitType] = { rejected, resetsAt };
+    }
+  }
+  return result;
+};
+
 export const writeRateLimit = (
   token: string,
   headers: Record<string, string | string[] | undefined>,
@@ -39,44 +80,84 @@ export const writeRateLimit = (
     if (Array.isArray(value)) return value[0];
     return value;
   };
+  const filePath = path.join(dir, `${hashToken(token)}.json`);
+  const existing = readPayload(filePath);
+  const rateLimitHeaders: Record<string, string> = {};
+  for (const key of Object.keys(headers)) {
+    if (key.startsWith('anthropic-ratelimit-')) {
+      const value = pick(key);
+      if (value !== undefined) {
+        rateLimitHeaders[key] = value;
+      }
+    }
+  }
   const payload = {
     ts: Date.now() / 1000,
-    headers: {
-      'anthropic-ratelimit-unified-status': pick(
-        'anthropic-ratelimit-unified-status',
-      ),
-      'anthropic-ratelimit-unified-5h-status': pick(
-        'anthropic-ratelimit-unified-5h-status',
-      ),
-      'anthropic-ratelimit-unified-5h-reset': pick(
-        'anthropic-ratelimit-unified-5h-reset',
-      ),
-      'anthropic-ratelimit-unified-5h-utilization': pick(
-        'anthropic-ratelimit-unified-5h-utilization',
-      ),
-      'anthropic-ratelimit-unified-7d-status': pick(
-        'anthropic-ratelimit-unified-7d-status',
-      ),
-      'anthropic-ratelimit-unified-7d-reset': pick(
-        'anthropic-ratelimit-unified-7d-reset',
-      ),
-      'anthropic-ratelimit-unified-7d-utilization': pick(
-        'anthropic-ratelimit-unified-7d-utilization',
-      ),
-    },
+    headers: rateLimitHeaders,
+    modelWeeklyLimits: readModelWeeklyLimits(existing),
   };
+  fs.writeFileSync(filePath, JSON.stringify(payload));
+};
+
+export const writeModelRateLimit = (
+  token: string,
+  limits: Record<string, ModelWeeklyLimit>,
+): void => {
+  const limitTypes = Object.keys(limits);
+  if (limitTypes.length === 0) 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 merged = {
+    ...readModelWeeklyLimits(existing),
+    ...limits,
+  };
+  const payload = {
+    ...existing,
+    modelWeeklyLimits: merged,
+  };
   fs.writeFileSync(filePath, JSON.stringify(payload));
 };
 
+export const parseModelRateLimitsFromBody = (
+  body: string,
+): Record<string, ModelWeeklyLimit> => {
+  const result: Record<string, ModelWeeklyLimit> = {};
+  const matches = body.match(
+    /\{[^{}]*"rateLimitType"[^{}]*\}|\{[^{}]*"resetsAt"[^{}]*"rateLimitType"[^{}]*\}/g,
+  );
+  if (matches === null) return result;
+  for (const candidate of matches) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(candidate);
+    } catch {
+      continue;
+    }
+    if (!isRecord(parsed)) continue;
+    const rateLimitType = parsed.rateLimitType;
+    const status = parsed.status;
+    const resetsAt = parsed.resetsAt;
+    if (typeof rateLimitType !== 'string') continue;
+    if (typeof status !== 'string') continue;
+    if (typeof resetsAt !== 'number') continue;
+    result[rateLimitType] = {
+      rejected: status === 'rejected',
+      resetsAt,
+    };
+  }
+  return result;
+};
+
 export const readRateLimit = (token: string): RateLimitSnapshot | null => {
   const filePath = cachePathForToken(token);
   if (!fs.existsSync(filePath)) return null;
   try {
     const raw = fs.readFileSync(filePath, 'utf8');
     const parsed: unknown = JSON.parse(raw);
-    const isRecord = (value: unknown): value is Record<string, unknown> =>
-      value !== null && typeof value === 'object' && !Array.isArray(value);
     if (!isRecord(parsed)) return null;
     const headersUnknown = parsed.headers;
     const headers: Record<string, string> = {};
@@ -96,6 +177,9 @@ export const readRateLimit = (token: string): RateLimitSnapshot | null => {
     const status = headers['anthropic-ratelimit-unified-status'];
     const fiveHourStatus = headers['anthropic-ratelimit-unified-5h-status'];
     const sevenDayStatus = headers['anthropic-ratelimit-unified-7d-status'];
+    const unifiedRejected = status === 'rejected';
+    const fiveHourRejected = fiveHourStatus === 'rejected';
+    const sevenDayRejected = sevenDayStatus === 'rejected';
     return {
       fiveHourUtilization: num('anthropic-ratelimit-unified-5h-utilization'),
       fiveHourReset: num('anthropic-ratelimit-unified-5h-reset'),
@@ -105,6 +189,11 @@ export const readRateLimit = (token: string): RateLimitSnapshot | null => {
         status === 'blocked' ||
         fiveHourStatus === 'blocked' ||
         sevenDayStatus === 'blocked',
+      rejected: unifiedRejected || fiveHourRejected || sevenDayRejected,
+      unifiedRejected,
+      fiveHourRejected,
+      sevenDayRejected,
+      modelWeeklyLimits: readModelWeeklyLimits(parsed),
     };
   } catch {
     return null;

package/src/adapter/proxy/proxyEntry.ts

@@ -1,9 +1,16 @@
 import * as http from 'http';
 import * as https from 'https';
-import { PROXY_PORT, writeRateLimit } from './RateLimitCache';
+import {
+  PROXY_PORT,
+  parseModelRateLimitsFromBody,
+  writeModelRateLimit,
+  writeRateLimit,
+} from './RateLimitCache';
 
 const UPSTREAM_HOST = 'api.anthropic.com';
 
+const MAX_INSPECTED_BODY_BYTES = 1024 * 1024;
+
 const BEARER_PREFIX = 'bearer ';
 
 const extractToken = (
@@ -40,6 +47,22 @@ const startProxy = (port: number): void => {
           } catch (error) {
             console.error('Failed to write rate limit cache:', error);
           }
+          const inspectedChunks: Uint8Array[] = [];
+          let inspectedBytes = 0;
+          upstreamResponse.on('data', (chunk: Buffer) => {
+            if (inspectedBytes >= MAX_INSPECTED_BODY_BYTES) return;
+            inspectedChunks.push(new Uint8Array(chunk));
+            inspectedBytes += chunk.length;
+          });
+          upstreamResponse.on('end', () => {
+            try {
+              const body = Buffer.concat(inspectedChunks).toString('utf8');
+              const limits = parseModelRateLimitsFromBody(body);
+              writeModelRateLimit(token, limits);
+            } catch (error) {
+              console.error('Failed to write model rate limit cache:', error);
+            }
+          });
         }
         clientResponse.writeHead(
           upstreamResponse.statusCode ?? 502,

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

@@ -65,16 +65,24 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       expect(mockLoadTokens.mock.calls).toEqual([['/tokens.json']]);
     });
 
+    const futureReset = Math.floor(Date.now() / 1000) + 3600;
+    const pastReset = Math.floor(Date.now() / 1000) - 3600;
+
     it('should map each token to its cached utilization', async () => {
       mockLoadTokens.mockReturnValue(['token-a', 'token-b']);
       mockReadRateLimit.mockImplementation((token: string) => {
         if (token === 'token-a') {
           return {
             fiveHourUtilization: 42,
-            fiveHourReset: 0,
+            fiveHourReset: futureReset,
             sevenDayUtilization: 0,
-            sevenDayReset: 0,
+            sevenDayReset: futureReset,
             blocked: false,
+            rejected: false,
+            unifiedRejected: false,
+            fiveHourRejected: false,
+            sevenDayRejected: false,
+            modelWeeklyLimits: {},
           };
         }
         return null;
@@ -84,8 +92,20 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       const result = await repository.getAvailableTokenUsages();
 
       expect(result).toEqual([
-        { token: 'token-a', fiveHourUtilization: 42, blocked: false },
-        { token: 'token-b', fiveHourUtilization: 0, blocked: false },
+        {
+          token: 'token-a',
+          fiveHourUtilization: 42,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+        {
+          token: 'token-b',
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
       ]);
     });
 
@@ -93,17 +113,344 @@ describe('ProxyClaudeTokenUsageRepository', () => {
       mockLoadTokens.mockReturnValue(['token-a']);
       mockReadRateLimit.mockReturnValue({
         fiveHourUtilization: 5,
-        fiveHourReset: 0,
+        fiveHourReset: futureReset,
         sevenDayUtilization: 0,
-        sevenDayReset: 0,
+        sevenDayReset: futureReset,
         blocked: true,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 5,
+          blocked: true,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should propagate the rejected status from the cache', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 100,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: true,
+        unifiedRejected: false,
+        fiveHourRejected: true,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 100,
+          blocked: false,
+          rejected: true,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should normalize fiveHourUtilization to 0 when the 5h reset has passed', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 100,
+        fiveHourReset: pastReset,
+        sevenDayUtilization: 30,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should keep fiveHourUtilization when the 5h reset is in the future', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 95,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 95,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should clear a 5h-origin rejection once the 5h reset has passed', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 100,
+        fiveHourReset: pastReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: true,
+        unifiedRejected: false,
+        fiveHourRejected: true,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should clear a 7d-origin rejection once the 7d reset has passed', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 10,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 100,
+        sevenDayReset: pastReset,
+        blocked: false,
+        rejected: true,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: true,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 10,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should keep a 5h-origin rejection while the 5h reset is in the future', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 100,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: true,
+        unifiedRejected: false,
+        fiveHourRejected: true,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 100,
+          blocked: false,
+          rejected: true,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should keep a still-active 7d rejection after the 5h reset has passed', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 100,
+        fiveHourReset: pastReset,
+        sevenDayUtilization: 100,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: true,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: true,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: true,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should clear a unified rejection once the 5h reset has passed', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 100,
+        fiveHourReset: pastReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: true,
+        unifiedRejected: true,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should default rejected to false when no snapshot exists', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue(null);
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        },
+      ]);
+    });
+
+    it('should keep a model weekly rejection while its reset is in the future', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 5,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 10,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {
+          seven_day_sonnet: { rejected: true, resetsAt: futureReset },
+        },
+      });
+      const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
+
+      const result = await repository.getAvailableTokenUsages();
+
+      expect(result).toEqual([
+        {
+          token: 'token-a',
+          fiveHourUtilization: 5,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {
+            seven_day_sonnet: { rejected: true, resetsAt: futureReset },
+          },
+        },
+      ]);
+    });
+
+    it('should clear a model weekly rejection once its reset has passed', async () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 5,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 10,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {
+          seven_day_sonnet: { rejected: true, resetsAt: pastReset },
+        },
       });
       const repository = new ProxyClaudeTokenUsageRepository('/tokens.json');
 
       const result = await repository.getAvailableTokenUsages();
 
       expect(result).toEqual([
-        { token: 'token-a', fiveHourUtilization: 5, blocked: true },
+        {
+          token: 'token-a',
+          fiveHourUtilization: 5,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {
+            seven_day_sonnet: { rejected: false, resetsAt: pastReset },
+          },
+        },
       ]);
     });
   });

package/src/adapter/repositories/ProxyClaudeTokenUsageRepository.ts

@@ -22,12 +22,52 @@ export class ProxyClaudeTokenUsageRepository implements ClaudeTokenUsageReposito
     if (tokens === null) {
       return [];
     }
+    const nowEpochSeconds = Date.now() / 1000;
     return tokens.map((token) => {
       const snapshot = readRateLimit(token);
+      if (snapshot === null) {
+        return {
+          token,
+          fiveHourUtilization: 0,
+          blocked: false,
+          rejected: false,
+          modelWeeklyLimits: {},
+        };
+      }
+      const fiveHourExpired = nowEpochSeconds > snapshot.fiveHourReset;
+      const sevenDayExpired = nowEpochSeconds > snapshot.sevenDayReset;
+      const fiveHourUtilization = fiveHourExpired
+        ? 0
+        : snapshot.fiveHourUtilization;
+      const fiveHourRejectionActive =
+        snapshot.fiveHourRejected && !fiveHourExpired;
+      const sevenDayRejectionActive =
+        snapshot.sevenDayRejected && !sevenDayExpired;
+      const unifiedRejectionActive =
+        snapshot.unifiedRejected && !fiveHourExpired;
+      const rejected =
+        unifiedRejectionActive ||
+        fiveHourRejectionActive ||
+        sevenDayRejectionActive;
+      const modelWeeklyLimits: Record<
+        string,
+        { rejected: boolean; resetsAt: number }
+      > = {};
+      for (const [limitType, limit] of Object.entries(
+        snapshot.modelWeeklyLimits,
+      )) {
+        const expired = nowEpochSeconds > limit.resetsAt;
+        modelWeeklyLimits[limitType] = {
+          rejected: limit.rejected && !expired,
+          resetsAt: limit.resetsAt,
+        };
+      }
       return {
         token,
-        fiveHourUtilization: snapshot ? snapshot.fiveHourUtilization : 0,
-        blocked: snapshot?.blocked ?? false,
+        fiveHourUtilization,
+        blocked: snapshot.blocked,
+        rejected,
+        modelWeeklyLimits,
       };
     });
   };