cortico-world-wechat-claw 0.1.3 → 0.1.4
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/CHANGELOG.md +17 -0
- package/README.md +30 -0
- package/describe.json +1 -1
- package/dist/webui.js +2 -2
- package/package.json +1 -1
- package/src/ENV_PROMPT.md +19 -0
- package/src/config.ts +74 -0
- package/src/segment.ts +185 -0
- package/src/world.ts +120 -6
package/CHANGELOG.md
CHANGED
|
@@ -1,5 +1,22 @@
|
|
|
1
1
|
# Changelog
|
|
2
2
|
|
|
3
|
+
## 0.1.4
|
|
4
|
+
|
|
5
|
+
新增语义分段发送。
|
|
6
|
+
|
|
7
|
+
- **按语义把一次回复拆成多条微信消息**,一条一条发,像人一句一句说话。
|
|
8
|
+
- **拆分只算一次**:有换行就只按换行拆;没有换行才按句号;再没有才按 `!?…~`。
|
|
9
|
+
换行与句号同时出现时不会拆两次,也不会多出空段。
|
|
10
|
+
- **删谁不删谁**:换行、`。`、`.` 删掉(微信里带句号显得生硬);`!?!?…~~` 只拆不删,语气留着。
|
|
11
|
+
ASCII `.` 只在后面跟空白或位于结尾时才当句号,`3.14`、`docs.nonebot.dev`、`report.md` 不会被切坏。
|
|
12
|
+
- **间隔可配**:固定间隔或随机区间,单位秒。默认固定 2 秒。
|
|
13
|
+
- **两道上限**:单次最多 12 段(超出并进最后一段)、累计等待最多 30 秒(到点就不再等,
|
|
14
|
+
但剩下的**照常发完**,不会因为等不起就漏发)。
|
|
15
|
+
- 每段之间会亮一次「正在输入」,让人看着像还在打字。
|
|
16
|
+
- 环境提示词里说明分段规则,让模型知道换行会变成独立消息、句号会被删掉。
|
|
17
|
+
|
|
18
|
+
默认开启。不想要就在配置页关掉「分段发送」,行为回到 0.1.3。
|
|
19
|
+
|
|
3
20
|
## 0.1.3
|
|
4
21
|
|
|
5
22
|
- **正文里的图片尺寸改成真图尺寸。** 之前用的是 `image_item.thumb_width` / `thumb_height`,
|
package/README.md
CHANGED
|
@@ -78,9 +78,39 @@ corepack pnpm add "<这个包所在的绝对路径>"
|
|
|
78
78
|
| `videoFrames` | `4` | 每条视频抽几帧,0 表示不抽 |
|
|
79
79
|
| `videoFrameMaxEdge` | `640` | 每帧最长边像素 |
|
|
80
80
|
| `ffmpegProxyUrl` | 空 | 下载 ffmpeg 用的代理;留空直连(不继承只给模型用的那条代理) |
|
|
81
|
+
| `segmentEnabled` | `true` | 分段发送:一次回复拆成多条微信消息 |
|
|
82
|
+
| `segmentDelayMode` | `fixed` | `fixed` 固定间隔;`random` 在 `segmentDelayMinSec`~`segmentDelayMaxSec` 之间随机 |
|
|
83
|
+
| `segmentDelayFixedSec` | `2` | 固定间隔,秒 |
|
|
84
|
+
| `segmentDelayMinSec` | `1` | 随机间隔下限,秒 |
|
|
85
|
+
| `segmentDelayMaxSec` | `4` | 随机间隔上限,秒 |
|
|
86
|
+
| `segmentMaxParts` | `12` | 单次最多拆几段,超出并进最后一段 |
|
|
87
|
+
| `segmentMaxTotalSec` | `30` | 累计等待上限,到点不再等但剩下的照常发完 |
|
|
81
88
|
|
|
82
89
|
`bot_token`、同步游标和 `context_token` 都在 `<dataDir>/wechat-claw/`,不进配置、不进日志、不进事件 `meta.raw`。
|
|
83
90
|
|
|
91
|
+
## 分段发送
|
|
92
|
+
|
|
93
|
+
微信里一次吐一大段不像人说话。打开分段发送后,一次回复会拆成几条,一条一条发,条与条之间停顿。
|
|
94
|
+
|
|
95
|
+
**拆分只算一次**,不会拆两次:
|
|
96
|
+
|
|
97
|
+
| 文本里有 | 按什么拆 | 分隔符 |
|
|
98
|
+
|---|---|---|
|
|
99
|
+
| 换行 `\n` | 只按换行 | 删掉 |
|
|
100
|
+
| 没有换行,有句号 `。..` | 只按句号 | 删掉 |
|
|
101
|
+
| 都没有,有 `!?!?…~~` | 只按这些 | **保留** |
|
|
102
|
+
| 都没有 | 整条发 | —— |
|
|
103
|
+
|
|
104
|
+
换行和句号同时出现时(「三层:\n第一。\n第二。」),按换行拆完就结束,句号留在段内,**不会再多拆一次**。
|
|
105
|
+
|
|
106
|
+
**为什么删句号**:微信里带句号显得生硬,像在写公文,真人不这么打字。`!?…~` 留着,因为那是语气。
|
|
107
|
+
|
|
108
|
+
**ASCII `.` 有额外保护**:只在后面跟空白或位于结尾时才当句号。所以 `3.14`、`docs.nonebot.dev`、`report.2026.11.md` 不会被切坏。
|
|
109
|
+
|
|
110
|
+
**两道上限**:单次最多 `segmentMaxParts` 段,多的并进最后一段;累计等待超过 `segmentMaxTotalSec` 就不再多等,但**剩下的照常发完**(不会因为等不起而漏发)。
|
|
111
|
+
|
|
112
|
+
不想要就在配置页关掉「分段发送」。
|
|
113
|
+
|
|
84
114
|
## 视频抽帧
|
|
85
115
|
|
|
86
116
|
视频抽帧要 ffmpeg,但扩展不把它打进包里,**也绝不悄悄下载**。
|
package/describe.json
CHANGED
|
@@ -154,7 +154,7 @@
|
|
|
154
154
|
"key": "worlds.wechat-claw.envPrompt",
|
|
155
155
|
"title": "微信 ClawBot · 环境提示词",
|
|
156
156
|
"role": "envPrompt",
|
|
157
|
-
"content": "微信 ClawBot 是一条一对一私聊通道,接在微信里,只能回复刚发消息的那个人。\n\n## 手边的状态\n\n{{wechat.state | (微信还没接上。)}}\n{{wechat.account | (还没有绑定的微信号。)}}\n{{wechat.lastMessageAt | (还没有收到过微信消息。)}}\n{{wechat.lastError | (最近没有连接错误。)}}\n\n## 什么时候用\n\n微信里来人说话时,会收到一条 `wechat-claw.message`,正文以 `[微信 时间 发送者]` 开头,媒体路径就写在里面。要回话就用 `wechat_send`;图片用 `wechat_send_image`,其他文件用 `wechat_send_file`,两者都接本机绝对路径。\n\n- 对方发来图片时,图片会作为附件一起到达,路径也写在正文里。看不到附件时,按路径自行读取。\n- 对方发来文件时,路径写在正文里,需要内容就按路径读。\n- 对方发来视频时,视频落盘、路径写在正文里;抽帧可用时按时间顺序附几张画面,正文会写明抽了几帧。正文说「视频帧未抽取」就是真的没看过,不要描述画面内容。\n- 对方发来语音时,正文里带服务端的转写文本;语音本身是 SILK 编码,一般不必再处理。没有转写文本时,你只知道时长,不知道说了什么。\n\n## 约束\n\n这条通道只能回复最近发消息的人,不能主动找人,也不能发到别处。`wechat_send` 的回执会写明发给了谁。\n\n一条文本最多 4000 字,超出的部分会自动接着发成下一条,不必自己切。断行位置优先落在段落和句号上。\n\n对方的 `context_token` 会过期。回复被拒并提示没有可用 token 时,等对方再说一句再回,不要反复重试。\n\n这里发出的一切都会真的进到对方的微信里。不确定要不要发的时候,先问清楚。\n"
|
|
157
|
+
"content": "微信 ClawBot 是一条一对一私聊通道,接在微信里,只能回复刚发消息的那个人。\n\n## 手边的状态\n\n{{wechat.state | (微信还没接上。)}}\n{{wechat.account | (还没有绑定的微信号。)}}\n{{wechat.lastMessageAt | (还没有收到过微信消息。)}}\n{{wechat.lastError | (最近没有连接错误。)}}\n\n## 什么时候用\n\n微信里来人说话时,会收到一条 `wechat-claw.message`,正文以 `[微信 时间 发送者]` 开头,媒体路径就写在里面。要回话就用 `wechat_send`;图片用 `wechat_send_image`,其他文件用 `wechat_send_file`,两者都接本机绝对路径。\n\n- 对方发来图片时,图片会作为附件一起到达,路径也写在正文里。看不到附件时,按路径自行读取。\n- 对方发来文件时,路径写在正文里,需要内容就按路径读。\n- 对方发来视频时,视频落盘、路径写在正文里;抽帧可用时按时间顺序附几张画面,正文会写明抽了几帧。正文说「视频帧未抽取」就是真的没看过,不要描述画面内容。\n- 对方发来语音时,正文里带服务端的转写文本;语音本身是 SILK 编码,一般不必再处理。没有转写文本时,你只知道时长,不知道说了什么。\n\n## 约束\n\n这条通道只能回复最近发消息的人,不能主动找人,也不能发到别处。`wechat_send` 的回执会写明发给了谁。\n\n一条文本最多 4000 字,超出的部分会自动接着发成下一条,不必自己切。断行位置优先落在段落和句号上。\n\n## 分段发送\n\n这一段决定你说话的样子,值得花心思。\n\n打开分段发送时,你写的东西会被拆成好几条微信消息,一条一条发出去,条与条之间会停顿,让对方看着像你还在打字。\n\n拆的顺序按一次算,不会拆两次:\n\n- 你写了换行,就只按换行拆;换行会消失,段内不再按标点拆。\n- 没写换行但有句号,就只按句号拆,句号会消失。\n- 都没写,但有 `!?…~`,就按它们拆;它们留着,因为你靠它们表达语气。\n- 都没有,就整条发出去。\n\n所以换行是你的节奏工具:**想让对方连看几行、想顿一下再说下一句,就写换行**。反过来,一句话里硬写换行会被拆成好几个气泡,看着像结巴。\n\n中文句号会被删掉,因为在微信里带句号显得生硬、像在写公文。这就是聊天里很少见句号的原因。别为了排版写句号。\n\n分段与间隔都是对方在配置页设的,你看不到也不必猜;照平时的习惯说话就行。\n\n对方的 `context_token` 会过期。回复被拒并提示没有可用 token 时,等对方再说一句再回,不要反复重试。\n\n这里发出的一切都会真的进到对方的微信里。不确定要不要发的时候,先问清楚。\n"
|
|
158
158
|
}
|
|
159
159
|
]
|
|
160
160
|
}
|
package/dist/webui.js
CHANGED
|
@@ -1,4 +1,4 @@
|
|
|
1
|
-
//
|
|
1
|
+
// src/webui/ffmpeg.ts
|
|
2
2
|
var TEXT = {
|
|
3
3
|
zh: {
|
|
4
4
|
sheet: "ffmpeg",
|
|
@@ -160,7 +160,7 @@ async function mountFfmpeg(ctx) {
|
|
|
160
160
|
await readState();
|
|
161
161
|
}
|
|
162
162
|
|
|
163
|
-
//
|
|
163
|
+
// src/webui/client.ts
|
|
164
164
|
var TEXT2 = {
|
|
165
165
|
zh: {
|
|
166
166
|
sheet: "\u5FAE\u4FE1\u7ED1\u5B9A",
|
package/package.json
CHANGED
package/src/ENV_PROMPT.md
CHANGED
|
@@ -22,6 +22,25 @@
|
|
|
22
22
|
|
|
23
23
|
一条文本最多 4000 字,超出的部分会自动接着发成下一条,不必自己切。断行位置优先落在段落和句号上。
|
|
24
24
|
|
|
25
|
+
## 分段发送
|
|
26
|
+
|
|
27
|
+
这一段决定你说话的样子,值得花心思。
|
|
28
|
+
|
|
29
|
+
打开分段发送时,你写的东西会被拆成好几条微信消息,一条一条发出去,条与条之间会停顿,让对方看着像你还在打字。
|
|
30
|
+
|
|
31
|
+
拆的顺序按一次算,不会拆两次:
|
|
32
|
+
|
|
33
|
+
- 你写了换行,就只按换行拆;换行会消失,段内不再按标点拆。
|
|
34
|
+
- 没写换行但有句号,就只按句号拆,句号会消失。
|
|
35
|
+
- 都没写,但有 `!?…~`,就按它们拆;它们留着,因为你靠它们表达语气。
|
|
36
|
+
- 都没有,就整条发出去。
|
|
37
|
+
|
|
38
|
+
所以换行是你的节奏工具:**想让对方连看几行、想顿一下再说下一句,就写换行**。反过来,一句话里硬写换行会被拆成好几个气泡,看着像结巴。
|
|
39
|
+
|
|
40
|
+
中文句号会被删掉,因为在微信里带句号显得生硬、像在写公文。这就是聊天里很少见句号的原因。别为了排版写句号。
|
|
41
|
+
|
|
42
|
+
分段与间隔都是对方在配置页设的,你看不到也不必猜;照平时的习惯说话就行。
|
|
43
|
+
|
|
25
44
|
对方的 `context_token` 会过期。回复被拒并提示没有可用 token 时,等对方再说一句再回,不要反复重试。
|
|
26
45
|
|
|
27
46
|
这里发出的一切都会真的进到对方的微信里。不确定要不要发的时候,先问清楚。
|
package/src/config.ts
CHANGED
|
@@ -35,6 +35,25 @@ export interface WechatClawConfigSection {
|
|
|
35
35
|
videoFrameMaxEdge: number;
|
|
36
36
|
/** 下载 ffmpeg 用的代理;留空表示直连(不继承只给模型用的那条代理)。 */
|
|
37
37
|
ffmpegProxyUrl: string;
|
|
38
|
+
/**
|
|
39
|
+
* 按语义分段发送。打开后一次回复会拆成多条微信消息,像人一句一句说。
|
|
40
|
+
*
|
|
41
|
+
* 有换行就只按换行拆;没有换行才按句号;再没有才按 `!?…~`。
|
|
42
|
+
* 中文句号删掉(社交软件里带句号显得生硬),情绪标点保留。
|
|
43
|
+
*/
|
|
44
|
+
segmentEnabled: boolean;
|
|
45
|
+
/** 段间等待口径:固定间隔,或在区间内随机。 */
|
|
46
|
+
segmentDelayMode: 'fixed' | 'random';
|
|
47
|
+
/** 固定间隔,秒。 */
|
|
48
|
+
segmentDelayFixedSec: number;
|
|
49
|
+
/** 随机间隔下限,秒。 */
|
|
50
|
+
segmentDelayMinSec: number;
|
|
51
|
+
/** 随机间隔上限,秒。 */
|
|
52
|
+
segmentDelayMaxSec: number;
|
|
53
|
+
/** 单次回复最多拆几条;超出就把剩下的合并进最后一条。 */
|
|
54
|
+
segmentMaxParts: number;
|
|
55
|
+
/** 一次发送累计等待上限,秒;到点就把剩下的一起发完。 */
|
|
56
|
+
segmentMaxTotalSec: number;
|
|
38
57
|
}
|
|
39
58
|
|
|
40
59
|
export const WECHAT_CLAW_DEFAULTS: WechatClawConfigSection = {
|
|
@@ -51,6 +70,13 @@ export const WECHAT_CLAW_DEFAULTS: WechatClawConfigSection = {
|
|
|
51
70
|
videoFrames: 4,
|
|
52
71
|
videoFrameMaxEdge: 640,
|
|
53
72
|
ffmpegProxyUrl: '',
|
|
73
|
+
segmentEnabled: true,
|
|
74
|
+
segmentDelayMode: 'fixed',
|
|
75
|
+
segmentDelayFixedSec: 2,
|
|
76
|
+
segmentDelayMinSec: 1,
|
|
77
|
+
segmentDelayMaxSec: 4,
|
|
78
|
+
segmentMaxParts: 12,
|
|
79
|
+
segmentMaxTotalSec: 30,
|
|
54
80
|
};
|
|
55
81
|
|
|
56
82
|
export const WECHAT_CLAW_CONFIG_GROUP: ConfigGroup = {
|
|
@@ -144,6 +170,54 @@ export const WECHAT_CLAW_CONFIG_GROUP: ConfigGroup = {
|
|
|
144
170
|
description: '抽出的帧会缩到这个尺寸再交给模型。越小越省 token,也越看不清细节。',
|
|
145
171
|
'x-hot': true,
|
|
146
172
|
},
|
|
173
|
+
'worlds.wechat-claw.segmentEnabled': {
|
|
174
|
+
type: 'boolean',
|
|
175
|
+
title: '分段发送',
|
|
176
|
+
description:
|
|
177
|
+
'打开后一次回复拆成多条微信消息,像人一句一句说。'
|
|
178
|
+
+ '有换行就只按换行拆;没有换行才按句号;再没有才按!?…~。'
|
|
179
|
+
+ '中文句号会删掉(社交软件里带句号显得生硬),!?…~ 保留语气。修改后需重启。',
|
|
180
|
+
'x-hot': false,
|
|
181
|
+
},
|
|
182
|
+
'worlds.wechat-claw.segmentDelayMode': {
|
|
183
|
+
type: 'string',
|
|
184
|
+
title: '间隔方式',
|
|
185
|
+
description: '固定间隔,或在区间内随机取值。只在「分段发送」打开时有效。',
|
|
186
|
+
enum: ['fixed', 'random'],
|
|
187
|
+
'x-hot': true,
|
|
188
|
+
},
|
|
189
|
+
'worlds.wechat-claw.segmentDelayFixedSec': {
|
|
190
|
+
type: 'number',
|
|
191
|
+
title: '固定间隔(秒)',
|
|
192
|
+
description: '每一段发完后等这么久。0 表示连着发完。',
|
|
193
|
+
'x-hot': true,
|
|
194
|
+
},
|
|
195
|
+
'worlds.wechat-claw.segmentDelayMinSec': {
|
|
196
|
+
type: 'number',
|
|
197
|
+
title: '随机下限(秒)',
|
|
198
|
+
description: '随机间隔的下界。和上限写反了会自动换过来。',
|
|
199
|
+
'x-hot': true,
|
|
200
|
+
},
|
|
201
|
+
'worlds.wechat-claw.segmentDelayMaxSec': {
|
|
202
|
+
type: 'number',
|
|
203
|
+
title: '随机上限(秒)',
|
|
204
|
+
description: '随机间隔的上界。',
|
|
205
|
+
'x-hot': true,
|
|
206
|
+
},
|
|
207
|
+
'worlds.wechat-claw.segmentMaxParts': {
|
|
208
|
+
type: 'number',
|
|
209
|
+
title: '最多拆几段',
|
|
210
|
+
description:
|
|
211
|
+
'单次回复的上限。超出时把多出来的内容并进最后一段,避免模型输出几十行把这次发送拖很久。',
|
|
212
|
+
'x-hot': true,
|
|
213
|
+
},
|
|
214
|
+
'worlds.wechat-claw.segmentMaxTotalSec': {
|
|
215
|
+
type: 'number',
|
|
216
|
+
title: '总等待上限(秒)',
|
|
217
|
+
description:
|
|
218
|
+
'一次发送里所有间隔加起来的上限。到点就把剩下的一起发完,回执会写明有截断。',
|
|
219
|
+
'x-hot': true,
|
|
220
|
+
},
|
|
147
221
|
},
|
|
148
222
|
},
|
|
149
223
|
};
|
package/src/segment.ts
ADDED
|
@@ -0,0 +1,185 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* 语义分段:把桌宠一次回复切成多条微信消息。
|
|
3
|
+
*
|
|
4
|
+
* 微信里一句一条才像人在说话。这里按「语义」拆,长度上限交给 `splitText`。
|
|
5
|
+
*
|
|
6
|
+
* ## 四种情况,只按一种分隔符拆
|
|
7
|
+
*
|
|
8
|
+
* ```
|
|
9
|
+
* ① 含 \n → 只按 \n 拆
|
|
10
|
+
* ② 无 \n,但有 。/./. → 只按句号拆
|
|
11
|
+
* ③ 无 \n 无句号,但有 !?…~ → 只按这些拆
|
|
12
|
+
* ④ 都没有 → 不分段
|
|
13
|
+
* ```
|
|
14
|
+
*
|
|
15
|
+
* **段内不再二次拆。** 一处文本里同时有换行和句号时(例如「三层:\n…第一。\n…」),
|
|
16
|
+
* 按换行拆完就结束;若再按句号拆一次,会多出空段、节奏也乱。
|
|
17
|
+
*
|
|
18
|
+
* ## 删谁不删谁
|
|
19
|
+
*
|
|
20
|
+
* - `\n`、`。`(U+3002)、`.`(U+FF0E) 删掉:中文社交软件里句号显得生硬,换行是版式。
|
|
21
|
+
* - `.`(U+002E) **只在后面跟空白或位于结尾时**才算句号,删掉。否则 `3.14`、
|
|
22
|
+
* `docs.nonebot.dev`、`report.2026.11.md` 会被切坏。
|
|
23
|
+
* - `!?!?…~~` 只拆不删:它们带情绪,删了语气就变平。
|
|
24
|
+
*
|
|
25
|
+
* ## 哪条规则同时命中
|
|
26
|
+
*
|
|
27
|
+
* 优先级从上往下:只要出现 `\n` 就用换行;只要有中文句号就用句号;
|
|
28
|
+
* 只剩情绪标点才用它。混排时不会两个都用,这正是「只按一次算」的含义。
|
|
29
|
+
*/
|
|
30
|
+
|
|
31
|
+
/** 中文句号与全角句点:无条件当分隔符,且删掉。 */
|
|
32
|
+
const HARD_STOPS = new Set(['。', '.']);
|
|
33
|
+
|
|
34
|
+
/** 情绪标点:只拆不删。 */
|
|
35
|
+
const SOFT_STOPS = new Set(['!', '?', '!', '?', '…', '~', '~']);
|
|
36
|
+
|
|
37
|
+
/** 空白字符(用来判断 ASCII 句点后面是不是断句)。 */
|
|
38
|
+
const isSpace = (ch: string | undefined): boolean => ch === undefined || /\s/.test(ch);
|
|
39
|
+
|
|
40
|
+
/**
|
|
41
|
+
* 判断位置 `i` 的 ASCII 句点算不算句号。
|
|
42
|
+
*
|
|
43
|
+
* 只有「后面是空白或已到结尾」才算。这样 `3.14`、`a.txt`、`example.com` 不会被拆。
|
|
44
|
+
*/
|
|
45
|
+
function isAsciiStop(text: string, i: number): boolean {
|
|
46
|
+
return isSpace(text[i + 1]);
|
|
47
|
+
}
|
|
48
|
+
|
|
49
|
+
/** 一个切点:分隔符起点、终点,以及切完要不要把它留在前一段里。 */
|
|
50
|
+
interface CutPoint {
|
|
51
|
+
/** 分隔符起点。 */
|
|
52
|
+
start: number;
|
|
53
|
+
/** 分隔符终点(不含)。 */
|
|
54
|
+
end: number;
|
|
55
|
+
/**
|
|
56
|
+
* 切完之后,分隔符本身留在前一段末尾(`keep`),还是删掉。
|
|
57
|
+
*
|
|
58
|
+
* `。`/换行删掉;`!?…~` 保留语气,留在前段里。
|
|
59
|
+
*/
|
|
60
|
+
keep: boolean;
|
|
61
|
+
}
|
|
62
|
+
|
|
63
|
+
/** 找出所有切点,按位置升序。 */
|
|
64
|
+
function findCuts(text: string, kind: 'newline' | 'stop' | 'soft'): CutPoint[] {
|
|
65
|
+
const cuts: CutPoint[] = [];
|
|
66
|
+
for (let i = 0; i < text.length; i += 1) {
|
|
67
|
+
const ch = text[i]!;
|
|
68
|
+
if (kind === 'newline') {
|
|
69
|
+
// 换行是版式,不留在正文里。
|
|
70
|
+
if (ch === '\n') cuts.push({ start: i, end: i + 1, keep: false });
|
|
71
|
+
continue;
|
|
72
|
+
}
|
|
73
|
+
if (kind === 'stop') {
|
|
74
|
+
// 句号删掉:社交软件里带着它显得生硬。
|
|
75
|
+
if (HARD_STOPS.has(ch)) {
|
|
76
|
+
cuts.push({ start: i, end: i + 1, keep: false });
|
|
77
|
+
continue;
|
|
78
|
+
}
|
|
79
|
+
if (ch === '.' && isAsciiStop(text, i)) cuts.push({ start: i, end: i + 1, keep: false });
|
|
80
|
+
continue;
|
|
81
|
+
}
|
|
82
|
+
// kind === 'soft':只拆不删,标点留在前一段。
|
|
83
|
+
if (SOFT_STOPS.has(ch)) {
|
|
84
|
+
// 成对的「!?」算一处,别拆两个空段。
|
|
85
|
+
const next = text[i + 1];
|
|
86
|
+
if (next && SOFT_STOPS.has(next) && ch + next === '!?') {
|
|
87
|
+
cuts.push({ start: i, end: i + 2, keep: true });
|
|
88
|
+
i += 1;
|
|
89
|
+
continue;
|
|
90
|
+
}
|
|
91
|
+
cuts.push({ start: i, end: i + 1, keep: true });
|
|
92
|
+
}
|
|
93
|
+
}
|
|
94
|
+
return cuts;
|
|
95
|
+
}
|
|
96
|
+
|
|
97
|
+
/** 有没有可用的分隔符,以及该用哪一种。 */
|
|
98
|
+
function pickKind(text: string): 'newline' | 'stop' | 'soft' | null {
|
|
99
|
+
if (text.includes('\n')) return 'newline';
|
|
100
|
+
if (findCuts(text, 'stop').length > 0) return 'stop';
|
|
101
|
+
if (findCuts(text, 'soft').length > 0) return 'soft';
|
|
102
|
+
return null;
|
|
103
|
+
}
|
|
104
|
+
|
|
105
|
+
/**
|
|
106
|
+
* 按语义把 `text` 拆成若干段。
|
|
107
|
+
*
|
|
108
|
+
* 返回值已去掉分隔符、去掉首尾空白、丢弃空段。不含分隔符时返回单元素数组,
|
|
109
|
+
* 调用方不必区分「拆了」和「没拆」。
|
|
110
|
+
*
|
|
111
|
+
* 这里**只管语义**,不管单条长度上限:结果里某段仍超过微信的 4000 字时,
|
|
112
|
+
* 由调用方交给 `splitText` 再切。
|
|
113
|
+
*/
|
|
114
|
+
export function splitSegments(text: string): string[] {
|
|
115
|
+
const source = String(text ?? '');
|
|
116
|
+
const kind = pickKind(source);
|
|
117
|
+
if (!kind) {
|
|
118
|
+
const only = source.trim();
|
|
119
|
+
return only ? [only] : [];
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
const cuts = findCuts(source, kind);
|
|
123
|
+
const parts: string[] = [];
|
|
124
|
+
let cursor = 0;
|
|
125
|
+
|
|
126
|
+
for (const cut of cuts) {
|
|
127
|
+
// `keep` 为真时把分隔符留在前一段末尾(`!?…~` 的语气不能丢)。
|
|
128
|
+
const piece = source.slice(cursor, cut.keep ? cut.end : cut.start).trim();
|
|
129
|
+
if (piece) parts.push(piece);
|
|
130
|
+
cursor = cut.end;
|
|
131
|
+
}
|
|
132
|
+
const tail = source.slice(cursor).trim();
|
|
133
|
+
if (tail) parts.push(tail);
|
|
134
|
+
|
|
135
|
+
return parts;
|
|
136
|
+
}
|
|
137
|
+
|
|
138
|
+
/** 分段延时的两种口径。 */
|
|
139
|
+
export type SegmentDelay = { mode: 'fixed'; seconds: number } | { mode: 'random'; min: number; max: number };
|
|
140
|
+
|
|
141
|
+
/**
|
|
142
|
+
* 从配置段里取出延时口径。
|
|
143
|
+
*
|
|
144
|
+
* 数值容错:负数归零、`NaN` 归零;随机区间写反了由 `segmentDelayMs` 换回来。
|
|
145
|
+
*/
|
|
146
|
+
export function segmentDelayOf(cfg: {
|
|
147
|
+
segmentDelayMode?: string;
|
|
148
|
+
segmentDelayFixedSec?: number;
|
|
149
|
+
segmentDelayMinSec?: number;
|
|
150
|
+
segmentDelayMaxSec?: number;
|
|
151
|
+
}): SegmentDelay {
|
|
152
|
+
if (cfg.segmentDelayMode === 'random') {
|
|
153
|
+
return {
|
|
154
|
+
mode: 'random',
|
|
155
|
+
min: numOr0(cfg.segmentDelayMinSec),
|
|
156
|
+
max: numOr0(cfg.segmentDelayMaxSec),
|
|
157
|
+
};
|
|
158
|
+
}
|
|
159
|
+
return { mode: 'fixed', seconds: numOr0(cfg.segmentDelayFixedSec) };
|
|
160
|
+
}
|
|
161
|
+
|
|
162
|
+
const numOr0 = (value: unknown): number => {
|
|
163
|
+
const n = Number(value);
|
|
164
|
+
return Number.isFinite(n) && n > 0 ? n : 0;
|
|
165
|
+
};
|
|
166
|
+
|
|
167
|
+
/**
|
|
168
|
+
* 算第 `index` 段发完之后该等多久(毫秒)。
|
|
169
|
+
*
|
|
170
|
+
* `index` 从 0 开始;最后一段之后不需要等待,调用方自己判断。
|
|
171
|
+
* 这里只做**纯计算**,不 sleep,方便测试与调用方控制总时长。
|
|
172
|
+
*
|
|
173
|
+
* 随机口径用 `random` 注入,默认 `Math.random`。
|
|
174
|
+
*/
|
|
175
|
+
export function segmentDelayMs(delay: SegmentDelay, index: number, random: () => number = Math.random): number {
|
|
176
|
+
void index;
|
|
177
|
+
if (delay.mode === 'fixed') {
|
|
178
|
+
return Math.max(0, Math.round(delay.seconds * 1000));
|
|
179
|
+
}
|
|
180
|
+
const lo = Math.min(delay.min, delay.max);
|
|
181
|
+
const hi = Math.max(delay.min, delay.max);
|
|
182
|
+
const span = Math.max(0, hi - lo);
|
|
183
|
+
const pick = lo + span * Math.min(Math.max(random(), 0), 1);
|
|
184
|
+
return Math.max(0, Math.round(pick * 1000));
|
|
185
|
+
}
|
package/src/world.ts
CHANGED
|
@@ -38,6 +38,7 @@ import { UploadMediaType, TypingStatus, type WeixinMessage } from './protocol/ty
|
|
|
38
38
|
import { ILinkDriver } from './driver.ts';
|
|
39
39
|
import { CredentialStore, type AuthRecord } from './store.ts';
|
|
40
40
|
import { pickChannel, splitText } from './text.ts';
|
|
41
|
+
import { segmentDelayMs, segmentDelayOf, splitSegments } from './segment.ts';
|
|
41
42
|
import { ensureFfmpeg, installFfmpeg, installedSize, removeFfmpeg, type FfmpegResolution, type InstallProgress } from './media/ffmpeg.ts';
|
|
42
43
|
import { extractFrames } from './media/frames.ts';
|
|
43
44
|
import {
|
|
@@ -200,6 +201,10 @@ export class WechatClawWorld implements World {
|
|
|
200
201
|
#lastError = '';
|
|
201
202
|
#lastMessageAt = '';
|
|
202
203
|
#contextCount = 0;
|
|
204
|
+
/** 段间等待的唤醒钩子;stop() 用它打断睡眠。 */
|
|
205
|
+
#sleepWake: (() => void) | null = null;
|
|
206
|
+
/** 随机源;测试可替换成定值。 */
|
|
207
|
+
#random: () => number = Math.random;
|
|
203
208
|
#networkProblem = '';
|
|
204
209
|
#ffmpeg: FfmpegResolution | null = null;
|
|
205
210
|
/** ffmpeg 安装进度;null 表示没在装。 */
|
|
@@ -292,6 +297,13 @@ export class WechatClawWorld implements World {
|
|
|
292
297
|
return token;
|
|
293
298
|
}
|
|
294
299
|
|
|
300
|
+
/**
|
|
301
|
+
* 发一条文本。
|
|
302
|
+
*
|
|
303
|
+
* 分两层:先按语义拆(换行 / 句号 / 情绪标点),再对仍超长的段交给 `splitText` 硬切。
|
|
304
|
+
* 逐条真发,条间按配置等待;累计等待到上限就把剩下的连着发完,并在回执里说明。
|
|
305
|
+
* 全部发完才返回——回执报「已发送」时不骗人。
|
|
306
|
+
*/
|
|
295
307
|
async #toolSendText(args: Record<string, unknown>): Promise<string> {
|
|
296
308
|
const text = String(args.text ?? '').trim();
|
|
297
309
|
if (!text) throw new Error('text 不能为空。');
|
|
@@ -299,15 +311,115 @@ export class WechatClawWorld implements World {
|
|
|
299
311
|
const contextToken = await this.#requireContextToken(to);
|
|
300
312
|
const api = this.#requireApi();
|
|
301
313
|
|
|
302
|
-
const chunks =
|
|
303
|
-
|
|
304
|
-
|
|
314
|
+
const { chunks, merged, waits } = this.#planChunks(text);
|
|
315
|
+
|
|
316
|
+
let sleptMs = 0;
|
|
317
|
+
const maxTotalMs = Math.max(0, Number(this.#cfg.segmentMaxTotalSec) || 0) * 1000;
|
|
318
|
+
let budgetCut = false;
|
|
319
|
+
|
|
320
|
+
for (let i = 0; i < chunks.length; i += 1) {
|
|
321
|
+
await api.sendMessage(textMessage({ to, text: chunks[i]!, contextToken }));
|
|
322
|
+
|
|
323
|
+
const isLast = i === chunks.length - 1;
|
|
324
|
+
if (isLast) break;
|
|
325
|
+
|
|
326
|
+
const waitMs = waits[i] ?? 0;
|
|
327
|
+
if (waitMs <= 0) continue;
|
|
328
|
+
|
|
329
|
+
// 预算不够就**不再等**,但剩下的段必须照常发完——不能因为等不起就不发了。
|
|
330
|
+
if (maxTotalMs > 0 && sleptMs + waitMs > maxTotalMs) {
|
|
331
|
+
budgetCut = true;
|
|
332
|
+
continue;
|
|
333
|
+
}
|
|
334
|
+
|
|
335
|
+
// 下一段之前先亮「正在输入」,让人看着像还在打,而不是卡住。
|
|
336
|
+
void this.#signalTyping(to, contextToken);
|
|
337
|
+
await this.#sleepMs(waitMs);
|
|
338
|
+
sleptMs += waitMs;
|
|
305
339
|
}
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
340
|
+
|
|
341
|
+
this.#host?.log?.info?.('微信已发送文本', {
|
|
342
|
+
to: shortId(to),
|
|
343
|
+
chars: text.length,
|
|
344
|
+
parts: chunks.length,
|
|
345
|
+
merged,
|
|
346
|
+
sleptMs,
|
|
347
|
+
budgetCut,
|
|
348
|
+
});
|
|
349
|
+
|
|
350
|
+
const bits: string[] = [];
|
|
351
|
+
if (chunks.length > 1) bits.push(`分 ${chunks.length} 条`);
|
|
352
|
+
if (merged) bits.push(`内容过多,已合并到 ${chunks.length} 条`);
|
|
353
|
+
if (budgetCut) bits.push('等待到上限,其余连着发完');
|
|
354
|
+
if (sleptMs > 0) bits.push(`共等待 ${(sleptMs / 1000).toFixed(1)} 秒`);
|
|
355
|
+
const suffix = bits.length ? `,${bits.join(',')}` : '';
|
|
356
|
+
return `已发送到微信(${shortId(to)})${suffix},共 ${text.length} 字。`;
|
|
309
357
|
}
|
|
310
358
|
|
|
359
|
+
/**
|
|
360
|
+
* 把一次回复规划成要发的内容。
|
|
361
|
+
*
|
|
362
|
+
* - 语义分段(`splitSegments`)
|
|
363
|
+
* - 每段仍超 4000 字时交给 `splitText` 再切,保证发得出去
|
|
364
|
+
* - 总段数超过 `segmentMaxParts` 时,把多出来的并进最后一段
|
|
365
|
+
* - 给出每段之后该等多久(毫秒)
|
|
366
|
+
*
|
|
367
|
+
* 分段关闭时退化成原来的行为:只按长度切、不等。
|
|
368
|
+
*/
|
|
369
|
+
#planChunks(text: string): { chunks: string[]; waits: number[]; merged: boolean } {
|
|
370
|
+
const enabled = this.#cfg.segmentEnabled !== false;
|
|
371
|
+
|
|
372
|
+
// 语义段 → 长度段。
|
|
373
|
+
const seedParts = enabled ? splitSegments(text) : [text];
|
|
374
|
+
let chunks: string[] = [];
|
|
375
|
+
for (const part of seedParts.length ? seedParts : [text]) {
|
|
376
|
+
for (const piece of splitText(part, MAX_TEXT_CHARS)) {
|
|
377
|
+
if (piece) chunks.push(piece);
|
|
378
|
+
}
|
|
379
|
+
}
|
|
380
|
+
if (!chunks.length) chunks = [text];
|
|
381
|
+
|
|
382
|
+
// 段数上限:多的并进最后一段。
|
|
383
|
+
const maxParts = Math.floor(Number(this.#cfg.segmentMaxParts) || 0);
|
|
384
|
+
let merged = false;
|
|
385
|
+
if (enabled && maxParts > 0 && chunks.length > maxParts) {
|
|
386
|
+
const keep = chunks.slice(0, maxParts - 1);
|
|
387
|
+
const rest = chunks.slice(maxParts - 1).join('');
|
|
388
|
+
chunks = [...keep, rest];
|
|
389
|
+
merged = true;
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
// 每段之后的等待;关闭分段时全 0。
|
|
393
|
+
const waits: number[] = [];
|
|
394
|
+
if (enabled) {
|
|
395
|
+
const delay = segmentDelayOf(this.#cfg);
|
|
396
|
+
for (let i = 0; i < chunks.length - 1; i += 1) {
|
|
397
|
+
waits.push(segmentDelayMs(delay, i, this.#random));
|
|
398
|
+
}
|
|
399
|
+
} else {
|
|
400
|
+
for (let i = 0; i < chunks.length - 1; i += 1) waits.push(0);
|
|
401
|
+
}
|
|
402
|
+
|
|
403
|
+
return { chunks, waits, merged };
|
|
404
|
+
}
|
|
405
|
+
|
|
406
|
+
/** 等一会儿;`stop()` 时会被唤醒,避免关机干等半分钟。 */
|
|
407
|
+
#sleepMs(ms: number): Promise<void> {
|
|
408
|
+
if (ms <= 0) return Promise.resolve();
|
|
409
|
+
return new Promise((resolve) => {
|
|
410
|
+
const timer = setTimeout(() => {
|
|
411
|
+
this.#sleepWake = null;
|
|
412
|
+
resolve();
|
|
413
|
+
}, ms);
|
|
414
|
+
this.#sleepWake = () => {
|
|
415
|
+
clearTimeout(timer);
|
|
416
|
+
this.#sleepWake = null;
|
|
417
|
+
resolve();
|
|
418
|
+
};
|
|
419
|
+
});
|
|
420
|
+
}
|
|
421
|
+
|
|
422
|
+
|
|
311
423
|
/**
|
|
312
424
|
* 图片与文件共用一条上传路径,只有 media_type 和消息项不同。
|
|
313
425
|
*
|
|
@@ -1314,6 +1426,8 @@ export class WechatClawWorld implements World {
|
|
|
1314
1426
|
|
|
1315
1427
|
async stop(): Promise<void> {
|
|
1316
1428
|
this.#started = false;
|
|
1429
|
+
// 打断段间等待,否则关机要干等到间隔结束。
|
|
1430
|
+
this.#sleepWake?.();
|
|
1317
1431
|
const login = this.#login;
|
|
1318
1432
|
if (login?.active) login.active = false;
|
|
1319
1433
|
this.#loginAbort?.abort();
|