[chat] Add ai related actions in Explore (#10834)

* [chat][explore]Add extensible log actions framework with standardized contracts

This PR introduces a comprehensive log actions framework that provides a standardized,
extensible contract for registering actions on log entries:
  - Log Actions Contracts: Standardized TypeScript interfaces (LogActionDefinition, LogActionContext, LogActionItemProps)
  - Log Action Registry: Centralized registry system for managing and discovering compatible actions
  - LogActionMenu Component: Reusable dropdown interface that dynamically shows available actions for any log entry
  - Flexible Compatibility System: Actions can define custom logic to determine when they should be available

Signed-off-by: Anan Zhuang <[email protected]>

* fix PR comments and add tests

Signed-off-by: Anan Zhuang <[email protected]>

* Changeset file for PR #10834 created/updated

---------

Signed-off-by: Anan Zhuang <[email protected]>
Co-authored-by: opensearch-changeset-bot[bot] <154024398+opensearch-changeset-bot[bot]@users.noreply.github.com>

Author: ananzh

changelogs/fragments/10834.yml

@@ -0,0 +1,2 @@
+feat:
+- [chat] Add ai related actions in Explore ([#10834](https://github.com/opensearch-project/OpenSearch-Dashboards/pull/10834))

src/plugins/chat/public/components/chat_header_button.test.tsx

@@ -36,13 +36,23 @@ describe('ChatHeaderButton', () => {
     mockChatService = {
       sendMessage: jest.fn(),
       newThread: jest.fn(),
+      isWindowOpen: jest.fn().mockReturnValue(false),
+      getWindowMode: jest.fn().mockReturnValue('sidecar'),
+      setWindowState: jest.fn(),
+      setChatWindowRef: jest.fn(),
+      clearChatWindowRef: jest.fn(),
+      onWindowStateChange: jest.fn().mockReturnValue(() => {}),
+      onWindowOpenRequest: jest.fn().mockReturnValue(() => {}),
+      onWindowCloseRequest: jest.fn().mockReturnValue(() => {}),
     } as any;
     mockContextProvider = {};
 
-    // Mock sidecar
-    mockCore.overlays.sidecar.open = jest.fn().mockReturnValue({
+    // Mock sidecar with complete SidecarRef
+    const mockSidecarRef = {
       close: jest.fn(),
-    });
+      onClose: Promise.resolve(),
+    } as any;
+    mockCore.overlays.sidecar.open = jest.fn().mockReturnValue(mockSidecarRef);
     mockCore.overlays.sidecar.setSidecarConfig = jest.fn();
   });
 
@@ -85,4 +95,186 @@ describe('ChatHeaderButton', () => {
       });
     });
   });
+
+  describe('initialization', () => {
+    it('should initialize with window closed state from ChatService', () => {
+      mockChatService.isWindowOpen.mockReturnValue(false);
+
+      render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      expect(mockChatService.isWindowOpen).toHaveBeenCalled();
+      expect(mockChatService.getWindowMode).toHaveBeenCalled();
+    });
+
+    it('should initialize with window open state from ChatService', () => {
+      mockChatService.isWindowOpen.mockReturnValue(true);
+
+      render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      expect(mockChatService.isWindowOpen).toHaveBeenCalled();
+    });
+
+    it('should register ChatWindow ref with ChatService', () => {
+      render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      expect(mockChatService.setChatWindowRef).toHaveBeenCalled();
+    });
+
+    it('should subscribe to ChatService state changes', () => {
+      render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      expect(mockChatService.onWindowStateChange).toHaveBeenCalled();
+      expect(mockChatService.onWindowOpenRequest).toHaveBeenCalled();
+      expect(mockChatService.onWindowCloseRequest).toHaveBeenCalled();
+    });
+  });
+
+  describe('window state synchronization', () => {
+    it('should respond to ChatService window open request', () => {
+      let openRequestCallback: () => void;
+      mockChatService.onWindowOpenRequest.mockImplementation((cb) => {
+        openRequestCallback = cb;
+        return jest.fn();
+      });
+
+      render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      // Trigger the open request
+      openRequestCallback!();
+
+      expect(mockCore.overlays.sidecar.open).toHaveBeenCalled();
+    });
+
+    it('should respond to ChatService window close request when window is open', async () => {
+      let closeRequestCallback: () => void;
+      const mockClose = jest.fn();
+      const mockSidecarRef = {
+        close: mockClose,
+        onClose: Promise.resolve(),
+      } as any;
+      mockChatService.onWindowCloseRequest.mockImplementation((cb) => {
+        closeRequestCallback = cb;
+        return jest.fn();
+      });
+      mockCore.overlays.sidecar.open.mockReturnValue(mockSidecarRef);
+
+      const { container } = render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      // First open the sidecar by clicking the button
+      const button = container.querySelector('[aria-label="Toggle chat assistant"]') as HTMLElement;
+      button?.click();
+
+      // Wait for the sidecar to be opened
+      await waitFor(() => {
+        expect(mockCore.overlays.sidecar.open).toHaveBeenCalled();
+      });
+
+      // Then trigger the close request
+      closeRequestCallback!();
+
+      // Verify close was called
+      await waitFor(() => {
+        expect(mockClose).toHaveBeenCalled();
+      });
+    });
+
+    it('should sync local state when ChatService state changes', () => {
+      let stateChangeCallback: (isOpen: boolean) => void;
+      mockChatService.onWindowStateChange.mockImplementation((cb) => {
+        stateChangeCallback = cb;
+        return jest.fn();
+      });
+
+      render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      // Trigger state change to open
+      stateChangeCallback!(true);
+
+      // Verify the component reflects the new state (button color should change)
+      const button = document.querySelector('[aria-label="Toggle chat assistant"]');
+      expect(button).toBeTruthy();
+    });
+  });
+
+  describe('cleanup', () => {
+    it('should clear ChatWindow ref on unmount', () => {
+      const { unmount } = render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      unmount();
+
+      expect(mockChatService.clearChatWindowRef).toHaveBeenCalled();
+    });
+
+    it('should close sidecar on unmount if open', () => {
+      const mockClose = jest.fn();
+      mockCore.overlays.sidecar.open.mockReturnValue({
+        close: mockClose,
+        onClose: Promise.resolve(),
+      } as any);
+
+      const { unmount } = render(
+        <ChatHeaderButton
+          core={mockCore}
+          chatService={mockChatService}
+          contextProvider={mockContextProvider}
+        />
+      );
+
+      // Open the sidecar
+      const button = document.querySelector('[aria-label="Toggle chat assistant"]');
+      button?.dispatchEvent(new MouseEvent('click', { bubbles: true }));
+
+      unmount();
+
+      expect(mockClose).toHaveBeenCalled();
+    });
+  });
 });

src/plugins/chat/public/components/chat_header_button.tsx

@@ -32,12 +32,21 @@ interface ChatHeaderButtonProps {
 
 export const ChatHeaderButton = React.forwardRef<ChatHeaderButtonInstance, ChatHeaderButtonProps>(
   ({ core, chatService, contextProvider, charts }, ref) => {
-    const [isOpen, setIsOpen] = useState(false);
-    const [layoutMode, setLayoutMode] = useState<ChatLayoutMode>(ChatLayoutMode.SIDECAR);
+    // Use ChatService as source of truth for window state
+    const [isOpen, setIsOpen] = useState<boolean>(chatService.isWindowOpen());
+    const [layoutMode, setLayoutMode] = useState<ChatLayoutMode>(chatService.getWindowMode());
     const sideCarRef = useRef<{ close: () => void }>();
     const mountPointRef = useRef<HTMLDivElement>(null);
     const chatWindowRef = useRef<ChatWindowInstance>(null);
 
+    // Register ChatWindow ref with ChatService for external access
+    useEffect(() => {
+      chatService.setChatWindowRef(chatWindowRef);
+      return () => {
+        chatService.clearChatWindowRef();
+      };
+    }, [chatService]);
+
     const openSidecar = useCallback(() => {
       if (!mountPointRef.current) return;
 
@@ -70,16 +79,20 @@ export const ChatHeaderButton = React.forwardRef<ChatHeaderButtonInstance, ChatH
         config: sidecarConfig,
       });
 
+      // Notify ChatService that window is now open
+      chatService.setWindowState(true, layoutMode);
       setIsOpen(true);
-    }, [core.overlays, layoutMode]);
+    }, [core.overlays, layoutMode, chatService]);
 
     const closeSidecar = useCallback(() => {
       if (sideCarRef.current) {
         sideCarRef.current.close();
         sideCarRef.current = undefined;
       }
+      // Notify ChatService that window is now closed
+      chatService.setWindowState(false);
       setIsOpen(false);
-    }, []);
+    }, [chatService]);
 
     const toggleSidecar = useCallback(() => {
       if (isOpen) {
@@ -112,7 +125,10 @@ export const ChatHeaderButton = React.forwardRef<ChatHeaderButtonInstance, ChatH
 
         core.overlays.sidecar.setSidecarConfig(newSidecarConfig);
       }
-    }, [layoutMode, isOpen, core.overlays.sidecar]);
+
+      // Update ChatService with new layout mode
+      chatService.setWindowState(isOpen, newLayoutMode);
+    }, [layoutMode, isOpen, chatService, core.overlays.sidecar]);
 
     const startNewConversation = useCallback<ChatHeaderButtonInstance['startNewConversation']>(
       async ({ content }) => {
@@ -125,6 +141,34 @@ export const ChatHeaderButton = React.forwardRef<ChatHeaderButtonInstance, ChatH
 
     useImperativeHandle(ref, () => ({ startNewConversation }), [startNewConversation]);
 
+    // Listen to ChatService window state changes and sync local state
+    useEffect(() => {
+      const unsubscribe = chatService.onWindowStateChange((newIsOpen) => {
+        setIsOpen(newIsOpen);
+      });
+      return unsubscribe;
+    }, [chatService]);
+
+    // Register callbacks for external window open/close requests
+    useEffect(() => {
+      const unsubscribeOpen = chatService.onWindowOpenRequest(() => {
+        if (!isOpen) {
+          openSidecar();
+        }
+      });
+
+      const unsubscribeClose = chatService.onWindowCloseRequest(() => {
+        if (isOpen) {
+          closeSidecar();
+        }
+      });
+
+      return () => {
+        unsubscribeOpen();
+        unsubscribeClose();
+      };
+    }, [chatService, isOpen, openSidecar, closeSidecar]);
+
     // Cleanup on unmount
     useEffect(() => {
       return () => {

src/plugins/chat/public/index.ts

@@ -16,3 +16,4 @@ export function plugin(initializerContext: PluginInitializerContext) {
   return new ChatPlugin(initializerContext);
 }
 export { ChatPluginSetup, ChatPluginStart } from './types';
+export { ChatService } from './services/chat_service';