@zaip-ai/cli 1.0.8 → 1.3.1

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-aggregates.ts

@@ -0,0 +1,497 @@
+import type { DatabaseSync } from "node:sqlite";
+
+type CostAgentProfile = {
+  persona: string | null;
+  job: string | null;
+};
+
+type CostDimensionAggregateRow = {
+  key: string;
+  label: string;
+  invocation_count: number;
+  task_count: number;
+  total_duration: number | null;
+  source_event_count: number | null;
+  total_tokens: number | null;
+  total_cost_usd: number | null;
+  total_cost_brl: number | null;
+};
+
+type CostRemoteAggregateRow = CostDimensionAggregateRow & {
+  id: string;
+  title: string;
+  status: string | null;
+  risk: string | null;
+  persona: string | null;
+  job: string | null;
+  latest_started_at: string;
+  first_day: string;
+  last_day: string;
+  occurred_at: string;
+  llm_call_count: number | null;
+  duration_unknown: number;
+  duration_known: number;
+  total_input_tokens: number | null;
+  total_cached_input_tokens: number | null;
+  total_output_tokens: number | null;
+  total_reasoning_tokens: number | null;
+};
+
+type CostRemoteAggregateProjection = {
+  rows: CostRemoteAggregateRow[];
+  totals: Record<string, number | null>;
+};
+
+export type CostDimensionAggregateSnapshot = Record<
+  "model" | "provider",
+  CostDimensionAggregateRow[]
+> & {
+  remote: Record<"agent" | "execution" | "task" | "conversation", CostRemoteAggregateProjection>;
+};
+
+function observedDimensionValue(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized.length > 0 &&
+    !["unavailable", "unknown", "mixed"].includes(normalized.toLowerCase())
+    ? normalized
+    : null;
+}
+
+export function buildCostDimensionAggregates(
+  database: DatabaseSync,
+  agentProfiles: Map<string, CostAgentProfile>,
+): CostDimensionAggregateSnapshot {
+  const dimensions = ["model", "provider"] as const;
+  const allowedProviders = new Set(
+    (
+      database.prepare("SELECT provider FROM zaip_dim_provider").all() as Array<{
+        provider: string;
+      }>
+    ).map((row) => row.provider),
+  );
+  const activities = database
+    .prepare(`SELECT activity_row_id, agent_invocation_id, task_id, duration_ms,
+    source_event_count, provider, model, total_tokens, cost_usd, cost_brl,
+    activity_source_kind, zaip_agent, zaip_agent_persona, zaip_agent_job,
+    execution_id, conversation_id, occurred_at, occurred_day_sp, llm_call_count,
+    input_tokens, cached_input_tokens, output_tokens, reasoning_tokens
+    FROM zaip_aios_activities WHERE payload_type IS NULL`)
+    .all() as Array<Record<string, unknown>>;
+  const segments = database
+    .prepare(`SELECT agent_invocation_id, provider, model, total_tokens, cost_usd, cost_brl
+    FROM invocation_usage_segments`)
+    .all() as Array<Record<string, unknown>>;
+  const activityByInvocation = new Map(
+    activities
+      .filter((row) => typeof row.agent_invocation_id === "string")
+      .map((row) => [String(row.agent_invocation_id), row] as const),
+  );
+  const rowsByDimension = new Map<"model" | "provider", Map<string, CostDimensionAggregateRow>>(
+    dimensions.map((dimension) => [dimension, new Map()]),
+  );
+  const ensure = (dimension: "model" | "provider", key: string) => {
+    const rows = rowsByDimension.get(dimension)!;
+    const current = rows.get(key);
+    if (current !== undefined) return current;
+    const created: CostDimensionAggregateRow = {
+      key,
+      label: key,
+      invocation_count: 0,
+      task_count: 0,
+      total_duration: null,
+      source_event_count: null,
+      total_tokens: null,
+      total_cost_usd: null,
+      total_cost_brl: null,
+    };
+    rows.set(key, created);
+    return created;
+  };
+  const add = (
+    target: CostDimensionAggregateRow,
+    field: "total_tokens" | "total_cost_usd" | "total_cost_brl",
+    value: unknown,
+  ) => {
+    if (typeof value === "number") target[field] = (target[field] ?? 0) + value;
+  };
+  const segmentsByInvocation = new Map<string, Array<Record<string, unknown>>>();
+  for (const segment of segments) {
+    const id = String(segment.agent_invocation_id ?? "");
+    if (id.length === 0) continue;
+    const invocationSegments = segmentsByInvocation.get(id);
+    if (invocationSegments === undefined) segmentsByInvocation.set(id, [segment]);
+    else invocationSegments.push(segment);
+  }
+  for (const [id, invocationSegments] of segmentsByInvocation) {
+    const activity = activityByInvocation.get(id);
+    if (activity === undefined) continue;
+    for (const dimension of dimensions) {
+      const financialSegments = invocationSegments.filter(
+        (segment) =>
+          observedDimensionValue(segment[dimension]) !== null &&
+          observedDimensionValue(segment.provider) !== null &&
+          allowedProviders.has(observedDimensionValue(segment.provider)!) &&
+          (typeof segment.total_tokens === "number" ||
+            typeof segment.cost_usd === "number" ||
+            typeof segment.cost_brl === "number"),
+      );
+      const keys = [
+        ...new Set(financialSegments.map((row) => observedDimensionValue(row[dimension])!)),
+      ];
+      if (keys.length === 0) {
+        // Keep auditable, dimensionless invocation facts visible so Models
+        // and Providers reconcile to the Cost KPI instead of silently
+        // dropping them.
+        const target = ensure(dimension, "unavailable");
+        target.invocation_count += 1;
+        if (typeof activity.duration_ms === "number")
+          target.total_duration = (target.total_duration ?? 0) + activity.duration_ms;
+        if (typeof activity.source_event_count === "number")
+          target.source_event_count =
+            (target.source_event_count ?? 0) + activity.source_event_count;
+        add(target, "total_tokens", activity.total_tokens);
+        add(target, "total_cost_usd", activity.cost_usd);
+        add(target, "total_cost_brl", activity.cost_brl);
+      }
+      for (const segment of financialSegments) {
+        const target = ensure(dimension, observedDimensionValue(segment[dimension])!);
+        add(target, "total_tokens", segment.total_tokens);
+        add(target, "total_cost_usd", segment.cost_usd);
+        add(target, "total_cost_brl", segment.cost_brl);
+      }
+      // An invocation's elapsed time is attributable only when its observed
+      // financial segments agree on one dimension.  Do not fabricate a
+      // mixed bucket or split wall-clock time across models/providers.
+      if (keys.length === 1) {
+        const target = ensure(dimension, keys[0]!);
+        target.invocation_count += 1;
+        if (typeof activity.duration_ms === "number")
+          target.total_duration = (target.total_duration ?? 0) + activity.duration_ms;
+        if (typeof activity.source_event_count === "number")
+          target.source_event_count =
+            (target.source_event_count ?? 0) + activity.source_event_count;
+      }
+    }
+  }
+  const taskKeys = new Map<"model" | "provider", Map<string, Set<string>>>(
+    dimensions.map((dimension) => [dimension, new Map()]),
+  );
+  for (const [id, invocationSegments] of segmentsByInvocation) {
+    const taskId = activityByInvocation.get(id)?.task_id;
+    if (typeof taskId !== "string") continue;
+    for (const dimension of dimensions) {
+      const byTask = taskKeys.get(dimension)!;
+      const keys = byTask.get(taskId) ?? new Set<string>();
+      for (const segment of invocationSegments) {
+        const key = observedDimensionValue(segment[dimension]);
+        const provider = observedDimensionValue(segment.provider);
+        const hasFinancialFact =
+          typeof segment.total_tokens === "number" ||
+          typeof segment.cost_usd === "number" ||
+          typeof segment.cost_brl === "number";
+        if (key !== null && provider !== null && allowedProviders.has(provider) && hasFinancialFact)
+          keys.add(key);
+      }
+      byTask.set(taskId, keys);
+    }
+  }
+  for (const dimension of dimensions)
+    for (const keys of taskKeys.get(dimension)!.values())
+      for (const key of keys) ensure(dimension, key).task_count += 1;
+  for (const activity of activities) {
+    if (typeof activity.agent_invocation_id === "string") continue;
+    const hasFinancialFact =
+      typeof activity.total_tokens === "number" ||
+      typeof activity.cost_usd === "number" ||
+      typeof activity.cost_brl === "number";
+    if (!hasFinancialFact) continue;
+    const provider = observedDimensionValue(activity.provider);
+    if (provider === null || !allowedProviders.has(provider)) continue;
+    for (const dimension of dimensions) {
+      const key = observedDimensionValue(activity[dimension]) ?? "unavailable";
+      const target = ensure(dimension, key);
+      target.invocation_count += 1;
+      if (typeof activity.task_id === "string") target.task_count += 1;
+      if (typeof activity.duration_ms === "number")
+        target.total_duration = (target.total_duration ?? 0) + activity.duration_ms;
+      if (typeof activity.source_event_count === "number")
+        target.source_event_count = (target.source_event_count ?? 0) + activity.source_event_count;
+      add(target, "total_tokens", activity.total_tokens);
+      add(target, "total_cost_usd", activity.cost_usd);
+      add(target, "total_cost_brl", activity.cost_brl);
+    }
+  }
+  const base = Object.fromEntries(
+    dimensions.map((dimension) => [
+      dimension,
+      [...rowsByDimension.get(dimension)!.values()].sort(
+        (left, right) =>
+          (right.total_cost_brl ?? -1) - (left.total_cost_brl ?? -1) ||
+          left.key.localeCompare(right.key),
+      ),
+    ]),
+  ) as Record<"model" | "provider", CostDimensionAggregateRow[]>;
+  const numericFields = [
+    "total_input_tokens",
+    "total_cached_input_tokens",
+    "total_output_tokens",
+    "total_reasoning_tokens",
+    "total_tokens",
+    "total_cost_usd",
+    "total_cost_brl",
+  ] as const;
+  const createRemoteRow = (key: string): CostRemoteAggregateRow => ({
+    key,
+    id: key,
+    label: key,
+    title: key,
+    status: null,
+    risk: null,
+    persona: null,
+    job: null,
+    latest_started_at: "",
+    first_day: "",
+    last_day: "",
+    occurred_at: "",
+    invocation_count: 0,
+    task_count: 0,
+    llm_call_count: null,
+    total_duration: null,
+    duration_unknown: 0,
+    duration_known: 0,
+    source_event_count: null,
+    total_input_tokens: null,
+    total_cached_input_tokens: null,
+    total_output_tokens: null,
+    total_reasoning_tokens: null,
+    total_tokens: null,
+    total_cost_usd: null,
+    total_cost_brl: null,
+  });
+  const addRemoteNumber = (
+    row: CostRemoteAggregateRow,
+    field: (typeof numericFields)[number],
+    value: unknown,
+  ) => {
+    if (typeof value === "number") row[field] = (row[field] ?? 0) + value;
+  };
+  const updateRemoteRow = (row: CostRemoteAggregateRow, activity: Record<string, unknown>) => {
+    row.invocation_count += 1;
+    if (typeof activity.llm_call_count === "number")
+      row.llm_call_count = (row.llm_call_count ?? 0) + activity.llm_call_count;
+    if (typeof activity.duration_ms === "number") {
+      row.total_duration = (row.total_duration ?? 0) + activity.duration_ms;
+      row.duration_known += activity.duration_ms;
+    } else {
+      row.duration_unknown += 1;
+    }
+    if (typeof activity.source_event_count === "number")
+      row.source_event_count = (row.source_event_count ?? 0) + activity.source_event_count;
+    for (const field of numericFields) {
+      const source =
+        field === "total_input_tokens"
+          ? "input_tokens"
+          : field === "total_cached_input_tokens"
+            ? "cached_input_tokens"
+            : field === "total_output_tokens"
+              ? "output_tokens"
+              : field === "total_reasoning_tokens"
+                ? "reasoning_tokens"
+                : field === "total_cost_usd"
+                  ? "cost_usd"
+                  : field === "total_cost_brl"
+                    ? "cost_brl"
+                    : field;
+      addRemoteNumber(row, field, activity[source]);
+    }
+    const occurredAt = typeof activity.occurred_at === "string" ? activity.occurred_at : "";
+    const day = typeof activity.occurred_day_sp === "string" ? activity.occurred_day_sp : "";
+    if (occurredAt > row.latest_started_at) row.latest_started_at = occurredAt;
+    if (row.first_day === "" || (day !== "" && day < row.first_day)) row.first_day = day;
+    if (day > row.last_day) row.last_day = day;
+  };
+
+  const agentRows = new Map<string, { row: CostRemoteAggregateRow; tasks: Set<string> }>();
+  const agentTasks = new Set<string>();
+  for (const activity of activities) {
+    const key = activity.zaip_agent;
+    const hasFinancialFact =
+      typeof activity.total_tokens === "number" ||
+      typeof activity.cost_usd === "number" ||
+      typeof activity.cost_brl === "number";
+    if (
+      typeof key !== "string" ||
+      key.length === 0 ||
+      (activity.activity_source_kind !== "agent_run" && !hasFinancialFact)
+    )
+      continue;
+    const entry = agentRows.get(key) ?? { row: createRemoteRow(key), tasks: new Set<string>() };
+    const persona =
+      typeof activity.zaip_agent_persona === "string"
+        ? activity.zaip_agent_persona
+        : (agentProfiles.get(key)?.persona ?? null);
+    const job =
+      typeof activity.zaip_agent_job === "string"
+        ? activity.zaip_agent_job
+        : (agentProfiles.get(key)?.job ?? null);
+    if (persona !== null && (entry.row.persona === null || persona > entry.row.persona))
+      entry.row.persona = persona;
+    if (job !== null && (entry.row.job === null || job > entry.row.job)) entry.row.job = job;
+    if (typeof activity.task_id === "string") {
+      entry.tasks.add(activity.task_id);
+      agentTasks.add(activity.task_id);
+    }
+    updateRemoteRow(entry.row, activity);
+    agentRows.set(key, entry);
+  }
+  const agents = [...agentRows.values()]
+    .map(({ row, tasks }) => ({ ...row, task_count: tasks.size }))
+    .sort(
+      (left, right) =>
+        (right.total_cost_brl ?? -1) - (left.total_cost_brl ?? -1) ||
+        left.key.localeCompare(right.key),
+    );
+
+  const lifecycleMetadata = new Map<
+    string,
+    { title: string; status: string | null; risk: string | null }
+  >();
+  for (const item of database
+    .prepare(
+      "SELECT entity_kind, id, title, status, risk FROM canonical_work_items WHERE entity_kind IN ('task', 'conversation')",
+    )
+    .all() as Array<{
+    entity_kind: string;
+    id: string;
+    title: string | null;
+    status: string | null;
+    risk: string | null;
+  }>)
+    lifecycleMetadata.set(`${item.entity_kind}:${item.id}`, {
+      title: item.title ?? item.id,
+      status: item.status,
+      risk: item.entity_kind === "task" ? item.risk : null,
+    });
+  for (const execution of database
+    .prepare("SELECT id, status FROM canonical_executions")
+    .all() as Array<{ id: string; status: string | null }>)
+    lifecycleMetadata.set(`execution:${execution.id}`, {
+      title: execution.id,
+      status: execution.status,
+      risk: null,
+    });
+  const lifecycleDefinitions = [
+    { dimension: "execution", column: "execution_id" },
+    { dimension: "task", column: "task_id" },
+    { dimension: "conversation", column: "conversation_id" },
+  ] as const;
+  const lifecycleRows = Object.fromEntries(
+    lifecycleDefinitions.map(({ dimension, column }) => {
+      const grouped = new Map<string, { row: CostRemoteAggregateRow; tasks: Set<string> }>();
+      for (const activity of activities) {
+        const key = activity[column];
+        if (
+          activity.activity_source_kind !== "agent_run" ||
+          typeof key !== "string" ||
+          key.length === 0
+        )
+          continue;
+        const entry = grouped.get(key) ?? { row: createRemoteRow(key), tasks: new Set<string>() };
+        const metadata = lifecycleMetadata.get(`${dimension}:${key}`);
+        entry.row.title = metadata?.title ?? key;
+        entry.row.status = metadata?.status ?? null;
+        entry.row.risk = metadata?.risk ?? null;
+        if (typeof activity.task_id === "string") entry.tasks.add(activity.task_id);
+        updateRemoteRow(entry.row, activity);
+        grouped.set(key, entry);
+      }
+      const rows = [...grouped.values()]
+        .map(({ row, tasks }) => ({
+          ...row,
+          task_count: tasks.size,
+          occurred_at: row.last_day === "" ? "" : `${row.last_day}T12:00:00.000Z`,
+        }))
+        .sort(
+          (left, right) =>
+            (right.total_cost_brl ?? -1) - (left.total_cost_brl ?? -1) ||
+            left.key.localeCompare(right.key),
+        );
+      return [dimension, rows] as const;
+    }),
+  ) as Record<"execution" | "task" | "conversation", CostRemoteAggregateRow[]>;
+  const lifecycleDurationTotals = Object.fromEntries(
+    lifecycleDefinitions.map(({ dimension, column }) => {
+      const result = database
+        .prepare(
+          `SELECT ROUND(SUM(duration_ms)) AS total_duration
+             FROM zaip_aios_activities
+            WHERE payload_type IS NULL AND activity_source_kind='agent_run'
+              AND ${column} IS NOT NULL`,
+        )
+        .get() as { total_duration: number | null };
+      return [dimension, result.total_duration] as const;
+    }),
+  ) as Record<"execution" | "task" | "conversation", number | null>;
+  const aggregateTotals = (
+    rows: CostRemoteAggregateRow[],
+    taskCount: number,
+  ): Record<string, number | null> => ({
+    entity_count: rows.length,
+    invocation_count: rows.reduce((sum, row) => sum + row.invocation_count, 0),
+    task_count: taskCount,
+    total_duration: rows.some((row) => row.total_duration !== null)
+      ? rows.reduce((sum, row) => sum + (row.total_duration ?? 0), 0)
+      : null,
+    duration_unknown: rows.reduce((sum, row) => sum + row.duration_unknown, 0),
+    duration_known: rows.reduce((sum, row) => sum + row.duration_known, 0),
+    source_event_count: rows.some((row) => row.source_event_count !== null)
+      ? rows.reduce((sum, row) => sum + (row.source_event_count ?? 0), 0)
+      : null,
+    total_tokens: rows.some((row) => row.total_tokens !== null)
+      ? rows.reduce((sum, row) => sum + (row.total_tokens ?? 0), 0)
+      : null,
+    total_cost_usd: rows.some((row) => row.total_cost_usd !== null)
+      ? rows.reduce((sum, row) => sum + (row.total_cost_usd ?? 0), 0)
+      : null,
+    total_cost_brl: rows.some((row) => row.total_cost_brl !== null)
+      ? rows.reduce((sum, row) => sum + (row.total_cost_brl ?? 0), 0)
+      : null,
+  });
+  const lifecycleAggregateTotals = (
+    rows: CostRemoteAggregateRow[],
+    totalDuration: number | null,
+  ): Record<string, number | null> => {
+    const totals = aggregateTotals(rows, 0);
+    return {
+      ...totals,
+      total_duration: totalDuration,
+    };
+  };
+  return {
+    ...base,
+    remote: {
+      agent: { rows: agents, totals: aggregateTotals(agents, agentTasks.size) },
+      execution: {
+        rows: lifecycleRows.execution,
+        totals: lifecycleAggregateTotals(
+          lifecycleRows.execution,
+          lifecycleDurationTotals.execution,
+        ),
+      },
+      task: {
+        rows: lifecycleRows.task,
+        totals: lifecycleAggregateTotals(lifecycleRows.task, lifecycleDurationTotals.task),
+      },
+      conversation: {
+        rows: lifecycleRows.conversation,
+        totals: lifecycleAggregateTotals(
+          lifecycleRows.conversation,
+          lifecycleDurationTotals.conversation,
+        ),
+      },
+    },
+  };
+}
+
+/** Only canonical inputs consumed by the fact or its direct dimensions. */

package/templates/.agents/dashboard/packages/local-runtime/src/sqlite-cost-fast-page-parity.test-support.ts

@@ -0,0 +1,65 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect } from "vitest";
+import {
+  type SqliteReadModelFileSystem,
+  type SqliteViewName,
+  sqliteReadModelPath,
+} from "./sqlite-read-model.js";
+
+const parityViews = [
+  ["cost_monitor_zaip_agents", "key"],
+  ["cost_monitor_executions", "id"],
+  ["cost_monitor_tasks", "id"],
+  ["cost_monitor_conversations", "id"],
+] as const satisfies ReadonlyArray<readonly [SqliteViewName, string]>;
+
+const commonTotals = [
+  "invocation_count",
+  "total_duration",
+  "total_tokens",
+  "total_cost_usd",
+  "total_cost_brl",
+] as const;
+
+function selectedTotals(value: unknown): Record<string, unknown> {
+  const totals = (value ?? {}) as Record<string, unknown>;
+  return Object.fromEntries(commonTotals.map((key) => [key, totals[key] ?? null]));
+}
+
+/** Compares the all-time technical payload path with the bounded canonical path. */
+export function expectFastCostPagesMatchCanonical(
+  root: string,
+  filesystem: SqliteReadModelFileSystem,
+): void {
+  for (const [view, idField] of parityViews) {
+    const fast = filesystem.viewPage(view, { limit: 200, offset: 0 });
+    const canonical = filesystem.viewPage(view, {
+      from: "1900-01-01",
+      to: "2999-12-31",
+      limit: 200,
+      offset: 0,
+    });
+    expect(fast.total_count, `${view} total_count`).toBe(canonical.total_count);
+    expect(fast.rows.map((row) => String(row[idField])).sort(), `${view} identifiers`).toEqual(
+      canonical.rows.map((row) => String(row[idField])).sort(),
+    );
+    expect(selectedTotals(fast.totals), `${view} totals`).toEqual(selectedTotals(canonical.totals));
+  }
+
+  const database = new DatabaseSync(sqliteReadModelPath(root), { readOnly: true });
+  try {
+    const observedAgentKeys = (
+      database
+        .prepare(
+          "SELECT zaip_agent FROM zaip_vw_cost_monitor_zaip_agents WHERE zaip_agent IS NOT NULL",
+        )
+        .all() as Array<{ zaip_agent: string }>
+    ).map((row) => row.zaip_agent);
+    const fastAgentKeys = filesystem
+      .viewPage("cost_monitor_zaip_agents", { limit: 200, offset: 0 })
+      .rows.map((row) => String(row.key));
+    expect(fastAgentKeys).toEqual(expect.arrayContaining(observedAgentKeys));
+  } finally {
+    database.close();
+  }
+}