情绪状态机设计

// index.ts
// 情绪转移规则表
 
const transitionRules = {
 
  calm: {
 
    triggers: [
 
      { event: 'praise',    nextState: 'happy',   condition: '收到夸奖或礼物' },
 
      { event: 'argument',  nextState: 'angry',   condition: '争吵、被忽视、记错重要事' },
 
      { event: 'user_sad',  nextState: 'sad',     condition: '用户表达负面情绪' },
 
      { event: 'intimate',  nextState: 'shy',     condition: '表白、亲密话语' },
 
      { event: 'rival',     nextState: 'jealous', condition: '提到其他异性' },
 
    ]
 
  },
 
  angry: {
 
    exitConditions: [
 
      { event: 'apology',   nextState: 'calm', condition: '真诚道歉 + 承认错误' },
 
      { event: 'gift',      nextState: 'happy', condition: '道歉 + 正确的礼物' },
 
      { event: 'decay',     nextState: 'calm', condition: '超过衰减时间（如6小时）' },
 
    ]
 
  },
 
  happy: {
 
    exitConditions: [
 
      { event: 'neglect',   nextState: 'sad',  condition: '长时间不回复' },
 
      { event: 'decay',     nextState: 'calm', condition: '超过衰减时间（如2小时）' },
 
    ]
 
  },
 
  // ... 其他状态类似
 
}

// index.ts
interface AgentState {
 
  messages: BaseMessage[]
 
  userProfile: Record<string, any>
 
  // 情绪相关字段
 
  npcMood: 'calm' | 'happy' | 'angry' | 'sad' | 'shy' | 'jealous'
 
  moodIntensity: number      // 0-100，情绪强度
 
  moodTimestamp: string       // 进入当前情绪的时间
 
  intimacyLevel: number       // 亲密度 0-100
 
  longTermMemories: string[]
 
  nextStep: string
 
}

// index.ts
async function emotionClassifierNode(state: AgentState) {
 
  const lastMessage = state.messages[state.messages.length - 1]
 
  const currentMood = state.npcMood
 
  // 用一个轻量级 LLM 调用来判断用户意图
 
  const classification = await llm.invoke([
 
    {
 
      role: 'system',
 
      content: `分析用户消息的意图，返回以下类别之一：
 
        praise（夸奖）, argument（争吵）, apology（道歉）,
 
        intimate（亲密）, rival（提到异性）, user_sad（用户低落）,
 
        neutral（普通闲聊）`
 
    },
 
    { role: 'user', content: lastMessage.content }
 
  ])
 
  // 根据分类结果 + 当前情绪，查转移规则表
 
  const newMood = applyTransition(currentMood, classification)
 
  return {
 
    ...state,
 
    npcMood: newMood.state,
 
    moodIntensity: newMood.intensity,
 
    moodTimestamp: newMood.changed ? new Date().toISOString() : state.moodTimestamp
 
  }
 
}

// index.ts
function emotionRouter(state: AgentState) {
 
  const { npcMood, moodIntensity } = state
 
  // 生气且强度高 → 暴怒模式
 
  if (npcMood === 'angry' && moodIntensity > 70) return 'furiousReplyNode'
 
  // 生气但强度低 → 冷淡模式
 
  if (npcMood === 'angry') return 'coldReplyNode'
 
  // 吃醋 → 醋意模式
 
  if (npcMood === 'jealous') return 'jealousReplyNode'
 
  // 害羞 → 娇羞模式
 
  if (npcMood === 'shy') return 'shyReplyNode'
 
  // 难过 → 共情模式
 
  if (npcMood === 'sad') return 'empatheticReplyNode'
 
  // 开心 → 甜蜜模式
 
  if (npcMood === 'happy') return 'sweetReplyNode'
 
  // 默认 → 正常模式
 
  return 'normalReplyNode'
 
}

// index.ts
// 1. 用户消息
 
"今天跟同事小李一起吃的午饭，她推荐的那家店还不错"
 
// 2. 情绪分类器识别
 
// → classification: 'rival'（提到异性）
 
// 3. 转移规则查询
 
// 当前状态：calm → 触发 rival → 新状态：jealous
 
// moodIntensity: 45（提到异性但不是特别亲密的描述）
 
// 4. 路由到 jealousReplyNode
 
// 5. 醋意模式 System Prompt
 
`你现在有点吃醋。语气酸酸的，会旁敲侧击地追问细节，
 
但不会直接发火。偶尔用"哦""这样啊"这种冷淡回应。`
 
// 6. LLM 生成回复
 
"哦……小李啊。她推荐的店？你们俩经常一起吃饭吗？"

// index.ts
function shouldTriggerJealous(
 
  event: string,
 
  intimacyLevel: number
 
): boolean {
 
  // 亲密度低（< 30）：不太在意，不容易吃醋
 
  if (intimacyLevel < 30) return false
 
  // 亲密度中等（30-70）：正常触发
 
  if (intimacyLevel <= 70) return event === 'rival'
 
  // 亲密度高（> 70）：更容易吃醋，轻微提及就触发
 
  return event === 'rival' || event === 'rival_mild'
 
}

// index.ts
const DECAY_CONFIG = {
 
  angry:   { halfLife: 3 * 60 * 60 * 1000, minDuration: 30 * 60 * 1000 },
 
  happy:   { halfLife: 1 * 60 * 60 * 1000, minDuration: 10 * 60 * 1000 },
 
  sad:     { halfLife: 2 * 60 * 60 * 1000, minDuration: 20 * 60 * 1000 },
 
  shy:     { halfLife: 30 * 60 * 1000,     minDuration: 5 * 60 * 1000 },
 
  jealous: { halfLife: 2 * 60 * 60 * 1000, minDuration: 15 * 60 * 1000 },
 
}
 
function calculateDecay(mood: string, timestamp: string, intensity: number) {
 
  const elapsed = Date.now() - new Date(timestamp).getTime()
 
  const config = DECAY_CONFIG[mood]
 
  // 最短持续时间内不衰减
 
  if (elapsed < config.minDuration) return intensity
 
  // 半衰期指数衰减
 
  const decayFactor = Math.pow(0.5, elapsed / config.halfLife)
 
  const newIntensity = Math.round(intensity * decayFactor)
 
  // 强度低于阈值，回到平静
 
  return newIntensity < 10 ? 0 : newIntensity
 
}

// index.ts
const EMOTION_PRIORITY = {
 
  angry: 5,    // 最高优先级，生气最难被覆盖
 
  sad: 4,
 
  jealous: 3,
 
  shy: 2,
 
  happy: 1,
 
  calm: 0,     // 最低优先级
 
}
 
function resolveConflict(
 
  currentMood: string,
 
  candidates: { state: string, intensity: number }[]
 
) {
 
  // 如果当前是高优先级情绪，且候选中有降级的（如道歉）
 
  // 则优先处理降级，因为"解决冲突"比"制造新冲突"重要
 
  const deescalation = candidates.find(c =>
 
    EMOTION_PRIORITY[c.state] < EMOTION_PRIORITY[currentMood]
 
  )
 
  if (deescalation) return deescalation
 
  // 否则选择优先级最高的候选
 
  return candidates.sort((a, b) =>
 
    EMOTION_PRIORITY[b.state] - EMOTION_PRIORITY[a.state]
 
  )[0]
 
}

// index.ts
const COOLDOWN_MS = 5000 // 5秒冷却期
 
function canTransition(state: AgentState): boolean {
 
  const elapsed = Date.now() - new Date(state.moodTimestamp).getTime()
 
  return elapsed >= COOLDOWN_MS
 
}