apex-code 0.5.0 → 0.5.2

package/dist/core/session-manager.js

@@ -1,8 +1,8 @@
-import { uuidv7 } from "@earendil-works/pi-ai";
+import { getCurrentSystemMessage, uuidv7, } from "@earendil-works/pi-ai";
 import { randomUUID } from "crypto";
 import { appendFileSync, closeSync, createReadStream, existsSync, mkdirSync, openSync, readdirSync, readSync, renameSync, rmSync, statSync, writeFileSync, } from "fs";
 import { readdir, stat } from "fs/promises";
-import { join, resolve } from "path";
+import { basename, join, resolve } from "path";
 import { createInterface } from "readline";
 import { StringDecoder } from "string_decoder";
 import { APP_NAME, getAgentDir as getDefaultAgentDir, getSessionsDir } from "../config.js";
@@ -184,6 +184,8 @@ export function sessionEntryToContextMessages(entry) {
         const message = entry.message;
         // Session files are parsed without validation; old versions, forks, or
         // hand-edited files can contain messages with null/missing content.
+        if (message.role === "system" && message.content == null)
+            return [{ ...message, content: "" }];
         if ((message.role === "user" || message.role === "assistant" || message.role === "toolResult") &&
             message.content == null) {
             return [{ ...message, content: [] }];
@@ -199,7 +201,8 @@ export function sessionEntryToContextMessages(entry) {
         return [createBranchSummaryMessage(entry.summary, entry.fromId, entry.timestamp)];
     }
     if (entry.type === "compaction") {
-        return [createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp)];
+        const summary = createCompactionSummaryMessage(entry.summary, entry.tokensBefore, entry.timestamp);
+        return entry.systemMessage ? [entry.systemMessage, summary] : [summary];
     }
     return [];
 }
@@ -233,7 +236,7 @@ export function buildContextEntries(entries, leafId, byId) {
         if (entry.id === compaction.firstKeptEntryId) {
             foundFirstKept = true;
         }
-        if (foundFirstKept) {
+        if (foundFirstKept && !(entry.type === "message" && entry.message.role === "system")) {
             contextEntries.push(entry);
         }
     }
@@ -245,10 +248,55 @@ export function buildContextEntries(entries, leafId, byId) {
  * If leafId is provided, walks from that entry to root.
  * Handles compaction and branch summaries along the path.
  */
-export function buildSessionContext(entries, leafId, byId) {
+function projectContextEntry(entry, edit) {
+    const messages = sessionEntryToContextMessages(entry);
+    if (!edit)
+        return messages;
+    const replacement = edit.replacement;
+    if (replacement === null)
+        return [];
+    return messages.map((message) => {
+        if (message.role !== "user" &&
+            message.role !== "assistant" &&
+            message.role !== "toolResult" &&
+            message.role !== "custom") {
+            return message;
+        }
+        const content = (message.role === "assistant" || message.role === "toolResult") && typeof replacement.content === "string"
+            ? [{ type: "text", text: replacement.content }]
+            : replacement.content;
+        return { ...message, content };
+    });
+}
+/** Build provenance-preserving, compaction-aware model context. */
+export function buildSessionProjection(entries, leafId, byId) {
     const path = buildSessionPath(entries, leafId, byId);
     const { thinkingLevel, model } = getSessionContextSettings(path);
-    const messages = buildContextEntries(entries, leafId, byId).flatMap(sessionEntryToContextMessages);
+    const contextEntries = buildContextEntries(entries, leafId, byId);
+    const edits = new Map();
+    for (const entry of contextEntries) {
+        if (entry.type === "context_edit")
+            edits.set(entry.targetId, entry);
+    }
+    const projectedEntries = contextEntries.map((sourceEntry, index) => ({
+        sourceEntry,
+        // buildContextEntries() may retain an older compaction entry because its
+        // raw ID lies inside the newest retained range. Only the newest compaction
+        // at index zero contributes a checkpoint and summary.
+        messages: sourceEntry.type === "compaction" && index > 0
+            ? []
+            : projectContextEntry(sourceEntry, edits.get(sourceEntry.id)),
+    }));
+    return {
+        entries: projectedEntries,
+        messages: projectedEntries.flatMap((entry) => entry.messages),
+        thinkingLevel,
+        model,
+    };
+}
+/** Build the finalized model context from the canonical session projection. */
+export function buildSessionContext(entries, leafId, byId) {
+    const { messages, thinkingLevel, model } = buildSessionProjection(entries, leafId, byId);
     return { messages, thinkingLevel, model };
 }
 /**
@@ -413,14 +461,16 @@ export function findMostRecentSession(sessionDir, cwd) {
     const resolvedCwd = cwd ? resolvePath(cwd) : undefined;
     try {
         const files = readdirSync(resolvedSessionDir)
-            .filter((f) => f.endsWith(".jsonl"))
-            .map((f) => join(resolvedSessionDir, f))
-            .map((path) => ({ path, header: readSessionHeaderForDiscovery(path) }))
-            .filter((file) => file.header !== null &&
-            (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(file.header), resolvedCwd)))
-            .map(({ path }) => ({ path, mtime: statSync(path).mtime }))
-            .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-        return files[0]?.path || null;
+            .filter((file) => file.endsWith(".jsonl"))
+            .map((file) => join(resolvedSessionDir, file))
+            .map((path) => ({ path, mtime: statSync(path).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime);
+        for (const { path } of files) {
+            const header = readSessionHeaderForDiscovery(path);
+            if (header && (!resolvedCwd || sessionCwdMatches(getSessionHeaderCwd(header), resolvedCwd)))
+                return path;
+        }
+        return null;
     }
     catch {
         // Directory access and stat races make recent-session discovery unavailable.
@@ -453,9 +503,9 @@ function getMessageActivityTime(entry) {
     const t = new Date(entry.timestamp).getTime();
     return Number.isNaN(t) ? undefined : t;
 }
-async function buildSessionInfo(filePath) {
+async function buildSessionInfo(filePath, signal, fileStats) {
     try {
-        const stats = await stat(filePath);
+        const stats = fileStats ?? (await stat(filePath));
         let header = null;
         let messageCount = 0;
         let firstMessage = "";
@@ -463,7 +513,7 @@ async function buildSessionInfo(filePath) {
         let name;
         let lastActivityTime;
         const rl = createInterface({
-            input: createReadStream(filePath, { encoding: "utf8" }),
+            input: createReadStream(filePath, { encoding: "utf8", signal }),
             crlfDelay: Infinity,
         });
         for await (const line of rl) {
@@ -524,67 +574,63 @@ async function buildSessionInfo(filePath) {
         };
     }
     catch {
+        signal?.throwIfAborted();
         return null;
     }
 }
 const MAX_CONCURRENT_SESSION_INFO_LOADS = 10;
-async function buildSessionInfosWithConcurrency(files, onLoaded) {
-    const results = new Array(files.length).fill(null);
-    const inFlight = new Set();
+const MAX_CONCURRENT_SESSION_DISCOVERY_LOADS = 64;
+const CURRENT_SESSION_LIST_PUBLISH_INTERVAL = 10;
+const ALL_SESSION_LIST_PUBLISH_INTERVAL = 100;
+async function mapWithConcurrency(items, limit, map, signal) {
+    const results = new Array(items.length);
     let nextIndex = 0;
-    const startNext = () => {
-        const index = nextIndex++;
-        const file = files[index];
-        if (!file)
-            return;
-        let task;
-        task = buildSessionInfo(file)
-            .then((info) => {
-            results[index] = info;
-        })
-            .catch(() => {
-            results[index] = null;
-        })
-            .finally(() => {
-            inFlight.delete(task);
-            onLoaded();
-        });
-        inFlight.add(task);
-    };
-    while (nextIndex < files.length || inFlight.size > 0) {
-        while (nextIndex < files.length && inFlight.size < MAX_CONCURRENT_SESSION_INFO_LOADS) {
-            startNext();
+    const worker = async () => {
+        while (nextIndex < items.length) {
+            signal?.throwIfAborted();
+            const index = nextIndex++;
+            results[index] = await map(items[index], index);
         }
-        if (inFlight.size > 0) {
-            await Promise.race(inFlight);
-        }
-    }
+    };
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, () => worker()));
     return results;
 }
-async function listSessionsFromDir(dir, onProgress, progressOffset = 0, progressTotal) {
-    const sessions = [];
-    if (!existsSync(dir)) {
-        return sessions;
-    }
+function sortSessionInfos(sessions) {
+    return sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+}
+function buildSessionInfosWithConcurrency(files, onLoaded, signal) {
+    return mapWithConcurrency(files, MAX_CONCURRENT_SESSION_INFO_LOADS, async (file, index) => {
+        const info = await buildSessionInfo(file.path, signal, file.stats);
+        onLoaded(info, index);
+        return info;
+    }, signal);
+}
+async function listSessionsFromDir(dir, onProgress, signal) {
+    signal?.throwIfAborted();
+    if (!existsSync(dir))
+        return [];
     try {
         const dirEntries = await readdir(dir);
-        const files = dirEntries.filter((f) => f.endsWith(".jsonl")).map((f) => join(dir, f));
-        const total = progressTotal ?? files.length;
+        const files = dirEntries
+            .filter((file) => file.endsWith(".jsonl"))
+            .sort((a, b) => b.localeCompare(a))
+            .map((file) => ({ path: join(dir, file) }));
+        const total = files.length;
+        const partialSessions = [];
         let loaded = 0;
-        const results = await buildSessionInfosWithConcurrency(files, () => {
+        const results = await buildSessionInfosWithConcurrency(files, (info) => {
             loaded++;
-            onProgress?.(progressOffset + loaded, total);
-        });
-        for (const info of results) {
-            if (info) {
-                sessions.push(info);
-            }
-        }
+            if (info)
+                partialSessions.push(info);
+            const publishPartial = loaded === 1 || loaded % CURRENT_SESSION_LIST_PUBLISH_INTERVAL === 0 || loaded === files.length;
+            onProgress?.(loaded, total, publishPartial ? sortSessionInfos([...partialSessions]) : undefined);
+        }, signal);
+        return results.filter((info) => info !== null);
     }
     catch {
-        // Return empty list on error
+        signal?.throwIfAborted();
+        return [];
     }
-    return sessions;
 }
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
@@ -625,6 +671,9 @@ export class SessionManager {
         if (sessionFile) {
             this._setSessionFile(sessionFile, preloadedFileEntries);
         }
+        else if (preloadedFileEntries?.length) {
+            this._loadEntries(preloadedFileEntries, newSessionOptions);
+        }
         else {
             this.newSession(newSessionOptions);
         }
@@ -636,11 +685,10 @@ export class SessionManager {
     _setSessionFile(sessionFile, preloadedFileEntries) {
         this.sessionFile = resolvePath(sessionFile);
         if (existsSync(this.sessionFile)) {
-            this.fileEntries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
-            this.entriesVersion++;
+            const entries = preloadedFileEntries ?? loadEntriesFromFile(this.sessionFile);
             // If file was empty, initialize it with a valid session header. If it was
             // non-empty but did not parse as a pi session, fail without modifying it.
-            if (this.fileEntries.length === 0) {
+            if (entries.length === 0) {
                 const explicitPath = this.sessionFile;
                 if (statSync(explicitPath).size > 0) {
                     throw new Error(`Session file is not a valid ${APP_NAME} session: ${explicitPath}`);
@@ -651,12 +699,7 @@ export class SessionManager {
                 this.flushed = true;
                 return;
             }
-            const header = this.fileEntries.find((e) => e.type === "session");
-            this.sessionId = header?.id ?? createSessionId();
-            if (migrateToCurrentVersion(this.fileEntries)) {
-                this._rewriteFile();
-            }
-            this._buildIndex();
+            this._loadEntries(entries);
             this.flushed = true;
         }
         else {
@@ -693,6 +736,22 @@ export class SessionManager {
         }
         return this.sessionFile;
     }
+    _loadEntries(entries, options) {
+        const header = entries.find((e) => e.type === "session");
+        if (header) {
+            this.fileEntries = entries;
+            this.sessionId = header.id;
+            if (migrateToCurrentVersion(this.fileEntries)) {
+                this._rewriteFile();
+            }
+        }
+        else {
+            this.newSession(options);
+            this.fileEntries = this.fileEntries.concat(entries);
+        }
+        this.entriesVersion++;
+        this._buildIndex();
+    }
     _buildIndex() {
         this.byId.clear();
         this.labelsById.clear();
@@ -833,19 +892,39 @@ export class SessionManager {
         this._appendEntry(entry);
         return entry.id;
     }
+    /** Append model-attributed usage that does not participate in LLM context. Returns the appended entry. */
+    appendUsage(kind, provider, model, usage, note) {
+        const entry = {
+            type: "usage",
+            id: generateId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            kind,
+            provider,
+            model,
+            usage,
+            ...(note ? { note } : {}),
+        };
+        this._appendEntry(entry);
+        return entry;
+    }
     /** Append a compaction summary as child of current leaf, then advance leaf. Returns entry id. */
     appendCompaction(summary, firstKeptEntryId, tokensBefore, details, fromHook, usage) {
+        const timestamp = new Date().toISOString();
+        const systemMessage = getCurrentSystemMessage(this.buildSessionProjection().messages);
+        const id = generateId(this.byId);
         const entry = {
             type: "compaction",
-            id: generateId(this.byId),
+            id,
             parentId: this.leafId,
-            timestamp: new Date().toISOString(),
+            timestamp,
             summary,
-            firstKeptEntryId,
+            firstKeptEntryId: firstKeptEntryId ?? id,
             tokensBefore,
             details,
             usage,
             fromHook,
+            ...(systemMessage ? { systemMessage: { ...systemMessage, timestamp: new Date(timestamp).getTime() } } : {}),
         };
         this._appendEntry(entry);
         return entry.id;
@@ -943,6 +1022,44 @@ export class SessionManager {
         this._appendEntry(entry);
         return entry.id;
     }
+    /** Append a branch-local edit to an earlier model-visible entry. */
+    appendContextEdit(targetId, replacement) {
+        if (replacement !== null &&
+            (typeof replacement !== "object" ||
+                !("content" in replacement) ||
+                (typeof replacement.content !== "string" && !Array.isArray(replacement.content)))) {
+            throw new Error("Context edit replacement must be null or contain string/array content");
+        }
+        const target = this.byId.get(targetId);
+        if (!target)
+            throw new Error(`Entry ${targetId} not found`);
+        if (!this.getBranch().some((entry) => entry.id === targetId)) {
+            throw new Error(`Entry ${targetId} is not on the active branch`);
+        }
+        const editable = target.type === "custom_message" ||
+            (target.type === "message" &&
+                (target.message.role === "user" ||
+                    target.message.role === "assistant" ||
+                    target.message.role === "toolResult"));
+        if (!editable)
+            throw new Error(`Entry ${targetId} does not contribute editable model content`);
+        const targetRole = target.type === "message" ? target.message.role : "custom";
+        const normalizedReplacement = replacement !== null &&
+            (targetRole === "assistant" || targetRole === "toolResult") &&
+            typeof replacement.content === "string"
+            ? { content: [{ type: "text", text: replacement.content }] }
+            : replacement;
+        const entry = {
+            type: "context_edit",
+            id: generateId(this.byId),
+            parentId: this.leafId,
+            timestamp: new Date().toISOString(),
+            targetId,
+            replacement: normalizedReplacement,
+        };
+        this._appendEntry(entry);
+        return entry.id;
+    }
     // =========================================================================
     // Tree Traversal
     // =========================================================================
@@ -1032,8 +1149,12 @@ export class SessionManager {
      * Build the session context (what gets sent to the LLM).
      * Uses tree traversal from current leaf.
      */
+    buildSessionProjection() {
+        return buildSessionProjection(this.getEntries(), this.leafId, this.byId);
+    }
     buildSessionContext() {
-        return buildSessionContext(this.getEntries(), this.leafId, this.byId);
+        const { messages, thinkingLevel, model } = this.buildSessionProjection();
+        return { messages, thinkingLevel, model };
     }
     /**
      * Get session header.
@@ -1167,11 +1288,27 @@ export class SessionManager {
         // Because labels are real tree entries, later entries can be children of labels;
         // removing labels requires re-chaining the retained path to avoid orphaned subtrees.
         const pathWithoutLabels = [];
+        const replacementByLabelId = new Map();
+        const pendingLabelIds = [];
         let pathParentId = null;
         for (const entry of path) {
-            if (entry.type === "label")
+            if (entry.type === "label") {
+                pendingLabelIds.push(entry.id);
                 continue;
-            pathWithoutLabels.push({ ...entry, parentId: pathParentId });
+            }
+            for (const labelId of pendingLabelIds) {
+                replacementByLabelId.set(labelId, entry.id);
+            }
+            pendingLabelIds.length = 0;
+            pathWithoutLabels.push(entry.type === "compaction"
+                ? {
+                    ...entry,
+                    parentId: pathParentId,
+                    firstKeptEntryId: entry.firstKeptEntryId === entry.id
+                        ? entry.id
+                        : (replacementByLabelId.get(entry.firstKeptEntryId) ?? entry.firstKeptEntryId),
+                }
+                : { ...entry, parentId: pathParentId });
             pathParentId = entry.id;
         }
         const newSessionId = createSessionId();
@@ -1305,9 +1442,9 @@ export class SessionManager {
         }
         return new SessionManager(cwd, dir, undefined, true);
     }
-    /** Create an in-memory session (no file persistence) */
-    static inMemory(cwd = process.cwd(), options) {
-        return new SessionManager(cwd, "", undefined, false, options);
+    /** Create an in-memory session (no file persistence), optionally from entries held outside the filesystem. */
+    static inMemory(cwd = process.cwd(), options, entries) {
+        return new SessionManager(cwd, "", undefined, false, options, entries);
     }
     /**
      * Fork a session from another project directory into the current project.
@@ -1357,67 +1494,110 @@ export class SessionManager {
         }
         return new SessionManager(resolvedTargetCwd, dir, newSessionFile, true);
     }
+    /**
+     * Find an exact session ID without loading transcript bodies.
+     * @param cwd Working directory (used to compute default session directory)
+     * @param id Exact session ID
+     * @param sessionDir Optional session directory. If omitted, uses default (~/.pi/agent/sessions/<encoded-cwd>/).
+     */
+    static findById(cwd, id, sessionDir) {
+        const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
+        const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
+        const resolvedCwd = resolvePath(cwd);
+        try {
+            for (const file of readdirSync(dir)) {
+                if (!file.endsWith(".jsonl"))
+                    continue;
+                const path = join(dir, file);
+                const header = readSessionHeaderForDiscovery(path);
+                if (header?.id !== id)
+                    continue;
+                if (filterCwd && !sessionCwdMatches(getSessionHeaderCwd(header), resolvedCwd))
+                    continue;
+                return path;
+            }
+        }
+        catch {
+            // Exact session discovery is best-effort, matching list().
+        }
+        return undefined;
+    }
     /**
      * List all sessions for a directory.
      * @param cwd Working directory (used to compute default session directory)
      * @param sessionDir Optional session directory. If omitted, uses default (~/.apex-code/agent/sessions/<encoded-cwd>/).
      * @param onProgress Optional callback for progress updates (loaded, total)
      */
-    static async list(cwd, sessionDir, onProgress) {
+    static async list(cwd, sessionDir, onProgress, signal) {
         const dir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
         const filterCwd = sessionDir !== undefined && dir !== getDefaultSessionDirPath(cwd);
         const resolvedCwd = resolvePath(cwd);
-        const sessions = (await listSessionsFromDir(dir, onProgress)).filter((session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd));
-        sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-        return sessions;
-    }
-    static async listAll(sessionDirOrOnProgress, onProgress) {
+        const includeSession = (session) => !filterCwd || sessionCwdMatches(session.cwd, resolvedCwd);
+        const progress = onProgress
+            ? (loaded, total, partialSessions) => onProgress(loaded, total, partialSessions?.filter(includeSession))
+            : undefined;
+        const sessions = (await listSessionsFromDir(dir, progress, signal)).filter(includeSession);
+        return sortSessionInfos(sessions);
+    }
+    static async listAll(sessionDirOrOnProgress, onProgressOrSignal, signal) {
         const customSessionDir = typeof sessionDirOrOnProgress === "string" ? normalizePath(sessionDirOrOnProgress) : undefined;
-        const progress = typeof sessionDirOrOnProgress === "function" ? sessionDirOrOnProgress : onProgress;
+        const progress = typeof sessionDirOrOnProgress === "function"
+            ? sessionDirOrOnProgress
+            : typeof onProgressOrSignal === "function"
+                ? onProgressOrSignal
+                : undefined;
+        const abortSignal = typeof sessionDirOrOnProgress === "string" || typeof onProgressOrSignal === "function"
+            ? signal
+            : (onProgressOrSignal ?? signal);
+        abortSignal?.throwIfAborted();
         if (customSessionDir) {
-            const sessions = await listSessionsFromDir(customSessionDir, progress);
-            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-            return sessions;
+            return sortSessionInfos(await listSessionsFromDir(customSessionDir, progress, abortSignal));
         }
         const sessionsDir = getSessionsDir();
         try {
-            if (!existsSync(sessionsDir)) {
+            if (!existsSync(sessionsDir))
                 return [];
-            }
             const entries = await readdir(sessionsDir, { withFileTypes: true });
             const dirs = entries
                 .filter((entry) => entry.isDirectory() || entry.isSymbolicLink())
                 .map((entry) => join(sessionsDir, entry.name));
-            // Count total files first for accurate progress
-            let totalFiles = 0;
-            const dirFiles = [];
-            for (const dir of dirs) {
+            const dirFiles = await mapWithConcurrency(dirs, MAX_CONCURRENT_SESSION_DISCOVERY_LOADS, async (dir) => {
                 try {
-                    const files = (await readdir(dir)).filter((f) => f.endsWith(".jsonl"));
-                    dirFiles.push(files.map((f) => join(dir, f)));
-                    totalFiles += files.length;
+                    return (await readdir(dir)).filter((file) => file.endsWith(".jsonl")).map((file) => join(dir, file));
                 }
                 catch {
-                    dirFiles.push([]);
+                    return [];
                 }
-            }
-            // Process all files with progress tracking
-            let loaded = 0;
-            const sessions = [];
+            }, abortSignal);
             const allFiles = dirFiles.flat();
-            const results = await buildSessionInfosWithConcurrency(allFiles, () => {
-                loaded++;
-                progress?.(loaded, totalFiles);
-            });
-            for (const info of results) {
-                if (info) {
-                    sessions.push(info);
+            const candidates = await mapWithConcurrency(allFiles, MAX_CONCURRENT_SESSION_DISCOVERY_LOADS, async (path) => {
+                try {
+                    return { path, stats: await stat(path) };
                 }
-            }
-            sessions.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-            return sessions;
+                catch {
+                    return { path };
+                }
+            }, abortSignal);
+            candidates.sort((a, b) => (b.stats?.mtimeMs ?? Number.NEGATIVE_INFINITY) - (a.stats?.mtimeMs ?? Number.NEGATIVE_INFINITY) ||
+                basename(b.path).localeCompare(basename(a.path)));
+            const totalFiles = candidates.length;
+            let loaded = 0;
+            let firstCandidateLoaded = false;
+            const partialSessions = [];
+            const results = await buildSessionInfosWithConcurrency(candidates, (info, index) => {
+                loaded++;
+                if (index === 0)
+                    firstCandidateLoaded = true;
+                if (info)
+                    partialSessions.push(info);
+                const publishPartial = firstCandidateLoaded &&
+                    (index === 0 || loaded % ALL_SESSION_LIST_PUBLISH_INTERVAL === 0 || loaded === totalFiles);
+                progress?.(loaded, totalFiles, publishPartial ? sortSessionInfos([...partialSessions]) : undefined);
+            }, abortSignal);
+            return sortSessionInfos(results.filter((info) => info !== null));
         }
         catch {
+            abortSignal?.throwIfAborted();
             return [];
         }
     }