style: 项目重构

1.项目改名为kilostar（千星）
2.后端部分进行大规模重构
3.node功能进行大规模重新设计

kilostar/core/postgres_database/__init__.py

@@ -0,0 +1,3 @@
+from kilostar.core.postgres_database.postgres import PostgresDatabase
+
+__all__ = ["PostgresDatabase"]

kilostar/core/postgres_database/database_exception.py

@@ -0,0 +1,51 @@
+#  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.
+
+from sqlalchemy.exc import IntegrityError, OperationalError
+from pydantic import ValidationError
+from kilostar.utils.error import UserNotExistError
+
+from kilostar.utils.logger import get_logger
+
+logger = get_logger("database_exception")
+
+
+def database_exception(func):
+    """执行与 database exception 相关的核心业务流转操作。
+    该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
+    Args:        func: 参与 database exception 逻辑运算或数据构建的上下文依赖对象。
+    Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+
+    async def wrapper(*args, **kwargs):
+        """执行与 wrapper 相关的核心业务流转操作。
+        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
+        Returns:        : 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        try:
+            return await func(*args, **kwargs)
+        except ValidationError as e:
+            logger.error(f"对象校验失败:{e}")
+            raise e
+        except IntegrityError as e:
+            logger.error(f"数据库完整性错误 (如重复记录): {e}")
+            raise e
+        except OperationalError as e:
+            logger.error(f"数据库连接异常: {e}")
+            raise e
+        except UserNotExistError as e:
+            logger.error(f"更改密码失败，用户不存在：{e}")
+        except Exception as e:
+            logger.exception(f"未预期的数据库错误: {e}")
+            raise e
+
+    return wrapper

kilostar/core/postgres_database/model/__init__.py

@@ -0,0 +1,19 @@
+#  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.
+
+from kilostar.core.postgres_database.model.user import User
+from kilostar.core.postgres_database.model.provider import Provider
+from kilostar.core.postgres_database.model.individual import WorkerIndividual
+
+__all__ = ["User", "Provider", "WorkerIndividual"]

kilostar/core/postgres_database/model/base.py

@@ -0,0 +1,19 @@
+#  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.
+
+from sqlalchemy.ext.asyncio import AsyncAttrs
+from sqlalchemy.orm import DeclarativeBase
+
+class BaseDataModel(DeclarativeBase, AsyncAttrs):
+    pass

kilostar/core/postgres_database/model/chat_history.py

@@ -0,0 +1,29 @@
+#  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.
+from typing import Literal
+
+from .base import BaseDataModel
+from sqlalchemy.orm import Mapped
+
+class ChatHistoryMessage(BaseDataModel):
+    __tablename__ = "chat_history_massage"
+    message_id: Mapped[str]
+    message: Mapped[str]
+    message_owner: Literal["user","regulatory_node"]
+
+class ChatHistoryRegister(BaseDataModel):
+    __tablename__ = "chat_history_register"
+    chat_id: Mapped[str]
+    user_id: Mapped[str]
+

kilostar/core/postgres_database/model/individual.py

@@ -0,0 +1,146 @@
+#  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.
+
+from enum import Enum
+from typing import List, Optional, Dict, Any
+from sqlalchemy import String, Text, text, ForeignKey
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from .base import BaseDataModel
+
+
+class ModalityType(str, Enum):
+    TEXT = "text"
+    VISION = "vision"
+    AUDIO = "audio"
+    MULTIMODAL = "multimodal"
+
+
+# ==========================================
+# 1. 通用基类表 (身份中心)
+# ==========================================
+class BaseIndividualModel(BaseDataModel):
+    __tablename__ = "base_individual"
+
+    agent_id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    agent_name: Mapped[str] = mapped_column(String(100), index=True, nullable=False)
+    description: Mapped[str] = mapped_column(Text, nullable=False)
+    system_prompt: Mapped[Optional[str]] = mapped_column(Text)
+    provider_title: Mapped[str] = mapped_column(String(50))
+    model_id: Mapped[str] = mapped_column(String(100))
+    owner_id: Mapped[str] = mapped_column(String(64), index=True)
+
+    agent_type: Mapped[str] = mapped_column(String(32))
+
+    __mapper_args__ = {
+        "polymorphic_on": "agent_type",
+        "polymorphic_identity": "base"
+    }
+
+
+# ==========================================
+# 2. 专家子个体 (技能与复杂工作流)
+# ==========================================
+class SpecialistIndividualModel(BaseIndividualModel):
+    __tablename__ = "specialist_individual"
+
+    agent_id: Mapped[str] = mapped_column(
+        ForeignKey("base_individual.agent_id", ondelete="CASCADE"),
+        primary_key=True
+    )
+    bound_skill: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSONB)
+    workspace: Mapped[Optional[List[str]]] = mapped_column(JSONB)
+    tools: Mapped[Optional[List[str]]] = mapped_column(
+        JSONB, default=list, server_default=text("'[]'::jsonb")
+    )
+
+    # 逻辑关联：作为管理者，管理下属个体
+    sub_ordinary_agents: Mapped[List["OrdinaryIndividualModel"]] = relationship(
+        back_populates="manager",
+        cascade="all, delete-orphan",
+        foreign_keys="[OrdinaryIndividualModel.manager_id]"
+    )
+    sub_special_agents: Mapped[List["SpecialIndividualModel"]] = relationship(
+        back_populates="manager",
+        cascade="all, delete-orphan",
+        foreign_keys="[SpecialIndividualModel.manager_id]"
+    )
+
+    __mapper_args__ = {
+        "polymorphic_identity": "specialist",
+    }
+
+
+# ==========================================
+# 3. 基础子个体 (普通微调模型)
+# ==========================================
+class OrdinaryIndividualModel(BaseIndividualModel):
+    __tablename__ = "ordinary_individual"
+
+    agent_id: Mapped[str] = mapped_column(
+        ForeignKey("base_individual.agent_id", ondelete="CASCADE"),
+        primary_key=True
+    )
+    finetuned_from: Mapped[Optional[str]] = mapped_column(String(100))
+    tools: Mapped[Optional[List[str]]] = mapped_column(
+        JSONB, default=list, server_default=text("'[]'::jsonb")
+    )
+
+    # 【修复1】：必须显式定义物理外键
+    manager_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("specialist_individual.agent_id", ondelete="SET NULL")
+    )
+
+    # 逻辑关联：指向上级专家
+    manager: Mapped[Optional["SpecialistIndividualModel"]] = relationship(
+        back_populates="sub_ordinary_agents",
+        foreign_keys=[manager_id]  # 显式指定使用 manager_id 解析关系
+    )
+
+    __mapper_args__ = {
+        "polymorphic_identity": "ordinary",
+    }
+
+
+# ==========================================
+# 4. 特殊子个体 (多模态)
+# ==========================================
+class SpecialIndividualModel(BaseIndividualModel):
+    __tablename__ = "special_individual"
+
+    agent_id: Mapped[str] = mapped_column(
+        ForeignKey("base_individual.agent_id", ondelete="CASCADE"),
+        primary_key=True
+    )
+    modality_type: Mapped[ModalityType] = mapped_column(
+        default=ModalityType.MULTIMODAL,
+        server_default=text("'multimodal'")
+    )
+    multimodal_config: Mapped[Optional[Dict[str, Any]]] = mapped_column(JSONB)
+
+    # 【修复1】：添加缺失的物理外键
+    manager_id: Mapped[Optional[str]] = mapped_column(
+        ForeignKey("specialist_individual.agent_id", ondelete="SET NULL")
+    )
+
+    # 【修复2】：修正 back_populates 指向正确的变量名
+    manager: Mapped[Optional["SpecialistIndividualModel"]] = relationship(
+        back_populates="sub_special_agents",
+        foreign_keys=[manager_id]
+    )
+
+    __mapper_args__ = {
+        "polymorphic_identity": "special",
+    }

kilostar/core/postgres_database/model/provider.py

@@ -0,0 +1,44 @@
+#  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.
+
+from typing import List, Optional
+from sqlalchemy import String, Text, Boolean, text
+from sqlalchemy.dialects.postgresql import JSONB  # 针对供应商模型列表优化
+from sqlalchemy.orm import Mapped, mapped_column
+from .base import BaseDataModel
+
+
+class ProviderModel(BaseDataModel):
+    """
+    Provider 物理模型。
+    作为模型/服务提供商适配器，标准化不同供应商（OpenAI, Anthropic 等）的配置。
+    """
+    __tablename__ = "provider"
+    provider_id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    provider_title: Mapped[str] = mapped_column(String(100), index=True, nullable=False)
+    provider_type: Mapped[str] = mapped_column(String(50), nullable=False)
+    provider_url: Mapped[Optional[str]] = mapped_column(Text)
+    provider_apikey: Mapped[Optional[str]] = mapped_column(Text)
+    provider_models: Mapped[List[str]] = mapped_column(
+        JSONB,
+        default=list,
+        server_default=text("'[]'::jsonb")
+    )
+    provider_owner: Mapped[str] = mapped_column(String(64), index=True)
+    is_active: Mapped[bool] = mapped_column(
+        Boolean,
+        default=True,
+        server_default=text("true"),
+        comment="该服务商节点是否在线/启用"
+    )

kilostar/core/postgres_database/model/system_node.py

@@ -0,0 +1,35 @@
+#  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.
+
+from typing import List, Optional
+from sqlalchemy import String, Text
+from sqlalchemy.dialects.postgresql import JSONB  # 针对 Postgres 优化，支持索引和高性能解析
+from sqlalchemy.orm import Mapped, mapped_column
+from .base import  BaseDataModel
+
+
+class SystemNodeConfigModel(BaseDataModel):
+    """
+    SystemNodeConfig 物理模型。
+    作为 kilostar 架构中的独立处理单元，负责存储 LLM 节点的执行策略与工具配置。
+    """
+    __tablename__ = "system_node_config"
+    node_name: Mapped[str] = mapped_column(String(100), primary_key=True)
+    provider_title: Mapped[str] = mapped_column(String(50), nullable=False)
+    model_id: Mapped[str] = mapped_column(String(100), nullable=False)
+    tools: Mapped[Optional[List[str]]] = mapped_column(
+        JSONB,
+        default=list,
+        comment="节点可调用的工具标识列表"
+    )

kilostar/core/postgres_database/model/user.py

@@ -0,0 +1,47 @@
+#  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.
+
+
+from enum import IntEnum
+
+from sqlalchemy import String, Integer, text
+from sqlalchemy.orm import Mapped, mapped_column
+
+from .base import BaseDataModel
+
+
+class UserAuthority(IntEnum):
+    """
+    权限枚举类
+    """
+    SUPER_ADMINISTRATOR = 100
+    ADMINISTRATOR = 50
+    USER = 20
+    UNAUTHORIZED_USER = 10
+    GUEST = 0
+
+
+class User(BaseDataModel):
+    """
+    数据库user表模型
+    """
+    __tablename__ = "user"
+    user_id: Mapped[str] = mapped_column(String(64), primary_key=True)
+    user_name: Mapped[str] = mapped_column(String(100), index=True, nullable=False)
+    hashed_password: Mapped[str] = mapped_column(String(255), nullable=False)
+    user_authority: Mapped[UserAuthority] = mapped_column(
+        Integer,
+        default=UserAuthority.USER,
+        server_default=text("20")
+    )

kilostar/core/postgres_database/model/workflow.py

@@ -0,0 +1,23 @@
+#  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.
+
+
+from sqlmodel import SQLModel, Field
+
+
+class EventRecord(SQLModel, table=True):
+    trace_id: str = Field(
+        primary_key=True, description="The unique trace ID of the kilostarEvent"
+    )
+    event_data_json: str = Field(description="The JSON serialized kilostarEvent data")

kilostar/core/postgres_database/module/__init__.py

@@ -0,0 +1,14 @@
+#  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.
+

kilostar/core/postgres_database/module/event.py

@@ -0,0 +1,46 @@
+from sqlmodel import select
+from typing import List, Optional
+from kilostar.core.postgres_database.model.workflow 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
+
+    async def upsert_event(self, trace_id: str, event_data_json: str) -> EventRecord:
+        async with self.async_session_maker() as session:
+            statement = select(EventRecord).where(EventRecord.trace_id == trace_id)
+            results = await session.execute(statement)
+            record = results.scalar_one_or_none()
+            if record:
+                record.event_data_json = event_data_json
+            else:
+                record = EventRecord(trace_id=trace_id, event_data_json=event_data_json)
+                session.add(record)
+            await session.commit()
+            await session.refresh(record)
+            return record
+
+    async def get_event(self, trace_id: str) -> Optional[EventRecord]:
+        async with self.async_session_maker() as session:
+            statement = select(EventRecord).where(EventRecord.trace_id == trace_id)
+            results = await session.execute(statement)
+            return results.scalar_one_or_none()
+
+    async def get_all_events(self) -> List[EventRecord]:
+        async with self.async_session_maker() as session:
+            statement = select(EventRecord)
+            results = await session.execute(statement)
+            return results.scalars().all()
+
+    async def delete_event(self, trace_id: str) -> bool:
+        async with self.async_session_maker() as session:
+            statement = select(EventRecord).where(EventRecord.trace_id == trace_id)
+            results = await session.execute(statement)
+            record = results.scalar_one_or_none()
+            if record:
+                await session.delete(record)
+                await session.commit()
+                return True
+            return False

kilostar/core/postgres_database/module/individual.py

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

kilostar/core/postgres_database/module/provider.py

@@ -0,0 +1,87 @@
+#  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.
+
+from typing import List
+
+from kilostar.core.postgres_database.model.provider import Provider
+from sqlmodel import select
+from kilostar.core.postgres_database.database_exception import database_exception
+
+
+class ProviderDatabase:
+    """ProviderDatabase 核心组件类。
+    这是一个模型/服务提供商适配器类，屏蔽了外部不同供应商（如 OpenAI、Anthropic 等）的底层 API 差异。它负责标准化参数组装、网络请求发送、鉴权处理以及响应结构的反序列化。"""
+
+    def __init__(self, async_session_maker):
+        self.async_session_maker = async_session_maker
+
+    @database_exception
+    async def get_provider(self) -> List[Provider]:
+        """检索并获取特定的 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
+            ]
+            return providers
+
+    @database_exception
+    async def add_provider(self, **kwargs) -> None:
+        """创建并持久化新的 provider 实体。
+        接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            provider = Provider(**kwargs)
+            session.add(provider)
+            await session.commit()
+
+    @database_exception
+    async def delete_provider(self, provider_id: str) -> None:
+        """安全地移除或注销 provider。
+        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
+        Args:        provider_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider 实例。
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            provider = await session.get(Provider, provider_id)
+            if provider is not None:
+                session.delete(provider)
+                await session.commit()
+
+    @database_exception
+    async def update_provider(self, provider_id: str, **kwargs) -> Provider:
+        """对现有的 provider 进行状态更新或属性覆盖。
+        基于增量变更原则，合并最新的配置或数据，并触发相关依赖组件的缓存刷新或事件通知。
+        Args:        provider_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 provider 实例。
+        Returns:         (Provider): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            provider = await session.get(Provider, provider_id)
+            if provider is not None:
+                for key, value in kwargs.items():
+                    setattr(provider, key, value)
+                session.add(provider)
+                await session.commit()
+                await session.refresh(provider)
+                return provider
+            return None

kilostar/core/postgres_database/module/system_node.py

@@ -0,0 +1,86 @@
+#  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.
+
+from kilostar.core.postgres_database.model.system_node import SystemNodeConfig
+from sqlmodel import select
+from typing import List, Optional
+from kilostar.core.postgres_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:
+        """执行与 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): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            statement = select(SystemNodeConfig).where(
+                SystemNodeConfig.node_name == node_name
+            )
+            results = await session.execute(statement)
+            config = results.scalar_one_or_none()
+            if config:
+                config.provider_title = provider_title
+                config.model_id = model_id
+                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,
+                )
+            session.add(config)
+            await session.commit()
+            await session.refresh(config)
+            return config
+
+    @database_exception
+    async def get_all_system_node_configs(self) -> List[SystemNodeConfig]:
+        """检索并获取特定的 all system node configs 数据集合或实例对象。
+        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
+        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]:
+        """检索并获取特定的 system node config 数据集合或实例对象。
+        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
+        Args:        node_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
+        Returns:         (Optional[SystemNodeConfig]): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            statement = select(SystemNodeConfig).where(
+                SystemNodeConfig.node_name == node_name
+            )
+            results = await session.execute(statement)
+            return results.scalar_one_or_none()

kilostar/core/postgres_database/module/user.py

@@ -0,0 +1,169 @@
+#  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.
+
+from kilostar.core.postgres_database.model.user import User
+from sqlmodel import select
+from kilostar.utils.error import UserNotExistError, UserPasswordError
+from kilostar.core.postgres_database.database_exception import database_exception
+from kilostar.core.postgres_database.model.user import UserAuthority
+from kilostar.utils.access import Accessor
+
+
+class AuthDatabase:
+    """AuthDatabase 核心组件类。
+    这是一个数据库操作层 (DAO/Repository) 封装类，专注于处理实体模型与关系型数据库表之间的映射。它将复杂的 SQL 查询、跨表 Join 和事务回滚逻辑进行了高级抽象，向上层服务暴露简洁的数据读写接口。"""
+
+    def __init__(self, async_session_maker):
+        self.async_session_maker = async_session_maker
+
+    @database_exception
+    async def add_user(self, user_name: str, hashed_password: str) -> User:
+        """创建并持久化新的 user 实体。
+        接收构建参数，执行必要的数据校验与默认值填充后，将新记录安全地写入底层存储或系统注册表中。
+        Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        hashed_password (str): 控制逻辑流向的具体字符串参数，指定了期望的 hashed password 内容。
+        Returns:         (User): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        from ulid import ULID
+
+        async with self.async_session_maker() as session:
+            # Check if any users exist
+            statement = select(User).limit(1)
+            results = await session.execute(statement)
+            existing_user = results.first()
+
+            authority = UserAuthority.USER
+            if existing_user is None:
+                authority = UserAuthority.SUPER_ADMINISTRATOR
+
+            user = User(
+                user_id=str(ULID()),
+                user_name=user_name,
+                hashed_password=hashed_password,
+                user_authority=authority,
+            )
+            session.add(user)
+            await session.commit()
+            await session.refresh(user)
+            return user
+
+    @database_exception
+    async def change_password(self, user_name, old_password, new_password) -> User:
+        """执行与 change password 相关的核心业务流转操作。
+        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
+        Args:        user_name: 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。        old_password: 参与 change password 逻辑运算或数据构建的上下文依赖对象。        new_password: 参与 change password 逻辑运算或数据构建的上下文依赖对象。
+        Returns:         (User): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            statement = select(User).where(User.user_name == user_name)
+            results = await session.execute(statement)
+            user = results.scalar_one_or_none()
+            if user is None:
+                raise UserNotExistError()
+            if not Accessor.verify_password(old_password, user.hashed_password):
+                raise UserPasswordError()
+            user.hashed_password = new_password
+            session.add(user)
+            await session.commit()
+            await session.refresh(user)
+            return user
+
+    @database_exception
+    async def delete_user(self, user_name: str) -> None:
+        """安全地移除或注销 user。
+        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
+        Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            statement = select(User).where(User.user_name == user_name)
+            results = await session.execute(statement)
+            user = results.scalar_one_or_none()
+            if user is None:
+                raise UserNotExistError()
+            session.delete(user)
+            await session.commit()
+
+    @database_exception
+    async def delete_user_by_id(self, user_id: str) -> None:
+        """安全地移除或注销 user by id。
+        执行物理删除或逻辑删除操作，并妥善清理相关的关联数据及占用资源。
+        Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。
+        Returns:         (None): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            user = await session.get(User, user_id)
+            if user is None:
+                raise UserNotExistError()
+            session.delete(user)
+            await session.commit()
+
+    @database_exception
+    async def login_user(self, user_name: str) -> str:
+        """执行与 login user 相关的核心业务流转操作。
+        该方法封装了具体的算法策略或状态控制逻辑，确保操作能够在事务上下文中被原子且一致地执行。
+        Args:        user_name (str): 赋予该实体的人类可读名称或标题字符串，主要用于前端 UI 展示、日志记录或模糊检索。
+        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)
+            user = results.scalar_one_or_none()
+            if user is None:
+                raise UserNotExistError()
+            return user
+
+    @database_exception
+    async def get_all_users(self) -> list[User]:
+        """检索并获取特定的 all users 数据集合或实例对象。
+        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
+        Returns:         (list[User]): 经过筛选、排序或分页处理后的实体对象列表集合。"""
+        async with self.async_session_maker() as session:
+            statement = select(User)
+            results = await session.execute(statement)
+            users = results.scalars().all()
+            return list(users)
+
+    @database_exception
+    async def get_user_authority(self, user_id: str) -> UserAuthority:
+        """检索并获取特定的 user authority 数据集合或实例对象。
+        根据提供的查询条件或上下文凭证，从数据库、缓存或第三方服务中读取对应的资源状态。
+        Args:        user_id (str): 目标对象的唯一全局标识符 (UUID/ULID)，用于在数据库表或缓存结构中精准匹配该 user 实例。
+        Returns:         (UserAuthority): 经由当前业务模型加工处理后所输出的具体数据实例或领域模型对象。"""
+        async with self.async_session_maker() as session:
+            user = await session.get(User, user_id)
+            if user is None:
+                raise UserNotExistError()
+            return user.user_authority
+
+    @database_exception
+    async def change_user_authority(
+        self, user_id: str, new_authority: UserAuthority
+    ) -> User:
+        """
+        Changes the authority level of a specific user.
+
+        Args:
+            user_id: The ID of the user whose authority is to be changed.
+            new_authority: The new authority level to assign to the user.
+
+        Returns:
+            User: The updated user object.
+
+        Raises:
+            UserNotExistError: If the specified user does not exist.
+        """
+        async with self.async_session_maker() as session:
+            user = await session.get(User, user_id)
+            if user is None:
+                raise UserNotExistError()
+            user.user_authority = new_authority
+            session.add(user)
+            await session.commit()
+            await session.refresh(user)
+            return user

kilostar/core/postgres_database/postgres.py

@@ -0,0 +1,256 @@
+#  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 .module.individual import IndividualDatabase
+from .module.event import EventDatabase
+from .module.user import AuthDatabase
+from .module.provider import ProviderDatabase
+from .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)