@kadaliao/dsh-bots 0.10.1 → 0.11.0
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/LICENSE +21 -0
- package/README.md +83 -48
- package/README.zh-CN.md +62 -34
- package/client.js +441 -100
- package/index.js +323 -50
- package/lib/channels/discord.mjs +1 -1
- package/lib/memory.mjs +39 -5
- package/lib/needs.mjs +400 -0
- package/lib/prompt.mjs +28 -8
- package/lib/settings.mjs +8 -5
- package/lib/watchdog.mjs +13 -0
- package/package.json +4 -4
package/lib/channels/discord.mjs
CHANGED
|
@@ -41,7 +41,7 @@ export const TEXT_LIMIT = 2000;
|
|
|
41
41
|
export const INTENTS = (1 << 0) | (1 << 9) | (1 << 12) | (1 << 15);
|
|
42
42
|
|
|
43
43
|
const API_BASE = 'https://discord.com/api/v10';
|
|
44
|
-
const USER_AGENT = 'DiscordBot (https://github.com/kadaliao/dsh-
|
|
44
|
+
const USER_AGENT = 'DiscordBot (https://github.com/kadaliao/dsh-bots, 0.4)';
|
|
45
45
|
const GATEWAY_QUERY = '/?v=10&encoding=json';
|
|
46
46
|
const MIN_BACKOFF = 1000;
|
|
47
47
|
const MAX_BACKOFF = 60_000;
|
package/lib/memory.mjs
CHANGED
|
@@ -223,9 +223,40 @@ const opsSpec = [
|
|
|
223
223
|
'- {"op":"update","id":"<id>","text":"…"} — a note that changed or was wrong',
|
|
224
224
|
'- {"op":"remove","id":"<id>"} — a note that is no longer true',
|
|
225
225
|
'- {"op":"merge","ids":["<id>","<id>"],"text":"…"} — notes that say the same thing',
|
|
226
|
-
'Each note is one self-contained sentence of at most 200 characters
|
|
226
|
+
'Each note is one self-contained sentence of at most 200 characters. Never store secrets (keys, passwords, tokens), one-off details or anything already in memory.',
|
|
227
227
|
].join('\n');
|
|
228
228
|
|
|
229
|
+
const LANGUAGES = { zh: 'Simplified Chinese', en: 'English' };
|
|
230
|
+
|
|
231
|
+
/**
|
|
232
|
+
* The language the user writes to the bots in, from what they wrote: `zh` when Han characters
|
|
233
|
+
* outweigh Latin words, `en` when Latin words do, '' when there is too little to tell. Code,
|
|
234
|
+
* links and @handles don't count.
|
|
235
|
+
* @param {Iterable<string>} texts
|
|
236
|
+
* @returns {'zh'|'en'|''}
|
|
237
|
+
*/
|
|
238
|
+
export function languageOf(texts) {
|
|
239
|
+
let han = 0;
|
|
240
|
+
let latin = 0;
|
|
241
|
+
for (const t of texts ?? []) {
|
|
242
|
+
const s = String(t ?? '').replace(/```[\s\S]*?```|`[^`\n]*`|https?:\/\/\S+|@[\w-]+/g, ' ');
|
|
243
|
+
han += (s.match(/[\u3400-\u9fff]/g) ?? []).length;
|
|
244
|
+
latin += (s.match(/[A-Za-z]{2,}/g) ?? []).length;
|
|
245
|
+
}
|
|
246
|
+
if (han + latin < 3) return '';
|
|
247
|
+
return han >= latin ? 'zh' : 'en';
|
|
248
|
+
}
|
|
249
|
+
|
|
250
|
+
/**
|
|
251
|
+
* The line telling a memory pass which language to write in. The model never sees the user's
|
|
252
|
+
* own words in a consolidation, so it is named; `fix` asks to rewrite notes left in another one.
|
|
253
|
+
*/
|
|
254
|
+
function languageLine(language, { fix = false } = {}) {
|
|
255
|
+
const name = LANGUAGES[language];
|
|
256
|
+
if (!name) return 'Write everything in the language the user writes to the bots in.';
|
|
257
|
+
return `Write everything in ${name}, the language the user writes to the bots in, whatever language the material below is in.${fix ? ` A note written in another language is rewritten in ${name} (an "update").` : ''}`;
|
|
258
|
+
}
|
|
259
|
+
|
|
229
260
|
const notesBlock = (notes) => (notes.length ? notes.map((n) => `[${n.id}]${n.pinned ? ' (pinned)' : ''} ${n.text}`).join('\n') : '(none)');
|
|
230
261
|
|
|
231
262
|
/** Shorten a transcript to its head and tail. */
|
|
@@ -237,7 +268,7 @@ export function clip(text, max = 12_000) {
|
|
|
237
268
|
}
|
|
238
269
|
|
|
239
270
|
/** After a task: summarize it and update the bot's notes (and propose team notes). */
|
|
240
|
-
export function reflectionPrompt({ bot, notes, team, transcript, trigger }) {
|
|
271
|
+
export function reflectionPrompt({ bot, notes, team, transcript, trigger, language = '' }) {
|
|
241
272
|
return {
|
|
242
273
|
system: [
|
|
243
274
|
`You keep the long-term memory of ${bot.name} (@${bot.handle}), one of the user's AI bots${bot.bio ? ` — ${bot.bio}` : ''}.`,
|
|
@@ -245,6 +276,7 @@ export function reflectionPrompt({ bot, notes, team, transcript, trigger }) {
|
|
|
245
276
|
'{"summary": "<one or two sentences: what was asked and what came of it, with names, numbers and links that matter>", "notes": [<edits to the bot\'s own notes>], "team": [<edits to the team notes>]}',
|
|
246
277
|
'',
|
|
247
278
|
opsSpec,
|
|
279
|
+
languageLine(language),
|
|
248
280
|
'Save only what will still matter in a week: stable preferences and facts about the user, people, projects and decisions; procedures that worked; lessons from mistakes. Most tasks need no note at all — then answer with empty lists. Team notes are only for what every bot should know.',
|
|
249
281
|
].join('\n'),
|
|
250
282
|
user: [`# The bot's notes\n${notesBlock(notes)}`, `# Team notes\n${notesBlock(team)}`, `# The task (${trigger})\n${clip(transcript)}`].join('\n\n'),
|
|
@@ -289,7 +321,7 @@ export function searchTickets(query, tickets, { limit = 10 } = {}) {
|
|
|
289
321
|
}
|
|
290
322
|
|
|
291
323
|
/** Once a day per bot: tidy the notes with the last days of its journal. */
|
|
292
|
-
export function dreamBotPrompt({ bot, notes, journal, tz = 0 }) {
|
|
324
|
+
export function dreamBotPrompt({ bot, notes, journal, tz = 0, language = '' }) {
|
|
293
325
|
return {
|
|
294
326
|
system: [
|
|
295
327
|
`You consolidate the long-term memory of ${bot.name} (@${bot.handle}), one of the user's AI bots${bot.bio ? ` — ${bot.bio}` : ''}, as it sleeps.`,
|
|
@@ -297,13 +329,14 @@ export function dreamBotPrompt({ bot, notes, journal, tz = 0 }) {
|
|
|
297
329
|
'Answer with one JSON object and nothing else: {"notes": [<edits>]}',
|
|
298
330
|
'',
|
|
299
331
|
opsSpec,
|
|
332
|
+
languageLine(language, { fix: true }),
|
|
300
333
|
].join('\n'),
|
|
301
334
|
user: [`# Notes\n${notesBlock(notes)}`, `# Journal of recent tasks\n${clip(journal.map((j) => `${stamp(j.at, tz)} ${j.summary || j.title}`).join('\n'), 14_000) || '(none)'}`].join('\n\n'),
|
|
302
335
|
};
|
|
303
336
|
}
|
|
304
337
|
|
|
305
338
|
/** Once a day for the team: a digest of what every bot did, and the shared notes tidied. */
|
|
306
|
-
export function dreamTeamPrompt({ bots, team, journal, date, tz = 0 }) {
|
|
339
|
+
export function dreamTeamPrompt({ bots, team, journal, date, tz = 0, language = '' }) {
|
|
307
340
|
const name = (id) => {
|
|
308
341
|
const b = bots.find((x) => x.id === id);
|
|
309
342
|
return b ? `@${b.handle}` : 'a removed bot';
|
|
@@ -311,10 +344,11 @@ export function dreamTeamPrompt({ bots, team, journal, date, tz = 0 }) {
|
|
|
311
344
|
return {
|
|
312
345
|
system: [
|
|
313
346
|
"You keep the shared memory of the user's team of AI bots.",
|
|
314
|
-
`Write the team's digest for ${date}: what was done (by whom), results worth remembering, what is still open or blocked, and what comes next — in Markdown, at most 1000 characters
|
|
347
|
+
`Write the team's digest for ${date}: what was done (by whom), results worth remembering, what is still open or blocked, and what comes next — in Markdown, at most 1000 characters. Then tidy the shared team notes: merge repeats, drop outdated ones, add facts every bot should know that the journal shows.`,
|
|
315
348
|
'Answer with one JSON object and nothing else: {"digest": "…", "team": [<edits>]}',
|
|
316
349
|
'',
|
|
317
350
|
opsSpec,
|
|
351
|
+
languageLine(language, { fix: true }),
|
|
318
352
|
].join('\n'),
|
|
319
353
|
user: [
|
|
320
354
|
`# Team: ${bots.map((b) => `@${b.handle} (${b.name})`).join(', ')}`,
|
package/lib/needs.mjs
ADDED
|
@@ -0,0 +1,400 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Needs (Bots 0.11): what the person asked for, one level above the tasks
|
|
3
|
+
* (tickets) that do the work. A need is one request in the person's own terms
|
|
4
|
+
* ("A comparison of Q3 competitor pricing"); the dispatcher names it when it
|
|
5
|
+
* hands out the work, in the person's language, and every task it opens for that
|
|
6
|
+
* request counts toward it. One need may take several tasks (research split
|
|
7
|
+
* between teammates, then a write-up), and several messages (the request, a
|
|
8
|
+
* change to it, "how is it going?"); a message may also hold two needs.
|
|
9
|
+
*
|
|
10
|
+
* A need stores only what a task does not know: its title, who asked where
|
|
11
|
+
* (`origin`), the person's words (`asks`), its tasks (top-level ones: a
|
|
12
|
+
* sub-task counts through the task that opened it) and whether the person
|
|
13
|
+
* dropped it (`closed`). Its status comes from its tasks' stages
|
|
14
|
+
* ({@link needStatus}); `snapshot` keeps the last one, for when the tasks are
|
|
15
|
+
* pruned.
|
|
16
|
+
*
|
|
17
|
+
* `needs.json` under the bots cache holds `{version: 1, needs}`. It is read on
|
|
18
|
+
* first use and written whole through a temp file and a rename; a missing file
|
|
19
|
+
* starts empty, one that is not JSON in the expected shape is set aside as
|
|
20
|
+
* `needs.json.corrupt-<time>` before the first write replaces it.
|
|
21
|
+
*
|
|
22
|
+
* @module @kadaliao/dsh-bots/lib/needs
|
|
23
|
+
*/
|
|
24
|
+
|
|
25
|
+
import { randomInt } from 'node:crypto';
|
|
26
|
+
import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
|
|
27
|
+
import { join } from 'node:path';
|
|
28
|
+
|
|
29
|
+
export const NEED_ID_RE = /^n[a-z0-9]{8}$/;
|
|
30
|
+
/** What a person sees a need as, most pressing first. */
|
|
31
|
+
export const NEED_STATUSES = ['waiting', 'working', 'failed', 'done', 'stopped'];
|
|
32
|
+
/** Longest title, in characters. */
|
|
33
|
+
export const MAX_NEED_TITLE = 80;
|
|
34
|
+
/** Longest piece of the person's words one need keeps. */
|
|
35
|
+
export const MAX_ASK = 2000;
|
|
36
|
+
/** The person's messages one need keeps; past this the oldest go (the first, the request itself, stays). */
|
|
37
|
+
export const KEEP_ASKS = 20;
|
|
38
|
+
/** Settled needs `prune` keeps by default. */
|
|
39
|
+
export const KEEP_SETTLED = 500;
|
|
40
|
+
|
|
41
|
+
const ALNUM = 'abcdefghijklmnopqrstuvwxyz0123456789';
|
|
42
|
+
|
|
43
|
+
/** `n` and 8 random lowercase letters and digits. */
|
|
44
|
+
export function newNeedId() {
|
|
45
|
+
let id = 'n';
|
|
46
|
+
for (let i = 0; i < 8; i += 1) id += ALNUM[randomInt(ALNUM.length)];
|
|
47
|
+
return id;
|
|
48
|
+
}
|
|
49
|
+
|
|
50
|
+
/** One line of at most `max` characters (code points); a cut one ends with `…`. */
|
|
51
|
+
export function clampNeedTitle(text, max = MAX_NEED_TITLE) {
|
|
52
|
+
const s = String(text ?? '').replace(/\s+/g, ' ').trim();
|
|
53
|
+
const chars = [...s];
|
|
54
|
+
return chars.length <= max ? s : `${chars.slice(0, Math.max(0, max - 1)).join('').trimEnd()}…`;
|
|
55
|
+
}
|
|
56
|
+
|
|
57
|
+
const str = (v, max) => (typeof v === 'string' ? v.slice(0, max) : '');
|
|
58
|
+
const time = (v) => (Number.isFinite(Number(v)) && Number(v) > 0 ? Number(v) : 0);
|
|
59
|
+
|
|
60
|
+
function normalizeAsk(raw) {
|
|
61
|
+
if (!raw || typeof raw !== 'object') return null;
|
|
62
|
+
const text = str(raw.text, MAX_ASK).trim();
|
|
63
|
+
if (!text) return null;
|
|
64
|
+
return {
|
|
65
|
+
...(typeof raw.id === 'string' && raw.id ? { id: raw.id.slice(0, 200) } : {}),
|
|
66
|
+
at: time(raw.at),
|
|
67
|
+
text,
|
|
68
|
+
...(typeof raw.via === 'string' && raw.via ? { via: raw.via.slice(0, 40) } : {}),
|
|
69
|
+
...(typeof raw.who === 'string' && raw.who ? { who: raw.who.slice(0, 120) } : {}),
|
|
70
|
+
};
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
function normalizeOrigin(raw) {
|
|
74
|
+
const o = raw && typeof raw === 'object' ? raw : {};
|
|
75
|
+
return {
|
|
76
|
+
...(typeof o.threadKey === 'string' && o.threadKey ? { threadKey: o.threadKey.slice(0, 500) } : {}),
|
|
77
|
+
...(typeof o.via === 'string' && o.via ? { via: o.via.slice(0, 40) } : {}),
|
|
78
|
+
...(typeof o.who === 'string' && o.who ? { who: o.who.slice(0, 120) } : {}),
|
|
79
|
+
};
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
const SNAPSHOT_KEYS = ['status', 'done', 'total', 'failed', 'stalled'];
|
|
83
|
+
|
|
84
|
+
/** A stored need in its known shape, unknown fields kept; null when it is not one. */
|
|
85
|
+
export function normalizeNeed(raw) {
|
|
86
|
+
if (!raw || typeof raw !== 'object' || !NEED_ID_RE.test(String(raw.id ?? ''))) return null;
|
|
87
|
+
const title = clampNeedTitle(raw.title);
|
|
88
|
+
if (!title) return null;
|
|
89
|
+
const asks = (Array.isArray(raw.asks) ? raw.asks : []).map(normalizeAsk).filter(Boolean);
|
|
90
|
+
const tickets = [...new Set((Array.isArray(raw.tickets) ? raw.tickets : []).filter((t) => typeof t === 'string' && t))];
|
|
91
|
+
const createdAt = time(raw.createdAt) || Date.now();
|
|
92
|
+
const snap = raw.snapshot && typeof raw.snapshot === 'object' && NEED_STATUSES.includes(raw.snapshot.status) ? raw.snapshot : null;
|
|
93
|
+
return {
|
|
94
|
+
...raw,
|
|
95
|
+
id: raw.id,
|
|
96
|
+
title,
|
|
97
|
+
...(raw.auto === true ? { auto: true } : { auto: undefined }),
|
|
98
|
+
botId: typeof raw.botId === 'string' ? raw.botId : '',
|
|
99
|
+
origin: normalizeOrigin(raw.origin),
|
|
100
|
+
asks,
|
|
101
|
+
tickets,
|
|
102
|
+
createdAt,
|
|
103
|
+
updatedAt: time(raw.updatedAt) || createdAt,
|
|
104
|
+
...(raw.closed && typeof raw.closed === 'object' ? { closed: { at: time(raw.closed.at) || createdAt, by: raw.closed.by === 'user' ? 'user' : 'dispatcher' } } : { closed: undefined }),
|
|
105
|
+
...(NEED_ID_RE.test(String(raw.mergedInto ?? '')) ? { mergedInto: raw.mergedInto } : { mergedInto: undefined }),
|
|
106
|
+
...(snap ? { snapshot: Object.fromEntries([...SNAPSHOT_KEYS.map((k) => [k, k === 'status' ? snap.status : Math.max(0, Math.round(Number(snap[k]) || 0))]), ['at', time(snap.at)]]) } : { snapshot: undefined }),
|
|
107
|
+
};
|
|
108
|
+
}
|
|
109
|
+
|
|
110
|
+
/**
|
|
111
|
+
* How far a need got, from its tasks (the top-level ones it lists, as stored; missing ones are left
|
|
112
|
+
* out). `stageOf` is lib/tickets.mjs's. The first row that matches wins:
|
|
113
|
+
*
|
|
114
|
+
* | status | when |
|
|
115
|
+
* | --------- | --------------------------------------------------------------------- |
|
|
116
|
+
* | `stopped` | the person (or the dispatcher, for them) dropped it |
|
|
117
|
+
* | `waiting` | a task asks a question, or is blocked, and nobody answered yet |
|
|
118
|
+
* | `working` | a task is open (queued, working, stalled) |
|
|
119
|
+
* | `done` | every task ended, and at least one is done |
|
|
120
|
+
* | `failed` | every task ended, none done, one failed |
|
|
121
|
+
* | `stopped` | every task ended stopped |
|
|
122
|
+
*
|
|
123
|
+
* With no task found (all pruned), the stored `snapshot` stands, else it is `working`.
|
|
124
|
+
* `failed` and `stalled` count tasks in those stages, so an open need can say "one failed".
|
|
125
|
+
* @param {object} need
|
|
126
|
+
* @param {object[]} tasks - its tickets, as found
|
|
127
|
+
* @param {(t: object) => string} stageOf
|
|
128
|
+
*/
|
|
129
|
+
export function needStatus(need, tasks, stageOf) {
|
|
130
|
+
const list = (Array.isArray(tasks) ? tasks : []).filter(Boolean);
|
|
131
|
+
const stages = list.map((t) => ({ t, stage: stageOf(t) }));
|
|
132
|
+
const count = (s) => stages.filter((x) => x.stage === s).length;
|
|
133
|
+
const done = count('done');
|
|
134
|
+
const failed = stages.filter((x) => x.stage === 'failed' && x.t.ended).length;
|
|
135
|
+
const stalled = count('stalled');
|
|
136
|
+
const waiting = stages.filter((x) => x.stage === 'question' || (x.stage === 'failed' && !x.t.ended));
|
|
137
|
+
const open = stages.filter((x) => !x.t.ended);
|
|
138
|
+
let status;
|
|
139
|
+
if (need?.closed) status = 'stopped';
|
|
140
|
+
else if (list.length === 0) status = need?.snapshot?.status ?? 'working';
|
|
141
|
+
else if (waiting.length) status = 'waiting';
|
|
142
|
+
else if (open.length) status = 'working';
|
|
143
|
+
else if (done) status = 'done';
|
|
144
|
+
else if (failed) status = 'failed';
|
|
145
|
+
else status = 'stopped';
|
|
146
|
+
const total = list.length || need?.snapshot?.total || 0;
|
|
147
|
+
const endedAt = list.length && open.length === 0 ? Math.max(...list.map((t) => time(t.ended?.at))) : 0;
|
|
148
|
+
return {
|
|
149
|
+
status,
|
|
150
|
+
done: list.length ? done : (need?.snapshot?.done ?? 0),
|
|
151
|
+
total,
|
|
152
|
+
failed,
|
|
153
|
+
stalled,
|
|
154
|
+
...(endedAt ? { endedAt } : {}),
|
|
155
|
+
// The tasks waiting for the person, so the board can say what they are asked.
|
|
156
|
+
waiting: waiting.map((x) => x.t.id),
|
|
157
|
+
};
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
/**
|
|
161
|
+
* The needs file under `dir`. Writes go through at once; `onChange(fn)` hears each one.
|
|
162
|
+
* @param {string} dir
|
|
163
|
+
* @param {{now?: () => number}} [opts]
|
|
164
|
+
*/
|
|
165
|
+
export function createNeeds(dir, { now = Date.now } = {}) {
|
|
166
|
+
const file = join(dir, 'needs.json');
|
|
167
|
+
/** @type {{version: 1, needs: object[]}|null} */
|
|
168
|
+
let data = null;
|
|
169
|
+
const byId = new Map();
|
|
170
|
+
const byTicket = new Map();
|
|
171
|
+
const listeners = new Set();
|
|
172
|
+
|
|
173
|
+
const setAside = () => {
|
|
174
|
+
try {
|
|
175
|
+
let to = `${file}.corrupt-${now()}`;
|
|
176
|
+
for (let n = 1; existsSync(to); n += 1) to = `${file}.corrupt-${now()}-${n}`;
|
|
177
|
+
renameSync(file, to);
|
|
178
|
+
} catch {
|
|
179
|
+
// It goes when the next write replaces it.
|
|
180
|
+
}
|
|
181
|
+
};
|
|
182
|
+
|
|
183
|
+
const index = (n) => {
|
|
184
|
+
byId.set(n.id, n);
|
|
185
|
+
if (!n.mergedInto) for (const t of n.tickets) byTicket.set(t, n.id);
|
|
186
|
+
};
|
|
187
|
+
|
|
188
|
+
const load = () => {
|
|
189
|
+
if (data) return data;
|
|
190
|
+
let parsed = null;
|
|
191
|
+
let text = null;
|
|
192
|
+
try {
|
|
193
|
+
text = readFileSync(file, 'utf8');
|
|
194
|
+
} catch (error) {
|
|
195
|
+
if (error?.code !== 'ENOENT') throw new Error(`cannot read ${file} (${error?.code ?? error?.message ?? error}); fix or move it, needs are not loaded until then`, { cause: error });
|
|
196
|
+
}
|
|
197
|
+
if (text !== null) {
|
|
198
|
+
try {
|
|
199
|
+
parsed = JSON.parse(text);
|
|
200
|
+
} catch {
|
|
201
|
+
parsed = null;
|
|
202
|
+
}
|
|
203
|
+
if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.needs)) {
|
|
204
|
+
parsed = null;
|
|
205
|
+
setAside();
|
|
206
|
+
}
|
|
207
|
+
}
|
|
208
|
+
data = { version: 1, needs: [] };
|
|
209
|
+
for (const raw of parsed?.needs ?? []) {
|
|
210
|
+
const n = normalizeNeed(raw);
|
|
211
|
+
if (!n || byId.has(n.id)) continue;
|
|
212
|
+
data.needs.push(n);
|
|
213
|
+
index(n);
|
|
214
|
+
}
|
|
215
|
+
return data;
|
|
216
|
+
};
|
|
217
|
+
|
|
218
|
+
const save = () => {
|
|
219
|
+
try {
|
|
220
|
+
mkdirSync(dir, { recursive: true });
|
|
221
|
+
// A need quotes what the person said: readable by this user only.
|
|
222
|
+
writeFileSync(`${file}.tmp`, JSON.stringify(data, (k, v) => (v === undefined ? undefined : v)), { encoding: 'utf8', mode: 0o600 });
|
|
223
|
+
renameSync(`${file}.tmp`, file);
|
|
224
|
+
} catch {
|
|
225
|
+
// Kept in memory; the next write tries again.
|
|
226
|
+
}
|
|
227
|
+
};
|
|
228
|
+
|
|
229
|
+
const changed = (need) => {
|
|
230
|
+
save();
|
|
231
|
+
for (const fn of listeners) {
|
|
232
|
+
try {
|
|
233
|
+
fn(need);
|
|
234
|
+
} catch {
|
|
235
|
+
// A listener must not break a write.
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
};
|
|
239
|
+
|
|
240
|
+
/** The need, following merges to the one that took it. */
|
|
241
|
+
const find = (id) => {
|
|
242
|
+
load();
|
|
243
|
+
let n = byId.get(String(id ?? '').trim().replace(/^need\//, ''));
|
|
244
|
+
for (let hops = 0; n?.mergedInto && hops < 8; hops += 1) n = byId.get(n.mergedInto) ?? n;
|
|
245
|
+
return n?.mergedInto ? undefined : n;
|
|
246
|
+
};
|
|
247
|
+
|
|
248
|
+
const addAsksTo = (n, asks) => {
|
|
249
|
+
let added = false;
|
|
250
|
+
for (const raw of asks ?? []) {
|
|
251
|
+
const a = normalizeAsk(raw);
|
|
252
|
+
if (!a) continue;
|
|
253
|
+
if (a.id ? n.asks.some((x) => x.id === a.id) : n.asks.some((x) => x.text === a.text && x.at === a.at)) continue;
|
|
254
|
+
n.asks.push(a);
|
|
255
|
+
added = true;
|
|
256
|
+
}
|
|
257
|
+
if (n.asks.length > KEEP_ASKS) n.asks = [n.asks[0], ...n.asks.slice(-(KEEP_ASKS - 1))];
|
|
258
|
+
return added;
|
|
259
|
+
};
|
|
260
|
+
|
|
261
|
+
return {
|
|
262
|
+
/** Every need not merged away, newest first. */
|
|
263
|
+
list() {
|
|
264
|
+
load();
|
|
265
|
+
return data.needs.filter((n) => !n.mergedInto).sort((a, b) => b.updatedAt - a.updatedAt);
|
|
266
|
+
},
|
|
267
|
+
|
|
268
|
+
get: (id) => find(id),
|
|
269
|
+
|
|
270
|
+
/** The need a top-level ticket counts toward, if any. */
|
|
271
|
+
byTicket(ticketId) {
|
|
272
|
+
load();
|
|
273
|
+
const id = byTicket.get(String(ticketId ?? ''));
|
|
274
|
+
return id ? find(id) : undefined;
|
|
275
|
+
},
|
|
276
|
+
|
|
277
|
+
/**
|
|
278
|
+
* A new need. `title` is the request restated for the person; `auto` marks one the dispatcher did
|
|
279
|
+
* not name (its title is the person's own words, clipped).
|
|
280
|
+
* @param {{title: string, botId?: string, origin?: object, asks?: object[], tickets?: string[], auto?: boolean}} p
|
|
281
|
+
*/
|
|
282
|
+
create({ title, botId = '', origin = {}, asks = [], tickets = [], auto = false }) {
|
|
283
|
+
load();
|
|
284
|
+
const at = now();
|
|
285
|
+
let id = newNeedId();
|
|
286
|
+
while (byId.has(id)) id = newNeedId();
|
|
287
|
+
const n = normalizeNeed({ id, title, botId, origin, asks, tickets, createdAt: at, updatedAt: at, ...(auto ? { auto: true } : {}) });
|
|
288
|
+
if (!n) throw new Error('a need needs a title');
|
|
289
|
+
data.needs.push(n);
|
|
290
|
+
index(n);
|
|
291
|
+
changed(n);
|
|
292
|
+
return n;
|
|
293
|
+
},
|
|
294
|
+
|
|
295
|
+
/** Count a (top-level) ticket toward a need, with the person's words that came with it. */
|
|
296
|
+
addTicket(id, ticketId, asks = []) {
|
|
297
|
+
const n = find(id);
|
|
298
|
+
if (!n) return undefined;
|
|
299
|
+
const prev = byTicket.get(ticketId);
|
|
300
|
+
if (prev && prev !== n.id) {
|
|
301
|
+
const other = byId.get(prev);
|
|
302
|
+
if (other) other.tickets = other.tickets.filter((t) => t !== ticketId);
|
|
303
|
+
}
|
|
304
|
+
if (!n.tickets.includes(ticketId)) n.tickets.push(ticketId);
|
|
305
|
+
byTicket.set(ticketId, n.id);
|
|
306
|
+
addAsksTo(n, asks);
|
|
307
|
+
// Work handed out again makes a dropped need live again.
|
|
308
|
+
n.closed = undefined;
|
|
309
|
+
n.updatedAt = now();
|
|
310
|
+
changed(n);
|
|
311
|
+
return n;
|
|
312
|
+
},
|
|
313
|
+
|
|
314
|
+
/** The person said more about a need (a change, a follow-up): their words join it. */
|
|
315
|
+
addAsks(id, asks) {
|
|
316
|
+
const n = find(id);
|
|
317
|
+
if (!n || !addAsksTo(n, asks)) return n;
|
|
318
|
+
n.updatedAt = now();
|
|
319
|
+
changed(n);
|
|
320
|
+
return n;
|
|
321
|
+
},
|
|
322
|
+
|
|
323
|
+
rename(id, title) {
|
|
324
|
+
const n = find(id);
|
|
325
|
+
const next = clampNeedTitle(title);
|
|
326
|
+
if (!n || !next) return undefined;
|
|
327
|
+
n.title = next;
|
|
328
|
+
n.auto = undefined;
|
|
329
|
+
n.updatedAt = now();
|
|
330
|
+
changed(n);
|
|
331
|
+
return n;
|
|
332
|
+
},
|
|
333
|
+
|
|
334
|
+
/** `id`'s tasks and words go to `into`; `id` is then only a pointer to it. */
|
|
335
|
+
merge(id, into) {
|
|
336
|
+
const from = find(id);
|
|
337
|
+
const to = find(into);
|
|
338
|
+
if (!from || !to || from.id === to.id) return undefined;
|
|
339
|
+
for (const t of from.tickets) {
|
|
340
|
+
if (!to.tickets.includes(t)) to.tickets.push(t);
|
|
341
|
+
byTicket.set(t, to.id);
|
|
342
|
+
}
|
|
343
|
+
addAsksTo(to, from.asks);
|
|
344
|
+
to.asks.sort((a, b) => a.at - b.at);
|
|
345
|
+
to.createdAt = Math.min(to.createdAt, from.createdAt);
|
|
346
|
+
to.updatedAt = now();
|
|
347
|
+
from.mergedInto = to.id;
|
|
348
|
+
from.tickets = [];
|
|
349
|
+
from.updatedAt = now();
|
|
350
|
+
changed(to);
|
|
351
|
+
return to;
|
|
352
|
+
},
|
|
353
|
+
|
|
354
|
+
/** The person dropped it (their tasks are stopped by the caller). */
|
|
355
|
+
close(id, { by = 'dispatcher' } = {}) {
|
|
356
|
+
const n = find(id);
|
|
357
|
+
if (!n) return undefined;
|
|
358
|
+
n.closed = { at: now(), by: by === 'user' ? 'user' : 'dispatcher' };
|
|
359
|
+
n.updatedAt = now();
|
|
360
|
+
changed(n);
|
|
361
|
+
return n;
|
|
362
|
+
},
|
|
363
|
+
|
|
364
|
+
/** Keep the latest status (a write only when it changed). */
|
|
365
|
+
snapshot(id, s) {
|
|
366
|
+
const n = find(id);
|
|
367
|
+
if (!n || !s || !NEED_STATUSES.includes(s.status)) return n;
|
|
368
|
+
const prev = n.snapshot ?? {};
|
|
369
|
+
if (SNAPSHOT_KEYS.every((k) => prev[k] === s[k])) return n;
|
|
370
|
+
n.snapshot = { ...Object.fromEntries(SNAPSHOT_KEYS.map((k) => [k, s[k]])), at: now() };
|
|
371
|
+
n.updatedAt = now();
|
|
372
|
+
changed(n);
|
|
373
|
+
return n;
|
|
374
|
+
},
|
|
375
|
+
|
|
376
|
+
/**
|
|
377
|
+
* Retention: keep the newest `keepSettled` needs that are done, failed or stopped (by their last
|
|
378
|
+
* change), drop older ones and merged pointers whose target went. Open needs are never dropped.
|
|
379
|
+
*/
|
|
380
|
+
prune({ keepSettled = KEEP_SETTLED } = {}) {
|
|
381
|
+
load();
|
|
382
|
+
const settled = data.needs.filter((n) => !n.mergedInto && ['done', 'failed', 'stopped'].includes(n.snapshot?.status ?? (n.closed ? 'stopped' : ''))).sort((a, b) => b.updatedAt - a.updatedAt);
|
|
383
|
+
const drop = new Set(settled.slice(keepSettled).map((n) => n.id));
|
|
384
|
+
for (const n of data.needs) if (n.mergedInto && (drop.has(n.mergedInto) || !byId.has(n.mergedInto))) drop.add(n.id);
|
|
385
|
+
if (drop.size === 0) return 0;
|
|
386
|
+
data.needs = data.needs.filter((n) => !drop.has(n.id));
|
|
387
|
+
byId.clear();
|
|
388
|
+
byTicket.clear();
|
|
389
|
+
for (const n of data.needs) index(n);
|
|
390
|
+
changed(null);
|
|
391
|
+
return drop.size;
|
|
392
|
+
},
|
|
393
|
+
|
|
394
|
+
/** `fn(need)` after each write (`null` for a prune). Returns an unsubscribe. */
|
|
395
|
+
onChange(fn) {
|
|
396
|
+
listeners.add(fn);
|
|
397
|
+
return () => listeners.delete(fn);
|
|
398
|
+
},
|
|
399
|
+
};
|
|
400
|
+
}
|
package/lib/prompt.mjs
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
/**
|
|
2
|
-
* What a bot's model reads: its persona section (
|
|
3
|
-
* dispatcher, or worker in a ticket session), the DM framing, the timing
|
|
2
|
+
* What a bot's model reads: its persona section (router dispatcher, a
|
|
3
|
+
* dispatcher working alone, or worker in a ticket session), the DM framing, the timing
|
|
4
4
|
* builder its schedule tool uses, and the router's tool limits. Pure
|
|
5
5
|
* functions, no Harness.
|
|
6
6
|
*
|
|
@@ -18,19 +18,34 @@ export function rosterLine(bot, selfId) {
|
|
|
18
18
|
const LANGUAGE_LINE = '- Write to the user in the language they use (Chinese or English). Between bots, use the language of the task you were given.';
|
|
19
19
|
const MANAGE_LINE = '- `bot_list` shows the team with each bot\'s skills and apps; `bot_create`, `bot_update` and `bot_delete` manage bots when the user asks for it or a new specialist is clearly needed.';
|
|
20
20
|
const SCHEDULE_NOTICE_LINE = '- Ignore "[SCHEDULE CHANGE]" notices: they need no reply.';
|
|
21
|
+
|
|
22
|
+
/**
|
|
23
|
+
* What a bot writes when a turn needs no words. Harness counts an answer with no content as a
|
|
24
|
+
* failed model call (`EMPTY_RESPONSE`, retried, then the turn fails), so "end your turn without a
|
|
25
|
+
* summary" must still leave text: this marker, which the plugin never shows or sends.
|
|
26
|
+
*/
|
|
27
|
+
export const NO_REPLY = 'NO_REPLY';
|
|
28
|
+
|
|
29
|
+
/** Whether a turn's text is the no-reply marker alone (any case, in backticks or with a full stop). */
|
|
30
|
+
export function isNoReply(text) {
|
|
31
|
+
return /^[\s`*_"']*no[_ ]reply[\s`*_"'.!]*$/i.test(String(text ?? ''));
|
|
32
|
+
}
|
|
33
|
+
|
|
34
|
+
const NO_REPLY_LINE = `- Never end a turn with an empty answer. When nothing needs saying (a notice, an acknowledgement, or after a tool already said it all), write only ${NO_REPLY}: it is never shown or sent.`;
|
|
21
35
|
const SCHEDULE_LINE = 'Use `bot_schedule` to give any bot (yourself included) recurring or timed tasks: the instruction is delivered to that bot\'s conversation at each occurrence.';
|
|
22
36
|
|
|
23
37
|
/** A team's dispatcher has no Harness sub-agents (Bots 0.10): parallel help is a teammate's task, which the person can follow. The other bots keep theirs. */
|
|
24
38
|
const teamHelpersLine = (router) =>
|
|
25
39
|
`- Your helpers are your teammates: as the dispatcher you have no Harness sub-agents (\`subagent\`, \`wait_agent\`, workflows). When a skill says to start sub-agents or parallel researchers, hand those parts to teammates with \`bot_send_message\` instead${router ? '' : ', or do them yourself one after another'}.`;
|
|
26
40
|
|
|
27
|
-
/** "Working with other bots" as a
|
|
41
|
+
/** "Working with other bots" as a dispatcher working alone reads it (the 0.7 text, from before tasks). */
|
|
28
42
|
const HANDS_ON_TEAM = [
|
|
29
43
|
'- Message another bot with `bot_send_message` (to: its @handle). It receives your text in its own conversation and works on it there; its answer comes back to you as a "Bot message from @…" message.',
|
|
30
44
|
'- A message that starts with "Bot message from @…" was sent by that bot, not by the user. Answer it with `bot_send_message` when it asks for something; do not answer pure acknowledgements or thanks, so conversations end.',
|
|
31
45
|
'- Keep messages self-contained: the other bot cannot see your conversation.',
|
|
32
|
-
'- When you are working on a bot message, your answer goes back through `bot_send_message`; after sending it, end your turn
|
|
46
|
+
'- When you are working on a bot message, your answer goes back through `bot_send_message`; after sending it, end your turn with only ' + NO_REPLY + ' — nobody reads a summary.',
|
|
33
47
|
SCHEDULE_NOTICE_LINE,
|
|
48
|
+
NO_REPLY_LINE,
|
|
34
49
|
LANGUAGE_LINE,
|
|
35
50
|
MANAGE_LINE,
|
|
36
51
|
];
|
|
@@ -41,6 +56,7 @@ const routerTeam = (self) => [
|
|
|
41
56
|
'- Keep messages self-contained: the bot cannot see this conversation.',
|
|
42
57
|
'- A message that starts with "Bot message from @…" was sent by that teammate, not by the person: teammates open no tasks for you, their messages come here. Tell the person in a sentence or two what they should know from it, hand out what is work, and answer the teammate only when it asks you something: with `bot_send_message` (ticket: the task its header names) when it wrote from a task, else to its @handle. Never answer acknowledgements or thanks.',
|
|
43
58
|
SCHEDULE_NOTICE_LINE,
|
|
59
|
+
NO_REPLY_LINE,
|
|
44
60
|
LANGUAGE_LINE,
|
|
45
61
|
MANAGE_LINE,
|
|
46
62
|
];
|
|
@@ -52,6 +68,7 @@ const HOME_TICKETS_TEAM = [
|
|
|
52
68
|
'- A message that starts with "Report from @…" or "Bot message from @…" was sent by that bot, not by the user. Pass a report\'s result on to whoever asked; a `question` or `blocked` report needs an answer with `bot_send_message` (ticket: its id).',
|
|
53
69
|
'- Keep messages self-contained: the other bot cannot see your conversation.',
|
|
54
70
|
SCHEDULE_NOTICE_LINE,
|
|
71
|
+
NO_REPLY_LINE,
|
|
55
72
|
LANGUAGE_LINE,
|
|
56
73
|
MANAGE_LINE,
|
|
57
74
|
];
|
|
@@ -62,6 +79,7 @@ const TICKET_TEAM = [
|
|
|
62
79
|
'- Keep messages self-contained: the other bot cannot see your conversation.',
|
|
63
80
|
'- A message that starts with "Bot message from @…" or "Report from @…" was sent by that bot, not by the user.',
|
|
64
81
|
SCHEDULE_NOTICE_LINE,
|
|
82
|
+
NO_REPLY_LINE,
|
|
65
83
|
LANGUAGE_LINE,
|
|
66
84
|
MANAGE_LINE,
|
|
67
85
|
];
|
|
@@ -104,7 +122,7 @@ function originPhrase(ticket) {
|
|
|
104
122
|
* @param {object[]} roster - every bot, the bot itself included.
|
|
105
123
|
* @param {{skillsInline?: boolean, apps?: string[], skillNames?: object, channels?: string[], dispatcher?: 'router'|'hands-on', tickets?: boolean, ticket?: object}} [extra]
|
|
106
124
|
* `channels`: chat apps the team is reachable from ('Telegram').
|
|
107
|
-
* `dispatcher`: how the dispatcher (role 'primary') works in its home conversation; 'hands-on' (default) is the 0.7 text
|
|
125
|
+
* `dispatcher`: how the dispatcher (role 'primary') works in its home conversation: 'router' (it has teammates) only understands, hands out and reports; 'hands-on' (default: it works alone) is the 0.7 text. Ignored for other bots.
|
|
108
126
|
* `tickets`: delegating from a home opens a task whose answer arrives as a report (router mode); a non-dispatcher bot's home then says so. Without it (hands-on) the 0.7 text stands.
|
|
109
127
|
* `ticket`: the ticket (see PLAN-0.8 §10) when this conversation is that ticket's session; the text then frames the conversation as one task, whatever the bot's role.
|
|
110
128
|
*/
|
|
@@ -132,9 +150,9 @@ export function personaText(bot, roster, extra = {}) {
|
|
|
132
150
|
? [
|
|
133
151
|
`- Your \`done\`, \`question\` and \`blocked\` reports are shown to the person as they are, ${shownWhere(ticket)}, and whoever asked is told. Write them for the person: the whole answer, in their language, nothing addressed to a bot. Their replies come back here.`,
|
|
134
152
|
'- To the person a report reads as you talking to them in the chat, so write it the way you would answer there: start with the answer itself, not with its status ("done", "finished", "here is the report"), and leave out task ids and how the work was handed around.',
|
|
135
|
-
'- Your plain text reaches no one: only reports do. Put everything the person needs in the report (nobody sees this conversation); after a `done` report, end your turn
|
|
153
|
+
'- Your plain text reaches no one: only reports do. Put everything the person needs in the report (nobody sees this conversation); after a `done` report, end your turn with only ' + NO_REPLY + '.',
|
|
136
154
|
]
|
|
137
|
-
: ['- Your plain text reaches no one: only reports do. Put everything the requester needs in the report (it cannot see this conversation); after a `done` report, end your turn
|
|
155
|
+
: ['- Your plain text reaches no one: only reports do. Put everything the requester needs in the report (it cannot see this conversation); after a `done` report, end your turn with only ' + NO_REPLY + '.']),
|
|
138
156
|
'- Asking another bot opens a sub-task; its report comes back here by itself.',
|
|
139
157
|
'- Messages from the person about this task may arrive here directly. Take them into account and answer them in a report.',
|
|
140
158
|
`- \`bot_recall\` reads this task (\`ticket/${ticket.id}\`), its parent and sub-tasks, and the threads it belongs to.`,
|
|
@@ -147,6 +165,8 @@ export function personaText(bot, roster, extra = {}) {
|
|
|
147
165
|
'- Every message is its own request, unless it clearly continues one of the open tasks listed with it ("[Panel]" messages list them). When several messages arrive together, handle every one of them: never drop a request because another came after it.',
|
|
148
166
|
'- You put no question cards to the person: a card would hold every message after it until it is answered. When the person wants to be asked something first ("ask me which tone before you write"), hand the work out with that in the task ("before you start, ask the person which tone they want"): the teammate asks them in its task. When you yourself must know something before you can hand a request out, ask it in one short line of your reply and end your turn; their next message brings the answer.',
|
|
149
167
|
'- For each request do one of these, then end your turn: answer it yourself only from what you already know (a greeting, what the person means, the team, its tasks and what they already reported); hand it out with `bot_send_message` and tell the person in a sentence what happens next, as a colleague would in a chat ("@ledger is looking into it, back in a few minutes"); or, when it continues an open task, add it to that task with `bot_send_message` (ticket: its id).',
|
|
168
|
+
'- Each request of the person is a need: the panel shows them their needs and how far the work on each got. When you hand out work for a new request, pass `need` with it: the request restated for the person in one short line, in their language, saying what they get, not who does it or how ("A comparison of Q3 competitor pricing", not "@scout researches pricing"). Tasks for the same request share its need: pass the same line, or the need id the first call returned. For more work on a need listed under "Open needs", pass its id. Leave `need` out for work the person did not ask for.',
|
|
169
|
+
'- When the person drops a request ("forget the logo"), drop its need with `bot_need`: its open tasks stop. When two needs turn out to be one request, merge them; when the person changes what they want, rename it.',
|
|
150
170
|
'- Talk to the person like a person in a chat, in their language. Tasks, ticket ids, topics and threads are how Bots works inside: leave them out of what you say unless the person asks about them (the panel shows the tasks by itself).',
|
|
151
171
|
'- A conversation that starts with "[Thread]" is a thread: the person replies to one earlier message, and you see the conversation up to it, not what came after. Stay on that message; tasks you open there answer in the thread.',
|
|
152
172
|
'- Every delegation with `bot_send_message` opens a task (ticket) for that bot and returns at once. Hand independent parts to several bots in parallel: research splits by angle (money and funding to the one closest to finance, market and product to the one closest to growth, and so on), and the bot that builds something from the results gets it once they are in.',
|
|
@@ -163,7 +183,7 @@ export function personaText(bot, roster, extra = {}) {
|
|
|
163
183
|
'',
|
|
164
184
|
'## You are the dispatcher',
|
|
165
185
|
'The user treats you as the main bot. For a task that fits another bot\'s role, delegate it with `bot_send_message`, possibly to several bots in parallel, then combine their answers for the user. Do small or general tasks yourself. When no bot fits a recurring kind of work, propose creating one.',
|
|
166
|
-
'While teammates are still answering, stay quiet: when a reply arrives and others are still outstanding,
|
|
186
|
+
'While teammates are still answering, stay quiet: when a reply arrives and others are still outstanding, write only ' + NO_REPLY + ' instead of writing to the user. Report once, when everything you asked for is in (or when something is blocked).',
|
|
167
187
|
SCHEDULE_LINE,
|
|
168
188
|
);
|
|
169
189
|
}
|
package/lib/settings.mjs
CHANGED
|
@@ -13,8 +13,9 @@ import { join } from 'node:path';
|
|
|
13
13
|
|
|
14
14
|
export const DEFAULTS = Object.freeze({
|
|
15
15
|
/**
|
|
16
|
-
* How the dispatcher works in its home conversation:
|
|
17
|
-
*
|
|
16
|
+
* How the dispatcher works in its home conversation: it only understands, hands out (each
|
|
17
|
+
* delegation is a ticket with its own conversation) and reports. Always 'router' since 0.11: the
|
|
18
|
+
* 0.7 'hands-on' mode is gone, and a stored one reads as 'router' (with the one-time notice).
|
|
18
19
|
*/
|
|
19
20
|
dispatcher: 'router',
|
|
20
21
|
tickets: Object.freeze({
|
|
@@ -27,7 +28,8 @@ export const DEFAULTS = Object.freeze({
|
|
|
27
28
|
}),
|
|
28
29
|
/**
|
|
29
30
|
* The one-time panel notice that an upgraded team now runs in router mode: 'pending' until the
|
|
30
|
-
* user dismisses it
|
|
31
|
+
* user dismisses it, 'dismissed' after; null before the first run of 0.8 decided. A team still set
|
|
32
|
+
* to the old hands-on mode gets it (again) when it is moved to router mode (0.11).
|
|
31
33
|
*/
|
|
32
34
|
routerNotice: null,
|
|
33
35
|
topics: Object.freeze({
|
|
@@ -108,13 +110,14 @@ export function normalizeSettings(input) {
|
|
|
108
110
|
}
|
|
109
111
|
const model = m.model && typeof m.model === 'object' && typeof m.model.provider === 'string' && m.model.provider && typeof m.model.model === 'string' && m.model.model ? { provider: m.model.provider.slice(0, 200), model: m.model.model.slice(0, 200) } : null;
|
|
110
112
|
return {
|
|
111
|
-
dispatcher:
|
|
113
|
+
dispatcher: 'router',
|
|
112
114
|
tickets: {
|
|
113
115
|
maxWorking: Math.round(num(tk.maxWorking, DEFAULTS.tickets.maxWorking, 1, 32)),
|
|
114
116
|
stallMinutes: Math.round(num(tk.stallMinutes, DEFAULTS.tickets.stallMinutes, 1, 24 * 60)),
|
|
115
117
|
archiveHours: num(tk.archiveHours, DEFAULTS.tickets.archiveHours, 0, 24 * 30),
|
|
116
118
|
},
|
|
117
|
-
|
|
119
|
+
// A team that had picked hands-on is told once that its dispatcher now only hands out the work.
|
|
120
|
+
routerNotice: s.dispatcher === 'hands-on' ? 'pending' : s.routerNotice === 'pending' || s.routerNotice === 'dismissed' ? s.routerNotice : null,
|
|
118
121
|
topics: {
|
|
119
122
|
idleHours: num(t.idleHours, DEFAULTS.topics.idleHours, 0, 24 * 30),
|
|
120
123
|
maxContextK: Math.round(num(t.maxContextK, DEFAULTS.topics.maxContextK, 0, 4096)),
|