feat(system):优化后端

1.新增后端测试
2.增加了后端的加密
3.增加了i18n（国际化）

kilostar/core/individual/consciousness_node/consciousness_node.py

@@ -29,6 +29,7 @@ from kilostar.core.global_state_machine.global_state_machine import GlobalStateM
 from kilostar.core.global_state_machine.model_provider.base_provider import Provider
 from kilostar.adapter.model_adapter.agent_factory import AgentFactory
 from kilostar.utils.ray_hook import ray_actor_hook
+from kilostar.utils.i18n import agent_prompt
 
 
 @ray.remote
@@ -45,22 +46,19 @@ class ConsciousnessNode:
         provider_title: str,
         model_id: str,
         tools_list: list[str] = None,
+        toolsets=None,
+        locale: str | None = None,
     ) -> None:
-        system_prompt: str = (
-            "你叫kilostar，是一个多智能体AI助手系统中的【意识节点 (Consciousness Node)】。\n"
-            "你是系统的'高级规划师'和'架构师'，负责处理监控节点分配过来的复杂任务。\n"
-            "你的主要工作场景包括：\n"
-            "1. 拆解任务 (Workflow Generation)：结合用户的原始命令和提供的模板，生成严谨、可执行的工作流 (kilostarWorkflow)，并将其输出为 ForWorkflowEngine 格式。拆解时步骤应清晰连贯。\n"
-            "2. 中途指导 (Workflow Execution)：在工作流执行中，如果某一步骤指派给你，你需要对控制节点的结果进行分析或提供下一步的指导，输出 ForWorkflow 格式。\n"
-            "3. 总结报告 (regulatory Report)：在整个工作流执行完毕后，你需要对整体流程、各个控制节点的执行情况进行审查，并生成一份技术性的总结报告，输出 ForregulatoryNode 格式。\n"
-            "请确保所有的思考和生成过程符合逻辑，严密且高质量。"
-        )
+        system_prompt: str = agent_prompt("consciousness_node", locale=locale)
         output_type = Union[ForregulatoryNode, ForWorkflow, ForWorkflowEngine]
         from kilostar.utils.get_tool import load_tools_from_list
+        from kilostar.core.global_state_machine.gsm_snapshot import fetch_snapshot
 
-        provider: Provider = await global_state_machine.get_provider.remote(
-            provider_title
-        )
+        snapshot = await fetch_snapshot(gsm_actor=global_state_machine)
+        provider: Provider = snapshot.providers.get(provider_title)
+        if provider is None:
+            from kilostar.utils.i18n import t
+            raise ValueError(t("provider_not_registered", locale=locale, provider_title=provider_title))
         agent_factory = AgentFactory()
 
         callables = load_tools_from_list(tools_list)
@@ -72,6 +70,7 @@ class ConsciousnessNode:
             deps_type=ConsciousnessNodeDeps,
             agent_name="consciousness_node",
             tools=callables,
+            toolsets=toolsets,
         )
 
         @self.agent.system_prompt
@@ -95,6 +94,13 @@ class ConsciousnessNode:
         开始进行工作流设计的交互过程（与用户通过 SSE 进行确认或直接生成）
         目前简化为：直接根据 command 拆解并构建工作流，然后提交执行。
         """
+        from kilostar.utils.request_context import trace_id_scope
+
+        # 进入工作流域：把 trace_id 绑到 contextvars，本协程所有日志自动带上它
+        with trace_id_scope(trace_id):
+            await self._do_start_workflow_design(trace_id, command)
+
+    async def _do_start_workflow_design(self, trace_id: str, command: str):
         self.logger.info(
             f"ConsciousnessNode: 开始为 trace_id {trace_id} 设计工作流。原始命令：{command}"
         )
@@ -116,11 +122,11 @@ class ConsciousnessNode:
             original_command=command, available_skills=available_skills
         )
 
-        # 通知 SSE 正在生成图结构
+        # 通知 SSE 正在生成图结构（pending 队列：节点端写入 → API SSE 读取，单向下行）
         global_workflow_manager = ray_actor_hook(
             "global_workflow_manager"
         ).global_workflow_manager
-        await global_workflow_manager.put_received.remote(
+        await global_workflow_manager.put_pending.remote(
             trace_id, "正在为您构建并规划工作流任务节点，请稍候..."
         )
 
@@ -131,17 +137,17 @@ class ConsciousnessNode:
             workflow = result.workflow
             workflow.trace_id = trace_id
 
-            await global_workflow_manager.put_received.remote(
+            await global_workflow_manager.put_pending.remote(
                 trace_id, "工作流构建完成，即将开始执行！"
             )
 
-            # 将生成的完整工作流提交执行
-            workflow_engine = ray_actor_hook(
-                "workflow_running_engine"
-            ).workflow_running_engine
-            await workflow_engine.execute_workflow.remote(workflow)
+            # 直接以 ray task 形式 fire workflow，不再经过 WorkflowRunningEngine 这层中转：
+            # workflow 是一次性、有头有尾的执行，task 语义比常驻 actor 更贴。
+            from kilostar.core.work.workflow.workflow_engine import run_workflow_task
+
+            run_workflow_task.remote(workflow.model_dump(), trace_id)
         else:
-            await global_workflow_manager.put_received.remote(
+            await global_workflow_manager.put_pending.remote(
                 trace_id, "很抱歉，工作流生成失败。"
             )
             await postgres_database.update_workflow_status.remote(trace_id, "failed")

kilostar/core/individual/control_node/control_node.py

@@ -22,6 +22,7 @@ from kilostar.core.individual.control_node.template import (
     ForWorkflowInput,
     ControlNodeDeps,
 )
+from kilostar.utils.i18n import agent_prompt
 
 
 @ray.remote
@@ -44,6 +45,8 @@ class ControlNode:
         provider_title: str,
         model_id: str,
         tools_list: list[str] = None,
+        toolsets=None,
+        locale: str | None = None,
     ) -> None:
         """
         create_agent方法，将agent对象装配到Control的属性内
@@ -54,25 +57,21 @@ class ControlNode:
             global_state_machine: 全局状态机
             provider_title: 供应商名
             model_id: 模型id
+            locale: 语言代码（zh/en），控制system prompt语言
 
         Returns:
             无返回
         """
-        system_prompt: str = (
-            "你叫kilostar，是一个多智能体AI助手系统中的【控制节点 (Control Node)】。\n"
-            "你是系统的'执行者'和'车间主任'，专门负责执行工作流中分配给你的具体子任务。\n"
-            "你的工作职责是：\n"
-            "1. 仔细分析分配给你的工作流步骤 (workflow_step) 的目标和要求。\n"
-            "2. 运用你被分配的工具 (如有) 或者依靠自身的知识和推理能力，精准、高效地完成该任务。\n"
-            "3. 将执行的结果、产生的数据或者具体的输出，严格按照 ForWorkflow 格式返回。\n"
-            "请注意：你的输出应当具体、实用，直接提供任务所要求的结果，不要做过多无关的寒暄。"
-        )
+        system_prompt: str = agent_prompt("control_node", locale=locale)
         output_type = ForWorkflow
         from kilostar.utils.get_tool import load_tools_from_list
+        from kilostar.core.global_state_machine.gsm_snapshot import fetch_snapshot
 
-        provider: Provider = await global_state_machine.get_provider.remote(
-            provider_title
-        )
+        snapshot = await fetch_snapshot(gsm_actor=global_state_machine)
+        provider: Provider = snapshot.providers.get(provider_title)
+        if provider is None:
+            from kilostar.utils.i18n import t
+            raise ValueError(t("provider_not_registered", locale=locale, provider_title=provider_title))
         agent_factory = AgentFactory()
 
         callables = load_tools_from_list(tools_list)
@@ -84,6 +83,7 @@ class ControlNode:
             deps_type=ControlNodeDeps,
             agent_name="control_node",
             tools=callables,
+            toolsets=toolsets,
         )
 
         @self.agent.system_prompt

kilostar/core/individual/regulatory_node/regulatory_node.py

@@ -24,6 +24,7 @@ from kilostar.core.individual.regulatory_node.template import (
     MessageResponse
 )
 from pydantic_ai import RunContext, Agent
+from kilostar.utils.i18n import agent_prompt
 
 
 @ray.remote
@@ -46,6 +47,8 @@ class RegulatoryNode:
         provider_title: str,
         model_id: str,
         tools_list: list[str] = None,
+        toolsets=None,
+        locale: str | None = None,
     ) -> None:
         """
         create_agent方法，将agent对象装配到regulatoryNode的属性内
@@ -56,24 +59,21 @@ class RegulatoryNode:
             provider_title: 供应商名
             model_id: 模型id
             tools_list: 工具列表
+            locale: 语言代码（zh/en），控制system prompt语言
         Returns:
             无返回
         """
-        system_prompt: str = (
-            "你叫kilostar，是一个多智能体AI助手系统中的【监控节点 (regulatory Node)】。\n"
-            "你是系统的'前台接待'和'大脑皮层'，负责接收用户的初始请求或工作流的最终报告。\n"
-            "你的核心职责是进行【意图识别与路由】。请仔细阅读用户的请求：\n"
-            "1. 如果用户只是进行简单的问候、闲聊或查询非常基础的信息，请直接生成友好的回复，使用 ForUser 格式。\n"
-            "2. 如果用户提出的是复杂任务（如需要编写代码、多步骤规划、数据处理等），请务必将其判定为需要工作流处理的任务，"
-            "   并使用 ForConsciousnessNode 格式将其移交意识节点处理。\n"
-            "3. 如果你收到的是 TerminationMessage（代表工作流已完成并生成了报告），请将报告内容转化为友好的面向用户的回复，使用 ForUser 格式。\n"
-            "请保持冷静、专业，并严格遵循上述路由规则。"
-        )
+        system_prompt: str = agent_prompt("regulatory_node", locale=locale)
         output_type = Union[MessageResponse]
         from kilostar.utils.get_tool import load_tools_from_list
-        provider: Provider = await global_state_machine.get_provider.remote(
-            provider_title
-        )
+        from kilostar.core.global_state_machine.gsm_snapshot import fetch_snapshot
+
+        # 走 Object Store 快照而不是 actor RPC：高频读路径不再受单 actor 串行限制
+        snapshot = await fetch_snapshot(gsm_actor=global_state_machine)
+        provider: Provider = snapshot.providers.get(provider_title)
+        if provider is None:
+            from kilostar.utils.i18n import t
+            raise ValueError(t("provider_not_registered", locale=locale, provider_title=provider_title))
         agent_factory = AgentFactory()
 
         callables = load_tools_from_list(tools_list)
@@ -85,6 +85,7 @@ class RegulatoryNode:
             deps_type=RegulatoryNodeDeps,
             agent_name="regulatory_node",
             tools=callables,
+            toolsets=toolsets,
         )
 
         @self.agent.system_prompt
@@ -112,16 +113,15 @@ class RegulatoryNode:
                 )
             return prompt
 
-    async def working(self, payload: MessageRequest) -> str:
-        """working方法，是节点唯一的调用方法，对于_run函数的结果进行判断并实现最终回复
+    async def working(self, payload: MessageRequest) -> Union[MessageResponse, None]:
+        """working方法，是节点唯一的调用方法，对_run函数的结果进行判断并返回最终回复
         Args:
             payload: 消息载荷，包含所有信息
 
         Returns:
-            str,监控节点对于用户的回复
+            MessageResponse 或 None，监控节点对用户的结构化回复
         """
-        await self._run(payload)
-        return ""
+        return await self._run(payload)
 
     async def _run(
         self, payload: MessageRequest
@@ -140,7 +140,8 @@ class RegulatoryNode:
                                             deps=deps,)
             response: MessageResponse = agent_response.output
             response.platform = platform
-            response.platform_id = MessageRequest.platform_id
+            response.platform_id = payload.platform_id
             return response
-        except:
-            pass
+        except Exception as e:
+            self.logger.exception(f"RegulatoryNode._run failed: {e}")
+            return None

kilostar/core/individual/regulatory_node/template.py

@@ -49,7 +49,7 @@ class MessageRequest(RequestModel):
     MessageRequest类
     任何消息渠道向regulatory_node发送消息请求的模型
     """
-    platform: Literal["client"]
+    platform: Literal["client", "onebot"]
     user_name: str
     platform_id: Optional[str]
     message: str
@@ -59,6 +59,6 @@ class MessageResponse(RegulatoryNodeResponse):
     MessageResponse类
     regulatory_node回复的模型
     """
-    platform: Optional[Literal["client"]] = Field(description="系统自动填入的platform")
+    platform: Optional[Literal["client", "onebot"]] = Field(description="系统自动填入的platform")
     platform_id: Optional[str] = Field(description="系统自动填入的platform_id")
     reply_message: str = Field(...,description="模型回复的消息")