import { stripEnvelope, stripMessageIdHints } from "../shared/chat-envelope.js";

import { asFiniteNumber } from "../shared/number-coercion.js";

import { normalizeOptionalString } from "../shared/string-coerce.js";

import { runTasksWithConcurrency } from "../utils/run-with-concurrency.js";

import { countToolResults, extractToolCallNames } from "../utils/transcript-tools.js";

import {

estimateUsageCost,

const USAGE_COST_CACHE_VERSION = 4;

const USAGE_COST_CACHE_FILE = ".usage-cost-cache.json";

const USAGE_COST_CACHE_LOCK_WRITE_GRACE_MS = 10_000;

const USAGE_COST_TRANSCRIPT_STAT_CONCURRENCY = 32;

const logger = createSubsystemLogger("usage-cost-cache");

type UsageCostRefreshState = {

});

}

async function listUsageCountedTranscriptFiles(

async function listUsageCountedTranscriptFileStats(

agentId?: string,

params?: { minMtimeMs?: number },

): Promise<UsageCostTranscriptFile[]> {

const sessionsDir = resolveSessionTranscriptsDirForAgent(agentId);

const entries = await fs.promises.readdir(sessionsDir, { withFileTypes: true }).catch(() => []);

const files = await Promise.all(

entries

.filter((entry) => entry.isFile() && isUsageCountedSessionTranscriptFileName(entry.name))

.map(async (entry) => {

const tasks = entries

.filter((entry) => entry.isFile() && isUsageCountedSessionTranscriptFileName(entry.name))

.map(

(entry) => async (): Promise<UsageCostTranscriptFile | undefined> => {

const filePath = path.join(sessionsDir, entry.name);

const stats = await fs.promises.stat(filePath).catch(() => null);

if (!stats) {

return undefined;

}

if (params?.minMtimeMs !== undefined && stats.mtimeMs < params.minMtimeMs) {

return undefined;

}

return { filePath, size: stats.size, mtimeMs: stats.mtimeMs };

}),

);

return files.filter((file): file is UsageCostTranscriptFile => Boolean(file));

},

);

const { results } = await runTasksWithConcurrency({

tasks,

limit: USAGE_COST_TRANSCRIPT_STAT_CONCURRENCY,

});

return results.filter((file): file is UsageCostTranscriptFile => Boolean(file));

}

async function listUsageCountedTranscriptFiles(

agentId?: string,

): Promise<UsageCostTranscriptFile[]> {

return await listUsageCountedTranscriptFileStats(agentId);

}

function isUsageCostCacheEntryFresh(params: {

const totals = emptyTotals();

const resolveCost = createUsageCostResolver(params?.config);

const sessionsDir = resolveSessionTranscriptsDirForAgent(params?.agentId);

const entries = await fs.promises.readdir(sessionsDir, { withFileTypes: true }).catch(() => []);

const files = (

await Promise.all(

entries

.filter((entry) => entry.isFile() && isUsageCountedSessionTranscriptFileName(entry.name))

.map(async (entry) => {

const filePath = path.join(sessionsDir, entry.name);

const stats = await fs.promises.stat(filePath).catch(() => null);

if (!stats) {

return null;

}

// Include file if it was modified after our start time

if (stats.mtimeMs < sinceTime) {

return null;

}

return filePath;

}),

)

).filter((filePath): filePath is string => Boolean(filePath));

const files = await listUsageCountedTranscriptFileStats(params?.agentId, {

minMtimeMs: sinceTime,

});

for (const filePath of files) {

for (const file of files) {

await scanUsageFile({

filePath,

filePath: file.filePath,

config: params?.config,

resolveCost,

onEntry: (entry) => {

endMs?: number;

includeFirstUserMessage?: boolean;

}): Promise<DiscoveredSession[]> {

const sessionsDir = resolveSessionTranscriptsDirForAgent(params?.agentId);

const entries = await fs.promises.readdir(sessionsDir, { withFileTypes: true }).catch(() => []);

const files = await listUsageCountedTranscriptFileStats(params?.agentId, {

minMtimeMs: params?.startMs,

});

const discovered = new Map<string, DiscoveredSession>();

for (const entry of entries) {

if (!entry.isFile() || !isUsageCountedSessionTranscriptFileName(entry.name)) {

continue;

}

const filePath = path.join(sessionsDir, entry.name);

const stats = await fs.promises.stat(filePath).catch(() => null);

if (!stats) {

continue;

}

// Filter by date range if provided

if (params?.startMs && stats.mtimeMs < params.startMs) {

continue;

}

for (const file of files) {

// Do not exclude by endMs: a session can have activity in range even if it continued later.

const filePath = file.filePath;

const fileName = path.basename(filePath);

const sessionId = parseUsageCountedSessionIdFromFileName(entry.name);

const sessionId = parseUsageCountedSessionIdFromFileName(fileName);

if (!sessionId) {

continue;

}

const isPrimaryTranscript = isPrimarySessionTranscriptFileName(entry.name);

const isPrimaryTranscript = isPrimarySessionTranscriptFileName(fileName);

// Try to read first user message for label extraction

let firstUserMessage: string | undefined;

const shouldReplace =

!existing ||

(isPrimaryTranscript && !existingIsPrimary) ||

(isPrimaryTranscript === existingIsPrimary && stats.mtimeMs >= existing.mtime);

(isPrimaryTranscript === existingIsPrimary && file.mtimeMs >= existing.mtime);

if (shouldReplace) {

discovered.set(sessionId, {

sessionId,

sessionFile: filePath,

mtime: stats.mtimeMs,

mtime: file.mtimeMs,

firstUserMessage: firstUserMessage ?? existing?.firstUserMessage,

});

continue;