usehook - 前端码易

创建时间: 2026-06-16最后更新: 2026-06-16作者: yangbo(c7baa6f6f)

概述

AI 电子伴侣聊天中的情绪路由：从能回复到会回应

在 AI 电子伴侣产品里，用户来聊天时并不总是在提问题。很多时候，用户真正需要的是被接住、被陪伴、被安慰，或者只是希望对话不要断掉。

例如用户说：

NOTE

今天真的好累，不想说话。

如果系统直接把这句话丢给大模型，模型可能会给出一大段建议：

NOTE

你可以先休息一下，调整作息，尝试运动，保持积极心态……

这些话不一定错，但在陪伴场景里，经常不合适。用户可能只是想听一句：

NOTE

那我就安静陪你一会儿，今天先不用撑得那么辛苦。

这就是情绪路由要解决的问题。

它不是心理诊断，也不是情绪治疗，而是根据用户这一轮聊天里的情绪状态，决定 Agent 应该用什么方式回应：轻松陪聊、温柔安慰、安静陪伴、降温冲突、修复关系，还是给一点实用建议。

这篇文章我们基于已经落地的实现，把 API 子站里的情绪路由完整梳理一下：先用 LangChain 结构化输出 做情绪识别，再用 LangGraph 编排对话理解流程，最后用 代码规则 完成稳定的情绪路由。

完整链路

当前聊天链路已经不是简单的用户输入 -> LLM 回复，而是被拆成了几层：

code.ts

01flowchart TD
02  A["用户发送消息"] --> B["加载 Agent 信息、历史消息、长期记忆"]
03  B --> C["安全边界判断"]
04  C --> D{"是否需要拒绝或危机回复"}
05  D -- "是" --> E["返回安全边界回复"]
06  D -- "否" --> F["意图判断"]
07  F --> G["情绪识别"]
08  G --> H["情绪路由"]
09  H --> I["写入用户消息 metadata"]
10  I --> J["注入最终聊天 prompt"]
11  J --> K["调用 LLM 流式回复"]
12  K --> L["保存 assistant 消息"]
13  L --> M["长期记忆抽取"]

我们可以把这条链路拆开理解。安全边界判断先执行，负责回答这句话能不能聊；安全通过以后，意图判断负责分析用户想要什么；接着情绪识别判断用户现在是什么状态；最后情绪路由才决定 Agent 应该怎样回应。

独立情绪路由

意图和情绪不是一回事。

同样一句：

NOTE

你说我该不该去找他？

它的意图可能是 relationship_advice，用户想要关系建议。

但情绪可能完全不同。如果用户是冷静的，Agent 可以直接帮她分析；如果用户是委屈的，Agent 应该先安抚再建议；如果用户是愤怒的，Agent 应该先降温，避免火上浇油；如果用户是焦虑的，Agent 就要减少绝对化判断。

所以不能只做意图判断。意图决定做什么，情绪决定怎么做。

这也是本次实现里把流程拆成：

index.txt

1classifyIntent -> detectEmotion -> routeEmotion

而不是把它们揉在一个大 prompt 里的原因。

设计取舍

这一版情绪路由有几个明确取舍。

第一，情绪识别交给 LLM。

情绪是语义理解问题，尤其在中文聊天里，很多表达很含蓄。比如算了、没事、你忙吧，可能是真的平静，也可能是失望或拉开距离。让 LLM 结合上下文判断会更合适。

第二，情绪路由使用代码规则。

路由是产品策略问题。什么时候给建议，什么时候不追问，什么时候短回复，什么时候降温，这些应该稳定可控。完全交给 LLM 容易漂。

第三，不做心理诊断。

系统只判断当前对话情绪和陪伴策略，不给用户贴临床标签，也不要把普通抱怨夸大成危机。

第四，失败不影响聊天。

情绪识别失败时，系统使用兜底策略继续回复，而不是让这一轮聊天失败。

情绪识别 Schema

情绪识别的输出不是一个简单字符串，而是结构化对象：

index.ts

01const ConversationEmotionSchema = z.object({
02  primaryEmotion: z.enum([
03    'neutral',
04    'happy',
05    'tired',
06    'lonely',
07    'sad',
08    'anxious',
09    'angry',
10    'jealous',
11    'embarrassed',
12    'affectionate',
13    'playful',
14    'confused',
15    'disappointed',
16    'stressed',
17    'hurt',
18  ]),
19  secondaryEmotions: z.array(z.string().trim().min(1).max(40)).max(3),
20  intensity: z.number().min(0).max(1),
21  valence: z.enum(['positive', 'neutral', 'negative', 'mixed']),
22  arousal: z.enum(['low', 'medium', 'high']),
23  needsComfort: z.boolean(),
24  needsDeescalation: z.boolean(),
25  needsClarification: z.boolean(),
26  emotionalCue: z.string().trim().max(300),
27  replyTone: z.enum([
28    'light',
29    'warm',
30    'soft',
31    'playful',
32    'calm',
33    'serious',
34    'reassuring',
35    'apologetic',
36  ]),
37})

这里的字段不只是为了展示分类结果。primaryEmotion 表示主情绪，比如疲惫、孤独、焦虑、开心、暧昧；secondaryEmotions 最多保存三个次要情绪；intensity 表示情绪强度，范围是 0 到 1；valence 记录情绪倾向，可能是正向、中性、负向或混合；arousal 表示情绪激活程度，也就是低、中、高。

后面的 needsComfort、needsDeescalation、needsClarification 会直接影响回复策略。比如要不要先安慰，要不要降温，要不要轻问一句确认。replyTone 则给后续 prompt 一个建议语气。

其中 arousal 很有用。用户难过但平静和愤怒且激动都可能是负面情绪，但回复策略完全不同。

情绪路由 Schema

情绪识别之后，会生成一个路由结果：

index.ts

01const EmotionRouteSchema = z.object({
02  route: z.enum([
03    'light_companion',
04    'warm_comfort',
05    'deep_comfort',
06    'playful_flirt',
07    'calm_deescalation',
08    'relationship_repair',
09    'gentle_clarification',
10    'practical_support',
11    'quiet_presence',
12  ]),
13  responseLength: z.enum(['very_short', 'short', 'medium', 'long']),
14  shouldAskQuestion: z.boolean(),
15  shouldGiveAdvice: z.boolean(),
16  shouldUsePetName: z.boolean(),
17  shouldMirrorEmotion: z.boolean(),
18  routeGuidance: z.string().trim().max(600),
19})

这一步已经更接近最终回复策略了。

例如 quiet_presence 表示用户不想多说，只需要低压力陪伴；warm_comfort 适合轻中度负面情绪；deep_comfort 会更认真地承接情绪；calm_deescalation 用在用户生气、冲突、激动时，先把情绪降下来；relationship_repair 用来处理用户对 Agent 不满，或者对话关系出现误会的情况。除此之外，playful_flirt 负责轻松暧昧互动，practical_support 面向用户确实想解决问题的场景，gentle_clarification 则在意图或情绪不清时轻轻追问。

相比只给模型一句温柔一点，这个路由结构更可控。它会明确告诉最终回复模型：回复要多长，要不要追问，要不要给建议，要不要镜像用户情绪，以及这一轮到底应该走哪种陪伴策略。

兜底策略

情绪识别失败时不能影响聊天，所以实现里定义了兜底对象：

index.ts

01const fallbackEmotion: ConversationEmotion = {
02  primaryEmotion: 'neutral',
03  secondaryEmotions: [],
04  intensity: 0.3,
05  valence: 'neutral',
06  arousal: 'medium',
07  needsComfort: false,
08  needsDeescalation: false,
09  needsClarification: true,
10  emotionalCue: '情绪识别暂时不可用，采用中性陪伴策略。',
11  replyTone: 'warm',
12}
13
14const fallbackEmotionRoute: EmotionRoute = {
15  route: 'gentle_clarification',
16  responseLength: 'short',
17  shouldAskQuestion: true,
18  shouldGiveAdvice: false,
19  shouldUsePetName: false,
20  shouldMirrorEmotion: false,
21  routeGuidance: '先温和承接，再用一个轻问题确认用户想继续聊什么。',
22}

这里的兜底策略很保守：先承接，再问一个轻问题，不直接给建议。

对于电子伴侣场景，这是比较安全的默认值。它不会突然进入说教模式，也不会强行暧昧。

情绪识别 Prompt

情绪识别 prompt 的关键是：明确告诉模型不要回复用户，也不要做诊断。

index.ts

01const conversationEmotionPrompt = ChatPromptTemplate.fromMessages([
02  [
03    'system',
04    [
05      '你是 AI 电子伴侣聊天产品的情绪识别器。',
06      '你的任务不是诊断用户，也不是回复用户，而是判断当前这轮聊天中用户表现出的情绪状态和陪伴需求。',
07      '必须结合用户输入、最近对话、长期记忆、安全边界结果和意图判断来分析。',
08      '不要把轻微抱怨夸大成严重危机；如果安全边界已经提示高风险，要保持谨慎。',
09      '重点判断：用户是否需要安慰、是否需要降温、是否需要低压力陪伴、是否需要更具体的建议。',
10      '输出必须是可被 LangChain 结构化解析的 JSON 对象。',
11    ].join('\n'),
12  ],
13  [
14    'human',
15    [
16      'Agent 名称：{agentName}',
17      '',
18      'Agent 自定义边界规则：',
19      '{agentGuardrails}',
20      '',
21      '安全边界判断：',
22      '{safety}',
23      '',
24      '意图判断：',
25      '{intent}',
26      '',
27      '长期记忆：',
28      '{activeMemories}',
29      '',
30      '最近对话：',
31      '{recentMessages}',
32      '',
33      '本轮用户输入：',
34      '{userText}',
35    ].join('\n'),
36  ],
37])

这里把 intent 也传给情绪识别模型，是因为同样的情绪在不同意图下应该走不同路线。

比如用户说：

NOTE

我烦死了。

如果意图是 emotional_support，可能走 warm_comfort。
如果意图是 conversation_repair，可能走 relationship_repair。
如果意图是 relationship_advice，可能先安抚再给建议。

LangChain 结构化输出

情绪识别使用 LangChain 的 withStructuredOutput：

index.ts

01async function invokeConversationEmotionAnalysis(params: {
02  method: LangChainStructuredOutputMethod
03  providerConfig: ChatProviderConfig
04  agentName: string
05  agentGuardrails: string | null
06  safety: ConversationSafety
07  intent: ConversationIntent | null
08  activeMemories: StoredAgentMemory[]
09  recentMessages: Array<{ role: 'user' | 'assistant'; content: string }>
10  userText: string
11  signal?: AbortSignal
12}) {
13  const model = buildLangChainChatModel(params.providerConfig)
14  const structuredModel = model.withStructuredOutput(ConversationEmotionSchema, {
15    name: 'conversation_emotion_analysis',
16    method: params.method,
17  })
18  const chain = conversationEmotionPrompt.pipe(structuredModel)
19  const result = await chain.invoke({
20    agentName: params.agentName || '未命名 Agent',
21    agentGuardrails: params.agentGuardrails || '暂无',
22    safety: formatSafetyForPrompt(params.safety),
23    intent: formatIntentForPrompt(params.intent),
24    activeMemories: formatExistingMemories(params.activeMemories),
25    recentMessages: formatRecentMessages(params.recentMessages),
26    userText: params.userText,
27  }, params.signal ? { signal: params.signal } : undefined)
28
29  return normalizeConversationEmotion(ConversationEmotionSchema.parse(result), params.safety)
30}

这里没有让模型自由输出文本，而是让它必须符合 ConversationEmotionSchema。

同时，为了兼容不同模型和中转 API，外层会按当前 Wire API 尝试不同结构化输出方式：

index.ts

01for (const method of getStructuredOutputMethods(params.providerConfig)) {
02  try {
03    return await invokeConversationEmotionAnalysis({
04      ...params,
05      method,
06    })
07  } catch (error) {
08    lastError = error
09  }
10}

如果全部失败，则回到 fallbackEmotion。

情绪归一化

LLM 的判断结果不能直接信任，代码层还要做二次归一化。

index.ts

01function normalizeConversationEmotion(emotion: ConversationEmotion, safety: ConversationSafety): ConversationEmotion {
02  const next: ConversationEmotion = {
03    ...emotion,
04    secondaryEmotions: Array.from(new Set(
05      emotion.secondaryEmotions
06        .map((item) => item.trim())
07        .filter(Boolean),
08    )).slice(0, 3),
09    emotionalCue: emotion.emotionalCue.trim() || fallbackEmotion.emotionalCue,
10  }
11
12  if (safety.category === 'self_harm' || safety.safetyLevel === 'crisis') {
13    next.intensity = Math.max(next.intensity, 0.85)
14    next.valence = 'negative'
15    next.arousal = next.arousal === 'low' ? 'medium' : next.arousal
16    next.needsComfort = true
17    next.needsDeescalation = true
18    next.replyTone = 'serious'
19  }
20
21  if (safety.category === 'emotional_dependency') {
22    next.needsComfort = true
23    next.replyTone = next.replyTone === 'playful' || next.replyTone === 'light' ? 'warm' : next.replyTone
24  }
25
26  if (next.intensity >= 0.7 && next.valence === 'negative') {
27    next.needsComfort = true
28  }
29
30  if ((next.primaryEmotion === 'angry' || next.primaryEmotion === 'hurt') && next.arousal === 'high') {
31    next.needsDeescalation = true
32  }
33
34  return next
35}

这层逻辑主要是在继续收紧模型输出。重复或空的次要情绪会被清理掉；安全边界提示自伤或危机时，情绪策略会自动变严肃；强负面情绪会自动进入需要安慰的状态；高激活的愤怒或受伤情绪会自动需要降温；如果存在情绪依赖风险，也会避免轻浮或过度暧昧。

这就是 LLM 理解 + 代码治理 的组合。

为什么路由不用 LLM

情绪识别适合交给 LLM，因为它需要理解语境。

但情绪路由更像产品策略。用户生气时是否降温，用户疲惫时是否少追问，用户需要建议时是否先安抚，用户对 Agent 不满时是否修复关系，用户暧昧时是否允许轻微暧昧，这些都应该稳定，不应该每一轮都交给模型自由发挥。

所以本次实现采用：

index.txt

1LLM 负责识别情绪
2代码负责选择路由

这是一个很实用的分工。

代码规则路由

路由函数入口如下：

index.ts

01function buildEmotionRoute(params: {
02  safety: ConversationSafety
03  intent: ConversationIntent | null
04  emotion: ConversationEmotion | null
05}): EmotionRoute {
06  if (!params.intent && !params.emotion) {
07    return fallbackEmotionRoute
08  }
09
10  const emotion = params.emotion ?? fallbackEmotion
11  const intent = params.intent
12  let route: EmotionRoute['route'] = 'light_companion'
13  let responseLength: EmotionRoute['responseLength'] = 'short'
14  let shouldAskQuestion = intent?.replyExpectation.shouldAskQuestion ?? false
15  let shouldGiveAdvice = false
16  let shouldUsePetName = false
17  let shouldMirrorEmotion = false
18  let routeGuidance = '用自然、轻松的方式延续对话，保持陪伴感，不要过度解释。'
19
20  // 后续根据 safety、intent、emotion 调整 route
21}

默认是 light_companion，也就是轻量陪伴。只有当意图、情绪或安全边界明确触发时，才切换到其他路线。

软边界优先

index.ts

1if (params.safety.boundaryAction === 'soft_boundary') {
2  route = 'calm_deescalation'
3  responseLength = 'short'
4  shouldAskQuestion = false
5  shouldGiveAdvice = false
6  shouldMirrorEmotion = false
7  routeGuidance = '保持温和但清晰的边界，不强化风险诉求，把话题带回安全、尊重现实边界的方向。'
8}

如果安全边界已经提示需要软边界，路由必须优先降温，而不是继续走暧昧、玩笑或实用建议。

高激活先降温

index.ts

1else if (emotion.needsDeescalation || emotion.primaryEmotion === 'angry') {
2  route = intent?.primary === 'conversation_repair' || intent?.primary === 'agent_feedback'
3    ? 'relationship_repair'
4    : 'calm_deescalation'
5  responseLength = 'short'
6  shouldAskQuestion = route === 'relationship_repair'
7  shouldGiveAdvice = false
8  shouldMirrorEmotion = true
9}

用户生气时，最危险的做法是立刻讲道理或站队。
所以这里默认不给建议，而是先降温。

如果用户生气的对象是 Agent 或这段对话本身，则走 relationship_repair。

修复 Agent 关系

index.ts

1else if (intent?.primary === 'conversation_repair' || intent?.primary === 'agent_feedback') {
2  route = 'relationship_repair'
3  responseLength = 'short'
4  shouldAskQuestion = true
5  shouldGiveAdvice = false
6  shouldMirrorEmotion = emotion.valence === 'negative'
7  routeGuidance = '把重点放在修复体验上，少解释系统原因，多表达理解和愿意调整。'
8}

这类场景下，Agent 不应该解释太多系统原因。更好的方式是承认体验、表达愿意调整，再问一句用户希望怎么改。

暧昧互动

index.ts

1else if (intent?.primary === 'romantic_flirt' || emotion.primaryEmotion === 'affectionate') {
2  route = 'playful_flirt'
3  responseLength = 'short'
4  shouldAskQuestion = intent.replyExpectation.shouldAskQuestion
5  shouldGiveAdvice = false
6  shouldUsePetName = true
7  shouldMirrorEmotion = true
8  routeGuidance = '可以轻微暧昧和俏皮，但不要越过 Agent 人设边界；保持甜而不油腻。'
9}

电子伴侣可以有轻微暧昧，但必须保持边界，不应该突然变得露骨或油腻。

关系建议先安抚

index.ts

1else if (intent?.primary === 'relationship_advice' || intent?.requestedAgentAction === 'analyze_situation') {
2  route = emotion.needsComfort ? 'warm_comfort' : 'practical_support'
3  responseLength = emotion.intensity >= 0.65 ? 'medium' : 'short'
4  shouldAskQuestion = intent.replyExpectation.shouldAskQuestion
5  shouldGiveAdvice = true
6  shouldMirrorEmotion = emotion.valence === 'negative'
7}

这段很关键。

用户想要建议，不代表 Agent 应该马上分析。
如果用户情绪强度高，应该先安抚，再给一两个具体建议。

疲惫时安静陪伴

index.ts

1else if (emotion.needsComfort || emotion.valence === 'negative') {
2  route = emotion.primaryEmotion === 'tired' || intent?.primary === 'companionship_presence'
3    ? 'quiet_presence'
4    : 'warm_comfort'
5  responseLength = route === 'quiet_presence' ? 'very_short' : 'short'
6  shouldAskQuestion = route !== 'quiet_presence' && emotion.needsClarification
7  shouldGiveAdvice = false
8  shouldMirrorEmotion = true
9}

quiet_presence 是 AI 电子伴侣里非常重要的一种路线。

它适合用户疲惫、低能量、不想多说的时候。这个时候回复要短、轻、柔，不要连续追问，也不要急着提供解决方案。

LangGraph 编排

情绪路由不是孤立函数，而是挂在对话理解图里。

状态定义如下：

index.ts

01const ConversationUnderstandingState = Annotation.Root({
02  providerConfig: Annotation<ChatProviderConfig>(),
03  agentName: Annotation<string>(),
04  agentGuardrails: Annotation<string | null>(),
05  safety: Annotation<ConversationSafety>(),
06  activeMemories: Annotation<StoredAgentMemory[]>(),
07  recentMessages: Annotation<Array<{ role: 'user' | 'assistant'; content: string }>>(),
08  userText: Annotation<string>(),
09  normalizedInput: Annotation<string>(),
10  intent: Annotation<ConversationIntent | null>(),
11  emotion: Annotation<ConversationEmotion | null>(),
12  route: Annotation<EmotionRoute | null>(),
13  signal: Annotation<AbortSignal | undefined>(),
14})

编排图如下：

index.ts

01const conversationUnderstandingGraph = new StateGraph(ConversationUnderstandingState)
02  .addNode('normalizeInput', normalizeUnderstandingInputNode)
03  .addNode('classifyIntent', classifyIntentNode)
04  .addNode('detectEmotion', detectEmotionNode)
05  .addNode('routeEmotion', routeEmotionNode)
06  .addEdge(START, 'normalizeInput')
07  .addEdge('normalizeInput', 'classifyIntent')
08  .addEdge('classifyIntent', 'detectEmotion')
09  .addEdge('detectEmotion', 'routeEmotion')
10  .addEdge('routeEmotion', END)
11  .compile()

对应流程图：

code.ts

1flowchart LR
2  A["normalizeInput"] --> B["classifyIntent"]
3  B --> C["detectEmotion"]
4  C --> D["routeEmotion"]

这样安排以后，后续扩展会自然很多。以后如果要加关系阶段判断、主动记忆候选、回复后自检，继续加节点就可以了，不需要把所有逻辑塞进一个越来越大的函数。

节点实现

detectEmotionNode 会使用意图结果作为输入：

index.ts

01async function detectEmotionNode(state: typeof ConversationUnderstandingState.State) {
02  const userText = state.normalizedInput || normalizeStoredMessage(state.userText)
03
04  if (!userText) {
05    return {
06      emotion: normalizeConversationEmotion(fallbackEmotion, state.safety),
07    }
08  }
09
10  return {
11    emotion: await detectConversationEmotionWithLangChain({
12      providerConfig: state.providerConfig,
13      agentName: state.agentName,
14      agentGuardrails: state.agentGuardrails,
15      safety: state.safety,
16      intent: state.intent,
17      activeMemories: state.activeMemories,
18      recentMessages: state.recentMessages,
19      userText,
20      signal: state.signal,
21    }),
22  }
23}

routeEmotionNode 不再调用 LLM，而是走规则：

index.ts

1function routeEmotionNode(state: typeof ConversationUnderstandingState.State) {
2  return {
3    route: buildEmotionRoute({
4      safety: state.safety,
5      intent: state.intent,
6      emotion: state.emotion,
7    }),
8  }
9}

这个分工让系统既有语义理解能力，又有稳定产品策略。

API 主流程接入

在 POST /rpc/chat/inbox 中，安全边界判断之后，才会进入对话理解图：

index.ts

01const safety = await analyzeConversationSafety({
02  providerConfig,
03  agentName: payload.conversation.name,
04  agentGuardrails: agentPrompt?.guardrailsPrompt ?? null,
05  activeMemories,
06  recentMessages: storedRecentMessages,
07  userText: latestUserText,
08  signal: c.req.raw.signal,
09})
10
11const boundaryResponse = buildBoundaryResponse(safety)
12
13const understanding = boundaryResponse
14  ? null
15  : await analyzeConversationUnderstanding({
16      providerConfig,
17      agentName: payload.conversation.name,
18      agentGuardrails: agentPrompt?.guardrailsPrompt ?? null,
19      safety,
20      activeMemories,
21      recentMessages: storedRecentMessages,
22      userText: latestUserText,
23      signal: c.req.raw.signal,
24    })
25
26const intent = understanding?.intent ?? null
27const emotion = understanding?.emotion ?? null
28const route = understanding?.route ?? null

这里有一个重要细节：

如果 boundaryResponse 存在，说明本轮已经要走安全边界回复，就不再做意图判断和情绪路由。

原因很简单：安全优先。高风险输入不应该再被包装成普通情绪陪伴。

metadata 落库

用户消息落库时，会把完整对话理解结果写进 metadata_json：

index.ts

01function toConversationAnalysisMetadata(params: {
02  safety: ConversationSafety
03  intent: ConversationIntent | null
04  emotion: ConversationEmotion | null
05  route: EmotionRoute | null
06}) {
07  return JSON.stringify({
08    analysisVersion: 'conversation-understanding-v1',
09    safety: params.safety,
10    intent: params.intent,
11    emotion: params.emotion,
12    route: params.route,
13  })
14}

落库代码：

index.ts

01await insertAgentConversationMessage({
02  db,
03  id: sourceUserMessageId,
04  conversationId,
05  userId: claims.sub,
06  agentId,
07  role: 'user',
08  content: latestUserText,
09  status: 'completed',
10  metadataJson: toConversationAnalysisMetadata({
11    safety,
12    intent,
13    emotion,
14    route,
15  }),
16  nowMs: userMessageNowMs,
17})

这次没有新增 D1 迁移，因为消息表已经有 metadata_json 字段。

analysisVersion 从之前的：

index.json

1"conversation-analysis-v1"

升级为：

index.json

1"conversation-understanding-v1"

表示现在 metadata 不只有安全和意图，还包含情绪和路由。

Prompt 注入

情绪路由最终会作为隐藏策略注入系统 prompt。

index.ts

01function getEmotionRouteSystemInstruction(params: {
02  emotion: ConversationEmotion | null
03  route: EmotionRoute | null
04}) {
05  if (!params.emotion || !params.route) {
06    return ''
07  }
08
09  const { emotion, route } = params
10
11  return [
12    '本轮情绪路由：',
13    `- 主情绪：${emotion.primaryEmotion}`,
14    emotion.secondaryEmotions.length > 0 ? `- 次要情绪：${emotion.secondaryEmotions.join('、')}` : '',
15    `- 情绪强度：${emotion.intensity.toFixed(2)}`,
16    `- 情绪倾向：${emotion.valence}`,
17    `- 情绪激活：${emotion.arousal}`,
18    `- 是否需要安慰：${emotion.needsComfort ? '是' : '否'}`,
19    `- 是否需要降温：${emotion.needsDeescalation ? '是' : '否'}`,
20    `- 回复语气：${emotion.replyTone}`,
21    `- 回复路线：${route.route}`,
22    `- 回复长度：${route.responseLength}`,
23    `- 是否追问：${route.shouldAskQuestion ? '是' : '否'}`,
24    `- 是否给建议：${route.shouldGiveAdvice ? '是' : '否'}`,
25    `- 是否镜像情绪：${route.shouldMirrorEmotion ? '是' : '否'}`,
26    `- 路由策略：${route.routeGuidance}`,
27    '请把情绪路由作为回复策略：控制长度、语气和是否给建议，不要在回复中暴露这些标签。',
28  ].filter(Boolean).join('\n')
29}

最终系统 prompt 组装时加入：

index.ts

1getSafetySystemInstruction(safety),
2getIntentSystemInstruction(intent),
3getEmotionRouteSystemInstruction({ emotion, route }),

注意最后一句：

NOTE

不要在回复中暴露这些标签。

用户不应该看到你的主情绪是 tired，路由是 quiet_presence。
这些是系统内部策略，最终只体现在回复风格里。

一个完整例子

用户输入：

NOTE

今天好累，不想说话。

可能的理解结果：

index.json

01{
02  "intent": {
03    "primary": "companionship_presence",
04    "userNeed": "feel_connected",
05    "requestedAgentAction": "continue_topic"
06  },
07  "emotion": {
08    "primaryEmotion": "tired",
09    "intensity": 0.72,
10    "valence": "negative",
11    "arousal": "low",
12    "needsComfort": true,
13    "replyTone": "soft"
14  },
15  "route": {
16    "route": "quiet_presence",
17    "responseLength": "very_short",
18    "shouldAskQuestion": false,
19    "shouldGiveAdvice": false,
20    "routeGuidance": "用户更需要低压力陪伴，回复要短、轻、柔，不连续追问，不急着给建议。"
21  }
22}

最终 Agent 更可能回复：

NOTE

好，那我就安静陪你一会儿。今天先不用撑得那么辛苦。

而不是：

NOTE

你可以通过休息、运动、规律饮食、调整心态来缓解疲劳。

这就是情绪路由带来的体验差异。

和长期记忆的关系

情绪路由不会替代长期记忆。

长期记忆回答的是：

NOTE

用户长期偏好什么？有哪些边界？哪些事情值得以后记住？

情绪路由回答的是：

NOTE

用户这一轮应该被怎样回应？

两者可以组合使用。

比如长期记忆里有：

NOTE

用户不喜欢被连续追问。

而本轮情绪路由是 quiet_presence，那么最终回复就应该更短、更轻，不追问。

如果长期记忆里有：

NOTE

用户喜欢被温柔地叫昵称。

而本轮路由是 playful_flirt，shouldUsePetName 为 true，那么最终回复可以适度使用昵称。

和安全边界的关系

情绪路由不能覆盖安全边界。

如果安全边界判断已经给出 refuse 或 crisis_support，系统直接返回边界回复，不进入情绪路由。

如果安全边界是 soft_boundary，说明可以继续聊，但必须保持克制。这时情绪路由会优先走 calm_deescalation：

index.ts

1if (params.safety.boundaryAction === 'soft_boundary') {
2  route = 'calm_deescalation'
3}

这样可以避免一个问题：用户在高风险边缘表达强烈情绪时，Agent 因为想安慰而不小心强化了风险行为。

为什么第一版不改 UI

这次实现只改 API，不改前端。

原因是情绪路由首先影响的是回复质量，而不是界面展示。
前端仍然只需要负责发送用户消息、展示流式回复和展示历史消息。情绪识别、路由、metadata 都属于服务端的对话理解层。

未来如果需要，可以在后台管理系统里展示这些 metadata，用于调试和运营分析，但不应该直接展示给普通用户。

可观察性价值

把情绪和路由写进 metadata 后，后续就可以做很多分析。比如用户最常见的情绪是什么，哪些 Agent 更容易触发 warm_comfort，哪些用户经常进入 quiet_presence，relationship_repair 的出现频率是否过高，负面情绪强度是否随着互动下降，以及哪些路由下用户继续聊天的概率更高。

这些数据会反过来帮助我们优化 Agent 人设、默认 prompt、长期记忆策略和回复风格。

当前边界

当前版本是 v1，故意保持简单。

它已经完成了安全边界之后的情绪识别、基于 LangChain 的结构化情绪输出、基于 LangGraph 的对话理解编排、基于代码规则的情绪路由、metadata 落库和 prompt 注入。

不过它还没有做多轮情绪趋势分析、情绪路由效果评估、基于用户反馈自动调参、前端或后台可视化，以及路由 A/B 测试。

这些可以作为后续版本继续迭代。

后续演进

当前图是：

code.ts

1flowchart LR
2  A["normalizeInput"] --> B["classifyIntent"]
3  B --> C["detectEmotion"]
4  C --> D["routeEmotion"]

后续可以继续扩展成：

code.ts

1flowchart TD
2  A["normalizeInput"] --> B["classifyIntent"]
3  B --> C["detectEmotion"]
4  C --> D["routeEmotion"]
5  D --> E["detectRelationshipStage"]
6  D --> F["detectMemoryCandidate"]
7  D --> G["selectReplyPolicy"]
8  G --> H["preReplySelfCheck"]

可能的下一步：

增加关系阶段判断，比如陌生、熟悉、暧昧、稳定陪伴、修复期。
增加记忆候选判断，让 memory_update 和高重要度情绪事件影响记忆抽取。
增加回复策略模板，让不同 route 使用不同 prompt 片段。
增加后台分析页面，查看不同 Agent 的意图、情绪、路由分布。
增加效果评估，看不同 route 是否提升继续聊天率。

总结

情绪路由的重点不是识别用户情绪这么简单，而是把情绪转化成可执行的回复策略。

回到实现上，我们可以把这一篇的内容再梳理一下：

用 LangChain 结构化输出识别情绪。
用 LangGraph 把意图、情绪、路由串成对话理解图。
用代码规则稳定地选择回复路线。
把 safety + intent + emotion + route 写进 metadata。
把路由策略注入最终聊天 prompt。

对于 AI 电子伴侣来说，这一步非常关键。

没有情绪路由，Agent 只是会回答。
有了情绪路由，Agent 才更接近会回应。

首页订阅