@sixb/pg 0.1.0 → 0.1.2

package/src/pg-webhook-run-storage.ts

@@ -1,91 +1,126 @@
+import { parseSixbFailure, serializeSixbFailure } from "@sixb/core/internal/errors"
+import { assertWebhookRunExecution } from "@sixb/core/internal/webhook-run-storage-provider"
 import type {
+  ExecutionStorage,
   FinishWebhookRunInput,
+  GetWebhookRunByDeliveryInput,
   ListWebhookRunsInput,
   ListWebhookRunsResult,
+  RestartWebhookRunInput,
   StartWebhookRunInput,
   WebhookRunRecord,
   WebhookRunStorage,
 } from "@sixb/core/storage"
-import { WebhookRunError } from "@sixb/core/storage"
+import { canRetryWebhookRun, WEBHOOK_RUN_FAILURE_CODES, WebhookRunError } from "@sixb/core/storage"
 import type { SqlParameter } from "./pg-client"
 import { appendRunListFilters, hasEmptyStatuses, queryRunList } from "./run-list-query"
 import { isUniqueViolation } from "./storage-errors"
 import { type PgStoreClient, runPgTransaction } from "./transactions"
 
 export class PgWebhookRunStorage implements WebhookRunStorage {
-  constructor(private readonly sql: PgStoreClient) {}
+  constructor(
+    private readonly sql: PgStoreClient,
+    private readonly executions: ExecutionStorage
+  ) {}
 
   async start(input: StartWebhookRunInput): Promise<WebhookRunRecord> {
+    await assertWebhookRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      route: input.route,
+    })
     try {
       const [row] = await this.sql<WebhookRunDatabaseRow[]>`
         INSERT INTO webhook_runs (
-          project_id,
-          id,
-          connector_id,
-          webhook_id,
-          status,
-          method,
-          route,
-          started_at
+          project_id, id, execution_id, connector_id, webhook_id, status, method, route,
+          started_at, request_body_bytes, request_body_sha256, idempotency_key
         ) VALUES (
-          ${input.projectId},
-          ${input.id},
-          ${input.connectorId},
-          ${input.webhookId},
-          ${"running"},
-          ${input.method},
-          ${input.route},
-          ${input.startedAt ?? new Date()}
+          ${input.projectId}, ${input.id}, ${input.executionId}, ${input.connectorId},
+          ${input.webhookId}, ${"running"}, ${input.method}, ${input.route},
+          ${input.startedAt ?? new Date()}, ${input.requestBodyBytes},
+          ${input.requestBodySha256}, ${input.idempotencyKey ?? null}
         )
         RETURNING *
       `
-
       return rowToWebhookRunRecord(row)
     } catch (error) {
       if (isUniqueViolation(error)) {
         throw new WebhookRunError(
-          `[SixbPg] Webhook run '${input.id}' already exists for project '${input.projectId}'.`
+          `[SixbPg] Webhook run '${input.id}' or delivery key already exists for project '${input.projectId}'.`,
+          "duplicate_run"
         )
       }
-
       throw error
     }
   }
 
-  async finish(input: FinishWebhookRunInput): Promise<WebhookRunRecord> {
+  async restart(input: RestartWebhookRunInput): Promise<WebhookRunRecord> {
     return runPgTransaction(this.sql, async (tx) => {
       const [existing] = await tx<WebhookRunDatabaseRow[]>`
         SELECT * FROM webhook_runs
         WHERE project_id = ${input.projectId} AND id = ${input.id}
         FOR UPDATE
       `
-
       if (!existing) {
         throw new WebhookRunError(
-          `[SixbPg] Webhook run '${input.id}' not found for project '${input.projectId}'.`
+          `[SixbPg] Webhook run '${input.id}' not found for project '${input.projectId}'.`,
+          "not_found"
+        )
+      }
+      if (!canRetryWebhookRun(rowToWebhookRunRecord(existing))) {
+        throw new WebhookRunError(
+          `[SixbPg] Webhook run '${input.id}' cannot restart from status '${existing.status}'.`,
+          "invalid_transition"
+        )
+      }
+
+      const [updated] = await tx<WebhookRunDatabaseRow[]>`
+        UPDATE webhook_runs
+        SET status = ${"running"}, started_at = ${input.startedAt ?? new Date()},
+            finished_at = ${null}, response_status = ${null}, error = ${null}
+        WHERE project_id = ${input.projectId} AND id = ${input.id} AND status = ${"failed"}
+        RETURNING *
+      `
+      if (!updated) {
+        throw new WebhookRunError(
+          `[SixbPg] Webhook run '${input.id}' changed while restarting.`,
+          "invalid_transition"
         )
       }
+      return rowToWebhookRunRecord(updated)
+    })
+  }
 
+  async finish(input: FinishWebhookRunInput): Promise<WebhookRunRecord> {
+    return runPgTransaction(this.sql, async (tx) => {
+      const [existing] = await tx<WebhookRunDatabaseRow[]>`
+        SELECT * FROM webhook_runs
+        WHERE project_id = ${input.projectId} AND id = ${input.id}
+        FOR UPDATE
+      `
+      if (!existing) {
+        throw new WebhookRunError(
+          `[SixbPg] Webhook run '${input.id}' not found for project '${input.projectId}'.`,
+          "not_found"
+        )
+      }
       if (existing.status !== "running") {
         throw new WebhookRunError(
-          `[SixbPg] Webhook run '${input.id}' for project '${input.projectId}' is already terminal.`
+          `[SixbPg] Webhook run '${input.id}' for project '${input.projectId}' is already terminal.`,
+          "invalid_transition"
         )
       }
 
       const [updated] = await tx<WebhookRunDatabaseRow[]>`
         UPDATE webhook_runs
-        SET
-          status = ${input.status},
-          finished_at = ${input.finishedAt ?? new Date()},
-          request_body_bytes = ${input.requestBodyBytes ?? null},
-          response_status = ${input.responseStatus ?? null},
-          idempotency_key = ${input.idempotencyKey ?? null},
-          delivery_claim_result = ${input.deliveryClaimResult ?? null},
-          error = ${input.status === "succeeded" ? null : (input.error ?? null)}
+        SET status = ${input.status}, finished_at = ${input.finishedAt ?? new Date()},
+            response_status = ${input.responseStatus ?? null},
+            error = ${input.status === "succeeded" ? null : serializeSixbFailure(input.error, WEBHOOK_RUN_FAILURE_CODES)}::text::jsonb
         WHERE project_id = ${input.projectId} AND id = ${input.id}
         RETURNING *
       `
-
       return rowToWebhookRunRecord(updated)
     })
   }
@@ -95,38 +130,38 @@ export class PgWebhookRunStorage implements WebhookRunStorage {
       SELECT * FROM webhook_runs
       WHERE project_id = ${params.projectId} AND id = ${params.id}
     `
+    return row ? rowToWebhookRunRecord(row) : null
+  }
 
+  async getByDelivery(input: GetWebhookRunByDeliveryInput): Promise<WebhookRunRecord | null> {
+    const [row] = await this.sql<WebhookRunDatabaseRow[]>`
+      SELECT * FROM webhook_runs
+      WHERE project_id = ${input.projectId}
+        AND connector_id = ${input.connectorId}
+        AND webhook_id = ${input.webhookId}
+        AND idempotency_key = ${input.idempotencyKey}
+    `
     return row ? rowToWebhookRunRecord(row) : null
   }
 
   async list(input: ListWebhookRunsInput): Promise<ListWebhookRunsResult> {
-    if (hasEmptyStatuses(input)) {
-      return {
-        runs: [],
-        hasMore: false,
-        total: 0,
-      }
-    }
+    if (hasEmptyStatuses(input)) return { runs: [], hasMore: false, total: 0 }
 
     const whereClauses = ["project_id = $1"]
     const params: SqlParameter[] = [input.projectId]
     let index = 2
-
     if (input.connectorId) {
       whereClauses.push(`connector_id = $${index++}`)
       params.push(input.connectorId)
     }
-
     if (input.webhookId) {
       whereClauses.push(`webhook_id = $${index++}`)
       params.push(input.webhookId)
     }
-
     if (input.idempotencyKey) {
       whereClauses.push(`idempotency_key = $${index++}`)
       params.push(input.idempotencyKey)
     }
-
     index = appendRunListFilters(whereClauses, params, index, input)
 
     const { rows, total, hasMore } = await queryRunList<WebhookRunDatabaseRow>({
@@ -139,12 +174,7 @@ export class PgWebhookRunStorage implements WebhookRunStorage {
       limit: input.limit,
       offset: input.offset,
     })
-
-    return {
-      runs: rows.map(rowToWebhookRunRecord),
-      hasMore,
-      total,
-    }
+    return { runs: rows.map(rowToWebhookRunRecord), hasMore, total }
   }
 }
 
@@ -152,6 +182,7 @@ function rowToWebhookRunRecord(row: WebhookRunDatabaseRow): WebhookRunRecord {
   return {
     id: row.id,
     projectId: row.project_id,
+    executionId: row.execution_id,
     connectorId: row.connector_id,
     webhookId: row.webhook_id,
     status: row.status,
@@ -159,17 +190,18 @@ function rowToWebhookRunRecord(row: WebhookRunDatabaseRow): WebhookRunRecord {
     route: row.route,
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
-    requestBodyBytes: row.request_body_bytes != null ? Number(row.request_body_bytes) : undefined,
+    requestBodyBytes: Number(row.request_body_bytes),
+    requestBodySha256: row.request_body_sha256,
     responseStatus: row.response_status != null ? Number(row.response_status) : undefined,
     idempotencyKey: row.idempotency_key ?? undefined,
-    deliveryClaimResult: row.delivery_claim_result ?? undefined,
-    error: row.error ?? undefined,
+    error: row.error === null ? undefined : parseSixbFailure(row.error, WEBHOOK_RUN_FAILURE_CODES),
   }
 }
 
 interface WebhookRunDatabaseRow {
   readonly project_id: string
   readonly id: string
+  readonly execution_id: string
   readonly connector_id: string
   readonly webhook_id: string
   readonly status: WebhookRunRecord["status"]
@@ -177,9 +209,9 @@ interface WebhookRunDatabaseRow {
   readonly route: string
   readonly started_at: Date | string
   readonly finished_at: Date | string | null
-  readonly request_body_bytes: number | string | null
+  readonly request_body_bytes: number | string
+  readonly request_body_sha256: string
   readonly response_status: number | string | null
   readonly idempotency_key: string | null
-  readonly delivery_claim_result: WebhookRunRecord["deliveryClaimResult"] | null
-  readonly error: string | null
+  readonly error: unknown | null
 }

package/src/pg-workflow-run-storage.ts

@@ -1,10 +1,17 @@
-import type { Principal, WorkflowRunSource } from "@sixb/core"
+import type { JsonValue } from "@sixb/core"
+import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth"
+import { parseSixbFailure, serializeSixbFailure } from "@sixb/core/internal/errors"
+import {
+  assertWorkflowAgentNodeRunExecution,
+  assertWorkflowRunExecution,
+} from "@sixb/core/internal/workflow-run-storage-provider"
 import type { WorkflowIOSnapshot } from "@sixb/core/internal/workflows"
 import type {
   CancelWorkflowAgentNodeRunInput,
   ConfirmWorkflowAgentNodeRunExecutionOwnershipInput,
   ConfirmWorkflowRunExecutionOwnershipInput,
   CreateWorkflowAgentNodeRunInput,
+  ExecutionStorage,
   FinishWorkflowAgentNodeRunInput,
   FinishWorkflowNodeRunInput,
   FinishWorkflowRunInput,
@@ -32,7 +39,11 @@ import type {
   WorkflowRunRecord,
   WorkflowRunStorage,
 } from "@sixb/core/storage"
-import { WorkflowRunError } from "@sixb/core/storage"
+import {
+  AGENT_RUN_FAILURE_CODES,
+  WORKFLOW_RUN_FAILURE_CODES,
+  WorkflowRunError,
+} from "@sixb/core/storage"
 import { queryLatestRunsByOwnerId } from "./latest-run-query"
 import type { SqlParameter } from "./pg-client"
 import { appendRunListFilters, hasEmptyStatuses, queryRunList } from "./run-list-query"
@@ -43,39 +54,47 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
   readonly nodes: PgWorkflowNodeRunStorage
   readonly agentNodes: PgWorkflowAgentNodeRunStorage
 
-  constructor(private readonly sql: PgStoreClient) {
+  constructor(
+    private readonly sql: PgStoreClient,
+    private readonly executions: ExecutionStorage
+  ) {
     this.nodes = new PgWorkflowNodeRunStorage(sql)
-    this.agentNodes = new PgWorkflowAgentNodeRunStorage(sql)
+    this.agentNodes = new PgWorkflowAgentNodeRunStorage(sql, executions)
   }
 
   async queue(input: QueueWorkflowRunInput): Promise<WorkflowRunRecord> {
     const queuedAt = input.queuedAt ?? new Date()
+    await assertWorkflowRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      workflowId: input.workflowId,
+    })
 
     try {
       const [row] = await this.sql<WorkflowRunDatabaseRow[]>`
         INSERT INTO workflow_runs (
           project_id,
           id,
+          execution_id,
           workflow_id,
           status,
           input,
           queued_at,
           started_at,
-          source,
-          requested_by_principal_type,
-          requested_by_principal_id,
+          requester_group_ids,
           attempt
         ) VALUES (
           ${input.projectId},
           ${input.id},
+          ${input.executionId},
           ${input.workflowId},
           ${"queued"},
           ${serializeRecord(input.input)}::text::jsonb,
           ${queuedAt},
           ${queuedAt},
-          ${input.source ? JSON.stringify(input.source) : null}::text::jsonb,
-          ${input.requestedByPrincipal?.type ?? "system"},
-          ${input.requestedByPrincipal?.id ?? "system"},
+          ${JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds))}::text::jsonb,
           ${0}
         )
         RETURNING *
@@ -85,7 +104,7 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
     } catch (error) {
       if (isUniqueViolation(error)) {
         throw new WorkflowRunError(
-          `[SixbPg] Workflow run '${input.id}' already exists for project '${input.projectId}'.`
+          `[SixbPg] Workflow run '${input.id}' or execution '${input.executionId}' is already linked for project '${input.projectId}'.`
         )
       }
 
@@ -102,83 +121,29 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
         FOR UPDATE
       `
 
-      if (existing) {
-        if (existing.status !== "queued") {
-          throw new WorkflowRunError(
-            `[SixbPg] Workflow run '${input.id}' already exists for project '${input.projectId}'.`
-          )
-        }
-
-        if (existing.workflow_id !== input.workflowId) {
-          throw new WorkflowRunError(
-            `[SixbPg] Workflow run '${input.id}' workflow '${input.workflowId}' does not match existing workflow '${existing.workflow_id}'.`
-          )
-        }
-
-        const [updated] = await tx<WorkflowRunDatabaseRow[]>`
-          UPDATE workflow_runs
-          SET
-            status = ${"running"},
-            input = ${serializeRecord(input.input)}::text::jsonb,
-            started_at = ${startedAt},
-            finished_at = ${null},
-            error = ${null},
-            source = COALESCE(
-              source,
-              ${input.source ? JSON.stringify(input.source) : null}::text::jsonb
-            ),
-            attempt = attempt + 1,
-            execution_token = ${input.execution?.token ?? null},
-            execution_queue_lease_expires_at = ${input.execution?.queueLeaseExpiresAt ?? null}
-          WHERE project_id = ${input.projectId} AND id = ${input.id}
-          RETURNING *
-        `
-
-        return rowToWorkflowRunRecord(updated)
+      if (!existing || existing.status !== "queued") {
+        throw new WorkflowRunError(
+          existing
+            ? `[SixbPg] Workflow run '${input.id}' cannot start from status '${existing.status}'.`
+            : `[SixbPg] Workflow run '${input.id}' not found for project '${input.projectId}'.`
+        )
       }
 
-      try {
-        const [row] = await tx<WorkflowRunDatabaseRow[]>`
-          INSERT INTO workflow_runs (
-            project_id,
-            id,
-            workflow_id,
-            status,
-            input,
-            started_at,
-            source,
-            requested_by_principal_type,
-            requested_by_principal_id,
-            attempt,
-            execution_token,
-            execution_queue_lease_expires_at
-          ) VALUES (
-            ${input.projectId},
-            ${input.id},
-            ${input.workflowId},
-            ${"running"},
-            ${serializeRecord(input.input)}::text::jsonb,
-            ${startedAt},
-            ${input.source ? JSON.stringify(input.source) : null}::text::jsonb,
-            ${input.requestedByPrincipal?.type ?? "system"},
-            ${input.requestedByPrincipal?.id ?? "system"},
-            ${1},
-            ${input.execution?.token ?? null},
-            ${input.execution?.queueLeaseExpiresAt ?? null}
-          )
-          RETURNING *
-        `
-
-        return rowToWorkflowRunRecord(row)
-      } catch (error) {
-        if (isUniqueViolation(error)) {
-          throw new WorkflowRunError(
-            `[SixbPg] Workflow run '${input.id}' already exists for project '${input.projectId}'.`
-          )
-        }
+      const [updated] = await tx<WorkflowRunDatabaseRow[]>`
+        UPDATE workflow_runs
+        SET
+          status = ${"running"},
+          started_at = ${startedAt},
+          finished_at = ${null},
+          error = ${null},
+          attempt = attempt + 1,
+          execution_token = ${input.execution?.token ?? null},
+          execution_queue_lease_expires_at = ${input.execution?.queueLeaseExpiresAt ?? null}
+        WHERE project_id = ${input.projectId} AND id = ${input.id}
+        RETURNING *
+      `
 
-        throw error
-      }
+      return rowToWorkflowRunRecord(updated)
     })
   }
 
@@ -245,6 +210,7 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
               SET
                 status = ${input.status},
                 finished_at = ${input.finishedAt ?? new Date()},
+                output = ${serializeRecord(input.output)}::text::jsonb,
                 error = ${null},
                 execution_token = ${null},
                 execution_queue_lease_expires_at = ${null}
@@ -256,7 +222,8 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
               SET
                 status = ${input.status},
                 finished_at = ${input.finishedAt ?? new Date()},
-                error = ${input.error ?? null},
+                output = ${null},
+                error = ${input.error === undefined ? null : serializeSixbFailure(input.error, WORKFLOW_RUN_FAILURE_CODES)}::text::jsonb,
                 execution_token = ${null},
                 execution_queue_lease_expires_at = ${null}
               WHERE project_id = ${input.projectId} AND id = ${input.id}
@@ -414,16 +381,43 @@ export class PgWorkflowRunStorage implements WorkflowRunStorage {
 }
 
 export class PgWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunStorage {
-  constructor(private readonly sql: PgStoreClient) {}
+  constructor(
+    private readonly sql: PgStoreClient,
+    private readonly executions: ExecutionStorage
+  ) {}
 
   async create(input: CreateWorkflowAgentNodeRunInput): Promise<WorkflowAgentNodeRunRecord> {
+    const [parent] = await this.sql<{ execution_id: string }[]>`
+      SELECT workflow_runs.execution_id
+      FROM workflow_node_runs
+      JOIN workflow_runs
+        ON workflow_runs.project_id = workflow_node_runs.project_id
+        AND workflow_runs.id = workflow_node_runs.workflow_run_id
+      WHERE workflow_node_runs.project_id = ${input.projectId}
+        AND workflow_node_runs.id = ${input.nodeRunId}
+        AND workflow_node_runs.node_type = ${"agent"}
+    `
+    if (!parent) {
+      throw new WorkflowRunError(
+        `[SixbPg] Agent workflow node run '${input.nodeRunId}' was not found.`
+      )
+    }
+    await assertWorkflowAgentNodeRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      nodeRunId: input.nodeRunId,
+      agentId: input.agentId,
+      workflowExecutionId: parent.execution_id,
+    })
+
     try {
       const [row] = await this.sql<WorkflowAgentNodeRunDatabaseRow[]>`
         INSERT INTO workflow_agent_node_runs (
-          project_id, node_run_id, agent_id, status, prompt, attempt, created_at
+          project_id, node_run_id, execution_id, agent_id, status, prompt, attempt, created_at
         ) VALUES (
-          ${input.projectId}, ${input.nodeRunId}, ${input.agentId}, ${"queued"},
-          ${input.prompt}, ${0}, ${input.createdAt ?? new Date()}
+          ${input.projectId}, ${input.nodeRunId}, ${input.executionId}, ${input.agentId},
+          ${"queued"}, ${input.prompt}, ${0}, ${input.createdAt ?? new Date()}
         ) RETURNING *
       `
       return rowToWorkflowAgentNodeRunRecord(row)
@@ -443,8 +437,6 @@ export class PgWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunStorag
       const [updated] = await tx<WorkflowAgentNodeRunDatabaseRow[]>`
         UPDATE workflow_agent_node_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},
@@ -502,10 +494,9 @@ export class PgWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunStorag
           status = ${input.status},
           model_id = COALESCE(${input.modelId ?? null}, model_id),
           finish_reason = ${input.finishReason ?? null},
-          usage = ${input.usage ? JSON.stringify(input.usage) : null}::text::jsonb,
           trace = ${input.trace ? JSON.stringify(input.trace) : null}::text::jsonb,
           diagnostics = ${input.diagnostics ? JSON.stringify(input.diagnostics) : null}::text::jsonb,
-          error = ${input.status === "succeeded" ? null : (input.error ?? null)},
+          error = ${input.status === "succeeded" || input.error === undefined ? null : serializeSixbFailure(input.error, AGENT_RUN_FAILURE_CODES)}::text::jsonb,
           execution_token = ${null},
           execution_queue_lease_expires_at = ${null},
           completed_at = ${input.completedAt ?? new Date()}
@@ -536,7 +527,7 @@ export class PgWorkflowAgentNodeRunStorage implements WorkflowAgentNodeRunStorag
       const [updated] = await tx<WorkflowAgentNodeRunDatabaseRow[]>`
         UPDATE workflow_agent_node_runs SET
           status = ${"cancelled"},
-          error = ${input.error ?? null},
+          error = ${input.error === undefined ? null : serializeSixbFailure(input.error, AGENT_RUN_FAILURE_CODES)}::text::jsonb,
           execution_token = ${null},
           execution_queue_lease_expires_at = ${null},
           completed_at = ${input.completedAt ?? new Date()}
@@ -696,7 +687,7 @@ export class PgWorkflowNodeRunStorage implements WorkflowNodeRunStorage {
                 status = ${input.status},
                 finished_at = ${input.finishedAt ?? new Date()},
                 output = ${null},
-                error = ${input.error ?? null}
+                error = ${input.error === undefined ? null : serializeSixbFailure(input.error, WORKFLOW_RUN_FAILURE_CODES)}::text::jsonb
               WHERE project_id = ${input.projectId} AND id = ${input.id}
               RETURNING *
             `
@@ -822,18 +813,16 @@ function rowToWorkflowRunRecord(row: WorkflowRunDatabaseRow): WorkflowRunRecord
   return {
     id: row.id,
     projectId: row.project_id,
+    executionId: row.execution_id,
     workflowId: row.workflow_id,
     status: row.status,
     input: parseRecord(row.input),
+    output: row.output ? parseRecord(row.output) : undefined,
     queuedAt: row.queued_at ? new Date(row.queued_at) : undefined,
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
-    error: row.error ?? undefined,
-    source: parseSource(row.source),
-    requestedByPrincipal: {
-      type: row.requested_by_principal_type,
-      id: row.requested_by_principal_id,
-    },
+    error: row.error === null ? undefined : parseSixbFailure(row.error, WORKFLOW_RUN_FAILURE_CODES),
+    requesterGroupIds: parseJson(row.requester_group_ids),
     attempt: Number(row.attempt),
     ...(row.execution_token && row.execution_queue_lease_expires_at
       ? {
@@ -846,14 +835,6 @@ function rowToWorkflowRunRecord(row: WorkflowRunDatabaseRow): WorkflowRunRecord
   }
 }
 
-function parseSource(value: WorkflowRunSource | string | null): WorkflowRunSource | undefined {
-  if (value === null || value === undefined) {
-    return undefined
-  }
-
-  return typeof value === "string" ? (JSON.parse(value) as WorkflowRunSource) : value
-}
-
 function rowToWorkflowNodeRunRecord(row: WorkflowNodeRunDatabaseRow): WorkflowNodeRunRecord {
   return {
     id: row.id,
@@ -869,7 +850,7 @@ function rowToWorkflowNodeRunRecord(row: WorkflowNodeRunDatabaseRow): WorkflowNo
     startedAt: new Date(row.started_at),
     finishedAt: row.finished_at ? new Date(row.finished_at) : undefined,
     output: row.output ? parseRecord(row.output) : undefined,
-    error: row.error ?? undefined,
+    error: row.error === null ? undefined : parseSixbFailure(row.error, WORKFLOW_RUN_FAILURE_CODES),
   }
 }
 
@@ -893,16 +874,16 @@ function canFinishWorkflowRun(
 interface WorkflowRunDatabaseRow {
   project_id: string
   id: string
+  execution_id: string
   workflow_id: string
   status: WorkflowRunRecord["status"]
   input: WorkflowIOSnapshot | string
+  output: WorkflowIOSnapshot | string | null
   queued_at: Date | string | null
   started_at: Date | string
   finished_at: Date | string | null
-  error: string | null
-  source: WorkflowRunSource | string | null
-  requested_by_principal_type: Principal["type"]
-  requested_by_principal_id: string
+  error: JsonValue | null
+  requester_group_ids: string[] | string
   attempt: number | string
   execution_token: string | null
   execution_queue_lease_expires_at: Date | string | null
@@ -922,23 +903,21 @@ interface WorkflowNodeRunDatabaseRow {
   started_at: Date | string
   finished_at: Date | string | null
   output: WorkflowIOSnapshot | string | null
-  error: string | null
+  error: JsonValue | null
 }
 
 interface WorkflowAgentNodeRunDatabaseRow {
   project_id: string
   node_run_id: string
+  execution_id: string
   agent_id: string
   status: WorkflowAgentNodeRunRecord["status"]
   prompt: string
-  execution_principal_type: "serviceAccount" | null
-  execution_principal_id: string | null
   model_id: string | null
   finish_reason: WorkflowAgentNodeRunRecord["finishReason"] | null
-  usage: WorkflowAgentNodeRunRecord["usage"] | string | null
   trace: WorkflowAgentNodeRunRecord["trace"] | string | null
   diagnostics: WorkflowAgentNodeRunRecord["diagnostics"] | string | null
-  error: string | null
+  error: JsonValue | null
   attempt: number | string
   execution_token: string | null
   execution_queue_lease_expires_at: Date | string | null
@@ -988,23 +967,15 @@ function rowToWorkflowAgentNodeRunRecord(
   return {
     projectId: row.project_id,
     nodeRunId: row.node_run_id,
+    executionId: row.execution_id,
     agentId: row.agent_id,
     status: row.status,
     prompt: row.prompt,
-    ...(row.execution_principal_type && row.execution_principal_id
-      ? {
-          executionPrincipal: {
-            type: row.execution_principal_type,
-            id: row.execution_principal_id,
-          },
-        }
-      : {}),
     ...(row.model_id ? { modelId: row.model_id } : {}),
     ...(row.finish_reason ? { finishReason: row.finish_reason } : {}),
-    ...(row.usage ? { usage: parseJson(row.usage) } : {}),
     ...(row.trace ? { trace: parseJson(row.trace) } : {}),
     ...(row.diagnostics ? { diagnostics: parseJson(row.diagnostics) } : {}),
-    ...(row.error ? { error: row.error } : {}),
+    ...(row.error ? { error: parseSixbFailure(row.error, AGENT_RUN_FAILURE_CODES) } : {}),
     attempt: Number(row.attempt),
     ...(row.execution_token && row.execution_queue_lease_expires_at
       ? {