Replace the conversation cache with a one-shot create-to-load handoff

Author: gary149

src/lib/utils/conversationCache.ts

@@ -0,0 +1,53 @@
+import { browser } from "$app/environment";
+import type { Message } from "$lib/types/Message";
+import type { DeployedSpace } from "$lib/types/Conversation";
+
+// Payload shape of GET /api/v2/conversations/[id] (post superjson-parse),
+// shared by the page load and the create-conversation seed.
+export interface ConversationData {
+	messages: Message[];
+	title: string;
+	model: string;
+	preprompt?: string;
+	rootMessageId?: string;
+	id: string;
+	updatedAt: Date;
+	modelId: string;
+	shared: boolean;
+	deployedSpaces?: Record<string, DeployedSpace>;
+}
+
+// One-shot handoff of the conversation payload embedded in the create
+// response: POST /conversation seeds it, and the very next load of that
+// conversation consumes (and deletes) it, skipping the GET that otherwise
+// sits between conversation creation and the first generation request.
+//
+// Deliberately NOT a cache: an entry lives for the milliseconds between
+// goto() and the page load, is read at most once, and every later load of
+// the conversation always fetches fresh data. That keeps this immune to the
+// staleness classes a real cache has to manage (deletes from other tabs,
+// invalidation ordering, session changes).
+//
+// Browser-only: module state on the server is shared across requests.
+const pending = new Map<string, ConversationData>();
+
+// An entry is only orphaned if the goto() after create never happens (e.g.
+// navigation error); keep the map bounded anyway.
+const MAX_ENTRIES = 2;
+
+export function seedPendingConversation(id: string, data: ConversationData): void {
+	if (!browser) return;
+	pending.set(id, data);
+	if (pending.size > MAX_ENTRIES) {
+		const oldest = pending.keys().next().value;
+		if (oldest !== undefined) pending.delete(oldest);
+	}
+}
+
+/** Returns the seeded payload at most once, deleting it on read. */
+export function takePendingConversation(id: string): ConversationData | undefined {
+	if (!browser) return undefined;
+	const data = pending.get(id);
+	pending.delete(id);
+	return data;
+}

src/lib/utils/pendingConversation.ts

@@ -25,7 +25,6 @@
 	import BackgroundGenerationPoller from "$lib/components/BackgroundGenerationPoller.svelte";
 	import { requireAuthUser } from "$lib/utils/auth";
 	import { createConversationsStore } from "$lib/stores/conversations.svelte";
-	import { invalidateCachedConversation } from "$lib/utils/conversationCache";
 
 	let { data = $bindable(), children } = $props();
 
@@ -74,9 +73,6 @@
 			.then(handleResponse)
 			.then(async () => {
 				convsStore.remove(id);
-				// Drop any cached copy so a back-navigation to the deleted
-				// conversation cannot render it from cache.
-				invalidateCachedConversation(id);
 
 				if (page.params.id === id) {
 					await goto(`${base}/`, { invalidateAll: true });

src/routes/+layout.svelte

@@ -10,7 +10,7 @@
 	import { ERROR_MESSAGES, error } from "$lib/stores/errors";
 	import { storePendingFiles } from "$lib/utils/pendingFiles";
 	import superjson from "superjson";
-	import { setCachedConversation, type ConversationData } from "$lib/utils/conversationCache";
+	import { seedPendingConversation, type ConversationData } from "$lib/utils/pendingConversation";
 	import { useSettingsStore } from "$lib/stores/settings.js";
 	import { useConversationsStore } from "$lib/stores/conversations.svelte";
 	import { findCurrentModel } from "$lib/utils/models";
@@ -78,12 +78,12 @@
 
 			const { conversationId, conversation } = await res.json();
 
-			// The create response embeds the conversation payload; seed the client
-			// cache with it so the conversation page load skips its GET and the
-			// first generation request starts one round-trip sooner.
+			// The create response embeds the conversation payload; hand it to the
+			// conversation page as a one-shot seed so its load skips the GET and
+			// the first generation request starts one round-trip sooner.
 			if (typeof conversation === "string") {
 				try {
-					setCachedConversation(conversationId, superjson.parse<ConversationData>(conversation));
+					seedPendingConversation(conversationId, superjson.parse<ConversationData>(conversation));
 				} catch {
 					// Malformed seed: the page load falls back to a normal fetch.
 				}

src/routes/+page.svelte

@@ -3,72 +3,8 @@ import { UrlDependency } from "$lib/types/UrlDependency";
 import { redirect } from "@sveltejs/kit";
 import { base } from "$app/paths";
 import { browser } from "$app/environment";
-import { safeInvalidate } from "$lib/utils/safeInvalidate";
 import type { PageLoad } from "./$types";
-import {
-	CONVERSATION_CACHE_FRESH_MS,
-	conversationFingerprint,
-	getCachedConversation,
-	invalidateCachedConversation,
-	setCachedConversation,
-	type ConversationData,
-} from "$lib/utils/conversationCache";
-
-// Id of the conversation the previous load() call served. A repeat load for
-// the same id means invalidate(UrlDependency.Conversation) ran (stream
-// finished, model switch, background poller) and fresh data is expected; only
-// a load for a different id is a navigation that may be served from cache.
-let lastLoadedId: string | undefined;
-
-async function fetchConversation(
-	client: ReturnType<typeof useAPIClient>,
-	id: string,
-	fromShare: string | undefined
-): Promise<ConversationData> {
-	return (await client
-		.conversations({ id })
-		.get({ query: { fromShare } })
-		.then(handleResponse)) as ConversationData;
-}
-
-// Serve-stale-then-revalidate: fetch fresh data off the critical path and, if
-// it differs from what the cache (and thus the page) currently shows, refresh
-// the cache and re-run the load — which then hits the updated, fresh entry.
-function revalidateInBackground(
-	client: ReturnType<typeof useAPIClient>,
-	id: string,
-	fromShare: string | undefined,
-	served: ConversationData
-) {
-	void client
-		.conversations({ id })
-		.get({ query: { fromShare } })
-		.then((response) => {
-			// The conversation is gone or this session can no longer read it
-			// (deleted in another tab, revoked access, expired session): drop the
-			// entry and re-run the load so the page takes its real error path
-			// (redirect home) instead of keeping the stale view on screen.
-			if (response.status === 401 || response.status === 403 || response.status === 404) {
-				invalidateCachedConversation(id);
-				return safeInvalidate(UrlDependency.Conversation);
-			}
-			// Throws on remaining errors (5xx etc.), handled as transient below.
-			const fresh = handleResponse(response) as ConversationData;
-			if (conversationFingerprint(fresh) === conversationFingerprint(served)) return;
-			setCachedConversation(id, fresh);
-			// safeInvalidate, not invalidate: a raw invalidate() fired from this
-			// background task can cancel an in-flight navigation the user just
-			// started (see safeInvalidate.ts).
-			return safeInvalidate(UrlDependency.Conversation);
-		})
-		.catch(() => {
-			// Transient failure (network blip, server error): only drop the cache
-			// entry; the next real navigation refetches and takes the genuine
-			// error path. Forcing a reload here would bounce the user to the
-			// homepage on a mere network hiccup.
-			invalidateCachedConversation(id);
-		});
-}
+import { takePendingConversation, type ConversationData } from "$lib/utils/pendingConversation";
 
 export const load: PageLoad = async ({ params, depends, fetch, url, parent }) => {
 	depends(UrlDependency.Conversation);
@@ -102,28 +38,24 @@ export const load: PageLoad = async ({ params, depends, fetch, url, parent }) =>
 	}
 
 	const fromShare = url.searchParams.get("fromShare") ?? undefined;
-	const isNavigation = lastLoadedId !== params.id;
-	lastLoadedId = params.id;
 
-	// Share views bypass the cache entirely: their payload depends on the
-	// fromShare parameter, not just the conversation id.
-	if (browser && isNavigation && !fromShare) {
-		const cached = getCachedConversation(params.id);
-		if (cached) {
-			if (Date.now() - cached.fetchedAt > CONVERSATION_CACHE_FRESH_MS) {
-				revalidateInBackground(client, params.id, fromShare, cached.data);
-			}
-			return cached.data;
+	// A conversation created by this tab hands its payload over via a one-shot
+	// seed (see pendingConversation.ts), consumed here so the first load after
+	// create skips the network round trip. Every other load, including every
+	// invalidate() re-run, fetches fresh data.
+	if (browser && !fromShare) {
+		const seeded = takePendingConversation(params.id);
+		if (seeded) {
+			return seeded;
 		}
 	}
 
 	// Load conversation (works for both owned and shared conversations)
 	try {
-		const data = await fetchConversation(client, params.id, fromShare);
-		if (browser && !fromShare) {
-			setCachedConversation(params.id, data);
-		}
-		return data;
+		return (await client
+			.conversations({ id: params.id })
+			.get({ query: { fromShare } })
+			.then(handleResponse)) as ConversationData;
 	} catch {
 		redirect(302, `${base}/`);
 	}