github-issue-tower-defence-management 1.126.3 → 1.128.0

package/src/adapter/entry-points/handlers/LiveSessionOauthTokenSelectHandler.ts

@@ -9,7 +9,7 @@ import {
   SEVEN_DAY_MIN_FREE_RATIO,
 } from '../../../domain/usecases/OauthTokenSelectUseCase';
 import { ProcClaudeLiveSessionRepository } from '../../repositories/ProcClaudeLiveSessionRepository';
-import { readRateLimit } from '../../proxy/RateLimitCache';
+import { FABLE_LIMIT_TYPE, readRateLimit } from '../../proxy/RateLimitCache';
 import { loadTokenEntries } from '../../proxy/TokenListLoader';
 import {
   resolveCacheDirectory,
@@ -63,6 +63,11 @@ export class LiveSessionOauthTokenSelectHandler {
 
     const candidates: OauthTokenCandidate[] = entries.map(({ name, token }) => {
       const snapshot = readRateLimit(token, cacheDirectory);
+      const fableLimit = snapshot?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      const fableRejected =
+        fableLimit !== undefined &&
+        fableLimit.rejected &&
+        input.nowEpochSeconds <= fableLimit.resetsAt;
       return {
         name,
         token,
@@ -77,6 +82,7 @@ export class LiveSessionOauthTokenSelectHandler {
               },
         subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
         unifiedRejected: snapshot?.unifiedRejected ?? false,
+        fableRejected,
       };
     });
 

package/src/adapter/entry-points/handlers/OauthTokenSelectHandler.test.ts

@@ -1,7 +1,7 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { hashToken } from '../../proxy/RateLimitCache';
+import { FABLE_LIMIT_TYPE, hashToken } from '../../proxy/RateLimitCache';
 import {
   OauthTokenSelectHandler,
   resolveCacheDirectory,
@@ -100,6 +100,28 @@ describe('OauthTokenSelectHandler', () => {
     );
   };
 
+  const writeFableRejectionCache = (token: string, resetsAt: number): void => {
+    const payload = {
+      ts: NOW,
+      headers: {
+        'anthropic-ratelimit-unified-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-status': 'allowed',
+        'anthropic-ratelimit-unified-5h-reset': String(NOW + HOUR),
+        'anthropic-ratelimit-unified-5h-utilization': '0.1',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': String(NOW + DAY),
+        'anthropic-ratelimit-unified-7d-utilization': '0.1',
+      },
+      modelWeeklyLimits: {
+        [FABLE_LIMIT_TYPE]: { rejected: true, resetsAt },
+      },
+    };
+    fs.writeFileSync(
+      path.join(cacheDirectory, `${hashToken(token)}.json`),
+      JSON.stringify(payload),
+    );
+  };
+
   it('selects the eligible token with the soonest 7d reset', () => {
     writeTokenList([
       { name: 'far', token: 'fake-far' },
@@ -248,6 +270,48 @@ describe('OauthTokenSelectHandler', () => {
     expect(output.diagnostics.join('\n')).toContain('rejected');
   });
 
+  it('excludes a token whose fable marker is set and not yet expired', () => {
+    writeTokenList([
+      { name: 'fable-out', token: 'fake-fable-out' },
+      { name: 'active', token: 'fake-active' },
+    ]);
+    writeFableRejectionCache('fake-fable-out', NOW + HOUR);
+    writeCache('fake-active', {
+      fiveHourUtilization: 0.1,
+      fiveHourReset: NOW + HOUR,
+      sevenDayUtilization: 0.1,
+      sevenDayReset: NOW + DAY,
+    });
+
+    const handler = new OauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+
+    expect(output.selectedName).toBe('active');
+    expect(output.diagnostics.join('\n')).toContain(
+      'fable weekly limit exhausted',
+    );
+  });
+
+  it('treats a token whose fable marker has expired as usable', () => {
+    writeTokenList([
+      { name: 'fable-recovered', token: 'fake-fable-recovered' },
+    ]);
+    writeFableRejectionCache('fake-fable-recovered', NOW - HOUR);
+
+    const handler = new OauthTokenSelectHandler();
+    const output = handler.handle({
+      tokenListJsonPath: tokenListPath,
+      cacheDirectory,
+      nowEpochSeconds: NOW,
+    });
+
+    expect(output.selectedName).toBe('fable-recovered');
+  });
+
   it('does not exclude a token solely because overage is disabled', () => {
     writeTokenList([{ name: 'overage', token: 'fake-overage' }]);
     writeCacheWithHeaders('fake-overage', {

package/src/adapter/entry-points/handlers/OauthTokenSelectHandler.ts

@@ -3,7 +3,11 @@ import {
   OauthTokenSelectResult,
   OauthTokenSelectUseCase,
 } from '../../../domain/usecases/OauthTokenSelectUseCase';
-import { cacheDir, readRateLimit } from '../../proxy/RateLimitCache';
+import {
+  FABLE_LIMIT_TYPE,
+  cacheDir,
+  readRateLimit,
+} from '../../proxy/RateLimitCache';
 import { loadTokenEntries } from '../../proxy/TokenListLoader';
 
 export type OauthTokenSelectHandlerInput = {
@@ -81,6 +85,11 @@ export class OauthTokenSelectHandler {
 
     const candidates: OauthTokenCandidate[] = entries.map(({ name, token }) => {
       const snapshot = readRateLimit(token, cacheDirectory);
+      const fableLimit = snapshot?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      const fableRejected =
+        fableLimit !== undefined &&
+        fableLimit.rejected &&
+        input.nowEpochSeconds <= fableLimit.resetsAt;
       return {
         name,
         token,
@@ -95,6 +104,7 @@ export class OauthTokenSelectHandler {
               },
         subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
         unifiedRejected: snapshot?.unifiedRejected ?? false,
+        fableRejected,
       };
     });
 

package/src/adapter/entry-points/handlers/tokenStatusWriter.ts

@@ -199,6 +199,7 @@ export const writeTokenStatus = (params: TokenStatusWriterParams): void => {
     snapshot: null,
     subscriptionDisabled: false,
     unifiedRejected: false,
+    fableRejected: false,
   }));
   const machineWideInTmuxByHumanIssues: Issue[] = [
     ...machineWideInTmuxByHumanUrls,

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

@@ -4,13 +4,17 @@ import * as path from 'path';
 import {
   cacheDir,
   cachePathForToken,
+  FABLE_LIMIT_TYPE,
   hashToken,
   HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS,
   HEADERLESS_429_MAX_COOLDOWN_SECONDS,
+  isFableModel,
   parseModelRateLimitsFromBody,
   parseModelRateLimitsFromHeaders,
+  parseSevenDayRejection,
   PERMISSION_DISABLED_COOLDOWN_SECONDS,
   readRateLimit,
+  writeFableRejection,
   writeModelRateLimit,
   writeRateLimit,
   writeSubscriptionDisabled,
@@ -699,6 +703,149 @@ describe('RateLimitCache', () => {
     });
   });
 
+  describe('isFableModel', () => {
+    it('should return true for the fable model id', () => {
+      expect(isFableModel('claude-fable-5')).toBe(true);
+    });
+
+    it('should be case insensitive', () => {
+      expect(isFableModel('Claude-FABLE-5')).toBe(true);
+    });
+
+    it('should return false for sonnet and opus models', () => {
+      expect(isFableModel('claude-sonnet-4-6')).toBe(false);
+      expect(isFableModel('claude-opus-4-8')).toBe(false);
+    });
+
+    it('should return false for a null model', () => {
+      expect(isFableModel(null)).toBe(false);
+    });
+  });
+
+  describe('writeFableRejection', () => {
+    it('should persist a rejected fable weekly limit readable by readRateLimit', () => {
+      const token = 'fable-rejection-token';
+      const nowEpochSeconds = Date.now() / 1000;
+      writeFableRejection(token, 120);
+      const snapshot = readRateLimit(token);
+      const fableLimit = snapshot?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      expect(fableLimit?.rejected).toBe(true);
+      expect(fableLimit?.resetsAt).toBeGreaterThanOrEqual(
+        nowEpochSeconds + 120,
+      );
+      expect(fableLimit?.resetsAt).toBeLessThanOrEqual(
+        nowEpochSeconds + 120 + 5,
+      );
+    });
+
+    it('should cap the reset from an oversized retry-after at the max cooldown', () => {
+      const token = 'fable-rejection-cap-token';
+      const nowEpochSeconds = Date.now() / 1000;
+      writeFableRejection(token, HEADERLESS_429_MAX_COOLDOWN_SECONDS + 10_000);
+      const fableLimit =
+        readRateLimit(token)?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      expect(fableLimit?.resetsAt).toBeLessThanOrEqual(
+        nowEpochSeconds + HEADERLESS_429_MAX_COOLDOWN_SECONDS + 5,
+      );
+    });
+
+    it('should use the default cooldown when retry-after is absent', () => {
+      const token = 'fable-rejection-default-token';
+      const nowEpochSeconds = Date.now() / 1000;
+      writeFableRejection(token, null);
+      const fableLimit =
+        readRateLimit(token)?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      expect(fableLimit?.resetsAt).toBeGreaterThanOrEqual(
+        nowEpochSeconds + HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS,
+      );
+      expect(fableLimit?.resetsAt).toBeLessThanOrEqual(
+        nowEpochSeconds + HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS + 5,
+      );
+    });
+
+    it('should preserve other model weekly limits already recorded', () => {
+      const token = 'fable-rejection-merge-token';
+      writeModelRateLimit(token, {
+        seven_day_sonnet: { rejected: true, resetsAt: 1779642000 },
+      });
+      writeFableRejection(token, 90);
+      const limits = readRateLimit(token)?.modelWeeklyLimits;
+      expect(limits?.seven_day_sonnet).toEqual({
+        rejected: true,
+        resetsAt: 1779642000,
+      });
+      expect(limits?.[FABLE_LIMIT_TYPE]?.rejected).toBe(true);
+    });
+
+    it('should use the seven-day reset for resetsAt when provided instead of the retry-after cooldown', () => {
+      const token = 'fable-rejection-sevenday-reset-token';
+      const sevenDayReset = 1893456000;
+      writeFableRejection(token, 120, sevenDayReset);
+      const fableLimit =
+        readRateLimit(token)?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      expect(fableLimit?.rejected).toBe(true);
+      expect(fableLimit?.resetsAt).toBe(sevenDayReset);
+    });
+
+    it('should fall back to the retry-after cooldown when the seven-day reset is null', () => {
+      const token = 'fable-rejection-null-reset-token';
+      const nowEpochSeconds = Date.now() / 1000;
+      writeFableRejection(token, 120, null);
+      const fableLimit =
+        readRateLimit(token)?.modelWeeklyLimits[FABLE_LIMIT_TYPE];
+      expect(fableLimit?.resetsAt).toBeGreaterThanOrEqual(
+        nowEpochSeconds + 120,
+      );
+      expect(fableLimit?.resetsAt).toBeLessThanOrEqual(
+        nowEpochSeconds + 120 + 5,
+      );
+    });
+  });
+
+  describe('parseSevenDayRejection', () => {
+    it('should report a rejection and the reset epoch when the 7-day status is rejected', () => {
+      expect(
+        parseSevenDayRejection({
+          'anthropic-ratelimit-unified-7d-status': 'rejected',
+          'anthropic-ratelimit-unified-7d-reset': '1893456000',
+        }),
+      ).toEqual({ sevenDayRejected: true, sevenDayReset: 1893456000 });
+    });
+
+    it('should report no rejection when only the 5-hour status is rejected', () => {
+      expect(
+        parseSevenDayRejection({
+          'anthropic-ratelimit-unified-5h-status': 'rejected',
+          'anthropic-ratelimit-unified-7d-status': 'allowed',
+        }),
+      ).toEqual({ sevenDayRejected: false, sevenDayReset: null });
+    });
+
+    it('should report no rejection when no rate-limit headers are present', () => {
+      expect(parseSevenDayRejection({})).toEqual({
+        sevenDayRejected: false,
+        sevenDayReset: null,
+      });
+    });
+
+    it('should return a null reset when the 7-day status is rejected but no reset header is present', () => {
+      expect(
+        parseSevenDayRejection({
+          'anthropic-ratelimit-unified-7d-status': 'rejected',
+        }),
+      ).toEqual({ sevenDayRejected: true, sevenDayReset: null });
+    });
+
+    it('should pick the first value when a header is an array', () => {
+      expect(
+        parseSevenDayRejection({
+          'anthropic-ratelimit-unified-7d-status': ['rejected', 'allowed'],
+          'anthropic-ratelimit-unified-7d-reset': ['1893456000'],
+        }),
+      ).toEqual({ sevenDayRejected: true, sevenDayReset: 1893456000 });
+    });
+  });
+
   describe('parseModelRateLimitsFromHeaders', () => {
     it('should extract a rejected seven_day_sonnet limit from the per-model unified headers', () => {
       expect(
@@ -915,6 +1062,7 @@ describe('RateLimitCache', () => {
                   },
             subscriptionDisabled: snapshot?.subscriptionDisabled ?? false,
             unifiedRejected: snapshot?.unifiedRejected ?? false,
+            fableRejected: false,
           },
         ],
         Date.now() / 1000,

package/src/adapter/proxy/RateLimitCache.ts

@@ -28,6 +28,8 @@ export interface RateLimitSnapshot {
 
 export const PROXY_PORT = 8787;
 
+export const FABLE_LIMIT_TYPE = 'seven_day_fable';
+
 const HASH_ALGORITHM = 'sha256';
 
 export const HEADERLESS_429_DEFAULT_COOLDOWN_SECONDS = 90;
@@ -36,6 +38,12 @@ export const HEADERLESS_429_MAX_COOLDOWN_SECONDS = 600;
 
 export const PERMISSION_DISABLED_COOLDOWN_SECONDS = 3600;
 
+const FIVE_HOUR_STATUS_HEADER = 'anthropic-ratelimit-unified-5h-status';
+
+const SEVEN_DAY_STATUS_HEADER = 'anthropic-ratelimit-unified-7d-status';
+
+const SEVEN_DAY_RESET_HEADER = 'anthropic-ratelimit-unified-7d-reset';
+
 export const cacheDir = (): string => {
   const base = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
   return path.join(base, 'tdpm', 'ratelimit');
@@ -182,6 +190,51 @@ export const writeModelRateLimit = (
   fs.writeFileSync(filePath, JSON.stringify(payload));
 };
 
+export const isFableModel = (modelName: string | null): boolean =>
+  (modelName ?? '').toLowerCase().includes('fable');
+
+export interface SevenDayRejectionSignal {
+  sevenDayRejected: boolean;
+  sevenDayReset: number | null;
+}
+
+const pickHeaderValue = (
+  headers: Record<string, string | string[] | undefined>,
+  key: string,
+): string | undefined => {
+  const value = headers[key];
+  return Array.isArray(value) ? value[0] : value;
+};
+
+export const parseSevenDayRejection = (
+  headers: Record<string, string | string[] | undefined>,
+): SevenDayRejectionSignal => {
+  const status = pickHeaderValue(headers, SEVEN_DAY_STATUS_HEADER);
+  const resetRaw = pickHeaderValue(headers, SEVEN_DAY_RESET_HEADER);
+  const sevenDayReset =
+    resetRaw !== undefined && Number.isFinite(Number(resetRaw))
+      ? Number(resetRaw)
+      : null;
+  return {
+    sevenDayRejected: status === 'rejected',
+    sevenDayReset,
+  };
+};
+
+export const writeFableRejection = (
+  token: string,
+  retryAfterSeconds: number | null,
+  sevenDayReset: number | null = null,
+): void => {
+  const resetsAt =
+    sevenDayReset !== null && sevenDayReset > 0
+      ? sevenDayReset
+      : cooldownEndFromRetryAfter(retryAfterSeconds, Date.now() / 1000);
+  writeModelRateLimit(token, {
+    [FABLE_LIMIT_TYPE]: { rejected: true, resetsAt },
+  });
+};
+
 export const writeSubscriptionDisabled = (
   token: string,
   baseDir: string = cacheDir(),
@@ -283,8 +336,8 @@ export const readRateLimit = (
       return Number.isFinite(parsedValue) ? parsedValue : 0;
     };
     const status = headers['anthropic-ratelimit-unified-status'];
-    const fiveHourStatus = headers['anthropic-ratelimit-unified-5h-status'];
-    const sevenDayStatus = headers['anthropic-ratelimit-unified-7d-status'];
+    const fiveHourStatus = headers[FIVE_HOUR_STATUS_HEADER];
+    const sevenDayStatus = headers[SEVEN_DAY_STATUS_HEADER];
     const overageDisabledReason =
       headers['anthropic-ratelimit-unified-overage-disabled-reason'];
     const unifiedRejected = status === 'rejected';
@@ -309,7 +362,7 @@ export const readRateLimit = (
       fiveHourUtilization: num('anthropic-ratelimit-unified-5h-utilization'),
       fiveHourReset: num('anthropic-ratelimit-unified-5h-reset'),
       sevenDayUtilization: num('anthropic-ratelimit-unified-7d-utilization'),
-      sevenDayReset: num('anthropic-ratelimit-unified-7d-reset'),
+      sevenDayReset: num(SEVEN_DAY_RESET_HEADER),
       blocked:
         status === 'blocked' ||
         fiveHourStatus === 'blocked' ||

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

@@ -103,6 +103,7 @@ describe('startProxy', () => {
   let proxyPort = 0;
   let writeRateLimitSpy: jest.SpyInstance;
   let writeModelRateLimitSpy: jest.SpyInstance;
+  let writeFableRejectionSpy: jest.SpyInstance;
 
   const listen = (server: http.Server): Promise<number> =>
     new Promise((resolve) => {
@@ -191,6 +192,9 @@ describe('startProxy', () => {
     writeModelRateLimitSpy = jest
       .spyOn(RateLimitCache, 'writeModelRateLimit')
       .mockImplementation(() => undefined);
+    writeFableRejectionSpy = jest
+      .spyOn(RateLimitCache, 'writeFableRejection')
+      .mockImplementation(() => undefined);
 
     proxyPort = await new Promise<number>((resolve) => {
       const probe = http.createServer();
@@ -207,6 +211,7 @@ describe('startProxy', () => {
     httpsRequestImpl = null;
     writeRateLimitSpy.mockRestore();
     writeModelRateLimitSpy.mockRestore();
+    writeFableRejectionSpy.mockRestore();
     await closeServer(proxyServer);
     await closeServer(upstreamServer);
   });
@@ -308,6 +313,127 @@ describe('startProxy', () => {
     );
   });
 
+  it('should mark the fable weekly limit when a fable 429 carries a rejected 7-day status, using the 7-day reset', async () => {
+    const sevenDayReset = 1893456000;
+    upstreamHandler = (_request, response) => {
+      response.writeHead(429, {
+        'content-type': 'application/json',
+        'retry-after': '120',
+        'anthropic-ratelimit-unified-7d-status': 'rejected',
+        'anthropic-ratelimit-unified-7d-reset': String(sevenDayReset),
+      });
+      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
+    };
+
+    const response = await requestThroughProxy(
+      'POST',
+      '/v1/messages',
+      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
+    );
+
+    expect(response.statusCode).toBe(429);
+    expect(writeFableRejectionSpy).toHaveBeenCalledTimes(1);
+    expect(writeFableRejectionSpy).toHaveBeenCalledWith(
+      TOKEN,
+      120,
+      sevenDayReset,
+    );
+  });
+
+  it('should fall back to retry-after for the reset when a rejected 7-day status carries no 7-day reset header', async () => {
+    upstreamHandler = (_request, response) => {
+      response.writeHead(429, {
+        'content-type': 'application/json',
+        'retry-after': '120',
+        'anthropic-ratelimit-unified-7d-status': 'rejected',
+      });
+      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
+    };
+
+    const response = await requestThroughProxy(
+      'POST',
+      '/v1/messages',
+      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
+    );
+
+    expect(response.statusCode).toBe(429);
+    expect(writeFableRejectionSpy).toHaveBeenCalledTimes(1);
+    expect(writeFableRejectionSpy).toHaveBeenCalledWith(TOKEN, 120, null);
+  });
+
+  it('should not mark the fable weekly limit when a fable 429 is a 5-hour rejection without a 7-day rejection', async () => {
+    upstreamHandler = (_request, response) => {
+      response.writeHead(429, {
+        'content-type': 'application/json',
+        'retry-after': '120',
+        'anthropic-ratelimit-unified-5h-status': 'rejected',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+      });
+      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
+    };
+
+    const response = await requestThroughProxy(
+      'POST',
+      '/v1/messages',
+      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
+    );
+
+    expect(response.statusCode).toBe(429);
+    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
+  });
+
+  it('should not mark the fable weekly limit when a fable 429 carries no rate-limit rejection headers', 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',
+      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
+    );
+
+    expect(response.statusCode).toBe(429);
+    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
+  });
+
+  it('should not mark the fable weekly limit when a non-fable request is rejected with a 7-day-rejected 429', async () => {
+    upstreamHandler = (_request, response) => {
+      response.writeHead(429, {
+        'content-type': 'application/json',
+        'anthropic-ratelimit-unified-7d-status': 'rejected',
+        'anthropic-ratelimit-unified-7d-reset': '1893456000',
+      });
+      response.end('{"type":"error","error":{"type":"rate_limit_error"}}');
+    };
+
+    const response = await requestThroughProxy(
+      'POST',
+      '/v1/messages',
+      JSON.stringify({ model: 'claude-sonnet-4-6', messages: [] }),
+    );
+
+    expect(response.statusCode).toBe(429);
+    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
+  });
+
+  it('should not mark the fable weekly limit when a fable request succeeds', async () => {
+    upstreamHandler = (_request, response) => {
+      response.writeHead(200, { 'content-type': 'application/json' });
+      response.end('{"model":"claude-fable-5"}');
+    };
+
+    const response = await requestThroughProxy(
+      'POST',
+      '/v1/messages',
+      JSON.stringify({ model: 'claude-fable-5', messages: [] }),
+    );
+
+    expect(response.statusCode).toBe(200);
+    expect(writeFableRejectionSpy).not.toHaveBeenCalled();
+  });
+
   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

@@ -3,7 +3,10 @@ import * as https from 'https';
 import {
   PROXY_PORT,
   hashToken,
+  isFableModel,
   parseModelRateLimitsFromBody,
+  parseSevenDayRejection,
+  writeFableRejection,
   writeModelRateLimit,
   writeRateLimit,
   writeSubscriptionDisabled,
@@ -46,12 +49,49 @@ const isPermissionError = (body: string): boolean => {
   return error.type === 'permission_error';
 };
 
+const matchModelInBody = (requestBody: string): string | null => {
+  const match = requestBody.match(/"model"\s*:\s*"([^"]+)"/);
+  return match !== null ? match[1] : null;
+};
+
+const extractRequestModel = (requestBody: string): string | null => {
+  try {
+    const parsed: unknown = JSON.parse(requestBody);
+    if (isRecord(parsed) && typeof parsed.model === 'string') {
+      return parsed.model;
+    }
+    return null;
+  } catch {
+    return matchModelInBody(requestBody);
+  }
+};
+
+const parseRetryAfterSeconds = (
+  headers: http.IncomingHttpHeaders,
+): number | null => {
+  const raw = headers['retry-after'];
+  const value =
+    typeof raw === 'string' ? raw : Array.isArray(raw) ? raw[0] : null;
+  if (typeof value !== 'string') return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
 const startProxy = (
   port: number,
   claudeMessageResponseRepository: ClaudeMessageResponseRepository | null = null,
 ): http.Server => {
   const server = http.createServer((clientRequest, clientResponse) => {
     const token = extractToken(clientRequest.headers['authorization']);
+    const requestChunks: Uint8Array[] = [];
+    let requestBytes = 0;
+    if (token !== null) {
+      clientRequest.on('data', (chunk: Buffer) => {
+        if (requestBytes >= MAX_INSPECTED_BODY_BYTES) return;
+        requestChunks.push(new Uint8Array(chunk));
+        requestBytes += chunk.length;
+      });
+    }
     const upstreamHeaders: Record<string, string | string[] | undefined> = {
       ...clientRequest.headers,
       host: UPSTREAM_HOST,
@@ -105,6 +145,26 @@ const startProxy = (
                 );
               }
             }
+            if (upstreamResponse.statusCode === 429) {
+              try {
+                const requestModel = extractRequestModel(
+                  Buffer.concat(requestChunks).toString('utf8'),
+                );
+                if (isFableModel(requestModel)) {
+                  const { sevenDayRejected, sevenDayReset } =
+                    parseSevenDayRejection(upstreamResponse.headers);
+                  if (sevenDayRejected) {
+                    writeFableRejection(
+                      token,
+                      parseRetryAfterSeconds(upstreamResponse.headers),
+                      sevenDayReset,
+                    );
+                  }
+                }
+              } catch (error) {
+                console.error('Failed to write fable rejection cache:', error);
+              }
+            }
             if (claudeMessageResponseRepository !== null) {
               try {
                 const response = parseClaudeMessageResponse(