@gleapai/kai-bridge 0.2.0

package/runner/lib/acp/transcripts.mjs

@@ -0,0 +1,238 @@
+// Per-request token usage from the harness's OWN transcript.
+//
+// ACP's `usage_update` is a context gauge (`used`/`size`) plus the
+// native CLI's cost figure — it carries no per-model
+// input / cache-read / cache-write / output split, and Kai Code bills
+// gateway models from exactly that split (registry `modelPricing`).
+// Every harness persists it though: Claude Code writes one JSONL line
+// per streamed assistant message (with `usage` + `model`) under
+// `<CLAUDE_CONFIG_DIR>/projects/<cwd-slug>/<sessionId>.jsonl`; Codex
+// writes `token_count` events into its rollout JSONL under
+// `<CODEX_HOME>/sessions/…/rollout-*-<threadId>.jsonl`. Reading those
+// after the turn gives billing parity with the stream-json runners
+// without forking the adapters.
+//
+// Pure parsers + thin fs locators; tests feed strings.
+
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+const num = (v) => (typeof v === "number" && Number.isFinite(v) && v > 0 ? v : 0);
+
+/**
+ * Claude Code project slug: the cwd with every `/` and `.` replaced by
+ * `-` (verified against 2.1.x: `/home/user/repos` → `-home-user-repos`).
+ */
+export function claudeProjectSlug(cwd) {
+  return String(cwd || "").replace(/[/.]/g, "-");
+}
+
+export function claudeTranscriptPath(configDir, cwd, sessionId) {
+  return join(configDir, "projects", claudeProjectSlug(cwd), `${sessionId}.jsonl`);
+}
+
+/**
+ * Parse a Claude Code session JSONL into per-request usage rows.
+ *
+ * Streaming writes several lines per assistant message (one per content
+ * block) that all repeat the SAME `message.id` + `usage`; keep one row
+ * per id (the last wins — it carries the final output count). Rows are
+ * returned in file order; `sinceTs` (ISO / epoch ms) drops earlier
+ * turns so a resume only bills the new requests.
+ */
+export function parseClaudeTranscript(text, { sinceTs } = {}) {
+  const since = sinceTs ? new Date(sinceTs).getTime() : 0;
+  const byId = new Map();
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    let obj;
+    try {
+      obj = JSON.parse(t);
+    } catch {
+      continue;
+    }
+    if (obj?.type !== "assistant" || !obj.message || typeof obj.message !== "object") continue;
+    const ts = obj.timestamp ? new Date(obj.timestamp).getTime() : 0;
+    if (since && ts && ts < since) continue;
+    const usage = obj.message.usage ?? {};
+    const id = String(obj.message.id ?? obj.uuid ?? byId.size);
+    byId.set(id, {
+      id,
+      model: String(obj.message.model ?? ""),
+      inputTokens: num(usage.input_tokens),
+      cachedInputTokens: num(usage.cache_read_input_tokens),
+      cacheWriteInputTokens: num(usage.cache_creation_input_tokens),
+      outputTokens: num(usage.output_tokens),
+      // `isSidechain` marks subagent transcripts; parentUuid chains the
+      // root. Kept so callers can pick the ROOT context snapshot.
+      sidechain: obj.isSidechain === true,
+      timestamp: ts || null,
+    });
+  }
+  return [...byId.values()];
+}
+
+/** Aggregate rows per model in the runner tracker's shape. */
+export function aggregateUsageRows(rows) {
+  const byModel = new Map();
+  for (const r of rows) {
+    if (!r.model) continue;
+    const t = byModel.get(r.model) ?? {
+      model: r.model,
+      inputTokens: 0,
+      cachedInputTokens: 0,
+      cacheWriteInputTokens: 0,
+      outputTokens: 0,
+      requests: 0,
+    };
+    t.inputTokens += r.inputTokens;
+    t.cachedInputTokens += r.cachedInputTokens;
+    t.cacheWriteInputTokens += r.cacheWriteInputTokens;
+    t.outputTokens += r.outputTokens;
+    t.requests += 1;
+    byModel.set(r.model, t);
+  }
+  return [...byModel.values()];
+}
+
+/**
+ * Context occupancy of the LAST root request = fresh + cache read +
+ * cache write of that single request (Anthropic's `input_tokens`
+ * excludes the cache buckets). Mirrors `noteContextSnapshot` in the
+ * claude runner.
+ */
+export function lastRootContextSnapshot(rows) {
+  for (let i = rows.length - 1; i >= 0; i--) {
+    const r = rows[i];
+    if (r.sidechain) continue;
+    const tokens = r.inputTokens + r.cachedInputTokens + r.cacheWriteInputTokens;
+    if (tokens > 0) return { model: r.model, tokens };
+  }
+  return null;
+}
+
+/**
+ * Locate the session transcript. The CLI keys the project dir by the
+ * REAL path of cwd (`/private/var/…` on macOS for a `/var/…` tmpdir), so
+ * try the path as given, its realpath, and finally any project dir that
+ * holds `<sessionId>.jsonl` (session ids are unique per config dir).
+ */
+export function findClaudeTranscript(configDir, cwd, sessionId) {
+  const candidates = [cwd];
+  try {
+    const real = realpathSync(cwd);
+    if (real !== cwd) candidates.push(real);
+  } catch {
+    /* cwd gone */
+  }
+  for (const c of candidates) {
+    const p = claudeTranscriptPath(configDir, c, sessionId);
+    if (existsSync(p)) return p;
+  }
+  const projects = join(configDir, "projects");
+  try {
+    for (const dir of readdirSync(projects)) {
+      const p = join(projects, dir, `${sessionId}.jsonl`);
+      if (existsSync(p)) return p;
+    }
+  } catch {
+    /* no projects dir yet */
+  }
+  return null;
+}
+
+export function readClaudeTurnUsage({ configDir, cwd, sessionId, sinceTs }) {
+  const path = findClaudeTranscript(configDir, cwd, sessionId);
+  if (!path) return { path: claudeTranscriptPath(configDir, cwd, sessionId), rows: [] };
+  return { path, rows: parseClaudeTranscript(readFileSync(path, "utf8"), { sinceTs }) };
+}
+
+// ── Codex ──────────────────────────────────────────────────────────────
+
+/**
+ * Codex rollout `token_count` events report `last_token_usage` (the
+ * most recent request) and a running `total_token_usage`. The per-
+ * request rows are the `last_token_usage` deltas; `cached_input_tokens`
+ * is INCLUDED in `input_tokens` (OpenAI convention — the tracker treats
+ * `inputTokens` as cache-inclusive too, so pass it through unchanged).
+ */
+export function parseCodexRollout(text, { sinceTs, model } = {}) {
+  const since = sinceTs ? new Date(sinceTs).getTime() : 0;
+  const rows = [];
+  let contextWindow = null;
+  let activeModel = model || "";
+  for (const line of String(text || "").split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    let obj;
+    try {
+      obj = JSON.parse(t);
+    } catch {
+      continue;
+    }
+    const ts = obj.timestamp ? new Date(obj.timestamp).getTime() : 0;
+    if (obj.type === "turn_context" && obj.payload?.model) {
+      activeModel = String(obj.payload.model);
+      continue;
+    }
+    if (obj.type !== "event_msg" || obj.payload?.type !== "token_count") continue;
+    if (since && ts && ts < since) continue;
+    const info = obj.payload.info ?? {};
+    const last = info.last_token_usage ?? {};
+    if (typeof info.model_context_window === "number" && info.model_context_window > 0) {
+      contextWindow = info.model_context_window;
+    }
+    const input = num(last.input_tokens);
+    if (input <= 0 && num(last.output_tokens) <= 0) continue;
+    rows.push({
+      id: `${ts || rows.length}`,
+      model: activeModel,
+      inputTokens: input,
+      cachedInputTokens: num(last.cached_input_tokens),
+      cacheWriteInputTokens: 0,
+      outputTokens: num(last.output_tokens) + num(last.reasoning_output_tokens),
+      sidechain: false,
+      timestamp: ts || null,
+    });
+  }
+  return { rows, contextWindow };
+}
+
+/** Newest rollout file for a thread id under CODEX_HOME/sessions. */
+export function findCodexRollout(codexHome, threadId) {
+  const root = join(codexHome, "sessions");
+  if (!existsSync(root)) return null;
+  let best = null;
+  const walk = (dir, depth) => {
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      const p = join(dir, name);
+      let st;
+      try {
+        st = statSync(p);
+      } catch {
+        continue;
+      }
+      if (st.isDirectory()) {
+        if (depth < 4) walk(p, depth + 1);
+      } else if (name.startsWith("rollout-") && name.endsWith(".jsonl") && name.includes(threadId)) {
+        if (!best || st.mtimeMs > best.mtimeMs) best = { path: p, mtimeMs: st.mtimeMs };
+      }
+    }
+  };
+  walk(root, 0);
+  return best?.path ?? null;
+}
+
+export function readCodexTurnUsage({ codexHome, threadId, sinceTs, model }) {
+  const path = findCodexRollout(codexHome, threadId);
+  if (!path) return { path: null, rows: [], contextWindow: null };
+  const parsed = parseCodexRollout(readFileSync(path, "utf8"), { sinceTs, model });
+  return { path, ...parsed };
+}