@sixb/pg 0.1.1 → 0.1.3

package/src/agents/checkpoints.ts

@@ -0,0 +1,175 @@
+import {
+  agentContextCheckpointMatchesCreateInput,
+  assertAgentContextCheckpointAnchors,
+  assertAgentContextCheckpointAuthority,
+  assertAgentContextCheckpointReplayState,
+  assertCreateAgentContextCheckpointInput,
+} from "@sixb/core/internal/agent-run-storage-provider"
+import {
+  type AgentContextCheckpointRecord,
+  type AgentContextCheckpointStore,
+  AgentStorageError,
+  type CreateAgentContextCheckpointInput,
+} from "@sixb/core/storage"
+import { isUniqueViolation } from "../storage-errors"
+import { type PgStoreClient, runPgTransaction } from "../transactions"
+import {
+  type AgentContextCheckpointRow,
+  type AgentMessageRow,
+  type AgentRunRow,
+  type AgentThreadRow,
+  rowToContextCheckpointRecord,
+  rowToMessageRecord,
+  rowToRunRecord,
+  rowToThreadRecord,
+} from "./rows"
+
+export class PgAgentContextCheckpointStore implements AgentContextCheckpointStore {
+  constructor(private readonly sql: PgStoreClient) {}
+
+  async create(input: CreateAgentContextCheckpointInput): Promise<AgentContextCheckpointRecord> {
+    assertCreateAgentContextCheckpointInput(input, "SixbPg")
+
+    try {
+      return await runPgTransaction(this.sql, async (tx) => {
+        // Match run finalization's lock order (run, then thread) to avoid a cross-operation deadlock.
+        const [runRow] = await tx<AgentRunRow[]>`
+          SELECT * FROM agent_runs
+          WHERE project_id = ${input.projectId} AND id = ${input.createdByRunId}
+          FOR UPDATE
+        `
+        const [threadRow] = await tx<AgentThreadRow[]>`
+          SELECT * FROM agent_threads
+          WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+          FOR UPDATE
+        `
+        assertAgentContextCheckpointAuthority({
+          create: input,
+          run: runRow ? rowToRunRecord(runRow) : null,
+          thread: threadRow ? rowToThreadRecord(threadRow) : null,
+          prefix: "SixbPg",
+        })
+
+        const [latestRow] = await tx<AgentContextCheckpointRow[]>`
+          SELECT * FROM agent_context_checkpoints
+          WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+          ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
+          LIMIT 1
+        `
+        const latest = latestRow ? rowToContextCheckpointRecord(latestRow) : null
+        const [headRow] = await tx<{ seq: number | string }[]>`
+          SELECT COALESCE(MAX(seq), 0) AS seq FROM agent_messages
+          WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+        `
+        const headSeq = Number(headRow?.seq ?? 0)
+
+        const [existingForRunRow] = await tx<AgentContextCheckpointRow[]>`
+          SELECT * FROM agent_context_checkpoints
+          WHERE project_id = ${input.projectId} AND created_by_run_id = ${input.createdByRunId}
+        `
+        if (existingForRunRow) {
+          const record = rowToContextCheckpointRecord(existingForRunRow)
+          if (agentContextCheckpointMatchesCreateInput(record, input)) {
+            assertAgentContextCheckpointReplayState({
+              create: input,
+              existing: record,
+              latest,
+              headSeq,
+              prefix: "SixbPg",
+            })
+            return record
+          }
+          throw new AgentStorageError(
+            "invalid_state",
+            `[SixbPg] Agent run '${input.createdByRunId}' already created a different context checkpoint.`
+          )
+        }
+
+        const [duplicateId] = await tx<{ present: number }[]>`
+          SELECT 1 AS present FROM agent_context_checkpoints
+          WHERE project_id = ${input.projectId} AND id = ${input.id}
+        `
+        if (duplicateId) {
+          throw new AgentStorageError(
+            "duplicate_id",
+            `[SixbPg] Agent context checkpoint '${input.id}' already exists for project '${input.projectId}'.`
+          )
+        }
+
+        const [firstRetainedRow] = await tx<AgentMessageRow[]>`
+          SELECT * FROM agent_messages
+          WHERE
+            project_id = ${input.projectId}
+            AND thread_id = ${input.threadId}
+            AND seq > ${input.summarizedThroughSeq}
+          ORDER BY seq ASC
+          LIMIT 1
+        `
+        assertAgentContextCheckpointAnchors({
+          create: input,
+          latest,
+          headSeq,
+          firstRetained: firstRetainedRow ? rowToMessageRecord(firstRetainedRow) : null,
+          prefix: "SixbPg",
+        })
+
+        const [row] = await tx<AgentContextCheckpointRow[]>`
+          INSERT INTO agent_context_checkpoints (
+            project_id,
+            id,
+            thread_id,
+            created_by_run_id,
+            previous_checkpoint_id,
+            reason,
+            summary,
+            summary_format_version,
+            summarized_through_seq,
+            observed_head_seq,
+            estimated_input_tokens_before,
+            estimated_input_tokens_after,
+            summary_model_id,
+            created_at
+          ) VALUES (
+            ${input.projectId},
+            ${input.id},
+            ${input.threadId},
+            ${input.createdByRunId},
+            ${input.expectedPreviousCheckpointId},
+            ${input.reason},
+            ${input.summary},
+            ${input.summaryFormatVersion},
+            ${input.summarizedThroughSeq},
+            ${input.observedHeadSeq},
+            ${input.estimatedInputTokensBefore},
+            ${input.estimatedInputTokensAfter},
+            ${input.summaryModelId},
+            ${input.createdAt ?? new Date()}
+          )
+          RETURNING *
+        `
+        return rowToContextCheckpointRecord(row)
+      })
+    } catch (error) {
+      if (isUniqueViolation(error)) {
+        throw new AgentStorageError(
+          "duplicate_id",
+          `[SixbPg] Agent context checkpoint '${input.id}' already exists for project '${input.projectId}'.`
+        )
+      }
+      throw error
+    }
+  }
+
+  async getLatest(input: {
+    readonly projectId: string
+    readonly threadId: string
+  }): Promise<AgentContextCheckpointRecord | null> {
+    const [row] = await this.sql<AgentContextCheckpointRow[]>`
+      SELECT * FROM agent_context_checkpoints
+      WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+      ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
+      LIMIT 1
+    `
+    return row ? rowToContextCheckpointRecord(row) : null
+  }
+}

package/src/agents/index.ts

@@ -1,5 +1,6 @@
 export type { PgAgentStorageOptions } from "./agent-storage"
 export { PgAgentStorage } from "./agent-storage"
+export { PgAgentContextCheckpointStore } from "./checkpoints"
 export { PgAgentMessageStore } from "./messages"
 export { PgAgentRunStore } from "./runs"
 export { PgAgentThreadStore } from "./threads"

package/src/agents/messages.ts

@@ -4,6 +4,7 @@ import {
   type AgentMessageStore,
   AgentStorageError,
   type AppendAgentMessageInput,
+  type DeleteAgentMessagesByRunInput,
   type ListAgentMessagesInput,
   type ListAgentMessagesResult,
 } from "@sixb/core/storage"
@@ -20,6 +21,23 @@ export class PgAgentMessageStore implements AgentMessageStore {
 
     try {
       return await runPgTransaction(this.sql, async (tx) => {
+        // Assistant finalization appends and finishes in one outer transaction. Lock its run first
+        // so every operation that needs both rows follows the same run -> thread order.
+        if (input.runId !== null) {
+          const [run] = await tx<{ id: string }[]>`
+            SELECT id FROM agent_runs
+            WHERE project_id = ${input.projectId} AND id = ${input.runId}
+            FOR UPDATE
+          `
+
+          if (!run) {
+            throw new AgentStorageError(
+              "run_not_found",
+              `[SixbPg] Agent run '${input.runId}' not found for project '${input.projectId}'.`
+            )
+          }
+        }
+
         const [thread] = await tx<{ id: string }[]>`
           SELECT id FROM agent_threads
           WHERE project_id = ${input.projectId} AND id = ${input.threadId}
@@ -33,19 +51,6 @@ export class PgAgentMessageStore implements AgentMessageStore {
           )
         }
 
-        if (input.runId !== null) {
-          const [run] = await tx<{ id: string }[]>`
-            SELECT id FROM agent_runs WHERE project_id = ${input.projectId} AND id = ${input.runId}
-          `
-
-          if (!run) {
-            throw new AgentStorageError(
-              "run_not_found",
-              `[SixbPg] Agent run '${input.runId}' not found for project '${input.projectId}'.`
-            )
-          }
-        }
-
         const [seqRow] = await tx<{ next: number | string }[]>`
           SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM agent_messages
           WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
@@ -104,6 +109,54 @@ export class PgAgentMessageStore implements AgentMessageStore {
     }
   }
 
+  async deleteByRunId(input: DeleteAgentMessagesByRunInput): Promise<number> {
+    return runPgTransaction(this.sql, async (tx) => {
+      const [thread] = await tx<{ id: string }[]>`
+        SELECT id FROM agent_threads
+        WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+        FOR UPDATE
+      `
+
+      if (!thread) {
+        throw new AgentStorageError(
+          "thread_not_found",
+          `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
+        )
+      }
+
+      const deleted = await tx<{ id: string }[]>`
+        DELETE FROM agent_messages
+        WHERE project_id = ${input.projectId}
+          AND thread_id = ${input.threadId}
+          AND run_id = ${input.runId}
+        RETURNING id
+      `
+      if (deleted.length === 0) {
+        return 0
+      }
+
+      const updatedAt = new Date()
+      await tx`
+        UPDATE agent_threads
+        SET
+          message_count = (
+            SELECT COUNT(*) FROM agent_messages
+            WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+          ),
+          last_message_at = (
+            SELECT created_at FROM agent_messages
+            WHERE project_id = ${input.projectId} AND thread_id = ${input.threadId}
+            ORDER BY seq DESC
+            LIMIT 1
+          ),
+          updated_at = ${updatedAt}
+        WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+      `
+
+      return deleted.length
+    })
+  }
+
   async getById(params: { projectId: string; id: string }): Promise<AgentMessageRecord | null> {
     const [row] = await this.sql<AgentMessageRow[]>`
       SELECT * FROM agent_messages WHERE project_id = ${params.projectId} AND id = ${params.id}
@@ -121,6 +174,11 @@ export class PgAgentMessageStore implements AgentMessageStore {
     const params: SqlParameter[] = [input.projectId, input.threadId]
     let index = 3
 
+    if (input.afterSeq !== undefined) {
+      whereClauses.push(`seq > $${index++}`)
+      params.push(input.afterSeq)
+    }
+
     if (input.roles) {
       const placeholders = input.roles.map(() => `$${index++}`)
       whereClauses.push(`role IN (${placeholders.join(", ")})`)

package/src/agents/rows.ts

@@ -1,9 +1,11 @@
-import { type AgentMessagePart, type Principal, SYSTEM_PRINCIPAL } from "@sixb/core"
+import type { AgentMessagePart, JsonValue, Principal } from "@sixb/core"
+import { parseSixbFailure } from "@sixb/core/internal/errors"
 import {
+  AGENT_RUN_FAILURE_CODES,
+  type AgentContextCheckpointRecord,
   type AgentMessageRecord,
   type AgentRunDiagnostic,
   type AgentRunRecord,
-  type AgentRunUsage,
   type AgentThreadRecord,
   coerceAgentRunFinishReason,
 } from "@sixb/core/storage"
@@ -30,22 +32,15 @@ export interface AgentThreadRow {
 export interface AgentRunRow {
   project_id: string
   id: string
+  execution_id: string
   thread_id: string
   agent_id: string
   trigger_message_id: string
-  requested_by_principal_type: Principal["type"] | null
-  requested_by_principal_id: string | null
-  execution_principal_type: "serviceAccount" | null
-  execution_principal_id: string | null
+  requester_group_ids: string[] | string
   status: AgentRunRecord["status"]
   model_id: string | null
   finish_reason: string | null
-  usage_input_tokens: number | string | null
-  usage_output_tokens: number | string | null
-  usage_total_tokens: number | string | null
-  usage_reasoning_tokens: number | string | null
-  usage_cached_input_tokens: number | string | null
-  error: string | null
+  error: JsonValue | null
   diagnostics: AgentRunDiagnostic[] | string | null
   attempt: number | string
   execution_token: string | null
@@ -71,6 +66,23 @@ export interface AgentMessageRow {
   completed_at: Date | string | null
 }
 
+export interface AgentContextCheckpointRow {
+  project_id: string
+  id: string
+  thread_id: string
+  created_by_run_id: string
+  previous_checkpoint_id: string | null
+  reason: AgentContextCheckpointRecord["reason"]
+  summary: string
+  summary_format_version: number | string
+  summarized_through_seq: number | string
+  observed_head_seq: number | string
+  estimated_input_tokens_before: number | string
+  estimated_input_tokens_after: number | string
+  summary_model_id: string
+  created_at: Date | string
+}
+
 // ── row → record mappers ────────────────────────────────────────────────────────────────────────
 
 export function rowToThreadRecord(row: AgentThreadRow): AgentThreadRecord {
@@ -93,21 +105,18 @@ export function rowToRunRecord(row: AgentRunRow): AgentRunRecord {
   return {
     id: row.id,
     projectId: row.project_id,
+    executionId: row.execution_id,
     threadId: row.thread_id,
     agentId: row.agent_id,
     triggerMessageId: row.trigger_message_id,
-    requestedByPrincipal:
-      principalFromColumns(row.requested_by_principal_type, row.requested_by_principal_id) ??
-      SYSTEM_PRINCIPAL,
-    executionPrincipal: serviceAccountPrincipalFromColumns(
-      row.execution_principal_type,
-      row.execution_principal_id
-    ),
+    requesterGroupIds:
+      typeof row.requester_group_ids === "string"
+        ? (JSON.parse(row.requester_group_ids) as string[])
+        : row.requester_group_ids,
     status: row.status,
     modelId: row.model_id ?? undefined,
     finishReason: coerceAgentRunFinishReason(row.finish_reason),
-    usage: rowToUsage(row),
-    error: row.error ?? undefined,
+    error: row.error === null ? undefined : parseSixbFailure(row.error, AGENT_RUN_FAILURE_CODES),
     diagnostics: normalizeDiagnostics(row.diagnostics),
     attempt: Number(row.attempt),
     execution:
@@ -143,6 +152,33 @@ export function rowToMessageRecord(row: AgentMessageRow): AgentMessageRecord {
   }
 }
 
+export function rowToContextCheckpointRecord(
+  row: AgentContextCheckpointRow
+): AgentContextCheckpointRecord {
+  const summaryFormatVersion = Number(row.summary_format_version)
+  if (summaryFormatVersion !== 1) {
+    throw new Error(
+      `[SixbPg] Unsupported agent context checkpoint summary format version '${summaryFormatVersion}'.`
+    )
+  }
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    threadId: row.thread_id,
+    createdByRunId: row.created_by_run_id,
+    previousCheckpointId: row.previous_checkpoint_id ?? undefined,
+    reason: row.reason,
+    summary: row.summary,
+    summaryFormatVersion: 1,
+    summarizedThroughSeq: Number(row.summarized_through_seq),
+    observedHeadSeq: Number(row.observed_head_seq),
+    estimatedInputTokensBefore: Number(row.estimated_input_tokens_before),
+    estimatedInputTokensAfter: Number(row.estimated_input_tokens_after),
+    summaryModelId: row.summary_model_id,
+    createdAt: new Date(row.created_at),
+  }
+}
+
 function principalFromColumns(
   type: Principal["type"] | null | undefined,
   id: string | null | undefined
@@ -150,28 +186,6 @@ function principalFromColumns(
   return type && id ? { type, id } : undefined
 }
 
-function serviceAccountPrincipalFromColumns(
-  type: "serviceAccount" | null | undefined,
-  id: string | null | undefined
-): Extract<Principal, { readonly type: "serviceAccount" }> | undefined {
-  return type === "serviceAccount" && id ? { type, id } : undefined
-}
-
-function rowToUsage(row: AgentRunRow): AgentRunUsage | undefined {
-  const usage: AgentRunUsage = {
-    ...(row.usage_input_tokens === null ? {} : { inputTokens: Number(row.usage_input_tokens) }),
-    ...(row.usage_output_tokens === null ? {} : { outputTokens: Number(row.usage_output_tokens) }),
-    ...(row.usage_total_tokens === null ? {} : { totalTokens: Number(row.usage_total_tokens) }),
-    ...(row.usage_reasoning_tokens === null
-      ? {}
-      : { reasoningTokens: Number(row.usage_reasoning_tokens) }),
-    ...(row.usage_cached_input_tokens === null
-      ? {}
-      : { cachedInputTokens: Number(row.usage_cached_input_tokens) }),
-  }
-  return Object.keys(usage).length === 0 ? undefined : usage
-}
-
 function normalizeMetadata(value: unknown): AgentMessageRecord["metadata"] {
   if (value === null || value === undefined) {
     return undefined

package/src/agents/runs.ts

@@ -1,9 +1,14 @@
+import { assertAgentRunExecution } from "@sixb/core/internal/agent-run-storage-provider"
+import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth"
+import { serializeSixbFailure } from "@sixb/core/internal/errors"
 import {
+  AGENT_RUN_FAILURE_CODES,
   type AgentRunRecord,
   type AgentRunStore,
   AgentStorageError,
   type ConfirmAgentRunExecutionOwnershipInput,
   type CreateAgentRunInput,
+  type ExecutionStorage,
   type FinishAgentRunInput,
   type FinishQueuedAgentRunInput,
   type ListAgentRunsInput,
@@ -20,10 +25,20 @@ import { type AgentRunRow, rowToRunRecord } from "./rows"
 const PG_RUN_ID_BATCH_SIZE = 10_000
 
 export class PgAgentRunStore implements AgentRunStore {
-  constructor(private readonly sql: PgStoreClient) {}
+  constructor(
+    private readonly sql: PgStoreClient,
+    private readonly executions: ExecutionStorage
+  ) {}
 
   async create(input: CreateAgentRunInput): Promise<AgentRunRecord> {
     const createdAt = input.createdAt ?? new Date()
+    await assertAgentRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      agentId: input.agentId,
+    })
 
     try {
       return await runPgTransaction(this.sql, async (tx) => {
@@ -51,22 +66,22 @@ export class PgAgentRunStore implements AgentRunStore {
           INSERT INTO agent_runs (
             project_id,
             id,
+            execution_id,
             thread_id,
             agent_id,
             trigger_message_id,
-            requested_by_principal_type,
-            requested_by_principal_id,
+            requester_group_ids,
             status,
             attempt,
             created_at
           ) VALUES (
             ${input.projectId},
             ${input.id},
+            ${input.executionId},
             ${input.threadId},
             ${input.agentId},
             ${input.triggerMessageId},
-            ${input.requestedByPrincipal.type},
-            ${input.requestedByPrincipal.id},
+            ${JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds))}::text::jsonb,
             ${"queued"},
             ${0},
             ${createdAt}
@@ -101,8 +116,6 @@ export class PgAgentRunStore implements AgentRunStore {
         UPDATE agent_runs
         SET
           status = ${"running"},
-          execution_principal_type = ${input.executionPrincipal?.type ?? null},
-          execution_principal_id = ${input.executionPrincipal?.id ?? null},
           model_id = ${input.modelId ?? null},
           attempt = ${1},
           execution_token = ${input.execution.token},
@@ -121,7 +134,10 @@ export class PgAgentRunStore implements AgentRunStore {
       const run = await this.lockStatus(tx, input.projectId, input.id, "queued")
       const [row] = await tx<AgentRunRow[]>`
         UPDATE agent_runs
-        SET status = ${input.status}, error = ${input.error ?? null}, completed_at = ${completedAt}
+        SET
+          status = ${input.status},
+          error = ${input.error === undefined ? null : serializeSixbFailure(input.error, AGENT_RUN_FAILURE_CODES)}::text::jsonb,
+          completed_at = ${completedAt}
         WHERE project_id = ${input.projectId} AND id = ${input.id}
         RETURNING *
       `
@@ -174,7 +190,10 @@ export class PgAgentRunStore implements AgentRunStore {
 
   async finish(input: FinishAgentRunInput): Promise<AgentRunRecord> {
     const completedAt = input.completedAt ?? new Date()
-    const errorValue = input.status === "succeeded" ? null : (input.error ?? null)
+    const errorValue =
+      input.status === "succeeded" || input.error === undefined
+        ? null
+        : serializeSixbFailure(input.error, AGENT_RUN_FAILURE_CODES)
 
     return runPgTransaction(this.sql, async (tx) => {
       const run = await this.lockRunning(tx, input.projectId, input.id)
@@ -192,12 +211,7 @@ export class PgAgentRunStore implements AgentRunStore {
           status = ${input.status},
           model_id = COALESCE(${input.modelId ?? null}, model_id),
           finish_reason = ${input.finishReason ?? null},
-          usage_input_tokens = ${input.usage?.inputTokens ?? null},
-          usage_output_tokens = ${input.usage?.outputTokens ?? null},
-          usage_total_tokens = ${input.usage?.totalTokens ?? null},
-          usage_reasoning_tokens = ${input.usage?.reasoningTokens ?? null},
-          usage_cached_input_tokens = ${input.usage?.cachedInputTokens ?? null},
-          error = ${errorValue},
+          error = ${errorValue}::text::jsonb,
           diagnostics = ${input.diagnostics === undefined ? null : JSON.stringify(input.diagnostics)}::text::jsonb,
           execution_token = ${null},
           execution_queue_lease_expires_at = ${null},

package/src/auth-storage/service-accounts.ts

@@ -85,28 +85,27 @@ export class PgAuthServiceAccountStore implements AuthServiceAccountStore {
   }
 
   async update(input: UpdateAuthServiceAccountInput): Promise<ServiceAccountRecord> {
-    const existing = await this.getById(input)
-    if (!existing) {
-      throw new AuthStorageError(
-        "missing_service_account",
-        `[Sixb] Service account '${input.id}' not found for project '${input.projectId}'.`
-      )
-    }
-
+    const id = assertNonEmpty(input.id, "Service account id")
+    const projectId = assertNonEmpty(input.projectId, "Project id")
     const updatedAt = dateOrNow(input.updatedAt)
     const name =
-      input.name === undefined ? existing.name : assertNonEmpty(input.name, "Service account name")
-    const description = input.description === undefined ? existing.description : input.description
+      input.name === undefined ? null : assertNonEmpty(input.name, "Service account name")
     const [row] = await this.sql<PgAuthServiceAccountRow[]>`
       UPDATE auth_service_accounts
-      SET name = ${name},
-          description = ${description ?? null},
-          status = ${input.status ?? existing.status},
+      SET name = COALESCE(${name}, name),
+          description = COALESCE(${input.description ?? null}, description),
+          status = COALESCE(${input.status ?? null}, status),
           updated_at = ${updatedAt}
-      WHERE project_id = ${input.projectId}
-        AND id = ${input.id}
+      WHERE project_id = ${projectId}
+        AND id = ${id}
       RETURNING *
     `
+    if (!row) {
+      throw new AuthStorageError(
+        "missing_service_account",
+        `[Sixb] Service account '${id}' not found for project '${projectId}'.`
+      )
+    }
 
     return rowToServiceAccountRecord(row)
   }

package/src/auth-storage/shared.ts

@@ -128,14 +128,6 @@ export async function getUserRowByEmail(
   return row ?? null
 }
 
-export async function getUserByEmail(
-  sql: SQLClient,
-  params: { readonly projectId: string; readonly email: string }
-): Promise<UserRecord | null> {
-  const row = await getUserRowByEmail(sql, params)
-  return row ? rowToUserRecord(row) : null
-}
-
 export async function requireUserById(
   sql: SQLClient,
   params: { readonly projectId: string; readonly id: string }