Import packages/plugin/src/session-history-cache.ts

This commit is contained in:
QQ 2026-11-14 14:57:50 +08:00
parent c15bd07a09
commit d712a47010
1 changed files with 679 additions and 0 deletions

View File

@ -0,0 +1,679 @@
import type { CodexPermissionPreset } from '@dsh-remote/protocol'
import type { AcpModelSelection } from './acp/virtual-catalog.js'
import type { AcpPermissionPreset, NativeEvent as AcpNativeEvent } from './acp/virtual-contract.js'
import type { CodexModelSelection } from './codex/virtual-catalog.js'
import type { CodexNativeHistoryPage } from './codex/virtual-history.js'
import type { HarnessSessionGeneration } from './harness-version.js'
const MAX_CACHED_SESSIONS = 32
const MAX_CACHED_RECORDS_PER_SESSION = 200
const MAX_ACP_CACHED_EVENTS_PER_SESSION = 10_000
const MAX_UNARY_PAGES_PER_SESSION = 8
const MAX_INVALIDATION_KEYS = 256
type JsonRecord = Record<string, unknown>
function isRecord(value: unknown): value is JsonRecord {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}
function cloneStructured<T>(value: T): T {
if (value === undefined || value === null || typeof value !== 'object') return value
try {
return structuredClone(value)
} catch {
return JSON.parse(JSON.stringify(value)) as T
}
}
function touchLru<K, V>(map: Map<K, V>, key: K, value: V, maxEntries: number): void {
map.delete(key)
map.set(key, value)
while (map.size > maxEntries) {
const oldest = map.keys().next().value
if (oldest === undefined) break
map.delete(oldest)
}
}
interface SharedInFlightEntry<T> {
client?: object
controller: AbortController
waiters: number
settled: boolean
promise: Promise<T>
}
function attachSharedInFlight<T>(
entry: SharedInFlightEntry<T>,
signal?: AbortSignal,
): Promise<T> {
if (signal?.aborted) {
return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'))
}
entry.waiters += 1
return new Promise<T>((resolve, reject) => {
let finished = false
const onAbort = () => {
if (finished) return
finished = true
entry.waiters = Math.max(0, entry.waiters - 1)
if (entry.waiters === 0 && !entry.settled) {
entry.controller.abort(signal?.reason)
}
reject(signal?.reason ?? new DOMException('The operation was aborted.', 'AbortError'))
}
signal?.addEventListener('abort', onAbort, { once: true })
entry.promise.then(
value => {
if (finished) return
finished = true
signal?.removeEventListener('abort', onAbort)
resolve(cloneStructured(value))
},
error => {
if (finished) return
finished = true
signal?.removeEventListener('abort', onAbort)
reject(error)
},
)
})
}
export function extractSessionIdFromGatewayPayload(payload: unknown): string | undefined {
if (!isRecord(payload)) return undefined
const args = isRecord(payload.args) ? payload.args : payload
const request = isRecord(args.request)
? args.request
: isRecord(args._request)
? args._request
: args
if (typeof request.sessionId === 'string' && request.sessionId.length > 0) return request.sessionId
if (typeof request.agentId === 'string' && request.agentId.length > 0) return request.agentId
if (isRecord(request.address)) {
const address = request.address
if (typeof address.sessionId === 'string' && address.sessionId.length > 0) return address.sessionId
if (typeof address.childSessionId === 'string' && address.childSessionId.length > 0) return address.childSessionId
}
return undefined
}
export function isSessionMutationEndpoint(endpoint: string): boolean {
return endpoint === 'session/prompt'
|| endpoint === 'session/cancel'
|| endpoint === 'session/rename'
|| endpoint === 'session/selectModel'
|| endpoint === 'session/selectPermission'
|| endpoint === 'session/fork'
|| endpoint === 'agentPresets/select'
|| endpoint === 'commands/execute'
|| endpoint === 'workspace/archiveSession'
}
export function canonicalUnaryHistoryKey(endpoint: string, payload: unknown): string {
if (!isRecord(payload)) return endpoint
const args = isRecord(payload.args) ? payload.args : payload
const request = isRecord(args.request)
? args.request
: isRecord(args._request)
? args._request
: args
return JSON.stringify([
endpoint,
typeof request.beforeSeq === 'number' ? request.beforeSeq : null,
typeof request.throughSeq === 'number' ? request.throughSeq : null,
typeof request.maxMessages === 'number' ? request.maxMessages : typeof request.limit === 'number' ? request.limit : null,
request.turnWindow ?? null,
])
}
interface CachedRemoteSessionEntry {
client?: object
snapshot?: JsonRecord
unary: Map<string, { client: object; value: unknown }>
}
/**
* Bounded LRU cache for Native Harness session follow snapshots and unary
* history/page/projection reads across project and session switches.
*/
export class RemoteSessionHistoryCache {
private readonly sessions = new Map<string, CachedRemoteSessionEntry>()
private readonly pendingUnary = new Map<string, SharedInFlightEntry<unknown>>()
private readonly invalidatedAt = new Map<string, number>()
private epoch = 0
private minValidEpoch = 0
beginReadEpoch(): number {
return ++this.epoch
}
isReadEpochValid(sessionId: string, readEpoch: number): boolean {
return readEpoch > this.minValidEpoch && readEpoch > (this.invalidatedAt.get(sessionId) ?? 0)
}
getFollowSnapshot(
client: object,
sessionId: string,
): { snapshot: JsonRecord; sameClient: boolean; cursor: number } | undefined {
const entry = this.sessions.get(sessionId)
if (entry?.snapshot === undefined) return undefined
touchLru(this.sessions, sessionId, entry, MAX_CACHED_SESSIONS)
const snapshot = cloneStructured(entry.snapshot)
const cursor = typeof snapshot.cursor === 'number' ? snapshot.cursor : -1
return {
snapshot: {
...snapshot,
...(isRecord(snapshot.assistantStream) ? { assistantStream: { ...snapshot.assistantStream, revision: 0 } } : {}),
},
sameClient: entry.client === client,
cursor,
}
}
recordFollowSnapshot(client: object, sessionId: string, frame: unknown): void {
if (!isRecord(frame) || frame.type !== 'snapshot') return
const id = sessionId.length > 0
? sessionId
: isRecord(frame.header) && typeof frame.header.id === 'string'
? frame.header.id
: ''
if (id.length === 0) return
const existing: CachedRemoteSessionEntry = this.sessions.get(id) ?? { unary: new Map() }
const cloned = cloneStructured(frame)
if (Array.isArray(cloned.records) && cloned.records.length > MAX_CACHED_RECORDS_PER_SESSION) {
cloned.records = cloned.records.slice(cloned.records.length - MAX_CACHED_RECORDS_PER_SESSION)
cloned.hasMore = true
}
this.invalidateUnary(id, existing)
existing.client = client
existing.snapshot = cloned
touchLru(this.sessions, id, existing, MAX_CACHED_SESSIONS)
}
prependBackfilledRecords(client: object, sessionId: string, backfilled: unknown[]): void {
const entry = this.sessions.get(sessionId)
if (entry === undefined || entry.client !== client || entry.snapshot === undefined || !Array.isArray(entry.snapshot.records)) return
const bySeq = new Map<number, unknown>()
for (const item of [...backfilled, ...entry.snapshot.records]) {
if (isRecord(item) && isRecord(item.event) && typeof item.event.seq === 'number') {
bySeq.set(item.event.seq, cloneStructured(item))
}
}
const sortedEntries = [...bySeq.entries()].sort((a, b) => a[0] - b[0])
const merged = sortedEntries.map(([, item]) => item)
if (merged.length > MAX_CACHED_RECORDS_PER_SESSION) {
entry.snapshot.records = merged.slice(merged.length - MAX_CACHED_RECORDS_PER_SESSION)
entry.snapshot.hasMore = true
} else {
entry.snapshot.records = merged
}
const highestSeq = sortedEntries.at(-1)?.[0]
const currentCursor = typeof entry.snapshot.cursor === 'number' ? entry.snapshot.cursor : -1
if (highestSeq !== undefined && highestSeq > currentCursor) {
entry.snapshot.cursor = highestSeq
}
this.invalidateUnary(sessionId, entry)
}
recordFollowFrame(client: object, sessionId: string, frame: unknown): void {
if (sessionId.length === 0 || !isRecord(frame)) return
const entry = this.sessions.get(sessionId)
if (entry === undefined || entry.client !== client || entry.snapshot === undefined) return
if (frame.type === 'event' && isRecord(frame.event) && typeof frame.event.seq === 'number') {
const seq = frame.event.seq
const currentCursor = typeof entry.snapshot.cursor === 'number' ? entry.snapshot.cursor : -1
if (seq <= currentCursor) return
if (seq === currentCursor + 1 && Array.isArray(entry.snapshot.records)) {
const records = [...entry.snapshot.records, cloneStructured(frame)]
if (records.length > MAX_CACHED_RECORDS_PER_SESSION) {
entry.snapshot.records = records.slice(records.length - MAX_CACHED_RECORDS_PER_SESSION)
entry.snapshot.hasMore = true
} else {
entry.snapshot.records = records
}
entry.snapshot.cursor = seq
this.invalidateUnary(sessionId, entry)
touchLru(this.sessions, sessionId, entry, MAX_CACHED_SESSIONS)
}
return
}
if (frame.type === 'projection' && typeof frame.key === 'string') {
const projections = isRecord(entry.snapshot.projections) ? entry.snapshot.projections : undefined
if (projections !== undefined && isRecord(projections.values)) {
projections.values[frame.key] = cloneStructured(frame.value)
if (typeof frame.seq === 'number' && typeof projections.asOfSeq === 'number' && frame.seq > projections.asOfSeq) {
projections.asOfSeq = frame.seq
}
}
this.invalidateUnary(sessionId, entry)
}
}
private invalidateUnary(sessionId: string, entry?: CachedRemoteSessionEntry): void {
const invalidationEpoch = ++this.epoch
this.invalidatedAt.delete(sessionId)
this.invalidatedAt.set(sessionId, invalidationEpoch)
while (this.invalidatedAt.size > MAX_INVALIDATION_KEYS) {
const oldestKey = this.invalidatedAt.keys().next().value
if (oldestKey === undefined) break
const oldestEpoch = this.invalidatedAt.get(oldestKey) ?? 0
this.minValidEpoch = Math.max(this.minValidEpoch, oldestEpoch)
this.invalidatedAt.delete(oldestKey)
}
entry?.unary.clear()
for (const [key, pending] of this.pendingUnary.entries()) {
if (key.startsWith(`${sessionId}:`)) {
pending.settled = true
this.pendingUnary.delete(key)
}
}
}
getUnary(client: object, sessionId: string, key: string): unknown | undefined {
const entry = this.sessions.get(sessionId)
if (entry === undefined || entry.client !== client) return undefined
const cached = entry.unary.get(key)
if (cached === undefined || cached.client !== client) return undefined
touchLru(entry.unary, key, cached, MAX_UNARY_PAGES_PER_SESSION)
touchLru(this.sessions, sessionId, entry, MAX_CACHED_SESSIONS)
return cloneStructured(cached.value)
}
setUnary(client: object, sessionId: string, key: string, value: unknown, readEpoch?: number): void {
if (readEpoch !== undefined && !this.isReadEpochValid(sessionId, readEpoch)) return
const existing = this.sessions.get(sessionId)
const entry: CachedRemoteSessionEntry = existing ?? { unary: new Map() }
if (entry.client !== undefined && entry.client !== client) {
entry.unary.clear()
}
entry.client = client
touchLru(entry.unary, key, { client, value: cloneStructured(value) }, MAX_UNARY_PAGES_PER_SESSION)
touchLru(this.sessions, sessionId, entry, MAX_CACHED_SESSIONS)
}
getFallbackUnary(sessionId: string, endpoint: string, key: string, payload: unknown): unknown | undefined {
const entry = this.sessions.get(sessionId)
if (entry === undefined) return undefined
const exact = entry.unary.get(key)
if (exact !== undefined) return cloneStructured(exact.value)
if (entry.snapshot === undefined) return undefined
const snapshot = entry.snapshot
if (endpoint === 'session/projections') {
return snapshot.projections !== undefined ? cloneStructured(snapshot.projections) : undefined
}
if (endpoint === 'session/history' && Array.isArray(snapshot.records)) {
return {
records: cloneStructured(snapshot.records),
hasMore: Boolean(snapshot.hasMore),
...(typeof snapshot.cursor === 'number' ? { throughSeq: snapshot.cursor, cursor: snapshot.cursor } : {}),
...(snapshot.projections === undefined ? {} : { projections: cloneStructured(snapshot.projections) }),
}
}
if (endpoint === 'session/page') {
return this.sliceSnapshotRecords(snapshot, payload)
}
return undefined
}
slicePageFromSnapshot(client: object, sessionId: string, payload: unknown): unknown | undefined {
const entry = this.sessions.get(sessionId)
if (entry === undefined || entry.client !== client || entry.snapshot === undefined) return undefined
if (entry.snapshot.hasMore === true) return undefined
return this.sliceSnapshotRecords(entry.snapshot, payload)
}
private sliceSnapshotRecords(snapshot: JsonRecord, payload: unknown): unknown | undefined {
if (!Array.isArray(snapshot.records)) return undefined
const args = isRecord(payload) && isRecord(payload.args) ? payload.args : isRecord(payload) ? payload : {}
const request = isRecord(args.request)
? args.request
: isRecord(args._request)
? args._request
: args
if (request.turnWindow !== undefined) return undefined
const snapshotCursor = typeof snapshot.cursor === 'number' ? snapshot.cursor : -1
const throughSeq = typeof request.throughSeq === 'number' ? request.throughSeq : snapshotCursor
if (throughSeq > snapshotCursor) return undefined
const beforeSeq = typeof request.beforeSeq === 'number' ? request.beforeSeq : undefined
const endSeq = beforeSeq === undefined ? throughSeq : Math.min(throughSeq, beforeSeq - 1)
const window = endSeq < 0
? []
: snapshot.records.filter(item => isRecord(item) && isRecord(item.event) && typeof item.event.seq === 'number' && item.event.seq <= endSeq)
if (throughSeq >= 0 && beforeSeq === undefined && window.length > 0) {
const tail = window.at(-1)
if (!isRecord(tail) || !isRecord(tail.event) || tail.event.seq !== throughSeq) return undefined
}
const maxMessages = typeof request.maxMessages === 'number' && request.maxMessages > 0
? request.maxMessages
: typeof request.limit === 'number' && request.limit > 0
? request.limit
: undefined
const records = maxMessages === undefined
? window
: window.slice(Math.max(0, window.length - maxMessages))
const hasMore = Boolean(snapshot.hasMore) || window.length > records.length
return cloneStructured({
records,
hasMore,
...(typeof snapshot.cursor === 'number' ? { cursor: snapshot.cursor } : {}),
})
}
runSingleFlightUnary<T>(
client: object,
sessionId: string,
key: string,
signal: AbortSignal,
factory: (sharedSignal: AbortSignal) => Promise<T>,
): Promise<T> {
if (signal.aborted) {
return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'))
}
const composite = `${sessionId}:${key}`
const existing = this.pendingUnary.get(composite)
if (existing !== undefined && existing.client === client && !existing.settled) {
return attachSharedInFlight(existing as SharedInFlightEntry<T>, signal)
}
const controller = new AbortController()
const entry: SharedInFlightEntry<T> = {
client,
controller,
waiters: 0,
settled: false,
promise: Promise.resolve() as unknown as Promise<T>,
}
entry.promise = factory(controller.signal).finally(() => {
entry.settled = true
if (this.pendingUnary.get(composite) === entry) {
this.pendingUnary.delete(composite)
}
})
void entry.promise.catch(() => undefined)
this.pendingUnary.set(composite, entry as SharedInFlightEntry<unknown>)
return attachSharedInFlight(entry, signal)
}
invalidateSession(sessionId: string): void {
const invalidationEpoch = ++this.epoch
this.invalidatedAt.delete(sessionId)
this.invalidatedAt.set(sessionId, invalidationEpoch)
while (this.invalidatedAt.size > MAX_INVALIDATION_KEYS) {
const oldestKey = this.invalidatedAt.keys().next().value
if (oldestKey === undefined) break
const oldestEpoch = this.invalidatedAt.get(oldestKey) ?? 0
this.minValidEpoch = Math.max(this.minValidEpoch, oldestEpoch)
this.invalidatedAt.delete(oldestKey)
}
const entry = this.sessions.get(sessionId)
if (entry !== undefined) {
entry.unary.clear()
entry.snapshot = undefined
this.sessions.delete(sessionId)
}
for (const [key, pending] of this.pendingUnary.entries()) {
if (key.startsWith(`${sessionId}:`)) {
pending.settled = true
this.pendingUnary.delete(key)
}
}
}
clear(): void {
this.minValidEpoch = ++this.epoch
this.invalidatedAt.clear()
this.sessions.clear()
for (const pending of this.pendingUnary.values()) {
pending.settled = true
}
this.pendingUnary.clear()
}
}
interface CachedCodexThreadHistory {
updatedAt?: number
stale: boolean
pages: Map<string, CodexNativeHistoryPage>
tailPage?: CodexNativeHistoryPage
selectedModel?: CodexModelSelection
permissionPreset?: CodexPermissionPreset
}
/**
* Bounded LRU cache for Codex virtual session history pages across project
* and session switches on the same remote Host.
*/
export class CodexSessionHistoryCache {
private readonly threads = new Map<string, CachedCodexThreadHistory>()
private readonly pendingPages = new Map<string, SharedInFlightEntry<CodexNativeHistoryPage>>()
private readonly invalidatedAt = new Map<string, number>()
private epoch = 0
private minValidEpoch = 0
static pageKey(
generation: HarnessSessionGeneration,
page: { beforeSeq?: number; throughSeq?: number; maxMessages?: number },
): string {
return JSON.stringify([
generation,
page.beforeSeq ?? null,
page.throughSeq ?? null,
page.maxMessages ?? null,
])
}
beginReadEpoch(): number {
return ++this.epoch
}
isReadEpochValid(threadId: string, readEpoch: number): boolean {
return readEpoch > this.minValidEpoch && readEpoch > (this.invalidatedAt.get(threadId) ?? 0)
}
getFreshPage(
threadId: string,
generation: HarnessSessionGeneration,
page: { beforeSeq?: number; throughSeq?: number; maxMessages?: number },
knownUpdatedAt?: number,
): CodexNativeHistoryPage | undefined {
const entry = this.threads.get(threadId)
if (entry === undefined || entry.stale) return undefined
if (knownUpdatedAt !== undefined && entry.updatedAt !== undefined && knownUpdatedAt > entry.updatedAt) {
entry.stale = true
return undefined
}
const key = CodexSessionHistoryCache.pageKey(generation, page)
const cached = entry.pages.get(key)
if (cached === undefined) return undefined
touchLru(entry.pages, key, cached, MAX_UNARY_PAGES_PER_SESSION)
touchLru(this.threads, threadId, entry, MAX_CACHED_SESSIONS)
return cloneStructured(cached)
}
getFreshTailCursor(
threadId: string,
generation: HarnessSessionGeneration,
knownUpdatedAt?: number,
): number | undefined {
const entry = this.threads.get(threadId)
if (entry === undefined || entry.stale || entry.tailPage === undefined) return undefined
if (knownUpdatedAt !== undefined && entry.updatedAt !== undefined && knownUpdatedAt > entry.updatedAt) {
entry.stale = true
return undefined
}
if ((entry.tailPage.header.version === 3 ? 'v3' : 'legacy') !== generation) return undefined
touchLru(this.threads, threadId, entry, MAX_CACHED_SESSIONS)
return entry.tailPage.cursor
}
getStalePage(
threadId: string,
generation: HarnessSessionGeneration,
page: { beforeSeq?: number; throughSeq?: number; maxMessages?: number },
): CodexNativeHistoryPage | undefined {
const entry = this.threads.get(threadId)
if (entry === undefined) return undefined
const key = CodexSessionHistoryCache.pageKey(generation, page)
const cached = entry.pages.get(key)
return cached === undefined ? undefined : cloneStructured(cached)
}
setPage(
threadId: string,
generation: HarnessSessionGeneration,
page: { beforeSeq?: number; throughSeq?: number; maxMessages?: number },
value: CodexNativeHistoryPage,
knownUpdatedAt?: number,
readEpoch?: number,
): void {
if (readEpoch !== undefined && !this.isReadEpochValid(threadId, readEpoch)) return
const existing = this.threads.get(threadId)
const entry: CachedCodexThreadHistory = existing ?? { stale: false, pages: new Map() }
if (entry.stale) {
entry.pages.clear()
entry.tailPage = undefined
entry.stale = false
}
if (knownUpdatedAt !== undefined) {
entry.updatedAt = knownUpdatedAt
}
const cloned = cloneStructured(value)
const key = CodexSessionHistoryCache.pageKey(generation, page)
touchLru(entry.pages, key, cloned, MAX_UNARY_PAGES_PER_SESSION)
if (page.beforeSeq === undefined && page.throughSeq === undefined) {
entry.tailPage = cloned
}
touchLru(this.threads, threadId, entry, MAX_CACHED_SESSIONS)
}
runSingleFlightPage(
threadId: string,
generation: HarnessSessionGeneration,
page: { beforeSeq?: number; throughSeq?: number; maxMessages?: number },
signal: AbortSignal | undefined,
factory: (sharedSignal: AbortSignal) => Promise<CodexNativeHistoryPage>,
): Promise<CodexNativeHistoryPage> {
if (signal?.aborted) {
return Promise.reject(signal.reason ?? new DOMException('The operation was aborted.', 'AbortError'))
}
const composite = `${threadId}:${CodexSessionHistoryCache.pageKey(generation, page)}`
const existing = this.pendingPages.get(composite)
if (existing !== undefined && !existing.settled) {
return attachSharedInFlight(existing, signal)
}
const controller = new AbortController()
const entry: SharedInFlightEntry<CodexNativeHistoryPage> = {
controller,
waiters: 0,
settled: false,
promise: Promise.resolve() as unknown as Promise<CodexNativeHistoryPage>,
}
entry.promise = factory(controller.signal).finally(() => {
entry.settled = true
if (this.pendingPages.get(composite) === entry) {
this.pendingPages.delete(composite)
}
})
void entry.promise.catch(() => undefined)
this.pendingPages.set(composite, entry)
return attachSharedInFlight(entry, signal)
}
invalidateThread(threadId: string): void {
const invalidationEpoch = ++this.epoch
this.invalidatedAt.delete(threadId)
this.invalidatedAt.set(threadId, invalidationEpoch)
while (this.invalidatedAt.size > MAX_INVALIDATION_KEYS) {
const oldestKey = this.invalidatedAt.keys().next().value
if (oldestKey === undefined) break
const oldestEpoch = this.invalidatedAt.get(oldestKey) ?? 0
this.minValidEpoch = Math.max(this.minValidEpoch, oldestEpoch)
this.invalidatedAt.delete(oldestKey)
}
const entry = this.threads.get(threadId)
if (entry !== undefined) {
entry.stale = true
}
for (const [key, pending] of this.pendingPages.entries()) {
if (key.startsWith(`${threadId}:`)) {
pending.settled = true
this.pendingPages.delete(key)
}
}
}
removeThread(threadId: string): void {
this.invalidateThread(threadId)
this.threads.delete(threadId)
}
clear(): void {
this.minValidEpoch = ++this.epoch
this.invalidatedAt.clear()
this.threads.clear()
for (const pending of this.pendingPages.values()) {
pending.settled = true
}
this.pendingPages.clear()
}
}
export interface CachedAcpSessionHistory {
events: Array<{ type: 'event'; event: AcpNativeEvent }>
blank: boolean
hydrated: boolean
stale?: boolean
truncated?: boolean
title?: string
titleOverridden?: boolean
titleFromPrompt?: boolean
hostUpdatedAt: number
selectedModel?: AcpModelSelection
permissionPreset?: AcpPermissionPreset
}
/**
* Bounded LRU cache for ACP virtual session histories (Claude, Hermes,
* OpenCode, Pi, Antigravity, Cursor) across project switches.
*/
export class AcpSessionHistoryCache {
private readonly sessions = new Map<string, CachedAcpSessionHistory>()
getFresh(sessionId: string): CachedAcpSessionHistory | undefined {
const entry = this.sessions.get(sessionId)
if (entry === undefined || entry.stale || entry.truncated || !entry.hydrated || entry.events.length === 0) return undefined
touchLru(this.sessions, sessionId, entry, MAX_CACHED_SESSIONS)
return cloneStructured(entry)
}
getStale(sessionId: string): CachedAcpSessionHistory | undefined {
const entry = this.sessions.get(sessionId)
if (entry === undefined) return undefined
return cloneStructured(entry)
}
set(sessionId: string, value: CachedAcpSessionHistory): void {
const cloned = cloneStructured(value)
if (cloned.events.length > MAX_ACP_CACHED_EVENTS_PER_SESSION) {
cloned.events = cloned.events.slice(cloned.events.length - MAX_ACP_CACHED_EVENTS_PER_SESSION)
cloned.truncated = true
}
touchLru(this.sessions, sessionId, cloned, MAX_CACHED_SESSIONS)
}
markStale(sessionId: string): void {
const entry = this.sessions.get(sessionId)
if (entry !== undefined) {
entry.stale = true
}
}
delete(sessionId: string): void {
this.sessions.delete(sessionId)
}
clear(): void {
this.sessions.clear()
}
}