@btst/stack 3.0.0-rc.2 → 3.0.0-rc.4

package/src/plugins/ai-chat/client/hooks/chat-hooks.tsx

@@ -1,16 +1,174 @@
 "use client";
 
+import {
+	hashKey,
+	useQueryClient,
+	type UseMutationResult,
+} from "@tanstack/react-query";
+import { useLayoutEffect, useRef } from "react";
+import { buildQueryKey } from "@btst/stack/plugins/client";
 import type { ResourceFormResult } from "@btst/stack/plugins/client/hooks";
-import { usePluginOverrides, useTranslate } from "@btst/stack/context";
+import {
+	useIdentity,
+	useIdentityResolutionPromise,
+	useIdentitySourceGeneration,
+	usePluginOverrides,
+	useStack,
+	useTranslate,
+} from "@btst/stack/context";
 import type {
+	AiChatIdentityPartition,
 	ConversationWithMessages,
 	CreateConversationInput,
 	RenameConversationInput,
 } from "../../query-keys";
+import { aiChatIdentityKey, aiChatResources } from "../../query-keys";
 import type { SerializedConversation, SerializedMessage } from "../../types";
 import type { AiChatPluginOverrides } from "../overrides";
 import { aiChat } from "./ai-chat-resource";
 
+function useAiChatIdentityState(): {
+	partition: AiChatIdentityPartition;
+	isPending: boolean;
+	error?: Error;
+	refetchIdentity: () => Promise<void>;
+} {
+	const { identity, isPending, error, refetch } = useIdentity();
+	const sourceGeneration = useIdentitySourceGeneration();
+	return {
+		partition: isPending
+			? `pending:${sourceGeneration}`
+			: error
+				? `error:${sourceGeneration}`
+				: identity
+					? identity
+					: "anonymous",
+		isPending,
+		...(error ? { error } : {}),
+		refetchIdentity: refetch,
+	};
+}
+
+/** Current auth generation, used to partition protected browser caches. */
+export function useAiChatIdentityPartition() {
+	return useAiChatIdentityState().partition;
+}
+
+function isUnresolvedIdentityPartition(
+	partition: ReturnType<typeof useAiChatIdentityPartition>,
+) {
+	return (
+		typeof partition === "string" &&
+		(partition.startsWith("pending:") || partition.startsWith("error:"))
+	);
+}
+
+function samePartition(
+	left: ReturnType<typeof useAiChatIdentityPartition>,
+	right: ReturnType<typeof useAiChatIdentityPartition>,
+) {
+	return (
+		hashKey([aiChatIdentityKey(left)]) === hashKey([aiChatIdentityKey(right)])
+	);
+}
+
+function queryBelongsToPartition(
+	queryKey: readonly unknown[],
+	partition: ReturnType<typeof useAiChatIdentityPartition>,
+) {
+	const marker = queryKey[3] as { identity?: unknown } | undefined;
+	if (partition === undefined) return marker === undefined;
+	return Boolean(
+		marker &&
+			hashKey([marker.identity]) === hashKey([aiChatIdentityKey(partition)]),
+	);
+}
+
+function useCurrentHistoryRefresh() {
+	const { queryClient: stackQueryClient } = useStack();
+	const queryClient = useQueryClient(stackQueryClient);
+	const { partition: identityPartition } = useAiChatIdentityState();
+	const latestPartition = useRef(identityPartition);
+	const mounted = useRef(true);
+	useLayoutEffect(() => {
+		latestPartition.current = identityPartition;
+	}, [identityPartition]);
+	useLayoutEffect(() => {
+		mounted.current = true;
+		return () => {
+			mounted.current = false;
+		};
+	}, []);
+
+	const refreshAfterSuccess = async (
+		startedAs: typeof identityPartition,
+		queryKey: readonly unknown[] = ["conversations"],
+	) => {
+		const current = latestPartition.current;
+		if (!mounted.current || !samePartition(startedAs, current)) {
+			queryClient.removeQueries({
+				queryKey: ["conversations"],
+				predicate: ({ queryKey }) =>
+					queryBelongsToPartition(queryKey, startedAs),
+			});
+			return;
+		}
+		await queryClient.invalidateQueries({
+			queryKey,
+			predicate: ({ queryKey }) => queryBelongsToPartition(queryKey, current),
+			refetchType: "all",
+		});
+	};
+	const removeConversationDetail = (
+		id: string,
+		partition: typeof identityPartition,
+	) => {
+		queryClient.removeQueries({
+			queryKey: buildQueryKey(
+				"conversations",
+				"detail",
+				aiChatResources.conversations.queries.detail,
+				[id, partition],
+			),
+			exact: true,
+		});
+	};
+
+	return {
+		currentPartition: () => identityPartition,
+		refreshAfterSuccess,
+		removeConversationDetail,
+	};
+}
+
+function withCurrentHistoryRefresh<TData, TVariables>(
+	mutation: UseMutationResult<TData, Error, TVariables>,
+	refresh: ReturnType<typeof useCurrentHistoryRefresh>,
+	queryKey?: readonly unknown[],
+	afterSuccess?: (
+		variables: TVariables,
+		startedAs: ReturnType<typeof useAiChatIdentityPartition>,
+	) => void,
+): UseMutationResult<TData, Error, TVariables> {
+	const mutateAsync: typeof mutation.mutateAsync = async (
+		variables,
+		options,
+	) => {
+		const startedAs = refresh.currentPartition();
+		const result = await mutation.mutateAsync(variables, options);
+		try {
+			await refresh.refreshAfterSuccess(startedAs, queryKey);
+		} finally {
+			afterSuccess?.(variables, startedAs);
+		}
+		return result;
+	};
+	const mutate: typeof mutation.mutate = (variables, options) => {
+		void mutateAsync(variables, options).catch(() => {});
+	};
+	return { ...mutation, mutate, mutateAsync };
+}
+
 /** Options for the useConversations hook. */
 export interface UseConversationsOptions {
 	/** Whether to enable the query (default: true). */
@@ -29,15 +187,29 @@ export interface UseConversationsResult {
 export function useConversations(
 	options: UseConversationsOptions = {},
 ): UseConversationsResult {
-	const query = aiChat.conversations.list.use([], {
-		enabled: options.enabled ?? true,
+	const {
+		partition: identityPartition,
+		isPending: isIdentityPending,
+		error: identityError,
+		refetchIdentity,
+	} = useAiChatIdentityState();
+	const query = aiChat.conversations.list.use([identityPartition], {
+		enabled:
+			(options.enabled ?? true) &&
+			!isUnresolvedIdentityPartition(identityPartition),
 	});
 
 	return {
 		conversations: query.data ?? [],
-		isLoading: query.isLoading,
-		error: query.error,
-		refetch: query.refetch,
+		isLoading: isIdentityPending || query.isLoading,
+		error: identityError ?? query.error,
+		refetch: () => {
+			if (isUnresolvedIdentityPartition(identityPartition)) {
+				void refetchIdentity();
+				return;
+			}
+			void query.refetch();
+		},
 	};
 }
 
@@ -46,10 +218,21 @@ export function useSuspenseConversations(): {
 	conversations: SerializedConversation[];
 	refetch: () => Promise<unknown>;
 } {
-	const query = aiChat.conversations.list.useSuspense([]);
+	const {
+		partition: identityPartition,
+		isPending: isIdentityPending,
+		error: identityError,
+		refetchIdentity,
+	} = useAiChatIdentityState();
+	const identityResolution = useIdentityResolutionPromise();
+	const query = aiChat.conversations.list.useSuspense([identityPartition]);
+	if (identityError) throw identityError;
+	if (isIdentityPending) throw identityResolution ?? Promise.resolve();
 	return {
 		conversations: query.data ?? [],
-		refetch: query.refetch,
+		refetch: isUnresolvedIdentityPartition(identityPartition)
+			? refetchIdentity
+			: query.refetch,
 	};
 }
 
@@ -72,15 +255,30 @@ export function useConversation(
 	id?: string,
 	options: UseConversationOptions = {},
 ): UseConversationResult {
-	const query = aiChat.conversations.detail.use([id ?? ""], {
-		enabled: (options.enabled ?? true) && !!id,
+	const {
+		partition: identityPartition,
+		isPending: isIdentityPending,
+		error: identityError,
+		refetchIdentity,
+	} = useAiChatIdentityState();
+	const query = aiChat.conversations.detail.use([id ?? "", identityPartition], {
+		enabled:
+			(options.enabled ?? true) &&
+			!!id &&
+			!isUnresolvedIdentityPartition(identityPartition),
 	});
 
 	return {
 		conversation: query.data ?? null,
-		isLoading: query.isLoading,
-		error: query.error,
-		refetch: query.refetch,
+		isLoading: isIdentityPending || query.isLoading,
+		error: identityError ?? query.error,
+		refetch: () => {
+			if (isUnresolvedIdentityPartition(identityPartition)) {
+				void refetchIdentity();
+				return;
+			}
+			void query.refetch();
+		},
 	};
 }
 
@@ -89,26 +287,53 @@ export function useSuspenseConversation(id: string): {
 	conversation: ConversationWithMessages | null;
 	refetch: () => Promise<unknown>;
 } {
-	const query = aiChat.conversations.detail.useSuspense([id]);
+	const {
+		partition: identityPartition,
+		isPending: isIdentityPending,
+		error: identityError,
+		refetchIdentity,
+	} = useAiChatIdentityState();
+	const identityResolution = useIdentityResolutionPromise();
+	const query = aiChat.conversations.detail.useSuspense([
+		id,
+		identityPartition,
+	]);
+	if (identityError) throw identityError;
+	if (isIdentityPending) throw identityResolution ?? Promise.resolve();
 	return {
 		conversation: query.data ?? null,
-		refetch: query.refetch,
+		refetch: isUnresolvedIdentityPartition(identityPartition)
+			? refetchIdentity
+			: query.refetch,
 	};
 }
 
 /** Create a persisted conversation. */
 export function useCreateConversation() {
-	return aiChat.conversations.create.use();
+	return withCurrentHistoryRefresh(
+		aiChat.conversations.create.use(),
+		useCurrentHistoryRefresh(),
+	);
 }
 
 /** Rename a persisted conversation. */
 export function useRenameConversation() {
-	return aiChat.conversations.rename.use();
+	return withCurrentHistoryRefresh(
+		aiChat.conversations.rename.use(),
+		useCurrentHistoryRefresh(),
+	);
 }
 
 /** Delete a persisted conversation. */
 export function useDeleteConversation() {
-	return aiChat.conversations.delete.use();
+	const historyRefresh = useCurrentHistoryRefresh();
+	return withCurrentHistoryRefresh(
+		aiChat.conversations.delete.use(),
+		historyRefresh,
+		["conversations", "list"],
+		({ id }, startedAs) =>
+			historyRefresh.removeConversationDetail(id, startedAs),
+	);
 }
 
 export interface RenameConversationFormValues {
@@ -131,9 +356,10 @@ export function useRenameConversationForm(
 	SerializedConversation | null
 > {
 	const t = useTranslate();
-	const { localization } = usePluginOverrides<AiChatPluginOverrides>("ai-chat");
+	const { localization } = usePluginOverrides<AiChatPluginOverrides>("aiChat");
+	const historyRefresh = useCurrentHistoryRefresh();
 
-	return aiChat.conversations.useForm<
+	const form = aiChat.conversations.useForm<
 		RenameConversationFormValues,
 		SerializedConversation | null,
 		SerializedConversation
@@ -158,6 +384,13 @@ export function useRenameConversationForm(
 			t("aiChat.toasts.renameFailure", "Failed to rename conversation"),
 		onSuccess: options.onSuccess,
 	});
+	const submit: typeof form.submit = async (values) => {
+		const startedAs = historyRefresh.currentPartition();
+		const result = await form.submit(values);
+		await historyRefresh.refreshAfterSuccess(startedAs);
+		return result;
+	};
+	return { ...form, submit };
 }
 
 export type {

package/src/plugins/ai-chat/client/index.ts

@@ -7,6 +7,7 @@ export type {
 } from "./plugin";
 export type {
 	AiChatPluginOverrides,
+	AiChatProviderConfig,
 	AllowedFileType,
 	ToolCallProps,
 	ToolCallState,

package/src/plugins/ai-chat/client/navigation.ts

@@ -0,0 +1,11 @@
+/** Perform a full-page navigation to a resolved cross-origin AI Chat page. */
+export function navigateAiChatCrossOrigin(
+	href: string,
+	options: { replace?: boolean } = {},
+): void {
+	if (options.replace) {
+		window.location.replace(href);
+		return;
+	}
+	window.location.assign(href);
+}

package/src/plugins/ai-chat/client/overrides.ts

@@ -1,4 +1,5 @@
 import type { ComponentType } from "react";
+import { normalizePath } from "@btst/stack/client";
 import type { AiChatLocalization } from "./localization";
 
 /**
@@ -8,6 +9,52 @@ import type { AiChatLocalization } from "./localization";
  */
 export type AiChatMode = "authenticated" | "public";
 
+/** Browser-safe AI Chat factory values carried by the resolved client stack. */
+export interface AiChatProviderConfig {
+	/** Conversation behavior selected by `aiChatClientPlugin()`. */
+	readonly mode: AiChatMode;
+}
+
+/** Resolve the registered AI Chat client factory mode. */
+export function resolveAiChatMode(
+	providerConfig: Readonly<Record<string, unknown>> | undefined,
+): AiChatMode {
+	return providerConfig?.mode === "public" ? "public" : "authenticated";
+}
+
+/** Join an AI Chat route onto its resolved site mount without duplicate slashes. */
+export function resolveAiChatSitePath(
+	basePath: string,
+	...segments: string[]
+): string {
+	return normalizePath([basePath, ...segments].join("/"));
+}
+
+/** Resolve the browser streaming URL from the effective AI Chat API mount. */
+export function resolveAiChatApiUrl(
+	baseURL: string | undefined,
+	basePath: string | undefined,
+): string {
+	return `${baseURL ?? ""}${normalizePath([basePath ?? "", "chat"].join("/"))}`;
+}
+
+/** Resolve path and absolute URL forms for an AI Chat page destination. */
+export function resolveAiChatSiteLocation(
+	site: { baseURL?: string; basePath: string },
+	currentOrigin: string | undefined,
+	...segments: string[]
+): { path: string; href: string; crossOrigin: boolean } {
+	const path = resolveAiChatSitePath(site.basePath, ...segments);
+	const href = site.baseURL ? `${site.baseURL}${path}` : path;
+	return {
+		path,
+		href,
+		crossOrigin:
+			Boolean(site.baseURL && currentOrigin) &&
+			new URL(href).origin !== currentOrigin,
+	};
+}
+
 /**
  * State of a tool call execution
  */
@@ -96,12 +143,6 @@ export interface RouteContext {
  * plugin-specific components and behavior.
  */
 export interface AiChatPluginOverrides {
-	/**
-	 * Plugin mode - should match backend config
-	 * @default 'authenticated'
-	 */
-	mode?: AiChatMode;
-
 	/**
 	 * Function used to upload a file and return its URL.
 	 * Called for images, PDFs, text files, and other supported file types.
@@ -121,11 +162,6 @@ export interface AiChatPluginOverrides {
 	 */
 	localization?: Partial<AiChatLocalization>;
 
-	/**
-	 * Optional headers to pass with API requests (e.g., for SSR auth)
-	 */
-	headers?: HeadersInit;
-
 	/**
 	 * Whether to show the attribution
 	 * @default true