@jingyi0605/codingns 0.1.4 → 0.2.0

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

@@ -0,0 +1,1175 @@
+import { execFile as nodeExecFile } from "node:child_process";
+import { accessSync, constants, existsSync, readdirSync, readFileSync, 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";
+    constructor(options) {
+        this.options = options;
+    }
+    async detectSessions(workspacePath, options) {
+        const discovery = await this.detectSessionsDetailed(workspacePath, options);
+        return discovery.sessions;
+    }
+    async detectSessionsDetailed(workspacePath, options) {
+        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 localSessions = this.readLocalSessions();
+        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);
+            }
+        }
+        return {
+            sessions: [...mergedByProviderSessionId.values()].sort((left, right) => (right.lastMessageAt ?? "").localeCompare(left.lastMessageAt ?? "")),
+            isComplete: cliResult.isComplete
+        };
+    }
+    async readSessionHistory(providerSessionId, rawStoreRef, cursor, limit, direction = "forward") {
+        const resolvedProviderSessionId = this.resolveProviderSessionId(providerSessionId, rawStoreRef);
+        const parsedChat = this.readParsedChatBySessionId(resolvedProviderSessionId);
+        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);
+        return {
+            provider: this.providerId,
+            providerSessionId: resolvedProviderSessionId,
+            resumedAt: nextTimestamp(),
+            rawStoreRef: buildGeminiRawStoreRef(resolvedProviderSessionId)
+        };
+    }
+    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);
+        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");
+    }
+    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,
+            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);
+        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,
+                fromRawStoreRef: false
+            };
+        }
+        return {
+            providerSessionId: parseGeminiRawStoreRef(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");
+    }
+    readLocalSessions() {
+        const sessions = [];
+        const latestByProviderSessionId = new Map();
+        for (const filePath of listGeminiChatFiles(this.options.homeDir)) {
+            let parsedChat;
+            try {
+                parsedChat = this.parseLocalChatFile(filePath);
+            }
+            catch {
+                continue;
+            }
+            const existing = latestByProviderSessionId.get(parsedChat.providerSessionId);
+            if (existing &&
+                (existing.sourceMtimeMs > parsedChat.sourceMtimeMs ||
+                    (existing.sourceMtimeMs === parsedChat.sourceMtimeMs &&
+                        existing.sourceSizeBytes >= parsedChat.sourceSizeBytes))) {
+                continue;
+            }
+            latestByProviderSessionId.set(parsedChat.providerSessionId, {
+                providerSessionId: parsedChat.providerSessionId,
+                workspacePath: parsedChat.workspacePath,
+                title: parsedChat.title,
+                lastMessageAt: parsedChat.lastMessageAt,
+                messageCount: parsedChat.messages.length,
+                filePath,
+                sourceMtimeMs: parsedChat.sourceMtimeMs,
+                sourceSizeBytes: parsedChat.sourceSizeBytes
+            });
+        }
+        sessions.push(...latestByProviderSessionId.values());
+        return sessions;
+    }
+    readParsedChatBySessionId(providerSessionId) {
+        const sessionId = providerSessionId.trim();
+        if (!sessionId) {
+            throw new Error("PROVIDER_SESSION_ID_REQUIRED");
+        }
+        const chatFiles = listGeminiChatFiles(this.options.homeDir);
+        let matchedByName = null;
+        for (const filePath of chatFiles) {
+            if (basename(filePath, ".json") === sessionId) {
+                matchedByName = filePath;
+            }
+            let parsed;
+            try {
+                parsed = this.parseLocalChatFile(filePath);
+            }
+            catch (error) {
+                if (basename(filePath, ".json") === sessionId) {
+                    throw wrapGeminiSchemaError(filePath, error);
+                }
+                continue;
+            }
+            if (parsed.providerSessionId === sessionId) {
+                return parsed;
+            }
+        }
+        if (matchedByName) {
+            try {
+                return this.parseLocalChatFile(matchedByName);
+            }
+            catch (error) {
+                throw wrapGeminiSchemaError(matchedByName, error);
+            }
+        }
+        throw new Error("GEMINI_CHAT_NOT_FOUND");
+    }
+    parseLocalChatFile(filePath) {
+        const stats = statSync(filePath);
+        const raw = readFileSync(filePath, "utf8").trim();
+        if (!raw) {
+            throw new Error("GEMINI_CHAT_SCHEMA_INVALID");
+        }
+        let parsedRaw;
+        try {
+            parsedRaw = JSON.parse(raw);
+        }
+        catch (error) {
+            throw wrapGeminiSchemaError(filePath, error);
+        }
+        const parsedRecord = toRecord(parsedRaw);
+        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
+        };
+    }
+    resolveLocalProviderSessionId(record, filePath) {
+        const sessionId = resolveStringField(record, [
+            "sessionId",
+            "session_id",
+            "id",
+            "chatId",
+            "conversationId",
+            "conversation_id"
+        ]) || basename(filePath, ".json");
+        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 buildGeminiRawStoreRef(providerSessionId) {
+    return `${GEMINI_RAW_STORE_PREFIX}${encodeURIComponent(providerSessionId)}`;
+}
+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")) {
+                continue;
+            }
+            if (!isGeminiChatFile(entryPath)) {
+                continue;
+            }
+            chatFiles.push(entryPath);
+        }
+    }
+    return chatFiles;
+}
+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;
+    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);
+            messages.push({
+                messageId: messageIdFromRawRef(rawRef),
+                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 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 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