@axhub/acp 0.1.0

package/dist/lib/conversations/store.mjs

@@ -0,0 +1,678 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeAcpProvider } from "../acp2aisdk/provider-registry.mjs";
+import { DEFAULT_PERMISSION_MODE, normalizeWorkspacePath, } from "../acp2aisdk/session-store.mjs";
+import { convertTranscriptToMessageRepository, findProviderSession, loadProviderTranscript, scanProviderSessions, } from "../provider-history/index.mjs";
+import { mergePersistedBuiltinToolSettings, normalizePersistedBuiltinToolSettings, } from "../../tools/registry.mjs";
+import { deleteRuntimeMessages, getRuntimeMessageRepository, isRuntimeMessageConversationExpired, pruneExpiredRuntimeMessages, upsertRuntimeMessage, } from "./message-repository.mjs";
+const STORE_VERSION = 1;
+const DEFAULT_CONVERSATION_LIST_LIMIT = 50;
+const MAX_CONVERSATION_LIST_LIMIT = 200;
+const PROVIDER_SCAN_CACHE_TTL_MS = 30000;
+const PLACEHOLDER_TITLE = "新对话";
+const GENERATED_TITLE_MAX_LENGTH = 48;
+const providerSessionScanCache = new Map();
+function createProviderSessionThreadId(provider, sessionId) {
+    return `${provider}-${sessionId}`;
+}
+function getStorePath(workspacePath) {
+    const overridePath = process.env.ACP_UI_CONVERSATION_STORE;
+    if (overridePath)
+        return path.resolve(/* turbopackIgnore: true */ overridePath);
+    const resolvedWorkspacePath = normalizeWorkspacePath(workspacePath);
+    return path.join(
+    /* turbopackIgnore: true */ resolvedWorkspacePath, ".axhub", "sessions", "conversations.json");
+}
+function emptyStore() {
+    return {
+        version: STORE_VERSION,
+        conversations: [],
+        sessions: [],
+        messages: {},
+    };
+}
+function nowIso() {
+    return new Date().toISOString();
+}
+function compareUpdatedAtDesc(left, right) {
+    return right.updatedAt.localeCompare(left.updatedAt);
+}
+function normalizeConversationListLimit(limit) {
+    if (!Number.isFinite(limit))
+        return DEFAULT_CONVERSATION_LIST_LIMIT;
+    return Math.min(MAX_CONVERSATION_LIST_LIMIT, Math.max(1, Math.floor(limit)));
+}
+function isActiveConversation(thread) {
+    return thread.status !== "deleted";
+}
+function compareSessionActivityDesc(left, right) {
+    var _a, _b, _c, _d;
+    return ((_b = (_a = right.lastActivityAt) !== null && _a !== void 0 ? _a : right.createdAt) !== null && _b !== void 0 ? _b : "").localeCompare((_d = (_c = left.lastActivityAt) !== null && _c !== void 0 ? _c : left.createdAt) !== null && _d !== void 0 ? _d : "");
+}
+function findActiveConversation(data, threadId) {
+    var _a;
+    return ((_a = data.conversations.find((thread) => thread.threadId === threadId && isActiveConversation(thread))) !== null && _a !== void 0 ? _a : null);
+}
+function findConversationByProviderSession(data, { provider, sessionId, workspacePath, }) {
+    var _a;
+    const normalizedSessionId = sessionId.trim();
+    if (!normalizedSessionId)
+        return null;
+    const runtimeSession = data.sessions
+        .filter((session) => session.provider === provider &&
+        session.workspacePath === workspacePath &&
+        session.acpSessionId === normalizedSessionId)
+        .sort(compareSessionActivityDesc)[0];
+    if (runtimeSession) {
+        const thread = findActiveConversation(data, runtimeSession.threadId);
+        if (thread)
+            return { thread, source: "runtime-session" };
+    }
+    const conversation = (_a = data.conversations.find((thread) => isActiveConversation(thread) &&
+        thread.provider === provider &&
+        thread.workspacePath === workspacePath &&
+        thread.providerSessionId === normalizedSessionId)) !== null && _a !== void 0 ? _a : null;
+    if (conversation)
+        return { thread: conversation, source: "conversation" };
+    const importedThread = findActiveConversation(data, `${provider}:${normalizedSessionId}`);
+    if (importedThread)
+        return { thread: importedThread, source: "thread" };
+    const directThread = findActiveConversation(data, normalizedSessionId);
+    if (directThread)
+        return { thread: directThread, source: "thread" };
+    return null;
+}
+function paginateConversations(conversations, options = {}) {
+    var _a;
+    const limit = normalizeConversationListLimit(options.limit);
+    const visible = conversations
+        .filter(isActiveConversation)
+        .sort(compareUpdatedAtDesc);
+    const startIndex = options.after
+        ? Math.max(visible.findIndex((thread) => thread.threadId === options.after) + 1, 0)
+        : 0;
+    const threads = visible.slice(startIndex, startIndex + limit);
+    const nextCursor = startIndex + threads.length < visible.length
+        ? (_a = threads.at(-1)) === null || _a === void 0 ? void 0 : _a.threadId
+        : undefined;
+    return {
+        threads,
+        nextCursor,
+        total: visible.length,
+    };
+}
+async function scanProviderSessionsCached(workspacePath, refreshProvider) {
+    const cacheKey = workspacePath;
+    const cached = providerSessionScanCache.get(cacheKey);
+    const now = Date.now();
+    if (!refreshProvider && cached && cached.expiresAt > now) {
+        return cached.sessions;
+    }
+    const sessions = await scanProviderSessions(workspacePath);
+    providerSessionScanCache.set(cacheKey, {
+        expiresAt: now + PROVIDER_SCAN_CACHE_TTL_MS,
+        sessions,
+    });
+    return sessions;
+}
+async function readStore(workspacePath) {
+    const storePath = getStorePath(workspacePath);
+    try {
+        const raw = await fs.readFile(
+        /* turbopackIgnore: true */ storePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return {
+            version: STORE_VERSION,
+            conversations: Array.isArray(parsed.conversations)
+                ? parsed.conversations
+                : [],
+            sessions: Array.isArray(parsed.sessions) ? parsed.sessions : [],
+            messages: parsed.messages && typeof parsed.messages === "object"
+                ? parsed.messages
+                : {},
+        };
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return emptyStore();
+        }
+        throw error;
+    }
+}
+async function writeStore(data, workspacePath) {
+    const storePath = getStorePath(workspacePath);
+    const tempStorePath = `${storePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.mkdir(/* turbopackIgnore: true */ path.dirname(storePath), {
+        recursive: true,
+    });
+    const body = `${JSON.stringify(data, null, 2)}\n`;
+    await fs.writeFile(/* turbopackIgnore: true */ tempStorePath, body, "utf8");
+    await fs.rename(
+    /* turbopackIgnore: true */ tempStorePath, 
+    /* turbopackIgnore: true */ storePath);
+}
+let updateQueue = Promise.resolve();
+async function updateStore(workspacePath, updater) {
+    const task = updateQueue.then(async () => {
+        const data = await readStore(workspacePath);
+        const result = await updater(data);
+        await writeStore(data, workspacePath);
+        return result;
+    });
+    updateQueue = task.then(() => undefined, () => undefined);
+    return task;
+}
+function defaultTitle(threadId) {
+    return `Chat ${threadId.slice(-6) || threadId}`;
+}
+function isRecord(value) {
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizeConversationTitle(value, maxLength) {
+    let title = typeof value === "string" ? value.replace(/\s+/g, " ").trim() : "";
+    if (maxLength)
+        title = title.slice(0, maxLength).trim();
+    return title && title !== PLACEHOLDER_TITLE ? title : undefined;
+}
+function normalizeRuntimeSessionTitle(value) {
+    return normalizeConversationTitle(value);
+}
+function extractStoredText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => extractStoredText(item))
+            .filter((text) => text.trim())
+            .join(" ");
+    }
+    if (!isRecord(value))
+        return "";
+    if (typeof value.text === "string")
+        return value.text;
+    if (typeof value.input_text === "string")
+        return value.input_text;
+    if (typeof value.output_text === "string")
+        return value.output_text;
+    if ("content" in value)
+        return extractStoredText(value.content);
+    return "";
+}
+function titleFromStoredMessage(message) {
+    const content = message.content;
+    if (!isRecord(content) || content.role !== "user")
+        return undefined;
+    const body = Array.isArray(content.parts) ? content.parts : content.content;
+    return normalizeConversationTitle(extractStoredText(body), GENERATED_TITLE_MAX_LENGTH);
+}
+function titleFromRuntimeMessages(data, threadId) {
+    var _a, _b, _c;
+    const messages = (_c = (_b = (_a = data.messages) === null || _a === void 0 ? void 0 : _a[threadId]) === null || _b === void 0 ? void 0 : _b.messages) !== null && _c !== void 0 ? _c : [];
+    for (const message of messages) {
+        const title = titleFromStoredMessage(message);
+        if (title)
+            return title;
+    }
+    return undefined;
+}
+function backfillMissingConversationTitles(data) {
+    var _a;
+    for (const conversation of data.conversations) {
+        const title = normalizeConversationTitle(conversation.title);
+        if (title) {
+            conversation.title = title;
+            continue;
+        }
+        conversation.title =
+            (_a = titleFromRuntimeMessages(data, conversation.threadId)) !== null && _a !== void 0 ? _a : null;
+    }
+}
+function shouldScanProviderSessionsForTitleBackfill(data, workspacePath) {
+    const activeSessionThreadIds = new Set(data.sessions
+        .filter((session) => session.provider === "codex" &&
+        session.workspacePath === workspacePath &&
+        !!session.acpSessionId &&
+        !session.closedAt)
+        .map((session) => session.threadId));
+    return data.conversations.some((thread) => isActiveConversation(thread) &&
+        thread.provider === "codex" &&
+        thread.workspacePath === workspacePath &&
+        !normalizeConversationTitle(thread.title) &&
+        !!(thread.providerSessionId ||
+            thread.sourcePath ||
+            activeSessionThreadIds.has(thread.threadId)));
+}
+function normalizeBuiltinToolSettings(value) {
+    return normalizePersistedBuiltinToolSettings(value);
+}
+function mergeBuiltinToolSettings(current, patch) {
+    return mergePersistedBuiltinToolSettings(current, patch);
+}
+function createConversationRecord(request) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const timestamp = nowIso();
+    return {
+        threadId: request.threadId,
+        title: (_a = normalizeConversationTitle(request.title)) !== null && _a !== void 0 ? _a : null,
+        createdAt: timestamp,
+        updatedAt: timestamp,
+        archivedAt: null,
+        deletedAt: null,
+        workspacePath: normalizeWorkspacePath(request.workspacePath),
+        provider: normalizeAcpProvider(request.provider),
+        model: (_b = request.model) !== null && _b !== void 0 ? _b : null,
+        modeId: (_c = request.modeId) !== null && _c !== void 0 ? _c : null,
+        thoughtLevel: (_d = request.thoughtLevel) !== null && _d !== void 0 ? _d : null,
+        permissionMode: (_e = request.permissionMode) !== null && _e !== void 0 ? _e : DEFAULT_PERMISSION_MODE,
+        status: "active",
+        builtinToolSettings: normalizeBuiltinToolSettings(request.builtinToolSettings),
+        providerSessionId: (_f = request.providerSessionId) !== null && _f !== void 0 ? _f : null,
+        sourcePath: (_g = request.sourcePath) !== null && _g !== void 0 ? _g : null,
+        sourceKind: (_h = request.sourceKind) !== null && _h !== void 0 ? _h : null,
+        lastSeenMtime: (_j = request.lastSeenMtime) !== null && _j !== void 0 ? _j : null,
+        lastActiveAt: (_k = request.lastActiveAt) !== null && _k !== void 0 ? _k : null,
+    };
+}
+function updateConversationRecord(record, request) {
+    var _a, _b, _c;
+    return Object.assign(Object.assign({}, record), { title: (_b = (_a = normalizeConversationTitle(request.title)) !== null && _a !== void 0 ? _a : normalizeConversationTitle(record.title)) !== null && _b !== void 0 ? _b : null, workspacePath: request.workspacePath
+            ? normalizeWorkspacePath(request.workspacePath)
+            : record.workspacePath, provider: request.provider
+            ? normalizeAcpProvider(request.provider)
+            : record.provider, model: request.model !== undefined ? request.model : record.model, modeId: request.modeId !== undefined ? request.modeId : record.modeId, thoughtLevel: request.thoughtLevel !== undefined
+            ? request.thoughtLevel
+            : record.thoughtLevel, permissionMode: (_c = request.permissionMode) !== null && _c !== void 0 ? _c : record.permissionMode, builtinToolSettings: request.builtinToolSettings !== undefined
+            ? mergeBuiltinToolSettings(record.builtinToolSettings, request.builtinToolSettings)
+            : record.builtinToolSettings, providerSessionId: request.providerSessionId !== undefined
+            ? request.providerSessionId
+            : record.providerSessionId, sourcePath: request.sourcePath !== undefined ? request.sourcePath : record.sourcePath, sourceKind: request.sourceKind !== undefined ? request.sourceKind : record.sourceKind, lastSeenMtime: request.lastSeenMtime !== undefined
+            ? request.lastSeenMtime
+            : record.lastSeenMtime, lastActiveAt: request.lastActiveAt !== undefined
+            ? request.lastActiveAt
+            : record.lastActiveAt, updatedAt: nowIso(), status: record.status === "deleted" ? "active" : record.status, deletedAt: record.status === "deleted" ? null : record.deletedAt });
+}
+function filterMessagesByFormat(repo, format) {
+    return format
+        ? repo.messages.filter((message) => message.format === format)
+        : repo.messages;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function listConversations(workspacePath, options = {}) {
+    const normalizedWorkspacePath = normalizeWorkspacePath(workspacePath);
+    const shouldRefreshProvider = options.refreshProvider === true;
+    const snapshot = shouldRefreshProvider
+        ? null
+        : await readStore(normalizedWorkspacePath);
+    const shouldScanProvider = shouldRefreshProvider ||
+        (snapshot
+            ? shouldScanProviderSessionsForTitleBackfill(snapshot, normalizedWorkspacePath)
+            : false);
+    const providerSessions = shouldScanProvider
+        ? await scanProviderSessionsCached(normalizedWorkspacePath, options.refreshProvider)
+        : [];
+    return updateStore(normalizedWorkspacePath, (data) => {
+        var _a, _b, _c, _d, _e, _f;
+        const now = nowIso();
+        const importProviderSessions = shouldRefreshProvider;
+        backfillMissingConversationTitles(data);
+        for (const session of providerSessions) {
+            const existingSession = data.sessions.find((record) => {
+                var _a;
+                return record.provider === session.provider &&
+                    record.workspacePath ===
+                        normalizeWorkspacePath((_a = session.workspacePath) !== null && _a !== void 0 ? _a : normalizedWorkspacePath) &&
+                    record.acpSessionId === session.sessionId;
+            });
+            let existingIndex = existingSession
+                ? data.conversations.findIndex((thread) => thread.threadId === existingSession.threadId)
+                : -1;
+            if (existingIndex < 0) {
+                existingIndex = data.conversations.findIndex((thread) => thread.provider === session.provider &&
+                    (thread.sourcePath === session.sourcePath ||
+                        thread.providerSessionId === session.sessionId));
+            }
+            const existing = existingIndex >= 0 ? data.conversations[existingIndex] : null;
+            if (!existing && !importProviderSessions)
+                continue;
+            const existingTitle = normalizeConversationTitle(existing === null || existing === void 0 ? void 0 : existing.title);
+            const providerTitle = normalizeConversationTitle(session.title);
+            const record = Object.assign(Object.assign({}, (existing !== null && existing !== void 0 ? existing : {
+                threadId: createProviderSessionThreadId(session.provider, session.sessionId),
+                title: providerTitle !== null && providerTitle !== void 0 ? providerTitle : null,
+                createdAt: (_a = session.createdAt) !== null && _a !== void 0 ? _a : now,
+                archivedAt: null,
+                deletedAt: null,
+                model: null,
+                modeId: null,
+                thoughtLevel: null,
+                permissionMode: DEFAULT_PERMISSION_MODE,
+                status: "active",
+            })), { updatedAt: (_c = (_b = session.lastActiveAt) !== null && _b !== void 0 ? _b : session.createdAt) !== null && _c !== void 0 ? _c : now, workspacePath: normalizeWorkspacePath((_d = session.workspacePath) !== null && _d !== void 0 ? _d : normalizedWorkspacePath), provider: session.provider, title: (_f = (_e = existingTitle !== null && existingTitle !== void 0 ? existingTitle : providerTitle) !== null && _e !== void 0 ? _e : (existing
+                    ? titleFromRuntimeMessages(data, existing.threadId)
+                    : null)) !== null && _f !== void 0 ? _f : null, providerSessionId: session.sessionId, sourcePath: session.sourcePath, sourceKind: session.sourceKind, lastSeenMtime: session.lastSeenMtime, lastActiveAt: session.lastActiveAt });
+            if (existingIndex >= 0) {
+                data.conversations[existingIndex] = record;
+            }
+            else {
+                data.conversations.unshift(record);
+            }
+        }
+        return paginateConversations(data.conversations, options);
+    });
+}
+export async function getConversation(threadId, workspacePath) {
+    const data = await readStore(workspacePath);
+    return findActiveConversation(data, threadId);
+}
+export async function resolveConversationByProviderSession({ provider: providerInput, sessionId, workspacePath, }) {
+    var _a;
+    const provider = normalizeAcpProvider(providerInput);
+    const normalizedSessionId = sessionId.trim();
+    if (!normalizedSessionId)
+        return null;
+    const normalizedWorkspacePath = normalizeWorkspacePath(workspacePath);
+    const data = await readStore(normalizedWorkspacePath);
+    const existing = findConversationByProviderSession(data, {
+        provider,
+        sessionId: normalizedSessionId,
+        workspacePath: normalizedWorkspacePath,
+    });
+    if (existing)
+        return existing;
+    const providerSession = await findProviderSession(provider, normalizedSessionId, normalizedWorkspacePath);
+    if (!providerSession)
+        return null;
+    await listConversations(normalizedWorkspacePath, { refreshProvider: true });
+    const refreshedData = await readStore(normalizedWorkspacePath);
+    return ((_a = findConversationByProviderSession(refreshedData, {
+        provider,
+        sessionId: normalizedSessionId,
+        workspacePath: normalizedWorkspacePath,
+    })) !== null && _a !== void 0 ? _a : null);
+}
+export async function upsertConversation(request) {
+    const workspacePath = normalizeWorkspacePath(request.workspacePath);
+    return updateStore(workspacePath, (data) => {
+        const existingIndex = data.conversations.findIndex((thread) => thread.threadId === request.threadId);
+        const existing = existingIndex >= 0 ? data.conversations[existingIndex] : undefined;
+        const record = existing
+            ? updateConversationRecord(existing, request)
+            : createConversationRecord(request);
+        if (existingIndex >= 0) {
+            data.conversations[existingIndex] = record;
+        }
+        else {
+            data.conversations.unshift(record);
+        }
+        return record;
+    });
+}
+export async function renameConversation(threadId, title, workspacePath) {
+    return updateStore(workspacePath, (data) => {
+        var _a, _b;
+        const record = data.conversations.find((thread) => thread.threadId === threadId && thread.status !== "deleted");
+        if (!record)
+            throw new Error("未找到对话");
+        record.title =
+            (_b = (_a = normalizeConversationTitle(title)) !== null && _a !== void 0 ? _a : normalizeConversationTitle(record.title)) !== null && _b !== void 0 ? _b : defaultTitle(threadId);
+        record.updatedAt = nowIso();
+        return record;
+    });
+}
+export async function archiveConversation(threadId, archived, workspacePath) {
+    return updateStore(workspacePath, (data) => {
+        const record = data.conversations.find((thread) => thread.threadId === threadId && thread.status !== "deleted");
+        if (!record)
+            throw new Error("未找到对话");
+        record.status = archived ? "archived" : "active";
+        record.archivedAt = archived ? nowIso() : null;
+        record.updatedAt = nowIso();
+        return record;
+    });
+}
+export async function deleteConversation(threadId, workspacePath) {
+    await updateStore(workspacePath, (data) => {
+        const record = data.conversations.find((thread) => thread.threadId === threadId);
+        if (record) {
+            record.status = "deleted";
+            record.deletedAt = nowIso();
+            record.updatedAt = nowIso();
+        }
+        for (const session of data.sessions) {
+            if (session.threadId === threadId && !session.closedAt) {
+                session.closedAt = nowIso();
+            }
+        }
+        deleteRuntimeMessages(data, threadId);
+    });
+}
+function readRuntimeMessagesIfAvailable(data, threadId, format) {
+    const runtimeRepo = getRuntimeMessageRepository(data, threadId, format);
+    return runtimeRepo.messages.length > 0 ? runtimeRepo : null;
+}
+async function deleteExpiredRuntimeMessagesForThread(workspacePath, threadId) {
+    await updateStore(workspacePath, (data) => {
+        var _a;
+        const conversation = findActiveConversation(data, threadId);
+        if (conversation &&
+            ((_a = data.messages) === null || _a === void 0 ? void 0 : _a[threadId]) &&
+            isRuntimeMessageConversationExpired(conversation)) {
+            deleteRuntimeMessages(data, threadId);
+        }
+    });
+}
+async function loadProviderMessageRepository({ threadId, format, workspacePath, conversation, }) {
+    var _a, _b;
+    let providerSession = null;
+    let providerSessionError = null;
+    const providerSessionId = (_a = conversation === null || conversation === void 0 ? void 0 : conversation.providerSessionId) !== null && _a !== void 0 ? _a : (threadId.includes(":") ? threadId.slice(threadId.indexOf(":") + 1) : null);
+    const provider = (_b = conversation === null || conversation === void 0 ? void 0 : conversation.provider) !== null && _b !== void 0 ? _b : threadId.split(":")[0];
+    if (!(conversation === null || conversation === void 0 ? void 0 : conversation.sourcePath) && providerSessionId) {
+        try {
+            providerSession = await findProviderSession(provider, providerSessionId, workspacePath);
+        }
+        catch (error) {
+            providerSessionError = errorMessage(error);
+        }
+    }
+    if (conversation === null || conversation === void 0 ? void 0 : conversation.sourcePath) {
+        try {
+            const transcript = await loadProviderTranscript({
+                provider: conversation.provider,
+                sessionId: conversation.providerSessionId,
+                sourcePath: conversation.sourcePath,
+            });
+            const repo = convertTranscriptToMessageRepository(transcript, format !== null && format !== void 0 ? format : "ai-sdk/v6");
+            const messages = filterMessagesByFormat(repo, format);
+            if (messages.length === 0) {
+                return {
+                    messages: [],
+                    diagnostic: {
+                        source: "provider-history",
+                        error: "Provider transcript had no messages",
+                    },
+                };
+            }
+            return {
+                headId: repo.headId,
+                messages,
+                diagnostic: { source: "provider-history" },
+            };
+        }
+        catch (error) {
+            return {
+                messages: [],
+                diagnostic: {
+                    source: "provider-history",
+                    error: errorMessage(error),
+                },
+            };
+        }
+    }
+    if (providerSession === null || providerSession === void 0 ? void 0 : providerSession.sourcePath) {
+        try {
+            const transcript = await loadProviderTranscript({
+                provider: providerSession.provider,
+                sessionId: providerSession.sessionId,
+                sourcePath: providerSession.sourcePath,
+            });
+            const repo = convertTranscriptToMessageRepository(transcript, format !== null && format !== void 0 ? format : "ai-sdk/v6");
+            const messages = filterMessagesByFormat(repo, format);
+            if (messages.length === 0) {
+                return {
+                    messages: [],
+                    diagnostic: {
+                        source: "provider-history",
+                        error: "Provider transcript had no messages",
+                    },
+                };
+            }
+            return {
+                headId: repo.headId,
+                messages,
+                diagnostic: { source: "provider-history" },
+            };
+        }
+        catch (error) {
+            return {
+                messages: [],
+                diagnostic: {
+                    source: "provider-history",
+                    error: errorMessage(error),
+                },
+            };
+        }
+    }
+    return {
+        messages: [],
+        diagnostic: {
+            source: "provider-history",
+            error: providerSessionError !== null && providerSessionError !== void 0 ? providerSessionError : "Provider transcript not found",
+        },
+    };
+}
+export async function loadConversationMessages(threadId, format, workspacePath) {
+    var _a;
+    const data = await readStore(workspacePath);
+    const conversation = data.conversations.find((thread) => thread.threadId === threadId && thread.status !== "deleted");
+    if (conversation) {
+        if (isRuntimeMessageConversationExpired(conversation)) {
+            if ((_a = data.messages) === null || _a === void 0 ? void 0 : _a[threadId]) {
+                await deleteExpiredRuntimeMessagesForThread(workspacePath, threadId);
+                deleteRuntimeMessages(data, threadId);
+            }
+        }
+        else {
+            const runtimeRepo = readRuntimeMessagesIfAvailable(data, threadId, format);
+            if (runtimeRepo)
+                return runtimeRepo;
+        }
+    }
+    const providerRepo = await loadProviderMessageRepository({
+        threadId,
+        format,
+        workspacePath,
+        conversation: conversation !== null && conversation !== void 0 ? conversation : null,
+    });
+    return providerRepo;
+}
+export async function saveConversationMessage(threadId, request, workspacePath) {
+    return updateStore(workspacePath, (data) => {
+        var _a, _b;
+        const record = data.conversations.find((thread) => thread.threadId === threadId && thread.status !== "deleted");
+        if (!record)
+            throw new Error("未找到对话");
+        record.updatedAt = nowIso();
+        const message = upsertRuntimeMessage(data, threadId, request);
+        if (!normalizeConversationTitle(record.title)) {
+            record.title =
+                (_b = (_a = titleFromStoredMessage(message)) !== null && _a !== void 0 ? _a : titleFromRuntimeMessages(data, threadId)) !== null && _b !== void 0 ? _b : null;
+        }
+        pruneExpiredRuntimeMessages(data);
+        return message;
+    });
+}
+export async function touchConversationFromRuntime(metadata) {
+    const providerSession = metadata.acpSessionId
+        ? await findProviderSession(metadata.provider, metadata.acpSessionId, metadata.workspacePath)
+        : null;
+    await updateStore(metadata.workspacePath, (data) => {
+        var _a, _b, _c, _d;
+        const timestamp = nowIso();
+        const conversationIndex = data.conversations.findIndex((thread) => thread.threadId === metadata.threadId);
+        const sessionTitle = (_b = (_a = normalizeRuntimeSessionTitle(metadata.sessionTitle)) !== null && _a !== void 0 ? _a : normalizeRuntimeSessionTitle(providerSession === null || providerSession === void 0 ? void 0 : providerSession.title)) !== null && _b !== void 0 ? _b : (conversationIndex >= 0
+            ? titleFromRuntimeMessages(data, metadata.threadId)
+            : undefined);
+        const conversationPatch = {
+            threadId: metadata.threadId,
+            workspacePath: metadata.workspacePath,
+            provider: metadata.provider,
+            model: metadata.model,
+            modeId: metadata.modeId,
+            thoughtLevel: metadata.thoughtLevel,
+            permissionMode: metadata.permissionMode,
+            providerSessionId: (_c = providerSession === null || providerSession === void 0 ? void 0 : providerSession.sessionId) !== null && _c !== void 0 ? _c : metadata.acpSessionId,
+            sourcePath: providerSession === null || providerSession === void 0 ? void 0 : providerSession.sourcePath,
+            sourceKind: providerSession === null || providerSession === void 0 ? void 0 : providerSession.sourceKind,
+            lastSeenMtime: providerSession === null || providerSession === void 0 ? void 0 : providerSession.lastSeenMtime,
+            lastActiveAt: (_d = providerSession === null || providerSession === void 0 ? void 0 : providerSession.lastActiveAt) !== null && _d !== void 0 ? _d : timestamp,
+        };
+        if (sessionTitle)
+            conversationPatch.title = sessionTitle;
+        const existingConversation = conversationIndex >= 0
+            ? data.conversations[conversationIndex]
+            : undefined;
+        const conversation = existingConversation
+            ? updateConversationRecord(existingConversation, conversationPatch)
+            : createConversationRecord(conversationPatch);
+        conversation.updatedAt = timestamp;
+        if (conversationIndex >= 0) {
+            data.conversations[conversationIndex] = conversation;
+        }
+        else {
+            data.conversations.unshift(conversation);
+        }
+        const existingSession = data.sessions.find((session) => session.threadId === metadata.threadId &&
+            session.provider === metadata.provider &&
+            session.workspacePath === metadata.workspacePath &&
+            !session.closedAt);
+        if (existingSession) {
+            existingSession.acpSessionId = metadata.acpSessionId;
+            existingSession.model = metadata.model;
+            existingSession.modeId = metadata.modeId;
+            existingSession.thoughtLevel = metadata.thoughtLevel;
+            existingSession.lastActivityAt = timestamp;
+            return;
+        }
+        data.sessions.push({
+            threadId: metadata.threadId,
+            acpSessionId: metadata.acpSessionId,
+            provider: metadata.provider,
+            workspacePath: metadata.workspacePath,
+            model: metadata.model,
+            modeId: metadata.modeId,
+            thoughtLevel: metadata.thoughtLevel,
+            createdAt: timestamp,
+            lastActivityAt: timestamp,
+            closedAt: null,
+        });
+    });
+}
+export async function closeConversationSession(metadata) {
+    if (!metadata)
+        return;
+    await updateStore(metadata.workspacePath, (data) => {
+        const timestamp = nowIso();
+        for (const session of data.sessions) {
+            if (session.threadId === metadata.threadId &&
+                session.provider === metadata.provider &&
+                session.workspacePath === metadata.workspacePath &&
+                !session.closedAt) {
+                session.closedAt = timestamp;
+                session.lastActivityAt = timestamp;
+            }
+        }
+    });
+}