@sixb/sqlite 0.1.25 → 0.2.0

package/src/agents/token-rates.ts

@@ -0,0 +1,90 @@
+import type { Database } from "bun:sqlite"
+import {
+  AGENT_TOKEN_RATE_SAMPLES,
+  assertAgentTokenRateRecord,
+} from "@sixb/core/internal/agent-run-storage-provider"
+import type { AgentTokenRateRecord, AgentTokenRateStore } from "@sixb/core/storage"
+import { runImmediateTransaction } from "../transactions"
+
+interface TokenRateRow {
+  readonly project_id: string
+  readonly run_id: string
+  readonly provider_id: string
+  readonly model_id: string
+  readonly bytes: number
+  readonly tokens: number
+  readonly measured_at: string
+}
+
+export class SqliteAgentTokenRateStore implements AgentTokenRateStore {
+  constructor(private readonly db: Database) {}
+
+  async record(input: AgentTokenRateRecord): Promise<void> {
+    assertAgentTokenRateRecord(input, "SixbSqlite")
+
+    runImmediateTransaction(this.db, () => {
+      this.db
+        .query(
+          `INSERT INTO agent_token_rates (
+             project_id, run_id, provider_id, model_id, bytes, tokens, measured_at
+           ) VALUES (?, ?, ?, ?, ?, ?, ?)
+           ON CONFLICT (project_id, run_id) DO UPDATE SET
+             provider_id = excluded.provider_id, model_id = excluded.model_id,
+             bytes = excluded.bytes, tokens = excluded.tokens, measured_at = excluded.measured_at`
+        )
+        .run(
+          input.projectId,
+          input.runId,
+          input.providerId,
+          input.modelId,
+          input.bytes,
+          input.tokens,
+          input.measuredAt.toISOString()
+        )
+
+      this.db
+        .query(
+          `DELETE FROM agent_token_rates
+           WHERE project_id = ?1 AND provider_id = ?2 AND model_id = ?3
+             AND run_id NOT IN (
+               SELECT run_id FROM agent_token_rates
+               WHERE project_id = ?1 AND provider_id = ?2 AND model_id = ?3
+               ORDER BY measured_at DESC, run_id DESC
+               LIMIT ?4
+             )`
+        )
+        .run(input.projectId, input.providerId, input.modelId, AGENT_TOKEN_RATE_SAMPLES)
+    })
+  }
+
+  async listLatest(input: {
+    readonly projectId: string
+    readonly providerId: string
+    readonly modelId: string
+  }): Promise<readonly AgentTokenRateRecord[]> {
+    const rows = this.db
+      .query(
+        `SELECT project_id, run_id, provider_id, model_id, bytes, tokens, measured_at
+         FROM agent_token_rates
+         WHERE project_id = ? AND provider_id = ? AND model_id = ?
+         ORDER BY measured_at DESC, run_id DESC
+         LIMIT ?`
+      )
+      .all(
+        input.projectId,
+        input.providerId,
+        input.modelId,
+        AGENT_TOKEN_RATE_SAMPLES
+      ) as TokenRateRow[]
+
+    return rows.map((row) => ({
+      projectId: row.project_id,
+      providerId: row.provider_id,
+      modelId: row.model_id,
+      runId: row.run_id,
+      bytes: row.bytes,
+      tokens: row.tokens,
+      measuredAt: new Date(row.measured_at),
+    }))
+  }
+}

package/src/ai-accounting-filters.ts

@@ -0,0 +1,51 @@
+import type { normalizeAiAccountingQuery } from "@sixb/core/internal/ai-cost-storage-provider"
+
+// The kind, source and requester filters every accounting read shares, over the joins it makes:
+// `execution`, `direct_agent`, `workflow_node`.
+
+/** Where a call came from, as `aiAccountingSource` reads its attribution. */
+export const SQLITE_SOURCE_WORKFLOW = `COALESCE(
+  workflow_node.workflow_id,
+  CASE WHEN execution.executor_kind = 'workflow' THEN execution.authority_primitive_id END
+)`
+export const SQLITE_SOURCE_KIND = `CASE
+  WHEN direct_agent.id IS NOT NULL THEN 'agent'
+  WHEN ${SQLITE_SOURCE_WORKFLOW} IS NOT NULL THEN 'workflow'
+  WHEN execution.executor_kind = 'action' THEN 'action'
+  ELSE 'other'
+END`
+
+/** The kind, source and requester filters over the columns that hold them; 12 positional params. */
+export function sqliteAccountingFilter(columns: {
+  readonly kind: string
+  readonly sourceKind: string
+  readonly sourceWorkflow: string
+  readonly userId: string
+  readonly serviceAccountId: string
+}): string {
+  return `(? IS NULL OR ${columns.kind} = ?)
+    AND (? IS NULL OR ${columns.sourceKind} = ?)
+    AND (? IS NULL OR ${columns.sourceWorkflow} = ?)
+    AND (
+      ? IS NULL
+      OR (? = 'none' AND ${columns.userId} IS NULL AND ${columns.serviceAccountId} IS NULL)
+      OR (? = 'user' AND ${columns.userId} = ?)
+      OR (? = 'serviceAccount' AND ${columns.serviceAccountId} = ?)
+    )`
+}
+
+export function sqliteAccountingFilterParameters(
+  query: ReturnType<typeof normalizeAiAccountingQuery>
+): readonly (string | null)[] {
+  const kind = query.modelKind ?? null
+  const source = query.source?.kind ?? null
+  const workflow = query.source?.kind === "workflow" ? (query.source.workflowId ?? null) : null
+  const mode =
+    query.requester === undefined
+      ? null
+      : query.requester === "none"
+        ? "none"
+        : query.requester.type
+  const id = query.requester === undefined || query.requester === "none" ? null : query.requester.id
+  return [kind, kind, source, source, workflow, workflow, mode, mode, mode, id, mode, id]
+}

package/src/ai-cost-groups.ts

@@ -3,17 +3,31 @@ import {
   aiModelCallGroupFragmentFromRow,
   buildAiModelCallGroupsFromFragments,
   normalizeAiModelCallAccountingQuery,
+  normalizeAiModelCallGroupSort,
   TOKENLESS_MODEL_KINDS,
 } from "@sixb/core/internal/ai-cost-storage-provider"
 import type { ListAiModelCallGroupsInput, ListAiModelCallGroupsResult } from "@sixb/core/storage"
+import {
+  SQLITE_SOURCE_KIND,
+  SQLITE_SOURCE_WORKFLOW,
+  sqliteAccountingFilter,
+  sqliteAccountingFilterParameters,
+} from "./ai-accounting-filters"
 import type { SqliteStoreConnection } from "./transactions"
 
-/** Paginate initiating executions, then aggregate their matching calls without loading usage payloads. */
+/** Positional `?` placeholders numbered from `start`, to sit among this file's numbered ones. */
+function numbered(sql: string, start: number): string {
+  let next = start
+  return sql.replace(/\?(?!\d)/g, () => `?${next++}`)
+}
+
+/** Paginate conversations, workflow runs and other 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 sort = normalizeAiModelCallGroupSort(input.sort)
   const parameters = [
     query.projectId,
     query.from.toISOString(),
@@ -22,14 +36,15 @@ export async function listAiModelCallGroups(
     query.modelId ?? null,
     query.valuationStatus ?? null,
   ]
-  const count = connection.db.query(COUNT_SQL).get(...parameters) as { total: string }
+  const filters = sqliteAccountingFilterParameters(query)
+  const count = connection.db.query(COUNT_SQL).get(...parameters, ...filters) as { total: string }
   const rows = connection.db
     .query(PAGE_SQL)
-    .all(...parameters, query.limit, query.offset) as AiModelCallGroupRow[]
+    .all(...parameters, ...filters, query.limit, query.offset, sort) 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))
+  const items = buildAiModelCallGroupsFromFragments(rows.map(aiModelCallGroupFragmentFromRow), sort)
   return { items, total, hasMore: query.offset + items.length < total }
 }
 
@@ -39,8 +54,15 @@ 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,
+    -- What the call is listed under, as aiModelCallGroupKey computes it.
+    CASE
+      WHEN root_agent.thread_id IS NOT NULL THEN 'thread:' || root_agent.thread_id
+      WHEN workflow_node.workflow_run_id IS NOT NULL THEN 'workflowRun:' || workflow_node.workflow_run_id
+      ELSE COALESCE(root_agent.execution_id, usage.execution_id)
+    END AS group_key,
     usage.execution_id, usage.provider_id, usage.requested_model_id, usage.occurred_at,
-    usage.total_tokens, usage.model_kind, usage.output_images, usage.input_characters,
+    usage.total_tokens, usage.input_tokens, usage.cache_read_input_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,
@@ -53,7 +75,8 @@ WITH filtered AS (
     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
+    workflow_node.workflow_run_id AS workflow_run_id,
+    execution.requested_by_user_id, execution.requested_by_service_account_id
   FROM ai_model_call_usage AS usage
   JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
   LEFT JOIN agent_runs AS direct_agent
@@ -73,23 +96,36 @@ WITH filtered AS (
     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)
+    AND ${numbered(
+      sqliteAccountingFilter({
+        kind: "usage.model_kind",
+        sourceKind: SQLITE_SOURCE_KIND,
+        sourceWorkflow: SQLITE_SOURCE_WORKFLOW,
+        userId: "execution.requested_by_user_id",
+        serviceAccountId: "execution.requested_by_service_account_id",
+      }),
+      7
+    )}
 ), roots AS (
-  SELECT root_execution_id, MAX(occurred_at) AS last_call_at
-  FROM filtered GROUP BY root_execution_id
+  SELECT group_key, MAX(occurred_at) AS last_call_at, TOTAL(amount_nanos) AS cost_nanos
+  FROM filtered GROUP BY group_key
 )
 `
 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 group_key FROM roots
+  ORDER BY CASE WHEN ?21 = 'cost' THEN cost_nanos END DESC, last_call_at DESC, group_key ASC
+  LIMIT ?19 OFFSET ?20
 )
-SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_id,
+SELECT filtered.group_key, 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(input_tokens) AS TEXT) AS input_tokens,
+  CAST(SUM(cache_read_input_tokens) AS TEXT) AS cache_read_input_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,
@@ -106,8 +142,10 @@ SELECT filtered.root_execution_id, execution_id, provider_id, requested_model_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,
+  MAX(workflow_run_id) AS workflow_run_id,
+  MAX(requested_by_user_id) AS requested_by_user_id,
+  MAX(requested_by_service_account_id) AS requested_by_service_account_id
+FROM filtered JOIN page ON page.group_key = filtered.group_key
+GROUP BY filtered.group_key, root_execution_id, execution_id, provider_id, requested_model_id,
   valuation_status, amount_currency
 `

package/src/ai-cost-storage.ts

@@ -28,6 +28,12 @@ import {
   type QueryAiAccountingOverviewInput,
   type SummarizeAiCostExecutionsInput,
 } from "@sixb/core/storage"
+import {
+  SQLITE_SOURCE_KIND,
+  SQLITE_SOURCE_WORKFLOW,
+  sqliteAccountingFilter,
+  sqliteAccountingFilterParameters,
+} from "./ai-accounting-filters"
 import { listAiModelCallGroups } from "./ai-cost-groups"
 import { requestedReasoningFromRow } from "./ai-usage-storage"
 import { isUniqueConstraintError } from "./storage-errors"
@@ -96,6 +102,8 @@ export class SqliteAiCostStorage implements AiCostStorage {
         query.providerId ?? null,
         query.modelId ?? null,
         query.modelId ?? null,
+        ...sqliteAccountingFilterParameters(query),
+        input.bucket,
         input.bucket
       ) as AggregateRow[]
     return buildAiAccountingOverviewFromFragments(input, rows.map(aggregateFragmentFromRow))
@@ -176,13 +184,34 @@ const SQLITE_ACCOUNTING_LIST_FILTER = `
       ELSE 'unvalued'
     END
   )
+  AND ${sqliteAccountingFilter({
+    kind: "usage.model_kind",
+    sourceKind: SQLITE_SOURCE_KIND,
+    sourceWorkflow: SQLITE_SOURCE_WORKFLOW,
+    userId: "execution.requested_by_user_id",
+    serviceAccountId: "execution.requested_by_service_account_id",
+  })}
+`
+
+const SQLITE_ACCOUNTING_LIST_JOINS = `
+  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
+  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
 `
 
 const SQLITE_ACCOUNTING_LIST_COUNT_SQL = `
   SELECT CAST(COUNT(*) AS 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
+  ${SQLITE_ACCOUNTING_LIST_JOINS}
   WHERE ${SQLITE_ACCOUNTING_LIST_FILTER}
 `
 
@@ -218,18 +247,7 @@ const SQLITE_ACCOUNTING_LIST_PAGE_SQL = `
     cost.details AS cost_details,
     cost.rated_at AS cost_rated_at
   FROM ai_model_call_usage AS usage
-  JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
-  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
+  ${SQLITE_ACCOUNTING_LIST_JOINS}
   WHERE ${SQLITE_ACCOUNTING_LIST_FILTER}
   ORDER BY usage.occurred_at DESC, usage.id ASC
   LIMIT ? OFFSET ?
@@ -269,7 +287,10 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
         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
+      CASE WHEN cost.status = 'rated' THEN cost.amount_nanos ELSE NULL END AS amount_nanos,
+      execution.requested_by_user_id AS requester_user_id,
+      execution.requested_by_service_account_id AS requester_service_account_id,
+      ${SQLITE_SOURCE_KIND} AS source_kind
     FROM ai_model_call_usage AS usage
     JOIN executions AS execution ON execution.project_id = usage.project_id AND execution.id = usage.execution_id
     LEFT JOIN agent_runs AS direct_agent
@@ -286,10 +307,19 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
     WHERE usage.project_id = ? AND usage.occurred_at >= ? AND usage.occurred_at < ?
       AND (? IS NULL OR usage.provider_id = ?)
       AND (? IS NULL OR usage.requested_model_id = ?)
+  ), filtered AS (
+    SELECT * FROM classified
+    WHERE ${sqliteAccountingFilter({
+      kind: "model_kind",
+      sourceKind: "source_kind",
+      sourceWorkflow: "attribution_workflow_id",
+      userId: "requester_user_id",
+      serviceAccountId: "requester_service_account_id",
+    })}
   ), expanded AS (
     SELECT 'totals' AS dimension, NULL AS key_1, NULL AS key_2, NULL AS key_3, NULL AS bucket_start,
-      classified.*
-    FROM classified
+      filtered.*
+    FROM filtered
     UNION ALL
     SELECT 'series', NULL, NULL, NULL,
       CASE ?
@@ -301,18 +331,39 @@ const SQLITE_ACCOUNTING_OVERVIEW_SQL = `
           printf('-%d days', (CAST(strftime('%w', occurred_at) AS INTEGER) + 6) % 7)
         )
       END,
-      classified.*
-    FROM classified
+      filtered.*
+    FROM filtered
     UNION ALL
-    SELECT 'model', provider_id, requested_model_id, NULL, NULL, classified.* FROM classified
+    SELECT 'modelSeries', provider_id, requested_model_id, 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)
+        ELSE strftime(
+          '%Y-%m-%dT00:00:00.000Z',
+          occurred_at,
+          printf('-%d days', (CAST(strftime('%w', occurred_at) AS INTEGER) + 6) % 7)
+        )
+      END,
+      filtered.*
+    FROM filtered
     UNION ALL
-    SELECT 'kind', model_kind, NULL, NULL, NULL, classified.* FROM classified
+    SELECT 'model', provider_id, requested_model_id, NULL, NULL, filtered.* FROM filtered
+    UNION ALL
+    SELECT 'person',
+      CASE
+        WHEN requester_user_id IS NOT NULL THEN 'user'
+        WHEN requester_service_account_id IS NOT NULL THEN 'serviceAccount'
+      END,
+      COALESCE(requester_user_id, requester_service_account_id), NULL, NULL, filtered.*
+    FROM filtered
     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
+    SELECT 'kind', model_kind, NULL, NULL, NULL, filtered.* FROM filtered
     UNION ALL
-    SELECT 'workflow', attribution_workflow_id, NULL, NULL, NULL, classified.*
-    FROM classified WHERE attribution_workflow_id IS NOT NULL
+    SELECT 'agent', attribution_agent_kind, attribution_workflow_id, attribution_agent_step_id, NULL, filtered.*
+    FROM filtered WHERE attribution_agent_kind IS NOT NULL
+    UNION ALL
+    SELECT 'workflow', attribution_workflow_id, NULL, NULL, NULL, filtered.*
+    FROM filtered WHERE attribution_workflow_id IS NOT NULL
   )
   SELECT dimension,
     key_1,
@@ -377,6 +428,7 @@ function accountingListFilterParameters(
     query.executionId ?? null,
     query.valuationStatus ?? null,
     query.valuationStatus ?? null,
+    ...sqliteAccountingFilterParameters(query),
   ]
 }
 
@@ -505,20 +557,30 @@ function aggregateFragmentFromRow(row: AggregateRow): AiAccountingAggregateFragm
   const dimensionKeys =
     row.dimension === "model"
       ? { providerId: required(row.key_1), modelId: required(row.key_2) }
-      : 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)) }
-              : {}
+      : row.dimension === "modelSeries"
+        ? {
+            providerId: required(row.key_1),
+            modelId: required(row.key_2),
+            start: new Date(required(row.bucket_start)),
+          }
+        : row.dimension === "person"
+          ? row.key_1 && row.key_2
+            ? { requesterType: row.key_1 as "user" | "serviceAccount", requesterId: row.key_2 }
+            : {}
+          : 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,

package/src/migrations/080-agent-run-cancel-requests.sql

@@ -0,0 +1,3 @@
+-- A cancel is recorded on the run, not only broadcast: a runner that never hears the broker learns
+-- of it at its next lease renewal, and the run token stops working at once.
+ALTER TABLE agent_runs ADD COLUMN cancel_requested_at TEXT;

package/src/migrations/081-agent-thread-runs-on.sql

@@ -0,0 +1,4 @@
+-- Where a conversation's turns run: NULL in the cloud, 'computer' on its owner's computer.
+ALTER TABLE agent_threads ADD COLUMN runs_on TEXT CHECK (runs_on IS NULL OR runs_on = 'computer');
+-- Which of its owner's computers runs a computer's thread: NULL until one claims its first turn.
+ALTER TABLE agent_threads ADD COLUMN computer_id TEXT;

package/src/migrations/082-agent-token-rates.sql

@@ -0,0 +1,17 @@
+-- What each model's tokenizer measured on a project's agent runs, one row per run: the bytes of a
+-- request's text as the Agent's context estimator weighs them, against the text tokens the
+-- provider counted. A record deletes the model's rows past its newest 20, so the table stays small.
+-- Timestamps are ISO-8601 UTC text and compare lexicographically.
+CREATE TABLE agent_token_rates (
+  project_id TEXT NOT NULL CHECK (length(trim(project_id)) > 0),
+  run_id TEXT NOT NULL CHECK (length(trim(run_id)) > 0),
+  provider_id TEXT NOT NULL CHECK (length(trim(provider_id)) > 0),
+  model_id TEXT NOT NULL CHECK (length(trim(model_id)) > 0),
+  bytes INTEGER NOT NULL CHECK (bytes > 0),
+  tokens INTEGER NOT NULL CHECK (tokens > 0),
+  measured_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, run_id)
+);
+
+CREATE INDEX idx_agent_token_rates_model
+  ON agent_token_rates (project_id, provider_id, model_id, measured_at DESC, run_id DESC);

package/src/migrations/083-agent-computer-sessions.sql

@@ -0,0 +1,27 @@
+-- Where a computer's thread runs: the computer's name and the folder there, beside its id. A
+-- computer kept before folders were has none until its owner moves the thread.
+ALTER TABLE agent_threads ADD COLUMN computer_name TEXT;
+ALTER TABLE agent_threads ADD COLUMN computer_folder TEXT;
+UPDATE agent_threads SET computer_id = NULL WHERE computer_id IS NOT NULL;
+-- When its turns last moved to where they run now: the files earlier turns used are not there.
+ALTER TABLE agent_threads ADD COLUMN moved_at TEXT;
+
+-- Each open sixb on its owner's computers, a lease it renews: while one is live, the threads that
+-- run on its computer in its folder are reachable there.
+CREATE TABLE agent_computer_sessions (
+  project_id TEXT NOT NULL,
+  owner_principal_type TEXT NOT NULL CHECK (owner_principal_type IN ('user', 'serviceAccount', 'system')),
+  owner_principal_id TEXT NOT NULL CHECK (length(owner_principal_id) > 0),
+  id TEXT NOT NULL CHECK (length(id) > 0),
+  computer_id TEXT NOT NULL,
+  computer_name TEXT NOT NULL,
+  folder TEXT NOT NULL,
+  expires_at TEXT NOT NULL,
+  PRIMARY KEY (project_id, owner_principal_type, owner_principal_id, id)
+);
+CREATE INDEX agent_computer_sessions_by_expiry ON agent_computer_sessions (project_id, expires_at);
+
+-- Each open sixb asks every 20 seconds which of its owner's threads here have a turn active.
+CREATE INDEX agent_threads_active_on_computer
+  ON agent_threads (project_id, owner_principal_type, owner_principal_id, computer_id, computer_folder)
+  WHERE active_run_id IS NOT NULL;

package/src/migrations.ts

@@ -311,6 +311,10 @@ export const sqliteStorageMigrations = defineMigrations({
       { checksum: checksum(subagentThreadsSql) }
     ),
     sqliteSql("079-subagent-questions", subagentQuestionsSql),
+    sqliteSql("080-agent-run-cancel-requests", agentRunCancelRequestsSql),
+    sqliteSql("081-agent-thread-runs-on", agentThreadRunsOnSql),
+    sqliteSql("082-agent-token-rates", agentTokenRatesSql),
+    sqliteSql("083-agent-computer-sessions", agentComputerSessionsSql),
   ],
 })
 
@@ -709,3 +713,11 @@ import agentApprovalResumeSql from "./migrations/077-agent-approval-resume.sql"
 }
 import subagentThreadsSql from "./migrations/078-subagent-threads.sql" with { type: "text" }
 import subagentQuestionsSql from "./migrations/079-subagent-questions.sql" with { type: "text" }
+import agentRunCancelRequestsSql from "./migrations/080-agent-run-cancel-requests.sql" with {
+  type: "text",
+}
+import agentThreadRunsOnSql from "./migrations/081-agent-thread-runs-on.sql" with { type: "text" }
+import agentTokenRatesSql from "./migrations/082-agent-token-rates.sql" with { type: "text" }
+import agentComputerSessionsSql from "./migrations/083-agent-computer-sessions.sql" with {
+  type: "text",
+}