diff --git a/client/packages/lowcoder-design/src/components/customSelect.tsx b/client/packages/lowcoder-design/src/components/customSelect.tsx
index 2f13f0db8e..72864178ad 100644
--- a/client/packages/lowcoder-design/src/components/customSelect.tsx
+++ b/client/packages/lowcoder-design/src/components/customSelect.tsx
@@ -20,7 +20,8 @@ const SelectWrapper = styled.div<{ $border?: boolean }>`
     padding: ${(props) => (props.$border ? "0px" : "0 0 0 12px")};
     height: 100%;
     align-items: center;
-    margin-right: 8px;
+    margin-right: 10px;
+    padding-right: 5px;
     background-color: #fff;
 
     .ant-select-selection-item {
@@ -46,9 +47,9 @@ const SelectWrapper = styled.div<{ $border?: boolean }>`
   }
 
   .ant-select-arrow {
-    width: 20px;
-    height: 20px;
-    right: 8px;
+    width: 17px;
+    height: 17px;
+    right: 10px;
     top: 0;
     bottom: 0;
     margin: auto;
diff --git a/client/packages/lowcoder/src/api/userApi.ts b/client/packages/lowcoder/src/api/userApi.ts
index 5955071a84..a65a72338c 100644
--- a/client/packages/lowcoder/src/api/userApi.ts
+++ b/client/packages/lowcoder/src/api/userApi.ts
@@ -63,10 +63,13 @@ export type GetCurrentUserResponse = GenericApiResponse<CurrentUser>;
 export interface GetMyOrgsResponse extends ApiResponse {
   data: {
     data: Array<{
-      orgId: string;
-      orgName: string;
-      createdAt?: number;
-      updatedAt?: number;
+      isCurrentOrg: boolean;
+      orgView: {
+        orgId: string;
+        orgName: string;
+        createdAt?: number;
+        updatedAt?: number;
+      };
     }>;
     pageNum: number;
     pageSize: number;
diff --git a/client/packages/lowcoder/src/components/PermissionDialog/Permission.tsx b/client/packages/lowcoder/src/components/PermissionDialog/Permission.tsx
index 6425d3afc6..adb9e9ffb3 100644
--- a/client/packages/lowcoder/src/components/PermissionDialog/Permission.tsx
+++ b/client/packages/lowcoder/src/components/PermissionDialog/Permission.tsx
@@ -274,7 +274,7 @@ function PermissionTagRender(props: CustomTagProps) {
       color={value}
       closable={closable}
       onClose={onClose}
-      style={{ marginRight: 3 }}
+      style={{ marginRight: 3, display: "flex", alignItems: "center" }}
     >
       {label}
     </StyledTag>
diff --git a/client/packages/lowcoder/src/components/ResCreatePanel.tsx b/client/packages/lowcoder/src/components/ResCreatePanel.tsx
index 04ed9fb79b..e52ea93df0 100644
--- a/client/packages/lowcoder/src/components/ResCreatePanel.tsx
+++ b/client/packages/lowcoder/src/components/ResCreatePanel.tsx
@@ -13,7 +13,7 @@ import { BottomResTypeEnum } from "types/bottomRes";
 import { LargeBottomResIconWrapper } from "util/bottomResUtils";
 import type { PageType } from "../constants/pageConstants";
 import type { SizeType } from "antd/es/config-provider/SizeContext";
-import { Datasource } from "constants/datasourceConstants";
+import { Datasource, QUICK_SSE_HTTP_API_ID } from "constants/datasourceConstants";
 import {
   QUICK_GRAPHQL_ID,
   QUICK_REST_API_ID,
@@ -172,6 +172,7 @@ const ResButton = (props: {
         compType: "streamApi",
       },
     },
+
     alasql: {
       label: trans("query.quickAlasql"),
       type: BottomResTypeEnum.Query,
@@ -179,6 +180,14 @@ const ResButton = (props: {
         compType: "alasql",
       },
     },
+    sseHttpApi: { 
+      label: trans("query.quickSseHttpAPI"),
+      type: BottomResTypeEnum.Query,
+      extra: {
+        compType: "sseHttpApi",
+        dataSourceId: QUICK_SSE_HTTP_API_ID,
+      },
+    },
     graphql: {
       label: trans("query.quickGraphql"),
       type: BottomResTypeEnum.Query,
@@ -339,6 +348,7 @@ export function ResCreatePanel(props: ResCreateModalProps) {
               <DataSourceListWrapper $placement={placement}>
                 <ResButton size={buttonSize} identifier={"restApi"} onSelect={onSelect} />
                 <ResButton size={buttonSize} identifier={"streamApi"} onSelect={onSelect} />
+                <ResButton size={buttonSize} identifier={"sseHttpApi"} onSelect={onSelect} />
                 <ResButton size={buttonSize} identifier={"alasql"} onSelect={onSelect} />
                 <ResButton size={buttonSize} identifier={"graphql"} onSelect={onSelect} />
                 <DataSourceButton size={buttonSize} onClick={() => setCurlModalVisible(true)}>
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/chatComp.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/chatComp.tsx
index d26dce7b29..da3bf6be1e 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/chatComp.tsx
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/chatComp.tsx
@@ -1,46 +1,257 @@
-// client/packages/lowcoder/src/comps/comps/chatComp/chatComp.tsx
-import { UICompBuilder } from "comps/generators";
-import { NameConfig, withExposingConfigs } from "comps/generators/withExposing";
-import { chatChildrenMap } from "./chatCompTypes";
-import { ChatView } from "./chatView";
-import { ChatPropertyView } from "./chatPropertyView";
-import { useEffect, useState } from "react";
-import { changeChildAction } from "lowcoder-core";
-
-// Build the component
-let ChatTmpComp = new UICompBuilder(
-  chatChildrenMap, 
-  (props, dispatch) => {
-    useEffect(() => {
-      if (Boolean(props.tableName)) return;
-
-      // Generate a unique database name for this ChatApp instance
-      const generateUniqueTableName = () => {
-        const timestamp = Date.now();
-        const randomId = Math.random().toString(36).substring(2, 15);
-        return `TABLE_${timestamp}`;
-      };
-      
-      const tableName = generateUniqueTableName();
-      dispatch(changeChildAction('tableName', tableName, true));
-    }, [props.tableName]);
-    
-    if (!props.tableName) {
-      return null; // Don't render until we have a unique DB name
-    }
-    return <ChatView {...props} chatQuery={props.chatQuery.value} />;
-  }
-)
-  .setPropertyViewFn((children) => <ChatPropertyView children={children} />)
-  .build();
-
-ChatTmpComp = class extends ChatTmpComp {
-  override autoHeight(): boolean {
-    return this.children.autoHeight.getView();
-  }
-};
-
-// Export the component
-export const ChatComp = withExposingConfigs(ChatTmpComp, [
-  new NameConfig("text", "Chat component text"),
+// client/packages/lowcoder/src/comps/comps/chatComp/chatComp.tsx
+
+import { UICompBuilder } from "comps/generators";
+import { NameConfig, withExposingConfigs } from "comps/generators/withExposing";
+import { StringControl } from "comps/controls/codeControl";
+import { arrayObjectExposingStateControl, stringExposingStateControl } from "comps/controls/codeStateControl";
+import { withDefault } from "comps/generators";
+import { BoolControl } from "comps/controls/boolControl";
+import { dropdownControl } from "comps/controls/dropdownControl";
+import QuerySelectControl from "comps/controls/querySelectControl";
+import { eventHandlerControl, EventConfigType } from "comps/controls/eventHandlerControl";
+import { ChatCore } from "./components/ChatCore";
+import { ChatPropertyView } from "./chatPropertyView";
+import { createChatStorage } from "./utils/storageFactory";
+import { QueryHandler, createMessageHandler } from "./handlers/messageHandlers";
+import { useMemo, useRef, useEffect } from "react";  
+import { changeChildAction } from "lowcoder-core";
+import { ChatMessage } from "./types/chatTypes";
+
+import "@assistant-ui/styles/index.css";
+import "@assistant-ui/styles/markdown.css";
+
+// ============================================================================
+// CHAT-SPECIFIC EVENTS
+// ============================================================================
+
+export const componentLoadEvent: EventConfigType = {
+  label: "Component Load",
+  value: "componentLoad",
+  description: "Triggered when the chat component finishes loading - Load existing data from backend",
+};
+
+export const messageSentEvent: EventConfigType = {
+  label: "Message Sent",
+  value: "messageSent",
+  description: "Triggered when a user sends a message - Auto-save user messages",
+};
+
+export const messageReceivedEvent: EventConfigType = {
+  label: "Message Received", 
+  value: "messageReceived",
+  description: "Triggered when a response is received from the AI - Auto-save AI responses",
+};
+
+export const threadCreatedEvent: EventConfigType = {
+  label: "Thread Created",
+  value: "threadCreated",
+  description: "Triggered when a new thread is created - Auto-save new threads",
+};
+
+export const threadUpdatedEvent: EventConfigType = {
+  label: "Thread Updated",
+  value: "threadUpdated",
+  description: "Triggered when a thread is updated - Auto-save thread changes",
+};
+
+export const threadDeletedEvent: EventConfigType = {
+  label: "Thread Deleted",
+  value: "threadDeleted",
+  description: "Triggered when a thread is deleted - Delete thread from backend",
+};
+
+const ChatEventOptions = [
+  componentLoadEvent,
+  messageSentEvent,
+  messageReceivedEvent,
+  threadCreatedEvent,
+  threadUpdatedEvent,
+  threadDeletedEvent,
+] as const;
+
+export const ChatEventHandlerControl = eventHandlerControl(ChatEventOptions);
+
+// ============================================================================
+// SIMPLIFIED CHILDREN MAP - WITH EVENT HANDLERS
+// ============================================================================
+
+
+export function addSystemPromptToHistory(
+  conversationHistory: ChatMessage[], 
+  systemPrompt: string
+): Array<{ role: string; content: string; timestamp: number }> {
+  // Format conversation history for use in queries
+  const formattedHistory = conversationHistory.map(msg => ({
+    role: msg.role,
+    content: msg.text,
+    timestamp: msg.timestamp
+  }));
+  
+  // Create system message (always exists since we have default)
+  const systemMessage = [{
+    role: "system" as const,
+    content: systemPrompt,
+    timestamp: Date.now() - 1000000 // Ensure it's always first chronologically
+  }];
+  
+  // Return complete history with system prompt prepended
+  return [...systemMessage, ...formattedHistory];
+}
+
+
+function generateUniqueTableName(): string {
+  return `chat${Math.floor(1000 + Math.random() * 9000)}`;
+ }
+
+const ModelTypeOptions = [
+  { label: "Query", value: "query" },
+  { label: "N8N Workflow", value: "n8n" },
+] as const;
+
+export const chatChildrenMap = {
+  // Storage
+  // Storage (add the hidden property here)
+  _internalDbName: withDefault(StringControl, ""),
+  // Message Handler Configuration
+  handlerType: dropdownControl(ModelTypeOptions, "query"),
+  chatQuery: QuerySelectControl,                    // Only used for "query" type
+  modelHost: withDefault(StringControl, ""),        // Only used for "n8n" type
+  systemPrompt: withDefault(StringControl, "You are a helpful assistant."),
+  streaming: BoolControl.DEFAULT_TRUE,
+  
+  // UI Configuration  
+  placeholder: withDefault(StringControl, "Chat Component"),
+  
+  // Database Information (read-only)
+  databaseName: withDefault(StringControl, ""),
+  
+  // Event Handlers
+  onEvent: ChatEventHandlerControl,
+  
+  // Exposed Variables (not shown in Property View)
+  currentMessage: stringExposingStateControl("currentMessage", ""),
+  conversationHistory: stringExposingStateControl("conversationHistory", "[]"),
+};
+
+// ============================================================================
+// CLEAN CHATCOMP - USES NEW ARCHITECTURE
+// ============================================================================
+
+const ChatTmpComp = new UICompBuilder(
+  chatChildrenMap,
+  (props, dispatch) => {
+
+    const uniqueTableName = useRef<string>();
+      // Generate unique table name once (with persistence)
+    if (!uniqueTableName.current) {
+      // Use persisted name if exists, otherwise generate new one
+      uniqueTableName.current = props._internalDbName || generateUniqueTableName();
+      
+      // Save the name for future refreshes
+      if (!props._internalDbName) {
+        dispatch(changeChildAction("_internalDbName", uniqueTableName.current, false));
+      }
+      
+      // Update the database name in the props for display
+      const dbName = `ChatDB_${uniqueTableName.current}`;
+      dispatch(changeChildAction("databaseName", dbName, false));
+    }
+     // Create storage with unique table name
+     const storage = useMemo(() => 
+      createChatStorage(uniqueTableName.current!), 
+      []
+    );
+    
+    // Create message handler based on type
+    const messageHandler = useMemo(() => {
+      const handlerType = props.handlerType;
+      
+      if (handlerType === "query") {
+        return new QueryHandler({
+          chatQuery: props.chatQuery.value,
+          dispatch,
+          streaming: props.streaming,
+        });
+      } else if (handlerType === "n8n") {
+        return createMessageHandler("n8n", {
+          modelHost: props.modelHost,
+          systemPrompt: props.systemPrompt,
+          streaming: props.streaming
+        });
+      } else {
+        // Fallback to mock handler
+        return createMessageHandler("mock", {
+          chatQuery: props.chatQuery.value,
+          dispatch,
+          streaming: props.streaming
+        });
+      }
+    }, [
+      props.handlerType,
+      props.chatQuery, 
+      props.modelHost,
+      props.systemPrompt,
+      props.streaming,
+      dispatch,
+    ]);
+
+    // Handle message updates for exposed variable
+    const handleMessageUpdate = (message: string) => {
+      dispatch(changeChildAction("currentMessage", message, false));
+      // Trigger messageSent event
+      props.onEvent("messageSent");
+    };
+
+    // Handle conversation history updates for exposed variable
+   // Handle conversation history updates for exposed variable
+const handleConversationUpdate = (conversationHistory: any[]) => {
+  // Use utility function to create complete history with system prompt
+  const historyWithSystemPrompt = addSystemPromptToHistory(
+    conversationHistory, 
+    props.systemPrompt
+  );
+  
+  // Expose the complete history (with system prompt) for use in queries
+  dispatch(changeChildAction("conversationHistory", JSON.stringify(historyWithSystemPrompt), false));
+  
+  // Trigger messageReceived event when bot responds
+  const lastMessage = conversationHistory[conversationHistory.length - 1];
+  if (lastMessage && lastMessage.role === 'assistant') {
+    props.onEvent("messageReceived");
+  }
+};
+
+    // Cleanup on unmount
+    useEffect(() => {
+      return () => {
+        const tableName = uniqueTableName.current;
+        if (tableName) {
+          storage.cleanup();
+        }
+      };
+    }, []);
+
+    return (
+      <ChatCore
+        storage={storage}
+        messageHandler={messageHandler}
+        placeholder={props.placeholder}
+        onMessageUpdate={handleMessageUpdate}
+        onConversationUpdate={handleConversationUpdate}
+        onEvent={props.onEvent}
+      />
+    );
+  }
+)
+.setPropertyViewFn((children) => <ChatPropertyView children={children} />)
+.build();
+
+// ============================================================================
+// EXPORT WITH EXPOSED VARIABLES
+// ============================================================================
+
+export const ChatComp = withExposingConfigs(ChatTmpComp, [
+  new NameConfig("currentMessage", "Current user message"),
+  new NameConfig("conversationHistory", "Full conversation history as JSON array (includes system prompt for API calls)"),
+  new NameConfig("databaseName", "Database name for SQL queries (ChatDB_<componentName>)"),
 ]);
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/chatCompTypes.ts b/client/packages/lowcoder/src/comps/comps/chatComp/chatCompTypes.ts
index 87dca43a37..ecb130c442 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/chatCompTypes.ts
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/chatCompTypes.ts
@@ -1,39 +1,26 @@
-// client/packages/lowcoder/src/comps/comps/chatComp/chatCompTypes.ts
-import { StringControl, NumberControl } from "comps/controls/codeControl";
-import { withDefault } from "comps/generators";
-import { BoolControl } from "comps/controls/boolControl";
-import { dropdownControl } from "comps/controls/dropdownControl";
-import QuerySelectControl from "comps/controls/querySelectControl";
-import { AutoHeightControl } from "@lowcoder-ee/comps/controls/autoHeightControl";
-
-// Model type dropdown options
-const ModelTypeOptions = [
-  { label: "Direct LLM", value: "direct-llm" },
-  { label: "n8n Workflow", value: "n8n" },
-] as const;
-
-export const chatChildrenMap = {
-  text: withDefault(StringControl, "Chat Component Placeholder"),
-  modelType: dropdownControl(ModelTypeOptions, "direct-llm"),
-  modelHost: withDefault(StringControl, ""),
-  streaming: BoolControl.DEFAULT_TRUE,
-  systemPrompt: withDefault(StringControl, "You are a helpful assistant."),
-  agent: BoolControl,
-  maxInteractions: withDefault(NumberControl, 10),
-  chatQuery: QuerySelectControl,
-  autoHeight: AutoHeightControl,
-  tableName: withDefault(StringControl, ""),
-};
-
-export type ChatCompProps = {
-  text?: string;
-  chatQuery?: string;
-  modelType?: string;
-  streaming?: boolean;
-  systemPrompt?: string;
-  agent?: boolean;
-  maxInteractions?: number;
-  modelHost?: string;
-  autoHeight?: boolean;
-  tableName?: string;
-};
\ No newline at end of file
+// client/packages/lowcoder/src/comps/comps/chatComp/chatCompTypes.ts
+
+// ============================================================================
+// CLEAN CHATCOMP TYPES - SIMPLIFIED AND FOCUSED
+// ============================================================================
+
+export type ChatCompProps = {
+  // Storage
+  tableName: string;
+  
+  // Message Handler
+  handlerType: "query" | "n8n";
+  chatQuery: string;        // Only used when handlerType === "query"
+  modelHost: string;        // Only used when handlerType === "n8n"
+  systemPrompt: string;
+  streaming: boolean;
+  
+  // UI
+  placeholder: string;
+  
+  // Exposed Variables
+  currentMessage: string;   // Read-only exposed variable
+};
+
+// Legacy export for backwards compatibility (if needed)
+export type ChatCompLegacyProps = ChatCompProps;
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/chatPropertyView.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/chatPropertyView.tsx
index 2a9143c4ae..793da2b5f1 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/chatPropertyView.tsx
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/chatPropertyView.tsx
@@ -1,35 +1,85 @@
-// client/packages/lowcoder/src/comps/comps/chatComp/chatPropertyView.tsx
-import React from "react";
-import { Section, sectionNames } from "lowcoder-design";
-import { trans } from "i18n";
-
-export const ChatPropertyView = React.memo((props: any) => {
-  const { children } = props;
-
-  return (
-    <>
-      <Section name={sectionNames.basic}>
-        {children.modelType.propertyView({ label: "Model Type" })}
-        {children.modelHost.propertyView({ label: "Model Host" })}
-        {/* {children.text.propertyView({ label: "Text" })}
-        {children.chatQuery.propertyView({ label: "Chat Query" })} */}
-        {children.streaming.propertyView({ label: "Enable Streaming" })}
-        {children.systemPrompt.propertyView({ 
-          label: "System Prompt",
-          placeholder: "Enter system prompt...",
-          enableSpellCheck: false,
-        })}
-        {children.agent.propertyView({ label: "Enable Agent Mode" })}
-        {children.maxInteractions.propertyView({ 
-          label: "Max Interactions",
-          placeholder: "10",
-        })}
-      </Section>
-      <Section name={sectionNames.layout}>
-        {children.autoHeight.propertyView({ label: trans("prop.height") })}
-      </Section>
-    </>
-  );
-});
-
+// client/packages/lowcoder/src/comps/comps/chatComp/chatPropertyView.tsx
+
+import React, { useMemo } from "react";
+import { Section, sectionNames, DocLink } from "lowcoder-design";
+import { placeholderPropertyView } from "../../utils/propertyUtils";
+
+// ============================================================================
+// CLEAN PROPERTY VIEW - FOCUSED ON ESSENTIAL CONFIGURATION
+// ============================================================================
+
+export const ChatPropertyView = React.memo((props: any) => {
+  const { children } = props;
+
+  return useMemo(() => (
+    <>
+      {/* Help & Documentation - Outside of Section */}
+      <div style={{ padding: "8px 16px", marginBottom: "16px", borderBottom: "1px solid #f0f0f0" }}>
+        <DocLink 
+          style={{ marginTop: 8 }} 
+          href="https://docs.lowcoder.cloud/lowcoder-documentation" 
+          title="Open Lowcoder Documentation"
+        >
+          📖 View Documentation
+        </DocLink>
+      </div>
+
+      {/* Message Handler Configuration */}
+      <Section name="Message Handler">
+        {children.handlerType.propertyView({ 
+          label: "Handler Type",
+          tooltip: "How messages are processed"
+        })}
+        
+        {/* Show chatQuery field only for "query" handler */}
+        {children.handlerType.value === "query" && (
+          children.chatQuery.propertyView({ 
+            label: "Chat Query",
+            placeholder: "Select a query to handle messages"
+          })
+        )}
+        
+        {/* Show modelHost field only for "n8n" handler */}
+        {children.handlerType.value === "n8n" && (
+          children.modelHost.propertyView({ 
+            label: "N8N Webhook URL",
+            placeholder: "http://localhost:5678/webhook/...",
+            tooltip: "N8N webhook endpoint for processing messages"
+          })
+        )}
+        
+        {children.systemPrompt.propertyView({ 
+          label: "System Prompt",
+          placeholder: "You are a helpful assistant...",
+          tooltip: "Initial instructions for the AI"
+        })}
+        
+        {children.streaming.propertyView({ 
+          label: "Enable Streaming",
+          tooltip: "Stream responses in real-time (when supported)"
+        })}
+      </Section>
+
+      {/* UI Configuration */}
+      <Section name="UI Configuration">
+        {placeholderPropertyView(children)}
+      </Section>
+
+      {/* Database Information */}
+      <Section name="Database">
+        {children.databaseName.propertyView({ 
+          label: "Database Name",
+          tooltip: "Auto-generated database name for this chat component (read-only)"
+        })}
+      </Section>
+
+      {/* STANDARD EVENT HANDLERS SECTION */}
+      <Section name={sectionNames.interaction}>
+        {children.onEvent.getPropertyView()}
+      </Section>
+
+    </>
+  ), [children]);
+});
+
 ChatPropertyView.displayName = 'ChatPropertyView';
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/chatView.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/chatView.tsx
deleted file mode 100644
index eca764ba6a..0000000000
--- a/client/packages/lowcoder/src/comps/comps/chatComp/chatView.tsx
+++ /dev/null
@@ -1,13 +0,0 @@
-// client/packages/lowcoder/src/comps/comps/chatComp/chatView.tsx
-import React from "react";
-import { ChatCompProps } from "./chatCompTypes";
-import { ChatApp } from "./components/ChatApp";
-
-import "@assistant-ui/styles/index.css";
-import "@assistant-ui/styles/markdown.css";
-
-export const ChatView = React.memo((props: ChatCompProps) => {
-  return <ChatApp {...props} />;
-});
-
-ChatView.displayName = 'ChatView';
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatApp.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatApp.tsx
deleted file mode 100644
index e8092a494b..0000000000
--- a/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatApp.tsx
+++ /dev/null
@@ -1,16 +0,0 @@
-import { ChatProvider } from "./context/ChatContext";
-import { ChatMain } from "./ChatMain";
-import { ChatCompProps } from "../chatCompTypes";
-import { useEffect, useState } from "react";
-
-export function ChatApp(props: ChatCompProps) {
-  if (!Boolean(props.tableName)) {
-    return null; // Don't render until we have a unique DB name
-  }
-  
-  return (
-    <ChatProvider>
-      <ChatMain {...props} />
-    </ChatProvider>
-  );
-}
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCore.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCore.tsx
new file mode 100644
index 0000000000..af867b7f5b
--- /dev/null
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCore.tsx
@@ -0,0 +1,31 @@
+// client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCore.tsx
+
+import React from "react";
+import { ChatProvider } from "./context/ChatContext";
+import { ChatCoreMain } from "./ChatCoreMain";
+import { ChatCoreProps } from "../types/chatTypes";
+
+// ============================================================================
+// CHAT CORE - THE SHARED FOUNDATION
+// ============================================================================
+
+export function ChatCore({ 
+  storage, 
+  messageHandler, 
+  placeholder,
+  onMessageUpdate, 
+  onConversationUpdate,
+  onEvent
+}: ChatCoreProps) {
+  return (
+    <ChatProvider storage={storage}>
+      <ChatCoreMain 
+        messageHandler={messageHandler}
+        placeholder={placeholder}
+        onMessageUpdate={onMessageUpdate}
+        onConversationUpdate={onConversationUpdate}
+        onEvent={onEvent}
+      />
+    </ChatProvider>
+  );
+}
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatMain.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCoreMain.tsx
similarity index 63%
rename from client/packages/lowcoder/src/comps/comps/chatComp/components/ChatMain.tsx
rename to client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCoreMain.tsx
index 14ba061ca7..d89baa8c64 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatMain.tsx
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCoreMain.tsx
@@ -1,255 +1,276 @@
-import React, { useState } from "react";
-import {
-  useExternalStoreRuntime,
-  ThreadMessageLike,
-  AppendMessage,
-  AssistantRuntimeProvider,
-  ExternalStoreThreadListAdapter,
-} from "@assistant-ui/react";
-import { Thread } from "./assistant-ui/thread";
-import { ThreadList } from "./assistant-ui/thread-list";
-import { 
-  useChatContext, 
-  MyMessage, 
-  ThreadData, 
-  RegularThreadData, 
-  ArchivedThreadData 
-} from "./context/ChatContext";
-import styled from "styled-components";
-import { ChatCompProps } from "../chatCompTypes";
-
-const ChatContainer = styled.div<{ $autoHeight?: boolean }>`
-  display: flex;
-  height: ${props => props.$autoHeight ? '500px' : '100%'};
-
-  p {
-    margin: 0;
-  }
-
-  .aui-thread-list-root {
-    width: 250px;
-    background-color: #fff;
-    padding: 10px;
-  }
-
-  .aui-thread-root {
-    flex: 1;
-    background-color: #f9fafb;
-  }
-
-  .aui-thread-list-item {
-    cursor: pointer;
-    transition: background-color 0.2s ease;
-
-    &[data-active="true"] {
-      background-color: #dbeafe;
-      border: 1px solid #bfdbfe;
-    }
-  }
-`;
-
-const generateId = () => Math.random().toString(36).substr(2, 9);
-
-const callYourAPI = async (params: {
-  text: string,
-  modelHost: string,
-  modelType: string,
-}) => {
-  const { text, modelHost, modelType } = params;
-
-  let url = modelHost;
-  if (modelType === "direct-llm") {
-    url = `${modelHost}/api/chat/completions`;
-  }
-
-  // Simulate API delay
-  await new Promise(resolve => setTimeout(resolve, 1500));
-  
-  // Simple responses
-  return {
-    content: "This is a mock response from your backend. You typed: " + text
-  };
-};
-
-export function ChatMain(props: ChatCompProps) {
-  const { state, actions } = useChatContext();
-  const [isRunning, setIsRunning] = useState(false);
-
-  console.log("STATE", state);
-
-  // Get messages for current thread
-  const currentMessages = actions.getCurrentMessages();
-
-  // Convert custom format to ThreadMessageLike
-  const convertMessage = (message: MyMessage): ThreadMessageLike => ({
-    role: message.role,
-    content: [{ type: "text", text: message.text }],
-    id: message.id,
-    createdAt: new Date(message.timestamp),
-  });
-
-  const onNew = async (message: AppendMessage) => {
-    // Extract text from AppendMessage content array
-    if (message.content.length !== 1 || message.content[0]?.type !== "text") {
-      throw new Error("Only text content is supported");
-    }
-
-    // Add user message in custom format
-    const userMessage: MyMessage = {
-      id: generateId(),
-      role: "user",
-      text: message.content[0].text,
-      timestamp: Date.now(),
-    };
-    
-    // Update current thread with new user message
-    await actions.addMessage(state.currentThreadId, userMessage);
-    setIsRunning(true);
-
-    try {
-      // Call mock API
-      const response = await callYourAPI({
-        text: userMessage.text,
-        modelHost: props.modelHost!,
-        modelType: props.modelType!,
-      });
-      
-      const assistantMessage: MyMessage = {
-        id: generateId(),
-        role: "assistant",
-        text: response.content,
-        timestamp: Date.now(),
-      };
-      
-      // Update current thread with assistant response
-      await actions.addMessage(state.currentThreadId, assistantMessage);
-    } catch (error) {
-      // Handle errors gracefully
-      const errorMessage: MyMessage = {
-        id: generateId(),
-        role: "assistant", 
-        text: `Sorry, I encountered an error: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        timestamp: Date.now(),
-      };
-      
-      await actions.addMessage(state.currentThreadId, errorMessage);
-    } finally {
-      setIsRunning(false);
-    }
-  };
-
-  // Add onEdit functionality
-  const onEdit = async (message: AppendMessage) => {
-    // Extract text from AppendMessage content array
-    if (message.content.length !== 1 || message.content[0]?.type !== "text") {
-      throw new Error("Only text content is supported");
-    }
-
-    // Find the index where to insert the edited message
-    const index = currentMessages.findIndex((m) => m.id === message.parentId) + 1;
-
-    // Keep messages up to the parent
-    const newMessages = [...currentMessages.slice(0, index)];
-
-    // Add the edited message in custom format
-    const editedMessage: MyMessage = {
-      id: generateId(),
-      role: "user",
-      text: message.content[0].text,
-      timestamp: Date.now(),
-    };
-    newMessages.push(editedMessage);
-
-    // Update messages using the new context action
-    await actions.updateMessages(state.currentThreadId, newMessages);
-    setIsRunning(true);
-
-    try {
-      // Generate new response
-      const response = await callYourAPI({
-        text: editedMessage.text,
-        modelHost: props.modelHost!,
-        modelType: props.modelType!,
-      });
-      
-      const assistantMessage: MyMessage = {
-        id: generateId(),
-        role: "assistant",
-        text: response.content,
-        timestamp: Date.now(),
-      };
-      
-      newMessages.push(assistantMessage);
-      await actions.updateMessages(state.currentThreadId, newMessages);
-    } catch (error) {
-      // Handle errors gracefully
-      const errorMessage: MyMessage = {
-        id: generateId(),
-        role: "assistant", 
-        text: `Sorry, I encountered an error: ${error instanceof Error ? error.message : 'Unknown error'}`,
-        timestamp: Date.now(),
-      };
-      
-      newMessages.push(errorMessage);
-      await actions.updateMessages(state.currentThreadId, newMessages);
-    } finally {
-      setIsRunning(false);
-    }
-  };
-
-  // Thread list adapter for managing multiple threads
-  const threadListAdapter: ExternalStoreThreadListAdapter = {
-    threadId: state.currentThreadId,
-    threads: state.threadList.filter((t): t is RegularThreadData => t.status === "regular"),
-    archivedThreads: state.threadList.filter((t): t is ArchivedThreadData => t.status === "archived"),
-
-    onSwitchToNewThread: async () => {
-      const threadId = await actions.createThread("New Chat");
-      actions.setCurrentThread(threadId);
-    },
-
-    onSwitchToThread: (threadId) => {
-      actions.setCurrentThread(threadId);
-    },
-
-    onRename: async (threadId, newTitle) => {
-      await actions.updateThread(threadId, { title: newTitle });
-    },
-
-    onArchive: async (threadId) => {
-      await actions.updateThread(threadId, { status: "archived" });
-    },
-
-    onDelete: async (threadId) => {
-      await actions.deleteThread(threadId);
-    },
-  };
-
-  const runtime = useExternalStoreRuntime({
-    messages: currentMessages,
-    setMessages: (messages) => {
-      actions.updateMessages(state.currentThreadId, messages);
-    },
-    convertMessage,
-    isRunning,
-    onNew,
-    onEdit,
-    adapters: {
-      threadList: threadListAdapter,
-    },
-  });
-
-  if (!state.isInitialized) {
-    return <div>Loading...</div>;
-  }
-
-  return (
-    <AssistantRuntimeProvider runtime={runtime}>
-      <ChatContainer $autoHeight={props.autoHeight}>
-        <ThreadList />
-        <Thread />
-      </ChatContainer>
-    </AssistantRuntimeProvider>
-  );
-}
-
+// client/packages/lowcoder/src/comps/comps/chatComp/components/ChatCoreMain.tsx
+
+import React, { useState, useEffect } from "react";
+import {
+  useExternalStoreRuntime,
+  ThreadMessageLike,
+  AppendMessage,
+  AssistantRuntimeProvider,
+  ExternalStoreThreadListAdapter,
+} from "@assistant-ui/react";
+import { Thread } from "./assistant-ui/thread";
+import { ThreadList } from "./assistant-ui/thread-list";
+import { 
+  useChatContext, 
+  ChatMessage, 
+  RegularThreadData, 
+  ArchivedThreadData 
+} from "./context/ChatContext";
+import { MessageHandler } from "../types/chatTypes";
+import styled from "styled-components";
+
+// ============================================================================
+// STYLED COMPONENTS (same as your current ChatMain)
+// ============================================================================
+
+const ChatContainer = styled.div`
+  display: flex;
+  height: 500px;
+
+  p {
+    margin: 0;
+  }
+
+  .aui-thread-list-root {
+    width: 250px;
+    background-color: #fff;
+    padding: 10px;
+  }
+
+  .aui-thread-root {
+    flex: 1;
+    background-color: #f9fafb;
+  }
+
+  .aui-thread-list-item {
+    cursor: pointer;
+    transition: background-color 0.2s ease;
+
+    &[data-active="true"] {
+      background-color: #dbeafe;
+      border: 1px solid #bfdbfe;
+    }
+  }
+`;
+
+// ============================================================================
+// CHAT CORE MAIN - CLEAN PROPS, FOCUSED RESPONSIBILITY
+// ============================================================================
+
+interface ChatCoreMainProps {
+  messageHandler: MessageHandler;
+  placeholder?: string;
+  onMessageUpdate?: (message: string) => void;
+  onConversationUpdate?: (conversationHistory: ChatMessage[]) => void;
+  // STANDARD LOWCODER EVENT PATTERN - SINGLE CALLBACK (OPTIONAL)
+  onEvent?: (eventName: string) => void;
+}
+
+const generateId = () => Math.random().toString(36).substr(2, 9);
+
+export function ChatCoreMain({ 
+  messageHandler, 
+  placeholder,
+  onMessageUpdate, 
+  onConversationUpdate,
+  onEvent
+}: ChatCoreMainProps) {
+  const { state, actions } = useChatContext();
+  const [isRunning, setIsRunning] = useState(false);
+
+  console.log("CHAT CORE STATE", state);
+
+  // Get messages for current thread
+  const currentMessages = actions.getCurrentMessages();
+
+
+  console.log("CURRENT MESSAGES", currentMessages);
+
+  // Notify parent component of conversation changes
+  useEffect(() => {
+    onConversationUpdate?.(currentMessages);
+  }, [currentMessages]);
+
+  // Trigger component load event on mount
+  useEffect(() => {
+    onEvent?.("componentLoad");
+  }, [onEvent]);
+
+  // Convert custom format to ThreadMessageLike (same as your current implementation)
+  const convertMessage = (message: ChatMessage): ThreadMessageLike => ({
+    role: message.role,
+    content: [{ type: "text", text: message.text }],
+    id: message.id,
+    createdAt: new Date(message.timestamp),
+  });
+
+  // Handle new message - MUCH CLEANER with messageHandler
+  const onNew = async (message: AppendMessage) => {
+    // Extract text from AppendMessage content array
+    if (message.content.length !== 1 || message.content[0]?.type !== "text") {
+      throw new Error("Only text content is supported");
+    }
+
+    // Add user message in custom format
+    const userMessage: ChatMessage = {
+      id: generateId(),
+      role: "user",
+      text: message.content[0].text,
+      timestamp: Date.now(),
+    };
+    
+    // Update currentMessage state to expose to queries
+    onMessageUpdate?.(userMessage.text);
+    
+    // Update current thread with new user message
+    await actions.addMessage(state.currentThreadId, userMessage);
+    setIsRunning(true);
+
+    try {
+      
+      // Use the message handler (no more complex logic here!)
+      const response = await messageHandler.sendMessage(userMessage.text);
+
+      console.log("AI RESPONSE", response);
+      
+      const assistantMessage: ChatMessage = {
+        id: generateId(),
+        role: "assistant",
+        text: response.content,
+        timestamp: Date.now(),
+      };
+      
+      // Update current thread with assistant response
+      await actions.addMessage(state.currentThreadId, assistantMessage);
+    } catch (error) {
+      // Handle errors gracefully
+      const errorMessage: ChatMessage = {
+        id: generateId(),
+        role: "assistant", 
+        text: `Sorry, I encountered an error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        timestamp: Date.now(),
+      };
+      
+      await actions.addMessage(state.currentThreadId, errorMessage);
+    } finally {
+      setIsRunning(false);
+    }
+  };
+
+  // Handle edit message - CLEANER with messageHandler
+  const onEdit = async (message: AppendMessage) => {
+    // Extract text from AppendMessage content array
+    if (message.content.length !== 1 || message.content[0]?.type !== "text") {
+      throw new Error("Only text content is supported");
+    }
+
+    // Find the index where to insert the edited message
+    const index = currentMessages.findIndex((m) => m.id === message.parentId) + 1;
+
+    // Keep messages up to the parent
+    const newMessages = [...currentMessages.slice(0, index)];
+
+    // Add the edited message in custom format
+    const editedMessage: ChatMessage = {
+      id: generateId(),
+      role: "user",
+      text: message.content[0].text,
+      timestamp: Date.now(),
+    };
+    newMessages.push(editedMessage);
+
+    // Update currentMessage state to expose to queries
+    onMessageUpdate?.(editedMessage.text);
+
+    // Update messages using the new context action
+    await actions.updateMessages(state.currentThreadId, newMessages);
+    setIsRunning(true);
+
+    try {
+      // Use the message handler (clean!)
+      const response = await messageHandler.sendMessage(editedMessage.text);
+      
+      const assistantMessage: ChatMessage = {
+        id: generateId(),
+        role: "assistant",
+        text: response.content,
+        timestamp: Date.now(),
+      };
+      
+      newMessages.push(assistantMessage);
+      await actions.updateMessages(state.currentThreadId, newMessages);
+    } catch (error) {
+      // Handle errors gracefully
+      const errorMessage: ChatMessage = {
+        id: generateId(),
+        role: "assistant", 
+        text: `Sorry, I encountered an error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        timestamp: Date.now(),
+      };
+      
+      newMessages.push(errorMessage);
+      await actions.updateMessages(state.currentThreadId, newMessages);
+    } finally {
+      setIsRunning(false);
+    }
+  };
+
+  // Thread list adapter for managing multiple threads (same as your current implementation)
+  const threadListAdapter: ExternalStoreThreadListAdapter = {
+    threadId: state.currentThreadId,
+    threads: state.threadList.filter((t): t is RegularThreadData => t.status === "regular"),
+    archivedThreads: state.threadList.filter((t): t is ArchivedThreadData => t.status === "archived"),
+
+    onSwitchToNewThread: async () => {
+      const threadId = await actions.createThread("New Chat");
+      actions.setCurrentThread(threadId);
+      onEvent?.("threadCreated");
+    },
+
+    onSwitchToThread: (threadId) => {
+      actions.setCurrentThread(threadId);
+    },
+
+    onRename: async (threadId, newTitle) => {
+      await actions.updateThread(threadId, { title: newTitle });
+      onEvent?.("threadUpdated");
+    },
+
+    onArchive: async (threadId) => {
+      await actions.updateThread(threadId, { status: "archived" });
+      onEvent?.("threadUpdated");
+    },
+
+    onDelete: async (threadId) => {
+      await actions.deleteThread(threadId);
+      onEvent?.("threadDeleted");
+    },
+  };
+
+  const runtime = useExternalStoreRuntime({
+    messages: currentMessages,
+    setMessages: (messages) => {
+      actions.updateMessages(state.currentThreadId, messages);
+    },
+    convertMessage,
+    isRunning,
+    onNew,
+    onEdit,
+    adapters: {
+      threadList: threadListAdapter,
+    },
+  });
+
+  if (!state.isInitialized) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      <ChatContainer>
+        <ThreadList />
+        <Thread placeholder={placeholder} />
+      </ChatContainer>
+    </AssistantRuntimeProvider>
+  );
+}
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatPanel.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatPanel.tsx
new file mode 100644
index 0000000000..a36c1f38ec
--- /dev/null
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/components/ChatPanel.tsx
@@ -0,0 +1,47 @@
+// client/packages/lowcoder/src/comps/comps/chatComp/components/ChatPanel.tsx
+
+import React, { useMemo } from "react";
+import { ChatCore } from "./ChatCore";
+import { createChatStorage } from "../utils/storageFactory";
+import { N8NHandler } from "../handlers/messageHandlers";
+import { ChatPanelProps } from "../types/chatTypes";
+
+import "@assistant-ui/styles/index.css";
+import "@assistant-ui/styles/markdown.css";
+
+// ============================================================================
+// CHAT PANEL - CLEAN BOTTOM PANEL COMPONENT
+// ============================================================================
+
+export function ChatPanel({
+  tableName,
+  modelHost,
+  systemPrompt = "You are a helpful assistant.",
+  streaming = true,
+  onMessageUpdate
+}: ChatPanelProps) {
+  
+  // Create storage instance
+  const storage = useMemo(() => 
+    createChatStorage(tableName), 
+    [tableName]
+  );
+  
+  // Create N8N message handler
+  const messageHandler = useMemo(() => 
+    new N8NHandler({
+      modelHost,
+      systemPrompt,
+      streaming
+    }), 
+    [modelHost, systemPrompt, streaming]
+  );
+
+  return (
+    <ChatCore
+      storage={storage}
+      messageHandler={messageHandler}
+      onMessageUpdate={onMessageUpdate}
+    />
+  );
+}
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread-list.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread-list.tsx
index 54dcbc5089..af703048cf 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread-list.tsx
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread-list.tsx
@@ -1,16 +1,16 @@
 import type { FC } from "react";
+import { useState } from "react";
 import {
   ThreadListItemPrimitive,
   ThreadListPrimitive,
+  useThreadListItem,
 } from "@assistant-ui/react";
 import { PencilIcon, PlusIcon, Trash2Icon } from "lucide-react";
-
 import { TooltipIconButton } from "./tooltip-icon-button";
 import { useThreadListItemRuntime } from "@assistant-ui/react";
-import { Button, Flex } from "antd";
+import { Button, Flex, Input } from "antd";
 
 import styled from "styled-components";
-import { useChatContext } from "../context/ChatContext";
 
 const StyledPrimaryButton = styled(Button)`
   // padding: 20px;
@@ -44,12 +44,23 @@ const ThreadListItems: FC = () => {
 };
 
 const ThreadListItem: FC = () => {
+  const [editing, setEditing] = useState(false);
+  
   return (
     <ThreadListItemPrimitive.Root className="aui-thread-list-item">
       <ThreadListItemPrimitive.Trigger className="aui-thread-list-item-trigger">
-        <ThreadListItemTitle />
+        {editing ? (
+          <ThreadListItemEditInput 
+            onFinish={() => setEditing(false)} 
+          />
+        ) : (
+          <ThreadListItemTitle />
+        )}
       </ThreadListItemPrimitive.Trigger>
-      <ThreadListItemRename />
+      <ThreadListItemRename 
+        onStartEdit={() => setEditing(true)} 
+        editing={editing}
+      />
       <ThreadListItemDelete />
     </ThreadListItemPrimitive.Root>
   );
@@ -78,37 +89,57 @@ const ThreadListItemDelete: FC = () => {
 };
 
 
-const ThreadListItemRename: FC = () => {
-  const runtime = useThreadListItemRuntime();
+
+const ThreadListItemEditInput: FC<{ onFinish: () => void }> = ({ onFinish }) => {
+  const threadItem = useThreadListItem();
+  const threadRuntime = useThreadListItemRuntime();
   
-  const handleClick = async () => {
-    // runtime doesn't expose a direct `title` prop; read it from its state
-    let current = "";
-    try {
-      // getState is part of the public runtime surface
-      current = (runtime.getState?.() as any)?.title ?? "";
-    } catch {
-      // fallback – generate a title if the runtime provides a helper
-      if (typeof (runtime as any).generateTitle === "function") {
-        // generateTitle(threadId) in older builds, generateTitle() in newer ones
-        current = (runtime as any).generateTitle((runtime as any).threadId ?? undefined);
-      }
+  const currentTitle = threadItem?.title || "New Chat";
+  
+  const handleRename = async (newTitle: string) => {
+    if (!newTitle.trim() || newTitle === currentTitle){
+      onFinish();
+      return;
     }
-
-    const next = prompt("Rename thread", current)?.trim();
-    if (next && next !== current) {
-      await runtime.rename(next);
+    
+    try {
+      await threadRuntime.rename(newTitle);
+      onFinish();
+    } catch (error) {
+      console.error("Failed to rename thread:", error);
     }
   };
 
+  return (
+    <Input
+      size="small"
+      defaultValue={currentTitle}
+      onBlur={(e) => handleRename(e.target.value)}
+      onPressEnter={(e) => handleRename((e.target as HTMLInputElement).value)}
+      onKeyDown={(e) => {
+        if (e.key === 'Escape') onFinish();
+      }}
+      autoFocus
+      style={{ fontSize: '14px', padding: '2px 8px' }}
+    />
+  );
+};
+
+
+const ThreadListItemRename: FC<{ onStartEdit: () => void; editing: boolean }> = ({ 
+  onStartEdit, 
+  editing 
+}) => {
+  if (editing) return null;
+
   return (
     <TooltipIconButton
-      tooltip="Rename thread"
       variant="ghost"
-      onClick={handleClick}
-      className="aui-thread-list-item-rename"
+      tooltip="Rename thread"
+      onClick={onStartEdit}
     >
       <PencilIcon />
     </TooltipIconButton>
   );
-};
\ No newline at end of file
+};
+  
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread.tsx
index ae3749fb77..d28bc07c9e 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread.tsx
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/components/assistant-ui/thread.tsx
@@ -21,10 +21,42 @@ import {
   import { Button } from "../ui/button";
   import { MarkdownText } from "./markdown-text";
   import { TooltipIconButton } from "./tooltip-icon-button";
+  import { Spin, Flex } from "antd";
+  import { LoadingOutlined } from "@ant-design/icons";
+  import styled from "styled-components";
+  const SimpleANTDLoader = () => {
+    const antIcon = <LoadingOutlined style={{ fontSize: 24 }} spin />;
+    
+    return (
+      <div style={{ textAlign: 'left', width: '100%' }}>
+        <Flex align="center" gap={12} style={{ paddingLeft: '16px' }}>
+          <Spin indicator={antIcon} size="small" />
+          <span style={{ color: '#666', fontSize: '14px' }}>Working on it...</span>
+        </Flex>
+      </div>
+    );
+  };
+
+  const StyledThreadRoot = styled(ThreadPrimitive.Root)`
+  /* Hide entire assistant message container when it contains running status */
+  .aui-assistant-message-root:has([data-status="running"]) {
+    display: none;
+  }
   
-  export const Thread: FC = () => {
+  /* Fallback for older browsers that don't support :has() */
+  .aui-assistant-message-content [data-status="running"] {
+    display: none;
+  }
+`;
+
+  
+  interface ThreadProps {
+    placeholder?: string;
+  }
+  
+  export const Thread: FC<ThreadProps> = ({ placeholder = "Write a message..." }) => {
     return (
-      <ThreadPrimitive.Root
+      <StyledThreadRoot
         className="aui-root aui-thread-root"
         style={{
           ["--thread-max-width" as string]: "42rem",
@@ -40,6 +72,10 @@ import {
               AssistantMessage: AssistantMessage,
             }}
           />
+
+          <ThreadPrimitive.If running>
+            <SimpleANTDLoader />
+          </ThreadPrimitive.If>
   
           <ThreadPrimitive.If empty={false}>
             <div className="aui-thread-viewport-spacer" />
@@ -47,10 +83,10 @@ import {
   
           <div className="aui-thread-viewport-footer">
             <ThreadScrollToBottom />
-            <Composer />
+            <Composer placeholder={placeholder} />
           </div>
         </ThreadPrimitive.Viewport>
-      </ThreadPrimitive.Root>
+      </StyledThreadRoot>
     );
   };
   
@@ -110,13 +146,13 @@ import {
     );
   };
   
-  const Composer: FC = () => {
+  const Composer: FC<{ placeholder?: string }> = ({ placeholder = "Write a message..." }) => {
     return (
       <ComposerPrimitive.Root className="aui-composer-root">
         <ComposerPrimitive.Input
           rows={1}
           autoFocus
-          placeholder="Write a message..."
+          placeholder={placeholder}
           className="aui-composer-input"
         />
         <ComposerAction />
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/components/context/ChatContext.tsx b/client/packages/lowcoder/src/comps/comps/chatComp/components/context/ChatContext.tsx
index 41ef892af4..e126109da2 100644
--- a/client/packages/lowcoder/src/comps/comps/chatComp/components/context/ChatContext.tsx
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/components/context/ChatContext.tsx
@@ -1,378 +1,395 @@
-import React, { createContext, useContext, useReducer, useEffect, ReactNode } from "react";
-import { chatStorage, ThreadData as StoredThreadData } from "../../utils/chatStorage";
-
-// Define thread-specific message type
-export interface MyMessage {
-  id: string;
-  role: "user" | "assistant";
-  text: string;
-  timestamp: number;
-}
-
-// Thread data interfaces
-export interface RegularThreadData {
-  threadId: string;
-  status: "regular";
-  title: string;
-}
-
-export interface ArchivedThreadData {
-  threadId: string;
-  status: "archived";
-  title: string;
-}
-
-export type ThreadData = RegularThreadData | ArchivedThreadData;
-
-// Chat state interface
-interface ChatState {
-  isInitialized: boolean;
-  isLoading: boolean;
-  currentThreadId: string;
-  threadList: ThreadData[];
-  threads: Map<string, MyMessage[]>;
-  lastSaved: number; // Timestamp for tracking when data was last saved
-}
-
-// Action types
-type ChatAction =
-  | { type: "INITIALIZE_START" }
-  | { type: "INITIALIZE_SUCCESS"; threadList: ThreadData[]; threads: Map<string, MyMessage[]>; currentThreadId: string }
-  | { type: "INITIALIZE_ERROR" }
-  | { type: "SET_CURRENT_THREAD"; threadId: string }
-  | { type: "ADD_THREAD"; thread: ThreadData }
-  | { type: "UPDATE_THREAD"; threadId: string; updates: Partial<ThreadData> }
-  | { type: "DELETE_THREAD"; threadId: string }
-  | { type: "SET_MESSAGES"; threadId: string; messages: MyMessage[] }
-  | { type: "ADD_MESSAGE"; threadId: string; message: MyMessage }
-  | { type: "UPDATE_MESSAGES"; threadId: string; messages: MyMessage[] }
-  | { type: "MARK_SAVED" };
-
-// Initial state
-const initialState: ChatState = {
-  isInitialized: false,
-  isLoading: false,
-  currentThreadId: "default",
-  threadList: [{ threadId: "default", status: "regular", title: "New Chat" }],
-  threads: new Map([["default", []]]),
-  lastSaved: 0,
-};
-
-// Reducer function
-function chatReducer(state: ChatState, action: ChatAction): ChatState {
-  switch (action.type) {
-    case "INITIALIZE_START":
-      return {
-        ...state,
-        isLoading: true,
-      };
-
-    case "INITIALIZE_SUCCESS":
-      return {
-        ...state,
-        isInitialized: true,
-        isLoading: false,
-        threadList: action.threadList,
-        threads: action.threads,
-        currentThreadId: action.currentThreadId,
-        lastSaved: Date.now(),
-      };
-
-    case "INITIALIZE_ERROR":
-      return {
-        ...state,
-        isInitialized: true,
-        isLoading: false,
-      };
-
-    case "SET_CURRENT_THREAD":
-      return {
-        ...state,
-        currentThreadId: action.threadId,
-      };
-
-    case "ADD_THREAD":
-      return {
-        ...state,
-        threadList: [...state.threadList, action.thread],
-        threads: new Map(state.threads).set(action.thread.threadId, []),
-      };
-
-    case "UPDATE_THREAD":
-      return {
-        ...state,
-        threadList: state.threadList.map(thread =>
-          thread.threadId === action.threadId
-            ? { ...thread, ...action.updates }
-            : thread
-        ),
-      };
-
-    case "DELETE_THREAD":
-      const newThreads = new Map(state.threads);
-      newThreads.delete(action.threadId);
-      return {
-        ...state,
-        threadList: state.threadList.filter(t => t.threadId !== action.threadId),
-        threads: newThreads,
-        currentThreadId: state.currentThreadId === action.threadId 
-          ? "default" 
-          : state.currentThreadId,
-      };
-
-    case "SET_MESSAGES":
-      return {
-        ...state,
-        threads: new Map(state.threads).set(action.threadId, action.messages),
-      };
-
-    case "ADD_MESSAGE":
-      const currentMessages = state.threads.get(action.threadId) || [];
-      return {
-        ...state,
-        threads: new Map(state.threads).set(action.threadId, [...currentMessages, action.message]),
-      };
-
-    case "UPDATE_MESSAGES":
-      return {
-        ...state,
-        threads: new Map(state.threads).set(action.threadId, action.messages),
-      };
-
-    case "MARK_SAVED":
-      return {
-        ...state,
-        lastSaved: Date.now(),
-      };
-
-    default:
-      return state;
-  }
-}
-
-// Context type
-interface ChatContextType {
-  state: ChatState;
-  actions: {
-    // Initialization
-    initialize: () => Promise<void>;
-    
-    // Thread management
-    setCurrentThread: (threadId: string) => void;
-    createThread: (title?: string) => Promise<string>;
-    updateThread: (threadId: string, updates: Partial<ThreadData>) => Promise<void>;
-    deleteThread: (threadId: string) => Promise<void>;
-    
-    // Message management  
-    addMessage: (threadId: string, message: MyMessage) => Promise<void>;
-    updateMessages: (threadId: string, messages: MyMessage[]) => Promise<void>;
-    
-    // Utility
-    getCurrentMessages: () => MyMessage[];
-  };
-}
-
-// Create the context
-const ChatContext = createContext<ChatContextType | null>(null);
-
-// Chat provider component
-export function ChatProvider({ children }: { children: ReactNode }) {
-  const [state, dispatch] = useReducer(chatReducer, initialState);
-
-  // Initialize data from storage
-  const initialize = async () => {
-    dispatch({ type: "INITIALIZE_START" });
-    
-    try {
-      await chatStorage.initialize();
-      
-      // Load all threads from storage
-      const storedThreads = await chatStorage.getAllThreads();
-      
-      if (storedThreads.length > 0) {
-        // Convert stored threads to UI format
-        const uiThreads: ThreadData[] = storedThreads.map(stored => ({
-          threadId: stored.threadId,
-          status: stored.status as "regular" | "archived",
-          title: stored.title,
-        }));
-        
-        // Load messages for each thread
-        const threadMessages = new Map<string, MyMessage[]>();
-        for (const thread of storedThreads) {
-          const messages = await chatStorage.getMessages(thread.threadId);
-          threadMessages.set(thread.threadId, messages);
-        }
-        
-        // Ensure default thread exists
-        if (!threadMessages.has("default")) {
-          threadMessages.set("default", []);
-        }
-        
-        // Find the most recently updated thread
-        const latestThread = storedThreads.sort((a, b) => b.updatedAt - a.updatedAt)[0];
-        const currentThreadId = latestThread ? latestThread.threadId : "default";
-        
-        dispatch({ 
-          type: "INITIALIZE_SUCCESS", 
-          threadList: uiThreads, 
-          threads: threadMessages, 
-          currentThreadId 
-        });
-      } else {
-        // Initialize with default thread
-        const defaultThread: StoredThreadData = {
-          threadId: "default",
-          status: "regular",
-          title: "New Chat",
-          createdAt: Date.now(),
-          updatedAt: Date.now(),
-        };
-        await chatStorage.saveThread(defaultThread);
-        
-        dispatch({ 
-          type: "INITIALIZE_SUCCESS", 
-          threadList: initialState.threadList, 
-          threads: initialState.threads, 
-          currentThreadId: "default" 
-        });
-      }
-    } catch (error) {
-      console.error("Failed to initialize chat data:", error);
-      dispatch({ type: "INITIALIZE_ERROR" });
-    }
-  };
-
-  // Thread management actions
-  const setCurrentThread = (threadId: string) => {
-    dispatch({ type: "SET_CURRENT_THREAD", threadId });
-  };
-
-  const createThread = async (title: string = "New Chat"): Promise<string> => {
-    const threadId = `thread-${Date.now()}`;
-    const newThread: ThreadData = {
-      threadId,
-      status: "regular",
-      title,
-    };
-    
-    // Update local state first
-    dispatch({ type: "ADD_THREAD", thread: newThread });
-    
-    // Save to storage
-    try {
-      const storedThread: StoredThreadData = {
-        threadId,
-        status: "regular",
-        title,
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-      };
-      await chatStorage.saveThread(storedThread);
-      dispatch({ type: "MARK_SAVED" });
-    } catch (error) {
-      console.error("Failed to save new thread:", error);
-    }
-    
-    return threadId;
-  };
-
-  const updateThread = async (threadId: string, updates: Partial<ThreadData>) => {
-    // Update local state first
-    dispatch({ type: "UPDATE_THREAD", threadId, updates });
-    
-    // Save to storage
-    try {
-      const existingThread = await chatStorage.getThread(threadId);
-      if (existingThread) {
-        const updatedThread: StoredThreadData = {
-          ...existingThread,
-          ...updates,
-          updatedAt: Date.now(),
-        };
-        await chatStorage.saveThread(updatedThread);
-        dispatch({ type: "MARK_SAVED" });
-      }
-    } catch (error) {
-      console.error("Failed to update thread:", error);
-    }
-  };
-
-  const deleteThread = async (threadId: string) => {
-    // Update local state first
-    dispatch({ type: "DELETE_THREAD", threadId });
-    
-    // Delete from storage
-    try {
-      await chatStorage.deleteThread(threadId);
-      dispatch({ type: "MARK_SAVED" });
-    } catch (error) {
-      console.error("Failed to delete thread:", error);
-    }
-  };
-
-  // Message management actions
-  const addMessage = async (threadId: string, message: MyMessage) => {
-    // Update local state first
-    dispatch({ type: "ADD_MESSAGE", threadId, message });
-    
-    // Save to storage
-    try {
-      await chatStorage.saveMessage(message, threadId);
-      dispatch({ type: "MARK_SAVED" });
-    } catch (error) {
-      console.error("Failed to save message:", error);
-    }
-  };
-
-  const updateMessages = async (threadId: string, messages: MyMessage[]) => {
-    // Update local state first
-    dispatch({ type: "UPDATE_MESSAGES", threadId, messages });
-    
-    // Save to storage
-    try {
-      await chatStorage.saveMessages(messages, threadId);
-      dispatch({ type: "MARK_SAVED" });
-    } catch (error) {
-      console.error("Failed to save messages:", error);
-    }
-  };
-
-  // Utility functions
-  const getCurrentMessages = (): MyMessage[] => {
-    return state.threads.get(state.currentThreadId) || [];
-  };
-
-  // Auto-initialize on mount
-  useEffect(() => {
-    if (!state.isInitialized && !state.isLoading) {
-      initialize();
-    }
-  }, [state.isInitialized, state.isLoading]);
-
-  const actions = {
-    initialize,
-    setCurrentThread,
-    createThread,
-    updateThread,
-    deleteThread,
-    addMessage,
-    updateMessages,
-    getCurrentMessages,
-  };
-
-  return (
-    <ChatContext.Provider value={{ state, actions }}>
-      {children}
-    </ChatContext.Provider>
-  );
-}
-
-// Hook for accessing chat context
-export function useChatContext() {
-  const context = useContext(ChatContext);
-  if (!context) {
-    throw new Error("useChatContext must be used within ChatProvider");
-  }
-  return context;
-} 
\ No newline at end of file
+// client/packages/lowcoder/src/comps/comps/chatComp/context/ChatContext.tsx
+
+import React, { createContext, useContext, useReducer, useEffect, ReactNode } from "react";
+import { ChatStorage, ChatMessage, ChatThread } from "../../types/chatTypes";
+
+// ============================================================================
+// UPDATED CONTEXT WITH CLEAN TYPES
+// ============================================================================
+
+// Thread data interfaces (using clean types)
+export interface RegularThreadData {
+  threadId: string;
+  status: "regular";
+  title: string;
+}
+
+export interface ArchivedThreadData {
+  threadId: string;
+  status: "archived";
+  title: string;
+}
+
+export type ThreadData = RegularThreadData | ArchivedThreadData;
+
+// Chat state interface (cleaned up)
+interface ChatState {
+  isInitialized: boolean;
+  isLoading: boolean;
+  currentThreadId: string;
+  threadList: ThreadData[];
+  threads: Map<string, ChatMessage[]>;
+  lastSaved: number;
+}
+
+// Action types (same as before)
+type ChatAction =
+  | { type: "INITIALIZE_START" }
+  | { type: "INITIALIZE_SUCCESS"; threadList: ThreadData[]; threads: Map<string, ChatMessage[]>; currentThreadId: string }
+  | { type: "INITIALIZE_ERROR" }
+  | { type: "SET_CURRENT_THREAD"; threadId: string }
+  | { type: "ADD_THREAD"; thread: ThreadData }
+  | { type: "UPDATE_THREAD"; threadId: string; updates: Partial<ThreadData> }
+  | { type: "DELETE_THREAD"; threadId: string }
+  | { type: "SET_MESSAGES"; threadId: string; messages: ChatMessage[] }
+  | { type: "ADD_MESSAGE"; threadId: string; message: ChatMessage }
+  | { type: "UPDATE_MESSAGES"; threadId: string; messages: ChatMessage[] }
+  | { type: "MARK_SAVED" };
+
+// Initial state
+const initialState: ChatState = {
+  isInitialized: false,
+  isLoading: false,
+  currentThreadId: "default",
+  threadList: [{ threadId: "default", status: "regular", title: "New Chat" }],
+  threads: new Map([["default", []]]),
+  lastSaved: 0,
+};
+
+// Reducer function (same logic, updated types)
+function chatReducer(state: ChatState, action: ChatAction): ChatState {
+  switch (action.type) {
+    case "INITIALIZE_START":
+      return {
+        ...state,
+        isLoading: true,
+      };
+
+    case "INITIALIZE_SUCCESS":
+      return {
+        ...state,
+        isInitialized: true,
+        isLoading: false,
+        threadList: action.threadList,
+        threads: action.threads,
+        currentThreadId: action.currentThreadId,
+        lastSaved: Date.now(),
+      };
+
+    case "INITIALIZE_ERROR":
+      return {
+        ...state,
+        isInitialized: true,
+        isLoading: false,
+      };
+
+    case "SET_CURRENT_THREAD":
+      return {
+        ...state,
+        currentThreadId: action.threadId,
+      };
+
+    case "ADD_THREAD":
+      return {
+        ...state,
+        threadList: [...state.threadList, action.thread],
+        threads: new Map(state.threads).set(action.thread.threadId, []),
+      };
+
+    case "UPDATE_THREAD":
+      return {
+        ...state,
+        threadList: state.threadList.map(thread =>
+          thread.threadId === action.threadId
+            ? { ...thread, ...action.updates }
+            : thread
+        ),
+      };
+
+    case "DELETE_THREAD":
+      const newThreads = new Map(state.threads);
+      newThreads.delete(action.threadId);
+      return {
+        ...state,
+        threadList: state.threadList.filter(t => t.threadId !== action.threadId),
+        threads: newThreads,
+        currentThreadId: state.currentThreadId === action.threadId 
+          ? "default" 
+          : state.currentThreadId,
+      };
+
+    case "SET_MESSAGES":
+      return {
+        ...state,
+        threads: new Map(state.threads).set(action.threadId, action.messages),
+      };
+
+    case "ADD_MESSAGE":
+      const currentMessages = state.threads.get(action.threadId) || [];
+      return {
+        ...state,
+        threads: new Map(state.threads).set(action.threadId, [...currentMessages, action.message]),
+      };
+
+    case "UPDATE_MESSAGES":
+      return {
+        ...state,
+        threads: new Map(state.threads).set(action.threadId, action.messages),
+      };
+
+    case "MARK_SAVED":
+      return {
+        ...state,
+        lastSaved: Date.now(),
+      };
+
+    default:
+      return state;
+  }
+}
+
+// Context type (cleaned up)
+interface ChatContextType {
+  state: ChatState;
+  actions: {
+    // Initialization
+    initialize: () => Promise<void>;
+    
+    // Thread management
+    setCurrentThread: (threadId: string) => void;
+    createThread: (title?: string) => Promise<string>;
+    updateThread: (threadId: string, updates: Partial<ThreadData>) => Promise<void>;
+    deleteThread: (threadId: string) => Promise<void>;
+    
+    // Message management  
+    addMessage: (threadId: string, message: ChatMessage) => Promise<void>;
+    updateMessages: (threadId: string, messages: ChatMessage[]) => Promise<void>;
+    
+    // Utility
+    getCurrentMessages: () => ChatMessage[];
+  };
+}
+
+// Create the context
+const ChatContext = createContext<ChatContextType | null>(null);
+
+// ============================================================================
+// CHAT PROVIDER - UPDATED TO USE CLEAN STORAGE INTERFACE
+// ============================================================================
+
+export function ChatProvider({ children, storage }: { 
+  children: ReactNode; 
+  storage: ChatStorage; 
+}) {
+  const [state, dispatch] = useReducer(chatReducer, initialState);
+
+  // Initialize data from storage
+  const initialize = async () => {
+    dispatch({ type: "INITIALIZE_START" });
+    
+    try {
+      await storage.initialize();
+      
+      // Load all threads from storage
+      const storedThreads = await storage.getAllThreads();
+      
+      if (storedThreads.length > 0) {
+        // Convert stored threads to UI format
+        const uiThreads: ThreadData[] = storedThreads.map(stored => ({
+          threadId: stored.threadId,
+          status: stored.status as "regular" | "archived",
+          title: stored.title,
+        }));
+        
+        // Load messages for each thread
+        const threadMessages = new Map<string, ChatMessage[]>();
+        for (const thread of storedThreads) {
+          const messages = await storage.getMessages(thread.threadId);
+          threadMessages.set(thread.threadId, messages);
+        }
+        
+        // Ensure default thread exists
+        if (!threadMessages.has("default")) {
+          threadMessages.set("default", []);
+        }
+        
+        // Find the most recently updated thread
+        const latestThread = storedThreads.sort((a, b) => b.updatedAt - a.updatedAt)[0];
+        const currentThreadId = latestThread ? latestThread.threadId : "default";
+        
+        dispatch({ 
+          type: "INITIALIZE_SUCCESS", 
+          threadList: uiThreads, 
+          threads: threadMessages, 
+          currentThreadId 
+        });
+      } else {
+        // Initialize with default thread
+        const defaultThread: ChatThread = {
+          threadId: "default",
+          status: "regular",
+          title: "New Chat",
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        };
+        await storage.saveThread(defaultThread);
+        
+        dispatch({ 
+          type: "INITIALIZE_SUCCESS", 
+          threadList: initialState.threadList, 
+          threads: initialState.threads, 
+          currentThreadId: "default" 
+        });
+      }
+    } catch (error) {
+      console.error("Failed to initialize chat data:", error);
+      dispatch({ type: "INITIALIZE_ERROR" });
+    }
+  };
+
+  // Thread management actions (same logic, cleaner types)
+  const setCurrentThread = (threadId: string) => {
+    dispatch({ type: "SET_CURRENT_THREAD", threadId });
+  };
+
+  const createThread = async (title: string = "New Chat"): Promise<string> => {
+    const threadId = `thread-${Date.now()}`;
+    const newThread: ThreadData = {
+      threadId,
+      status: "regular",
+      title,
+    };
+    
+    // Update local state first
+    dispatch({ type: "ADD_THREAD", thread: newThread });
+    
+    // Save to storage
+    try {
+      const storedThread: ChatThread = {
+        threadId,
+        status: "regular",
+        title,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      };
+      await storage.saveThread(storedThread);
+      dispatch({ type: "MARK_SAVED" });
+    } catch (error) {
+      console.error("Failed to save new thread:", error);
+    }
+    
+    return threadId;
+  };
+
+  const updateThread = async (threadId: string, updates: Partial<ThreadData>) => {
+    // Update local state first
+    dispatch({ type: "UPDATE_THREAD", threadId, updates });
+    
+    // Save to storage
+    try {
+      const existingThread = await storage.getThread(threadId);
+      if (existingThread) {
+        const updatedThread: ChatThread = {
+          ...existingThread,
+          ...updates,
+          updatedAt: Date.now(),
+        };
+        await storage.saveThread(updatedThread);
+        dispatch({ type: "MARK_SAVED" });
+      }
+    } catch (error) {
+      console.error("Failed to update thread:", error);
+    }
+  };
+
+  const deleteThread = async (threadId: string) => {
+    // Determine if this is the last remaining thread BEFORE we delete it
+    const isLastThread = state.threadList.length === 1;
+
+    // Update local state first
+    dispatch({ type: "DELETE_THREAD", threadId });
+    
+    // Delete from storage
+    try {
+      await storage.deleteThread(threadId);
+      dispatch({ type: "MARK_SAVED" });
+      // avoid deleting the last thread
+      // if there are no threads left, create a new one
+      // avoid infinite re-renders
+      if (isLastThread) {
+        const newThreadId = await createThread("New Chat");
+        setCurrentThread(newThreadId);
+      }
+    } catch (error) {
+      console.error("Failed to delete thread:", error);
+    }
+  };
+
+  // Message management actions (same logic)
+  const addMessage = async (threadId: string, message: ChatMessage) => {
+    // Update local state first
+    dispatch({ type: "ADD_MESSAGE", threadId, message });
+    
+    // Save to storage
+    try {
+      await storage.saveMessage(message, threadId);
+      dispatch({ type: "MARK_SAVED" });
+    } catch (error) {
+      console.error("Failed to save message:", error);
+    }
+  };
+
+  const updateMessages = async (threadId: string, messages: ChatMessage[]) => {
+    // Update local state first
+    dispatch({ type: "UPDATE_MESSAGES", threadId, messages });
+    
+    // Save to storage
+    try {
+      await storage.saveMessages(messages, threadId);
+      dispatch({ type: "MARK_SAVED" });
+    } catch (error) {
+      console.error("Failed to save messages:", error);
+    }
+  };
+
+  // Utility functions
+  const getCurrentMessages = (): ChatMessage[] => {
+    return state.threads.get(state.currentThreadId) || [];
+  };
+
+  // Auto-initialize on mount
+  useEffect(() => {
+    if (!state.isInitialized && !state.isLoading) {
+      initialize();
+    }
+  }, [state.isInitialized, state.isLoading]);
+
+  const actions = {
+    initialize,
+    setCurrentThread,
+    createThread,
+    updateThread,
+    deleteThread,
+    addMessage,
+    updateMessages,
+    getCurrentMessages,
+  };
+
+  return (
+    <ChatContext.Provider value={{ state, actions }}>
+      {children}
+    </ChatContext.Provider>
+  );
+}
+
+// Hook for accessing chat context
+export function useChatContext() {
+  const context = useContext(ChatContext);
+  if (!context) {
+    throw new Error("useChatContext must be used within ChatProvider");
+  }
+  return context;
+}
+
+// Re-export types for convenience
+export type { ChatMessage, ChatThread };
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/handlers/messageHandlers.ts b/client/packages/lowcoder/src/comps/comps/chatComp/handlers/messageHandlers.ts
new file mode 100644
index 0000000000..a4f20ec123
--- /dev/null
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/handlers/messageHandlers.ts
@@ -0,0 +1,124 @@
+// client/packages/lowcoder/src/comps/comps/chatComp/handlers/messageHandlers.ts
+
+import { MessageHandler, MessageResponse, N8NHandlerConfig, QueryHandlerConfig } from "../types/chatTypes";
+import { CompAction, routeByNameAction, executeQueryAction } from "lowcoder-core";
+import { getPromiseAfterDispatch } from "util/promiseUtils";
+
+// ============================================================================
+// N8N HANDLER (for Bottom Panel)
+// ============================================================================
+
+export class N8NHandler implements MessageHandler {
+  constructor(private config: N8NHandlerConfig) {}
+
+  async sendMessage(message: string): Promise<MessageResponse> {
+    const { modelHost, systemPrompt, streaming } = this.config;
+    
+    if (!modelHost) {
+      throw new Error("Model host is required for N8N calls");
+    }
+
+    try {
+      const response = await fetch(modelHost, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          message,
+          systemPrompt: systemPrompt || "You are a helpful assistant.",
+          streaming: streaming || false
+        })
+      });
+
+      if (!response.ok) {
+        throw new Error(`N8N call failed: ${response.status} ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      
+      // Extract content from various possible response formats
+      const content = data.response || data.message || data.content || data.text || String(data);
+      
+      return { content };
+    } catch (error) {
+      throw new Error(`N8N call failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+}
+
+// ============================================================================
+// QUERY HANDLER (for Canvas Components)
+// ============================================================================
+
+export class QueryHandler implements MessageHandler {
+  constructor(private config: QueryHandlerConfig) {}
+
+  async sendMessage(message: string): Promise<MessageResponse> {
+    const { chatQuery, dispatch} = this.config;
+    
+    // If no query selected or dispatch unavailable, return mock response
+    if (!chatQuery || !dispatch) {
+      await new Promise((res) => setTimeout(res, 500));
+      return { content: "(mock) You typed: " + message };
+    }
+
+    try {
+
+      const result: any = await getPromiseAfterDispatch(
+        dispatch,
+        routeByNameAction(
+          chatQuery,
+          executeQueryAction({
+            // Send both individual prompt and full conversation history
+            args: { 
+              prompt: { value: message },
+            },
+          })
+        )
+      );
+
+      console.log("QUERY RESULT", result);
+
+     return result.message
+    } catch (e: any) {
+      throw new Error(e?.message || "Query execution failed");
+    }
+  }
+}
+
+// ============================================================================
+// MOCK HANDLER (for testing/fallbacks)
+// ============================================================================
+
+export class MockHandler implements MessageHandler {
+  constructor(private delay: number = 1000) {}
+
+  async sendMessage(message: string): Promise<MessageResponse> {
+    await new Promise(resolve => setTimeout(resolve, this.delay));
+    return { content: `Mock response: ${message}` };
+  }
+}
+
+// ============================================================================
+// HANDLER FACTORY (creates the right handler based on type)
+// ============================================================================
+
+export function createMessageHandler(
+  type: "n8n" | "query" | "mock",
+  config: N8NHandlerConfig | QueryHandlerConfig
+): MessageHandler {
+  switch (type) {
+    case "n8n":
+      return new N8NHandler(config as N8NHandlerConfig);
+    
+    case "query":
+      return new QueryHandler(config as QueryHandlerConfig);
+    
+    case "mock":
+      return new MockHandler();
+    
+    default:
+      throw new Error(`Unknown message handler type: ${type}`);
+  }
+}
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/types/chatTypes.ts b/client/packages/lowcoder/src/comps/comps/chatComp/types/chatTypes.ts
new file mode 100644
index 0000000000..25595b44df
--- /dev/null
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/types/chatTypes.ts
@@ -0,0 +1,92 @@
+// client/packages/lowcoder/src/comps/comps/chatComp/types/chatTypes.ts
+
+// ============================================================================
+// CORE MESSAGE AND THREAD TYPES (cleaned up from your existing types)
+// ============================================================================
+
+export interface ChatMessage {
+    id: string;
+    role: "user" | "assistant";
+    text: string;
+    timestamp: number;
+  }
+  
+  export interface ChatThread {
+    threadId: string;
+    status: "regular" | "archived";
+    title: string;
+    createdAt: number;
+    updatedAt: number;
+  }
+  
+  // ============================================================================
+  // STORAGE INTERFACE (abstracted from your existing storage factory)
+  // ============================================================================
+  
+  export interface ChatStorage {
+    initialize(): Promise<void>;
+    saveThread(thread: ChatThread): Promise<void>;
+    getThread(threadId: string): Promise<ChatThread | null>;
+    getAllThreads(): Promise<ChatThread[]>;
+    deleteThread(threadId: string): Promise<void>;
+    saveMessage(message: ChatMessage, threadId: string): Promise<void>;
+    saveMessages(messages: ChatMessage[], threadId: string): Promise<void>;
+    getMessages(threadId: string): Promise<ChatMessage[]>;
+    deleteMessages(threadId: string): Promise<void>;
+    clearAllData(): Promise<void>;
+    resetDatabase(): Promise<void>;
+    cleanup(): Promise<void>;
+  }
+  
+  // ============================================================================
+  // MESSAGE HANDLER INTERFACE (new clean abstraction)
+  // ============================================================================
+  
+  export interface MessageHandler {
+    sendMessage(message: string): Promise<MessageResponse>;
+    // Future: sendMessageStream?(message: string): AsyncGenerator<MessageResponse>;
+  }
+  
+  export interface MessageResponse {
+    content: string;
+    metadata?: any;
+  }
+  
+  // ============================================================================
+  // CONFIGURATION TYPES (simplified)
+  // ============================================================================
+  
+  export interface N8NHandlerConfig {
+    modelHost: string;
+    systemPrompt?: string;
+    streaming?: boolean;
+  }
+  
+  export interface QueryHandlerConfig {
+    chatQuery: string;
+    dispatch: any;
+    streaming?: boolean;
+    systemPrompt?: string;
+  }
+  
+  // ============================================================================
+  // COMPONENT PROPS (what each component actually needs)
+  // ============================================================================
+  
+  export interface ChatCoreProps {
+    storage: ChatStorage;
+    messageHandler: MessageHandler;
+    placeholder?: string;
+    onMessageUpdate?: (message: string) => void;
+    onConversationUpdate?: (conversationHistory: ChatMessage[]) => void;
+    // STANDARD LOWCODER EVENT PATTERN - SINGLE CALLBACK
+    onEvent?: (eventName: string) => void;
+  }
+  
+  export interface ChatPanelProps {
+    tableName: string;
+    modelHost: string;
+    systemPrompt?: string;
+    streaming?: boolean;
+    onMessageUpdate?: (message: string) => void;
+  }
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/utils/chatStorage.ts b/client/packages/lowcoder/src/comps/comps/chatComp/utils/chatStorage.ts
deleted file mode 100644
index edc68a0d93..0000000000
--- a/client/packages/lowcoder/src/comps/comps/chatComp/utils/chatStorage.ts
+++ /dev/null
@@ -1,281 +0,0 @@
-import alasql from "alasql";
-import { MyMessage } from "../components/context/ChatContext";
-
-// Database configuration
-const DB_NAME = "ChatDB";
-const THREADS_TABLE = "threads";
-const MESSAGES_TABLE = "messages";
-
-// Thread data interface
-export interface ThreadData {
-  threadId: string;
-  status: "regular" | "archived";
-  title: string;
-  createdAt: number;
-  updatedAt: number;
-}
-
-// Initialize the database
-class ChatStorage {
-  private initialized = false;
-
-  async initialize() {
-    if (this.initialized) return;
-
-    try {
-      // Create database with localStorage backend
-      await alasql.promise(`CREATE LOCALSTORAGE DATABASE IF NOT EXISTS ${DB_NAME}`);
-      await alasql.promise(`ATTACH LOCALSTORAGE DATABASE ${DB_NAME}`);
-      await alasql.promise(`USE ${DB_NAME}`);
-
-      // Create threads table
-      await alasql.promise(`
-        CREATE TABLE IF NOT EXISTS ${THREADS_TABLE} (
-          threadId STRING PRIMARY KEY,
-          status STRING,
-          title STRING,
-          createdAt NUMBER,
-          updatedAt NUMBER
-        )
-      `);
-
-      // Create messages table
-      await alasql.promise(`
-        CREATE TABLE IF NOT EXISTS ${MESSAGES_TABLE} (
-          id STRING PRIMARY KEY,
-          threadId STRING,
-          role STRING,
-          text STRING,
-          timestamp NUMBER
-        )
-      `);
-
-      this.initialized = true;
-      console.log("Chat database initialized successfully");
-    } catch (error) {
-      console.error("Failed to initialize chat database:", error);
-      throw error;
-    }
-  }
-
-  // Thread operations
-  async saveThread(thread: ThreadData): Promise<void> {
-    await this.initialize();
-    
-    try {
-      // Insert or replace thread
-      await alasql.promise(`
-        DELETE FROM ${THREADS_TABLE} WHERE threadId = ?
-      `, [thread.threadId]);
-      
-      await alasql.promise(`
-        INSERT INTO ${THREADS_TABLE} VALUES (?, ?, ?, ?, ?)
-      `, [thread.threadId, thread.status, thread.title, thread.createdAt, thread.updatedAt]);
-    } catch (error) {
-      console.error("Failed to save thread:", error);
-      throw error;
-    }
-  }
-
-  async getThread(threadId: string): Promise<ThreadData | null> {
-    await this.initialize();
-    
-    try {
-      const result = await alasql.promise(`
-        SELECT * FROM ${THREADS_TABLE} WHERE threadId = ?
-      `, [threadId]) as ThreadData[];
-      
-      return result && result.length > 0 ? result[0] : null;
-    } catch (error) {
-      console.error("Failed to get thread:", error);
-      return null;
-    }
-  }
-
-  async getAllThreads(): Promise<ThreadData[]> {
-    await this.initialize();
-    
-    try {
-      const result = await alasql.promise(`
-        SELECT * FROM ${THREADS_TABLE} ORDER BY updatedAt DESC
-      `) as ThreadData[];
-      
-      return Array.isArray(result) ? result : [];
-    } catch (error) {
-      console.error("Failed to get threads:", error);
-      return [];
-    }
-  }
-
-  async deleteThread(threadId: string): Promise<void> {
-    await this.initialize();
-    
-    try {
-      // Delete thread and all its messages
-      await alasql.promise(`DELETE FROM ${THREADS_TABLE} WHERE threadId = ?`, [threadId]);
-      await alasql.promise(`DELETE FROM ${MESSAGES_TABLE} WHERE threadId = ?`, [threadId]);
-    } catch (error) {
-      console.error("Failed to delete thread:", error);
-      throw error;
-    }
-  }
-
-  // Message operations
-  async saveMessage(message: MyMessage, threadId: string): Promise<void> {
-    await this.initialize();
-    
-    try {
-      // Insert or replace message
-      await alasql.promise(`
-        DELETE FROM ${MESSAGES_TABLE} WHERE id = ?
-      `, [message.id]);
-      
-      await alasql.promise(`
-        INSERT INTO ${MESSAGES_TABLE} VALUES (?, ?, ?, ?, ?)
-      `, [message.id, threadId, message.role, message.text, message.timestamp]);
-    } catch (error) {
-      console.error("Failed to save message:", error);
-      throw error;
-    }
-  }
-
-  async saveMessages(messages: MyMessage[], threadId: string): Promise<void> {
-    await this.initialize();
-    
-    try {
-      // Delete existing messages for this thread
-      await alasql.promise(`DELETE FROM ${MESSAGES_TABLE} WHERE threadId = ?`, [threadId]);
-      
-      // Insert all messages
-      for (const message of messages) {
-        await alasql.promise(`
-          INSERT INTO ${MESSAGES_TABLE} VALUES (?, ?, ?, ?, ?)
-        `, [message.id, threadId, message.role, message.text, message.timestamp]);
-      }
-    } catch (error) {
-      console.error("Failed to save messages:", error);
-      throw error;
-    }
-  }
-
-  async getMessages(threadId: string): Promise<MyMessage[]> {
-    await this.initialize();
-    
-    try {
-      const result = await alasql.promise(`
-        SELECT id, role, text, timestamp FROM ${MESSAGES_TABLE} 
-        WHERE threadId = ? ORDER BY timestamp ASC
-      `, [threadId]) as MyMessage[];
-      
-      return Array.isArray(result) ? result : [];
-    } catch (error) {
-      console.error("Failed to get messages:", error);
-      return [];
-    }
-  }
-
-  async deleteMessages(threadId: string): Promise<void> {
-    await this.initialize();
-    
-    try {
-      await alasql.promise(`DELETE FROM ${MESSAGES_TABLE} WHERE threadId = ?`, [threadId]);
-    } catch (error) {
-      console.error("Failed to delete messages:", error);
-      throw error;
-    }
-  }
-
-  // Utility methods
-  async clearAllData(): Promise<void> {
-    await this.initialize();
-    
-    try {
-      await alasql.promise(`DELETE FROM ${THREADS_TABLE}`);
-      await alasql.promise(`DELETE FROM ${MESSAGES_TABLE}`);
-    } catch (error) {
-      console.error("Failed to clear all data:", error);
-      throw error;
-    }
-  }
-
-  async resetDatabase(): Promise<void> {
-    try {
-      // Drop the entire database
-      await alasql.promise(`DROP LOCALSTORAGE DATABASE IF EXISTS ${DB_NAME}`);
-      this.initialized = false;
-      
-      // Reinitialize fresh
-      await this.initialize();
-      console.log("✅ Database reset and reinitialized");
-    } catch (error) {
-      console.error("Failed to reset database:", error);
-      throw error;
-    }
-  }
-
-  async clearOnlyMessages(): Promise<void> {
-    await this.initialize();
-    
-    try {
-      await alasql.promise(`DELETE FROM ${MESSAGES_TABLE}`);
-      console.log("✅ All messages cleared, threads preserved");
-    } catch (error) {
-      console.error("Failed to clear messages:", error);
-      throw error;
-    }
-  }
-
-  async clearOnlyThreads(): Promise<void> {
-    await this.initialize();
-    
-    try {
-      await alasql.promise(`DELETE FROM ${THREADS_TABLE}`);
-      await alasql.promise(`DELETE FROM ${MESSAGES_TABLE}`); // Clear orphaned messages
-      console.log("✅ All threads and messages cleared");
-    } catch (error) {
-      console.error("Failed to clear threads:", error);
-      throw error;
-    }
-  }
-
-  async exportData(): Promise<{ threads: ThreadData[]; messages: any[] }> {
-    await this.initialize();
-    
-    try {
-      const threads = await this.getAllThreads();
-      const messages = await alasql.promise(`SELECT * FROM ${MESSAGES_TABLE}`) as any[];
-      
-      return { threads, messages: Array.isArray(messages) ? messages : [] };
-    } catch (error) {
-      console.error("Failed to export data:", error);
-      throw error;
-    }
-  }
-
-  async importData(data: { threads: ThreadData[]; messages: any[] }): Promise<void> {
-    await this.initialize();
-    
-    try {
-      // Clear existing data
-      await this.clearAllData();
-      
-      // Import threads
-      for (const thread of data.threads) {
-        await this.saveThread(thread);
-      }
-      
-      // Import messages
-      for (const message of data.messages) {
-        await alasql.promise(`
-          INSERT INTO ${MESSAGES_TABLE} VALUES (?, ?, ?, ?, ?)
-        `, [message.id, message.threadId, message.role, message.text, message.timestamp]);
-      }
-    } catch (error) {
-      console.error("Failed to import data:", error);
-      throw error;
-    }
-  }
-}
-
-// Export singleton instance
-export const chatStorage = new ChatStorage(); 
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/chatComp/utils/storageFactory.ts b/client/packages/lowcoder/src/comps/comps/chatComp/utils/storageFactory.ts
new file mode 100644
index 0000000000..b4d092af59
--- /dev/null
+++ b/client/packages/lowcoder/src/comps/comps/chatComp/utils/storageFactory.ts
@@ -0,0 +1,188 @@
+// client/packages/lowcoder/src/comps/comps/chatComp/utils/storageFactory.ts
+
+import alasql from "alasql";
+import { ChatMessage, ChatThread, ChatStorage } from "../types/chatTypes";
+
+// ============================================================================
+// CLEAN STORAGE FACTORY (simplified from your existing implementation)
+// ============================================================================
+
+export function createChatStorage(tableName: string): ChatStorage {
+  const dbName = `ChatDB_${tableName}`;
+  const threadsTable = `${dbName}.threads`;
+  const messagesTable = `${dbName}.messages`;
+  
+  return {
+    async initialize() {
+      try {
+        // Create database with localStorage backend
+        await alasql.promise(`CREATE LOCALSTORAGE DATABASE IF NOT EXISTS ${dbName}`);
+        await alasql.promise(`ATTACH LOCALSTORAGE DATABASE ${dbName}`);
+
+        // Create threads table
+        await alasql.promise(`
+          CREATE TABLE IF NOT EXISTS ${threadsTable} (
+            threadId STRING PRIMARY KEY,
+            status STRING,
+            title STRING,
+            createdAt NUMBER,
+            updatedAt NUMBER
+          )
+        `);
+
+        // Create messages table
+        await alasql.promise(`
+          CREATE TABLE IF NOT EXISTS ${messagesTable} (
+            id STRING PRIMARY KEY,
+            threadId STRING,
+            role STRING,
+            text STRING,
+            timestamp NUMBER
+          )
+        `);
+
+        console.log(`✅ Chat database initialized: ${dbName}`);
+      } catch (error) {
+        console.error(`Failed to initialize chat database ${dbName}:`, error);
+        throw error;
+      }
+    },
+
+    async saveThread(thread: ChatThread) {
+      try {
+        // Insert or replace thread
+        await alasql.promise(`DELETE FROM ${threadsTable} WHERE threadId = ?`, [thread.threadId]);
+        
+        await alasql.promise(`
+          INSERT INTO ${threadsTable} VALUES (?, ?, ?, ?, ?)
+        `, [thread.threadId, thread.status, thread.title, thread.createdAt, thread.updatedAt]);
+      } catch (error) {
+        console.error("Failed to save thread:", error);
+        throw error;
+      }
+    },
+
+    async getThread(threadId: string) {
+      try {
+        const result = await alasql.promise(`
+          SELECT * FROM ${threadsTable} WHERE threadId = ?
+        `, [threadId]) as ChatThread[];
+        
+        return result && result.length > 0 ? result[0] : null;
+      } catch (error) {
+        console.error("Failed to get thread:", error);
+        return null;
+      }
+    },
+
+    async getAllThreads() {
+      try {
+        const result = await alasql.promise(`
+          SELECT * FROM ${threadsTable} ORDER BY updatedAt DESC
+        `) as ChatThread[];
+        
+        return Array.isArray(result) ? result : [];
+      } catch (error) {
+        console.error("Failed to get threads:", error);
+        return [];
+      }
+    },
+
+    async deleteThread(threadId: string) {
+      try {
+        // Delete thread and all its messages
+        await alasql.promise(`DELETE FROM ${threadsTable} WHERE threadId = ?`, [threadId]);
+        await alasql.promise(`DELETE FROM ${messagesTable} WHERE threadId = ?`, [threadId]);
+      } catch (error) {
+        console.error("Failed to delete thread:", error);
+        throw error;
+      }
+    },
+
+    async saveMessage(message: ChatMessage, threadId: string) {
+      try {
+        // Insert or replace message
+        await alasql.promise(`DELETE FROM ${messagesTable} WHERE id = ?`, [message.id]);
+        
+        await alasql.promise(`
+          INSERT INTO ${messagesTable} VALUES (?, ?, ?, ?, ?)
+        `, [message.id, threadId, message.role, message.text, message.timestamp]);
+      } catch (error) {
+        console.error("Failed to save message:", error);
+        throw error;
+      }
+    },
+
+    async saveMessages(messages: ChatMessage[], threadId: string) {
+      try {
+        // Delete existing messages for this thread
+        await alasql.promise(`DELETE FROM ${messagesTable} WHERE threadId = ?`, [threadId]);
+        
+        // Insert all messages
+        for (const message of messages) {
+          await alasql.promise(`
+            INSERT INTO ${messagesTable} VALUES (?, ?, ?, ?, ?)
+          `, [message.id, threadId, message.role, message.text, message.timestamp]);
+        }
+      } catch (error) {
+        console.error("Failed to save messages:", error);
+        throw error;
+      }
+    },
+
+    async getMessages(threadId: string) {
+      try {
+        const result = await alasql.promise(`
+          SELECT id, role, text, timestamp FROM ${messagesTable} 
+          WHERE threadId = ? ORDER BY timestamp ASC
+        `, [threadId]) as ChatMessage[];
+        
+        return Array.isArray(result) ? result : [];
+      } catch (error) {
+        console.error("Failed to get messages:", error);
+        return [];
+      }
+    },
+
+    async deleteMessages(threadId: string) {
+      try {
+        await alasql.promise(`DELETE FROM ${messagesTable} WHERE threadId = ?`, [threadId]);
+      } catch (error) {
+        console.error("Failed to delete messages:", error);
+        throw error;
+      }
+    },
+
+    async clearAllData() {
+      try {
+        await alasql.promise(`DELETE FROM ${threadsTable}`);
+        await alasql.promise(`DELETE FROM ${messagesTable}`);
+      } catch (error) {
+        console.error("Failed to clear all data:", error);
+        throw error;
+      }
+    },
+
+    async resetDatabase() {
+      try {
+        // Drop the entire database
+        await alasql.promise(`DROP LOCALSTORAGE DATABASE IF EXISTS ${dbName}`);
+        
+        // Reinitialize fresh
+        await this.initialize();
+        console.log(`✅ Database reset and reinitialized: ${dbName}`);
+      } catch (error) {
+        console.error("Failed to reset database:", error);
+        throw error;
+      }
+    },
+    async cleanup() {
+      try {
+        await alasql.promise(`DROP LOCALSTORAGE DATABASE IF EXISTS ${dbName}`);
+      } catch (error) {
+        console.error("Failed to cleanup database:", error);
+        throw error;
+      }
+    }
+  };
+}
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/comps/selectInputComp/selectInputConstants.tsx b/client/packages/lowcoder/src/comps/comps/selectInputComp/selectInputConstants.tsx
index 290f3628d5..d7b5648e17 100644
--- a/client/packages/lowcoder/src/comps/comps/selectInputComp/selectInputConstants.tsx
+++ b/client/packages/lowcoder/src/comps/comps/selectInputComp/selectInputConstants.tsx
@@ -128,7 +128,8 @@ export const SelectInputValidationSection = (children: ValidationComp) => (
       label: trans("prop.showEmptyValidation"),
     })}
     {children.allowCustomTags.propertyView({
-      label: trans("prop.customTags") 
+      label: trans("prop.customTags"),
+      tooltip: trans("prop.customTagsTooltip")
     })}
     {children.customRule.propertyView({})}
   </Section>
diff --git a/client/packages/lowcoder/src/comps/comps/textInputComp/textInputConstants.tsx b/client/packages/lowcoder/src/comps/comps/textInputComp/textInputConstants.tsx
index bacb892bd8..97af00711b 100644
--- a/client/packages/lowcoder/src/comps/comps/textInputComp/textInputConstants.tsx
+++ b/client/packages/lowcoder/src/comps/comps/textInputComp/textInputConstants.tsx
@@ -179,15 +179,10 @@ export const useTextInputProps = (props: RecordConstructorToView<typeof textInpu
   const inputValue = { ...props.value }.value;
 
   useEffect(() => {
+    setLocalInputValue(defaultValue);
     props.value.onChange(defaultValue)
   }, [defaultValue]);
 
-  useEffect(() => {
-    if (inputValue !== localInputValue) {
-      setLocalInputValue(inputValue);
-    }
-  }, [inputValue]);
-
   useEffect(() => {
     if (!changeRef.current) return;
 
@@ -220,8 +215,7 @@ export const useTextInputProps = (props: RecordConstructorToView<typeof textInpu
       propsRef.current.value.onChange(value);
       propsRef.current.onEvent("change");
     }, 1000)
-  );
-  
+  );  
 
   const handleChange = (e: ChangeEvent<HTMLInputElement>) => {
     const value = e.target.value;
diff --git a/client/packages/lowcoder/src/comps/comps/timerComp.tsx b/client/packages/lowcoder/src/comps/comps/timerComp.tsx
index a749cb0687..e9fc26ad05 100644
--- a/client/packages/lowcoder/src/comps/comps/timerComp.tsx
+++ b/client/packages/lowcoder/src/comps/comps/timerComp.tsx
@@ -299,6 +299,42 @@ let TimerCompBasic = (function () {
           comp.children.actionHandler.dispatch(comp.children.actionHandler.changeValueAction('reset'))
         },
       },
+      {
+        method: {
+          name: "start",
+          description: trans("timer.start"),
+          params: [],
+        },
+        execute: async (comp, params) => {
+          if (comp.children.timerState.value === 'stoped') {
+            comp.children.actionHandler.dispatch(comp.children.actionHandler.changeValueAction('start'))
+          }
+        },
+      },
+      {
+        method: {
+          name: "pause",
+          description: trans("timer.pause"),
+          params: [],
+        },
+        execute: async (comp, params) => {
+          if (comp.children.timerState.value === 'started') {
+            comp.children.actionHandler.dispatch(comp.children.actionHandler.changeValueAction('pause'))
+          }
+        },
+      },
+      {
+        method: {
+          name: "resume",
+          description: trans("timer.resume"),
+          params: [],
+        },
+        execute: async (comp, params) => {
+          if (comp.children.timerState.value === 'paused') {
+            comp.children.actionHandler.dispatch(comp.children.actionHandler.changeValueAction('resume'))
+          }
+        }
+      }
     ])
     .build();
 })();
diff --git a/client/packages/lowcoder/src/comps/queries/httpQuery/sseHttpQuery.tsx b/client/packages/lowcoder/src/comps/queries/httpQuery/sseHttpQuery.tsx
new file mode 100644
index 0000000000..2271f582ef
--- /dev/null
+++ b/client/packages/lowcoder/src/comps/queries/httpQuery/sseHttpQuery.tsx
@@ -0,0 +1,222 @@
+// SSEHTTPQUERY.tsx
+import { Dropdown, ValueFromOption } from "components/Dropdown";
+import { QueryConfigItemWrapper, QueryConfigLabel, QueryConfigWrapper } from "components/query";
+import { valueComp, withDefault } from "comps/generators";
+import { trans } from "i18n";
+import { includes } from "lodash";
+import { CompAction, MultiBaseComp } from "lowcoder-core";
+import { keyValueListControl } from "../../controls/keyValueListControl";
+import { ParamsJsonControl, ParamsStringControl } from "../../controls/paramsControl";
+import { withTypeAndChildrenAbstract } from "../../generators/withType";
+import { toSseQueryView } from "../queryCompUtils";
+import {
+  HttpHeaderPropertyView,
+  HttpParametersPropertyView,
+  HttpPathPropertyView,
+} from "./httpQueryConstants";
+
+const BodyTypeOptions = [
+  { label: "JSON", value: "application/json" },
+  { label: "Raw", value: "text/plain" },
+  {
+    label: "x-www-form-urlencoded",
+    value: "application/x-www-form-urlencoded",
+  },
+  { label: "Form Data", value: "multipart/form-data" },
+  { label: "None", value: "none" },
+] as const;
+type BodyTypeValue = ValueFromOption<typeof BodyTypeOptions>;
+
+const HttpMethodOptions = [
+  { label: "GET", value: "GET" },
+  { label: "POST", value: "POST" },
+  { label: "PUT", value: "PUT" },
+  { label: "DELETE", value: "DELETE" },
+  { label: "PATCH", value: "PATCH" },
+  { label: "HEAD", value: "HEAD" },
+  { label: "OPTIONS", value: "OPTIONS" },
+  { label: "TRACE", value: "TRACE" },
+] as const;
+type HttpMethodValue = ValueFromOption<typeof HttpMethodOptions>;
+
+const CommandMap = {
+  "application/json": ParamsJsonControl,
+  "text/plain": ParamsStringControl,
+  "application/x-www-form-urlencoded": ParamsStringControl,
+  "multipart/form-data": ParamsStringControl,
+  none: ParamsStringControl,
+};
+
+const childrenMap = {
+  httpMethod: valueComp<HttpMethodValue>("GET"),
+  path: ParamsStringControl,
+  headers: withDefault(keyValueListControl(), [
+    { key: "Accept", value: "text/event-stream" }
+  ]),
+  params: withDefault(keyValueListControl(), [{ key: "", value: "" }]),
+  bodyFormData: withDefault(
+    keyValueListControl(true, [
+      { label: trans("httpQuery.text"), value: "text" },
+      { label: trans("httpQuery.file"), value: "file" },
+    ] as const),
+    [{ key: "", value: "", type: "text" }]
+  ),
+  // Add SSE-specific configuration
+  streamingEnabled: valueComp<boolean>(true),
+};
+
+const SseHttpTmpQuery = withTypeAndChildrenAbstract(
+  CommandMap,
+  "none",
+  childrenMap,
+  "bodyType",
+  "body"
+);
+
+export class SseHttpQuery extends SseHttpTmpQuery {
+  isWrite(action: CompAction) {
+    return (
+      action.path.includes("httpMethod") && "value" in action && !includes(["GET"], action.value)
+    );
+  }
+
+  override getView() {
+    const children = this.children;
+    const params = [
+      ...children.headers.getQueryParams(),
+      ...children.params.getQueryParams(),
+      ...children.bodyFormData.getQueryParams(),
+      ...children.path.getQueryParams(),
+      ...children.body.getQueryParams(),
+      // Add streaming flag to params
+      { key: "_streaming", value: () => "true" },
+      { key: "_streamingEnabled", value: () => children.streamingEnabled.getView() }
+    ];
+    
+    // Use SSE-specific query view
+    return toSseQueryView(params);
+  }
+
+  propertyView(props: {
+    datasourceId: string;
+    urlPlaceholder?: string;
+    supportHttpMethods?: HttpMethodValue[];
+    supportBodyTypes?: BodyTypeValue[];
+  }) {
+    return <SseHttpQueryPropertyView {...props} comp={this} />;
+  }
+
+  getHttpMethod() {
+    return this.children.httpMethod.getView();
+  }
+}
+
+type ChildrenType = InstanceType<typeof SseHttpQuery> extends MultiBaseComp<infer X> ? X : never;
+
+const ContentTypeKey = "Content-Type";
+
+const showBodyConfig = (children: ChildrenType) => {
+  switch (children.bodyType.getView() as BodyTypeValue) {
+    case "application/x-www-form-urlencoded":
+      return children.bodyFormData.propertyView({});
+    case "multipart/form-data":
+      return children.bodyFormData.propertyView({
+        showType: true,
+        typeTooltip: trans("httpQuery.bodyFormDataTooltip", {
+          type: `"${trans("httpQuery.file")}"`,
+          object: "{ data: base64 string, name: string }",
+          example: "{{ {data: file1.value[0], name: file1.files[0].name} }}",
+        }),
+      });
+    case "application/json":
+    case "text/plain":
+      return children.body.propertyView({ styleName: "medium", width: "100%" });
+    default:
+      return <></>;
+  }
+};
+
+const SseHttpQueryPropertyView = (props: {
+  comp: InstanceType<typeof SseHttpQuery>;
+  datasourceId: string;
+  urlPlaceholder?: string;
+  supportHttpMethods?: HttpMethodValue[];
+  supportBodyTypes?: BodyTypeValue[];
+}) => {
+  const { comp, supportHttpMethods, supportBodyTypes } = props;
+  const { children, dispatch } = comp;
+
+  return (
+    <>
+      <Dropdown
+        placement={"bottom"}
+        value={children.httpMethod.value}
+        options={HttpMethodOptions.filter(
+          (o) => !supportHttpMethods || supportHttpMethods.includes(o.value)
+        )}
+        label={"HTTP Method"}
+        onChange={(value: HttpMethodValue) => {
+          children.httpMethod.dispatchChangeValueAction(value);
+        }}
+      />
+
+      <HttpPathPropertyView 
+        {...props} 
+        comp={comp} 
+        urlPlaceholder={props.urlPlaceholder || "https://api.example.com/stream"}
+      />
+
+      <HttpHeaderPropertyView comp={comp} />
+
+      <HttpParametersPropertyView comp={comp} />
+
+      <Dropdown
+        label={"Body"}
+        placement={"bottom"}
+        options={BodyTypeOptions.filter(
+          (o) => !supportBodyTypes || supportBodyTypes?.includes(o.value)
+        )}
+        value={children.bodyType.getView()}
+        onChange={(value) => {
+          let headers = children.headers
+            .toJsonValue()
+            .filter((header) => header.key !== ContentTypeKey);
+          
+          // Always ensure Accept: text/event-stream for SSE
+          const hasAcceptHeader = headers.some(h => h.key === "Accept");
+          if (!hasAcceptHeader) {
+            headers.push({ key: "Accept", value: "text/event-stream" });
+          }
+          
+          if (value !== "none") {
+            headers = [
+              {
+                key: ContentTypeKey,
+                value: value,
+              },
+              ...headers,
+            ];
+          }
+
+          dispatch(
+            comp.changeValueAction({ ...comp.toJsonValue(), bodyType: value, headers: headers })
+          );
+        }}
+      />
+
+      <QueryConfigWrapper>
+        <QueryConfigLabel />
+        <QueryConfigItemWrapper>{showBodyConfig(children)}</QueryConfigItemWrapper>
+      </QueryConfigWrapper>
+      
+      <QueryConfigWrapper>
+        <QueryConfigLabel>Streaming Options</QueryConfigLabel>
+        <QueryConfigItemWrapper>
+          <div style={{ fontSize: "13px", color: "#8B8FA3" }}>
+            This query will establish a Server-Sent Events connection for real-time data streaming.
+          </div>
+        </QueryConfigItemWrapper>
+      </QueryConfigWrapper>
+    </>
+  );
+};
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/comps/queries/queryCompUtils.tsx b/client/packages/lowcoder/src/comps/queries/queryCompUtils.tsx
index bf49517af0..87f3926bc8 100644
--- a/client/packages/lowcoder/src/comps/queries/queryCompUtils.tsx
+++ b/client/packages/lowcoder/src/comps/queries/queryCompUtils.tsx
@@ -82,7 +82,7 @@ export function toQueryView(params: FunctionProperty[]) {
         }).map(({ key, value }) => ({ key, value: value(props.args) })),
         ...Object.entries(props.timeout.getView()).map(([key, value]) => ({
           key,
-          value: value(props.args),
+          value: (value as ValueFunction)(props.args),
         })),
         ...mappedVariables,
       ],
@@ -143,3 +143,362 @@ export function onlyManualTrigger(type: ResourceType) {
 export function getTriggerType(comp: any): TriggerType {
   return comp.children.triggerType.getView();
 }
+
+// STREAMING QUERY
+
+export interface SseQueryResult extends QueryResult {
+  streamId?: string;
+  isStreaming?: boolean;
+}
+
+export interface SseQueryViewProps {
+  queryId: string;
+  applicationId: string;
+  applicationPath: string[];
+  args?: Record<string, unknown>;
+  variables?: any;
+  timeout: any;
+  onStreamData?: (data: any) => void;
+  onStreamError?: (error: any) => void;
+  onStreamEnd?: () => void;
+}
+
+/**
+ * SSE-specific query view that handles streaming responses
+ */
+export function toSseQueryView(params: FunctionProperty[]) {
+  // Store active connections
+  const activeConnections = new Map<string, EventSource>();
+  
+  return async (props: SseQueryViewProps): Promise<SseQueryResult> => {
+    const { applicationId, isViewMode } = getGlobalSettings();
+    
+    // Process parameters similar to toQueryView
+    let mappedVariables: Array<{key: string, value: string}> = [];
+    Object.keys(props.variables || {})
+      .filter(k => k !== "$queryName")
+      .forEach(key => {
+        const value = Object.hasOwn(props.variables[key], 'value') 
+          ? props.variables[key].value 
+          : props.variables[key];
+        mappedVariables.push({
+          key: `${key}.value`,
+          value: value || ""
+        });
+        mappedVariables.push({
+          key: `${props.args?.$queryName}.variables.${key}`,
+          value: value || ""
+        });
+      });
+
+    let request: QueryExecuteRequest = {
+      path: props.applicationPath,
+      params: [
+        ...params.filter(param => {
+          return !mappedVariables.map(v => v.key).includes(param.key);
+        }).map(({ key, value }) => ({ key, value: value(props.args) })),
+        ...Object.entries(props.timeout.getView()).map(([key, value]) => ({
+          key,
+          value: (value as ValueFunction)(props.args),
+        })),
+        ...mappedVariables,
+      ],
+      viewMode: !!isViewMode,
+    };
+    
+    if (!applicationId) {
+      request = { ...request, libraryQueryId: props.queryId, libraryQueryRecordId: "latest" };
+    } else {
+      request = { ...request, applicationId: props.applicationId, queryId: props.queryId };
+    }
+
+    try {
+      // For SSE queries, we need a different approach
+      // Option 1: If your backend supports SSE proxying
+      const streamId = `sse_${props.queryId}_${Date.now()}`;
+      
+      // First, initiate the SSE connection through your backend
+      const initResponse = await QueryApi.executeQuery(
+        {
+          ...request,
+          // Add SSE-specific flags
+          params: [
+            ...(request.params || []),
+            { key: "_sseInit", value: "true" },
+            { key: "_streamId", value: streamId }
+          ]
+        },
+        props.timeout.children.text.getView() as number
+      );
+
+      if (!initResponse.data.success) {
+        return {
+          ...initResponse.data,
+          code: initResponse.data.queryCode,
+          extra: _.omit(initResponse.data, ["code", "message", "data", "success", "runTime", "queryCode"]),
+        };
+      }
+
+      // Get the SSE endpoint from backend response
+      const sseEndpoint = (initResponse.data.data as any)?.sseEndpoint;
+      
+      if (sseEndpoint) {
+        // Establish SSE connection
+        establishSseConnection(
+          streamId,
+          sseEndpoint,
+          props.onStreamData,
+          props.onStreamError,
+          props.onStreamEnd,
+          activeConnections
+        );
+        
+        return {
+          ...initResponse.data,
+          code: QUERY_EXECUTION_OK,
+          streamId,
+          isStreaming: true,
+          extra: {
+            ..._.omit(initResponse.data, ["code", "message", "data", "success", "runTime", "queryCode"]),
+            streamId,
+            closeStream: () => closeSseConnection(streamId, activeConnections)
+          }
+        };
+      }
+
+      // Fallback to regular response if SSE not available
+      return {
+        ...initResponse.data,
+        code: initResponse.data.queryCode,
+        extra: _.omit(initResponse.data, ["code", "message", "data", "success", "runTime", "queryCode"]),
+      };
+      
+    } catch (error) {
+      return {
+        success: false,
+        data: "",
+        code: QUERY_EXECUTION_ERROR,
+        message: (error as any).message || "Failed to execute SSE query",
+      };
+    }
+  };
+}
+
+function establishSseConnection(
+  streamId: string,
+  endpoint: string,
+  onData?: (data: any) => void,
+  onError?: (error: any) => void,
+  onEnd?: () => void,
+  connections?: Map<string, EventSource>
+) {
+  // Close any existing connection with the same ID
+  if (connections?.has(streamId)) {
+    connections.get(streamId)?.close();
+  }
+  
+  const eventSource = new EventSource(endpoint);
+  
+  eventSource.onmessage = (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      onData?.(data);
+    } catch (error) {
+      // Handle non-JSON data
+      onData?.(event.data);
+    }
+  };
+  
+  eventSource.onerror = (error) => {
+    onError?.(error);
+    eventSource.close();
+    connections?.delete(streamId);
+    onEnd?.();
+  };
+  
+  eventSource.onopen = () => {
+    console.log(`SSE connection established: ${streamId}`);
+  };
+  
+  // Store the connection
+  connections?.set(streamId, eventSource);
+}
+
+function closeSseConnection(streamId: string, connections?: Map<string, EventSource>) {
+  const eventSource = connections?.get(streamId);
+  if (eventSource) {
+    eventSource.close();
+    connections?.delete(streamId);
+    console.log(`SSE connection closed: ${streamId}`);
+  }
+}
+
+// Alternative implementation using fetch with ReadableStream
+export function toSseQueryViewWithFetch(params: FunctionProperty[]) {
+  const activeControllers = new Map<string, AbortController>();
+  
+  return async (props: SseQueryViewProps): Promise<SseQueryResult> => {
+    const { applicationId, isViewMode } = getGlobalSettings();
+    
+    // Similar parameter processing as above...
+    let mappedVariables: Array<{key: string, value: string}> = [];
+    Object.keys(props.variables || {})
+      .filter(k => k !== "$queryName")
+      .forEach(key => {
+        const value = Object.hasOwn(props.variables[key], 'value') 
+          ? props.variables[key].value 
+          : props.variables[key];
+        mappedVariables.push({
+          key: `${key}.value`,
+          value: value || ""
+        });
+      });
+
+    const processedParams = [
+      ...params.filter(param => {
+        return !mappedVariables.map(v => v.key).includes(param.key);
+      }).map(({ key, value }) => ({ key, value: value(props.args) })),
+      ...Object.entries(props.timeout.getView()).map(([key, value]) => ({
+        key,
+        value: (value as ValueFunction)(props.args),
+      })),
+      ...mappedVariables,
+    ];
+
+    // Build the request configuration from params
+    const config = buildRequestConfig(processedParams);
+    
+    const streamId = `fetch_${props.queryId}_${Date.now()}`;
+    const controller = new AbortController();
+    activeControllers.set(streamId, controller);
+    
+    try {
+      const response = await fetch(config.url, {
+        method: config.method,
+        headers: config.headers,
+        body: config.body,
+        signal: controller.signal,
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      // Process the stream
+      if (response.body) {
+        processStream(
+          response.body,
+          props.onStreamData,
+          props.onStreamError,
+          props.onStreamEnd
+        );
+      }
+
+      return {
+        success: true,
+        data: { message: "Stream started" },
+        code: QUERY_EXECUTION_OK,
+        streamId,
+        isStreaming: true,
+        runTime: 0,
+        extra: {
+          streamId,
+          closeStream: () => {
+            controller.abort();
+            activeControllers.delete(streamId);
+          }
+        }
+      };
+      
+    } catch (error) {
+      activeControllers.delete(streamId);
+      return {
+        success: false,
+        data: "",
+        code: QUERY_EXECUTION_ERROR,
+        message: (error as any).message || "Failed to establish stream",
+      };
+    }
+  };
+}
+
+function buildRequestConfig(params: Array<{key: string, value: any}>) {
+  const config: any = {
+    url: "",
+    method: "GET",
+    headers: {},
+    body: undefined,
+  };
+  
+  params.forEach(param => {
+    if (param.key === "url" || param.key === "path") {
+      config.url = param.value;
+    } else if (param.key === "method") {
+      config.method = param.value;
+    } else if (param.key.startsWith("header.")) {
+      const headerName = param.key.substring(7);
+      config.headers[headerName] = param.value;
+    } else if (param.key === "body") {
+      config.body = param.value;
+    }
+  });
+  
+  return config;
+}
+
+async function processStream(
+  readableStream: ReadableStream<Uint8Array>,
+  onData?: (data: any) => void,
+  onError?: (error: any) => void,
+  onEnd?: () => void
+) {
+  const reader = readableStream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      
+      if (done) {
+        onEnd?.();
+        break;
+      }
+      
+      buffer += decoder.decode(value, { stream: true });
+      
+      // Process complete lines
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+      
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            // Handle SSE format
+            let data = line.trim();
+            if (data.startsWith('data: ')) {
+              data = data.substring(6);
+            }
+            
+            // Skip control messages
+            if (data === '[DONE]' || data.startsWith('event:') || data.startsWith('id:')) {
+              continue;
+            }
+            
+            const jsonData = JSON.parse(data);
+            onData?.(jsonData);
+          } catch (error) {
+            // Handle non-JSON lines
+            if (line.trim() !== '') {
+              onData?.(line.trim());
+            }
+          }
+        }
+      }
+    }
+  } catch (error) {
+    onError?.(error);
+  } finally {
+    reader.releaseLock();
+  }
+}
\ No newline at end of file
diff --git a/client/packages/lowcoder/src/constants/datasourceConstants.ts b/client/packages/lowcoder/src/constants/datasourceConstants.ts
index 0c65449f38..31094d43df 100644
--- a/client/packages/lowcoder/src/constants/datasourceConstants.ts
+++ b/client/packages/lowcoder/src/constants/datasourceConstants.ts
@@ -45,3 +45,4 @@ export const QUICK_REST_API_ID = "#QUICK_REST_API";
 export const QUICK_GRAPHQL_ID = "#QUICK_GRAPHQL";
 export const JS_CODE_ID = "#JS_CODE";
 export const OLD_LOWCODER_DATASOURCE: Partial<DatasourceType>[] = [];
+export const QUICK_SSE_HTTP_API_ID = "#QUICK_REST_API";
diff --git a/client/packages/lowcoder/src/constants/orgConstants.ts b/client/packages/lowcoder/src/constants/orgConstants.ts
index d46d9957bc..e2afb5c5fe 100644
--- a/client/packages/lowcoder/src/constants/orgConstants.ts
+++ b/client/packages/lowcoder/src/constants/orgConstants.ts
@@ -56,6 +56,7 @@ export type Org = {
   createTime?: string;
   createdAt?: number;
   updatedAt?: number;
+  isCurrentOrg?: boolean;
 };
 
 export type OrgAndRole = {
diff --git a/client/packages/lowcoder/src/constants/queryConstants.ts b/client/packages/lowcoder/src/constants/queryConstants.ts
index be78de0d6e..06de2507c2 100644
--- a/client/packages/lowcoder/src/constants/queryConstants.ts
+++ b/client/packages/lowcoder/src/constants/queryConstants.ts
@@ -14,12 +14,14 @@ import { toPluginQuery } from "comps/queries/pluginQuery/pluginQuery";
 import { MultiCompConstructor } from "lowcoder-core";
 import { DataSourcePluginMeta } from "lowcoder-sdk/dataSource";
 import { AlaSqlQuery } from "@lowcoder-ee/comps/queries/httpQuery/alasqlQuery";
+import { SseHttpQuery } from "@lowcoder-ee/comps/queries/httpQuery/sseHttpQuery";
 
 export type DatasourceType =
   | "mysql"
   | "mongodb"
   | "restApi"
   | "streamApi"
+  | "sseHttpApi"  
   | "postgres"
   | "redis"
   | "es"
@@ -41,6 +43,7 @@ export const QueryMap = {
   alasql: AlaSqlQuery,
   restApi: HttpQuery,
   streamApi: StreamQuery,
+  sseHttpApi: SseHttpQuery,
   mongodb: MongoQuery,
   postgres: SQLQuery,
   redis: RedisQuery,
diff --git a/client/packages/lowcoder/src/i18n/locales/en.ts b/client/packages/lowcoder/src/i18n/locales/en.ts
index 43bcb39868..121c583830 100644
--- a/client/packages/lowcoder/src/i18n/locales/en.ts
+++ b/client/packages/lowcoder/src/i18n/locales/en.ts
@@ -235,7 +235,8 @@ export const en = {
     "verticalGridCells": "Vertical Grid Cells",
     "timeZone": "TimeZone",
     "pickerMode": "Picker Mode",
-    "customTags": "Custom Tags"
+    "customTags": "Allow Custom Tags",
+    "customTagsTooltip": "Allow users to enter custom tags that are not in the options list."
   },
   "autoHeightProp": {
     "auto": "Auto",
@@ -744,6 +745,7 @@ export const en = {
     "transformer": "Transformer",
     "quickRestAPI": "REST Query",
     "quickStreamAPI": "Stream Query",
+    "quickSseHttpAPI": "SSE HTTP Stream Query",
     "quickGraphql": "GraphQL Query",
     "quickAlasql": "Local SQL Query",
     "databaseType": "Database Type",
diff --git a/client/packages/lowcoder/src/pages/common/WorkspaceSection.tsx b/client/packages/lowcoder/src/pages/common/WorkspaceSection.tsx
index f1cb0709f2..0bd8a4c547 100644
--- a/client/packages/lowcoder/src/pages/common/WorkspaceSection.tsx
+++ b/client/packages/lowcoder/src/pages/common/WorkspaceSection.tsx
@@ -242,11 +242,11 @@ export default function WorkspaceSectionComponent({
           displayWorkspaces.map((org: Org) => (
             <WorkspaceItem
               key={org.id}
-              $isActive={user.currentOrgId === org.id}
+              $isActive={org.isCurrentOrg}
               onClick={() => handleOrgSwitch(org.id)}
             >
               <WorkspaceName title={org.name}>{org.name}</WorkspaceName>
-              {user.currentOrgId === org.id && <ActiveIcon />}
+              {org.isCurrentOrg && <ActiveIcon />}
             </WorkspaceItem>
           ))
         ) : (
diff --git a/client/packages/lowcoder/src/pages/editor/bottom/BottomPanel.tsx b/client/packages/lowcoder/src/pages/editor/bottom/BottomPanel.tsx
index c71364470b..0ca02f6b23 100644
--- a/client/packages/lowcoder/src/pages/editor/bottom/BottomPanel.tsx
+++ b/client/packages/lowcoder/src/pages/editor/bottom/BottomPanel.tsx
@@ -1,145 +1,149 @@
-import { BottomContent } from "pages/editor/bottom/BottomContent";
-import { ResizableBox, ResizeCallbackData } from "react-resizable";
-import styled from "styled-components";
-import * as React from "react";
-import { useMemo, useState } from "react";
-import { getPanelStyle, savePanelStyle } from "util/localStorageUtil";
-import { BottomResultPanel } from "../../../components/resultPanel/BottomResultPanel";
-import { AppState } from "../../../redux/reducers";
-import { getUser } from "../../../redux/selectors/usersSelectors";
-import { connect } from "react-redux";
-import { Layers } from "constants/Layers";
-import Flex from "antd/es/flex";
-import type { MenuProps } from 'antd/es/menu';
-import { BuildOutlined, DatabaseOutlined } from "@ant-design/icons";
-import Menu from "antd/es/menu/menu";
-import { ChatView } from "@lowcoder-ee/comps/comps/chatComp/chatView";
-import { AIGenerate } from "lowcoder-design";
-
-type MenuItem = Required<MenuProps>['items'][number];
-
-const StyledResizableBox = styled(ResizableBox)`
-  position: relative;
-  box-shadow: 0 0 10px 0 rgba(0, 0, 0, 0.1);
-  border-top: 1px solid #e1e3eb;
-  z-index: ${Layers.bottomPanel};
-
-  .react-resizable-handle {
-    position: absolute;
-    border-top: transparent solid 3px;
-    width: 100%;
-    padding: 0 3px 3px 0;
-    top: 0;
-    cursor: row-resize;
-  }
-`;
-
-const StyledMenu = styled(Menu)`
-  width: 40px;
-  padding: 6px 0;
-
-  .ant-menu-item {
-    height: 30px;
-    line-height: 30px;
-  }
-`;
-
-const ChatHeader = styled.div`
-  flex: 0 0 35px;
-  padding: 0 16px;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  border-bottom: 1px solid #e1e3eb;
-  background: #fafafa;
-`;
-const ChatTitle = styled.h3`
-  margin: 0;
-  font-size: 14px;
-  font-weight: 500;
-  color: #222222;
-`;
-
-const preventDefault = (e: any) => {
-  e.preventDefault();
-};
-
-// prevent the editor window slide when resize
-const addListener = () => {
-  window.addEventListener("mousedown", preventDefault);
-};
-
-const removeListener = () => {
-  window.removeEventListener("mousedown", preventDefault);
-};
-
-function Bottom(props: any) {
-  const panelStyle = useMemo(() => getPanelStyle(), []);
-  const clientHeight = document.documentElement.clientHeight;
-  const resizeStop = (e: React.SyntheticEvent, data: ResizeCallbackData) => {
-    savePanelStyle({ ...panelStyle, bottom: { h: data.size.height } });
-    setBottomHeight(data.size.height);
-    removeListener();
-  };
-
-  const [bottomHeight, setBottomHeight] = useState(panelStyle.bottom.h);
-  const [currentOption, setCurrentOption] = useState("data");
-
-  const items: MenuItem[] = [
-    { key: 'data', icon: <DatabaseOutlined />, label: 'Data Queries' },
-    { key: 'ai', icon: <AIGenerate />, label: 'Lowcoder AI' },
-  ];
-
-  return (
-    <>
-      <BottomResultPanel bottom={bottomHeight} />
-      <StyledResizableBox
-        width={Infinity}
-        height={panelStyle.bottom.h}
-        resizeHandles={["n"]}
-        minConstraints={[680, 285]}
-        maxConstraints={[Infinity, clientHeight - 48 - 40]} // - app_header - right_header
-        onResizeStart={addListener}
-        onResizeStop={resizeStop}
-      >
-        <Flex style={{height: '100%'}}>
-          <StyledMenu
-            defaultSelectedKeys={[currentOption]}
-            mode="inline"
-            inlineCollapsed={true}
-            items={items}
-            onSelect={({key}) => {
-              setCurrentOption(key);
-            }}
-          />
-          { currentOption === "data" && <BottomContent /> }
-          { currentOption === "ai" && (
-            <Flex style={{height: '100%', flex: 1}} vertical>
-              <ChatHeader>
-                <ChatTitle>Lowcoder AI Assistant</ChatTitle>
-              </ChatHeader>
-              <ChatView
-                tableName="LC_AI"
-                modelType="n8n"
-                // streaming={true}
-                // systemPrompt="You are a helpful assistant."
-                // agent={true}
-                // maxInteractions={10}
-                modelHost="http://localhost:5678/webhook-test/9a363e76-d3a5-46d1-98c3-4359f7106d33"
-              />
-            </Flex>
-          )}
-        </Flex>
-      </StyledResizableBox>
-    </>
-  );
-}
-
-const mapStateToProps = (state: AppState) => {
-  return {
-    orgId: getUser(state).currentOrgId,
-    datasourceInfos: state.entities.datasource.data,
-  };
-};
-
-export default connect(mapStateToProps, null)(Bottom);
+import { BottomContent } from "pages/editor/bottom/BottomContent";
+import { ResizableBox, ResizeCallbackData } from "react-resizable";
+import styled from "styled-components";
+import * as React from "react";
+import { useMemo, useState } from "react";
+import { getPanelStyle, savePanelStyle } from "util/localStorageUtil";
+import { BottomResultPanel } from "../../../components/resultPanel/BottomResultPanel";
+import { AppState } from "../../../redux/reducers";
+import { getUser } from "../../../redux/selectors/usersSelectors";
+import { connect } from "react-redux";
+import { Layers } from "constants/Layers";
+import Flex from "antd/es/flex";
+import type { MenuProps } from 'antd/es/menu';
+import { BuildOutlined, DatabaseOutlined } from "@ant-design/icons";
+import Menu from "antd/es/menu/menu";
+import { AIGenerate } from "lowcoder-design";
+import { ChatPanel } from "@lowcoder-ee/comps/comps/chatComp/components/ChatPanel";
+
+type MenuItem = Required<MenuProps>['items'][number];
+
+const StyledResizableBox = styled(ResizableBox)`
+  position: relative;
+  box-shadow: 0 0 10px 0 rgba(0, 0, 0, 0.1);
+  border-top: 1px solid #e1e3eb;
+  z-index: ${Layers.bottomPanel};
+
+  .react-resizable-handle {
+    position: absolute;
+    border-top: transparent solid 3px;
+    width: 100%;
+    padding: 0 3px 3px 0;
+    top: 0;
+    cursor: row-resize;
+  }
+`;
+
+const StyledMenu = styled(Menu)`
+  width: 40px;
+  padding: 6px 0;
+
+  .ant-menu-item {
+    height: 30px;
+    line-height: 30px;
+  }
+`;
+
+const ChatHeader = styled.div`
+  flex: 0 0 35px;
+  padding: 0 16px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  border-bottom: 1px solid #e1e3eb;
+  background: #fafafa;
+`;
+const ChatTitle = styled.h3`
+  margin: 0;
+  font-size: 14px;
+  font-weight: 500;
+  color: #222222;
+`;
+
+const preventDefault = (e: any) => {
+  e.preventDefault();
+};
+
+// prevent the editor window slide when resize
+const addListener = () => {
+  window.addEventListener("mousedown", preventDefault);
+};
+
+const removeListener = () => {
+  window.removeEventListener("mousedown", preventDefault);
+};
+
+function Bottom(props: any) {
+  const panelStyle = useMemo(() => getPanelStyle(), []);
+  const clientHeight = document.documentElement.clientHeight;
+  const resizeStop = (e: React.SyntheticEvent, data: ResizeCallbackData) => {
+    savePanelStyle({ ...panelStyle, bottom: { h: data.size.height } });
+    setBottomHeight(data.size.height);
+    removeListener();
+  };
+
+  const [bottomHeight, setBottomHeight] = useState(panelStyle.bottom.h);
+  const [currentOption, setCurrentOption] = useState("data");
+
+  const items: MenuItem[] = [
+    { key: 'data', icon: <DatabaseOutlined />, label: 'Data Queries' },
+    { key: 'ai', icon: <AIGenerate />, label: 'Lowcoder AI' },
+  ];
+
+  return (
+    <>
+      <BottomResultPanel bottom={bottomHeight} />
+      <StyledResizableBox
+        width={Infinity}
+        height={panelStyle.bottom.h}
+        resizeHandles={["n"]}
+        minConstraints={[680, 285]}
+        maxConstraints={[Infinity, clientHeight - 48 - 40]} // - app_header - right_header
+        onResizeStart={addListener}
+        onResizeStop={resizeStop}
+      >
+        <Flex style={{height: '100%'}}>
+          <StyledMenu
+            defaultSelectedKeys={[currentOption]}
+            mode="inline"
+            inlineCollapsed={true}
+            items={items}
+            onSelect={({key}) => {
+              setCurrentOption(key);
+            }}
+          />
+          { currentOption === "data" && <BottomContent /> }
+          { currentOption === "ai" && (
+            <Flex style={{height: '100%', flex: 1}} vertical>
+              <ChatHeader>
+                <ChatTitle>Lowcoder AI Assistant</ChatTitle>
+              </ChatHeader>
+              {/* <ChatView
+                tableName="LC_AI"
+                handlerType="n8n"
+                streaming={true}
+                systemPrompt="You are a helpful assistant."
+                modelHost="http://localhost:5678/webhook-test/9a363e76-d3a5-46d1-98c3-4359f7106d33"
+              /> */}
+             <ChatPanel
+              tableName="LC_AI"
+              modelHost="http://localhost:5678/..."
+              systemPrompt="You are a helpful assistant."
+              streaming={true}
+              />
+            </Flex>
+          )}
+        </Flex>
+      </StyledResizableBox>
+    </>
+  );
+}
+
+const mapStateToProps = (state: AppState) => {
+  return {
+    orgId: getUser(state).currentOrgId,
+    datasourceInfos: state.entities.datasource.data,
+  };
+};
+
+export default connect(mapStateToProps, null)(Bottom);
diff --git a/client/packages/lowcoder/src/pages/setting/organization/orgList.tsx b/client/packages/lowcoder/src/pages/setting/organization/orgList.tsx
index c60f492ead..0e9c8a01c0 100644
--- a/client/packages/lowcoder/src/pages/setting/organization/orgList.tsx
+++ b/client/packages/lowcoder/src/pages/setting/organization/orgList.tsx
@@ -211,6 +211,7 @@ function OrganizationSetting() {
     logoUrl: org.logoUrl || "",
     createdAt: org.createdAt,
     updatedAt: org.updatedAt,
+    isCurrentOrg: org.isCurrentOrg,
   }));
 
 
@@ -262,7 +263,7 @@ function OrganizationSetting() {
                   dataIndex: "orgName",
                   ellipsis: true,
                   render: (_, record: any) => {
-                    const isActiveOrg = record.id === user.currentOrgId;
+                    const isActiveOrg = record.isCurrentOrg;
                     return (
                       <OrgName>
                         <StyledOrgLogo source={record.logoUrl} orgName={record.orgName} />
@@ -307,7 +308,7 @@ function OrganizationSetting() {
                 key: i,
                 operation: (
                   <OperationWrapper>
-                    {item.id !== user.currentOrgId && (
+                    {!item.isCurrentOrg && (
                       <SwitchBtn
                         className={"home-datasource-edit-button"}
                         buttonType={"blue"}
diff --git a/client/packages/lowcoder/src/redux/reducers/uiReducers/usersReducer.ts b/client/packages/lowcoder/src/redux/reducers/uiReducers/usersReducer.ts
index 4146dfd625..3142ca13d3 100644
--- a/client/packages/lowcoder/src/redux/reducers/uiReducers/usersReducer.ts
+++ b/client/packages/lowcoder/src/redux/reducers/uiReducers/usersReducer.ts
@@ -25,6 +25,8 @@ const initialState: UsersReduxState = {
   workspaces: {
     items: [],
     totalCount: 0,
+    currentOrg: null
+    
   }
 };
 
@@ -231,6 +233,7 @@ export interface UsersReduxState {
   workspaces: {
     items: Org[];           // Current page of workspaces
     totalCount: number;     // Total workspaces available
+    currentOrg: Org | null;
   };
 }
 
diff --git a/client/packages/lowcoder/src/redux/sagas/orgSagas.ts b/client/packages/lowcoder/src/redux/sagas/orgSagas.ts
index f427eeb92b..dd64bf1c9f 100644
--- a/client/packages/lowcoder/src/redux/sagas/orgSagas.ts
+++ b/client/packages/lowcoder/src/redux/sagas/orgSagas.ts
@@ -368,10 +368,11 @@ export function* fetchWorkspacesSaga(action: ReduxAction<{page: number, pageSize
       
       // Transform orgId/orgName to match Org interface
       const transformedItems = apiData.data.map(item => ({
-        id: item.orgId,
-        name: item.orgName,
-        createdAt: item.createdAt,
-        updatedAt: item.updatedAt,
+        id: item.orgView.orgId,
+        name: item.orgView.orgName,
+        createdAt: item.orgView.createdAt,
+        updatedAt: item.orgView.updatedAt,
+        isCurrentOrg: item.isCurrentOrg,
       }));
         
       yield put({
diff --git a/client/packages/lowcoder/src/util/bottomResUtils.tsx b/client/packages/lowcoder/src/util/bottomResUtils.tsx
index b2f2baf425..78c5a4de3e 100644
--- a/client/packages/lowcoder/src/util/bottomResUtils.tsx
+++ b/client/packages/lowcoder/src/util/bottomResUtils.tsx
@@ -110,6 +110,8 @@ export const getBottomResIcon = (
         return <MongoIcon />;
       case "streamApi":
         return <StreamApiIcon />;
+      case "sseHttpApi":
+        return <StreamApiIcon />;
       case "alasql":
         return <AlasqlIcon />;
       case "restApi":
diff --git a/client/packages/lowcoder/src/util/useWorkspaceManager.ts b/client/packages/lowcoder/src/util/useWorkspaceManager.ts
index 59732ac539..5c5cafee07 100644
--- a/client/packages/lowcoder/src/util/useWorkspaceManager.ts
+++ b/client/packages/lowcoder/src/util/useWorkspaceManager.ts
@@ -91,10 +91,11 @@ export function useWorkspaceManager({
         if (response.data.success) {
           const apiData = response.data.data;
           const transformedItems = apiData.data.map(item => ({
-            id: item.orgId,
-            name: item.orgName,
-            createdAt: item.createdAt,
-            updatedAt: item.updatedAt,
+            id: item.orgView.orgId,
+            name: item.orgView.orgName,
+            createdAt: item.orgView.createdAt,
+            updatedAt: item.orgView.updatedAt,
+            isCurrentOrg: item.isCurrentOrg,
           }));
 
           dispatch({
diff --git a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationApiServiceTest.java b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationApiServiceTest.java
index 1069447772..0a4fdd3f64 100644
--- a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationApiServiceTest.java
+++ b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationApiServiceTest.java
@@ -21,9 +21,12 @@
 import org.lowcoder.domain.application.model.ApplicationStatus;
 import org.lowcoder.domain.application.model.ApplicationType;
 import org.lowcoder.domain.application.service.ApplicationService;
+import org.lowcoder.domain.solutions.TemplateSolutionService;
 
 import org.lowcoder.domain.permission.model.ResourceHolder;
 import org.lowcoder.domain.permission.model.ResourceRole;
+import org.lowcoder.domain.permission.model.ResourceAction;
+import org.lowcoder.domain.permission.model.ResourcePermission;
 import org.lowcoder.sdk.constants.FieldName;
 import org.lowcoder.sdk.exception.BizError;
 import org.lowcoder.sdk.exception.BizException;
@@ -53,13 +56,507 @@ public class ApplicationApiServiceTest {
     @Autowired
     private DatasourceApiService datasourceApiService;
     @Autowired
-    private InitData initData;
+    private InitData initData = new InitData();
+    @Autowired
+    private TemplateSolutionService templateSolutionService;
 
     @BeforeAll
     public void beforeAll() {
         initData.init();
     }
 
+    @Test
+    @WithMockUser
+    public void testCreateApplication() {
+        CreateApplicationRequest request = new CreateApplicationRequest(
+            "org01",
+            null,
+            "test-app",
+            ApplicationType.APPLICATION.getValue(),
+            Map.of("comp", "list"),
+            null,
+            null,
+            null
+        );
+
+        Mono<ApplicationView> result = applicationApiService.create(request);
+
+        StepVerifier.create(result)
+            .assertNext(applicationView -> {
+                Assertions.assertNotNull(applicationView);
+                Assertions.assertEquals("test-app", applicationView.getApplicationInfoView().getName());
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testGetRecycledApplications() {
+        String appName = "recycled-app";
+        Mono<String> recycledAppIdMono = createApplication(appName, null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.recycle(appId))
+            .cache();
+
+        String normalAppName = "normal-app";
+        createApplication(normalAppName, null).block();
+
+        StepVerifier.create(
+            recycledAppIdMono.thenMany(applicationApiService.getRecycledApplications(null, null).collectList())
+        )
+        .assertNext(apps -> {
+            Assertions.assertTrue(
+                apps.stream().anyMatch(app -> appName.equals(app.getName()) && app.getApplicationStatus() == ApplicationStatus.RECYCLED),
+                "Expected recycled application not found"
+            );
+            // Optionally, assert that normal-app is not in the recycled list
+            Assertions.assertTrue(
+                apps.stream().noneMatch(app -> normalAppName.equals(app.getName())),
+                "Normal app should not be in recycled list"
+            );
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testDeleteApplication() {
+        // Step 1: Create application
+        Mono<String> appIdMono = createApplication("delete-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            // Step 2: Recycle the application
+            .delayUntil(appId -> applicationApiService.recycle(appId))
+            .cache();
+
+        // Step 3: Delete the application and verify
+        StepVerifier.create(
+            appIdMono
+                .delayUntil(appId -> applicationApiService.delete(appId))
+                .flatMap(appId -> applicationService.findById(appId))
+        )
+        .assertNext(app -> Assertions.assertEquals(ApplicationStatus.DELETED, app.getApplicationStatus()))
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testRecycleApplication() {
+        Mono<String> appIdMono = createApplication("recycle-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        StepVerifier.create(
+            appIdMono
+                .delayUntil(appId -> applicationApiService.recycle(appId))
+                .flatMap(appId -> applicationService.findById(appId))
+        )
+        .assertNext(app -> Assertions.assertEquals(ApplicationStatus.RECYCLED, app.getApplicationStatus()))
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testRestoreApplication() {
+        // Create application and recycle it
+        Mono<String> appIdMono = createApplication("restore-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.recycle(appId))
+            .cache();
+
+        // Restore the application and verify status
+        StepVerifier.create(
+            appIdMono
+                .delayUntil(appId -> applicationApiService.restore(appId))
+                .flatMap(appId -> applicationService.findById(appId))
+        )
+        .assertNext(app -> Assertions.assertNotEquals(ApplicationStatus.RECYCLED, app.getApplicationStatus()))
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testGetEditingApplication() {
+        // Create a new application
+        Mono<String> appIdMono = createApplication("editing-app-test", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        // Retrieve the editing application and verify its properties
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.getEditingApplication(appId, false))
+        )
+        .assertNext(applicationView -> {
+            Assertions.assertNotNull(applicationView);
+            Assertions.assertEquals("editing-app-test", applicationView.getApplicationInfoView().getName());
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testGetPublishedApplication() {
+        // Create a new application
+        Mono<String> appIdMono = createApplication("published-app-test", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        // Publish the application
+        Mono<String> publishedAppIdMono = appIdMono
+            .delayUntil(appId -> applicationApiService.publish(appId, new ApplicationPublishRequest("Initial Publish", "1.0.0")))
+            .cache();
+
+        // Retrieve the published application and verify its properties
+        StepVerifier.create(
+            publishedAppIdMono.flatMap(appId ->
+                applicationApiService.getPublishedApplication(appId, ApplicationRequestType.PUBLIC_TO_ALL, false)
+            )
+        )
+        .assertNext(applicationView -> {
+            Assertions.assertNotNull(applicationView);
+            Assertions.assertEquals("published-app-test", applicationView.getApplicationInfoView().getName());
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testUpdateUserApplicationLastViewTime() {
+        Mono<String> appIdMono = createApplication("last-view-time-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.updateUserApplicationLastViewTime(appId))
+        )
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testUpdateApplication() {
+        // Create a new application
+        Mono<String> appIdMono = createApplication("update-app-test", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        // Update the application's name
+        Mono<ApplicationView> updatedAppMono = appIdMono
+            .flatMap(appId -> applicationApiService.update(
+                appId,
+                Application.builder().name("updated-app-name").build(),
+                false
+            ));
+
+        // Verify the application's name is updated
+        StepVerifier.create(updatedAppMono)
+            .assertNext(applicationView ->
+                Assertions.assertEquals("updated-app-name", applicationView.getApplicationInfoView().getName())
+            )
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testPublishFunction() {
+        // Step 1: Create a new application
+        Mono<String> appIdMono = createApplication("publish-app-test", null)
+                .map(appView -> appView.getApplicationInfoView().getApplicationId())
+                .cache();
+
+        // Step 2: Publish the application
+        ApplicationPublishRequest publishRequest = new ApplicationPublishRequest("Initial Publish", "1.0.0");
+        Mono<ApplicationView> publishedAppMono = appIdMono
+                .delayUntil(appId -> applicationApiService.publish(appId, publishRequest))
+                .flatMap(appId -> applicationApiService.getPublishedApplication(appId, ApplicationRequestType.PUBLIC_TO_ALL, false));
+
+        // Step 3: Assert the result
+        StepVerifier.create(publishedAppMono)
+                .assertNext(applicationView -> {
+                    Assertions.assertNotNull(applicationView);
+                    Assertions.assertEquals("publish-app-test", applicationView.getApplicationInfoView().getName());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testUpdateEditState() {
+        Mono<String> appIdMono = createApplication("edit-state-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        ApplicationEndpoints.UpdateEditStateRequest request =
+            new ApplicationEndpoints.UpdateEditStateRequest(true);
+
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.updateEditState(appId, request))
+        )
+        .expectNext(true)
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testGrantPermission() {
+        // Create a new application
+        Mono<String> appIdMono = createApplication("grant-permission-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        // Grant permissions to user and group, then verify
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.grantPermission(
+                appId,
+                Set.of("user02"),
+                Set.of("group01"),
+                ResourceRole.EDITOR
+            ).then(applicationApiService.getApplicationPermissions(appId)))
+        )
+        .assertNext(applicationPermissionView -> {
+            Assertions.assertTrue(applicationPermissionView.getPermissions().stream()
+                .anyMatch(permissionItemView ->
+                    permissionItemView.getType() == ResourceHolder.USER &&
+                        "user02".equals(permissionItemView.getId()) &&
+                        ResourceRole.EDITOR.getValue().equals(permissionItemView.getRole())
+                ));
+            Assertions.assertTrue(applicationPermissionView.getPermissions().stream()
+                .anyMatch(permissionItemView ->
+                    permissionItemView.getType() == ResourceHolder.GROUP &&
+                        "group01".equals(permissionItemView.getId()) &&
+                        ResourceRole.EDITOR.getValue().equals(permissionItemView.getRole())
+                ));
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testUpdatePermission() {
+        // Create a new application and grant EDITOR permission to user02
+        Mono<String> appIdMono = createApplication("update-permission-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.grantPermission(
+                    appId, Set.of("user02"), Set.of(), ResourceRole.EDITOR))
+            .cache();
+
+        // Update the permission role for user02 to VIEWER and verify
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.getApplicationPermissions(appId)
+                .map(applicationPermissionView -> applicationPermissionView.getPermissions().stream()
+                    .filter(p -> p.getType() == ResourceHolder.USER && "user02".equals(p.getId()))
+                    .findFirst()
+                    .orElseThrow())
+                .flatMap(permissionItemView -> applicationApiService.updatePermission(
+                    appId, permissionItemView.getPermissionId(), ResourceRole.VIEWER))
+                .then(applicationApiService.getApplicationPermissions(appId)))
+        )
+        .assertNext(applicationPermissionView -> {
+            Assertions.assertTrue(applicationPermissionView.getPermissions().stream()
+                .anyMatch(p -> p.getType() == ResourceHolder.USER
+                    && "user02".equals(p.getId())
+                    && ResourceRole.VIEWER.getValue().equals(p.getRole())));
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testRemovePermission() {
+        // Create a new application and grant EDITOR permission to user02
+        Mono<String> appIdMono = createApplication("remove-permission-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.grantPermission(
+                    appId, Set.of("user02"), Set.of(), ResourceRole.EDITOR))
+            .cache();
+
+        // Remove the permission for user02 and verify
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.getApplicationPermissions(appId)
+                .map(applicationPermissionView -> applicationPermissionView.getPermissions().stream()
+                    .filter(p -> p.getType() == ResourceHolder.USER && "user02".equals(p.getId()))
+                    .findFirst()
+                    .orElseThrow())
+                .flatMap(permissionItemView -> applicationApiService.removePermission(
+                    appId, permissionItemView.getPermissionId()))
+                .then(applicationApiService.getApplicationPermissions(appId)))
+        )
+        .assertNext(applicationPermissionView -> {
+            Assertions.assertTrue(applicationPermissionView.getPermissions().stream()
+                .noneMatch(p -> p.getType() == ResourceHolder.USER && "user02".equals(p.getId())));
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testGetApplicationPermissions() {
+        // Create a new application and grant permissions to user and group
+        Mono<String> appIdMono = createApplication("get-permissions-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.grantPermission(
+                    appId, Set.of("user02"), Set.of("group01"), ResourceRole.EDITOR))
+            .cache();
+
+        // Retrieve and verify permissions
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.getApplicationPermissions(appId))
+        )
+        .assertNext(applicationPermissionView -> {
+            Assertions.assertTrue(applicationPermissionView.getPermissions().stream()
+                .anyMatch(p -> p.getType() == ResourceHolder.USER
+                    && "user02".equals(p.getId())
+                    && ResourceRole.EDITOR.getValue().equals(p.getRole())));
+            Assertions.assertTrue(applicationPermissionView.getPermissions().stream()
+                .anyMatch(p -> p.getType() == ResourceHolder.GROUP
+                    && "group01".equals(p.getId())
+                    && ResourceRole.EDITOR.getValue().equals(p.getRole())));
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testCreateFromTemplate() {
+        String templateId = "test-template-id";
+        Mono<ApplicationView> result = applicationApiService.createFromTemplate(templateId);
+
+        StepVerifier.create(result)
+            .expectErrorMatches(throwable ->
+                throwable instanceof BizException &&
+                    throwable.getMessage().contains("template does not exist")
+            )
+            .verify();
+    }
+
+    @Test
+    @WithMockUser
+    public void testCheckPermissionWithReadableErrorMsg() {
+        // Create a new application and grant EDITOR permission to user02
+        Mono<String> appIdMono = createApplication("check-permission-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.grantPermission(
+                    appId, Set.of("user02"), Set.of(), ResourceRole.EDITOR))
+            .cache();
+
+        // Check permission for an EDIT_APPLICATIONS action
+        StepVerifier.create(
+            appIdMono.flatMap(appId ->
+                applicationApiService.checkPermissionWithReadableErrorMsg(appId, ResourceAction.EDIT_APPLICATIONS)
+            )
+        )
+        .assertNext(resourcePermission -> {
+            Assertions.assertNotNull(resourcePermission);
+            Assertions.assertTrue(resourcePermission.getResourceRole().canDo(ResourceAction.EDIT_APPLICATIONS));
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testCheckApplicationPermissionWithReadableErrorMsg() {
+        // Create a new application and grant EDITOR permission to user02
+        Mono<String> appIdMono = createApplication("check-app-permission-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .delayUntil(appId -> applicationApiService.grantPermission(
+                    appId, Set.of("user02"), Set.of(), ResourceRole.EDITOR))
+            .cache();
+
+        // Check permission for an EDIT_APPLICATIONS action with PUBLIC_TO_ALL request type
+        StepVerifier.create(
+            appIdMono.flatMap(appId ->
+                applicationApiService.checkApplicationPermissionWithReadableErrorMsg(
+                    appId, ResourceAction.EDIT_APPLICATIONS, ApplicationRequestType.PUBLIC_TO_ALL)
+            )
+        )
+        .assertNext(resourcePermission -> {
+            Assertions.assertNotNull(resourcePermission);
+            Assertions.assertTrue(resourcePermission.getResourceRole().canDo(ResourceAction.EDIT_APPLICATIONS));
+        })
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testSetApplicationPublicToAll() {
+        Mono<String> appIdMono = createApplication("public-to-all-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.setApplicationPublicToAll(appId, true))
+        )
+            .expectNext(true)
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testSetApplicationPublicToMarketplace() {
+        Mono<String> appIdMono = createApplication("public-to-marketplace-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        ApplicationEndpoints.ApplicationPublicToMarketplaceRequest request =
+            new ApplicationEndpoints.ApplicationPublicToMarketplaceRequest(true);
+
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.setApplicationPublicToMarketplace(appId, request))
+        )
+        .expectNext(true)
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testSetApplicationAsAgencyProfile() {
+        Mono<String> appIdMono = createApplication("agency-profile-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        StepVerifier.create(
+            appIdMono.flatMap(appId -> applicationApiService.setApplicationAsAgencyProfile(appId, true))
+        )
+        .expectNext(true)
+        .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser
+    public void testUpdateSlug() {
+        String uniqueAppName = "SlugTestApp-" + System.currentTimeMillis();
+        String uniqueSlug = "new-slug-" + System.currentTimeMillis();
+
+        createApplication(uniqueAppName, null)
+            .map(applicationView -> applicationView.getApplicationInfoView().getApplicationId())
+            .flatMap(applicationId -> applicationApiService.updateSlug(applicationId, uniqueSlug))
+            .as(StepVerifier::create)
+            .expectComplete() // Expect no value, just completion
+            .verify();
+    }
+
+    @Test
+    @WithMockUser
+    public void testGetGroupsOrMembersWithoutPermissions() {
+        // Create a new application
+        Mono<String> appIdMono = createApplication("no-permission-test-app", null)
+            .map(appView -> appView.getApplicationInfoView().getApplicationId())
+            .cache();
+
+        // Grant permission to user02 and group01
+        Mono<List<Object>> resultMono = appIdMono
+            .delayUntil(appId -> applicationApiService.grantPermission(
+                    appId, Set.of("user02"), Set.of("group01"), ResourceRole.EDITOR))
+            .flatMap(appId -> applicationApiService.getGroupsOrMembersWithoutPermissions(appId));
+
+        StepVerifier.create(resultMono)
+        .assertNext(list -> {
+            // Should contain users/groups except user02 and group01
+            Assertions.assertTrue(list.stream().noneMatch(obj -> obj.toString().contains("user02")));
+            Assertions.assertTrue(list.stream().noneMatch(obj -> obj.toString().contains("group01")));
+        })
+        .verifyComplete();
+    }
+
     @Test
     @WithMockUser
     public void testAutoInheritFoldersPermissionsOnAppCreate() {
@@ -334,25 +831,4 @@ public void testAppCreateAndRetrievalByGID() {
                 })
                 .verifyComplete();
     }
-
-    // Skipping this test as it requires a database setup that's not available in the test environment
-    @Test
-    @WithMockUser
-    @Disabled("This test requires a database setup that's not available in the test environment")
-    public void testUpdateSlug() {
-        // Create a dummy application with a unique name to avoid conflicts
-        String uniqueAppName = "SlugTestApp-" + System.currentTimeMillis();
-        String uniqueSlug = "new-slug-" + System.currentTimeMillis();
-
-        // Create the application and then update its slug
-        createApplication(uniqueAppName, null)
-                .map(applicationView -> applicationView.getApplicationInfoView().getApplicationId())
-                .flatMap(applicationId -> applicationApiService.updateSlug(applicationId, uniqueSlug))
-                .as(StepVerifier::create)
-                .assertNext(application -> {
-                    Assertions.assertNotNull(application.getSlug(), "Slug should not be null");
-                    Assertions.assertEquals(uniqueSlug, application.getSlug(), "Slug should be updated to the new value");
-                })
-                .verifyComplete();
-    }
 }
\ No newline at end of file
diff --git a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationEndpointsTest.java b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationEndpointsTest.java
new file mode 100644
index 0000000000..c09bc9d63a
--- /dev/null
+++ b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationEndpointsTest.java
@@ -0,0 +1,1442 @@
+package org.lowcoder.api.application;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lowcoder.api.application.ApplicationEndpoints.*;
+import org.lowcoder.api.application.view.*;
+import org.lowcoder.api.framework.view.ResponseView;
+import org.lowcoder.api.home.UserHomeApiService;
+import org.lowcoder.api.home.UserHomepageView;
+import org.lowcoder.api.util.BusinessEventPublisher;
+import org.lowcoder.api.util.GidService;
+import org.lowcoder.domain.application.model.Application;
+import org.lowcoder.domain.application.model.ApplicationRequestType;
+import org.lowcoder.domain.application.model.ApplicationStatus;
+import org.lowcoder.domain.application.service.ApplicationRecordService;
+import org.lowcoder.domain.permission.model.ResourceRole;
+import org.mockito.Mockito;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+import reactor.core.publisher.Flux;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.when;
+
+class ApplicationEndpointsTest {
+
+    private UserHomeApiService userHomeApiService;
+    private ApplicationApiService applicationApiService;
+    private BusinessEventPublisher businessEventPublisher;
+    private GidService gidService;
+    private ApplicationRecordService applicationRecordService;
+    private ApplicationController controller;
+
+    private static final String TEST_APPLICATION_ID = "test-app-id";
+    private static final String TEST_ORGANIZATION_ID = "test-org-id";
+    private static final String TEST_TEMPLATE_ID = "template-123";
+
+    @BeforeEach
+    void setUp() {
+        // Create mocks manually
+        userHomeApiService = Mockito.mock(UserHomeApiService.class);
+        applicationApiService = Mockito.mock(ApplicationApiService.class);
+        businessEventPublisher = Mockito.mock(BusinessEventPublisher.class);
+        gidService = Mockito.mock(GidService.class);
+        applicationRecordService = Mockito.mock(ApplicationRecordService.class);
+
+        // Setup common mocks
+        when(businessEventPublisher.publishApplicationCommonEvent(any(), any(), any())).thenReturn(Mono.empty());
+        when(businessEventPublisher.publishApplicationCommonEvent(any(), any(), any(), any(), any())).thenReturn(Mono.empty());
+        when(businessEventPublisher.publishApplicationPublishEvent(any(), any())).thenReturn(Mono.empty());
+        when(businessEventPublisher.publishApplicationVersionChangeEvent(any(), any())).thenReturn(Mono.empty());
+        when(businessEventPublisher.publishApplicationPermissionEvent(any(), any(), any(), any(), any())).thenReturn(Mono.empty());
+        when(businessEventPublisher.publishApplicationSharingEvent(any(), any(), any())).thenReturn(Mono.empty());
+        
+        // Mock gidService to return the same ID that was passed to it
+        when(gidService.convertApplicationIdToObjectId(any())).thenAnswer(invocation -> {
+            String appId = invocation.getArgument(0);
+            return Mono.just(appId);
+        });
+        when(gidService.convertLibraryQueryIdToObjectId(any())).thenAnswer(invocation -> {
+            String appId = invocation.getArgument(0);
+            return Mono.just(appId);
+        });
+
+        // Mock getApplicationPermissions to prevent null pointer exceptions
+        ApplicationPermissionView mockPermissionView = Mockito.mock(ApplicationPermissionView.class);
+        when(applicationApiService.getApplicationPermissions(any())).thenReturn(Mono.just(mockPermissionView));
+
+        // Mock setApplicationPublicToMarketplace to return a proper Mono
+        when(applicationApiService.setApplicationPublicToMarketplace(any(), any())).thenReturn(Mono.just(true));
+
+        // Mock setApplicationAsAgencyProfile to return a proper Mono
+        when(applicationApiService.setApplicationAsAgencyProfile(any(), anyBoolean())).thenReturn(Mono.just(true));
+
+        // Mock setApplicationPublicToAll to return a proper Mono
+        when(applicationApiService.setApplicationPublicToAll(any(), anyBoolean())).thenReturn(Mono.just(true));
+
+        // Mock getGroupsOrMembersWithoutPermissions to return a proper Mono
+        when(applicationApiService.getGroupsOrMembersWithoutPermissions(any())).thenReturn(Mono.just(List.of()));
+
+        // Create controller with all required dependencies
+        controller = new ApplicationController(
+                userHomeApiService,
+                applicationApiService,
+                businessEventPublisher,
+                gidService,
+                applicationRecordService
+        );
+    }
+
+    @Test
+    void testCreateApplication_success() {
+        // Prepare request data
+        CreateApplicationRequest request = new CreateApplicationRequest(
+                TEST_ORGANIZATION_ID,
+                null,
+                "Test App",
+                1,
+                new HashMap<>(),
+                null,
+                null,
+                null
+        );
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.create(any(CreateApplicationRequest.class)))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.create(request);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationInfoView() != null;
+                    assert TEST_APPLICATION_ID.equals(response.getData().getApplicationInfoView().getApplicationId());
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreateApplication_withAllFields() {
+        // Prepare request data with all fields populated
+        HashMap<String, Object> dsl = new HashMap<>();
+        dsl.put("components", new HashMap<>());
+        dsl.put("layout", new HashMap<>());
+
+        CreateApplicationRequest request = new CreateApplicationRequest(
+                TEST_ORGANIZATION_ID,
+                "test-gid",
+                "Test Application with All Fields",
+                1,
+                dsl,
+                "folder-123",
+                true,
+                false
+        );
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.create(any(CreateApplicationRequest.class)))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.create(request);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreateApplication_serviceError() {
+        // Prepare request data
+        CreateApplicationRequest request = new CreateApplicationRequest(
+                TEST_ORGANIZATION_ID,
+                null,
+                "Error App",
+                1,
+                new HashMap<>(),
+                null,
+                false,
+                false
+        );
+
+        when(applicationApiService.create(any(CreateApplicationRequest.class)))
+                .thenReturn(Mono.error(new RuntimeException("Service error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.create(request);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testCreateFromTemplate_success() {
+        // Mock the service response
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.createFromTemplate(TEST_TEMPLATE_ID))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.createFromTemplate(TEST_TEMPLATE_ID);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationInfoView() != null;
+                    assert TEST_APPLICATION_ID.equals(response.getData().getApplicationInfoView().getApplicationId());
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreateFromTemplate_withDifferentTemplateId() {
+        // Test with a different template ID
+        String differentTemplateId = "template-456";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.createFromTemplate(differentTemplateId))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.createFromTemplate(differentTemplateId);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreateFromTemplate_serviceError() {
+        // Mock service error
+        when(applicationApiService.createFromTemplate(TEST_TEMPLATE_ID))
+                .thenReturn(Mono.error(new RuntimeException("Template not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.createFromTemplate(TEST_TEMPLATE_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testCreateFromTemplate_withEmptyTemplateId() {
+        // Test with empty template ID
+        String emptyTemplateId = "";
+
+        when(applicationApiService.createFromTemplate(emptyTemplateId))
+                .thenReturn(Mono.error(new IllegalArgumentException("Template ID cannot be empty")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.createFromTemplate(emptyTemplateId);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(IllegalArgumentException.class)
+                .verify();
+    }
+
+    @Test
+    void testCreateFromTemplate_withNullTemplateId() {
+        // Test with null template ID
+        when(applicationApiService.createFromTemplate(null))
+                .thenReturn(Mono.error(new IllegalArgumentException("Template ID cannot be null")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.createFromTemplate(null);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(IllegalArgumentException.class)
+                .verify();
+    }
+
+    @Test
+    void testRecycle_success() {
+        // Mock the service responses
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.recycle(TEST_APPLICATION_ID))
+                .thenReturn(Mono.just(true));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.recycle(TEST_APPLICATION_ID);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testRecycle_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-456";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(differentAppId, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.recycle(differentAppId))
+                .thenReturn(Mono.just(true));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.recycle(differentAppId);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testRecycle_serviceError() {
+        // Mock service error
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.recycle(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testRecycle_recycleServiceError() {
+        // Mock successful get but failed recycle
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.recycle(TEST_APPLICATION_ID))
+                .thenReturn(Mono.error(new RuntimeException("Recycle operation failed")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.recycle(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testRestore_success() {
+        // Mock the service responses
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.restore(TEST_APPLICATION_ID))
+                .thenReturn(Mono.just(true));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.restore(TEST_APPLICATION_ID);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testRestore_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-789";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(differentAppId, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.restore(differentAppId))
+                .thenReturn(Mono.just(true));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.restore(differentAppId);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testRestore_serviceError() {
+        // Mock service error
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.restore(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testRestore_restoreServiceError() {
+        // Mock successful get but failed restore
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.restore(TEST_APPLICATION_ID))
+                .thenReturn(Mono.error(new RuntimeException("Restore operation failed")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.restore(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testRecycle_withEmptyApplicationId() {
+        // Test with empty application ID
+        String emptyAppId = "";
+
+        when(applicationApiService.getEditingApplication(emptyAppId, true))
+                .thenReturn(Mono.error(new RuntimeException("Application ID cannot be empty")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.recycle(emptyAppId);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testRestore_withEmptyApplicationId() {
+        // Test with empty application ID
+        String emptyAppId = "";
+
+        when(applicationApiService.getEditingApplication(emptyAppId, true))
+                .thenReturn(Mono.error(new RuntimeException("Application ID cannot be empty")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.restore(emptyAppId);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetRecycledApplications_success() {
+        // Mock the service response
+        List<ApplicationInfoView> mockRecycledApps = List.of(
+                createMockApplicationInfoView(),
+                createMockApplicationInfoView()
+        );
+        when(applicationApiService.getRecycledApplications(null, null))
+                .thenReturn(Flux.fromIterable(mockRecycledApps));
+
+        // Test the controller method directly
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getRecycledApplications(null, null);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().size() == 2;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetRecycledApplications_withNameFilter() {
+        // Mock the service response with name filter
+        String nameFilter = "test-app";
+        List<ApplicationInfoView> mockRecycledApps = List.of(createMockApplicationInfoView());
+        when(applicationApiService.getRecycledApplications(nameFilter, null))
+                .thenReturn(Flux.fromIterable(mockRecycledApps));
+
+        // Test the controller method directly
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getRecycledApplications(nameFilter, null);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().size() == 1;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetRecycledApplications_withCategoryFilter() {
+        // Mock the service response with category filter
+        String categoryFilter = "business";
+        List<ApplicationInfoView> mockRecycledApps = List.of(createMockApplicationInfoView());
+        when(applicationApiService.getRecycledApplications(null, categoryFilter))
+                .thenReturn(Flux.fromIterable(mockRecycledApps));
+
+        // Test the controller method directly
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getRecycledApplications(null, categoryFilter);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().size() == 1;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetRecycledApplications_withNameAndCategoryFilter() {
+        // Mock the service response with both filters
+        String nameFilter = "test-app";
+        String categoryFilter = "business";
+        List<ApplicationInfoView> mockRecycledApps = List.of(createMockApplicationInfoView());
+        when(applicationApiService.getRecycledApplications(nameFilter, categoryFilter))
+                .thenReturn(Flux.fromIterable(mockRecycledApps));
+
+        // Test the controller method directly
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getRecycledApplications(nameFilter, categoryFilter);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().size() == 1;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetRecycledApplications_emptyResult() {
+        // Mock empty service response
+        when(applicationApiService.getRecycledApplications(null, null))
+                .thenReturn(Flux.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getRecycledApplications(null, null);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().isEmpty();
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetRecycledApplications_serviceError() {
+        // Mock service error
+        when(applicationApiService.getRecycledApplications(null, null))
+                .thenReturn(Flux.error(new RuntimeException("Database error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getRecycledApplications(null, null);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testDelete_success() {
+        // Mock the service responses
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.delete(TEST_APPLICATION_ID))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.delete(TEST_APPLICATION_ID);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationInfoView() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testDelete_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-999";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(differentAppId, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.delete(differentAppId))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.delete(differentAppId);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testDelete_serviceError() {
+        // Mock service error
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.delete(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testDelete_deleteServiceError() {
+        // Mock successful get but failed delete
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.delete(TEST_APPLICATION_ID))
+                .thenReturn(Mono.error(new RuntimeException("Delete operation failed")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.delete(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testDelete_withEmptyApplicationId() {
+        // Test with empty application ID
+        String emptyAppId = "";
+
+        when(applicationApiService.getEditingApplication(emptyAppId, true))
+                .thenReturn(Mono.error(new RuntimeException("Application ID cannot be empty")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.delete(emptyAppId);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetEditingApplication_success() {
+        // Mock the service response
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getEditingApplication(TEST_APPLICATION_ID, false);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationInfoView() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetEditingApplication_withDeleted() {
+        // Mock the service response with withDeleted=true
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getEditingApplication(TEST_APPLICATION_ID, true);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetEditingApplication_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-123";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getEditingApplication(differentAppId, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(differentAppId))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getEditingApplication(differentAppId, false);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetEditingApplication_serviceError() {
+        // Mock service error
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, false))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getEditingApplication(TEST_APPLICATION_ID, false);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetEditingApplication_withEmptyApplicationId() {
+        // Test with empty application ID
+        String emptyAppId = "";
+
+        when(applicationApiService.getEditingApplication(emptyAppId, false))
+                .thenReturn(Mono.error(new RuntimeException("Application ID cannot be empty")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getEditingApplication(emptyAppId, false);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetPublishedApplication_success() {
+        // Mock the service responses
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.PUBLIC_TO_ALL, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedApplication(TEST_APPLICATION_ID, false);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationInfoView() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetPublishedApplication_withDeleted() {
+        // Mock the service responses with withDeleted=true
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.PUBLIC_TO_ALL, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedApplication(TEST_APPLICATION_ID, true);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetPublishedApplication_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-456";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(differentAppId, ApplicationRequestType.PUBLIC_TO_ALL, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(differentAppId))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedApplication(differentAppId, false);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetPublishedApplication_serviceError() {
+        // Mock service error
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.PUBLIC_TO_ALL, false))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedApplication(TEST_APPLICATION_ID, false);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetPublishedApplication_withEmptyApplicationId() {
+        // Test with empty application ID
+        String emptyAppId = "";
+
+        when(applicationApiService.getPublishedApplication(emptyAppId, ApplicationRequestType.PUBLIC_TO_ALL, false))
+                .thenReturn(Mono.error(new RuntimeException("Application ID cannot be empty")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedApplication(emptyAppId, false);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetPublishedMarketPlaceApplication_success() {
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.PUBLIC_TO_MARKETPLACE, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedMarketPlaceApplication(TEST_APPLICATION_ID);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetPublishedMarketPlaceApplication_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-789";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(differentAppId, ApplicationRequestType.PUBLIC_TO_MARKETPLACE, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(differentAppId))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedMarketPlaceApplication(differentAppId);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetPublishedMarketPlaceApplication_serviceError() {
+        // Mock service error
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.PUBLIC_TO_MARKETPLACE, false))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getPublishedMarketPlaceApplication(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetAgencyProfileApplication_success() {
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.AGENCY_PROFILE, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+
+        Mono<ResponseView<ApplicationView>> result = controller.getAgencyProfileApplication(TEST_APPLICATION_ID);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetAgencyProfileApplication_withDifferentApplicationId() {
+        // Test with a different application ID
+        String differentAppId = "app-999";
+
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationApiService.getPublishedApplication(differentAppId, ApplicationRequestType.AGENCY_PROFILE, false))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.updateUserApplicationLastViewTime(differentAppId))
+                .thenReturn(Mono.empty());
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getAgencyProfileApplication(differentAppId);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetAgencyProfileApplication_serviceError() {
+        // Mock service error
+        when(applicationApiService.getPublishedApplication(TEST_APPLICATION_ID, ApplicationRequestType.AGENCY_PROFILE, false))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.getAgencyProfileApplication(TEST_APPLICATION_ID);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testUpdate_success() {
+        ApplicationView mockApplicationView = createMockApplicationView();
+        Application mockApplication = createMockApplication();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.update(TEST_APPLICATION_ID, mockApplication, null))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        Mono<ResponseView<ApplicationView>> result = controller.update(TEST_APPLICATION_ID, mockApplication, null);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testUpdate_withUpdateStatus() {
+        // Mock the service responses with updateStatus=true
+        ApplicationView mockApplicationView = createMockApplicationView();
+        Application mockApplication = createMockApplication();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.update(TEST_APPLICATION_ID, mockApplication, true))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.update(TEST_APPLICATION_ID, mockApplication, true);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testUpdate_serviceError() {
+        // Mock service error
+        Application mockApplication = createMockApplication();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.error(new RuntimeException("Application not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.update(TEST_APPLICATION_ID, mockApplication, null);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testUpdate_updateServiceError() {
+        // Mock successful get but failed update
+        ApplicationView mockApplicationView = createMockApplicationView();
+        Application mockApplication = createMockApplication();
+        when(applicationApiService.getEditingApplication(TEST_APPLICATION_ID, true))
+                .thenReturn(Mono.just(mockApplicationView));
+        when(applicationApiService.update(TEST_APPLICATION_ID, mockApplication, null))
+                .thenReturn(Mono.error(new RuntimeException("Update operation failed")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.update(TEST_APPLICATION_ID, mockApplication, null);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testPublish_success() {
+        ApplicationView mockApplicationView = createMockApplicationView();
+        when(applicationRecordService.getLatestRecordByApplicationId(any()))
+                .thenReturn(Mono.empty());
+        when(applicationApiService.publish(any(), any(ApplicationPublishRequest.class)))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        Mono<ResponseView<ApplicationView>> result = controller.publish(TEST_APPLICATION_ID, null);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testPublish_withPublishRequest() {
+        // Mock the service responses with publish request
+        ApplicationView mockApplicationView = createMockApplicationView();
+        ApplicationPublishRequest publishRequest = new ApplicationPublishRequest("test-tag", "1.0.0");
+        when(applicationRecordService.getLatestRecordByApplicationId(TEST_APPLICATION_ID))
+                .thenReturn(Mono.empty());
+        when(applicationApiService.publish(TEST_APPLICATION_ID, publishRequest))
+                .thenReturn(Mono.just(mockApplicationView));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.publish(TEST_APPLICATION_ID, publishRequest);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testPublish_serviceError() {
+        // Mock service error
+        when(applicationRecordService.getLatestRecordByApplicationId(TEST_APPLICATION_ID))
+                .thenReturn(Mono.error(new RuntimeException("Application record not found")));
+
+        // Test the controller method directly
+        Mono<ResponseView<ApplicationView>> result = controller.publish(TEST_APPLICATION_ID, null);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testUpdateEditState_success() {
+        UpdateEditStateRequest updateRequest = new UpdateEditStateRequest(true);
+        when(applicationApiService.updateEditState(TEST_APPLICATION_ID, updateRequest))
+                .thenReturn(Mono.just(true));
+
+        Mono<ResponseView<Boolean>> result = controller.updateEditState(TEST_APPLICATION_ID, updateRequest);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testUpdateSlug_success() {
+        String newSlug = "new-app-slug";
+        Application mockApplication = createMockApplication();
+        when(applicationApiService.updateSlug(TEST_APPLICATION_ID, newSlug))
+                .thenReturn(Mono.just(mockApplication));
+
+        Mono<ResponseView<Application>> result = controller.updateSlug(TEST_APPLICATION_ID, newSlug);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetUserHomePage_success() {
+        UserHomepageView mockHomepageView = Mockito.mock(UserHomepageView.class);
+        when(userHomeApiService.getUserHomePageView(any()))
+                .thenReturn(Mono.just(mockHomepageView));
+
+        Mono<ResponseView<UserHomepageView>> result = controller.getUserHomePage(0);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetApplications_success() {
+        List<ApplicationInfoView> mockApps = List.of(createMockApplicationInfoView());
+        when(userHomeApiService.getAllAuthorisedApplications4CurrentOrgMember(any(), any(), anyBoolean(), any(), any()))
+                .thenReturn(Flux.fromIterable(mockApps));
+
+        Mono<ResponseView<List<ApplicationInfoView>>> result = controller.getApplications(null, null, true, null, null, 1, 10);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetMarketplaceApplications_success() {
+        List<MarketplaceApplicationInfoView> mockApps = List.of(Mockito.mock(MarketplaceApplicationInfoView.class));
+        when(userHomeApiService.getAllMarketplaceApplications(any()))
+                .thenReturn(Flux.fromIterable(mockApps));
+
+        Mono<ResponseView<List<MarketplaceApplicationInfoView>>> result = controller.getMarketplaceApplications(null);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetAgencyProfileApplications_success() {
+        List<MarketplaceApplicationInfoView> mockApps = List.of(Mockito.mock(MarketplaceApplicationInfoView.class));
+        when(userHomeApiService.getAllAgencyProfileApplications(any()))
+                .thenReturn(Flux.fromIterable(mockApps));
+
+        Mono<ResponseView<List<MarketplaceApplicationInfoView>>> result = controller.getAgencyProfileApplications(null);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testUpdatePermission_success() {
+        UpdatePermissionRequest updateRequest = new UpdatePermissionRequest("editor");
+        when(applicationApiService.updatePermission(eq(TEST_APPLICATION_ID), eq("permission-123"), any()))
+                .thenReturn(Mono.just(true));
+
+        Mono<ResponseView<Boolean>> result = controller.updatePermission(TEST_APPLICATION_ID, "permission-123", updateRequest);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testRemovePermission_success() {
+        when(applicationApiService.removePermission(TEST_APPLICATION_ID, "permission-123"))
+                .thenReturn(Mono.just(true));
+
+        Mono<ResponseView<Boolean>> result = controller.removePermission(TEST_APPLICATION_ID, "permission-123");
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGrantPermission_success() {
+        BatchAddPermissionRequest grantRequest = new BatchAddPermissionRequest("editor", Set.of("user1"), Set.of("group1"));
+        when(applicationApiService.grantPermission(TEST_APPLICATION_ID, Set.of("user1"), Set.of("group1"), ResourceRole.EDITOR))
+                .thenReturn(Mono.just(true));
+
+        Mono<ResponseView<Boolean>> result = controller.grantPermission(TEST_APPLICATION_ID, grantRequest);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetApplicationPermissions_success() {
+        Mono<ResponseView<ApplicationPermissionView>> result = controller.getApplicationPermissions(TEST_APPLICATION_ID);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetGroupsOrMembersWithoutPermissions_success() {
+        Mono<ResponseView<List<Object>>> result = controller.getGroupsOrMembersWithoutPermissions(TEST_APPLICATION_ID, null, 1, 1000);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testSetApplicationPublicToAll_success() {
+        ApplicationPublicToAllRequest request = new ApplicationPublicToAllRequest(true);
+
+        Mono<ResponseView<Boolean>> result = controller.setApplicationPublicToAll(TEST_APPLICATION_ID, request);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testSetApplicationPublicToMarketplace_success() {
+        ApplicationPublicToMarketplaceRequest request = new ApplicationPublicToMarketplaceRequest(true);
+
+        Mono<ResponseView<Boolean>> result = controller.setApplicationPublicToMarketplace(TEST_APPLICATION_ID, request);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testSetApplicationAsAgencyProfile_success() {
+        ApplicationAsAgencyProfileRequest request = new ApplicationAsAgencyProfileRequest(true);
+
+        Mono<ResponseView<Boolean>> result = controller.setApplicationAsAgencyProfile(TEST_APPLICATION_ID, request);
+
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    // Helper methods to create mock objects
+    private ApplicationView createMockApplicationView() {
+        ApplicationView view = Mockito.mock(ApplicationView.class);
+        ApplicationInfoView infoView = createMockApplicationInfoView();
+        when(view.getApplicationInfoView()).thenReturn(infoView);
+        return view;
+    }
+
+    private ApplicationInfoView createMockApplicationInfoView() {
+        ApplicationInfoView view = Mockito.mock(ApplicationInfoView.class);
+        when(view.getApplicationId()).thenReturn(TEST_APPLICATION_ID);
+        when(view.getName()).thenReturn("Test Application");
+        when(view.getApplicationType()).thenReturn(1); // ApplicationType.APPLICATION.getValue()
+        when(view.getApplicationStatus()).thenReturn(ApplicationStatus.NORMAL);
+        return view;
+    }
+
+    private Application createMockApplication() {
+        Application application = Mockito.mock(Application.class);
+        when(application.getId()).thenReturn(TEST_APPLICATION_ID);
+        when(application.getName()).thenReturn("Test Application");
+        when(application.getApplicationType()).thenReturn(1); // ApplicationType.APPLICATION.getValue()
+        when(application.getApplicationStatus()).thenReturn(ApplicationStatus.NORMAL);
+        return application;
+    }
+}
diff --git a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationHistorySnapshotEndpointsIntegrationTest.java b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationHistorySnapshotEndpointsIntegrationTest.java
new file mode 100644
index 0000000000..373945d340
--- /dev/null
+++ b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationHistorySnapshotEndpointsIntegrationTest.java
@@ -0,0 +1,470 @@
+package org.lowcoder.api.application;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.lowcoder.api.application.ApplicationHistorySnapshotEndpoints.ApplicationHistorySnapshotRequest;
+import org.lowcoder.api.application.view.HistorySnapshotDslView;
+import org.lowcoder.api.common.InitData;
+import org.lowcoder.api.common.mockuser.WithMockUser;
+import org.lowcoder.api.framework.view.ResponseView;
+import org.lowcoder.domain.application.model.Application;
+import org.lowcoder.domain.application.service.ApplicationService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.test.context.ActiveProfiles;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.Map;
+
+import static org.lowcoder.sdk.constants.GlobalContext.VISITOR_TOKEN;
+import org.lowcoder.api.application.view.ApplicationView;
+
+@SpringBootTest
+@ActiveProfiles("test") // Uses embedded MongoDB
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+public class ApplicationHistorySnapshotEndpointsIntegrationTest {
+
+    @Autowired
+    private ApplicationHistorySnapshotController controller;
+    
+    @Autowired
+    private ApplicationController applicationController;
+    
+    @Autowired
+    private InitData initData;
+
+    @BeforeAll
+    public void beforeAll() {
+        initData.init(); // Initialize test database with data
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testCreateHistorySnapshotWithExistingApplication() {
+        // Use an existing application from test data instead of creating a new one
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // Create history snapshot request for existing application
+        ApplicationHistorySnapshotRequest snapshotRequest = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            createTestDsl(),
+            createTestContext()
+        );
+        
+        System.out.println("Creating history snapshot for existing app: " + existingAppId);
+        
+        // Create history snapshot
+        Mono<ResponseView<Boolean>> result = controller.create(snapshotRequest)
+            .doOnNext(response -> {
+                System.out.println("History snapshot creation response: " + response);
+            })
+            .doOnError(error -> {
+                System.err.println("History snapshot creation error: " + error.getMessage());
+                error.printStackTrace();
+            })
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData());
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testListHistorySnapshotsWithExistingApplication() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // First create a history snapshot for the existing application
+        ApplicationHistorySnapshotRequest snapshotRequest = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            createTestDsl(),
+            createTestContext()
+        );
+        
+        // Create snapshot and then list snapshots
+        Mono<ResponseView<Map<String, Object>>> result = controller.create(snapshotRequest)
+            .then(controller.listAllHistorySnapshotBriefInfo(
+                existingAppId,
+                1,
+                10,
+                null,
+                null,
+                null,
+                null
+            ))
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData().containsKey("list"));
+                Assertions.assertTrue(response.getData().containsKey("count"));
+                Assertions.assertTrue((Long) response.getData().get("count") >= 1L);
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testGetHistorySnapshotDslWithExistingApplication() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // First create a history snapshot for the existing application
+        ApplicationHistorySnapshotRequest snapshotRequest = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            createTestDsl(),
+            createTestContext()
+        );
+        
+        // Create snapshot and then get snapshot DSL
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.create(snapshotRequest)
+            .then(controller.listAllHistorySnapshotBriefInfo(
+                existingAppId,
+                1,
+                10,
+                null,
+                null,
+                null,
+                null
+            ))
+            .flatMap(listResponse -> {
+                @SuppressWarnings("unchecked")
+                java.util.List<ApplicationHistorySnapshotEndpoints.ApplicationHistorySnapshotBriefInfo> snapshots = 
+                    (java.util.List<ApplicationHistorySnapshotEndpoints.ApplicationHistorySnapshotBriefInfo>) listResponse.getData().get("list");
+                
+                if (!snapshots.isEmpty()) {
+                    String snapshotId = snapshots.get(0).snapshotId();
+                    return controller.getHistorySnapshotDsl(existingAppId, snapshotId);
+                } else {
+                    return Mono.error(new RuntimeException("No snapshots found"));
+                }
+            })
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertNotNull(response.getData().getApplicationsDsl());
+                Assertions.assertNotNull(response.getData().getModuleDSL());
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testListArchivedHistorySnapshotsWithExistingApplication() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // First create a history snapshot for the existing application
+        ApplicationHistorySnapshotRequest snapshotRequest = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            createTestDsl(),
+            createTestContext()
+        );
+        
+        // Create snapshot and then list archived snapshots
+        Mono<ResponseView<Map<String, Object>>> result = controller.create(snapshotRequest)
+            .then(controller.listAllHistorySnapshotBriefInfoArchived(
+                existingAppId,
+                1,
+                10,
+                null,
+                null,
+                null,
+                null
+            ))
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData().containsKey("list"));
+                Assertions.assertTrue(response.getData().containsKey("count"));
+                // Archived snapshots might be empty in test environment
+                Assertions.assertNotNull(response.getData().get("count"));
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testListArchivedHistorySnapshotsEmptyList() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // Test the archived endpoint structure - in test environment, there are no archived snapshots
+        // so we test that the endpoint responds correctly with an empty list
+        Mono<ResponseView<Map<String, Object>>> listResult = controller.listAllHistorySnapshotBriefInfoArchived(
+            existingAppId,
+            1,
+            10,
+            null,
+            null,
+            null,
+            null
+        )
+        .contextWrite(setupTestContext());
+
+        // Verify that the archived list endpoint works correctly
+        StepVerifier.create(listResult)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData().containsKey("list"));
+                Assertions.assertTrue(response.getData().containsKey("count"));
+                // In test environment, count should be 0 since no snapshots are archived
+                Assertions.assertEquals(0L, response.getData().get("count"));
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testCreateMultipleSnapshotsWithExistingApplication() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // Create multiple history snapshots for the existing application
+        ApplicationHistorySnapshotRequest snapshotRequest1 = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            createTestDsl(),
+            createTestContext("snapshot1")
+        );
+        
+        ApplicationHistorySnapshotRequest snapshotRequest2 = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            createTestDsl(),
+            createTestContext("snapshot2")
+        );
+        
+        // Create multiple snapshots and then list them
+        Mono<ResponseView<Map<String, Object>>> result = controller.create(snapshotRequest1)
+            .then(controller.create(snapshotRequest2))
+            .then(controller.listAllHistorySnapshotBriefInfo(
+                existingAppId,
+                1,
+                10,
+                null,
+                null,
+                null,
+                null
+            ))
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData().containsKey("list"));
+                Assertions.assertTrue(response.getData().containsKey("count"));
+                Assertions.assertTrue((Long) response.getData().get("count") >= 2L);
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testCreateSnapshotWithEmptyDslWithExistingApplication() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // Create history snapshot with empty DSL for the existing application
+        ApplicationHistorySnapshotRequest snapshotRequest = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            new HashMap<>(),
+            createTestContext()
+        );
+        
+        // Create snapshot
+        Mono<ResponseView<Boolean>> result = controller.create(snapshotRequest)
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData());
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testCreateSnapshotWithComplexDslWithExistingApplication() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        
+        // Create complex DSL
+        Map<String, Object> complexDsl = createComplexTestDsl();
+        
+        // Create history snapshot with complex DSL for the existing application
+        ApplicationHistorySnapshotRequest snapshotRequest = new ApplicationHistorySnapshotRequest(
+            existingAppId,
+            complexDsl,
+            createTestContext("complex-snapshot")
+        );
+        
+        // Create snapshot
+        Mono<ResponseView<Boolean>> result = controller.create(snapshotRequest)
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertTrue(response.getData());
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testApplicationCreationWorks() {
+        // Test that application creation works independently
+        ApplicationEndpoints.CreateApplicationRequest createRequest = new ApplicationEndpoints.CreateApplicationRequest(
+            "org01",
+            null,
+            "Test App for Creation",
+            1,
+            createTestDsl(),
+            null,
+            null,
+            null
+        );
+
+        System.out.println("Creating application with request: " + createRequest);
+
+        Mono<ResponseView<ApplicationView>> result = applicationController.create(createRequest)
+            .doOnNext(response -> {
+                System.out.println("Application creation response: " + response);
+                if (response.isSuccess() && response.getData() != null) {
+                    System.out.println("Application created successfully with ID: " + response.getData().getApplicationInfoView().getApplicationId());
+                } else {
+                    System.out.println("Application creation failed: " + response.getMessage());
+                }
+            })
+            .doOnError(error -> {
+                System.err.println("Application creation error: " + error.getMessage());
+                error.printStackTrace();
+            })
+            .contextWrite(setupTestContext());
+
+        // Verify the result
+        StepVerifier.create(result)
+            .assertNext(response -> {
+                Assertions.assertTrue(response.isSuccess());
+                Assertions.assertNotNull(response.getData());
+                Assertions.assertNotNull(response.getData().getApplicationInfoView());
+                Assertions.assertNotNull(response.getData().getApplicationInfoView().getApplicationId());
+                System.out.println("Successfully created application with ID: " + response.getData().getApplicationInfoView().getApplicationId());
+            })
+            .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    public void testGetHistorySnapshotDslArchivedWithNonExistentSnapshot() {
+        // Use an existing application from test data
+        String existingAppId = "app01"; // This exists in the test data
+        String nonExistentSnapshotId = "non-existent-snapshot-id";
+        
+        // Test that trying to get a non-existent archived snapshot returns an appropriate error
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.getHistorySnapshotDslArchived(
+            existingAppId,
+            nonExistentSnapshotId
+        )
+        .contextWrite(setupTestContext());
+
+        // Verify that the endpoint handles non-existent snapshots appropriately
+        StepVerifier.create(result)
+            .expectError()
+            .verify();
+    }
+
+    // Helper method to set up Reactor context for tests
+    private reactor.util.context.Context setupTestContext() {
+        return reactor.util.context.Context.of(
+            VISITOR_TOKEN, "test-token-" + System.currentTimeMillis(),
+            "headers", new HashMap<String, String>()
+        );
+    }
+
+    // Helper methods
+    private Map<String, Object> createTestDsl() {
+        Map<String, Object> dsl = new HashMap<>();
+        Map<String, Object> components = new HashMap<>();
+        Map<String, Object> layout = new HashMap<>();
+        
+        components.put("test-component", new HashMap<>());
+        layout.put("type", "grid");
+        
+        dsl.put("components", components);
+        dsl.put("layout", layout);
+        
+        return dsl;
+    }
+
+    private Map<String, Object> createComplexTestDsl() {
+        Map<String, Object> dsl = new HashMap<>();
+        Map<String, Object> components = new HashMap<>();
+        Map<String, Object> layout = new HashMap<>();
+        
+        // Create complex component structure
+        Map<String, Object> component1 = new HashMap<>();
+        component1.put("type", "button");
+        component1.put("text", "Click me");
+        component1.put("style", Map.of("backgroundColor", "#007bff"));
+        
+        Map<String, Object> component2 = new HashMap<>();
+        component2.put("type", "input");
+        component2.put("placeholder", "Enter text");
+        component2.put("style", Map.of("border", "1px solid #ccc"));
+        
+        components.put("button-1", component1);
+        components.put("input-1", component2);
+        
+        layout.put("type", "flex");
+        layout.put("direction", "column");
+        layout.put("items", java.util.List.of("button-1", "input-1"));
+        
+        dsl.put("components", components);
+        dsl.put("layout", layout);
+        
+        return dsl;
+    }
+
+    private Map<String, Object> createTestContext() {
+        return createTestContext("test-snapshot");
+    }
+
+    private Map<String, Object> createTestContext(String snapshotName) {
+        Map<String, Object> context = new HashMap<>();
+        context.put("action", "save");
+        context.put("timestamp", Instant.now().toEpochMilli());
+        context.put("name", snapshotName);
+        context.put("description", "Test snapshot created during integration test");
+        return context;
+    }
+} 
\ No newline at end of file
diff --git a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationHistorySnapshotEndpointsTest.java b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationHistorySnapshotEndpointsTest.java
new file mode 100644
index 0000000000..7e1190e4e3
--- /dev/null
+++ b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/application/ApplicationHistorySnapshotEndpointsTest.java
@@ -0,0 +1,570 @@
+package org.lowcoder.api.application;
+
+import com.google.common.collect.ImmutableMap;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lowcoder.api.application.ApplicationHistorySnapshotEndpoints.ApplicationHistorySnapshotRequest;
+import org.lowcoder.api.application.view.HistorySnapshotDslView;
+import org.lowcoder.api.framework.view.ResponseView;
+import org.lowcoder.api.home.SessionUserService;
+import org.lowcoder.api.util.Pagination;
+import org.lowcoder.domain.application.model.Application;
+import org.lowcoder.domain.application.model.ApplicationHistorySnapshot;
+import org.lowcoder.domain.application.model.ApplicationHistorySnapshotTS;
+import org.lowcoder.domain.application.service.ApplicationHistorySnapshotService;
+import org.lowcoder.domain.application.service.ApplicationRecordService;
+import org.lowcoder.domain.application.service.ApplicationService;
+import org.lowcoder.domain.permission.model.ResourceAction;
+import org.lowcoder.domain.permission.service.ResourcePermissionService;
+import org.lowcoder.domain.user.model.User;
+import org.lowcoder.domain.user.service.UserService;
+import org.mockito.Mockito;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.when;
+
+class ApplicationHistorySnapshotEndpointsTest {
+
+    private ResourcePermissionService resourcePermissionService;
+    private ApplicationHistorySnapshotService applicationHistorySnapshotService;
+    private SessionUserService sessionUserService;
+    private UserService userService;
+    private ApplicationService applicationService;
+    private ApplicationRecordService applicationRecordService;
+    private ApplicationHistorySnapshotController controller;
+
+    private static final String TEST_APPLICATION_ID = "test-app-id";
+    private static final String TEST_SNAPSHOT_ID = "test-snapshot-id";
+    private static final String TEST_USER_ID = "test-user-id";
+    private static final String TEST_USER_NAME = "Test User";
+    private static final String TEST_USER_AVATAR = "https://example.com/avatar.jpg";
+
+    @BeforeEach
+    void setUp() {
+        // Create mocks manually
+        resourcePermissionService = Mockito.mock(ResourcePermissionService.class);
+        applicationHistorySnapshotService = Mockito.mock(ApplicationHistorySnapshotService.class);
+        sessionUserService = Mockito.mock(SessionUserService.class);
+        userService = Mockito.mock(UserService.class);
+        applicationService = Mockito.mock(ApplicationService.class);
+        applicationRecordService = Mockito.mock(ApplicationRecordService.class);
+
+        // Setup common mocks
+        when(sessionUserService.getVisitorId()).thenReturn(Mono.just(TEST_USER_ID));
+        when(resourcePermissionService.checkResourcePermissionWithError(anyString(), anyString(), any(ResourceAction.class)))
+                .thenReturn(Mono.empty());
+
+        // Create controller with all required dependencies
+        controller = new ApplicationHistorySnapshotController(
+                resourcePermissionService,
+                applicationHistorySnapshotService,
+                sessionUserService,
+                userService,
+                applicationService,
+                applicationRecordService
+        );
+    }
+
+    @Test
+    void testCreate_success() {
+        // Prepare request data
+        Map<String, Object> dsl = new HashMap<>();
+        dsl.put("components", new HashMap<>());
+        dsl.put("layout", new HashMap<>());
+
+        Map<String, Object> context = new HashMap<>();
+        context.put("action", "save");
+        context.put("timestamp", Instant.now().toEpochMilli());
+
+        ApplicationHistorySnapshotRequest request = new ApplicationHistorySnapshotRequest(
+                TEST_APPLICATION_ID,
+                dsl,
+                context
+        );
+
+        when(applicationHistorySnapshotService.createHistorySnapshot(
+                eq(TEST_APPLICATION_ID),
+                eq(dsl),
+                eq(context),
+                eq(TEST_USER_ID)
+        )).thenReturn(Mono.just(true));
+
+        when(applicationService.updateLastEditedAt(eq(TEST_APPLICATION_ID), any(Instant.class), eq(TEST_USER_ID)))
+                .thenReturn(Mono.just(true));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.create(request);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData() == true;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreate_withEmptyDsl() {
+        // Prepare request data with empty DSL
+        ApplicationHistorySnapshotRequest request = new ApplicationHistorySnapshotRequest(
+                TEST_APPLICATION_ID,
+                new HashMap<>(),
+                new HashMap<>()
+        );
+
+        when(applicationHistorySnapshotService.createHistorySnapshot(
+                eq(TEST_APPLICATION_ID),
+                any(Map.class),
+                any(Map.class),
+                eq(TEST_USER_ID)
+        )).thenReturn(Mono.just(true));
+
+        when(applicationService.updateLastEditedAt(eq(TEST_APPLICATION_ID), any(Instant.class), eq(TEST_USER_ID)))
+                .thenReturn(Mono.just(true));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.create(request);
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreate_serviceError() {
+        // Prepare request data
+        ApplicationHistorySnapshotRequest request = new ApplicationHistorySnapshotRequest(
+                TEST_APPLICATION_ID,
+                new HashMap<>(),
+                new HashMap<>()
+        );
+
+        when(applicationHistorySnapshotService.createHistorySnapshot(
+                anyString(),
+                any(Map.class),
+                any(Map.class),
+                anyString()
+        )).thenReturn(Mono.error(new RuntimeException("Service error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.create(request);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testListAllHistorySnapshotBriefInfo_success() {
+        // Prepare test data
+        ApplicationHistorySnapshot snapshot1 = createMockApplicationHistorySnapshot("snapshot-1", "user1");
+        ApplicationHistorySnapshot snapshot2 = createMockApplicationHistorySnapshot("snapshot-2", "user2");
+        List<ApplicationHistorySnapshot> snapshotList = List.of(snapshot1, snapshot2);
+
+        User user1 = createMockUser("user1", "User One", "avatar1.jpg");
+        User user2 = createMockUser("user2", "User Two", "avatar2.jpg");
+
+        when(applicationHistorySnapshotService.listAllHistorySnapshotBriefInfo(
+                eq(TEST_APPLICATION_ID),
+                anyString(),
+                anyString(),
+                any(Instant.class),
+                any(Instant.class),
+                any()
+        )).thenReturn(Mono.just(snapshotList));
+
+        when(userService.getByIds(anyList())).thenReturn(Mono.just(Map.of("user1", user1, "user2", user2)));
+        when(applicationHistorySnapshotService.countByApplicationId(eq(TEST_APPLICATION_ID)))
+                .thenReturn(Mono.just(2L));
+
+        // Test the controller method directly
+        Mono<ResponseView<Map<String, Object>>> result = controller.listAllHistorySnapshotBriefInfo(
+                TEST_APPLICATION_ID,
+                1,
+                10,
+                "test-component",
+                "dark",
+                Instant.now().minusSeconds(3600),
+                Instant.now()
+        );
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().containsKey("list");
+                    assert response.getData().containsKey("count");
+                    assert (Long) response.getData().get("count") == 2L;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testListAllHistorySnapshotBriefInfo_withNullFilters() {
+        // Prepare test data
+        List<ApplicationHistorySnapshot> snapshotList = List.of();
+        User user = createMockUser("user1", "User One", "avatar1.jpg");
+
+        when(applicationHistorySnapshotService.listAllHistorySnapshotBriefInfo(
+                eq(TEST_APPLICATION_ID),
+                isNull(),
+                isNull(),
+                isNull(),
+                isNull(),
+                any()
+        )).thenReturn(Mono.just(snapshotList));
+
+        when(userService.getByIds(anyList())).thenReturn(Mono.just(Map.of()));
+        when(applicationHistorySnapshotService.countByApplicationId(eq(TEST_APPLICATION_ID)))
+                .thenReturn(Mono.just(0L));
+
+        // Test the controller method directly
+        Mono<ResponseView<Map<String, Object>>> result = controller.listAllHistorySnapshotBriefInfo(
+                TEST_APPLICATION_ID,
+                1,
+                10,
+                null,
+                null,
+                null,
+                null
+        );
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().containsKey("list");
+                    assert response.getData().containsKey("count");
+                    assert (Long) response.getData().get("count") == 0L;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testListAllHistorySnapshotBriefInfo_serviceError() {
+        when(applicationHistorySnapshotService.listAllHistorySnapshotBriefInfo(
+                anyString(),
+                anyString(),
+                anyString(),
+                any(Instant.class),
+                any(Instant.class),
+                any()
+        )).thenReturn(Mono.error(new RuntimeException("Service error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Map<String, Object>>> result = controller.listAllHistorySnapshotBriefInfo(
+                TEST_APPLICATION_ID,
+                1,
+                10,
+                "test-component",
+                "dark",
+                Instant.now().minusSeconds(3600),
+                Instant.now()
+        );
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testListAllHistorySnapshotBriefInfoArchived_success() {
+        // Prepare test data
+        ApplicationHistorySnapshotTS snapshot1 = createMockApplicationHistorySnapshotTS("snapshot-1", "user1");
+        ApplicationHistorySnapshotTS snapshot2 = createMockApplicationHistorySnapshotTS("snapshot-2", "user2");
+        List<ApplicationHistorySnapshotTS> snapshotList = List.of(snapshot1, snapshot2);
+
+        User user1 = createMockUser("user1", "User One", "avatar1.jpg");
+        User user2 = createMockUser("user2", "User Two", "avatar2.jpg");
+
+        when(applicationHistorySnapshotService.listAllHistorySnapshotBriefInfoArchived(
+                eq(TEST_APPLICATION_ID),
+                anyString(),
+                anyString(),
+                any(Instant.class),
+                any(Instant.class),
+                any()
+        )).thenReturn(Mono.just(snapshotList));
+
+        when(userService.getByIds(anyList())).thenReturn(Mono.just(Map.of("user1", user1, "user2", user2)));
+        when(applicationHistorySnapshotService.countByApplicationIdArchived(eq(TEST_APPLICATION_ID)))
+                .thenReturn(Mono.just(2L));
+
+        // Test the controller method directly
+        Mono<ResponseView<Map<String, Object>>> result = controller.listAllHistorySnapshotBriefInfoArchived(
+                TEST_APPLICATION_ID,
+                1,
+                10,
+                "test-component",
+                "dark",
+                Instant.now().minusSeconds(3600),
+                Instant.now()
+        );
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().containsKey("list");
+                    assert response.getData().containsKey("count");
+                    assert (Long) response.getData().get("count") == 2L;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testListAllHistorySnapshotBriefInfoArchived_serviceError() {
+        when(applicationHistorySnapshotService.listAllHistorySnapshotBriefInfoArchived(
+                anyString(),
+                anyString(),
+                anyString(),
+                any(Instant.class),
+                any(Instant.class),
+                any()
+        )).thenReturn(Mono.error(new RuntimeException("Service error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Map<String, Object>>> result = controller.listAllHistorySnapshotBriefInfoArchived(
+                TEST_APPLICATION_ID,
+                1,
+                10,
+                "test-component",
+                "dark",
+                Instant.now().minusSeconds(3600),
+                Instant.now()
+        );
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetHistorySnapshotDsl_success() {
+        // Prepare test data
+        ApplicationHistorySnapshot snapshot = createMockApplicationHistorySnapshot(TEST_SNAPSHOT_ID, TEST_USER_ID);
+        Map<String, Object> dsl = new HashMap<>();
+        dsl.put("components", new HashMap<>());
+        dsl.put("layout", new HashMap<>());
+
+        List<Application> dependentModules = List.of();
+
+        when(applicationHistorySnapshotService.getHistorySnapshotDetail(eq(TEST_SNAPSHOT_ID)))
+                .thenReturn(Mono.just(snapshot));
+        when(applicationService.getAllDependentModulesFromDsl(any(Map.class)))
+                .thenReturn(Mono.just(dependentModules));
+
+        // Test the controller method directly
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.getHistorySnapshotDsl(
+                TEST_APPLICATION_ID,
+                TEST_SNAPSHOT_ID
+        );
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationsDsl() != null;
+                    assert response.getData().getModuleDSL() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetHistorySnapshotDsl_withDependentModules() {
+        // Prepare test data
+        ApplicationHistorySnapshot snapshot = createMockApplicationHistorySnapshot(TEST_SNAPSHOT_ID, TEST_USER_ID);
+        Map<String, Object> dsl = new HashMap<>();
+        dsl.put("components", new HashMap<>());
+        dsl.put("layout", new HashMap<>());
+
+        Application dependentApp = createMockApplication("dependent-app-id");
+        List<Application> dependentModules = List.of(dependentApp);
+
+        when(applicationHistorySnapshotService.getHistorySnapshotDetail(eq(TEST_SNAPSHOT_ID)))
+                .thenReturn(Mono.just(snapshot));
+        when(applicationService.getAllDependentModulesFromDsl(any(Map.class)))
+                .thenReturn(Mono.just(dependentModules));
+        when(dependentApp.getLiveApplicationDsl(applicationRecordService))
+                .thenReturn(Mono.just(new HashMap<>()));
+
+        // Test the controller method directly
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.getHistorySnapshotDsl(
+                TEST_APPLICATION_ID,
+                TEST_SNAPSHOT_ID
+        );
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationsDsl() != null;
+                    assert response.getData().getModuleDSL() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetHistorySnapshotDsl_serviceError() {
+        when(applicationHistorySnapshotService.getHistorySnapshotDetail(eq(TEST_SNAPSHOT_ID)))
+                .thenReturn(Mono.error(new RuntimeException("Service error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.getHistorySnapshotDsl(
+                TEST_APPLICATION_ID,
+                TEST_SNAPSHOT_ID
+        );
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testGetHistorySnapshotDslArchived_success() {
+        // Prepare test data
+        ApplicationHistorySnapshotTS snapshot = createMockApplicationHistorySnapshotTS(TEST_SNAPSHOT_ID, TEST_USER_ID);
+        Map<String, Object> dsl = new HashMap<>();
+        dsl.put("components", new HashMap<>());
+        dsl.put("layout", new HashMap<>());
+
+        List<Application> dependentModules = List.of();
+
+        when(applicationHistorySnapshotService.getHistorySnapshotDetailArchived(eq(TEST_SNAPSHOT_ID)))
+                .thenReturn(Mono.just(snapshot));
+        when(applicationService.getAllDependentModulesFromDsl(any(Map.class)))
+                .thenReturn(Mono.just(dependentModules));
+
+        // Test the controller method directly
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.getHistorySnapshotDslArchived(
+                TEST_APPLICATION_ID,
+                TEST_SNAPSHOT_ID
+        );
+
+        // Verify the result
+        StepVerifier.create(result)
+                .expectNextMatches(response -> {
+                    assert response != null;
+                    assert response.isSuccess();
+                    assert response.getData() != null;
+                    assert response.getData().getApplicationsDsl() != null;
+                    assert response.getData().getModuleDSL() != null;
+                    return true;
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testGetHistorySnapshotDslArchived_serviceError() {
+        when(applicationHistorySnapshotService.getHistorySnapshotDetailArchived(eq(TEST_SNAPSHOT_ID)))
+                .thenReturn(Mono.error(new RuntimeException("Service error")));
+
+        // Test the controller method directly
+        Mono<ResponseView<HistorySnapshotDslView>> result = controller.getHistorySnapshotDslArchived(
+                TEST_APPLICATION_ID,
+                TEST_SNAPSHOT_ID
+        );
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    @Test
+    void testPermissionCheck_failure() {
+        // Prepare request data
+        ApplicationHistorySnapshotRequest request = new ApplicationHistorySnapshotRequest(
+                TEST_APPLICATION_ID,
+                new HashMap<>(),
+                new HashMap<>()
+        );
+
+        when(resourcePermissionService.checkResourcePermissionWithError(
+                eq(TEST_USER_ID),
+                eq(TEST_APPLICATION_ID),
+                eq(ResourceAction.EDIT_APPLICATIONS)
+        )).thenReturn(Mono.error(new RuntimeException("Permission denied")));
+
+        // Test the controller method directly
+        Mono<ResponseView<Boolean>> result = controller.create(request);
+
+        // Verify the error is propagated
+        StepVerifier.create(result)
+                .expectError(RuntimeException.class)
+                .verify();
+    }
+
+    // Helper methods to create mock objects
+    private ApplicationHistorySnapshot createMockApplicationHistorySnapshot(String snapshotId, String userId) {
+        ApplicationHistorySnapshot snapshot = Mockito.mock(ApplicationHistorySnapshot.class);
+        when(snapshot.getId()).thenReturn(snapshotId);
+        when(snapshot.getApplicationId()).thenReturn(TEST_APPLICATION_ID);
+        when(snapshot.getCreatedBy()).thenReturn(userId);
+        when(snapshot.getCreatedAt()).thenReturn(Instant.now());
+        when(snapshot.getDsl()).thenReturn(new HashMap<>());
+        when(snapshot.getContext()).thenReturn(new HashMap<>());
+        return snapshot;
+    }
+
+    private ApplicationHistorySnapshotTS createMockApplicationHistorySnapshotTS(String snapshotId, String userId) {
+        ApplicationHistorySnapshotTS snapshot = Mockito.mock(ApplicationHistorySnapshotTS.class);
+        when(snapshot.getId()).thenReturn(snapshotId);
+        when(snapshot.getApplicationId()).thenReturn(TEST_APPLICATION_ID);
+        when(snapshot.getCreatedBy()).thenReturn(userId);
+        when(snapshot.getCreatedAt()).thenReturn(Instant.now());
+        when(snapshot.getDsl()).thenReturn(new HashMap<>());
+        when(snapshot.getContext()).thenReturn(new HashMap<>());
+        return snapshot;
+    }
+
+    private User createMockUser(String userId, String userName, String avatarUrl) {
+        User user = Mockito.mock(User.class);
+        when(user.getId()).thenReturn(userId);
+        when(user.getName()).thenReturn(userName);
+        when(user.getAvatarUrl()).thenReturn(avatarUrl);
+        return user;
+    }
+
+    private Application createMockApplication(String appId) {
+        Application app = Mockito.mock(Application.class);
+        when(app.getId()).thenReturn(appId);
+        return app;
+    }
+} 
\ No newline at end of file
diff --git a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/authentication/AuthenticationEndpointsIntegrationTest.java b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/authentication/AuthenticationEndpointsIntegrationTest.java
new file mode 100644
index 0000000000..3c103dd74e
--- /dev/null
+++ b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/authentication/AuthenticationEndpointsIntegrationTest.java
@@ -0,0 +1,647 @@
+package org.lowcoder.api.authentication;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+import org.lowcoder.api.authentication.dto.APIKeyRequest;
+import org.lowcoder.api.authentication.dto.AuthConfigRequest;
+import org.lowcoder.api.common.InitData;
+import org.lowcoder.api.common.mockuser.WithMockUser;
+import org.lowcoder.api.framework.view.ResponseView;
+import org.lowcoder.api.usermanagement.view.APIKeyVO;
+import org.lowcoder.domain.authentication.AuthenticationService;
+import org.lowcoder.domain.authentication.FindAuthConfig;
+import org.lowcoder.domain.user.model.APIKey;
+import org.lowcoder.domain.user.repository.UserRepository;
+import org.lowcoder.sdk.auth.AbstractAuthConfig;
+import org.lowcoder.sdk.auth.EmailAuthConfig;
+import org.lowcoder.sdk.constants.AuthSourceConstants;
+import org.lowcoder.sdk.exception.BizException;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.dao.DuplicateKeyException;
+import org.springframework.http.ResponseCookie;
+import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
+import org.springframework.mock.web.server.MockServerWebExchange;
+import org.springframework.test.context.ActiveProfiles;
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.lowcoder.sdk.exception.BizError.INVALID_PASSWORD;
+import org.lowcoder.domain.user.model.Connection;
+
+@SpringBootTest
+@ActiveProfiles("test")
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class AuthenticationEndpointsIntegrationTest {
+
+    @Autowired
+    private AuthenticationController authenticationController;
+    
+    @Autowired
+    private UserRepository userRepository;
+    
+    @Autowired
+    private AuthenticationService authenticationService;
+    
+    @Autowired
+    private InitData initData;
+
+    private ServerWebExchange mockExchange;
+
+    @BeforeEach
+    void setUp() {
+        try {
+            initData.init();
+        } catch (RuntimeException e) {
+            // Handle duplicate key errors gracefully - this happens when test data already exists
+            if (e.getCause() instanceof DuplicateKeyException) {
+                // Data already exists, continue with test
+                System.out.println("Test data already exists, continuing with test...");
+            } else {
+                // Re-throw other exceptions
+                throw e;
+            }
+        }
+        MockServerHttpRequest request = MockServerHttpRequest.post("").build();
+        mockExchange = MockServerWebExchange.builder(request).build();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLogin_Integration_Success() {
+        // Arrange
+        String email = "integration_test@example.com";
+        String password = "testPassword123";
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                email, password, true, source, authId
+        );
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.formLogin(
+                formLoginRequest, null, null, mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+
+        // Verify user was created in database
+        StepVerifier.create(userRepository.findByConnections_SourceAndConnections_RawId(source, email))
+                .assertNext(user -> {
+                    assertNotNull(user);
+                    // Since connections is a Set, we need to find the connection by source
+                    // Fixed: Changed from get(0) to stream().filter().findFirst() approach
+                    Connection connection = user.getConnections().stream()
+                            .filter(conn -> source.equals(conn.getSource()))
+                            .findFirst()
+                            .orElse(null);
+                    assertNotNull(connection);
+                    assertEquals(email, connection.getRawId());
+                    assertEquals(source, connection.getSource());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLogin_Integration_LoginExistingUser() {
+        // Arrange - First register a user
+        String email = "existing_user@example.com";
+        String password = "testPassword123";
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+
+        AuthenticationEndpoints.FormLoginRequest registerRequest = new AuthenticationEndpoints.FormLoginRequest(
+                email, password, true, source, authId
+        );
+
+        // Register the user first
+        authenticationController.formLogin(registerRequest, null, null, mockExchange).block();
+
+        // Now try to login with the same credentials
+        AuthenticationEndpoints.FormLoginRequest loginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                email, password, false, source, authId
+        );
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.formLogin(
+                loginRequest, null, null, mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLogin_Integration_InvalidCredentials() {
+        // Arrange
+        String email = "nonexistent@example.com";
+        String password = "wrongPassword";
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                email, password, false, source, authId
+        );
+
+        // Act & Assert
+        StepVerifier.create(authenticationController.formLogin(formLoginRequest, null, null, mockExchange))
+                .verifyErrorMatches(throwable -> {
+                    assertTrue(throwable instanceof BizException);
+                    BizException bizException = (BizException) throwable;
+                    assertEquals(INVALID_PASSWORD, bizException.getError());
+                    return true;
+                });
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testLogout_Integration_Success() {
+        // Arrange - Set up a mock session token
+        MockServerHttpRequest request = MockServerHttpRequest.post("")
+                .cookie(ResponseCookie.from("token", "test-session-token").build())
+                .build();
+        ServerWebExchange exchangeWithCookie = MockServerWebExchange.builder(request).build();
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.logout(exchangeWithCookie);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testEnableAuthConfig_Integration_Success() {
+        // Arrange
+        AuthConfigRequest authConfigRequest = new AuthConfigRequest();
+        authConfigRequest.put("authType", "FORM");
+        authConfigRequest.put("source", "test-email");
+        authConfigRequest.put("sourceName", "Test Email Auth");
+        authConfigRequest.put("enableRegister", true);
+
+        // Act
+        Mono<ResponseView<Void>> result = authenticationController.enableAuthConfig(authConfigRequest);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNull(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testGetAllConfigs_Integration_Success() {
+        // Act
+        Mono<ResponseView<List<AbstractAuthConfig>>> result = authenticationController.getAllConfigs();
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNotNull(response.getData());
+                    // Should have at least the default email config
+                    assertTrue(response.getData().size() >= 1);
+                    
+                    // Verify at least one config is an EmailAuthConfig
+                    boolean hasEmailConfig = response.getData().stream()
+                            .anyMatch(config -> config instanceof EmailAuthConfig);
+                    assertTrue(hasEmailConfig);
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testCreateAPIKey_Integration_Success() {
+        // Arrange
+        APIKeyRequest apiKeyRequest = new APIKeyRequest();
+        apiKeyRequest.put("name", "Integration Test API Key");
+        apiKeyRequest.put("description", "API Key created during integration test");
+
+        // Act
+        Mono<ResponseView<APIKeyVO>> result = authenticationController.createAPIKey(apiKeyRequest);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNotNull(response.getData());
+                    assertNotNull(response.getData().getId());
+                    assertNotNull(response.getData().getToken());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testGetAllAPIKeys_Integration_Success() {
+        // Arrange - Create an API key first
+        APIKeyRequest apiKeyRequest = new APIKeyRequest();
+        apiKeyRequest.put("name", "Test API Key for List");
+        apiKeyRequest.put("description", "Test Description");
+        
+        authenticationController.createAPIKey(apiKeyRequest).block();
+
+        // Act
+        Mono<ResponseView<List<APIKey>>> result = authenticationController.getAllAPIKeys();
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNotNull(response.getData());
+                    assertTrue(response.getData().size() >= 1);
+                    
+                    // Verify the created API key is in the list
+                    boolean foundCreatedKey = response.getData().stream()
+                            .anyMatch(key -> "Test API Key for List".equals(key.getName()));
+                    assertTrue(foundCreatedKey);
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testDeleteAPIKey_Integration_Success() {
+        // Arrange - Create an API key first
+        APIKeyRequest apiKeyRequest = new APIKeyRequest();
+        apiKeyRequest.put("name", "API Key to Delete");
+        apiKeyRequest.put("description", "This key will be deleted");
+        
+        APIKeyVO createdKey = authenticationController.createAPIKey(apiKeyRequest).block().getData();
+
+        // Act
+        Mono<ResponseView<Void>> result = authenticationController.deleteAPIKey(createdKey.getId());
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNull(response.getData());
+                })
+                .verifyComplete();
+
+        // Verify the key was actually deleted
+        StepVerifier.create(authenticationController.getAllAPIKeys())
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    boolean keyStillExists = response.getData().stream()
+                            .anyMatch(key -> createdKey.getId().equals(key.getId()));
+                    assertFalse(keyStillExists);
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testBindEmail_Integration_Success() {
+        // Arrange
+        String emailToBind = "bound_email@example.com";
+
+        // Act
+        Mono<ResponseView<?>> result = authenticationController.bindEmail(emailToBind);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNotNull(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLogin_Integration_WithInvitationId() {
+        // Arrange - Test registration without invitation ID (invitation ID is optional)
+        String email = "invited_user@example.com";
+        String password = "testPassword123";
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+        String invitationId = null; // No invitation ID - should work fine
+
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                email, password, true, source, authId
+        );
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.formLogin(
+                formLoginRequest, invitationId, null, mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLogin_Integration_WithOrgId() {
+        // Arrange
+        String email = "org_user@example.com";
+        String password = "testPassword123";
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+        String orgId = null; // Use null to get default EMAIL auth config
+
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                email, password, true, source, authId
+        );
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.formLogin(
+                formLoginRequest, null, orgId, mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testDisableAuthConfig_Integration_Success() {
+        // Arrange - First enable an auth config
+        AuthConfigRequest authConfigRequest = new AuthConfigRequest();
+        authConfigRequest.put("authType", "FORM");
+        authConfigRequest.put("source", "disable-test");
+        authConfigRequest.put("sourceName", "Test Auth to Disable");
+        authConfigRequest.put("enableRegister", true);
+
+        authenticationController.enableAuthConfig(authConfigRequest).block();
+
+        // Get the config ID (this is a simplified approach - in real scenario you'd get it from the response)
+        String configId = "disable-test"; // Simplified for test
+
+        // Act
+        Mono<ResponseView<Void>> result = authenticationController.disableAuthConfig(configId, false);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNull(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testLoginWithThirdParty_Integration_Success() {
+        // Arrange - Use the existing Google OAuth config from test data
+        String authId = "106e4f4a4f6a48e5aa23cca6757c29e4"; // Google OAuth config ID from organization.json
+        String source = "GOOGLE";
+        String code = "mock-oauth-code";
+        String redirectUrl = "http://localhost:8080/auth/callback";
+        String orgId = "org01";
+
+        // Act & Assert - Expect network error since auth.google.com doesn't exist
+        StepVerifier.create(authenticationController.loginWithThirdParty(
+                authId, source, code, null, redirectUrl, orgId, mockExchange
+        ))
+                .verifyErrorMatches(throwable -> {
+                    assertTrue(throwable instanceof BizException);
+                    BizException bizException = (BizException) throwable;
+                    // Should fail due to network error when trying to reach auth.google.com
+                    assertTrue(bizException.getMessage().contains("Failed to get OIDC information") ||
+                              bizException.getMessage().contains("Failed to resolve"));
+                    return true;
+                });
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testLoginWithThirdParty_Integration_WithInvitationId() {
+        // Arrange - Test with invitation ID
+        String authId = "106e4f4a4f6a48e5aa23cca6757c29e4";
+        String source = "GOOGLE";
+        String code = "mock-oauth-code";
+        String redirectUrl = "http://localhost:8080/auth/callback";
+        String orgId = "org01";
+        String invitationId = "test-invitation-id";
+
+        // Act & Assert - Expect network error since auth.google.com doesn't exist
+        StepVerifier.create(authenticationController.loginWithThirdParty(
+                authId, source, code, invitationId, redirectUrl, orgId, mockExchange
+        ))
+                .verifyErrorMatches(throwable -> {
+                    assertTrue(throwable instanceof BizException);
+                    BizException bizException = (BizException) throwable;
+                    // Should fail due to network error when trying to reach auth.google.com
+                    assertTrue(bizException.getMessage().contains("Failed to get OIDC information") ||
+                              bizException.getMessage().contains("Failed to resolve"));
+                    return true;
+                });
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testLinkAccountWithThirdParty_Integration_Success() {
+        // Arrange - Use the existing Google OAuth config from test data
+        String authId = "106e4f4a4f6a48e5aa23cca6757c29e4"; // Google OAuth config ID from organization.json
+        String source = "GOOGLE";
+        String code = "mock-oauth-code";
+        String redirectUrl = "http://localhost:8080/auth/callback";
+        String orgId = "org01";
+
+        // Act & Assert - Expect network error since auth.google.com doesn't exist
+        StepVerifier.create(authenticationController.linkAccountWithThirdParty(
+                authId, source, code, redirectUrl, orgId, mockExchange
+        ))
+                .verifyErrorMatches(throwable -> {
+                    assertTrue(throwable instanceof BizException);
+                    BizException bizException = (BizException) throwable;
+                    // Should fail due to network error when trying to reach auth.google.com
+                    assertTrue(bizException.getMessage().contains("Failed to get OIDC information") ||
+                              bizException.getMessage().contains("Failed to resolve"));
+                    return true;
+                });
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testLoginWithThirdParty_Integration_InvalidAuthConfig() {
+        // Arrange - Test with non-existent auth config
+        String authId = "non-existent-auth-id";
+        String source = "GOOGLE";
+        String code = "mock-oauth-code";
+        String redirectUrl = "http://localhost:8080/auth/callback";
+        String orgId = "org01";
+
+        // Act & Assert
+        StepVerifier.create(authenticationController.loginWithThirdParty(
+                authId, source, code, null, redirectUrl, orgId, mockExchange
+        ))
+                .verifyErrorMatches(throwable -> {
+                    assertTrue(throwable instanceof BizException);
+                    // Should fail due to invalid auth config
+                    return true;
+                });
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testLinkAccountWithThirdParty_Integration_InvalidAuthConfig() {
+        // Arrange - Test with non-existent auth config
+        String authId = "non-existent-auth-id";
+        String source = "GOOGLE";
+        String code = "mock-oauth-code";
+        String redirectUrl = "http://localhost:8080/auth/callback";
+        String orgId = "org01";
+
+        // Act & Assert
+        StepVerifier.create(authenticationController.linkAccountWithThirdParty(
+                authId, source, code, redirectUrl, orgId, mockExchange
+        ))
+                .verifyErrorMatches(throwable -> {
+                    assertTrue(throwable instanceof BizException);
+                    // Should fail due to invalid auth config
+                    return true;
+                });
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLoginRequest_Record_Integration() {
+        // Arrange - Test FormLoginRequest record creation and validation
+        String loginId = "test@example.com";
+        String password = "testPassword123";
+        boolean register = true;
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+
+        // Act - Create FormLoginRequest record
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, register, source, authId
+        );
+
+        // Assert - Verify record properties
+        assertEquals(loginId, formLoginRequest.loginId());
+        assertEquals(password, formLoginRequest.password());
+        assertEquals(register, formLoginRequest.register());
+        assertEquals(source, formLoginRequest.source());
+        assertEquals(authId, formLoginRequest.authId());
+
+        // Test record immutability and equality
+        AuthenticationEndpoints.FormLoginRequest sameRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, register, source, authId
+        );
+        assertEquals(formLoginRequest, sameRequest);
+        assertEquals(formLoginRequest.hashCode(), sameRequest.hashCode());
+
+        // Test different request
+        AuthenticationEndpoints.FormLoginRequest differentRequest = new AuthenticationEndpoints.FormLoginRequest(
+                "different@example.com", password, register, source, authId
+        );
+        assertNotEquals(formLoginRequest, differentRequest);
+
+        // Test toString method
+        String toString = formLoginRequest.toString();
+        assertTrue(toString.contains(loginId));
+        assertTrue(toString.contains(source));
+        assertTrue(toString.contains(String.valueOf(register)));
+
+        // Test with null values (should work for optional fields)
+        AuthenticationEndpoints.FormLoginRequest nullAuthIdRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, register, source, null
+        );
+        assertNull(nullAuthIdRequest.authId());
+        assertEquals(loginId, nullAuthIdRequest.loginId());
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLoginRequest_Record_WithDifferentSources() {
+        // Arrange - Test FormLoginRequest with different auth sources
+        String loginId = "test@example.com";
+        String password = "testPassword123";
+        boolean register = false;
+        String authId = getEmailAuthConfigId();
+
+        // Test with EMAIL source
+        AuthenticationEndpoints.FormLoginRequest emailRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, register, AuthSourceConstants.EMAIL, authId
+        );
+        assertEquals(AuthSourceConstants.EMAIL, emailRequest.source());
+
+        // Test with PHONE source
+        AuthenticationEndpoints.FormLoginRequest phoneRequest = new AuthenticationEndpoints.FormLoginRequest(
+                "1234567890", password, register, AuthSourceConstants.PHONE, authId
+        );
+        assertEquals(AuthSourceConstants.PHONE, phoneRequest.source());
+        assertEquals("1234567890", phoneRequest.loginId());
+
+        // Test with GOOGLE source
+        AuthenticationEndpoints.FormLoginRequest googleRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, register, "GOOGLE", authId
+        );
+        assertEquals("GOOGLE", googleRequest.source());
+    }
+
+    @Test
+    @WithMockUser(id = "user01")
+    void testFormLoginRequest_Record_WithDifferentRegisterModes() {
+        // Arrange - Test FormLoginRequest with different register modes
+        String loginId = "test@example.com";
+        String password = "testPassword123";
+        String source = AuthSourceConstants.EMAIL;
+        String authId = getEmailAuthConfigId();
+
+        // Test register mode (true)
+        AuthenticationEndpoints.FormLoginRequest registerRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, true, source, authId
+        );
+        assertTrue(registerRequest.register());
+
+        // Test login mode (false)
+        AuthenticationEndpoints.FormLoginRequest loginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                loginId, password, false, source, authId
+        );
+        assertFalse(loginRequest.register());
+
+        // Verify they are different
+        assertNotEquals(registerRequest, loginRequest);
+    }
+
+    private String getEmailAuthConfigId() {
+        return authenticationService.findAuthConfigBySource(null, AuthSourceConstants.EMAIL)
+                .map(FindAuthConfig::authConfig)
+                .map(AbstractAuthConfig::getId)
+                .block();
+    }
+} 
\ No newline at end of file
diff --git a/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/authentication/AuthenticationEndpointsUnitTest.java b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/authentication/AuthenticationEndpointsUnitTest.java
new file mode 100644
index 0000000000..b744836840
--- /dev/null
+++ b/server/api-service/lowcoder-server/src/test/java/org/lowcoder/api/authentication/AuthenticationEndpointsUnitTest.java
@@ -0,0 +1,384 @@
+package org.lowcoder.api.authentication;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.lowcoder.api.authentication.dto.APIKeyRequest;
+import org.lowcoder.api.authentication.dto.AuthConfigRequest;
+import org.lowcoder.api.authentication.service.AuthenticationApiService;
+import org.lowcoder.api.framework.view.ResponseView;
+import org.lowcoder.api.home.SessionUserService;
+import org.lowcoder.api.usermanagement.view.APIKeyVO;
+import org.lowcoder.api.util.BusinessEventPublisher;
+import org.lowcoder.domain.user.model.APIKey;
+import org.lowcoder.domain.user.model.AuthUser;
+import org.lowcoder.domain.user.model.User;
+import org.lowcoder.domain.user.service.UserService;
+import org.lowcoder.sdk.auth.AbstractAuthConfig;
+import org.lowcoder.sdk.auth.EmailAuthConfig;
+import org.lowcoder.sdk.util.CookieHelper;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+import org.springframework.mock.http.server.reactive.MockServerHttpRequest;
+import org.springframework.mock.web.server.MockServerWebExchange;
+import org.springframework.web.server.ServerWebExchange;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+@ExtendWith(MockitoExtension.class)
+class AuthenticationEndpointsUnitTest {
+
+    @Mock
+    private AuthenticationApiService authenticationApiService;
+    
+    @Mock
+    private SessionUserService sessionUserService;
+    
+    @Mock
+    private CookieHelper cookieHelper;
+    
+    @Mock
+    private BusinessEventPublisher businessEventPublisher;
+    
+    @Mock
+    private UserService userService;
+
+    private AuthenticationController authenticationController;
+    private ServerWebExchange mockExchange;
+
+    @BeforeEach
+    void setUp() {
+        authenticationController = new AuthenticationController(
+                authenticationApiService,
+                sessionUserService,
+                cookieHelper,
+                businessEventPublisher,
+                userService
+        );
+        
+        MockServerHttpRequest request = MockServerHttpRequest.post("").build();
+        mockExchange = MockServerWebExchange.builder(request).build();
+    }
+
+    @Test
+    void testFormLogin_Success() {
+        // Arrange
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                "test@example.com", "password", false, "email", "authId"
+        );
+        AuthUser mockAuthUser = mock(AuthUser.class);
+        
+        when(authenticationApiService.authenticateByForm(
+                eq("test@example.com"), eq("password"), eq("email"), 
+                eq(false), eq("authId"), eq("orgId")
+        )).thenReturn(Mono.just(mockAuthUser));
+        
+        when(authenticationApiService.loginOrRegister(
+                eq(mockAuthUser), eq(mockExchange), eq("invitationId"), eq(false)
+        )).thenReturn(Mono.empty());
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.formLogin(
+                formLoginRequest, "invitationId", "orgId", mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+        
+        verify(authenticationApiService).authenticateByForm(
+                "test@example.com", "password", "email", false, "authId", "orgId"
+        );
+        verify(authenticationApiService).loginOrRegister(mockAuthUser, mockExchange, "invitationId", false);
+    }
+
+    @Test
+    void testFormLogin_RegisterMode() {
+        // Arrange
+        AuthenticationEndpoints.FormLoginRequest formLoginRequest = new AuthenticationEndpoints.FormLoginRequest(
+                "new@example.com", "password", true, "email", "authId"
+        );
+        AuthUser mockAuthUser = mock(AuthUser.class);
+        
+        when(authenticationApiService.authenticateByForm(
+                eq("new@example.com"), eq("password"), eq("email"), 
+                eq(true), eq("authId"), isNull()
+        )).thenReturn(Mono.just(mockAuthUser));
+        
+        when(authenticationApiService.loginOrRegister(
+                eq(mockAuthUser), eq(mockExchange), isNull(), eq(false)
+        )).thenReturn(Mono.empty());
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.formLogin(
+                formLoginRequest, null, null, mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testLoginWithThirdParty_Success() {
+        // Arrange
+        AuthUser mockAuthUser = mock(AuthUser.class);
+        
+        when(authenticationApiService.authenticateByOauth2(
+                eq("authId"), eq("google"), eq("code"), eq("redirectUrl"), eq("orgId")
+        )).thenReturn(Mono.just(mockAuthUser));
+        
+        when(authenticationApiService.loginOrRegister(
+                eq(mockAuthUser), eq(mockExchange), eq("invitationId"), eq(false)
+        )).thenReturn(Mono.empty());
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.loginWithThirdParty(
+                "authId", "google", "code", "invitationId", "redirectUrl", "orgId", mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testLinkAccountWithThirdParty_Success() {
+        // Arrange
+        AuthUser mockAuthUser = mock(AuthUser.class);
+        
+        when(authenticationApiService.authenticateByOauth2(
+                eq("authId"), eq("github"), eq("code"), eq("redirectUrl"), eq("orgId")
+        )).thenReturn(Mono.just(mockAuthUser));
+        
+        when(authenticationApiService.loginOrRegister(
+                eq(mockAuthUser), eq(mockExchange), isNull(), eq(true)
+        )).thenReturn(Mono.empty());
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.linkAccountWithThirdParty(
+                "authId", "github", "code", "redirectUrl", "orgId", mockExchange
+        );
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testLogout_Success() {
+        // Arrange
+        when(cookieHelper.getCookieToken(mockExchange)).thenReturn("sessionToken");
+        when(sessionUserService.removeUserSession("sessionToken")).thenReturn(Mono.empty());
+        when(businessEventPublisher.publishUserLogoutEvent()).thenReturn(Mono.empty());
+
+        // Act
+        Mono<ResponseView<Boolean>> result = authenticationController.logout(mockExchange);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertTrue(response.getData());
+                })
+                .verifyComplete();
+        
+        verify(cookieHelper).getCookieToken(mockExchange);
+        verify(sessionUserService).removeUserSession("sessionToken");
+        verify(businessEventPublisher).publishUserLogoutEvent();
+    }
+
+    @Test
+    void testEnableAuthConfig_Success() {
+        // Arrange
+        AuthConfigRequest authConfigRequest = new AuthConfigRequest();
+        authConfigRequest.put("authType", "FORM");
+        authConfigRequest.put("source", "email");
+        
+        when(authenticationApiService.enableAuthConfig(authConfigRequest)).thenReturn(Mono.just(true));
+
+        // Act
+        Mono<ResponseView<Void>> result = authenticationController.enableAuthConfig(authConfigRequest);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNull(response.getData());
+                })
+                .verifyComplete();
+        
+        verify(authenticationApiService).enableAuthConfig(authConfigRequest);
+    }
+
+    @Test
+    void testDisableAuthConfig_Success() {
+        // Arrange
+        when(authenticationApiService.disableAuthConfig("authId", true)).thenReturn(Mono.just(true));
+
+        // Act
+        Mono<ResponseView<Void>> result = authenticationController.disableAuthConfig("authId", true);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNull(response.getData());
+                })
+                .verifyComplete();
+        
+        verify(authenticationApiService).disableAuthConfig("authId", true);
+    }
+
+    @Test
+    void testGetAllConfigs_Success() {
+        // Arrange
+        EmailAuthConfig emailConfig = new EmailAuthConfig("email", true, true);
+        List<AbstractAuthConfig> configs = List.of(emailConfig);
+        
+        when(authenticationApiService.findAuthConfigs(false))
+                .thenReturn(reactor.core.publisher.Flux.fromIterable(
+                        configs.stream().map(config -> new org.lowcoder.domain.authentication.FindAuthConfig(config, null)).toList()
+                ));
+
+        // Act
+        Mono<ResponseView<List<AbstractAuthConfig>>> result = authenticationController.getAllConfigs();
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertEquals(1, response.getData().size());
+                    assertEquals(emailConfig, response.getData().get(0));
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testCreateAPIKey_Success() {
+        // Arrange
+        APIKeyRequest apiKeyRequest = new APIKeyRequest();
+        apiKeyRequest.put("name", "Test API Key");
+        apiKeyRequest.put("description", "Test Description");
+        
+        APIKeyVO mockApiKeyVO = mock(APIKeyVO.class);
+        when(authenticationApiService.createAPIKey(apiKeyRequest)).thenReturn(Mono.just(mockApiKeyVO));
+
+        // Act
+        Mono<ResponseView<APIKeyVO>> result = authenticationController.createAPIKey(apiKeyRequest);
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertEquals(mockApiKeyVO, response.getData());
+                })
+                .verifyComplete();
+        
+        verify(authenticationApiService).createAPIKey(apiKeyRequest);
+    }
+
+    @Test
+    void testDeleteAPIKey_Success() {
+        // Arrange
+        when(authenticationApiService.deleteAPIKey("apiKeyId")).thenReturn(Mono.empty());
+
+        // Act
+        Mono<ResponseView<Void>> result = authenticationController.deleteAPIKey("apiKeyId");
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertNull(response.getData());
+                })
+                .verifyComplete();
+        
+        verify(authenticationApiService).deleteAPIKey("apiKeyId");
+    }
+
+    @Test
+    void testGetAllAPIKeys_Success() {
+        // Arrange
+        APIKey apiKey1 = APIKey.builder().id("key1").name("Key 1").build();
+        APIKey apiKey2 = APIKey.builder().id("key2").name("Key 2").build();
+        List<APIKey> apiKeys = List.of(apiKey1, apiKey2);
+        
+        when(authenticationApiService.findAPIKeys())
+                .thenReturn(reactor.core.publisher.Flux.fromIterable(apiKeys));
+
+        // Act
+        Mono<ResponseView<List<APIKey>>> result = authenticationController.getAllAPIKeys();
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertEquals(2, response.getData().size());
+                    assertEquals(apiKey1, response.getData().get(0));
+                    assertEquals(apiKey2, response.getData().get(1));
+                })
+                .verifyComplete();
+    }
+
+    @Test
+    void testBindEmail_Success() {
+        // Arrange
+        User mockUser = mock(User.class);
+        when(sessionUserService.getVisitor()).thenReturn(Mono.just(mockUser));
+        when(userService.bindEmail(mockUser, "test@example.com")).thenReturn(Mono.just(true));
+
+        // Act
+        Mono<ResponseView<?>> result = authenticationController.bindEmail("test@example.com");
+
+        // Assert
+        StepVerifier.create(result)
+                .assertNext(response -> {
+                    assertTrue(response.isSuccess());
+                    assertEquals(true, response.getData());
+                })
+                .verifyComplete();
+        
+        verify(sessionUserService).getVisitor();
+        verify(userService).bindEmail(mockUser, "test@example.com");
+    }
+
+    @Test
+    void testFormLoginRequest_Record() {
+        // Arrange & Act
+        AuthenticationEndpoints.FormLoginRequest request = new AuthenticationEndpoints.FormLoginRequest(
+                "test@example.com", "password", false, "email", "authId"
+        );
+
+        // Assert
+        assertEquals("test@example.com", request.loginId());
+        assertEquals("password", request.password());
+        assertFalse(request.register());
+        assertEquals("email", request.source());
+        assertEquals("authId", request.authId());
+    }
+} 
\ No newline at end of file