spl-agent-engine 0.1.0__py3-none-any.whl

spl_agent_engine/feature/__init__.py

@@ -0,0 +1,24 @@
+"""
+SPL Agent Engine — Composable feature modules.
+
+Each module is self-contained and can be mixed into a persona:
+    - identity:  multi-identity system with identity conflict
+    - goal:      goal hierarchy and goal-engine dynamics
+    - bias:      cognitive bias profiles (optimistic / paranoid / depressive)
+    - value:     value system and dissonance
+    - world:     world-model priors (optimistic / pessimistic / traumatized)
+"""
+
+from .identity import IdentityNode, IdentityEngine
+from .goal import GoalNode, GoalEngine
+from .bias import BiasProfile, BiasEngine
+from .value import ValueProfile, ValueEngine
+from .world import WorldModel
+
+__all__ = [
+    "IdentityNode", "IdentityEngine",
+    "GoalNode", "GoalEngine",
+    "BiasProfile", "BiasEngine",
+    "ValueProfile", "ValueEngine",
+    "WorldModel",
+]

spl_agent_engine/feature/bias.py

@@ -0,0 +1,162 @@
+# ================================================================
+# 认知偏见系统（Cognitive Bias Profile）—— 【自设模块】
+# ================================================================
+# 偏见是角色对信息的系统性扭曲，不同角色有不同的偏见图谱。
+#
+# 这是"角色的人格滤镜"——同样一件事，不同偏见的人感受完全不同。
+# 偏见直接影响核心引擎的 _core_appraisal_gain（认知增益阶段）。
+#
+# 用法：在自定义 Mapper 或引擎外层集成 BiasProfile，
+#       调用 apply_appraisal_bias() 调制 perceived vector。
+# ================================================================
+
+from dataclasses import dataclass
+from typing import Dict
+
+
+@dataclass
+class BiasProfile:
+    """
+    角色认知偏见图谱。
+
+    不是"有没有偏见"——所有人都有。这是"有什么样的偏见"。
+    """
+
+    # ── 注意偏差（Attentional Biases）──
+    negativity_bias: float = 0.7        # 负面信息优先加工 [0,1]
+    threat_vigilance: float = 0.5       # 威胁警觉（高→草木皆兵）[0,1]
+    positivity_offset: float = 0.3      # 正面信息基线捕获 [0,1]
+
+    # ── 解释偏差（Interpretive Biases）──
+    confirmation_bias: float = 0.6      # 确认偏见（只信符合预期的）[0,1]
+    hostile_attribution: float = 0.3    # 敌意归因（中性→恶意）[0,1]
+    benevolent_attribution: float = 0.4 # 善意归因（中性→善意）[0,1]
+
+    # ── 记忆偏差（Memory Biases）──
+    mood_congruent_memory: float = 0.5  # 情绪一致性记忆（心情差→只想起坏事）
+    peak_end_rule: float = 0.6          # 峰终定律权重（只记住高峰和结尾）
+    rosy_retrospection: float = 0.3     # 玫瑰色回顾（美化过去）
+
+    # ── 归因偏差（Attributional Biases）──
+    self_serving_bias: float = 0.5      # 自我服务偏差（成功内归因→失败外归因）
+    fundamental_attribution: float = 0.6 # 基本归因错误（别人的错是性格，自己的错是环境）
+
+    # ── 社会偏差（Social Biases）──
+    in_group_bias: float = 0.4          # 内群体偏好
+    authority_bias: float = 0.3         # 权威服从倾向
+    projection_bias: float = 0.4        # 投射倾向（自己怎么想就觉得别人也这么想）
+
+
+class BiasEngine:
+    """
+    偏见引擎：把 BiasProfile 应用到认知处理管道。
+
+    在核心引擎的 _core_appraisal_gain 之后、_vector_to_fluid 之前调用。
+    """
+
+    def __init__(self, profile: BiasProfile = None):
+        self.profile = profile or BiasProfile()
+
+    def apply_appraisal_bias(self, perceived: Dict[str, float],
+                             world_model=None) -> Dict[str, float]:
+        """
+        对认知增益后的 perceived vector 施加偏见调制。
+
+        调用时机：engine._core_appraisal_gain() 之后。
+
+        Args:
+            perceived: 认知增益后的内感受向量
+            world_model: 可选的世界模型引用，用于确认偏见
+
+        Returns:
+            偏见调制后的向量
+        """
+        out = dict(perceived)
+        p = self.profile
+
+        # ── 负面偏差：放大 threat，放大负向 belonging ──
+        if out.get("threat", 0.0) > 0:
+            out["threat"] *= (1.0 + p.negativity_bias * 0.6)
+        if out.get("belonging", 0.0) < 0:
+            out["belonging"] *= (1.0 + p.negativity_bias * 0.4)
+
+        # ── 威胁警觉：任何微弱 threat 都被放大 ──
+        if 0 < out.get("threat", 0.0) < 0.2:
+            out["threat"] *= (1.0 + p.threat_vigilance)
+
+        # ── 敌意归因：对中性 threat 加码 ──
+        if out.get("threat", 0.0) > 0 and p.hostile_attribution > 0.5:
+            out["threat"] *= (1.0 + (p.hostile_attribution - 0.5))
+
+        # ── 确认偏见：如果世界模型认为人不值得信任，threat 被强化 ──
+        if world_model and world_model.trust_people < 0.3:
+            if out.get("threat", 0.0) > 0:
+                out["threat"] *= (1.0 + p.confirmation_bias * 0.5)
+            if out.get("belonging", 0.0) > 0:
+                out["belonging"] *= (1.0 - p.confirmation_bias * 0.3)
+
+        return out
+
+    def modulate_memory_strength(self, event_type: str, strength: float) -> float:
+        """
+        调制记忆写入强度——有偏见的记忆系统。
+
+        负面事件记忆更牢固（负向偏见），符合预期的记忆更牢固（确认偏见）。
+        """
+        p = self.profile
+        if event_type in ["insult", "betrayal", "criticism", "threat"]:
+            strength *= (1.0 + p.negativity_bias)
+        elif event_type in ["compliment", "trust_signal"]:
+            # 正面事件，确认偏见影响编码
+            strength *= (1.0 - p.confirmation_bias * 0.3)
+        # 情绪一致性：如果负面偏见很高，负面记忆更牢固
+        if p.negativity_bias > 0.6 and strength > 0:
+            strength *= (1.0 + p.mood_congruent_memory * 0.2)
+        return min(1.0, max(0.0, strength))
+
+    def interpret_neutral(self, signal_valence: float) -> float:
+        """
+        解释中性信号：偏见决定了中性信号被推向正面还是负面。
+
+        Args:
+            signal_valence: 信号效价（~0 = 中性）
+
+        Returns:
+            被偏见扭曲后的效价
+        """
+        p = self.profile
+        # 敌意归因 → 推向负面；善意归因 → 推向正面
+        net_bias = p.hostile_attribution - p.benevolent_attribution
+        return max(-1.0, min(1.0, signal_valence + net_bias * 0.5 * (1.0 - abs(signal_valence))))
+
+
+# ── 预设角色模板 ──
+
+def paranoid_bias() -> BiasProfile:
+    """偏执型偏见——高威胁警觉 + 高敌意归因"""
+    return BiasProfile(
+        negativity_bias=0.9, threat_vigilance=0.85,
+        hostile_attribution=0.8, benevolent_attribution=0.1,
+        confirmation_bias=0.8, projection_bias=0.7,
+        mood_congruent_memory=0.7,
+    )
+
+
+def optimistic_bias() -> BiasProfile:
+    """乐观型偏见——高正面偏倚 + 低威胁警觉"""
+    return BiasProfile(
+        negativity_bias=0.3, threat_vigilance=0.2,
+        positivity_offset=0.7, hostile_attribution=0.1,
+        benevolent_attribution=0.7, rosy_retrospection=0.6,
+        self_serving_bias=0.7,
+    )
+
+
+def depressive_bias() -> BiasProfile:
+    """抑郁型偏见——高负面 + 低自我服务"""
+    return BiasProfile(
+        negativity_bias=0.9, threat_vigilance=0.7,
+        positivity_offset=0.1, hostile_attribution=0.5,
+        confirmation_bias=0.7, self_serving_bias=0.1,
+        mood_congruent_memory=0.8, rosy_retrospection=0.1,
+    )

spl_agent_engine/feature/goal.py

@@ -0,0 +1,174 @@
+# ================================================================
+# 目标系统（Goal Engine）—— 【自设模块】
+# ================================================================
+# 目标是角色行为的驱动力。目标受阻产生挫折感，
+# 目标达成产生成就感。不同角色有不同的目标层级。
+#
+# 用法：在 Agent 初始化时加载 GoalEngine，
+#       用 update_progress() 更新目标进度，
+#       用 get_emotion_vector() 获取目标状态的情绪影响。
+# ================================================================
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+import math
+
+
+@dataclass
+class GoalNode:
+    """一个目标节点"""
+    name: str              # 目标名称
+    importance: float      # 重要性 [0,1]
+    progress: float = 0.0  # 当前进度 [0,1]
+    urgency: float = 0.5   # 紧迫度 [0,1]
+    difficulty: float = 0.5  # 难度 [0,1]
+    dependencies: List[str] = field(default_factory=list)  # 依赖的其他目标
+    stalled: bool = False  # 是否卡住了
+
+
+class GoalEngine:
+    """
+    目标引擎：管理目标的层级结构和进度。
+
+    核心机制：
+    1. 目标受阻（progress 停滞 + urgency 高）→ 挫折情绪
+    2. 目标达成（progress → 1.0）→ 成就感
+    3. 目标冲突（A 的进度牺牲了 B）→ 内在张力
+    4. 当前主目标决定注意力分配和行为优先级
+    """
+
+    def __init__(self):
+        self.goals: List[GoalNode] = []
+        self.completed_goals: List[GoalNode] = []
+
+    def add_goal(self, name: str, importance: float, urgency: float = 0.5,
+                 difficulty: float = 0.5, dependencies: List[str] = None):
+        """添加一个目标。"""
+        self.goals.append(GoalNode(
+            name=name, importance=importance,
+            urgency=urgency, difficulty=difficulty,
+            dependencies=dependencies or [],
+        ))
+
+    def update_progress(self, goal_name: str, delta: float):
+        """
+        更新目标进度。
+
+        Args:
+            goal_name: 目标名
+            delta: 进度变化 [-1, 1]
+        """
+        for goal in self.goals:
+            if goal.name == goal_name:
+                old_progress = goal.progress
+                goal.progress = max(0.0, min(1.0, goal.progress + delta))
+
+                # 进度停止 → 标记为卡住
+                if abs(goal.progress - old_progress) < 0.01 and goal.progress < 0.9:
+                    goal.stalled = True
+                else:
+                    goal.stalled = False
+
+                # 目标达成
+                if goal.progress >= 0.99:
+                    self.completed_goals.append(goal)
+                    self.goals.remove(goal)
+                break
+
+    def set_urgency(self, goal_name: str, urgency: float):
+        """更新目标紧迫度。"""
+        for goal in self.goals:
+            if goal.name == goal_name:
+                goal.urgency = max(0.0, min(1.0, urgency))
+                break
+
+    def get_primary_goal(self) -> Optional[GoalNode]:
+        """获取当前主目标（重要性 × 紧迫度 × (1-进度) 最大）。"""
+        if not self.goals:
+            return None
+        return max(self.goals, key=lambda g:
+            g.importance * g.urgency * (1.0 - g.progress) * g.difficulty)
+
+    def goal_conflict_level(self) -> float:
+        """
+        计算目标间的冲突水平。
+
+        高重要性目标之间的进度权衡会产生冲突。
+        """
+        if len(self.goals) < 2:
+            return 0.0
+        # 依赖冲突：如果 A 的完成阻碍了 B
+        conflict = 0.0
+        for g in self.goals:
+            for dep_name in g.dependencies:
+                for other in self.goals:
+                    if other.name == dep_name and other.progress < 0.3:
+                        conflict += g.importance * g.urgency
+        return min(1.0, conflict * 0.5)
+
+    def get_emotion_vector(self) -> Dict[str, float]:
+        """
+        将目标状态转化为情绪向量。
+
+        定期调用，注入 core.process_vector() 作为基底。
+        """
+        vector = {}
+        primary = self.get_primary_goal()
+
+        if primary:
+            # 重要目标卡住 → 挫折/张力
+            if primary.stalled and primary.importance > 0.5:
+                frustration = primary.importance * primary.urgency * 0.3
+                vector["tension_base"] = vector.get("tension_base", 0.0) + frustration
+                # 如果卡住的是高难度目标 → 可能触发羞耻（"我做不到"）
+                if primary.difficulty > 0.7:
+                    vector["shame_trigger"] = 0.15 * primary.importance
+
+            # 目标进展 → 轻微喜悦
+            if primary.progress > 0.5:
+                progress_joy = primary.importance * (primary.progress - 0.5) * 0.2
+                vector["belonging"] = vector.get("belonging", 0.0) + progress_joy
+
+            # 高紧迫度 → 张力
+            if primary.urgency > 0.7:
+                vector["tension_base"] = vector.get("tension_base", 0.0) + primary.urgency * 0.2
+
+        # 目标冲突 → 张力
+        conflict = self.goal_conflict_level()
+        if conflict > 0.1:
+            vector["tension_base"] = vector.get("tension_base", 0.0) + conflict * 0.3
+
+        # 近期完成目标 → 喜悦+自尊提升
+        if self.completed_goals:
+            total_importance = sum(g.importance for g in self.completed_goals[-3:])
+            vector["belonging"] = vector.get("belonging", 0.0) + total_importance * 0.15
+
+        return vector
+
+    def snapshot(self) -> dict:
+        """目标系统快照。"""
+        return {
+            "active_goals": [
+                {"name": g.name, "importance": g.importance,
+                 "progress": g.progress, "urgency": g.urgency,
+                 "stalled": g.stalled}
+                for g in self.goals
+            ],
+            "primary": self.get_primary_goal().name if self.get_primary_goal() else None,
+            "completed": len(self.completed_goals),
+            "conflict": self.goal_conflict_level(),
+        }
+
+
+# ── 预设：苏瑾的目标配置 ──
+
+def sujin_goals() -> GoalEngine:
+    """苏瑾的目标层级"""
+    engine = GoalEngine()
+    engine.add_goal("赢得客户信任", importance=0.8, urgency=0.7, difficulty=0.7)
+    engine.add_goal("保持专业独立性", importance=0.75, urgency=0.5, difficulty=0.6)
+    engine.add_goal("交付高质量方案", importance=0.9, urgency=0.8, difficulty=0.8)
+    # 此目标依赖"赢得客户信任"
+    engine.add_goal("建立长期战略合作", importance=0.7, urgency=0.4, difficulty=0.8,
+                    dependencies=["赢得客户信任"])
+    return engine

spl_agent_engine/feature/identity.py

@@ -0,0 +1,162 @@
+# ================================================================
+# 身份系统（Identity Engine）—— 【自设模块】
+# ================================================================
+# 角色拥有多重身份（职业身份、家庭角色、社会角色），
+# 身份之间有和谐也有冲突。冲突产生持续的心理张力。
+#
+# 用法：在 Agent 初始化时加载 IdentityEngine，
+#       定期检查冲突并将张力注入核心引擎。
+# ================================================================
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+
+
+@dataclass
+class IdentityNode:
+    """一个身份节点"""
+    name: str              # 身份名称（"顾问"、"母亲"、"合伙人"）
+    strength: float        # 身份强度 [0,1]（有多认同这个身份）
+    priority: float        # 优先度 [0,1]（在冲突时有多优先）
+    satisfaction: float = 0.5  # 身份满意度 [0,1]（在这个角色中感到多满意）
+    threat_level: float = 0.0  # 该身份受到的威胁 [0,1]
+
+
+@dataclass
+class IdentityEngine:
+    """
+    身份引擎：管理多重身份及其冲突。
+
+    核心洞察：
+    - 身份冲突会产生持续的基底张力（不只是瞬时情绪）
+    - 身份威胁比对个体的攻击更伤人（"你不配做顾问" > "你这个方案不行"）
+    - 身份满意度的变化影响自尊
+    """
+
+    identities: List[IdentityNode] = field(default_factory=list)
+    conflict_matrix: Dict[str, Dict[str, float]] = field(default_factory=dict)
+    # conflict_history 追踪冲突趋势（上升 vs 下降）
+    conflict_history: List[float] = field(default_factory=list)
+
+    def add_identity(self, name: str, strength: float = 0.7,
+                     priority: float = 0.5, satisfaction: float = 0.5):
+        """添加一个身份。"""
+        node = IdentityNode(
+            name=name, strength=strength,
+            priority=priority, satisfaction=satisfaction,
+        )
+        self.identities.append(node)
+        # 初始化冲突矩阵
+        for other in self.identities:
+            if other.name != name:
+                self.conflict_matrix.setdefault(name, {})[other.name] = 0.0
+                self.conflict_matrix.setdefault(other.name, {})[name] = 0.0
+
+    def set_conflict(self, id1: str, id2: str, level: float):
+        """
+        设置两个身份之间的冲突水平 [0,1]。
+
+        比如："顾问"和"朋友"之间的冲突 = 0.6
+        意味着在这两个角色之间切换时，有 60% 的内在张力。
+        """
+        self.conflict_matrix.setdefault(id1, {})[id2] = max(0.0, min(1.0, level))
+        self.conflict_matrix.setdefault(id2, {})[id1] = max(0.0, min(1.0, level))
+
+    def total_conflict(self) -> float:
+        """
+        计算当前所有身份冲突的总和。
+
+        返回值 [0,1]：0 = 完全和谐，1 = 极度撕裂。
+        """
+        if len(self.identities) < 2:
+            return 0.0
+        total = 0.0
+        count = 0
+        for i in range(len(self.identities)):
+            for j in range(i + 1, len(self.identities)):
+                a = self.identities[i]
+                b = self.identities[j]
+                conflict_level = self.conflict_matrix.get(a.name, {}).get(b.name, 0.0)
+                # 冲突强度 = 身份强度乘积 × 冲突水平 × 优先度差
+                tension = (conflict_level
+                           * a.strength
+                           * b.strength
+                           * abs(a.priority - b.priority))
+                total += tension
+                count += 1
+        return min(1.0, total / max(1, count) * 2.0)
+
+    def threaten_identity(self, identity_name: str, threat_magnitude: float):
+        """
+        对某个身份施加威胁。
+
+        触发：当角色感知到某个身份被攻击/否定时调用。
+        返回一个可用于注入核心引擎的情绪向量。
+        """
+        for ident in self.identities:
+            if ident.name == identity_name:
+                ident.threat_level = min(1.0, ident.threat_level + threat_magnitude)
+                ident.satisfaction = max(0.0, ident.satisfaction - threat_magnitude * 0.5)
+                break
+
+    def affirm_identity(self, identity_name: str, boost: float):
+        """肯定某个身份（提升满意度和强度）。"""
+        for ident in self.identities:
+            if ident.name == identity_name:
+                ident.satisfaction = min(1.0, ident.satisfaction + boost)
+                ident.strength = min(1.0, ident.strength + boost * 0.3)
+                ident.threat_level = max(0.0, ident.threat_level - boost * 0.5)
+                break
+
+    def get_emotion_vector(self) -> Dict[str, float]:
+        """
+        将当前身份状态转化为可供核心引擎消化的情绪向量。
+
+        这个向量应该定期（或在事件处理前）注入 core.process_vector()。
+        """
+        tc = self.total_conflict()
+
+        # 身份冲突 → 持续张力基底
+        vector = {"tension_base": tc * 0.3}
+
+        # 身份威胁 → shame_trigger（"我不配当X"）
+        max_threat = max((i.threat_level for i in self.identities), default=0.0)
+        if max_threat > 0.3:
+            vector["shame_trigger"] = max_threat * 0.4
+
+        # 低身份满意度 → 归属感下降
+        min_satisfaction = min((i.satisfaction for i in self.identities), default=1.0)
+        if min_satisfaction < 0.4:
+            vector["belonging"] = -0.2 * (0.5 - min_satisfaction)
+
+        # 高身份满意度 → 喜悦基线
+        avg_satisfaction = (sum(i.satisfaction for i in self.identities) /
+                            max(1, len(self.identities)))
+        if avg_satisfaction > 0.7:
+            vector["belonging"] = 0.15 * (avg_satisfaction - 0.5)
+
+        return vector
+
+    def snapshot(self) -> dict:
+        """身份系统快照。"""
+        return {
+            "identities": [
+                {"name": i.name, "strength": i.strength,
+                 "priority": i.priority, "satisfaction": i.satisfaction,
+                 "threat": i.threat_level}
+                for i in self.identities
+            ],
+            "total_conflict": self.total_conflict(),
+        }
+
+
+# ── 预设：苏瑾的身份配置 ──
+
+def sujin_identity() -> IdentityEngine:
+    """苏瑾的多重身份配置"""
+    engine = IdentityEngine()
+    engine.add_identity("资深行业顾问", strength=0.9, priority=0.8, satisfaction=0.7)
+    engine.add_identity("战略合作伙伴", strength=0.6, priority=0.6, satisfaction=0.5)
+    # 顾问（理性距离） vs 朋友（情感亲近）存在天然冲突
+    engine.set_conflict("资深行业顾问", "战略合作伙伴", 0.35)
+    return engine