class ReflectiveMemory:
    """反思记忆系统"""
    
    def reflect_on_decision(self, decision, outcome):
        """
        元认知监控：反思决策过程
        """
        reflection = {
            # 元认知知识
            "self_knowledge": self.extract_self_knowledge(decision),
            "task_knowledge": self.extract_task_knowledge(decision),
            "strategy_knowledge": self.extract_strategy_knowledge(decision),
            
            # 元认知监控
            "evaluation": self.evaluate_outcome(outcome),
            "error_detection": self.detect_errors(decision, outcome),
            "strategy_adjustment": self.suggest_adjustments(decision, outcome)
        }
        
        return reflection

class SimpleReflectiveMemory:
    """单层反思记忆"""
    
    def __init__(self):
        self.reflections = []  # 反思条目列表
    
    def reflect(self, episode):
        """
        对单个经历进行反思
        """
        prompt = f"""
        分析以下经历，提取反思洞察:
        
        经历: {episode.content}
        上下文: {episode.context}
        结果: {episode.outcome}
        
        请输出:
        1. 核心洞察 (Key Insight)
        2. 可推广的模式 (Generalizable Pattern)
        3. 改进建议 (Improvement Suggestion)
        """
        
        reflection = llm.generate(prompt)
        self.reflections.append(reflection)
        return reflection

class HierarchicalReflectiveMemory:
    """分层反思记忆系统"""
    
    def __init__(self):
        self.immediate_reflections = []    # 即时反思 (最近 10 条)
        self.periodic_reflections = []     # 周期反思 (最近 100 条)
        self.deep_reflections = {}         # 深度反思 (持久化)
    
    def immediate_reflect(self, interaction):
        """
        Layer 1: 即时反思
        每次交互后触发
        """
        prompt = f"""
        快速评估这次交互:
        
        用户输入: {interaction.user_input}
        我的回复: {interaction.my_response}
        用户反馈: {interaction.user_feedback}
        
        输出:
        - 回复质量评分 (1-10)
        - 主要问题
        - 立即改进点
        """
        
        reflection = llm.generate(prompt)
        self.immediate_reflections.append(reflection)
        
        # 触发周期反思检查
        if len(self.immediate_reflections) >= 10:
            self.periodic_reflect()
    
    def periodic_reflect(self):
        """
        Layer 2: 周期反思
        分析最近的即时反思，提取模式
        """
        recent = self.immediate_reflections[-10:]
        
        prompt = f"""
        分析最近 10 次交互的反思:
        
        {format_reflections(recent)}
        
        请提取:
        1. 重复出现的问题模式
        2. 成功的策略
        3. 需要长期改进的方面
        """
        
        reflection = llm.generate(prompt)
        self.periodic_reflections.append(reflection)
        
        # 触发深度反思检查
        if len(self.periodic_reflections) >= 10:
            self.deep_reflect()
    
    def deep_reflect(self):
        """
        Layer 3: 深度反思
        长期模式分析和价值观检验
        """
        recent = self.periodic_reflections[-10:]
        
        prompt = f"""
        基于最近的周期反思，进行深度分析:
        
        {format_reflections(recent)}
        
        请思考:
        1. 我的核心优势和劣势是什么？
        2. 我的行为是否符合我的价值观？
        3. 我需要改变哪些根本性的策略？
        4. 我的长远改进方向是什么？
        """
        
        reflection = llm.generate(prompt)
        
        # 持久化存储
        key = generate_key(reflection)
        self.deep_reflections[key] = {
            "content": reflection,
            "timestamp": datetime.now(),
            "based_on": len(recent)
        }

class GraphReflectiveMemory:
    """基于图的反思记忆系统"""
    
    def __init__(self):
        self.graph = Neo4jGraph()  # 或其他图数据库
    
    def add_reflection(self, episode, reflection):
        """
        添加反思到图谱
        """
        # 1. 创建经历节点
        episode_node = self.graph.create_node(
            label="Episode",
            properties={
                "content": episode.content,
                "timestamp": episode.timestamp,
                "outcome": episode.outcome
            }
        )
        
        # 2. 创建洞察节点
        insight_node = self.graph.create_node(
            label="Insight",
            properties={
                "content": reflection.insight,
                "confidence": reflection.confidence,
                "created_at": datetime.now()
            }
        )
        
        # 3. 创建关联
        self.graph.create_edge(
            from_node=episode_node,
            to_node=insight_node,
            relationship="GENERATED"
        )
        
        # 4. 查找相似经历
        similar_episodes = self.find_similar_episodes(episode)
        
        # 5. 如果有多个相似经历，提取模式
        if len(similar_episodes) >= 3:
            pattern = self.extract_pattern([episode] + similar_episodes)
            pattern_node = self.graph.create_node(
                label="Pattern",
                properties=pattern
            )
            
            # 关联经历到模式
            for ep in [episode] + similar_episodes:
                self.graph.create_edge(
                    from_node=ep.node,
                    to_node=pattern_node,
                    relationship="MATCHES"
                )
    
    def retrieve_relevant_reflections(self, current_context):
        """
        检索相关的反思
        """
        # 1. 找到相似经历
        similar = self.find_similar_episodes(current_context)
        
        # 2. 图遍历获取相关洞察
        query = """
        MATCH (e:Episode)-[:GENERATED]->(i:Insight)
        WHERE e.id IN $episode_ids
        RETURN i
        ORDER BY i.confidence DESC
        LIMIT 10
        """
        
        insights = self.graph.run(query, episode_ids=[e.id for e in similar])
        
        # 3. 获取相关模式
        patterns = self.get_related_patterns(similar)
        
        return {
            "insights": insights,
            "patterns": patterns
        }

from pydantic import BaseModel
from datetime import datetime
from typing import List, Dict, Optional

class ReflectionEntry(BaseModel):
    """反思条目"""
    
    # 基础信息
    id: str
    timestamp: datetime
    source_type: str  # "immediate" | "periodic" | "deep"
    
    # 来源追溯
    source_episodes: List[str]  # 基于哪些经历
    source_reflections: List[str]  # 基于哪些其他反思
    
    # 反思内容
    insight: str  # 核心洞察
    pattern: Optional[str]  # 识别的模式
    lesson: str  # 学到的教训
    suggestion: str  # 改进建议
    
    # 分类标签
    category: str  # "communication" | "task_execution" | "strategy" | "self_awareness"
    tags: List[str]  # ["user_preference", "error_recovery", ...]
    
    # 置信度和重要性
    confidence: float  # 0.0 - 1.0
    importance: int  # 1-10
    
    # 验证状态
    validated: bool  # 是否经过验证
    validation_count: int  # 验证次数
    validation_success_rate: float  # 验证成功率
    
    # 嵌入向量
    embedding: Optional[List[float]]
    
    # 元数据
    metadata: Dict = {}

class ReflectiveMemoryIndex:
    """反思记忆索引"""
    
    def __init__(self):
        # 向量索引 (语义检索)
        self.vector_index = VectorStore()
        
        # 标签索引 (分类检索)
        self.tag_index = defaultdict(set)
        
        # 时间索引 (时间范围查询)
        self.time_index = TimeSeriesDB()
        
        # 重要性索引 (优先级检索)
        self.importance_index = PriorityQueue()
    
    def add(self, reflection: ReflectionEntry):
        """添加反思到索引"""
        # 1. 向量索引
        if reflection.embedding:
            self.vector_index.add(
                id=reflection.id,
                vector=reflection.embedding,
                metadata=reflection.dict()
            )
        
        # 2. 标签索引
        for tag in reflection.tags:
            self.tag_index[tag].add(reflection.id)
        
        # 3. 时间索引
        self.time_index.add(
            timestamp=reflection.timestamp,
            id=reflection.id
        )
        
        # 4. 重要性索引
        self.importance_index.put(
            priority=reflection.importance,
            item=reflection.id
        )
    
    def search(self, query: str, top_k: int = 10):
        """多维度检索"""
        # 1. 向量检索
        query_vec = embed(query)
        vector_results = self.vector_index.search(query_vec, top_k * 2)
        
        # 2. 标签匹配
        query_tags = extract_tags(query)
        tag_results = set()
        for tag in query_tags:
            tag_results.update(self.tag_index.get(tag, set()))
        
        # 3. 融合排序
        merged = self.merge_and_rank(
            vector_results=vector_results,
            tag_results=tag_results
        )
        
        return merged[:top_k]

class ReflectionTrigger:
    """反思触发器"""
    
    def __init__(self):
        self.episode_buffer = []
        self.trigger_rules = {
            "immediate": {
                "every_n_episodes": 1,
                "on_error": True,
                "on_negative_feedback": True
            },
            "periodic": {
                "every_n_episodes": 10,
                "every_n_minutes": 60
            },
            "deep": {
                "every_n_hours": 24,
                "on_pattern_detected": True
            }
        }
    
    def check_triggers(self, episode):
        """检查是否触发反思"""
        self.episode_buffer.append(episode)
        
        triggers = []
        
        # 即时反思
        if episode.has_error or episode.negative_feedback:
            triggers.append("immediate")
        
        # 周期反思
        if len(self.episode_buffer) >= self.trigger_rules["periodic"]["every_n_episodes"]:
            triggers.append("periodic")
        
        # 深度反思
        if self.should_deep_reflect():
            triggers.append("deep")
        
        return triggers

REFLECTION_PROMPTS = {
    "immediate": """
你是一个 AI Agent 的反思模块。请对刚才的交互进行快速反思。

【交互信息】
- 用户输入: {user_input}
- 我的回复: {my_response}
- 用户反馈: {user_feedback}
- 是否有错误: {has_error}

【快速反思】
1. 回复质量评分 (1-10): ?
2. 主要问题: ?
3. 立即改进点: ?

请简洁回答，不超过 100 字。
""",

    "periodic": """
你是一个 AI Agent 的反思模块。请对最近的交互进行模式分析。

【最近 {n} 次交互】
{episodes_summary}

【反思任务】
1. 识别重复出现的问题模式
2. 总结成功的策略
3. 提炼可推广的经验

【输出格式】
```json
{{
  "patterns": [
    {{
      "description": "模式描述",
      "frequency": "出现频率",
      "impact": "影响程度"
    }}
  ],
  "success_strategies": [
    "策略1",
    "策略2"
  ],
  "lessons": [
    "教训1",
    "教训2"
  ]
}}

class ReflectionApplicator:
    """反思应用器"""
    
    def apply_reflections(self, context, action_space):
        """
        将反思应用到当前决策
        """
        # 1. 检索相关反思
        relevant_reflections = self.retrieve_relevant(context)
        
        # 2. 过滤高置信度的反思
        high_confidence = [
            r for r in relevant_reflections
            if r.confidence > 0.7 and r.validation_success_rate > 0.8
        ]
        
        # 3. 生成决策指导
        guidance = self.synthesize_guidance(high_confidence)
        
        # 4. 调整行动策略
        adjusted_actions = self.adjust_actions(
            action_space=action_space,
            guidance=guidance
        )
        
        return adjusted_actions, guidance
    
    def synthesize_guidance(self, reflections):
        """综合多个反思生成指导"""
        prompt = f"""
        基于以下反思，生成行动指导:
        
        反思列表:
        {format_reflections(reflections)}
        
        输出行动指导:
        - 优先策略: ?
        - 避免策略: ?
        - 注意事项: ?
        """
        
        return llm.generate(prompt)

class ReflectionEvaluator:
    """反思自动评估器"""
    
    def evaluate_reflection_quality(self, reflection: ReflectionEntry):
        """评估反思质量"""
        scores = {}
        
        # 1. 洞察准确性
        scores['accuracy'] = self.evaluate_accuracy(reflection)
        
        # 2. 可操作性
        scores['actionability'] = self.evaluate_actionability(reflection)
        
        # 3. 泛化能力
        scores['generalizability'] = self.evaluate_generalizability(reflection)
        
        # 4. 新颖性
        scores['novelty'] = self.evaluate_novelty(reflection)
        
        # 5. 综合评分
        overall = (
            0.30 * scores['accuracy'] +
            0.25 * scores['actionability'] +
            0.25 * scores['generalizability'] +
            0.20 * scores['novelty']
        )
        
        return {
            'scores': scores,
            'overall': overall,
            'grade': self.assign_grade(overall)
        }
    
    def evaluate_accuracy(self, reflection):
        """评估洞察准确性"""
        prompt = f"""
        评估以下反思洞察的准确性:
        
        反思: {reflection.insight}
        来源经历: {reflection.source_episodes}
        
        评分标准:
        5 - 完全准确，有充分证据支持
        4 - 大部分准确，有轻微偏差
        3 - 部分准确，存在明显偏差
        2 - 大部分不准确
        1 - 完全不准确
        
        输出: 评分 (1-5) + 理由
        """
        
        result = llm.generate(prompt)
        return result.score / 5.0

class ReflectionABTest:
    """反思效果 A/B 测试"""
    
    async def run_ab_test(self, test_cases, with_reflection=True):
        """
        对比有/无反思的 Agent 表现
        """
        results = []
        
        for test_case in test_cases:
            if with_reflection:
                # 有反思的 Agent
                result = await self.agent_with_reflection.execute(test_case)
            else:
                # 无反思的 Agent
                result = await self.agent_without_reflection.execute(test_case)
            
            results.append({
                'test_case': test_case.id,
                'with_reflection': with_reflection,
                'success': result.success,
                'quality': result.quality,
                'time': result.execution_time
            })
        
        return results
    
    def analyze_results(self, results_with, results_without):
        """分析 A/B 测试结果"""
        # 成功率对比
        success_rate_with = np.mean([r['success'] for r in results_with])
        success_rate_without = np.mean([r['success'] for r in results_without])
        
        # 质量对比
        quality_with = np.mean([r['quality'] for r in results_with])
        quality_without = np.mean([r['quality'] for r in results_without])
        
        # 统计显著性检验
        from scipy import stats
        t_stat, p_value = stats.ttest_ind(
            [r['quality'] for r in results_with],
            [r['quality'] for r in results_without]
        )
        
        return {
            'success_rate_lift': success_rate_with - success_rate_without,
            'quality_lift': quality_with - quality_without,
            'statistical_significance': p_value < 0.05,
            'p_value': p_value
        }

class ReflectionOptimizer:
    """反思优化器"""
    
    def optimize_reflection(self, reflection: ReflectionEntry):
        """优化低质量反思"""
        evaluation = self.evaluator.evaluate_reflection_quality(reflection)
        
        if evaluation['overall'] < 0.70:
            # 质量不达标，尝试改进
            improved = self.improve_reflection(reflection, evaluation)
            return improved
        
        return reflection
    
    def improve_reflection(self, reflection, evaluation):
        """改进反思"""
        prompt = f"""
        以下反思质量不达标，请改进:
        
        原始反思: {reflection.insight}
        
        质量评估:
        - 准确性: {evaluation['scores']['accuracy']}
        - 可操作性: {evaluation['scores']['actionability']}
        - 泛化能力: {evaluation['scores']['generalizability']}
        - 新颖性: {evaluation['scores']['novelty']}
        
        改进要求:
        1. 提高准确性: 确保洞察有充分证据支持
        2. 增强可操作性: 给出具体可执行的建议
        3. 提升泛化能力: 避免过度特化
        4. 增加新颖性: 避免重复已知信息
        
        输出改进后的反思。
        """
        
        improved_content = llm.generate(prompt)
        
        # 更新反思
        reflection.insight = improved_content.insight
        reflection.suggestion = improved_content.suggestion
        
        return reflection

class ReflectionStorageOptimizer:
    """反思存储优化器"""
    
    def optimize_storage(self):
        """优化反思存储"""
        # 1. 去重
        self.deduplicate_reflections()
        
        # 2. 合并相似反思
        self.merge_similar_reflections()
        
        # 3. 归档低价值反思
        self.archive_low_value_reflections()
    
    def deduplicate_reflections(self):
        """去重相似反思"""
        all_reflections = self.get_all_reflections()
        
        # 基于向量相似度聚类
        clusters = self.cluster_by_similarity(all_reflections, threshold=0.90)
        
        for cluster in clusters:
            if len(cluster) > 1:
                # 保留质量最高的
                best = max(cluster, key=lambda r: r.importance * r.confidence)
                
                # 删除其他的
                for r in cluster:
                    if r.id != best.id:
                        self.delete_reflection(r.id)
    
    def merge_similar_reflections(self):
        """合并相似反思"""
        all_reflections = self.get_all_reflections()
        
        # 基于语义相似度聚类
        clusters = self.cluster_by_similarity(all_reflections, threshold=0.75)
        
        for cluster in clusters:
            if len(cluster) > 1:
                # LLM 合并
                merged = self.merge_reflection_cluster(cluster)
                
                # 存储合并结果
                self.add_reflection(merged)
                
                # 删除原始反思
                for r in cluster:
                    self.delete_reflection(r.id)

class MemGPTReflective:
    """MemGPT 的反思实现"""
    
    def heartbeat(self):
        """
        周期性反思
        MemGPT 的核心创新
        """
        prompt = f"""
        你是一个 AI Agent。现在是反思时间。
        
        【当前状态】
        Core Memory: {self.core_memory}
        最近对话: {self.recent_messages}
        
        【反思任务】
        1. 回顾最近的交互
        2. 识别需要改进的地方
        3. 决定是否更新 Core Memory
        
        【可能的行动】
        - core_memory_append: 追加信息到 Core Memory
        - core_memory_replace: 替换 Core Memory 中的信息
        - send_message: 向用户发送消息
        - none: 无需行动
        """
        
        action = self.llm.generate(prompt)
        
        if action.type == "core_memory_append":
            self.core_memory.append(action.content)
        elif action.type == "core_memory_replace":
            self.core_memory.replace(action.old, action.new)

class ToolMemory(BaseMemory):
    """ReMe 的工具记忆"""
    
    memory_type: str = "tool"
    tool_call_results: List[ToolCallResult]
    
    # ToolCallResult 包含:
    # - summary: 工具调用的总结
    # - evaluation: 对调用结果的评估（反思）
    # - score: 调用质量评分
    
    def reflect_on_tool_usage(self):
        """
        反思工具使用情况
        """
        # 分析历史调用
        successful = [r for r in self.tool_call_results if r.success]
        failed = [r for r in self.tool_call_results if not r.success]
        
        # 提取成功模式
        success_patterns = self.extract_patterns(successful)
        
        # 提取失败原因
        failure_reasons = self.analyze_failures(failed)
        
        # 生成反思
        reflection = {
            "success_patterns": success_patterns,
            "failure_reasons": failure_reasons,
            "optimal_params": self.find_optimal_params(),
            "avoid_strategies": self.find_avoid_strategies()
        }
        
        return reflection

class ForesightExtractor:
    """前瞻记忆提取器"""
    
    async def generate_foresights_for_episode(self, episode):
        """
        从情景中提取前瞻预测
        这是反思的一种特殊形式
        """
        prompt = f"""
        基于以下经历，生成前瞻预测:
        
        情景: {episode.content}
        
        请思考:
        1. 未来可能出现什么情况？
        2. 在那种情况下应该怎么做？
        3. 有什么需要注意的？
        
        输出格式:
        ```json
        {{
          "foresights": [
            {{
              "trigger_condition": "触发条件",
              "action_suggestion": "建议行动",
              "validity_period": "有效期（天）",
              "priority": "优先级（1-10）"
            }}
          ]
        }}

class AdaptiveReflectiveMemory:
    """自适应反思系统"""
    
    def __init__(self):
        self.reflection_strategies = {
            "quick": QuickReflectionStrategy(),
            "thorough": ThoroughReflectionStrategy(),
            "creative": CreativeReflectionStrategy(),
            "analytical": AnalyticalReflectionStrategy()
        }
        
        self.strategy_selector = StrategySelector()
    
    def reflect(self, episode):
        """
        自适应选择反思策略
        """
        # 1. 分析情境特征
        context_features = self.analyze_context(episode)
        
        # 2. 选择最适合的策略
        strategy = self.strategy_selector.select(
            context_features=context_features,
            past_performance=self.get_strategy_performance()
        )
        
        # 3. 执行反思
        reflection = strategy.reflect(episode)
        
        # 4. 评估反思质量
        quality = self.evaluate_reflection(reflection)
        
        # 5. 更新策略性能
        self.update_strategy_performance(strategy, quality)
        
        return reflection

class CollaborativeReflection:
    """协作反思系统"""
    
    async def collaborative_reflect(self, agents, shared_experience):
        """
        多 Agent 协作反思
        """
        # 1. 每个 Agent 独立反思
        individual_reflections = []
        for agent in agents:
            reflection = await agent.reflect(shared_experience)
            individual_reflections.append({
                "agent": agent.name,
                "reflection": reflection
            })
        
        # 2. 共享到反思空间
        self.shared_space.add_reflections(individual_reflections)
        
        # 3. 寻找共识和争议
        consensus = self.find_consensus(individual_reflections)
        controversies = self.find_controversies(individual_reflections)
        
        # 4. 综合集体洞察
        collective_insight = self.synthesize_collective_insight(
            individual_reflections,
            consensus,
            controversies
        )
        
        return {
            "individual": individual_reflections,
            "consensus": consensus,
            "controversies": controversies,
            "collective_insight": collective_insight
        }

class ExplainableReflection:
    """可解释反思系统"""
    
    def explainable_reflect(self, episode):
        """
        生成可解释的反思
        """
        reflection = {
            "insight": "...",
            "evidence": [],  # 支持证据
            "reasoning_chain": [],  # 推理链
            "counter_evidence": [],  # 反对证据
            "confidence": 0.85,
            "uncertainty": "..."
        }
        
        # 1. 提供支持证据
        reflection["evidence"] = self.extract_evidence(episode)
        
        # 2. 展示推理过程
        reflection["reasoning_chain"] = self.trace_reasoning(episode)
        
        # 3. 承认不确定性
        reflection["uncertainty"] = self.acknowledge_uncertainty(episode)
        
        # 4. 提供反对证据（批判性思考）
        reflection["counter_evidence"] = self.find_counter_evidence(episode)
        
        return reflection

class LifelongReflectiveMemory:
    """终身反思系统"""
    
    def __init__(self):
        self.reflection_timeline = []  # 反思时间线
        self.belief_evolution = {}     # 信念演化
    
    def track_belief_evolution(self, topic):
        """
        追踪某个主题的信念演化
        """
        related_reflections = [
            r for r in self.reflection_timeline
            if topic in r.tags
        ]
        
        evolution = {
            "initial_belief": related_reflections[0].insight,
            "current_belief": related_reflections[-1].insight,
            "evolution_path": [],
            "key_turning_points": []
        }
        
        # 追踪信念变化
        for i, reflection in enumerate(related_reflections[1:], 1):
            prev = related_reflections[i-1]
            if reflection.insight != prev.insight:
                evolution["evolution_path"].append({
                    "from": prev.insight,
                    "to": reflection.insight,
                    "reason": reflection.source_episodes,
                    "timestamp": reflection.timestamp
                })
        
        return evolution

class StorageQualityEvaluator:
    """存储质量评估器"""
    
    def __init__(self, embed_model, llm_client):
        self.embed_model = embed_model
        self.llm = llm_client
    
    async def evaluate_completeness(self, original_text, stored_memory):
        """评估信息完整性"""
        # 方法1: Embedding 相似度
        emb_original = await self.embed_model.embed(original_text)
        emb_stored = await self.embed_model.embed(stored_memory)
        cosine_sim = cosine_similarity(emb_original, emb_stored)
        
        # 方法2: LLM-based 评估
        prompt = f"""
        评估以下记忆是否完整保留了原始信息的关键内容：
        
        原始文本: {original_text}
        存储记忆: {stored_memory}
        
        评分标准 (0-1):
        1.0 - 完整保留所有关键信息
        0.8 - 保留大部分关键信息，细节有损失
        0.6 - 保留部分关键信息
        0.4 - 关键信息不完整
        0.2 - 严重信息丢失
        
        输出评分和理由。
        """
        
        llm_score = await self.llm.evaluate(prompt)
        
        # 综合评分
        return {
            'embedding_similarity': cosine_sim,
            'llm_score': llm_score['score'],
            'composite_score': 0.4 * cosine_sim + 0.6 * llm_score['score'],
            'reasoning': llm_score['reasoning']
        }