github-issue-tower-defence-management 2.19.0 → 2.19.2

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

@@ -1,262 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import type { Issue } from '../../../domain/entities/Issue';
-import { IN_TMUX_STATUS_NAME } from '../../../domain/entities/WorkflowStatus';
-import {
-  GenerateTokenStatusUseCase,
-  SevenDayWindowAggregate,
-  TokenRateLimitSnapshot,
-  TokenStatus,
-  TokenStatusInput,
-  computeSevenDayWindowAggregate,
-} from '../../../domain/usecases/dashboard/GenerateTokenStatusUseCase';
-import { InTmuxByHumanSessionTokenCountUseCase } from '../../../domain/usecases/InTmuxByHumanSessionTokenCountUseCase';
-import { OauthTokenCandidate } from '../../../domain/usecases/OauthTokenSelectUseCase';
-import { ClaudeInteractiveSessionRepository } from '../../../domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository';
-import { TakeOwnershipSpawnRepository } from '../../../domain/usecases/adapter-interfaces/TakeOwnershipSpawnRepository';
-import { RateLimitSnapshot, readRateLimit } from '../../proxy/RateLimitCache';
-import { loadTokenEntries } from '../../proxy/TokenListLoader';
-import { ProcClaudeInteractiveSessionRepository } from '../../repositories/ProcClaudeInteractiveSessionRepository';
-import { ProcTakeOwnershipSpawnRepository } from '../../repositories/ProcTakeOwnershipSpawnRepository';
-
-const SEVEN_DAY_SONNET_LIMIT_TYPE = 'seven_day_sonnet';
-const SEVEN_DAY_OPUS_LIMIT_TYPE = 'seven_day_opus';
-
-const IN_TMUX_PROJECTS_DIR_NAME = 'token-status-in-tmux';
-
-export type TokenStatusWriterParams = {
-  dashboardDataDir: string | null | undefined;
-  tokenListJsonPath: string | null | undefined;
-  issues: Issue[];
-  pjcode?: string | null | undefined;
-  now?: Date;
-  readSnapshot?: (token: string) => RateLimitSnapshot | null;
-  interactiveSessionRepository?: ClaudeInteractiveSessionRepository;
-  spawnRepository?: TakeOwnershipSpawnRepository;
-};
-
-export type TokenStatusFile = {
-  tokens: TokenStatus[];
-  sevenDayWindowAggregate: SevenDayWindowAggregate | null;
-  capturedAt: string;
-};
-
-type InTmuxByHumanProjectFile = {
-  pjcode: string;
-  urls: string[];
-  capturedAt: string;
-};
-
-const writeJsonAtomic = (filePath: string, data: unknown): void => {
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-  const tmpPath = `${filePath}.tmp`;
-  fs.writeFileSync(tmpPath, JSON.stringify(data));
-  fs.renameSync(tmpPath, filePath);
-};
-
-const inTmuxByHumanUrlsFromIssues = (issues: Issue[]): string[] => {
-  const urls = new Set<string>();
-  for (const issue of issues) {
-    if (issue.status === IN_TMUX_STATUS_NAME && issue.isClosed === false) {
-      urls.add(issue.url);
-    }
-  }
-  return [...urls];
-};
-
-const persistProjectInTmuxByHumanUrls = (
-  inTmuxProjectsDir: string,
-  pjcode: string,
-  urls: string[],
-  capturedAt: string,
-): void => {
-  const file: InTmuxByHumanProjectFile = { pjcode, urls, capturedAt };
-  writeJsonAtomic(path.join(inTmuxProjectsDir, `${pjcode}.json`), file);
-};
-
-const readMachineWideInTmuxByHumanUrls = (
-  inTmuxProjectsDir: string,
-): Set<string> => {
-  const urls = new Set<string>();
-  let fileNames: string[];
-  try {
-    fileNames = fs.readdirSync(inTmuxProjectsDir);
-  } catch {
-    return urls;
-  }
-  for (const fileName of fileNames) {
-    if (!fileName.endsWith('.json')) {
-      continue;
-    }
-    try {
-      const parsed: unknown = JSON.parse(
-        fs.readFileSync(path.join(inTmuxProjectsDir, fileName), 'utf8'),
-      );
-      if (
-        parsed === null ||
-        typeof parsed !== 'object' ||
-        !('urls' in parsed) ||
-        !Array.isArray(parsed.urls)
-      ) {
-        continue;
-      }
-      for (const url of parsed.urls) {
-        if (typeof url === 'string') {
-          urls.add(url);
-        }
-      }
-    } catch {
-      continue;
-    }
-  }
-  return urls;
-};
-
-export const toTokenRateLimitSnapshot = (
-  snapshot: RateLimitSnapshot | null,
-): TokenRateLimitSnapshot | null => {
-  if (snapshot === null) {
-    return null;
-  }
-  const hasWindowData =
-    snapshot.unifiedStatus !== null ||
-    snapshot.fiveHourReset > 0 ||
-    snapshot.sevenDayReset > 0 ||
-    snapshot.fiveHourUtilization > 0 ||
-    snapshot.sevenDayUtilization > 0;
-  return {
-    fiveHourUtilization: snapshot.fiveHourUtilization,
-    fiveHourReset: snapshot.fiveHourReset,
-    sevenDayUtilization: snapshot.sevenDayUtilization,
-    sevenDayReset: snapshot.sevenDayReset,
-    blocked: snapshot.blocked,
-    fiveHourRejected: snapshot.fiveHourRejected,
-    sevenDayRejected: snapshot.sevenDayRejected,
-    unifiedStatus: snapshot.unifiedStatus,
-    sevenDaySonnetRejected:
-      snapshot.modelWeeklyLimits[SEVEN_DAY_SONNET_LIMIT_TYPE]?.rejected ??
-      false,
-    sevenDayOpusRejected:
-      snapshot.modelWeeklyLimits[SEVEN_DAY_OPUS_LIMIT_TYPE]?.rejected ?? false,
-    hasWindowData,
-    lastUpdatedEpoch: snapshot.lastUpdatedEpoch,
-    subscriptionDisabled: snapshot.subscriptionDisabled,
-  };
-};
-
-export const writeTokenStatus = (params: TokenStatusWriterParams): void => {
-  const { dashboardDataDir, tokenListJsonPath, issues, pjcode } = params;
-  if (!dashboardDataDir || !tokenListJsonPath) {
-    return;
-  }
-
-  const entries = loadTokenEntries(tokenListJsonPath);
-  if (entries === null) {
-    return;
-  }
-
-  const now = params.now ?? new Date();
-  const inTmuxProjectsDir = path.join(
-    dashboardDataDir,
-    IN_TMUX_PROJECTS_DIR_NAME,
-  );
-  if (pjcode) {
-    persistProjectInTmuxByHumanUrls(
-      inTmuxProjectsDir,
-      pjcode,
-      inTmuxByHumanUrlsFromIssues(issues),
-      now.toISOString(),
-    );
-  }
-  const machineWideInTmuxByHumanUrls = pjcode
-    ? readMachineWideInTmuxByHumanUrls(inTmuxProjectsDir)
-    : new Set(inTmuxByHumanUrlsFromIssues(issues));
-
-  const readSnapshot = params.readSnapshot ?? readRateLimit;
-  const interactiveSessionRepository =
-    params.interactiveSessionRepository ??
-    new ProcClaudeInteractiveSessionRepository();
-  const spawnRepository =
-    params.spawnRepository ?? new ProcTakeOwnershipSpawnRepository();
-
-  const tokenInputs: TokenStatusInput[] = entries.map((entry) => ({
-    name: entry.name,
-    token: entry.token,
-    snapshot: toTokenRateLimitSnapshot(readSnapshot(entry.token)),
-  }));
-
-  const distinctLogPathsByToken = new Map<string, Set<string>>();
-  for (const spawn of spawnRepository.listSpawns()) {
-    const logPaths =
-      distinctLogPathsByToken.get(spawn.token) ?? new Set<string>();
-    logPaths.add(spawn.logPath);
-    distinctLogPathsByToken.set(spawn.token, logPaths);
-  }
-  const prepCountByToken = new Map<string, number>();
-  for (const [token, logPaths] of distinctLogPathsByToken.entries()) {
-    prepCountByToken.set(token, logPaths.size);
-  }
-
-  const candidates: OauthTokenCandidate[] = entries.map((entry) => ({
-    name: entry.name,
-    token: entry.token,
-    snapshot: null,
-    subscriptionDisabled: false,
-    unifiedRejected: false,
-    fableRejected: false,
-  }));
-  const machineWideInTmuxByHumanIssues: Issue[] = [
-    ...machineWideInTmuxByHumanUrls,
-  ].map((url) => ({
-    nameWithOwner: '',
-    number: 0,
-    title: '',
-    state: 'OPEN',
-    status: IN_TMUX_STATUS_NAME,
-    story: null,
-    nextActionDate: null,
-    nextActionHour: null,
-    estimationMinutes: null,
-    dependedIssueUrls: [],
-    completionDate50PercentConfidence: null,
-    url,
-    assignees: [],
-    labels: [],
-    org: '',
-    repo: '',
-    body: '',
-    itemId: '',
-    isPr: false,
-    isInProgress: false,
-    isClosed: false,
-    createdAt: now,
-    author: '',
-    closingIssueReferenceUrls: [],
-    agent: null,
-    stateReason: null,
-  }));
-  const humResult = new InTmuxByHumanSessionTokenCountUseCase().run(
-    candidates,
-    interactiveSessionRepository.listInteractiveSessions(),
-    machineWideInTmuxByHumanIssues,
-  );
-  const humCountByToken = new Map<string, number>(
-    humResult.counts.map((count) => [count.token, count.count]),
-  );
-
-  const tokens = new GenerateTokenStatusUseCase().run({
-    tokens: tokenInputs,
-    prepCountByToken,
-    humCountByToken,
-    nowEpochSeconds: Math.floor(now.getTime() / 1000),
-  });
-
-  const file: TokenStatusFile = {
-    tokens,
-    sevenDayWindowAggregate: computeSevenDayWindowAggregate(tokens),
-    capturedAt: now.toISOString(),
-  };
-
-  writeJsonAtomic(path.join(dashboardDataDir, 'token-status.json'), file);
-};

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

@@ -1,211 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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;
-  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
-  if (typeof value !== 'string') return null;
-  const parsed = parseInt(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'),
-  };
-};