@sixb/sqlite 0.1.6 → 0.1.8

package/src/agents/runs.ts

@@ -1,5 +1,11 @@
 import type { Database } from "bun:sqlite"
-import { assertAgentRunExecution } from "@sixb/core/internal/agent-run-storage-provider"
+import {
+  assertAgentRunExecution,
+  assertConversationAgentRunSpec,
+  assertCreateSubagentRunInput,
+  assertSubagentRunResult,
+  subagentRunMatchesCreateInput,
+} from "@sixb/core/internal/agent-run-storage-provider"
 import { normalizeRequesterGroupIds } from "@sixb/core/internal/auth"
 import { serializeSixbFailure } from "@sixb/core/internal/errors"
 import {
@@ -8,7 +14,9 @@ import {
   type AgentRunStore,
   AgentStorageError,
   type ConfirmAgentRunExecutionOwnershipInput,
+  type ConversationAgentRunRecord,
   type CreateAgentRunInput,
+  type CreateSubagentRunInput,
   type ExecutionStorage,
   type FinishAgentRunInput,
   type FinishQueuedAgentRunInput,
@@ -16,6 +24,7 @@ import {
   type ListAgentRunsResult,
   type ReclaimAgentRunInput,
   type StartAgentRunInput,
+  type SubagentRunRecord,
 } from "@sixb/core/storage"
 import {
   appendRunListFilters,
@@ -34,14 +43,14 @@ export class SqliteAgentRunStore implements AgentRunStore {
     private readonly executions: ExecutionStorage
   ) {}
 
-  async create(input: CreateAgentRunInput): Promise<AgentRunRecord> {
+  async create(input: CreateAgentRunInput): Promise<ConversationAgentRunRecord> {
+    assertConversationAgentRunSpec(input.spec, "SixbSqlite")
     const createdAt = input.createdAt ?? new Date()
     await assertAgentRunExecution({
       executions: this.executions,
       projectId: input.projectId,
       executionId: input.executionId,
       runId: input.id,
-      agentId: input.agentId,
     })
 
     return this.db.transaction(() => {
@@ -55,7 +64,6 @@ export class SqliteAgentRunStore implements AgentRunStore {
           `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
         )
       }
-
       if (thread.active_run_id !== null) {
         throw new AgentStorageError(
           "active_run_exists",
@@ -71,14 +79,15 @@ export class SqliteAgentRunStore implements AgentRunStore {
               project_id,
               id,
               execution_id,
+              kind,
               thread_id,
-              agent_id,
               trigger_message_id,
+              spec,
               requester_group_ids,
               status,
               attempt,
               created_at
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, 'queued', 0, ?)
+            ) VALUES (?, ?, ?, 'conversation', ?, ?, ?, ?, 'queued', 0, ?)
           `
           )
           .run(
@@ -86,8 +95,8 @@ export class SqliteAgentRunStore implements AgentRunStore {
             input.id,
             input.executionId,
             input.threadId,
-            input.agentId,
             input.triggerMessageId,
+            JSON.stringify(input.spec),
             JSON.stringify(normalizeRequesterGroupIds(input.requesterGroupIds)),
             createdAt.toISOString()
           )
@@ -108,7 +117,115 @@ export class SqliteAgentRunStore implements AgentRunStore {
         )
         .run(input.id, createdAt.toISOString(), input.projectId, input.threadId)
 
-      return this.requireRun(input.projectId, input.id)
+      const created = this.requireRun(input.projectId, input.id)
+      if (created.kind !== "conversation") {
+        throw new Error(`[SixbSqlite] Agent run insert '${input.id}' returned the wrong run kind.`)
+      }
+      return created
+    })()
+  }
+
+  async createSubagent(input: CreateSubagentRunInput): Promise<SubagentRunRecord> {
+    assertCreateSubagentRunInput(input, "SixbSqlite")
+    const execution = await assertAgentRunExecution({
+      executions: this.executions,
+      projectId: input.projectId,
+      executionId: input.executionId,
+      runId: input.id,
+    })
+
+    return this.db.transaction(() => {
+      const parentRow = this.db
+        .query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.parentRunId) as AgentRunRow | null
+      if (!parentRow || parentRow.kind !== "conversation") {
+        throw new AgentStorageError(
+          "run_not_found",
+          `[SixbSqlite] Parent Agent run '${input.parentRunId}' was not found.`
+        )
+      }
+
+      const existingRow = this.db
+        .query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.id) as AgentRunRow | null
+      if (existingRow) {
+        const existing = rowToRunRecord(existingRow)
+        if (subagentRunMatchesCreateInput(existing, input)) return existing
+        throw new AgentStorageError(
+          "duplicate_id",
+          `[SixbSqlite] Subagent run '${input.id}' already exists with different immutable inputs.`
+        )
+      }
+      if (parentRow.status !== "running") {
+        throw new AgentStorageError(
+          "invalid_state",
+          `[SixbSqlite] Parent Agent run '${parentRow.id}' is not running (status '${parentRow.status}').`
+        )
+      }
+      if (
+        execution.source.type !== "execution" ||
+        execution.source.executionId !== parentRow.execution_id
+      ) {
+        throw new AgentStorageError(
+          "invalid_input",
+          `[SixbSqlite] Subagent execution '${execution.id}' is not a child of parent execution '${parentRow.execution_id}'.`
+        )
+      }
+      if (parentRow.execution_token !== input.parentExecutionToken) {
+        throw new AgentStorageError(
+          "execution_lost",
+          `[SixbSqlite] Parent Agent run '${parentRow.id}' is no longer owned by this execution.`
+        )
+      }
+
+      const count = this.db
+        .query(
+          `SELECT COUNT(*) AS count FROM agent_runs
+           WHERE project_id = ? AND parent_run_id = ? AND status IN ('queued', 'running')`
+        )
+        .get(input.projectId, input.parentRunId) as { count: number }
+      if (count.count >= input.maxActiveChildren) {
+        throw new AgentStorageError(
+          "active_child_limit",
+          `[SixbSqlite] Agent run '${parentRow.id}' already has ${count.count} active subagents.`
+        )
+      }
+
+      try {
+        this.db
+          .query(
+            `
+            INSERT INTO agent_runs (
+              project_id, id, execution_id, kind, parent_run_id, spawn_key, spec,
+              requester_group_ids, status, attempt, created_at
+            ) VALUES (?, ?, ?, 'subagent', ?, ?, ?, ?, 'queued', 0, ?)
+          `
+          )
+          .run(
+            input.projectId,
+            input.id,
+            input.executionId,
+            input.parentRunId,
+            input.spawnKey,
+            JSON.stringify(input.spec),
+            parentRow.requester_group_ids,
+            (input.createdAt ?? new Date()).toISOString()
+          )
+      } catch (error) {
+        if (isUniqueConstraintError(error)) {
+          throw new AgentStorageError(
+            "duplicate_id",
+            `[SixbSqlite] Subagent run '${input.id}' conflicts with an existing durable spawn.`
+          )
+        }
+        throw error
+      }
+
+      const created = this.requireRun(input.projectId, input.id)
+      if (created.kind !== "subagent") {
+        throw new Error(`[SixbSqlite] Subagent insert '${input.id}' returned the wrong run kind.`)
+      }
+      return created
     })()
   }
 
@@ -205,7 +322,6 @@ export class SqliteAgentRunStore implements AgentRunStore {
           `[SixbSqlite] Execution token is no longer current on agent run '${input.id}'.`
         )
       }
-
       this.db
         .query(
           `
@@ -235,6 +351,19 @@ export class SqliteAgentRunStore implements AgentRunStore {
           `[SixbSqlite] Execution token is no longer current on agent run '${input.id}'.`
         )
       }
+      if (input.status === "succeeded" && run.kind === "subagent") {
+        assertSubagentRunResult(input.result, run.id, "SixbSqlite")
+      }
+      if (
+        input.status === "succeeded" &&
+        run.kind === "conversation" &&
+        input.result !== undefined
+      ) {
+        throw new AgentStorageError(
+          "invalid_input",
+          `[SixbSqlite] Conversational Agent run '${run.id}' cannot persist a subagent result.`
+        )
+      }
 
       this.db
         .query(
@@ -246,6 +375,7 @@ export class SqliteAgentRunStore implements AgentRunStore {
             finish_reason = ?,
             error = ?,
             diagnostics = ?,
+            result = ?,
             execution_token = NULL,
             execution_queue_lease_expires_at = NULL,
             completed_at = ?
@@ -258,6 +388,9 @@ export class SqliteAgentRunStore implements AgentRunStore {
           input.finishReason ?? null,
           errorValue,
           input.diagnostics === undefined ? null : JSON.stringify(input.diagnostics),
+          input.status === "succeeded" && input.result !== undefined
+            ? JSON.stringify(input.result)
+            : null,
           completedAt.toISOString(),
           input.projectId,
           input.id
@@ -304,21 +437,26 @@ export class SqliteAgentRunStore implements AgentRunStore {
   }
 
   async list(input: ListAgentRunsInput): Promise<ListAgentRunsResult> {
-    if (hasEmptyStatuses(input)) {
+    if (hasEmptyStatuses(input) || input.kinds?.length === 0) {
       return { runs: [], hasMore: false, total: 0 }
     }
 
     const whereClauses = ["project_id = ?"]
     const args: SqliteValue[] = [input.projectId]
 
+    if (input.kinds) {
+      whereClauses.push(`kind IN (${input.kinds.map(() => "?").join(", ")})`)
+      args.push(...input.kinds)
+    }
+
     if (input.threadId) {
       whereClauses.push("thread_id = ?")
       args.push(input.threadId)
     }
 
-    if (input.agentId) {
-      whereClauses.push("agent_id = ?")
-      args.push(input.agentId)
+    if (input.parentRunId) {
+      whereClauses.push("parent_run_id = ?")
+      args.push(input.parentRunId)
     }
 
     appendRunListFilters(whereClauses, args, input, "COALESCE(started_at, created_at)")
@@ -367,6 +505,7 @@ export class SqliteAgentRunStore implements AgentRunStore {
   }
 
   private releaseThread(run: AgentRunRow, completedAt: Date): void {
+    if (run.kind !== "conversation") return
     this.db
       .query(
         `

package/src/agents/threads.ts

@@ -25,7 +25,6 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
           INSERT INTO agent_threads (
             project_id,
             id,
-            agent_id,
             owner_principal_type,
             owner_principal_id,
             title,
@@ -35,13 +34,12 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
             message_count,
             created_at,
             updated_at
-          ) VALUES (?, ?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?)
+          ) VALUES (?, ?, ?, ?, ?, ?, NULL, NULL, 0, ?, ?)
         `
         )
         .run(
           input.projectId,
           input.id,
-          input.agentId,
           input.ownerPrincipal.type,
           input.ownerPrincipal.id,
           input.title ?? null,
@@ -72,26 +70,13 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
   }
 
   async list(input: ListAgentThreadsInput): Promise<ListAgentThreadsResult> {
-    if (
-      (input.statuses !== undefined && input.statuses.length === 0) ||
-      (input.agentIds !== undefined && input.agentIds.length === 0)
-    ) {
+    if (input.statuses !== undefined && input.statuses.length === 0) {
       return { threads: [], hasMore: false, total: 0 }
     }
 
     const whereClauses = ["project_id = ?"]
     const args: SqliteValue[] = [input.projectId]
 
-    if (input.agentId) {
-      whereClauses.push("agent_id = ?")
-      args.push(input.agentId)
-    }
-
-    if (input.agentIds) {
-      whereClauses.push(`agent_id IN (${input.agentIds.map(() => "?").join(", ")})`)
-      args.push(...input.agentIds)
-    }
-
     if (input.statuses) {
       whereClauses.push(`status IN (${input.statuses.map(() => "?").join(", ")})`)
       args.push(...input.statuses)

package/src/ai-cost-groups.ts

@@ -0,0 +1,100 @@
+import {
+  type AiModelCallGroupRow,
+  aiModelCallGroupFragmentFromRow,
+  buildAiModelCallGroupsFromFragments,
+  normalizeAiModelCallAccountingQuery,
+} from "@sixb/core/internal/ai-cost-storage-provider"
+import type { ListAiModelCallGroupsInput, ListAiModelCallGroupsResult } from "@sixb/core/storage"
+import type { SqliteStoreConnection } from "./transactions"
+
+/** Paginate initiating executions, then aggregate their matching calls without loading usage payloads. */
+export async function listAiModelCallGroups(
+  connection: SqliteStoreConnection,
+  input: ListAiModelCallGroupsInput
+): Promise<ListAiModelCallGroupsResult> {
+  const query = normalizeAiModelCallAccountingQuery(input)
+  const parameters = [
+    query.projectId,
+    query.from.toISOString(),
+    query.to.toISOString(),
+    query.providerId ?? null,
+    query.modelId ?? null,
+    query.valuationStatus ?? null,
+  ]
+  const count = connection.db.query(COUNT_SQL).get(...parameters) as { total: string }
+  const rows = connection.db
+    .query(PAGE_SQL)
+    .all(...parameters, query.limit, query.offset) as AiModelCallGroupRow[]
+  const total = Number(count?.total)
+  if (!Number.isSafeInteger(total) || total < 0)
+    throw new RangeError("[Sixb] Invalid model-call group count.")
+  const items = buildAiModelCallGroupsFromFragments(rows.map(aiModelCallGroupFragmentFromRow))
+  return { items, total, hasMore: query.offset + items.length < total }
+}
+
+const FILTERED_SQL = `
+WITH filtered AS (
+  SELECT COALESCE(root_agent.execution_id, usage.execution_id) AS root_execution_id,
+    usage.execution_id, usage.provider_id, usage.requested_model_id, usage.occurred_at,
+    usage.total_tokens,
+    COALESCE(cost.status, 'unvalued') AS valuation_status,
+    cost.currency AS amount_currency, cost.amount_nanos,
+    root_agent.id AS root_agent_run_id,
+    root_agent.thread_id AS root_thread_id,
+    direct_agent.kind AS direct_kind,
+    direct_agent.id AS direct_run_id,
+    direct_agent.parent_run_id AS parent_run_id,
+    workflow_node.node_id AS workflow_agent_step_id,
+    workflow_agent.node_run_id AS workflow_node_run_id,
+    workflow_node.workflow_id AS workflow_id,
+    workflow_node.workflow_run_id AS workflow_run_id
+  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 agent_runs AS root_agent
+    ON root_agent.project_id = usage.project_id
+    AND root_agent.id = COALESCE(direct_agent.parent_run_id, direct_agent.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 = ?1
+    AND usage.occurred_at >= ?2
+    AND usage.occurred_at < ?3
+    AND (?4 IS NULL OR usage.provider_id = ?4)
+    AND (?5 IS NULL OR usage.requested_model_id = ?5)
+    AND (?6 IS NULL OR COALESCE(cost.status, 'unvalued') = ?6)
+), roots AS (
+  SELECT root_execution_id, MAX(occurred_at) AS last_call_at
+  FROM filtered GROUP BY root_execution_id
+)
+`
+const COUNT_SQL = `${FILTERED_SQL} SELECT CAST(COUNT(*) AS TEXT) AS total FROM roots`
+const PAGE_SQL = `${FILTERED_SQL}, page AS (
+  SELECT root_execution_id FROM roots
+  ORDER BY last_call_at DESC, root_execution_id ASC LIMIT ?7 OFFSET ?8
+)
+SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_id,
+  MIN(occurred_at) AS first_call_at, MAX(occurred_at) AS last_call_at,
+  CAST(COUNT(*) AS TEXT) AS call_count,
+  CAST(COUNT(total_tokens) AS TEXT) AS token_count,
+  CAST(SUM(total_tokens) AS TEXT) AS total_tokens,
+  valuation_status, amount_currency,
+  CAST(SUM(amount_nanos / 1000000000000) AS TEXT) AS amount_high,
+  CAST(SUM((amount_nanos / 1000000) % 1000000) AS TEXT) AS amount_middle,
+  CAST(SUM(amount_nanos % 1000000) AS TEXT) AS amount_low,
+  MAX(root_agent_run_id) AS root_agent_run_id,
+  MAX(root_thread_id) AS root_thread_id,
+  MAX(direct_kind) AS direct_kind,
+  MAX(direct_run_id) AS direct_run_id,
+  MAX(parent_run_id) AS parent_run_id,
+  MAX(workflow_agent_step_id) AS workflow_agent_step_id,
+  MAX(workflow_node_run_id) AS workflow_node_run_id,
+  MAX(workflow_id) AS workflow_id,
+  MAX(workflow_run_id) AS workflow_run_id
+FROM filtered JOIN page ON page.root_execution_id = filtered.root_execution_id
+GROUP BY filtered.root_execution_id, execution_id, provider_id, requested_model_id,
+  valuation_status, amount_currency
+`

package/src/ai-cost-storage.ts

@@ -10,6 +10,7 @@ import {
   parseAiModelCallCostDetails,
   toAccountingItem,
 } from "@sixb/core/internal/ai-cost-storage-provider"
+import { normalizeModelProviderIds } from "@sixb/core/models"
 import type { ReadonlyJsonObject } from "@sixb/core/storage"
 import {
   type AiAccountingOverview,
@@ -20,9 +21,13 @@ import {
   type AiModelCallUsageRecord,
   type ListAiModelCallAccountingInput,
   type ListAiModelCallAccountingResult,
+  type ListAiModelCallGroupsInput,
+  type ListAiModelCallGroupsResult,
   type QueryAiAccountingOverviewInput,
   type SummarizeAiCostExecutionsInput,
 } from "@sixb/core/storage"
+import { listAiModelCallGroups } from "./ai-cost-groups"
+import { requestedReasoningFromRow } from "./ai-usage-storage"
 import { isUniqueConstraintError } from "./storage-errors"
 import { runImmediateTransaction, type SqliteStoreConnection } from "./transactions"
 
@@ -30,6 +35,12 @@ import { runImmediateTransaction, type SqliteStoreConnection } from "./transacti
 export class SqliteAiCostStorage implements AiCostStorage {
   constructor(private readonly connection: SqliteStoreConnection) {}
 
+  async listModelCallGroups(
+    input: ListAiModelCallGroupsInput
+  ): Promise<ListAiModelCallGroupsResult> {
+    return listAiModelCallGroups(this.connection, input)
+  }
+
   async recordModelCallCost(input: AiModelCallCostRecord): Promise<void> {
     const record = normalizeAiModelCallCostRecord(input)
     runImmediateTransaction(this.connection.db, () => {
@@ -176,13 +187,15 @@ const SQLITE_ACCOUNTING_LIST_COUNT_SQL = `
 const SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
   SELECT usage.*,
     CASE
-      WHEN direct_agent.id IS NOT NULL THEN 'agent'
+      WHEN direct_agent.kind = 'conversation' THEN 'agent'
+      WHEN direct_agent.kind = 'subagent' THEN 'subagent'
       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,
+    workflow_node.node_id AS attribution_agent_step_id,
     direct_agent.id AS attribution_agent_run_id,
     direct_agent.thread_id AS attribution_thread_id,
+    direct_agent.parent_run_id AS attribution_parent_run_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,
@@ -231,7 +244,12 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
       usage.text_output_tokens,
       usage.reasoning_output_tokens,
       usage.reporting_status,
-      COALESCE(direct_agent.agent_id, workflow_agent.agent_id) AS attribution_agent_id,
+      CASE
+        WHEN direct_agent.kind = 'conversation' THEN 'agent'
+        WHEN workflow_agent.node_run_id IS NOT NULL THEN 'workflowAgent'
+        ELSE NULL
+      END AS attribution_agent_kind,
+      workflow_node.node_id AS attribution_agent_step_id,
       workflow_node.workflow_id AS attribution_workflow_id,
       CASE
         WHEN cost.status = 'rated' THEN 'rated'
@@ -256,11 +274,11 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
       AND (? IS NULL OR usage.provider_id = ?)
       AND (? IS NULL OR usage.requested_model_id = ?)
   ), expanded AS (
-    SELECT 'totals' AS dimension, NULL AS key_1, NULL AS key_2, NULL AS bucket_start,
+    SELECT 'totals' AS dimension, NULL AS key_1, NULL AS key_2, NULL AS key_3, NULL AS bucket_start,
       classified.*
     FROM classified
     UNION ALL
-    SELECT 'series', NULL, NULL,
+    SELECT 'series', NULL, NULL, NULL,
       CASE ?
         WHEN 'hour' THEN strftime('%Y-%m-%dT%H:00:00.000Z', occurred_at)
         WHEN 'day' THEN strftime('%Y-%m-%dT00:00:00.000Z', occurred_at)
@@ -273,17 +291,18 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
       classified.*
     FROM classified
     UNION ALL
-    SELECT 'model', provider_id, requested_model_id, NULL, classified.* FROM classified
+    SELECT 'model', provider_id, requested_model_id, NULL, NULL, classified.* FROM classified
     UNION ALL
-    SELECT 'agent', attribution_agent_id, NULL, NULL, classified.*
-    FROM classified WHERE attribution_agent_id IS NOT NULL
+    SELECT 'agent', attribution_agent_kind, attribution_workflow_id, attribution_agent_step_id, NULL, classified.*
+    FROM classified WHERE attribution_agent_kind IS NOT NULL
     UNION ALL
-    SELECT 'workflow', attribution_workflow_id, NULL, NULL, classified.*
+    SELECT 'workflow', attribution_workflow_id, NULL, NULL, NULL, classified.*
     FROM classified WHERE attribution_workflow_id IS NOT NULL
   )
   SELECT dimension,
     key_1,
     key_2,
+    key_3,
     bucket_start,
     amount_currency,
     CAST(COUNT(*) AS TEXT) AS model_call_count,
@@ -313,7 +332,7 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     CAST(SUM((amount_nanos / 1000000) % 1000000) AS TEXT) AS amount_middle,
     CAST(SUM(amount_nanos % 1000000) AS TEXT) AS amount_low
   FROM expanded
-  GROUP BY dimension, key_1, key_2, bucket_start, amount_currency
+  GROUP BY dimension, key_1, key_2, key_3, bucket_start, amount_currency
 `
 
 function accountingListFilterParameters(
@@ -355,6 +374,7 @@ interface UsageRow {
   readonly call_id: string
   readonly provider_id: string
   readonly requested_model_id: string
+  readonly requested_reasoning: string | null
   readonly response_model_id: string | null
   readonly response_id: string
   readonly input_tokens: number | null
@@ -367,15 +387,17 @@ interface UsageRow {
   readonly reasoning_output_tokens: number | null
   readonly reporting_status: AiModelCallUsageRecord["usage"]["reportingStatus"]
   readonly raw_usage: string | null
+  readonly provider_ids: string | null
   readonly occurred_at: string
   readonly recorded_at: string
 }
 
 interface JoinedRow extends UsageRow {
-  readonly attribution_kind: "agent" | "workflowAgent" | null
-  readonly attribution_agent_id: string | null
+  readonly attribution_kind: "agent" | "subagent" | "workflowAgent" | null
+  readonly attribution_agent_step_id: string | null
   readonly attribution_agent_run_id: string | null
   readonly attribution_thread_id: string | null
+  readonly attribution_parent_run_id: string | null
   readonly attribution_node_run_id: string | null
   readonly attribution_workflow_id: string | null
   readonly attribution_workflow_run_id: string | null
@@ -394,6 +416,7 @@ interface AggregateRow {
   readonly dimension: AiAccountingAggregateFragment["dimension"]
   readonly key_1: string | null
   readonly key_2: string | null
+  readonly key_3: string | null
   readonly bucket_start: string | null
   readonly amount_currency: string | null
   readonly model_call_count: string
@@ -436,7 +459,12 @@ function aggregateFragmentFromRow(row: AggregateRow): AiAccountingAggregateFragm
     row.dimension === "model"
       ? { providerId: required(row.key_1), modelId: required(row.key_2) }
       : row.dimension === "agent"
-        ? { agentId: required(row.key_1) }
+        ? {
+            agentKind: required(row.key_1) as "agent" | "workflowAgent",
+            ...(row.key_1 === "workflowAgent"
+              ? { workflowId: required(row.key_2), agentStepId: required(row.key_3) }
+              : {}),
+          }
         : row.dimension === "workflow"
           ? { workflowId: required(row.key_1) }
           : row.dimension === "series"
@@ -510,17 +538,22 @@ function accountingItemFromRow(row: JoinedRow): AiAccountingRecordSetItem {
       : row.attribution_kind === "agent"
         ? {
             kind: "agent" as const,
-            agentId: required(row.attribution_agent_id),
             agentRunId: required(row.attribution_agent_run_id),
             threadId: required(row.attribution_thread_id),
           }
-        : {
-            kind: "workflowAgent" as const,
-            agentId: required(row.attribution_agent_id),
-            nodeRunId: required(row.attribution_node_run_id),
-            workflowId: required(row.attribution_workflow_id),
-            workflowRunId: required(row.attribution_workflow_run_id),
-          }
+        : row.attribution_kind === "subagent"
+          ? {
+              kind: "subagent" as const,
+              subagentRunId: required(row.attribution_agent_run_id),
+              parentRunId: required(row.attribution_parent_run_id),
+            }
+          : {
+              kind: "workflowAgent" as const,
+              agentStepId: required(row.attribution_agent_step_id),
+              nodeRunId: required(row.attribution_node_run_id),
+              workflowId: required(row.attribution_workflow_id),
+              workflowRunId: required(row.attribution_workflow_run_id),
+            }
   return {
     usage,
     ...(attribution ? { attribution } : {}),
@@ -537,7 +570,13 @@ function usageFromRow(row: UsageRow, requesterGroupIds: readonly string[]): AiMo
     callId: row.call_id,
     requesterGroupIds,
     providerId: row.provider_id,
+    ...(row.provider_ids === null
+      ? {}
+      : { providerIds: normalizeModelProviderIds(JSON.parse(row.provider_ids)) }),
     requestedModelId: row.requested_model_id,
+    ...(row.requested_reasoning === null
+      ? {}
+      : { requestedReasoning: requestedReasoningFromRow(row.requested_reasoning) }),
     ...(row.response_model_id === null ? {} : { responseModelId: row.response_model_id }),
     responseId: row.response_id,
     usage: {
@@ -610,14 +649,15 @@ function costRecord(input: {
   ratedAt: string
 }): AiModelCallCostRecord {
   const details = parseAiModelCallCostDetails(input.details)
+  const priceSource =
+    details.priceSource === undefined
+      ? undefined
+      : { ...details.priceSource, observedAt: new Date(details.priceSource.observedAt) }
   const base = {
+    ...(details.estimate === undefined ? {} : { estimate: details.estimate }),
     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") {
@@ -625,6 +665,7 @@ function costRecord(input: {
       ...base,
       status: "rated",
       billingIdentity: { providerId: required(input.providerId), modelId: required(input.modelId) },
+      priceSource: required(priceSource),
       money: { currency: required(input.currency), amountNanos: required(input.amountNanos) },
       components: required(details.components),
     })
@@ -635,6 +676,7 @@ function costRecord(input: {
     ...(input.providerId && input.modelId
       ? { billingIdentity: { providerId: input.providerId, modelId: input.modelId } }
       : {}),
+    ...(priceSource === undefined ? {} : { priceSource }),
     reason: required(input.reason) as Extract<
       AiModelCallCostRecord,
       { status: "unpriceable" }