dsh-agent-soul 0.2.0 → 0.4.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/mood.js CHANGED
@@ -44,6 +44,37 @@ export const DIMS = Object.freeze([
44
44
  /** 时间线留多少条(老的挤掉,防止 state 文件无限膨胀)。 */
45
45
  export const TIMELINE_CAP = 200
46
46
 
47
+ /**
48
+ * 七情的「满格」= 20,不是 100。
49
+ *
50
+ * ⚠️ 判定单次上限 ±10,情绪又被 90 分钟半衰期往回磨 —— 2026-10-29 实测一整天
51
+ * 走下来,峰值只到 13(开心)/ 12.8(踏实)。按 100 分制显示的话,「开心 13」
52
+ * 看起来像「才 13%」,其实那是相当高兴了。
53
+ * 取 20:连着两轮明显的好/坏(各 ±5~10)就算满格。
54
+ * 所有对外显示七情的地方(设置页、日记)都按这个折算成百分比。
55
+ */
56
+ export const DIM_FULL = 20
57
+
58
+ /** 七情原始值 → 百分比(0~100,按 20 满格)。 */
59
+ export const dimPercent = (v) => {
60
+ const raw = Number(v)
61
+ if (!Number.isFinite(raw)) return 0
62
+ return Math.round((Math.min(Math.max(raw, 0), DIM_FULL) / DIM_FULL) * 100)
63
+ }
64
+
65
+ /** 百分比 → 一个能读出来的词(比数字更像「她现在怎么样」)。 */
66
+ export const dimWord = (percent) => {
67
+ const p = Number(percent) || 0
68
+ if (p <= 0) return '没有'
69
+ if (p < 25) return '一点点'
70
+ if (p < 50) return '有点'
71
+ if (p < 75) return '挺'
72
+ return '很'
73
+ }
74
+
75
+ /** 这个百分比算不算「最突出」(topDims 的门槛,按百分比而不是原始值)。 */
76
+ const DIM_TOP_PERCENT = 25
77
+
47
78
  const MIN = 60000
48
79
 
49
80
  /** 情绪向 0 衰减的半衰期(分钟)—— 单根情绪比总心情散得快。 */
@@ -82,6 +113,14 @@ const escapeRegExp = (s) => String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
82
113
  /** 七情取整(状态里存小数,只有对外显示取整)。 */
83
114
  export const displayDims = (s) => Object.fromEntries(DIMS.map(([k]) => [k, Math.round(s.dims[k] || 0)]))
84
115
 
116
+ /**
117
+ * 七情的显示值:百分比(按 DIM_FULL=20 满格)。
118
+ *
119
+ * 原始值只留给内部算(驱动、日记的原始快照),**对外一律用这个** ——
120
+ * 「踏实 12.8」在界面上读起来像「才 12%」,实际那是很踏实了。
121
+ */
122
+ export const displayDimPercents = (s) => Object.fromEntries(DIMS.map(([k]) => [k, dimPercent(s?.dims?.[k])]))
123
+
85
124
  export function moodLabel(v) {
86
125
  const n = Math.round(Number(v) || 0)
87
126
  if (n >= 80) return '欢喜'
@@ -111,9 +150,15 @@ export function moodFace(v) {
111
150
  /** 最高的几根七情(≥15 才算数)。 */
112
151
  export function topDims(s, n = 2) {
113
152
  return DIMS
114
- .map(([k, label]) => ({ k, label, v: s.dims[k] || 0 }))
115
- .filter((x) => x.v >= 15)
116
- .sort((a, b) => b.v - a.v)
153
+ .map(([k, label]) => {
154
+ const v = Number(s?.dims?.[k]) || 0
155
+ const p = dimPercent(v)
156
+ return { k, label, v, p, word: dimWord(p) }
157
+ })
158
+ // 门槛按百分比:原来写死 `v >= 15`(100 分制的 15)—— 实测峰值才 12.8,
159
+ // 这个条件永远不成立,设置页「最突出」一直是空的。
160
+ .filter((x) => x.p >= DIM_TOP_PERCENT)
161
+ .sort((a, b) => b.p - a.p)
117
162
  .slice(0, n)
118
163
  }
119
164
 
@@ -474,7 +519,11 @@ export function lastUserTurnOf(session) {
474
519
  if (EXTERNAL_TRIGGER.has(src) || SELF_SPEAK.has(src)) return { text: txt, sourceKind: src }
475
520
  if (isMachineSource(src)) continue
476
521
  // 桥进来的话 = 对方在说话;没见过的来源先按人说话处理(免得把某座桥漏掉)
477
- return { text: txt, sourceKind: BRIDGE_SOURCES.has(src) ? 'user' : (src && src !== 'user' ? 'user' : 'user') }
522
+ // 走到这里说明来源既不是宿主注入的上下文、也不是定时任务/主动搭话,
523
+ // 那就是人说的(本地会话或某座桥)。
524
+ // 原来这里写的是 `BRIDGE_SOURCES.has(src) ? 'user' : (src && src !== 'user' ? 'user' : 'user')`
525
+ // —— 三个分支全返回 'user',纯废代码,容易让人以为还有什么区分逻辑。
526
+ return { text: txt, sourceKind: 'user' }
478
527
  }
479
528
  } catch { /* 读不到就算了 */ }
480
529
  return null
@@ -514,6 +563,9 @@ export function sessionModelOf(agent) {
514
563
  // 判断:用 DSH 自己的模型(一次很短的调用)
515
564
  // --------------------------------------------------------------------------
516
565
 
566
+ /** 单次心情判断的硬上限(毫秒)。超过就放弃这一轮,别把整条判断链堵死。 */
567
+ const JUDGE_TIMEOUT_MS = 25000
568
+
517
569
  /**
518
570
  * 判一轮的心情变化。返回 delta(parseDelta 的形状)或 null。
519
571
  *
@@ -560,25 +612,42 @@ export async function judgeMood(llm, agent, userText, reply, mode, o, note) {
560
612
  source: { kind: 'plugin', plugin: 'dsh-agent-soul' },
561
613
  }]
562
614
  let out = ''
615
+ let timer = null
563
616
  try {
564
- for await (const chunk of llm.stream({
565
- provider: target.provider,
566
- model: target.model,
567
- system: sys,
568
- messages,
569
- // maxTokens 400 太小:reason 是中文口语,一长就被切在 JSON 中间 ⇒ 整轮白判。
570
- // 调大不花钱:maxTokens 只是上限,按实际吐出来的算。
571
- maxTokens: 1000,
572
- temperature: 0.2,
573
- })) {
574
- if (!chunk) continue
575
- if (chunk.type === 'text-delta') out += chunk.text
576
- if (chunk.type === 'finish' && chunk.reason && chunk.reason.kind === 'error') return null
577
- }
617
+ // 超时保护:底层模型万一卡住(网络挂起、provider 不吐字),judgeChain 会永远等下去,
618
+ // 之后**所有回合**的心情判断全被堵死 —— 表现就是「心情从某一刻起再也不动了」。
619
+ // 设一个上限,超时就丢掉这一轮;后台那条流会自己结束,只是结果不再采用。
620
+ const timeout = new Promise((_resolve, reject) => {
621
+ timer = setTimeout(() => reject(new Error(`判断超时(超过 ${JUDGE_TIMEOUT_MS / 1000} 秒)`)), JUDGE_TIMEOUT_MS)
622
+ if (timer !== null && typeof timer.unref === 'function') timer.unref()
623
+ })
624
+ const consume = (async () => {
625
+ for await (const chunk of llm.stream({
626
+ provider: target.provider,
627
+ model: target.model,
628
+ system: sys,
629
+ messages,
630
+ // maxTokens 400 太小:reason 是中文口语,一长就被切在 JSON 中间 ⇒ 整轮白判。
631
+ // 调大不花钱:maxTokens 只是上限,按实际吐出来的算。
632
+ maxTokens: 1000,
633
+ temperature: 0.2,
634
+ })) {
635
+ if (!chunk) continue
636
+ if (chunk.type === 'text-delta') out += chunk.text
637
+ if (chunk.type === 'finish' && chunk.reason && chunk.reason.kind === 'error') return false
638
+ }
639
+ return true
640
+ })()
641
+ // 超时之后 consume 仍可能抛(流断掉),先挂个空 catch 吞掉,否则变成 unhandledRejection
642
+ consume.catch(() => {})
643
+ const finished = await Promise.race([consume, timeout])
644
+ if (finished === false) return null
578
645
  } catch (e) {
579
646
  // 静默失败会让「心情停住不动」毫无线索:至少留一行日志,诊断时不至于全靠猜
580
647
  if (note) note('mood', `判断调用失败:${e instanceof Error ? e.message : String(e)}`)
581
648
  return null
649
+ } finally {
650
+ if (timer !== null) clearTimeout(timer)
582
651
  }
583
652
  return parseDelta(out, o.owner)
584
653
  }
@@ -587,7 +656,14 @@ export async function judgeMood(llm, agent, userText, reply, mode, o, note) {
587
656
  // 每轮钩子:懒挂 agent 的 turn-stopping(挂一次就够)
588
657
  // --------------------------------------------------------------------------
589
658
 
590
- const mounted = new Map() // agent -> { offs: [] }
659
+ /**
660
+ * agent -> { offs }。**必须是 WeakMap**:agent 身上挂着整个会话的事件历史,
661
+ * 用普通 Map 强引用它就永远回收不掉 —— 会话开了又关,内存只涨不降。
662
+ * 但 WeakMap 不可遍历,unobserveAll 又需要全量拆掉,所以另留一个只存 `{ offs }`
663
+ * 的 Set:它不引用 agent,只是记录有哪些监听还挂着。
664
+ */
665
+ const mounted = new WeakMap()
666
+ const mountedOffs = new Set()
591
667
  let judgeChain = Promise.resolve() // 判断串行,避免多轮堆积互相覆盖
592
668
 
593
669
  /**
@@ -660,18 +736,189 @@ export function observeAgent(agent, { llm, config, note }) {
660
736
  if (note) note('mood', `监听 turn-stopping 失败:${e instanceof Error ? e.message : e}`)
661
737
  }
662
738
 
663
- mounted.set(agent, { offs })
739
+ const entry = { offs }
740
+ mounted.set(agent, entry)
741
+ mountedOffs.add(entry)
664
742
  }
665
743
 
666
744
  /** 拆掉全部钩子(插件卸载/测试用)。 */
667
745
  export function unobserveAll() {
668
- for (const entry of mounted.values()) {
746
+ // 遍历 mountedOffs 而不是 mounted:WeakMap 不可枚举
747
+ for (const entry of mountedOffs) {
669
748
  for (const off of entry.offs) {
670
749
  try { if (typeof off === 'function') off() } catch { /* ignore */ }
671
750
  }
672
751
  }
673
- mounted.clear()
752
+ mountedOffs.clear()
674
753
  }
675
754
 
676
755
  /** 测试用:当前挂了几个 agent。 */
677
- export const observedCount = () => mounted.size
756
+ export const observedCount = () => mountedOffs.size
757
+
758
+ // --------------------------------------------------------------------------
759
+ // 心情摘要(给日记当情绪底色)
760
+ // --------------------------------------------------------------------------
761
+
762
+ /**
763
+ * 毫秒时间戳 → HH:MM(本地时区)。
764
+ * 不写 UTC:日记里的「22:18」得是她感受到的那个钟点。
765
+ */
766
+ export const clockOf = (at) => {
767
+ const d = new Date(Number(at) || 0)
768
+ const pad = (n) => String(n).padStart(2, '0')
769
+ return `${pad(d.getHours())}:${pad(d.getMinutes())}`
770
+ }
771
+
772
+ /**
773
+ * 把一段时间里的心情压成一份摘要(纯函数,不读文件)。
774
+ *
775
+ * ── 为什么要这个 ──
776
+ * 日记原来的素材只有「对话流水 + 摘要」—— 全是事实,没有温度。而心情时间线里
777
+ * 存着她**用第一人称写下的、带情绪的真实想法**(reason 字段),比流水生动得多。
778
+ * 攒了一天却只有仪表盘能看见,太浪费。
779
+ *
780
+ * ── 输入为什么是「状态数组」 ──
781
+ * 心情按工作区分片(每个 cwd 一份文件),日记没有 cwd —— 所以调用方把当天所有
782
+ * 分片一起传进来,这里合并着看:时间线跨分片按时间排序,七情取各分片的**峰值**
783
+ * (今天情绪到过哪,而不是最后停在哪)。
784
+ *
785
+ * @param {object[]} states normMoodState 出来的心情状态(一个或多个)
786
+ * @returns {object} { empty, from, to, low, high, delta, dims, moments }
787
+ */
788
+ export function moodDigest(states, { since = 0, until = 0, maxMoments = 5, dimTop = 3 } = {}) {
789
+ const list = Array.isArray(states) ? states : [states]
790
+ const moments = []
791
+ for (const state of list) {
792
+ if (state === null || typeof state !== 'object') continue
793
+ for (const item of Array.isArray(state.timeline) ? state.timeline : []) {
794
+ const at = Number(item?.at)
795
+ if (!Number.isFinite(at) || at <= 0) continue
796
+ if (since > 0 && at < since) continue
797
+ if (until > 0 && at > until) continue
798
+ const raw = String(item?.reason ?? '').trim()
799
+ // 没有理由的条目只有数字,喂给日记等于没喂
800
+ if (raw === '') continue
801
+ moments.push({
802
+ at,
803
+ mood: Number(item?.mood),
804
+ delta: Number(item?.delta),
805
+ // 截断要留个记号:日记里出现半句话,她会以为是自己的记忆断了
806
+ reason: raw.length > 140 ? `${raw.slice(0, 139)}…` : raw
807
+ })
808
+ }
809
+ }
810
+
811
+ if (moments.length === 0) {
812
+ return { empty: true, from: null, to: null, low: null, high: null, delta: 0, dims: [], fading: [], moments: [] }
813
+ }
814
+
815
+ moments.sort((a, b) => a.at - b.at)
816
+ const values = moments.map((m) => m.mood).filter((v) => Number.isFinite(v))
817
+ const round = (v) => Math.round(Number(v) * 10) / 10
818
+
819
+ // 七情分两件事看:
820
+ // 峰值 —— 今天到过哪(时间线里的快照取最大,也含当前值兜底)
821
+ // 此刻 —— 现在还留着多少(各分片当前 dims 取最大)
822
+ // 两者差得多,说明这股劲儿已经淡下去了 —— 这是日记里才有的一层信息。
823
+ const peak = {}
824
+ const now = {}
825
+ for (const state of list) {
826
+ if (state === null || typeof state !== 'object') continue
827
+ for (const [key] of DIMS) {
828
+ const cur = Number(state.dims?.[key]) || 0
829
+ now[key] = Math.max(Number(now[key]) || 0, cur)
830
+ peak[key] = Math.max(Number(peak[key]) || 0, cur)
831
+ }
832
+ for (const item of Array.isArray(state.timeline) ? state.timeline : []) {
833
+ if (item?.dims === null || typeof item?.dims !== 'object') continue
834
+ for (const [key] of DIMS) peak[key] = Math.max(Number(peak[key]) || 0, Number(item.dims[key]) || 0)
835
+ }
836
+ }
837
+
838
+ const dims = DIMS
839
+ .map(([key, label]) => {
840
+ const percent = dimPercent(peak[key])
841
+ return { key, label, value: Math.round(Number(peak[key]) || 0), percent, word: dimWord(percent) }
842
+ })
843
+ .filter((item) => item.percent > 0)
844
+ .sort((a, b) => b.percent - a.percent)
845
+ .slice(0, Math.max(1, dimTop))
846
+
847
+ // 淡了 25 个百分点以上才算「明显退下去」,差一点点不值得单说
848
+ const fading = dims
849
+ .map((item) => ({ label: item.label, from: item.percent, to: dimPercent(now[item.key]) }))
850
+ .filter((item) => item.from - item.to >= 25)
851
+
852
+ // 挑「起伏最大」的几段,再按时间正序输出(读起来是顺着一天走的)
853
+ const picked = moments
854
+ .slice()
855
+ .sort((a, b) => Math.abs(Number(b.delta) || 0) - Math.abs(Number(a.delta) || 0))
856
+ .slice(0, Math.max(1, maxMoments))
857
+ .sort((a, b) => a.at - b.at)
858
+
859
+ return {
860
+ empty: false,
861
+ from: round(values[0]),
862
+ to: round(values[values.length - 1]),
863
+ low: round(Math.min(...values)),
864
+ high: round(Math.max(...values)),
865
+ delta: round(values[values.length - 1] - values[0]),
866
+ dims,
867
+ fading,
868
+ moments: picked
869
+ }
870
+ }
871
+
872
+ /**
873
+ * 把摘要渲染成给日记的一段(纯函数)。
874
+ *
875
+ * 公开 / 私密两版的区别不只是条数:
876
+ * · 公开版只给心情走向和两三句,措辞是「可以写进去」—— 那是要拿给人看的;
877
+ * · 私密版给全部,措辞是「这是你当时的真实想法」—— 那些 reason 本来就是心里话。
878
+ *
879
+ * 只给**事实与素材**,不给「你要写得开心一点」这类指令:
880
+ * 一旦让她照着情绪演,日记就假了(跟心情不注入提示词是同一个道理)。
881
+ */
882
+ export function renderMoodDigest(digest, { mode = 'public', maxMoments = 3 } = {}) {
883
+ if (digest === null || typeof digest !== 'object' || digest.empty === true) return ''
884
+ const privateMode = mode === 'private'
885
+ const limit = privateMode ? Math.max(1, maxMoments) : Math.min(Math.max(1, maxMoments), 3)
886
+
887
+ const lines = []
888
+ lines.push(privateMode ? '【今天的情绪(只有你自己看得到)】' : '【今天的情绪】')
889
+
890
+ const from = digest.from
891
+ const to = digest.to
892
+ const arrow = from === null ? '' : `心情 ${from} → ${to}`
893
+ const spread = digest.low === null ? '' : `(区间 ${digest.low}~${digest.high}`
894
+ const net = Number(digest.delta) || 0
895
+ const netText = spread === '' ? '' : `,净 ${net > 0 ? '+' : ''}${net})`
896
+ if (arrow !== '') lines.push(`${arrow}${spread}${netText}`)
897
+
898
+ if (Array.isArray(digest.dims) && digest.dims.length > 0) {
899
+ // 按 20 满格折算成百分比:「踏实 64%」比「踏实 13」读得出来
900
+ lines.push(`七情峰值:${digest.dims.map((d) => `${d.label} ${d.percent}%(${d.word})`).join('、')}`)
901
+ }
902
+ const fading = Array.isArray(digest.fading) ? digest.fading : []
903
+ if (fading.length > 0) {
904
+ lines.push(`已经淡下去的:${fading.map((f) => `${f.label} ${f.from}% → ${f.to}%`).join('、')}`)
905
+ }
906
+
907
+ const moments = (Array.isArray(digest.moments) ? digest.moments : []).slice(0, limit)
908
+ if (moments.length > 0) {
909
+ lines.push('')
910
+ lines.push('那天你自己的想法(当时记下的):')
911
+ for (const m of moments) {
912
+ const sign = Number(m.delta) > 0 ? '+' : ''
913
+ const deltaText = Number.isFinite(Number(m.delta)) && Number(m.delta) !== 0 ? `(${sign}${Math.round(m.delta)})` : ''
914
+ lines.push(` ${clockOf(m.at)} ${deltaText} 「${m.reason}」`)
915
+ }
916
+ }
917
+
918
+ lines.push('')
919
+ lines.push(privateMode
920
+ ? '这些是你今天的真实情绪。私密日记里不用收着,可以写公开版里略过的、没说出口的部分。'
921
+ : '写的时候可以带上你当时的心情,但记得这是会拿给对方看的版本。')
922
+
923
+ return lines.join('\n')
924
+ }