fix: finish new-session opening-message handoff

2026-10-27 18:19:38 +02:00
parent 8ca291526c
commit f24fda926a
11 changed files with 689 additions and 107 deletions
@@ -0,0 +1,83 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { SessionModel } from "../components/session-core.ts";
+import { newUserMessage } from "../src/core/native-messages.ts";
+
+function deferred<T>() {
+	let resolve!: (value: T) => void;
+	const promise = new Promise<T>(done => { resolve = done; });
+	return { promise, resolve };
+}
+
+describe("new-session opening delivery acceptance", () => {
+	it("notifies acceptance before the record read or teacher stream completes", async () => {
+		const record = deferred<Response>();
+		const accepted = deferred<void>();
+		const calls: string[] = [];
+		const m = new SessionModel({ chatId: "c1", initialMessages: [], fetch: async url => {
+			calls.push(String(url));
+			if (String(url) === "/api/chat") return Response.json({ ok: true });
+			if (String(url).endsWith("/stream")) return new Response("data: [DONE]\n\n");
+			return record.promise;
+		} });
+		let completed = false;
+		const sending = m.send({ type: "text", text: "my syllabus" }, () => accepted.resolve()).then(result => { completed = true; return result; });
+		await accepted.promise;
+		assert.equal(completed, false);
+		assert.equal(m.getState().hasConfirmedConversation, false, "optimistic user text is not canonical proof");
+		record.resolve(Response.json({ messages: [newUserMessage("my syllabus")] }));
+		assert.equal(await sending, true);
+		assert.equal(m.getState().hasConfirmedConversation, true);
+		assert.equal(calls.filter(url => url === "/api/chat").length, 1);
+	});
+
+	it("a teardown racing the POST still cleans up on acknowledgment without attaching", async () => {
+		const post = deferred<Response>();
+		let notified = 0;
+		const m = new SessionModel({ chatId: "c1", initialMessages: [], fetch: async url => {
+			assert.equal(String(url), "/api/chat");
+			return post.promise;
+		} });
+		const sending = m.send({ type: "text", text: "hello" }, () => { notified++; });
+		m.stop();
+		post.resolve(Response.json({ ok: true }));
+		assert.equal(await sending, true);
+		assert.equal(notified, 1);
+	});
+
+	for (const failure of ["refusal", "409", "lost acknowledgment"] as const) {
+		it(`${failure} does not notify acceptance or leave a false confirmed conversation`, async () => {
+			let notified = false;
+			const m = new SessionModel({ chatId: "c1", initialMessages: [], waitMaxMs: 0, fetch: async () => {
+				if (failure === "lost acknowledgment") throw new TypeError("connection lost");
+				return new Response("refused", { status: failure === "409" ? 409 : 503 });
+			} });
+			assert.equal(await m.send({ type: "text", text: "keep this" }, () => { notified = true; }), false);
+			assert.equal(notified, false);
+			assert.equal(m.getState().hasConfirmedConversation, false);
+			assert.equal(m.getState().nativeMessages.length, 0, "restore the opening draft, not a stranded optimistic bubble");
+			assert.equal(m.status, "error");
+		});
+	}
+
+	it("post-acceptance attachment failure remains accepted and does not resend input", async () => {
+		let posts = 0;
+		let notified = 0;
+		const m = new SessionModel({ chatId: "c1", initialMessages: [], fetch: async url => {
+			if (String(url) === "/api/chat") { posts++; return Response.json({ ok: true }); }
+			throw new TypeError("record read failed");
+		} });
+		assert.equal(await m.send({ type: "text", text: "hello" }, () => { notified++; }), true);
+		assert.equal(notified, 1);
+		assert.equal(posts, 1);
+		assert.equal(m.status, "error");
+	});
+
+	it("a busy gate sends nothing, then canonical adoption can confirm an earlier lost acknowledgment", async () => {
+		const m = new SessionModel({ chatId: "c1", initialMessages: [], fetch: async () => { throw new Error("must not post"); } });
+		m.readyRef = false;
+		assert.equal(await m.send({ type: "text", text: "hello" }, () => assert.fail("must not acknowledge")), false);
+		m.setMessages([newUserMessage("hello")]);
+		assert.equal(m.getState().hasConfirmedConversation, true);
+	});
+});
@@ -0,0 +1,123 @@
+import assert from "node:assert/strict";
+import { afterEach, beforeEach, describe, it } from "node:test";
+import { clearOpeningPrompt, readOpeningPrompt, readOpeningPromptEntry, stashOpeningPrompt } from "../components/opening-prompt.ts";
+import { SessionStarter } from "../components/start-session.ts";
+
+const original = Object.getOwnPropertyDescriptor(globalThis, "sessionStorage");
+let data: Map<string, string>;
+let storage: Pick<Storage, "getItem" | "setItem" | "removeItem">;
+function install(value: unknown) {
+	Object.defineProperty(globalThis, "sessionStorage", { configurable: true, value });
+}
+beforeEach(() => {
+	data = new Map();
+	storage = {
+		getItem: key => data.get(key) ?? null,
+		setItem: (key, value) => { data.set(key, value); },
+		removeItem: key => { data.delete(key); },
+	};
+	install(storage);
+});
+afterEach(() => {
+	if (original) Object.defineProperty(globalThis, "sessionStorage", original);
+	else Reflect.deleteProperty(globalThis, "sessionStorage");
+});
+const fail = () => { throw new Error("synthetic storage failure"); };
+
+describe("opening message storage", () => {
+	it("keeps full text off the URL and records attempted delivery before send", () => {
+		const text = "a syllabus with Unicode 世界 & ? # ".repeat(1500);
+		assert.equal(stashOpeningPrompt("c1", text), true);
+		assert.deepEqual(readOpeningPromptEntry("c1"), { text, attempted: false });
+		assert.equal(stashOpeningPrompt("c1", text, true), true);
+		assert.deepEqual(readOpeningPromptEntry("c1"), { text, attempted: true });
+		assert.equal(clearOpeningPrompt("c1"), true);
+		assert.equal(readOpeningPrompt("c1"), undefined);
+	});
+
+	it("treats a legacy raw-text stash conservatively as a possibly attempted send", () => {
+		data.set("lh.openingPrompt.old", "teach me logic");
+		assert.deepEqual(readOpeningPromptEntry("old"), { text: "teach me logic", attempted: true });
+	});
+
+	for (const unavailable of [undefined, null]) {
+		it(`reports unavailable storage (${unavailable}) instead of claiming a safe handover`, () => {
+			install(unavailable);
+			assert.equal(stashOpeningPrompt("c1", "keep this"), false);
+			assert.equal(readOpeningPrompt("c1"), undefined);
+			assert.equal(clearOpeningPrompt("c1"), false);
+		});
+	}
+	it("catches a throwing storage getter", () => {
+		Object.defineProperty(globalThis, "sessionStorage", { configurable: true, get: fail });
+		assert.equal(stashOpeningPrompt("c1", "keep this"), false);
+		assert.equal(readOpeningPrompt("c1"), undefined);
+		assert.equal(clearOpeningPrompt("c1"), false);
+	});
+	for (const method of ["getItem", "setItem", "removeItem"] as const) {
+		it(`contains ${method} exceptions without crashing a source or chat page`, () => {
+			storage[method] = fail;
+			assert.doesNotThrow(() => stashOpeningPrompt("c1", "keep this"));
+			assert.doesNotThrow(() => readOpeningPrompt("c1"));
+			assert.doesNotThrow(() => clearOpeningPrompt("c1"));
+			if (method !== "removeItem") assert.equal(stashOpeningPrompt("c1", "keep this"), false);
+		});
+	}
+	it("does not accept a storage write that failed silently", () => {
+		storage.setItem = () => {};
+		assert.equal(stashOpeningPrompt("c1", "keep this"), false);
+	});
+});
+
+describe("new-session create and handover", () => {
+	function createFetch() {
+		const bodies: unknown[] = [];
+		const fetchLike = (async (_url, init) => {
+			bodies.push(JSON.parse(String(init?.body)));
+			return Response.json({ id: `chat_${bodies.length}` });
+		}) as typeof fetch;
+		return { bodies, fetchLike };
+	}
+	it("refuses navigation on quota failure, then reuses the created session for unchanged retry", async () => {
+		const starter = new SessionStarter();
+		const { bodies, fetchLike } = createFetch();
+		const text = "full text ".repeat(4000);
+		const setItem = storage.setItem;
+		storage.setItem = fail;
+		await assert.rejects(starter.start({ title: text }, fetchLike));
+		assert.equal(bodies.length, 1);
+		storage.setItem = setItem;
+		assert.equal(await starter.start({ title: text }, fetchLike), "/chat/chat_1");
+		assert.equal(bodies.length, 1);
+		assert.equal(readOpeningPrompt("chat_1"), text);
+	});
+	it("reuses creation even when verifying the first storage write failed", async () => {
+		const starter = new SessionStarter();
+		const { bodies, fetchLike } = createFetch();
+		const getItem = storage.getItem;
+		storage.getItem = fail;
+		await assert.rejects(starter.start({ title: "hello" }, fetchLike));
+		storage.getItem = getItem;
+		assert.equal(await starter.start({ title: "hello" }, fetchLike), "/chat/chat_1");
+		assert.equal(bodies.length, 1);
+	});
+	it("changed text, mode, picks or birth settings create a matching new session", async () => {
+		const starter = new SessionStarter();
+		const { bodies, fetchLike } = createFetch();
+		await starter.start({ title: "original" }, fetchLike, "model-a");
+		await starter.start({ title: "edited" }, fetchLike, "model-a");
+		await starter.start({ title: "edited", kind: "practice" }, fetchLike, "model-a");
+		const picked = { title: "edited", kind: "practice" as const, graphContext: { propositions: [{ id: "p1", name: "P", statement: "S" }] } };
+		await starter.start(picked, fetchLike, "model-a");
+		await starter.start(picked, fetchLike, "model-b");
+		assert.equal(bodies.length, 5);
+		assert.equal(readOpeningPrompt("chat_1"), undefined);
+	});
+	it("does not stash or navigate on a refused creation or invalid ID", async () => {
+		for (const response of [new Response("unavailable", { status: 503 }), Response.json({}), Response.json({ id: "../bad?prompt=leak" })]) {
+			const starter = new SessionStarter();
+			await assert.rejects(starter.start({ title: "hello" }, (async () => response) as typeof fetch));
+			assert.equal(data.size, 0);
+		}
+	});
+});
@@ -2,10 +2,24 @@ import React from "react";
 (globalThis as Record<string, unknown>).React = React;

 import { renderToStaticMarkup } from "react-dom/server";
-import { describe, it } from "node:test";
+import { afterEach, beforeEach, describe, it } from "node:test";
 import assert from "node:assert/strict";
 import { DraftShell, startDraftSession } from "../components/new-session.tsx";
-import { clearOpeningPrompt, readOpeningPrompt } from "../components/opening-prompt.ts";
+import { clearOpeningPrompt, readOpeningPrompt, OPENING_PROMPT_FAILURE } from "../components/opening-prompt.ts";
+
+const originalStorage = Object.getOwnPropertyDescriptor(globalThis, "sessionStorage");
+beforeEach(() => {
+	const data = new Map<string, string>();
+	Object.defineProperty(globalThis, "sessionStorage", { configurable: true, value: {
+		getItem: (key: string) => data.get(key) ?? null,
+		setItem: (key: string, value: string) => { data.set(key, value); },
+		removeItem: (key: string) => { data.delete(key); },
+	} });
+});
+afterEach(() => {
+	if (originalStorage) Object.defineProperty(globalThis, "sessionStorage", originalStorage);
+	else Reflect.deleteProperty(globalThis, "sessionStorage");
+});

 /**
 * The sessionless draft view (/chat/new, owner 2026-09-13): "+ New session"
@@ -82,6 +96,12 @@ describe("startDraftSession — the create-on-send contract", () => {
 });

 describe("DraftShell — the sessionless surface", () => {
+	it("storage failure leaves the full draft editable beside the approved error", () => {
+		const html = renderToStaticMarkup(<DraftShell busy={false} text="keep all my text" onChange={() => {}} onSend={() => {}} startError />);
+		assert.ok(html.includes('role="alert"'));
+		assert.ok(html.includes(OPENING_PROMPT_FAILURE));
+		assert.match(html, /<textarea[^>]*>keep all my text<\/textarea>/);
+	});
 	it("renders the composer blob, the stats bar, and the fresh-chat empty state", () => {
 		const html = renderToStaticMarkup(
 			<DraftShell