@jingyi0605/codingns 0.7.4 → 0.8.0

package/node_modules/@codingns/session-sync-core/dist/providers/gemini.js

@@ -1,1480 +0,0 @@
-import { execFile as nodeExecFile } from "node:child_process";
-import { accessSync, constants, existsSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
-import { basename, delimiter, dirname, extname, join } from "node:path";
-import { promisify } from "node:util";
-import { buildApplyPatchFromStructuredFileTool } from "../patch-builder.js";
-import { ensureText, extractTextBlocks, messageIdFromRawRef, nextTimestamp, normalizeWorkspacePath, sliceHistory, stringifyStructuredValue } from "./utils.js";
-const execFile = promisify(nodeExecFile);
-const GEMINI_RAW_STORE_PREFIX = "gemini://session/";
-const DEFAULT_GEMINI_TITLE_LENGTH = 48;
-export class GeminiAdapter {
-    options;
-    providerId = "gemini";
-    parsedChatCache = new Map();
-    localSessionCache = new Map();
-    constructor(options) {
-        this.options = options;
-    }
-    async detectSessions(workspacePath, options) {
-        const discovery = await this.detectSessionsDetailed(workspacePath, options);
-        return discovery.sessions;
-    }
-    async detectSessionsDetailed(workspacePath, options) {
-        const startedAt = Date.now();
-        const targetPath = normalizeWorkspacePath(workspacePath);
-        const knownSessions = (options?.knownSessions ?? []).filter((session) => session.provider === this.providerId);
-        const knownByProviderSessionId = new Map(knownSessions.map((session) => [session.providerSessionId, session]));
-        const localScan = this.readLocalSessionsDetailed();
-        const localSessions = localScan.sessions;
-        const cliResult = await this.readCliSessions(workspacePath);
-        const mergedByProviderSessionId = new Map();
-        for (const localSession of localSessions) {
-            const known = knownByProviderSessionId.get(localSession.providerSessionId);
-            const resolvedWorkspacePath = localSession.workspacePath || ensureNonEmptyText(known?.workspacePath);
-            if (!this.matchesWorkspace(resolvedWorkspacePath, targetPath)) {
-                continue;
-            }
-            mergedByProviderSessionId.set(localSession.providerSessionId, {
-                provider: this.providerId,
-                providerSessionId: localSession.providerSessionId,
-                title: localSession.title,
-                workspacePath: resolvedWorkspacePath || workspacePath,
-                rawStoreRef: buildGeminiRawStoreRef(localSession.providerSessionId),
-                lastMessageAt: localSession.lastMessageAt ?? known?.lastMessageAt ?? null,
-                messageCount: localSession.messageCount,
-                sourceMtimeMs: localSession.sourceMtimeMs,
-                sourceSizeBytes: localSession.sourceSizeBytes
-            });
-        }
-        for (const cliSession of cliResult.sessions) {
-            const known = knownByProviderSessionId.get(cliSession.providerSessionId);
-            const local = mergedByProviderSessionId.get(cliSession.providerSessionId);
-            const resolvedWorkspacePath = cliSession.workspacePath ||
-                local?.workspacePath ||
-                ensureNonEmptyText(known?.workspacePath);
-            if (!this.matchesWorkspace(resolvedWorkspacePath, targetPath)) {
-                continue;
-            }
-            mergedByProviderSessionId.set(cliSession.providerSessionId, {
-                provider: this.providerId,
-                providerSessionId: cliSession.providerSessionId,
-                title: local?.title ||
-                    cliSession.title ||
-                    known?.title ||
-                    cliSession.providerSessionId,
-                workspacePath: resolvedWorkspacePath || workspacePath,
-                rawStoreRef: buildGeminiRawStoreRef(cliSession.providerSessionId),
-                lastMessageAt: local?.lastMessageAt ??
-                    cliSession.lastMessageAt ??
-                    known?.lastMessageAt ??
-                    null,
-                messageCount: local?.messageCount ??
-                    cliSession.messageCount ??
-                    known?.messageCount ??
-                    0,
-                sourceMtimeMs: local?.sourceMtimeMs ?? known?.sourceMtimeMs,
-                sourceSizeBytes: local?.sourceSizeBytes ?? known?.sourceSizeBytes
-            });
-        }
-        // 当 CLI 临时失败时，用 knownSessions 补回最近一次已发现的会话，避免列表突然丢失。
-        if (!cliResult.isComplete) {
-            for (const known of knownSessions) {
-                if (mergedByProviderSessionId.has(known.providerSessionId)) {
-                    continue;
-                }
-                if (!this.matchesWorkspace(known.workspacePath, targetPath)) {
-                    continue;
-                }
-                mergedByProviderSessionId.set(known.providerSessionId, known);
-            }
-        }
-        const diagnostic = {
-            provider: this.providerId,
-            status: cliResult.isComplete ? "success" : "partial",
-            durationMs: Date.now() - startedAt,
-            sessionCount: mergedByProviderSessionId.size,
-            isComplete: cliResult.isComplete,
-            errorMessage: null,
-            scannedFiles: localScan.scannedFiles,
-            skippedByMtimeSize: localScan.skippedByMtimeSize,
-            parsedFiles: localScan.parsedFiles,
-            bytesRead: localScan.bytesRead
-        };
-        return {
-            sessions: [...mergedByProviderSessionId.values()].sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.lastMessageAt ?? "")),
-            isComplete: cliResult.isComplete,
-            providerDiagnostics: [diagnostic]
-        };
-    }
-    async readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
-        const resolvedProviderSessionId = this.resolveProviderSessionId(providerSessionId, rawStoreRef);
-        const parsedChat = this.readParsedChatBySessionId(resolvedProviderSessionId, resolveGeminiScopedHomeDir(rawStoreRef));
-        return sliceHistory(parsedChat.messages, cursor, limit, direction);
-    }
-    subscribeSession(providerSessionId, rawStoreRef, cursor, limit, onEvent) {
-        const sessionRef = this.resolveSessionRef(providerSessionId, rawStoreRef);
-        let currentCursor = cursor;
-        let lastSeenSignature = "";
-        let closed = false;
-        const timer = setInterval(() => {
-            if (closed || !sessionRef.providerSessionId) {
-                return;
-            }
-            let page;
-            try {
-                page = this.readSessionHistorySync(sessionRef.providerSessionId, rawStoreRef, currentCursor, limit);
-            }
-            catch {
-                return;
-            }
-            if (page.messages.length === 0) {
-                return;
-            }
-            const signature = `${page.messages.at(-1)?.messageId ?? ""}:${page.cursor ?? ""}`;
-            if (signature === lastSeenSignature) {
-                return;
-            }
-            lastSeenSignature = signature;
-            currentCursor = page.cursor;
-            void onEvent({
-                messages: page.messages,
-                cursor: page.cursor
-            });
-        }, 700);
-        return {
-            close() {
-                closed = true;
-                clearInterval(timer);
-            }
-        };
-    }
-    async resumeSession(providerSessionId, rawStoreRef) {
-        const resolvedProviderSessionId = this.resolveProviderSessionId(providerSessionId, rawStoreRef);
-        this.readParsedChatBySessionId(resolvedProviderSessionId, resolveGeminiScopedHomeDir(rawStoreRef));
-        return {
-            provider: this.providerId,
-            providerSessionId: resolvedProviderSessionId,
-            resumedAt: nextTimestamp(),
-            rawStoreRef: buildGeminiRawStoreRef(resolvedProviderSessionId, resolveGeminiScopedHomeDir(rawStoreRef))
-        };
-    }
-    async startSession(_workspacePath, _options) {
-        throw new Error("GEMINI_READ_ONLY_PROVIDER");
-    }
-    async sendMessage(_providerSessionId, _rawStoreRef, _content, _clientRequestId, _permissionMode) {
-        throw new Error("GEMINI_READ_ONLY_PROVIDER");
-    }
-    async readSessionTitle(providerSessionId, rawStoreRef) {
-        const resolvedProviderSessionId = this.resolveProviderSessionId(providerSessionId, rawStoreRef);
-        const parsedChat = this.readParsedChatBySessionId(resolvedProviderSessionId, resolveGeminiScopedHomeDir(rawStoreRef));
-        return parsedChat.title;
-    }
-    async renameSessionTitle(_providerSessionId, _rawStoreRef, _title) {
-        throw new Error("GEMINI_READ_ONLY_PROVIDER");
-    }
-    async updateSessionArchiveState(_providerSessionId, _rawStoreRef, _isArchived) {
-        throw new Error("GEMINI_ARCHIVE_NOT_SUPPORTED");
-    }
-    async deleteSession(providerSessionId, rawStoreRef) {
-        const resolvedProviderSessionId = this.resolveProviderSessionId(providerSessionId, rawStoreRef);
-        const matchedFilePaths = this.findLocalChatFilePathsBySessionId(resolvedProviderSessionId, resolveGeminiScopedHomeDir(rawStoreRef));
-        let deletedAny = false;
-        for (const filePath of matchedFilePaths) {
-            if (!existsSync(filePath)) {
-                continue;
-            }
-            rmSync(filePath, { force: true });
-            this.parsedChatCache.delete(filePath);
-            this.localSessionCache.delete(filePath);
-            deletedAny = true;
-        }
-        if (!deletedAny) {
-            throw new Error("PROVIDER_SESSION_NOT_FOUND");
-        }
-    }
-    getProviderCapabilities() {
-        return {
-            provider: this.providerId,
-            canStartSession: true,
-            canResumeSession: true,
-            canSendMessage: true,
-            inRunInputMode: "none",
-            supportsSubagents: false,
-            supportsInterrupt: true,
-            supportsStructuredToolCalls: true,
-            supportsTokenUsage: false,
-            supportsAttachments: false,
-            supportsPermissionPrompt: false,
-            supportsCheckpoint: false,
-            supportsSessionDelete: true,
-            limitations: [
-                "当前 Gemini 仅接入会话发现与历史只读能力，运行时链路尚未启用",
-                "本地 chats schema 属于非稳定公开协议，升级 CLI 后需要通过 fixture 回归"
-            ]
-        };
-    }
-    async getSessionCapabilities(_providerSessionId) {
-        return this.getProviderCapabilities();
-    }
-    readSessionHistorySync(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
-        const resolvedProviderSessionId = this.resolveProviderSessionId(providerSessionId, rawStoreRef);
-        const parsedChat = this.readParsedChatBySessionId(resolvedProviderSessionId, resolveGeminiScopedHomeDir(rawStoreRef));
-        return sliceHistory(parsedChat.messages, cursor, limit, direction);
-    }
-    resolveProviderSessionId(providerSessionId, rawStoreRef) {
-        const sessionRef = this.resolveSessionRef(providerSessionId, rawStoreRef);
-        if (!sessionRef.providerSessionId) {
-            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
-        }
-        return sessionRef.providerSessionId;
-    }
-    resolveSessionRef(providerSessionId, rawStoreRef) {
-        const trimmedProviderSessionId = providerSessionId.trim();
-        if (trimmedProviderSessionId) {
-            return {
-                providerSessionId: trimmedProviderSessionId,
-                homeDir: resolveGeminiScopedHomeDir(rawStoreRef),
-                fromRawStoreRef: false
-            };
-        }
-        return {
-            providerSessionId: parseGeminiRawStoreRef(rawStoreRef),
-            homeDir: resolveGeminiScopedHomeDir(rawStoreRef),
-            fromRawStoreRef: true
-        };
-    }
-    async readCliSessions(workspacePath) {
-        if (this.options.listSessions) {
-            try {
-                return {
-                    sessions: await this.options.listSessions(),
-                    isComplete: true
-                };
-            }
-            catch {
-                return {
-                    sessions: [],
-                    isComplete: false
-                };
-            }
-        }
-        const commandPath = this.options.commandPath?.trim() || "gemini";
-        // CLI 没装是正常场景，直接回退到本地 chats 扫描，不要把整个工作区打成 partial。
-        if (!isCommandAvailable(commandPath)) {
-            return {
-                sessions: [],
-                isComplete: true
-            };
-        }
-        try {
-            const sessions = await this.readCliSessionsFromCommand(workspacePath);
-            return {
-                sessions,
-                isComplete: true
-            };
-        }
-        catch {
-            return {
-                sessions: [],
-                isComplete: false
-            };
-        }
-    }
-    async readCliSessionsFromCommand(workspacePath) {
-        const commandPath = this.options.commandPath?.trim() || "gemini";
-        const env = {
-            ...process.env,
-            GEMINI_HOME: this.options.homeDir
-        };
-        const attempts = [
-            ["--list-sessions", "--output-format", "json"],
-            ["--list-sessions"]
-        ];
-        let lastError = null;
-        for (const args of attempts) {
-            try {
-                const result = await execFile(commandPath, args, {
-                    env,
-                    cwd: workspacePath,
-                    timeout: 8_000,
-                    windowsHide: true,
-                    shell: shouldUseShellForCommand(commandPath)
-                });
-                return parseGeminiCliSessionOutput(result.stdout, workspacePath);
-            }
-            catch (error) {
-                lastError = error;
-            }
-        }
-        throw lastError ?? new Error("GEMINI_LIST_SESSIONS_FAILED");
-    }
-    readLocalSessionsDetailed() {
-        const sessions = [];
-        const latestByProviderSessionId = new Map();
-        let scannedFiles = 0;
-        let skippedByMtimeSize = 0;
-        let parsedFiles = 0;
-        let bytesRead = 0;
-        for (const filePath of listGeminiChatFiles(this.options.homeDir)) {
-            scannedFiles += 1;
-            let localSession;
-            try {
-                const stats = statSync(filePath);
-                const cached = this.localSessionCache.get(filePath);
-                if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
-                    skippedByMtimeSize += 1;
-                    localSession = cached.session;
-                }
-                else {
-                    parsedFiles += 1;
-                    bytesRead += stats.size;
-                    localSession = this.parseLocalSessionSummary(filePath, stats);
-                    this.localSessionCache.set(filePath, {
-                        mtimeMs: stats.mtimeMs,
-                        size: stats.size,
-                        session: localSession
-                    });
-                }
-            }
-            catch {
-                continue;
-            }
-            const existing = latestByProviderSessionId.get(localSession.providerSessionId);
-            if (existing &&
-                (existing.sourceMtimeMs > localSession.sourceMtimeMs ||
-                    (existing.sourceMtimeMs === localSession.sourceMtimeMs &&
-                        existing.sourceSizeBytes >= localSession.sourceSizeBytes))) {
-                continue;
-            }
-            latestByProviderSessionId.set(localSession.providerSessionId, localSession);
-        }
-        sessions.push(...latestByProviderSessionId.values());
-        return {
-            sessions,
-            scannedFiles,
-            skippedByMtimeSize,
-            parsedFiles,
-            bytesRead
-        };
-    }
-    readParsedChatBySessionId(providerSessionId, scopedHomeDir = null) {
-        const sessionId = providerSessionId.trim();
-        if (!sessionId) {
-            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
-        }
-        const chatFiles = listGeminiChatFiles(scopedHomeDir ?? this.options.homeDir);
-        let matchedByName = null;
-        let matchedBySessionId = null;
-        for (const filePath of chatFiles) {
-            if (basename(filePath, ".json") === sessionId) {
-                matchedByName = filePath;
-            }
-            let summary;
-            try {
-                const stats = statSync(filePath);
-                const cached = this.localSessionCache.get(filePath);
-                if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
-                    summary = cached.session;
-                }
-                else {
-                    summary = this.parseLocalSessionSummary(filePath, stats);
-                    this.localSessionCache.set(filePath, {
-                        mtimeMs: stats.mtimeMs,
-                        size: stats.size,
-                        session: summary
-                    });
-                }
-            }
-            catch (error) {
-                if (basename(filePath, ".json") === sessionId) {
-                    throw wrapGeminiSchemaError(filePath, error);
-                }
-                continue;
-            }
-            if (summary.providerSessionId === sessionId) {
-                matchedBySessionId = filePath;
-                break;
-            }
-        }
-        if (matchedBySessionId) {
-            return this.readCachedLocalChatFile(matchedBySessionId);
-        }
-        if (matchedByName) {
-            try {
-                return this.readCachedLocalChatFile(matchedByName);
-            }
-            catch (error) {
-                throw wrapGeminiSchemaError(matchedByName, error);
-            }
-        }
-        throw new Error("GEMINI_CHAT_NOT_FOUND");
-    }
-    findLocalChatFilePathsBySessionId(providerSessionId, scopedHomeDir = null) {
-        const sessionId = providerSessionId.trim();
-        if (!sessionId) {
-            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
-        }
-        const matchedFilePaths = new Set();
-        for (const filePath of listGeminiChatFiles(scopedHomeDir ?? this.options.homeDir)) {
-            if (basename(filePath, ".json") === sessionId) {
-                matchedFilePaths.add(filePath);
-                continue;
-            }
-            try {
-                const stats = statSync(filePath);
-                const cached = this.localSessionCache.get(filePath);
-                const summary = cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size
-                    ? cached.session
-                    : this.parseLocalSessionSummary(filePath, stats);
-                if (!cached || cached.mtimeMs !== stats.mtimeMs || cached.size !== stats.size) {
-                    this.localSessionCache.set(filePath, {
-                        mtimeMs: stats.mtimeMs,
-                        size: stats.size,
-                        session: summary
-                    });
-                }
-                if (summary.providerSessionId === sessionId) {
-                    matchedFilePaths.add(filePath);
-                }
-            }
-            catch {
-                continue;
-            }
-        }
-        return [...matchedFilePaths];
-    }
-    readCachedLocalChatFile(filePath) {
-        const stats = statSync(filePath);
-        const cached = this.parsedChatCache.get(filePath);
-        if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
-            return cached.parsedChat;
-        }
-        const parsedChat = this.parseLocalChatFile(filePath, stats);
-        this.parsedChatCache.set(filePath, {
-            mtimeMs: stats.mtimeMs,
-            size: stats.size,
-            parsedChat
-        });
-        return parsedChat;
-    }
-    parseLocalChatFile(filePath, stats) {
-        const parsedRecord = readGeminiParsedChatSource(filePath).record;
-        const providerSessionId = this.resolveLocalProviderSessionId(parsedRecord, filePath);
-        const messageNodes = readMessageNodes(parsedRecord);
-        const messages = normalizeMessageNodes({
-            sessionId: providerSessionId,
-            filePath,
-            messageNodes
-        });
-        const title = resolveStringField(parsedRecord, ["title", "name", "chatTitle"]) ||
-            messages.find((message) => message.role === "user")?.content.slice(0, DEFAULT_GEMINI_TITLE_LENGTH) ||
-            providerSessionId;
-        const workspacePath = resolveWorkspacePath(parsedRecord, messageNodes, filePath);
-        const lastMessageAt = messages.at(-1)?.timestamp ||
-            resolveStringField(parsedRecord, [
-                "updatedAt",
-                "updated_at",
-                "lastUpdated",
-                "last_updated",
-                "lastMessageAt",
-                "last_message_at",
-                "startTime",
-                "start_time",
-                "createdAt",
-                "created_at"
-            ]) ||
-            null;
-        return {
-            providerSessionId,
-            workspacePath,
-            title,
-            lastMessageAt,
-            messages,
-            sourceMtimeMs: stats.mtimeMs,
-            sourceSizeBytes: stats.size
-        };
-    }
-    parseLocalSessionSummary(filePath, stats) {
-        const parsedRecord = readGeminiParsedChatSource(filePath).record;
-        const providerSessionId = this.resolveLocalProviderSessionId(parsedRecord, filePath);
-        const messageNodes = readMessageNodes(parsedRecord);
-        const messageSummary = summarizeGeminiMessageNodes(messageNodes);
-        const workspacePath = resolveWorkspacePath(parsedRecord, messageNodes, filePath);
-        return {
-            providerSessionId,
-            workspacePath,
-            title: resolveStringField(parsedRecord, ["title", "name", "chatTitle"]) ||
-                messageSummary.firstUserText?.slice(0, DEFAULT_GEMINI_TITLE_LENGTH) ||
-                providerSessionId,
-            lastMessageAt: resolveStringField(parsedRecord, [
-                "updatedAt",
-                "updated_at",
-                "lastUpdated",
-                "last_updated",
-                "lastMessageAt",
-                "last_message_at",
-                "startTime",
-                "start_time",
-                "createdAt",
-                "created_at"
-            ]) ||
-                messageSummary.lastMessageAt,
-            messageCount: resolveGeminiSummaryMessageCount(parsedRecord, messageSummary.messageCount),
-            filePath,
-            sourceMtimeMs: stats.mtimeMs,
-            sourceSizeBytes: stats.size
-        };
-    }
-    resolveLocalProviderSessionId(record, filePath) {
-        const sessionId = resolveStringField(record, [
-            "sessionId",
-            "session_id",
-            "id",
-            "chatId",
-            "conversationId",
-            "conversation_id"
-        ]) || stripGeminiChatFileExtension(filePath);
-        if (!sessionId.trim()) {
-            throw new Error("GEMINI_CHAT_SCHEMA_INVALID");
-        }
-        return sessionId.trim();
-    }
-    matchesWorkspace(workspacePath, targetPath) {
-        const normalizedWorkspacePath = normalizeWorkspacePath(workspacePath ?? "");
-        if (!normalizedWorkspacePath) {
-            return false;
-        }
-        return normalizedWorkspacePath === targetPath;
-    }
-}
-function parseGeminiRawStoreRef(rawStoreRef) {
-    const trimmed = rawStoreRef.trim();
-    if (!trimmed.startsWith(GEMINI_RAW_STORE_PREFIX)) {
-        return null;
-    }
-    const rawSessionId = trimmed.slice(GEMINI_RAW_STORE_PREFIX.length).split(/[?#]/, 1)[0];
-    return rawSessionId ? decodeURIComponent(rawSessionId) : null;
-}
-function resolveGeminiScopedHomeDir(rawStoreRef) {
-    const trimmed = rawStoreRef.trim();
-    if (!trimmed.startsWith(GEMINI_RAW_STORE_PREFIX)) {
-        return null;
-    }
-    const query = trimmed.split("?", 2)[1] ?? "";
-    const params = new URLSearchParams(query);
-    const homeDir = params.get("homeDir")?.trim();
-    return homeDir ? homeDir : null;
-}
-function buildGeminiRawStoreRef(providerSessionId, scopedHomeDir = null) {
-    const encodedSessionId = encodeURIComponent(providerSessionId);
-    if (!scopedHomeDir?.trim()) {
-        return `${GEMINI_RAW_STORE_PREFIX}${encodedSessionId}`;
-    }
-    return `${GEMINI_RAW_STORE_PREFIX}${encodedSessionId}?homeDir=${encodeURIComponent(scopedHomeDir)}`;
-}
-function listGeminiChatFiles(homeDir) {
-    const tmpRoot = join(homeDir, "tmp");
-    if (!existsSync(tmpRoot)) {
-        return [];
-    }
-    const queue = [tmpRoot];
-    const chatFiles = [];
-    while (queue.length > 0) {
-        const current = queue.shift();
-        if (!current) {
-            continue;
-        }
-        const entries = readdirSync(current, { withFileTypes: true });
-        for (const entry of entries) {
-            const entryPath = join(current, entry.name);
-            if (entry.isDirectory()) {
-                queue.push(entryPath);
-                continue;
-            }
-            if (!entry.isFile()
-                || (!entry.name.endsWith(".json") && !entry.name.endsWith(".jsonl"))) {
-                continue;
-            }
-            if (!isGeminiChatFile(entryPath)) {
-                continue;
-            }
-            chatFiles.push(entryPath);
-        }
-    }
-    return chatFiles;
-}
-function readGeminiParsedChatSource(filePath) {
-    const raw = readFileSync(filePath, "utf8").trim();
-    if (!raw) {
-        throw new Error("GEMINI_CHAT_SCHEMA_INVALID");
-    }
-    try {
-        if (filePath.endsWith(".jsonl")) {
-            return {
-                record: parseGeminiJsonlChat(raw)
-            };
-        }
-        return {
-            record: toRecord(JSON.parse(raw))
-        };
-    }
-    catch (error) {
-        throw wrapGeminiSchemaError(filePath, error);
-    }
-}
-function parseGeminiJsonlChat(raw) {
-    const lines = raw.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0);
-    if (lines.length === 0) {
-        throw new Error("GEMINI_CHAT_SCHEMA_INVALID");
-    }
-    const root = {};
-    const messages = [];
-    for (const line of lines) {
-        const parsedLine = toRecord(JSON.parse(line));
-        const patch = maybeRecord(parsedLine.$set);
-        if (patch) {
-            Object.assign(root, patch);
-            continue;
-        }
-        if (isGeminiJsonlMessageLine(parsedLine)) {
-            messages.push(parsedLine);
-            continue;
-        }
-        Object.assign(root, parsedLine);
-    }
-    root.messages = messages;
-    return root;
-}
-function isGeminiJsonlMessageLine(record) {
-    const type = ensureText(record.type).trim().toLowerCase();
-    if (type === "user" || type === "gemini" || type === "tool" || type === "system") {
-        return true;
-    }
-    return Boolean(record.content !== undefined
-        || record.parts !== undefined
-        || record.toolCalls !== undefined
-        || record.tool_calls !== undefined
-        || record.thoughts !== undefined);
-}
-function stripGeminiChatFileExtension(filePath) {
-    const name = basename(filePath);
-    if (name.endsWith(".jsonl")) {
-        return name.slice(0, -".jsonl".length);
-    }
-    if (name.endsWith(".json")) {
-        return name.slice(0, -".json".length);
-    }
-    return name;
-}
-function isGeminiChatFile(filePath) {
-    return filePath.replaceAll("\\", "/").includes("/chats/");
-}
-function parseGeminiCliSessionOutput(stdout, workspacePathFallback = null) {
-    const trimmed = stdout.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const parsedAsWhole = parseJsonSafe(trimmed);
-    const normalizedWhole = normalizeCliSessionsPayload(parsedAsWhole, workspacePathFallback);
-    if (normalizedWhole.length > 0) {
-        return normalizedWhole;
-    }
-    const normalizedText = parseGeminiPlainTextSessions(trimmed, workspacePathFallback);
-    if (normalizedText.length > 0) {
-        return normalizedText;
-    }
-    const sessions = [];
-    for (const line of trimmed.split(/\r?\n/)) {
-        const parsedLine = parseJsonSafe(line.trim());
-        if (!parsedLine) {
-            continue;
-        }
-        sessions.push(...normalizeCliSessionsPayload(parsedLine, workspacePathFallback));
-    }
-    return dedupeCliSessions(sessions);
-}
-function normalizeCliSessionsPayload(payload, workspacePathFallback) {
-    if (!payload) {
-        return [];
-    }
-    if (Array.isArray(payload)) {
-        return dedupeCliSessions(payload
-            .map((item) => normalizeCliSessionRecord(item, workspacePathFallback))
-            .filter((item) => item !== null));
-    }
-    const record = toRecord(payload);
-    const wrappedArray = arrayFromUnknown(record.sessions) ||
-        arrayFromUnknown(record.items) ||
-        arrayFromUnknown(record.data);
-    if (wrappedArray) {
-        return dedupeCliSessions(wrappedArray
-            .map((item) => normalizeCliSessionRecord(item, workspacePathFallback))
-            .filter((item) => item !== null));
-    }
-    const single = normalizeCliSessionRecord(record, workspacePathFallback);
-    return single ? [single] : [];
-}
-function normalizeCliSessionRecord(payload, workspacePathFallback) {
-    const record = toRecord(payload);
-    const providerSessionId = resolveStringField(record, [
-        "sessionId",
-        "session_id",
-        "id",
-        "conversationId",
-        "conversation_id"
-    ]);
-    if (!providerSessionId) {
-        return null;
-    }
-    const messageCountValue = resolveNumberField(record, ["messageCount", "message_count"]);
-    return {
-        providerSessionId,
-        workspacePath: resolveStringField(record, [
-            "workspacePath",
-            "workspace_path",
-            "cwd",
-            "directory",
-            "projectPath",
-            "project_path"
-        ]) || workspacePathFallback,
-        title: resolveStringField(record, ["title", "name", "summary"]) || null,
-        lastMessageAt: resolveStringField(record, [
-            "updatedAt",
-            "updated_at",
-            "lastUpdated",
-            "last_updated",
-            "lastMessageAt",
-            "last_message_at",
-            "startTime",
-            "start_time",
-            "createdAt",
-            "created_at"
-        ]) || null,
-        messageCount: messageCountValue === null ? null : messageCountValue
-    };
-}
-function dedupeCliSessions(sessions) {
-    const deduped = new Map();
-    for (const session of sessions) {
-        const existing = deduped.get(session.providerSessionId);
-        if (!existing ||
-            (existing.lastMessageAt ?? "").localeCompare(session.lastMessageAt ?? "") < 0) {
-            deduped.set(session.providerSessionId, session);
-        }
-    }
-    return [...deduped.values()];
-}
-function resolveWorkspacePath(record, messageNodes, filePath) {
-    const directWorkspace = resolveStringField(record, [
-        "workspacePath",
-        "workspace_path",
-        "cwd",
-        "projectPath",
-        "project_path"
-    ]);
-    if (directWorkspace) {
-        return directWorkspace;
-    }
-    for (const node of messageNodes) {
-        const nodeRecord = toRecord(node);
-        const workspace = resolveStringField(nodeRecord, [
-            "workspacePath",
-            "workspace_path",
-            "cwd",
-            "projectPath",
-            "project_path"
-        ]);
-        if (workspace) {
-            return workspace;
-        }
-    }
-    return resolveWorkspacePathFromChatFile(filePath);
-}
-function readMessageNodes(record) {
-    const candidates = [
-        record.messages,
-        record.history,
-        record.events,
-        record.contents,
-        record.turns,
-        toRecord(record.chat).messages,
-        toRecord(record.conversation).messages,
-        toRecord(record.transcript).messages
-    ];
-    for (const candidate of candidates) {
-        const array = arrayFromUnknown(candidate);
-        if (array && array.length > 0) {
-            return array;
-        }
-    }
-    return [];
-}
-function normalizeMessageNodes(input) {
-    const messages = [];
-    let sequence = 0;
-    const identityState = {
-        userTextIndex: 0,
-        assistantTextIndex: 0
-    };
-    for (let index = 0; index < input.messageNodes.length; index += 1) {
-        const node = input.messageNodes[index];
-        const nodeRecord = toRecord(node);
-        const role = resolveGeminiRole(nodeRecord);
-        const timestamp = resolveMessageTimestamp(nodeRecord);
-        const descriptors = readMessageDescriptors(nodeRecord, role);
-        if (descriptors.length === 0) {
-            continue;
-        }
-        for (let descriptorIndex = 0; descriptorIndex < descriptors.length; descriptorIndex += 1) {
-            const descriptor = descriptors[descriptorIndex];
-            sequence += 1;
-            const rawRef = buildGeminiMessageRawRef(input.sessionId, input.filePath, index, descriptorIndex);
-            const messageId = buildGeminiMessageId({
-                sessionId: input.sessionId,
-                descriptor,
-                rawRef,
-                identityState
-            });
-            messages.push({
-                messageId,
-                provider: "gemini",
-                providerSessionId: input.sessionId,
-                role: descriptor.role,
-                kind: descriptor.kind,
-                content: descriptor.content,
-                toolCall: descriptor.toolCall,
-                timestamp: descriptor.timestamp ?? timestamp,
-                sequence,
-                rawRef
-            });
-        }
-    }
-    return messages;
-}
-function summarizeGeminiMessageNodes(messageNodes) {
-    let messageCount = 0;
-    let lastMessageAt = null;
-    let firstUserText = null;
-    for (const node of messageNodes) {
-        const nodeRecord = toRecord(node);
-        const role = resolveGeminiRole(nodeRecord);
-        const nodeTimestamp = resolveMessageTimestamp(nodeRecord);
-        const descriptors = readMessageDescriptors(nodeRecord, role);
-        if (descriptors.length === 0) {
-            continue;
-        }
-        messageCount += descriptors.length;
-        lastMessageAt = descriptors.at(-1)?.timestamp ?? nodeTimestamp;
-        if (firstUserText) {
-            continue;
-        }
-        const firstUserDescriptor = descriptors.find((descriptor) => descriptor.role === "user" &&
-            descriptor.kind === "text" &&
-            descriptor.content.trim().length > 0);
-        if (firstUserDescriptor) {
-            firstUserText = firstUserDescriptor.content.trim();
-        }
-    }
-    return {
-        messageCount,
-        lastMessageAt,
-        firstUserText
-    };
-}
-function resolveGeminiSummaryMessageCount(record, fallbackMessageCount) {
-    const explicitMessageCount = firstGeminiNumber(record.messageCount, record.message_count, record.totalMessages, record.total_messages, record.messageTotal);
-    if (explicitMessageCount !== null && explicitMessageCount >= 0) {
-        return Math.trunc(explicitMessageCount);
-    }
-    return fallbackMessageCount;
-}
-function firstGeminiNumber(...values) {
-    for (const value of values) {
-        if (typeof value === "number" && Number.isFinite(value)) {
-            return value;
-        }
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (!trimmed) {
-                continue;
-            }
-            const parsed = Number(trimmed);
-            if (Number.isFinite(parsed)) {
-                return parsed;
-            }
-        }
-    }
-    return null;
-}
-function readMessageDescriptors(nodeRecord, fallbackRole) {
-    const descriptors = [];
-    descriptors.push(...readGeminiThoughtDescriptors(nodeRecord));
-    descriptors.push(...readGeminiToolCallDescriptors(nodeRecord));
-    const parts = arrayFromUnknown(nodeRecord.parts) ||
-        arrayFromUnknown(nodeRecord.content) ||
-        arrayFromUnknown(toRecord(nodeRecord.message).parts) ||
-        null;
-    const partDescriptors = [];
-    if (parts && parts.length > 0) {
-        for (const part of parts) {
-            const descriptor = normalizeMessagePart(part, fallbackRole);
-            if (descriptor) {
-                partDescriptors.push(descriptor);
-            }
-        }
-    }
-    if (partDescriptors.length > 0) {
-        descriptors.push(...partDescriptors);
-        return descriptors;
-    }
-    const fallbackDescriptor = normalizeMessagePart(nodeRecord, fallbackRole);
-    if (fallbackDescriptor) {
-        descriptors.push(fallbackDescriptor);
-    }
-    return descriptors;
-}
-function normalizeMessagePart(value, fallbackRole) {
-    const record = toRecord(value);
-    const toolCallPayload = maybeRecord(record.tool_use) ??
-        maybeRecord(record.toolUse) ??
-        maybeRecord(record.functionCall) ??
-        (record.type === "tool_use" || record.type === "function_call" ? record : null);
-    if (toolCallPayload) {
-        const timestamp = resolveOptionalMessageTimestamp(record);
-        const patchText = buildGeminiApplyPatchFromInput(toolCallPayload);
-        const callId = resolveStringField(toolCallPayload, ["id", "toolCallId", "call_id"]) || "gemini-call";
-        const name = patchText
-            ? "apply_patch"
-            : resolveStringField(toolCallPayload, ["name", "toolName", "tool_name"]) || "unknown_tool";
-        const inputPayload = toolCallPayload.input ??
-            toolCallPayload.arguments ??
-            toolCallPayload.args ??
-            null;
-        const inputText = patchText || stringifyStructuredValue(inputPayload);
-        return {
-            role: patchText ? "tool" : "assistant",
-            kind: "tool_call",
-            content: inputText,
-            toolCall: {
-                callId,
-                name,
-                input: inputText,
-                output: null,
-                error: null,
-                status: "running"
-            },
-            timestamp
-        };
-    }
-    const toolResultPayload = maybeRecord(record.tool_result) ??
-        maybeRecord(record.toolResult) ??
-        maybeRecord(record.functionResponse) ??
-        (record.type === "tool_result" || record.type === "function_response" ? record : null);
-    if (toolResultPayload) {
-        const timestamp = resolveOptionalMessageTimestamp(record);
-        const errorDetail = resolveStringField(toolResultPayload, ["error", "error_message"]);
-        const outputPayload = toolResultPayload.output ??
-            toolResultPayload.result ??
-            toolResultPayload.content ??
-            null;
-        const normalizedName = resolveStringField(toolResultPayload, [
-            "name",
-            "tool_name",
-            "toolName"
-        ]) || "unknown_tool";
-        const name = isGeminiEditableToolName(normalizedName) ? "apply_patch" : normalizedName;
-        return {
-            role: "tool",
-            kind: "tool_result",
-            content: extractTextBlocks(outputPayload).trim() || stringifyStructuredValue(outputPayload),
-            toolCall: {
-                callId: resolveStringField(toolResultPayload, [
-                    "tool_use_id",
-                    "toolUseId",
-                    "call_id",
-                    "callId"
-                ]) || "gemini-tool-result",
-                name,
-                input: "",
-                output: stringifyStructuredValue(outputPayload),
-                error: errorDetail,
-                status: errorDetail ? "failed" : "completed"
-            },
-            timestamp
-        };
-    }
-    const text = extractTextBlocks(record.text ??
-        record.content ??
-        record.output ??
-        record.message ??
-        value).trim();
-    if (!text) {
-        return null;
-    }
-    const partType = ensureText(record.type).toLowerCase();
-    const kind = partType.includes("think") ? "thinking" : "text";
-    return {
-        role: fallbackRole,
-        kind,
-        content: text,
-        toolCall: null,
-        timestamp: resolveOptionalMessageTimestamp(record)
-    };
-}
-function readGeminiThoughtDescriptors(nodeRecord) {
-    const thoughts = arrayFromUnknown(nodeRecord.thoughts) ??
-        arrayFromUnknown(nodeRecord.reasoning) ??
-        null;
-    if (!thoughts || thoughts.length === 0) {
-        return [];
-    }
-    return thoughts
-        .map((thought) => normalizeGeminiThoughtDescriptor(thought))
-        .filter((descriptor) => descriptor !== null);
-}
-function normalizeGeminiThoughtDescriptor(value) {
-    const record = toRecord(value);
-    const subject = resolveStringField(record, ["subject", "title", "name"]);
-    const description = resolveStringField(record, [
-        "description",
-        "content",
-        "text",
-        "message"
-    ]);
-    const content = [subject, description].filter((item) => Boolean(item)).join("\n\n").trim();
-    if (!content) {
-        return null;
-    }
-    return {
-        role: "assistant",
-        kind: "thinking",
-        content,
-        toolCall: null,
-        timestamp: resolveOptionalMessageTimestamp(record)
-    };
-}
-function readGeminiToolCallDescriptors(nodeRecord) {
-    const toolCalls = arrayFromUnknown(nodeRecord.toolCalls) ??
-        arrayFromUnknown(nodeRecord.tool_calls) ??
-        null;
-    if (!toolCalls || toolCalls.length === 0) {
-        return [];
-    }
-    const descriptors = [];
-    for (let index = 0; index < toolCalls.length; index += 1) {
-        const descriptorSet = normalizeGeminiToolCall(toolCalls[index], index);
-        if (descriptorSet.call) {
-            descriptors.push(descriptorSet.call);
-        }
-        if (descriptorSet.result) {
-            descriptors.push(descriptorSet.result);
-        }
-    }
-    return descriptors;
-}
-function normalizeGeminiToolCall(value, index) {
-    const record = toRecord(value);
-    const timestamp = resolveOptionalMessageTimestamp(record);
-    const patchText = buildGeminiApplyPatchFromInput(record);
-    const callId = resolveStringField(record, ["id", "toolCallId", "call_id"]) ||
-        `gemini-tool-call-${index + 1}`;
-    const rawName = resolveStringField(record, ["name", "toolName", "tool_name", "displayName"]) || "tool";
-    const name = patchText ? "apply_patch" : rawName;
-    const inputPayload = record.args ?? record.input ?? record.arguments ?? null;
-    const inputText = patchText || stringifyStructuredValue(inputPayload);
-    const callDescriptor = {
-        role: patchText ? "tool" : "assistant",
-        kind: "tool_call",
-        content: inputText || name,
-        toolCall: {
-            callId,
-            name,
-            input: inputText,
-            output: null,
-            error: null,
-            status: "running"
-        },
-        timestamp
-    };
-    return {
-        call: callDescriptor,
-        result: normalizeGeminiToolCallResult(record, callId, name, timestamp)
-    };
-}
-function normalizeGeminiToolCallResult(record, callId, name, fallbackTimestamp) {
-    const output = extractGeminiToolCallOutput(record);
-    const error = extractGeminiToolCallError(record);
-    const hasResultPayload = Array.isArray(record.result) ||
-        record.result !== undefined ||
-        record.output !== undefined ||
-        record.resultDisplay !== undefined ||
-        error !== null;
-    if (!hasResultPayload) {
-        return null;
-    }
-    const status = normalizeGeminiToolCallStatus(record, error);
-    const content = output || error || name;
-    if (!content.trim()) {
-        return null;
-    }
-    return {
-        role: "tool",
-        kind: "tool_result",
-        content,
-        toolCall: {
-            callId,
-            name,
-            input: "",
-            output: output || null,
-            error,
-            status
-        },
-        timestamp: resolveStringField(record, [
-            "timestamp",
-            "updatedAt",
-            "updated_at",
-            "lastUpdated",
-            "last_updated"
-        ]) || fallbackTimestamp
-    };
-}
-function extractGeminiToolCallOutput(record) {
-    const resultItems = arrayFromUnknown(record.result) ?? [];
-    for (const item of resultItems) {
-        const itemRecord = toRecord(item);
-        const functionResponse = toRecord(itemRecord.functionResponse);
-        const response = toRecord(functionResponse.response);
-        const outputText = extractTextBlocks(response.output ??
-            itemRecord.output ??
-            itemRecord.result ??
-            itemRecord.content).trim();
-        if (outputText) {
-            return outputText;
-        }
-    }
-    const directOutput = extractTextBlocks(record.output ??
-        record.result ??
-        toRecord(record.resultDisplay).fileDiff ??
-        toRecord(record.resultDisplay).newContent).trim();
-    return directOutput;
-}
-function extractGeminiToolCallError(record) {
-    const directError = resolveStringField(record, [
-        "error",
-        "error_message",
-        "failure",
-        "description"
-    ]);
-    if (directError && normalizeGeminiToolCallStatus(record, null) === "failed") {
-        return directError;
-    }
-    return null;
-}
-function normalizeGeminiToolCallStatus(record, error) {
-    if (error) {
-        return "failed";
-    }
-    const normalizedStatus = ensureText(record.status).trim().toLowerCase();
-    if (!normalizedStatus || normalizedStatus === "success" || normalizedStatus === "completed") {
-        return "completed";
-    }
-    if (["error", "failed", "failure", "cancelled", "canceled"].includes(normalizedStatus)) {
-        return "failed";
-    }
-    return "completed";
-}
-function buildGeminiApplyPatchFromInput(value) {
-    const input = value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : null;
-    if (!input) {
-        return null;
-    }
-    const candidates = [toRecord(input.input), toRecord(input.arguments), toRecord(input.args), input];
-    for (const candidate of candidates) {
-        const patchText = buildApplyPatchFromStructuredFileTool(candidate);
-        if (patchText) {
-            return patchText;
-        }
-    }
-    return null;
-}
-function isGeminiEditableToolName(toolName) {
-    const normalized = toolName.trim().toLowerCase();
-    return [
-        "write_file",
-        "writefile",
-        "create_file",
-        "edit_file",
-        "replace",
-        "replace_file",
-        "update_file",
-        "multi_edit",
-        "multiedit"
-    ].includes(normalized);
-}
-function resolveGeminiRole(record) {
-    const candidate = resolveStringField(record, [
-        "role",
-        "author",
-        "sender",
-        "source",
-        "participant",
-        "type"
-    ])?.toLowerCase();
-    if (!candidate) {
-        return "assistant";
-    }
-    if (candidate.includes("user") || candidate.includes("human")) {
-        return "user";
-    }
-    if (candidate.includes("tool")) {
-        return "tool";
-    }
-    if (candidate.includes("system")) {
-        return "system";
-    }
-    if (candidate.includes("assistant")
-        || candidate.includes("model")
-        || candidate.includes("gemini")) {
-        return "assistant";
-    }
-    return "assistant";
-}
-function resolveMessageTimestamp(record) {
-    const direct = resolveStringField(record, [
-        "timestamp",
-        "time",
-        "createdAt",
-        "created_at",
-        "updatedAt",
-        "updated_at"
-    ]);
-    if (direct) {
-        return direct;
-    }
-    return nextTimestamp();
-}
-function resolveOptionalMessageTimestamp(record) {
-    return resolveStringField(record, [
-        "timestamp",
-        "time",
-        "createdAt",
-        "created_at",
-        "updatedAt",
-        "updated_at",
-        "lastUpdated",
-        "last_updated"
-    ]);
-}
-function buildGeminiMessageRawRef(sessionId, filePath, messageIndex, partIndex) {
-    return `${GEMINI_RAW_STORE_PREFIX}${encodeURIComponent(sessionId)}#file=${encodeURIComponent(filePath.replaceAll("\\", "/"))}&index=${messageIndex}&part=${partIndex}`;
-}
-function buildGeminiMessageId(input) {
-    const { descriptor, identityState, rawRef, sessionId } = input;
-    if (descriptor.kind === "text" && descriptor.toolCall === null) {
-        if (descriptor.role === "user") {
-            identityState.userTextIndex += 1;
-            return messageIdFromRawRef(buildGeminiRuntimeTextRawRef(sessionId, "user", identityState.userTextIndex));
-        }
-        if (descriptor.role === "assistant") {
-            identityState.assistantTextIndex += 1;
-            return messageIdFromRawRef(buildGeminiRuntimeTextRawRef(sessionId, "assistant", identityState.assistantTextIndex));
-        }
-    }
-    if ((descriptor.kind === "tool_call" || descriptor.kind === "tool_result")
-        && descriptor.toolCall?.callId?.trim()) {
-        return messageIdFromRawRef(buildGeminiRuntimeToolRawRef(sessionId, descriptor.toolCall.callId.trim(), descriptor.kind === "tool_call" ? "call" : "result"));
-    }
-    return messageIdFromRawRef(rawRef);
-}
-function buildGeminiRuntimeTextRawRef(sessionId, role, index) {
-    return `${GEMINI_RAW_STORE_PREFIX}${encodeURIComponent(sessionId)}/message/${role}-${index}`;
-}
-function buildGeminiRuntimeToolRawRef(sessionId, toolId, kind) {
-    return `${GEMINI_RAW_STORE_PREFIX}${encodeURIComponent(sessionId)}/tool/${encodeURIComponent(toolId)}/${kind}`;
-}
-function resolveStringField(record, fieldNames) {
-    for (const fieldName of fieldNames) {
-        const value = ensureNonEmptyText(record[fieldName]);
-        if (value) {
-            return value;
-        }
-    }
-    const metadata = toRecord(record.metadata);
-    for (const fieldName of fieldNames) {
-        const value = ensureNonEmptyText(metadata[fieldName]);
-        if (value) {
-            return value;
-        }
-    }
-    return null;
-}
-function resolveNumberField(record, fieldNames) {
-    for (const fieldName of fieldNames) {
-        const value = record[fieldName];
-        if (typeof value === "number" && Number.isFinite(value)) {
-            return Math.max(0, Math.trunc(value));
-        }
-        if (typeof value === "string") {
-            const parsed = Number.parseInt(value, 10);
-            if (Number.isFinite(parsed)) {
-                return Math.max(0, parsed);
-            }
-        }
-    }
-    return null;
-}
-function parseGeminiPlainTextSessions(stdout, workspacePathFallback) {
-    const sessions = stdout
-        .split(/\r?\n/)
-        .map((line) => normalizePlainTextCliSessionLine(line, workspacePathFallback))
-        .filter((item) => item !== null);
-    return dedupeCliSessions(sessions);
-}
-function normalizePlainTextCliSessionLine(line, workspacePathFallback) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-        return null;
-    }
-    const sessionIdMatch = trimmed.match(/\[([^\]]+)\]\s*$/);
-    if (!sessionIdMatch?.[1]) {
-        return null;
-    }
-    const providerSessionId = sessionIdMatch[1].trim();
-    if (!providerSessionId) {
-        return null;
-    }
-    let prefix = trimmed.slice(0, sessionIdMatch.index).trim();
-    prefix = prefix.replace(/^\d+\.\s*/, "").trim();
-    const timeSuffixMatch = prefix.match(/\(([^()]*)\)\s*$/);
-    const title = (timeSuffixMatch && typeof timeSuffixMatch.index === "number"
-        ? prefix.slice(0, timeSuffixMatch.index)
-        : prefix).trim() || providerSessionId;
-    return {
-        providerSessionId,
-        workspacePath: workspacePathFallback,
-        title,
-        lastMessageAt: null,
-        messageCount: null
-    };
-}
-function ensureNonEmptyText(value) {
-    const text = ensureText(value).trim();
-    return text.length > 0 ? text : null;
-}
-function parseJsonSafe(value) {
-    if (!value) {
-        return null;
-    }
-    try {
-        return JSON.parse(value);
-    }
-    catch {
-        return null;
-    }
-}
-function arrayFromUnknown(value) {
-    return Array.isArray(value) ? value : null;
-}
-function toRecord(value) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    return {};
-}
-function maybeRecord(value) {
-    if (value && typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    return null;
-}
-function resolveWorkspacePathFromChatFile(filePath) {
-    const projectRootFile = join(dirname(dirname(filePath)), ".project_root");
-    if (!existsSync(projectRootFile)) {
-        return null;
-    }
-    try {
-        return ensureNonEmptyText(readFileSync(projectRootFile, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-function shouldUseShellForCommand(commandPath) {
-    return process.platform === "win32" && [".cmd", ".bat"].includes(extname(commandPath).toLowerCase());
-}
-function isCommandAvailable(commandPath) {
-    const normalizedCommandPath = stripWrappingQuotes(commandPath);
-    if (!normalizedCommandPath) {
-        return false;
-    }
-    if (normalizedCommandPath.includes("/")
-        || normalizedCommandPath.includes("\\")) {
-        if (!existsSync(normalizedCommandPath)) {
-            return false;
-        }
-        const extension = extname(normalizedCommandPath).toLowerCase();
-        if ([".js", ".cjs", ".mjs"].includes(extension)) {
-            return true;
-        }
-        if (process.platform === "win32") {
-            return true;
-        }
-        try {
-            accessSync(normalizedCommandPath, constants.X_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    const pathEntries = (process.env.PATH ?? "")
-        .split(delimiter)
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-    if (process.platform === "win32") {
-        const pathextEntries = (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM")
-            .split(";")
-            .map((entry) => entry.trim().toLowerCase())
-            .filter(Boolean);
-        const candidateNames = extname(normalizedCommandPath)
-            ? [normalizedCommandPath]
-            : pathextEntries.map((entry) => `${normalizedCommandPath}${entry.toLowerCase()}`);
-        for (const entry of pathEntries) {
-            for (const candidateName of candidateNames) {
-                if (existsSync(join(entry, candidateName))) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    for (const entry of pathEntries) {
-        const candidatePath = join(entry, normalizedCommandPath);
-        if (!existsSync(candidatePath)) {
-            continue;
-        }
-        try {
-            accessSync(candidatePath, constants.X_OK);
-            return true;
-        }
-        catch {
-            continue;
-        }
-    }
-    return false;
-}
-function stripWrappingQuotes(value) {
-    const trimmed = value.trim();
-    if ((trimmed.startsWith("\"") && trimmed.endsWith("\""))
-        || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
-        return trimmed.slice(1, -1).trim();
-    }
-    return trimmed;
-}
-function wrapGeminiSchemaError(filePath, error) {
-    const detail = error instanceof Error ? error.message : ensureText(error);
-    return new Error(`GEMINI_CHAT_SCHEMA_INVALID: file=${filePath.replaceAll("\\", "/")} detail=${detail}`);
-}
-//# sourceMappingURL=gemini.js.map