typeof import("../../session-write-lock.js").acquireSessionWriteLock;

type ShouldPreemptivelyCompactBeforePromptFn =

typeof import("./preemptive-compaction.js").shouldPreemptivelyCompactBeforePrompt;

type WaitForCompactionRetryWithAggregateTimeoutFn =

typeof import("./compaction-retry-aggregate-timeout.js").waitForCompactionRetryWithAggregateTimeout;

type SubscriptionMock = ReturnType<SubscribeEmbeddedPiSessionFn>;

type UnknownMock = Mock<(...args: unknown[]) => unknown>;

(sessionKey: string | undefined, config: unknown) => number | undefined

>;

limitHistoryTurnsMock: Mock<<T>(messages: T, limit: number | undefined) => T>;

waitForCompactionRetryWithAggregateTimeoutMock: Mock<WaitForCompactionRetryWithAggregateTimeoutFn>;

preemptiveCompactionCalls: Parameters<ShouldPreemptivelyCompactBeforePromptFn>[0][];

systemPromptOverrideTexts: string[];

sessionManager: SessionManagerMocks;

const limitHistoryTurnsMock = vi.fn<<T>(messages: T, limit: number | undefined) => T>(

(messages) => messages,

);

const waitForCompactionRetryWithAggregateTimeoutMock =

vi.fn<WaitForCompactionRetryWithAggregateTimeoutFn>(async () => ({

timedOut: false,

}));

const preemptiveCompactionCalls: Parameters<ShouldPreemptivelyCompactBeforePromptFn>[0][] = [];

const systemPromptOverrideTexts: string[] = [];

const sessionManager = {

detectAndLoadPromptImagesMock,

getHistoryLimitFromSessionKeyMock,

limitHistoryTurnsMock,

waitForCompactionRetryWithAggregateTimeoutMock,

preemptiveCompactionCalls,

systemPromptOverrideTexts,

sessionManager,

}));

vi.mock("./compaction-retry-aggregate-timeout.js", () => ({

waitForCompactionRetryWithAggregateTimeout: async () => ({

timedOut: false,

aborted: false,

}),

waitForCompactionRetryWithAggregateTimeout: (

...args: Parameters<WaitForCompactionRetryWithAggregateTimeoutFn>

) => hoisted.waitForCompactionRetryWithAggregateTimeoutMock(...args),

}));

vi.mock("./compaction-timeout.js", () => ({

hoisted.runContextEngineMaintenanceMock.mockReset().mockResolvedValue(undefined);

hoisted.getHistoryLimitFromSessionKeyMock.mockReset().mockReturnValue(undefined);

hoisted.limitHistoryTurnsMock.mockReset().mockImplementation((messages) => messages);

hoisted.waitForCompactionRetryWithAggregateTimeoutMock

.mockReset()

.mockResolvedValue({ timedOut: false });

hoisted.preemptiveCompactionCalls.length = 0;

hoisted.systemPromptOverrideTexts.length = 0;

hoisted.sessionManager.getLeafEntry.mockReset().mockReturnValue(null);