01
// 情绪转移规则表
02
const transitionRules = {
03
  calm: {
04
    triggers: [
05
      { event: 'praise',    nextState: 'happy',   condition: '收到夸奖或礼物' },
06
      { event: 'argument',  nextState: 'angry',   condition: '争吵、被忽视、记错重要事' },
07
      { event: 'user_sad',  nextState: 'sad',     condition: '用户表达负面情绪' },
08
      { event: 'intimate',  nextState: 'shy',     condition: '表白、亲密话语' },
09
      { event: 'rival',     nextState: 'jealous', condition: '提到其他异性' },
10
    ]
11
  },
12
  angry: {
13
    exitConditions: [
14
      { event: 'apology',   nextState: 'calm', condition: '真诚道歉 + 承认错误' },
15
      { event: 'gift',      nextState: 'happy', condition: '道歉 + 正确的礼物' },
16
      { event: 'decay',     nextState: 'calm', condition: '超过衰减时间（如6小时）' },
17
    ]
18
  },
19
  happy: {
20
    exitConditions: [
21
      { event: 'neglect',   nextState: 'sad',  condition: '长时间不回复' },
22
      { event: 'decay',     nextState: 'calm', condition: '超过衰减时间（如2小时）' },
23
    ]
24
  },
25
  // ... 其他状态类似
26
}

01
interface AgentState {
02
  messages: BaseMessage[]
03
  userProfile: Record<string, any>
04
  // 情绪相关字段
05
  npcMood: 'calm' | 'happy' | 'angry' | 'sad' | 'shy' | 'jealous'
06
  moodIntensity: number      // 0-100，情绪强度
07
  moodTimestamp: string       // 进入当前情绪的时间
08
  intimacyLevel: number       // 亲密度 0-100
09
  longTermMemories: string[]
10
  nextStep: string
11
}

01
async function emotionClassifierNode(state: AgentState) {
02
  const lastMessage = state.messages[state.messages.length - 1]
03
  const currentMood = state.npcMood
04

05
  // 用一个轻量级 LLM 调用来判断用户意图
06
  const classification = await llm.invoke([
07
    {
08
      role: 'system',
09
      content: `分析用户消息的意图，返回以下类别之一：
10
        praise（夸奖）, argument（争吵）, apology（道歉）,
11
        intimate（亲密）, rival（提到异性）, user_sad（用户低落）,
12
        neutral（普通闲聊）`
13
    },
14
    { role: 'user', content: lastMessage.content }
15
  ])
16

17
  // 根据分类结果 + 当前情绪，查转移规则表
18
  const newMood = applyTransition(currentMood, classification)
19

20
  return {
21
    ...state,
22
    npcMood: newMood.state,
23
    moodIntensity: newMood.intensity,
24
    moodTimestamp: newMood.changed ? new Date().toISOString() : state.moodTimestamp
25
  }
26
}

01
function emotionRouter(state: AgentState) {
02
  const { npcMood, moodIntensity } = state
03

04
  // 生气且强度高 → 暴怒模式
05
  if (npcMood === 'angry' && moodIntensity > 70) return 'furiousReplyNode'
06
  // 生气但强度低 → 冷淡模式
07
  if (npcMood === 'angry') return 'coldReplyNode'
08
  // 吃醋 → 醋意模式
09
  if (npcMood === 'jealous') return 'jealousReplyNode'
10
  // 害羞 → 娇羞模式
11
  if (npcMood === 'shy') return 'shyReplyNode'
12
  // 难过 → 共情模式
13
  if (npcMood === 'sad') return 'empatheticReplyNode'
14
  // 开心 → 甜蜜模式
15
  if (npcMood === 'happy') return 'sweetReplyNode'
16
  // 默认 → 正常模式
17
  return 'normalReplyNode'
18
}

01
// 1. 用户消息
02
"今天跟同事小李一起吃的午饭，她推荐的那家店还不错"
03

04
// 2. 情绪分类器识别
05
// → classification: 'rival'（提到异性）
06

07
// 3. 转移规则查询
08
// 当前状态：calm → 触发 rival → 新状态：jealous
09
// moodIntensity: 45（提到异性但不是特别亲密的描述）
10

11
// 4. 路由到 jealousReplyNode
12

13
// 5. 醋意模式 System Prompt
14
`你现在有点吃醋。语气酸酸的，会旁敲侧击地追问细节，
15
但不会直接发火。偶尔用"哦""这样啊"这种冷淡回应。`
16

17
// 6. LLM 生成回复
18
"哦……小李啊。她推荐的店？你们俩经常一起吃饭吗？"

01
function shouldTriggerJealous(
02
  event: string,
03
  intimacyLevel: number
04
): boolean {
05
  // 亲密度低（< 30）：不太在意，不容易吃醋
06
  if (intimacyLevel < 30) return false
07

08
  // 亲密度中等（30-70）：正常触发
09
  if (intimacyLevel <= 70) return event === 'rival'
10

11
  // 亲密度高（> 70）：更容易吃醋，轻微提及就触发
12
  return event === 'rival' || event === 'rival_mild'
13
}

01
const DECAY_CONFIG = {
02
  angry:   { halfLife: 3 * 60 * 60 * 1000, minDuration: 30 * 60 * 1000 },
03
  happy:   { halfLife: 1 * 60 * 60 * 1000, minDuration: 10 * 60 * 1000 },
04
  sad:     { halfLife: 2 * 60 * 60 * 1000, minDuration: 20 * 60 * 1000 },
05
  shy:     { halfLife: 30 * 60 * 1000,     minDuration: 5 * 60 * 1000 },
06
  jealous: { halfLife: 2 * 60 * 60 * 1000, minDuration: 15 * 60 * 1000 },
07
}
08

09
function calculateDecay(mood: string, timestamp: string, intensity: number) {
10
  const elapsed = Date.now() - new Date(timestamp).getTime()
11
  const config = DECAY_CONFIG[mood]
12

13
  // 最短持续时间内不衰减
14
  if (elapsed < config.minDuration) return intensity
15

16
  // 半衰期指数衰减
17
  const decayFactor = Math.pow(0.5, elapsed / config.halfLife)
18
  const newIntensity = Math.round(intensity * decayFactor)
19

20
  // 强度低于阈值，回到平静
21
  return newIntensity < 10 ? 0 : newIntensity
22
}

01
const EMOTION_PRIORITY = {
02
  angry: 5,    // 最高优先级，生气最难被覆盖
03
  sad: 4,
04
  jealous: 3,
05
  shy: 2,
06
  happy: 1,
07
  calm: 0,     // 最低优先级
08
}
09

10
function resolveConflict(
11
  currentMood: string,
12
  candidates: { state: string, intensity: number }[]
13
) {
14
  // 如果当前是高优先级情绪，且候选中有降级的（如道歉）
15
  // 则优先处理降级，因为"解决冲突"比"制造新冲突"重要
16
  const deescalation = candidates.find(c =>
17
    EMOTION_PRIORITY[c.state] < EMOTION_PRIORITY[currentMood]
18
  )
19
  if (deescalation) return deescalation
20

21
  // 否则选择优先级最高的候选
22
  return candidates.sort((a, b) =>
23
    EMOTION_PRIORITY[b.state] - EMOTION_PRIORITY[a.state]
24
  )[0]
25
}

1
const COOLDOWN_MS = 5000 // 5秒冷却期
2

3
function canTransition(state: AgentState): boolean {
4
  const elapsed = Date.now() - new Date(state.moodTimestamp).getTime()
5
  return elapsed >= COOLDOWN_MS
6
}