"""知识需求生成Agent

KnowledgeRequirementGenerationAgent - 根据输入生成知识需求文档并获取对应知识

功能:
- 分析PRD文档、小红书帖子、解构上下文等输入
- 生成结构化的知识需求清单
- 调用知识检索工具获取每项需求对应的知识
- 输出markdown格式的知识需求文档

实现方式: Agent组件（需要LLM推理、语义分析、动态决策）
依据: What解构业务需要动态获取知识来指导解构过程
"""

from typing import Dict, Any, List, Optional
from pydantic import BaseModel, Field
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.language_models import BaseChatModel

from src.utils.logger import get_logger

logger = get_logger(__name__)


class KnowledgeRequirementInput(BaseModel):
    """知识需求生成Agent输入Schema"""

    prd_content: Optional[str] = Field(
        default=None,
        description="PRD文档内容，用于理解业务需求和解构目标"
    )

    post_content: Optional[Dict[str, Any]] = Field(
        default=None,
        description="小红书帖子内容，包含images、text、comments等"
    )

    deconstruction_context: Optional[Dict[str, Any]] = Field(
        default=None,
        description="解构过程中产生的上下文信息，如品类、主题、关键词、消费者亮点等"
    )

    current_element: Optional[Dict[str, Any]] = Field(
        default=None,
        description="当前正在解构的元素信息，包含what字段值、描述维度等"
    )

    knowledge_scope: Optional[List[str]] = Field(
        default=None,
        description="需要获取的知识范围，如['描述维度', '拆分判断', '工具推荐']"
    )

    task_stage: Optional[str] = Field(
        default=None,
        description="当前执行的任务阶段，例如：'帖子整体解构'、'图片元素解构'、'文本元素解构'等"
    )


class KnowledgeRequirementOutput(BaseModel):
    """知识需求生成Agent输出Schema"""

    markdown_document: str = Field(
        description="Markdown格式的知识需求文档（包含完整的需求清单和上下文信息）"
    )

    summary: str = Field(
        description="知识需求的简要总结"
    )


class KnowledgeRequirementGenerationAgent:
    """知识需求生成Agent

    根据多种输入源生成知识需求文档（不再调用知识检索工具）

    使用场景:
    1. What解构开始前：基于PRD和帖子内容生成初始知识需求
    2. 解构过程中：基于当前元素生成动态知识需求
    3. 解构特定节点：生成针对性的描述维度、拆分判断知识需求
    """

    def __init__(
        self,
        llm: BaseChatModel,
        knowledge_tool: Optional[Any] = None,  # 保留参数以兼容旧代码
        enable_retrieval: bool = False  # 默认不启用知识检索
    ):
        """初始化知识需求生成Agent

        Args:
            llm: 语言模型实例
            knowledge_tool: 知识检索工具实例（已废弃，保留以兼容）
            enable_retrieval: 是否启用知识检索（已废弃）
        """
        self.llm = llm
        self.enable_retrieval = False  # 强制禁用知识检索

        # 构建Prompt模板
        self._build_prompts()

    def _build_prompts(self):
        """构建Prompt模板"""

        # 知识需求分析Prompt（生成新的输出格式）
        self.requirement_analysis_prompt = ChatPromptTemplate.from_messages([
            ("system", """你是一个专业的知识需求分析专家，负责分析What解构任务并生成结构化的知识需求文档。

## 核心任务

根据输入的PRD文档、小红书帖子内容、解构上下文、当前任务阶段等信息，生成一份结构化的知识需求文档。

## 知识需求分类（PRD 3.3.2节）

知识需求分为两类：
1. **内容知识**：如何进行what解构的方法、标准、维度等
2. **工具知识**：解构过程需要用到什么工具

## 输出格式要求

严格按照以下Markdown格式输出：

# 整体项目目标
[从PRD文档中提取的核心目标，如果没有PRD则根据业务背景推断]

# 本次任务目标
[根据当前执行的阶段（task_stage）和待解构元素，明确本次任务的具体目标。例如：
- 帖子整体解构：确定帖子的描述维度（品类、主题、脚本等）
- 图片元素解构：确定图片拆解的维度、方法、是否继续分割的判断标准
- 文本元素解构：确定文本拆解的维度、方法等]

# 上下文
[当前运行时信息，包括品类、主题、关键词、消费者亮点等一切有助于理解并找到有帮助的知识的信息]

# 待解构帖子信息
[帖子的完整内容，包括：
- 标题：完整标题
- 正文：完整正文内容（不截断）
- 话题标签：所有话题标签
- 图片：列出所有图片（图片1、图片2...）]

# 需求
## 内容知识需求
### 需求约束
[列出内容知识需求的约束条件，例如：
- 必须基于小红书平台特点
- 必须从消费者视角出发
- 必须符合当前品类和主题]

### 需求描述
[具体描述需要什么内容知识，每项需求单独一行，格式为：
- 需求1：具体描述（包含完整上下文：品类、主题、元素类型等）
- 需求2：具体描述
- ...]

## 工具知识需求
### 需求约束
[列出工具知识需求的约束条件，例如：
- 工具必须支持多模态内容处理
- 工具必须能够进行精确分割
- 工具必须适用于当前场景]

### 需求描述
[具体描述需要什么工具知识，参考PRD 3.3.2节的Query句式，每项需求单独一行，格式为：
- 需求1：具体描述（例如：对一张"XXX图片描述"的图片，需要使用什么图片分割/抠图工具？）
- 需求2：具体描述
- ...]

## 重要原则

1. **项目目标提取**：从PRD中准确提取整体项目目标
2. **任务目标明确**：根据task_stage明确本次任务的具体目标
3. **上下文完整**：包含品类、主题、关键词、消费者亮点等所有关键信息
4. **帖子信息完整**：在"待解构帖子信息"部分，必须输出输入中提供的完整帖子内容，包括：
   - 完整的标题
   - 完整的正文（不截断、不省略）
   - 所有话题标签
   - 所有图片列表
5. **需求具体化**：每项知识需求必须包含完整的上下文信息（品类、主题、元素类型等）
6. **避免抽象**：使用具体的品类、主题、元素名称，不要用"XXX类内容"这样的占位符
7. **工具Query规范**：工具知识需求应遵循PRD 3.3.2节定义的Query句式

## 内容知识 vs 工具知识示例

**内容知识示例**：
- "美食品类中关于'食物双标'主题的小红书帖子的描述维度框架（品类、主题、脚本、内容亮点、情绪共鸣点等）"
- "幽默搞笑类图片中对比手法和表情包风格的识别方法和标准"
- "图片元素是否继续分割的判断标准和停止条件"

**工具知识示例**（参考PRD 3.3.2节）：
- "对一张描述为'年轻人对食物的双标表现对比图'的图片，从内容创作者视角进行视觉元素分割，需要使用哪些图片分割/抠图工具？"
- "对一段描述为'食物双标主题的幽默文案'的文本段落，从内容创作者视角进行结构化分割拆解，需要使用什么文本切分工具或文本结构化大模型？"
"""),
            ("user", """{input_description}

请严格按照上述格式生成知识需求文档。直接输出Markdown文本，不要添加代码块标记。
""")
        ])

    def generate_requirements(
        self,
        input_data: KnowledgeRequirementInput
    ) -> KnowledgeRequirementOutput:
        """生成知识需求Markdown文档

        Args:
            input_data: 输入数据

        Returns:
            知识需求输出，包含Markdown文档和总结
        """
        logger.info("开始生成知识需求清单")

        # Step 1: 构建输入描述
        input_description = self._build_input_description(input_data)

        # Step 2: 调用LLM生成Markdown格式的知识需求文档
        markdown_doc = self._generate_requirement_list(input_description)

        # Step 3: 生成总结
        summary = self._generate_summary_from_markdown(markdown_doc)

        logger.info(f"知识需求生成完成，文档长度: {len(markdown_doc)} 字符")

        return KnowledgeRequirementOutput(
            markdown_document=markdown_doc,
            summary=summary
        )

    def _build_input_description(self, input_data: KnowledgeRequirementInput) -> str:
        """构建输入描述文本

        Args:
            input_data: 输入数据

        Returns:
            格式化的输入描述
        """
        sections = []

        # PRD内容
        if input_data.prd_content:
            sections.append(f"## PRD文档内容\n{input_data.prd_content}")

        # 当前任务阶段
        if input_data.task_stage:
            sections.append(f"## 当前任务阶段\n{input_data.task_stage}")

        # 解构上下文
        if input_data.deconstruction_context:
            ctx = input_data.deconstruction_context
            ctx_desc = []

            if ctx.get("category"):
                ctx_desc.append(f"品类: {ctx['category']}")
            if ctx.get("theme"):
                ctx_desc.append(f"主题: {ctx['theme']}")
            if ctx.get("keywords"):
                ctx_desc.append(f"关键词: {ctx['keywords']}")
            if ctx.get("consumer_highlights"):
                ctx_desc.append(f"消费者亮点: {ctx['consumer_highlights']}")

            if ctx_desc:
                sections.append(f"## 解构上下文\n" + "\n".join(ctx_desc))

        # 帖子内容（完整详细版本）
        if input_data.post_content:
            post_desc = []
            post_desc.append("## 完整帖子内容")
            post_desc.append("")

            # 文本内容（完整）
            if input_data.post_content.get("text"):
                text_data = input_data.post_content["text"]
                post_desc.append("### 文本内容")
                if text_data.get('title'):
                    post_desc.append(f"**标题**: {text_data['title']}")
                if text_data.get('body'):
                    # 不截断正文，显示完整内容
                    post_desc.append(f"**正文**: {text_data['body']}")
                if text_data.get('hashtags'):
                    post_desc.append(f"**话题标签**: {text_data['hashtags']}")
                post_desc.append("")

            # 图片内容（列出所有图片URL）
            if input_data.post_content.get("images"):
                images = input_data.post_content["images"]
                post_desc.append("### 图片内容")
                post_desc.append(f"**图片数量**: {len(images)}张")
                post_desc.append("**图片列表**:")
                for i, img in enumerate(images, 1):
                    if isinstance(img, str):
                        post_desc.append(f"  - 图片{i}: {img}")
                    elif isinstance(img, dict) and img.get('url'):
                        post_desc.append(f"  - 图片{i}: {img['url']}")
                post_desc.append("")

            # 评论内容已移除 - 不在知识需求文档中包含评论信息

            sections.append("\n".join(post_desc))

        # 当前元素
        if input_data.current_element:
            elem = input_data.current_element
            elem_desc = []

            if elem.get("what"):
                elem_desc.append(f"元素What值: {elem['what']}")
            if elem.get("element_type"):
                elem_desc.append(f"元素类型: {elem['element_type']}")
            if elem.get("depth"):
                elem_desc.append(f"当前深度: {elem['depth']}")

            if elem_desc:
                sections.append(f"## 当前解构元素\n" + "\n".join(elem_desc))

        # 知识范围
        if input_data.knowledge_scope:
            sections.append(f"## 需要的知识范围\n" + "\n".join([f"- {scope}" for scope in input_data.knowledge_scope]))

        return "\n\n".join(sections)

    def _generate_requirement_list(self, input_description: str) -> str:
        """调用LLM生成Markdown格式的知识需求文档

        Args:
            input_description: 输入描述

        Returns:
            Markdown格式的知识需求文档
        """
        try:
            # 调用LLM
            messages = self.requirement_analysis_prompt.format_messages(
                input_description=input_description
            )
            response = self.llm.invoke(messages)

            # 直接返回Markdown内容
            markdown_content = response.content

            # 清理可能的代码块标记
            if "```markdown" in markdown_content:
                markdown_content = markdown_content.split("```markdown")[1].split("```")[0].strip()
            elif markdown_content.startswith("```") and markdown_content.endswith("```"):
                # 移除开头和结尾的代码块标记
                lines = markdown_content.split("\n")
                if lines[0].startswith("```"):
                    lines = lines[1:]
                if lines and lines[-1].strip() == "```":
                    lines = lines[:-1]
                markdown_content = "\n".join(lines)

            logger.info(f"LLM生成了Markdown格式的知识需求文档，长度: {len(markdown_content)} 字符")
            return markdown_content

        except Exception as e:
            logger.error(f"生成知识需求文档失败: {e}", exc_info=True)
            # 返回默认的Markdown文档
            return self._get_default_markdown_requirements()

    def _get_default_markdown_requirements(self) -> str:
        """获取默认Markdown格式的知识需求（LLM失败时的备用方案）

        Returns:
            默认的Markdown格式知识需求文档
        """
        logger.warning("使用默认知识需求文档")

        return """## 知识需求清单

### 高优先级需求

#### 需求1：指导整体解构流程和各环节的执行

**知识需求描述**：
小红书多模态内容的What解构方法论和标准流程

**知识类别**：方法论

**需求原因**：
需要了解整体解构方法论作为指导框架

**应用场景**：
指导整体解构流程和各环节的执行

**上下文信息**：
- 适用范围：所有小红书多模态内容
- 解构层级：全流程

---

#### 需求2：判断图片元素是否继续分割拆解

**知识需求描述**：
图片元素分割的判断标准和停止条件

**知识类别**：标准规范

**需求原因**：
图片解构中需要明确的决策标准

**应用场景**：
判断图片元素是否继续分割拆解

**上下文信息**：
- 适用对象：图片类元素
- 决策节点：递归解构过程中

---

### 中优先级需求

#### 需求3：为各类元素确定描述维度和分类标准

**知识需求描述**：
多模态内容的描述维度框架和要素分类方法

**知识类别**：方法论

**需求原因**：
需要统一的描述框架来组织解构结果

**应用场景**：
为各类元素确定描述维度和分类标准

**上下文信息**：
- 适用范围：所有多模态元素
- 输出目标：结构化的描述框架

---
"""

    def _add_input_overview(self, markdown_doc: str, input_data: KnowledgeRequirementInput) -> str:
        """在Markdown文档开头添加输入概览

        Args:
            markdown_doc: Markdown文档内容
            input_data: 输入数据

        Returns:
            添加了概览的完整Markdown文档
        """
        lines = []

        # 文档标题和时间
        lines.append("# What解构知识需求文档")
        lines.append("")
        lines.append(f"**生成时间**: {self._get_current_time()}")
        lines.append("")

        # 输入概览 - 只显示关键的解构上下文信息
        lines.append("## 输入概览")
        lines.append("")

        # 优先显示解构上下文（最核心的上下文信息）
        has_context = False
        if input_data.deconstruction_context:
            ctx = input_data.deconstruction_context
            if ctx.get("category") or ctx.get("theme"):
                has_context = True
                if ctx.get("category"):
                    lines.append(f"- **品类**: {ctx['category']}")
                if ctx.get("theme"):
                    lines.append(f"- **主题**: {ctx['theme']}")

        # 显示帖子标题（提供内容概览）
        if input_data.post_content:
            post = input_data.post_content
            if post.get("text", {}).get("title"):
                has_context = True
                lines.append(f"- **帖子标题**: {post['text']['title']}")
            if post.get("images"):
                has_context = True
                lines.append(f"- **图片数量**: {len(post['images'])}张")

        # 如果没有任何上下文，显示提示信息
        if not has_context:
            lines.append("_无特定上下文信息_")

        lines.append("")
        lines.append("---")
        lines.append("")

        # 拼接原始markdown文档
        overview = "\n".join(lines)
        return overview + markdown_doc

    def _generate_summary_from_markdown(self, markdown_doc: str) -> str:
        """从Markdown文档中生成总结

        Args:
            markdown_doc: Markdown文档内容

        Returns:
            总结文本
        """
        # 统计内容知识需求数量（通过计算"## 内容知识需求"下"### 需求描述"中的"-"数量）
        content_knowledge_count = 0
        tool_knowledge_count = 0

        # 简单统计：查找"内容知识需求"和"工具知识需求"部分
        if "## 内容知识需求" in markdown_doc:
            content_section = markdown_doc.split("## 内容知识需求")[1]
            if "## 工具知识需求" in content_section:
                content_section = content_section.split("## 工具知识需求")[0]
            # 统计需求描述部分的"-"开头的行数
            if "### 需求描述" in content_section:
                desc_section = content_section.split("### 需求描述")[1]
                content_knowledge_count = len([line for line in desc_section.split('\n') if line.strip().startswith('-')])

        if "## 工具知识需求" in markdown_doc:
            tool_section = markdown_doc.split("## 工具知识需求")[1]
            # 统计需求描述部分的"-"开头的行数
            if "### 需求描述" in tool_section:
                desc_section = tool_section.split("### 需求描述")[1]
                tool_knowledge_count = len([line for line in desc_section.split('\n') if line.strip().startswith('-')])

        total_count = content_knowledge_count + tool_knowledge_count

        summary = f"生成了{total_count}项知识需求"
        if content_knowledge_count > 0:
            summary += f"，其中{content_knowledge_count}项内容知识需求"
        if tool_knowledge_count > 0:
            summary += f"，{tool_knowledge_count}项工具知识需求"
        summary += "。"

        return summary

    def _retrieve_all_knowledge(self, requirements: List[Dict[str, Any]]) -> Dict[str, Any]:
        """不再调用知识检索工具（已废弃）

        Args:
            requirements: 知识需求清单

        Returns:
            空字典
        """
        logger.info("知识检索功能已禁用，使用大模型内置知识")
        return {}

    def _convert_requirement_to_query(self, requirement: str, knowledge_category: str) -> str:
        """不再使用（已废弃）

        Args:
            requirement: 知识需求描述
            knowledge_category: 知识类别

        Returns:
            原始需求文本
        """
        return requirement

    def _map_category_to_type(self, knowledge_category: str) -> str:
        """不再使用（已废弃）

        Args:
            knowledge_category: 知识类别

        Returns:
            默认类型
        """
        return "general"

    def _generate_markdown_document(
        self,
        requirements: List[Dict[str, Any]],
        retrieved_knowledge: Dict[str, Any],
        input_data: KnowledgeRequirementInput
    ) -> str:
        """生成Markdown格式的知识需求文档

        Args:
            requirements: 知识需求清单
            retrieved_knowledge: 检索到的知识
            input_data: 输入数据

        Returns:
            Markdown文档字符串
        """
        lines = []

        # 文档标题
        lines.append("# What解构知识需求文档")
        lines.append("")
        lines.append(f"生成时间: {self._get_current_time()}")
        lines.append("")

        # 输入概览
        lines.append("## 输入概览")
        lines.append("")

        if input_data.deconstruction_context:
            ctx = input_data.deconstruction_context
            if ctx.get("category"):
                lines.append(f"- **品类**: {ctx['category']}")
            if ctx.get("theme"):
                lines.append(f"- **主题**: {ctx['theme']}")
            if ctx.get("keywords"):
                lines.append(f"- **关键词**: {', '.join(ctx['keywords']) if isinstance(ctx['keywords'], list) else ctx['keywords']}")

        if input_data.post_content:
            post = input_data.post_content
            if post.get("text", {}).get("title"):
                lines.append(f"- **帖子标题**: {post['text']['title']}")
            if post.get("images"):
                lines.append(f"- **图片数量**: {len(post['images'])}张")

        lines.append("")

        # 知识需求清单
        lines.append("## 知识需求清单")
        lines.append("")
        lines.append(f"共识别 **{len(requirements)}** 项知识需求")
        lines.append("")

        # 按优先级分组
        high_priority = [r for r in requirements if r.get("priority") == "高"]
        medium_priority = [r for r in requirements if r.get("priority") == "中"]
        low_priority = [r for r in requirements if r.get("priority") == "低"]

        if high_priority:
            lines.append("### 高优先级需求")
            lines.append("")
            for req in high_priority:
                lines.extend(self._format_requirement(req, retrieved_knowledge))

        if medium_priority:
            lines.append("### 中优先级需求")
            lines.append("")
            for req in medium_priority:
                lines.extend(self._format_requirement(req, retrieved_knowledge))

        if low_priority:
            lines.append("### 低优先级需求")
            lines.append("")
            for req in low_priority:
                lines.extend(self._format_requirement(req, retrieved_knowledge))

        # 知识检索统计
        lines.append("## 知识检索统计")
        lines.append("")

        total_reqs = len(requirements)
        successful_reqs = len([k for k, v in retrieved_knowledge.items() if v.get("results_count", 0) > 0])
        avg_confidence = sum([v.get("confidence", 0) for v in retrieved_knowledge.values()]) / len(retrieved_knowledge) if retrieved_knowledge else 0

        lines.append(f"- **总需求数**: {total_reqs}")
        lines.append(f"- **成功检索**: {successful_reqs}/{total_reqs}")
        lines.append(f"- **平均置信度**: {avg_confidence:.4f}")
        lines.append("")

        # 附录：完整知识内容
        lines.append("## 附录：完整知识内容")
        lines.append("")

        for req in requirements:
            req_id = req.get("id", "unknown")
            if req_id in retrieved_knowledge:
                knowledge = retrieved_knowledge[req_id]
                lines.append(f"### [{req_id}] {req.get('application', 'N/A')}")
                lines.append("")
                lines.append("**知识需求**:")
                lines.append(f"> {req.get('requirement', 'N/A')}")
                lines.append("")
                lines.append("**知识类别**:")
                lines.append(f"> {req.get('knowledge_category', 'N/A')}")
                lines.append("")
                lines.append("**知识内容**:")
                lines.append("")
                lines.append("```")
                lines.append(knowledge.get("knowledge", "暂无知识"))
                lines.append("```")
                lines.append("")

                if knowledge.get("sources"):
                    lines.append(f"**来源**: {', '.join(knowledge['sources'])}")
                    lines.append("")

                lines.append(f"**置信度**: {knowledge.get('confidence', 0):.4f}")
                lines.append("")
                lines.append("---")
                lines.append("")

        return "\n".join(lines)

    def _format_requirement(
        self,
        req: Dict[str, Any],
        retrieved_knowledge: Dict[str, Any]
    ) -> List[str]:
        """格式化单个需求为Markdown

        Args:
            req: 需求项
            retrieved_knowledge: 检索到的知识

        Returns:
            Markdown行列表
        """
        lines = []

        req_id = req.get("id", "unknown")

        lines.append(f"#### {req_id}: {req.get('application', 'N/A')}")
        lines.append("")
        lines.append(f"- **知识需求**: {req.get('requirement', 'N/A')}")
        lines.append(f"- **知识类别**: {req.get('knowledge_category', 'N/A')}")
        lines.append(f"- **需求原因**: {req.get('reason', 'N/A')}")

        # 检索结果摘要
        if req_id in retrieved_knowledge:
            knowledge = retrieved_knowledge[req_id]
            lines.append(f"- **检索状态**: ✅ 成功 (置信度: {knowledge.get('confidence', 0):.4f})")
            lines.append(f"- **结果数量**: {knowledge.get('results_count', 0)}条")

            # 显示知识摘要（前200字符）
            knowledge_text = knowledge.get("knowledge", "")
            if knowledge_text:
                summary = knowledge_text
                lines.append(f"- **知识摘要**: {summary}")
        else:
            lines.append("- **检索状态**: ❌ 未检索")

        lines.append("")

        return lines

    def _generate_summary(
        self,
        requirements: List[Dict[str, Any]],
        retrieved_knowledge: Dict[str, Any]
    ) -> str:
        """生成知识需求总结

        Args:
            requirements: 知识需求清单
            retrieved_knowledge: 检索到的知识

        Returns:
            总结文本
        """
        total_reqs = len(requirements)
        high_priority_count = len([r for r in requirements if r.get("priority") == "高"])
        successful_count = len([k for k, v in retrieved_knowledge.items() if v.get("results_count", 0) > 0])

        summary = f"生成了{total_reqs}项知识需求，其中{high_priority_count}项为高优先级。"

        if retrieved_knowledge:
            summary += f"成功检索{successful_count}/{total_reqs}项。"

        return summary

    def _get_current_time(self) -> str:
        """获取当前时间字符串"""
        from datetime import datetime
        return datetime.now().strftime("%Y-%m-%d %H:%M:%S")


# 便捷函数：快速生成知识需求文档
def generate_knowledge_requirements(
    llm: BaseChatModel,
    prd_content: Optional[str] = None,
    post_content: Optional[Dict[str, Any]] = None,
    deconstruction_context: Optional[Dict[str, Any]] = None,
    current_element: Optional[Dict[str, Any]] = None,
    knowledge_scope: Optional[List[str]] = None,
    task_stage: Optional[str] = None,
    knowledge_tool: Optional[Any] = None,  # 保留参数以兼容
    enable_retrieval: bool = False  # 默认不启用
) -> KnowledgeRequirementOutput:
    """快速生成知识需求文档的便捷函数

    Args:
        llm: 语言模型实例
        prd_content: PRD文档内容
        post_content: 小红书帖子内容
        deconstruction_context: 解构上下文
        current_element: 当前元素
        knowledge_scope: 知识范围
        task_stage: 当前任务阶段
        knowledge_tool: 知识检索工具（已废弃）
        enable_retrieval: 是否启用知识检索（已废弃）

    Returns:
        知识需求输出
    """
    agent = KnowledgeRequirementGenerationAgent(
        llm=llm,
        knowledge_tool=knowledge_tool,
        enable_retrieval=False  # 强制禁用
    )

    input_data = KnowledgeRequirementInput(
        prd_content=prd_content,
        post_content=post_content,
        deconstruction_context=deconstruction_context,
        current_element=current_element,
        knowledge_scope=knowledge_scope,
        task_stage=task_stage
    )

    return agent.generate_requirements(input_data)
