Skip to content

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

fix(settings): retain refreshes across streaming updates

dajiaohuang4da74d01f234
diff --git a/web/hooks/useSetupSync.ts b/web/hooks/useSetupSync.ts
index fc8c3bc9f..1126d576e 100644
--- a/web/hooks/useSetupSync.ts
+++ b/web/hooks/useSetupSync.ts
@@ -46,6 +46,15 @@ export function useSetupSync(
messages: ReadonlyArray<{ events?: StreamEvent[] }> | undefined,
): void {
const handledRef = useRef<Set<string>>(new Set());
+ const requestRevisionRef = useRef(0);
+ const mountedRef = useRef(false);
+
+ useEffect(() => {
+ mountedRef.current = true;
+ return () => {
+ mountedRef.current = false;
+ };
+ }, []);
useEffect(() => {
const fresh = collectAppliedSettingIds(messages).filter(
@@ -54,17 +63,19 @@ export function useSetupSync(
if (fresh.length === 0) return;
for (const id of fresh) handledRef.current.add(id);
- let cancelled = false;
+ // Message deltas must not cancel the refresh already attached to this
+ // tool call. Only a newer settings write or unmount makes it obsolete.
+ const requestRevision = ++requestRevisionRef.current;
void (async () => {
try {
const res = await apiFetch(apiUrl("/api/settings/ui"));
- if (!res.ok || cancelled) return;
+ if (!res.ok || !mountedRef.current || requestRevision !== requestRevisionRef.current) return;
const payload = (await res.json()) as {
language?: unknown;
response_language?: unknown;
theme?: unknown;
};
- if (cancelled) return;
+ if (!mountedRef.current || requestRevision !== requestRevisionRef.current) return;
if (isAppLanguage(payload.language)) {
writeStoredLanguage(payload.language);
writeStoredResponseLanguage(
@@ -83,10 +94,6 @@ export function useSetupSync(
// stored server-side and the next load picks it up.
}
})();
-
- return () => {
- cancelled = true;
- };
}, [messages]);
}
diff --git a/web/tests/setup-sync-stream-updates.spec.tsx b/web/tests/setup-sync-stream-updates.spec.tsx
new file mode 100644
index 000000000..93687cdf7
--- /dev/null
+++ b/web/tests/setup-sync-stream-updates.spec.tsx
@@ -0,0 +1,77 @@
+import { act, renderHook } from "@testing-library/react";
+import { describe, expect, it, vi } from "vitest";
+import { useSetupSync } from "@/hooks/useSetupSync";
+import type { StreamEvent } from "@/features/chat/model/protocol";
+
+const api = vi.hoisted(() => ({ fetch: vi.fn() }));
+vi.mock("@/lib/api", () => ({ apiFetch: api.fetch, apiUrl: (url: string) => url }));
+
+function messages(id = "call-1") {
+ return [{ events: [{ type: "tool_result", source: "setup", stage: "loop",
+ content: "", session_id: "session-1", turn_id: "turn-1", seq: 1, timestamp: 0,
+ metadata: { tool_call_id: id, tool_metadata: { setup_applied: { key: "interface.language" } } },
+ } as StreamEvent] }];
+}
+
+function deferredResponse() {
+ let resolve!: (response: Response) => void;
+ const promise = new Promise<Response>(done => { resolve = done; });
+ return { promise, resolve };
+}
+
+async function finish(resolve: (response: Response) => void, language: string) {
+ await act(async () => {
+ resolve(new Response(JSON.stringify({ language, response_language: language })));
+ });
+}
+
+describe("setup preference synchronization during a streamed turn", () => {
+ it("honors the setting through strict-mode effect replay", async () => {
+ localStorage.clear();
+ const pending = deferredResponse();
+ api.fetch.mockReset().mockReturnValue(pending.promise);
+ renderHook(() => useSetupSync(messages()), { reactStrictMode: true });
+ await finish(pending.resolve, "zh");
+ expect(localStorage.getItem("deeptutor-language")).toBe("zh");
+ expect(api.fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it("applies the response after an ordinary message update", async () => {
+ localStorage.clear();
+ const pending = deferredResponse();
+ api.fetch.mockReset().mockReturnValue(pending.promise);
+ const { rerender } = renderHook(({ items }) => useSetupSync(items), {
+ initialProps: { items: messages() },
+ });
+ rerender({ items: messages() });
+ await finish(pending.resolve, "zh");
+ expect(localStorage.getItem("deeptutor-language")).toBe("zh");
+ expect(api.fetch).toHaveBeenCalledTimes(1);
+ rerender({ items: messages() });
+ expect(api.fetch).toHaveBeenCalledTimes(1);
+ });
+
+ it("does not apply a response after unmount", async () => {
+ localStorage.clear();
+ const pending = deferredResponse();
+ api.fetch.mockReset().mockReturnValue(pending.promise);
+ const { unmount } = renderHook(() => useSetupSync(messages()));
+ unmount();
+ await finish(pending.resolve, "zh");
+ expect(localStorage.getItem("deeptutor-language")).toBeNull();
+ });
+
+ it("keeps the newest applied setting when responses arrive out of order", async () => {
+ localStorage.clear();
+ const first = deferredResponse();
+ const second = deferredResponse();
+ api.fetch.mockReset().mockReturnValueOnce(first.promise).mockReturnValueOnce(second.promise);
+ const { rerender } = renderHook(({ items }) => useSetupSync(items), {
+ initialProps: { items: messages() },
+ });
+ rerender({ items: messages("call-2") });
+ await finish(second.resolve, "zh");
+ await finish(first.resolve, "en");
+ expect(localStorage.getItem("deeptutor-language")).toBe("zh");
+ });
+});