feat: workflow和chat分离

1，增加了创建workflow的页面
2.删除了event

kilostar/core/individual/regulatory_node/__init__.py

@@ -12,6 +12,6 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-from .regulatory_node import regulatoryNode
+from .regulatory_node import RegulatoryNode
 
-__all__ = ["regulatoryNode"]
+__all__ = ["RegulatoryNode"]

kilostar/core/individual/regulatory_node/regulatory_node.py

@@ -15,7 +15,6 @@
 import datetime
 import ray
 from typing import Union, overload
-from kilostar.api.platform.event import kilostarEvent
 from kilostar.adapter.model_adapter.agent_factory import AgentFactory
 from kilostar.core.global_state_machine.global_state_machine import GlobalStateMachine
 from kilostar.core.global_state_machine.model_provider import Provider
@@ -29,6 +28,14 @@ from pydantic_ai import RunContext, Agent
 from kilostar.utils.ray_hook import ray_actor_hook
 
 
+class ClientMessage:
+    def __init__(self, user_id: str, user_name: str, message: str):
+        self.user_id = user_id
+        self.user_name = user_name
+        self.message = message
+        self.platform = "client"
+
+
 @ray.remote
 class RegulatoryNode:
     """regulatoryNode 核心组件类。
@@ -116,35 +123,43 @@ class RegulatoryNode:
                 )
             return prompt
 
-    ###工作函数
-    async def working(self, payload: Union[kilostarEvent, TerminationMessage]) -> str:
-        """
-        working方法，是节点唯一的调用方法，对于_run函数的结果进行判断并实现最终回复
+    async def handle_chat_message(
+        self, user_id: str, chat_id: str, message: str
+    ) -> str:
+        payload = ClientMessage(
+            user_id=user_id, user_name="", message=message
+        )
+        return await self._process(payload)
+
+    async def handle_client_message(
+        self, user_id: str, user_name: str, message: str
+    ) -> str:
+        payload = ClientMessage(
+            user_id=user_id, user_name=user_name, message=message
+        )
+        return await self._process(payload)
+
+    async def working(self, payload: Union[ClientMessage, TerminationMessage]) -> str:
+        """working方法，是节点唯一的调用方法，对于_run函数的结果进行判断并实现最终回复
         Args:
             payload: 消息载荷，包含所有信息
 
         Returns:
             str,监控节点对于用户的回复
         """
+        return await self._process(payload)
+
+    async def _process(
+        self, payload: Union[ClientMessage, TerminationMessage]
+    ) -> str:
         try:
             result = await self._run(payload)
             if isinstance(result, ForConsciousnessNode):
-                self.logger.info("regulatoryNode: 任务已分配给工作流引擎处理")
-                if isinstance(payload, kilostarEvent):
-                    try:
-                        global_workflow_manager = ray_actor_hook(
-                            "global_workflow_manager"
-                        ).global_workflow_manager
-                        await global_workflow_manager.add_event.remote(payload)
-                        workflow_running_engine = ray_actor_hook(
-                            "workflow_running_engine"
-                        ).workflow_running_engine
-                        await workflow_running_engine.put_event.remote(payload)
-                    except Exception as e:
-                        self.logger.error(
-                            f"regulatoryNode: 无法将事件放入 WorkflowRunningEngine: {e}"
-                        )
-                        return "抱歉，任务提交失败，系统内部错误。"
+                self.logger.info("regulatoryNode: 任务需交意识节点处理")
+                workflow_running_engine = ray_actor_hook(
+                    "workflow_running_engine"
+                ).workflow_running_engine
+                await workflow_running_engine.put_event.remote(payload)
                 return f"任务已创建，准备创建工作流。原因：{result.reasoning}"
             elif isinstance(result, ForUser):
                 self.logger.info("regulatoryNode: 直接向用户返回简单回复。")
@@ -158,43 +173,15 @@ class RegulatoryNode:
 
     @overload
     async def _run(
-        self, payload: kilostarEvent
-    ) -> Union[ForConsciousnessNode, ForUser]:
-        """
-            _run方法
-        Args:
-            payload: kilostarEvent的实例，是用户输入时对于消息的封装
-
-        Returns:
-            ForUser对象，监控节点对于用户进行的简单回答
-            ForConsciousnessNode对象，监控节点将用户的请求判断为复杂任务，将kilostarEvent传递给意识节点
-        """
-        ...
+        self, payload: ClientMessage
+    ) -> Union[ForConsciousnessNode, ForUser]: ...
 
     @overload
-    async def _run(self, payload: TerminationMessage) -> ForUser:
-        """
-            _run方法
-        Args:
-            payload: Termination的实例，是工作流结束后到达监控节点的最后结果
-
-        Returns:
-            ForUser对象，工作流结束后给用户的返回
-        """
-        ...
+    async def _run(self, payload: TerminationMessage) -> ForUser: ...
 
     async def _run(
-        self, payload: Union[kilostarEvent, TerminationMessage]
+        self, payload: Union[ClientMessage, TerminationMessage]
     ) -> Union[ForConsciousnessNode, ForUser]:
-        """
-        _run方法，将payload转化为对llm发送的消息并发送
-        Args:
-            payload: 消息载荷
-
-        Returns:
-            ForConsciousnessNode对象，对意识节点发送的消息
-            ForUser对象，对用户发送到消息
-        """
         platform = payload.platform
         user_name = payload.user_name
         message = payload.message