AI项目实战（10）多智能体内容创作平台

"""项目七：数据模型层。

定义多智能体内容创作平台的领域模型和数据结构。
"""
from __future__ import annotations

from dataclasses import dataclass, field
from enum import Enum
from typing import Any


class AgentRole(str, Enum):
    """Agent 角色枚举。"""
    PLANNER = "planner"        # 策划师
    WRITER = "writer"          # 撰稿人
    REVIEWER = "reviewer"      # 审稿人
    DESIGNER = "designer"      # 配图设计师
    EDITOR = "editor"          # 主编（总控）


class TaskStatus(str, Enum):
    """任务状态枚举。"""
    PENDING = "pending"
    RUNNING = "running"
    COMPLETED = "completed"
    FAILED = "failed"


@dataclass
class ContentOutline:
    """文章大纲模型。"""
    topic: str
    title: str = ""
    introduction: str = ""
    sections: list[str] = field(default_factory=list)
    conclusion: str = ""

    def to_markdown(self) -> str:
        """转换为 Markdown 格式。"""
        lines = [f"# {self.title or self.topic}", "", "## 导语", self.introduction]
        for i, section in enumerate(self.sections, 1):
            lines.extend(["", f"## 第 {i} 章：{section}"])
        if self.conclusion:
            lines.extend(["", "## 结语", self.conclusion])
        return "\n".join(lines)


@dataclass
class ArticleSection:
    """文章章节模型。"""
    title: str
    content: str
    order: int = 0
    word_count: int = 0

    def __post_init__(self) -> None:
        """计算字数。"""
        self.word_count = len(self.content)


@dataclass
class ImageSuggestion:
    """配图建议模型。"""
    section_title: str
    image_type: str  # 示意图、数据图、场景图、概念图
    prompt: str      # AI 生成提示词（英文）
    description: str = ""  # 中文描述


@dataclass
class ReviewFeedback:
    """审稿反馈模型。"""
    overall_score: int  # 1-10 分
    strengths: list[str] = field(default_factory=list)
    issues: list[str] = field(default_factory=list)
    suggestions: list[str] = field(default_factory=list)


@dataclass
class ContentTask:
    """内容创作任务模型。"""
    task_id: str
    topic: str
    status: TaskStatus = TaskStatus.PENDING
    outline: ContentOutline | None = None
    sections: list[ArticleSection] = field(default_factory=list)
    images: list[ImageSuggestion] = field(default_factory=list)
    review: ReviewFeedback | None = None
    final_article: str = ""

    def add_section(self, title: str, content: str, order: int = 0) -> None:
        """添加章节。"""
        self.sections.append(ArticleSection(
            title=title,
            content=content,
            order=order,
        ))

    def get_total_words(self) -> int:
        """获取总字数。"""
        return sum(s.word_count for s in self.sections)


class SharedMemory:
    """多 Agent 共享记忆池。

    所有 Agent 的输出都存入这里，后续 Agent 可读取。
    """

    def __init__(self) -> None:
        self._store: dict[str, Any] = {}
        self._order: list[str] = []

    def put(self, key: str, content: Any) -> None:
        """存入记忆。

        Args:
            key: 记忆键
            content: 记忆内容
        """
        self._store[key] = content
        if key not in self._order:
            self._order.append(key)

    def get(self, key: str) -> Any:
        """读取记忆。

        Args:
            key: 记忆键

        Returns:
            记忆内容，不存在返回空字符串
        """
        return self._store.get(key, "")

    def keys(self) -> list[str]:
        """获取所有记忆键。"""
        return list(self._order)

    def summary(self) -> str:
        """生成记忆池摘要。

        Returns:
            摘要文本
        """
        lines = ["📦 共享记忆池内容：", ""]
        for k in self._order:
            content = self._store[k]
            preview = str(content)[:80].replace("\n", " ")
            lines.append(f"  [{k}] {preview}...")
        return "\n".join(lines)

    def clear(self) -> None:
        """清空记忆池。"""
        self._store.clear()
        self._order.clear()


# 全局共享记忆实例
shared_memory = SharedMemory()

"""项目七：Prompt 层。

定义多智能体内容创作平台各角色的系统提示词。
"""
from __future__ import annotations

# 主编 Agent 系统提示词
EDITOR_SYSTEM_PROMPT = """你是内容创作平台的主编 Agent，负责协调团队完成高质量文章创作。

## 你的团队
- 👨‍💼 策划师 (plan_content)：生成文章大纲
- ✍️ 撰稿人 (write_section)：撰写各章节内容
- 🔍 审稿人 (review_content)：审查质量并提供反馈
- 🎨 配图设计师 (suggest_images)：提供配图建议

## 工作流程（严格执行）
1. **第一步**：调用 plan_content 生成文章大纲
2. **第二步**：调用 write_section 逐章节撰写（至少写 2-3 个章节）
3. **第三步**：全部写完后调用 review_content 进行审校
4. **第四步**：调用 suggest_images 为文章配图
5. **第五步**：合并所有内容，输出完整文章

## 质量要求
- 文章结构清晰，逻辑连贯
- 语言通俗易懂，适合目标读者
- 每章节 800-1500 字
- 配图建议具体，可用于 AI 生成

## 最终交付格式
```markdown
# 文章标题

## 导语
（导语内容）

## 章节 1
（章节内容）

## 章节 2
（章节内容）

## 结语
（结语内容）

---

## 审校反馈
（审稿意见）

---

## 配图建议
（每张图的建议）
```"""


# 策划师 Agent 提示词
PLANNER_PROMPT = """你是资深内容策划师，擅长设计高质量文章的结构和大纲。

请为主题「{topic}」生成详细的文章大纲。

## 大纲要求
1. 吸引人的标题（结合热点和 SEO）
2. 100-200 字的导语，说明文章价值
3. 3-5 个核心章节，每章标题明确
4. 简短的结语，总结要点并引导行动
5. 明确每个章节的核心观点和写作方向

## 输出格式
```markdown
# 文章标题

## 导语
（导语内容）

## 章节列表
1. 第一章标题 - （本章核心要点）
2. 第二章标题 - （本章核心要点）
3. 第三章标题 - （本章核心要点）

## 结语
（结语方向）
```"""


# 撰稿人 Agent 提示词
WRITER_PROMPT = """你是专业撰稿人，文风通俗生动，擅长把复杂概念讲清楚。

## 文章大纲
{outline}

## 当前任务
请撰写章节「{section_title}」的完整内容。

## 写作要求
1. 800-1500 字
2. 段落分明，每段不超过 5 行
3. 使用生活化案例辅助理解
4. 适当使用列表和加粗强调重点
5. 结尾过渡到下一章或总结本章要点

## 目标读者
互联网行业从业者、产品经理、工程师，具有一定技术背景但非专家。

请直接输出章节内容，不需要解释写作思路。"""


# 审稿人 Agent 提示词
REVIEWER_PROMPT = """你是首席编辑，具有 10 年以上审稿经验。

请审查以下文章内容，给出专业反馈。

## 已完成内容
{all_content}

## 审查维度
1. **逻辑连贯性**：章节之间是否衔接自然？论点是否有足够支撑？
2. **语言表达**：是否有语法错误？语句是否通顺易懂？
3. **内容质量**：是否有遗漏的重要观点？案例是否贴切？
4. **可读性**：段落长度是否合适？重点是否突出？

## 输出格式
```
【整体评分】X/10

【优点】
- （列出 2-3 个优点）

【问题】
- （列出具体问题及位置）

【修改建议】
- （具体可操作的建议）
```"""


# 配图设计师 Agent 提示词
DESIGNER_PROMPT = """你是视觉设计师，擅长为文章设计配图方案。

## 文章大纲
{outline}

## 任务
为每个章节设计 1-2 张配图建议。

## 配图要求
1. 图片类型：示意图、数据图、场景图、概念图四选一
2. AI 生成提示词：英文，简洁准确，包含主体、风格、色调
3. 中文描述：说明图片在文章中的作用和位置

## 输出格式
```
## 第 N 章：章节标题

### 配图 1：[图片类型]
英文 Prompt: (stable diffusion / DALL-E prompt)
说明：（这张图表达什么，放在哪里合适）

### 配图 2：[图片类型]
英文 Prompt: ...
说明：...
```"""


# 内容整合提示词
ASSEMBLE_PROMPT = """请将以下内容整合成一篇完整的文章。

## 大纲
{outline}

## 已完成章节
{sections_text}

## 审校反馈
{review_text}

## 配图建议
{images_text}

要求：
1. 保持 Markdown 格式
2. 标题层级正确
3. 各部分之间有清晰的分隔线
4. 格式美观，便于阅读"""

"""项目七：工具层。

定义多智能体内容创作平台的各角色工具函数。
"""
from __future__ import annotations

from typing import Any

from langchain.tools import tool

from core import build_chat_model
from core.logging_conf import get_logger

from .models import shared_memory
from .prompts import (
    DESIGNER_PROMPT,
    PLANNER_PROMPT,
    REVIEWER_PROMPT,
    WRITER_PROMPT,
)

logger = get_logger("p07.content_creation.tools")


@tool
def plan_content(topic: str) -> str:
    """策划师：根据主题生成内容大纲和结构规划。

    Args:
        topic: 文章主题

    Returns:
        Markdown 格式的大纲（标题 + 导语 + 章节列表 + 结语）
    """
    logger.info("策划师开始工作，主题: %s", topic)

    prompt = PLANNER_PROMPT.format(topic=topic)

    try:
        model = build_chat_model()
        result = model.invoke(prompt)
        outline = result.content if hasattr(result, "content") else str(result)

        shared_memory.put("outline", outline)
        shared_memory.put("topic", topic)

        logger.info("大纲生成完成，长度: %d", len(outline))
        return outline
    except Exception as e:
        logger.error("大纲生成失败: %s", e)
        return f"❌ 大纲生成失败: {e}"


@tool
def write_section(section_title: str) -> str:
    """撰稿人：根据大纲中指定的章节标题，撰写该章节的完整内容。

    会先读取共享记忆中的大纲，确保内容与大纲一致。

    Args:
        section_title: 要撰写的章节标题

    Returns:
        章节内容
    """
    logger.info("撰稿人开始工作，章节: %s", section_title)

    outline = shared_memory.get("outline")
    if not outline:
        return "⚠️ 请先生成文章大纲，再开始写作。"

    prompt = WRITER_PROMPT.format(
        outline=outline,
        section_title=section_title,
    )

    try:
        model = build_chat_model()
        result = model.invoke(prompt)
        content = result.content if hasattr(result, "content") else str(result)

        key = f"section:{section_title}"
        shared_memory.put(key, content)

        logger.info("章节「%s」撰写完成，字数: %d", section_title, len(content))
        return content
    except Exception as e:
        logger.error("章节撰写失败: %s", e)
        return f"❌ 章节撰写失败: {e}"


@tool
def review_content() -> str:
    """审稿人：审查共享记忆中所有已完成内容，检查逻辑、语法、可读性。

    Returns:
        审校意见（问题列表 + 修改建议）
    """
    logger.info("审稿人开始工作")

    all_content = []
    section_count = 0

    for key in shared_memory.keys():
        if key.startswith("section:"):
            content = shared_memory.get(key)
            section_title = key[8:]  # 去掉 "section:" 前缀
            all_content.append(f"--- {section_title} ---\n{content}")
            section_count += 1

    if section_count == 0:
        return "⚠️ 尚无内容可供审校，请先撰写至少一个章节。"

    combined = "\n\n".join(all_content)

    prompt = REVIEWER_PROMPT.format(all_content=combined[:8000])

    try:
        model = build_chat_model()
        result = model.invoke(prompt)
        feedback = result.content if hasattr(result, "content") else str(result)

        shared_memory.put("review_feedback", feedback)

        logger.info("审校完成")
        return feedback
    except Exception as e:
        logger.error("审校失败: %s", e)
        return f"❌ 审校失败: {e}"


@tool
def suggest_images() -> str:
    """配图设计师：根据文章大纲，为每个章节建议配图方案。

    Returns:
        配图建议列表（图片类型 + AI 生成 prompt）
    """
    logger.info("配图设计师开始工作")

    outline = shared_memory.get("outline")
    if not outline:
        return "⚠️ 请先生成文章大纲。"

    prompt = DESIGNER_PROMPT.format(outline=outline[:3000])

    try:
        model = build_chat_model()
        result = model.invoke(prompt)
        images = result.content if hasattr(result, "content") else str(result)

        shared_memory.put("images", images)

        logger.info("配图建议生成完成")
        return images
    except Exception as e:
        logger.error("配图建议生成失败: %s", e)
        return f"❌ 配图建议生成失败: {e}"


@tool
def read_memory(key: str = "") -> str:
    """读取共享记忆池中的内容。

    Args:
        key: 记忆键，留空查看所有可用的记忆键和摘要

    Returns:
        记忆内容或摘要
    """
    if not key:
        return shared_memory.summary()

    content = shared_memory.get(key)
    if not content:
        return f"⚠️ 记忆键 '{key}' 不存在，可用的键有：{', '.join(shared_memory.keys())}"
    return content


@tool
def clear_memory() -> str:
    """清空共享记忆池，用于开始新的创作任务。

    Returns:
        操作结果
    """
    shared_memory.clear()
    logger.info("共享记忆池已清空")
    return "✅ 共享记忆池已清空，可以开始新的创作任务。"


def get_all_tools() -> list[Any]:
    """获取所有可用工具列表。

    Returns:
        工具对象列表
    """
    return [
        plan_content,
        write_section,
        review_content,
        suggest_images,
        read_memory,
        clear_memory,
    ]

"""项目七：Graph 层（Multi-Agent 编排）。

定义多智能体内容创作平台的工作流编排逻辑。
"""
from __future__ import annotations

import asyncio
from typing import Any

from langchain.agents import create_agent

from core import build_chat_model
from core.logging_conf import get_logger

from .models import ContentTask, TaskStatus, shared_memory
from .prompts import EDITOR_SYSTEM_PROMPT
from .tools import get_all_tools, plan_content, read_memory

logger = get_logger("p07.content_creation.graph")


class ContentCreationGraph:
    """内容创作工作流图。

    编排多个 Agent 协作完成文章创作：
    1. 策划 Agent 生成大纲
    2. 写作 Agent 撰写各章节，配图 Agent 生成配图建议（两者只依赖大纲，并行执行）
    3. 审校 Agent 审查正文质量
    4. 整合输出最终文章
    """

    def __init__(self) -> None:
        self._tasks: dict[str, ContentTask] = {}
        self._agent: Any | None = None

    def build_agent(self) -> Any:
        """构建主编 Agent。

        Returns:
            LangChain Agent 对象
        """
        if self._agent is not None:
            return self._agent

        self._agent = create_agent(
            model=build_chat_model(),
            tools=get_all_tools(),
            system_prompt=EDITOR_SYSTEM_PROMPT,
        )
        return self._agent

    def create_task(self, topic: str, task_id: str | None = None) -> ContentTask:
        """创建内容创作任务。

        Args:
            topic: 文章主题
            task_id: 可选任务 ID

        Returns:
            任务对象
        """
        import uuid

        if task_id is None:
            task_id = f"content_{uuid.uuid4().hex[:8]}"

        task = ContentTask(
            task_id=task_id,
            topic=topic,
            status=TaskStatus.PENDING,
        )
        self._tasks[task_id] = task
        logger.info("创建内容创作任务: %s - %s", task_id, topic)
        return task

    async def run_planner_step(self, task: ContentTask) -> bool:
        """运行策划步骤。

        Args:
            task: 任务对象

        Returns:
            是否成功
        """
        try:
            task.status = TaskStatus.RUNNING
            logger.info("[%s] 步骤 1/3: 生成大纲", task.task_id)

            outline_text = plan_content.invoke({"topic": task.topic})

            if "失败" in outline_text or "⚠️" in outline_text:
                logger.error("大纲生成失败: %s", outline_text)
                return False

            logger.info("大纲生成成功，长度: %d", len(outline_text))
            return True
        except Exception as e:
            logger.error("策划步骤异常: %s", e)
            return False

    async def run_writer_step(self, task: ContentTask, section_titles: list[str]) -> bool:
        """运行写作步骤。

        Args:
            task: 任务对象
            section_titles: 章节标题列表

        Returns:
            是否成功
        """
        try:
            logger.info("[%s] 步骤 2/3: 撰写章节", task.task_id)

            from .tools import write_section

            for i, title in enumerate(section_titles, 1):
                logger.info("  撰写第 %d/%d 章: %s", i, len(section_titles), title)
                content = write_section.invoke({"section_title": title})
                if "失败" in content:
                    logger.warning("章节「%s」撰写失败", title)
                    continue
                task.add_section(title, content, order=i)

            logger.info("章节撰写完成，共 %d 章，总字数: %d",
                       len(task.sections), task.get_total_words())
            return len(task.sections) > 0
        except Exception as e:
            logger.error("写作步骤异常: %s", e)
            return False

    async def run_reviewer_step(self, task: ContentTask) -> bool:
        """运行审校步骤。

        Args:
            task: 任务对象

        Returns:
            是否成功
        """
        try:
            logger.info("[%s] 步骤 3/3: 内容审校", task.task_id)

            from .tools import review_content

            feedback = await asyncio.to_thread(review_content.invoke, {})
            if "尚无" in feedback or "失败" in feedback:
                logger.warning("审校未完成: %s", feedback)
                return False

            logger.info("审校完成")
            return True
        except Exception as e:
            logger.error("审校步骤异常: %s", e)
            return False

    async def run_designer_step(self, task: ContentTask) -> bool:
        """运行配图设计步骤。

        Args:
            task: 任务对象

        Returns:
            是否成功
        """
        try:
            logger.info("[%s] 步骤 2/3: 配图设计（与写作并行）", task.task_id)

            from .tools import suggest_images

            # 用 asyncio.to_thread 把同步工具调用扔进线程池，
            # 避免阻塞事件循环，使写作步骤得以与之真正并行
            images = await asyncio.to_thread(suggest_images.invoke, {})
            if "先生成" in images or "失败" in images:
                logger.warning("配图设计未完成: %s", images)
                return False

            logger.info("配图设计完成")
            return True
        except Exception as e:
            logger.error("配图步骤异常: %s", e)
            return False

    def assemble_final_article(self, task: ContentTask) -> str:
        """整合最终文章。

        Args:
            task: 任务对象

        Returns:
            完整文章 Markdown
        """
        memory_summary = read_memory.invoke({"key": ""})

        outline = shared_memory.get("outline")
        review = shared_memory.get("review_feedback", "")
        images = shared_memory.get("images", "")

        sections_text = "\n\n".join([
            f"## {s.title}\n\n{s.content}"
            for s in task.sections
        ])

        final_article = f"""# {task.topic}

---

## 大纲
{outline}

---

## 正文

{sections_text}

---

## 审校反馈
{review or '（暂无）'}

---

## 配图建议
{images or '（暂无）'}
"""
        task.final_article = final_article
        return final_article

    async def run_full_workflow(self, topic: str) -> str:
        """运行完整创作工作流。

        Args:
            topic: 文章主题

        Returns:
            最终文章
        """
        task = self.create_task(topic)

        # 清空之前的记忆
        shared_memory.clear()

        # 步骤 1: 策划
        success = await self.run_planner_step(task)
        if not success:
            return "❌ 大纲生成失败，请重试"

        # 步骤 2: 写作 + 配图 并行
        # 两者都只依赖大纲、彼此无依赖：写作写 section:*，配图写 images，
        # SharedMemory 是普通 dict，写不同键在 GIL 下并发安全。
        agent = self.build_agent()
        await asyncio.gather(
            self._agent_write_sections(agent, task),
            self.run_designer_step(task),
        )

        # 步骤 3: 审校（依赖写作产出的正文，须等写作完成）
        await self.run_reviewer_step(task)

        # 整合输出
        task.status = TaskStatus.COMPLETED
        return self.assemble_final_article(task)

    async def _agent_write_sections(self, agent: Any, task: ContentTask) -> None:
        """让 Agent 自主决定写作哪些章节。

        Args:
            agent: Agent 对象
            task: 任务对象
        """
        prompt = (
            f"文章主题：{task.topic}\n"
            "大纲已生成，请根据大纲撰写 2-3 个核心章节。"
            "写完每个章节后检查是否还需要继续写。"
        )
        try:
            # 交给 Agent 自主控制写作流程
            # 用 asyncio.to_thread 把同步 agent.run 扔进线程池，
            # 避免阻塞事件循环，使配图步骤得以与之真正并行
            result = await asyncio.to_thread(agent.run, prompt)
            logger.info("Agent 自主写作完成")
        except Exception as e:
            logger.error("Agent 自主写作异常: %s", e)


# 全局 Graph 实例
_graph: ContentCreationGraph | None = None


def get_graph() -> ContentCreationGraph:
    """获取内容创作工作流图实例。

    Returns:
        ContentCreationGraph 单例
    """
    global _graph
    if _graph is None:
        _graph = ContentCreationGraph()
    return _graph

"""项目七：项目定义层。

定义多智能体内容创作平台的项目注册和对外接口。
"""
from __future__ import annotations

from typing import Any

from core import BaseProject, registry

from .graph import get_graph
from .tools import get_all_tools


class ContentCreationProject(BaseProject):
    """多智能体内容创作平台。

    主讲能力：Multi-Agent 编排 + 共享记忆系统

    业务场景：用户给一个主题，多个 Agent 分工协作完成一篇高质量文章：
    策划 Agent →（写作 Agent ‖ 配图 Agent）→ 审校 Agent

    生产级特性：
    - 主管-子智能体编排（Orchestrator Pattern）
    - 共享记忆池（各 Agent 输出存入共享上下文，下个 Agent 可见）
    - 子 Agent 独立 System Prompt（角色专精，互不干扰）
    - 并行执行（写作和配图用 asyncio.gather 同时进行）
    - 结构化输出（最终文章为 Markdown 格式）
    """

    id = "p07_content_creation"
    name = "多智能体内容创作平台"
    description = "策划+写作+审校+配图，四 Agent 分工协作，共享记忆。"
    capabilities = ["Multi-Agent", "Shared Memory", "Content Creation"]

    def build_agent(self) -> Any:
        """构建主编 Agent 实例。

        Returns:
            LangChain Agent 对象
        """
        graph = get_graph()
        return graph.build_agent()

    def run(self, message: str) -> str:
        """运行内容创作任务。

        Args:
            message: 用户输入的文章主题或创作需求

        Returns:
            创作结果
        """
        import asyncio

        graph = get_graph()

        try:
            # 尝试运行完整工作流
            loop = asyncio.get_event_loop_policy().get_event_loop()
            if loop.is_running():
                # 如果已有事件循环（如在服务中），使用 Agent 直接运行
                agent = self.build_agent()
                return agent.run(message)
            else:
                # 否则异步运行完整工作流
                return asyncio.run(graph.run_full_workflow(message))
        except Exception as e:
            # 降级方案：直接用 Agent 运行
            agent = self.build_agent()
            return agent.run(message)


# 项目实例
project = ContentCreationProject()

# 对外暴露的快捷函数
run = project.run
build_agent = project.build_agent
get_tools = get_all_tools

__all__ = [
    "ContentCreationProject",
    "project",
    "run",
    "build_agent",
    "get_tools",
]

"""项目七：多智能体内容创作平台（Multi-Agent + 共享记忆）

主讲能力：Multi-Agent 编排 + 共享记忆系统

业务场景：用户给一个主题，多个 Agent 分工协作完成一篇高质量文章：
策划 Agent →（写作 Agent ‖ 配图 Agent）→ 审校 Agent

生产级特性：
- 主管-子智能体编排（Orchestrator Pattern）
- 共享记忆池（各 Agent 输出存入共享上下文，下个 Agent 可见）
- 子 Agent 独立 System Prompt（角色专精，互不干扰）
- 并行执行（写作和配图用 asyncio.gather 同时进行）
- 结构化输出（最终文章为 Markdown 格式）

架构分层：
- models.py: 数据模型、共享记忆池
- prompts.py: 各角色系统提示词
- tools.py: 各 Agent 工具函数
- graph.py: Multi-Agent 工作流编排
- project.py: 项目定义、对外接口
"""
from __future__ import annotations

from core import registry

# 导出 models 层
from .models import (
    AgentRole,
    ArticleSection,
    ContentOutline,
    ContentTask,
    ImageSuggestion,
    ReviewFeedback,
    SharedMemory,
    shared_memory,
    TaskStatus,
)

# 导出 prompts 层
from .prompts import (
    ASSEMBLE_PROMPT,
    DESIGNER_PROMPT,
    EDITOR_SYSTEM_PROMPT,
    PLANNER_PROMPT,
    REVIEWER_PROMPT,
    WRITER_PROMPT,
)

# 导出 tools 层（保持向后兼容）
from .tools import (
    clear_memory,
    get_all_tools,
    plan_content,
    read_memory,
    review_content,
    suggest_images,
    write_section,
)

# 导出 graph 层
from .graph import ContentCreationGraph, get_graph

# 导出 project 层
from .project import (
    ContentCreationProject,
    build_agent,
    get_tools,
    project,
    run,
)

# 向后兼容别名：原单文件版本使用 SYSTEM_PROMPT
SYSTEM_PROMPT = EDITOR_SYSTEM_PROMPT

# 注册项目到全局注册表
registry.register(project)

__all__ = [
    # models
    "AgentRole",
    "TaskStatus",
    "ContentOutline",
    "ArticleSection",
    "ImageSuggestion",
    "ReviewFeedback",
    "ContentTask",
    "SharedMemory",
    "shared_memory",
    # prompts
    "EDITOR_SYSTEM_PROMPT",
    "SYSTEM_PROMPT",
    "PLANNER_PROMPT",
    "WRITER_PROMPT",
    "REVIEWER_PROMPT",
    "DESIGNER_PROMPT",
    "ASSEMBLE_PROMPT",
    # tools
    "plan_content",
    "write_section",
    "review_content",
    "suggest_images",
    "read_memory",
    "clear_memory",
    "get_all_tools",
    # graph
    "ContentCreationGraph",
    "get_graph",
    # project
    "ContentCreationProject",
    "project",
    "run",
    "build_agent",
    "get_tools",
]