@sixb/pg 0.1.2 → 0.1.3

package/dist/index.js

@@ -16,8 +16,14 @@ import {
   throwNestedStorageTransaction
 } from "@sixb/core/storage";
 
-// src/agents/messages.ts
-import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents";
+// src/agents/checkpoints.ts
+import {
+  agentContextCheckpointMatchesCreateInput,
+  assertAgentContextCheckpointAnchors,
+  assertAgentContextCheckpointAuthority,
+  assertAgentContextCheckpointReplayState,
+  assertCreateAgentContextCheckpointInput
+} from "@sixb/core/internal/agent-run-storage-provider";
 import {
   AgentStorageError
 } from "@sixb/core/storage";
@@ -149,6 +155,28 @@ function rowToMessageRecord(row) {
     completedAt: row.completed_at ? new Date(row.completed_at) : undefined
   };
 }
+function rowToContextCheckpointRecord(row) {
+  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, id) {
   return type && id ? { type, id } : undefined;
 }
@@ -184,7 +212,144 @@ async function queryAgentList(input) {
   return { rows, total, hasMore: offset + rows.length < total };
 }
 
+// src/agents/checkpoints.ts
+class PgAgentContextCheckpointStore {
+  sql;
+  constructor(sql) {
+    this.sql = sql;
+  }
+  async create(input) {
+    assertCreateAgentContextCheckpointInput(input, "SixbPg");
+    try {
+      return await runPgTransaction(this.sql, async (tx) => {
+        const [runRow] = await tx`
+          SELECT * FROM agent_runs
+          WHERE project_id = ${input.projectId} AND id = ${input.createdByRunId}
+          FOR UPDATE
+        `;
+        const [threadRow] = await tx`
+          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`
+          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`
+          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`
+          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`
+          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`
+          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`
+          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) {
+    const [row] = await this.sql`
+      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;
+  }
+}
+
 // src/agents/messages.ts
+import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents";
+import {
+  AgentStorageError as AgentStorageError2
+} from "@sixb/core/storage";
 class PgAgentMessageStore {
   sql;
   constructor(sql) {
@@ -194,21 +359,23 @@ class PgAgentMessageStore {
     const createdAt = input.createdAt ?? new Date;
     try {
       return await runPgTransaction(this.sql, async (tx) => {
+        if (input.runId !== null) {
+          const [run] = await tx`
+            SELECT id FROM agent_runs
+            WHERE project_id = ${input.projectId} AND id = ${input.runId}
+            FOR UPDATE
+          `;
+          if (!run) {
+            throw new AgentStorageError2("run_not_found", `[SixbPg] Agent run '${input.runId}' not found for project '${input.projectId}'.`);
+          }
+        }
         const [thread] = await tx`
           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}'.`);
-        }
-        if (input.runId !== null) {
-          const [run] = await tx`
-            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}'.`);
-          }
+          throw new AgentStorageError2("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
         }
         const [seqRow] = await tx`
           SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM agent_messages
@@ -255,11 +422,51 @@ class PgAgentMessageStore {
       });
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new AgentStorageError("duplicate_id", `[SixbPg] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError2("duplicate_id", `[SixbPg] Agent message '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
   }
+  async deleteByRunId(input) {
+    return runPgTransaction(this.sql, async (tx) => {
+      const [thread] = await tx`
+        SELECT id FROM agent_threads
+        WHERE project_id = ${input.projectId} AND id = ${input.threadId}
+        FOR UPDATE
+      `;
+      if (!thread) {
+        throw new AgentStorageError2("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+      }
+      const deleted = await tx`
+        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) {
     const [row] = await this.sql`
       SELECT * FROM agent_messages WHERE project_id = ${params.projectId} AND id = ${params.id}
@@ -273,6 +480,10 @@ class PgAgentMessageStore {
     const whereClauses = ["project_id = $1", "thread_id = $2"];
     const params = [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(", ")})`);
@@ -299,7 +510,7 @@ import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth";
 import { serializeSixbFailure } from "@sixb/core/internal/errors";
 import {
   AGENT_RUN_FAILURE_CODES as AGENT_RUN_FAILURE_CODES2,
-  AgentStorageError as AgentStorageError2
+  AgentStorageError as AgentStorageError3
 } from "@sixb/core/storage";
 
 // src/run-list-query.ts
@@ -384,10 +595,10 @@ class PgAgentRunStore {
           FOR UPDATE
         `;
         if (!thread) {
-          throw new AgentStorageError2("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
+          throw new AgentStorageError3("thread_not_found", `[SixbPg] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`);
         }
         if (thread.active_run_id !== null) {
-          throw new AgentStorageError2("active_run_exists", `[SixbPg] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
+          throw new AgentStorageError3("active_run_exists", `[SixbPg] Agent thread '${input.threadId}' already has an active run '${thread.active_run_id}'.`);
         }
         const [row] = await tx`
           INSERT INTO agent_runs (
@@ -423,7 +634,7 @@ class PgAgentRunStore {
       });
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new AgentStorageError2("duplicate_id", `[SixbPg] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError3("duplicate_id", `[SixbPg] Agent run '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
@@ -483,7 +694,7 @@ class PgAgentRunStore {
     return runPgTransaction(this.sql, async (tx) => {
       const run = await this.lockRunning(tx, input.projectId, input.id);
       if (run.execution_token !== input.executionToken) {
-        throw new AgentStorageError2("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
+        throw new AgentStorageError3("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
       }
       const [row] = await tx`
         UPDATE agent_runs
@@ -503,7 +714,7 @@ class PgAgentRunStore {
     return runPgTransaction(this.sql, async (tx) => {
       const run = await this.lockRunning(tx, input.projectId, input.id);
       if (run.execution_token !== input.executionToken) {
-        throw new AgentStorageError2("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
+        throw new AgentStorageError3("execution_lost", `[SixbPg] Execution token is no longer current on agent run '${input.id}'.`);
       }
       const [row] = await tx`
         UPDATE agent_runs
@@ -584,10 +795,10 @@ class PgAgentRunStore {
       FOR UPDATE
     `;
     if (!row) {
-      throw new AgentStorageError2("run_not_found", `[SixbPg] Agent run '${id}' not found for project '${projectId}'.`);
+      throw new AgentStorageError3("run_not_found", `[SixbPg] Agent run '${id}' not found for project '${projectId}'.`);
     }
     if (row.status !== status) {
-      throw new AgentStorageError2("invalid_state", `[SixbPg] Agent run '${id}' is not ${status} (status '${row.status}').`);
+      throw new AgentStorageError3("invalid_state", `[SixbPg] Agent run '${id}' is not ${status} (status '${row.status}').`);
     }
     return row;
   }
@@ -601,7 +812,7 @@ class PgAgentRunStore {
 
 // src/agents/threads.ts
 import {
-  AgentStorageError as AgentStorageError3
+  AgentStorageError as AgentStorageError4
 } from "@sixb/core/storage";
 class PgAgentThreadStore {
   sql;
@@ -639,7 +850,7 @@ class PgAgentThreadStore {
       return rowToThreadRecord(row);
     } catch (error) {
       if (isUniqueViolation(error)) {
-        throw new AgentStorageError3("duplicate_id", `[SixbPg] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
+        throw new AgentStorageError4("duplicate_id", `[SixbPg] Agent thread '${input.id}' already exists for project '${input.projectId}'.`);
       }
       throw error;
     }
@@ -695,10 +906,12 @@ class PgAgentStorage {
   threads;
   runs;
   messages;
+  checkpoints;
   constructor(options) {
     this.threads = new PgAgentThreadStore(options.sql);
     this.runs = new PgAgentRunStore(options.sql, options.executions);
     this.messages = new PgAgentMessageStore(options.sql);
+    this.checkpoints = new PgAgentContextCheckpointStore(options.sql);
   }
 }
 // src/auth-storage/auth-storage.ts
@@ -5915,6 +6128,105 @@ CREATE INDEX idx_connector_connections_status
   ON connector_connections (project_id, connector_id, status, id);
 `;
 
+// src/migrations/026-ai-cost-accounting.sql
+var _026_ai_cost_accounting_default = `CREATE TABLE ai_model_call_valuations (
+  project_id TEXT NOT NULL CHECK (length(btrim(project_id)) > 0),
+  usage_record_id TEXT NOT NULL CHECK (length(btrim(usage_record_id)) > 0),
+  status TEXT NOT NULL CHECK (status IN ('rated', 'unpriceable')),
+  provider_id TEXT CHECK (provider_id IS NULL OR length(btrim(provider_id)) > 0),
+  model_id TEXT CHECK (model_id IS NULL OR length(btrim(model_id)) > 0),
+  currency TEXT CHECK (currency IS NULL OR currency ~ '^[A-Z]{3}$'),
+  amount_nanos BIGINT CHECK (amount_nanos IS NULL OR amount_nanos >= 0),
+  reason TEXT CHECK (
+    reason IS NULL OR reason IN (
+      'missingBillingIdentity',
+      'missingCatalogEntry',
+      'missingUsageMeter',
+      'unsupportedPricingDimension',
+      'invalidUsageForFormula'
+    )
+  ),
+  details JSONB NOT NULL CHECK (jsonb_typeof(details) = 'object'),
+  rated_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, usage_record_id),
+  FOREIGN KEY (project_id, usage_record_id)
+    REFERENCES ai_model_call_usage(project_id, id)
+    ON DELETE RESTRICT,
+  CHECK (
+    (
+      status = 'rated'
+      AND provider_id IS NOT NULL
+      AND model_id IS NOT NULL
+      AND currency IS NOT NULL
+      AND amount_nanos IS NOT NULL
+      AND reason IS NULL
+    )
+    OR
+    (
+      status = 'unpriceable'
+      AND currency IS NULL
+      AND amount_nanos IS NULL
+      AND reason IS NOT NULL
+      AND (
+        (reason = 'missingBillingIdentity' AND provider_id IS NULL AND model_id IS NULL)
+        OR
+        (reason <> 'missingBillingIdentity' AND provider_id IS NOT NULL AND model_id IS NOT NULL)
+      )
+    )
+  )
+);
+
+CREATE INDEX idx_ai_model_call_usage_provider_model_time
+  ON ai_model_call_usage (project_id, provider_id, requested_model_id, occurred_at, id);
+CREATE INDEX idx_ai_model_call_usage_model_time
+  ON ai_model_call_usage (project_id, requested_model_id, occurred_at, id);
+CREATE INDEX idx_ai_model_call_valuations_summary
+  ON ai_model_call_valuations (project_id, status, currency, usage_record_id);
+`;
+
+// src/migrations/027-agent-context-checkpoints.sql
+var _027_agent_context_checkpoints_default = `CREATE TABLE agent_context_checkpoints (
+  project_id TEXT NOT NULL,
+  id TEXT NOT NULL,
+  thread_id TEXT NOT NULL,
+  created_by_run_id TEXT NOT NULL,
+  previous_checkpoint_id TEXT,
+  reason TEXT NOT NULL CHECK (reason IN ('threshold', 'overflow')),
+  summary TEXT NOT NULL CHECK (length(trim(summary)) > 0),
+  summary_format_version INTEGER NOT NULL CHECK (summary_format_version = 1),
+  summarized_through_seq INTEGER NOT NULL CHECK (summarized_through_seq >= 1),
+  observed_head_seq INTEGER NOT NULL,
+  estimated_input_tokens_before BIGINT NOT NULL CHECK (estimated_input_tokens_before >= 0),
+  estimated_input_tokens_after BIGINT NOT NULL CHECK (estimated_input_tokens_after >= 0),
+  summary_model_id TEXT NOT NULL CHECK (length(trim(summary_model_id)) > 0),
+  created_at TIMESTAMPTZ NOT NULL,
+  PRIMARY KEY (project_id, id),
+  UNIQUE (project_id, created_by_run_id),
+  FOREIGN KEY (project_id, thread_id)
+    REFERENCES agent_threads(project_id, id) ON DELETE CASCADE,
+  FOREIGN KEY (project_id, created_by_run_id)
+    REFERENCES agent_runs(project_id, id) ON DELETE RESTRICT,
+  FOREIGN KEY (project_id, previous_checkpoint_id)
+    REFERENCES agent_context_checkpoints(project_id, id) ON DELETE RESTRICT,
+  CHECK (summarized_through_seq < observed_head_seq)
+);
+
+CREATE INDEX idx_agent_context_checkpoints_thread_latest
+  ON agent_context_checkpoints (
+    project_id,
+    thread_id,
+    summarized_through_seq DESC,
+    created_at DESC,
+    id DESC
+  );
+`;
+
+// src/migrations/028-object-override-edit-times.sql
+var _028_object_override_edit_times_default = `ALTER TABLE ontology_object_overrides
+ADD COLUMN edited_at JSONB NOT NULL DEFAULT '{}'::jsonb
+CHECK (jsonb_typeof(edited_at) = 'object');
+`;
+
 // src/migrations.ts
 var POSTGRES_STORAGE_ADAPTER_ID = "SixbPostgresStorage";
 function pgSql(id, sqlText) {
@@ -6114,7 +6426,10 @@ var postgresStorageMigrations = defineMigrations({
     pgSql("022-projection-executions", _022_projection_executions_default),
     pgSql("023-webhook-executions", _023_webhook_executions_default),
     pgSql("024-ontology-commit-executions", _024_ontology_commit_executions_default),
-    pgSql("025-connector-connections", _025_connector_connections_default)
+    pgSql("025-connector-connections", _025_connector_connections_default),
+    pgSql("026-ai-cost-accounting", _026_ai_cost_accounting_default),
+    pgSql("027-agent-context-checkpoints", _027_agent_context_checkpoints_default),
+    pgSql("028-object-override-edit-times", _028_object_override_edit_times_default)
   ]
 });
 
@@ -7159,6 +7474,7 @@ function storedObjectOverride(row) {
   return {
     ref,
     value: structuredClone(row.value),
+    editedAt: structuredClone(row.edited_at),
     lastCommitId: row.last_commit_id,
     updatedAt: toIsoString2(row.updated_at)
   };
@@ -7592,6 +7908,7 @@ class PgMaterializationWriter {
       objectTypeId: item.ref.objectTypeId,
       primaryId: item.ref.primaryId,
       value: item.value,
+      editedAt: item.editedAt,
       lastCommitId: item.lastCommitId,
       updatedAt: item.updatedAt,
       expectedLastCommitId: item.expectedLastCommitId
@@ -7603,10 +7920,10 @@ class PgMaterializationWriter {
           SELECT value FROM jsonb_array_elements(${jsonParameter2(this.sql, objectInserts)}::jsonb)
         )
         INSERT INTO ontology_object_overrides (
-          project_id, object_type_id, primary_id, value, last_commit_id, updated_at
+          project_id, object_type_id, primary_id, value, edited_at, last_commit_id, updated_at
         )
         SELECT ${projectId}, value->>'objectTypeId', value->>'primaryId', value->'value',
-          value->>'lastCommitId',
+          value->'editedAt', value->>'lastCommitId',
           (value->>'updatedAt')::timestamptz
         FROM staged
         ON CONFLICT DO NOTHING
@@ -7622,7 +7939,8 @@ class PgMaterializationWriter {
           SELECT value FROM jsonb_array_elements(${jsonParameter2(this.sql, objectUpdates)}::jsonb)
         )
         UPDATE ontology_object_overrides AS overrides
-        SET value = staged.value->'value', last_commit_id = staged.value->>'lastCommitId',
+        SET value = staged.value->'value', edited_at = staged.value->'editedAt',
+          last_commit_id = staged.value->>'lastCommitId',
           updated_at = (staged.value->>'updatedAt')::timestamptz
         FROM staged
         WHERE overrides.project_id = ${projectId}
@@ -9811,6 +10129,502 @@ function rowToActionSubject(row) {
   };
 }
 
+// src/pg-ai-cost-storage.ts
+import {
+  aiModelCallCostDetails,
+  aiModelCallCostMatchesUsage,
+  buildAiAccountingOverviewFromFragments,
+  normalizeAiAccountingQuery,
+  normalizeAiModelCallAccountingQuery,
+  normalizeAiModelCallCostRecord,
+  parseAiModelCallCostDetails,
+  toAccountingItem
+} from "@sixb/core/internal/ai-cost-storage-provider";
+import {
+  AiCostStorageError
+} from "@sixb/core/storage";
+class PgAiCostStorage {
+  sql;
+  constructor(sql) {
+    this.sql = sql;
+  }
+  async recordModelCallCost(input) {
+    const record = normalizeAiModelCallCostRecord(input);
+    await runPgTransaction(this.sql, async (tx) => {
+      const usage = await findUsage(tx, record.projectId, record.usageRecordId);
+      if (!usage)
+        throw missingUsage(record);
+      assertCostMatchesUsage(record, usage);
+      if (await findCost(tx, record.projectId, record.usageRecordId))
+        return;
+      const rated = record.status === "rated" ? record : undefined;
+      const inserted = await tx`
+        INSERT INTO ai_model_call_valuations (
+          project_id, usage_record_id, status, provider_id, model_id,
+          currency, amount_nanos, reason, details, rated_at
+        ) VALUES (
+          ${record.projectId}, ${record.usageRecordId}, ${record.status},
+          ${record.billingIdentity?.providerId ?? null},
+          ${record.billingIdentity?.modelId ?? null}, ${rated?.money.currency ?? null},
+          ${rated?.money.amountNanos ?? null},
+          ${record.status === "unpriceable" ? record.reason : null},
+          ${JSON.stringify(aiModelCallCostDetails(record))}::text::jsonb, ${record.ratedAt}
+        )
+        ON CONFLICT DO NOTHING
+        RETURNING usage_record_id
+      `;
+      if (inserted.length === 0 && !await findCost(tx, record.projectId, record.usageRecordId)) {
+        throw new Error("[SixbPg] AI valuation insert conflicted without a visible row.");
+      }
+    });
+  }
+  async summarizeExecutions(input) {
+    assertNonBlank(input.projectId, "cost summary projectId");
+    for (const id of input.executionIds)
+      assertNonBlank(id, "cost summary executionId");
+    if (input.executionIds.length === 0)
+      return [];
+    const ids = [...new Set(input.executionIds)];
+    const rows = await this.sql`
+      WITH requested(execution_id) AS (
+        SELECT DISTINCT * FROM unnest(${this.sql.array(ids)}::text[])
+      )
+      SELECT usage.execution_id,
+        cost.status,
+        cost.currency,
+        cost.amount_nanos
+      FROM requested
+      JOIN ai_model_call_usage AS usage
+        ON usage.project_id = ${input.projectId} AND usage.execution_id = requested.execution_id
+      LEFT JOIN ai_model_call_valuations AS cost
+        ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+    `;
+    return aggregateSummaryRows(input.executionIds, rows);
+  }
+  async queryProjectOverview(input) {
+    const query = normalizeAiAccountingQuery(input);
+    const providerId = query.providerId ?? null;
+    const modelId = query.modelId ?? null;
+    const rows = await this.sql`
+      WITH filtered AS (
+        SELECT usage.provider_id,
+          usage.requested_model_id,
+          usage.occurred_at,
+          usage.input_tokens,
+          usage.output_tokens,
+          usage.uncached_input_tokens,
+          usage.cache_read_input_tokens,
+          usage.cache_write_input_tokens,
+          usage.text_output_tokens,
+          usage.reasoning_output_tokens,
+          usage.reporting_status,
+          COALESCE(direct_agent.agent_id, workflow_agent.agent_id) AS attribution_agent_id,
+          workflow_node.workflow_id AS attribution_workflow_id,
+          cost.status AS cost_status,
+          cost.currency AS cost_currency,
+          cost.amount_nanos AS cost_amount_nanos
+        FROM ai_model_call_usage AS usage
+        LEFT JOIN agent_runs AS direct_agent
+          ON direct_agent.project_id = usage.project_id
+          AND direct_agent.execution_id = usage.execution_id
+        LEFT JOIN workflow_agent_node_runs AS workflow_agent
+          ON workflow_agent.project_id = usage.project_id
+          AND workflow_agent.execution_id = usage.execution_id
+        LEFT JOIN workflow_node_runs AS workflow_node
+          ON workflow_node.project_id = workflow_agent.project_id
+          AND workflow_node.id = workflow_agent.node_run_id
+        LEFT JOIN ai_model_call_valuations AS cost
+          ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+        WHERE usage.project_id = ${query.projectId}
+          AND usage.occurred_at >= ${query.from} AND usage.occurred_at < ${query.to}
+          AND (${providerId}::text IS NULL OR usage.provider_id = ${providerId})
+          AND (${modelId}::text IS NULL OR usage.requested_model_id = ${modelId})
+      ), classified AS (
+        SELECT filtered.*,
+          CASE
+            WHEN cost_status = 'rated' THEN 'rated'
+            WHEN cost_status = 'unpriceable' THEN 'unpriceable'
+            ELSE 'unvalued'
+          END AS valuation_status,
+          CASE WHEN cost_status = 'rated' THEN cost_currency ELSE NULL END AS amount_currency,
+          CASE WHEN cost_status = 'rated' THEN cost_amount_nanos ELSE NULL END AS amount_nanos
+        FROM filtered
+      ), expanded AS (
+        SELECT 'totals'::text AS dimension,
+          NULL::text AS key_1,
+          NULL::text AS key_2,
+          NULL::timestamptz AS bucket_start,
+          classified.*
+        FROM classified
+        UNION ALL
+        SELECT 'series', NULL, NULL,
+          CASE ${input.bucket}::text
+            WHEN 'hour' THEN
+              date_trunc('hour', occurred_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC'
+            WHEN 'day' THEN
+              date_trunc('day', occurred_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC'
+            ELSE date_trunc('week', occurred_at AT TIME ZONE 'UTC') AT TIME ZONE 'UTC'
+          END,
+          classified.*
+        FROM classified
+        UNION ALL
+        SELECT 'model', provider_id, requested_model_id, NULL, classified.* FROM classified
+        UNION ALL
+        SELECT 'agent', attribution_agent_id, NULL, NULL, classified.*
+        FROM classified WHERE attribution_agent_id IS NOT NULL
+        UNION ALL
+        SELECT 'workflow', attribution_workflow_id, NULL, NULL, classified.*
+        FROM classified WHERE attribution_workflow_id IS NOT NULL
+      )
+      SELECT dimension,
+        key_1,
+        key_2,
+        bucket_start,
+        amount_currency,
+        COUNT(*)::text AS model_call_count,
+        COUNT(*) FILTER (WHERE reporting_status <> 'unavailable')::text
+          AS reported_usage_call_count,
+        COUNT(input_tokens)::text AS input_tokens_count,
+        SUM(input_tokens)::text AS input_tokens_sum,
+        COUNT(output_tokens)::text AS output_tokens_count,
+        SUM(output_tokens)::text AS output_tokens_sum,
+        COUNT(uncached_input_tokens)::text AS uncached_input_tokens_count,
+        SUM(uncached_input_tokens)::text AS uncached_input_tokens_sum,
+        COUNT(cache_read_input_tokens)::text AS cache_read_input_tokens_count,
+        SUM(cache_read_input_tokens)::text AS cache_read_input_tokens_sum,
+        COUNT(cache_write_input_tokens)::text AS cache_write_input_tokens_count,
+        SUM(cache_write_input_tokens)::text AS cache_write_input_tokens_sum,
+        COUNT(text_output_tokens)::text AS text_output_tokens_count,
+        SUM(text_output_tokens)::text AS text_output_tokens_sum,
+        COUNT(reasoning_output_tokens)::text AS reasoning_output_tokens_count,
+        SUM(reasoning_output_tokens)::text AS reasoning_output_tokens_sum,
+        COUNT(*) FILTER (WHERE valuation_status = 'rated')::text AS rated_call_count,
+        COUNT(*) FILTER (WHERE valuation_status = 'unpriceable')::text
+          AS unpriceable_call_count,
+        COUNT(*) FILTER (WHERE valuation_status = 'unvalued')::text
+          AS unvalued_call_count,
+        SUM(amount_nanos)::text AS amount_nanos
+      FROM expanded
+      GROUP BY dimension, key_1, key_2, bucket_start, amount_currency
+    `;
+    return buildAiAccountingOverviewFromFragments(input, rows.map(aggregateFragmentFromRow));
+  }
+  async listModelCalls(input) {
+    const query = normalizeAiModelCallAccountingQuery(input);
+    const providerId = query.providerId ?? null;
+    const modelId = query.modelId ?? null;
+    const executionId = query.executionId ?? null;
+    const valuationStatus = query.valuationStatus ?? null;
+    const [count] = await this.sql`
+      SELECT COUNT(*)::text AS total
+      FROM ai_model_call_usage AS usage
+      LEFT JOIN ai_model_call_valuations AS cost
+        ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+      WHERE usage.project_id = ${query.projectId}
+        AND usage.occurred_at >= ${query.from} AND usage.occurred_at < ${query.to}
+        AND (${providerId}::text IS NULL OR usage.provider_id = ${providerId})
+        AND (${modelId}::text IS NULL OR usage.requested_model_id = ${modelId})
+        AND (${executionId}::text IS NULL OR usage.execution_id = ${executionId})
+        AND (
+          ${valuationStatus}::text IS NULL OR ${valuationStatus} = CASE
+            WHEN cost.status = 'rated' THEN 'rated'
+            WHEN cost.status = 'unpriceable' THEN 'unpriceable'
+            ELSE 'unvalued'
+          END
+        )
+    `;
+    const rows = await this.sql`
+      SELECT usage.*,
+        CASE
+          WHEN direct_agent.id IS NOT NULL THEN 'agent'
+          WHEN workflow_agent.node_run_id IS NOT NULL THEN 'workflowAgent'
+          ELSE NULL
+        END AS attribution_kind,
+        COALESCE(direct_agent.agent_id, workflow_agent.agent_id) AS attribution_agent_id,
+        direct_agent.id AS attribution_agent_run_id,
+        direct_agent.thread_id AS attribution_thread_id,
+        workflow_agent.node_run_id AS attribution_node_run_id,
+        workflow_node.workflow_id AS attribution_workflow_id,
+        workflow_node.workflow_run_id AS attribution_workflow_run_id,
+        COALESCE((
+          SELECT jsonb_agg(groups.group_id ORDER BY groups.group_id)
+          FROM ai_model_call_usage_groups AS groups
+          WHERE groups.project_id = usage.project_id AND groups.usage_record_id = usage.id
+        ), '[]'::jsonb) AS requester_group_ids,
+        cost.status AS cost_status,
+        cost.provider_id AS cost_provider_id,
+        cost.model_id AS cost_model_id,
+        cost.currency AS cost_currency,
+        cost.amount_nanos AS cost_amount_nanos,
+        cost.reason AS cost_reason,
+        cost.details AS cost_details,
+        cost.rated_at AS cost_rated_at
+      FROM ai_model_call_usage AS usage
+      LEFT JOIN agent_runs AS direct_agent
+        ON direct_agent.project_id = usage.project_id
+        AND direct_agent.execution_id = usage.execution_id
+      LEFT JOIN workflow_agent_node_runs AS workflow_agent
+        ON workflow_agent.project_id = usage.project_id
+        AND workflow_agent.execution_id = usage.execution_id
+      LEFT JOIN workflow_node_runs AS workflow_node
+        ON workflow_node.project_id = workflow_agent.project_id
+        AND workflow_node.id = workflow_agent.node_run_id
+      LEFT JOIN ai_model_call_valuations AS cost
+        ON cost.project_id = usage.project_id AND cost.usage_record_id = usage.id
+      WHERE usage.project_id = ${query.projectId}
+        AND usage.occurred_at >= ${query.from} AND usage.occurred_at < ${query.to}
+        AND (${providerId}::text IS NULL OR usage.provider_id = ${providerId})
+        AND (${modelId}::text IS NULL OR usage.requested_model_id = ${modelId})
+        AND (${executionId}::text IS NULL OR usage.execution_id = ${executionId})
+        AND (
+          ${valuationStatus}::text IS NULL OR ${valuationStatus} = CASE
+            WHEN cost.status = 'rated' THEN 'rated'
+            WHEN cost.status = 'unpriceable' THEN 'unpriceable'
+            ELSE 'unvalued'
+          END
+        )
+      ORDER BY usage.occurred_at DESC, usage.id ASC
+      LIMIT ${query.limit} OFFSET ${query.offset}
+    `;
+    const items = rows.map((row) => toAccountingItem(accountingItemFromRow(row)));
+    if (!count)
+      throw new Error("[SixbPg] AI accounting count query returned no row.");
+    const total = safeSqlCount(count.total, "model-call list total");
+    return structuredClone({
+      items,
+      total,
+      hasMore: query.offset + items.length < total
+    });
+  }
+}
+async function findCost(sql, projectId, usageId) {
+  const [row] = await sql`
+    SELECT * FROM ai_model_call_valuations
+    WHERE project_id = ${projectId} AND usage_record_id = ${usageId}
+  `;
+  return row ? rowToCost(row) : null;
+}
+async function findUsage(sql, projectId, id) {
+  const [row] = await sql`
+    SELECT * FROM ai_model_call_usage WHERE project_id = ${projectId} AND id = ${id}
+  `;
+  return row ? usageFromRow(row, []) : null;
+}
+function aggregateFragmentFromRow(row) {
+  const dimensionKeys = row.dimension === "model" ? { providerId: required2(row.key_1), modelId: required2(row.key_2) } : row.dimension === "agent" ? { agentId: required2(row.key_1) } : row.dimension === "workflow" ? { workflowId: required2(row.key_1) } : row.dimension === "series" ? { start: new Date(required2(row.bucket_start)) } : {};
+  return {
+    dimension: row.dimension,
+    ...dimensionKeys,
+    modelCallCount: row.model_call_count,
+    usage: {
+      reportedCallCount: row.reported_usage_call_count,
+      inputTokens: meterFragment(row.input_tokens_count, row.input_tokens_sum),
+      outputTokens: meterFragment(row.output_tokens_count, row.output_tokens_sum),
+      uncachedInputTokens: meterFragment(row.uncached_input_tokens_count, row.uncached_input_tokens_sum),
+      cacheReadInputTokens: meterFragment(row.cache_read_input_tokens_count, row.cache_read_input_tokens_sum),
+      cacheWriteInputTokens: meterFragment(row.cache_write_input_tokens_count, row.cache_write_input_tokens_sum),
+      textOutputTokens: meterFragment(row.text_output_tokens_count, row.text_output_tokens_sum),
+      reasoningOutputTokens: meterFragment(row.reasoning_output_tokens_count, row.reasoning_output_tokens_sum)
+    },
+    costs: {
+      ...row.amount_currency === null || row.amount_nanos === null ? {} : {
+        amount: {
+          currency: row.amount_currency,
+          amountNanos: row.amount_nanos
+        }
+      },
+      ratedCallCount: row.rated_call_count,
+      unpriceableCallCount: row.unpriceable_call_count,
+      unvaluedCallCount: row.unvalued_call_count
+    }
+  };
+}
+function meterFragment(presentCallCount, total) {
+  return { presentCallCount, total };
+}
+function accountingItemFromRow(row) {
+  const usage = usageFromRow(row, parseStringArray(row.requester_group_ids));
+  const cost = row.cost_status === null ? undefined : costFromJoinedRow(row);
+  const attribution = row.attribution_kind === null ? undefined : row.attribution_kind === "agent" ? {
+    kind: "agent",
+    agentId: required2(row.attribution_agent_id),
+    agentRunId: required2(row.attribution_agent_run_id),
+    threadId: required2(row.attribution_thread_id)
+  } : {
+    kind: "workflowAgent",
+    agentId: required2(row.attribution_agent_id),
+    nodeRunId: required2(row.attribution_node_run_id),
+    workflowId: required2(row.attribution_workflow_id),
+    workflowRunId: required2(row.attribution_workflow_run_id)
+  };
+  return {
+    usage,
+    ...attribution ? { attribution } : {},
+    ...cost ? { cost } : {}
+  };
+}
+function usageFromRow(row, requesterGroupIds) {
+  const number = (value) => value === null ? undefined : Number(value);
+  return {
+    id: row.id,
+    projectId: row.project_id,
+    executionId: row.execution_id,
+    attempt: Number(row.attempt),
+    callId: row.call_id,
+    requesterGroupIds,
+    providerId: row.provider_id,
+    requestedModelId: row.requested_model_id,
+    ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
+    responseId: row.response_id,
+    usage: {
+      ...number(row.input_tokens) === undefined ? {} : { inputTokens: number(row.input_tokens) },
+      ...number(row.output_tokens) === undefined ? {} : { outputTokens: number(row.output_tokens) },
+      ...number(row.total_tokens) === undefined ? {} : { totalTokens: number(row.total_tokens) },
+      ...number(row.uncached_input_tokens) === undefined ? {} : { uncachedInputTokens: number(row.uncached_input_tokens) },
+      ...number(row.cache_read_input_tokens) === undefined ? {} : { cacheReadInputTokens: number(row.cache_read_input_tokens) },
+      ...number(row.cache_write_input_tokens) === undefined ? {} : { cacheWriteInputTokens: number(row.cache_write_input_tokens) },
+      ...number(row.text_output_tokens) === undefined ? {} : { textOutputTokens: number(row.text_output_tokens) },
+      ...number(row.reasoning_output_tokens) === undefined ? {} : { reasoningOutputTokens: number(row.reasoning_output_tokens) },
+      reportingStatus: row.reporting_status
+    },
+    ...row.raw_usage === null ? {} : { rawUsage: parseJsonObject(row.raw_usage) },
+    occurredAt: new Date(row.occurred_at),
+    recordedAt: new Date(row.recorded_at)
+  };
+}
+function rowToCost(row) {
+  return costRecord({
+    projectId: row.project_id,
+    usageId: row.usage_record_id,
+    status: row.status,
+    providerId: row.provider_id,
+    modelId: row.model_id,
+    currency: row.currency,
+    amountNanos: row.amount_nanos,
+    reason: row.reason,
+    details: row.details,
+    ratedAt: row.rated_at
+  });
+}
+function costFromJoinedRow(row) {
+  return costRecord({
+    projectId: row.project_id,
+    usageId: row.id,
+    status: required2(row.cost_status),
+    providerId: row.cost_provider_id,
+    modelId: row.cost_model_id,
+    currency: row.cost_currency,
+    amountNanos: row.cost_amount_nanos,
+    reason: row.cost_reason,
+    details: row.cost_details,
+    ratedAt: required2(row.cost_rated_at)
+  });
+}
+function costRecord(input) {
+  const details = parseAiModelCallCostDetails(input.details);
+  const base = {
+    projectId: input.projectId,
+    usageRecordId: input.usageId,
+    pricingContext: details.pricingContext,
+    priceSource: {
+      ...details.priceSource,
+      observedAt: new Date(details.priceSource.observedAt)
+    },
+    ratedAt: new Date(input.ratedAt)
+  };
+  if (input.status === "rated") {
+    return normalizeAiModelCallCostRecord({
+      ...base,
+      status: "rated",
+      billingIdentity: { providerId: required2(input.providerId), modelId: required2(input.modelId) },
+      money: { currency: required2(input.currency), amountNanos: required2(input.amountNanos) },
+      components: required2(details.components)
+    });
+  }
+  return normalizeAiModelCallCostRecord({
+    ...base,
+    status: "unpriceable",
+    ...input.providerId && input.modelId ? { billingIdentity: { providerId: input.providerId, modelId: input.modelId } } : {},
+    reason: required2(input.reason),
+    ...details.missingMeters ? { missingMeters: details.missingMeters } : {}
+  });
+}
+function aggregateSummaryRows(ids, rows) {
+  const map = new Map(ids.map((id) => [id, accumulator()]));
+  for (const row of rows) {
+    const value = map.get(row.execution_id);
+    if (!value)
+      continue;
+    if (row.status === null)
+      value.unvaluedCallCount += 1;
+    else if (row.status === "unpriceable")
+      value.unpriceableCallCount += 1;
+    else {
+      value.ratedCallCount += 1;
+      add(value.amounts, required2(row.currency), required2(row.amount_nanos));
+    }
+  }
+  return ids.map((id) => finish(map.get(id)));
+}
+function accumulator() {
+  return {
+    amounts: new Map,
+    ratedCallCount: 0,
+    unpriceableCallCount: 0,
+    unvaluedCallCount: 0
+  };
+}
+function finish(value) {
+  return {
+    amounts: [...value.amounts].sort(([left], [right]) => left.localeCompare(right)).map(([currency, amount]) => ({ currency, amountNanos: amount.toString() })),
+    ratedCallCount: value.ratedCallCount,
+    unpriceableCallCount: value.unpriceableCallCount,
+    unvaluedCallCount: value.unvaluedCallCount
+  };
+}
+function add(amounts, currency, amount) {
+  amounts.set(currency, (amounts.get(currency) ?? 0n) + BigInt(amount));
+}
+function parseStringArray(value) {
+  const parsed = typeof value === "string" ? JSON.parse(value) : value;
+  if (!Array.isArray(parsed) || parsed.some((item) => typeof item !== "string")) {
+    throw new Error("[SixbPg] AI requester group ids are invalid.");
+  }
+  return parsed;
+}
+function parseJsonObject(value) {
+  return typeof value === "string" ? JSON.parse(value) : value;
+}
+function assertCostMatchesUsage(record, usage) {
+  if (!aiModelCallCostMatchesUsage(record, usage)) {
+    throw new AiCostStorageError("cost_mismatch", `[SixbPg] AI valuation for usage '${record.usageRecordId}' does not match its usage record.`);
+  }
+}
+function missingUsage(record) {
+  return new AiCostStorageError("missing_usage", `[SixbPg] AI usage '${record.usageRecordId}' does not exist.`);
+}
+function assertNonBlank(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new TypeError(`[Sixb] AI ${field} must be nonblank.`);
+  }
+}
+function safeSqlCount(value, field) {
+  if (!/^(0|[1-9]\d*)$/.test(value)) {
+    throw new Error(`[SixbPg] AI accounting ${field} is invalid.`);
+  }
+  const count = Number(value);
+  if (!Number.isSafeInteger(count)) {
+    throw new TypeError(`[Sixb] AI accounting ${field} exceeds the safe integer range.`);
+  }
+  return count;
+}
+function required2(value) {
+  if (value === null || value === undefined) {
+    throw new Error("[SixbPg] AI valuation column is unexpectedly null.");
+  }
+  return value;
+}
+
 // src/pg-ai-usage-storage.ts
 import {
   AiUsageStorageError,
@@ -9950,7 +10764,7 @@ class PgAiUsageStorage {
       ...row.response_model_id === null ? {} : { responseModelId: row.response_model_id },
       responseId: row.response_id,
       usage: {
-        ...usageFromRow(row),
+        ...usageFromRow2(row),
         ...row.total_tokens === null ? {} : { totalTokens: Number(row.total_tokens) },
         reportingStatus: row.reporting_status
       },
@@ -9987,7 +10801,7 @@ function aggregateExecutionRows(executionIds, rows) {
   for (const executionId of executionIds)
     usageByExecutionId.set(executionId, []);
   for (const row of rows) {
-    usageByExecutionId.get(row.execution_id)?.push(usageFromRow(row));
+    usageByExecutionId.get(row.execution_id)?.push(usageFromRow2(row));
   }
   return executionIds.map((executionId) => {
     const usages = usageByExecutionId.get(executionId) ?? [];
@@ -9997,7 +10811,7 @@ function aggregateExecutionRows(executionIds, rows) {
     };
   });
 }
-function usageFromRow(row) {
+function usageFromRow2(row) {
   return {
     ...row.input_tokens === null ? {} : { inputTokens: Number(row.input_tokens) },
     ...row.output_tokens === null ? {} : { outputTokens: Number(row.output_tokens) },
@@ -14190,6 +15004,7 @@ class PostgresStorage {
   executions;
   agents;
   aiUsage;
+  aiCosts;
   actionRuns;
   pipelineRuns;
   workflowRuns;
@@ -14239,6 +15054,7 @@ class PostgresStorage {
     this.executions = createOperationScopedFacade(stores.executions, scope);
     this.agents = createAgentOperationScope(stores.agents, scope);
     this.aiUsage = createOperationScopedFacade(stores.aiUsage, scope);
+    this.aiCosts = createOperationScopedFacade(stores.aiCosts, scope);
     this.actionRuns = createOperationScopedFacade(stores.actionRuns, scope);
     this.pipelineRuns = createOperationScopedFacade(stores.pipelineRuns, scope);
     this.workflowRuns = createWorkflowRunOperationScope(stores.workflowRuns, scope);
@@ -14327,6 +15143,7 @@ function createPostgresStores(sql, options) {
     executions,
     agents: new PgAgentStorage({ sql, executions }),
     aiUsage: new PgAiUsageStorage(sql),
+    aiCosts: new PgAiCostStorage(sql),
     actionRuns: new PgActionRunStorage(sql, executions),
     pipelineRuns: new PgPipelineRunStorage(sql, executions),
     workflowRuns: new PgWorkflowRunStorage(sql, executions),
@@ -14353,4 +15170,4 @@ export {
   PostgresStorage
 };
 
-//# debugId=C543A4DF0CE709F964756E2164756E21
+//# debugId=687ACDC68EF0C51B64756E2164756E21