Merge branch 'release-1.8.0' into fix-agent-component-watsonx

Author: HimavarshaVS

src/frontend/src/components/core/playgroundComponent/chat-view/chat-header/hooks/use-edit-session-info.ts

@@ -37,8 +37,8 @@ export const useEditSessionInfo = ({
   const { mutate: deleteSession } = useDeleteSession();
 
   const handleDelete = (sessionId: string) => {
-    if (sessionId && dbSessions.includes(sessionId)) {
-      deleteSession({ sessionId: sessionId });
+    if (sessionId && flowId) {
+      deleteSession({ sessionId: sessionId, flowId: flowId });
     }
     if (flowId && sessionId === selectedSession) {
       setSelectedSession(flowId);

src/frontend/src/components/core/playgroundComponent/chat-view/chat-header/hooks/use-get-add-sessions.ts

@@ -138,6 +138,7 @@ export const useGetAddSessions: UseGetAddSessionsReturnType = ({
   };
 
   const removeLocalSession = (sessionId: string) => {
+    // Update state - the useEffect on line 67-77 will sync to sessionStorage
     setLocalSessions((prev) => {
       const updated = new Set(prev);
       updated.delete(sessionId);

src/frontend/src/components/core/playgroundComponent/chat-view/chat-messages/hooks/use-chat-history.ts

@@ -4,6 +4,7 @@ import { useGetFlowId } from "@/components/core/playgroundComponent/hooks/use-ge
 import { useGetMessagesQuery } from "@/controllers/API/queries/messages";
 import type { ChatMessageType } from "@/types/chat";
 import type { Message } from "@/types/messages";
+import { isMessageForSession } from "../../utils/session-filter";
 import sortSenderMessages from "../utils/sort-sender-messages";
 
 export const useChatHistory = (visibleSession: string | null) => {
@@ -45,17 +46,20 @@ export const useChatHistory = (visibleSession: string | null) => {
     if (queryData && typeof queryData === "object" && "rows" in queryData) {
       const rowsData = queryData.rows as { data?: Message[] } | undefined;
       if (rowsData && typeof rowsData === "object" && "data" in rowsData) {
-        const backendMessages = rowsData.data || [];
+        const backendMessages = (rowsData.data || []).filter((msg: Message) =>
+          isMessageForSession(msg, currentFlowId, visibleSession),
+        );
+
         const existingCache =
           queryClient.getQueryData<Message[]>(sessionCacheKey) || [];
 
-        // Only initialize if cache is empty and we have backend messages
+        // Only initialize if cache is empty and we have backend messages for this session
         if (existingCache.length === 0 && backendMessages.length > 0) {
           queryClient.setQueryData(sessionCacheKey, backendMessages);
         }
       }
     }
-  }, [queryData, queryClient, sessionCacheKey]);
+  }, [queryData, queryClient, sessionCacheKey, currentFlowId, visibleSession]);
 
   // Use session cache as the single source of truth
   // updateMessage and addUserMessage handle all updates (placeholders, streaming, etc.)
@@ -65,21 +69,10 @@ export const useChatHistory = (visibleSession: string | null) => {
   const chatHistory = useMemo(() => {
     // Filter messages for current session
     const filteredMessages: ChatMessageType[] = messages
-      .filter((message: Message) => {
-        const isCurrentFlow = message.flow_id === currentFlowId;
-        // If visibleSession is the flow_id, it means we are in the default session
-        // In the default session, we show messages that have the same session_id as the flow_id
-        // OR messages that have NO session_id (legacy behavior)
-        if (visibleSession === currentFlowId) {
-          const matches =
-            isCurrentFlow &&
-            (message.session_id === visibleSession || !message.session_id);
-          return matches;
-        }
-        const matches = isCurrentFlow && message.session_id === visibleSession;
-        return matches;
-      })
-      .map((message: Message) => {
+      .filter((message: Message) =>
+        isMessageForSession(message, currentFlowId, visibleSession),
+      )
+      .map((message: Message): ChatMessageType => {
         let files = message.files;
         // Handle the "[]" case, empty string, or already parsed array
         if (Array.isArray(files)) {
@@ -96,6 +89,28 @@ export const useChatHistory = (visibleSession: string | null) => {
         }
         const messageText = message.text || "";
 
+        // Convert Message.properties to ChatMessageType.properties (PropertiesType)
+        // Properties are now properly typed in Message, no cast needed
+        let properties: ChatMessageType["properties"] = undefined;
+        if (message.properties?.source?.id) {
+          properties = {
+            source: {
+              id: message.properties.source.id,
+              display_name: message.properties.source.display_name || "",
+              source: message.properties.source.source || "",
+            },
+            state: message.properties.state,
+            icon: message.properties.icon,
+            background_color: message.properties.background_color,
+            text_color: message.properties.text_color,
+            targets: message.properties.targets,
+            edited: message.properties.edited,
+            allow_markdown: message.properties.allow_markdown,
+            positive_feedback: message.properties.positive_feedback,
+            build_duration: message.properties.build_duration,
+          };
+        }
+
         return {
           isSend: message.sender === "User",
           message: messageText,
@@ -110,7 +125,7 @@ export const useChatHistory = (visibleSession: string | null) => {
           text_color: message.text_color,
           content_blocks: message.content_blocks,
           category: message.category,
-          properties: message.properties,
+          properties: properties,
         };
       });
 

src/frontend/src/components/core/playgroundComponent/chat-view/utils/session-filter.ts

@@ -0,0 +1,31 @@
+import type { Message } from "@/types/messages";
+
+/**
+ * Determines if a message belongs to a specific session.
+ *
+ * Why this logic exists:
+ * - Default session (sessionId === flowId): Shows messages with matching session_id OR no session_id (legacy)
+ * - Named sessions: Only shows messages with exact session_id match
+ * - This prevents cross-session data leakage after deletions
+ *
+ * @param msg - The message to check
+ * @param flowId - The current flow ID
+ * @param sessionId - The session ID to filter for (null means no filtering)
+ * @returns true if the message belongs to the session
+ */
+export function isMessageForSession(
+  msg: Message,
+  flowId: string,
+  sessionId: string | null,
+): boolean {
+  if (!sessionId) return false;
+
+  const isCurrentFlow = msg.flow_id === flowId;
+
+  if (sessionId === flowId) {
+    // Default session: include messages with matching session_id or no session_id (legacy behavior)
+    return isCurrentFlow && (msg.session_id === sessionId || !msg.session_id);
+  }
+
+  return isCurrentFlow && msg.session_id === sessionId;
+}

src/frontend/src/controllers/API/queries/messages/use-delete-sessions.ts

@@ -1,39 +1,98 @@
 import type { UseMutationResult } from "@tanstack/react-query";
-import type { useMutationFunctionType } from "@/types/api";
+import type {
+  DeleteSessionError,
+  DeleteSessionParams,
+  DeleteSessionResponse,
+} from "@/types/messages/session";
 import { api } from "../../api";
 import { getURL } from "../../helpers/constants";
 import { UseRequestProcessor } from "../../services/request-processor";
 
-interface DeleteSessionParams {
-  sessionId: string;
-}
-
-export const useDeleteSession: useMutationFunctionType<
-  undefined,
-  DeleteSessionParams
-> = (options?) => {
+export const useDeleteSession = (options?: {
+  onSuccess?: (
+    data: DeleteSessionResponse,
+    variables: DeleteSessionParams,
+    context: unknown,
+  ) => void;
+  onSettled?: (
+    data: DeleteSessionResponse | undefined,
+    error: DeleteSessionError | null,
+    variables: DeleteSessionParams,
+    context: unknown,
+  ) => void;
+  onError?: (error: DeleteSessionError) => void;
+}) => {
   const { mutate, queryClient } = UseRequestProcessor();
 
   const deleteSession = async ({
     sessionId,
-  }: DeleteSessionParams): Promise<any> => {
+  }: DeleteSessionParams): Promise<DeleteSessionResponse> => {
     const response = await api.delete(
       `${getURL("MESSAGES")}/session/${sessionId}`,
     );
     return response.data;
   };
 
   const mutation: UseMutationResult<
-    DeleteSessionParams,
-    any,
+    DeleteSessionResponse,
+    DeleteSessionError,
     DeleteSessionParams
   > = mutate(["useDeleteSession"], deleteSession, {
     ...options,
-    onSettled: (data, error, variables, context) => {
+    onSuccess: (data, variables, context, ...rest) => {
+      // Cast needed because UseRequestProcessor's mutate doesn't properly infer callback types
+      const vars = variables as unknown as DeleteSessionParams;
+
+      // Remove all message queries for this session immediately to prevent stale data
+      if (vars.flowId) {
+        // Remove session-specific queries
+        queryClient.removeQueries({
+          queryKey: [
+            "useGetMessagesQuery",
+            { id: vars.flowId, session_id: vars.sessionId },
+          ],
+        });
+
+        // Also remove any queries that might have the session_id in params (e.g., Message Logs)
+        queryClient.removeQueries({
+          predicate: (query) => {
+            const queryKey = query.queryKey;
+            if (
+              Array.isArray(queryKey) &&
+              queryKey[0] === "useGetMessagesQuery"
+            ) {
+              const params = queryKey[1] as Record<string, unknown>;
+              if (params?.params && typeof params.params === "object") {
+                const nestedParams = params.params as Record<string, unknown>;
+                if (nestedParams.session_id === vars.sessionId) {
+                  return true;
+                }
+              }
+            }
+            return false;
+          },
+        });
+      }
+      options?.onSuccess?.(data, vars, context);
+    },
+    onSettled: (data, error, variables, context, ...rest) => {
+      // Cast needed because UseRequestProcessor's mutate doesn't properly infer callback types
+      const vars = variables as unknown as DeleteSessionParams;
+
+      // Invalidate sessions list to refresh the sidebar
       queryClient.invalidateQueries({
         queryKey: ["useGetSessionsFromFlowQuery"],
       });
-      options?.onSettled?.(data, error, variables, context);
+
+      // Invalidate all message queries to ensure fresh data everywhere
+      if (vars.flowId) {
+        queryClient.invalidateQueries({
+          queryKey: ["useGetMessagesQuery"],
+          refetchType: "none", // Prevent automatic refetching to avoid race conditions
+        });
+      }
+
+      options?.onSettled?.(data, error, vars, context);
     },
   });
 

src/frontend/src/modals/IOModal/components/session-view.tsx

@@ -56,9 +56,7 @@ export default function SessionView({
       const rowsData = queryData.rows as { data?: any[] } | undefined;
       if (rowsData && typeof rowsData === "object" && "data" in rowsData) {
         const fetchedMessages = rowsData.data || [];
-        if (fetchedMessages.length > 0) {
-          setMessages(fetchedMessages);
-        }
+        setMessages(fetchedMessages);
       }
     }
   }, [queryData, setMessages]);

src/frontend/src/types/messages/index.ts

@@ -15,7 +15,19 @@ type Message = {
   category?: string;
   properties?: {
     state?: "partial" | "complete";
-    source?: { id?: string };
+    source?: {
+      id?: string;
+      display_name?: string;
+      source?: string;
+    };
+    icon?: string;
+    background_color?: string;
+    text_color?: string;
+    targets?: string[];
+    edited?: boolean;
+    allow_markdown?: boolean;
+    positive_feedback?: boolean | null;
+    build_duration?: number | null;
     [key: string]: unknown;
   };
   content_blocks?: ContentBlock[];

src/frontend/src/types/messages/session.ts

@@ -0,0 +1,17 @@
+export interface DeleteSessionParams {
+  sessionId: string;
+  flowId?: string;
+}
+
+export interface DeleteSessionResponse {
+  message: string;
+}
+
+export interface DeleteSessionError {
+  response?: {
+    data?: {
+      detail?: string;
+    };
+  };
+  message?: string;
+}