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

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

@@ -0,0 +1,211 @@
+import { parseClaudeMessageResponse } from './ClaudeMessageResponseParser';
+
+const SUCCESS_BODY = JSON.stringify({
+  id: 'msg_01XFDUDYJgAACTvykiHMn8xy',
+  type: 'message',
+  role: 'assistant',
+  model: 'claude-sonnet-4-5',
+  stop_reason: 'end_turn',
+  stop_sequence: null,
+  usage: {
+    input_tokens: 100,
+    output_tokens: 50,
+    cache_creation_input_tokens: null,
+    cache_read_input_tokens: null,
+  },
+});
+
+const ERROR_BODY = JSON.stringify({
+  type: 'error',
+  error: {
+    type: 'rate_limit_error',
+    message: 'Too many requests',
+  },
+});
+
+const SUCCESS_HEADERS = {
+  'x-request-id': 'req_01234',
+  'anthropic-ratelimit-unified-status': 'active',
+  'anthropic-ratelimit-unified-5h-status': 'active',
+  'anthropic-ratelimit-unified-5h-utilization': '42.5',
+  'anthropic-ratelimit-unified-5h-reset': '1705316200',
+  'anthropic-ratelimit-unified-7d-status': 'active',
+  'anthropic-ratelimit-unified-7d-utilization': '10.0',
+  'anthropic-ratelimit-unified-7d-reset': '1705920000',
+  'anthropic-organization-id': 'org-abc123',
+  'anthropic-service-tier': 'standard',
+};
+
+describe('parseClaudeMessageResponse', () => {
+  it('parses a successful 200 response with all fields', () => {
+    const result = parseClaudeMessageResponse(
+      'hashed-token',
+      200,
+      SUCCESS_HEADERS,
+      SUCCESS_BODY,
+    );
+
+    expect(result.tokenName).toBe('hashed-token');
+    expect(result.httpStatus).toBe(200);
+    expect(result.externalClaudeMessageId).toBe('msg_01XFDUDYJgAACTvykiHMn8xy');
+    expect(result.externalClaudeRequestId).toBe('req_01234');
+    expect(result.model).toBe('claude-sonnet-4-5');
+    expect(result.role).toBe('assistant');
+    expect(result.stopReason).toBe('end_turn');
+    expect(result.stopSequence).toBeNull();
+    expect(result.inputTokens).toBe(100);
+    expect(result.outputTokens).toBe(50);
+    expect(result.cacheCreationInputTokens).toBeNull();
+    expect(result.cacheReadInputTokens).toBeNull();
+    expect(result.serviceTier).toBe('standard');
+    expect(result.errorType).toBeNull();
+    expect(result.errorMessage).toBeNull();
+    expect(result.anthropicRatelimitUnifiedStatus).toBe('active');
+    expect(result.anthropicRatelimitUnified5hStatus).toBe('active');
+    expect(result.anthropicRatelimitUnified5hUtilization).toBe(42.5);
+    expect(result.anthropicRatelimitUnified5hReset).toBe(1705316200);
+    expect(result.anthropicRatelimitUnified7dStatus).toBe('active');
+    expect(result.anthropicRatelimitUnified7dUtilization).toBe(10.0);
+    expect(result.anthropicRatelimitUnified7dReset).toBe(1705920000);
+    expect(result.retryAfter).toBeNull();
+    expect(result.anthropicOrganizationId).toBe('org-abc123');
+  });
+
+  it('assigns a non-empty ULID as id', () => {
+    const result = parseClaudeMessageResponse('tok', 200, {}, '{}');
+    expect(result.id).toHaveLength(26);
+    expect(/^[0-9A-HJKMNP-TV-Z]{26}$/.test(result.id)).toBe(true);
+  });
+
+  it('sets observedAt to a recent Date', () => {
+    const before = Date.now();
+    const result = parseClaudeMessageResponse('tok', 200, {}, '{}');
+    const after = Date.now();
+    expect(result.observedAt.getTime()).toBeGreaterThanOrEqual(before);
+    expect(result.observedAt.getTime()).toBeLessThanOrEqual(after);
+  });
+
+  it('parses an error response body', () => {
+    const result = parseClaudeMessageResponse(
+      'hashed-token',
+      429,
+      { 'retry-after': '30' },
+      ERROR_BODY,
+    );
+
+    expect(result.httpStatus).toBe(429);
+    expect(result.errorType).toBe('rate_limit_error');
+    expect(result.errorMessage).toBe('Too many requests');
+    expect(result.retryAfter).toBe(30);
+    expect(result.model).toBeNull();
+    expect(result.role).toBeNull();
+    expect(result.stopReason).toBeNull();
+    expect(result.inputTokens).toBeNull();
+    expect(result.outputTokens).toBeNull();
+  });
+
+  it('returns null for missing body fields when body is empty object', () => {
+    const result = parseClaudeMessageResponse('tok', 200, {}, '{}');
+
+    expect(result.externalClaudeMessageId).toBeNull();
+    expect(result.model).toBeNull();
+    expect(result.role).toBeNull();
+    expect(result.stopReason).toBeNull();
+    expect(result.stopSequence).toBeNull();
+    expect(result.inputTokens).toBeNull();
+    expect(result.outputTokens).toBeNull();
+  });
+
+  it('returns null for rate limit headers when they are absent', () => {
+    const result = parseClaudeMessageResponse('tok', 200, {}, '{}');
+
+    expect(result.anthropicRatelimitUnifiedStatus).toBeNull();
+    expect(result.anthropicRatelimitUnified5hStatus).toBeNull();
+    expect(result.anthropicRatelimitUnified5hUtilization).toBeNull();
+    expect(result.anthropicRatelimitUnified5hReset).toBeNull();
+    expect(result.anthropicOrganizationId).toBeNull();
+    expect(result.retryAfter).toBeNull();
+  });
+
+  it('handles non-JSON body gracefully by leaving body fields null', () => {
+    const result = parseClaudeMessageResponse(
+      'tok',
+      200,
+      {},
+      'this is not json',
+    );
+
+    expect(result.externalClaudeMessageId).toBeNull();
+    expect(result.model).toBeNull();
+    expect(result.inputTokens).toBeNull();
+  });
+
+  it('handles empty body string gracefully', () => {
+    const result = parseClaudeMessageResponse('tok', 200, {}, '');
+
+    expect(result.externalClaudeMessageId).toBeNull();
+    expect(result.model).toBeNull();
+  });
+
+  it('picks the first value when a header is an array', () => {
+    const result = parseClaudeMessageResponse(
+      'tok',
+      200,
+      { 'x-request-id': ['req-first', 'req-second'] },
+      '{}',
+    );
+
+    expect(result.externalClaudeRequestId).toBe('req-first');
+  });
+
+  it('parses cache token fields from usage', () => {
+    const body = JSON.stringify({
+      id: 'msg_cache',
+      role: 'assistant',
+      model: 'claude-sonnet-4-5',
+      stop_reason: 'end_turn',
+      usage: {
+        input_tokens: 200,
+        output_tokens: 80,
+        cache_creation_input_tokens: 150,
+        cache_read_input_tokens: 50,
+      },
+    });
+
+    const result = parseClaudeMessageResponse('tok', 200, {}, body);
+
+    expect(result.cacheCreationInputTokens).toBe(150);
+    expect(result.cacheReadInputTokens).toBe(50);
+  });
+
+  it('parses ephemeral token fields from usage', () => {
+    const body = JSON.stringify({
+      id: 'msg_ephemeral',
+      role: 'assistant',
+      model: 'claude-sonnet-4-5',
+      stop_reason: 'end_turn',
+      usage: {
+        input_tokens: 300,
+        output_tokens: 120,
+        ephemeral_5m_input_tokens: 100,
+        ephemeral_1h_input_tokens: 200,
+      },
+    });
+
+    const result = parseClaudeMessageResponse('tok', 200, {}, body);
+
+    expect(result.ephemeral5mInputTokens).toBe(100);
+    expect(result.ephemeral1hInputTokens).toBe(200);
+  });
+
+  it('parses a non-finite utilization header as null', () => {
+    const result = parseClaudeMessageResponse(
+      'tok',
+      200,
+      { 'anthropic-ratelimit-unified-5h-utilization': 'not-a-number' },
+      '{}',
+    );
+
+    expect(result.anthropicRatelimitUnified5hUtilization).toBeNull();
+  });
+});

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/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 };