@sixb/sqlite 0.1.26 → 0.2.0

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/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

@@ -313,6 +313,8 @@ export const sqliteStorageMigrations = defineMigrations({
     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),
   ],
 })
 
@@ -715,3 +717,7 @@ import agentRunCancelRequestsSql from "./migrations/080-agent-run-cancel-request
   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",
+}

package/src/objects/query-compiler.ts

@@ -9,6 +9,7 @@ import {
 import {
   hasVectorProfile,
   isVectorProfileQuery,
+  linkEndpointObjectTypeIds,
   normalizeVector,
   vectorSearchCandidateLimit,
 } from "@sixb/core/internal/query"
@@ -190,14 +191,7 @@ function compileObjectQueryInternal(
     case "page":
       return compilePage(projectId, query.input, query.pageSize, query.pageToken, ctx)
     case "traverse":
-      return compileTraversal(
-        projectId,
-        query.input,
-        query.linkId,
-        query.direction,
-        query.sourceObjectTypeId,
-        ctx
-      )
+      return compileTraversal(projectId, query, ctx)
     case "set":
       return compileSet(projectId, query.op, query.inputs, ctx)
     case "project":
@@ -571,14 +565,13 @@ function compilePage(
 
 function compileTraversal(
   projectId: string,
-  inputQuery: ObjectQuery,
-  linkId: string,
-  direction: "outgoing" | "incoming",
-  sourceObjectTypeId: string | undefined,
+  traversal: Extract<ObjectQuery, { kind: "traverse" }>,
   ctx: CompileContext
 ): CompiledObjectQuery {
-  const input = compileObjectQueryInternal(projectId, inputQuery, exactContext(ctx))
+  const { linkId, direction, sourceObjectTypeId } = traversal
+  const input = compileObjectQueryInternal(projectId, traversal.input, exactContext(ctx))
   const outputAlias = direction === "outgoing" ? "target_object" : "source_object"
+  const endpointType = compileEndpointTypes(outputAlias, linkEndpointObjectTypeIds(traversal))
   const joinSql =
     direction === "outgoing"
       ? `
@@ -591,6 +584,7 @@ function compileTraversal(
           ON target_object.project_id = edge.project_id
          AND target_object.object_type_id = edge.target_type_id
          AND target_object.primary_id = edge.target_id
+         ${endpointType.sql}
       `
       : `
         JOIN ${ctx.source.linksTable} AS edge
@@ -602,6 +596,7 @@ function compileTraversal(
           ON source_object.project_id = edge.project_id
          AND source_object.object_type_id = edge.source_type_id
          AND source_object.primary_id = edge.source_id
+         ${endpointType.sql}
       `
   const order = compileOrder(identityOrderFields())
   const qualifiedOrder = compileOrder(identityOrderFields(), outputAlias)
@@ -614,7 +609,8 @@ function compileTraversal(
   const args = [
     ...input.args,
     linkId,
-    ...(sourceObjectTypeId === undefined ? [] : [sourceObjectTypeId]),
+    ...(direction === "incoming" && sourceObjectTypeId !== undefined ? [sourceObjectTypeId] : []),
+    ...endpointType.args,
     ...qualifiedOrder.args,
   ]
 
@@ -630,6 +626,19 @@ function compileTraversal(
   }
 }
 
+/** Only the types the ontology says this link can reach. */
+function compileEndpointTypes(
+  alias: string,
+  objectTypeIds: readonly string[] | undefined
+): CompiledPredicate {
+  if (!objectTypeIds?.length) return { sql: "", args: [] }
+
+  return {
+    sql: `AND ${alias}.object_type_id IN (${objectTypeIds.map(() => "?").join(", ")})`,
+    args: [...objectTypeIds],
+  }
+}
+
 /** Correlation handle for an expansion: the parent row's identity columns. */
 interface ExpansionParent {
   project: string
@@ -730,7 +739,8 @@ function compileExpansionValue(
     `${parentId} = ${parent.id}`,
     `${edge}.link_id = ?`,
   ]
-  const whereArgs: SqliteValue[] = [expansion.linkId]
+  const endpointType = compileEndpointTypes(target, expansion.endpointObjectTypeIds)
+  const whereArgs: SqliteValue[] = [...endpointType.args, expansion.linkId]
   if (incoming && expansion.sourceObjectTypeId !== undefined) {
     whereParts.push(`${edge}.source_type_id = ?`)
     whereArgs.push(expansion.sourceObjectTypeId)
@@ -742,6 +752,7 @@ function compileExpansionValue(
       ON ${target}.project_id = ${edge}.project_id
      AND ${target}.object_type_id = ${neighborType}
      AND ${target}.primary_id = ${neighborId}
+     ${endpointType.sql}
     WHERE ${whereParts.join(" AND ")}
   `
 

package/src/ontology-storage/commits.ts

@@ -11,6 +11,7 @@ import type {
 import {
   assertNonblank,
   assertNonnegativeInteger,
+  assertTimestamp,
   commitRecord,
   originWhere,
   type SqliteOntologyCommitRow,
@@ -78,6 +79,9 @@ export class SqliteOntologyCommitStorage implements OntologyCommitStorage {
       const limit = input.limit ?? -1
       assertNonnegativeInteger(offset, "Ontology commit list offset")
       if (limit !== -1) assertNonnegativeInteger(limit, "Ontology commit list limit")
+      if (input.committedAt !== undefined) {
+        assertTimestamp(input.committedAt, "Ontology commit list committedAt")
+      }
       const filters = ["project_id = ?"]
       const values: (string | number)[] = [input.projectId]
       if (input.run?.kind === "action") {
@@ -87,6 +91,11 @@ export class SqliteOntologyCommitStorage implements OntologyCommitStorage {
         filters.push("origin_run_id = ? AND origin_kind IN ('projection', 'telemetry')")
         values.push(input.run.id)
       }
+      if (input.committedAt !== undefined) {
+        // Commit times are stored canonical, so text equality is exact and the index serves it.
+        filters.push("committed_at = ?")
+        values.push(input.committedAt)
+      }
       const where = filters.join(" AND ")
       const totalRow = this.db
         .query(`SELECT COUNT(*) AS total FROM ontology_commits WHERE ${where}`)

package/src/ontology-storage/materializations.ts

@@ -25,6 +25,7 @@ import {
   invalidCorrelation,
   materializationOutboxWrite,
   materializationPlanChunk,
+  prepareMaterializationStateRead,
   sameNonnegativeCounts as sameCounts,
   uniqueSorted,
 } from "@sixb/core/internal/ontology-storage-provider"
@@ -36,16 +37,18 @@ import type {
   MaterializationPlanHeader,
   MaterializationPlanWorkRecord,
   MaterializationSession,
+  MaterializationState,
   MaterializationStatePage,
   MaterializationVectorChangePage,
   OntologyCommitRecord,
   OntologyMaterializationStorage,
+  ReadMaterializationStateInput,
   SourceActivationWrite,
   StageMaterializationWorkInput,
   StreamMaterializationStateInput,
   StreamMaterializationVectorChangesInput,
 } from "@sixb/core/storage"
-import { yieldSqliteEventLoop } from "../transactions"
+import { runDeferredReadTransaction, yieldSqliteEventLoop } from "../transactions"
 import {
   type SqliteMaterializationSessionState,
   SqliteMaterializationSessions,
@@ -243,6 +246,20 @@ export class SqliteOntologyMaterializationStorage implements OntologyMaterializa
     }
   }
 
+  async readState(input: ReadMaterializationStateInput): Promise<MaterializationState> {
+    const request = prepareMaterializationStateRead(input)
+
+    // One snapshot for every statement, so the read never straddles a commit.
+    return runDeferredReadTransaction(this.db, () => {
+      const reader = new SqliteMaterializationStateReader(this.db, request.projectId)
+      return {
+        objects: reader.objectStates(request.objects),
+        links: reader.linkStates(request.links),
+        linkScopes: reader.linkSlotStates(request.linkScopes),
+      }
+    })
+  }
+
   async stageWork(input: StageMaterializationWorkInput): Promise<void> {
     this.sessions.stage(input)
     await yieldSqliteEventLoop()