@zaip-ai/cli 1.0.7 → 1.3.0

package/templates/.agents/dashboard/apps/frontend/src/use-app-cost-loaders.test.ts

@@ -0,0 +1,253 @@
+import { CostRunsTable, matchesCostRunFilter } from "@zaip-ai/dashboard-cost-monitor/react";
+import { describe, expect, it } from "vitest";
+import {
+  adaptSqliteCompactLifecyclePage,
+  adaptSqliteCostRun,
+  loadSqliteCostGroupPage,
+} from "./use-app-cost-loaders.js";
+
+describe("daily Cost Monitor continuous pagination", () => {
+  it("uses cost_monitor_daily as a 30-day direct pager across months and keeps full-filter totals", async () => {
+    const calls: Array<{ view: string; range: unknown; page: Record<string, unknown> }> = [];
+    const api = {
+      sqliteViewPage: async (view: string, range: unknown, page: Record<string, unknown>) => {
+        calls.push({ view, range, page });
+        if (page.offset === 0) {
+          return {
+            offset: 0,
+            limit: 30,
+            total_count: 35,
+            has_more: true,
+            rows: [{ period_key: "2026-08-17" }, { period_key: "2026-07-19" }],
+            totals: {
+              task_count: 916,
+              prd_count: 13,
+              spec_count: 59,
+              total_run_count: 238,
+              total_duration: 619_920_000,
+              total_tokens: 7_300_000_000,
+              total_cost_usd: 8_731.92,
+              total_cost_brl: 47_589,
+            },
+          };
+        }
+        return {
+          offset: 30,
+          limit: 30,
+          total_count: 35,
+          has_more: false,
+          rows: [
+            { period_key: "2026-07-18", task_count: 2, total_tokens: 10 },
+            { period_key: "2026-07-14", task_count: 2, total_tokens: 10 },
+          ],
+          totals: {
+            task_count: 916,
+            prd_count: 13,
+            spec_count: 59,
+            total_run_count: 238,
+            total_duration: 619_920_000,
+            total_tokens: 7_300_000_000,
+            total_cost_usd: 8_731.92,
+            total_cost_brl: 47_589,
+          },
+        };
+      },
+    };
+    const filters = {
+      query: "",
+      provider: "",
+      model: "",
+      agent: "",
+      phase: "",
+      status: "",
+      origin: "",
+      workType: "",
+      priority: "",
+      risk: "",
+    } as never;
+    const firstPage = await loadSqliteCostGroupPage(api as never, {
+      view: "daily",
+      from: "2026-07-14",
+      to: "2026-08-17",
+      offset: 0,
+      limit: 30,
+      filters,
+    });
+    const secondPage = await loadSqliteCostGroupPage(api as never, {
+      view: "daily",
+      from: "2026-07-14",
+      to: "2026-08-17",
+      offset: 30,
+      limit: 30,
+      filters,
+    });
+
+    expect(calls).toEqual([
+      {
+        view: "cost_monitor_daily",
+        range: { from: "2026-07-14", to: "2026-08-17" },
+        page: { offset: 0, limit: 30 },
+      },
+      {
+        view: "cost_monitor_daily",
+        range: { from: "2026-07-14", to: "2026-08-17" },
+        page: { offset: 30, limit: 30 },
+      },
+    ]);
+    expect(firstPage).toMatchObject({
+      offset: 0,
+      limit: 30,
+      total_count: 35,
+      has_more: true,
+      rows: [{ key: "2026-08-17" }, { key: "2026-07-19" }],
+      totals: {
+        task_count: 916,
+        prd_count: 13,
+        spec_count: 59,
+        total_tokens: 7_300_000_000,
+        estimated_brl: 47_589,
+      },
+    });
+    expect(secondPage).toMatchObject({
+      offset: 30,
+      limit: 30,
+      total_count: 35,
+      has_more: false,
+      rows: [{ key: "2026-07-18" }, { key: "2026-07-14" }],
+    });
+  });
+});
+
+describe("adaptSqliteCostRun", () => {
+  it("renders a sparse API invocation row without throwing and marks missing multipliers unavailable", () => {
+    const run = adaptSqliteCostRun({
+      agent_invocation_id: "AINV-API-SPARSE",
+      occurred_at: "2026-08-12T20:00:00.000Z",
+      phase: "execution",
+      status: "completed",
+      total_tokens: 0,
+      calculated_cost_usd: 0,
+      cost_brl: 0,
+      current_fx_rate: 5.5,
+      source_event_count: undefined,
+      context_input_multiplier: undefined,
+      context_output_multiplier: undefined,
+    });
+
+    expect(run).toMatchObject({
+      total_tokens: 0,
+      estimated_brl: 0,
+      fx_rate: 5.5,
+      event_count: null,
+      context_input_multiplier: null,
+      context_output_multiplier: null,
+    });
+    const table = CostRunsTable({
+      rows: [run],
+      onOpenRun: () => undefined,
+      currency: "BRL",
+      locale: "pt-BR",
+    });
+    const multiplier = (
+      table.props.columns as Array<{
+        key: string;
+        render: (row: typeof run) => unknown;
+      }>
+    ).find((column) => column.key === "contextMultiplier");
+    expect(multiplier?.render(run)).toBe("Indisponível");
+    expect(
+      matchesCostRunFilter(run, {
+        query: "tarefa avulsa",
+        provider: "",
+        model: "",
+        agent: "",
+        phase: "",
+        status: "",
+        priority: "",
+        risk: "",
+        origin: "",
+        workType: "",
+      }),
+    ).toBe(true);
+  });
+
+  it("maps catalog pricing and keeps current FX separate from recorded period FX", () => {
+    const run = adaptSqliteCostRun({
+      agent_invocation_id: "AINV-PRICED",
+      occurred_at: "2026-08-13T20:00:00.000Z",
+      model: "gpt-5.6-terra",
+      total_tokens: 1_000_000,
+      input_rate_usd_per_million: 2.5,
+      cached_input_rate_usd_per_million: 0.25,
+      output_rate_usd_per_million: 15,
+      reasoning_rate_usd_per_million: 15,
+      calculated_cost_usd: 2,
+      cost_usd: 2.1,
+      cost_brl: 10.5,
+      current_fx_rate: 5.5,
+      recorded_cost_usd: 2.1,
+      recorded_brl: 10.5,
+      recorded_fx_rate: 5,
+    });
+
+    expect(run).toMatchObject({
+      input_rate_usd_per_million: 2.5,
+      cached_input_rate_usd_per_million: 0.25,
+      output_rate_usd_per_million: 15,
+      reasoning_rate_usd_per_million: 15,
+      estimated_usd: 2,
+      estimated_brl: 11,
+      fx_rate: 5.5,
+      recorded_usd: 2.1,
+      recorded_brl: 10.5,
+      recorded_fx_rate: 5,
+    });
+  });
+});
+
+describe("adaptSqliteCompactLifecyclePage", () => {
+  it("keeps identical server subtotals on page two for all compact lifecycle views", () => {
+    const sqlitePage = {
+      data_source: "sqlite_read_model",
+      offset: 50,
+      limit: 50,
+      total_count: 270,
+      has_more: true,
+      totals: {
+        entity_count: 270,
+        invocation_count: 270,
+        total_duration: 270_000,
+        total_tokens: 540,
+        total_cost_usd: 270,
+        total_cost_brl: 1_350,
+      },
+      rows: Array.from({ length: 50 }, (_, index) => ({
+        task_id: `TASK-${index}`,
+        invocation_count: 1,
+        total_duration: 1_000,
+        total_tokens: 2,
+        total_cost_brl: 5,
+      })),
+    } as const;
+    for (const [kind, view] of [
+      ["tasks", "cost_monitor_tasks"],
+      ["specs", "cost_monitor_specs"],
+      ["prds", "cost_monitor_prds"],
+      ["conversations", "cost_monitor_conversations"],
+    ] as const) {
+      const page = adaptSqliteCompactLifecyclePage(kind, { ...sqlitePage, view });
+      expect(page.rows).toHaveLength(50);
+      expect(page.offset).toBe(50);
+      expect(page.subtotal).toEqual({
+        entity_count: 270,
+        run_count: { known_sum: 270, unknown: 0, complete: true, coverage_ratio: 1 },
+        metrics: {
+          duration: { known_sum: 270_000, unknown: 0, complete: true, coverage_ratio: 1 },
+          total_tokens: { known_sum: 540, unknown: 0, complete: true, coverage_ratio: 1 },
+          cost_brl: { known_sum: 1_350, unknown: 0, complete: true, coverage_ratio: 1 },
+          cost_usd: { known_sum: 270, unknown: 0, complete: true, coverage_ratio: 1 },
+        },
+      });
+    }
+  });
+});

package/templates/.agents/dashboard/apps/frontend/src/use-app-cost-loaders.ts

@@ -0,0 +1,380 @@
+import type { CostMonitorProjection } from "@zaip-ai/dashboard-cost-monitor/contracts";
+import type {
+  CompactLifecycleCostPage,
+  LoadCompactCostPage,
+  LoadCostMonitorDetail,
+  LoadCostRunPage,
+} from "@zaip-ai/dashboard-cost-monitor/react";
+import { useCallback } from "react";
+export type LoadCostGroupPage = import("@zaip-ai/dashboard-cost-monitor/react").LoadCostGroupPage;
+
+import type { DashboardApiClient, SqliteViewPage } from "./dashboard-api.js";
+import {
+  costGroupDuration,
+  legacyKnownMetric,
+  nullableSqlNumber,
+  requiredSqlNumber,
+} from "./sqlite-cost-adapters.js";
+
+type CostGroupLoadRequest = Parameters<LoadCostGroupPage>[0];
+
+function costGroupQueryOptions(request: CostGroupLoadRequest, offset: number, limit: number) {
+  const { filters, query } = request;
+  return {
+    offset,
+    limit,
+    ...(query === undefined || query === "" ? {} : { query }),
+    ...(filters.provider ? { provider: filters.provider } : {}),
+    ...(filters.model ? { model: filters.model } : {}),
+    ...(filters.agent ? { agent: filters.agent } : {}),
+    ...(filters.phase ? { phase: filters.phase } : {}),
+    ...(filters.status ? { status: filters.status } : {}),
+    ...(filters.origin ? { origin: filters.origin } : {}),
+    ...(filters.workType ? { workType: filters.workType } : {}),
+    ...(filters.priority ? { priority: filters.priority } : {}),
+    ...(filters.risk ? { risk: filters.risk } : {}),
+  };
+}
+
+function adaptSqliteCostGroup(row: Record<string, unknown>) {
+  const duration = costGroupDuration(row);
+  const durationUnknown = Number(row.duration_unknown ?? (duration === null ? 1 : 0));
+  const durationKnown = nullableSqlNumber(row.duration_known) ?? duration ?? 0;
+  return {
+    key: String(row.key ?? row.period_key ?? "total"),
+    label: String(row.label ?? row.key ?? row.period_key ?? ""),
+    latest_started_at: typeof row.latest_started_at === "string" ? row.latest_started_at : "",
+    persona: typeof row.persona === "string" ? row.persona : null,
+    job: typeof row.job === "string" ? row.job : null,
+    run_count: Number(row.total_run_count ?? row.invocation_count ?? 0),
+    task_count: nullableSqlNumber(row.task_count),
+    prd_count: Number(row.prd_count ?? 0),
+    spec_count: Number(row.spec_count ?? 0),
+    evidence_count: Number(row.evidence_count ?? 0),
+    test_count: Number(row.validation_count ?? 0),
+    event_count: Number(row.source_event_count ?? 0),
+    total_tokens: nullableSqlNumber(row.total_tokens),
+    estimated_usd: nullableSqlNumber(row.total_cost_usd),
+    estimated_brl: nullableSqlNumber(row.total_cost_brl),
+    duration_ms: duration,
+    duration: {
+      known_sum: durationKnown,
+      unknown: durationUnknown,
+      complete: durationUnknown === 0,
+      coverage_ratio: durationUnknown === 0 ? 1 : 0,
+    },
+    coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+  };
+}
+
+export async function loadSqliteCostGroupPage(
+  api: DashboardApiClient,
+  request: CostGroupLoadRequest,
+) {
+  const { from, limit, offset, signal, to, view } = request;
+  const selectedRange = from === undefined || to === undefined ? undefined : { from, to };
+  if (view === "daily") {
+    const page = await api.sqliteViewPage(
+      "cost_monitor_daily",
+      selectedRange,
+      costGroupQueryOptions(request, offset, limit),
+      signal,
+    );
+    return {
+      offset: page.offset,
+      limit: page.limit,
+      total_count: page.total_count,
+      has_more: page.has_more,
+      rows: page.rows.map(adaptSqliteCostGroup),
+      ...(page.totals === undefined ? {} : { totals: adaptSqliteCostGroup(page.totals) }),
+    };
+  }
+  const sqlView = (
+    {
+      monthly: "cost_monitor_monthly",
+      annual: "cost_monitor_annual",
+      agents: "cost_monitor_zaip_agents",
+      models: "cost_monitor_models",
+      providers: "cost_monitor_providers",
+    } as const
+  )[view];
+  const page = await api.sqliteViewPage(
+    sqlView,
+    selectedRange,
+    costGroupQueryOptions(request, offset, limit),
+    signal,
+  );
+  return {
+    offset: page.offset,
+    limit: page.limit,
+    total_count: page.total_count,
+    has_more: page.has_more,
+    rows: page.rows.map(adaptSqliteCostGroup),
+    ...(page.totals === undefined ? {} : { totals: adaptSqliteCostGroup(page.totals) }),
+  };
+}
+
+/** Adapts a sparse SQLite invocation row to the complete CostRunRow contract. */
+export function adaptSqliteCostRun(
+  row: Record<string, unknown>,
+): CostMonitorProjection["runs"][number] {
+  const text = (value: unknown, fallback: string) => (typeof value === "string" ? value : fallback);
+  const nullableNumber = (value: unknown) => (typeof value === "number" ? value : null);
+  const invocationId = text(row.agent_invocation_id, "unavailable");
+  const taskId = typeof row.task_id === "string" ? row.task_id : null;
+  const specId = typeof row.spec_id === "string" ? row.spec_id : null;
+  const prdId = typeof row.prd_id === "string" ? row.prd_id : null;
+  const phase = text(row.phase, "execution");
+  const durationProvenance =
+    row.duration_provenance === "observed" ||
+    row.duration_provenance === "reconciled" ||
+    row.duration_provenance === "estimated" ||
+    row.duration_provenance === "legacy_inferred"
+      ? row.duration_provenance
+      : "unavailable";
+  const calculatedUsd = Object.hasOwn(row, "calculated_cost_usd")
+    ? nullableNumber(row.calculated_cost_usd)
+    : nullableNumber(row.cost_usd);
+  const currentFxRate = nullableNumber(row.current_fx_rate) ?? nullableNumber(row.fx_rate);
+  const recordedUsd = nullableNumber(row.recorded_cost_usd) ?? nullableNumber(row.recorded_usd);
+  const recordedFxRate = Object.hasOwn(row, "recorded_fx_rate")
+    ? nullableNumber(row.recorded_fx_rate)
+    : nullableNumber(row.fx_rate);
+  const recordedBrl =
+    nullableNumber(row.recorded_brl) ??
+    (!Object.hasOwn(row, "recorded_brl") && recordedUsd !== null
+      ? nullableNumber(row.cost_brl)
+      : null);
+  const currentBrl =
+    calculatedUsd !== null && currentFxRate !== null
+      ? Math.round(calculatedUsd * currentFxRate * 1_000_000) / 1_000_000
+      : null;
+  return {
+    run_id: invocationId,
+    execution_id: typeof row.execution_id === "string" ? row.execution_id : null,
+    conversation_id: text(row.run_id, invocationId),
+    task_id: taskId,
+    // A missing relationship is an explicitly unscoped run, not unavailable telemetry.
+    task_title: text(row.task_title, taskId ?? "Tarefa avulsa"),
+    task_status: text(row.task_status, "unavailable"),
+    priority: text(row.priority, "unavailable"),
+    risk: text(row.risk, "unavailable"),
+    spec_id: specId,
+    prd_id: prdId,
+    change_id: typeof row.change_id === "string" ? row.change_id : null,
+    parent_run_id:
+      typeof row.parent_agent_invocation_id === "string" ? row.parent_agent_invocation_id : null,
+    run_role: row.invocation_kind === "subagent" ? "subagent" : "orchestrator",
+    run_kind: row.run_kind === "subrun" ? "subrun" : "run",
+    run_purpose: "execution",
+    requires_finalizer: false,
+    client: text(row.client, "unavailable"),
+    agent: text(row.zaip_agent, "unavailable"),
+    agent_name: text(row.zaip_agent, "unavailable"),
+    provider: typeof row.provider === "string" ? row.provider : null,
+    model: text(row.model, "unavailable"),
+    requested_model: text(row.requested_model, "unavailable"),
+    reasoning_effort: typeof row.reasoning_effort === "string" ? row.reasoning_effort : null,
+    effective_reasoning_effort:
+      typeof row.effective_reasoning_effort === "string" ? row.effective_reasoning_effort : null,
+    service_tier: typeof row.service_tier === "string" ? row.service_tier : null,
+    call_count: nullableNumber(row.llm_call_count),
+    status: text(row.status, "completed"),
+    phase,
+    origin:
+      prdId !== null ? "prd" : specId !== null ? "spec" : taskId !== null ? "task" : "conversation",
+    work_type: row.work_type === "rework" ? "rework" : "new",
+    started_at: text(row.occurred_at, ""),
+    finished_at: typeof row.finished_at === "string" ? row.finished_at : null,
+    duration_ms: nullableNumber(row.duration_ms),
+    duration_provenance: durationProvenance,
+    estimation_basis: typeof row.estimation_basis === "string" ? row.estimation_basis : null,
+    source_started_at: typeof row.source_started_at === "string" ? row.source_started_at : null,
+    source_finished_at: typeof row.source_finished_at === "string" ? row.source_finished_at : null,
+    capture_lag_ms: nullableNumber(row.capture_lag_ms),
+    event_count: nullableNumber(row.source_event_count),
+    input_tokens: nullableNumber(row.input_tokens),
+    cached_input_tokens: nullableNumber(row.cached_input_tokens),
+    output_tokens: nullableNumber(row.output_tokens),
+    reasoning_tokens: nullableNumber(row.reasoning_tokens),
+    total_tokens: nullableNumber(row.total_tokens),
+    uncached_input_tokens: nullableNumber(row.uncached_input_tokens),
+    visible_output_tokens: nullableNumber(row.visible_output_tokens),
+    input_rate_usd_per_million: nullableNumber(row.input_rate_usd_per_million),
+    cached_input_rate_usd_per_million: nullableNumber(row.cached_input_rate_usd_per_million),
+    output_rate_usd_per_million: nullableNumber(row.output_rate_usd_per_million),
+    reasoning_rate_usd_per_million: nullableNumber(row.reasoning_rate_usd_per_million),
+    context_input_multiplier: nullableNumber(row.context_input_multiplier),
+    context_output_multiplier: nullableNumber(row.context_output_multiplier),
+    speed_cost_multiplier: nullableNumber(row.speed_cost_multiplier),
+    standard_cost_usd: nullableNumber(row.standard_cost_usd),
+    speed_uplift_usd: nullableNumber(row.speed_uplift_usd),
+    input_cost_usd: nullableNumber(row.input_cost_usd),
+    cached_input_cost_usd: nullableNumber(row.cached_input_cost_usd),
+    output_cost_usd: nullableNumber(row.output_cost_usd),
+    reasoning_cost_usd: nullableNumber(row.reasoning_cost_usd),
+    fx_rate: currentFxRate,
+    estimated_usd: calculatedUsd,
+    estimated_brl: currentBrl,
+    recorded_usd: recordedUsd,
+    recorded_brl: recordedBrl,
+    recorded_fx_rate: recordedFxRate,
+    coverage: { events: 0, tokens: 0, usd: 0, brl: 0 },
+    artifact_path: `.agents/records/runs/${invocationId}`,
+  };
+}
+
+export function adaptSqliteCompactLifecyclePage(
+  kind: CompactLifecycleCostPage["kind"],
+  page: SqliteViewPage,
+): CompactLifecycleCostPage {
+  const totals = page.totals;
+  const subtotalMetric = (key: string) => legacyKnownMetric(totals?.[key]);
+  return {
+    data_source: "lifecycle_daily_read_models",
+    snapshot_id: null,
+    source_latest_at: null,
+    kind,
+    offset: page.offset,
+    limit: page.limit,
+    total: page.total_count,
+    has_more: page.has_more,
+    next_cursor: null,
+    subtotal: {
+      entity_count:
+        typeof totals?.entity_count === "number" ? totals.entity_count : page.total_count,
+      run_count: subtotalMetric("invocation_count"),
+      metrics: {
+        duration: subtotalMetric("total_duration"),
+        total_tokens: subtotalMetric("total_tokens"),
+        cost_brl: subtotalMetric("total_cost_brl"),
+        cost_usd: subtotalMetric("total_cost_usd"),
+      },
+    },
+    rows: page.rows.map((row) => ({
+      id: String(
+        row.task_id ??
+          row.spec_id ??
+          row.prd_id ??
+          row.execution_id ??
+          row.conversation_id ??
+          row.id ??
+          "unavailable",
+      ),
+      title: String(
+        row.title ??
+          row.task_id ??
+          row.spec_id ??
+          row.prd_id ??
+          row.execution_id ??
+          row.conversation_id ??
+          "Unavailable",
+      ),
+      kind:
+        kind === "tasks"
+          ? "task"
+          : kind === "specs"
+            ? "spec"
+            : kind === "prds"
+              ? "prd"
+              : kind === "executions"
+                ? "execution"
+                : "conversation",
+      status: typeof row.status === "string" ? row.status : null,
+      risk: typeof row.risk === "string" ? row.risk : null,
+      occurred_at:
+        typeof row.occurred_at === "string"
+          ? row.occurred_at
+          : typeof row.started_at === "string"
+            ? row.started_at
+            : typeof row.last_day === "string"
+              ? `${row.last_day}T12:00:00.000Z`
+              : "",
+      parent_id: null,
+      run_count: Number(row.invocation_count ?? 0),
+      cost_currency: "BRL",
+      metrics: {
+        duration: legacyKnownMetric(row.total_duration),
+        total_tokens: legacyKnownMetric(row.total_tokens),
+        cost: legacyKnownMetric(row.total_cost_brl),
+      },
+    })),
+  };
+}
+
+export function useAppCostLoaders(api: DashboardApiClient) {
+  const loadCostDetail = useCallback<LoadCostMonitorDetail>(async () => {
+    throw new Error(
+      "SQLite Cost Monitor loads the selected paginated view; full detail is disabled.",
+    );
+  }, []);
+  const loadCostReadModelPage = useCallback<LoadCompactCostPage>(
+    async ({ filters, from, kind, limit, offset, query, signal, to }) => {
+      const view = (
+        {
+          tasks: "cost_monitor_tasks",
+          specs: "cost_monitor_specs",
+          prds: "cost_monitor_prds",
+          executions: "cost_monitor_executions",
+          conversations: "cost_monitor_conversations",
+        } as const
+      )[kind];
+      const page = await api.sqliteViewPage(
+        view,
+        from === undefined || to === undefined ? undefined : { from, to },
+        {
+          offset,
+          limit,
+          ...(query === undefined || query === "" ? {} : { query }),
+          ...(filters.provider ? { provider: filters.provider } : {}),
+          ...(filters.model ? { model: filters.model } : {}),
+          ...(filters.agent ? { agent: filters.agent } : {}),
+          ...(filters.phase ? { phase: filters.phase } : {}),
+          ...(filters.status ? { status: filters.status } : {}),
+          ...(filters.origin ? { origin: filters.origin } : {}),
+          ...(filters.workType ? { workType: filters.workType } : {}),
+          ...(filters.priority ? { priority: filters.priority } : {}),
+          ...(filters.risk ? { risk: filters.risk } : {}),
+        },
+        signal,
+      );
+      return adaptSqliteCompactLifecyclePage(kind, page);
+    },
+    [api],
+  );
+  const loadCostRunPage = useCallback<LoadCostRunPage>(
+    async ({ filters, from, offset, signal, to }) => {
+      const page = await api.sqliteViewPage(
+        "cost_monitor_agent_invocations",
+        from === undefined || to === undefined ? undefined : { from, to },
+        {
+          offset,
+          limit: 100,
+          ...(filters?.query ? { query: filters.query } : {}),
+          ...(filters?.provider ? { provider: filters.provider } : {}),
+          ...(filters?.model ? { model: filters.model } : {}),
+          ...(filters?.agent ? { agent: filters.agent } : {}),
+          ...(filters?.phase ? { phase: filters.phase } : {}),
+          ...(filters?.status ? { status: filters.status } : {}),
+        },
+        signal,
+      );
+      return {
+        page_only: true,
+        runs: page.rows.map(adaptSqliteCostRun),
+        run_page: {
+          offset: page.offset,
+          limit: page.limit,
+          total: page.total_count,
+          has_more: page.has_more,
+        },
+      };
+    },
+    [api],
+  );
+  const loadCostGroupPage = useCallback<LoadCostGroupPage>(
+    (request) => loadSqliteCostGroupPage(api, request),
+    [api],
+  );
+  return { loadCostDetail, loadCostReadModelPage, loadCostRunPage, loadCostGroupPage };
+}