refactor(core): decouple actors and remove workflow templates (#67)

Removes the deprecated `workflow_template` concept entirely across both backend API routers, internal logic handling within the `supervisory_node` and `consciousness_node`, and front-end components. Enables `consciousness_node` to work autonomously.

Also refactors core package structure to enforce the "one python package, one Ray Actor" architectural rule. `GlobalWorkflowManager`, `WorkflowRunningEngine`, `PostgresDatabase`, and `WorkerCluster` have been moved to their own top-level decoupled package directories with properly exported `__init__.py` modules. Test suites have been relocated and import paths updated across the system.

Co-authored-by: google-labs-jules[bot] <161369871+google-labs-jules[bot]@users.noreply.github.com>
Co-authored-by: zhaoxi826 <198742034+zhaoxi826@users.noreply.github.com>

pretor/core/database/database_exception.py

@@ -17,16 +17,20 @@ from pydantic import ValidationError
 from pretor.utils.error import UserNotExistError
 
 from pretor.utils.logger import get_logger
-logger = get_logger('database_exception')
+
+logger = get_logger("database_exception")
+
+
 def database_exception(func):
     """执行与 database exception 相关的核心业务流转操作。
     该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
     Args:        func: 参与 database exception 逻辑运算或数据构建的上下文依赖对象。
-    Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+    Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+
     async def wrapper(*args, **kwargs):
         """执行与 wrapper 相关的核心业务流转操作。
         该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         try:
             return await func(*args, **kwargs)
         except ValidationError as e:
@@ -43,4 +47,5 @@ def database_exception(func):
         except Exception as e:
             logger.exception(f"未预期的数据库错误: {e}")
             raise e
-    return wrapper
+
+    return wrapper

pretor/core/database/module/event.py

@@ -3,6 +3,7 @@ from typing import List, Optional
 from pretor.core.database.table.event import EventRecord
 from sqlalchemy.ext.asyncio import async_sessionmaker, AsyncSession
 
+
 class EventDatabase:
     def __init__(self, async_session_maker: async_sessionmaker[AsyncSession]):
         self.async_session_maker = async_session_maker

pretor/core/database/module/individual.py

@@ -19,9 +19,11 @@ from pretor.core.database.database_exception import database_exception
 
 from ulid import ULID
 
+
 class IndividualDatabase:
     """IndividualDatabase 核心组件类。
-    这是一个数据库操作层 (DAO/Repository) 封装类，专注于处理实体模型与关系型数据库表之间的映射。它将复杂的 SQL 查询、跨表 Join 和事务回滚逻辑进行了高级抽象，向上层服务暴露简洁的数据读写接口。    """
+    这是一个数据库操作层 (DAO/Repository) 封装类，专注于处理实体模型与关系型数据库表之间的映射。它将复杂的 SQL 查询、跨表 Join 和事务回滚逻辑进行了高级抽象，向上层服务暴露简洁的数据读写接口。"""
+
     def __init__(self, async_session_maker):
         self.async_session_maker = async_session_maker
 
@@ -29,7 +31,7 @@ class IndividualDatabase:
     async def add_worker_individual(self, **kwargs) -> WorkerIndividual:
         """创建并持久化新的 worker individual 实体。
         接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
-        Returns:         (WorkerIndividual): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (WorkerIndividual): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             agent_id = str(ULID())
             individual = WorkerIndividual(agent_id=agent_id, **kwargs)
@@ -43,9 +45,11 @@ class IndividualDatabase:
         """检索并获取特定的 worker individual 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
         Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。
-        Returns:         (Optional[WorkerIndividual]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (Optional[WorkerIndividual]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
-            statement = select(WorkerIndividual).where(WorkerIndividual.agent_id == agent_id)
+            statement = select(WorkerIndividual).where(
+                WorkerIndividual.agent_id == agent_id
+            )
             results = await session.execute(statement)
             return results.scalar_one_or_none()
 
@@ -54,20 +58,26 @@ class IndividualDatabase:
         """检索并获取特定的 worker individual list 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
         Args:        owner_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 owner 实例。
-        Returns:         (List[WorkerIndividual]): 经过筛选、排序或分页处理后的实体对象列表集合。    """
+        Returns:         (List[WorkerIndividual]): 经过筛选、排序或分页处理后的实体对象列表集合。"""
         async with self.async_session_maker() as session:
-            statement = select(WorkerIndividual).where(WorkerIndividual.owner_id == owner_id)
+            statement = select(WorkerIndividual).where(
+                WorkerIndividual.owner_id == owner_id
+            )
             results = await session.execute(statement)
             return list(results.scalars().all())
 
     @database_exception
-    async def update_worker_individual(self, agent_id: str, **kwargs) -> Optional[WorkerIndividual]:
+    async def update_worker_individual(
+        self, agent_id: str, **kwargs
+    ) -> Optional[WorkerIndividual]:
         """对现有的 worker individual 进行状态更新或属性覆盖。
         基于增量变更原则，合并最新的配置或数据，并触发相关依赖组件的缓存刷新或事件通知。
         Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。
-        Returns:         (Optional[WorkerIndividual]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (Optional[WorkerIndividual]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
-            statement = select(WorkerIndividual).where(WorkerIndividual.agent_id == agent_id)
+            statement = select(WorkerIndividual).where(
+                WorkerIndividual.agent_id == agent_id
+            )
             results = await session.execute(statement)
             individual = results.scalar_one_or_none()
             if not individual:
@@ -85,9 +95,11 @@ class IndividualDatabase:
         """安全地移除或注销 worker individual。
         执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
         Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。
-        Returns:         (bool): 一个布尔型结果标志，明确返回 True 表示该操作成功应用或条件达成，False 则表示失败或被拒绝。    """
+        Returns:         (bool): 一个布尔型结果标志，明确返回 True 表示该操作成功应用或条件达成，False 则表示失败或被拒绝。"""
         async with self.async_session_maker() as session:
-            statement = select(WorkerIndividual).where(WorkerIndividual.agent_id == agent_id)
+            statement = select(WorkerIndividual).where(
+                WorkerIndividual.agent_id == agent_id
+            )
             results = await session.execute(statement)
             individual = results.scalar_one_or_none()
             if not individual:
@@ -100,8 +112,8 @@ class IndividualDatabase:
     async def get_all_worker_individual(self) -> List[WorkerIndividual]:
         """检索并获取特定的 all worker individual 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:         (List[WorkerIndividual]): 经过筛选、排序或分页处理后的实体对象列表集合。    """
+        Returns:         (List[WorkerIndividual]): 经过筛选、排序或分页处理后的实体对象列表集合。"""
         async with self.async_session_maker() as session:
             statement = select(WorkerIndividual)
             results = await session.execute(statement)
-            return list(results.scalars().all())
+            return list(results.scalars().all())

pretor/core/database/module/provider.py

@@ -18,9 +18,11 @@ from pretor.core.database.table.provider import Provider
 from sqlmodel import select
 from pretor.core.database.database_exception import database_exception
 
+
 class ProviderDatabase:
     """ProviderDatabase 核心组件类。
-    这是一个模型/服务提供商适配器类，屏蔽了外部不同供应商（如 OpenAI、Anthropic 等）的底层 API 差异。它负责标准化参数组装、网络请求发送、鉴权处理以及响应结构的反序列化。    """
+    这是一个模型/服务提供商适配器类，屏蔽了外部不同供应商（如 OpenAI、Anthropic 等）的底层 API 差异。它负责标准化参数组装、网络请求发送、鉴权处理以及响应结构的反序列化。"""
+
     def __init__(self, async_session_maker):
         self.async_session_maker = async_session_maker
 
@@ -28,23 +30,28 @@ class ProviderDatabase:
     async def get_provider(self) -> List[Provider]:
         """检索并获取特定的 provider 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:         (List[Provider]): 经过筛选、排序或分页处理后的实体对象列表集合。    """
+        Returns:         (List[Provider]): 经过筛选、排序或分页处理后的实体对象列表集合。"""
         async with self.async_session_maker() as session:
             statement = select(Provider)
             results = await session.execute(statement)
             results = results.scalars().all()
-            providers = [Provider(provider_title=provider.provider_title,
-                                  provider_url=provider.provider_url,
-                                  provider_apikey=provider.provider_apikey,
-                                  provider_models=provider.provider_models,
-                                  provider_type=provider.provider_type) for provider in results]
+            providers = [
+                Provider(
+                    provider_title=provider.provider_title,
+                    provider_url=provider.provider_url,
+                    provider_apikey=provider.provider_apikey,
+                    provider_models=provider.provider_models,
+                    provider_type=provider.provider_type,
+                )
+                for provider in results
+            ]
             return providers
 
     @database_exception
     async def add_provider(self, **kwargs) -> None:
         """创建并持久化新的 provider 实体。
         接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
-        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             provider = Provider(**kwargs)
             session.add(provider)
@@ -55,7 +62,7 @@ class ProviderDatabase:
         """安全地移除或注销 provider。
         执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
         Args:        provider_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider 实例。
-        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             provider = await session.get(Provider, provider_id)
             if provider is not None:
@@ -67,7 +74,7 @@ class ProviderDatabase:
         """对现有的 provider 进行状态更新或属性覆盖。
         基于增量变更原则，合并最新的配置或数据，并触发相关依赖组件的缓存刷新或事件通知。
         Args:        provider_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider 实例。
-        Returns:         (Provider): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (Provider): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             provider = await session.get(Provider, provider_id)
             if provider is not None:
@@ -77,4 +84,4 @@ class ProviderDatabase:
                 await session.commit()
                 await session.refresh(provider)
                 return provider
-            return None
+            return None

pretor/core/database/module/system_node.py

@@ -17,20 +17,30 @@ from sqlmodel import select
 from typing import List, Optional
 from pretor.core.database.database_exception import database_exception
 
+
 class SystemNodeDatabase:
     """SystemNodeDatabase 核心组件类。
-    这是一个系统执行节点类，作为多智能体架构中的独立处理单元。它能够接收工作流上下文，根据内置的大模型策略进行意图理解和自主决策，从而驱动特定阶段的任务闭环。    """
+    这是一个系统执行节点类，作为多智能体架构中的独立处理单元。它能够接收工作流上下文，根据内置的大模型策略进行意图理解和自主决策，从而驱动特定阶段的任务闭环。"""
+
     def __init__(self, async_session_maker):
         self.async_session_maker = async_session_maker
 
     @database_exception
-    async def upsert_system_node_config(self, node_name: str, provider_title: str, model_id: str, tools: Optional[List[str]] = None) -> SystemNodeConfig:
+    async def upsert_system_node_config(
+        self,
+        node_name: str,
+        provider_title: str,
+        model_id: str,
+        tools: Optional[List[str]] = None,
+    ) -> SystemNodeConfig:
         """执行与 upsert system node config 相关的核心业务流转操作。
         该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
         Args:        node_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        provider_title (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider_title 实例。        model_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 model 实例。        tools (Optional[List[str]]): 控制逻辑流向的具体字符串参数，指定了期望的 tools 内容。
-        Returns:         (SystemNodeConfig): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (SystemNodeConfig): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
-            statement = select(SystemNodeConfig).where(SystemNodeConfig.node_name == node_name)
+            statement = select(SystemNodeConfig).where(
+                SystemNodeConfig.node_name == node_name
+            )
             results = await session.execute(statement)
             config = results.scalar_one_or_none()
             if config:
@@ -39,7 +49,12 @@ class SystemNodeDatabase:
                 if tools is not None:
                     config.tools = tools
             else:
-                config = SystemNodeConfig(node_name=node_name, provider_title=provider_title, model_id=model_id, tools=tools)
+                config = SystemNodeConfig(
+                    node_name=node_name,
+                    provider_title=provider_title,
+                    model_id=model_id,
+                    tools=tools,
+                )
             session.add(config)
             await session.commit()
             await session.refresh(config)
@@ -49,19 +64,23 @@ class SystemNodeDatabase:
     async def get_all_system_node_configs(self) -> List[SystemNodeConfig]:
         """检索并获取特定的 all system node configs 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:         (List[SystemNodeConfig]): 经过筛选、排序或分页处理后的实体对象列表集合。    """
+        Returns:         (List[SystemNodeConfig]): 经过筛选、排序或分页处理后的实体对象列表集合。"""
         async with self.async_session_maker() as session:
             statement = select(SystemNodeConfig)
             results = await session.execute(statement)
             return list(results.scalars().all())
 
     @database_exception
-    async def get_system_node_config(self, node_name: str) -> Optional[SystemNodeConfig]:
+    async def get_system_node_config(
+        self, node_name: str
+    ) -> Optional[SystemNodeConfig]:
         """检索并获取特定的 system node config 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
         Args:        node_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
-        Returns:         (Optional[SystemNodeConfig]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (Optional[SystemNodeConfig]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
-            statement = select(SystemNodeConfig).where(SystemNodeConfig.node_name == node_name)
+            statement = select(SystemNodeConfig).where(
+                SystemNodeConfig.node_name == node_name
+            )
             results = await session.execute(statement)
             return results.scalar_one_or_none()

pretor/core/database/module/user.py

@@ -19,9 +19,11 @@ from pretor.core.database.database_exception import database_exception
 from pretor.core.database.table.user import UserAuthority
 from pretor.utils.access import Accessor
 
+
 class AuthDatabase:
     """AuthDatabase 核心组件类。
-    这是一个数据库操作层 (DAO/Repository) 封装类，专注于处理实体模型与关系型数据库表之间的映射。它将复杂的 SQL 查询、跨表 Join 和事务回滚逻辑进行了高级抽象，向上层服务暴露简洁的数据读写接口。    """
+    这是一个数据库操作层 (DAO/Repository) 封装类，专注于处理实体模型与关系型数据库表之间的映射。它将复杂的 SQL 查询、跨表 Join 和事务回滚逻辑进行了高级抽象，向上层服务暴露简洁的数据读写接口。"""
+
     def __init__(self, async_session_maker):
         self.async_session_maker = async_session_maker
 
@@ -30,8 +32,9 @@ class AuthDatabase:
         """创建并持久化新的 user 实体。
         接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
         Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        hashed_password (str): 控制逻辑流向的具体字符串参数，指定了期望的 hashed password 内容。
-        Returns:         (User): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (User): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         from ulid import ULID
+
         async with self.async_session_maker() as session:
             # Check if any users exist
             statement = select(User).limit(1)
@@ -46,7 +49,7 @@ class AuthDatabase:
                 user_id=str(ULID()),
                 user_name=user_name,
                 hashed_password=hashed_password,
-                user_authority=authority
+                user_authority=authority,
             )
             session.add(user)
             await session.commit()
@@ -58,7 +61,7 @@ class AuthDatabase:
         """执行与 change password 相关的核心业务流转操作。
         该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
         Args:        user_name: 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        old_password: 参与 change password 逻辑运算或数据构建的上下文依赖对象。        new_password: 参与 change password 逻辑运算或数据构建的上下文依赖对象。
-        Returns:         (User): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (User): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             statement = select(User).where(User.user_name == user_name)
             results = await session.execute(statement)
@@ -78,7 +81,7 @@ class AuthDatabase:
         """安全地移除或注销 user。
         执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
         Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
-        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             statement = select(User).where(User.user_name == user_name)
             results = await session.execute(statement)
@@ -93,7 +96,7 @@ class AuthDatabase:
         """安全地移除或注销 user by id。
         执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
         Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。
-        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             user = await session.get(User, user_id)
             if user is None:
@@ -106,7 +109,7 @@ class AuthDatabase:
         """执行与 login user 相关的核心业务流转操作。
         该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
         Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
-        Returns:         (str): 处理流程所输出的具体字符串产物，可能是新生成的 ID 序列、格式化好的文本片段或 LLM 推理的回答内容。    """
+        Returns:         (str): 处理流程所输出的具体字符串产物，可能是新生成的 ID 序列、格式化好的文本片段或 LLM 推理的回答内容。"""
         async with self.async_session_maker() as session:
             statement = select(User).where(User.user_name == user_name)
             results = await session.execute(statement)
@@ -119,7 +122,7 @@ class AuthDatabase:
     async def get_all_users(self) -> list[User]:
         """检索并获取特定的 all users 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:         (list[User]): 经过筛选、排序或分页处理后的实体对象列表集合。    """
+        Returns:         (list[User]): 经过筛选、排序或分页处理后的实体对象列表集合。"""
         async with self.async_session_maker() as session:
             statement = select(User)
             results = await session.execute(statement)
@@ -131,7 +134,7 @@ class AuthDatabase:
         """检索并获取特定的 user authority 数据集合或实例对象。
         根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
         Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。
-        Returns:         (UserAuthority): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
+        Returns:         (UserAuthority): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
         async with self.async_session_maker() as session:
             user = await session.get(User, user_id)
             if user is None:
@@ -139,7 +142,9 @@ class AuthDatabase:
             return user.user_authority
 
     @database_exception
-    async def change_user_authority(self, user_id: str, new_authority: UserAuthority) -> User:
+    async def change_user_authority(
+        self, user_id: str, new_authority: UserAuthority
+    ) -> User:
         """
         Changes the authority level of a specific user.
 
@@ -161,4 +166,4 @@ class AuthDatabase:
             session.add(user)
             await session.commit()
             await session.refresh(user)
-            return user
+            return user

pretor/core/database/postgres.py

@@ -1,237 +0,0 @@
-#  Copyright 2026 zhaoxi826
-#
-#  Licensed under the Apache License, Version 2.0 (the "License");
-#  you may not use this file except in compliance with the License.
-#  You may obtain a copy of the License at
-#
-#       http://www.apache.org/licenses/LICENSE-2.0
-#
-#  Unless required by applicable law or agreed to in writing, software
-#  distributed under the License is distributed on an "AS IS" BASIS,
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-#  See the License for the specific language governing permissions and
-#  limitations under the License.
-
-import os
-import asyncio
-
-import ray
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
-from sqlalchemy.orm import sessionmaker
-from sqlmodel import SQLModel
-
-from pretor.core.database.module.individual import IndividualDatabase
-from pretor.core.database.module.event import EventDatabase
-from pretor.core.database.module.user import AuthDatabase
-from pretor.core.database.module.provider import ProviderDatabase
-from pretor.core.database.module.system_node import SystemNodeDatabase
-
-@ray.remote
-class PostgresDatabase:
-    """PostgresDatabase 核心组件类。
-    这是一个数据库操作层 (DAO/Repository) 封装类，专注于处理实体模型与关系型数据库表之间的映射。它将复杂的 SQL 查询、跨表 Join 和事务回滚逻辑进行了高级抽象，向上层服务暴露简洁的数据读写接口。    """
-    def __init__(self):
-        user = os.environ.get('POSTGRES_USER')
-        password = os.environ.get('POSTGRES_PASSWORD')
-        host = os.environ.get('POSTGRES_HOST')
-        port = os.environ.get('POSTGRES_PORT')
-        database = os.environ.get('POSTGRES_DB')
-        database_url = f"postgresql+asyncpg://{user}:{password}@{host}:{port}/{database}"
-        self.async_engine = create_async_engine(database_url, echo=True)
-        self.async_session_maker = sessionmaker(self.async_engine, class_=AsyncSession, expire_on_commit=False)
-
-        self._auth_database = AuthDatabase(self.async_session_maker)
-        self._provider_database = ProviderDatabase(self.async_session_maker)
-        self._individual_database = IndividualDatabase(self.async_session_maker)
-        self._event_database = EventDatabase(self.async_session_maker)
-        self._system_node_database = SystemNodeDatabase(self.async_session_maker)
-
-        self.ready_event = asyncio.Event()
-
-    async def init_db(self) -> None:
-        """完成 db 模块的启动与依赖初始化。
-        在系统引导或服务拉起阶段被调用，负责建立网络连接、分配基础内存资源及注册核心服务组件。
-        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        try:
-            async with self.async_engine.begin() as conn:
-                await conn.run_sync(SQLModel.metadata.create_all)
-        except Exception as e:
-            # Provide a warning if the database is not accessible, allowing
-            # the app to start up for development/UI tests without crashing immediately.
-            print(f"Warning: Failed to initialize PostgreSQL database: {e}")
-        finally:
-            self.ready_event.set()
-
-    # Auth Database Methods
-    async def add_user(self, user_name: str, hashed_password: str):
-        """创建并持久化新的 user 实体。
-        接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
-        Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        hashed_password (str): 控制逻辑流向的具体字符串参数，指定了期望的 hashed password 内容。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.add_user(user_name, hashed_password)
-
-    async def change_password(self, user_name, old_password, new_password):
-        """执行与 change password 相关的核心业务流转操作。
-        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
-        Args:        user_name: 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        old_password: 参与 change password 逻辑运算或数据构建的上下文依赖对象。        new_password: 参与 change password 逻辑运算或数据构建的上下文依赖对象。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.change_password(user_name, old_password, new_password)
-
-    async def delete_user(self, user_name: str):
-        """安全地移除或注销 user。
-        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
-        Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.delete_user(user_name)
-
-    async def delete_user_by_id(self, user_id: str):
-        """安全地移除或注销 user by id。
-        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
-        Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.delete_user_by_id(user_id)
-
-    async def login_user(self, user_name: str):
-        """执行与 login user 相关的核心业务流转操作。
-        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
-        Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.login_user(user_name)
-
-    async def get_all_users(self):
-        """检索并获取特定的 all users 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.get_all_users()
-
-    async def get_user_authority(self, user_id: str):
-        """检索并获取特定的 user authority 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.get_user_authority(user_id)
-
-    async def change_user_authority(self, user_id: str, new_authority):
-        """执行与 change user authority 相关的核心业务流转操作。
-        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
-        Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。        new_authority: 参与 change user authority 逻辑运算或数据构建的上下文依赖对象。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._auth_database.change_user_authority(user_id, new_authority)
-
-    # Provider Database Methods
-    async def get_provider(self):
-        """检索并获取特定的 provider 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._provider_database.get_provider()
-
-    async def add_provider_db(self, **kwargs):
-        """创建并持久化新的 provider db 实体。
-        接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._provider_database.add_provider(**kwargs)
-
-    async def delete_provider_db(self, provider_id: str):
-        """安全地移除或注销 provider db。
-        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
-        Args:        provider_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._provider_database.delete_provider(provider_id)
-
-    async def update_provider_db(self, provider_id: str, **kwargs):
-        """对现有的 provider db 进行状态更新或属性覆盖。
-        基于增量变更原则，合并最新的配置或数据，并触发相关依赖组件的缓存刷新或事件通知。
-        Args:        provider_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._provider_database.update_provider(provider_id, **kwargs)
-
-    # System Node Database Methods
-    async def upsert_system_node_config(self, node_name: str, provider_title: str, model_id: str, tools: list[str] = None):
-        """执行与 upsert system node config 相关的核心业务流转操作。
-        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
-        Args:        node_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        provider_title (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider_title 实例。        model_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 model 实例。        tools (list[str]): 控制逻辑流向的具体字符串参数，指定了期望的 tools 内容。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._system_node_database.upsert_system_node_config(node_name, provider_title, model_id, tools)
-
-    async def get_all_system_node_configs(self):
-        """检索并获取特定的 all system node configs 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._system_node_database.get_all_system_node_configs()
-
-    # Individual Database Methods
-    async def add_worker_individual(self, **kwargs):
-        """创建并持久化新的 worker individual 实体。
-        接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._individual_database.add_worker_individual(**kwargs)
-
-    async def get_worker_individual(self, agent_id: str):
-        """检索并获取特定的 worker individual 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._individual_database.get_worker_individual(agent_id)
-
-    async def get_worker_individual_list(self, owner_id: str):
-        """检索并获取特定的 worker individual list 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Args:        owner_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 owner 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._individual_database.get_worker_individual_list(owner_id)
-
-    async def update_worker_individual(self, agent_id: str, **kwargs):
-        """对现有的 worker individual 进行状态更新或属性覆盖。
-        基于增量变更原则，合并最新的配置或数据，并触发相关依赖组件的缓存刷新或事件通知。
-        Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._individual_database.update_worker_individual(agent_id, **kwargs)
-
-    async def delete_worker_individual(self, agent_id: str):
-        """安全地移除或注销 worker individual。
-        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
-        Args:        agent_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 agent 实例。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._individual_database.delete_worker_individual(agent_id)
-
-    async def get_all_worker_individual(self):
-        """检索并获取特定的 all worker individual 数据集合或实例对象。
-        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
-        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。    """
-        await self.ready_event.wait()
-        return await self._individual_database.get_all_worker_individual()
-    # Event Database Methods
-    async def upsert_event(self, trace_id: str, event_data_json: str):
-        await self.ready_event.wait()
-        return await self._event_database.upsert_event(trace_id, event_data_json)
-
-    async def get_event(self, trace_id: str):
-        await self.ready_event.wait()
-        return await self._event_database.get_event(trace_id)
-
-    async def get_all_events(self):
-        await self.ready_event.wait()
-        return await self._event_database.get_all_events()
-
-    async def delete_event(self, trace_id: str):
-        await self.ready_event.wait()
-        return await self._event_database.delete_event(trace_id)

pretor/core/database/table/__init__.py

@@ -15,4 +15,5 @@
 from pretor.core.database.table.user import User
 from pretor.core.database.table.provider import Provider
 from pretor.core.database.table.individual import WorkerIndividual
+
 __all__ = ["User", "Provider", "WorkerIndividual"]

pretor/core/database/table/event.py

@@ -1,5 +1,8 @@
 from sqlmodel import SQLModel, Field
 
+
 class EventRecord(SQLModel, table=True):
-    trace_id: str = Field(primary_key=True, description="The unique trace ID of the PretorEvent")
+    trace_id: str = Field(
+        primary_key=True, description="The unique trace ID of the PretorEvent"
+    )
     event_data_json: str = Field(description="The JSON serialized PretorEvent data")

pretor/core/database/table/individual.py

@@ -17,16 +17,20 @@ from typing import List, Optional
 from sqlalchemy import Column, JSON
 from enum import Enum
 
+
 class AgentType(str, Enum):
     """AgentType 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 AgentType 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。    """
+    这是一个领域数据模型或功能封装类，承载了 AgentType 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+
     SKILL_INDIVIDUAL = "skill_individual"
     ORDINARY_INDIVIDUAL = "ordinary_individual"
     SPECIAL_INDIVIDUAL = "special_individual"
 
+
 class WorkerIndividual(SQLModel, table=True):
     """WorkerIndividual 核心组件类。
-    这是一个具体的 Worker 智能体实体类，代表着具备特定人设、领域技能或长文本处理能力的数字员工。它可以被控制器动态拉起，并在安全沙箱内执行复杂的工作流指令与多步骤推理任务。    """
+    这是一个具体的 Worker 智能体实体类，代表着具备特定人设、领域技能或长文本处理能力的数字员工。它可以被控制器动态拉起，并在安全沙箱内执行复杂的工作流指令与多步骤推理任务。"""
+
     __tablename__ = "worker_individual"
     agent_id: str = Field(primary_key=True)
     agent_name: str = Field(index=True)
@@ -35,8 +39,10 @@ class WorkerIndividual(SQLModel, table=True):
     provider_title: str
     model_id: str
     system_prompt: Optional[str]
-    output_template: Optional[dict] = Field(sa_column=Column(JSON),description="输出模板标识")
+    output_template: Optional[dict] = Field(
+        sa_column=Column(JSON), description="输出模板标识"
+    )
     bound_skill: Optional[str] = Field(sa_column=Column(JSON))
     workspace: Optional[List[str]] = Field(sa_column=Column(JSON))
     tools: Optional[List[str]] = Field(sa_column=Column(JSON), default=None)
-    owner_id: str
+    owner_id: str

pretor/core/database/table/provider.py

@@ -17,9 +17,11 @@ from typing import List
 from sqlalchemy import Column, JSON
 from typing import Optional
 
+
 class Provider(SQLModel, table=True):
     """Provider 核心组件类。
-    这是一个模型/服务提供商适配器类，屏蔽了外部不同供应商（如 OpenAI、Anthropic 等）的底层 API 差异。它负责标准化参数组装、网络请求发送、鉴权处理以及响应结构的反序列化。    """
+    这是一个模型/服务提供商适配器类，屏蔽了外部不同供应商（如 OpenAI、Anthropic 等）的底层 API 差异。它负责标准化参数组装、网络请求发送、鉴权处理以及响应结构的反序列化。"""
+
     __tablename__ = "provider"
     provider_id: str = Field(primary_key=True)
     provider_title: str = Field(index=True)
@@ -31,4 +33,4 @@ class Provider(SQLModel, table=True):
     provider_models: List[str] = Field(sa_column=Column(JSON))
 
     provider_owner: str
-    is_active: bool = Field(default=True, description="该服务商节点是否在线/启用")
+    is_active: bool = Field(default=True, description="该服务商节点是否在线/启用")

pretor/core/database/table/system_node.py

@@ -17,9 +17,11 @@ from sqlmodel import SQLModel, Field
 from typing import List, Optional
 from sqlalchemy import Column, JSON
 
+
 class SystemNodeConfig(SQLModel, table=True):
     """SystemNodeConfig 核心组件类。
-    这是一个系统执行节点类，作为多智能体架构中的独立处理单元。它能够接收工作流上下文，根据内置的大模型策略进行意图理解和自主决策，从而驱动特定阶段的任务闭环。    """
+    这是一个系统执行节点类，作为多智能体架构中的独立处理单元。它能够接收工作流上下文，根据内置的大模型策略进行意图理解和自主决策，从而驱动特定阶段的任务闭环。"""
+
     __tablename__ = "system_node_config"
     node_name: str = Field(primary_key=True)
     provider_title: str

pretor/core/database/table/user.py

@@ -15,21 +15,24 @@
 from sqlmodel import SQLModel, Field
 from enum import IntEnum
 
+
 class UserAuthority(IntEnum):
     """UserAuthority 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 UserAuthority 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。    """
+    这是一个领域数据模型或功能封装类，承载了 UserAuthority 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+
     SUPER_ADMINISTRATOR = 100
     ADMINISTRATOR = 50
     USER = 20
     UNAUTHORIZED_USER = 10
     GUEST = 0
 
+
 class User(SQLModel, table=True):
     """User 核心组件类。
-    这是一个领域数据模型或功能封装类，承载了 User 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。    """
-    __tablename__ = 'user'
+    这是一个领域数据模型或功能封装类，承载了 User 相关的内聚属性定义与状态维护。它的存在隔离了局部的业务复杂性，并对外提供了类型安全的访问接口。"""
+
+    __tablename__ = "user"
     user_id: str = Field(primary_key=True)
     user_name: str = Field(index=True)
     hashed_password: str
     user_authority: UserAuthority = Field(default=UserAuthority.USER)
-