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

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

@@ -0,0 +1,313 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import Database from 'better-sqlite3';
+import {
+  SqliteClaudeMessageResponseRepository,
+  generateUlid,
+} from './SqliteClaudeMessageResponseRepository';
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const requireRecord = (value: unknown): Record<string, unknown> => {
+  if (!isRecord(value))
+    throw new Error(`Expected record, got: ${String(value)}`);
+  return value;
+};
+
+const requireRecordArray = (value: unknown[]): Array<Record<string, unknown>> =>
+  value.map(requireRecord);
+
+const buildTestResponse = (
+  overrides: Partial<ClaudeMessageResponse> = {},
+): ClaudeMessageResponse => ({
+  id: generateUlid(),
+  observedAt: new Date('2024-01-15T10:30:00.000Z'),
+  tokenName: 'hashed-token-abc',
+  externalClaudeMessageId: 'msg_01XFDUDYJgAACTvykiHMn8xy',
+  externalClaudeRequestId: 'req_01234',
+  httpStatus: 200,
+  model: 'claude-sonnet-4-5',
+  role: 'assistant',
+  stopReason: 'end_turn',
+  stopSequence: null,
+  inputTokens: 100,
+  outputTokens: 50,
+  cacheCreationInputTokens: null,
+  cacheReadInputTokens: null,
+  ephemeral5mInputTokens: null,
+  ephemeral1hInputTokens: null,
+  serviceTier: 'standard',
+  inferenceGeo: null,
+  errorType: null,
+  errorMessage: null,
+  anthropicRatelimitUnifiedStatus: 'active',
+  anthropicRatelimitUnified5hStatus: 'active',
+  anthropicRatelimitUnified5hUtilization: 42.5,
+  anthropicRatelimitUnified5hReset: 1705316200,
+  anthropicRatelimitUnified7dStatus: 'active',
+  anthropicRatelimitUnified7dUtilization: 10.0,
+  anthropicRatelimitUnified7dReset: 1705920000,
+  retryAfter: null,
+  anthropicOrganizationId: 'org-abc123',
+  ...overrides,
+});
+
+describe('generateUlid', () => {
+  it('generates a 26-character uppercase alphanumeric string', () => {
+    const ulid = generateUlid();
+    expect(ulid).toHaveLength(26);
+    expect(/^[0-9A-HJKMNP-TV-Z]{26}$/.test(ulid)).toBe(true);
+  });
+
+  it('generates unique values across multiple calls', () => {
+    const ids = new Set(Array.from({ length: 100 }, () => generateUlid()));
+    expect(ids.size).toBe(100);
+  });
+
+  it('generates a value whose first 10 characters encode a timestamp no later than the current time', () => {
+    const before = Date.now();
+    const ulid = generateUlid();
+    const after = Date.now();
+    const ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+    const timeChars = ulid.slice(0, 10);
+    let decoded = 0;
+    for (const char of timeChars) {
+      decoded = decoded * 32 + ENCODING.indexOf(char);
+    }
+    expect(decoded).toBeGreaterThanOrEqual(before);
+    expect(decoded).toBeLessThanOrEqual(after);
+  });
+});
+
+describe('SqliteClaudeMessageResponseRepository', () => {
+  let tmpDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'claude-msg-repo-test-'));
+    dbPath = path.join(tmpDir, 'claude_message_response.db');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe('constructor', () => {
+    it('creates the database file when it does not exist', () => {
+      new SqliteClaudeMessageResponseRepository(dbPath);
+      expect(fs.existsSync(dbPath)).toBe(true);
+    });
+
+    it('creates the parent directory when it does not exist', () => {
+      const nestedDbPath = path.join(tmpDir, 'nested', 'dir', 'test.db');
+      new SqliteClaudeMessageResponseRepository(nestedDbPath);
+      expect(fs.existsSync(nestedDbPath)).toBe(true);
+    });
+
+    it('creates the claude_message_response table on first open', () => {
+      new SqliteClaudeMessageResponseRepository(dbPath);
+      const db = new Database(dbPath);
+      const row = db
+        .prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name='claude_message_response'",
+        )
+        .get();
+      db.close();
+      expect(row).toBeDefined();
+    });
+
+    it('does not fail when reopened against an existing database', () => {
+      new SqliteClaudeMessageResponseRepository(dbPath);
+      expect(() => {
+        new SqliteClaudeMessageResponseRepository(dbPath);
+      }).not.toThrow();
+    });
+  });
+
+  describe('append', () => {
+    it('inserts a row with all fields set', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse();
+
+      repo.append(response);
+
+      const db = new Database(dbPath);
+      const row = requireRecord(
+        db
+          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
+          .get(response.id),
+      );
+      db.close();
+
+      expect(row['id']).toBe(response.id);
+      expect(row['observed_at']).toBe(response.observedAt.getTime());
+      expect(row['token_name']).toBe(response.tokenName);
+      expect(row['external_claude_message_id']).toBe(
+        response.externalClaudeMessageId,
+      );
+      expect(row['external_claude_request_id']).toBe(
+        response.externalClaudeRequestId,
+      );
+      expect(row['http_status']).toBe(response.httpStatus);
+      expect(row['model']).toBe(response.model);
+      expect(row['role']).toBe(response.role);
+      expect(row['stop_reason']).toBe(response.stopReason);
+      expect(row['stop_sequence']).toBeNull();
+      expect(row['input_tokens']).toBe(response.inputTokens);
+      expect(row['output_tokens']).toBe(response.outputTokens);
+      expect(row['cache_creation_input_tokens']).toBeNull();
+      expect(row['cache_read_input_tokens']).toBeNull();
+      expect(row['ephemeral_5m_input_tokens']).toBeNull();
+      expect(row['ephemeral_1h_input_tokens']).toBeNull();
+      expect(row['service_tier']).toBe(response.serviceTier);
+      expect(row['inference_geo']).toBeNull();
+      expect(row['error_type']).toBeNull();
+      expect(row['error_message']).toBeNull();
+      expect(row['anthropic_ratelimit_unified_status']).toBe(
+        response.anthropicRatelimitUnifiedStatus,
+      );
+      expect(row['anthropic_ratelimit_unified_5h_status']).toBe(
+        response.anthropicRatelimitUnified5hStatus,
+      );
+      expect(row['anthropic_ratelimit_unified_5h_utilization']).toBe(
+        response.anthropicRatelimitUnified5hUtilization,
+      );
+      expect(row['anthropic_ratelimit_unified_5h_reset']).toBe(
+        response.anthropicRatelimitUnified5hReset,
+      );
+      expect(row['anthropic_ratelimit_unified_7d_status']).toBe(
+        response.anthropicRatelimitUnified7dStatus,
+      );
+      expect(row['anthropic_ratelimit_unified_7d_utilization']).toBe(
+        response.anthropicRatelimitUnified7dUtilization,
+      );
+      expect(row['anthropic_ratelimit_unified_7d_reset']).toBe(
+        response.anthropicRatelimitUnified7dReset,
+      );
+      expect(row['retry_after']).toBeNull();
+      expect(row['anthropic_organization_id']).toBe(
+        response.anthropicOrganizationId,
+      );
+    });
+
+    it('inserts a row where all nullable fields are null', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse({
+        externalClaudeMessageId: null,
+        externalClaudeRequestId: null,
+        model: null,
+        role: null,
+        stopReason: null,
+        stopSequence: null,
+        inputTokens: null,
+        outputTokens: null,
+        cacheCreationInputTokens: null,
+        cacheReadInputTokens: null,
+        ephemeral5mInputTokens: null,
+        ephemeral1hInputTokens: null,
+        serviceTier: null,
+        inferenceGeo: null,
+        errorType: null,
+        errorMessage: null,
+        anthropicRatelimitUnifiedStatus: null,
+        anthropicRatelimitUnified5hStatus: null,
+        anthropicRatelimitUnified5hUtilization: null,
+        anthropicRatelimitUnified5hReset: null,
+        anthropicRatelimitUnified7dStatus: null,
+        anthropicRatelimitUnified7dUtilization: null,
+        anthropicRatelimitUnified7dReset: null,
+        retryAfter: null,
+        anthropicOrganizationId: null,
+      });
+
+      repo.append(response);
+
+      const db = new Database(dbPath);
+      const row = requireRecord(
+        db
+          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
+          .get(response.id),
+      );
+      db.close();
+
+      expect(row['id']).toBe(response.id);
+      expect(row['http_status']).toBe(response.httpStatus);
+      expect(row['external_claude_message_id']).toBeNull();
+      expect(row['model']).toBeNull();
+    });
+
+    it('inserts an error response with error fields set', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse({
+        httpStatus: 429,
+        model: null,
+        role: null,
+        stopReason: null,
+        inputTokens: null,
+        outputTokens: null,
+        errorType: 'rate_limit_error',
+        errorMessage: 'Too many requests',
+        retryAfter: 30,
+      });
+
+      repo.append(response);
+
+      const db = new Database(dbPath);
+      const row = requireRecord(
+        db
+          .prepare('SELECT * FROM claude_message_response WHERE id = ?')
+          .get(response.id),
+      );
+      db.close();
+
+      expect(row['http_status']).toBe(429);
+      expect(row['error_type']).toBe('rate_limit_error');
+      expect(row['error_message']).toBe('Too many requests');
+      expect(row['retry_after']).toBe(30);
+    });
+
+    it('inserts multiple rows appending each independently', () => {
+      const repo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const responses = [
+        buildTestResponse({ httpStatus: 200 }),
+        buildTestResponse({ httpStatus: 429 }),
+        buildTestResponse({ httpStatus: 200 }),
+      ];
+
+      for (const response of responses) {
+        repo.append(response);
+      }
+
+      const db = new Database(dbPath);
+      const rows = requireRecordArray(
+        db.prepare('SELECT id FROM claude_message_response').all(),
+      );
+      db.close();
+
+      expect(rows).toHaveLength(3);
+      const rowIds = rows.map((r) => r['id']).sort();
+      const responseIds = responses.map((r) => r.id).sort();
+      expect(rowIds).toEqual(responseIds);
+    });
+
+    it('persists rows that survive a repository close and reopen', () => {
+      const firstRepo = new SqliteClaudeMessageResponseRepository(dbPath);
+      const response = buildTestResponse();
+      firstRepo.append(response);
+
+      const secondRepo = new SqliteClaudeMessageResponseRepository(dbPath);
+
+      const db = new Database(dbPath);
+      const countRow = requireRecord(
+        db.prepare('SELECT COUNT(*) as cnt FROM claude_message_response').get(),
+      );
+      db.close();
+
+      expect(countRow['cnt']).toBe(1);
+      expect(secondRepo).toBeDefined();
+    });
+  });
+});

package/src/adapter/repositories/SqliteClaudeMessageResponseRepository.ts

@@ -0,0 +1,164 @@
+import * as crypto from 'crypto';
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
+
+const ULID_ENCODING = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+const encodeUlidTime = (ms: number): string => {
+  let str = '';
+  for (let i = 9; i >= 0; i--) {
+    str = ULID_ENCODING[ms % 32] + str;
+    ms = Math.floor(ms / 32);
+  }
+  return str;
+};
+
+const encodeUlidRandom = (): string => {
+  const bytes = crypto.randomBytes(10);
+  let bits = 0;
+  let bitLen = 0;
+  let str = '';
+  for (let i = 0; i < bytes.length && str.length < 16; i++) {
+    bits = (bits << 8) | bytes[i];
+    bitLen += 8;
+    while (bitLen >= 5 && str.length < 16) {
+      str += ULID_ENCODING[(bits >>> (bitLen - 5)) & 0x1f];
+      bitLen -= 5;
+    }
+  }
+  return str;
+};
+
+export const generateUlid = (): string =>
+  encodeUlidTime(Date.now()) + encodeUlidRandom();
+
+const CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS claude_message_response (
+    id TEXT PRIMARY KEY,
+    observed_at INTEGER NOT NULL,
+    token_name TEXT NOT NULL,
+    external_claude_message_id TEXT,
+    external_claude_request_id TEXT,
+    http_status INTEGER NOT NULL,
+    model TEXT,
+    role TEXT,
+    stop_reason TEXT,
+    stop_sequence TEXT,
+    input_tokens INTEGER,
+    output_tokens INTEGER,
+    cache_creation_input_tokens INTEGER,
+    cache_read_input_tokens INTEGER,
+    ephemeral_5m_input_tokens INTEGER,
+    ephemeral_1h_input_tokens INTEGER,
+    service_tier TEXT,
+    inference_geo TEXT,
+    error_type TEXT,
+    error_message TEXT,
+    anthropic_ratelimit_unified_status TEXT,
+    anthropic_ratelimit_unified_5h_status TEXT,
+    anthropic_ratelimit_unified_5h_utilization REAL,
+    anthropic_ratelimit_unified_5h_reset REAL,
+    anthropic_ratelimit_unified_7d_status TEXT,
+    anthropic_ratelimit_unified_7d_utilization REAL,
+    anthropic_ratelimit_unified_7d_reset REAL,
+    retry_after REAL,
+    anthropic_organization_id TEXT
+  ) STRICT
+`;
+
+const INSERT_SQL = `
+  INSERT INTO claude_message_response (
+    id, observed_at, token_name,
+    external_claude_message_id, external_claude_request_id,
+    http_status, model, role, stop_reason, stop_sequence,
+    input_tokens, output_tokens,
+    cache_creation_input_tokens, cache_read_input_tokens,
+    ephemeral_5m_input_tokens, ephemeral_1h_input_tokens,
+    service_tier, inference_geo,
+    error_type, error_message,
+    anthropic_ratelimit_unified_status,
+    anthropic_ratelimit_unified_5h_status,
+    anthropic_ratelimit_unified_5h_utilization,
+    anthropic_ratelimit_unified_5h_reset,
+    anthropic_ratelimit_unified_7d_status,
+    anthropic_ratelimit_unified_7d_utilization,
+    anthropic_ratelimit_unified_7d_reset,
+    retry_after, anthropic_organization_id
+  ) VALUES (
+    @id, @observedAt, @tokenName,
+    @externalClaudeMessageId, @externalClaudeRequestId,
+    @httpStatus, @model, @role, @stopReason, @stopSequence,
+    @inputTokens, @outputTokens,
+    @cacheCreationInputTokens, @cacheReadInputTokens,
+    @ephemeral5mInputTokens, @ephemeral1hInputTokens,
+    @serviceTier, @inferenceGeo,
+    @errorType, @errorMessage,
+    @anthropicRatelimitUnifiedStatus,
+    @anthropicRatelimitUnified5hStatus,
+    @anthropicRatelimitUnified5hUtilization,
+    @anthropicRatelimitUnified5hReset,
+    @anthropicRatelimitUnified7dStatus,
+    @anthropicRatelimitUnified7dUtilization,
+    @anthropicRatelimitUnified7dReset,
+    @retryAfter, @anthropicOrganizationId
+  )
+`;
+
+export class SqliteClaudeMessageResponseRepository implements ClaudeMessageResponseRepository {
+  private readonly db: Database.Database;
+  private readonly insert: Database.Statement;
+
+  constructor(dbPath: string) {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.exec(CREATE_TABLE_SQL);
+    this.insert = this.db.prepare(INSERT_SQL);
+  }
+
+  append = (response: ClaudeMessageResponse): void => {
+    this.insert.run({
+      id: response.id,
+      observedAt: response.observedAt.getTime(),
+      tokenName: response.tokenName,
+      externalClaudeMessageId: response.externalClaudeMessageId,
+      externalClaudeRequestId: response.externalClaudeRequestId,
+      httpStatus: response.httpStatus,
+      model: response.model,
+      role: response.role,
+      stopReason: response.stopReason,
+      stopSequence: response.stopSequence,
+      inputTokens: response.inputTokens,
+      outputTokens: response.outputTokens,
+      cacheCreationInputTokens: response.cacheCreationInputTokens,
+      cacheReadInputTokens: response.cacheReadInputTokens,
+      ephemeral5mInputTokens: response.ephemeral5mInputTokens,
+      ephemeral1hInputTokens: response.ephemeral1hInputTokens,
+      serviceTier: response.serviceTier,
+      inferenceGeo: response.inferenceGeo,
+      errorType: response.errorType,
+      errorMessage: response.errorMessage,
+      anthropicRatelimitUnifiedStatus: response.anthropicRatelimitUnifiedStatus,
+      anthropicRatelimitUnified5hStatus:
+        response.anthropicRatelimitUnified5hStatus,
+      anthropicRatelimitUnified5hUtilization:
+        response.anthropicRatelimitUnified5hUtilization,
+      anthropicRatelimitUnified5hReset:
+        response.anthropicRatelimitUnified5hReset,
+      anthropicRatelimitUnified7dStatus:
+        response.anthropicRatelimitUnified7dStatus,
+      anthropicRatelimitUnified7dUtilization:
+        response.anthropicRatelimitUnified7dUtilization,
+      anthropicRatelimitUnified7dReset:
+        response.anthropicRatelimitUnified7dReset,
+      retryAfter: response.retryAfter,
+      anthropicOrganizationId: response.anthropicOrganizationId,
+    });
+  };
+}

package/src/domain/entities/ClaudeMessageResponse.ts

@@ -0,0 +1,31 @@
+export type ClaudeMessageResponse = {
+  id: string;
+  observedAt: Date;
+  tokenName: string;
+  externalClaudeMessageId: string | null;
+  externalClaudeRequestId: string | null;
+  httpStatus: number;
+  model: string | null;
+  role: string | null;
+  stopReason: string | null;
+  stopSequence: string | null;
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheCreationInputTokens: number | null;
+  cacheReadInputTokens: number | null;
+  ephemeral5mInputTokens: number | null;
+  ephemeral1hInputTokens: number | null;
+  serviceTier: string | null;
+  inferenceGeo: string | null;
+  errorType: string | null;
+  errorMessage: string | null;
+  anthropicRatelimitUnifiedStatus: string | null;
+  anthropicRatelimitUnified5hStatus: string | null;
+  anthropicRatelimitUnified5hUtilization: number | null;
+  anthropicRatelimitUnified5hReset: number | null;
+  anthropicRatelimitUnified7dStatus: string | null;
+  anthropicRatelimitUnified7dUtilization: number | null;
+  anthropicRatelimitUnified7dReset: number | null;
+  retryAfter: number | null;
+  anthropicOrganizationId: string | null;
+};

package/src/domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository.ts

@@ -0,0 +1,5 @@
+import { ClaudeMessageResponse } from '../../entities/ClaudeMessageResponse';
+
+export interface ClaudeMessageResponseRepository {
+  append: (response: ClaudeMessageResponse) => void;
+}

package/types/adapter/proxy/ClaudeMessageResponseParser.d.ts

@@ -0,0 +1,4 @@
+import * as http from 'http';
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+export declare const parseClaudeMessageResponse: (tokenName: string, httpStatus: number, headers: http.IncomingHttpHeaders, body: string) => ClaudeMessageResponse;
+//# sourceMappingURL=ClaudeMessageResponseParser.d.ts.map

package/types/adapter/proxy/ClaudeMessageResponseParser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeMessageResponseParser.d.ts","sourceRoot":"","sources":["../../../src/adapter/proxy/ClaudeMessageResponseParser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AAiFpF,eAAO,MAAM,0BAA0B,GACrC,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,SAAS,IAAI,CAAC,mBAAmB,EACjC,MAAM,MAAM,KACX,qBA4FF,CAAC"}

package/types/adapter/proxy/proxyEntry.d.ts

@@ -1,4 +1,5 @@
+import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
 declare const extractToken: (authorization: string | string[] | undefined) => string | null;
-declare const startProxy: (port: number) => void;
+declare const startProxy: (port: number, claudeMessageResponseRepository?: ClaudeMessageResponseRepository | null) => void;
 export { startProxy, extractToken };
 //# sourceMappingURL=proxyEntry.d.ts.map

package/types/adapter/proxy/proxyEntry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proxyEntry.d.ts","sourceRoot":"","sources":["../../../src/adapter/proxy/proxyEntry.ts"],"names":[],"mappings":"AAeA,QAAA,MAAM,YAAY,GAChB,eAAe,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,KAC3C,MAAM,GAAG,IAQX,CAAC;AAEF,QAAA,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,IA0DlC,CAAC;AAMF,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC"}
+{"version":3,"file":"proxyEntry.d.ts","sourceRoot":"","sources":["../../../src/adapter/proxy/proxyEntry.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AAU3H,QAAA,MAAM,YAAY,GAChB,eAAe,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,KAC3C,MAAM,GAAG,IAQX,CAAC;AAEF,QAAA,MAAM,UAAU,GACd,MAAM,MAAM,EACZ,kCAAiC,+BAA+B,GAAG,IAAW,KAC7E,IA0EF,CAAC;AAQF,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,CAAC"}

package/types/adapter/repositories/SqliteClaudeMessageResponseRepository.d.ts

@@ -0,0 +1,10 @@
+import { ClaudeMessageResponse } from '../../domain/entities/ClaudeMessageResponse';
+import { ClaudeMessageResponseRepository } from '../../domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository';
+export declare const generateUlid: () => string;
+export declare class SqliteClaudeMessageResponseRepository implements ClaudeMessageResponseRepository {
+    private readonly db;
+    private readonly insert;
+    constructor(dbPath: string);
+    append: (response: ClaudeMessageResponse) => void;
+}
+//# sourceMappingURL=SqliteClaudeMessageResponseRepository.d.ts.map

package/types/adapter/repositories/SqliteClaudeMessageResponseRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SqliteClaudeMessageResponseRepository.d.ts","sourceRoot":"","sources":["../../../src/adapter/repositories/SqliteClaudeMessageResponseRepository.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AACpF,OAAO,EAAE,+BAA+B,EAAE,MAAM,0EAA0E,CAAC;AA6B3H,eAAO,MAAM,YAAY,QAAO,MACiB,CAAC;AA0ElD,qBAAa,qCAAsC,YAAW,+BAA+B;IAC3F,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAoB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqB;gBAEhC,MAAM,EAAE,MAAM;IAW1B,MAAM,GAAI,UAAU,qBAAqB,KAAG,IAAI,CAsC9C;CACH"}

package/types/domain/entities/ClaudeMessageResponse.d.ts

@@ -0,0 +1,32 @@
+export type ClaudeMessageResponse = {
+    id: string;
+    observedAt: Date;
+    tokenName: string;
+    externalClaudeMessageId: string | null;
+    externalClaudeRequestId: string | null;
+    httpStatus: number;
+    model: string | null;
+    role: string | null;
+    stopReason: string | null;
+    stopSequence: string | null;
+    inputTokens: number | null;
+    outputTokens: number | null;
+    cacheCreationInputTokens: number | null;
+    cacheReadInputTokens: number | null;
+    ephemeral5mInputTokens: number | null;
+    ephemeral1hInputTokens: number | null;
+    serviceTier: string | null;
+    inferenceGeo: string | null;
+    errorType: string | null;
+    errorMessage: string | null;
+    anthropicRatelimitUnifiedStatus: string | null;
+    anthropicRatelimitUnified5hStatus: string | null;
+    anthropicRatelimitUnified5hUtilization: number | null;
+    anthropicRatelimitUnified5hReset: number | null;
+    anthropicRatelimitUnified7dStatus: string | null;
+    anthropicRatelimitUnified7dUtilization: number | null;
+    anthropicRatelimitUnified7dReset: number | null;
+    retryAfter: number | null;
+    anthropicOrganizationId: string | null;
+};
+//# sourceMappingURL=ClaudeMessageResponse.d.ts.map

package/types/domain/entities/ClaudeMessageResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeMessageResponse.d.ts","sourceRoot":"","sources":["../../../src/domain/entities/ClaudeMessageResponse.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,IAAI,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAC;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,wBAAwB,EAAE,MAAM,GAAG,IAAI,CAAC;IACxC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;IACtC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,+BAA+B,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/C,iCAAiC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjD,sCAAsC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtD,gCAAgC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,iCAAiC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjD,sCAAsC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtD,gCAAgC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,uBAAuB,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC,CAAC"}

package/types/domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository.d.ts

@@ -0,0 +1,5 @@
+import { ClaudeMessageResponse } from '../../entities/ClaudeMessageResponse';
+export interface ClaudeMessageResponseRepository {
+    append: (response: ClaudeMessageResponse) => void;
+}
+//# sourceMappingURL=ClaudeMessageResponseRepository.d.ts.map

package/types/domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClaudeMessageResponseRepository.d.ts","sourceRoot":"","sources":["../../../../src/domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAE7E,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,CAAC,QAAQ,EAAE,qBAAqB,KAAK,IAAI,CAAC;CACnD"}