portable-agent-layer 0.97.0 → 0.98.0

package/src/tools/lib/backfill/git.ts

@@ -0,0 +1,184 @@
+/**
+ * Every commit that still exists in a registered project's repository, as a
+ * commit event whose id is its hash. Names, emails and the subject are text,
+ * so they go to the content store; the event keeps counts and flags.
+ */
+
+import { spawnSync } from "node:child_process";
+import { appendEvent } from "../../../hooks/lib/events";
+import { PAL_REPO_URL } from "../../../hooks/lib/remote";
+
+const RECORD = "\x1e";
+const FIELD = "\x1f";
+const FORMAT = [
+  "%H",
+  "%aI",
+  "%cI",
+  "%an",
+  "%ae",
+  "%cn",
+  "%ce",
+  "%D",
+  "%P",
+  "%s",
+  "%b",
+  "",
+]
+  .join(FIELD)
+  .replace(/^/, RECORD);
+const AI_CO_AUTHOR = new RegExp(
+  String.raw`noreply@anthropic\.com|${PAL_REPO_URL.replace(/[.]/g, String.raw`\.`)}|copilot|cursor|openai|codex|gemini`,
+  "i"
+);
+const CONVENTIONAL = /^(\w+)(\([^)]*\))?(!)?:/;
+
+interface Commit {
+  hash: string;
+  authoredAt: string;
+  committedAt: string;
+  author: string;
+  authorEmail: string;
+  committer: string;
+  committerEmail: string;
+  subject: string;
+  files: number;
+  added: number;
+  deleted: number;
+  commitType: string | null;
+  breaking: boolean;
+  revert: boolean;
+  merge: boolean;
+  tags: string[];
+  coAuthors: number;
+  aiCoAuthored: boolean;
+}
+
+function gitLog(repo: string, since: string | undefined): string | null {
+  const args = [
+    "-C",
+    repo,
+    "log",
+    "--branches",
+    "--tags",
+    "--remotes",
+    "--numstat",
+    `--format=${FORMAT}`,
+  ];
+  if (since) args.push(`--since=${since}`);
+  const result = spawnSync("git", args, {
+    encoding: "utf-8",
+    maxBuffer: 256 * 1024 * 1024,
+  });
+  return result.status === 0 ? result.stdout : null;
+}
+
+function numstatOf(text: string) {
+  const rows = text
+    .split("\n")
+    .map((line) => line.split("\t"))
+    .filter((cells) => cells.length === 3);
+  const count = (cell: string) => (cell === "-" ? 0 : Number(cell));
+  return {
+    files: rows.length,
+    added: rows.reduce((sum, [added]) => sum + count(added), 0),
+    deleted: rows.reduce((sum, [, deleted]) => sum + count(deleted), 0),
+  };
+}
+
+function coAuthorLines(body: string): string[] {
+  return body.split("\n").filter((line) => /^co-authored[- ]by\b/i.test(line.trim()));
+}
+
+function tagsOf(refs: string): string[] {
+  return refs
+    .split(", ")
+    .filter((ref) => ref.startsWith("tag: "))
+    .map((ref) => ref.slice("tag: ".length));
+}
+
+function commitOf(record: string): Commit | null {
+  const [hash, aI, cI, an, ae, cn, ce, refs, parents, subject, body, numstat] =
+    record.split(FIELD);
+  if (!hash || !aI || !cI) return null;
+  const conventional = CONVENTIONAL.exec(subject ?? "");
+  const coAuthors = coAuthorLines(body ?? "");
+  return {
+    hash,
+    authoredAt: new Date(aI).toISOString(),
+    committedAt: new Date(cI).toISOString(),
+    author: an ?? "",
+    authorEmail: ae ?? "",
+    committer: cn ?? "",
+    committerEmail: ce ?? "",
+    subject: subject ?? "",
+    ...numstatOf(numstat ?? ""),
+    commitType: conventional?.[1] ?? null,
+    breaking: !!conventional?.[3] || /^BREAKING CHANGE:/m.test(body ?? ""),
+    revert: conventional?.[1] === "revert" || (subject ?? "").startsWith("Revert "),
+    merge: (parents ?? "").trim().split(" ").length > 1,
+    tags: tagsOf(refs ?? ""),
+    coAuthors: coAuthors.length,
+    aiCoAuthored: coAuthors.some((line) => AI_CO_AUTHOR.test(line)),
+  };
+}
+
+function readCommits(repo: string, since?: string): Commit[] {
+  const log = gitLog(repo, since);
+  if (log === null) return [];
+  return log
+    .split(RECORD)
+    .map(commitOf)
+    .filter((commit): commit is Commit => commit !== null);
+}
+
+const commitEventId = (hash: string) => `git:${hash}`;
+
+function emitCommit(repo: string, commit: Commit): void {
+  appendEvent(
+    "commit",
+    {
+      hash: commit.hash,
+      committedAt: commit.committedAt,
+      files: commit.files,
+      added: commit.added,
+      deleted: commit.deleted,
+      commitType: commit.commitType,
+      breaking: commit.breaking,
+      revert: commit.revert,
+      merge: commit.merge,
+      tags: commit.tags,
+      coAuthors: commit.coAuthors,
+      aiCoAuthored: commit.aiCoAuthored,
+    },
+    {
+      id: commitEventId(commit.hash),
+      ts: commit.authoredAt,
+      session: null,
+      runtime: "git",
+      channel: null,
+      cwd: repo,
+      content: {
+        author: commit.author,
+        authorEmail: commit.authorEmail,
+        committer: commit.committer,
+        committerEmail: commit.committerEmail,
+        subject: commit.subject,
+      },
+    }
+  );
+}
+
+/** Appends the commits not yet logged and returns how many. */
+export function backfillGit(repos: string[], known: Set<string>, since?: string): number {
+  let emitted = 0;
+  for (const repo of repos) {
+    for (const commit of readCommits(repo, since)) {
+      const id = commitEventId(commit.hash);
+      if (known.has(id)) continue;
+      known.add(id);
+      emitCommit(repo, commit);
+      emitted++;
+    }
+  }
+  return emitted;
+}

package/src/tools/lib/backfill/index.ts

@@ -0,0 +1,32 @@
+/**
+ * Everything that still exists, read into the event log once. Every event's id
+ * comes from its source's own id, so a second run appends nothing.
+ */
+
+import { loggedEventIds } from "../../../hooks/lib/events";
+import { readAllProjects } from "../../../hooks/lib/projects";
+import { eventLogEnabled } from "../../../hooks/lib/settings";
+import { backfillGit } from "./git";
+import { backfillLedger } from "./ledger";
+import { backfillRatings } from "./ratings";
+import { backfillSessions } from "./sessions";
+import { backfillTurns } from "./turns";
+
+function projectRepos(): string[] {
+  const paths = readAllProjects().flatMap((project) =>
+    project.path ? [project.path] : []
+  );
+  return [...new Set(paths)];
+}
+
+export function backfillEvents(since?: string): Record<string, number> {
+  if (!eventLogEnabled()) return {};
+  const known = loggedEventIds();
+  return {
+    git: backfillGit(projectRepos(), known, since),
+    sessions: backfillSessions(since),
+    turns: backfillTurns(known, since),
+    ratings: backfillRatings(known, since),
+    ledger: backfillLedger(known, since),
+  };
+}

package/src/tools/lib/backfill/ledger.ts

@@ -0,0 +1,28 @@
+/**
+ * Every ledger entry, as the action event it would have streamed. Rows the
+ * test suite leaked into the real ledger before it was sandboxed are left out.
+ */
+
+import {
+  actionEventId,
+  type LedgerEntry,
+  logActionEvent,
+} from "../../../hooks/lib/ledger";
+import { readLedger } from "../../ledger/query";
+import { emitUnseen, recordedAttribution } from "./rows";
+
+const SUITE_SANDBOXED_AT = "2026-09-23T14:35:01.000Z";
+
+function leakedFromTestSuite(entry: LedgerEntry): boolean {
+  return entry.command === "rm -rf /" && entry.ts < SUITE_SANDBOXED_AT;
+}
+
+function emitAction(entry: LedgerEntry): void {
+  logActionEvent(entry, recordedAttribution(entry));
+}
+
+/** Appends the ledger entries not yet logged and returns how many. */
+export function backfillLedger(known: Set<string>, since?: string): number {
+  const entries = readLedger().filter((entry) => !leakedFromTestSuite(entry));
+  return emitUnseen(entries, actionEventId, emitAction, known, since);
+}

package/src/tools/lib/backfill/ratings.ts

@@ -0,0 +1,21 @@
+/**
+ * Every rating in the signals file, as a rating event. The rated context and
+ * the reply preview are text, so they go to the content store.
+ */
+
+import {
+  logRatingEvent,
+  type RatingSignal,
+  ratingEventId,
+  readRatings,
+} from "../../../hooks/lib/signals";
+import { emitUnseen, recordedAttribution } from "./rows";
+
+function emitRating(row: RatingSignal): void {
+  logRatingEvent(row, { cwd: "", attribution: recordedAttribution(row) });
+}
+
+/** Appends the ratings not yet logged and returns how many. */
+export function backfillRatings(known: Set<string>, since?: string): number {
+  return emitUnseen(readRatings(), ratingEventId, emitRating, known, since);
+}

package/src/tools/lib/backfill/rows.ts

@@ -0,0 +1,33 @@
+import type { RecordAttribution } from "../../../hooks/lib/actor";
+
+export type AttributedRow = Partial<RecordAttribution> & { ts: string };
+
+/** The origin a row was written with; a field it never carried is unknown, not this machine's. */
+export function recordedAttribution(row: AttributedRow): Partial<RecordAttribution> {
+  return {
+    machine: row.machine ?? "unknown",
+    actor: row.actor ?? "unknown",
+    runtime: row.runtime ?? "unknown",
+    ...(row.authority && { authority: row.authority }),
+  };
+}
+
+/** Emits each row whose id is not logged yet and that falls on or after `since`; returns how many. */
+export function emitUnseen<Row extends AttributedRow>(
+  rows: Row[],
+  idOf: (row: Row) => string,
+  emit: (row: Row, id: string) => void,
+  known: Set<string>,
+  since?: string
+): number {
+  const from = new Date(since ?? 0).toISOString();
+  let emitted = 0;
+  for (const row of rows) {
+    const id = idOf(row);
+    if (known.has(id) || row.ts < from) continue;
+    known.add(id);
+    emit(row, id);
+    emitted++;
+  }
+  return emitted;
+}

package/src/tools/lib/backfill/sessions.ts

@@ -0,0 +1,56 @@
+/**
+ * Every session PAL still has a record of, as the session_end it would have
+ * logged. A record is the session's last known state, so it carries no reason,
+ * duration or turn count; its name, summary and handoff are text and go to the
+ * content store.
+ */
+
+import { appendEvent, eventsSince } from "../../../hooks/lib/events";
+import { readSessionHistory, type SessionRecord } from "../../../hooks/lib/work-tracking";
+
+const sessionEventId = (sessionId: string) => `session:${sessionId}`;
+
+function endedSessions(): Set<string> {
+  return new Set(
+    eventsSince("session_end", new Date(0)).flatMap((e) => (e.session ? [e.session] : []))
+  );
+}
+
+function emitSession(record: SessionRecord): void {
+  appendEvent(
+    "session_end",
+    {
+      reason: "backfill",
+      durationSec: null,
+      turns: null,
+      messages: record.messageCount,
+      status: record.status,
+    },
+    {
+      id: sessionEventId(record.sessionId),
+      ts: record.ts,
+      session: record.sessionId,
+      runtime: "unknown",
+      channel: null,
+      cwd: record.cwd,
+      content: {
+        name: record.name,
+        summary: record.summary,
+        handoff: record.handoff,
+        artifacts: record.artifacts,
+      },
+    }
+  );
+}
+
+/** Appends the sessions with no session_end yet and returns how many. */
+export function backfillSessions(since?: string): number {
+  const ended = endedSessions();
+  const fresh = readSessionHistory().filter(
+    (record) =>
+      !ended.has(record.sessionId) &&
+      (!since || record.ts >= new Date(since).toISOString())
+  );
+  for (const record of fresh) emitSession(record);
+  return fresh.length;
+}

package/src/tools/lib/backfill/turns.ts

@@ -0,0 +1,32 @@
+/**
+ * Every turn measured before turns streamed into the event log. A row keeps
+ * the machine, actor and runtime it was written with, since an imported file
+ * holds other machines' rows too.
+ */
+
+import { appendEvent } from "../../../hooks/lib/events";
+import {
+  legacyTurnId,
+  legacyTurns,
+  type TurnEvent,
+} from "../../../hooks/lib/interaction";
+import { type AttributedRow, emitUnseen, recordedAttribution } from "./rows";
+
+type LegacyTurn = TurnEvent & AttributedRow;
+
+function emitTurn(turn: LegacyTurn, id: string): void {
+  const { ts, session, channel, ...fields } = turn;
+  appendEvent("turn", fields, {
+    id,
+    ts,
+    session,
+    channel: channel ?? null,
+    cwd: "",
+    attribution: recordedAttribution(turn),
+  });
+}
+
+/** Appends the legacy turns not yet logged and returns how many. */
+export function backfillTurns(known: Set<string>, since?: string): number {
+  return emitUnseen(legacyTurns() as LegacyTurn[], legacyTurnId, emitTurn, known, since);
+}

package/src/tools/lib/collectors/billing.ts

@@ -0,0 +1,105 @@
+/**
+ * How each agent's model calls are paid for: a subscription, an API key, or
+ * unknown. Each reader takes the few fields that say so and nothing else from
+ * files that also hold the agent's credentials.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { platform } from "../../../hooks/lib/paths";
+
+export interface Billing {
+  billing: "subscription" | "api" | "unknown";
+  plan: string | null;
+  extraUsage: boolean | null;
+}
+
+export const UNKNOWN: Billing = { billing: "unknown", plan: null, extraUsage: null };
+const API: Billing = { billing: "api", plan: null, extraUsage: null };
+const SUBSCRIPTION: Billing = { billing: "subscription", plan: null, extraUsage: null };
+
+type Json = Record<string, unknown>;
+
+function readJson(path: string): Json {
+  try {
+    return existsSync(path) ? JSON.parse(readFileSync(path, "utf-8")) : {};
+  } catch {
+    return {};
+  }
+}
+
+function stringField(record: unknown, name: string): string | null {
+  const value = (record as Json | undefined)?.[name];
+  return typeof value === "string" ? value : null;
+}
+
+function booleanField(record: unknown, name: string): boolean | null {
+  const value = (record as Json | undefined)?.[name];
+  return typeof value === "boolean" ? value : null;
+}
+
+interface ClaudeSubscription {
+  plan: string | null;
+  extraUsage: boolean | null;
+  since: number;
+}
+
+function claudeSubscriptionOf(config: Json): ClaudeSubscription | null {
+  const account = config.oauthAccount;
+  if (!stringField(account, "billingType")) return null;
+  return {
+    plan:
+      stringField(account, "organizationRateLimitTier") ??
+      stringField(account, "organizationType"),
+    extraUsage: booleanField(account, "hasExtraUsageEnabled"),
+    since: Date.parse(stringField(account, "subscriptionCreatedAt") ?? ""),
+  };
+}
+
+export function claudeConfigFile(): string {
+  return resolve(dirname(platform.claudeDir()), ".claude.json");
+}
+
+/** Billing for a call at `at`; a call older than the subscription is unknown. */
+export function claudeBilling(configPath: string): (at: string) => Billing {
+  const config = readJson(configPath);
+  const subscription = claudeSubscriptionOf(config);
+  const apiKeyLogin = "primaryApiKey" in config;
+  return (at) => {
+    if (!subscription) return apiKeyLogin ? API : UNKNOWN;
+    if (Date.parse(at) < subscription.since) return UNKNOWN;
+    return {
+      billing: "subscription",
+      plan: subscription.plan,
+      extraUsage: subscription.extraUsage,
+    };
+  };
+}
+
+const CODEX_AUTH_MODES: Record<string, Billing> = { apikey: API, chatgpt: SUBSCRIPTION };
+
+export function codexBilling(authPath: string): Billing {
+  return CODEX_AUTH_MODES[stringField(readJson(authPath), "auth_mode") ?? ""] ?? UNKNOWN;
+}
+
+const OPENCODE_AUTH_TYPES: Record<string, Billing> = {
+  oauth: SUBSCRIPTION,
+  api: API,
+  wellknown: API,
+};
+
+/** Billing per provider, from the type of the login opencode holds for it. */
+export function opencodeBilling(
+  authPath: string
+): (provider: string | undefined) => Billing {
+  const logins = readJson(authPath);
+  const billingOf = new Map(
+    Object.entries(logins).map(([provider, login]) => [
+      provider,
+      OPENCODE_AUTH_TYPES[stringField(login, "type") ?? ""] ?? UNKNOWN,
+    ])
+  );
+  return (provider) => (provider && billingOf.get(provider)) || UNKNOWN;
+}
+
+export const COPILOT_BILLING = SUBSCRIPTION;

package/src/tools/lib/collectors/claude.ts

@@ -12,6 +12,7 @@ import { relative, sep } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
 import { cacheWritesOf, type TranscriptUsage } from "../transcript-usage";
 import { claudeTranscripts } from "../usage-buckets";
+import { type Billing, UNKNOWN } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 
 const SETTLE_MS = 5 * 60_000;
@@ -34,12 +35,14 @@ interface ClaudeLine {
   };
 }
 
+type ModelCallLine = ClaudeLine & { timestamp: string };
+
 interface SettledRead {
-  messages: ClaudeLine[];
+  messages: ModelCallLine[];
   resumeAt: number;
 }
 
-function isModelCall(line: ClaudeLine | null): line is ClaudeLine {
+function isModelCall(line: ClaudeLine | null): line is ModelCallLine {
   return (
     line?.type === "assistant" &&
     !!line.message?.usage &&
@@ -79,7 +82,7 @@ function settledMessages(
   settled: boolean
 ): SettledRead {
   const { lines, end } = completeLinesFrom(filepath, offset);
-  const groups = new Map<string, { start: number; line: ClaudeLine }>();
+  const groups = new Map<string, { start: number; line: ModelCallLine }>();
   let newest: string | undefined;
   for (const { text, start } of lines) {
     if (!text.includes('"usage"')) continue;
@@ -97,11 +100,12 @@ function settledMessages(
   };
 }
 
-function emitModelCall(line: ClaudeLine): void {
+function emitModelCall(line: ClaudeLine, billing: Billing): void {
   const usage = line.message?.usage ?? {};
   appendEvent(
     "model_call",
     {
+      ...billing,
       model: line.message?.model,
       requestedModel: line.requestedModel,
       inputTokens: usage.input_tokens,
@@ -132,7 +136,11 @@ function isSettled(filepath: string, now: Date): boolean {
   return now.getTime() - statSync(filepath).mtimeMs > SETTLE_MS;
 }
 
-export function collectClaude(projectsDir: string, now: Date = new Date()): number {
+export function collectClaude(
+  projectsDir: string,
+  now: Date = new Date(),
+  billingAt: (at: string) => Billing = () => UNKNOWN
+): number {
   const cursor = readCursor("claude");
   let emitted = 0;
   for (const filepath of claudeTranscripts(projectsDir)) {
@@ -140,7 +148,7 @@ export function collectClaude(projectsDir: string, now: Date = new Date()): numb
     const offset = Number(cursor[key] ?? 0);
     const read = settledMessages(filepath, offset, isSettled(filepath, now));
     if (read.resumeAt === offset) continue;
-    for (const line of read.messages) emitModelCall(line);
+    for (const line of read.messages) emitModelCall(line, billingAt(line.timestamp));
     emitted += read.messages.length;
     cursor[key] = read.resumeAt;
     writeCursor("claude", cursor);

package/src/tools/lib/collectors/codex.ts

@@ -5,9 +5,10 @@
  */
 
 import { readFileSync, statSync } from "node:fs";
-import { relative, sep } from "node:path";
+import { relative, resolve, sep } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
 import { codexRollouts } from "../agent-usage";
+import { type Billing, codexBilling } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 
 interface CodexUsage {
@@ -90,12 +91,13 @@ function callsOf(filepath: string): CodexCall[] {
   return calls;
 }
 
-function emitModelCall({ ts, usage, context }: CodexCall): void {
+function emitModelCall({ ts, usage, context }: CodexCall, billing: Billing): void {
   const cacheRead = usage.cached_input_tokens ?? 0;
   const cacheWrite = usage.cache_write_input_tokens ?? 0;
   appendEvent(
     "model_call",
     {
+      ...billing,
       model: context.model,
       provider: context.provider,
       inputTokens: (usage.input_tokens ?? 0) - cacheRead - cacheWrite,
@@ -111,6 +113,7 @@ function emitModelCall({ ts, usage, context }: CodexCall): void {
 
 export function collectCodex(codexDir: string): number {
   const cursor = readCursor("codex");
+  const billing = codexBilling(resolve(codexDir, "auth.json"));
   let emitted = 0;
   for (const filepath of codexRollouts(codexDir)) {
     const key = relative(codexDir, filepath).split(sep).join("/");
@@ -119,7 +122,7 @@ export function collectCodex(codexDir: string): number {
     const collectedTotal = Number(cursor[key] ?? -1);
     for (const call of callsOf(filepath)) {
       if (call.total <= collectedTotal) continue;
-      emitModelCall(call);
+      emitModelCall(call, billing);
       emitted++;
       cursor[key] = call.total;
     }

package/src/tools/lib/collectors/copilot.ts

@@ -7,6 +7,7 @@
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
+import { COPILOT_BILLING } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 import { type AllowList, selectAllowed } from "./sqlite";
 
@@ -66,6 +67,7 @@ function emitModelCall(row: UsageRow, session: SessionRow | undefined): void {
   appendEvent(
     "model_call",
     {
+      ...COPILOT_BILLING,
       model: row.model,
       inputTokens: num(row.input_tokens) - cacheRead,
       outputTokens: row.output_tokens,

package/src/tools/lib/collectors/index.ts

@@ -12,6 +12,7 @@ import { paths, platform } from "../../../hooks/lib/paths";
 import { eventLogEnabled } from "../../../hooks/lib/settings";
 import { opencodeDatabase } from "../agent-usage";
 import { antigravityDatabase, collectAntigravity } from "./antigravity";
+import { claudeBilling, claudeConfigFile } from "./billing";
 import { collectClaude } from "./claude";
 import { collectCodex } from "./codex";
 import { collectCopilot, copilotDatabase } from "./copilot";
@@ -20,7 +21,12 @@ import { collectOpencode } from "./opencode";
 const LOCK_STALE_MS = 10 * 60_000;
 
 const COLLECTORS: Record<string, () => number> = {
-  claude: () => collectClaude(resolve(platform.claudeDir(), "projects")),
+  claude: () =>
+    collectClaude(
+      resolve(platform.claudeDir(), "projects"),
+      new Date(),
+      claudeBilling(claudeConfigFile())
+    ),
   opencode: () => collectOpencode(opencodeDatabase()),
   codex: () => collectCodex(platform.codexDir()),
   copilot: () => collectCopilot(copilotDatabase(platform.copilotDir())),

package/src/tools/lib/collectors/opencode.ts

@@ -5,7 +5,9 @@
  */
 
 import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
 import { appendEvent } from "../../../hooks/lib/events";
+import { type Billing, opencodeBilling } from "./billing";
 import { readCursor, writeCursor } from "./cursors";
 import { type AllowList, selectAllowed } from "./sqlite";
 
@@ -57,11 +59,16 @@ function durationOf(message: AssistantMessage): number | undefined {
   return created && completed ? completed - created : undefined;
 }
 
-function emitModelCall(row: MessageRow, message: AssistantMessage): void {
+function emitModelCall(
+  row: MessageRow,
+  message: AssistantMessage,
+  billing: Billing
+): void {
   const tokens = message.tokens ?? {};
   appendEvent(
     "model_call",
     {
+      ...billing,
       model: message.modelID,
       provider: message.providerID,
       inputTokens: tokens.input,
@@ -99,12 +106,13 @@ export function collectOpencode(dbPath: string, now: Date = new Date()): number
       id: String(cursor.id ?? ""),
     }
   );
+  const billingOf = opencodeBilling(resolve(dirname(dbPath), "auth.json"));
   let emitted = 0;
   for (const row of rows) {
     const message = assistantMessageOf(row);
     if (message && stillStreaming(message, row, now)) break;
     if (message) {
-      emitModelCall(row, message);
+      emitModelCall(row, message, billingOf(message.providerID));
       emitted++;
     }
     cursor.order = row.time_created;