@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-NUO7B3SH.js

@@ -0,0 +1,318 @@
+import {
+  readContextWindow
+} from "./chunk-Z7CDQNH3.js";
+import {
+  ModelInvocationsDB,
+  NON_METERED_COST_SQL,
+  resolveInvocationsDbPath
+} from "./chunk-Q64IR2Z2.js";
+
+// src/telemetry/task-report.ts
+function unionDurationMs(rows) {
+  const intervals = rows.filter(
+    (row) => typeof row.time_last_token_ms === "number" && row.time_last_token_ms >= row.time_request_sent_ms
+  ).map((row) => [row.time_request_sent_ms, row.time_last_token_ms]).sort(([left], [right]) => left - right);
+  if (intervals.length === 0) return null;
+  let total = 0;
+  let [start, end] = intervals[0];
+  for (const [nextStart, nextEnd] of intervals.slice(1)) {
+    if (nextStart <= end) {
+      end = Math.max(end, nextEnd);
+    } else {
+      total += end - start;
+      start = nextStart;
+      end = nextEnd;
+    }
+  }
+  return total + end - start;
+}
+var TaskReportService = class {
+  constructor(invocations, variantsDb) {
+    this.invocations = invocations;
+    this.variantsDb = variantsDb;
+  }
+  invocations;
+  variantsDb;
+  /**
+   * Report for one task, or, with no `taskId`, for every invocation of one run.
+   * Commands that do not stamp a task id on their invocations (`build`)
+   * are only attributable by run, and a run may span several task ids.
+   */
+  getTaskReport(input) {
+    const runScoped = input.taskId === void 0;
+    if (runScoped && !input.runId) {
+      throw new Error("A task report needs a task id or a run id");
+    }
+    const clauses = [];
+    const params = [];
+    if (!runScoped) {
+      clauses.push("task_id = ?");
+      params.push(input.taskId);
+    }
+    if (input.runId) {
+      clauses.push("run_id = ?");
+      params.push(input.runId);
+    }
+    if (input.projectId) {
+      clauses.push("project_id = ?");
+      params.push(input.projectId);
+    }
+    if (input.labId) {
+      clauses.push("lab_id = ?");
+      params.push(input.labId);
+      if (input.labRunId) {
+        clauses.push("lab_run_id = ?");
+        params.push(input.labRunId);
+      }
+    } else if (!runScoped) {
+      clauses.push("lab_id IS NULL");
+    }
+    const where = clauses.join(" AND ");
+    const rollup = runScoped ? this.invocations.db.prepare(
+      `SELECT
+                 MAX(project_id) AS project_id, MAX(lab_id) AS lab_id,
+                 MAX(lab_run_id) AS lab_run_id, run_id, COALESCE(MAX(task_id), '') AS task_id,
+                 MAX(last_invocation_ms) AS last_invocation_ms,
+                 SUM(invocation_count) AS invocation_count,
+                 SUM(usage_reported_count) AS usage_reported_count,
+                 SUM(priced_count) AS priced_count,
+                 MIN(provider_started_ms) AS provider_started_ms,
+                 MAX(provider_finished_ms) AS provider_finished_ms,
+                 SUM(provider_sum_ms) AS provider_sum_ms,
+                 SUM(input_tokens) AS input_tokens, SUM(output_tokens) AS output_tokens,
+                 SUM(cache_read_tokens) AS cache_read_tokens,
+                 SUM(cache_write_tokens) AS cache_write_tokens,
+                 SUM(reasoning_tokens) AS reasoning_tokens, SUM(tool_tokens) AS tool_tokens,
+                 SUM(api_equivalent_cost_usd) AS api_equivalent_cost_usd,
+                 SUM(provider_reported_cost_usd) AS provider_reported_cost_usd
+               FROM task_invocation_rollup_v
+               WHERE ${where}
+               GROUP BY run_id`
+    ).get(...params) : this.invocations.db.prepare(
+      `SELECT *
+               FROM task_invocation_rollup_v
+               WHERE ${where}
+               ORDER BY last_invocation_ms DESC
+               LIMIT 1`
+    ).get(...params);
+    if (!rollup) {
+      return {
+        receiptVersion: 1,
+        projectId: input.projectId ?? null,
+        labId: input.labId ?? null,
+        labRunId: input.labRunId ?? null,
+        taskId: input.taskId ?? "",
+        runId: input.runId ?? null,
+        duration: { wallMs: null, providerBusyMs: null, providerSumMs: null },
+        usage: {
+          status: "unavailable",
+          inputTokens: null,
+          outputTokens: null,
+          cacheReadTokens: null,
+          cacheWriteTokens: null,
+          reasoningTokens: null,
+          toolTokens: null,
+          billableTokens: null,
+          ambiguousDimensions: []
+        },
+        cost: { status: "unavailable", currency: "USD", reason: "no_invocations" },
+        coverage: {
+          invocations: 0,
+          usageReportedInvocations: 0,
+          pricedInvocations: 0,
+          status: "unavailable"
+        }
+      };
+    }
+    const selectedColumns = runScoped ? ["run_id"] : ["task_id", "project_id", "lab_id", "lab_run_id", "run_id"];
+    const selectedWhereFor = (prefix) => selectedColumns.map((column) => `${prefix}${column} ${column === "task_id" ? "=" : "IS"} ?`).join(" AND ");
+    const selectedWhere = selectedWhereFor("");
+    const selectedParams = runScoped ? [rollup.run_id] : [rollup.task_id, rollup.project_id, rollup.lab_id, rollup.lab_run_id, rollup.run_id];
+    const metricRows = this.invocations.db.prepare(
+      `SELECT
+           time_request_sent_ms, time_last_token_ms,
+           input_tokens, output_tokens, cache_read_tokens, cache_write_tokens,
+           reasoning_tokens, tool_tokens,
+           cache_read_included_in_input, cache_write_included_in_input,
+           provider_reported_cost_usd
+         FROM invocation_metrics_v WHERE ${selectedWhere}`
+    ).all(...selectedParams);
+    const providerBusyMs = unionDurationMs(metricRows);
+    const wallMs = this.readWallDurationMs({
+      projectId: rollup.project_id,
+      taskId: rollup.task_id,
+      runId: input.runId,
+      labId: rollup.lab_id,
+      labRunId: rollup.lab_run_id
+    });
+    const usageStatus = rollup.usage_reported_count === rollup.invocation_count ? "available" : rollup.usage_reported_count > 0 ? "partial" : "unavailable";
+    const seatLicensed = this.invocations.db.prepare(
+      `SELECT COUNT(*) AS n FROM invocation_metrics_v m
+           JOIN enriched_invocations e ON e.invocation_id = m.invocation_id
+           WHERE ${selectedWhereFor("m.")}
+             AND m.cost_status <> 'complete' AND ${NON_METERED_COST_SQL}`
+    ).get(...selectedParams).n;
+    const partialPriced = this.invocations.db.prepare(
+      `SELECT COUNT(*) AS n FROM invocation_metrics_v
+           WHERE ${selectedWhere}
+             AND cost_status = 'partial' AND api_equivalent_cost_usd IS NOT NULL`
+    ).get(...selectedParams).n;
+    const settledCount = rollup.priced_count + seatLicensed;
+    const coverageStatus = settledCount === rollup.invocation_count ? "complete" : rollup.priced_count > 0 || partialPriced > 0 ? "partial" : "unavailable";
+    const estimateComplete = partialPriced > 0 && settledCount + partialPriced === rollup.invocation_count;
+    const ambiguousDimensions = /* @__PURE__ */ new Set();
+    let billableTokens = 0;
+    for (const row of metricRows) {
+      billableTokens += (row.input_tokens ?? 0) + (row.output_tokens ?? 0);
+      if ((row.cache_read_tokens ?? 0) > 0) {
+        if (row.cache_read_included_in_input === 0) {
+          billableTokens += row.cache_read_tokens ?? 0;
+        } else if (row.cache_read_included_in_input === null) {
+          ambiguousDimensions.add("cacheRead");
+        }
+      }
+      if ((row.cache_write_tokens ?? 0) > 0) {
+        if (row.cache_write_included_in_input === 0) {
+          billableTokens += row.cache_write_tokens ?? 0;
+        } else if (row.cache_write_included_in_input === null) {
+          ambiguousDimensions.add("cacheWrite");
+        }
+      }
+      if ((row.reasoning_tokens ?? 0) > 0) ambiguousDimensions.add("reasoning");
+      if ((row.tool_tokens ?? 0) > 0) ambiguousDimensions.add("tool");
+    }
+    const providerReportedRows = metricRows.filter(
+      (row) => row.provider_reported_cost_usd !== null
+    );
+    const providerReportedUsd = providerReportedRows.length === metricRows.length ? providerReportedRows.reduce((sum, row) => sum + (row.provider_reported_cost_usd ?? 0), 0) : null;
+    const cost = coverageStatus === "complete" && rollup.api_equivalent_cost_usd !== null ? {
+      status: "available",
+      currency: "USD",
+      apiEquivalentUsd: rollup.api_equivalent_cost_usd,
+      providerReportedUsd
+    } : coverageStatus === "partial" ? {
+      status: "partial",
+      currency: "USD",
+      pricedInvocations: rollup.priced_count,
+      totalInvocations: rollup.invocation_count,
+      ...estimateComplete && rollup.api_equivalent_cost_usd !== null ? {
+        estimatedApiEquivalentUsd: rollup.api_equivalent_cost_usd,
+        partialPricedInvocations: partialPriced
+      } : rollup.api_equivalent_cost_usd !== null ? {
+        knownApiEquivalentUsd: rollup.api_equivalent_cost_usd,
+        knownAmountInvocations: rollup.priced_count + partialPriced
+      } : {}
+    } : {
+      status: "unavailable",
+      currency: "USD",
+      reason: coverageStatus === "complete" ? "seat_licensed" : "pricing_unavailable"
+    };
+    const models = this.readModels(selectedWhereFor("v."), selectedParams);
+    return {
+      receiptVersion: 1,
+      projectId: rollup.project_id,
+      labId: rollup.lab_id,
+      labRunId: rollup.lab_run_id,
+      taskId: rollup.task_id,
+      runId: rollup.run_id,
+      duration: {
+        wallMs,
+        providerBusyMs,
+        providerSumMs: rollup.provider_sum_ms
+      },
+      usage: {
+        status: usageStatus,
+        inputTokens: rollup.input_tokens,
+        outputTokens: rollup.output_tokens,
+        cacheReadTokens: rollup.cache_read_tokens,
+        cacheWriteTokens: rollup.cache_write_tokens,
+        reasoningTokens: rollup.reasoning_tokens,
+        toolTokens: rollup.tool_tokens,
+        billableTokens: usageStatus === "available" ? billableTokens : null,
+        ambiguousDimensions: [...ambiguousDimensions]
+      },
+      cost,
+      ...models.length > 0 ? { models } : {},
+      coverage: {
+        invocations: rollup.invocation_count,
+        usageReportedInvocations: rollup.usage_reported_count,
+        pricedInvocations: rollup.priced_count,
+        ...seatLicensed > 0 ? { seatLicensedInvocations: seatLicensed } : {},
+        ...partialPriced > 0 ? { partialPricedInvocations: partialPriced } : {},
+        status: coverageStatus
+      }
+    };
+  }
+  readModels(where, params) {
+    const rows = this.invocations.db.prepare(
+      `SELECT i.provider_id, i.model_id, i.requested_model_id, i.execution_model_id,
+                i.reported_model_id, v.availability_json
+         FROM invocation_metrics_v v
+         JOIN model_invocations i ON i.id = v.invocation_id
+         WHERE ${where}`
+    ).all(...params);
+    const byModel = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const executedModel = row.reported_model_id || row.execution_model_id || row.model_id;
+      const requested = row.requested_model_id || row.model_id;
+      const key = `${row.provider_id}\0${executedModel}\0${requested}`;
+      const contextWindow = readContextWindow(row.availability_json);
+      const entry = byModel.get(key);
+      if (entry) {
+        entry.invocations += 1;
+        if (entry.contextWindow === void 0 && contextWindow !== void 0) {
+          entry.contextWindow = contextWindow;
+        }
+        continue;
+      }
+      byModel.set(key, {
+        provider: row.provider_id,
+        executedModel,
+        ...requested !== executedModel ? { requestedModel: requested } : {},
+        ...contextWindow !== void 0 ? { contextWindow } : {},
+        invocations: 1
+      });
+    }
+    return [...byModel.values()].sort((a, b) => b.invocations - a.invocations);
+  }
+  readWallDurationMs(input) {
+    if (!this.variantsDb || !input.projectId || input.runId) return null;
+    try {
+      const labWhere = input.labId ? "lab_id = ? AND lab_run_id IS ?" : "lab_id IS NULL";
+      const params = [input.projectId, input.taskId];
+      if (input.labId) params.push(input.labId, input.labRunId);
+      const row = this.variantsDb.prepare(
+        `SELECT started_at, completed_at
+           FROM competition_runs_v2
+           WHERE project_id = ? AND task_id = ? AND ${labWhere}
+           ORDER BY started_at DESC LIMIT 1`
+      ).get(...params);
+      if (!row?.completed_at) return null;
+      const start = Date.parse(row.started_at);
+      const end = Date.parse(row.completed_at);
+      return Number.isFinite(start) && Number.isFinite(end) ? Math.max(0, end - start) : null;
+    } catch {
+      return null;
+    }
+  }
+};
+function loadTaskReport(input) {
+  const invocations = new ModelInvocationsDB(resolveInvocationsDbPath(input.buildDir));
+  try {
+    return new TaskReportService(invocations, input.variantsDb).getTaskReport({
+      ...input.taskId !== void 0 ? { taskId: input.taskId } : {},
+      ...input.runId ? { runId: input.runId } : {},
+      ...input.projectId ? { projectId: input.projectId } : {},
+      ...input.labId ? { labId: input.labId } : {},
+      ...input.labRunId ? { labRunId: input.labRunId } : {}
+    });
+  } finally {
+    invocations.close();
+  }
+}
+
+export {
+  TaskReportService,
+  loadTaskReport
+};
+//# sourceMappingURL=chunk-NUO7B3SH.js.map