Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
import { act, renderHook, waitFor } from "@testing-library/react";
import type { ReactNode } from "react";
import { beforeEach, describe, expect, it, vi } from "vitest";
import { useSessionHistory, useSessions } from "@/hooks/useSessions";
import * as api from "@/lib/api";
import { webuiThreadCache } from "@/lib/webui-thread-cache";
import { activateReloadCache, clearReloadCache, writeReloadCache } from "@/lib/reload-cache";
import { ClientProvider } from "@/providers/ClientProvider";
import { canonicalThreadPayload } from "./thread-test-payload";
vi.mock("@/lib/api", async (importOriginal) => {
const actual = await importOriginal<typeof import("@/lib/api")>();
return {
...actual,
listSessions: vi.fn(),
deleteSession: vi.fn(),
fetchWebuiThread: vi.fn(),
};
});
function fakeClient() {
const sessionUpdateHandlers = new Set<(chatId: string, scope?: string) => void>();
return {
status: "open" as const,
defaultChatId: null as string | null,
onStatus: () => () => {},
onRunCompletion: () => () => {},
onError: () => () => {},
onChat: () => () => {},
getRunStartedAt: () => null,
onSessionUpdate: (handler: (chatId: string, scope?: string) => void) => {
sessionUpdateHandlers.add(handler);
return () => sessionUpdateHandlers.delete(handler);
},
emitSessionUpdate: (chatId: string, scope?: string) => {
for (const handler of sessionUpdateHandlers) handler(chatId, scope);
},
sendMessage: vi.fn(),
newChat: vi.fn(),
forkChat: vi.fn(),
attach: vi.fn(),
connect: vi.fn(),
close: vi.fn(),
updateUrl: vi.fn(),
};
}
function wrap(
client: ReturnType<typeof fakeClient>,
tokenSource: string | { current: string } = "tok",
) {
return function Wrapper({ children }: { children: ReactNode }) {
const token = typeof tokenSource === "string" ? tokenSource : tokenSource.current;
return (
<ClientProvider
client={client as unknown as import("@/lib/nanobot-client").NanobotClient}
token={token}
>
{children}
</ClientProvider>
);
};
}
describe("useSessions", () => {
it("distinguishes initial loading from revalidating a successfully loaded empty list", async () => {
let finish!: (rows: Awaited<ReturnType<typeof api.listSessions>>) => void;
vi.mocked(api.listSessions).mockImplementation(() => new Promise((resolve) => { finish = resolve; }));
const { result } = renderHook(() => useSessions(), { wrapper: wrap(fakeClient()) });
expect(result.current.initialLoading).toBe(true);
await act(async () => finish([]));
expect(result.current.initialLoading).toBe(false);
let refresh!: Promise<void>;
act(() => { refresh = result.current.refresh(); });
expect(result.current.loading).toBe(true);
expect(result.current.initialLoading).toBe(false);
await act(async () => { finish([]); await refresh; });
});
it("shows tab-cached sessions while revalidating and removes server-deleted rows", async () => {
activateReloadCache("ws://localhost:8765/");
writeReloadCache("sessions", [{
key: "websocket:cached", channel: "websocket", chatId: "cached", preview: "Saved answer",
createdAt: null, updatedAt: null,
}]);
let finish!: (rows: Awaited<ReturnType<typeof api.listSessions>>) => void;
vi.mocked(api.listSessions).mockImplementation(() => new Promise((resolve) => { finish = resolve; }));
const { result, unmount } = renderHook(() => useSessions(), { wrapper: wrap(fakeClient()) });
try {
expect(result.current.sessions[0]?.key).toBe("websocket:cached");
expect(result.current.loading).toBe(true);
expect(result.current.initialLoading).toBe(false);
await act(async () => finish([]));
expect(result.current.sessions).toEqual([]);
expect(result.current.loading).toBe(false);
} finally {
unmount();
clearReloadCache();
}
});
it("coalesces a burst across tasks and preserves unchanged session identities", async () => {
const row = { key: "websocket:burst", channel: "websocket", chatId: "burst",
createdAt: "2026-09-08", updatedAt: "2026-09-08", preview: "Stable" };
vi.mocked(api.listSessions).mockImplementation(async () => [{ ...row }]);
const client = fakeClient();
const { result, unmount } = renderHook(() => useSessions(), { wrapper: wrap(client) });
await waitFor(() => expect(result.current.sessions).toHaveLength(1));
const original = result.current.sessions;
vi.useFakeTimers();
try {
for (let index = 0; index < 20; index++) {
await act(async () => {
client.emitSessionUpdate("burst");
await vi.advanceTimersByTimeAsync(10);
});
}
expect(api.listSessions).toHaveBeenCalledTimes(1);
await act(async () => { await vi.advanceTimersByTimeAsync(50); });
expect(api.listSessions).toHaveBeenCalledTimes(2);
expect(result.current.sessions).toBe(original);
client.emitSessionUpdate("burst");
unmount();
await vi.advanceTimersByTimeAsync(250);
expect(api.listSessions).toHaveBeenCalledTimes(2);
} finally {
vi.useRealTimers();
}
});
beforeEach(() => {
vi.mocked(api.listSessions).mockReset();
vi.mocked(api.deleteSession).mockReset();
vi.mocked(api.fetchWebuiThread).mockReset();
webuiThreadCache.clear();
});
it("removes a session from the local list after delete succeeds", async () => {
vi.mocked(api.listSessions).mockResolvedValue([
{
key: "websocket:chat-a",
channel: "websocket",
chatId: "chat-a",
createdAt: "2026-04-16T10:00:00Z",
updatedAt: "2026-04-16T10:00:00Z",
preview: "Alpha",
},
{
key: "websocket:chat-b",
channel: "websocket",
chatId: "chat-b",
createdAt: "2026-04-16T11:00:00Z",
updatedAt: "2026-04-16T11:00:00Z",
preview: "Beta",
},
]);
vi.mocked(api.deleteSession).mockResolvedValue({ deleted: true });
const client = fakeClient();
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.sessions).toHaveLength(2));
await act(async () => {
await result.current.deleteChat("websocket:chat-a");
});
expect(api.deleteSession).toHaveBeenCalledWith(client, "websocket:chat-a", undefined);
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-b"]);
});
it("removes an optimistic chat when the gateway no longer has its draft", async () => {
vi.mocked(api.listSessions).mockResolvedValue([]);
vi.mocked(api.deleteSession).mockResolvedValue({ deleted: false });
const client = fakeClient();
client.newChat.mockResolvedValue("chat-empty");
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.createChat();
});
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-empty"]);
let deleteResult: Awaited<ReturnType<typeof result.current.deleteChat>> | undefined;
await act(async () => {
deleteResult = await result.current.deleteChat("websocket:chat-empty");
});
expect(deleteResult?.deleted).toBe(true);
expect(result.current.sessions).toEqual([]);
});
it("keeps an optimistic chat when delete is blocked by bound automations", async () => {
vi.mocked(api.listSessions).mockResolvedValue([]);
vi.mocked(api.deleteSession).mockResolvedValue({
deleted: false,
blocked_by_automations: true,
automations: [],
});
const client = fakeClient();
client.newChat.mockResolvedValue("chat-empty");
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.createChat();
});
let deleteResult: Awaited<ReturnType<typeof result.current.deleteChat>> | undefined;
await act(async () => {
deleteResult = await result.current.deleteChat("websocket:chat-empty");
});
expect(deleteResult?.blocked_by_automations).toBe(true);
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-empty"]);
});
it("keeps a session when delete is blocked by bound automations", async () => {
vi.mocked(api.listSessions).mockResolvedValue([
{
key: "websocket:chat-a",
channel: "websocket",
chatId: "chat-a",
createdAt: "2026-04-16T10:00:00Z",
updatedAt: "2026-04-16T10:00:00Z",
preview: "Alpha",
},
]);
vi.mocked(api.deleteSession).mockResolvedValue({
deleted: false,
blocked_by_automations: true,
automations: [],
});
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.sessions).toHaveLength(1));
let deleteResult: Awaited<ReturnType<typeof result.current.deleteChat>> | undefined;
await act(async () => {
deleteResult = await result.current.deleteChat("websocket:chat-a");
});
expect(deleteResult?.blocked_by_automations).toBe(true);
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-a"]);
});
it("locks a draft project when a session update reports it persisted", async () => {
vi.mocked(api.listSessions)
.mockResolvedValueOnce([])
.mockResolvedValueOnce([
{
key: "websocket:chat-a",
channel: "websocket",
chatId: "chat-a",
createdAt: "2026-04-16T10:00:00Z",
updatedAt: "2026-04-16T10:01:00Z",
title: "生成的小标题",
preview: "用户第一句话",
projectLocked: true,
},
]);
const client = fakeClient();
client.newChat.mockResolvedValue("chat-a");
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => { await result.current.createChat(); });
expect(result.current.sessions[0].projectLocked).toBe(false);
act(() => {
client.emitSessionUpdate("chat-a", "metadata");
});
await waitFor(() => expect(result.current.sessions[0]?.title).toBe("生成的小标题"));
expect(result.current.sessions[0].projectLocked).toBe(true);
expect(api.listSessions).toHaveBeenCalledTimes(2);
});
it("coalesces a same-task burst of session updates into one refresh", async () => {
vi.mocked(api.listSessions).mockResolvedValue([]);
const client = fakeClient();
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(api.listSessions).toHaveBeenCalledTimes(1);
await act(async () => {
client.emitSessionUpdate("chat-a", "metadata");
client.emitSessionUpdate("chat-a", "thread");
client.emitSessionUpdate("chat-b", "metadata");
await Promise.resolve();
});
await waitFor(() => expect(api.listSessions).toHaveBeenCalledTimes(2));
expect(result.current.loading).toBe(false);
});
it("runs one trailing refresh when an update arrives during a session request", async () => {
let resolveInFlight!: (rows: []) => void;
vi.mocked(api.listSessions)
.mockResolvedValueOnce([])
.mockImplementationOnce(() => new Promise((resolve) => {
resolveInFlight = resolve;
}))
.mockResolvedValueOnce([
{
key: "websocket:chat-a",
channel: "websocket",
chatId: "chat-a",
createdAt: "2026-04-16T10:00:00Z",
updatedAt: "2026-04-16T10:01:00Z",
title: "Latest title",
preview: "Latest preview",
},
]);
const client = fakeClient();
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
client.emitSessionUpdate("chat-a", "metadata");
await Promise.resolve();
});
await waitFor(() => expect(api.listSessions).toHaveBeenCalledTimes(2));
await act(async () => {
client.emitSessionUpdate("chat-a", "thread");
await Promise.resolve();
});
expect(api.listSessions).toHaveBeenCalledTimes(2);
await act(async () => {
resolveInFlight([]);
await Promise.resolve();
});
await waitFor(() => expect(api.listSessions).toHaveBeenCalledTimes(3));
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.sessions[0]?.title).toBe("Latest title");
});
it("keeps a newly created chat visible until the server session list catches up", async () => {
vi.mocked(api.listSessions)
.mockResolvedValueOnce([])
.mockResolvedValueOnce([])
.mockResolvedValueOnce([
{
key: "websocket:chat-new",
channel: "websocket",
chatId: "chat-new",
createdAt: "2026-05-20T10:00:00Z",
updatedAt: "2026-05-20T10:01:00Z",
title: "Generated title",
preview: "First message",
},
]);
const client = fakeClient();
client.newChat.mockResolvedValue("chat-new");
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.sessions).toEqual([]);
await act(async () => {
await result.current.createChat();
});
expect(client.newChat).toHaveBeenCalledWith(60_000, undefined);
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-new"]);
await act(async () => {
await result.current.refresh();
});
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-new"]);
expect(result.current.sessions[0]?.preview).toBe("");
await act(async () => {
await result.current.refresh();
});
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-new"]);
expect(result.current.sessions[0]?.preview).toBe("First message");
expect(result.current.sessions[0]?.title).toBe("Generated title");
});
it("stores optimistic workspace scope when creating a chat", async () => {
vi.mocked(api.listSessions).mockResolvedValue([]);
const client = fakeClient();
client.newChat.mockResolvedValue("chat-workspace");
const workspaceScope = {
project_path: "/tmp/project",
project_name: "project",
access_mode: "restricted" as const,
restrict_to_workspace: true,
};
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.createChat(workspaceScope);
});
expect(client.newChat).toHaveBeenCalledWith(60_000, workspaceScope);
expect(result.current.sessions[0]?.workspaceScope).toEqual(workspaceScope);
});
it("stores an optimistic model preset when creating a chat", async () => {
vi.mocked(api.listSessions).mockResolvedValue([]);
const client = fakeClient();
client.newChat.mockResolvedValue("chat-fast");
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(client),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.createChat(null, "fast");
});
expect(result.current.sessions[0]?.modelPreset).toBe("fast");
});
it("passes through WebUI transcript user media as images and media", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{
id: "u1",
role: "user",
content: "what's this?",
createdAt: 1,
images: [
{ url: "/api/media/sig-1/payload-1", name: "snap.png" },
{ url: "/api/media/sig-2/payload-2", name: "diag.jpg" },
],
media: [
{ kind: "image", url: "/api/media/sig-1/payload-1", name: "snap.png" },
{ kind: "image", url: "/api/media/sig-2/payload-2", name: "diag.jpg" },
],
},
{ id: "a1", role: "assistant", content: "it's a cat", createdAt: 2 },
{ id: "u2", role: "user", content: "follow-up without images", createdAt: 3 },
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-media"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
const [first, second, third] = result.current.messages;
expect(first.role).toBe("user");
expect(first.images).toEqual([
{ url: "/api/media/sig-1/payload-1", name: "snap.png" },
{ url: "/api/media/sig-2/payload-2", name: "diag.jpg" },
]);
expect(first.media).toEqual([
{ kind: "image", url: "/api/media/sig-1/payload-1", name: "snap.png" },
{ kind: "image", url: "/api/media/sig-2/payload-2", name: "diag.jpg" },
]);
expect(second.role).toBe("assistant");
expect(second.images).toBeUndefined();
expect(third.role).toBe("user");
expect(third.images).toBeUndefined();
});
it("passes through assistant video media from transcript replay", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{
id: "a1",
role: "assistant",
content: "clip ready",
createdAt: 1,
media: [{ kind: "video", url: "/api/media/sig-v/payload-v", name: "clip.mp4" }],
},
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-video"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages[0]!.role).toBe("assistant");
expect(result.current.messages[0]!.images).toBeUndefined();
expect(result.current.messages[0]!.media).toEqual([
{ kind: "video", url: "/api/media/sig-v/payload-v", name: "clip.mp4" },
]);
});
it("passes through assistant reasoning from transcript replay", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{
id: "a1",
role: "assistant",
content: "final answer",
createdAt: 1,
reasoning: "hidden but persisted reasoning",
},
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-reasoning"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages).toHaveLength(1);
expect(result.current.messages[0]!.role).toBe("assistant");
expect(result.current.messages[0]!.content).toBe("final answer");
expect(result.current.messages[0]!.reasoning).toBe("hidden but persisted reasoning");
});
it("accepts transcript rows produced by the server replay reducer", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u1", role: "user", content: "research this", createdAt: 1 },
{
id: "t1",
role: "tool",
kind: "trace",
content: "web_fetch({})",
traces: ["web_search({\"query\":\"agents\"})", "web_fetch({\"url\":\"https://example.com\"})"],
createdAt: 2,
},
{ id: "a1", role: "assistant", content: "summary", createdAt: 3 },
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-tools"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages.map((m) => m.role)).toEqual(["user", "tool", "assistant"]);
const trace = result.current.messages[1]!;
expect(trace.kind).toBe("trace");
expect(trace.traces).toEqual([
"web_search({\"query\":\"agents\"})",
"web_fetch({\"url\":\"https://example.com\"})",
]);
expect(result.current.messages[2]!.content).toBe("summary");
});
it("projects canonical transcript events with the live event reducer", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(api.parseWebuiThreadPayload({
schemaVersion: 3,
projection: "events",
events: [
{
event: "user_message",
chat_id: "chat-event-history",
text: "explain",
starts_turn: true,
projection_id: "history-user",
turn_id: "turn-history",
turn_phase: "user",
turn_seq: 1,
},
{
event: "reasoning_delta",
chat_id: "chat-event-history",
text: "thinking",
projection_id: "history-reasoning",
turn_id: "turn-history",
turn_phase: "reasoning",
turn_seq: 2,
},
{
event: "reasoning_end",
chat_id: "chat-event-history",
projection_id: "history-reasoning-end",
turn_id: "turn-history",
turn_phase: "reasoning",
turn_seq: 3,
},
{
event: "delta",
chat_id: "chat-event-history",
text: "answer",
projection_id: "history-answer",
turn_id: "turn-history",
turn_phase: "answer",
turn_seq: 4,
},
{
event: "turn_end",
chat_id: "chat-event-history",
projection_id: "history-end",
latency_ms: 25,
turn_id: "turn-history",
turn_phase: "complete",
turn_seq: 5,
},
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-event-history"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages).toHaveLength(2);
expect(result.current.messages[1]).toMatchObject({
role: "assistant",
content: "answer",
reasoning: "thinking",
latencyMs: 25,
turnId: "turn-history",
});
});
it("shows a cached transcript immediately while revalidating it", async () => {
const cached = canonicalThreadPayload({
schemaVersion: 3,
revision: "rev-cached",
messages: [
{ id: "a1", role: "assistant", content: "cached answer", createdAt: 1 },
],
});
vi.mocked(api.fetchWebuiThread).mockResolvedValueOnce(cached);
const first = renderHook(() => useSessionHistory("websocket:cached"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(first.result.current.loading).toBe(false));
first.unmount();
vi.mocked(api.fetchWebuiThread).mockImplementationOnce(() => new Promise(() => {}));
const second = renderHook(() => useSessionHistory("websocket:cached"), {
wrapper: wrap(fakeClient()),
});
expect(second.result.current.loading).toBe(false);
expect(second.result.current.messages[0]?.content).toBe("cached answer");
expect(api.fetchWebuiThread).toHaveBeenLastCalledWith(
"tok",
"websocket:cached",
expect.objectContaining({
limit: 40,
direction: "latest",
revision: "rev-cached",
cached,
}),
);
second.unmount();
});
it("reconciles a cached 304 response as a new successful latest-page observation", async () => {
const cached = canonicalThreadPayload({
schemaVersion: 3,
revision: "rev-not-modified",
has_pending_tool_calls: false,
completed_turn_ids: ["completed-turn"],
messages: [{
id: "completed-answer", role: "assistant", content: "complete answer",
createdAt: 1, turnId: "completed-turn",
}],
})!;
vi.mocked(api.fetchWebuiThread).mockResolvedValue(cached);
const { result, unmount } = renderHook(() => useSessionHistory("websocket:unchanged"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
const previousVersion = result.current.version;
const lineage = result.current.lineage;
act(() => result.current.refresh());
await waitFor(() => expect(result.current.version).toBeGreaterThan(previousVersion));
expect(result.current.lineage).toBe(lineage);
expect(result.current.completedTurnIds).toEqual(["completed-turn"]);
expect(result.current.messages[0]?.content).toBe("complete answer");
unmount();
});
it("publishes canonical reconnect history to both mounted readers and ignores their older responses", async () => {
const requests: Array<{
resolve: (body: Awaited<ReturnType<typeof api.fetchWebuiThread>>) => void;
signal: AbortSignal | undefined;
}> = [];
vi.mocked(api.fetchWebuiThread).mockImplementation((_token, _key, optionsOrBase) => new Promise((resolve) => {
const options = typeof optionsOrBase === "string" ? undefined : optionsOrBase;
requests.push({ resolve, signal: options?.signal });
}));
const first = renderHook(() => useSessionHistory("websocket:shared-reconnect"), {
wrapper: wrap(fakeClient()),
});
const second = renderHook(() => useSessionHistory("websocket:shared-reconnect"), {
wrapper: wrap(fakeClient()),
});
const completed = canonicalThreadPayload({
schemaVersion: 3, revision: "completed-response", has_pending_tool_calls: false,
completed_turn_ids: ["completed-turn"],
messages: [{
id: "answer", role: "assistant", content: "published complete answer",
turnId: "completed-turn", createdAt: 1,
}],
})!;
act(() => webuiThreadCache.set("websocket:shared-reconnect", completed));
expect(first.result.current.messages[0]?.content).toBe("published complete answer");
expect(second.result.current.messages[0]?.content).toBe("published complete answer");
expect(requests.every((request) => request.signal?.aborted)).toBe(true);
const active = canonicalThreadPayload({
schemaVersion: 3, revision: "older-active-response", has_pending_tool_calls: true,
completed_turn_ids: [], active_turn_id: "completed-turn",
messages: [{
id: "answer", role: "assistant", content: "older prefix", turnId: "completed-turn", createdAt: 1,
}],
})!;
await act(async () => {
for (const request of requests) request.resolve(active);
await Promise.resolve();
});
expect(first.result.current.messages[0]?.content).toBe("published complete answer");
expect(second.result.current.messages[0]?.content).toBe("published complete answer");
expect(first.result.current.hasPendingToolCalls).toBe(false);
expect(second.result.current.hasPendingToolCalls).toBe(false);
expect(webuiThreadCache.get("websocket:shared-reconnect")).toBe(completed);
first.unmount();
second.unmount();
});
it("keeps rendered history visible when its LRU entry was evicted before refresh", async () => {
const loaded = canonicalThreadPayload({
schemaVersion: 3,
revision: "rev-loaded",
messages: [
{ id: "a1", role: "assistant", content: "still visible", createdAt: 1 },
],
});
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(loaded)
.mockImplementationOnce(() => new Promise(() => {}));
const { result, unmount } = renderHook(
() => useSessionHistory("websocket:evicted"),
{ wrapper: wrap(fakeClient()) },
);
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages[0]?.content).toBe("still visible");
webuiThreadCache.delete("websocket:evicted");
act(() => result.current.refresh());
await waitFor(() => expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2));
expect(result.current.loading).toBe(false);
expect(result.current.messages[0]?.content).toBe("still visible");
unmount();
});
it("flags transcript ending with a trace row as pending", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{
id: "t1",
role: "tool",
kind: "trace",
content: "Using 2 tools",
traces: ["Using 2 tools"],
createdAt: 1,
},
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-pending"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.hasPendingToolCalls).toBe(true);
});
it("uses the server pending flag for completed tails that still end with trace rows", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: false,
messages: [
{
id: "a1",
role: "assistant",
content: "Cron test",
turnId: "cron:run",
createdAt: 1,
},
{
id: "t1",
role: "tool",
kind: "trace",
content: "message({})",
traces: ["message({})"],
turnId: "cron:run",
createdAt: 2,
},
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-cron-done"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages.at(-1)?.kind).toBe("trace");
expect(result.current.hasPendingToolCalls).toBe(false);
});
it("exposes valid completion ids from parsed persisted history", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(api.parseWebuiThreadPayload({
schemaVersion: 3,
projection: "events",
has_pending_tool_calls: false,
completed_turn_ids: ["turn-empty", "", null, "turn-empty"],
events: [
{
event: "user_message", chat_id: "chat-empty", text: "stop", turn_id: "turn-empty", starts_turn: true,
},
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-empty"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.error).toBeNull();
expect(result.current.messages[0]?.content).toBe("stop");
expect(result.current.completedTurnIds).toEqual(["turn-empty"]);
expect(result.current.hasPendingToolCalls).toBe(false);
});
it("respects an explicit empty completion list for an incomplete persisted transcript", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue({
schemaVersion: 3,
projection: "events",
has_pending_tool_calls: true,
active_turn_id: "incomplete-turn",
completed_turn_ids: [],
events: [
{ event: "user_message", chat_id: "incomplete", text: "question", turn_id: "incomplete-turn", starts_turn: true },
{ event: "turn_end", chat_id: "incomplete", turn_id: "incomplete-turn" },
],
});
const { result } = renderHook(() => useSessionHistory("websocket:incomplete"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.completedTurnIds).toEqual([]);
expect(result.current.completionIdsProvided).toBe(true);
expect(result.current.hasPendingToolCalls).toBe(true);
});
it("does not flag transcript as pending when last row is not a trace", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "a1", role: "assistant", content: "All done", createdAt: 1 },
],
}));
const { result } = renderHook(() => useSessionHistory("websocket:chat-done"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.hasPendingToolCalls).toBe(false);
});
it("treats missing transcript (404) as empty history", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(null);
const { result } = renderHook(() => useSessionHistory("websocket:new-chat"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages).toEqual([]);
expect(result.current.hasPendingToolCalls).toBe(false);
});
it("clears the body and paging metadata when no session is selected", async () => {
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: true,
active_turn_id: "selected-turn",
messages: [{ id: "selected-user", role: "user", content: "selected question", turnId: "selected-turn", createdAt: 1 }],
fork_boundary_message_count: 1,
page: {
before_cursor: "selected-cursor", has_more_before: true,
loaded_event_count: 1, user_message_offset: 4,
},
}));
const { result, rerender } = renderHook(({ sessionKey }) => useSessionHistory(sessionKey), {
initialProps: { sessionKey: "websocket:selected" as string | null },
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages[0]?.id).toBe("selected-user");
expect(result.current.messagesKey).toBe("websocket:selected");
expect(result.current.hasMoreBefore).toBe(true);
expect(result.current.userMessageOffset).toBe(4);
expect(result.current.hasPendingToolCalls).toBe(true);
expect(result.current.activeTurnId).toBe("selected-turn");
expect(result.current.forkBoundaryMessageCount).toBe(1);
rerender({ sessionKey: null });
expect(result.current.messages).toEqual([]);
expect(result.current.messagesKey).toBeNull();
expect(result.current.loading).toBe(false);
expect(result.current.hasMoreBefore).toBe(false);
expect(result.current.userMessageOffset).toBe(0);
expect(result.current.hasPendingToolCalls).toBe(false);
expect(result.current.activeTurnId).toBeNull();
expect(result.current.forkBoundaryMessageCount).toBeNull();
act(() => result.current.refresh());
await act(async () => { await result.current.loadOlder(); });
expect(api.fetchWebuiThread).toHaveBeenCalledTimes(1);
});
it("does not reload history when only the auth token rotates", async () => {
const tokenSource = { current: "tok-old" };
vi.mocked(api.fetchWebuiThread).mockResolvedValue(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "a1", role: "assistant", content: "stable", createdAt: 1 },
],
}));
const { result, rerender } = renderHook(
() => useSessionHistory("websocket:token-rotation"),
{ wrapper: wrap(fakeClient(), tokenSource) },
);
await waitFor(() => expect(result.current.loading).toBe(false));
expect(api.fetchWebuiThread).toHaveBeenCalledTimes(1);
expect(api.fetchWebuiThread).toHaveBeenLastCalledWith(
"tok-old",
"websocket:token-rotation",
expect.any(Object),
);
tokenSource.current = "tok-new";
rerender();
await act(async () => Promise.resolve());
expect(api.fetchWebuiThread).toHaveBeenCalledTimes(1);
act(() => result.current.refresh());
await waitFor(() => expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2));
expect(api.fetchWebuiThread).toHaveBeenLastCalledWith(
"tok-new",
"websocket:token-rotation",
expect.any(Object),
);
});
it("ignores an old client's pending response after the provider switches clients", async () => {
let oldSignal: AbortSignal | undefined;
let finishOld!: (body: Awaited<ReturnType<typeof api.fetchWebuiThread>>) => void;
const currentBody = canonicalThreadPayload({
schemaVersion: 3,
messages: [{ id: "current-host-answer", role: "assistant", content: "current host", createdAt: 2 }],
});
vi.mocked(api.fetchWebuiThread)
.mockImplementationOnce((_token, _key, optionsOrBase) => new Promise((resolve) => {
if (typeof optionsOrBase !== "string") oldSignal = optionsOrBase?.signal;
finishOld = resolve;
}))
.mockResolvedValueOnce(currentBody);
let client = fakeClient();
const wrapper = ({ children }: { children: ReactNode }) => (
<ClientProvider client={client as unknown as import("@/lib/nanobot-client").NanobotClient} token="tok">
{children}
</ClientProvider>
);
const { result, rerender } = renderHook(() => useSessionHistory("websocket:host-switch"), { wrapper });
await waitFor(() => expect(oldSignal).toBeDefined());
client = fakeClient();
rerender();
expect(oldSignal?.aborted).toBe(true);
await waitFor(() => expect(result.current.messages[0]?.id).toBe("current-host-answer"));
await act(async () => {
finishOld(canonicalThreadPayload({
schemaVersion: 3,
messages: [{ id: "old-host-answer", role: "assistant", content: "old host", createdAt: 1 }],
}));
});
expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2);
expect(result.current.messages.map((message) => message.id)).toEqual(["current-host-answer"]);
expect(result.current.error).toBeNull();
expect(webuiThreadCache.get("websocket:host-switch")).toBe(currentBody);
});
it("aborts a superseded latest-history request without surfacing an error", async () => {
let firstSignal: AbortSignal | undefined;
vi.mocked(api.fetchWebuiThread)
.mockImplementationOnce((_token, _key, optionsOrBase) => new Promise((_resolve, reject) => {
if (typeof optionsOrBase !== "string") firstSignal = optionsOrBase?.signal;
firstSignal?.addEventListener("abort", () => {
reject(new DOMException("Aborted", "AbortError"));
});
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "a2", role: "assistant", content: "latest", createdAt: 2 },
],
}));
const { result } = renderHook(
() => useSessionHistory("websocket:superseded"),
{ wrapper: wrap(fakeClient()) },
);
await waitFor(() => expect(firstSignal).toBeDefined());
act(() => result.current.refresh());
await waitFor(() => expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2));
expect(firstSignal?.aborted).toBe(true);
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.error).toBeNull();
expect(result.current.messages.map((message) => message.id)).toEqual(["a2"]);
});
it("loads older transcript pages before the current history", async () => {
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u2", role: "user", content: "new question", createdAt: 2 },
{ id: "a2", role: "assistant", content: "new answer", createdAt: 3 },
],
page: {
before_cursor: "cursor-2",
has_more_before: true,
loaded_event_count: 2,
user_message_offset: 1,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u1", role: "user", content: "old question", createdAt: 0 },
{ id: "a1", role: "assistant", content: "old answer", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
loaded_event_count: 2,
user_message_offset: 0,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:paged"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(api.fetchWebuiThread).toHaveBeenCalledWith(
"tok",
"websocket:paged",
expect.objectContaining({
limit: 40,
direction: "latest",
signal: expect.any(AbortSignal),
}),
);
expect(result.current.hasMoreBefore).toBe(true);
expect(result.current.userMessageOffset).toBe(1);
const latestVersion = result.current.version;
const latestLineage = result.current.lineage;
await act(async () => {
await result.current.loadOlder();
});
expect(api.fetchWebuiThread).toHaveBeenLastCalledWith(
"tok",
"websocket:paged",
expect.objectContaining({
limit: 120,
before: "cursor-2",
signal: expect.any(AbortSignal),
}),
);
expect(result.current.messages.map((message) => message.content)).toEqual([
"old question",
"old answer",
"new question",
"new answer",
]);
expect(result.current.hasMoreBefore).toBe(false);
expect(result.current.userMessageOffset).toBe(0);
expect(result.current.version).toBe(latestVersion);
expect(result.current.lineage).toBe(latestLineage);
});
it("keeps older-history failures separate and retries them explicitly", async () => {
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u2", role: "user", content: "latest question", createdAt: 2 },
],
page: {
before_cursor: "cursor-2",
has_more_before: true,
loaded_event_count: 1,
user_message_offset: 1,
},
}))
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u1", role: "user", content: "earliest question", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
loaded_event_count: 1,
user_message_offset: 0,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:retry-older"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.loadOlder();
});
expect(result.current.error).toBeNull();
expect(result.current.olderError).toBe("offline");
expect(result.current.hasMoreBefore).toBe(true);
await act(async () => {
await result.current.loadOlder();
});
expect(result.current.olderError).toBeNull();
expect(result.current.hasMoreBefore).toBe(false);
expect(result.current.messages.map((message) => message.id)).toEqual(["u1", "u2"]);
});
it("preserves a failed history cursor on refresh but clears it for another session", async () => {
const latest = canonicalThreadPayload({
schemaVersion: 3,
messages: [{ id: "u2", role: "user", content: "question", createdAt: 2 }],
page: {
before_cursor: "cursor-2", has_more_before: true,
loaded_event_count: 1, user_message_offset: 1,
},
});
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(latest)
.mockRejectedValueOnce(new Error("offline"))
.mockResolvedValueOnce({ ...latest })
.mockResolvedValueOnce(canonicalThreadPayload({ schemaVersion: 3, messages: [] }));
const { result, rerender } = renderHook(({ sessionKey }) => useSessionHistory(sessionKey), {
initialProps: { sessionKey: "websocket:failed-prefix" },
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => { await result.current.loadOlder(); });
expect(result.current.olderError).toBe("offline");
const previousVersion = result.current.version;
act(() => result.current.refresh());
await waitFor(() => expect(result.current.version).toBeGreaterThan(previousVersion));
expect(result.current.olderError).toBe("offline");
expect(result.current.error).toBeNull();
rerender({ sessionKey: "websocket:other-history" });
expect(result.current.messages).toEqual([]);
expect(result.current.olderError).toBeNull();
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.messages).toEqual([]);
});
it("releases a superseded older read when the replacement latest read fails", async () => {
const latest = canonicalThreadPayload({
schemaVersion: 3,
messages: [{ id: "current", role: "assistant", content: "current answer", createdAt: 2 }],
page: { before_cursor: "previous-page", has_more_before: true, user_message_offset: 1 },
});
const older = canonicalThreadPayload({
schemaVersion: 3,
messages: [{ id: "previous", role: "assistant", content: "previous answer", createdAt: 1 }],
page: { before_cursor: null, has_more_before: false, user_message_offset: 0 },
});
let olderSignal: AbortSignal | undefined;
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(latest)
.mockImplementationOnce((_token, _key, options) => new Promise((_resolve, reject) => {
if (typeof options !== "string") olderSignal = options?.signal;
olderSignal?.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")));
}))
.mockRejectedValueOnce(new Error("latest unavailable"))
.mockResolvedValueOnce(older);
const { result } = renderHook(() => useSessionHistory("websocket:superseded-older"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.messages[0]?.content).toBe("current answer"));
let pending!: Promise<void>;
act(() => { pending = result.current.loadOlder(); });
expect(result.current.loadingOlder).toBe(true);
act(() => result.current.refresh());
await waitFor(() => expect(result.current.error).toBe("latest unavailable"));
await act(async () => { await pending; });
expect(olderSignal?.aborted).toBe(true);
expect(result.current.loadingOlder).toBe(false);
expect(result.current.hasMoreBefore).toBe(true);
expect(result.current.messages.map((row) => row.content)).toEqual(["current answer"]);
await act(async () => { await result.current.loadOlder(); });
expect(api.fetchWebuiThread).toHaveBeenLastCalledWith("tok", "websocket:superseded-older",
expect.objectContaining({ before: "previous-page" }));
expect(result.current.messages.map((row) => row.content)).toEqual(["previous answer", "current answer"]);
});
it("aborts an older-history request when the consumer unmounts", async () => {
let olderSignal: AbortSignal | undefined;
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u2", role: "user", content: "latest question", createdAt: 2 },
],
page: {
before_cursor: "cursor-2",
has_more_before: true,
loaded_event_count: 1,
user_message_offset: 1,
},
}))
.mockImplementationOnce((_token, _key, optionsOrBase) => new Promise((_resolve, reject) => {
if (typeof optionsOrBase !== "string") olderSignal = optionsOrBase?.signal;
olderSignal?.addEventListener("abort", () => {
reject(new DOMException("Aborted", "AbortError"));
});
}));
const { result, unmount } = renderHook(
() => useSessionHistory("websocket:unmount-older"),
{ wrapper: wrap(fakeClient()) },
);
await waitFor(() => expect(result.current.loading).toBe(false));
let olderRequest!: Promise<void>;
act(() => {
olderRequest = result.current.loadOlder();
});
await waitFor(() => expect(olderSignal).toBeDefined());
unmount();
expect(olderSignal?.aborted).toBe(true);
await expect(olderRequest).resolves.toBeUndefined();
});
it("preserves a loaded prefix when a canonical latest window overlaps its tail", async () => {
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: true,
messages: [
{ id: "u2", role: "user", content: "middle question", turnId: "turn-2", turnSeq: 1, createdAt: 2 },
{ id: "a2", role: "assistant", content: "middle answer", turnId: "turn-2", turnSeq: 2, createdAt: 3 },
],
page: {
before_cursor: "cursor-middle",
has_more_before: true,
loaded_event_count: 2,
user_message_offset: 1,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u1", role: "user", content: "old question", createdAt: 0 },
{ id: "a1", role: "assistant", content: "old answer", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
loaded_event_count: 2,
user_message_offset: 0,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: false,
completed_turn_ids: ["turn-3"],
messages: [
{ id: "a2-replayed", role: "assistant", content: "middle answer", turnId: "turn-2", turnSeq: 2, createdAt: 3 },
{
id: "u3",
role: "user",
content: "latest question",
turnId: "turn-3",
createdAt: 4,
},
{
id: "a3",
role: "assistant",
content: "latest answer",
turnId: "turn-3",
createdAt: 5,
},
],
page: {
before_cursor: "cursor-shifted",
has_more_before: true,
loaded_event_count: 3,
user_message_offset: 1,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:paged-refresh"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.loadOlder();
});
const loadedVersion = result.current.version;
const loadedLineage = result.current.lineage;
act(() => result.current.refresh());
await waitFor(() => expect(result.current.version).toBeGreaterThan(loadedVersion));
expect(result.current.messages.map((message) => message.id)).toEqual([
"u1",
"a1",
"u2",
"a2-replayed",
"u3",
"a3",
]);
expect(result.current.hasMoreBefore).toBe(false);
expect(result.current.userMessageOffset).toBe(0);
expect(result.current.hasPendingToolCalls).toBe(false);
expect(result.current.completedTurnIds).toEqual(["turn-3"]);
expect(result.current.lineage).toBe(loadedLineage);
});
it("starts a new lineage for a disjoint latest window even when row text repeats", async () => {
const oldWindow = Array.from({ length: 160 }, (_, index) => ({
id: `old-${index}`,
role: index % 2 === 0 ? "user" as const : "assistant" as const,
content: `window row ${index}`,
turnId: `old-turn-${Math.floor(index / 2)}`,
turnSeq: index % 2 + 1,
createdAt: index,
}));
const newWindow = Array.from({ length: 160 }, (_, index) => ({
id: `new-${index}`,
role: index % 2 === 0 ? "user" as const : "assistant" as const,
content: `window row ${index}`,
turnId: `new-turn-${Math.floor(index / 2)}`,
turnSeq: index % 2 + 1,
createdAt: 1_000 + index,
}));
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: oldWindow,
page: {
before_cursor: "old-window-cursor",
has_more_before: true,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: newWindow,
page: {
before_cursor: "new-window-cursor",
has_more_before: true,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:window-reset"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
const initialLineage = result.current.lineage;
expect(result.current.messages[0]?.id).toBe("old-0");
act(() => result.current.refresh());
await waitFor(() => expect(result.current.messages[0]?.id).toBe("new-0"));
expect(result.current.messages).toHaveLength(160);
expect(result.current.messages.at(-1)?.id).toBe("new-159");
expect(result.current.lineage).toBeGreaterThan(initialLineage);
expect(result.current.hasMoreBefore).toBe(true);
});
it("preserves repeated prompts by stable turn sources when replay IDs change", async () => {
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "repeat-1-old", role: "user", content: "repeat", turnId: "repeat-turn-1", turnSeq: 1, createdAt: 10 },
{ id: "answer-1-old", role: "assistant", content: "first answer", turnId: "repeat-turn-1", turnSeq: 2, createdAt: 11 },
{ id: "repeat-2-old", role: "user", content: "repeat", turnId: "repeat-turn-2", turnSeq: 1, createdAt: 12 },
{ id: "answer-2-old", role: "assistant", content: "second answer", turnId: "repeat-turn-2", turnSeq: 2, createdAt: 13 },
],
page: {
before_cursor: "source-cursor",
has_more_before: true,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "old-prefix", role: "user", content: "old prefix", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "repeat-2-new", role: "user", content: "repeat", turnId: "repeat-turn-2", turnSeq: 1, createdAt: 9_012 },
{ id: "answer-2-new", role: "assistant", content: "second answer", turnId: "repeat-turn-2", turnSeq: 2, createdAt: 9_013 },
{ id: "new-tail", role: "assistant", content: "new tail", createdAt: 9_014 },
],
page: {
before_cursor: "shifted-source-cursor",
has_more_before: true,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:source-overlap"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
await act(async () => {
await result.current.loadOlder();
});
const lineage = result.current.lineage;
act(() => result.current.refresh());
await waitFor(() => expect(result.current.messages.at(-1)?.id).toBe("new-tail"));
expect(result.current.messages.map((message) => message.id)).toEqual([
"old-prefix",
"repeat-1-old",
"answer-1-old",
"repeat-2-new",
"answer-2-new",
"new-tail",
]);
expect(result.current.lineage).toBe(lineage);
});
it("ignores an older-page response after a latest refresh resets its lineage", async () => {
let resolveOlder:
| ((value: Awaited<ReturnType<typeof api.fetchWebuiThread>>) => void)
| null = null;
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "old-latest", role: "assistant", content: "old latest", createdAt: 10 },
],
page: {
before_cursor: "cursor-old-lineage",
has_more_before: true,
},
}))
.mockImplementationOnce(() => new Promise((resolve) => {
resolveOlder = resolve;
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "new-latest", role: "assistant", content: "new latest", createdAt: 20 },
],
page: {
before_cursor: "cursor-new-lineage",
has_more_before: true,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:paged-race"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
const oldLineage = result.current.lineage;
let olderRequest: Promise<void> | undefined;
act(() => {
olderRequest = result.current.loadOlder();
});
await waitFor(() => expect(api.fetchWebuiThread).toHaveBeenCalledTimes(2));
act(() => result.current.refresh());
await waitFor(() => expect(result.current.messages[0]?.id).toBe("new-latest"));
expect(result.current.lineage).toBeGreaterThan(oldLineage);
await act(async () => {
resolveOlder?.(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "stale-prefix", role: "user", content: "stale prefix", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
},
}));
await olderRequest;
});
expect(result.current.messages.map((message) => message.id)).toEqual(["new-latest"]);
expect(result.current.hasMoreBefore).toBe(true);
});
it("preserves authoritative active state while prepending older history", async () => {
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: true,
messages: [
{ id: "u2", role: "user", content: "current question", createdAt: 2 },
{ id: "a2", role: "assistant", content: "partial answer", createdAt: 3 },
],
page: {
before_cursor: "cursor-active",
has_more_before: true,
loaded_event_count: 2,
user_message_offset: 1,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: false,
messages: [
{ id: "u1", role: "user", content: "old question", createdAt: 0 },
{ id: "a1", role: "assistant", content: "old answer", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
loaded_event_count: 2,
user_message_offset: 0,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:paged-active"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.hasPendingToolCalls).toBe(true);
const latestVersion = result.current.version;
await act(async () => {
await result.current.loadOlder();
});
expect(result.current.hasPendingToolCalls).toBe(true);
expect(result.current.version).toBe(latestVersion);
});
it("preserves authoritative completed state while prepending trace history", async () => {
vi.mocked(api.fetchWebuiThread)
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
has_pending_tool_calls: false,
messages: [
{
id: "t2",
role: "tool",
kind: "trace",
content: "completed trace",
traces: ["completed trace"],
createdAt: 2,
},
],
page: {
before_cursor: "cursor-complete",
has_more_before: true,
loaded_event_count: 1,
user_message_offset: 1,
},
}))
.mockResolvedValueOnce(canonicalThreadPayload({
schemaVersion: 3,
messages: [
{ id: "u1", role: "user", content: "old question", createdAt: 0 },
{ id: "a1", role: "assistant", content: "old answer", createdAt: 1 },
],
page: {
before_cursor: null,
has_more_before: false,
loaded_event_count: 2,
user_message_offset: 0,
},
}));
const { result } = renderHook(() => useSessionHistory("websocket:paged-complete"), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.loading).toBe(false));
expect(result.current.hasPendingToolCalls).toBe(false);
await act(async () => {
await result.current.loadOlder();
});
expect(result.current.hasPendingToolCalls).toBe(false);
});
it("keeps the session in the list when delete fails", async () => {
vi.mocked(api.listSessions).mockResolvedValue([
{
key: "websocket:chat-a",
channel: "websocket",
chatId: "chat-a",
createdAt: "2026-04-16T10:00:00Z",
updatedAt: "2026-04-16T10:00:00Z",
preview: "Alpha",
},
]);
vi.mocked(api.deleteSession).mockRejectedValue(new Error("boom"));
const { result } = renderHook(() => useSessions(), {
wrapper: wrap(fakeClient()),
});
await waitFor(() => expect(result.current.sessions).toHaveLength(1));
await expect(
act(async () => {
await result.current.deleteChat("websocket:chat-a");
}),
).rejects.toThrow("boom");
expect(result.current.sessions.map((s) => s.key)).toEqual(["websocket:chat-a"]);
});
});