@memorax/memorax-code 0.1.0

package/lib/memorax-code-backend/dist/claude-transcript-turn.js

@@ -0,0 +1,876 @@
+import { readFile } from "node:fs/promises";
+export async function readClaudeTranscriptTurn(input) {
+    let transcript;
+    try {
+        transcript = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "transcript_unavailable",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return claudeTranscriptTurnFromJsonLines(transcript, input);
+}
+export async function readClaudeInterruptedTranscriptTurn(input) {
+    let transcript;
+    try {
+        transcript = await readFile(input.transcriptPath, "utf8");
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: "transcript_unavailable",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    return claudeInterruptedTranscriptTurnFromJsonLines(transcript, input);
+}
+export function claudeTranscriptTurnFromJsonLines(transcript, input) {
+    const requested = requestedTranscriptRecords(transcript, input.sessionId);
+    if (!requested.ok)
+        return requested;
+    const records = requested.records;
+    const promptRecords = records.filter((record) => (promptIdFromRecord(record) === input.promptId && isInteractiveUserRecord(record)));
+    if (promptRecords.length === 0)
+        return { ok: false, reason: "turn_not_found" };
+    const sessionTurnIndex = interactivePromptIndex(records, input.promptId);
+    const recordsByUuid = indexRecordsByUuid(records);
+    const candidates = [];
+    let ambiguousBranch = false;
+    for (const record of records) {
+        if (!isCompletedAssistantRecord(record))
+            continue;
+        const assistantReply = completedAssistantReply(record);
+        const branch = promptBranch(record, recordsByUuid);
+        if (branch.ambiguous) {
+            ambiguousBranch = true;
+            continue;
+        }
+        if (branch.promptId === input.promptId && branch.userPrompt) {
+            const usage = aggregateClaudeUsage(branch.assistantMessages);
+            candidates.push({
+                branch,
+                userPrompt: branch.userPrompt,
+                ...(assistantReply ? { assistantReply } : {}),
+                activities: claudeMemoryActivities(branch.assistantMessages),
+                ...(usage ? { usage } : {}),
+            });
+        }
+    }
+    const terminalCandidates = maximalTerminalLineages(candidates);
+    if (ambiguousBranch || terminalCandidates.length > 1) {
+        return { ok: false, reason: "turn_ambiguous" };
+    }
+    const candidate = terminalCandidates[0];
+    if (candidate?.assistantReply && sessionTurnIndex !== undefined) {
+        return {
+            ok: true,
+            turn: {
+                sessionId: input.sessionId,
+                promptId: input.promptId,
+                sessionTurnIndex,
+                userPrompt: candidate.userPrompt,
+                assistantReply: candidate.assistantReply,
+                activities: candidate.activities,
+                ...(candidate.usage ? { usage: candidate.usage } : {}),
+            },
+        };
+    }
+    if (!promptRecords.some((record) => visibleUserPrompt(record))) {
+        return { ok: false, reason: "user_prompt_missing" };
+    }
+    return { ok: false, reason: "assistant_message_missing" };
+}
+export function claudeInterruptedTranscriptTurnFromJsonLines(transcript, input) {
+    const requested = requestedTranscriptRecords(transcript, input.sessionId);
+    if (!requested.ok)
+        return requested;
+    const records = requested.records;
+    const promptRecords = records.filter((record) => (promptIdFromRecord(record) === input.promptId && isInteractiveUserRecord(record)));
+    if (promptRecords.length === 0)
+        return { ok: false, reason: "turn_not_found" };
+    const sessionTurnIndex = interactivePromptIndex(records, input.promptId);
+    const recordsByUuid = indexRecordsByUuid(records);
+    const candidates = [];
+    let ambiguousBranch = false;
+    for (const record of records) {
+        if (!interruptionMarker(record))
+            continue;
+        const prompt = promptOnBranch(record, recordsByUuid, input.promptId);
+        if (prompt.ambiguous) {
+            ambiguousBranch = true;
+            continue;
+        }
+        if (!prompt.userPrompt || !prompt.assistantMessages)
+            continue;
+        if (prompt.assistantMessages.some((message) => message.stop_reason === "end_turn"))
+            continue;
+        const usage = aggregateClaudeUsage(prompt.assistantMessages);
+        const interruptedAt = transcriptRecordTimestamp(record);
+        candidates.push({
+            userPrompt: prompt.userPrompt,
+            assistantReply: interruptedAssistantReply(prompt.assistantMessages),
+            activities: claudeMemoryActivities(prompt.assistantMessages),
+            ...(usage ? { usage } : {}),
+            ...(interruptedAt ? { interruptedAt } : {}),
+        });
+    }
+    if (ambiguousBranch || candidates.length > 1) {
+        return { ok: false, reason: "turn_ambiguous" };
+    }
+    const candidate = candidates[0];
+    if (candidate && sessionTurnIndex !== undefined) {
+        return {
+            ok: true,
+            turn: {
+                sessionId: input.sessionId,
+                promptId: input.promptId,
+                sessionTurnIndex,
+                ...candidate,
+            },
+        };
+    }
+    if (!promptRecords.some((record) => visibleUserPrompt(record))) {
+        return { ok: false, reason: "user_prompt_missing" };
+    }
+    return { ok: false, reason: "turn_not_interrupted" };
+}
+export function claudeTranscriptMemoryActivitiesFromJsonLines(transcript, input) {
+    const requested = requestedTranscriptRecords(transcript, input.sessionId);
+    if (!requested.ok)
+        return [];
+    const records = requested.records;
+    const recordsByUuid = indexRecordsByUuid(records);
+    const terminals = new Map();
+    const interrupted = new Map();
+    for (const record of records) {
+        if (isMemoryActivityTerminalAssistantRecord(record)) {
+            const branch = promptBranch(record, recordsByUuid);
+            if (!branch.ambiguous && branch.promptId && branch.userPrompt) {
+                const candidates = terminals.get(branch.promptId) ?? [];
+                candidates.push(branch);
+                terminals.set(branch.promptId, candidates);
+            }
+            continue;
+        }
+        if (!interruptionMarker(record))
+            continue;
+        const branch = promptBranch(record, recordsByUuid);
+        if (branch.ambiguous
+            || !branch.promptId
+            || !branch.userPrompt
+            || branch.assistantMessages.some((message) => message.stop_reason === "end_turn")) {
+            continue;
+        }
+        const candidates = interrupted.get(branch.promptId) ?? [];
+        candidates.push(branch);
+        interrupted.set(branch.promptId, candidates);
+    }
+    const activities = [];
+    const promptIds = new Set([...terminals.keys(), ...interrupted.keys()]);
+    for (const promptId of promptIds) {
+        const terminalBranches = maximalTerminalLineages((terminals.get(promptId) ?? []).map((branch) => ({ branch }))).map((candidate) => candidate.branch);
+        const interruptedBranches = interrupted.get(promptId) ?? [];
+        const branch = terminalBranches.length === 1
+            ? terminalBranches[0]
+            : terminalBranches.length === 0 && interruptedBranches.length === 1
+                ? interruptedBranches[0]
+                : undefined;
+        if (!branch)
+            continue;
+        activities.push(...claudeMemoryActivityDetails(promptId, branch, input.includeAuthority === true));
+    }
+    return activities;
+}
+function requestedTranscriptRecords(transcript, sessionId) {
+    const parsed = transcriptRecords(transcript);
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            reason: "transcript_unavailable",
+            error: "Claude transcript contains an invalid completed JSONL record.",
+        };
+    }
+    const records = requestedSessionRecords(parsed.records, sessionId);
+    return records
+        ? { ok: true, records }
+        : { ok: false, reason: "transcript_session_mismatch" };
+}
+function indexRecordsByUuid(records) {
+    const indexed = new Map();
+    for (const record of records) {
+        const uuid = stringValue(record.uuid);
+        if (uuid)
+            indexed.set(uuid, record);
+    }
+    return indexed;
+}
+function requestedSessionRecords(records, requestedSessionId) {
+    let requestedSessionStart;
+    for (const [index, record] of records.entries()) {
+        const sessionId = sessionIdFromRecord(record);
+        if (!sessionId)
+            continue;
+        if (requestedSessionStart === undefined) {
+            if (sessionId === requestedSessionId)
+                requestedSessionStart = index;
+            continue;
+        }
+        if (sessionId !== requestedSessionId)
+            return undefined;
+    }
+    return requestedSessionStart === undefined
+        ? undefined
+        : records.slice(requestedSessionStart);
+}
+function transcriptRecords(transcript) {
+    const records = [];
+    const lines = transcript.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (!isRecord(parsed))
+                return { ok: false };
+            records.push(parsed);
+        }
+        catch {
+            // Claude may append while the file is being read; only an unterminated tail can be incomplete.
+            if (records.length > 0 && index === lines.length - 1 && !transcript.endsWith("\n"))
+                continue;
+            return { ok: false };
+        }
+    }
+    return { ok: true, records };
+}
+function maximalTerminalLineages(candidates) {
+    const indexesByRecord = new Map();
+    const indexesByUuid = new Map();
+    for (const [index, candidate] of candidates.entries()) {
+        const terminal = candidate.branch.records[0];
+        if (!terminal)
+            continue;
+        indexesByRecord.set(terminal, [...(indexesByRecord.get(terminal) ?? []), index]);
+        const uuid = stringValue(terminal.uuid);
+        if (uuid)
+            indexesByUuid.set(uuid, [...(indexesByUuid.get(uuid) ?? []), index]);
+    }
+    const superseded = new Set();
+    for (const [descendantIndex, candidate] of candidates.entries()) {
+        for (const ancestor of candidate.branch.records.slice(1)) {
+            const ancestorUuid = stringValue(ancestor.uuid);
+            const indexes = new Set([
+                ...(indexesByRecord.get(ancestor) ?? []),
+                ...(ancestorUuid ? indexesByUuid.get(ancestorUuid) ?? [] : []),
+            ]);
+            for (const ancestorIndex of indexes) {
+                if (ancestorIndex !== descendantIndex)
+                    superseded.add(ancestorIndex);
+            }
+        }
+    }
+    return candidates.filter((candidate, index) => (Boolean(candidate.branch.records[0]) && !superseded.has(index)));
+}
+function promptBranch(terminal, recordsByUuid) {
+    const visited = new Set();
+    const assistantMessages = [];
+    const branchRecords = [];
+    let current = terminal;
+    while (current) {
+        branchRecords.push(current);
+        const uuid = stringValue(current.uuid);
+        if (uuid) {
+            if (visited.has(uuid))
+                return { assistantMessages, records: branchRecords, ambiguous: true };
+            visited.add(uuid);
+        }
+        const assistantMessage = assistantMessageFromRecord(current);
+        if (assistantMessage)
+            assistantMessages.push(assistantMessage);
+        const prompt = visibleUserPrompt(current);
+        if (prompt) {
+            return {
+                promptId: promptIdFromRecord(current),
+                userPrompt: prompt,
+                assistantMessages,
+                records: branchRecords,
+                ambiguous: false,
+            };
+        }
+        const parentUuid = stringValue(current.parentUuid) ?? stringValue(current.parent_uuid);
+        current = parentUuid ? recordsByUuid.get(parentUuid) : undefined;
+    }
+    return { assistantMessages, records: branchRecords, ambiguous: false };
+}
+function promptOnBranch(assistant, recordsByUuid, promptId) {
+    const branch = promptBranch(assistant, recordsByUuid);
+    if (branch.ambiguous)
+        return { ambiguous: true };
+    return branch.promptId === promptId && branch.userPrompt
+        ? {
+            userPrompt: branch.userPrompt,
+            assistantMessages: branch.assistantMessages,
+            ambiguous: false,
+        }
+        : { ambiguous: false };
+}
+function visibleUserPrompt(record) {
+    if (!isInteractiveUserRecord(record))
+        return undefined;
+    const message = record.message;
+    return visibleMessageText(message.content);
+}
+function isInteractiveUserRecord(record) {
+    if (record.type !== "user"
+        || record.userType !== "external"
+        || record.isSidechain === true
+        || record.isMeta === true
+        || record.isCompactSummary === true
+        || record.isVisibleInTranscriptOnly === true) {
+        return false;
+    }
+    const origin = isRecord(record.origin) ? record.origin : undefined;
+    if (stringValue(origin?.kind)?.toLowerCase() === "task-notification"
+        || stringValue(record.promptSource ?? record.prompt_source)?.toLowerCase() === "system"
+        || stringValue(record.interruptedMessageId ?? record.interrupted_message_id)) {
+        return false;
+    }
+    const message = isRecord(record.message) ? record.message : undefined;
+    return Boolean(message && message.role === "user");
+}
+function interactivePromptIndex(records, targetPromptId) {
+    const seenPromptIds = new Set();
+    let index = 0;
+    for (const record of records) {
+        if (!visibleUserPrompt(record))
+            continue;
+        const promptId = promptIdFromRecord(record);
+        if (!promptId || seenPromptIds.has(promptId))
+            continue;
+        seenPromptIds.add(promptId);
+        index += 1;
+        if (promptId === targetPromptId)
+            return index;
+    }
+    return undefined;
+}
+function interruptionMarker(record) {
+    return record.type === "user"
+        && record.isSidechain !== true
+        && Boolean(stringValue(record.interruptedMessageId ?? record.interrupted_message_id));
+}
+function interruptedAssistantReply(assistantMessages) {
+    const textSegments = [];
+    const seenByMessageId = new Set();
+    for (const message of assistantMessages.slice().reverse()) {
+        const text = visibleMessageText(message.content);
+        if (!text)
+            continue;
+        const messageId = stringValue(message.id);
+        const dedupeKey = messageId ? `${messageId}\u0000${text}` : undefined;
+        if (dedupeKey && seenByMessageId.has(dedupeKey))
+            continue;
+        if (dedupeKey)
+            seenByMessageId.add(dedupeKey);
+        textSegments.push(text);
+    }
+    return textSegments.join("\n\n");
+}
+function transcriptRecordTimestamp(record) {
+    const timestamp = stringValue(record.timestamp);
+    return timestamp && Number.isFinite(Date.parse(timestamp)) ? timestamp : undefined;
+}
+function claudeMemoryActivityDetails(promptId, branch, includeAuthority) {
+    const activities = [];
+    const terminalRecordId = includeAuthority
+        ? stringValue(branch.records[0]?.uuid)
+        : undefined;
+    const seenToolUseIds = new Set();
+    let index = 1;
+    for (const record of branch.records.slice().reverse()) {
+        const message = assistantMessageFromRecord(record);
+        if (!message || !Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (!isRecord(block) || block.type !== "tool_use")
+                continue;
+            const toolUseId = stringValue(block.id);
+            if (!toolUseId || seenToolUseIds.has(toolUseId))
+                continue;
+            seenToolUseIds.add(toolUseId);
+            if (block.name !== "Bash")
+                continue;
+            const toolInput = isRecord(block.input) ? block.input : undefined;
+            const command = toolInput ? stringValue(toolInput.command) : undefined;
+            if (!command)
+                continue;
+            const types = memoryCliCommandTypes(command);
+            if (types.length === 0)
+                continue;
+            const timestamp = canonicalTranscriptActivityTimestamp(record);
+            const result = claudeToolResultDetails(branch.records, toolUseId, types.length === 1 && types[0] === "memory_cli_search");
+            for (const [occurrence, type] of types.entries()) {
+                activities.push({
+                    promptId,
+                    index,
+                    occurrence: occurrence + 1,
+                    type,
+                    toolUseId,
+                    ...(terminalRecordId ? { terminalRecordId } : {}),
+                    ...(timestamp ? { timestamp } : {}),
+                    ...(result.ok === undefined ? {} : { ok: result.ok }),
+                    ...(type === "memory_cli_search" && result.itemCount !== undefined
+                        ? { itemCount: result.itemCount }
+                        : {}),
+                });
+            }
+            index += 1;
+        }
+    }
+    return activities;
+}
+function canonicalTranscriptActivityTimestamp(record) {
+    const timestamp = transcriptRecordTimestamp(record);
+    return timestamp ? new Date(Date.parse(timestamp)).toISOString() : undefined;
+}
+function claudeToolResultDetails(branchRecords, toolUseId, deriveSearchItemCount) {
+    const matches = [];
+    let failed = false;
+    for (const record of branchRecords) {
+        const message = isRecord(record.message) ? record.message : undefined;
+        if (message?.role !== "user" || !Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (!isRecord(block)
+                || block.type !== "tool_result"
+                || stringValue(block.tool_use_id ?? block.toolUseId) !== toolUseId) {
+                continue;
+            }
+            matches.push(block);
+            if (block.is_error === true)
+                failed = true;
+        }
+    }
+    if (matches.length === 0)
+        return {};
+    if (failed)
+        return { ok: false };
+    if (!deriveSearchItemCount || matches.length !== 1)
+        return { ok: true };
+    const itemCount = safeMemorySearchItemCount(matches[0]?.content);
+    return itemCount === undefined ? { ok: true } : { ok: true, itemCount };
+}
+function memoryCliCommandTypes(command) {
+    const activities = [];
+    for (const segment of shellCommandSegments(command)) {
+        const words = shellWords(segment);
+        if (!words)
+            continue;
+        let executableIndex = 0;
+        while (isShellAssignmentWord(words[executableIndex]))
+            executableIndex += 1;
+        const executable = words[executableIndex];
+        if (!isMemoraxCliExecutable(executable))
+            continue;
+        const operation = words[executableIndex + 1]?.toLowerCase();
+        if (operation === "search")
+            activities.push("memory_cli_search");
+        if (operation === "add")
+            activities.push("memory_cli_add");
+    }
+    return activities;
+}
+function shellCommandSegments(command) {
+    const segments = [];
+    let segment = "";
+    let quote;
+    let escaped = false;
+    let substitutionDepth = 0;
+    const pushSegment = () => {
+        if (segment.trim())
+            segments.push(segment);
+        segment = "";
+    };
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index] ?? "";
+        if (escaped) {
+            segment += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            segment += character;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            segment += character;
+            if (character === quote)
+                quote = undefined;
+            continue;
+        }
+        if (character === "'" || character === "\"" || character === "`") {
+            quote = character;
+            segment += character;
+            continue;
+        }
+        if (character === "$" && command[index + 1] === "(") {
+            substitutionDepth += 1;
+            segment += "$(";
+            index += 1;
+            continue;
+        }
+        if (character === ")" && substitutionDepth > 0) {
+            substitutionDepth -= 1;
+            segment += character;
+            continue;
+        }
+        if (substitutionDepth === 0 && (character === ";" || character === "\n" || character === "\r")) {
+            pushSegment();
+            if (character === "\r" && command[index + 1] === "\n")
+                index += 1;
+            continue;
+        }
+        if (substitutionDepth === 0
+            && ((character === "&" && command[index + 1] === "&")
+                || (character === "|" && command[index + 1] === "|"))) {
+            pushSegment();
+            index += 1;
+            continue;
+        }
+        segment += character;
+    }
+    pushSegment();
+    return segments;
+}
+function shellWords(segment) {
+    const words = [];
+    let word = "";
+    let hasWord = false;
+    let quote;
+    for (let index = 0; index < segment.length; index += 1) {
+        const character = segment[index] ?? "";
+        if (quote === "'") {
+            if (character === "'")
+                quote = undefined;
+            else
+                word += character;
+            hasWord = true;
+            continue;
+        }
+        if (quote === "\"") {
+            if (character === "\"") {
+                quote = undefined;
+            }
+            else if (character === "\\"
+                && ["\\", "\"", "$", "`", "\n"].includes(segment[index + 1] ?? "")) {
+                index += 1;
+                word += segment[index] ?? "";
+            }
+            else {
+                word += character;
+            }
+            hasWord = true;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            hasWord = true;
+            continue;
+        }
+        if (character === "\\") {
+            index += 1;
+            if (index >= segment.length)
+                return undefined;
+            word += segment[index] ?? "";
+            hasWord = true;
+            continue;
+        }
+        if (/\s/u.test(character)) {
+            if (hasWord)
+                words.push(word);
+            word = "";
+            hasWord = false;
+            continue;
+        }
+        word += character;
+        hasWord = true;
+    }
+    if (quote)
+        return undefined;
+    if (hasWord)
+        words.push(word);
+    return words;
+}
+function isShellAssignmentWord(word) {
+    return Boolean(word && /^[A-Za-z_][A-Za-z0-9_]*=/u.test(word));
+}
+function isMemoraxCliExecutable(word) {
+    return isNamedExecutable(word, "memorax-cli");
+}
+function isNamedExecutable(word, name) {
+    if (!word)
+        return false;
+    const normalized = word.replaceAll("\\", "/");
+    if (normalized === name || normalized === `${name}.mjs`)
+        return true;
+    const absolute = normalized.startsWith("/") || /^[A-Za-z]:\//u.test(normalized);
+    if (!absolute)
+        return false;
+    const basename = normalized.slice(normalized.lastIndexOf("/") + 1);
+    return basename === name || basename === `${name}.mjs`;
+}
+function safeMemorySearchItemCount(content) {
+    if (typeof content !== "string" || content.length > 2 * 1024 * 1024)
+        return undefined;
+    const output = content.trim();
+    if (!output)
+        return undefined;
+    if (output.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(output);
+            if (!isRecord(parsed)
+                || parsed.ok !== true
+                || parsed.action !== "memory.search"
+                || !Array.isArray(parsed.items)
+                || parsed.items.length > 100) {
+                return undefined;
+            }
+            return parsed.items.length;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    const lines = output.split(/\r?\n/u);
+    if (lines[0] !== "<memories>" || lines.at(-1) !== "</memories>")
+        return undefined;
+    let insideFacts = false;
+    let factsGroups = 0;
+    let itemCount = 0;
+    for (const line of lines.slice(1, -1)) {
+        if (!insideFacts && /^ {2}<facts(?: memory_type="[^"\r\n]*")?>$/u.test(line)) {
+            insideFacts = true;
+            factsGroups += 1;
+            continue;
+        }
+        if (insideFacts && line === "  </facts>") {
+            insideFacts = false;
+            continue;
+        }
+        if (insideFacts && /^ {3}-(?:\[[^\]\r\n]+\] | )\S.*$/u.test(line)) {
+            itemCount += 1;
+            if (itemCount > 100)
+                return undefined;
+            continue;
+        }
+        return undefined;
+    }
+    return !insideFacts && factsGroups > 0 && itemCount > 0 ? itemCount : undefined;
+}
+function claudeMemoryActivities(assistantMessages) {
+    const activities = [];
+    const seenToolUseIds = new Set();
+    let index = 1;
+    for (const message of assistantMessages.slice().reverse()) {
+        if (!Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (!isRecord(block) || block.type !== "tool_use")
+                continue;
+            const toolUseId = stringValue(block.id);
+            if (!toolUseId || seenToolUseIds.has(toolUseId))
+                continue;
+            seenToolUseIds.add(toolUseId);
+            if (block.name !== "Bash")
+                continue;
+            const toolInput = isRecord(block.input) ? block.input : undefined;
+            const command = toolInput ? stringValue(toolInput.command) : undefined;
+            if (!command)
+                continue;
+            const types = memoryCliCommandTypes(command);
+            if (types.length === 0)
+                continue;
+            for (const type of types) {
+                activities.push({
+                    index,
+                    type,
+                });
+            }
+            index += 1;
+        }
+    }
+    return activities;
+}
+const CLAUDE_USAGE_COUNT_FIELDS = [
+    "input_tokens",
+    "cache_creation_input_tokens",
+    "cache_read_input_tokens",
+    "output_tokens",
+    "ephemeral_1h_input_tokens",
+    "ephemeral_5m_input_tokens",
+    "web_search_requests",
+    "web_fetch_requests",
+];
+function aggregateClaudeUsage(assistantMessages) {
+    const usageByMessageId = new Map();
+    const totals = emptyClaudeUsageCounts();
+    for (const message of assistantMessages) {
+        const messageId = stringValue(message.id);
+        const usage = claudeUsageCounts(message.usage);
+        if (!messageId || !usage)
+            return undefined;
+        const existing = usageByMessageId.get(messageId);
+        if (existing) {
+            if (!sameClaudeUsageCounts(existing, usage))
+                return undefined;
+            continue;
+        }
+        usageByMessageId.set(messageId, usage);
+        if (!addClaudeUsageCounts(totals, usage))
+            return undefined;
+    }
+    return usageByMessageId.size > 0 ? claudeTokenUsage(totals) : undefined;
+}
+function claudeUsageCounts(value) {
+    if (!isRecord(value))
+        return undefined;
+    const inputTokens = nonNegativeInteger(value.input_tokens);
+    const cacheCreationInputTokens = nullableNonNegativeInteger(value.cache_creation_input_tokens);
+    const cacheReadInputTokens = nullableNonNegativeInteger(value.cache_read_input_tokens);
+    const outputTokens = nonNegativeInteger(value.output_tokens);
+    const cacheCreation = nullableUsageGroup(value.cache_creation, [
+        "ephemeral_1h_input_tokens",
+        "ephemeral_5m_input_tokens",
+    ]);
+    const serverToolUse = nullableUsageGroup(value.server_tool_use, [
+        "web_search_requests",
+        "web_fetch_requests",
+    ]);
+    if (inputTokens === undefined
+        || cacheCreationInputTokens === undefined
+        || cacheReadInputTokens === undefined
+        || outputTokens === undefined
+        || !cacheCreation
+        || !serverToolUse) {
+        return undefined;
+    }
+    return {
+        input_tokens: inputTokens,
+        cache_creation_input_tokens: cacheCreationInputTokens,
+        cache_read_input_tokens: cacheReadInputTokens,
+        output_tokens: outputTokens,
+        ephemeral_1h_input_tokens: cacheCreation.ephemeral_1h_input_tokens,
+        ephemeral_5m_input_tokens: cacheCreation.ephemeral_5m_input_tokens,
+        web_search_requests: serverToolUse.web_search_requests,
+        web_fetch_requests: serverToolUse.web_fetch_requests,
+    };
+}
+function nullableUsageGroup(value, fields) {
+    if (value === null) {
+        return Object.fromEntries(fields.map((field) => [field, 0]));
+    }
+    if (!isRecord(value))
+        return undefined;
+    const entries = fields.map((field) => [field, nonNegativeInteger(value[field])]);
+    if (entries.some(([, count]) => count === undefined))
+        return undefined;
+    return Object.fromEntries(entries);
+}
+function sameClaudeUsageCounts(left, right) {
+    return CLAUDE_USAGE_COUNT_FIELDS.every((field) => left[field] === right[field]);
+}
+function addClaudeUsageCounts(total, next) {
+    for (const field of CLAUDE_USAGE_COUNT_FIELDS) {
+        const sum = total[field] + next[field];
+        if (!Number.isSafeInteger(sum))
+            return false;
+        total[field] = sum;
+    }
+    return true;
+}
+function emptyClaudeUsageCounts() {
+    return Object.fromEntries(CLAUDE_USAGE_COUNT_FIELDS.map((field) => [field, 0]));
+}
+function claudeTokenUsage(counts) {
+    return {
+        input_tokens: counts.input_tokens,
+        cache_creation_input_tokens: counts.cache_creation_input_tokens,
+        cache_read_input_tokens: counts.cache_read_input_tokens,
+        output_tokens: counts.output_tokens,
+        cache_creation: {
+            ephemeral_1h_input_tokens: counts.ephemeral_1h_input_tokens,
+            ephemeral_5m_input_tokens: counts.ephemeral_5m_input_tokens,
+        },
+        server_tool_use: {
+            web_search_requests: counts.web_search_requests,
+            web_fetch_requests: counts.web_fetch_requests,
+        },
+    };
+}
+function completedAssistantReply(record) {
+    const message = assistantMessageFromRecord(record);
+    if (!message || message.stop_reason !== "end_turn")
+        return undefined;
+    return visibleMessageText(message.content);
+}
+function isCompletedAssistantRecord(record) {
+    return assistantMessageFromRecord(record)?.stop_reason === "end_turn";
+}
+function isMemoryActivityTerminalAssistantRecord(record) {
+    const message = assistantMessageFromRecord(record);
+    const stopReason = message ? stringValue(message.stop_reason) : undefined;
+    return Boolean(message && ((stopReason && stopReason !== "tool_use")
+        || record.isApiErrorMessage === true
+        || record.error));
+}
+function assistantMessageFromRecord(record) {
+    if (record.type !== "assistant"
+        || record.isSidechain === true
+        || record.isMeta === true
+        || record.isCompactSummary === true
+        || record.isVisibleInTranscriptOnly === true) {
+        return undefined;
+    }
+    const message = isRecord(record.message) ? record.message : undefined;
+    return message?.role === "assistant" ? message : undefined;
+}
+function visibleMessageText(content) {
+    if (typeof content === "string")
+        return nonBlankString(content);
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .map((part) => isRecord(part) && part.type === "text" ? nonBlankString(part.text) : undefined)
+        .filter(isString)
+        .join("\n\n")
+        .trim();
+    return text || undefined;
+}
+function sessionIdFromRecord(record) {
+    return stringValue(record.sessionId) ?? stringValue(record.session_id);
+}
+function promptIdFromRecord(record) {
+    return stringValue(record.promptId) ?? stringValue(record.prompt_id);
+}
+function nonBlankString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function nonNegativeInteger(value) {
+    return Number.isSafeInteger(value) && Number(value) >= 0 ? Number(value) : undefined;
+}
+function nullableNonNegativeInteger(value) {
+    return value === null ? 0 : nonNegativeInteger(value);
+}
+function isString(value) {
+    return value !== undefined;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}