@btst/stack 4.4.0 → 4.5.1

package/src/plugins/ai-chat/client/components/chat-interface.tsx

@@ -1,5 +1,7 @@
 "use client";
 
+import { persistedHistory } from "../../history";
+
 import { useChat } from "@ai-sdk/react";
 import {
 	useEffect,
@@ -94,30 +96,28 @@ function reconcilePersistedMessageIds(
 	return messages.map((message) => ({
 		...message,
 		id: persistedIds.get(message) ?? message.id,
+		...(persistedMessages.some(
+			(saved) => saved.id === message.id && saved.interrupted,
+		)
+			? { metadata: { ...(message.metadata as object), interrupted: true } }
+			: {}),
 	}));
 }
 
 function persistedMessagesToUiMessages(
 	messages: readonly SerializedMessage[],
 ): UIMessage[] {
-	return messages
-		.filter((message) => message.role !== "data")
-		.map((message) => {
-			let parts: UIMessage["parts"];
-			try {
-				const parsed = JSON.parse(message.content);
-				parts = Array.isArray(parsed)
-					? parsed
-					: [{ type: "text" as const, text: message.content }];
-			} catch {
-				parts = [{ type: "text" as const, text: message.content }];
-			}
-			return {
-				id: message.id,
-				role: message.role as "user" | "assistant" | "system",
-				parts,
-			};
-		});
+	return persistedHistory(messages).map((message) => {
+		// Browser tool callbacks do not resume when saved history is restored.
+		const abandoned = message.parts.some(
+			(part) =>
+				"toolCallId" in part &&
+				(part.state === "input-streaming" || part.state === "input-available"),
+		);
+		return abandoned
+			? { ...message, metadata: { interrupted: true } }
+			: message;
+	});
 }
 
 function ChatActionCheck({
@@ -566,17 +566,19 @@ export function ChatInterface({
 		id: `${chatInstanceId}:${isPublicMode ? "public" : identitySessionVersion}`,
 		transport,
 		onData: ({ type, data }) => {
+			if (!mounted.current || !data || typeof data !== "object") return;
 			if (
-				!isPublicMode ||
-				!mounted.current ||
-				!data ||
-				typeof data !== "object"
+				!isPublicMode &&
+				(identitySessionVersion !== identitySessionGeneration.current ||
+					activeStreamPartitionKey.current !==
+						latestIdentityPartitionKey.current)
 			)
 				return;
 			if (type === "data-context-status" && "compacting" in data) {
 				setIsCompacting(data.compacting === true);
 			}
 			if (
+				isPublicMode &&
 				type === "data-context-checkpoint" &&
 				"summary" in data &&
 				"throughMessageId" in data &&
@@ -726,6 +728,25 @@ export function ChatInterface({
 					).length,
 				});
 			}
+			if (
+				completion?.isAbort ||
+				completion?.isError ||
+				completion?.isDisconnect
+			) {
+				setMessages((current) =>
+					current.map((message) =>
+						message.id === completion.message.id
+							? {
+									...message,
+									metadata: {
+										...(message.metadata as object),
+										interrupted: true,
+									},
+								}
+							: message,
+					),
+				);
+			}
 			// In public mode, skip all persistence-related operations
 			if (isPublicMode) {
 				activeStreamPartitionKey.current = undefined;
@@ -1449,7 +1470,6 @@ export function ChatInterface({
 									variant={isWidget ? "compact" : "default"}
 									onFilesAttached={setAttachedFiles}
 									attachedFiles={attachedFiles}
-									allowAttachments={!isPublicMode}
 									attachmentPermissionFacts={{
 										...(currentConversationId
 											? { conversationId: currentConversationId }

package/src/plugins/ai-chat/client/components/chat-message.tsx

@@ -132,6 +132,12 @@ export function ChatMessage({
 	isRetrying = false,
 }: ChatMessageProps) {
 	const isUser = message.role === "user";
+	const interrupted = Boolean(
+		message.metadata &&
+			typeof message.metadata === "object" &&
+			"interrupted" in message.metadata &&
+			message.metadata.interrupted,
+	);
 
 	const {
 		localization: customLocalization,
@@ -479,10 +485,22 @@ export function ChatMessage({
 									{toolParts.map((part: any) => {
 										const toolName = getToolName(part);
 										const toolCallId = part.toolCallId;
-										const state = part.state as ToolCallState;
+										const unfinished =
+											interrupted &&
+											(part.state === "input-streaming" ||
+												part.state === "input-available");
+										const state = (
+											unfinished ? "output-error" : part.state
+										) as ToolCallState;
 										const input = part.input;
 										const output = part.output;
-										const errorText = part.errorText;
+										const errorText = unfinished
+											? tr(
+													"CHAT_INTERRUPTED",
+													"aiChat.interrupted",
+													"Response interrupted",
+												)
+											: part.errorText;
 										const isLoading =
 											state === "input-streaming" ||
 											state === "input-available";
@@ -513,6 +531,18 @@ export function ChatMessage({
 								</div>
 							)}
 							{/* Text content */}
+							{interrupted && !isStreaming && (
+								<p
+									className="text-xs text-muted-foreground"
+									data-testid="chat-interrupted"
+								>
+									{tr(
+										"CHAT_INTERRUPTED",
+										"aiChat.interrupted",
+										"Response interrupted",
+									)}
+								</p>
+							)}
 							{displayContent ? (
 								<MarkdownContent
 									markdown={displayContent}

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

@@ -13,6 +13,7 @@ export interface AiChatLocalization {
 	CHAT_EMPTY_STATE: string;
 	CHAT_LOADING: string;
 	CHAT_COMPACTING?: string;
+	CHAT_INTERRUPTED?: string;
 	CHAT_ERROR: string;
 	CHAT_RETRY: string;
 

package/src/plugins/ai-chat/db.ts

@@ -21,6 +21,10 @@ export const aiChatSchema = createDbPlugin("aiChat", {
 				type: "string",
 				required: true,
 			},
+			contextCheckpoint: {
+				type: "string",
+				required: false,
+			},
 			createdAt: {
 				type: "date",
 				defaultValue: () => new Date(),
@@ -56,6 +60,10 @@ export const aiChatSchema = createDbPlugin("aiChat", {
 				type: "string",
 				required: true,
 			},
+			interrupted: {
+				type: "boolean",
+				required: false,
+			},
 			createdAt: {
 				type: "date",
 				defaultValue: () => new Date(),

package/src/plugins/ai-chat/history.ts

@@ -0,0 +1,68 @@
+import type { UIMessage } from "ai";
+import type { Message } from "./types";
+
+function isMessagePart(value: unknown): boolean {
+	if (!value || typeof value !== "object" || !("type" in value)) return false;
+	const part = value as Record<string, unknown>;
+	if (typeof part.type !== "string") return false;
+	switch (part.type) {
+		case "text":
+		case "reasoning":
+			return typeof part.text === "string";
+		case "file":
+			return typeof part.url === "string" && typeof part.mediaType === "string";
+		case "source-url":
+			return typeof part.sourceId === "string" && typeof part.url === "string";
+		case "source-document":
+			return (
+				typeof part.sourceId === "string" &&
+				typeof part.mediaType === "string" &&
+				typeof part.title === "string"
+			);
+		case "step-start":
+			return true;
+		default:
+			if (part.type.startsWith("data-")) return "data" in part;
+			return (
+				(part.type.startsWith("tool-") ||
+					(part.type === "dynamic-tool" &&
+						typeof part.toolName === "string")) &&
+				typeof part.toolCallId === "string" &&
+				[
+					"input-streaming",
+					"input-available",
+					"output-available",
+					"output-error",
+				].includes(String(part.state))
+			);
+	}
+}
+
+export function persistedHistory(
+	messages: readonly Pick<Message, "id" | "role" | "content" | "interrupted">[],
+): UIMessage[] {
+	return messages
+		.filter((message) => message.role !== "data")
+		.map((message) => {
+			let parts: UIMessage["parts"];
+			try {
+				const parsed = JSON.parse(message.content);
+				// The old completion writer saved [] for empty assistant replies.
+				// Empty arrays in legacy user text must remain literal text.
+				parts =
+					Array.isArray(parsed) &&
+					(parsed.length > 0 || message.role === "assistant") &&
+					parsed.every(isMessagePart)
+						? parsed
+						: [{ type: "text", text: message.content }];
+			} catch {
+				parts = [{ type: "text", text: message.content }];
+			}
+			return {
+				id: message.id,
+				role: message.role as UIMessage["role"],
+				parts,
+				...(message.interrupted ? { metadata: { interrupted: true } } : {}),
+			};
+		});
+}

package/src/plugins/ai-chat/types.ts

@@ -15,6 +15,8 @@ export type Message = {
 	conversationId: string;
 	role: "system" | "user" | "assistant" | "data";
 	content: string;
+	/** True when generation stopped before a successful completion. */
+	interrupted?: boolean | null;
 	createdAt: Date;
 };