@clawchatsai/connector 0.1.25 → 0.1.27

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.
@@ -0,0 +1,297 @@
1
+ import { test } from 'node:test';
2
+ import assert from 'node:assert/strict';
3
+ import { Database } from './bootstrap/native.js';
4
+ import { createTeamStore } from './store/team-store.js';
5
+ import { TeamCoordinator, parseMentions, namedIn, splitLabel, entryId } from './team.js';
6
+ import { SessionLens } from './session-lens.js';
7
+
8
+ const AGENTS = [{ id: 'main', identity: {} }, { id: 'dev', identity: { name: 'Dev' } }, { id: 'atlas', identity: { name: 'Atlas' } }];
9
+
10
+ /** Fake gateway. `reply(agentId, prompt)` returns the agent's reply text, null (abort) or a promise. */
11
+ function harness(reply, { preparedTitle = 'Team title', titler = null } = {}) {
12
+ const sessions = new Map(); // key -> [{ role, content, timestamp, __m: { id } }]
13
+ const calls = [];
14
+ let clock = 1_000, seq = 0;
15
+ const events = [];
16
+ let team;
17
+ const request = async (method, params) => {
18
+ calls.push({ method, params });
19
+ switch (method) {
20
+ case 'agents.list': return { agents: AGENTS };
21
+ case 'sessions.create': sessions.set(params.key, []); return { ok: true, key: params.key };
22
+ case 'sessions.describe': return { session: { key: params.key } };
23
+ case 'sessions.title.prepare': return { title: preparedTitle };
24
+ case 'sessions.patch': case 'sessions.delete': return { ok: true };
25
+ case 'chat.inject': {
26
+ const id = `m${++seq}`;
27
+ sessions.get(params.sessionKey).push({ role: 'assistant', content: [{ type: 'text', text: `[${params.label}]\n\n${params.message}` }], timestamp: ++clock, __m: { id } });
28
+ return { ok: true, messageId: id };
29
+ }
30
+ case 'chat.history': return { messages: (sessions.get(params.sessionKey) || []).slice(-(params.limit || 80)) };
31
+ case 'chat.send': {
32
+ sessions.get(params.sessionKey).push({ role: 'user', content: params.message, timestamp: ++clock, __m: { id: `u${++seq}` } });
33
+ const agentId = /^agent:([^:]+):/.exec(params.sessionKey)[1];
34
+ const runId = params.idempotencyKey;
35
+ Promise.resolve(reply(agentId, params.message)).then(text => {
36
+ if (text && typeof text === 'object') { // { partial, state }: streamed some text, then aborted/error
37
+ team.onGatewayEvent({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: 'delta', message: { role: 'assistant', content: [{ type: 'text', text: text.partial }] } } });
38
+ team.onGatewayEvent({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: 'delta', deltaText: ' more' } });
39
+ team.onGatewayEvent({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: text.state, errorMessage: text.error } });
40
+ return;
41
+ }
42
+ const state = text === null ? 'aborted' : 'final';
43
+ const payload = { runId, sessionKey: params.sessionKey, state };
44
+ if (text && text !== 'NO_REPLY') payload.message = { role: 'assistant', content: [{ type: 'text', text }] };
45
+ team.onGatewayEvent({ type: 'event', event: 'chat', payload });
46
+ if (text === 'NO_REPLY') team.onGatewayEvent({ type: 'event', event: 'chat', payload: { runId, sessionKey: params.sessionKey, state: 'error' } });
47
+ });
48
+ return { runId, status: 'started' };
49
+ }
50
+ case 'chat.abort': return { ok: true };
51
+ default: throw new Error(`unexpected ${method}`);
52
+ }
53
+ };
54
+ const db = new Database(':memory:');
55
+ team = new TeamCoordinator({ store: createTeamStore(() => db), request, titler, broadcast: d => events.push(JSON.parse(d)), logger: { warn() {}, error() {} } });
56
+ const room = key => (sessions.get(key) || []).map(m => m.content[0].text);
57
+ const settle = async () => { for (let i = 0; i < 50; i++) await new Promise(r => setImmediate(r)); for (const c of team._chains.values()) await c; };
58
+ return { team, calls, room, settle, events, sessions };
59
+ }
60
+
61
+ test('parsing helpers', () => {
62
+ const agents = [{ agentId: 'main', name: 'main' }, { agentId: 'atlas', name: 'Atlas' }, { agentId: 'dev', name: 'Dev Bot' }];
63
+ assert.deepEqual(parseMentions('hey @Atlas and @devbot.', agents), { agentIds: ['atlas', 'dev'] });
64
+ assert.deepEqual(parseMentions('mail me at x@atlas.com', agents), { agentIds: [] });
65
+ assert.deepEqual(parseMentions('@all thoughts?', agents), { all: true });
66
+ assert.deepEqual(parseMentions('no mention here', agents), { agentIds: [] });
67
+ assert.deepEqual(namedIn('I agree with Atlas, @main?', agents).sort(), ['atlas', 'main']);
68
+ assert.deepEqual(namedIn('Atlassian is a company', agents), []);
69
+ assert.deepEqual(splitLabel('[Atlas]\n\nhi\n\nthere'), { label: 'Atlas', body: 'hi\n\nthere' });
70
+ assert.deepEqual(splitLabel('plain'), { label: null, body: 'plain' });
71
+ assert.equal(entryId({ role: 'x', __meta: { id: 'e1' } }), 'e1');
72
+ });
73
+
74
+ test('create, open message: everyone asked, silent agents stay out of the room', async () => {
75
+ const h = harness((agent, prompt) => {
76
+ assert.match(prompt, /not addressed to anyone/);
77
+ return agent === 'dev' ? 'dev answer' : 'NO_REPLY';
78
+ });
79
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
80
+ assert.match(roomKey, /^agent:dev:dashboard:/);
81
+ await h.team.send(roomKey, { text: 'what is 2+2?', userLabel: 'Houman' });
82
+ await h.settle();
83
+ assert.deepEqual(h.room(roomKey), ['[Houman]\n\nwhat is 2+2?', '[Dev]\n\ndev answer']);
84
+ const r = h.team.room(roomKey);
85
+ assert.deepEqual(Object.values(r.authors), [{ type: 'user', agentId: null }, { type: 'agent', agentId: 'dev' }]);
86
+ assert.equal(r.agents.every(a => a.workKey), true);
87
+ assert.equal(h.calls.filter(c => c.method === 'chat.send').length, 2);
88
+ assert.equal(h.team.isWorkKey(r.agents[0].workKey), true);
89
+ assert.equal(h.team.isWorkKey(roomKey), false);
90
+ });
91
+
92
+ test('mention gating: only the mentioned agent runs; the other catches up next time', async () => {
93
+ const prompts = {};
94
+ const h = harness((agent, prompt) => { (prompts[agent] ||= []).push(prompt); return `${agent} reply`; });
95
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
96
+ await h.team.send(roomKey, { text: '@atlas first question', userLabel: 'H' });
97
+ await h.settle();
98
+ assert.equal(prompts.dev, undefined);
99
+ assert.match(prompts.atlas[0], /addressed to you/);
100
+ await h.team.send(roomKey, { text: '@dev your turn', userLabel: 'H' });
101
+ await h.settle();
102
+ // dev sees the earlier exchange it missed, but not its own messages
103
+ assert.match(prompts.dev[0], /\[H\]: @atlas first question[\s\S]*\[Atlas\]: atlas reply[\s\S]*\[H\]: @dev your turn/);
104
+ assert.equal(prompts.atlas.length, 1);
105
+ });
106
+
107
+ test('@all makes everyone answer; discuss runs follow-up rounds until everyone passes', async () => {
108
+ let round2 = 0;
109
+ const h = harness((agent, prompt) => {
110
+ if (/just replied/.test(prompt)) { round2++; return agent === 'atlas' && round2 <= 2 ? 'atlas adds one thing' : 'NO_REPLY'; }
111
+ return `${agent} first`;
112
+ });
113
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
114
+ h.team.setDiscuss(roomKey, true);
115
+ await h.team.send(roomKey, { text: '@all go', userLabel: 'H' });
116
+ await h.settle();
117
+ assert.deepEqual(h.room(roomKey), ['[H]\n\n@all go', '[Dev]\n\ndev first', '[Atlas]\n\natlas first', '[Atlas]\n\natlas adds one thing']);
118
+ // round 2: both (each saw a sibling reply). Round 3: only atlas replied and named nobody,
119
+ // so nobody is eligible (dev neither replied nor was named): 2 + 2 sends.
120
+ assert.equal(h.calls.filter(c => c.method === 'chat.send').length, 4);
121
+ });
122
+
123
+ test('without discuss there is exactly one round', async () => {
124
+ const h = harness(agent => `${agent} says`);
125
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
126
+ await h.team.send(roomKey, { text: '@all hi', userLabel: 'H' });
127
+ await h.settle();
128
+ assert.equal(h.calls.filter(c => c.method === 'chat.send').length, 2);
129
+ });
130
+
131
+ test('stop aborts running agents and drops queued messages; later messages still run', async () => {
132
+ const pending = [];
133
+ const h = harness(agent => new Promise(resolve => pending.push({ agent, resolve })));
134
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
135
+ await h.team.send(roomKey, { text: '@dev one', userLabel: 'H' });
136
+ await h.team.send(roomKey, { text: '@dev two (queued)', userLabel: 'H' });
137
+ for (let i = 0; i < 20; i++) await new Promise(r => setImmediate(r));
138
+ assert.equal(pending.length, 1);
139
+ await h.team.stop(roomKey);
140
+ assert.equal(h.calls.filter(c => c.method === 'chat.abort').length, 1);
141
+ pending[0].resolve(null); // the gateway reports the aborted run
142
+ await h.team.send(roomKey, { text: '@dev three', userLabel: 'H' });
143
+ for (let i = 0; i < 20; i++) await new Promise(r => setImmediate(r));
144
+ assert.equal(pending.length, 2);
145
+ assert.match(h.calls.filter(c => c.method === 'chat.send').at(-1).params.message, /three/);
146
+ pending[1].resolve('done');
147
+ await h.settle();
148
+ // "two" was already in the room when "one" was dispatched, so dev saw it there; it never got a run of its own
149
+ assert.equal(h.calls.filter(c => c.method === 'chat.send').length, 2);
150
+ assert.equal(h.room(roomKey).at(-1), '[Dev]\n\ndone');
151
+ });
152
+
153
+ test('converting an existing chat keeps it as the agent working session; delete cleans up', async () => {
154
+ const h = harness(agent => `${agent} ok`);
155
+ const source = 'agent:atlas:dashboard:old-chat';
156
+ h.sessions.set(source, []);
157
+ const created = await h.team.createRoom({ sourceKey: source, agentIds: ['dev'], label: 'Old title', category: 'Work' });
158
+ assert.equal(created.agents[0].agentId, 'atlas');
159
+ assert.equal(created.agents[0].workKey, source);
160
+ assert.equal(h.team.isWorkKey(source), true);
161
+ const createCall = h.calls.find(c => c.method === 'sessions.create');
162
+ assert.equal(createCall.params.label, 'Old title');
163
+ assert.equal(createCall.params.category, 'Work');
164
+ await assert.rejects(h.team.createRoom({ sourceKey: source, agentIds: ['main'] }), /already part/);
165
+
166
+ const lens = new SessionLens({ broadcast() {}, team: h.team });
167
+ assert.equal(lens.isVisible(source), false);
168
+ assert.equal(lens.forwardsRunEvent(source), true);
169
+ assert.equal(lens.isVisible(created.roomKey), true);
170
+
171
+ await h.team.send(created.roomKey, { text: '@dev hi', userLabel: 'H' });
172
+ await h.settle();
173
+ const devWork = h.team.room(created.roomKey).agents.find(a => a.agentId === 'dev').workKey;
174
+ lens.sessionsChanged({ sessionKey: created.roomKey, reason: 'delete' });
175
+ assert.equal(h.team.room(created.roomKey), null);
176
+ assert.equal(h.team.isWorkKey(source), false);
177
+ assert.equal(lens.isVisible(source), true); // the user's own chat comes back
178
+ assert.ok(!h.calls.some(c => c.method === 'sessions.delete' && c.params.key === source)); // never deleted
179
+ assert.ok(h.calls.some(c => c.method === 'sessions.delete' && c.params.key === devWork));
180
+ });
181
+
182
+ test('unconvert: back to the original chat; only converted rooms', async () => {
183
+ const h = harness(agent => `${agent} ok`);
184
+ const source = 'agent:atlas:dashboard:orig';
185
+ h.sessions.set(source, []);
186
+ const { roomKey } = await h.team.createRoom({ sourceKey: source, agentIds: ['dev'] });
187
+ await h.team.send(roomKey, { text: '@all hi', userLabel: 'H' });
188
+ await h.settle();
189
+ const devWork = h.team.room(roomKey).agents.find(a => a.agentId === 'dev').workKey;
190
+ assert.equal(await h.team.unconvert(roomKey), source);
191
+ assert.equal(h.team.room(roomKey), null);
192
+ assert.equal(h.team.isWorkKey(source), false);
193
+ const deleted = h.calls.filter(c => c.method === 'sessions.delete').map(c => c.params.key);
194
+ assert.deepEqual(deleted.sort(), [devWork, roomKey].sort());
195
+ const fresh = (await h.team.createRoom({ agentIds: ['dev', 'atlas'] })).roomKey;
196
+ await assert.rejects(h.team.unconvert(fresh), /not converted/);
197
+ });
198
+
199
+ test('room title: gateway titler first, main-model titler when it has no utility model', async () => {
200
+ const a = harness(() => 'NO_REPLY');
201
+ const r1 = (await a.team.createRoom({ agentIds: ['dev', 'atlas'] })).roomKey;
202
+ await a.team.send(r1, { text: 'plan the offsite', userLabel: 'H' });
203
+ await a.settle();
204
+ assert.deepEqual(a.calls.find(c => c.method === 'sessions.patch').params, { key: r1, label: 'Team title' });
205
+
206
+ const b = harness(() => 'NO_REPLY', { preparedTitle: null, titler: async m => `T: ${m}` });
207
+ const r2 = (await b.team.createRoom({ agentIds: ['dev', 'atlas'] })).roomKey;
208
+ await b.team.send(r2, { text: 'plan the offsite', userLabel: 'H' });
209
+ await b.settle();
210
+ assert.deepEqual(b.calls.find(c => c.method === 'sessions.patch').params, { key: r2, label: 'T: plan the offsite' });
211
+ });
212
+
213
+ test('a team chat needs two agents; removing down to one is refused', async () => {
214
+ const h = harness(() => 'x');
215
+ await assert.rejects(h.team.createRoom({ agentIds: ['dev'] }), /at least two/);
216
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
217
+ assert.throws(() => h.team.removeAgent(roomKey, 'dev'), /at least two/);
218
+ await h.team.addAgent(roomKey, 'main');
219
+ assert.deepEqual(h.team.removeAgent(roomKey, 'dev').agents.map(a => a.agentId), ['atlas', 'main']);
220
+ });
221
+
222
+ test('stop: a partial reply is posted marked stopped; a reply that finished anyway is posted', async () => {
223
+ const pending = [];
224
+ const h = harness(agent => new Promise(resolve => pending.push({ agent, resolve })));
225
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
226
+ await h.team.send(roomKey, { text: '@all go', userLabel: 'H' });
227
+ for (let i = 0; i < 20; i++) await new Promise(r => setImmediate(r));
228
+ assert.equal(pending.length, 2);
229
+ await h.team.stop(roomKey);
230
+ pending.find(p => p.agent === 'dev').resolve({ partial: 'half an', state: 'aborted' });
231
+ pending.find(p => p.agent === 'atlas').resolve('atlas finished anyway');
232
+ await h.settle();
233
+ const room = h.room(roomKey);
234
+ assert.ok(room.includes('[Dev]\n\nhalf an more\n\n*[stopped]*'));
235
+ assert.ok(room.includes('[Atlas]\n\natlas finished anyway'));
236
+ assert.equal(h.calls.filter(c => c.method === 'chat.send').length, 2); // no follow-up round after Stop
237
+ });
238
+
239
+ test('a failed turn shows in the room with its partial text', async () => {
240
+ const h = harness(agent => agent === 'dev' ? { partial: 'started', state: 'error', error: 'runtime died' } : 'NO_REPLY');
241
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
242
+ await h.team.send(roomKey, { text: 'hello', userLabel: 'H' });
243
+ await h.settle();
244
+ assert.equal(h.room(roomKey).at(-1), "[Dev]\n\nstarted more\n\n⚠️ *Couldn't finish this reply: runtime died*");
245
+ });
246
+
247
+ test('working session labels are unique per room; unknown agents are refused', async () => {
248
+ const h = harness(() => 'ok');
249
+ const a = (await h.team.createRoom({ agentIds: ['dev', 'atlas'] })).roomKey;
250
+ const b = (await h.team.createRoom({ agentIds: ['dev', 'atlas'] })).roomKey;
251
+ await h.team.send(a, { text: '@dev hi', userLabel: 'H' });
252
+ await h.team.send(b, { text: '@dev hi', userLabel: 'H' });
253
+ await h.settle();
254
+ const labels = h.calls.filter(c => c.method === 'sessions.create' && c.params.label).map(c => c.params.label);
255
+ assert.equal(labels.length, 2);
256
+ assert.notEqual(labels[0], labels[1]);
257
+ await assert.rejects(h.team.createRoom({ agentIds: ['dev', 'ghost'] }), /unknown agent: ghost/);
258
+ await assert.rejects(h.team.addAgent(a, 'ghost'), /unknown agent/);
259
+ });
260
+
261
+ test('stop: a reply the runtime finished after the abort is recovered from the agent session', async () => {
262
+ const h = harness(() => 'x');
263
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas'] });
264
+ const workKey = 'agent:dev:dashboard:w1';
265
+ h.sessions.set(workKey, [{ role: 'user', content: 'prompt', timestamp: 1 }]);
266
+ h.team._recoverAfterAbort(roomKey, { agentId: 'dev', name: 'Dev' }, workKey, { intervalMs: 1 });
267
+ await new Promise(r => setTimeout(r, 20));
268
+ assert.equal(h.room(roomKey).length, 0); // nothing landed: nothing posted
269
+ h.sessions.get(workKey).push({ role: 'assistant', content: [{ type: 'text', text: 'late full answer' }], timestamp: 2 });
270
+ h.team._recoverAfterAbort(roomKey, { agentId: 'dev', name: 'Dev' }, workKey, { intervalMs: 1 });
271
+ await new Promise(r => setTimeout(r, 20));
272
+ assert.deepEqual(h.room(roomKey), ['[Dev]\n\nlate full answer\n\n*[stopped]*']);
273
+ });
274
+
275
+ test('a removed agent keeps its hidden session and gets it back when re-added', async () => {
276
+ const h = harness(agent => `${agent} ok`);
277
+ const { roomKey } = await h.team.createRoom({ agentIds: ['dev', 'atlas', 'main'] });
278
+ await h.team.send(roomKey, { text: '@dev hi', userLabel: 'H' });
279
+ await h.settle();
280
+ const devWork = h.team.room(roomKey).agents.find(a => a.agentId === 'dev').workKey;
281
+ h.team.removeAgent(roomKey, 'dev');
282
+ assert.deepEqual(h.team.room(roomKey).agents.map(a => a.agentId), ['atlas', 'main']);
283
+ assert.equal(h.team.isWorkKey(devWork), true); // still hidden from the thread list
284
+ await h.team.addAgent(roomKey, 'dev');
285
+ const back = h.team.room(roomKey).agents.find(a => a.agentId === 'dev');
286
+ assert.equal(back.workKey, devWork);
287
+ h.team.onSessionDeleted(roomKey);
288
+ assert.ok(h.calls.some(c => c.method === 'sessions.delete' && c.params.key === devWork));
289
+ });
290
+
291
+ test('team_members migration adds the removed column to an existing table', () => {
292
+ const db = new Database(':memory:');
293
+ db.exec('CREATE TABLE team_members (room_key TEXT NOT NULL, agent_id TEXT NOT NULL, work_key TEXT, seen_at INTEGER NOT NULL DEFAULT 0, position INTEGER NOT NULL, PRIMARY KEY (room_key, agent_id))');
294
+ const store = createTeamStore(() => db);
295
+ assert.deepEqual(store.listRooms(), []);
296
+ assert.ok(db.prepare('PRAGMA table_info(team_members)').all().some(c => c.name === 'removed'));
297
+ });