Merge remote-tracking branch 'upstream/dev' into feat/inbox

surfsense_web/app/dashboard/[search_space_id]/new-chat/[[...chat_id]]/page.tsx

@@ -42,9 +42,11 @@ import { RecallMemoryToolUI, SaveMemoryToolUI } from "@/components/tool-ui/user-
 import { Spinner } from "@/components/ui/spinner";
 import { useChatSessionStateSync } from "@/hooks/use-chat-session-state";
 import { useMessagesElectric } from "@/hooks/use-messages-electric";
+import { publicChatApiService } from "@/lib/apis/public-chat-api.service";
 // import { WriteTodosToolUI } from "@/components/tool-ui/write-todos";
 import { getBearerToken } from "@/lib/auth-utils";
 import { createAttachmentAdapter, extractAttachmentContent } from "@/lib/chat/attachment-adapter";
+import { convertToThreadMessage } from "@/lib/chat/message-utils";
 import {
 	isPodcastGenerating,
 	looksLikePodcastRequest,
@@ -114,112 +116,6 @@ function extractMentionedDocuments(content: unknown): MentionedDocumentInfo[] {
 	return [];
 }
 
-/**
- * Zod schema for persisted attachment info
- */
-const PersistedAttachmentSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	type: z.string(),
-	contentType: z.string().optional(),
-	imageDataUrl: z.string().optional(),
-	extractedContent: z.string().optional(),
-});
-
-const AttachmentsPartSchema = z.object({
-	type: z.literal("attachments"),
-	items: z.array(PersistedAttachmentSchema),
-});
-
-type PersistedAttachment = z.infer<typeof PersistedAttachmentSchema>;
-
-/**
- * Extract persisted attachments from message content (type-safe with Zod)
- */
-function extractPersistedAttachments(content: unknown): PersistedAttachment[] {
-	if (!Array.isArray(content)) return [];
-
-	for (const part of content) {
-		const result = AttachmentsPartSchema.safeParse(part);
-		if (result.success) {
-			return result.data.items;
-		}
-	}
-
-	return [];
-}
-
-/**
- * Convert backend message to assistant-ui ThreadMessageLike format
- * Filters out 'thinking-steps' part as it's handled separately via messageThinkingSteps
- * Restores attachments for user messages from persisted data
- */
-function convertToThreadMessage(msg: MessageRecord): ThreadMessageLike {
-	let content: ThreadMessageLike["content"];
-
-	if (typeof msg.content === "string") {
-		content = [{ type: "text", text: msg.content }];
-	} else if (Array.isArray(msg.content)) {
-		// Filter out custom metadata parts - they're handled separately
-		const filteredContent = msg.content.filter((part: unknown) => {
-			if (typeof part !== "object" || part === null || !("type" in part)) return true;
-			const partType = (part as { type: string }).type;
-			// Filter out thinking-steps, mentioned-documents, and attachments
-			return (
-				partType !== "thinking-steps" &&
-				partType !== "mentioned-documents" &&
-				partType !== "attachments"
-			);
-		});
-		content =
-			filteredContent.length > 0
-				? (filteredContent as ThreadMessageLike["content"])
-				: [{ type: "text", text: "" }];
-	} else {
-		content = [{ type: "text", text: String(msg.content) }];
-	}
-
-	// Restore attachments for user messages
-	let attachments: ThreadMessageLike["attachments"];
-	if (msg.role === "user") {
-		const persistedAttachments = extractPersistedAttachments(msg.content);
-		if (persistedAttachments.length > 0) {
-			attachments = persistedAttachments.map((att) => ({
-				id: att.id,
-				name: att.name,
-				type: att.type as "document" | "image" | "file",
-				contentType: att.contentType || "application/octet-stream",
-				status: { type: "complete" as const },
-				content: [],
-				// Custom fields for our ChatAttachment interface
-				imageDataUrl: att.imageDataUrl,
-				extractedContent: att.extractedContent,
-			}));
-		}
-	}
-
-	// Build metadata.custom for author display in shared chats
-	const metadata = msg.author_id
-		? {
-				custom: {
-					author: {
-						displayName: msg.author_display_name ?? null,
-						avatarUrl: msg.author_avatar_url ?? null,
-					},
-				},
-			}
-		: undefined;
-
-	return {
-		id: `msg-${msg.id}`,
-		role: msg.role,
-		content,
-		createdAt: new Date(msg.created_at),
-		attachments,
-		metadata,
-	};
-}
-
 /**
  * Tools that should render custom UI in the chat.
  */
@@ -246,6 +142,7 @@ export default function NewChatPage() {
 	const params = useParams();
 	const queryClient = useQueryClient();
 	const [isInitializing, setIsInitializing] = useState(true);
+	const [isCompletingClone, setIsCompletingClone] = useState(false);
 	const [threadId, setThreadId] = useState<number | null>(null);
 	const [currentThread, setCurrentThread] = useState<ThreadRecord | null>(null);
 	const [messages, setMessages] = useState<ThreadMessageLike[]>([]);
@@ -300,6 +197,12 @@ export default function NewChatPage() {
 						? membersData?.find((m) => m.user_id === msg.author_id)
 						: null;
 
+					// Preserve existing author info if member lookup fails (e.g., cloned chats)
+					const existingMsg = prev.find((m) => m.id === `msg-${msg.id}`);
+					const existingAuthor = existingMsg?.metadata?.custom?.author as
+						| { displayName?: string | null; avatarUrl?: string | null }
+						| undefined;
+
 					return convertToThreadMessage({
 						id: msg.id,
 						thread_id: msg.thread_id,
@@ -307,8 +210,8 @@ export default function NewChatPage() {
 						content: msg.content,
 						author_id: msg.author_id,
 						created_at: msg.created_at,
-						author_display_name: member?.user_display_name ?? null,
-						author_avatar_url: member?.user_avatar_url ?? null,
+						author_display_name: member?.user_display_name ?? existingAuthor?.displayName ?? null,
+						author_avatar_url: member?.user_avatar_url ?? existingAuthor?.avatarUrl ?? null,
 					});
 				});
 			});
@@ -428,6 +331,34 @@ export default function NewChatPage() {
 		initializeThread();
 	}, [initializeThread]);
 
+	// Handle clone completion when thread has clone_pending flag
+	useEffect(() => {
+		if (!currentThread?.clone_pending || isCompletingClone) return;
+
+		const completeClone = async () => {
+			setIsCompletingClone(true);
+
+			try {
+				await publicChatApiService.completeClone({ thread_id: currentThread.id });
+
+				// Re-initialize thread to fetch cloned content using existing logic
+				await initializeThread();
+
+				// Invalidate threads query to update sidebar
+				queryClient.invalidateQueries({
+					predicate: (query) => Array.isArray(query.queryKey) && query.queryKey[0] === "threads",
+				});
+			} catch (error) {
+				console.error("[NewChatPage] Failed to complete clone:", error);
+				toast.error("Failed to copy chat content. Please try again.");
+			} finally {
+				setIsCompletingClone(false);
+			}
+		};
+
+		completeClone();
+	}, [currentThread?.clone_pending, currentThread?.id, isCompletingClone, initializeThread, queryClient]);
+
 	// Handle scroll to comment from URL query params (e.g., from inbox item click)
 	const searchParams = useSearchParams();
 	const targetCommentIdParam = searchParams.get("commentId");
@@ -454,6 +385,8 @@ export default function NewChatPage() {
 			visibility: currentThread?.visibility ?? null,
 			hasComments: currentThread?.has_comments ?? false,
 			addingCommentToMessageId: null,
+			publicShareEnabled: currentThread?.public_share_enabled ?? false,
+			publicShareToken: currentThread?.public_share_token ?? null,
 		}));
 	}, [currentThread, setCurrentThreadState]);
 
@@ -880,13 +813,13 @@ export default function NewChatPage() {
 											// Update the tool call with its result
 											updateToolCall(parsed.toolCallId, { result: parsed.output });
 											// Handle podcast-specific logic
-											if (parsed.output?.status === "processing" && parsed.output?.task_id) {
+											if (parsed.output?.status === "pending" && parsed.output?.podcast_id) {
 												// Check if this is a podcast tool by looking at the content part
 												const idx = toolCallIndices.get(parsed.toolCallId);
 												if (idx !== undefined) {
 													const part = contentParts[idx];
 													if (part?.type === "tool-call" && part.toolName === "generate_podcast") {
-														setActivePodcastTaskId(parsed.output.task_id);
+														setActivePodcastTaskId(String(parsed.output.podcast_id));
 													}
 												}
 											}
@@ -1300,12 +1233,12 @@ export default function NewChatPage() {
 
 										case "tool-output-available":
 											updateToolCall(parsed.toolCallId, { result: parsed.output });
-											if (parsed.output?.status === "processing" && parsed.output?.task_id) {
+											if (parsed.output?.status === "pending" && parsed.output?.podcast_id) {
 												const idx = toolCallIndices.get(parsed.toolCallId);
 												if (idx !== undefined) {
 													const part = contentParts[idx];
 													if (part?.type === "tool-call" && part.toolName === "generate_podcast") {
-														setActivePodcastTaskId(parsed.output.task_id);
+														setActivePodcastTaskId(String(parsed.output.podcast_id));
 													}
 												}
 											}
@@ -1478,6 +1411,16 @@ export default function NewChatPage() {
 		);
 	}
 
+	// Show loading state while completing clone
+	if (isCompletingClone) {
+		return (
+			<div className="flex h-[calc(100vh-64px)] flex-col items-center justify-center gap-4">
+				<Spinner size="lg" />
+				<div className="text-sm text-muted-foreground">Copying chat content...</div>
+			</div>
+		);
+	}
+
 	// Show error state only if we tried to load an existing thread but failed
 	// For new chats (urlChatId === 0), threadId being null is expected (lazy creation)
 	if (!threadId && urlChatId > 0) {