waypoi 0.0.0

package/dist/src/storage/captureRepository.js

@@ -0,0 +1,1591 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureCaptureStore = ensureCaptureStore;
+exports.getCaptureConfig = getCaptureConfig;
+exports.updateCaptureConfig = updateCaptureConfig;
+exports.isCaptureEnabled = isCaptureEnabled;
+exports.persistCaptureRecord = persistCaptureRecord;
+exports.runCaptureRetention = runCaptureRetention;
+exports.listCaptureRecords = listCaptureRecords;
+exports.getCaptureRecordById = getCaptureRecordById;
+exports.getCaptureCalendarMonth = getCaptureCalendarMonth;
+exports.findCaptureBlobPath = findCaptureBlobPath;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const DEFAULT_CAPTURE_CONFIG = {
+    enabled: false,
+    retentionDays: 30,
+    maxBytes: 20 * 1024 * 1024 * 1024,
+};
+const DATA_URL_RE = /^data:([^;]+);base64,(.+)$/i;
+function captureDir(paths) {
+    return path_1.default.join(paths.baseDir, "capture");
+}
+function captureConfigPath(paths) {
+    return path_1.default.join(captureDir(paths), "config.json");
+}
+function captureIndexPath(paths) {
+    return path_1.default.join(captureDir(paths), "index.jsonl");
+}
+function captureRecordsDir(paths) {
+    return path_1.default.join(captureDir(paths), "records");
+}
+function captureBlobsDir(paths) {
+    return path_1.default.join(captureDir(paths), "blobs");
+}
+async function ensureCaptureStore(paths) {
+    await fs_1.promises.mkdir(captureDir(paths), { recursive: true });
+    await fs_1.promises.mkdir(captureRecordsDir(paths), { recursive: true });
+    await fs_1.promises.mkdir(captureBlobsDir(paths), { recursive: true });
+    const configPath = captureConfigPath(paths);
+    try {
+        await fs_1.promises.access(configPath);
+    }
+    catch {
+        await fs_1.promises.writeFile(configPath, JSON.stringify(DEFAULT_CAPTURE_CONFIG, null, 2), "utf8");
+    }
+}
+async function getCaptureConfig(paths) {
+    await ensureCaptureStore(paths);
+    try {
+        const raw = await fs_1.promises.readFile(captureConfigPath(paths), "utf8");
+        const parsed = JSON.parse(raw);
+        return normalizeCaptureConfig(parsed);
+    }
+    catch {
+        return { ...DEFAULT_CAPTURE_CONFIG };
+    }
+}
+async function updateCaptureConfig(paths, patch) {
+    const current = await getCaptureConfig(paths);
+    const next = normalizeCaptureConfig({ ...current, ...patch });
+    await fs_1.promises.writeFile(captureConfigPath(paths), JSON.stringify(next, null, 2), "utf8");
+    return next;
+}
+async function isCaptureEnabled(paths) {
+    const config = await getCaptureConfig(paths);
+    return config.enabled;
+}
+async function persistCaptureRecord(paths, input) {
+    const config = await getCaptureConfig(paths);
+    if (!config.enabled) {
+        return null;
+    }
+    const id = (0, crypto_1.randomUUID)();
+    const now = new Date();
+    const timestamp = now.toISOString();
+    const artifacts = [];
+    const requestBodyPreview = await buildPreviewBody(paths, input.requestBody, artifacts);
+    const responseBodyPreview = await buildPreviewBody(paths, input.responseBody, artifacts);
+    const record = {
+        id,
+        timestamp,
+        route: input.route,
+        method: input.method,
+        captureEnabledSnapshot: true,
+        statusCode: input.statusCode,
+        latencyMs: input.latencyMs,
+        request: {
+            headers: normalizeHeaderRecord(input.requestHeaders),
+            body: input.requestBody,
+            derived: input.derivedRequest,
+        },
+        response: {
+            headers: normalizeHeaderRecord(input.responseHeaders),
+            body: input.responseBody,
+            error: input.error,
+        },
+        routing: input.routing ?? {},
+        analysis: buildAnalysisProjection(input.route, input.requestBody, input.responseBody, input.derivedRequest),
+        artifacts,
+    };
+    // Attach preview representations in derived block for UI readability.
+    if (requestBodyPreview !== undefined || responseBodyPreview !== undefined) {
+        record.request.derived = {
+            ...(record.request.derived ?? {}),
+            preview: {
+                request: requestBodyPreview,
+                response: responseBodyPreview,
+            },
+        };
+    }
+    const datePath = path_1.default.join(captureRecordsDir(paths), `${now.getUTCFullYear()}`, `${String(now.getUTCMonth() + 1).padStart(2, "0")}`, `${String(now.getUTCDate()).padStart(2, "0")}`);
+    await fs_1.promises.mkdir(datePath, { recursive: true });
+    const fileName = `${timestamp.replace(/[:.]/g, "-")}_${id}.json`;
+    const absoluteRecordPath = path_1.default.join(datePath, fileName);
+    await fs_1.promises.writeFile(absoluteRecordPath, JSON.stringify(record, null, 2), "utf8");
+    const relRecordPath = path_1.default.relative(captureDir(paths), absoluteRecordPath);
+    const entry = {
+        id,
+        timestamp,
+        route: input.route,
+        method: input.method,
+        statusCode: input.statusCode,
+        latencyMs: input.latencyMs,
+        model: input.routing?.publicModel,
+        file: relRecordPath,
+    };
+    await fs_1.promises.appendFile(captureIndexPath(paths), `${JSON.stringify(entry)}\n`, "utf8");
+    await applyCaptureRetention(paths, config);
+    return record;
+}
+async function runCaptureRetention(paths) {
+    const config = await getCaptureConfig(paths);
+    await applyCaptureRetention(paths, config);
+}
+async function listCaptureRecords(paths, options = 5) {
+    await ensureCaptureStore(paths);
+    const entries = await readCaptureIndex(paths, { pruneMissing: true });
+    const opts = typeof options === "number"
+        ? { limit: options, offset: 0 }
+        : { limit: 5, offset: 0, ...options };
+    const timeZone = normalizeTimeZone(opts.timeZone);
+    const limit = Math.max(1, Math.min(200, Math.floor(opts.limit ?? 5)));
+    const offset = Math.max(0, Math.floor(opts.offset ?? 0));
+    const filtered = opts.date
+        ? entries.filter((entry) => dateStringForTimeZone(entry.timestamp, timeZone) === opts.date)
+        : entries;
+    const newestFirst = [...filtered].reverse();
+    return {
+        data: newestFirst.slice(offset, offset + limit),
+        total: filtered.length,
+    };
+}
+async function getCaptureRecordById(paths, id) {
+    const entries = await readCaptureIndex(paths, { pruneMissing: true });
+    const match = entries.find((entry) => entry.id === id);
+    if (!match) {
+        return null;
+    }
+    const absolute = path_1.default.join(captureDir(paths), match.file);
+    try {
+        const raw = await fs_1.promises.readFile(absolute, "utf8");
+        return hydrateCaptureRecord(JSON.parse(raw));
+    }
+    catch {
+        return null;
+    }
+}
+async function getCaptureCalendarMonth(paths, month, timeZone = "UTC") {
+    await ensureCaptureStore(paths);
+    const entries = await readCaptureIndex(paths, { pruneMissing: true });
+    const normalizedTimeZone = normalizeTimeZone(timeZone);
+    const counts = new Map();
+    for (const entry of entries) {
+        const date = dateStringForTimeZone(entry.timestamp, normalizedTimeZone);
+        if (!date.startsWith(`${month}-`))
+            continue;
+        counts.set(date, (counts.get(date) ?? 0) + 1);
+    }
+    return Array.from(counts.entries())
+        .sort((a, b) => a[0].localeCompare(b[0]))
+        .map(([date, count]) => ({ date, count }));
+}
+async function findCaptureBlobPath(paths, hash) {
+    await ensureCaptureStore(paths);
+    const blobDir = captureBlobsDir(paths);
+    let files;
+    try {
+        files = await fs_1.promises.readdir(blobDir);
+    }
+    catch {
+        return null;
+    }
+    const candidate = files.find((name) => name.startsWith(`${hash}.`));
+    if (!candidate)
+        return null;
+    const ext = candidate.split(".").pop()?.toLowerCase() ?? "bin";
+    return {
+        path: path_1.default.join(blobDir, candidate),
+        mime: extToMime(ext),
+    };
+}
+function normalizeCaptureConfig(input) {
+    const retentionDays = Number.isFinite(input.retentionDays) ? Number(input.retentionDays) : DEFAULT_CAPTURE_CONFIG.retentionDays;
+    const maxBytes = Number.isFinite(input.maxBytes) ? Number(input.maxBytes) : DEFAULT_CAPTURE_CONFIG.maxBytes;
+    return {
+        enabled: input.enabled === true,
+        retentionDays: Math.max(1, Math.min(365, Math.floor(retentionDays))),
+        maxBytes: Math.max(50 * 1024 * 1024, Math.floor(maxBytes)),
+    };
+}
+function normalizeHeaderRecord(headers) {
+    const out = {};
+    if (!headers)
+        return out;
+    for (const [key, value] of Object.entries(headers)) {
+        if (!value)
+            continue;
+        out[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : String(value);
+    }
+    return out;
+}
+function buildAnalysisProjection(route, requestBody, responseBody, derived) {
+    const source = derived?.normalizedRequest ?? asRecord(requestBody);
+    const messages = Array.isArray(source?.messages) ? source.messages : [];
+    const toolsRaw = Array.isArray(source?.tools) ? source.tools : [];
+    const systemMessages = [];
+    const userMessages = [];
+    const assistantMessages = [];
+    const toolMessages = [];
+    const tools = [];
+    const mcpToolDescriptions = [];
+    const hints = new Set();
+    const rawSections = [];
+    const requestTimeline = buildRequestTimeline(source, rawSections);
+    const responseTimeline = buildResponseTimeline(responseBody);
+    for (const message of messages) {
+        const m = asRecord(message);
+        if (!m)
+            continue;
+        const role = typeof m.role === "string" ? m.role : "unknown";
+        const content = extractTextContent(m.content);
+        const reasoningContent = typeof m.reasoning_content === "string" ? m.reasoning_content : undefined;
+        const combinedText = [content, reasoningContent].filter(Boolean).join("\n\n").trim();
+        if (combinedText && /(agents\.md|guardrail|mcp|tool|policy)/i.test(combinedText)) {
+            hints.add(combinedText);
+        }
+        if (role === "system" && content) {
+            systemMessages.push({ content });
+            continue;
+        }
+        if (role === "user" && content) {
+            userMessages.push({ content });
+            continue;
+        }
+        if (role === "assistant") {
+            const assistantMessage = {
+                content,
+            };
+            if (reasoningContent)
+                assistantMessage.reasoningContent = reasoningContent;
+            const toolCalls = extractToolCalls(m.tool_calls);
+            if (toolCalls.length > 0)
+                assistantMessage.toolCalls = toolCalls;
+            if (looksLikeClarification(content))
+                assistantMessage.asksForClarification = true;
+            if (assistantMessage.content ||
+                assistantMessage.reasoningContent ||
+                (assistantMessage.toolCalls && assistantMessage.toolCalls.length > 0)) {
+                assistantMessages.push(assistantMessage);
+            }
+            continue;
+        }
+        if (role === "tool") {
+            const toolMessage = {
+                content,
+            };
+            if (typeof m.tool_call_id === "string")
+                toolMessage.toolCallId = m.tool_call_id;
+            if (toolMessage.content || toolMessage.toolCallId) {
+                toolMessages.push(toolMessage);
+            }
+        }
+    }
+    for (const tool of toolsRaw) {
+        const t = asRecord(tool);
+        if (!t)
+            continue;
+        const fn = asRecord(t.function);
+        const name = typeof fn?.name === "string" ? fn.name : undefined;
+        const description = typeof fn?.description === "string" ? fn.description : undefined;
+        if (!name)
+            continue;
+        tools.push({ name, description });
+        if (description) {
+            mcpToolDescriptions.push(`${name}: ${description}`);
+            if (/(agents\.md|guardrail|mcp|policy)/i.test(description)) {
+                hints.add(description);
+            }
+        }
+    }
+    return {
+        systemMessages,
+        userMessages,
+        assistantMessages,
+        toolMessages,
+        requestTimeline,
+        responseTimeline,
+        tools,
+        mcpToolDescriptions,
+        agentsMdHints: Array.from(hints),
+        rawSections,
+        tokenFlow: buildTokenFlowProjection(route, source, responseBody),
+    };
+}
+function buildRequestTimeline(source, rawSections) {
+    const timeline = [];
+    if (!source)
+        return timeline;
+    const push = createTimelinePusher("request", timeline);
+    if (typeof source.instructions === "string") {
+        rawSections.push("request.body.instructions");
+        push({
+            kind: "instructions",
+            role: "system",
+            sourcePath: "request.body.instructions",
+            content: source.instructions,
+        });
+    }
+    if (Array.isArray(source.messages)) {
+        rawSections.push("request.body.messages");
+        source.messages.forEach((message, idx) => pushMessageEntries(push, message, `request.body.messages[${idx}]`));
+    }
+    if (Array.isArray(source.input)) {
+        rawSections.push("request.body.input");
+        source.input.forEach((item, idx) => pushInputOutputEntry(push, item, `request.body.input[${idx}]`, "request"));
+    }
+    if (Array.isArray(source.tools)) {
+        rawSections.push("request.body.tools");
+        source.tools.forEach((tool, idx) => {
+            const t = asRecord(tool);
+            const fn = asRecord(t?.function);
+            const name = typeof fn?.name === "string" ? fn.name : undefined;
+            const description = typeof fn?.description === "string" ? fn.description : undefined;
+            push({
+                kind: "tool_definition",
+                sourcePath: `request.body.tools[${idx}]`,
+                name,
+                content: description,
+                metadata: t ?? undefined,
+            });
+        });
+    }
+    return timeline;
+}
+function buildResponseTimeline(responseBody) {
+    const timeline = [];
+    const push = createTimelinePusher("response", timeline);
+    const body = asRecord(responseBody);
+    if (!body) {
+        if (typeof responseBody === "string" && responseBody) {
+            push({ kind: "message", sourcePath: "response.body", content: responseBody });
+        }
+        return timeline;
+    }
+    if (asRecord(body.error)) {
+        const error = asRecord(body.error);
+        push({
+            kind: "error",
+            sourcePath: "response.body.error",
+            content: typeof error.message === "string" ? error.message : JSON.stringify(error, null, 2),
+            metadata: error,
+        });
+    }
+    if (body.$type === "stream") {
+        const text = typeof body.text === "string" ? body.text : undefined;
+        if (text) {
+            const merged = buildMergedSsePreview(text);
+            if (merged) {
+                push({
+                    kind: "stream_preview",
+                    sourcePath: "response.body.stream",
+                    content: merged.content,
+                    metadata: merged.metadata,
+                });
+            }
+            const streamedToolCalls = extractStreamToolCalls(text);
+            streamedToolCalls.forEach((toolCall, idx) => push({
+                kind: "tool_call",
+                role: "assistant",
+                sourcePath: `response.body.stream.tool_calls[${idx}]`,
+                name: toolCall.function?.name,
+                arguments: toolCall.function?.arguments,
+                toolCallId: toolCall.id,
+                metadata: toolCall.type ? { type: toolCall.type } : undefined,
+            }));
+        }
+        else {
+            push({
+                kind: "stream_preview",
+                sourcePath: "response.body",
+                content: typeof body.note === "string" ? body.note : "Stream response metadata only",
+                metadata: body,
+            });
+        }
+        return timeline;
+    }
+    if (Array.isArray(body.output)) {
+        body.output.forEach((item, idx) => pushInputOutputEntry(push, item, `response.body.output[${idx}]`, "response"));
+    }
+    if (Array.isArray(body.choices)) {
+        body.choices.forEach((choice, idx) => {
+            const choiceRecord = asRecord(choice);
+            const message = asRecord(choiceRecord?.message);
+            if (message) {
+                pushMessageEntries(push, message, `response.body.choices[${idx}].message`);
+            }
+        });
+    }
+    if (timeline.length === 0) {
+        push({
+            kind: "message",
+            sourcePath: "response.body",
+            content: JSON.stringify(responseBody, null, 2),
+        });
+    }
+    return timeline;
+}
+function extractTextContent(content) {
+    if (typeof content === "string") {
+        return content;
+    }
+    if (!Array.isArray(content)) {
+        return "";
+    }
+    const chunks = [];
+    for (const part of content) {
+        const p = asRecord(part);
+        if (!p)
+            continue;
+        if (p.type === "text" && typeof p.text === "string") {
+            chunks.push(p.text);
+        }
+    }
+    return chunks.join(" ");
+}
+function extractToolCalls(value) {
+    if (!Array.isArray(value))
+        return [];
+    const calls = [];
+    for (const item of value) {
+        const record = asRecord(item);
+        if (!record)
+            continue;
+        const call = {};
+        if (typeof record.id === "string")
+            call.id = record.id;
+        if (typeof record.type === "string")
+            call.type = record.type;
+        const fn = asRecord(record.function);
+        if (fn) {
+            call.function = {};
+            if (typeof fn.name === "string")
+                call.function.name = fn.name;
+            if (typeof fn.arguments === "string")
+                call.function.arguments = fn.arguments;
+            if (!call.function.name && !call.function.arguments)
+                delete call.function;
+        }
+        calls.push(call);
+    }
+    return calls;
+}
+function pushMessageEntries(push, message, sourcePath) {
+    const m = asRecord(message);
+    if (!m)
+        return;
+    const role = normalizeRole(m.role);
+    const content = extractTextContent(m.content);
+    if (content) {
+        push({
+            kind: role === "tool" ? "tool_result" : "message",
+            role,
+            sourcePath,
+            content,
+            toolCallId: typeof m.tool_call_id === "string" ? m.tool_call_id : undefined,
+        });
+    }
+    if (typeof m.reasoning_content === "string") {
+        push({
+            kind: "reasoning",
+            role: role ?? "assistant",
+            sourcePath: `${sourcePath}.reasoning_content`,
+            content: m.reasoning_content,
+        });
+    }
+    const toolCalls = extractToolCalls(m.tool_calls);
+    toolCalls.forEach((toolCall, idx) => push({
+        kind: "tool_call",
+        role: "assistant",
+        sourcePath: `${sourcePath}.tool_calls[${idx}]`,
+        name: toolCall.function?.name,
+        arguments: toolCall.function?.arguments,
+        toolCallId: toolCall.id,
+        metadata: toolCall.type ? { type: toolCall.type } : undefined,
+    }));
+}
+function pushInputOutputEntry(push, item, sourcePath, direction) {
+    const record = asRecord(item);
+    if (!record) {
+        if (typeof item === "string") {
+            push({ kind: "message", sourcePath, content: item });
+        }
+        return;
+    }
+    const type = typeof record.type === "string" ? record.type : undefined;
+    if (type === "message") {
+        const role = normalizeRole(record.role);
+        const content = extractTextContentFromResponseItem(record);
+        if (content) {
+            push({ kind: "message", role, sourcePath, content });
+        }
+        return;
+    }
+    if (type === "function_call") {
+        push({
+            kind: "tool_call",
+            role: direction === "response" ? "assistant" : undefined,
+            sourcePath,
+            name: typeof record.name === "string" ? record.name : undefined,
+            arguments: typeof record.arguments === "string" ? record.arguments : undefined,
+            toolCallId: typeof record.call_id === "string" ? record.call_id : undefined,
+        });
+        return;
+    }
+    if (type === "function_call_output") {
+        push({
+            kind: "tool_result",
+            role: "tool",
+            sourcePath,
+            content: typeof record.output === "string" ? record.output : stringifyMaybe(record.output),
+            toolCallId: typeof record.call_id === "string" ? record.call_id : undefined,
+        });
+        return;
+    }
+    if (type === "reasoning") {
+        push({
+            kind: "reasoning",
+            role: "assistant",
+            sourcePath,
+            content: extractReasoningItemText(record),
+        });
+        return;
+    }
+    push({
+        kind: "message",
+        sourcePath,
+        content: stringifyMaybe(record),
+        metadata: type ? { type } : undefined,
+    });
+}
+function looksLikeClarification(content) {
+    const text = content.trim();
+    if (!text)
+        return false;
+    return /(?:^|\b)(could you|can you|would you|which|what|do you want|please clarify|clarify)\b/i.test(text)
+        || text.includes("?");
+}
+function createTimelinePusher(direction, timeline) {
+    return (entry) => {
+        timeline.push({
+            direction,
+            index: timeline.length,
+            ...entry,
+        });
+    };
+}
+function extractTextContentFromResponseItem(item) {
+    const content = item.content;
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const chunks = [];
+    for (const part of content) {
+        const record = asRecord(part);
+        if (!record)
+            continue;
+        if (typeof record.text === "string")
+            chunks.push(record.text);
+        else if (typeof record.content === "string")
+            chunks.push(record.content);
+    }
+    return chunks.join("\n\n");
+}
+function extractReasoningItemText(item) {
+    if (typeof item.summary === "string")
+        return item.summary;
+    if (Array.isArray(item.summary)) {
+        return item.summary
+            .map((part) => {
+            const record = asRecord(part);
+            if (!record)
+                return "";
+            if (typeof record.text === "string")
+                return record.text;
+            return "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    if (typeof item.content === "string")
+        return item.content;
+    return stringifyMaybe(item);
+}
+function parseSsePreview(text) {
+    const entries = [];
+    const blocks = text.split(/\n\n+/).map((part) => part.trim()).filter(Boolean);
+    for (const block of blocks) {
+        const dataLines = block
+            .split("\n")
+            .filter((line) => line.startsWith("data:"))
+            .map((line) => line.slice(5).trim());
+        if (dataLines.length === 0)
+            continue;
+        const joined = dataLines.join("\n");
+        try {
+            const parsed = JSON.parse(joined);
+            entries.push({
+                content: stringifyMaybe(parsed),
+                metadata: parsed,
+            });
+        }
+        catch {
+            entries.push({ content: joined });
+        }
+    }
+    return entries;
+}
+function buildMergedSsePreview(text) {
+    const entries = parseSsePreview(text);
+    if (entries.length === 0)
+        return null;
+    const mergedText = mergeUsefulSseText(entries);
+    if (mergedText.trim()) {
+        return {
+            content: mergedText,
+            metadata: { events: entries.length, mode: "merged_text" },
+        };
+    }
+    return {
+        content: entries.map((entry) => entry.content).join("\n\n"),
+        metadata: { events: entries.length, mode: "merged_events" },
+    };
+}
+function extractMergedUsefulSseText(text) {
+    return mergeUsefulSseText(parseSsePreview(text));
+}
+function mergeUsefulSseText(entries) {
+    const textChunks = [];
+    for (const entry of entries) {
+        const extracted = extractStreamText(entry.metadata);
+        if (extracted) {
+            textChunks.push(extracted);
+        }
+    }
+    return textChunks.join("");
+}
+function mergeSseEventPayloadText(text) {
+    const entries = parseSsePreview(text);
+    if (entries.length === 0)
+        return "";
+    return entries.map((entry) => entry.content).join("\n\n");
+}
+function extractStreamText(value) {
+    const record = asRecord(value);
+    if (!record)
+        return "";
+    if (typeof record.delta === "string") {
+        return record.delta;
+    }
+    if (typeof record.text === "string") {
+        return record.text;
+    }
+    const choices = Array.isArray(record.choices) ? record.choices : [];
+    const choiceChunks = [];
+    for (const choice of choices) {
+        const choiceRecord = asRecord(choice);
+        if (!choiceRecord)
+            continue;
+        const delta = asRecord(choiceRecord.delta);
+        if (typeof delta?.content === "string")
+            choiceChunks.push(delta.content);
+        if (typeof delta?.reasoning_content === "string")
+            choiceChunks.push(delta.reasoning_content);
+        const message = asRecord(choiceRecord.message);
+        if (typeof message?.content === "string")
+            choiceChunks.push(message.content);
+    }
+    if (choiceChunks.length > 0) {
+        return choiceChunks.join("");
+    }
+    if (typeof record.type === "string") {
+        if (record.type === "response.output_text.delta" ||
+            record.type === "response.reasoning.delta" ||
+            record.type === "response.output_text") {
+            if (typeof record.delta === "string")
+                return record.delta;
+            if (typeof record.text === "string")
+                return record.text;
+        }
+    }
+    const output = Array.isArray(record.output) ? record.output : [];
+    const outputChunks = [];
+    for (const item of output) {
+        const itemRecord = asRecord(item);
+        if (!itemRecord)
+            continue;
+        const content = itemRecord.content;
+        if (typeof content === "string") {
+            outputChunks.push(content);
+            continue;
+        }
+        if (Array.isArray(content)) {
+            for (const part of content) {
+                const partRecord = asRecord(part);
+                if (!partRecord)
+                    continue;
+                if (typeof partRecord.text === "string")
+                    outputChunks.push(partRecord.text);
+            }
+        }
+    }
+    return outputChunks.join("");
+}
+function extractStreamToolCalls(text) {
+    const entries = parseSsePreview(text);
+    const byIndex = new Map();
+    const order = [];
+    const ensureBuilder = (index) => {
+        const existing = byIndex.get(index);
+        if (existing)
+            return existing;
+        const created = { functionName: "", functionArguments: "" };
+        byIndex.set(index, created);
+        order.push(index);
+        return created;
+    };
+    for (const entry of entries) {
+        const payload = asRecord(entry.metadata);
+        if (!payload)
+            continue;
+        const choices = Array.isArray(payload.choices) ? payload.choices : [];
+        for (const choice of choices) {
+            const choiceRecord = asRecord(choice);
+            if (!choiceRecord)
+                continue;
+            const delta = asRecord(choiceRecord.delta);
+            if (!delta)
+                continue;
+            const deltaToolCalls = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];
+            for (const item of deltaToolCalls) {
+                const callRecord = asRecord(item);
+                if (!callRecord)
+                    continue;
+                const index = typeof callRecord.index === "number" ? Math.max(0, Math.floor(callRecord.index)) : 0;
+                const builder = ensureBuilder(index);
+                if (typeof callRecord.id === "string")
+                    builder.id = callRecord.id;
+                if (typeof callRecord.type === "string")
+                    builder.type = callRecord.type;
+                const fn = asRecord(callRecord.function);
+                if (fn) {
+                    if (typeof fn.name === "string")
+                        builder.functionName += fn.name;
+                    if (typeof fn.arguments === "string")
+                        builder.functionArguments += fn.arguments;
+                }
+            }
+            const legacyFunctionCall = asRecord(delta.function_call);
+            if (legacyFunctionCall) {
+                const builder = ensureBuilder(0);
+                builder.type = builder.type ?? "function";
+                if (typeof legacyFunctionCall.name === "string")
+                    builder.functionName += legacyFunctionCall.name;
+                if (typeof legacyFunctionCall.arguments === "string")
+                    builder.functionArguments += legacyFunctionCall.arguments;
+            }
+        }
+    }
+    const calls = [];
+    for (const index of order) {
+        const built = byIndex.get(index);
+        if (!built)
+            continue;
+        const call = {};
+        if (built.id)
+            call.id = built.id;
+        if (built.type)
+            call.type = built.type;
+        const hasName = built.functionName.trim().length > 0;
+        const hasArguments = built.functionArguments.length > 0;
+        if (hasName || hasArguments) {
+            call.function = {};
+            if (hasName)
+                call.function.name = built.functionName;
+            if (hasArguments)
+                call.function.arguments = built.functionArguments;
+        }
+        if (call.id || call.type || call.function) {
+            calls.push(call);
+        }
+    }
+    return calls;
+}
+const INPUT_TOKEN_CATEGORIES = [
+    { key: "instructions", label: "Instructions" },
+    { key: "system", label: "System" },
+    { key: "developer", label: "Developer" },
+    { key: "user", label: "User" },
+    { key: "assistant_history", label: "Assistant History" },
+    { key: "input_media", label: "Input Media" },
+    { key: "tool_results", label: "Tool Results" },
+    { key: "tool_definitions", label: "Tool Definitions" },
+    { key: "unattributed_input", label: "Unattributed Input" },
+];
+const OUTPUT_TOKEN_CATEGORIES = [
+    { key: "assistant_text", label: "Assistant Text" },
+    { key: "reasoning", label: "Reasoning" },
+    { key: "tool_calls", label: "Tool Calls" },
+    { key: "tool_results", label: "Tool Results" },
+    { key: "errors", label: "Errors" },
+    { key: "unattributed_output", label: "Unattributed Output" },
+];
+function buildTokenFlowProjection(route, source, responseBody) {
+    if (!route.startsWith("/v1/chat/completions")) {
+        return {
+            eligible: false,
+            reason: "Token flow is available only for /v1/chat/completions captures.",
+            method: "unavailable",
+            totals: { inputTokens: null, outputTokens: null, totalTokens: null },
+            input: INPUT_TOKEN_CATEGORIES.map((category) => ({ ...category, tokens: 0 })),
+            output: OUTPUT_TOKEN_CATEGORIES.map((category) => ({ ...category, tokens: 0 })),
+            notes: ["Route is not eligible for token flow analysis."],
+        };
+    }
+    const usage = extractTokenUsageTotals(responseBody);
+    const estimatedInput = estimateInputCategoryTokens(source);
+    const estimatedOutput = estimateOutputCategoryTokens(responseBody);
+    const streamSource = estimatedOutput.streamSource;
+    const estimatedOutputTokens = estimatedOutput.tokens;
+    const hasExactSides = usage.inputTokens !== null && usage.outputTokens !== null;
+    if (hasExactSides) {
+        const inputExact = usage.inputTokens;
+        const outputExact = usage.outputTokens;
+        const inputBuckets = scaleCategoryTokens(INPUT_TOKEN_CATEGORIES, estimatedInput, inputExact);
+        const outputBuckets = scaleCategoryTokens(OUTPUT_TOKEN_CATEGORIES, estimatedOutputTokens, outputExact);
+        const totalTokens = usage.totalTokens ?? inputExact + outputExact;
+        const notes = [
+            "Input/output totals are exact from response usage.",
+            "Category slices are estimated from captured content structure.",
+        ];
+        if (streamSource === "timeline_text_with_tool_calls") {
+            notes.push("For streamed responses, output categories are estimated from extracted timeline-equivalent SSE text and reconstructed streamed tool-call deltas.");
+        }
+        else if (streamSource === "timeline_text") {
+            notes.push("For streamed responses, output categories are estimated from extracted timeline-equivalent SSE text.");
+        }
+        else if (streamSource === "timeline_tool_calls_only") {
+            notes.push("For streamed responses, output categories are estimated from reconstructed streamed tool-call deltas.");
+        }
+        else if (streamSource === "fallback_events") {
+            notes.push("For streamed responses, no useful SSE text was extracted; output fallback uses merged SSE event payload text (lower confidence).");
+        }
+        return {
+            eligible: true,
+            method: "exact_totals_estimated_categories",
+            totals: {
+                inputTokens: inputExact,
+                outputTokens: outputExact,
+                totalTokens,
+            },
+            input: inputBuckets,
+            output: outputBuckets,
+            notes,
+        };
+    }
+    const rawInputTotal = sumTokenMapValues(estimatedInput);
+    const rawOutputTotal = sumTokenMapValues(estimatedOutputTokens);
+    let estimatedInputTotal = rawInputTotal;
+    let estimatedOutputTotal = rawOutputTotal;
+    if (usage.totalTokens !== null && usage.totalTokens > 0 && rawInputTotal + rawOutputTotal > 0) {
+        const split = splitTotalByWeights(usage.totalTokens, [rawInputTotal, rawOutputTotal]);
+        estimatedInputTotal = split[0];
+        estimatedOutputTotal = split[1];
+    }
+    const inputBuckets = estimatedInputTotal !== rawInputTotal
+        ? scaleCategoryTokens(INPUT_TOKEN_CATEGORIES, estimatedInput, estimatedInputTotal)
+        : mapTokensToBuckets(INPUT_TOKEN_CATEGORIES, estimatedInput);
+    const outputBuckets = estimatedOutputTotal !== rawOutputTotal
+        ? scaleCategoryTokens(OUTPUT_TOKEN_CATEGORIES, estimatedOutputTokens, estimatedOutputTotal)
+        : mapTokensToBuckets(OUTPUT_TOKEN_CATEGORIES, estimatedOutputTokens);
+    const notes = [
+        "Input/output totals are estimated from captured content.",
+        "Category slices are estimated from captured content structure.",
+    ];
+    if (streamSource === "timeline_text_with_tool_calls") {
+        notes.push("For streamed responses, output categories are estimated from extracted timeline-equivalent SSE text and reconstructed streamed tool-call deltas.");
+    }
+    else if (streamSource === "timeline_text") {
+        notes.push("For streamed responses, output categories are estimated from extracted timeline-equivalent SSE text.");
+    }
+    else if (streamSource === "timeline_tool_calls_only") {
+        notes.push("For streamed responses, output categories are estimated from reconstructed streamed tool-call deltas.");
+    }
+    else if (streamSource === "fallback_events") {
+        notes.push("For streamed responses, no useful SSE text was extracted; output fallback uses merged SSE event payload text (lower confidence).");
+    }
+    return {
+        eligible: true,
+        method: "estimated_only",
+        totals: {
+            inputTokens: estimatedInputTotal,
+            outputTokens: estimatedOutputTotal,
+            totalTokens: usage.totalTokens ?? estimatedInputTotal + estimatedOutputTotal,
+        },
+        input: inputBuckets,
+        output: outputBuckets,
+        notes,
+    };
+}
+function extractTokenUsageTotals(responseBody) {
+    const body = asRecord(responseBody);
+    const usage = asRecord(body?.usage);
+    if (!usage) {
+        return { inputTokens: null, outputTokens: null, totalTokens: null };
+    }
+    const promptTokens = toNullableInt(usage.prompt_tokens);
+    const completionTokens = toNullableInt(usage.completion_tokens);
+    const inputTokens = toNullableInt(usage.input_tokens);
+    const outputTokens = toNullableInt(usage.output_tokens);
+    const totalTokens = toNullableInt(usage.total_tokens);
+    const normalizedInput = promptTokens ?? inputTokens;
+    const normalizedOutput = completionTokens ?? outputTokens;
+    const normalizedTotal = totalTokens ?? (normalizedInput !== null && normalizedOutput !== null ? normalizedInput + normalizedOutput : null);
+    return {
+        inputTokens: normalizedInput,
+        outputTokens: normalizedOutput,
+        totalTokens: normalizedTotal,
+    };
+}
+function estimateInputCategoryTokens(source) {
+    const tokens = initCategoryTokenMap(INPUT_TOKEN_CATEGORIES);
+    if (!source) {
+        return tokens;
+    }
+    if (typeof source.instructions === "string") {
+        tokens.instructions += roughTokenEstimate(source.instructions);
+    }
+    if (Array.isArray(source.messages)) {
+        for (const message of source.messages) {
+            const record = asRecord(message);
+            if (!record)
+                continue;
+            const role = normalizeRole(record.role);
+            const text = extractTextContent(record.content);
+            tokens.input_media += estimateMediaTokensFromContent(record.content);
+            if (role === "system")
+                tokens.system += roughTokenEstimate(text);
+            else if (role === "developer")
+                tokens.developer += roughTokenEstimate(text);
+            else if (role === "user")
+                tokens.user += roughTokenEstimate(text);
+            else if (role === "assistant")
+                tokens.assistant_history += roughTokenEstimate(text);
+            else if (role === "tool")
+                tokens.tool_results += roughTokenEstimate(text);
+            else
+                tokens.unattributed_input += roughTokenEstimate(text);
+            if (role === "assistant" && typeof record.reasoning_content === "string") {
+                tokens.assistant_history += roughTokenEstimate(record.reasoning_content);
+            }
+            const toolCalls = extractToolCalls(record.tool_calls);
+            for (const toolCall of toolCalls) {
+                tokens.assistant_history += roughTokenEstimate(`${toolCall.function?.name ?? ""} ${toolCall.function?.arguments ?? ""}`.trim());
+            }
+        }
+    }
+    if (Array.isArray(source.input)) {
+        for (const item of source.input) {
+            const record = asRecord(item);
+            if (!record) {
+                if (typeof item === "string") {
+                    tokens.user += roughTokenEstimate(item);
+                }
+                else {
+                    tokens.unattributed_input += roughTokenEstimate(stringifyMaybe(item));
+                }
+                continue;
+            }
+            const type = typeof record.type === "string" ? record.type : "";
+            if (type === "message") {
+                const role = normalizeRole(record.role);
+                const text = extractTextContent(record.content);
+                tokens.input_media += estimateMediaTokensFromContent(record.content);
+                if (role === "system")
+                    tokens.system += roughTokenEstimate(text);
+                else if (role === "developer")
+                    tokens.developer += roughTokenEstimate(text);
+                else if (role === "user")
+                    tokens.user += roughTokenEstimate(text);
+                else if (role === "assistant")
+                    tokens.assistant_history += roughTokenEstimate(text);
+                else if (role === "tool")
+                    tokens.tool_results += roughTokenEstimate(text);
+                else
+                    tokens.unattributed_input += roughTokenEstimate(text);
+            }
+            else if (isMediaInputItem(record)) {
+                tokens.input_media += estimateMediaTokensFromItem(record);
+            }
+            else if (type === "function_call_output") {
+                tokens.tool_results += roughTokenEstimate(stringifyMaybe(record.output));
+            }
+            else if (type === "function_call") {
+                tokens.assistant_history += roughTokenEstimate(`${record.name ?? ""} ${record.arguments ?? ""}`.trim());
+            }
+            else {
+                tokens.unattributed_input += roughTokenEstimate(stringifyMaybe(record));
+            }
+        }
+    }
+    if (Array.isArray(source.tools)) {
+        for (const tool of source.tools) {
+            const record = asRecord(tool);
+            if (!record)
+                continue;
+            const fn = asRecord(record.function);
+            const name = typeof fn?.name === "string" ? fn.name : "";
+            const description = typeof fn?.description === "string" ? fn.description : "";
+            const parameters = fn?.parameters ? stringifyMaybe(fn.parameters) : "";
+            tokens.tool_definitions += roughTokenEstimate(`${name}\n${description}\n${parameters}`.trim());
+        }
+    }
+    return tokens;
+}
+function estimateMediaTokensFromContent(content) {
+    if (!Array.isArray(content))
+        return 0;
+    let total = 0;
+    for (const part of content) {
+        const record = asRecord(part);
+        if (!record)
+            continue;
+        if (isTextPart(record))
+            continue;
+        if (isMediaInputItem(record)) {
+            total += estimateMediaTokensFromItem(record);
+        }
+    }
+    return total;
+}
+function isTextPart(record) {
+    const type = typeof record.type === "string" ? record.type : "";
+    return type === "text" || type === "input_text" || type === "output_text";
+}
+function isMediaInputItem(record) {
+    const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+    if (type.includes("image") || type.includes("audio"))
+        return true;
+    return (record.image_url !== undefined ||
+        record.input_image !== undefined ||
+        record.image !== undefined ||
+        record.input_audio !== undefined ||
+        record.audio !== undefined);
+}
+function estimateMediaTokensFromItem(record) {
+    const type = typeof record.type === "string" ? record.type.toLowerCase() : "";
+    if (type.includes("image") || record.image_url !== undefined || record.input_image !== undefined || record.image !== undefined) {
+        return estimateImageTokens(record);
+    }
+    if (type.includes("audio") || record.input_audio !== undefined || record.audio !== undefined) {
+        return 256;
+    }
+    return 128;
+}
+function estimateImageTokens(record) {
+    let detail = record.detail;
+    const imageUrl = asRecord(record.image_url);
+    if (detail === undefined && imageUrl)
+        detail = imageUrl.detail;
+    if (detail === "high")
+        return 768;
+    if (detail === "low")
+        return 128;
+    return 256;
+}
+function estimateOutputCategoryTokens(responseBody) {
+    const tokens = initCategoryTokenMap(OUTPUT_TOKEN_CATEGORIES);
+    const body = asRecord(responseBody);
+    if (!body) {
+        tokens.unattributed_output += roughTokenEstimate(stringifyMaybe(responseBody));
+        return { tokens };
+    }
+    const error = asRecord(body.error);
+    if (error) {
+        tokens.errors += roughTokenEstimate(typeof error.message === "string" ? error.message : stringifyMaybe(error));
+    }
+    if (body.$type === "stream") {
+        if (typeof body.text === "string") {
+            const usefulText = extractMergedUsefulSseText(body.text);
+            const streamedToolCalls = extractStreamToolCalls(body.text);
+            const hasUsefulText = usefulText.trim().length > 0;
+            const hasToolCalls = streamedToolCalls.length > 0;
+            if (hasUsefulText) {
+                tokens.assistant_text += roughTokenEstimate(usefulText);
+            }
+            if (hasToolCalls) {
+                for (const toolCall of streamedToolCalls) {
+                    const callText = `${toolCall.function?.name ?? ""} ${toolCall.function?.arguments ?? ""}`.trim();
+                    tokens.tool_calls += roughTokenEstimate(callText);
+                }
+            }
+            if (hasUsefulText && hasToolCalls) {
+                return { tokens, streamSource: "timeline_text_with_tool_calls" };
+            }
+            if (hasUsefulText) {
+                return { tokens, streamSource: "timeline_text" };
+            }
+            if (hasToolCalls) {
+                return { tokens, streamSource: "timeline_tool_calls_only" };
+            }
+            const fallback = mergeSseEventPayloadText(body.text);
+            if (fallback.trim()) {
+                tokens.unattributed_output += roughTokenEstimate(fallback);
+                return { tokens, streamSource: "fallback_events" };
+            }
+        }
+        else if (typeof body.note === "string") {
+            tokens.unattributed_output += roughTokenEstimate(body.note);
+            return { tokens, streamSource: "none" };
+        }
+        return { tokens, streamSource: "none" };
+    }
+    if (Array.isArray(body.output)) {
+        for (const item of body.output) {
+            const record = asRecord(item);
+            if (!record)
+                continue;
+            const type = typeof record.type === "string" ? record.type : "";
+            if (type === "message") {
+                tokens.assistant_text += roughTokenEstimate(extractTextContentFromResponseItem(record));
+            }
+            else if (type === "reasoning") {
+                tokens.reasoning += roughTokenEstimate(extractReasoningItemText(record));
+            }
+            else if (type === "function_call") {
+                tokens.tool_calls += roughTokenEstimate(`${record.name ?? ""} ${record.arguments ?? ""}`.trim());
+            }
+            else if (type === "function_call_output") {
+                tokens.tool_results += roughTokenEstimate(stringifyMaybe(record.output));
+            }
+            else {
+                tokens.unattributed_output += roughTokenEstimate(stringifyMaybe(record));
+            }
+        }
+        return { tokens };
+    }
+    if (Array.isArray(body.choices)) {
+        for (const choice of body.choices) {
+            const choiceRecord = asRecord(choice);
+            const message = asRecord(choiceRecord?.message);
+            if (!message)
+                continue;
+            tokens.assistant_text += roughTokenEstimate(extractTextContent(message.content));
+            if (typeof message.reasoning_content === "string") {
+                tokens.reasoning += roughTokenEstimate(message.reasoning_content);
+            }
+            const toolCalls = extractToolCalls(message.tool_calls);
+            for (const toolCall of toolCalls) {
+                tokens.tool_calls += roughTokenEstimate(`${toolCall.function?.name ?? ""} ${toolCall.function?.arguments ?? ""}`.trim());
+            }
+        }
+        return { tokens };
+    }
+    tokens.unattributed_output += roughTokenEstimate(stringifyMaybe(body));
+    return { tokens };
+}
+function initCategoryTokenMap(categories) {
+    const out = {};
+    for (const category of categories) {
+        out[category.key] = 0;
+    }
+    return out;
+}
+function mapTokensToBuckets(categories, values) {
+    return categories.map((category) => ({
+        key: category.key,
+        label: category.label,
+        tokens: Math.max(0, Math.round(values[category.key] ?? 0)),
+    }));
+}
+function scaleCategoryTokens(categories, values, targetTotal) {
+    const sanitizedTarget = Math.max(0, Math.round(targetTotal));
+    if (sanitizedTarget === 0) {
+        return categories.map((category) => ({ key: category.key, label: category.label, tokens: 0 }));
+    }
+    const weights = categories.map((category) => Math.max(0, values[category.key] ?? 0));
+    const scaled = splitTotalByWeights(sanitizedTarget, weights);
+    return categories.map((category, idx) => ({
+        key: category.key,
+        label: category.label,
+        tokens: scaled[idx] ?? 0,
+    }));
+}
+function splitTotalByWeights(total, weights) {
+    const sanitizedTotal = Math.max(0, Math.round(total));
+    const normalizedWeights = weights.map((value) => Math.max(0, value));
+    const sum = normalizedWeights.reduce((acc, value) => acc + value, 0);
+    if (sanitizedTotal === 0)
+        return normalizedWeights.map(() => 0);
+    if (sum <= 0) {
+        const equal = Math.floor(sanitizedTotal / normalizedWeights.length);
+        let remainder = sanitizedTotal - equal * normalizedWeights.length;
+        return normalizedWeights.map((_value, idx) => equal + (remainder-- > 0 ? 1 : 0));
+    }
+    const rawShares = normalizedWeights.map((value) => (value / sum) * sanitizedTotal);
+    const floors = rawShares.map((value) => Math.floor(value));
+    let remainder = sanitizedTotal - floors.reduce((acc, value) => acc + value, 0);
+    const order = rawShares
+        .map((value, idx) => ({ idx, frac: value - floors[idx] }))
+        .sort((a, b) => b.frac - a.frac);
+    for (let i = 0; i < order.length && remainder > 0; i += 1) {
+        floors[order[i].idx] += 1;
+        remainder -= 1;
+    }
+    return floors;
+}
+function sumTokenMapValues(values) {
+    return Object.values(values).reduce((acc, value) => acc + Math.max(0, Math.round(value)), 0);
+}
+function toNullableInt(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    return Math.max(0, Math.round(value));
+}
+function roughTokenEstimate(value) {
+    if (!value)
+        return 0;
+    return Math.ceil(Buffer.byteLength(value, "utf8") / 4);
+}
+function normalizeRole(value) {
+    if (value === "system" ||
+        value === "user" ||
+        value === "assistant" ||
+        value === "tool" ||
+        value === "developer") {
+        return value;
+    }
+    return undefined;
+}
+function stringifyMaybe(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === undefined)
+        return "";
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function dateStringForTimeZone(timestamp, timeZone) {
+    const value = new Date(timestamp);
+    if (!Number.isFinite(value.getTime())) {
+        return timestamp.slice(0, 10);
+    }
+    const formatter = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    });
+    const parts = formatter.formatToParts(value);
+    const year = parts.find((part) => part.type === "year")?.value ?? "0000";
+    const month = parts.find((part) => part.type === "month")?.value ?? "00";
+    const day = parts.find((part) => part.type === "day")?.value ?? "00";
+    return `${year}-${month}-${day}`;
+}
+function normalizeTimeZone(input) {
+    if (!input)
+        return "UTC";
+    try {
+        new Intl.DateTimeFormat("en-US", { timeZone: input });
+        return input;
+    }
+    catch {
+        return "UTC";
+    }
+}
+function hydrateCaptureRecord(record) {
+    const analysis = buildAnalysisProjection(record.route, record.request.body, record.response.body, record.request.derived);
+    return {
+        ...record,
+        analysis: {
+            ...record.analysis,
+            ...analysis,
+            tools: record.analysis?.tools?.length ? record.analysis.tools : analysis.tools,
+            mcpToolDescriptions: record.analysis?.mcpToolDescriptions?.length
+                ? record.analysis.mcpToolDescriptions
+                : analysis.mcpToolDescriptions,
+            agentsMdHints: record.analysis?.agentsMdHints?.length ? record.analysis.agentsMdHints : analysis.agentsMdHints,
+            rawSections: record.analysis?.rawSections?.length ? record.analysis.rawSections : analysis.rawSections,
+        },
+    };
+}
+async function buildPreviewBody(paths, value, artifacts) {
+    if (value === null || value === undefined)
+        return value;
+    if (typeof value === "string") {
+        return previewString(value);
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        for (const item of value) {
+            out.push(await buildPreviewBody(paths, item, artifacts));
+        }
+        return out;
+    }
+    if (typeof value === "object") {
+        const out = {};
+        for (const [key, v] of Object.entries(value)) {
+            if (typeof v === "string") {
+                const dataMatch = v.match(DATA_URL_RE);
+                if (dataMatch) {
+                    out[key] = await storeDataUrlArtifact(paths, v, artifacts);
+                    continue;
+                }
+            }
+            out[key] = await buildPreviewBody(paths, v, artifacts);
+        }
+        return out;
+    }
+    return value;
+}
+function previewString(input) {
+    if (input.length <= 4000)
+        return input;
+    return {
+        $type: "long_text",
+        length: input.length,
+        preview: `${input.slice(0, 320)}…`,
+    };
+}
+async function storeDataUrlArtifact(paths, value, artifacts) {
+    const match = value.match(DATA_URL_RE);
+    if (!match)
+        return previewString(value);
+    const mime = match[1].toLowerCase();
+    let buffer;
+    try {
+        buffer = Buffer.from(match[2], "base64");
+    }
+    catch {
+        return {
+            $type: "data_url",
+            mime,
+            error: "invalid_base64",
+        };
+    }
+    const hash = (0, crypto_1.createHash)("sha256").update(buffer).digest("hex");
+    const ext = mimeToExt(mime);
+    const blobFile = `${hash}.${ext}`;
+    const blobPath = path_1.default.join(captureBlobsDir(paths), blobFile);
+    try {
+        await fs_1.promises.access(blobPath);
+    }
+    catch {
+        await fs_1.promises.writeFile(blobPath, buffer);
+    }
+    const artifact = {
+        hash,
+        mime,
+        bytes: buffer.byteLength,
+        blobRef: `/admin/capture/blobs/${hash}`,
+        kind: mime.startsWith("image/")
+            ? "image"
+            : mime.startsWith("audio/")
+                ? "audio"
+                : "binary",
+    };
+    if (!artifacts.some((item) => item.hash === hash)) {
+        artifacts.push(artifact);
+    }
+    return {
+        $type: "data_url_ref",
+        mime,
+        bytes: buffer.byteLength,
+        blobRef: artifact.blobRef,
+    };
+}
+function mimeToExt(mime) {
+    if (mime === "image/png")
+        return "png";
+    if (mime === "image/jpeg")
+        return "jpg";
+    if (mime === "image/webp")
+        return "webp";
+    if (mime === "image/gif")
+        return "gif";
+    if (mime === "audio/mpeg")
+        return "mp3";
+    if (mime === "audio/wav")
+        return "wav";
+    if (mime === "audio/ogg")
+        return "ogg";
+    if (mime === "audio/webm")
+        return "webm";
+    return "bin";
+}
+function extToMime(ext) {
+    if (ext === "png")
+        return "image/png";
+    if (ext === "jpg" || ext === "jpeg")
+        return "image/jpeg";
+    if (ext === "webp")
+        return "image/webp";
+    if (ext === "gif")
+        return "image/gif";
+    if (ext === "mp3")
+        return "audio/mpeg";
+    if (ext === "wav")
+        return "audio/wav";
+    if (ext === "ogg")
+        return "audio/ogg";
+    if (ext === "webm")
+        return "audio/webm";
+    return "application/octet-stream";
+}
+async function readCaptureIndex(paths, options) {
+    try {
+        const raw = await fs_1.promises.readFile(captureIndexPath(paths), "utf8");
+        const entries = raw
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .map((line) => JSON.parse(line))
+            .sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        if (!options?.pruneMissing) {
+            return entries;
+        }
+        const existing = [];
+        let removed = false;
+        for (const entry of entries) {
+            try {
+                await fs_1.promises.access(path_1.default.join(captureDir(paths), entry.file));
+                existing.push(entry);
+            }
+            catch {
+                removed = true;
+            }
+        }
+        if (removed) {
+            const content = existing.map((entry) => JSON.stringify(entry)).join("\n");
+            await fs_1.promises.writeFile(captureIndexPath(paths), content ? `${content}\n` : "", "utf8");
+        }
+        return existing;
+    }
+    catch {
+        return [];
+    }
+}
+async function applyCaptureRetention(paths, config) {
+    const cutoff = Date.now() - config.retentionDays * 24 * 60 * 60 * 1000;
+    let entries = await readCaptureIndex(paths);
+    if (entries.length === 0)
+        return;
+    entries = entries.filter((entry) => {
+        const ts = new Date(entry.timestamp).getTime();
+        if (!Number.isFinite(ts) || ts < cutoff) {
+            return false;
+        }
+        return true;
+    });
+    let total = await dirSize(captureDir(paths));
+    if (total > config.maxBytes) {
+        const sorted = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+        while (total > config.maxBytes && sorted.length > 0) {
+            const oldest = sorted.shift();
+            if (!oldest)
+                break;
+            const recPath = path_1.default.join(captureDir(paths), oldest.file);
+            try {
+                await fs_1.promises.unlink(recPath);
+            }
+            catch {
+                // noop
+            }
+            entries = entries.filter((entry) => entry.id !== oldest.id);
+            total = await dirSize(captureDir(paths));
+        }
+    }
+    else {
+        const existingIds = new Set(entries.map((entry) => entry.id));
+        const allEntries = await readCaptureIndex(paths);
+        for (const item of allEntries) {
+            if (existingIds.has(item.id))
+                continue;
+            try {
+                await fs_1.promises.unlink(path_1.default.join(captureDir(paths), item.file));
+            }
+            catch {
+                // noop
+            }
+        }
+    }
+    await cleanupOrphanBlobs(paths, entries);
+    const content = entries.map((entry) => JSON.stringify(entry)).join("\n");
+    await fs_1.promises.writeFile(captureIndexPath(paths), content ? `${content}\n` : "", "utf8");
+}
+async function cleanupOrphanBlobs(paths, entries) {
+    const referenced = new Set();
+    for (const entry of entries) {
+        try {
+            const raw = await fs_1.promises.readFile(path_1.default.join(captureDir(paths), entry.file), "utf8");
+            const record = JSON.parse(raw);
+            for (const artifact of record.artifacts ?? []) {
+                referenced.add(artifact.hash);
+            }
+        }
+        catch {
+            // noop
+        }
+    }
+    let files;
+    try {
+        files = await fs_1.promises.readdir(captureBlobsDir(paths));
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        const hash = file.split(".")[0];
+        if (!referenced.has(hash)) {
+            try {
+                await fs_1.promises.unlink(path_1.default.join(captureBlobsDir(paths), file));
+            }
+            catch {
+                // noop
+            }
+        }
+    }
+}
+async function dirSize(root) {
+    let total = 0;
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await fs_1.promises.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = path_1.default.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else if (entry.isFile()) {
+                try {
+                    const stat = await fs_1.promises.stat(full);
+                    total += stat.size;
+                }
+                catch {
+                    // noop
+                }
+            }
+        }
+    }
+    await walk(root);
+    return total;
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object")
+        return null;
+    return value;
+}