im_wower
·
2026-04-01
final-message.test.cjs
1const assert = require("node:assert/strict");
2const test = require("node:test");
3
4const {
5 createRelayState,
6 extractClaudeCandidateFromText,
7 extractGeminiCandidateFromText,
8 isRelevantStreamUrl,
9 observeSse
10} = require("./final-message.js");
11
12function buildChatgptChunk({
13 assistantMessageId = "msg_abort",
14 conversationId = "conv_abort",
15 text = "@conductor::status"
16} = {}) {
17 return `data: ${JSON.stringify({
18 conversation_id: conversationId,
19 message: {
20 author: {
21 role: "assistant"
22 },
23 content: {
24 parts: [text]
25 },
26 end_turn: true,
27 id: assistantMessageId
28 }
29 })}`;
30}
31
32function buildClaudeChunk({
33 event = null,
34 payload = {}
35} = {}) {
36 return [
37 event ? `event: ${event}` : null,
38 `data: ${JSON.stringify(payload)}`
39 ].filter(Boolean).join("\n");
40}
41
42test("isRelevantStreamUrl only accepts ChatGPT root conversation streams", () => {
43 assert.equal(
44 isRelevantStreamUrl("chatgpt", "https://chatgpt.com/backend-api/conversation"),
45 true
46 );
47 assert.equal(
48 isRelevantStreamUrl("chatgpt", "https://chatgpt.com/backend-api/f/conversation?oai-device-id=test"),
49 true
50 );
51 assert.equal(
52 isRelevantStreamUrl("chatgpt", "https://chatgpt.com/backend-api/conversation/implicit_message_feedback"),
53 false
54 );
55 assert.equal(
56 isRelevantStreamUrl("chatgpt", "https://chatgpt.com/backend-api/f/conversation/prepare"),
57 false
58 );
59});
60
61test("observeSse recovers a ChatGPT final message when the SSE stream aborts after chunks arrived", () => {
62 const state = createRelayState("chatgpt");
63 const meta = {
64 observedAt: 1743206400000,
65 pageUrl: "https://chatgpt.com/c/conv_abort"
66 };
67 const url = "https://chatgpt.com/backend-api/f/conversation";
68 const reqBody = JSON.stringify({
69 conversation_id: "conv_abort"
70 });
71
72 assert.equal(
73 observeSse(state, {
74 chunk: buildChatgptChunk(),
75 reqBody,
76 url
77 }, meta),
78 null
79 );
80
81 const relay = observeSse(state, {
82 error: "The operation was aborted.",
83 reqBody,
84 url
85 }, meta);
86
87 assert.ok(relay);
88 assert.equal(relay.payload.platform, "chatgpt");
89 assert.equal(relay.payload.conversation_id, "conv_abort");
90 assert.equal(relay.payload.assistant_message_id, "msg_abort");
91 assert.equal(relay.payload.raw_text, "@conductor::status");
92 assert.equal(relay.payload.observed_at, 1743206400000);
93 assert.equal(state.activeStream, null);
94});
95
96test("observeSse ignores ChatGPT auxiliary conversation subpaths", () => {
97 const state = createRelayState("chatgpt");
98 const relay = observeSse(state, {
99 chunk: buildChatgptChunk(),
100 url: "https://chatgpt.com/backend-api/conversation/implicit_message_feedback"
101 }, {
102 observedAt: 1743206400000,
103 pageUrl: "https://chatgpt.com/c/conv_abort"
104 });
105
106 assert.equal(relay, null);
107 assert.equal(state.activeStream, null);
108});
109
110test("extractClaudeCandidateFromText falls back to Claude text_delta chunks when completion payloads are absent", () => {
111 const candidate = extractClaudeCandidateFromText([
112 buildClaudeChunk({
113 event: "message_start",
114 payload: {
115 type: "message_start",
116 message: {
117 uuid: "msg_claude_delta"
118 }
119 }
120 }),
121 buildClaudeChunk({
122 event: "content_block_delta",
123 payload: {
124 type: "content_block_delta",
125 delta: {
126 type: "thinking_delta",
127 thinking: "Let me think"
128 }
129 }
130 }),
131 buildClaudeChunk({
132 event: "content_block_delta",
133 payload: {
134 type: "content_block_delta",
135 delta: {
136 type: "text_delta",
137 text: "Hello"
138 }
139 }
140 }),
141 buildClaudeChunk({
142 event: "content_block_delta",
143 payload: {
144 type: "content_block_delta",
145 delta: {
146 type: "text_delta",
147 text: " world"
148 }
149 }
150 }),
151 buildClaudeChunk({
152 event: "message_stop",
153 payload: {
154 type: "message_stop"
155 }
156 })
157 ].join("\n\n"), {
158 pageUrl: "https://claude.ai/chat/conv-claude-delta",
159 url: "https://claude.ai/api/organizations/org-1/chat_conversations/conv-claude-delta/completion"
160 });
161
162 assert.ok(candidate);
163 assert.equal(candidate.assistantMessageId, "msg_claude_delta");
164 assert.equal(candidate.conversationId, "conv-claude-delta");
165 assert.equal(candidate.rawText, "Hello world");
166});
167
168test("extractClaudeCandidateFromText keeps completion as the primary Claude path when both payload shapes appear", () => {
169 const candidate = extractClaudeCandidateFromText([
170 buildClaudeChunk({
171 event: "message_start",
172 payload: {
173 type: "message_start",
174 message: {
175 id: "msg_claude_primary"
176 }
177 }
178 }),
179 buildClaudeChunk({
180 event: "content_block_delta",
181 payload: {
182 type: "content_block_delta",
183 delta: {
184 type: "text_delta",
185 text: "fallback text"
186 }
187 }
188 }),
189 buildClaudeChunk({
190 event: "completion",
191 payload: {
192 type: "completion",
193 id: "msg_claude_primary",
194 completion: "primary text"
195 }
196 })
197 ].join("\n\n"), {
198 pageUrl: "https://claude.ai/chat/conv-claude-primary",
199 url: "https://claude.ai/api/organizations/org-1/chat_conversations/conv-claude-primary/completion"
200 });
201
202 assert.ok(candidate);
203 assert.equal(candidate.assistantMessageId, "msg_claude_primary");
204 assert.equal(candidate.conversationId, "conv-claude-primary");
205 assert.equal(candidate.rawText, "primary text");
206});
207
208test("observeSse relays Claude text_delta fallback after an aborted SSE stream", () => {
209 const state = createRelayState("claude");
210 const meta = {
211 observedAt: 1743206400000,
212 pageUrl: "https://claude.ai/chat/conv-claude-sse"
213 };
214 const url = "https://claude.ai/api/organizations/org-1/chat_conversations/conv-claude-sse/completion";
215
216 assert.equal(
217 observeSse(state, {
218 chunk: buildClaudeChunk({
219 event: "message_start",
220 payload: {
221 type: "message_start",
222 message: {
223 uuid: "msg-claude-sse"
224 }
225 }
226 }),
227 url
228 }, meta),
229 null
230 );
231
232 assert.equal(
233 observeSse(state, {
234 chunk: buildClaudeChunk({
235 event: "content_block_delta",
236 payload: {
237 type: "content_block_delta",
238 delta: {
239 type: "thinking_delta",
240 thinking: "scratchpad"
241 }
242 }
243 }),
244 url
245 }, meta),
246 null
247 );
248
249 assert.equal(
250 observeSse(state, {
251 chunk: buildClaudeChunk({
252 event: "content_block_delta",
253 payload: {
254 type: "content_block_delta",
255 delta: {
256 type: "text_delta",
257 text: "Alpha"
258 }
259 }
260 }),
261 url
262 }, meta),
263 null
264 );
265
266 assert.equal(
267 observeSse(state, {
268 chunk: buildClaudeChunk({
269 event: "content_block_delta",
270 payload: {
271 type: "content_block_delta",
272 delta: {
273 type: "text_delta",
274 text: " beta"
275 }
276 }
277 }),
278 url
279 }, meta),
280 null
281 );
282
283 const relay = observeSse(state, {
284 error: "The operation was aborted.",
285 url
286 }, meta);
287
288 assert.ok(relay);
289 assert.equal(relay.payload.platform, "claude");
290 assert.equal(relay.payload.conversation_id, "conv-claude-sse");
291 assert.equal(relay.payload.assistant_message_id, "msg-claude-sse");
292 assert.equal(relay.payload.raw_text, "Alpha beta");
293 assert.equal(relay.payload.observed_at, 1743206400000);
294 assert.equal(state.activeStream, null);
295});
296
297test("observeSse relays Claude text_delta fallback when a CRLF-delimited stream arrives as one buffered chunk", () => {
298 const state = createRelayState("claude");
299 const meta = {
300 observedAt: 1743206400000,
301 pageUrl: "https://claude.ai/chat/conv-claude-crlf"
302 };
303 const url = "https://claude.ai/api/organizations/org-1/chat_conversations/conv-claude-crlf/completion";
304 const chunk = [
305 "event: message_start",
306 'data: {"type":"message_start","message":{"uuid":"msg-claude-crlf"}}',
307 "",
308 "event: content_block_delta",
309 'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"Alpha"}}',
310 "",
311 "event: content_block_delta",
312 'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":" beta"}}',
313 "",
314 "event: message_stop",
315 'data: {"type":"message_stop"}',
316 ""
317 ].join("\r\n");
318
319 assert.equal(
320 observeSse(state, {
321 chunk,
322 url
323 }, meta),
324 null
325 );
326
327 const relay = observeSse(state, {
328 error: "The operation was aborted.",
329 url
330 }, meta);
331
332 assert.ok(relay);
333 assert.equal(relay.payload.platform, "claude");
334 assert.equal(relay.payload.conversation_id, "conv-claude-crlf");
335 assert.equal(relay.payload.assistant_message_id, "msg-claude-crlf");
336 assert.equal(relay.payload.raw_text, "Alpha beta");
337 assert.equal(relay.payload.observed_at, 1743206400000);
338 assert.equal(state.activeStream, null);
339});
340
341test("observeSse ignores Claude thinking-only protocol chunks", () => {
342 const state = createRelayState("claude");
343 const meta = {
344 observedAt: 1743206400000,
345 pageUrl: "https://claude.ai/chat/conv-claude-thinking-only"
346 };
347 const url = "https://claude.ai/api/organizations/org-1/chat_conversations/conv-claude-thinking-only/completion";
348
349 assert.equal(
350 observeSse(state, {
351 chunk: buildClaudeChunk({
352 event: "message_start",
353 payload: {
354 type: "message_start",
355 message: {
356 uuid: "msg-claude-thinking-only"
357 }
358 }
359 }),
360 url
361 }, meta),
362 null
363 );
364
365 assert.equal(
366 observeSse(state, {
367 chunk: buildClaudeChunk({
368 event: "content_block_delta",
369 payload: {
370 type: "content_block_delta",
371 delta: {
372 type: "thinking_delta",
373 thinking: "plan"
374 }
375 }
376 }),
377 url
378 }, meta),
379 null
380 );
381
382 const relay = observeSse(state, {
383 done: true,
384 url
385 }, meta);
386
387 assert.equal(relay, null);
388 assert.equal(state.activeStream, null);
389});
390
391test("extractGeminiCandidateFromText keeps short exact-reply tokens instead of serialized wrappers", () => {
392 const reqBody = new URLSearchParams({
393 "f.req": JSON.stringify([
394 null,
395 JSON.stringify([["Reply with exactly: conductor-ok-731. No punctuation, no explanation."]])
396 ])
397 }).toString();
398 const candidate = extractGeminiCandidateFromText(JSON.stringify([
399 ["wrb.fr", "req-smoke", JSON.stringify([["conductor-ok-731"]]), null, null, null, "generic"]
400 ]), {
401 pageUrl: "https://gemini.google.com/app/conv-gemini-short-token",
402 reqBody
403 });
404
405 assert.ok(candidate);
406 assert.equal(candidate.conversationId, "conv-gemini-short-token");
407 assert.equal(candidate.rawText, "conductor-ok-731");
408});
409
410test("extractGeminiCandidateFromText rejects nested Gemini protocol fragments", () => {
411 const candidate = extractGeminiCandidateFromText(JSON.stringify([
412 [
413 "wrb.fr",
414 "req-smoke",
415 "[[[[2,15,2],1,0,[1774860674,754000000],80,80],[[2,4,2],1,8,[1774865703,894000000],25,23]],\"e6fa609c3fa255c0\"]",
416 null,
417 null,
418 null,
419 "generic"
420 ]
421 ]), {
422 pageUrl: "https://gemini.google.com/app/conv-gemini-protocol-fragment",
423 reqBody: ""
424 });
425
426 assert.equal(candidate, null);
427});