sidekick-shared 0.28.3 → 0.29.0

package/dist/esm/parsers/codexParser.js

@@ -171,6 +171,10 @@ export function extractPatchFilePaths(input) {
 }
 /** Default cap on each piece of per-call correlation state the parser keeps. */
 export const DEFAULT_MAX_TRACKED_TOOL_CALLS = 4096;
+/** Fixed per-entry cost added to each pending call's byte estimate. */
+const PENDING_ENTRY_OVERHEAD_BYTES = 64;
+/** Prefix of the bookkeeping keys the parser stashes inside tool inputs. */
+const SIDEKICK_INPUT_KEY_PREFIX = '_sidekick';
 /** Adds `key`, refreshing its position, and evicts the oldest past `max`. */
 function rememberBounded(set, key, max) {
     set.delete(key);
@@ -178,12 +182,31 @@ function rememberBounded(set, key, max) {
     while (set.size > max)
         set.delete(set.values().next().value);
 }
-/** Sets `key`, refreshing its position, and evicts the oldest past `max`. */
-function setBounded(map, key, value, max) {
-    map.delete(key);
-    map.set(key, value);
-    while (map.size > max)
-        map.delete(map.keys().next().value);
+function stringBytes(...values) {
+    let total = 0;
+    for (const value of values)
+        if (typeof value === 'string')
+            total += value.length;
+    return total;
+}
+function approxJsonBytes(value) {
+    if (value === undefined)
+        return 0;
+    try {
+        return JSON.stringify(value)?.length ?? 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Only the `_sidekick*` bookkeeping keys of a tool input. */
+function sidekickKeysOnly(input) {
+    const kept = {};
+    for (const key of Object.keys(input)) {
+        if (key.startsWith(SIDEKICK_INPUT_KEY_PREFIX))
+            kept[key] = input[key];
+    }
+    return kept;
 }
 /**
  * Stateful parser for Codex JSONL rollout lines.
@@ -209,10 +232,35 @@ export class CodexRolloutParser {
     emittedToolUseIds = new Set();
     patchExpandedToolUseIds = new Map();
     maxTrackedToolCalls;
+    /** Byte budget for pending calls; `null` = unlimited (no accounting). */
+    maxPendingBytes;
+    metadataOnly;
+    /** Pending calls in insertion order, for the byte budget. */
+    pendingLedger = new Map();
+    pendingBytes = 0;
+    evictedByCount = 0;
+    evictedByBytes = 0;
     constructor(options = {}) {
         const max = options.maxTrackedToolCalls;
         this.maxTrackedToolCalls =
             typeof max === 'number' && max >= 1 ? Math.floor(max) : DEFAULT_MAX_TRACKED_TOOL_CALLS;
+        const maxBytes = options.maxPendingBytes;
+        this.maxPendingBytes =
+            typeof maxBytes === 'number' && Number.isFinite(maxBytes) && maxBytes >= 1
+                ? Math.floor(maxBytes)
+                : null;
+        this.metadataOnly = options.metadataOnly === true;
+    }
+    /** Counters for the pending tool-call state and what the caps evicted. */
+    getPendingStats() {
+        return {
+            pendingCalls: this.pendingExecCommands.size +
+                this.pendingMcpToolCalls.size +
+                this.patchExpandedToolUseIds.size,
+            pendingBytes: this.maxPendingBytes === null ? null : this.pendingBytes,
+            evictedByCount: this.evictedByCount,
+            evictedByBytes: this.evictedByBytes,
+        };
     }
     /** Get stored session metadata. */
     getSessionMeta() {
@@ -267,6 +315,72 @@ export class CodexRolloutParser {
         this.inPlanMode = false;
         this.emittedToolUseIds.clear();
         this.patchExpandedToolUseIds.clear();
+        this.pendingLedger.clear();
+        this.pendingBytes = 0;
+        this.evictedByCount = 0;
+        this.evictedByBytes = 0;
+    }
+    // --- Pending call state ---
+    /**
+     * Stores a pending call, refreshing its position, then enforces the count
+     * cap on its table and the byte budget across all pending tables, oldest
+     * first.
+     */
+    putPending(table, callId, value, estimateBytes) {
+        this.forgetPendingBytes(table, callId);
+        table.delete(callId);
+        table.set(callId, value);
+        while (table.size > this.maxTrackedToolCalls) {
+            const oldest = table.keys().next().value;
+            table.delete(oldest);
+            this.forgetPendingBytes(table, oldest);
+            this.evictedByCount += 1;
+        }
+        if (this.maxPendingBytes === null)
+            return;
+        const bytes = PENDING_ENTRY_OVERHEAD_BYTES + estimateBytes();
+        this.pendingLedger.set(this.ledgerKey(table, callId), {
+            table: table,
+            callId,
+            bytes,
+        });
+        this.pendingBytes += bytes;
+        while (this.pendingBytes > this.maxPendingBytes && this.pendingLedger.size > 0) {
+            const [key, oldest] = this.pendingLedger.entries().next().value;
+            this.pendingLedger.delete(key);
+            this.pendingBytes -= oldest.bytes;
+            oldest.table.delete(oldest.callId);
+            this.evictedByBytes += 1;
+        }
+    }
+    /** Removes and returns a pending call. */
+    takePending(table, callId) {
+        const value = table.get(callId);
+        table.delete(callId);
+        this.forgetPendingBytes(table, callId);
+        return value;
+    }
+    forgetPendingBytes(table, callId) {
+        if (this.maxPendingBytes === null)
+            return;
+        const key = this.ledgerKey(table, callId);
+        const entry = this.pendingLedger.get(key);
+        if (!entry)
+            return;
+        this.pendingLedger.delete(key);
+        this.pendingBytes -= entry.bytes;
+    }
+    ledgerKey(table, callId) {
+        const kind = table === this.pendingExecCommands ? 'e' : table === this.pendingMcpToolCalls ? 'm' : 'p';
+        return `${kind}\u0000${callId}`;
+    }
+    /** The emitted tool input: unchanged, or only its `_sidekick*` keys in metadata-only mode. */
+    toolInput(input) {
+        return this.metadataOnly ? sidekickKeysOnly(input) : input;
+    }
+    /** The emitted tool-result content: unchanged, or empty in metadata-only mode. */
+    toolOutput(content) {
+        return this.metadataOnly ? '' : content;
     }
     // --- Handlers ---
     handleSessionMeta(timestamp, payload) {
@@ -373,7 +487,9 @@ export class CodexRolloutParser {
                     role: 'assistant',
                     id: item.id,
                     model: this.currentModel || undefined,
-                    content: [{ type: 'thinking', thinking: summaryTexts.join('\n') }],
+                    content: [
+                        { type: 'thinking', thinking: this.metadataOnly ? '' : summaryTexts.join('\n') },
+                    ],
                 },
                 timestamp,
             },
@@ -381,11 +497,13 @@ export class CodexRolloutParser {
     }
     handleFunctionCall(timestamp, item) {
         let parsedArgs = {};
-        try {
-            parsedArgs = JSON.parse(item.arguments);
-        }
-        catch {
-            parsedArgs = { raw: item.arguments };
+        if (!this.metadataOnly) {
+            try {
+                parsedArgs = JSON.parse(item.arguments);
+            }
+            catch {
+                parsedArgs = { raw: item.arguments };
+            }
         }
         const canonicalName = normalizeCodexToolName(item.name);
         const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedArgs);
@@ -402,7 +520,7 @@ export class CodexRolloutParser {
                             type: 'tool_use',
                             id: item.call_id,
                             name: canonicalName,
-                            input: normalizedInput,
+                            input: this.toolInput(normalizedInput),
                         },
                     ],
                 },
@@ -422,7 +540,7 @@ export class CodexRolloutParser {
                         {
                             type: 'tool_result',
                             tool_use_id: item.call_id,
-                            content: item.output,
+                            content: this.toolOutput(item.output),
                             is_error: isError,
                         },
                     ],
@@ -446,11 +564,11 @@ export class CodexRolloutParser {
                             type: 'tool_use',
                             id: item.call_id,
                             name: 'Bash',
-                            input: {
+                            input: this.toolInput({
                                 command,
                                 workdir: item.action?.workdir,
                                 _sidekickRawToolName: 'local_shell_call',
-                            },
+                            }),
                         },
                     ],
                 },
@@ -464,7 +582,7 @@ export class CodexRolloutParser {
             if (filePaths.length === 0)
                 return [];
             const toolUseIds = filePaths.map((fp) => `${item.call_id}-${fp}`);
-            setBounded(this.patchExpandedToolUseIds, item.call_id, toolUseIds, this.maxTrackedToolCalls);
+            this.putPending(this.patchExpandedToolUseIds, item.call_id, toolUseIds, () => stringBytes(item.call_id, ...toolUseIds));
             for (const id of toolUseIds) {
                 rememberBounded(this.emittedToolUseIds, id, this.maxTrackedToolCalls);
             }
@@ -479,10 +597,10 @@ export class CodexRolloutParser {
                             type: 'tool_use',
                             id: `${item.call_id}-${fp}`,
                             name: 'Edit',
-                            input: {
+                            input: this.toolInput({
                                 file_path: fp,
                                 _sidekickRawToolName: 'apply_patch',
-                            },
+                            }),
                         },
                     ],
                 },
@@ -490,12 +608,14 @@ export class CodexRolloutParser {
             }));
         }
         // Generic custom tool
-        let parsedInput;
-        try {
-            parsedInput = JSON.parse(item.input);
-        }
-        catch {
-            parsedInput = { raw: item.input };
+        let parsedInput = {};
+        if (!this.metadataOnly) {
+            try {
+                parsedInput = JSON.parse(item.input);
+            }
+            catch {
+                parsedInput = { raw: item.input };
+            }
         }
         const canonicalName = normalizeCodexToolName(item.name);
         const normalizedInput = normalizeCodexToolInput(canonicalName, item.name, parsedInput);
@@ -512,7 +632,7 @@ export class CodexRolloutParser {
                             type: 'tool_use',
                             id: item.call_id,
                             name: canonicalName,
-                            input: normalizedInput,
+                            input: this.toolInput(normalizedInput),
                         },
                     ],
                 },
@@ -533,8 +653,9 @@ export class CodexRolloutParser {
         catch {
             isError = parsePlainTextFailure(item.output);
         }
-        const toolUseIds = this.patchExpandedToolUseIds.get(item.call_id) ?? [item.call_id];
-        this.patchExpandedToolUseIds.delete(item.call_id);
+        const toolUseIds = this.takePending(this.patchExpandedToolUseIds, item.call_id) ?? [
+            item.call_id,
+        ];
         return toolUseIds.map((toolUseId) => ({
             type: 'user',
             message: {
@@ -544,7 +665,7 @@ export class CodexRolloutParser {
                     {
                         type: 'tool_result',
                         tool_use_id: toolUseId,
-                        content: item.output,
+                        content: this.toolOutput(item.output),
                         is_error: isError,
                         duration,
                     },
@@ -608,18 +729,15 @@ export class CodexRolloutParser {
             // response_item/message events which carry richer metadata (id, content parts, role).
             case 'exec_command_begin': {
                 const e = event;
-                setBounded(this.pendingExecCommands, e.call_id, {
-                    call_id: e.call_id,
-                    command: e.command,
-                    workdir: e.workdir,
-                    timestamp,
-                }, this.maxTrackedToolCalls);
+                const pending = this.metadataOnly
+                    ? { call_id: e.call_id, command: [], timestamp }
+                    : { call_id: e.call_id, command: e.command, workdir: e.workdir, timestamp };
+                this.putPending(this.pendingExecCommands, e.call_id, pending, () => stringBytes(pending.call_id, pending.workdir, pending.timestamp, ...(Array.isArray(pending.command) ? pending.command : [])));
                 return [];
             }
             case 'exec_command_end': {
                 const e = event;
-                const pending = this.pendingExecCommands.get(e.call_id);
-                this.pendingExecCommands.delete(e.call_id);
+                const pending = this.takePending(this.pendingExecCommands, e.call_id);
                 const command = pending?.command?.join(' ') || '';
                 const events = [];
                 if (!this.emittedToolUseIds.has(e.call_id)) {
@@ -635,18 +753,20 @@ export class CodexRolloutParser {
                                     type: 'tool_use',
                                     id: e.call_id,
                                     name: 'Bash',
-                                    input: {
+                                    input: this.toolInput({
                                         command,
                                         workdir: pending?.workdir,
                                         _sidekickRawToolName: 'exec_command',
-                                    },
+                                    }),
                                 },
                             ],
                         },
                         timestamp: pending?.timestamp || timestamp,
                     });
                 }
-                const output = [e.stdout, e.stderr].filter(Boolean).join('\n') || '';
+                const output = this.metadataOnly
+                    ? ''
+                    : [e.stdout, e.stderr].filter(Boolean).join('\n') || '';
                 events.push({
                     type: 'user',
                     message: {
@@ -668,19 +788,20 @@ export class CodexRolloutParser {
             }
             case 'mcp_tool_call_begin': {
                 const e = event;
-                setBounded(this.pendingMcpToolCalls, e.call_id, {
+                const pending = {
                     call_id: e.call_id,
                     server_name: e.server_name,
                     tool_name: e.tool_name,
-                    arguments: e.arguments,
+                    arguments: this.metadataOnly ? undefined : e.arguments,
                     timestamp,
-                }, this.maxTrackedToolCalls);
+                };
+                this.putPending(this.pendingMcpToolCalls, e.call_id, pending, () => stringBytes(pending.call_id, pending.server_name, pending.tool_name, timestamp) +
+                    approxJsonBytes(pending.arguments));
                 return [];
             }
             case 'mcp_tool_call_end': {
                 const e = event;
-                const pendingMcp = this.pendingMcpToolCalls.get(e.call_id);
-                this.pendingMcpToolCalls.delete(e.call_id);
+                const pendingMcp = this.takePending(this.pendingMcpToolCalls, e.call_id);
                 const toolName = pendingMcp?.tool_name || 'McpTool';
                 const events = [];
                 if (!this.emittedToolUseIds.has(e.call_id)) {
@@ -696,11 +817,11 @@ export class CodexRolloutParser {
                                     type: 'tool_use',
                                     id: e.call_id,
                                     name: normalizeCodexToolName(toolName),
-                                    input: {
+                                    input: this.toolInput({
                                         ...(pendingMcp?.arguments || {}),
                                         _sidekickRawToolName: toolName,
                                         _sidekickMcpServerName: pendingMcp?.server_name,
-                                    },
+                                    }),
                                 },
                             ],
                         },
@@ -716,7 +837,7 @@ export class CodexRolloutParser {
                             {
                                 type: 'tool_result',
                                 tool_use_id: e.call_id,
-                                content: e.result || '',
+                                content: this.toolOutput(e.result || ''),
                                 is_error: e.is_error || false,
                                 duration: e.duration_ms,
                             },
@@ -775,12 +896,12 @@ export class CodexRolloutParser {
                                     type: 'tool_use',
                                     id: patchId,
                                     name: 'Edit',
-                                    input: {
+                                    input: this.toolInput({
                                         file_path: e.file_path,
                                         additions: e.additions ?? 0,
                                         deletions: e.deletions ?? 0,
                                         _sidekickRawToolName: 'patch_applied',
-                                    },
+                                    }),
                                 },
                             ],
                         },
@@ -807,10 +928,10 @@ export class CodexRolloutParser {
                                     type: 'tool_use',
                                     id: `plan-enter-${timestamp}`,
                                     name: 'EnterPlanMode',
-                                    input: {
+                                    input: this.toolInput({
                                         source: 'codex_task_started',
                                         _sidekickRawToolName: 'task_started',
-                                    },
+                                    }),
                                 },
                             ],
                         },
@@ -834,10 +955,10 @@ export class CodexRolloutParser {
                                     type: 'tool_use',
                                     id: `plan-exit-${timestamp}`,
                                     name: 'ExitPlanMode',
-                                    input: {
+                                    input: this.toolInput({
                                         source: 'codex_task_complete',
                                         _sidekickRawToolName: 'task_complete',
-                                    },
+                                    }),
                                 },
                             ],
                         },

package/dist/esm/parsers/codexRolloutOrigin.js

@@ -0,0 +1,107 @@
+/**
+ * Where a Codex rollout came from, read from its `session_meta` record:
+ * a session a person started, a fork of another session, or a subagent.
+ *
+ * Codex writes `session_meta.source` as a plain string for sessions started
+ * from a surface (`cli`, `vscode`, `exec`, …) and as an object for subagents:
+ * `{ subagent: { thread_spawn: { parent_thread_id, … } } }` for a spawned
+ * agent, `{ subagent: { other: 'guardian' } }` for internal reviewers, or
+ * `{ subagent: 'review' }`. The same JSON appears as a string in the state
+ * database's `threads.source`. A forked rollout records `forked_from_id`, and
+ * embeds its parent's `session_meta` after its own, so only the first counts.
+ *
+ * Pure: no filesystem access. Browser-safe.
+ *
+ * @module parsers/codexRolloutOrigin
+ */
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** A `source` value as an object: rollouts store it parsed, the database as JSON text. */
+function sourceObject(source) {
+    if (typeof source !== 'string')
+        return record(source);
+    if (!source.startsWith('{'))
+        return undefined;
+    try {
+        return record(JSON.parse(source));
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parent thread id of a spawned subagent's `source` (object, or JSON text as
+ * stored in `threads.source`): `subagent.thread_spawn.parent_thread_id`.
+ */
+export function codexSpawnParentFromSource(source) {
+    const spawn = record(record(sourceObject(source)?.subagent)?.thread_spawn);
+    const parent = spawn?.parent_thread_id;
+    return typeof parent === 'string' ? parent : undefined;
+}
+function subagentKindOf(subagent) {
+    if (typeof subagent === 'string')
+        return nonEmpty(subagent);
+    const variant = record(subagent);
+    if (!variant)
+        return undefined;
+    const other = nonEmpty(variant.other);
+    if (other)
+        return other;
+    return Object.keys(variant)[0];
+}
+/** The `session_meta` payload of a record, of a bare payload, or of the first in a list. */
+function metaPayload(input) {
+    if (Array.isArray(input)) {
+        for (const item of input) {
+            const row = record(item);
+            if (row?.type === 'session_meta')
+                return record(row.payload);
+        }
+        return undefined;
+    }
+    const row = record(input);
+    if (!row)
+        return undefined;
+    if (row.type === 'session_meta')
+        return record(row.payload);
+    // A payload on its own, as `readSessionMeta()` returns it.
+    if (row.type === undefined && row.payload === undefined)
+        return row;
+    return undefined;
+}
+/**
+ * Origin of a Codex rollout from its `session_meta`. Accepts the parsed
+ * `session_meta` record, its payload, or the rollout's records in order (the
+ * first `session_meta` wins: a fork embeds its parent's after its own).
+ * Anything else yields `{ isSubagent: false }`.
+ */
+export function codexRolloutOrigin(input) {
+    const payload = metaPayload(input);
+    if (!payload)
+        return { isSubagent: false };
+    const forkedFromId = nonEmpty(payload.forked_from_id);
+    const object = sourceObject(payload.source);
+    const isSubagent = object !== undefined && 'subagent' in object;
+    const source = typeof payload.source === 'string' && object === undefined
+        ? nonEmpty(payload.source)
+        : isSubagent
+            ? 'subagent'
+            : undefined;
+    const parentId = forkedFromId ??
+        nonEmpty(codexSpawnParentFromSource(object)) ??
+        (isSubagent ? nonEmpty(payload.parent_thread_id) : undefined);
+    const subagentKind = isSubagent ? subagentKindOf(object?.subagent) : undefined;
+    return {
+        ...(forkedFromId ? { forkedFromId } : {}),
+        ...(source ? { source } : {}),
+        isSubagent,
+        ...(parentId ? { parentId } : {}),
+        ...(subagentKind ? { subagentKind } : {}),
+    };
+}

package/dist/esm/parsers/openCodeParser.js

@@ -115,6 +115,78 @@ function toISOString(time) {
         return time;
     return new Date(time).toISOString();
 }
+/**
+ * Token counts from a message in either storage shape: database rows are
+ * mapped to flat `cacheRead` / `cacheWrite`, while file-storage messages keep
+ * OpenCode's nested `cache: { read, write }`.
+ * @internal
+ */
+export function openCodeTokenCounts(tokens) {
+    const raw = (tokens ?? {});
+    const cache = (raw.cache ?? {});
+    const num = (value) => (typeof value === 'number' ? value : undefined);
+    return {
+        input: num(raw.input),
+        output: num(raw.output),
+        reasoning: num(raw.reasoning),
+        cacheRead: num(raw.cacheRead) ?? num(cache.read),
+        cacheWrite: num(raw.cacheWrite) ?? num(cache.write),
+        total: num(raw.total),
+    };
+}
+/**
+ * How a stored OpenCode message splits its tokens. Current OpenCode stores
+ * every bucket disjoint for every provider: `input` excludes cache reads and
+ * writes (since 2025-11) and `output` excludes `reasoning` (since 2026-04),
+ * with `total` equal to their sum. Older messages either counted cached input
+ * in `input` (OpenAI-compatible providers) or reasoning in `output`. The
+ * stored `total` tells the layouts apart; without it the current layout is
+ * assumed.
+ * @internal
+ */
+export function openCodeTokenLayout(tokens) {
+    const n = (value) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+    const input = n(tokens.input);
+    const output = n(tokens.output);
+    const reasoning = n(tokens.reasoning);
+    const cache = n(tokens.cacheRead) + n(tokens.cacheWrite);
+    const total = n(tokens.total);
+    if (total > 0 && total !== input + cache + output + reasoning) {
+        if (reasoning > 0 && total === input + cache + output) {
+            return { inputIncludesCache: false, reasoningInOutput: true };
+        }
+        if (cache > 0 && total === input + output + reasoning) {
+            return { inputIncludesCache: true, reasoningInOutput: false };
+        }
+        if (cache > 0 && reasoning > 0 && total === input + output) {
+            return { inputIncludesCache: true, reasoningInOutput: true };
+        }
+    }
+    return { inputIncludesCache: false, reasoningInOutput: false };
+}
+/** Normalizes one OpenCode message's or step's stored tokens. @internal */
+export function normalizeOpenCodeUsage(tokens, providerID, extra = {}) {
+    const layout = openCodeTokenLayout(tokens);
+    return normalizeProviderUsage({
+        // `openai` semantics subtract cache reads from input; only an old
+        // cache-inclusive message needs that.
+        semantics: layout.inputIncludesCache
+            ? 'openai'
+            : providerID === 'anthropic'
+                ? 'anthropic'
+                : 'sidekick',
+        provider: providerID ?? 'opencode',
+        ...(extra.source ? { source: extra.source } : {}),
+        ...(extra.model ? { model: extra.model } : {}),
+        inputTokens: tokens.input,
+        outputTokens: tokens.output,
+        cacheReadTokens: tokens.cacheRead,
+        cacheWriteTokens: tokens.cacheWrite,
+        reasoningTokens: tokens.reasoning,
+        reasoningIncludedInOutput: layout.reasoningInOutput,
+        ...(extra.reportedCostUsd !== undefined ? { reportedCostUsd: extra.reportedCostUsd } : {}),
+    });
+}
 /**
  * Converts an OpenCode message and its parts into SessionEvent array.
  *
@@ -320,31 +392,20 @@ function convertAssistantMessage(message, parts) {
         : stepFinishCost > 0
             ? stepFinishCost
             : undefined;
-    const usage = {
-        input_tokens: message.tokens.input || 0,
-        output_tokens: message.tokens.output || 0,
-        cache_creation_input_tokens: message.tokens.cacheWrite || 0,
-        cache_read_input_tokens: message.tokens.cacheRead || 0,
-        reported_cost: reportedCost,
-        reasoning_tokens: message.tokens.reasoning || 0,
-    };
-    const normalizedUsage = normalizeProviderUsage({
-        semantics: message.providerID === 'openai'
-            ? 'openai'
-            : message.providerID === 'anthropic'
-                ? 'anthropic'
-                : 'sidekick',
-        provider: message.providerID ?? 'opencode',
+    const counts = openCodeTokenCounts(message.tokens);
+    const normalizedUsage = normalizeOpenCodeUsage(counts, message.providerID, {
         source: 'opencode-message',
         model: message.modelID,
-        inputTokens: message.tokens.input,
-        outputTokens: message.tokens.output,
-        cacheReadTokens: message.tokens.cacheRead,
-        cacheWriteTokens: message.tokens.cacheWrite,
-        reasoningTokens: message.tokens.reasoning,
-        reasoningIncludedInOutput: message.providerID === 'openai',
         reportedCostUsd: reportedCost,
     });
+    const usage = {
+        input_tokens: normalizedUsage.uncachedInputTokens,
+        output_tokens: counts.output || 0,
+        cache_creation_input_tokens: counts.cacheWrite || 0,
+        cache_read_input_tokens: counts.cacheRead || 0,
+        reported_cost: reportedCost,
+        reasoning_tokens: counts.reasoning || 0,
+    };
     const timestamp = toISOString(message.time.completed || message.time.created);
     const retryAttempts = parts
         .filter((part) => part.type === 'retry')
@@ -483,6 +544,7 @@ export function parseDbMessageData(row) {
             cacheRead: cache?.read || 0,
             cacheWrite: cache?.write || 0,
             reasoning: tokens?.reasoning || 0,
+            ...(typeof tokens?.total === 'number' ? { total: tokens.total } : {}),
         },
         time: {
             created: time?.created || row.time_created,

package/dist/esm/pricing.js

@@ -0,0 +1,18 @@
+/**
+ * `sidekick-shared/pricing` — model pricing, model-id identity, usage
+ * normalization and cost, cost provenance, cost/token formatting, and text
+ * token estimates, as one small pure entry (no filesystem, network, or Zod).
+ *
+ * For hosts that price usage or format costs without session reading: it
+ * loads a handful of modules instead of the full browser surface. LiteLLM
+ * catalog hydration stays Node-only in `sidekick-shared/node`
+ * (`hydratePricingCatalog`); once hydrated, lookups here see the catalog.
+ * Everything here is also exported from the package root and
+ * `sidekick-shared/browser`.
+ *
+ * @module pricing
+ */
+export { MODEL_PROVIDER_IDS, canonicalModelId, isMovingModelAlias, parseModelId, compareModelIds, sortModelIds, shortModelName, getModelDisplayInfo, getModelInfo, getModelPricing, resolveModelPricing, registerModelPricing, clearRegisteredModelPricing, getPricingCatalogInfo, calculateCost, calculateCostWithPricing, calculateCostWithProvenance, mergeCostSources, costSourceFromPricingProvenance, mergeCostComponents, formatCost, } from './modelInfo';
+export { normalizeProviderUsage, extractNormalizedUsage, calculateNormalizedUsageCost, } from './usageNormalization';
+export { formatTokenCount, formatDurationMs } from './formatting';
+export { ASCII_CHARS_PER_TOKEN, estimateTextTokens, estimateSerializedTokens, } from './tokenEstimation';