@nordbyte/nordrelay 0.5.2 → 0.7.0

package/dist/channel-peer-prompt.js

@@ -0,0 +1,95 @@
+import { friendlyErrorText } from "./error-messages.js";
+import { RemoteRelayClient } from "./peer-client.js";
+import { peerPromptProxyPayload } from "./remote-prompt.js";
+export async function runChannelPeerPrompt(options) {
+    if (!options.targetPeerId) {
+        return false;
+    }
+    const client = options.remoteClient ?? new RemoteRelayClient();
+    let responseMessageId;
+    let accumulated = "";
+    let lastEditAt = 0;
+    let completed = false;
+    let closeSubscription = () => { };
+    const typing = setInterval(() => {
+        void options.sendTyping().catch(() => { });
+    }, options.typingIntervalMs);
+    typing.unref?.();
+    void options.sendTyping().catch(() => { });
+    const flush = async (force = false) => {
+        if (!accumulated.trim()) {
+            return;
+        }
+        const now = Date.now();
+        if (!force && now - lastEditAt < options.editMinIntervalMs) {
+            return;
+        }
+        if (responseMessageId === undefined) {
+            responseMessageId = await options.sendResponse(accumulated);
+        }
+        else {
+            await options.editResponse(responseMessageId, accumulated);
+        }
+        lastEditAt = now;
+    };
+    const done = new Promise((resolve) => {
+        const timeout = setTimeout(resolve, 30 * 60 * 1000);
+        timeout.unref?.();
+        let subscription;
+        const finish = () => {
+            clearTimeout(timeout);
+            subscription?.close();
+            resolve();
+        };
+        subscription = client.subscribe(options.targetPeerId, (event) => {
+            if (event.type === "turn_start") {
+                void options.sendTurnStart(event.prompt).catch(() => { });
+            }
+            else if (event.type === "text_delta") {
+                accumulated += event.delta;
+                void flush(false).catch(() => { });
+            }
+            else if (event.type === "tool_start") {
+                void options.sendToolStart(event.toolName).catch(() => { });
+            }
+            else if (event.type === "turn_complete") {
+                completed = true;
+                finish();
+            }
+            else if (event.type === "turn_error") {
+                accumulated += `\n\nError: ${event.error}`;
+                completed = true;
+                finish();
+            }
+        }, (error) => {
+            accumulated += `\n\nRemote event stream failed: ${error.message}`;
+            finish();
+        }, options.contextKey);
+        closeSubscription = () => subscription?.close();
+    });
+    try {
+        const result = await client.webProxy(options.targetPeerId, await peerPromptProxyPayload(options.prompt), options.prompt.activityActor, options.contextKey);
+        if (isQueuedRemoteResult(result)) {
+            closeSubscription();
+            await options.sendQueued(String(result.queueId ?? ""));
+            return true;
+        }
+        await done;
+        await flush(true);
+        if (!accumulated.trim() && completed) {
+            await options.sendCompleted();
+        }
+        return true;
+    }
+    catch (error) {
+        await options.sendFailure(friendlyErrorText(error));
+        return true;
+    }
+    finally {
+        clearInterval(typing);
+        closeSubscription();
+    }
+}
+function isQueuedRemoteResult(value) {
+    return Boolean(value && typeof value === "object" && "queued" in value && value.queued);
+}

package/dist/channel-runtime.js

@@ -1,13 +1,19 @@
 export class ChannelCommandRouter {
     handlers = new Map();
     command(name, handler) {
-        const normalized = normalizeCommandName(name);
+        const normalized = normalizeChannelCommandName(name);
         if (!normalized) {
             throw new Error("Channel command name is required.");
         }
         this.handlers.set(normalized, handler);
         return this;
     }
+    commands(names, handler) {
+        for (const name of names) {
+            this.command(name, handler);
+        }
+        return this;
+    }
     async dispatch(message) {
         const parsed = parseChannelCommand(message.text ?? "");
         if (!parsed) {
@@ -36,13 +42,14 @@ export async function deliverChannelAction(runtime, context, response) {
         buttons: response.buttons,
     });
 }
-export function parseChannelCommand(text) {
-    const match = text.trimStart().match(/^\/([a-zA-Z0-9_-]+)(?:@\w+)?(?:\s+([\s\S]*))?$/);
+export function parseChannelCommand(text, options = {}) {
+    const mention = options.allowBotMention === false ? "" : "(?:@\\w+)?";
+    const match = text.trimStart().match(new RegExp(`^/([a-zA-Z0-9_-]+)${mention}(?:\\s+([\\s\\S]*))?$`));
     if (!match?.[1]) {
         return null;
     }
     return {
-        command: normalizeCommandName(match[1]),
+        command: normalizeChannelCommandName(match[1]),
         argument: match[2]?.trim() ?? "",
     };
 }
@@ -84,6 +91,6 @@ export class InMemoryChannelRuntime {
         return { messageId };
     }
 }
-function normalizeCommandName(name) {
+export function normalizeChannelCommandName(name) {
     return name.trim().replace(/^\//, "").toLowerCase();
 }

package/dist/channel-turn-service.js

@@ -0,0 +1,237 @@
+import { randomUUID } from "node:crypto";
+import { CODEX_AGENT_CAPABILITIES, agentLabel, } from "./agent.js";
+import { friendlyErrorText } from "./error-messages.js";
+export class ChannelTurnService {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    async run(session, envelope) {
+        const actor = envelope.activityActor;
+        await this.options.ensureActiveThread(session);
+        const info = session.getInfo();
+        if ((info.capabilities ?? CODEX_AGENT_CAPABILITIES).auth) {
+            const auth = await this.options.checkAuth(info);
+            if (!auth.authenticated) {
+                throw new Error(`${agentLabel(info.agentId)} is not authenticated: ${auth.detail}`);
+            }
+        }
+        const turnId = randomUUID().slice(0, 12);
+        const startedMs = Date.now();
+        this.options.setCurrentTurn(turnId, startedMs, "");
+        this.options.setCurrentProgress({
+            id: turnId,
+            source: this.options.source,
+            status: "running",
+            prompt: envelope.description,
+            agentId: info.agentId,
+            agentLabel: info.agentLabel,
+            threadId: info.threadId,
+            workspace: info.workspace,
+            startedAt: new Date(startedMs).toISOString(),
+            updatedAt: new Date(startedMs).toISOString(),
+            durationMs: 0,
+            outputChars: 0,
+            tools: [],
+        });
+        this.options.setLastPrompt(envelope);
+        const startedDate = new Date();
+        const startedAt = startedDate.toISOString();
+        this.options.chatStore.append({
+            threadId: info.threadId ?? "pending",
+            role: "user",
+            text: envelope.description,
+            source: this.options.source,
+            turnId,
+            timestamp: startedAt,
+        });
+        this.options.appendActivity({
+            source: this.options.source,
+            status: "running",
+            type: "prompt_started",
+            threadId: info.threadId,
+            workspace: info.workspace,
+            agentId: info.agentId,
+            actor,
+            prompt: envelope.description,
+        });
+        this.options.appendAudit({
+            action: "prompt_started",
+            status: "ok",
+            contextKey: this.options.contextKey,
+            agentId: info.agentId,
+            threadId: info.threadId,
+            workspace: info.workspace,
+            actor,
+            description: envelope.description,
+        });
+        this.options.broadcast({ type: "turn_start", id: turnId, prompt: envelope.description, at: startedAt, source: this.options.source });
+        try {
+            await session.prompt(envelope.input, this.callbacks(turnId, info, envelope, actor));
+            this.options.updateSession(session);
+            await this.options.artifactService.persistWorkspaceArtifactsForTurn(session.getInfo().workspace, turnId, startedDate);
+            const text = this.options.getAccumulatedText();
+            if (text.trim()) {
+                this.options.chatStore.append({
+                    threadId: info.threadId ?? "pending",
+                    role: "agent",
+                    text,
+                    source: this.options.source,
+                    turnId,
+                });
+            }
+            this.options.appendActivity({
+                source: this.options.source,
+                status: "completed",
+                type: "prompt_completed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                prompt: envelope.description,
+                durationMs: Date.now() - this.options.getCurrentTurnStartedAt(),
+            });
+            this.options.appendAudit({
+                action: "prompt_completed",
+                status: "ok",
+                contextKey: this.options.contextKey,
+                agentId: info.agentId,
+                threadId: info.threadId,
+                workspace: info.workspace,
+                actor,
+                description: envelope.description,
+            });
+            this.updateCurrentProgress({ status: "completed" });
+            this.options.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() });
+            this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+        }
+        catch (error) {
+            const errorText = friendlyErrorText(error);
+            this.options.chatStore.append({
+                threadId: info.threadId ?? "pending",
+                role: "system",
+                text: `Error: ${errorText}`,
+                source: this.options.source,
+                turnId,
+            });
+            this.options.appendActivity({
+                source: this.options.source,
+                status: "failed",
+                type: "prompt_failed",
+                threadId: info.threadId,
+                workspace: info.workspace,
+                agentId: info.agentId,
+                actor,
+                prompt: envelope.description,
+                detail: errorText,
+                durationMs: Date.now() - this.options.getCurrentTurnStartedAt(),
+            });
+            this.options.appendAudit({
+                action: "prompt_failed",
+                status: "failed",
+                contextKey: this.options.contextKey,
+                agentId: info.agentId,
+                threadId: info.threadId,
+                workspace: info.workspace,
+                actor,
+                description: envelope.description,
+                detail: errorText,
+            });
+            this.updateCurrentProgress({ status: "failed", detail: errorText });
+            this.options.broadcast({ type: "turn_error", id: turnId, error: errorText, at: new Date().toISOString() });
+            this.options.broadcast({ type: "chat_history", messages: await this.options.chatHistory() });
+            throw error;
+        }
+        finally {
+            const progress = this.options.getCurrentProgress();
+            if (progress) {
+                progress.durationMs = Date.now() - this.options.getCurrentTurnStartedAt();
+                progress.updatedAt = new Date().toISOString();
+            }
+            this.options.setCurrentTurn(null);
+        }
+    }
+    callbacks(turnId, info, envelope, actor) {
+        return {
+            onTextDelta: (delta) => {
+                const nextText = this.options.getAccumulatedText() + delta;
+                this.options.setAccumulatedText(nextText);
+                this.updateCurrentProgress({ outputChars: nextText.length });
+                this.options.broadcast({ type: "text_delta", id: turnId, delta });
+            },
+            onToolStart: (toolName, toolCallId) => {
+                this.addCurrentTool(toolName);
+                this.options.appendActivity({
+                    source: this.options.source,
+                    status: "running",
+                    type: "tool_started",
+                    threadId: info.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor,
+                    prompt: envelope.description,
+                    detail: toolName,
+                });
+                this.options.broadcast({ type: "tool_start", id: turnId, toolCallId, toolName });
+            },
+            onToolUpdate: (toolCallId, partialResult) => {
+                this.updateCurrentProgress();
+                this.options.broadcast({ type: "tool_update", id: turnId, toolCallId, partialResult });
+            },
+            onToolEnd: (toolCallId, isError) => {
+                const progress = this.options.getCurrentProgress();
+                const toolName = progress?.currentTool ?? progress?.lastTool ?? toolCallId;
+                this.updateCurrentProgress({ currentTool: undefined });
+                this.options.appendActivity({
+                    source: this.options.source,
+                    status: isError ? "failed" : "completed",
+                    type: isError ? "tool_failed" : "tool_completed",
+                    threadId: info.threadId,
+                    workspace: info.workspace,
+                    agentId: info.agentId,
+                    actor,
+                    prompt: envelope.description,
+                    detail: toolName,
+                });
+                this.options.broadcast({ type: "tool_end", id: turnId, toolCallId, isError });
+            },
+            onTodoUpdate: (items) => {
+                this.updateCurrentProgress({ detail: `Plan: ${items.filter((item) => item.completed).length}/${items.length} done` });
+                this.options.broadcast({ type: "todo_update", id: turnId, items });
+            },
+            onTurnComplete: () => { },
+            onAgentEnd: () => this.options.broadcast({ type: "turn_complete", id: turnId, at: new Date().toISOString() }),
+        };
+    }
+    updateCurrentProgress(patch = {}) {
+        const progress = this.options.getCurrentProgress();
+        if (!progress) {
+            return;
+        }
+        if ("currentTool" in patch) {
+            progress.currentTool = patch.currentTool;
+            const { currentTool: _currentTool, ...rest } = patch;
+            Object.assign(progress, rest);
+        }
+        else {
+            Object.assign(progress, patch);
+        }
+        progress.durationMs = Date.now() - this.options.getCurrentTurnStartedAt();
+        progress.updatedAt = new Date().toISOString();
+        this.options.setCurrentProgress(progress);
+    }
+    addCurrentTool(toolName) {
+        const progress = this.options.getCurrentProgress();
+        if (!progress) {
+            return;
+        }
+        const existing = progress.tools.find((tool) => tool.name === toolName);
+        if (existing) {
+            existing.count += 1;
+        }
+        else {
+            progress.tools.push({ name: toolName, count: 1 });
+        }
+        this.updateCurrentProgress({ currentTool: toolName, lastTool: toolName });
+    }
+}

package/dist/codex-state.js

@@ -1,6 +1,8 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { closeSync, existsSync, openSync, readFileSync, readSync, readdirSync, statSync } from "node:fs";
 import path from "node:path";
 import { isCodexApprovalPolicy, isCodexSandboxMode, } from "./codex-launch.js";
+const ROLLOUT_CACHE_MAX_EVENTS = 200;
+const rolloutSnapshotCache = new Map();
 export const FALLBACK_MODELS = [
     { slug: "gpt-5.5", displayName: "GPT-5.5" },
     { slug: "gpt-5.4", displayName: "GPT-5.4" },
@@ -74,31 +76,7 @@ export function getThreadUsage(id) {
     }
 }
 export function getThreadActivity(id, options = {}) {
-    const rolloutPath = getThreadRolloutPath(id);
-    if (!rolloutPath || !existsSync(rolloutPath)) {
-        return null;
-    }
-    try {
-        const parsed = parseActivityFromRollout(id, rolloutPath, readFileSync(rolloutPath, "utf8"));
-        const fileModifiedAtMs = statSync(rolloutPath).mtimeMs;
-        const updatedAtMs = Math.max(parsed.updatedAt?.getTime() ?? 0, fileModifiedAtMs);
-        const updatedAt = updatedAtMs > 0 ? new Date(updatedAtMs) : parsed.updatedAt;
-        const staleAfterMs = options.staleAfterMs ?? 5 * 60 * 1000;
-        const nowMs = options.nowMs ?? Date.now();
-        const stale = Boolean(parsed.active &&
-            updatedAt &&
-            staleAfterMs > 0 &&
-            nowMs - updatedAt.getTime() > staleAfterMs);
-        return {
-            ...parsed,
-            updatedAt,
-            stale,
-            active: parsed.active && !stale,
-        };
-    }
-    catch {
-        return null;
-    }
+    return getThreadRolloutSnapshot(id, { ...options, maxEvents: 0 })?.activity ?? null;
 }
 export function getThreadRolloutSnapshot(id, options = {}) {
     const rolloutPath = getThreadRolloutPath(id);
@@ -106,8 +84,9 @@ export function getThreadRolloutSnapshot(id, options = {}) {
         return null;
     }
     try {
-        const parsed = parseRolloutSnapshot(id, rolloutPath, readFileSync(rolloutPath, "utf8"));
-        return finalizeRolloutSnapshot(parsed, statSync(rolloutPath).mtimeMs, options);
+        const fileModifiedAtMs = statSync(rolloutPath).mtimeMs;
+        const parsed = readCachedRolloutSnapshot(id, rolloutPath);
+        return finalizeRolloutSnapshot(parsed, fileModifiedAtMs, options);
     }
     catch {
         return null;
@@ -167,13 +146,7 @@ export function getThreadRolloutPath(id) {
     }) ?? null);
 }
 function parseUsageFromRollout(contents) {
-    let contextWindow = null;
-    let contextUsedPercent = null;
-    let lastTokenUsage = null;
-    let totalTokenUsage = null;
-    let rateLimits = null;
-    let updatedAt = null;
-    for (const line of contents.split(/\r?\n/)) {
+    for (const line of iterateLinesReverse(contents)) {
         if (!line.includes('"token_count"')) {
             continue;
         }
@@ -188,6 +161,7 @@ function parseUsageFromRollout(contents) {
         if (payload?.type !== "token_count") {
             continue;
         }
+        let updatedAt = null;
         const timestamp = readString(readObject(event)?.timestamp);
         if (timestamp) {
             const parsedTimestamp = new Date(timestamp);
@@ -196,54 +170,116 @@ function parseUsageFromRollout(contents) {
             }
         }
         const info = readObject(payload.info);
-        const parsedTotal = parseTokenUsage(readObject(info?.total_token_usage));
-        const parsedLast = parseTokenUsage(readObject(info?.last_token_usage));
+        const totalTokenUsage = parseTokenUsage(readObject(info?.total_token_usage));
+        const lastTokenUsage = parseTokenUsage(readObject(info?.last_token_usage));
         const parsedContextWindow = readNumber(info?.model_context_window);
-        if (parsedTotal) {
-            totalTokenUsage = parsedTotal;
+        const contextWindow = parsedContextWindow !== null && parsedContextWindow > 0
+            ? parsedContextWindow
+            : null;
+        const contextUsedPercent = lastTokenUsage && contextWindow
+            ? Math.min(100, (lastTokenUsage.totalTokens / contextWindow) * 100)
+            : null;
+        const rateLimits = parseRateLimits(readObject(payload.rate_limits));
+        if (!lastTokenUsage && !totalTokenUsage && !rateLimits) {
+            continue;
         }
-        if (parsedLast) {
-            lastTokenUsage = parsedLast;
+        return {
+            contextWindow,
+            contextUsedPercent,
+            lastTokenUsage,
+            totalTokenUsage,
+            rateLimits,
+            updatedAt,
+        };
+    }
+    return null;
+}
+function readCachedRolloutSnapshot(threadId, rolloutPath) {
+    const size = statSync(rolloutPath).size;
+    const cached = rolloutSnapshotCache.get(rolloutPath);
+    if (cached && size >= cached.byteOffset) {
+        const suffix = size > cached.byteOffset
+            ? readFileRangeUtf8(rolloutPath, cached.byteOffset, size - cached.byteOffset)
+            : "";
+        if (!suffix.trim()) {
+            return cached.parsed;
         }
-        if (parsedContextWindow !== null && parsedContextWindow > 0) {
-            contextWindow = parsedContextWindow;
+        const parsed = parseRolloutSnapshot(threadId, rolloutPath, suffix, {
+            base: cached.parsed,
+            maxEvents: ROLLOUT_CACHE_MAX_EVENTS,
+        });
+        rolloutSnapshotCache.set(rolloutPath, { byteOffset: size, parsed });
+        return parsed;
+    }
+    const contents = readFileSync(rolloutPath, "utf8");
+    const parsed = parseRolloutSnapshot(threadId, rolloutPath, contents, {
+        maxEvents: ROLLOUT_CACHE_MAX_EVENTS,
+    });
+    rolloutSnapshotCache.set(rolloutPath, {
+        byteOffset: Buffer.byteLength(contents),
+        parsed,
+    });
+    return parsed;
+}
+function readFileRangeUtf8(filePath, position, length) {
+    if (length <= 0) {
+        return "";
+    }
+    const fd = openSync(filePath, "r");
+    try {
+        const buffer = Buffer.allocUnsafe(length);
+        const bytesRead = readSync(fd, buffer, 0, length, position);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+function* iterateLinesReverse(contents) {
+    let end = contents.length;
+    while (end > 0) {
+        let start = contents.lastIndexOf("\n", end - 1);
+        const lineStart = start === -1 ? 0 : start + 1;
+        let line = contents.slice(lineStart, end);
+        if (line.endsWith("\r")) {
+            line = line.slice(0, -1);
         }
-        if (lastTokenUsage && contextWindow) {
-            contextUsedPercent = Math.min(100, (lastTokenUsage.totalTokens / contextWindow) * 100);
+        if (line.trim()) {
+            yield line;
         }
-        const parsedRateLimits = parseRateLimits(readObject(payload.rate_limits));
-        if (parsedRateLimits) {
-            rateLimits = parsedRateLimits;
+        if (start === -1) {
+            break;
         }
+        end = start;
     }
-    if (!lastTokenUsage && !totalTokenUsage && !rateLimits) {
-        return null;
-    }
-    return {
-        contextWindow,
-        contextUsedPercent,
-        lastTokenUsage,
-        totalTokenUsage,
-        rateLimits,
-        updatedAt,
-    };
 }
-function parseActivityFromRollout(threadId, rolloutPath, contents) {
-    return parseRolloutSnapshot(threadId, rolloutPath, contents).activity;
-}
-function parseRolloutSnapshot(threadId, rolloutPath, contents) {
-    let activeTurnId = null;
-    let startedAt = null;
-    let updatedAt = null;
-    let latestAgentMessage = null;
-    let latestUserMessage = null;
-    let latestToolName = null;
-    const events = [];
+function parseRolloutSnapshot(threadId, rolloutPath, contents, options = {}) {
+    let activeTurnId = options.base?.activity.active ? options.base.activity.turnId : null;
+    let startedAt = options.base?.activity.active ? options.base.activity.startedAt : null;
+    let updatedAt = options.base?.activity.updatedAt ?? null;
+    let latestAgentMessage = options.base?.latestAgentMessage ?? null;
+    let latestUserMessage = options.base?.latestUserMessage ?? null;
+    let latestToolName = options.base?.latestToolName ?? null;
+    const events = [...(options.base?.events ?? [])];
     const lines = contents.split(/\r?\n/);
+    const lineNumberOffset = options.base?.lineCount ?? 0;
+    let lineCount = lineNumberOffset;
+    const afterLine = options.afterLine ?? 0;
+    const maxEvents = options.maxEvents ?? Number.POSITIVE_INFINITY;
+    const pushEvent = (event) => {
+        if (maxEvents <= 0 || event.lineNumber <= afterLine) {
+            return;
+        }
+        events.push(event);
+        if (Number.isFinite(maxEvents) && events.length > maxEvents) {
+            events.splice(0, events.length - maxEvents);
+        }
+    };
     for (const [index, line] of lines.entries()) {
         if (!line.trim()) {
             continue;
         }
+        lineCount += 1;
         if (!line.includes('"task_') &&
             !line.includes('"turn_') &&
             !line.includes('"user_message"') &&
@@ -262,7 +298,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         const eventObject = readObject(event);
         const payload = readObject(eventObject?.payload);
         const eventTimestamp = parseTimestamp(readString(eventObject?.timestamp));
-        const lineNumber = index + 1;
+        const lineNumber = lineNumberOffset + index + 1;
         if (activeTurnId && eventTimestamp) {
             updatedAt = eventTimestamp;
         }
@@ -274,7 +310,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
             activeTurnId = readString(payload?.turn_id);
             startedAt = parseUnixSeconds(readNumber(payload?.started_at)) ?? eventTimestamp;
             updatedAt = eventTimestamp ?? startedAt;
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "task",
                 timestamp: eventTimestamp,
@@ -289,7 +325,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (isTaskTerminalEvent(type)) {
             const turnId = readString(payload?.turn_id);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "task",
                 timestamp: eventTimestamp,
@@ -309,7 +345,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (type === "user_message") {
             latestUserMessage = readString(payload?.message);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "user",
                 timestamp: eventTimestamp,
@@ -324,7 +360,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (type === "agent_message") {
             latestAgentMessage = readString(payload?.message);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "agent",
                 timestamp: eventTimestamp,
@@ -339,7 +375,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
         }
         if (type === "function_call") {
             latestToolName = readString(payload?.name);
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "tool",
                 timestamp: eventTimestamp,
@@ -353,7 +389,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
             continue;
         }
         if (type === "function_call_output") {
-            events.push({
+            pushEvent({
                 lineNumber,
                 kind: "tool",
                 timestamp: eventTimestamp,
@@ -369,7 +405,7 @@ function parseRolloutSnapshot(threadId, rolloutPath, contents) {
     return {
         threadId,
         rolloutPath,
-        lineCount: lines.filter((line) => line.trim()).length,
+        lineCount,
         activity: {
             threadId,
             rolloutPath,