@jingyi0605/codingns 0.1.4 → 0.1.5

package/dist/server/modules/sessions/session-history-service.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
+import { CapabilityService, ClaudeCodeAdapter, CodexAdapter, GeminiAdapter, KimiAdapter, OpenCodeAdapter, ProviderRegistry, SessionSyncService } from "@codingns/session-sync-core";
 import { AppError } from "../../shared/errors/app-error.js";
+import { hashContent } from "../../shared/utils/hash.js";
 import { createId } from "../../shared/utils/id.js";
 import { logPerformance } from "../../shared/utils/perf-log.js";
 import { nowIso } from "../../shared/utils/time.js";
@@ -10,6 +11,14 @@ import { mapSessionProviderError } from "./session-provider-error-mapper.js";
 import { enrichClaudeCapabilities } from "../provider/claude-model-options.js";
 import { CodexModelOptionsService, enrichCodexCapabilities } from "../provider/codex-model-options.js";
 import { OpenCodeModelOptionsService, enrichOpenCodeCapabilities } from "../provider/opencode-model-options.js";
+const SESSION_START_DEFERRED_PROVIDERS = new Set([
+    "codex",
+    "claude-code",
+    "opencode",
+    "gemini",
+    "kimi"
+]);
+const MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS = 1_200;
 export class SessionHistoryService {
     db;
     workspaceRepository;
@@ -19,6 +28,7 @@ export class SessionHistoryService {
     sessionMessageAttachmentService;
     sessionStateRepository;
     sessionStatusSnapshotRepository;
+    sessionMessageOriginRepository;
     providerRegistry;
     sessionSyncService;
     capabilityService;
@@ -30,7 +40,7 @@ export class SessionHistoryService {
     workspaceDiscoveryInflight = new Map();
     workspaceStateRefreshInflight = new Map();
     workspaceSessionRelations = new Map();
-    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService()) {
+    constructor(db, workspaceRepository, sessionBindingRepository, sessionChangedFileService, sessionIndexRepository, sessionMessageAttachmentService, sessionStateRepository, sessionStatusSnapshotRepository, config, sessionActivityAuthorityService = new SessionActivityAuthorityService(), sessionMessageOriginRepository = null) {
         this.db = db;
         this.workspaceRepository = workspaceRepository;
         this.sessionBindingRepository = sessionBindingRepository;
@@ -39,11 +49,20 @@ export class SessionHistoryService {
         this.sessionMessageAttachmentService = sessionMessageAttachmentService;
         this.sessionStateRepository = sessionStateRepository;
         this.sessionStatusSnapshotRepository = sessionStatusSnapshotRepository;
+        this.sessionMessageOriginRepository = sessionMessageOriginRepository;
         this.sessionActivityAuthorityService = sessionActivityAuthorityService;
         this.claudeCodeHomeDir = config.claudeCodeHomeDir;
         this.providerRegistry = new ProviderRegistry([
             new ClaudeCodeAdapter({ homeDir: config.claudeCodeHomeDir }),
             new CodexAdapter({ homeDir: config.codexHomeDir }),
+            new GeminiAdapter({
+                homeDir: config.geminiHomeDir,
+                commandPath: config.geminiCliPath
+            }),
+            new KimiAdapter({
+                homeDir: config.kimiHomeDir,
+                defaultModel: config.kimiDefaultModel
+            }),
             new OpenCodeAdapter({
                 baseUrl: config.opencodeBaseUrl,
                 baseUrlResolver: config.opencodeBaseUrlResolver?.resolve.bind(config.opencodeBaseUrlResolver),
@@ -98,15 +117,16 @@ export class SessionHistoryService {
     }
     async readSessionHistory(sessionId, cursor, limit, direction = "forward", userId) {
         const startedAt = Date.now();
-        const binding = this.getBindingOrThrow(sessionId);
-        const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
+        const resolvedSessionId = this.resolveCanonicalSessionId(sessionId, userId);
+        const binding = this.getBindingOrThrow(resolvedSessionId);
+        const current = this.sessionStatusSnapshotRepository.findBySessionId(resolvedSessionId);
         const safeLimit = clampLimit(limit);
         const knownTotalMessageCount = direction === "backward" && cursor === null
-            ? this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null
+            ? this.sessionIndexRepository.findIndexRecordBySessionId(resolvedSessionId)?.messageCount ?? null
             : null;
         let readDurationMs = 0;
         let refreshStateDurationMs = 0;
-        this.upsertSnapshot(sessionId, {
+        this.upsertSnapshot(resolvedSessionId, {
             syncStatus: "syncing",
             syncCursor: current?.syncCursor ?? cursor,
             lastSyncAt: current?.lastSyncAt ?? null,
@@ -116,9 +136,9 @@ export class SessionHistoryService {
         });
         try {
             const readStartedAt = Date.now();
-            const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, safeLimit, direction, knownTotalMessageCount);
+            const page = await this.readPage(resolvedSessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, cursor, safeLimit, direction, knownTotalMessageCount);
             readDurationMs = Date.now() - readStartedAt;
-            this.upsertSnapshot(sessionId, {
+            this.upsertSnapshot(resolvedSessionId, {
                 syncStatus: "idle",
                 syncCursor: direction === "backward" && cursor !== null
                     ? current?.syncCursor ?? page.cursor
@@ -129,7 +149,8 @@ export class SessionHistoryService {
                 resumedAt: current?.resumedAt ?? null
             });
             logPerformance("session.read_history", Date.now() - startedAt, {
-                sessionId,
+                sessionId: resolvedSessionId,
+                requestedSessionId: sessionId,
                 provider: binding.provider,
                 direction,
                 limit: safeLimit,
@@ -145,7 +166,8 @@ export class SessionHistoryService {
         }
         catch (error) {
             logPerformance("session.read_history.failed", Date.now() - startedAt, {
-                sessionId,
+                sessionId: resolvedSessionId,
+                requestedSessionId: sessionId,
                 provider: binding.provider,
                 direction,
                 limit: safeLimit,
@@ -157,10 +179,17 @@ export class SessionHistoryService {
                 thresholdMs: 0,
                 force: true
             });
-            this.markSessionError(sessionId, "PROVIDER_READ_FAILED", error);
+            this.markSessionError(resolvedSessionId, "PROVIDER_READ_FAILED", error);
             throw mapSessionProviderError(error);
         }
     }
+    resolveMessageOrigin(sessionId, message) {
+        return this.resolveMessageOrigins(sessionId, [message])[0] ?? {
+            ...message,
+            origin: null,
+            originRef: null
+        };
+    }
     async findLatestUserMessage(sessionId, content, maxAttempts = 12, minTimestamp = null) {
         const binding = this.getBindingOrThrow(sessionId);
         const acceptedContents = new Set((Array.isArray(content) ? content : [content]).filter((value) => value.trim().length > 0));
@@ -171,7 +200,7 @@ export class SessionHistoryService {
                 .reverse()
                 .find((message) => message.role === "user" &&
                 acceptedContents.has(message.content) &&
-                isMessageAtOrAfter(message.timestamp, minTimestamp));
+                isAcceptedUserMessageTimestamp(binding.provider, message.timestamp, minTimestamp));
             if (matched) {
                 return matched;
             }
@@ -209,7 +238,9 @@ export class SessionHistoryService {
         return this.sessionChangedFileService.listBySessionId(sessionId);
     }
     listWorkspaceSessions(workspaceId, userId) {
-        return this.enrichSessionItems(workspaceId, this.sessionIndexRepository.listByWorkspace(workspaceId, userId));
+        return this.enrichSessionItems(workspaceId, this.sessionIndexRepository
+            .listByWorkspace(workspaceId, userId)
+            .filter((item) => !this.isPendingSessionAlias(item)));
     }
     getProviderCapabilitiesSnapshot(provider) {
         try {
@@ -281,7 +312,7 @@ export class SessionHistoryService {
     }
     async startSession(input) {
         const workspace = this.getWorkspaceOrThrow(input.workspaceId);
-        if (input.provider === "codex" || input.provider === "claude-code" || input.provider === "opencode") {
+        if (SESSION_START_DEFERRED_PROVIDERS.has(input.provider)) {
             throw new AppError({
                 statusCode: 409,
                 errorCode: "SESSION_START_DEFERRED",
@@ -385,7 +416,7 @@ export class SessionHistoryService {
         };
     }
     async subscribeSession(sessionId, cursor, limit, onEnvelope) {
-        const sentMessageIds = new Set();
+        const deliveredMessages = createDeliveredHistoryMessageState();
         const safeLimit = clampLimit(limit);
         let currentCursor = cursor;
         const current = this.sessionStatusSnapshotRepository.findBySessionId(sessionId);
@@ -401,10 +432,10 @@ export class SessionHistoryService {
         });
         try {
             if (currentCursor === null) {
-                currentCursor = await this.pullRecentSessionHistory(sessionId, safeLimit, sentMessageIds, onEnvelope, "session.backfill");
+                currentCursor = await this.pullRecentSessionHistory(sessionId, safeLimit, deliveredMessages, onEnvelope, "session.backfill");
             }
             else {
-                await this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.backfill").then((nextCursor) => {
+                await this.pullSessionHistory(sessionId, currentCursor, safeLimit, deliveredMessages, onEnvelope, "session.backfill").then((nextCursor) => {
                     currentCursor = nextCursor;
                 });
             }
@@ -418,7 +449,7 @@ export class SessionHistoryService {
                 return;
             }
             polling = true;
-            void this.pullSessionHistory(sessionId, currentCursor, safeLimit, sentMessageIds, onEnvelope, "session.delta", () => closed)
+            void this.pullSessionHistory(sessionId, currentCursor, safeLimit, deliveredMessages, onEnvelope, "session.delta", () => closed)
                 .then((nextCursor) => {
                 currentCursor = nextCursor;
             })
@@ -567,7 +598,7 @@ export class SessionHistoryService {
                 detail: "session 不存在"
             });
         }
-        return binding;
+        return this.resolvePendingSessionAliasBinding(binding) ?? binding;
     }
     persistSessionBinding(sessionId, workspaceId, snapshot) {
         if (!snapshot.providerSessionId || !snapshot.rawStoreRef) {
@@ -643,7 +674,8 @@ export class SessionHistoryService {
                         continue;
                     }
                     const pendingDuplicate = exactExisting
-                        ?? findClaudePendingDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds);
+                        ?? findClaudePendingDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds)
+                        ?? findKimiRuntimeDiscoveryDuplicate(session, existingWorkspaceSessions, claimedPendingSessionIds);
                     const existing = exactExisting ?? (pendingDuplicate
                         ? this.sessionBindingRepository.findBySessionId(pendingDuplicate.sessionId)
                         : null);
@@ -788,7 +820,8 @@ export class SessionHistoryService {
             : this.sessionSyncService.readHistory(provider, providerSessionId, rawStoreRef, cursor, limit, direction);
         return historyTask
             .then((page) => {
-            const messages = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            const messagesWithAttachments = this.sessionMessageAttachmentService.enrichMessages(sessionId, page.messages);
+            const messages = this.enrichMessagesWithOrigin(sessionId, messagesWithAttachments);
             this.persistSessionChangedFiles(sessionId, messages);
             return {
                 ...page,
@@ -807,6 +840,64 @@ export class SessionHistoryService {
             throw mapSessionProviderError(error);
         });
     }
+    enrichMessagesWithOrigin(sessionId, messages) {
+        return this.resolveMessageOrigins(sessionId, messages);
+    }
+    resolveMessageOrigins(sessionId, messages) {
+        const originRepository = this.sessionMessageOriginRepository;
+        if (!originRepository || messages.length === 0) {
+            return messages.map((message) => ({
+                ...message,
+                origin: null,
+                originRef: null
+            }));
+        }
+        const messageIds = [...new Set(messages.map((message) => message.messageId).filter(Boolean))];
+        const originRows = originRepository.listBySessionAndMessageIds(sessionId, messageIds);
+        const originByMessageId = new Map(originRows
+            .filter((row) => row.messageId)
+            .map((row) => [row.messageId, row]));
+        const unresolvedRows = originRepository.listUnresolvedBySessionAndContents(sessionId, [...new Set(messages.map((message) => message.content).filter((content) => content.trim().length > 0))]);
+        const unresolvedByContent = new Map();
+        for (const row of unresolvedRows) {
+            const current = unresolvedByContent.get(row.content) ?? [];
+            current.push(row);
+            unresolvedByContent.set(row.content, current);
+        }
+        return messages.map((message) => {
+            const resolved = originByMessageId.get(message.messageId) ?? null;
+            if (resolved) {
+                return {
+                    ...message,
+                    origin: resolved.origin,
+                    originRef: resolved.originRef
+                };
+            }
+            if (message.role !== "user") {
+                return {
+                    ...message,
+                    origin: null,
+                    originRef: null
+                };
+            }
+            const candidates = unresolvedByContent.get(message.content) ?? [];
+            const matched = candidates.find((row) => isMessageAtOrAfter(message.timestamp, row.createdAt)) ?? null;
+            if (!matched) {
+                return {
+                    ...message,
+                    origin: null,
+                    originRef: null
+                };
+            }
+            originRepository.resolveMessageId(sessionId, matched.clientRequestId, message.messageId, message.timestamp);
+            unresolvedByContent.set(message.content, candidates.filter((candidate) => candidate.clientRequestId !== matched.clientRequestId));
+            return {
+                ...message,
+                origin: matched.origin,
+                originRef: matched.originRef
+            };
+        });
+    }
     buildWorkspaceSessionRelationMap(sessions, discoveredSessionIds) {
         const relationMap = new Map();
         for (const session of sessions) {
@@ -863,12 +954,18 @@ export class SessionHistoryService {
         const resolution = this.sessionActivityAuthorityService.resolvePersistedSession(nextItem);
         return applySessionActivityResolution(nextItem, resolution);
     }
-    async pullSessionHistory(sessionId, cursor, limit, sentMessageIds, onEnvelope, envelopeType, isClosed = () => false) {
+    async pullSessionHistory(sessionId, cursor, limit, deliveredMessages, onEnvelope, envelopeType, isClosed = () => false) {
         let currentCursor = cursor;
         while (!isClosed()) {
             const binding = this.getBindingOrThrow(sessionId);
             const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, currentCursor, limit);
-            await this.publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType);
+            await this.publishHistoryEnvelope(sessionId, binding, page, deliveredMessages, onEnvelope, envelopeType);
+            if (envelopeType === "session.delta" &&
+                shouldRefreshMutableHistoryTail(binding.provider, page, currentCursor, deliveredMessages)) {
+                const tailPage = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, Math.max(limit, 20), "backward");
+                deliveredMessages.lastMutableTailRefreshAtMs = Date.now();
+                await this.publishHistoryEnvelope(sessionId, binding, tailPage, deliveredMessages, onEnvelope, envelopeType);
+            }
             currentCursor = page.cursor;
             if (!page.nextCursor) {
                 return currentCursor;
@@ -876,19 +973,21 @@ export class SessionHistoryService {
         }
         return currentCursor;
     }
-    async pullRecentSessionHistory(sessionId, limit, sentMessageIds, onEnvelope, envelopeType) {
+    async pullRecentSessionHistory(sessionId, limit, deliveredMessages, onEnvelope, envelopeType) {
         const binding = this.getBindingOrThrow(sessionId);
         const knownTotalMessageCount = this.sessionIndexRepository.findIndexRecordBySessionId(sessionId)?.messageCount ?? null;
         const page = await this.readPage(sessionId, binding.provider, binding.providerSessionId, binding.rawStoreRef, null, limit, "backward", knownTotalMessageCount);
-        await this.publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType);
+        await this.publishHistoryEnvelope(sessionId, binding, page, deliveredMessages, onEnvelope, envelopeType);
         return page.cursor;
     }
-    async publishHistoryEnvelope(sessionId, binding, page, sentMessageIds, onEnvelope, envelopeType) {
+    async publishHistoryEnvelope(sessionId, binding, page, deliveredMessages, onEnvelope, envelopeType) {
         const messages = page.messages.filter((message) => {
-            if (sentMessageIds.has(message.messageId)) {
+            const nextSignature = buildDeliveredHistoryMessageSignature(message);
+            const previousSignature = deliveredMessages.signaturesByMessageId.get(message.messageId);
+            if (previousSignature === nextSignature) {
                 return false;
             }
-            sentMessageIds.add(message.messageId);
+            rememberDeliveredHistoryMessage(deliveredMessages, message.messageId, nextSignature);
             return true;
         });
         if (messages.length === 0) {
@@ -980,7 +1079,53 @@ export class SessionHistoryService {
                 detail: "session 索引缺失"
             });
         }
-        return item;
+        const aliasTargetSessionId = this.findPendingSessionAliasTargetSessionId(item);
+        if (!aliasTargetSessionId) {
+            return item;
+        }
+        return this.sessionIndexRepository.findBySessionId(aliasTargetSessionId, userId) ?? item;
+    }
+    resolveCanonicalSessionId(sessionId, userId) {
+        if (userId) {
+            const item = this.sessionIndexRepository.findBySessionId(sessionId, userId);
+            const aliasTargetSessionId = this.findPendingSessionAliasTargetSessionId(item);
+            if (aliasTargetSessionId) {
+                return aliasTargetSessionId;
+            }
+        }
+        const binding = this.sessionBindingRepository.findBySessionId(sessionId);
+        return this.findPendingSessionAliasTargetSessionId(binding) ?? sessionId;
+    }
+    isPendingSessionAlias(item) {
+        return Boolean(this.findPendingSessionAliasTargetSessionId(item));
+    }
+    resolvePendingSessionAliasBinding(binding) {
+        const aliasTargetSessionId = this.findPendingSessionAliasTargetSessionId(binding);
+        if (!aliasTargetSessionId) {
+            return null;
+        }
+        return this.sessionBindingRepository.findBySessionId(aliasTargetSessionId);
+    }
+    findPendingSessionAliasTargetSessionId(descriptor) {
+        if (!descriptor || descriptor.provider !== "gemini") {
+            return null;
+        }
+        const aliasTargetSessionId = extractPendingBindingTargetSessionId(descriptor.providerSessionId)
+            ?? extractPendingBindingTargetSessionId(descriptor.rawStoreRef);
+        if (!aliasTargetSessionId || aliasTargetSessionId === descriptor.sessionId) {
+            return null;
+        }
+        const targetBinding = this.sessionBindingRepository.findBySessionId(aliasTargetSessionId);
+        if (!targetBinding) {
+            return null;
+        }
+        if (targetBinding.workspaceId !== descriptor.workspaceId
+            || targetBinding.provider !== descriptor.provider
+            || isPendingBindingValue(targetBinding.providerSessionId)
+            || isPendingBindingValue(targetBinding.rawStoreRef)) {
+            return null;
+        }
+        return aliasTargetSessionId;
     }
     async refreshRecentSessionStates(sessions, userId) {
         for (let index = 0; index < sessions.length; index += 1) {
@@ -1585,12 +1730,20 @@ function isPendingBindingValue(value) {
 function buildPendingBindingValue(provider, sessionId) {
     return `pending://${provider}/${sessionId}`;
 }
+function extractPendingBindingTargetSessionId(value) {
+    if (!isPendingBindingValue(value)) {
+        return null;
+    }
+    const normalizedValue = value.trim();
+    const targetSessionId = normalizedValue.slice(normalizedValue.indexOf("/", "pending://".length) + 1).trim();
+    return targetSessionId || null;
+}
 function isClaudePendingRuntimeRawStoreRef(rawStoreRef) {
     const normalizedRawStoreRef = rawStoreRef.replaceAll("\\", "/").toLowerCase();
     return normalizedRawStoreRef.includes("/.pending-");
 }
 function shouldShortCircuitClaudePendingHistory(provider, providerSessionId, rawStoreRef) {
-    if (provider !== "claude-code") {
+    if (provider !== "claude-code" && provider !== "gemini") {
         return false;
     }
     return isPendingBindingValue(providerSessionId) || isPendingBindingValue(rawStoreRef);
@@ -1639,6 +1792,66 @@ function findClaudePendingDiscoveryDuplicate(session, existingSessions, claimedS
     });
     return activePendingCandidates.length === 1 ? activePendingCandidates[0] : null;
 }
+function findKimiRuntimeDiscoveryDuplicate(session, existingSessions, claimedSessionIds) {
+    if (session.provider !== "kimi" || isPendingBindingValue(session.providerSessionId)) {
+        return null;
+    }
+    const candidates = existingSessions.filter((item) => {
+        if (claimedSessionIds.has(item.sessionId)) {
+            return false;
+        }
+        if (item.provider !== "kimi" || !shouldRecoverKimiRuntimeBinding(item)) {
+            return false;
+        }
+        return isCloseKimiSessionTimestamp(item.lastMessageAt ?? item.createdAt, session.lastMessageAt);
+    });
+    if (candidates.length === 1) {
+        return candidates[0];
+    }
+    const comparableTitle = normalizeKimiComparableTitle(session.title);
+    if (!comparableTitle) {
+        return null;
+    }
+    const titleMatchedCandidates = candidates.filter((item) => normalizeKimiComparableTitle(item.title) === comparableTitle);
+    return titleMatchedCandidates.length === 1
+        ? titleMatchedCandidates[0]
+        : null;
+}
+function shouldRecoverKimiRuntimeBinding(item) {
+    if (isPendingBindingValue(item.providerSessionId)) {
+        return true;
+    }
+    if (item.messageCount !== 0 || item.activitySource !== "runtime") {
+        return false;
+    }
+    if (item.runningState === "starting") {
+        return true;
+    }
+    if (item.lastErrorCode === "PROVIDER_READ_FAILED") {
+        return true;
+    }
+    return (item.lastErrorDetail ?? "").includes("provider 会话不存在");
+}
+function normalizeKimiComparableTitle(title) {
+    const normalized = title.trim().replace(/\s+/g, " ");
+    if (!normalized) {
+        return null;
+    }
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(normalized)
+        ? null
+        : normalized;
+}
+function isCloseKimiSessionTimestamp(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    const leftAt = Date.parse(left);
+    const rightAt = Date.parse(right);
+    if (!Number.isFinite(leftAt) || !Number.isFinite(rightAt)) {
+        return false;
+    }
+    return Math.abs(leftAt - rightAt) <= 2 * 60 * 1_000;
+}
 function normalizeClaudeComparableTitle(title) {
     return title?.trim().replace(/\s+/g, " ").toLowerCase() ?? "";
 }
@@ -1670,6 +1883,54 @@ function isMessageAtOrAfter(timestamp, minTimestamp) {
     }
     return messageAt >= minAt;
 }
+function isAcceptedUserMessageTimestamp(provider, timestamp, minTimestamp) {
+    if (provider === "kimi"
+        && isSyntheticKimiHistoryTimestamp(timestamp)) {
+        return true;
+    }
+    return isMessageAtOrAfter(timestamp, minTimestamp);
+}
+function isSyntheticKimiHistoryTimestamp(timestamp) {
+    return timestamp.startsWith("2020-01-01T00:");
+}
+function createDeliveredHistoryMessageState() {
+    return {
+        signaturesByMessageId: new Map(),
+        lastMutableTailRefreshAtMs: 0
+    };
+}
+function shouldRefreshMutableHistoryTail(provider, page, cursor, deliveredMessages) {
+    if (provider !== "kimi" || cursor === null || page.messages.length > 0) {
+        return false;
+    }
+    return Date.now() - deliveredMessages.lastMutableTailRefreshAtMs >= MUTABLE_HISTORY_TAIL_REFRESH_INTERVAL_MS;
+}
+function buildDeliveredHistoryMessageSignature(message) {
+    return hashContent(JSON.stringify({
+        provider: message.provider,
+        providerSessionId: message.providerSessionId,
+        role: message.role,
+        kind: message.kind,
+        content: message.content,
+        toolCall: message.toolCall,
+        attachments: message.attachments ?? [],
+        timestamp: message.timestamp,
+        rawRef: message.rawRef
+    }));
+}
+function rememberDeliveredHistoryMessage(state, messageId, signature) {
+    if (state.signaturesByMessageId.has(messageId)) {
+        state.signaturesByMessageId.delete(messageId);
+    }
+    state.signaturesByMessageId.set(messageId, signature);
+    while (state.signaturesByMessageId.size > 2_048) {
+        const oldestMessageId = state.signaturesByMessageId.keys().next().value;
+        if (typeof oldestMessageId !== "string") {
+            break;
+        }
+        state.signaturesByMessageId.delete(oldestMessageId);
+    }
+}
 function delay(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);