@sixb/sqlite 0.1.21 → 0.1.23

package/src/agents/threads.ts

@@ -1,24 +1,40 @@
 import type { Database } from "bun:sqlite"
 import {
+  assertConversationThreadRow,
+  participantsToAdd,
+  planAgentThreadFork,
+  remapArtifactIds,
   snapshotAgentThreadSandboxParams,
   transitionAgentThreadSandbox,
 } from "@sixb/core/internal/agent-run-storage-provider"
 import {
+  type AddAgentThreadParticipantsInput,
+  type AgentContextCheckpointRecord,
   AgentStorageError,
+  type AgentThreadParticipantRecord,
   type AgentThreadRecord,
   type AgentThreadSandboxState,
   type AgentThreadStore,
   type CreateAgentThreadInput,
+  type ForkAgentThreadInput,
+  type ListAgentThreadChildrenInput,
+  type ListAgentThreadParticipantsInput,
   type ListAgentThreadsInput,
   type ListAgentThreadsResult,
+  type RemoveAgentThreadParticipantInput,
   type TransitionAgentThreadSandboxInput,
 } from "@sixb/core/storage"
 import type { SqliteValue } from "../run-list-query"
 import { isUniqueConstraintError } from "../storage-errors"
 import {
+  type AgentContextCheckpointRow,
+  type AgentMessageRow,
   type AgentRunRow,
+  type AgentThreadParticipantRow,
   type AgentThreadRow,
   queryAgentList,
+  rowToContextCheckpointRecord,
+  rowToParticipantRecord,
   rowToRunRecord,
   rowToThreadRecord,
 } from "./rows"
@@ -100,6 +116,130 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
     return this.requireThread(input.projectId, input.id)
   }
 
+  async fork(input: ForkAgentThreadInput): Promise<AgentThreadRecord> {
+    return this.db
+      .transaction(() => {
+        const source = this.db
+          .query(
+            "SELECT id, kind, active_run_id FROM agent_threads WHERE project_id = ? AND id = ?"
+          )
+          .get(input.projectId, input.sourceThreadId) as Pick<
+          AgentThreadRow,
+          "id" | "kind" | "active_run_id"
+        > | null
+
+        if (!source) {
+          throw new AgentStorageError(
+            "thread_not_found",
+            `[SixbSqlite] Agent thread '${input.sourceThreadId}' not found for project '${input.projectId}'.`
+          )
+        }
+        assertConversationThreadRow(source, "can be forked", "SixbSqlite")
+
+        const activeRun = source.active_run_id === null ? null : this.findActiveRun(input, source)
+
+        // Only what the plan needs: the parts are copied by the database, not through here. A
+        // message of approval outcomes only is not counted (`countsAsThreadMessage`).
+        const messages = (
+          this.db
+            .query(
+              `
+              SELECT id, seq,
+                NOT (
+                  json_array_length(parts) > 0 AND NOT EXISTS (
+                    SELECT 1 FROM json_each(agent_messages.parts)
+                    WHERE json_extract(value, '$.type') <> 'approval-outcome'
+                  )
+                ) AS counted
+              FROM agent_messages WHERE project_id = ? AND thread_id = ? ORDER BY seq ASC
+            `
+            )
+            .all(input.projectId, source.id) as (Pick<AgentMessageRow, "id" | "seq"> & {
+            counted: number
+          })[]
+        ).map((row) => ({ id: row.id, seq: row.seq, counted: row.counted === 1 }))
+
+        const checkpoints = this.db
+          .query(
+            `
+            SELECT * FROM agent_context_checkpoints
+            WHERE project_id = ? AND thread_id = ?
+            ORDER BY summarized_through_seq DESC, created_at DESC, id DESC
+          `
+          )
+          .all(input.projectId, source.id) as AgentContextCheckpointRow[]
+
+        const plan = planAgentThreadFork(
+          input,
+          {
+            ...(activeRun?.trigger_message_id
+              ? { triggerMessageId: activeRun.trigger_message_id }
+              : {}),
+            messages,
+            checkpoints: checkpoints.map(rowToContextCheckpointRecord),
+          },
+          "SixbSqlite"
+        )
+
+        this.insertForkedThread(plan.thread)
+
+        this.db
+          .query(
+            `
+            INSERT INTO agent_messages (
+              project_id,
+              id,
+              thread_id,
+              run_id,
+              role,
+              author_principal_type,
+              author_principal_id,
+              seq,
+              parts,
+              metadata,
+              content_version,
+              created_at,
+              completed_at
+            )
+            SELECT
+              message.project_id,
+              json_extract(copy.value, '$[1]'),
+              ?,
+              message.run_id,
+              message.role,
+              message.author_principal_type,
+              message.author_principal_id,
+              message.seq,
+              message.parts,
+              message.metadata,
+              message.content_version,
+              message.created_at,
+              message.completed_at
+            FROM json_each(?) AS copy
+            JOIN agent_messages AS message
+              ON message.project_id = ? AND message.id = json_extract(copy.value, '$[0]')
+          `
+          )
+          .run(
+            plan.thread.id,
+            JSON.stringify(plan.messages.map((copy) => [copy.sourceId, copy.id])),
+            input.projectId
+          )
+        this.remapCopiedParts(
+          input.projectId,
+          plan.messages.map((copy) => copy.id),
+          input.artifactCopies
+        )
+
+        if (plan.checkpoint) {
+          this.insertCopiedCheckpoint(plan.checkpoint)
+        }
+
+        return this.requireThread(input.projectId, input.id)
+      })
+      .immediate()
+  }
+
   async getById(params: { projectId: string; id: string }): Promise<AgentThreadRecord | null> {
     const row = this.db
       .query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?")
@@ -135,12 +275,36 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
     })
   }
 
+  async listChildren(input: ListAgentThreadChildrenInput): Promise<readonly AgentThreadRecord[]> {
+    // By `idx_agent_threads_children`, which holds sub-agents' threads only.
+    const turn = input.parentRunId === undefined ? "" : "AND parent_run_id = ?"
+    const rows = this.db
+      .query(
+        `
+        SELECT *
+        FROM agent_threads
+        WHERE project_id = ? AND parent_thread_id = ? AND kind = 'subagent' ${turn}
+        ORDER BY created_at ASC, id ASC
+        LIMIT ? OFFSET ?
+      `
+      )
+      .all(
+        input.projectId,
+        input.parentThreadId,
+        ...(input.parentRunId === undefined ? [] : [input.parentRunId]),
+        input.limit ?? 100,
+        input.offset ?? 0
+      ) as AgentThreadRow[]
+    return rows.map(rowToThreadRecord)
+  }
+
   async list(input: ListAgentThreadsInput): Promise<ListAgentThreadsResult> {
     if (input.statuses !== undefined && input.statuses.length === 0) {
       return { threads: [], hasMore: false, total: 0 }
     }
 
-    const whereClauses = ["project_id = ?"]
+    // A sub-agent's thread is read through its conversation; the list indexes leave it out too.
+    const whereClauses = ["project_id = ?", "kind = 'conversation'"]
     const args: SqliteValue[] = [input.projectId]
 
     if (input.statuses) {
@@ -153,6 +317,17 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
       args.push(input.ownerPrincipal.type, input.ownerPrincipal.id)
     }
 
+    if (input.participantPrincipal) {
+      whereClauses.push(`EXISTS (
+        SELECT 1 FROM agent_thread_participants participant
+        WHERE participant.project_id = agent_threads.project_id
+          AND participant.thread_id = agent_threads.id
+          AND participant.principal_type = ?
+          AND participant.principal_id = ?
+      )`)
+      args.push(input.participantPrincipal.type, input.participantPrincipal.id)
+    }
+
     const dir = input.order === "asc" ? "ASC" : "DESC"
     const { rows, total, hasMore } = queryAgentList<AgentThreadRow>({
       db: this.db,
@@ -167,6 +342,215 @@ export class SqliteAgentThreadStore implements AgentThreadStore {
     return { threads: rows.map(rowToThreadRecord), hasMore, total }
   }
 
+  async addParticipants(
+    input: AddAgentThreadParticipantsInput
+  ): Promise<readonly AgentThreadParticipantRecord[]> {
+    return this.db
+      .transaction(() => {
+        const thread = this.db
+          .query("SELECT id, kind FROM agent_threads WHERE project_id = ? AND id = ?")
+          .get(input.projectId, input.threadId) as Pick<AgentThreadRow, "id" | "kind"> | null
+        if (!thread) {
+          throw new AgentStorageError(
+            "thread_not_found",
+            `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
+          )
+        }
+        assertConversationThreadRow(thread, "has participants", "SixbSqlite")
+
+        const existing = this.selectParticipants(input.projectId, [input.threadId])
+        const added = participantsToAdd(input, existing, "SixbSqlite")
+        const addedAt = (input.addedAt ?? new Date()).toISOString()
+
+        const insert = this.db.query(`
+          INSERT INTO agent_thread_participants (
+            project_id,
+            thread_id,
+            principal_type,
+            principal_id,
+            added_at,
+            added_by_type,
+            added_by_id
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `)
+        for (const principal of added) {
+          insert.run(
+            input.projectId,
+            input.threadId,
+            principal.type,
+            principal.id,
+            addedAt,
+            input.addedBy.type,
+            input.addedBy.id
+          )
+        }
+
+        return added.length === 0
+          ? existing
+          : this.selectParticipants(input.projectId, [input.threadId])
+      })
+      .immediate()
+  }
+
+  async removeParticipant(input: RemoveAgentThreadParticipantInput): Promise<boolean> {
+    const result = this.db
+      .query(`
+        DELETE FROM agent_thread_participants
+        WHERE project_id = ? AND thread_id = ? AND principal_type = ? AND principal_id = ?
+      `)
+      .run(input.projectId, input.threadId, input.principal.type, input.principal.id)
+
+    return result.changes > 0
+  }
+
+  async listParticipants(
+    input: ListAgentThreadParticipantsInput
+  ): Promise<readonly AgentThreadParticipantRecord[]> {
+    return this.selectParticipants(input.projectId, [...new Set(input.threadIds)])
+  }
+
+  private selectParticipants(
+    projectId: string,
+    threadIds: readonly string[]
+  ): AgentThreadParticipantRecord[] {
+    if (threadIds.length === 0) {
+      return []
+    }
+
+    const rows = this.db
+      .query(`
+        SELECT *
+        FROM agent_thread_participants
+        WHERE project_id = ?
+          AND thread_id IN (SELECT value FROM json_each(?))
+        ORDER BY added_at, principal_id, thread_id
+      `)
+      .all(projectId, JSON.stringify(threadIds)) as AgentThreadParticipantRow[]
+
+    return rows.map(rowToParticipantRecord)
+  }
+
+  private findActiveRun(
+    input: ForkAgentThreadInput,
+    source: Pick<AgentThreadRow, "active_run_id">
+  ): Pick<AgentRunRow, "trigger_message_id"> | null {
+    return this.db
+      .query("SELECT trigger_message_id FROM agent_runs WHERE project_id = ? AND id = ?")
+      .get(input.projectId, source.active_run_id) as Pick<AgentRunRow, "trigger_message_id"> | null
+  }
+
+  private insertForkedThread(thread: AgentThreadRecord): void {
+    try {
+      this.db
+        .query(
+          `
+          INSERT INTO agent_threads (
+            project_id,
+            id,
+            owner_principal_type,
+            owner_principal_id,
+            title,
+            sandbox_params,
+            sandbox_state,
+            status,
+            active_run_id,
+            last_message_at,
+            message_count,
+            created_at,
+            updated_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?)
+        `
+        )
+        .run(
+          thread.projectId,
+          thread.id,
+          thread.ownerPrincipal.type,
+          thread.ownerPrincipal.id,
+          thread.title ?? null,
+          thread.sandboxParams === undefined ? null : JSON.stringify(thread.sandboxParams),
+          thread.sandboxState === undefined ? null : JSON.stringify(thread.sandboxState),
+          thread.status,
+          thread.lastMessageAt?.toISOString() ?? null,
+          thread.messageCount,
+          thread.createdAt.toISOString(),
+          thread.updatedAt.toISOString()
+        )
+    } catch (error) {
+      if (isUniqueConstraintError(error)) {
+        throw new AgentStorageError(
+          "duplicate_id",
+          `[SixbSqlite] Agent thread '${thread.id}' already exists for project '${thread.projectId}'.`
+        )
+      }
+
+      throw error
+    }
+  }
+
+  private insertCopiedCheckpoint(checkpoint: AgentContextCheckpointRecord): void {
+    this.db
+      .query(
+        `
+        INSERT INTO agent_context_checkpoints (
+          project_id,
+          id,
+          thread_id,
+          created_by_run_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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `
+      )
+      .run(
+        checkpoint.projectId,
+        checkpoint.id,
+        checkpoint.threadId,
+        checkpoint.createdByRunId,
+        checkpoint.reason,
+        checkpoint.summary,
+        checkpoint.summaryFormatVersion,
+        checkpoint.summarizedThroughSeq,
+        checkpoint.observedHeadSeq,
+        checkpoint.estimatedInputTokensBefore,
+        checkpoint.estimatedInputTokensAfter,
+        checkpoint.summaryModelId,
+        checkpoint.createdAt.toISOString()
+      )
+  }
+
+  /** The copied messages name the fork's copies of the source's artifacts. */
+  private remapCopiedParts(
+    projectId: string,
+    messageIds: readonly string[],
+    copies: Readonly<Record<string, string>> | undefined
+  ): void {
+    if (!copies || Object.keys(copies).length === 0 || messageIds.length === 0) return
+
+    const rows = this.db
+      .query(
+        `SELECT id, parts FROM agent_messages
+         WHERE project_id = ? AND id IN (SELECT value FROM json_each(?))`
+      )
+      .all(projectId, JSON.stringify(messageIds)) as {
+      readonly id: string
+      readonly parts: string
+    }[]
+    const update = this.db.query(
+      "UPDATE agent_messages SET parts = ? WHERE project_id = ? AND id = ?"
+    )
+    for (const row of rows) {
+      const parts = remapArtifactIds(row.parts, copies)
+      if (parts !== row.parts) update.run(parts, projectId, row.id)
+    }
+  }
+
   private requireThread(projectId: string, id: string): AgentThreadRecord {
     const row = this.db
       .query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?")

package/src/ai-cost-groups.ts

@@ -3,6 +3,7 @@ import {
   aiModelCallGroupFragmentFromRow,
   buildAiModelCallGroupsFromFragments,
   normalizeAiModelCallAccountingQuery,
+  TOKENLESS_MODEL_KINDS,
 } from "@sixb/core/internal/ai-cost-storage-provider"
 import type { ListAiModelCallGroupsInput, ListAiModelCallGroupsResult } from "@sixb/core/storage"
 import type { SqliteStoreConnection } from "./transactions"
@@ -32,11 +33,15 @@ export async function listAiModelCallGroups(
   return { items, total, hasMore: query.offset + items.length < total }
 }
 
+// Fixed kind names, never user input.
+const TOKENLESS_KINDS = TOKENLESS_MODEL_KINDS.map((kind) => `'${kind}'`).join(", ")
+
 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,
+    usage.total_tokens, usage.model_kind, usage.output_images, usage.input_characters,
+    usage.audio_duration_ms,
     execution.executor_kind, execution.executor_id, execution.authority_primitive_id AS primitive_id,
     COALESCE(cost.status, 'unvalued') AS valuation_status,
     cost.currency AS amount_currency, cost.amount_nanos,
@@ -82,7 +87,12 @@ 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(COUNT(CASE WHEN total_tokens IS NULL AND model_kind IN (${TOKENLESS_KINDS}) THEN 1 END) AS TEXT)
+    AS tokenless_count,
   CAST(SUM(total_tokens) AS TEXT) AS total_tokens,
+  CAST(SUM(output_images) AS TEXT) AS output_images,
+  CAST(SUM(input_characters) AS TEXT) AS input_characters,
+  CAST(SUM(audio_duration_ms) AS TEXT) AS audio_duration_ms,
   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,

package/src/ai-cost-storage.ts

@@ -1,6 +1,7 @@
 import {
   type AiAccountingAggregateFragment,
   type AiAccountingRecordSetItem,
+  aiAccountingModelKind,
   aiModelCallCostDetails,
   aiModelCallCostMatchesUsage,
   buildAiAccountingOverviewFromFragments,
@@ -238,6 +239,7 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
   WITH classified AS (
     SELECT usage.provider_id,
       usage.requested_model_id,
+      usage.model_kind,
       usage.occurred_at,
       usage.input_tokens,
       usage.output_tokens,
@@ -247,6 +249,10 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
       usage.text_output_tokens,
       usage.reasoning_output_tokens,
       usage.audio_duration_ms,
+      usage.image_output_tokens,
+      usage.audio_output_tokens,
+      usage.output_images,
+      usage.input_characters,
       usage.reporting_status,
       CASE
         WHEN direct_agent.kind = 'conversation' THEN 'agent'
@@ -300,6 +306,8 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     UNION ALL
     SELECT 'model', provider_id, requested_model_id, NULL, NULL, classified.* FROM classified
     UNION ALL
+    SELECT 'kind', model_kind, NULL, NULL, NULL, classified.* FROM classified
+    UNION ALL
     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
@@ -332,7 +340,15 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     CAST(COUNT(reasoning_output_tokens) AS TEXT) AS reasoning_output_tokens_count,
     CAST(SUM(reasoning_output_tokens) AS TEXT) AS reasoning_output_tokens_sum,
     CAST(COUNT(audio_duration_ms) AS TEXT) AS audio_duration_ms_count,
+    CAST(COUNT(image_output_tokens) AS TEXT) AS image_output_tokens_count,
+    CAST(COUNT(audio_output_tokens) AS TEXT) AS audio_output_tokens_count,
+    CAST(COUNT(output_images) AS TEXT) AS output_images_count,
+    CAST(COUNT(input_characters) AS TEXT) AS input_characters_count,
     CAST(SUM(audio_duration_ms) AS TEXT) AS audio_duration_ms_sum,
+    CAST(SUM(image_output_tokens) AS TEXT) AS image_output_tokens_sum,
+    CAST(SUM(audio_output_tokens) AS TEXT) AS audio_output_tokens_sum,
+    CAST(SUM(output_images) AS TEXT) AS output_images_sum,
+    CAST(SUM(input_characters) AS TEXT) AS input_characters_sum,
     CAST(SUM(CASE WHEN valuation_status = 'rated' THEN 1 ELSE 0 END) AS TEXT)
       AS rated_call_count,
     CAST(SUM(CASE WHEN valuation_status = 'unpriceable' THEN 1 ELSE 0 END) AS TEXT)
@@ -398,6 +414,10 @@ interface UsageRow {
   readonly text_output_tokens: number | null
   readonly reasoning_output_tokens: number | null
   readonly audio_duration_ms: number | null
+  readonly image_output_tokens: number | null
+  readonly audio_output_tokens: number | null
+  readonly output_images: number | null
+  readonly input_characters: number | null
   readonly reporting_status: AiModelCallUsageRecord["usage"]["reportingStatus"]
   readonly raw_usage: string | null
   readonly provider_ids: string | null
@@ -453,7 +473,15 @@ interface AggregateRow {
   readonly reasoning_output_tokens_count: string
   readonly reasoning_output_tokens_sum: string | null
   readonly audio_duration_ms_count: string
+  readonly image_output_tokens_count: string
+  readonly audio_output_tokens_count: string
+  readonly output_images_count: string
+  readonly input_characters_count: string
   readonly audio_duration_ms_sum: string | null
+  readonly image_output_tokens_sum: string | null
+  readonly audio_output_tokens_sum: string | null
+  readonly output_images_sum: string | null
+  readonly input_characters_sum: string | null
   readonly rated_call_count: string
   readonly unpriceable_call_count: string
   readonly unvalued_call_count: string
@@ -477,18 +505,20 @@ function aggregateFragmentFromRow(row: AggregateRow): AiAccountingAggregateFragm
   const dimensionKeys =
     row.dimension === "model"
       ? { providerId: required(row.key_1), modelId: required(row.key_2) }
-      : row.dimension === "agent"
-        ? {
-            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"
-            ? { start: new Date(required(row.bucket_start)) }
-            : {}
+      : row.dimension === "kind"
+        ? withModelKind(aiAccountingModelKind(row.key_1))
+        : row.dimension === "agent"
+          ? {
+              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"
+              ? { start: new Date(required(row.bucket_start)) }
+              : {}
   return {
     dimension: row.dimension,
     ...dimensionKeys,
@@ -516,6 +546,10 @@ function aggregateFragmentFromRow(row: AggregateRow): AiAccountingAggregateFragm
         row.reasoning_output_tokens_sum
       ),
       audioDurationMs: meterFragment(row.audio_duration_ms_count, row.audio_duration_ms_sum),
+      imageOutputTokens: meterFragment(row.image_output_tokens_count, row.image_output_tokens_sum),
+      audioOutputTokens: meterFragment(row.audio_output_tokens_count, row.audio_output_tokens_sum),
+      outputImages: meterFragment(row.output_images_count, row.output_images_sum),
+      inputCharacters: meterFragment(row.input_characters_count, row.input_characters_sum),
     },
     costs: {
       ...(row.amount_currency === null ||
@@ -619,6 +653,10 @@ function usageFromRow(row: UsageRow, requesterGroupIds: readonly string[]): AiMo
         ? {}
         : { reasoningOutputTokens: row.reasoning_output_tokens }),
       ...(row.audio_duration_ms === null ? {} : { audioDurationMs: row.audio_duration_ms }),
+      ...(row.image_output_tokens === null ? {} : { imageOutputTokens: row.image_output_tokens }),
+      ...(row.audio_output_tokens === null ? {} : { audioOutputTokens: row.audio_output_tokens }),
+      ...(row.output_images === null ? {} : { outputImages: row.output_images }),
+      ...(row.input_characters === null ? {} : { inputCharacters: row.input_characters }),
       reportingStatus: row.reporting_status,
     },
     ...(row.raw_usage === null
@@ -807,3 +845,7 @@ function required<T>(value: T | null | undefined): T {
   }
   return value
 }
+
+function withModelKind(modelKind: AiAccountingAggregateFragment["modelKind"]) {
+  return modelKind === undefined ? {} : { modelKind }
+}