@sixb/sqlite 0.1.21 → 0.1.23

package/src/agents/messages.ts

@@ -1,4 +1,5 @@
 import type { Database } from "bun:sqlite"
+import { countsAsThreadMessage } from "@sixb/core/internal/agent-run-storage-provider"
 import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents"
 import {
   type AgentMessageRecord,
@@ -101,11 +102,17 @@ export class SqliteAgentMessageStore implements AgentMessageStore {
         .query(
           `
           UPDATE agent_threads
-          SET message_count = message_count + 1, last_message_at = ?, updated_at = ?
+          SET message_count = message_count + ?, last_message_at = ?, updated_at = ?
           WHERE project_id = ? AND id = ?
         `
         )
-        .run(createdAt.toISOString(), createdAt.toISOString(), input.projectId, input.threadId)
+        .run(
+          countsAsThreadMessage(input) ? 1 : 0,
+          createdAt.toISOString(),
+          createdAt.toISOString(),
+          input.projectId,
+          input.threadId
+        )
 
       return this.requireMessage(input.projectId, input.id)
     })()
@@ -125,11 +132,17 @@ export class SqliteAgentMessageStore implements AgentMessageStore {
       }
 
       const deleted = this.db
-        .query("DELETE FROM agent_messages WHERE project_id = ? AND thread_id = ? AND run_id = ?")
-        .run(input.projectId, input.threadId, input.runId)
-      if (deleted.changes === 0) {
+        .query(
+          "DELETE FROM agent_messages WHERE project_id = ? AND thread_id = ? AND run_id = ? RETURNING parts"
+        )
+        .all(input.projectId, input.threadId, input.runId) as { parts: string }[]
+      if (deleted.length === 0) {
         return 0
       }
+      // The thread counts only the messages the conversation shows: take back the ones it counted.
+      const counted = deleted.filter((row) =>
+        countsAsThreadMessage({ parts: JSON.parse(row.parts) })
+      ).length
 
       const updatedAt = new Date().toISOString()
       this.db
@@ -137,9 +150,7 @@ export class SqliteAgentMessageStore implements AgentMessageStore {
           `
           UPDATE agent_threads
           SET
-            message_count = (
-              SELECT COUNT(*) FROM agent_messages WHERE project_id = ? AND thread_id = ?
-            ),
+            message_count = MAX(message_count - ?, 0),
             last_message_at = (
               SELECT created_at FROM agent_messages
               WHERE project_id = ? AND thread_id = ?
@@ -150,17 +161,9 @@ export class SqliteAgentMessageStore implements AgentMessageStore {
           WHERE project_id = ? AND id = ?
         `
         )
-        .run(
-          input.projectId,
-          input.threadId,
-          input.projectId,
-          input.threadId,
-          updatedAt,
-          input.projectId,
-          input.threadId
-        )
+        .run(counted, input.projectId, input.threadId, updatedAt, input.projectId, input.threadId)
 
-      return deleted.changes
+      return deleted.length
     })()
   }
 

package/src/agents/rows.ts

@@ -8,6 +8,7 @@ import {
   type AgentMessageRecord,
   type AgentRunDiagnostic,
   type AgentRunRecord,
+  type AgentThreadParticipantRecord,
   type AgentThreadRecord,
   type AgentThreadSandboxState,
   type ConversationAgentRunSpec,
@@ -22,6 +23,10 @@ import type { SqliteValue } from "../run-list-query"
 export interface AgentThreadRow {
   project_id: string
   id: string
+  kind: AgentThreadRecord["kind"]
+  parent_thread_id: string | null
+  parent_run_id: string | null
+  spawn_key: string | null
   owner_principal_type: Principal["type"]
   owner_principal_id: string
   title: string | null
@@ -35,6 +40,16 @@ export interface AgentThreadRow {
   updated_at: string
 }
 
+export interface AgentThreadParticipantRow {
+  project_id: string
+  thread_id: string
+  principal_type: "user"
+  principal_id: string
+  added_at: string
+  added_by_type: Principal["type"]
+  added_by_id: string
+}
+
 export interface AgentRunRow {
   project_id: string
   id: string
@@ -98,6 +113,16 @@ export function rowToThreadRecord(row: AgentThreadRow): AgentThreadRecord {
   return {
     id: row.id,
     projectId: row.project_id,
+    kind: row.kind,
+    ...(row.parent_thread_id && row.parent_run_id && row.spawn_key
+      ? {
+          parent: {
+            threadId: row.parent_thread_id,
+            spawnedBy: row.parent_run_id,
+            key: row.spawn_key,
+          },
+        }
+      : {}),
     ownerPrincipal: { type: row.owner_principal_type, id: row.owner_principal_id },
     title: row.title ?? undefined,
     ...(row.sandbox_state == null
@@ -154,12 +179,20 @@ export function rowToRunRecord(row: AgentRunRow): AgentRunRecord {
       ...(row.spec === null ? {} : { spec: JSON.parse(row.spec) as ConversationAgentRunSpec }),
     }
   }
-  if (!row.parent_run_id || !row.spawn_key || row.spec === null) {
+  if (
+    !row.thread_id ||
+    !row.trigger_message_id ||
+    !row.parent_run_id ||
+    !row.spawn_key ||
+    row.spec === null
+  ) {
     throw new Error(`[SixbSqlite] Subagent run '${row.id}' has invalid persisted fields.`)
   }
   return {
     ...base,
     kind: "subagent",
+    threadId: row.thread_id,
+    triggerMessageId: row.trigger_message_id,
     parentRunId: row.parent_run_id,
     spawnKey: row.spawn_key,
     spec: JSON.parse(row.spec) as SubagentRunSpec,
@@ -212,6 +245,18 @@ export function rowToContextCheckpointRecord(
   }
 }
 
+export function rowToParticipantRecord(
+  row: AgentThreadParticipantRow
+): AgentThreadParticipantRecord {
+  return {
+    projectId: row.project_id,
+    threadId: row.thread_id,
+    principal: { type: "user", id: row.principal_id },
+    addedAt: new Date(row.added_at),
+    addedBy: { type: row.added_by_type, id: row.added_by_id },
+  }
+}
+
 function principalFromColumns(
   type: Principal["type"] | null | undefined,
   id: string | null | undefined

package/src/agents/runs.ts

@@ -1,11 +1,17 @@
 import type { Database } from "bun:sqlite"
 import {
+  agentRunMayHoldCalls,
   assertAgentRunExecution,
+  assertAgentRunFinishPayload,
+  assertAwaitingApprovalFinish,
   assertConversationAgentRunSpec,
+  assertConversationThreadRow,
   assertCreateSubagentRunInput,
-  assertSubagentRunResult,
+  assertSubagentThreadTakesRun,
+  newSubagentThreadRecord,
   subagentRunMatchesCreateInput,
 } from "@sixb/core/internal/agent-run-storage-provider"
+import { AGENT_MESSAGE_CONTENT_VERSION } from "@sixb/core/internal/agents"
 import { serializeSixbFailure } from "@sixb/core/internal/errors"
 import {
   AGENT_RUN_FAILURE_CODES,
@@ -21,6 +27,7 @@ import {
   type FinishQueuedAgentRunInput,
   type ListAgentRunsInput,
   type ListAgentRunsResult,
+  type ListThreadSubagentsInput,
   type ReclaimAgentRunInput,
   type StartAgentRunInput,
   type SubagentRunRecord,
@@ -32,7 +39,8 @@ import {
   type SqliteValue,
 } from "../run-list-query"
 import { isUniqueConstraintError } from "../storage-errors"
-import { type AgentRunRow, rowToRunRecord } from "./rows"
+import { sqliteHoldsRun } from "./approvals"
+import { type AgentRunRow, type AgentThreadRow, rowToRunRecord, rowToThreadRecord } from "./rows"
 
 const SQLITE_RUN_ID_BATCH_SIZE = 500
 
@@ -54,8 +62,11 @@ export class SqliteAgentRunStore implements AgentRunStore {
 
     return this.db.transaction(() => {
       const thread = this.db
-        .query("SELECT active_run_id FROM agent_threads WHERE project_id = ? AND id = ?")
-        .get(input.projectId, input.threadId) as { active_run_id: string | null } | null
+        .query("SELECT id, kind, active_run_id FROM agent_threads WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.threadId) as Pick<
+        AgentThreadRow,
+        "id" | "kind" | "active_run_id"
+      > | null
 
       if (!thread) {
         throw new AgentStorageError(
@@ -63,6 +74,7 @@ export class SqliteAgentRunStore implements AgentRunStore {
           `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
         )
       }
+      assertConversationThreadRow(thread, "takes turns", "SixbSqlite")
       if (thread.active_run_id !== null) {
         throw new AgentStorageError(
           "active_run_exists",
@@ -188,24 +200,54 @@ export class SqliteAgentRunStore implements AgentRunStore {
         )
       }
 
+      const createdAt = input.createdAt ?? new Date()
       try {
+        this.claimChildThread(input, parentRow, createdAt)
         this.db
           .query(
             `
             INSERT INTO agent_runs (
-              project_id, id, execution_id, kind, parent_run_id, spawn_key, spec,
-              status, attempt, created_at
-            ) VALUES (?, ?, ?, 'subagent', ?, ?, ?, 'queued', 0, ?)
+              project_id, id, execution_id, kind, thread_id, trigger_message_id, parent_run_id,
+              spawn_key, spec, status, attempt, created_at
+            ) VALUES (?, ?, ?, 'subagent', ?, ?, ?, ?, ?, 'queued', 0, ?)
           `
           )
           .run(
             input.projectId,
             input.id,
             input.executionId,
+            input.thread.id,
+            input.trigger.id,
             input.parentRunId,
             input.spawnKey,
             JSON.stringify(input.spec),
-            (input.createdAt ?? new Date()).toISOString()
+            createdAt.toISOString()
+          )
+        this.db
+          .query(
+            `
+            INSERT INTO agent_messages (
+              project_id, id, thread_id, run_id, role, seq, parts, metadata, content_version,
+              created_at
+            ) VALUES (
+              ?, ?, ?, ?, 'user',
+              (SELECT COALESCE(MAX(seq), 0) + 1 FROM agent_messages
+                WHERE project_id = ? AND thread_id = ?),
+              ?, ?, ?, ?
+            )
+          `
+          )
+          .run(
+            input.projectId,
+            input.trigger.id,
+            input.thread.id,
+            input.id,
+            input.projectId,
+            input.thread.id,
+            JSON.stringify(input.trigger.parts),
+            input.trigger.metadata === undefined ? null : JSON.stringify(input.trigger.metadata),
+            AGENT_MESSAGE_CONTENT_VERSION,
+            createdAt.toISOString()
           )
       } catch (error) {
         if (isUniqueConstraintError(error)) {
@@ -347,18 +389,14 @@ 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.`
-        )
+      assertAgentRunFinishPayload(run.kind, input, run.id, "SixbSqlite")
+      if (input.finishReason === "awaiting_approval") {
+        assertAwaitingApprovalFinish({
+          runId: input.id,
+          status: input.status,
+          holdsApproval: sqliteHoldsRun(this.db, input.projectId, input.id),
+          prefix: "SixbSqlite",
+        })
       }
 
       this.db
@@ -393,11 +431,43 @@ export class SqliteAgentRunStore implements AgentRunStore {
         )
 
       this.releaseThread(run, completedAt)
+      if (agentRunMayHoldCalls(rowToRunRecord(run)))
+        this.settleApprovals(run.kind, input, completedAt)
 
       return this.requireRun(input.projectId, input.id)
     })()
   }
 
+  /**
+   * A turn that pauses keeps its calls for their decision. A turn that ends any other way cancels
+   * the ones still waiting, a late one included, and never resumes on the rest. A child that fails
+   * or is cancelled takes its own pending calls with it.
+   */
+  private settleApprovals(
+    kind: AgentRunRecord["kind"],
+    input: FinishAgentRunInput,
+    completedAt: Date
+  ): void {
+    if (input.finishReason === "awaiting_approval") return
+    const turn = kind === "conversation"
+    if (!turn && input.status === "succeeded") return
+
+    this.db
+      .query(
+        `UPDATE agent_approvals SET status = 'cancelled'
+         WHERE project_id = ? AND status = 'pending' AND (run_id = ? OR caller_run_id = ?)`
+      )
+      .run(input.projectId, input.id, input.id)
+    if (!turn) return
+    this.db
+      .query(
+        `UPDATE agent_approvals SET turn_stopped_at = ?
+         WHERE project_id = ? AND run_id = ?
+           AND reported_in_message_id IS NULL AND turn_stopped_at IS NULL`
+      )
+      .run(completedAt.toISOString(), input.projectId, input.id)
+  }
+
   async getById(params: { projectId: string; id: string }): Promise<AgentRunRecord | null> {
     const row = this.db
       .query("SELECT * FROM agent_runs WHERE project_id = ? AND id = ?")
@@ -432,6 +502,41 @@ export class SqliteAgentRunStore implements AgentRunStore {
     })
   }
 
+  async listThreadSubagents(
+    input: ListThreadSubagentsInput
+  ): Promise<readonly SubagentRunRecord[]> {
+    // Reached through the turns of the conversation, by thread, then each turn's children by key
+    // or, for a finish reason, by `idx_agent_runs_paused_on_question`.
+    const filters: string[] = []
+    const args: SqliteValue[] = [input.projectId, input.threadId]
+    if (input.spawnKey !== undefined) {
+      filters.push("AND child.spawn_key = ?")
+      args.push(input.spawnKey)
+    }
+    if (input.finishReason !== undefined) {
+      filters.push("AND child.finish_reason = ?")
+      args.push(input.finishReason)
+    }
+    args.push(input.limit ?? 100)
+
+    const rows = this.db
+      .query(
+        `SELECT child.* FROM agent_runs turn
+         JOIN agent_runs child
+           ON child.project_id = turn.project_id AND child.parent_run_id = turn.id
+         WHERE turn.project_id = ? AND turn.thread_id = ? AND child.kind = 'subagent'
+           ${filters.join(" ")}
+         ORDER BY COALESCE(turn.started_at, turn.created_at) DESC, turn.id DESC,
+           child.created_at DESC, child.id DESC
+         LIMIT ?`
+      )
+      .all(...args) as AgentRunRow[]
+    return rows.flatMap((row) => {
+      const run = rowToRunRecord(row)
+      return run.kind === "subagent" ? [run] : []
+    })
+  }
+
   async list(input: ListAgentRunsInput): Promise<ListAgentRunsResult> {
     if (hasEmptyStatuses(input) || input.kinds?.length === 0) {
       return { runs: [], hasMore: false, total: 0 }
@@ -500,8 +605,84 @@ export class SqliteAgentRunStore implements AgentRunStore {
     return row
   }
 
+  /**
+   * The child's thread: its first run creates it, owned by the conversation's owner; a later run
+   * takes it while it is idle. Either way the run is its active run.
+   */
+  private claimChildThread(
+    input: CreateSubagentRunInput,
+    parent: AgentRunRow,
+    createdAt: Date
+  ): void {
+    if (!input.thread.create) {
+      const row = this.db
+        .query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?")
+        .get(input.projectId, input.thread.id) as AgentThreadRow | null
+      assertSubagentThreadTakesRun(
+        row ? rowToThreadRecord(row) : null,
+        input,
+        parent.thread_id ?? "",
+        "SixbSqlite"
+      )
+      this.db
+        .query(
+          `
+          UPDATE agent_threads
+          SET active_run_id = ?, message_count = message_count + 1, last_message_at = ?,
+            updated_at = ?
+          WHERE project_id = ? AND id = ?
+        `
+        )
+        .run(
+          input.id,
+          createdAt.toISOString(),
+          createdAt.toISOString(),
+          input.projectId,
+          input.thread.id
+        )
+      return
+    }
+
+    const conversation = this.db
+      .query("SELECT * FROM agent_threads WHERE project_id = ? AND id = ?")
+      .get(input.projectId, parent.thread_id) as AgentThreadRow | null
+    if (!conversation) {
+      throw new AgentStorageError(
+        "thread_not_found",
+        `[SixbSqlite] Agent thread '${parent.thread_id}' not found for project '${input.projectId}'.`
+      )
+    }
+
+    const thread = newSubagentThreadRecord(input, rowToThreadRecord(conversation), createdAt)
+    this.db
+      .query(
+        `
+        INSERT INTO agent_threads (
+          project_id, id, kind, parent_thread_id, parent_run_id, spawn_key, owner_principal_type,
+          owner_principal_id, status, active_run_id, last_message_at, message_count, created_at,
+          updated_at
+        ) VALUES (?, ?, 'subagent', ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `
+      )
+      .run(
+        thread.projectId,
+        thread.id,
+        conversation.id,
+        input.parentRunId,
+        input.spawnKey,
+        thread.ownerPrincipal.type,
+        thread.ownerPrincipal.id,
+        thread.status,
+        input.id,
+        createdAt.toISOString(),
+        thread.messageCount,
+        createdAt.toISOString(),
+        createdAt.toISOString()
+      )
+  }
+
+  /** A turn releases its conversation, a child run its own thread. */
   private releaseThread(run: AgentRunRow, completedAt: Date): void {
-    if (run.kind !== "conversation") return
     this.db
       .query(
         `

package/src/agents/settings.ts

@@ -0,0 +1,112 @@
+import type { Database } from "bun:sqlite"
+import { assertAgentApprovalModeInput } from "@sixb/core/internal/agent-run-storage-provider"
+import {
+  type AgentApprovalMode,
+  type AgentApprovalModeStore,
+  AgentStorageError,
+  type Principal,
+} from "@sixb/core/storage"
+
+export class SqliteAgentApprovalModeStore implements AgentApprovalModeStore {
+  constructor(private readonly db: Database) {}
+
+  async getDefault(input: {
+    readonly projectId: string
+    readonly principal: Principal
+  }): Promise<AgentApprovalMode | null> {
+    const row = this.db
+      .query(
+        `SELECT approval_mode FROM agent_user_settings
+         WHERE project_id = ? AND principal_type = ? AND principal_id = ?`
+      )
+      .get(input.projectId, input.principal.type, input.principal.id) as {
+      approval_mode: AgentApprovalMode
+    } | null
+    return row?.approval_mode ?? null
+  }
+
+  async setDefault(input: {
+    readonly projectId: string
+    readonly principal: Principal
+    readonly mode: AgentApprovalMode
+    readonly updatedAt?: Date
+  }): Promise<void> {
+    assertAgentApprovalModeInput(input.mode, "SixbSqlite")
+    this.db
+      .query(
+        `INSERT INTO agent_user_settings (
+           project_id, principal_type, principal_id, approval_mode, updated_at
+         ) VALUES (?, ?, ?, ?, ?)
+         ON CONFLICT (project_id, principal_type, principal_id)
+         DO UPDATE SET approval_mode = excluded.approval_mode, updated_at = excluded.updated_at`
+      )
+      .run(
+        input.projectId,
+        input.principal.type,
+        input.principal.id,
+        input.mode,
+        (input.updatedAt ?? new Date()).toISOString()
+      )
+  }
+
+  async getForThread(input: {
+    readonly projectId: string
+    readonly threadId: string
+    readonly principal: Principal
+  }): Promise<AgentApprovalMode | null> {
+    const row = this.db
+      .query(
+        `SELECT approval_mode FROM agent_thread_user_settings
+         WHERE project_id = ? AND thread_id = ? AND principal_type = ? AND principal_id = ?`
+      )
+      .get(input.projectId, input.threadId, input.principal.type, input.principal.id) as {
+      approval_mode: AgentApprovalMode
+    } | null
+    return row?.approval_mode ?? null
+  }
+
+  async setForThread(input: {
+    readonly projectId: string
+    readonly threadId: string
+    readonly principal: Principal
+    readonly mode: AgentApprovalMode | null
+    readonly updatedAt?: Date
+  }): Promise<void> {
+    if (input.mode !== null) assertAgentApprovalModeInput(input.mode, "SixbSqlite")
+    const thread = this.db
+      .query("SELECT id FROM agent_threads WHERE project_id = ? AND id = ?")
+      .get(input.projectId, input.threadId)
+    if (!thread) {
+      throw new AgentStorageError(
+        "thread_not_found",
+        `[SixbSqlite] Agent thread '${input.threadId}' not found for project '${input.projectId}'.`
+      )
+    }
+
+    if (input.mode === null) {
+      this.db
+        .query(
+          `DELETE FROM agent_thread_user_settings
+           WHERE project_id = ? AND thread_id = ? AND principal_type = ? AND principal_id = ?`
+        )
+        .run(input.projectId, input.threadId, input.principal.type, input.principal.id)
+      return
+    }
+    this.db
+      .query(
+        `INSERT INTO agent_thread_user_settings (
+           project_id, thread_id, principal_type, principal_id, approval_mode, updated_at
+         ) VALUES (?, ?, ?, ?, ?, ?)
+         ON CONFLICT (project_id, thread_id, principal_type, principal_id)
+         DO UPDATE SET approval_mode = excluded.approval_mode, updated_at = excluded.updated_at`
+      )
+      .run(
+        input.projectId,
+        input.threadId,
+        input.principal.type,
+        input.principal.id,
+        input.mode,
+        (input.updatedAt ?? new Date()).toISOString()
+      )
+  }
+}