modelmeter-collect 0.3.0 → 0.4.0

package/collect.mjs

@@ -86,6 +86,9 @@ function recentFiles(dir, limit = Infinity) {
 }
 
 const events = []
+// Codex tool attribution is computed per session (its token accounting is periodic,
+// not per-turn), so it is collected here and folded into the tool aggregation later.
+const codexToolDeltas = []
 
 // --- Claude Code: assistant turns carry message.usage; dedup by message uuid.
 function scanClaude(files) {
@@ -143,14 +146,30 @@ function findLastTokenCount(obj) {
   }
   return last
 }
+// Codex tool names are plain (exec_command, apply_patch, ...); MCP calls carry an
+// invocation with a server name. Returns a group key, or null if not a tool call.
+function codexToolFromEvent(payload, ptype) {
+  if (ptype === 'function_call' || ptype === 'custom_tool_call') {
+    return typeof payload.name === 'string' && payload.name ? payload.name : null
+  }
+  if (ptype === 'mcp_tool_call_end' || ptype === 'mcp_tool_call_begin') {
+    const inv = payload.invocation || {}
+    const server = inv.server || inv.server_name
+    return server ? `mcp:${server}` : 'mcp'
+  }
+  return null
+}
+
 function scanCodex(files) {
   for (const file of files) {
     const m = file.match(/rollout-(\d{4}-\d{2}-\d{2})T[\d-]+-([0-9a-f-]+)\.jsonl$/)
     if (!m) continue
-    const date = m[1]
     const sessionId = m[2]
     let totals = null
+    let totalsTs = null // timestamp of the latest token_count event, for the 5-hour window
+    let maxTs = ''
     let model = 'gpt-5'
+    const toolCalls = [] // { ts, group }
     let text = ''
     try {
       text = readFileSync(file, 'utf8')
@@ -165,34 +184,63 @@ function scanCodex(files) {
       } catch {
         continue
       }
-      const t = findLastTokenCount(o)
-      if (t) totals = t
+      const ts = typeof o.timestamp === 'string' ? o.timestamp : null
+      if (ts && ts > maxTs) maxTs = ts
+      const p = o.payload || o
+      const ptype = p.type || o.type
       if (typeof o.model === 'string') model = o.model
-      else if (typeof o.payload?.model === 'string') model = o.payload.model
+      else if (typeof p.model === 'string') model = p.model
+      const tc = findLastTokenCount(o)
+      if (tc) {
+        totals = tc
+        if (ts) totalsTs = ts
+      }
+      const g = codexToolFromEvent(p, ptype)
+      if (g) toolCalls.push({ ts: ts || totalsTs || '', group: g })
     }
     if (!totals) continue
-    const prev = state.codex[sessionId] || {
-      input_tokens: 0,
-      cached_input_tokens: 0,
-      output_tokens: 0,
-      reasoning_output_tokens: 0,
-    }
-    const dInput = Math.max(0, (totals.input_tokens || 0) - prev.input_tokens)
-    const dCached = Math.max(0, (totals.cached_input_tokens || 0) - prev.cached_input_tokens)
-    const dOut = Math.max(0, (totals.output_tokens || 0) - prev.output_tokens)
-    const dReason = Math.max(0, (totals.reasoning_output_tokens || 0) - prev.reasoning_output_tokens)
+    const stored = state.codex[sessionId]
+    const prevTotal =
+      (stored && stored.total) ||
+      (stored && stored.input_tokens != null ? stored : null) || {
+        input_tokens: 0,
+        cached_input_tokens: 0,
+        output_tokens: 0,
+        reasoning_output_tokens: 0,
+      }
+    const prevLastTs = (stored && stored.lastTs) || ''
+    const dInput = Math.max(0, (totals.input_tokens || 0) - prevTotal.input_tokens)
+    const dCached = Math.max(0, (totals.cached_input_tokens || 0) - prevTotal.cached_input_tokens)
+    const dOut = Math.max(0, (totals.output_tokens || 0) - prevTotal.output_tokens)
+    const dReason = Math.max(0, (totals.reasoning_output_tokens || 0) - prevTotal.reasoning_output_tokens)
+    const newTotalTokens = Math.max(0, dInput - dCached) + dCached + (dOut + dReason)
     if (dInput + dCached + dOut + dReason > 0) {
+      const occurredOn = (totalsTs || '').slice(0, 10) || m[1]
       events.push({
         provider: 'openai',
         model,
-        occurredOn: date,
+        occurredOn,
+        occurredAt: totalsTs || undefined, // enables the 5-hour window for Codex
         uncachedInputTokens: Math.max(0, dInput - dCached),
         cacheReadInputTokens: dCached,
         cacheCreationInputTokens: 0,
         outputTokens: dOut + dReason, // reasoning tokens bill as output
         numRequests: 1,
       })
-      state.codex[sessionId] = totals
+      // Tool calls new since the last run; even-split this run's new tokens across them.
+      const newCalls = toolCalls.filter((c) => c.ts && c.ts > prevLastTs)
+      if (newCalls.length > 0 && newTotalTokens > 0) {
+        const share = Math.round(newTotalTokens / newCalls.length)
+        for (const c of newCalls) {
+          codexToolDeltas.push({
+            tool: c.group,
+            bucketDate: (c.ts || '').slice(0, 10) || occurredOn,
+            calls: 1,
+            tokens: share,
+          })
+        }
+      }
+      state.codex[sessionId] = { total: totals, lastTs: maxTs }
     }
   }
 }
@@ -299,6 +347,13 @@ for (const e of events) {
     byTool.set(key, cur)
   }
 }
+for (const d of codexToolDeltas) {
+  const key = `${d.tool}|${d.bucketDate}`
+  const cur = byTool.get(key) || { tool: d.tool, bucketDate: d.bucketDate, calls: 0, tokens: 0 }
+  cur.calls += d.calls
+  cur.tokens += d.tokens
+  byTool.set(key, cur)
+}
 const toolsPayload = [...byTool.values()]
 
 if (payload.length === 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmeter-collect",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Report LLM token usage from local Claude Code / Codex logs to ModelMeter. Token counts only, never prompts or keys.",
   "type": "module",
   "bin": {