@sixb/core 0.1.1 → 0.1.3

package/src/storage/projection-runs/types.ts

@@ -1,3 +1,4 @@
+import type { SixbFailure } from "../../errors/types"
 import type {
   PinnedDatasetVersion,
   ProjectionExecution,
@@ -8,10 +9,14 @@ import type {
   LinkProjectionTarget,
   ObjectProjectionTarget,
   ProjectionKind,
+  ProjectionRunFailureCode,
   ProjectionTarget,
 } from "../../projections/types"
 
-export type ProjectionRunStatus = "running" | "succeeded" | "failed" | "cancelled"
+export type { ProjectionRunFailureCode } from "../../projections/types"
+export { PROJECTION_RUN_FAILURE_CODES } from "../../projections/types"
+
+export type ProjectionRunStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled"
 
 export interface ProjectionRunProgress {
   /** Physical immutable-version rows consumed, before normalization or semantic materialization. */
@@ -63,12 +68,14 @@ export interface ProjectionMissingTarget {
 interface ProjectionRunRecordBase {
   readonly id: string
   readonly projectId: string
+  readonly executionId: string
   readonly status: ProjectionRunStatus
   readonly attempt: number
   readonly progress: ProjectionRunProgress
-  readonly startedAt: Date
+  readonly queuedAt: Date
+  readonly startedAt?: Date
   readonly finishedAt?: Date
-  readonly errorMessage?: string
+  readonly error?: SixbFailure<ProjectionRunFailureCode>
 }
 
 type ProjectionIdentity<TKind extends ProjectionKind> = Extract<
@@ -118,29 +125,43 @@ export function projectionRunObjectTypesVisible(
   return canView(target.objectTypeId)
 }
 
-interface StartOrReclaimProjectionRunBase {
+interface ProjectionRunAdmissionBase {
   readonly id: string
   readonly projectId: string
-  readonly startedAt?: Date
+  readonly executionId: string
+  readonly queuedAt?: Date
 }
 
-export type StartOrReclaimProjectionRunInput =
-  | (StartOrReclaimProjectionRunBase & {
+export type QueueProjectionRunInput =
+  | (ProjectionRunAdmissionBase & {
       readonly identity: ProjectionIdentity<"object">
       readonly target: ObjectProjectionRunRecord["target"]
       readonly fixedBatchSize?: never
     })
-  | (StartOrReclaimProjectionRunBase & {
+  | (ProjectionRunAdmissionBase & {
       readonly identity: ProjectionIdentity<"link">
       readonly target: LinkProjectionRunRecord["target"]
       readonly fixedBatchSize?: never
     })
-  | (StartOrReclaimProjectionRunBase & {
+  | (ProjectionRunAdmissionBase & {
       readonly identity: ProjectionIdentity<"telemetry">
       readonly target: TelemetryProjectionRunRecord["target"]
       readonly fixedBatchSize: number
     })
 
+export type StartOrReclaimProjectionRunInput = QueueProjectionRunInput extends infer TInput
+  ? TInput extends QueueProjectionRunInput
+    ? Omit<TInput, "executionId" | "queuedAt"> & { readonly startedAt?: Date }
+    : never
+  : never
+
+export interface FailProjectionRunEnqueueInput {
+  readonly id: string
+  readonly projectId: string
+  readonly finishedAt?: Date
+  readonly error: SixbFailure<ProjectionRunFailureCode>
+}
+
 export interface ProjectionRunClaim {
   readonly run: ProjectionRunRecord
   readonly execution: ProjectionExecution
@@ -187,8 +208,8 @@ export interface ListProjectionRunsInput {
   readonly datasetId?: string
   readonly datasetVersionId?: string
   /**
-   * Viewable object type ids. A run is included only if every target type is present. Omit for a
-   * privileged caller; an empty set matches no runs.
+   * Viewable object type ids. A run is included only if every target type is present. Omit for an
+   * unrestricted internal execution; an empty set matches no runs.
    */
   readonly objectTypeIds?: readonly string[]
   readonly statuses?: readonly ProjectionRunStatus[]
@@ -215,7 +236,9 @@ export interface ListLatestProjectionRunsResult {
 }
 
 export interface ProjectionRunStorage {
+  queue(input: QueueProjectionRunInput): Promise<ProjectionRunRecord>
   startOrReclaim(input: StartOrReclaimProjectionRunInput): Promise<ProjectionRunClaim>
+  failEnqueue(input: FailProjectionRunEnqueueInput): Promise<ProjectionRunRecord>
   /** Transactionally fences the current execution before ontology materialization writes. */
   lockForMaterialization(
     input: LockProjectionRunForMaterializationInput

package/src/storage/run-listing.ts

@@ -6,13 +6,8 @@ export { paginate } from "./pagination"
 export interface StartedAtRunRecord<TStatus extends string = string> {
   readonly id: string
   readonly status: TStatus
-  readonly startedAt: Date
-}
-
-export interface RunListDateFilters<TStatus extends string = string> {
-  readonly statuses?: readonly TStatus[]
-  readonly startedAfter?: Date
-  readonly startedBefore?: Date
+  readonly startedAt?: Date
+  readonly queuedAt?: Date
 }
 
 export function storageKey(projectId: string, id: string): string {
@@ -45,11 +40,13 @@ export function matchesRunListDateFilters<TStatus extends string>(
     return false
   }
 
-  if (filters.startedAfter && record.startedAt < filters.startedAfter) {
+  const startedAt = effectiveStartedAt(record)
+
+  if (filters.startedAfter && startedAt < filters.startedAfter) {
     return false
   }
 
-  if (filters.startedBefore && record.startedAt > filters.startedBefore) {
+  if (filters.startedBefore && startedAt > filters.startedBefore) {
     return false
   }
 
@@ -57,11 +54,11 @@ export function matchesRunListDateFilters<TStatus extends string>(
 }
 
 export function compareStartedAt(
-  left: { readonly id: string; readonly startedAt: Date },
-  right: { readonly id: string; readonly startedAt: Date },
+  left: { readonly id: string; readonly startedAt?: Date; readonly queuedAt?: Date },
+  right: { readonly id: string; readonly startedAt?: Date; readonly queuedAt?: Date },
   order: RunListOrder
 ): number {
-  const delta = left.startedAt.getTime() - right.startedAt.getTime()
+  const delta = effectiveStartedAt(left).getTime() - effectiveStartedAt(right).getTime()
   if (delta !== 0) {
     return order === "asc" ? delta : -delta
   }
@@ -74,7 +71,7 @@ export function compareStartedAt(
 }
 
 export function latestStartedAtByOwnerId<
-  TRecord extends { readonly id: string; readonly startedAt: Date },
+  TRecord extends { readonly id: string; readonly startedAt?: Date; readonly queuedAt?: Date },
 >(
   records: readonly TRecord[],
   ownerIds: readonly string[],
@@ -105,3 +102,15 @@ export function latestStartedAtByOwnerId<
     return record ? [record] : []
   })
 }
+
+function effectiveStartedAt(record: {
+  readonly id: string
+  readonly startedAt?: Date
+  readonly queuedAt?: Date
+}): Date {
+  const value = record.startedAt ?? record.queuedAt
+  if (!value) {
+    throw new Error(`[Sixb] Run '${record.id}' has neither startedAt nor queuedAt.`)
+  }
+  return value
+}

package/src/storage/sync-runs/idempotency.ts

@@ -0,0 +1,18 @@
+import type { QueueSyncRunInput, SyncRunRecord } from "./types"
+
+export function canRequeueSyncRunAfterEnqueueFailure(
+  existing: SyncRunRecord,
+  input: QueueSyncRunInput
+): boolean {
+  return (
+    existing.status === "failed" &&
+    existing.error?.code === "queue.enqueue_failed" &&
+    existing.error.retryable &&
+    existing.executionId === input.executionId &&
+    existing.syncId === input.syncId &&
+    existing.datasetId === input.datasetId &&
+    existing.mode === input.mode &&
+    existing.expectedLatestVersionId === input.expectedLatestVersionId &&
+    existing.commitMessage === input.commitMessage
+  )
+}

package/src/storage/sync-runs/in-memory.ts

@@ -1,4 +1,7 @@
+import { parseSixbFailure } from "../../errors/internal"
+import type { SixbFailure } from "../../errors/types"
 import { cloneJsonValue, type JsonValue } from "../../json"
+import type { ExecutionStorage } from "../executions"
 import {
   compareStartedAt,
   hasEmptyStatuses,
@@ -8,17 +11,21 @@ import {
   toStatusSet,
 } from "../run-listing"
 import { SyncRunError } from "./errors"
+import { canRequeueSyncRunAfterEnqueueFailure } from "./idempotency"
+import { assertSyncRunExecution } from "./provider"
 import type {
   FinishSyncRunInput,
   ListLatestSyncRunsInput,
   ListLatestSyncRunsResult,
   ListSyncRunsInput,
   ListSyncRunsResult,
+  QueueSyncRunInput,
   StartSyncRunInput,
-  SyncRunFailure,
+  SyncRunFailureCode,
   SyncRunRecord,
   SyncRunStorage,
 } from "./types"
+import { SYNC_RUN_FAILURE_CODES } from "./types"
 
 function syncRunKey(projectId: string, id: string): string {
   return `${projectId}:${id}`
@@ -32,13 +39,17 @@ function normalizeCheckpoint(checkpoint: JsonValue | undefined): JsonValue | und
   return checkpoint !== undefined ? cloneJsonValue(checkpoint) : undefined
 }
 
-function normalizeError(error: SyncRunFailure | undefined): SyncRunFailure | undefined {
-  return error ? structuredClone(error) : undefined
+function normalizeError(
+  error: SixbFailure<SyncRunFailureCode> | undefined
+): SixbFailure<SyncRunFailureCode> | undefined {
+  return error ? parseSixbFailure(error, SYNC_RUN_FAILURE_CODES) : undefined
 }
 
 export class InMemorySyncRunStorage implements SyncRunStorage {
   private readonly rows = new Map<string, SyncRunRecord>()
 
+  constructor(private readonly executions: ExecutionStorage) {}
+
   snapshot(): InMemorySyncRunStorageSnapshot {
     return structuredClone(this.rows)
   }
@@ -50,22 +61,60 @@ export class InMemorySyncRunStorage implements SyncRunStorage {
     }
   }
 
-  async start(input: StartSyncRunInput): Promise<SyncRunRecord> {
+  async queue(input: QueueSyncRunInput): Promise<SyncRunRecord> {
     const key = syncRunKey(input.projectId, input.id)
-    if (this.rows.has(key)) {
+    const existing = this.rows.get(key)
+    if (existing && !canRequeueSyncRunAfterEnqueueFailure(existing, input)) {
       throw new SyncRunError(
         `[Sixb] Sync run '${input.id}' already exists for project '${input.projectId}'.`
       )
     }
+    if (
+      [...this.rows.values()].some(
+        (run) =>
+          run.projectId === input.projectId &&
+          run.id !== input.id &&
+          run.executionId === input.executionId
+      )
+    ) {
+      throw new SyncRunError(
+        `[Sixb] Execution '${input.executionId}' already belongs to another Sync run.`
+      )
+    }
+    await assertSyncRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+      syncId: input.syncId,
+    })
+
+    const queuedAt = new Date(input.queuedAt ?? new Date())
+    if (existing) {
+      const next: SyncRunRecord = {
+        ...existing,
+        status: "queued",
+        queuedAt,
+        startedAt: undefined,
+        finishedAt: undefined,
+        rowsRead: undefined,
+        output: undefined,
+        error: undefined,
+        checkpoint: undefined,
+      }
+      this.rows.set(key, structuredClone(next))
+      return cloneSyncRunRecord(next)
+    }
 
     const record: SyncRunRecord = {
       id: input.id,
       projectId: input.projectId,
+      executionId: input.executionId,
       syncId: input.syncId,
       datasetId: input.datasetId,
       mode: input.mode,
-      status: "running",
-      startedAt: new Date(input.startedAt ?? new Date()),
+      status: "queued",
+      queuedAt,
       expectedLatestVersionId: input.expectedLatestVersionId,
       commitMessage: input.commitMessage,
     }
@@ -74,6 +123,30 @@ export class InMemorySyncRunStorage implements SyncRunStorage {
     return cloneSyncRunRecord(record)
   }
 
+  async start(input: StartSyncRunInput): Promise<SyncRunRecord> {
+    const key = syncRunKey(input.projectId, input.id)
+    const existing = this.rows.get(key)
+    if (!existing) {
+      throw new SyncRunError(
+        `[Sixb] Sync run '${input.id}' not found for project '${input.projectId}'.`
+      )
+    }
+    if (existing.status !== "queued") {
+      throw new SyncRunError(
+        `[Sixb] Sync run '${input.id}' cannot start from status '${existing.status}'.`
+      )
+    }
+
+    const next: SyncRunRecord = {
+      ...existing,
+      status: "running",
+      startedAt: new Date(input.startedAt ?? new Date()),
+      error: undefined,
+    }
+    this.rows.set(key, structuredClone(next))
+    return cloneSyncRunRecord(next)
+  }
+
   async finish(input: FinishSyncRunInput): Promise<SyncRunRecord> {
     const key = syncRunKey(input.projectId, input.id)
     const existing = this.rows.get(key)
@@ -84,6 +157,16 @@ export class InMemorySyncRunStorage implements SyncRunStorage {
       )
     }
 
+    const enqueueFailure = input.status === "failed" && input.error.code === "queue.enqueue_failed"
+    if (
+      (enqueueFailure && existing.status !== "queued") ||
+      (!enqueueFailure && existing.status !== "running")
+    ) {
+      throw new SyncRunError(
+        `[Sixb] Sync run '${input.id}' cannot finish from status '${existing.status}'.`
+      )
+    }
+
     if (input.status === "succeeded") {
       if (input.output && input.output.datasetId !== existing.datasetId) {
         throw new SyncRunError(

package/src/storage/sync-runs/index.ts

@@ -1,4 +1,5 @@
 export { SyncRunError } from "./errors"
+export { canRequeueSyncRunAfterEnqueueFailure } from "./idempotency"
 export { InMemorySyncRunStorage } from "./in-memory"
 export type {
   FinishSyncRunInput,
@@ -6,10 +7,12 @@ export type {
   ListLatestSyncRunsResult,
   ListSyncRunsInput,
   ListSyncRunsResult,
+  QueueSyncRunInput,
   StartSyncRunInput,
-  SyncRunFailure,
+  SyncRunFailureCode,
   SyncRunMode,
   SyncRunRecord,
   SyncRunStatus,
   SyncRunStorage,
 } from "./types"
+export { SYNC_RUN_FAILURE_CODES } from "./types"

package/src/storage/sync-runs/provider.ts

@@ -0,0 +1,25 @@
+import type { ExecutionStorage } from "../executions"
+import { findPrimitiveRunExecution } from "../executions/run-link"
+import { SyncRunError } from "./errors"
+
+/** Validate the semantic link between a durable Sync run and its immutable execution. */
+export async function assertSyncRunExecution(input: {
+  readonly executions: ExecutionStorage
+  readonly projectId: string
+  readonly executionId: string
+  readonly runId: string
+  readonly syncId: string
+}): Promise<void> {
+  const execution = await findPrimitiveRunExecution({
+    executions: input.executions,
+    projectId: input.projectId,
+    executionId: input.executionId,
+    primitive: { kind: "sync", id: input.syncId, runId: input.runId },
+    sourceTypes: ["execution", "schedule", "event"],
+  })
+  if (!execution) {
+    throw new SyncRunError(
+      `[Sixb] Execution '${input.executionId}' does not authorize Sync run '${input.runId}'.`
+    )
+  }
+}

package/src/storage/sync-runs/types.ts

@@ -1,44 +1,58 @@
+import type { SixbErrorCode, SixbFailure } from "../../errors/types"
 import type { JsonValue } from "../../json"
 import type { DatasetVersionRef, DatasetWriteMode } from "../../lake-storage"
 
 export type SyncRunMode = DatasetWriteMode | "merge"
 
-export type SyncRunStatus = "running" | "succeeded" | "failed" | "cancelled"
+export type SyncRunStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled"
+/** Error codes a sync run can persist and expose through its public contract. */
+export const SYNC_RUN_FAILURE_CODES = [
+  "internal.unexpected",
+  "runtime.cancelled",
+  "queue.enqueue_failed",
+  "sync.execution_failed",
+] as const satisfies readonly [SixbErrorCode, ...SixbErrorCode[]]
 
-export interface SyncRunFailure {
-  readonly name?: string // Example: "AbortError"
-  readonly message: string // Example: "Sync cancelled by request"
-}
+export type SyncRunFailureCode = (typeof SYNC_RUN_FAILURE_CODES)[number]
 
 export interface SyncRunRecord {
   readonly id: string
   readonly projectId: string
+  readonly executionId: string
   readonly syncId: string
   readonly datasetId: string
   readonly mode: SyncRunMode
   readonly status: SyncRunStatus
-  readonly startedAt: Date
+  readonly queuedAt: Date
+  readonly startedAt?: Date
   readonly finishedAt?: Date
   /** Source items successfully consumed. Merge runs count both upserts and deletes. */
   readonly rowsRead?: number
   readonly output?: DatasetVersionRef
   readonly expectedLatestVersionId?: string
   readonly commitMessage?: string
-  readonly error?: SyncRunFailure
+  readonly error?: SixbFailure<SyncRunFailureCode>
   readonly checkpoint?: JsonValue
 }
 
-export interface StartSyncRunInput {
+export interface QueueSyncRunInput {
   readonly id: string
   readonly projectId: string
+  readonly executionId: string
   readonly syncId: string
   readonly datasetId: string
   readonly mode: SyncRunMode
-  readonly startedAt?: Date
+  readonly queuedAt?: Date
   readonly expectedLatestVersionId?: string
   readonly commitMessage?: string
 }
 
+export interface StartSyncRunInput {
+  readonly id: string
+  readonly projectId: string
+  readonly startedAt?: Date
+}
+
 export type FinishSyncRunInput =
   | {
       readonly id: string
@@ -54,11 +68,20 @@ export type FinishSyncRunInput =
   | {
       readonly id: string
       readonly projectId: string
-      readonly status: "failed" | "cancelled"
+      readonly status: "failed"
       readonly finishedAt?: Date
       /** Source items successfully consumed before the failure or cancellation. */
       readonly rowsRead?: number
-      readonly error?: SyncRunFailure
+      readonly error: SixbFailure<SyncRunFailureCode>
+    }
+  | {
+      readonly id: string
+      readonly projectId: string
+      readonly status: "cancelled"
+      readonly finishedAt?: Date
+      /** Source items successfully consumed before cancellation. */
+      readonly rowsRead?: number
+      readonly error?: SixbFailure<SyncRunFailureCode>
     }
 
 export interface ListSyncRunsInput {
@@ -90,6 +113,7 @@ export interface ListLatestSyncRunsResult {
 }
 
 export interface SyncRunStorage {
+  queue(input: QueueSyncRunInput): Promise<SyncRunRecord>
   start(input: StartSyncRunInput): Promise<SyncRunRecord>
   finish(input: FinishSyncRunInput): Promise<SyncRunRecord>
   getById(params: { projectId: string; id: string }): Promise<SyncRunRecord | null>

package/src/storage/types.ts

@@ -1,6 +1,10 @@
 import type { ActionRunStorage } from "./action-runs"
 import type { AgentStorage } from "./agents"
+import type { AiCostStorage } from "./ai-cost"
+import type { AiUsageStorage } from "./ai-usage"
 import type { AuthStorage } from "./auth"
+import type { ConnectorConnectionStorage } from "./connector-connections"
+import type { ExecutionStorage } from "./executions"
 import type { FileUploadSessionStore } from "./file-upload-sessions"
 import type { ObjectStorage } from "./objects/types"
 import type { OntologyStorage } from "./ontology"
@@ -9,7 +13,6 @@ import type { ProjectionRunStorage } from "./projection-runs"
 import type { RulesStorage } from "./rules"
 import type { SyncRunStorage } from "./sync-runs"
 import type { TimeseriesStorage } from "./timeseries/types"
-import type { WebhookDeliveryStorage } from "./webhook-deliveries"
 import type { WebhookRunStorage } from "./webhook-runs"
 import type { WorkflowInterventionStorage } from "./workflow-interventions"
 import type { WorkflowRunStorage } from "./workflow-runs"
@@ -21,6 +24,8 @@ export type {
 } from "../materialization/model"
 export type {
   ActionRunFailure,
+  ActionRunFailureCode,
+  ActionRunFailureDetails,
   ActionRunParams,
   ActionRunPhase,
   ActionRunRecord,
@@ -33,10 +38,11 @@ export type {
   QueueActionRunInput,
   StartActionRunInput,
 } from "./action-runs"
-export { ActionRunError } from "./action-runs"
+export { ACTION_RUN_FAILURE_CODES, ACTION_RUN_PHASES, ActionRunError } from "./action-runs"
 export type {
   AgentMessageRecord,
   AgentRunExecution,
+  AgentRunFailureCode,
   AgentRunRecord,
   AgentStorage,
   AgentThreadRecord,
@@ -55,7 +61,27 @@ export type {
   ReclaimAgentRunInput,
   StartAgentRunInput,
 } from "./agents"
-export { AgentStorageError } from "./agents"
+export { AGENT_RUN_FAILURE_CODES, AgentStorageError } from "./agents"
+export type {
+  AiModelCallUsage,
+  AiModelCallUsageInput,
+  AiModelCallUsageRecord,
+  AiUsageExecutionSummary,
+  AiUsageReportingStatus,
+  AiUsageStorage,
+  AiUsageStorageErrorCode,
+  RecordAiModelCallInput,
+  RecordAiModelCallResult,
+  SummarizeAiUsageExecutionInput,
+  SummarizeAiUsageExecutionsInput,
+} from "./ai-usage"
+export {
+  AiUsageStorageError,
+  aggregateAiModelCallUsage,
+  assertAiUsageExecutionId,
+  normalizeAiModelCallRecord,
+  normalizeAiModelCallUsage,
+} from "./ai-usage"
 export type {
   AuthGroupMembershipStore,
   AuthInvitationStore,
@@ -128,11 +154,13 @@ export type {
   ListPipelineRunsResult,
   ListPipelineStepRunsInput,
   ListPipelineStepRunsResult,
-  PipelineRunFailure,
+  PipelineRunFailureCode,
   PipelineRunRecord,
   PipelineRunStatus,
   PipelineRunStorage,
   PipelineStepRunRecord,
+  PipelineStepRunStatus,
+  QueuePipelineRunInput,
   StartPipelineRunInput,
   StartPipelineStepRunInput,
 } from "./pipeline-runs"
@@ -149,6 +177,7 @@ export type {
   ObjectProjectionTarget,
   ProjectionKind,
   ProjectionRunClaim,
+  ProjectionRunFailureCode,
   ProjectionRunProgress,
   ProjectionRunRecord,
   ProjectionRunStatus,
@@ -159,7 +188,7 @@ export type {
   TelemetryProjectionRunRecord,
   UpdateProjectionRunInput,
 } from "./projection-runs"
-export { ProjectionRunError } from "./projection-runs"
+export { PROJECTION_RUN_FAILURE_CODES, ProjectionRunError } from "./projection-runs"
 export type {
   ListActiveRuleStatesInput,
   ListActiveRuleStatesResult,
@@ -170,8 +199,9 @@ export type {
   FinishSyncRunInput,
   ListSyncRunsInput,
   ListSyncRunsResult,
+  QueueSyncRunInput,
   StartSyncRunInput,
-  SyncRunFailure,
+  SyncRunFailureCode,
   SyncRunMode,
   SyncRunRecord,
   SyncRunStatus,
@@ -185,25 +215,20 @@ export type {
   TimeseriesPoint,
   TimeseriesStorage,
 } from "./timeseries/types"
-export type {
-  WebhookDeliveryClaimRecord,
-  WebhookDeliveryClaimResult,
-  WebhookDeliveryKey,
-  WebhookDeliveryRecord,
-  WebhookDeliveryStatus,
-  WebhookDeliveryStorage,
-} from "./webhook-deliveries"
 export type {
   FinishWebhookRunInput,
   FinishWebhookRunStatus,
+  GetWebhookRunByDeliveryInput,
   ListWebhookRunsInput,
   ListWebhookRunsResult,
+  RestartWebhookRunInput,
   StartWebhookRunInput,
+  WebhookRunFailureCode,
   WebhookRunRecord,
   WebhookRunStatus,
   WebhookRunStorage,
 } from "./webhook-runs"
-export { WebhookRunError } from "./webhook-runs"
+export { WEBHOOK_RUN_FAILURE_CODES, WebhookRunError } from "./webhook-runs"
 export type {
   CancelWorkflowInterventionInput,
   CreateWorkflowInterventionInput,
@@ -250,11 +275,12 @@ export type {
   WorkflowNodeRunStorage,
   WorkflowNodeRunType,
   WorkflowRunExecution,
+  WorkflowRunFailureCode,
   WorkflowRunRecord,
   WorkflowRunStatus,
   WorkflowRunStorage,
 } from "./workflow-runs"
-export { WorkflowRunError } from "./workflow-runs"
+export { WORKFLOW_RUN_FAILURE_CODES, WorkflowRunError } from "./workflow-runs"
 
 export interface StorageTransactionOptions {
   readonly isolation?: "default" | "serializable"
@@ -264,18 +290,21 @@ export interface Storage {
   objects: ObjectStorage
   timeseries: TimeseriesStorage
   ontology: OntologyStorage
+  executions: ExecutionStorage
   auth?: AuthStorage
   agents?: AgentStorage
+  aiUsage?: AiUsageStorage
+  aiCosts?: AiCostStorage
   actionRuns?: ActionRunStorage
   syncRuns?: SyncRunStorage
   pipelineRuns?: PipelineRunStorage
   projectionRuns?: ProjectionRunStorage
   workflowRuns?: WorkflowRunStorage
   workflowInterventions?: WorkflowInterventionStorage
-  webhookDeliveries?: WebhookDeliveryStorage
   webhookRuns?: WebhookRunStorage
   rules?: RulesStorage
   fileUploadSessions?: FileUploadSessionStore
+  connectorConnections?: ConnectorConnectionStorage
 
   /** Lightweight reachability probe. It must not open a write transaction or run migrations. */
   ping(): Promise<void>