Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

fix(chat, text): replay the visible failed turn and retain repeated section titles

Bingxi Zhao (Frank)98529ad0c731
diff --git a/deeptutor/textbook_struct/chapter_rebuild.py b/deeptutor/textbook_struct/chapter_rebuild.py
index 4fd957195..9925aa074 100644
--- a/deeptutor/textbook_struct/chapter_rebuild.py
+++ b/deeptutor/textbook_struct/chapter_rebuild.py
@@ -201,6 +201,13 @@ UNIT_RE_MAP = {
"单元": re.compile(r"^第\s*[一二三四五六七八九十百\d]+\s*单元"),
}
+PARENT_UNITS = {
+ "课": ("单元", "章"),
+ "章": ("单元",),
+ "节": ("单元", "章"),
+ "单元": (),
+}
+
def rebuild_from_headers_level(layout: dict, unit: str = "课") -> list[Chapter]:
"""Level-aware rebuild: only ``unit``-level running-header changes mark boundaries.
@@ -217,16 +224,27 @@ def rebuild_from_headers_level(layout: dict, unit: str = "课") -> list[Chapter]
if unit_re is None:
raise ValueError(f"unknown unit: {unit}")
chapters: list[Chapter] = []
- seen: set[str] = set()
+ parent_titles: dict[str, str] = {}
+ last_boundary: tuple[str, ...] | None = None
page_count = layout_page_count(layout)
- for page in layout.get("pdf_info", []):
+ for page in sorted(layout.get("pdf_info", []), key=lambda item: item["page_idx"]):
footers, printed = page_facts(page)
+ for title in footers:
+ for parent_unit in PARENT_UNITS[unit]:
+ if UNIT_RE_MAP[parent_unit].match(title):
+ parent_titles[parent_unit] = title
+ if parent_unit == "单元":
+ parent_titles.pop("章", None)
for title in footers:
if not unit_re.match(title):
continue
- if title in seen:
+ boundary = (
+ *(parent_titles.get(parent_unit, "") for parent_unit in PARENT_UNITS[unit]),
+ title,
+ )
+ if boundary == last_boundary:
continue
- seen.add(title)
+ last_boundary = boundary
chapters.append(
Chapter(
title=title,
diff --git a/tests/textbook_struct/test_page_headers.py b/tests/textbook_struct/test_page_headers.py
index a3b97e1bd..1cac15069 100644
--- a/tests/textbook_struct/test_page_headers.py
+++ b/tests/textbook_struct/test_page_headers.py
@@ -130,6 +130,20 @@ def test_rebuild_level_unit_filter_drops_other_levels() -> None:
assert [c.title for c in chapters] == ["第1节 函数的概念", "第2节 函数的表示法"]
+def test_section_numbering_can_restart_in_a_new_chapter() -> None:
+ layout = {
+ "pdf_info": [
+ _page(0, [_footer("第一章 A"), _footer("第一节 概述")]),
+ _page(1, [_footer("第二章 B"), _footer("第一节 概述")]),
+ ]
+ }
+ chapters = rebuild_from_headers_level(layout, unit="节")
+ assert [(chapter.title, chapter.page_idx, chapter.end_page_idx) for chapter in chapters] == [
+ ("第一节 概述", 0, 1),
+ ("第一节 概述", 1, 2),
+ ]
+
+
def test_chapters_starting_on_one_page_both_include_that_page() -> None:
chapters = [Chapter("A", 2, []), Chapter("B", 2, [])]
assert [chapter.end_page_idx for chapter in assign_page_ranges(chapters, page_count=3)] == [
diff --git a/web/features/chat/ChatStateAdapter.tsx b/web/features/chat/ChatStateAdapter.tsx
index 9209ffd82..2edb062f8 100644
--- a/web/features/chat/ChatStateAdapter.tsx
+++ b/web/features/chat/ChatStateAdapter.tsx
@@ -58,6 +58,7 @@ import {
} from "@/lib/message-branches";
import { nextOptimisticId, resolvePersistedMessage } from "@/lib/optimistic-id";
import { reconcileTurnIds } from "@/lib/turn-reconcile";
+import { decideFailedTurnReplay, isFailedTurnVisible } from "@/lib/chat-resend";
import {
isRetractionMarker,
recomputeAnswerContent,
@@ -2650,7 +2651,7 @@ export function ChatStateAdapterProvider({
[sendThroughRunner],
);
- const regenerateLastMessage = useCallback(() => {
+ const regenerateLastMessage = useCallback((replaySnapshot = false) => {
const currentState = stateRef.current;
const key = currentState.selectedKey;
if (!key) return;
@@ -2675,9 +2676,9 @@ export function ChatStateAdapterProvider({
sendThroughRunner(key, {
type: "regenerate",
session_id: session.sessionId,
- overrides: {
- language: readStoredResponseLanguage(),
- },
+ overrides: replaySnapshot
+ ? { replay_snapshot: true }
+ : { language: readStoredResponseLanguage() },
});
}, [sendThroughRunner]);
@@ -2687,8 +2688,12 @@ export function ChatStateAdapterProvider({
if (!key) return;
const session = currentState.sessions[key];
if (!session || !session.sessionId) return;
- if (session.isStreaming) return;
- if (session.status !== "failed" && session.status !== "rejected") return;
+ if (!isFailedTurnVisible(
+ session.messages,
+ session.selectedBranches,
+ session.status,
+ session.isStreaming,
+ )) return;
const lastUser = [...session.messages]
.reverse()
.find((m) => m.role === "user" && m.requestSnapshot);
@@ -2710,67 +2715,55 @@ export function ChatStateAdapterProvider({
resolvingResendRef.current.delete(key);
}
const live = stateRef.current;
+ const liveSession = live.sessions[key];
if (
live.selectedKey !== key ||
- live.sessions[key]?.isStreaming ||
- !["failed", "rejected"].includes(live.sessions[key]?.status ?? "")
+ !liveSession ||
+ !isFailedTurnVisible(
+ liveSession.messages,
+ liveSession.selectedBranches,
+ liveSession.status,
+ liveSession.isStreaming,
+ )
) return;
- if (remote.active_turns?.length) {
- void loadSessionRef.current?.(session.sessionId);
- return;
- }
- const knownIds = new Set(
- session.messages
- .filter((message) => typeof message.id === "number" && message.id > 0)
- .map((message) => String(message.id)),
- );
- const newRows = (remote.messages ?? []).filter(
- (message) => message.role !== "system" && !knownIds.has(String(message.id)),
+ const liveLastUser = [...liveSession.messages]
+ .reverse()
+ .find((message) => message.role === "user" && message.requestSnapshot);
+ if (!liveLastUser?.requestSnapshot) return;
+ const decision = decideFailedTurnReplay(
+ liveSession.messages,
+ { ...liveLastUser, requestSnapshot: liveLastUser.requestSnapshot },
+ remote,
);
- // A persisted user can go straight through the server's regenerate path.
- // If other rows arrived since this tab's snapshot, show them first.
- if (typeof lastUser.id === "number" && lastUser.id > 0) {
- if (newRows.length > 0 || remote.status === "completed") {
- void loadSessionRef.current?.(session.sessionId);
- } else {
- regenerateLastMessage();
- }
+ if (decision.kind === "refresh") {
+ void loadSessionRef.current?.(session.sessionId);
return;
}
- const persistedUser = [...newRows].reverse().find((message) => message.role === "user");
- if (persistedUser) {
- if (
- !["failed", "rejected", "cancelled"].includes(remote.status ?? "") ||
- persistedUser.content !== lastUser.requestSnapshot.content ||
- (persistedUser.parent_message_id ?? null) !== (lastUser.parentMessageId ?? null)
- ) {
- void loadSessionRef.current?.(session.sessionId);
- return;
- }
+ if (decision.kind === "reconcile_regenerate") {
dispatch({
type: "RECONCILE_TURN",
key,
turnId: null,
- userMessageId: persistedUser.id,
+ // Runtime storage can return PocketBase string IDs; the existing
+ // reconciliation path preserves them despite its numeric legacy type.
+ userMessageId: decision.userId as number,
assistantMessageId: null,
});
- regenerateLastMessage();
- return;
}
- if (newRows.length > 0) {
- void loadSessionRef.current?.(session.sessionId);
+ if (decision.kind === "regenerate" || decision.kind === "reconcile_regenerate") {
+ regenerateLastMessage(true);
return;
}
// The first attempt failed before the user row reached storage. Retry it
// as a new turn, keeping the existing optimistic row visible.
- const lastMessage = session.messages[session.messages.length - 1];
+ const lastMessage = liveSession.messages[liveSession.messages.length - 1];
if (lastMessage?.role === "assistant") {
pendingResendRef.current.set(key, { ...lastMessage });
}
// Remove the trailing failed assistant bubble so the new turn's
// STREAM_START placeholder replaces it rather than stacking below.
dispatch({ type: "POP_LAST_ASSISTANT", key });
- const snapshot = lastUser.requestSnapshot;
+ const snapshot = liveLastUser.requestSnapshot;
void sendMessage(
snapshot.content,
undefined,
@@ -2781,10 +2774,10 @@ export function ChatStateAdapterProvider({
displayUserMessage: false,
requestSnapshotOverride: snapshot,
parentMessageId:
- typeof lastUser.parentMessageId === "number" &&
- lastUser.parentMessageId <= 0
+ typeof liveLastUser.parentMessageId === "number" &&
+ liveLastUser.parentMessageId <= 0
? undefined
- : lastUser.parentMessageId,
+ : liveLastUser.parentMessageId,
},
).then((sent) => {
if (sent) return;
@@ -2796,7 +2789,6 @@ export function ChatStateAdapterProvider({
const derivedState = useMemo<ChatState>(() => {
const current = ensureSelectedSession(state);
- const lastMsg = current.messages[current.messages.length - 1];
return {
sessionKey: current.key,
sessionId: current.sessionId,
@@ -2818,10 +2810,12 @@ export function ChatStateAdapterProvider({
currentStage: current.currentStage,
language: current.language,
selectedBranches: current.selectedBranches,
- lastTurnFailed:
- !current.isStreaming &&
- (current.status === "failed" || current.status === "rejected") &&
- lastMsg?.role === "assistant",
+ lastTurnFailed: isFailedTurnVisible(
+ current.messages,
+ current.selectedBranches,
+ current.status,
+ current.isStreaming,
+ ),
};
}, [state]);
diff --git a/web/lib/chat-resend.ts b/web/lib/chat-resend.ts
new file mode 100644
index 000000000..ea548211d
--- /dev/null
+++ b/web/lib/chat-resend.ts
@@ -0,0 +1,84 @@
+import { buildVisiblePath, type BranchMessage } from "./message-branches";
+
+type MessageId = number | string;
+
+interface ChatBranchMessage extends BranchMessage {
+ role: "user" | "assistant" | "system";
+}
+
+/** A failed turn can be retried only while its assistant is on the visible branch. */
+export function isFailedTurnVisible<T extends ChatBranchMessage>(
+ messages: T[],
+ selectedBranches: Record<string, number>,
+ status: string,
+ isStreaming: boolean,
+): boolean {
+ if (isStreaming || (status !== "failed" && status !== "rejected")) return false;
+ const tail = messages[messages.length - 1];
+ if (tail?.role !== "assistant") return false;
+ return buildVisiblePath(messages, selectedBranches).messages.at(-1) === tail;
+}
+
+interface LocalMessage {
+ id?: MessageId;
+ parentMessageId?: MessageId | null;
+}
+
+interface RemoteMessage {
+ id: MessageId;
+ role: "user" | "assistant" | "system";
+ content: string;
+ parent_message_id?: MessageId | null;
+}
+
+interface RemoteSession {
+ status?: string | null;
+ active_turns?: readonly unknown[];
+ messages?: readonly RemoteMessage[];
+}
+
+type ReplayDecision =
+ | { kind: "refresh" }
+ | { kind: "regenerate" }
+ | { kind: "reconcile_regenerate"; userId: MessageId }
+ | { kind: "resend" };
+
+function isPersistedId(id: unknown): id is MessageId {
+ return (typeof id === "number" && id > 0) ||
+ (typeof id === "string" && id.length > 0);
+}
+
+function sameParent(left: MessageId | null | undefined, right: MessageId | null | undefined): boolean {
+ return left == null ? right == null : right != null && String(left) === String(right);
+}
+
+/** Distinguish this failed turn from an earlier completed turn in the session. */
+export function decideFailedTurnReplay(
+ localMessages: readonly LocalMessage[],
+ lastUser: LocalMessage & { requestSnapshot: { content: string } },
+ remote: RemoteSession,
+): ReplayDecision {
+ if (remote.active_turns?.length) return { kind: "refresh" };
+ const knownIds = new Set(
+ localMessages.filter((message) => isPersistedId(message.id)).map((message) => String(message.id)),
+ );
+ const newRows = (remote.messages ?? []).filter(
+ (message) => message.role !== "system" && !knownIds.has(String(message.id)),
+ );
+
+ if (isPersistedId(lastUser.id)) {
+ return newRows.length > 0 || remote.status === "completed"
+ ? { kind: "refresh" }
+ : { kind: "regenerate" };
+ }
+
+ const persistedUser = [...newRows].reverse().find((message) => message.role === "user");
+ if (persistedUser) {
+ return ["failed", "rejected", "cancelled"].includes(remote.status ?? "") &&
+ persistedUser.content === lastUser.requestSnapshot.content &&
+ sameParent(persistedUser.parent_message_id, lastUser.parentMessageId)
+ ? { kind: "reconcile_regenerate", userId: persistedUser.id }
+ : { kind: "refresh" };
+ }
+ return newRows.length > 0 ? { kind: "refresh" } : { kind: "resend" };
+}
diff --git a/web/tests/chat-resend-decision.test.ts b/web/tests/chat-resend-decision.test.ts
new file mode 100644
index 000000000..72d126a1e
--- /dev/null
+++ b/web/tests/chat-resend-decision.test.ts
@@ -0,0 +1,58 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { decideFailedTurnReplay, isFailedTurnVisible } from "../lib/chat-resend";
+
+test("an earlier completed turn does not discard an unsaved failed attempt", () => {
+ const previous = { id: 1, role: "user" as const, parentMessageId: null };
+ const lastUser = { id: -3, parentMessageId: 2, requestSnapshot: { content: "retry me" } };
+ assert.deepEqual(
+ decideFailedTurnReplay(
+ [previous, { id: 2 }, lastUser, { id: -4 }],
+ lastUser,
+ { status: "completed", messages: [
+ { id: 1, role: "user", content: "old" },
+ { id: 2, role: "assistant", content: "done" },
+ ] },
+ ),
+ { kind: "resend" },
+ );
+});
+
+test("PocketBase string ids are already persisted, so old rows are not mistaken for this turn", () => {
+ const lastUser = { id: -3, parentMessageId: "assistant_old", requestSnapshot: { content: "retry me" } };
+ assert.deepEqual(
+ decideFailedTurnReplay(
+ [{ id: "user_old" }, { id: "assistant_old" }, lastUser, { id: -4 }],
+ lastUser,
+ { status: "completed", messages: [
+ { id: "user_old", role: "user", content: "old" },
+ { id: "assistant_old", role: "assistant", content: "done" },
+ ] },
+ ),
+ { kind: "resend" },
+ );
+});
+
+test("a failed user persisted during socket loss is reconciled before regenerate", () => {
+ const lastUser = { id: -3, parentMessageId: "assistant_old", requestSnapshot: { content: "retry me" } };
+ assert.deepEqual(
+ decideFailedTurnReplay(
+ [{ id: "assistant_old" }, lastUser, { id: -4 }],
+ lastUser,
+ { status: "failed", messages: [
+ { id: "assistant_old", role: "assistant", content: "done" },
+ { id: "user_new", role: "user", content: "retry me", parent_message_id: "assistant_old" },
+ ] },
+ ),
+ { kind: "reconcile_regenerate", userId: "user_new" },
+ );
+});
+
+test("resend is unavailable when the failed tail is hidden by branch selection", () => {
+ const root = { id: 1, role: "user" as const, parentMessageId: null };
+ const older = { id: 2, role: "assistant" as const, parentMessageId: 1 };
+ const newer = { id: 3, role: "assistant" as const, parentMessageId: 1 };
+ assert.equal(isFailedTurnVisible([root, older, newer], { "1": 2 }, "failed", false), false);
+ assert.equal(isFailedTurnVisible([root, older, newer], { "1": 3 }, "failed", false), true);
+});
diff --git a/web/tests/chat-resend-failed-turn.test.ts b/web/tests/chat-resend-failed-turn.test.ts
index 803ca596a..eac1d4b5f 100644
--- a/web/tests/chat-resend-failed-turn.test.ts
+++ b/web/tests/chat-resend-failed-turn.test.ts
@@ -6,13 +6,6 @@ import test from "node:test";
const source = (relative: string) =>
fs.readFileSync(path.resolve(process.cwd(), relative), "utf8");
-test("ChatStateAdapter exposes lastTurnFailed derived state", () => {
- const adapter = source("features/chat/ChatStateAdapter.tsx");
- assert.match(adapter, /lastTurnFailed/);
- assert.match(adapter, /"failed".*"rejected"/);
- assert.match(adapter, /lastMsg\?\.role === "assistant"/);
-});
-
test("ChatStateAdapter implements resendLastMessage preserving snapshot", () => {
const adapter = source("features/chat/ChatStateAdapter.tsx");
assert.match(adapter, /resendLastMessage/);