mixdog 0.9.52 → 0.9.53

package/src/runtime/memory/lib/pg/supervisor.mjs

@@ -341,10 +341,6 @@ function patchActiveInstance(fields, opts = {}) {
 
 // ── postmaster.pid helpers ───────────────────────────────────────────────────
 
-function readPostmasterPid(pgdata) {
-  return readPostmasterInfo(pgdata).pid;
-}
-
 function readPostmasterInfo(pgdata) {
   try {
     const raw = readFileSync(join(pgdata, 'postmaster.pid'), 'utf8');

package/src/runtime/memory/lib/query-handlers.mjs

@@ -24,8 +24,8 @@ import { searchRelevantHybrid } from './memory-recall-store.mjs'
 import { fetchEntriesByIdsScoped } from './memory-recall-id-patch.mjs'
 import { retrieveEntries } from './memory-retrievers.mjs'
 import { buildPromotedExclusionClauses } from './memory-recall-scope-filter.mjs'
-import { cleanMemoryText } from './memory.mjs'
 import { insertTraceEvents } from './trace-store.mjs'
+import { createQueryMaintenanceHandlers } from './query-maintenance-handlers.mjs'
 import {
   embedText,
   embedTexts,
@@ -45,6 +45,7 @@ export function createQueryHandlers({
   // instance (one memory runtime = one factory) so the 10s de-dup window
   // behaves exactly as it did when it was a top-level `let` in index.mjs.
   let _embeddingColdRecallLogAt = 0
+  const { dumpSessionRootChunks, entryStats } = createQueryMaintenanceHandlers({ getDb })
 
   // Raw-row priority lookup for narrow-window queries. Raw rows (is_root=0,
   // chunk_root IS NULL) are inserted immediately by ingestTranscriptFile before
@@ -866,127 +867,6 @@ export function createQueryHandlers({
     return { text: recallCapPrefix + renderSessionGroupedLines(sliced, { currentSessionId: _currentSessionHint, recencyOrder: sort === 'date' }) }
   }
 
-  async function dumpSessionRootChunks(args = {}) {
-    const db = getDb()
-    const sessionId = String(args.sessionId || args.session_id || '').trim()
-    if (!sessionId) return { text: '(no current session)', rows: [], chunks: [], isError: true }
-    const includeRaw = args.includeRaw !== false
-    const limit = Math.max(1, Math.min(1000, Number(args.limit) || 1000))
-    const rootRows = (await db.query(`
-      SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
-             element, category, summary, status, score, last_seen_at, project_id
-      FROM entries
-      WHERE session_id = $1 AND is_root = 1
-      ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-      LIMIT $2
-    `, [sessionId, limit])).rows
-    const roots = rootRows.map((r) => ({ ...r, members: [] }))
-    const rootIds = roots.map((r) => Number(r.id)).filter((id) => Number.isFinite(id))
-    const memberRows = rootIds.length > 0
-      ? (await db.query(`
-          SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
-          FROM entries
-          WHERE chunk_root = ANY($1::bigint[]) AND is_root = 0
-          ORDER BY chunk_root ASC, COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-        `, [rootIds])).rows
-      : []
-    const byRoot = new Map(roots.map((r) => [Number(r.id), r]))
-    for (const m of memberRows) {
-      const root = byRoot.get(Number(m.chunk_root))
-      if (root) root.members.push(m)
-    }
-    let rawRows = []
-    if (includeRaw) {
-      rawRows = (await db.query(`
-        SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
-        FROM entries
-        WHERE session_id = $1
-          AND is_root = 0
-          AND (chunk_root IS NULL OR chunk_root = id)
-        ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
-        LIMIT $2
-      `, [sessionId, limit])).rows
-    }
-    const chunks = []
-    for (const root of roots) {
-      const memberText = root.members
-        .map((m) => `${m.role === 'assistant' ? 'assistant' : m.role === 'user' ? 'user' : m.role}: ${cleanMemoryText(String(m.content ?? ''))}`)
-        .filter(Boolean)
-        .join('\n')
-      const summary = [root.element, root.summary].map((v) => String(v || '').trim()).filter(Boolean).join(' — ')
-      chunks.push({
-        id: Number(root.id),
-        kind: 'root',
-        ts: Number(root.ts) || 0,
-        sourceTurn: root.source_turn ?? null,
-        category: root.category || null,
-        summary,
-        text: memberText || cleanMemoryText(String(root.content ?? '')),
-        members: root.members,
-      })
-    }
-    for (const raw of rawRows) {
-      chunks.push({
-        id: Number(raw.id),
-        kind: 'raw',
-        chunkRoot: raw.chunk_root ?? null,
-        ts: Number(raw.ts) || 0,
-        sourceTurn: raw.source_turn ?? null,
-        category: null,
-        summary: '',
-        text: `${raw.role === 'assistant' ? 'assistant' : raw.role === 'user' ? 'user' : raw.role}: ${cleanMemoryText(String(raw.content ?? ''))}`,
-        members: [],
-      })
-    }
-    chunks.sort((a, b) => {
-      const at = Number.isFinite(Number(a.sourceTurn)) ? Number(a.sourceTurn) : 2147483647
-      const bt = Number.isFinite(Number(b.sourceTurn)) ? Number(b.sourceTurn) : 2147483647
-      return (at - bt) || ((a.ts || 0) - (b.ts || 0)) || ((a.id || 0) - (b.id || 0))
-    })
-    const text = chunks.length
-      ? chunks.map((chunk, idx) => {
-          const label = chunk.kind === 'root'
-            ? `# chunk ${idx + 1} root=${chunk.id}${chunk.category ? ` category=${chunk.category}` : ''}`
-            : `${chunk.chunkRoot == null ? '# raw_pending' : '# raw_terminal'} ${idx + 1} id=${chunk.id}`
-          const summary = chunk.summary ? `summary: ${chunk.summary}\n` : ''
-          return `${label}\n${summary}${chunk.text}`.trim()
-        }).join('\n\n')
-      : '(no results)'
-    return { text, rows: [...roots, ...rawRows], chunks }
-  }
-
-  async function entryStats() {
-    const db = getDb()
-    return await db.transaction(async (tx) => {
-      const total               = (await tx.query(`SELECT COUNT(*) c FROM entries`)).rows[0].c
-      const roots               = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1`)).rows[0].c
-      const active_roots        = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active'`)).rows[0].c
-      const archived_roots      = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'archived'`)).rows[0].c
-      const unchunked_leaves    = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL`)).rows[0].c
-      const cycle2_pending_roots = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'pending'`)).rows[0].c
-      const core_entries        = (await tx.query(`SELECT COUNT(*) c FROM core_entries`)).rows[0].c
-      const core_embed_null     = (await tx.query(`SELECT COUNT(*) c FROM core_entries WHERE embedding IS NULL`)).rows[0].c
-      const active_core_summaries = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active' AND core_summary IS NOT NULL`)).rows[0].c
-      const active_core_summary_missing = (await tx.query(`
-        SELECT COUNT(*) c
-        FROM entries
-        WHERE is_root = 1
-          AND status = 'active'
-          AND (core_summary IS NULL OR btrim(core_summary) = '')
-      `)).rows[0].c
-      const byStatus            = (await tx.query(`SELECT status, COUNT(*) c FROM entries WHERE is_root = 1 GROUP BY status`)).rows
-      const byCategory          = (await tx.query(`SELECT category, COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active' GROUP BY category ORDER BY c DESC`)).rows
-      const mvRows              = (await tx.query(`SELECT relispopulated FROM pg_class WHERE relname = 'mv_hot_active' LIMIT 1`)).rows
-      const mv_hot_active_populated = mvRows.length ? Boolean(mvRows[0].relispopulated) : null
-      return {
-        total, roots, active_roots, archived_roots, unchunked_leaves, cycle2_pending_roots,
-        core_entries, core_embed_null, active_core_summaries, active_core_summary_missing,
-        mv_hot_active_populated,
-        byStatus, byCategory,
-      }
-    })
-  }
-
   return {
     readRawRowsInWindow,
     recallSessionRows,

package/src/runtime/memory/lib/query-maintenance-handlers.mjs

@@ -0,0 +1,126 @@
+import { cleanMemoryText } from './memory.mjs'
+
+export function createQueryMaintenanceHandlers({ getDb }) {
+  async function dumpSessionRootChunks(args = {}) {
+    const db = getDb()
+    const sessionId = String(args.sessionId || args.session_id || '').trim()
+    if (!sessionId) return { text: '(no current session)', rows: [], chunks: [], isError: true }
+    const includeRaw = args.includeRaw !== false
+    const limit = Math.max(1, Math.min(1000, Number(args.limit) || 1000))
+    const rootRows = (await db.query(`
+      SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root,
+             element, category, summary, status, score, last_seen_at, project_id
+      FROM entries
+      WHERE session_id = $1 AND is_root = 1
+      ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
+      LIMIT $2
+    `, [sessionId, limit])).rows
+    const roots = rootRows.map((r) => ({ ...r, members: [] }))
+    const rootIds = roots.map((r) => Number(r.id)).filter((id) => Number.isFinite(id))
+    const memberRows = rootIds.length > 0
+      ? (await db.query(`
+          SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
+          FROM entries
+          WHERE chunk_root = ANY($1::bigint[]) AND is_root = 0
+          ORDER BY chunk_root ASC, COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
+        `, [rootIds])).rows
+      : []
+    const byRoot = new Map(roots.map((r) => [Number(r.id), r]))
+    for (const m of memberRows) {
+      const root = byRoot.get(Number(m.chunk_root))
+      if (root) root.members.push(m)
+    }
+    let rawRows = []
+    if (includeRaw) {
+      rawRows = (await db.query(`
+        SELECT id, ts, role, content, session_id, source_turn, chunk_root, is_root, project_id
+        FROM entries
+        WHERE session_id = $1
+          AND is_root = 0
+          AND (chunk_root IS NULL OR chunk_root = id)
+        ORDER BY COALESCE(source_turn, 2147483647) ASC, ts ASC, id ASC
+        LIMIT $2
+      `, [sessionId, limit])).rows
+    }
+    const chunks = []
+    for (const root of roots) {
+      const memberText = root.members
+        .map((m) => `${m.role === 'assistant' ? 'assistant' : m.role === 'user' ? 'user' : m.role}: ${cleanMemoryText(String(m.content ?? ''))}`)
+        .filter(Boolean)
+        .join('\n')
+      const summary = [root.element, root.summary].map((v) => String(v || '').trim()).filter(Boolean).join(' — ')
+      chunks.push({
+        id: Number(root.id),
+        kind: 'root',
+        ts: Number(root.ts) || 0,
+        sourceTurn: root.source_turn ?? null,
+        category: root.category || null,
+        summary,
+        text: memberText || cleanMemoryText(String(root.content ?? '')),
+        members: root.members,
+      })
+    }
+    for (const raw of rawRows) {
+      chunks.push({
+        id: Number(raw.id),
+        kind: 'raw',
+        chunkRoot: raw.chunk_root ?? null,
+        ts: Number(raw.ts) || 0,
+        sourceTurn: raw.source_turn ?? null,
+        category: null,
+        summary: '',
+        text: `${raw.role === 'assistant' ? 'assistant' : raw.role === 'user' ? 'user' : raw.role}: ${cleanMemoryText(String(raw.content ?? ''))}`,
+        members: [],
+      })
+    }
+    chunks.sort((a, b) => {
+      const at = Number.isFinite(Number(a.sourceTurn)) ? Number(a.sourceTurn) : 2147483647
+      const bt = Number.isFinite(Number(b.sourceTurn)) ? Number(b.sourceTurn) : 2147483647
+      return (at - bt) || ((a.ts || 0) - (b.ts || 0)) || ((a.id || 0) - (b.id || 0))
+    })
+    const text = chunks.length
+      ? chunks.map((chunk, idx) => {
+          const label = chunk.kind === 'root'
+            ? `# chunk ${idx + 1} root=${chunk.id}${chunk.category ? ` category=${chunk.category}` : ''}`
+            : `${chunk.chunkRoot == null ? '# raw_pending' : '# raw_terminal'} ${idx + 1} id=${chunk.id}`
+          const summary = chunk.summary ? `summary: ${chunk.summary}\n` : ''
+          return `${label}\n${summary}${chunk.text}`.trim()
+        }).join('\n\n')
+      : '(no results)'
+    return { text, rows: [...roots, ...rawRows], chunks }
+  }
+
+  async function entryStats() {
+    const db = getDb()
+    return await db.transaction(async (tx) => {
+      const total               = (await tx.query(`SELECT COUNT(*) c FROM entries`)).rows[0].c
+      const roots               = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1`)).rows[0].c
+      const active_roots        = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active'`)).rows[0].c
+      const archived_roots      = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'archived'`)).rows[0].c
+      const unchunked_leaves    = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE chunk_root IS NULL`)).rows[0].c
+      const cycle2_pending_roots = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'pending'`)).rows[0].c
+      const core_entries        = (await tx.query(`SELECT COUNT(*) c FROM core_entries`)).rows[0].c
+      const core_embed_null     = (await tx.query(`SELECT COUNT(*) c FROM core_entries WHERE embedding IS NULL`)).rows[0].c
+      const active_core_summaries = (await tx.query(`SELECT COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active' AND core_summary IS NOT NULL`)).rows[0].c
+      const active_core_summary_missing = (await tx.query(`
+        SELECT COUNT(*) c
+        FROM entries
+        WHERE is_root = 1
+          AND status = 'active'
+          AND (core_summary IS NULL OR btrim(core_summary) = '')
+      `)).rows[0].c
+      const byStatus            = (await tx.query(`SELECT status, COUNT(*) c FROM entries WHERE is_root = 1 GROUP BY status`)).rows
+      const byCategory          = (await tx.query(`SELECT category, COUNT(*) c FROM entries WHERE is_root = 1 AND status = 'active' GROUP BY category ORDER BY c DESC`)).rows
+      const mvRows              = (await tx.query(`SELECT relispopulated FROM pg_class WHERE relname = 'mv_hot_active' LIMIT 1`)).rows
+      const mv_hot_active_populated = mvRows.length ? Boolean(mvRows[0].relispopulated) : null
+      return {
+        total, roots, active_roots, archived_roots, unchunked_leaves, cycle2_pending_roots,
+        core_entries, core_embed_null, active_core_summaries, active_core_summary_missing,
+        mv_hot_active_populated,
+        byStatus, byCategory,
+      }
+    })
+  }
+
+  return { dumpSessionRootChunks, entryStats }
+}

package/src/runtime/memory/lib/tool-call-handler.mjs

@@ -0,0 +1,57 @@
+export function createToolCallHandler({ handleSearch, handleMemoryAction }) {
+  async function handleToolCall(name, args, signal) {
+    try {
+      if (name === 'search_memories') {
+        const result = await handleSearch(args || {}, signal)
+        return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
+      }
+      if (name === 'recall') {
+        // recall is aiWrapped in the unified build; in standalone mode map it to
+        // search_memories so the advertised tool name actually works. Forward
+        // every advertised arg so id/limit/offset/sort/includeArchived/
+        // includeMembers/includeRaw reach handleSearch instead of being dropped.
+        const a = args || {}
+        const hasQuery = Array.isArray(a.query)
+          ? a.query.some((value) => String(value || '').trim())
+          : String(a.query ?? '').trim() !== ''
+        const recallIds = hasQuery
+          ? []
+          : (Array.isArray(a.id) ? a.id : [a.id])
+              .map((value) => Number(value))
+              .filter((value) => Number.isInteger(value) && value > 0)
+        const searchArgs = {
+          ...(a.query !== undefined ? { query: a.query } : {}),
+          ...(recallIds.length > 0 ? { ids: recallIds } : {}),
+          ...(a.period ? { period: a.period } : {}),
+          ...(a.limit !== undefined ? { limit: a.limit } : {}),
+          ...(a.offset !== undefined ? { offset: a.offset } : {}),
+          ...(a.sort !== undefined ? { sort: a.sort } : {}),
+          ...(a.category !== undefined ? { category: a.category } : {}),
+          ...(a.includeArchived !== undefined ? { includeArchived: a.includeArchived } : {}),
+          ...(a.includeMembers !== undefined ? { includeMembers: a.includeMembers } : {}),
+          ...(a.includeRaw !== undefined ? { includeRaw: a.includeRaw } : {}),
+          ...(a.cwd ? { cwd: a.cwd } : {}),
+          ...(a.projectScope ? { projectScope: a.projectScope } : {}),
+          ...(a.sessionId ? { sessionId: a.sessionId } : {}),
+          ...(a.session_id ? { session_id: a.session_id } : {}),
+          ...(a.currentSession !== undefined ? { currentSession: a.currentSession } : {}),
+          // Hint only — never a filter. Marks the caller's own session as
+          // "(current)" in the multi-session grouped browse output.
+          ...(a.currentSessionId ? { currentSessionId: a.currentSessionId } : {}),
+        }
+        const result = await handleSearch(searchArgs, signal)
+        return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
+      }
+      if (name === 'memory') {
+        const result = await handleMemoryAction(args || {}, signal)
+        return { ...result, content: [{ type: 'text', text: result.text }], isError: result.isError || false }
+      }
+      return { content: [{ type: 'text', text: `unknown tool: ${name}` }], isError: true }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      return { content: [{ type: 'text', text: `${name} failed: ${msg}` }], isError: true }
+    }
+  }
+
+  return handleToolCall
+}

package/src/runtime/search/lib/http-fetch.mjs

@@ -7,7 +7,7 @@ import {
   pinnedFetch,
 } from './ssrf-guard.mjs'
 
-const PKG_VERSION = (() => { try { return JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version } catch { return '0.0.1' } })()
+const PKG_VERSION = (() => { try { return JSON.parse(readFileSync(new URL('../../../../package.json', import.meta.url), 'utf8')).version } catch { return '0.0.1' } })()
 
 export function withTimeout(controller, timeoutMs) {
   return setTimeout(() => controller.abort(), timeoutMs)

package/src/runtime/shared/config.mjs

@@ -27,7 +27,13 @@ export {
 }
 
 const _require = createRequire(import.meta.url)
-const { getSecret: _getSecret, setSecret: _setSecret, deleteSecret: _deleteSecret, hasSecret: _hasSecret } = _require('../../lib/keychain-cjs.cjs')
+const {
+  getSecret: _getSecret,
+  setSecret: _setSecret,
+  deleteSecret: _deleteSecret,
+  hasSecret: _hasSecret,
+  invalidateSecretCache: _invalidateSecretCache,
+} = _require('../../lib/keychain-cjs.cjs')
 
 const DATA_DIR = resolvePluginData()
 
@@ -338,25 +344,60 @@ function withConfigLockAsync(fn) {
   return withFileLock(`${CONFIG_PATH}.lock`, fn, { secret: true })
 }
 
-export async function updateConfigAsync(updater) {
-  let saved = null
-  await withConfigLockAsync(async () => {
-    const current = stripGeneratedMarker(readAllForRmW()) || {}
-    const next = typeof updater === 'function' ? updater({ ...current }) : updater
-    if (!isPlainObject(next)) throw new Error('[config] updateConfigAsync updater must return an object')
-    saved = stripGeneratedMarker(next) || {}
-    await writeAllAsync(saved)
+// Process-wide registry at the lock-owning layer: every public async RMW path
+// registers before lock acquisition and unregisters on both fulfillment and
+// rejection. Lifecycle teardown can therefore drain direct callers too, not
+// just its own debounce queues.
+const _pendingConfigWrites = new Set()
+
+function trackConfigWrite(work) {
+  let promise
+  try {
+    promise = Promise.resolve(work())
+  } catch (error) {
+    promise = Promise.reject(error)
+  }
+  _pendingConfigWrites.add(promise)
+  const remove = () => { _pendingConfigWrites.delete(promise) }
+  promise.then(remove, remove)
+  return promise
+}
+
+export async function pendingConfigWrites() {
+  while (_pendingConfigWrites.size > 0) {
+    await Promise.allSettled([..._pendingConfigWrites])
+  }
+}
+
+export function updateConfigAsync(updater) {
+  return trackConfigWrite(async () => {
+    let saved = null
+    await withConfigLockAsync(async () => {
+      const current = stripGeneratedMarker(readAllForRmW()) || {}
+      const next = typeof updater === 'function' ? updater({ ...current }) : updater
+      if (!isPlainObject(next)) throw new Error('[config] updateConfigAsync updater must return an object')
+      saved = stripGeneratedMarker(next) || {}
+      await writeAllAsync(saved)
+    })
+    return saved
   })
-  return saved
 }
 
-export async function updateSectionAsync(section, updater) {
-  await withConfigLockAsync(async () => {
+export function writeSectionAsync(section, data) {
+  return trackConfigWrite(() => withConfigLockAsync(async () => {
+    const all = readAllForRmW()
+    all[section] = stripGeneratedMarker(data)
+    await writeAllAsync(all)
+  }))
+}
+
+export function updateSectionAsync(section, updater) {
+  return trackConfigWrite(() => withConfigLockAsync(async () => {
     const all = readAllForRmW()
     const current = stripGeneratedMarker(all[section] || {})
     all[section] = stripGeneratedMarker(typeof updater === 'function' ? updater(current) : updater)
     await writeAllAsync(all)
-  })
+  }))
 }
 
 // ── Capabilities (B2 central path policy) ───────────────────────────
@@ -510,6 +551,10 @@ export function deleteSecret(account) {
   _deleteSecret(account)
 }
 
+export function invalidateSecretReadCache(account) {
+  _invalidateSecretCache(account)
+}
+
 /**
  * Whether a secret is stored in the OS keychain for `account` (ignores env).
  * Lets the setup UI show "Set" WITHOUT ever sending the secret value to the

package/src/runtime/shared/llm/cost.mjs

@@ -31,7 +31,14 @@ export function isInclusiveProvider(provider) {
     // usage rows — without it, cached tokens would be double-billed in the
     // cost fallback and prompt totals.
     return p.includes('openai') || p.includes('codex') || p.includes('gemini') || p.includes('google') || p.includes('xai') || p.includes('grok')
-        || p.includes('deepseek') || p.includes('ollama') || p.includes('lmstudio') || p.includes('groq') || p.includes('openrouter');
+        || p.includes('deepseek') || p.includes('ollama') || p.includes('lmstudio') || p.includes('groq') || p.includes('openrouter')
+        || p.includes('opencode-go');
+}
+
+export function billableInputTokensForProvider(provider, inputTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+    const input = Number(inputTokens) || 0;
+    if (!isInclusiveProvider(provider)) return input;
+    return Math.max(input - (Number(cacheReadTokens) || 0) - (Number(cacheWriteTokens) || 0), 0);
 }
 
 /**
@@ -51,9 +58,12 @@ export function computeCostUsd(args) {
     const outputTokens = args.outputTokens || 0;
     const cacheReadTokens = args.cacheReadTokens || 0;
     const cacheWriteTokens = args.cacheWriteTokens || 0;
-    const billableInput = isInclusiveProvider(args.provider)
-        ? Math.max(inputTokens - cacheReadTokens - cacheWriteTokens, 0)
-        : inputTokens;
+    const billableInput = billableInputTokensForProvider(
+        args.provider,
+        inputTokens,
+        cacheReadTokens,
+        cacheWriteTokens,
+    );
     const parts = [
         billableInput * (meta.inputCostPerM || 0),
         outputTokens * (meta.outputCostPerM || 0),