github-issue-tower-defence-management 1.58.3 → 1.60.0

package/src/adapter/proxy/ClaudeMessageResponseParser.ts

@@ -0,0 +1,180 @@
+import * as http from 'http';
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+import { generateUlid } from '../repositories/SqliteClaudeMessageResponseRepository';
+
+const pickHeader = (
+  headers: http.IncomingHttpHeaders,
+  key: string,
+): string | null => {
+  const value = headers[key];
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
+};
+
+const parseNullableFloat = (value: string | null): number | null => {
+  if (value === null) return null;
+  const parsed = parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const parseNullableInt = (value: unknown): number | null => {
+  if (value === null || value === undefined) return null;
+  const parsed =
+    typeof value === 'number' ? value : parseInt(String(value), 10);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const extractUsage = (
+  body: Record<string, unknown>,
+): {
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheCreationInputTokens: number | null;
+  cacheReadInputTokens: number | null;
+  ephemeral5mInputTokens: number | null;
+  ephemeral1hInputTokens: number | null;
+} => {
+  const usage = body['usage'];
+  if (!isRecord(usage)) {
+    return {
+      inputTokens: null,
+      outputTokens: null,
+      cacheCreationInputTokens: null,
+      cacheReadInputTokens: null,
+      ephemeral5mInputTokens: null,
+      ephemeral1hInputTokens: null,
+    };
+  }
+  return {
+    inputTokens: parseNullableInt(usage['input_tokens']),
+    outputTokens: parseNullableInt(usage['output_tokens']),
+    cacheCreationInputTokens: parseNullableInt(
+      usage['cache_creation_input_tokens'],
+    ),
+    cacheReadInputTokens: parseNullableInt(usage['cache_read_input_tokens']),
+    ephemeral5mInputTokens: parseNullableInt(
+      usage['ephemeral_5m_input_tokens'],
+    ),
+    ephemeral1hInputTokens: parseNullableInt(
+      usage['ephemeral_1h_input_tokens'],
+    ),
+  };
+};
+
+const extractRole = (body: Record<string, unknown>): string | null => {
+  const role = body['role'];
+  return typeof role === 'string' ? role : null;
+};
+
+const extractFirstContentRole = (
+  body: Record<string, unknown>,
+): string | null => {
+  const content = body['content'];
+  if (!Array.isArray(content)) return null;
+  const first: unknown = content[0];
+  if (!isRecord(first)) return null;
+  const role = first['role'];
+  return typeof role === 'string' ? role : null;
+};
+
+export const parseClaudeMessageResponse = (
+  tokenName: string,
+  httpStatus: number,
+  headers: http.IncomingHttpHeaders,
+  body: string,
+): ClaudeMessageResponse => {
+  let parsedBody: Record<string, unknown> = {};
+  try {
+    const parsed: unknown = JSON.parse(body);
+    if (isRecord(parsed)) {
+      parsedBody = parsed;
+    }
+  } catch {
+    parsedBody = {};
+  }
+
+  const errorObj = parsedBody['error'];
+  const errorRecord = isRecord(errorObj) ? errorObj : null;
+  const errorType =
+    errorRecord !== null && typeof errorRecord['type'] === 'string'
+      ? errorRecord['type']
+      : null;
+  const errorMessage =
+    errorRecord !== null && typeof errorRecord['message'] === 'string'
+      ? errorRecord['message']
+      : null;
+
+  const externalClaudeMessageId =
+    typeof parsedBody['id'] === 'string' ? parsedBody['id'] : null;
+
+  const model =
+    typeof parsedBody['model'] === 'string' ? parsedBody['model'] : null;
+
+  const role = extractRole(parsedBody) ?? extractFirstContentRole(parsedBody);
+
+  const stopReason =
+    typeof parsedBody['stop_reason'] === 'string'
+      ? parsedBody['stop_reason']
+      : null;
+  const stopSequence =
+    typeof parsedBody['stop_sequence'] === 'string'
+      ? parsedBody['stop_sequence']
+      : null;
+
+  const usage = extractUsage(parsedBody);
+
+  const retryAfterRaw = pickHeader(headers, 'retry-after');
+  const retryAfter = parseNullableFloat(retryAfterRaw);
+
+  return {
+    id: generateUlid(),
+    observedAt: new Date(),
+    tokenName,
+    externalClaudeMessageId,
+    externalClaudeRequestId: pickHeader(headers, 'x-request-id'),
+    httpStatus,
+    model,
+    role,
+    stopReason,
+    stopSequence,
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens,
+    cacheReadInputTokens: usage.cacheReadInputTokens,
+    ephemeral5mInputTokens: usage.ephemeral5mInputTokens,
+    ephemeral1hInputTokens: usage.ephemeral1hInputTokens,
+    serviceTier: pickHeader(headers, 'anthropic-service-tier'),
+    inferenceGeo: pickHeader(headers, 'anthropic-inference-geo'),
+    errorType,
+    errorMessage,
+    anthropicRatelimitUnifiedStatus: pickHeader(
+      headers,
+      'anthropic-ratelimit-unified-status',
+    ),
+    anthropicRatelimitUnified5hStatus: pickHeader(
+      headers,
+      'anthropic-ratelimit-unified-5h-status',
+    ),
+    anthropicRatelimitUnified5hUtilization: parseNullableFloat(
+      pickHeader(headers, 'anthropic-ratelimit-unified-5h-utilization'),
+    ),
+    anthropicRatelimitUnified5hReset: parseNullableFloat(
+      pickHeader(headers, 'anthropic-ratelimit-unified-5h-reset'),
+    ),
+    anthropicRatelimitUnified7dStatus: pickHeader(
+      headers,
+      'anthropic-ratelimit-unified-7d-status',
+    ),
+    anthropicRatelimitUnified7dUtilization: parseNullableFloat(
+      pickHeader(headers, 'anthropic-ratelimit-unified-7d-utilization'),
+    ),
+    anthropicRatelimitUnified7dReset: parseNullableFloat(
+      pickHeader(headers, 'anthropic-ratelimit-unified-7d-reset'),
+    ),
+    retryAfter,
+    anthropicOrganizationId: pickHeader(headers, 'anthropic-organization-id'),
+  };
+};

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

@@ -220,6 +220,66 @@ describe('RateLimitCache', () => {
     });
   });
 
+  describe('writeRateLimit stores all anthropic-ratelimit-* headers', () => {
+    const isRecord = (value: unknown): value is Record<string, unknown> =>
+      value !== null && typeof value === 'object' && !Array.isArray(value);
+
+    const readStoredHeaders = (token: string): Record<string, unknown> => {
+      const filePath = cachePathForToken(token);
+      const raw: unknown = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      if (isRecord(raw) && isRecord(raw.headers)) {
+        return raw.headers;
+      }
+      return {};
+    };
+
+    it('should store any anthropic-ratelimit-* header present in the response', () => {
+      const token = 'extra-header-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': '10',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '5',
+        'anthropic-ratelimit-unified-reset': '1700000000',
+        'anthropic-ratelimit-requests-limit': '100',
+        'anthropic-ratelimit-requests-remaining': '99',
+        'content-type': 'application/json',
+      });
+      const storedHeaders = readStoredHeaders(token);
+      expect(storedHeaders['anthropic-ratelimit-unified-reset']).toBe(
+        '1700000000',
+      );
+      expect(storedHeaders['anthropic-ratelimit-requests-limit']).toBe('100');
+      expect(storedHeaders['anthropic-ratelimit-requests-remaining']).toBe(
+        '99',
+      );
+      expect(storedHeaders['content-type']).toBeUndefined();
+    });
+
+    it('should not store non-anthropic-ratelimit headers', () => {
+      const token = 'non-ratelimit-header-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': '10',
+        'anthropic-ratelimit-unified-7d-status': 'allowed',
+        'anthropic-ratelimit-unified-7d-reset': '1700100000',
+        'anthropic-ratelimit-unified-7d-utilization': '5',
+        'x-request-id': 'abc123',
+        'content-type': 'application/json',
+        'transfer-encoding': 'chunked',
+      });
+      const storedHeaders = readStoredHeaders(token);
+      expect(storedHeaders['x-request-id']).toBeUndefined();
+      expect(storedHeaders['content-type']).toBeUndefined();
+      expect(storedHeaders['transfer-encoding']).toBeUndefined();
+    });
+  });
+
   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

@@ -82,31 +82,18 @@ export const writeRateLimit = (
   };
   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));

package/src/adapter/proxy/proxyEntry.ts

@@ -2,10 +2,14 @@ import * as http from 'http';
 import * as https from 'https';
 import {
   PROXY_PORT,
+  hashToken,
   parseModelRateLimitsFromBody,
   writeModelRateLimit,
   writeRateLimit,
 } from './RateLimitCache';
+import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
+import { parseClaudeMessageResponse } from './ClaudeMessageResponseParser';
+import { SqliteClaudeMessageResponseRepository } from '../repositories/SqliteClaudeMessageResponseRepository';
 
 const UPSTREAM_HOST = 'api.anthropic.com';
 
@@ -25,7 +29,10 @@ const extractToken = (
   return token.length > 0 ? token : null;
 };
 
-const startProxy = (port: number): void => {
+const startProxy = (
+  port: number,
+  claudeMessageResponseRepository: ClaudeMessageResponseRepository | null = null,
+): void => {
   const server = http.createServer((clientRequest, clientResponse) => {
     const token = extractToken(clientRequest.headers['authorization']);
     const upstreamHeaders: Record<string, string | string[] | undefined> = {
@@ -55,13 +62,29 @@ const startProxy = (port: number): void => {
             inspectedBytes += chunk.length;
           });
           upstreamResponse.on('end', () => {
+            const body = Buffer.concat(inspectedChunks).toString('utf8');
             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);
             }
+            if (claudeMessageResponseRepository !== null) {
+              try {
+                const response = parseClaudeMessageResponse(
+                  hashToken(token),
+                  upstreamResponse.statusCode ?? 0,
+                  upstreamResponse.headers,
+                  body,
+                );
+                claudeMessageResponseRepository.append(response);
+              } catch (error) {
+                console.error(
+                  'Failed to record Claude message response:',
+                  error,
+                );
+              }
+            }
           });
         }
         clientResponse.writeHead(
@@ -86,7 +109,9 @@ const startProxy = (port: number): void => {
 };
 
 if (require.main === module) {
-  startProxy(PROXY_PORT);
+  const dbPath = './db/claude_message_response.db';
+  const repository = new SqliteClaudeMessageResponseRepository(dbPath);
+  startProxy(PROXY_PORT, repository);
 }
 
 export { startProxy, extractToken };

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

@@ -0,0 +1,101 @@
+const mockReadRateLimit = jest.fn();
+const mockLoadTokens = jest.fn();
+
+jest.mock('../proxy/RateLimitCache', () => ({
+  PROXY_PORT: 8787,
+  readRateLimit: mockReadRateLimit,
+}));
+
+jest.mock('../proxy/TokenListLoader', () => ({
+  loadTokens: mockLoadTokens,
+}));
+
+import { ProxyRateLimitCacheRepository } from './ProxyRateLimitCacheRepository';
+
+describe('ProxyRateLimitCacheRepository', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getTokenRateLimitCaches', () => {
+    it('should return an empty list when no token path is configured', () => {
+      const repository = new ProxyRateLimitCacheRepository(null);
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([]);
+      expect(mockLoadTokens).not.toHaveBeenCalled();
+    });
+
+    it('should return an empty list when the token list cannot be loaded', () => {
+      mockLoadTokens.mockReturnValue(null);
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([]);
+    });
+
+    const futureReset = Math.floor(Date.now() / 1000) + 3600;
+
+    it('should return fiveHourReset as unifiedReset for a token with a cached snapshot', () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue({
+        fiveHourUtilization: 42,
+        fiveHourReset: futureReset,
+        sevenDayUtilization: 0,
+        sevenDayReset: futureReset,
+        blocked: false,
+        rejected: false,
+        unifiedRejected: false,
+        fiveHourRejected: false,
+        sevenDayRejected: false,
+        modelWeeklyLimits: {},
+      });
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([{ token: 'token-a', unifiedReset: futureReset }]);
+    });
+
+    it('should return unifiedReset of 0 when no snapshot exists for a token', () => {
+      mockLoadTokens.mockReturnValue(['token-a']);
+      mockReadRateLimit.mockReturnValue(null);
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([{ token: 'token-a', unifiedReset: 0 }]);
+    });
+
+    it('should return entries for all tokens in the list', () => {
+      mockLoadTokens.mockReturnValue(['token-a', 'token-b']);
+      mockReadRateLimit.mockImplementation((token: string) => {
+        if (token === 'token-a') {
+          return {
+            fiveHourUtilization: 10,
+            fiveHourReset: futureReset,
+            sevenDayUtilization: 0,
+            sevenDayReset: futureReset,
+            blocked: false,
+            rejected: false,
+            unifiedRejected: false,
+            fiveHourRejected: false,
+            sevenDayRejected: false,
+            modelWeeklyLimits: {},
+          };
+        }
+        return null;
+      });
+      const repository = new ProxyRateLimitCacheRepository('/tokens.json');
+
+      const result = repository.getTokenRateLimitCaches();
+
+      expect(result).toEqual([
+        { token: 'token-a', unifiedReset: futureReset },
+        { token: 'token-b', unifiedReset: 0 },
+      ]);
+    });
+  });
+});

package/src/adapter/repositories/ProxyRateLimitCacheRepository.ts

@@ -0,0 +1,66 @@
+import * as http from 'http';
+import { RateLimitCacheRepository } from '../../domain/usecases/adapter-interfaces/RateLimitCacheRepository';
+import { TokenRateLimitCache } from '../../domain/usecases/adapter-interfaces/RateLimitCacheRepository';
+import { PROXY_PORT, readRateLimit } from '../proxy/RateLimitCache';
+import { loadTokens } from '../proxy/TokenListLoader';
+
+const HAIKU_MODEL = 'claude-haiku-4-5';
+
+const PROBE_REQUEST_BODY = JSON.stringify({
+  model: HAIKU_MODEL,
+  max_tokens: 1,
+  messages: [{ role: 'user', content: 'hi' }],
+});
+
+export class ProxyRateLimitCacheRepository implements RateLimitCacheRepository {
+  constructor(
+    private readonly tokenListJsonPath: string | null,
+    private readonly port: number = PROXY_PORT,
+  ) {}
+
+  getTokenRateLimitCaches = (): TokenRateLimitCache[] => {
+    if (this.tokenListJsonPath === null) {
+      return [];
+    }
+    const tokens = loadTokens(this.tokenListJsonPath);
+    if (tokens === null) {
+      return [];
+    }
+    return tokens.map((token) => {
+      const snapshot = readRateLimit(token);
+      const unifiedReset = snapshot !== null ? snapshot.fiveHourReset : 0;
+      return { token, unifiedReset };
+    });
+  };
+
+  probeToken = async (token: string): Promise<void> => {
+    await new Promise<void>((resolve) => {
+      const request = http.request(
+        {
+          host: '127.0.0.1',
+          port: this.port,
+          method: 'POST',
+          path: '/v1/messages',
+          headers: {
+            'content-type': 'application/json',
+            'anthropic-version': '2023-06-01',
+            authorization: `Bearer ${token}`,
+            'content-length': Buffer.byteLength(PROBE_REQUEST_BODY),
+          },
+        },
+        (response) => {
+          response.resume();
+          response.on('end', () => resolve());
+        },
+      );
+      request.on('error', (error) => {
+        console.error(
+          `[UpdateRateLimitCache] Probe request failed for token hash: ${error.message}`,
+        );
+        resolve();
+      });
+      request.write(PROBE_REQUEST_BODY);
+      request.end();
+    });
+  };
+}