@getpaseo/server 0.1.91-beta.2 → 0.1.92

package/dist/server/server/agent/providers/pi/agent.js

@@ -2,6 +2,8 @@ import { randomUUID } from "node:crypto";
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
 import { join } from "node:path";
+import { z } from "zod";
+import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { runProviderTurn } from "../provider-runner.js";
 import { checkProviderLaunchAvailable, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../../prompt-attachments.js";
@@ -10,6 +12,7 @@ import { buildBinaryDiagnosticRows, formatDiagnosticStatus, formatProviderDiagno
 import { getUserMessageText, streamPiHistory, } from "./history-mapper.js";
 import { PiCliRuntime } from "./cli-runtime.js";
 import { revertPiConversation } from "./rewind.js";
+import { listPiImportableSessions } from "./session-descriptor.js";
 import { mapToolDetail, parseToolArgs, parseToolResult, resolveToolCallName, } from "./tool-call-mapper.js";
 const PI_PROVIDER = "pi";
 const DEFAULT_PI_THINKING_LEVEL = "medium";
@@ -23,9 +26,35 @@ const QUESTION_RESPONSE_HEADER = "Response";
 const QUESTION_COMMENT_HEADER = "Comment";
 const PI_ASK_USER_FREEFORM_SENTINEL = "✏️ Type custom response...";
 const COMBINED_ASK_USER_METADATA = "ask_user_select_optional_comment";
+export const PiProviderParamsSchema = z
+    .object({
+    sessionDir: z.string().min(1).optional(),
+})
+    .strict();
+const PI_HANDLED_BUILTIN_SLASH_COMMANDS = [
+    {
+        name: "compact",
+        description: "Manually compact the session context",
+        argumentHint: "[instructions]",
+        kind: "command",
+    },
+    {
+        name: "autocompact",
+        description: "Toggle automatic context compaction",
+        argumentHint: "[on|off|toggle]",
+        kind: "command",
+    },
+];
+function mapPiCommandKind(source) {
+    if (source === "skill") {
+        return "skill";
+    }
+    return "command";
+}
 const PI_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: true,
     supportsMcpServers: false,
     supportsReasoningStream: true,
@@ -43,7 +72,12 @@ const PI_THINKING_OPTIONS = [
     { id: "xhigh", label: "XHigh", description: "Maximum reasoning" },
 ];
 function normalizePiModelLabel(label) {
-    return label.trim().replace(/[_\s]+/g, " ");
+    const normalizedLabel = label.trim().replace(/[_\s]+/g, " ");
+    const vendorSeparatorIndex = normalizedLabel.indexOf(": ");
+    if (vendorSeparatorIndex === -1) {
+        return normalizedLabel;
+    }
+    return normalizedLabel.slice(vendorSeparatorIndex + 2).trim();
 }
 export function transformPiModels(models) {
     return models.map((model) => {
@@ -76,6 +110,19 @@ function normalizePiThinkingOption(value) {
     }
     return isPiThinkingLevel(value) ? value : null;
 }
+function parseAutoCompactMode(value) {
+    const mode = (value ?? "toggle").trim().toLowerCase();
+    if (mode === "on" || mode === "true" || mode === "enable" || mode === "enabled") {
+        return true;
+    }
+    if (mode === "off" || mode === "false" || mode === "disable" || mode === "disabled") {
+        return false;
+    }
+    if (mode === "toggle") {
+        return "toggle";
+    }
+    return "unknown";
+}
 function mapThinkingOption(option) {
     const mappedOption = {
         id: option.id,
@@ -654,6 +701,9 @@ export class PiRpcAgentSession {
         this.seenUserEntryIds = new Set();
         this.pendingUserMessages = [];
         this.pendingExtensionResults = new Map();
+        this.outOfBandCompactionEmit = null;
+        this.outOfBandCompactionStarted = false;
+        this.outOfBandCompactionCompleted = false;
         this.closed = false;
         this.runtimeSession = options.runtimeSession;
         this.config = options.config;
@@ -821,11 +871,42 @@ export class PiRpcAgentSession {
     }
     async listCommands() {
         const commands = await this.runtimeSession.getCommands();
-        return commands.map((command) => ({
-            name: command.name,
-            description: command.description ?? command.source,
-            argumentHint: "",
-        }));
+        const mappedCommands = new Map(PI_HANDLED_BUILTIN_SLASH_COMMANDS.map((command) => [command.name, { ...command }]));
+        for (const command of commands) {
+            const knownCommand = mappedCommands.get(command.name);
+            mappedCommands.set(command.name, {
+                name: command.name,
+                description: command.description ?? command.source,
+                argumentHint: knownCommand?.argumentHint ?? "",
+                kind: mapPiCommandKind(command.source),
+            });
+        }
+        return [...mappedCommands.values()];
+    }
+    tryHandleOutOfBand(prompt) {
+        if (typeof prompt !== "string") {
+            return null;
+        }
+        const parsed = this.parseSlashCommandInput(prompt);
+        if (!parsed) {
+            return null;
+        }
+        const commandName = parsed.commandName.toLowerCase();
+        if (commandName === "compact") {
+            return {
+                run: async ({ emit }) => {
+                    await this.executeCompactCommand(parsed.args, emit);
+                },
+            };
+        }
+        if (commandName === "autocompact") {
+            return {
+                run: async ({ emit }) => {
+                    await this.executeAutoCompactCommand(parsed.args, emit);
+                },
+            };
+        }
+        return null;
     }
     async setModel(modelId) {
         const parsedReference = parseModelReference(modelId);
@@ -860,6 +941,117 @@ export class PiRpcAgentSession {
     currentTurnIdForEvent() {
         return this.activeTurnId ?? undefined;
     }
+    parseSlashCommandInput(text) {
+        const trimmed = text.trim();
+        if (!trimmed.startsWith("/") || trimmed.length <= 1) {
+            return null;
+        }
+        const withoutPrefix = trimmed.slice(1);
+        const firstWhitespaceIdx = withoutPrefix.search(/\s/);
+        const commandName = firstWhitespaceIdx === -1 ? withoutPrefix : withoutPrefix.slice(0, firstWhitespaceIdx);
+        if (!commandName || commandName.includes("/")) {
+            return null;
+        }
+        const rawArgs = firstWhitespaceIdx === -1 ? "" : withoutPrefix.slice(firstWhitespaceIdx + 1).trim();
+        return rawArgs.length > 0 ? { commandName, args: rawArgs } : { commandName };
+    }
+    async executeCompactCommand(customInstructions, emit) {
+        if (this.outOfBandCompactionEmit) {
+            throw new Error("A Pi compact command is already running");
+        }
+        this.outOfBandCompactionEmit = emit;
+        this.outOfBandCompactionStarted = false;
+        this.outOfBandCompactionCompleted = false;
+        try {
+            await this.runtimeSession.compact(customInstructions);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (this.outOfBandCompactionEmit === emit &&
+                this.outOfBandCompactionStarted &&
+                !this.outOfBandCompactionCompleted) {
+                this.emitCompactionTimeline({
+                    turnId: undefined,
+                    item: {
+                        type: "compaction",
+                        status: "completed",
+                        trigger: "manual",
+                    },
+                });
+            }
+            emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: `[Error] Failed to compact context: ${message}`,
+                },
+            });
+        }
+        finally {
+            if (this.outOfBandCompactionEmit === emit && !this.outOfBandCompactionStarted) {
+                this.outOfBandCompactionEmit = null;
+                this.outOfBandCompactionStarted = false;
+                this.outOfBandCompactionCompleted = false;
+            }
+        }
+    }
+    async executeAutoCompactCommand(mode, emit) {
+        let enabled = parseAutoCompactMode(mode);
+        if (enabled === "unknown") {
+            emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: "[Error] Usage: /autocompact [on|off|toggle]",
+                },
+            });
+            return;
+        }
+        if (enabled === "toggle") {
+            const state = await this.runtimeSession.getState();
+            if (typeof state.autoCompactionEnabled !== "boolean") {
+                emit({
+                    type: "timeline",
+                    provider: PI_PROVIDER,
+                    item: {
+                        type: "assistant_message",
+                        text: "[Error] Auto-compaction state is unavailable. Use /autocompact on or /autocompact off.",
+                    },
+                });
+                return;
+            }
+            enabled = !state.autoCompactionEnabled;
+        }
+        try {
+            await this.runtimeSession.setAutoCompaction(enabled);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            emit({
+                type: "timeline",
+                provider: PI_PROVIDER,
+                item: {
+                    type: "assistant_message",
+                    text: `[Error] Failed to set auto-compaction: ${message}`,
+                },
+            });
+            return;
+        }
+        this.state = {
+            ...this.state,
+            autoCompactionEnabled: enabled,
+        };
+        emit({
+            type: "timeline",
+            provider: PI_PROVIDER,
+            item: {
+                type: "assistant_message",
+                text: `Auto-compaction ${enabled ? "enabled" : "disabled"}.`,
+            },
+        });
+    }
     async requestEntryCapture(reason) {
         const requestId = randomUUID();
         const resultPromise = this.waitForExtensionResult(requestId);
@@ -1090,9 +1282,7 @@ export class PiRpcAgentSession {
                 return;
             }
             case "compaction_start":
-                this.emit({
-                    type: "timeline",
-                    provider: PI_PROVIDER,
+                this.emitCompactionTimeline({
                     turnId,
                     item: {
                         type: "compaction",
@@ -1102,13 +1292,12 @@ export class PiRpcAgentSession {
                 });
                 return;
             case "compaction_end":
-                this.emit({
-                    type: "timeline",
-                    provider: PI_PROVIDER,
+                this.emitCompactionTimeline({
                     turnId,
                     item: {
                         type: "compaction",
                         status: "completed",
+                        trigger: event.reason === "manual" ? "manual" : "auto",
                     },
                 });
                 return;
@@ -1119,6 +1308,33 @@ export class PiRpcAgentSession {
                 return;
         }
     }
+    emitCompactionTimeline(input) {
+        const emitOutOfBand = this.outOfBandCompactionEmit;
+        if (emitOutOfBand && input.item.type === "compaction") {
+            if (input.item.status === "loading") {
+                this.outOfBandCompactionStarted = true;
+            }
+            if (input.item.status === "completed") {
+                this.outOfBandCompactionCompleted = true;
+            }
+        }
+        const event = {
+            type: "timeline",
+            provider: PI_PROVIDER,
+            ...(emitOutOfBand ? {} : { turnId: input.turnId }),
+            item: input.item,
+        };
+        if (emitOutOfBand) {
+            emitOutOfBand(event);
+            if (input.item.type === "compaction" && input.item.status === "completed") {
+                this.outOfBandCompactionEmit = null;
+                this.outOfBandCompactionStarted = false;
+                this.outOfBandCompactionCompleted = false;
+            }
+            return;
+        }
+        this.emit(event);
+    }
     handleMessageUpdate(event, turnId) {
         if (event.message.role !== "assistant") {
             return;
@@ -1240,6 +1456,7 @@ export class PiRpcAgentClient {
         this.capabilities = PI_CAPABILITIES;
         this.logger = options.logger;
         this.runtimeSettings = options.runtimeSettings;
+        this.providerParams = PiProviderParamsSchema.parse(options.providerParams ?? {});
         this.runtime = options.runtime ?? createRuntime(options.logger, options.runtimeSettings);
     }
     async createSession(config, launchContext) {
@@ -1332,8 +1549,20 @@ export class PiRpcAgentClient {
     async listModes(_options) {
         return [];
     }
-    async listPersistedAgents(_options) {
-        return [];
+    async listImportableSessions(options) {
+        return await listPiImportableSessions({
+            ...options,
+            sessionDir: this.providerParams.sessionDir,
+            runtimeSettings: this.runtimeSettings,
+        });
+    }
+    async importSession(input, context) {
+        return importSessionFromPersistence({
+            provider: PI_PROVIDER,
+            request: input,
+            context,
+            resumeSession: this.resumeSession.bind(this),
+        });
     }
     async isAvailable() {
         const launch = await this.resolvePiLaunch();

package/dist/server/server/agent/providers/pi/cli-runtime.js

@@ -76,6 +76,15 @@ class PiCliRuntimeSession {
     async prompt(message, images) {
         await this.request({ type: "prompt", message, ...(images?.length ? { images } : {}) });
     }
+    async compact(customInstructions) {
+        await this.request({
+            type: "compact",
+            ...(customInstructions ? { customInstructions } : {}),
+        });
+    }
+    async setAutoCompaction(enabled) {
+        await this.request({ type: "set_auto_compaction", enabled });
+    }
     async abort() {
         await this.request({ type: "abort" });
     }

package/dist/server/server/agent/providers/pi/rpc-types.d.ts

@@ -66,6 +66,7 @@ export interface PiSessionState {
     thinkingLevel: PiThinkingLevel;
     isStreaming: boolean;
     isCompacting: boolean;
+    autoCompactionEnabled?: boolean;
     sessionFile?: string;
     sessionId: string;
     sessionName?: string;
@@ -98,6 +99,14 @@ export type PiRpcCommand = {
     type: "prompt";
     message: string;
     images?: PiImageContent[];
+} | {
+    id?: string;
+    type: "compact";
+    customInstructions?: string;
+} | {
+    id?: string;
+    type: "set_auto_compaction";
+    enabled: boolean;
 } | {
     id?: string;
     type: "abort";

package/dist/server/server/agent/providers/pi/runtime.d.ts

@@ -28,6 +28,8 @@ export interface PiRuntimeSession {
         data: string;
         mimeType: string;
     }>): Promise<void>;
+    compact(customInstructions?: string): Promise<void>;
+    setAutoCompaction(enabled: boolean): Promise<void>;
     abort(): Promise<void>;
     getState(): Promise<PiSessionState>;
     getMessages(): Promise<PiAgentMessage[]>;

package/dist/server/server/agent/providers/pi/session-descriptor.d.ts

@@ -0,0 +1,11 @@
+import type { ImportableProviderSession, ListImportableSessionsOptions } from "../../agent-sdk-types.js";
+import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
+interface PiSessionDescriptorOptions extends ListImportableSessionsOptions {
+    sessionDir?: string;
+    runtimeSettings?: ProviderRuntimeSettings;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+}
+export declare function listPiImportableSessions(options?: PiSessionDescriptorOptions): Promise<ImportableProviderSession[]>;
+export {};
+//# sourceMappingURL=session-descriptor.d.ts.map

package/dist/server/server/agent/providers/pi/session-descriptor.js

@@ -0,0 +1,284 @@
+import { open, readdir, readFile, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { createRealpathAwarePathMatcher } from "../../../../utils/path.js";
+const PI_CONFIG_DIR_NAME = ".pi";
+const PI_AGENT_DIR_ENV = "PI_CODING_AGENT_DIR";
+const PI_SESSION_DIR_ENV = "PI_CODING_AGENT_SESSION_DIR";
+const HEAD_BYTES = 64 * 1024;
+const TAIL_BYTES = 256 * 1024;
+const FULL_SCAN_LINE_LIMIT = 2000;
+export async function listPiImportableSessions(options = {}) {
+    const sessionsDir = await resolvePiSessionsDir(options);
+    const files = await walkJsonlFiles(sessionsDir);
+    const matchesCwd = options.cwd ? createRealpathAwarePathMatcher(options.cwd) : null;
+    const limit = options.limit ?? 20;
+    const sessions = [];
+    for (const file of files) {
+        const session = await readPiImportableSession(file);
+        if (!session)
+            continue;
+        if (matchesCwd && !matchesCwd(session.cwd))
+            continue;
+        sessions.push(session);
+    }
+    return sessions
+        .sort((left, right) => right.lastActivityAt.getTime() - left.lastActivityAt.getTime())
+        .slice(0, limit);
+}
+async function resolvePiSessionsDir(options) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const baseDir = options.cwd ?? process.cwd();
+    if (options.sessionDir?.trim()) {
+        return resolveConfigPath(options.sessionDir, { baseDir, homeDir });
+    }
+    const agentDir = resolvePiAgentDir({ runtimeSettings: options.runtimeSettings, env, homeDir });
+    const envSessionDir = options.runtimeSettings?.env?.[PI_SESSION_DIR_ENV] ?? env[PI_SESSION_DIR_ENV];
+    if (envSessionDir?.trim()) {
+        return resolveConfigPath(envSessionDir, { baseDir, homeDir });
+    }
+    const settingsSessionDir = await readConfiguredSessionDir({
+        agentDir,
+        cwd: options.cwd,
+    });
+    if (settingsSessionDir?.trim()) {
+        return resolveConfigPath(settingsSessionDir, { baseDir, homeDir });
+    }
+    return path.join(agentDir, "sessions");
+}
+function resolvePiAgentDir(input) {
+    const configured = input.runtimeSettings?.env?.[PI_AGENT_DIR_ENV] ?? input.env[PI_AGENT_DIR_ENV];
+    if (configured?.trim()) {
+        return resolveConfigPath(configured, { baseDir: process.cwd(), homeDir: input.homeDir });
+    }
+    return path.join(input.homeDir, PI_CONFIG_DIR_NAME, "agent");
+}
+async function readConfiguredSessionDir(input) {
+    const values = await Promise.all([
+        readSessionDirFromSettings(path.join(input.agentDir, "settings.json")),
+        input.cwd
+            ? readSessionDirFromSettings(path.join(input.cwd, PI_CONFIG_DIR_NAME, "settings.json"))
+            : null,
+    ]);
+    return values[1] ?? values[0] ?? null;
+}
+async function readSessionDirFromSettings(settingsPath) {
+    try {
+        const parsed = JSON.parse(await readFile(settingsPath, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return null;
+        }
+        const sessionDir = Reflect.get(parsed, "sessionDir");
+        return typeof sessionDir === "string" && sessionDir.trim() ? sessionDir : null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfigPath(value, options) {
+    if (value === "~") {
+        return options.homeDir;
+    }
+    if (value.startsWith("~/")) {
+        return path.join(options.homeDir, value.slice(2));
+    }
+    return path.isAbsolute(value) ? value : path.resolve(options.baseDir, value);
+}
+async function walkJsonlFiles(root) {
+    let entries;
+    try {
+        entries = await readdir(root, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            return await walkJsonlFiles(entryPath);
+        }
+        return entry.isFile() && entry.name.endsWith(".jsonl") ? [entryPath] : [];
+    }));
+    return files.flat();
+}
+async function readPiImportableSession(filePath) {
+    const firstLine = await readFirstLine(filePath);
+    if (!firstLine)
+        return null;
+    const header = parseSessionHeader(firstLine);
+    if (!header)
+        return null;
+    const tail = await readTail(filePath).catch(() => "");
+    const tailInfo = parseSessionTail(tail);
+    const headInfo = await scanSessionHead(filePath);
+    const title = tailInfo.title ?? headInfo.title ?? headInfo.firstUserMessage;
+    const lastActivityAt = tailInfo.lastActivityAt ?? (await readFileMtime(filePath)) ?? header.createdAt ?? new Date(0);
+    return {
+        providerHandleId: filePath,
+        cwd: header.cwd,
+        title,
+        firstPromptPreview: normalizePromptPreview(headInfo.firstUserMessage),
+        lastPromptPreview: normalizePromptPreview(tailInfo.lastUserMessage ?? headInfo.firstUserMessage),
+        lastActivityAt,
+    };
+}
+async function readFirstLine(filePath) {
+    const handle = await open(filePath, "r").catch(() => null);
+    if (!handle)
+        return null;
+    try {
+        const buffer = Buffer.alloc(HEAD_BYTES);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+        if (bytesRead <= 0)
+            return null;
+        const chunk = buffer.subarray(0, bytesRead).toString("utf8");
+        const newlineIndex = chunk.indexOf("\n");
+        return (newlineIndex === -1 ? chunk : chunk.slice(0, newlineIndex)).trim();
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+async function readTail(filePath) {
+    const fileStats = await stat(filePath);
+    const start = Math.max(0, fileStats.size - TAIL_BYTES);
+    const length = fileStats.size - start;
+    const handle = await open(filePath, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+        return buffer.subarray(0, bytesRead).toString("utf8");
+    }
+    finally {
+        await handle.close().catch(() => undefined);
+    }
+}
+async function readFileMtime(filePath) {
+    try {
+        return (await stat(filePath)).mtime;
+    }
+    catch {
+        return null;
+    }
+}
+function parseSessionHeader(firstLine) {
+    const entry = parseJsonRecord(firstLine);
+    if (!entry || entry.type !== "session")
+        return null;
+    const sessionId = typeof entry.id === "string" ? entry.id : null;
+    const cwd = typeof entry.cwd === "string" ? entry.cwd : null;
+    if (!sessionId || !cwd)
+        return null;
+    const createdAt = parseDate(entry.timestamp);
+    return { sessionId, cwd, createdAt };
+}
+function parseSessionTail(tail) {
+    const lines = tail.split(/\r?\n/u);
+    let title = null;
+    let lastActivityAt = null;
+    let fallbackTimestamp = null;
+    let lastUserMessage = null;
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        const entry = parseJsonRecord(lines[index].trim());
+        if (!entry)
+            continue;
+        if (!title && entry.type === "session_info") {
+            title = readNonEmptyString(entry.name);
+        }
+        const entryTimestamp = parseDate(entry.timestamp);
+        if (!fallbackTimestamp && entryTimestamp) {
+            fallbackTimestamp = entryTimestamp;
+        }
+        if (entry.type !== "message") {
+            continue;
+        }
+        if (!lastActivityAt && entryTimestamp) {
+            lastActivityAt = entryTimestamp;
+        }
+        if (!lastUserMessage && isRecord(entry.message) && entry.message.role === "user") {
+            lastUserMessage = extractMessageText(entry.message.content);
+        }
+        if (title && lastActivityAt && lastUserMessage) {
+            break;
+        }
+    }
+    return { title, lastActivityAt: lastActivityAt ?? fallbackTimestamp, lastUserMessage };
+}
+async function scanSessionHead(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, "utf8");
+    }
+    catch {
+        return { title: null, firstUserMessage: null };
+    }
+    let title = null;
+    let firstUserMessage = null;
+    let lineCount = 0;
+    for (const rawLine of content.split(/\r?\n/u)) {
+        lineCount += 1;
+        const entry = parseJsonRecord(rawLine.trim());
+        if (!entry)
+            continue;
+        if (entry.type === "session_info") {
+            title = readNonEmptyString(entry.name) ?? title;
+        }
+        if (!firstUserMessage && entry.type === "message" && isRecord(entry.message)) {
+            if (entry.message.role === "user") {
+                firstUserMessage = extractMessageText(entry.message.content);
+            }
+        }
+        if (title && firstUserMessage) {
+            break;
+        }
+        if (lineCount >= FULL_SCAN_LINE_LIMIT && firstUserMessage) {
+            break;
+        }
+    }
+    return { title, firstUserMessage };
+}
+function parseJsonRecord(line) {
+    if (!line)
+        return null;
+    try {
+        const parsed = JSON.parse(line);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizePromptPreview(text) {
+    const normalized = text?.trim().replace(/\s+/g, " ") ?? "";
+    if (!normalized)
+        return null;
+    return normalized.length > 160 ? normalized.slice(0, 160) : normalized;
+}
+function parseDate(value) {
+    if (typeof value !== "string" && typeof value !== "number") {
+        return null;
+    }
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function extractMessageText(content) {
+    if (typeof content === "string") {
+        return content.trim() || null;
+    }
+    if (!Array.isArray(content)) {
+        return null;
+    }
+    const text = content
+        .flatMap((part) => isRecord(part) && part.type === "text" && typeof part.text === "string" ? [part.text] : [])
+        .join("\n\n")
+        .trim();
+    return text || null;
+}
+//# sourceMappingURL=session-descriptor.js.map