Add unit tests for prompt-converters.js (#5364) * Add unit tests for prompt-converters.js * fix: add type annotation for prompt-converters module --------- Co-authored-by: Cohee <18619528+Cohee1207@users.noreply.github.com>

760263b78a32feecc7cc184511f5b9c15a167649

Tony Gies <tgies@tgies.net>

Signed
Parents: 128888f605381d1d4b3c999fb39ca52f65932f00
1 files changed, +1263 -0Ignore whitespace
tests/prompt-converters.test.js+1263 -0
@@ -0,0 +1,1263 @@
1+import { describe, test, expect, jest, beforeAll } from '@jest/globals';
2+
3+jest.unstable_mockModule('../src/util.js', () => ({
4+ getConfigValue: jest.fn((_key, defaultValue) => defaultValue),
5+ tryParse: (str) => { try { return JSON.parse(str); } catch { return undefined; } },
6+}));
7+
8+/** @type {import('../src/prompt-converters.js')} */
9+let mod;
10+
11+beforeAll(async () => {
12+ mod = await import('../src/prompt-converters.js');
13+});
14+
15+function makeNames(charName = '', userName = '', groupNames = []) {
16+ return {
17+ charName,
18+ userName,
19+ groupNames,
20+ startsWithGroupName(message) {
21+ return this.groupNames.some(name => message.startsWith(`${name}: `));
22+ },
23+ };
24+}
25+
26+
27+describe('addAssistantPrefix', () => {
28+ test('returns empty array unchanged', () => {
29+ expect(mod.addAssistantPrefix([], [], 'prefix')).toEqual([]);
30+ });
31+
32+ test('sets property on last message when it is assistant and no tools', () => {
33+ const prompt = [
34+ { role: 'user', content: 'hi' },
35+ { role: 'assistant', content: 'hello' },
36+ ];
37+ mod.addAssistantPrefix(prompt, [], 'prefix');
38+ expect(prompt[1].prefix).toBe(true);
39+ });
40+
41+ test('does not set property when tools are present', () => {
42+ const prompt = [
43+ { role: 'user', content: 'hi' },
44+ { role: 'assistant', content: 'hello' },
45+ ];
46+ mod.addAssistantPrefix(prompt, [{ type: 'function' }], 'prefix');
47+ expect(prompt[1].prefix).toBeUndefined();
48+ });
49+
50+ test('does not set property when last message is not assistant', () => {
51+ const prompt = [
52+ { role: 'assistant', content: 'hello' },
53+ { role: 'user', content: 'hi' },
54+ ];
55+ mod.addAssistantPrefix(prompt, [], 'prefix');
56+ expect(prompt[0].prefix).toBeUndefined();
57+ expect(prompt[1].prefix).toBeUndefined();
58+ });
59+
60+ test('does not set property when a tool role message exists in prompt', () => {
61+ const prompt = [
62+ { role: 'user', content: 'hi' },
63+ { role: 'tool', content: 'result' },
64+ { role: 'assistant', content: 'hello' },
65+ ];
66+ mod.addAssistantPrefix(prompt, [], 'prefix');
67+ expect(prompt[2].prefix).toBeUndefined();
68+ });
69+});
70+
71+
72+describe('convertTextCompletionPrompt', () => {
73+ test('passes through string input unchanged', () => {
74+ expect(mod.convertTextCompletionPrompt('raw prompt')).toBe('raw prompt');
75+ });
76+
77+ test('converts basic message array to text format', () => {
78+ const messages = [
79+ { role: 'system', content: 'You are helpful.' },
80+ { role: 'user', content: 'Hello' },
81+ { role: 'assistant', content: 'Hi there' },
82+ ];
83+ const result = mod.convertTextCompletionPrompt(messages);
84+ expect(result).toBe(
85+ 'System: You are helpful.\nuser: Hello\nassistant: Hi there\nassistant:',
86+ );
87+ });
88+
89+ test('uses name instead of role for named system messages', () => {
90+ const messages = [
91+ { role: 'system', name: 'Narrator', content: 'Once upon a time' },
92+ ];
93+ const result = mod.convertTextCompletionPrompt(messages);
94+ expect(result).toBe('Narrator: Once upon a time\nassistant:');
95+ });
96+
97+ test('handles empty array', () => {
98+ expect(mod.convertTextCompletionPrompt([])).toBe('\nassistant:');
99+ });
100+});
101+
102+
103+describe('calculateClaudeBudgetTokens', () => {
104+ describe('adaptive model (Opus 4.6+)', () => {
105+ test('auto returns null', () => {
106+ expect(mod.calculateClaudeBudgetTokens(8192, 'auto', true, true)).toBeNull();
107+ });
108+
109+ test('min returns "low"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'min', true, true)).toBe('low'));
110+ test('low returns "low"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'low', true, true)).toBe('low'));
111+ test('medium returns "medium"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'medium', true, true)).toBe('medium'));
112+ test('high returns "high"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'high', true, true)).toBe('high'));
113+ test('max returns "max"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'max', true, true)).toBe('max'));
114+ });
115+
116+ describe('traditional model', () => {
117+ test('auto returns null', () => {
118+ expect(mod.calculateClaudeBudgetTokens(8192, 'auto', true, false)).toBeNull();
119+ });
120+
121+ test('min returns 1024 regardless of maxTokens', () => {
122+ expect(mod.calculateClaudeBudgetTokens(100, 'min', true, false)).toBe(1024);
123+ expect(mod.calculateClaudeBudgetTokens(100000, 'min', true, false)).toBe(1024);
124+ });
125+
126+ test('low is 10% of maxTokens, floored to 1024', () => {
127+ expect(mod.calculateClaudeBudgetTokens(50000, 'low', true, false)).toBe(5000);
128+ // 10% of 5000 = 500, but floor is 1024
129+ expect(mod.calculateClaudeBudgetTokens(5000, 'low', true, false)).toBe(1024);
130+ });
131+
132+ test('medium is 25% of maxTokens', () => {
133+ expect(mod.calculateClaudeBudgetTokens(40000, 'medium', true, false)).toBe(10000);
134+ });
135+
136+ test('high is 50% of maxTokens', () => {
137+ expect(mod.calculateClaudeBudgetTokens(40000, 'high', true, false)).toBe(20000);
138+ });
139+
140+ test('max is 95% of maxTokens', () => {
141+ expect(mod.calculateClaudeBudgetTokens(40000, 'max', true, false)).toBe(38000);
142+ });
143+
144+ test('non-streaming caps at 21333', () => {
145+ expect(mod.calculateClaudeBudgetTokens(100000, 'max', false, false)).toBe(21333);
146+ });
147+
148+ test('streaming does not cap at 21333', () => {
149+ expect(mod.calculateClaudeBudgetTokens(100000, 'max', true, false)).toBe(95000);
150+ });
151+ });
152+});
153+
154+
155+describe('calculateGoogleBudgetTokens', () => {
156+ test('returns null for unrecognized model', () => {
157+ expect(mod.calculateGoogleBudgetTokens(8192, 'medium', 'gpt-4')).toBeNull();
158+ });
159+
160+ describe('gemini-3 flash', () => {
161+ test('auto returns null', () => expect(mod.calculateGoogleBudgetTokens(8192, 'auto', 'gemini-3.5-flash')).toBeNull());
162+ test('min returns minimal', () => expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-3.5-flash')).toBe('minimal'));
163+ test('low returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'low', 'gemini-3.5-flash')).toBe('low'));
164+ test('medium returns medium', () => expect(mod.calculateGoogleBudgetTokens(8192, 'medium', 'gemini-3.5-flash')).toBe('medium'));
165+ test('high returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'high', 'gemini-3.5-flash')).toBe('high'));
166+ test('max returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'max', 'gemini-3.5-flash')).toBe('high'));
167+ });
168+
169+ describe('gemini-3 pro', () => {
170+ test('auto returns null', () => expect(mod.calculateGoogleBudgetTokens(8192, 'auto', 'gemini-3.0-pro')).toBeNull());
171+ test('min returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-3.0-pro')).toBe('low'));
172+ test('low returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'low', 'gemini-3.0-pro')).toBe('low'));
173+ test('medium returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'medium', 'gemini-3.0-pro')).toBe('low'));
174+ test('high returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'high', 'gemini-3.0-pro')).toBe('high'));
175+ test('max returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'max', 'gemini-3.0-pro')).toBe('high'));
176+ });
177+
178+ describe('flash (non-gemini-3)', () => {
179+ test('auto returns -1', () => {
180+ expect(mod.calculateGoogleBudgetTokens(8192, 'auto', 'gemini-2.0-flash')).toBe(-1);
181+ });
182+
183+ test('min returns 0', () => {
184+ expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-2.0-flash')).toBe(0);
185+ });
186+
187+ test('caps at 24576', () => {
188+ expect(mod.calculateGoogleBudgetTokens(500000, 'max', 'gemini-2.0-flash')).toBe(24576);
189+ });
190+ });
191+
192+ describe('flash-lite', () => {
193+ test('min returns 0', () => {
194+ expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-2.0-flash-lite')).toBe(0);
195+ });
196+
197+ test('floors at 512', () => {
198+ expect(mod.calculateGoogleBudgetTokens(1000, 'low', 'gemini-2.0-flash-lite')).toBe(512);
199+ });
200+ });
201+
202+ describe('pro (non-gemini-3)', () => {
203+ test('min returns 128', () => {
204+ expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-2.5-pro')).toBe(128);
205+ });
206+
207+ test('floors at 128', () => {
208+ expect(mod.calculateGoogleBudgetTokens(500, 'low', 'gemini-2.5-pro')).toBe(128);
209+ });
210+
211+ test('caps at 32768', () => {
212+ expect(mod.calculateGoogleBudgetTokens(500000, 'max', 'gemini-2.5-pro')).toBe(32768);
213+ });
214+ });
215+
216+ describe('model matching priority', () => {
217+ // flash-lite must match before flash
218+ test('flash-lite matches before flash', () => {
219+ // flash-lite min = 0, flash min = 0 too, so use a differentiating case
220+ // flash-lite low floors at 512, flash low does not
221+ expect(mod.calculateGoogleBudgetTokens(1000, 'low', 'gemini-2.0-flash-lite')).toBe(512);
222+ expect(mod.calculateGoogleBudgetTokens(1000, 'low', 'gemini-2.0-flash')).toBe(100);
223+ });
224+ });
225+});
226+
227+
228+describe('addReasoningContentToToolCalls', () => {
229+ test('adds reasoning_content to messages with tool_calls', () => {
230+ const messages = [
231+ { role: 'assistant', tool_calls: [{ id: '1', function: { name: 'f' } }] },
232+ ];
233+ mod.addReasoningContentToToolCalls(messages);
234+ expect(messages[0].reasoning_content).toBe('');
235+ });
236+
237+ test('does not overwrite existing reasoning_content', () => {
238+ const messages = [
239+ { role: 'assistant', tool_calls: [{ id: '1' }], reasoning_content: 'existing' },
240+ ];
241+ mod.addReasoningContentToToolCalls(messages);
242+ expect(messages[0].reasoning_content).toBe('existing');
243+ });
244+
245+ test('skips messages without tool_calls', () => {
246+ const messages = [{ role: 'user', content: 'hi' }];
247+ mod.addReasoningContentToToolCalls(messages);
248+ expect(messages[0].reasoning_content).toBeUndefined();
249+ });
250+
251+ test('handles non-array input gracefully', () => {
252+ expect(() => mod.addReasoningContentToToolCalls(null)).not.toThrow();
253+ expect(() => mod.addReasoningContentToToolCalls('string')).not.toThrow();
254+ });
255+});
256+
257+
258+describe('embedOpenRouterMedia', () => {
259+ test('converts audio data URLs to input_audio format', () => {
260+ const messages = [{
261+ role: 'user',
262+ content: [{
263+ type: 'audio_url',
264+ audio_url: { url: 'data:audio/wav;base64,AAAA' },
265+ }],
266+ }];
267+ mod.embedOpenRouterMedia(messages);
268+ expect(messages[0].content[0]).toEqual({
269+ type: 'input_audio',
270+ input_audio: { format: 'wav', data: 'AAAA' },
271+ });
272+ });
273+
274+ test('defaults to mp3 for unknown audio mime types', () => {
275+ const messages = [{
276+ role: 'user',
277+ content: [{
278+ type: 'audio_url',
279+ audio_url: { url: 'data:audio/ogg;base64,BBBB' },
280+ }],
281+ }];
282+ mod.embedOpenRouterMedia(messages);
283+ expect(messages[0].content[0].input_audio.format).toBe('mp3');
284+ });
285+
286+ test('skips non-data-URL audio', () => {
287+ const messages = [{
288+ role: 'user',
289+ content: [{
290+ type: 'audio_url',
291+ audio_url: { url: 'https://example.com/audio.mp3' },
292+ }],
293+ }];
294+ mod.embedOpenRouterMedia(messages);
295+ expect(messages[0].content[0].type).toBe('audio_url');
296+ });
297+
298+ test('keeps video_url type for video data URLs', () => {
299+ const messages = [{
300+ role: 'user',
301+ content: [{
302+ type: 'video_url',
303+ video_url: { url: 'data:video/mp4;base64,CCCC' },
304+ }],
305+ }];
306+ mod.embedOpenRouterMedia(messages);
307+ expect(messages[0].content[0].type).toBe('video_url');
308+ });
309+
310+ test('skips non-data-URL video', () => {
311+ const messages = [{
312+ role: 'user',
313+ content: [{
314+ type: 'video_url',
315+ video_url: { url: 'https://example.com/video.mp4' },
316+ }],
317+ }];
318+ mod.embedOpenRouterMedia(messages);
319+ expect(messages[0].content[0].type).toBe('video_url');
320+ });
321+
322+ test('respects audio=false option', () => {
323+ const messages = [{
324+ role: 'user',
325+ content: [{
326+ type: 'audio_url',
327+ audio_url: { url: 'data:audio/wav;base64,AAAA' },
328+ }],
329+ }];
330+ mod.embedOpenRouterMedia(messages, { audio: false, video: true });
331+ expect(messages[0].content[0].type).toBe('audio_url');
332+ });
333+
334+ test('respects video=false option', () => {
335+ const messages = [{
336+ role: 'user',
337+ content: [{
338+ type: 'video_url',
339+ video_url: { url: 'data:video/mp4;base64,CCCC' },
340+ }],
341+ }];
342+ mod.embedOpenRouterMedia(messages, { audio: true, video: false });
343+ expect(messages[0].content[0].type).toBe('video_url');
344+ });
345+
346+ test('handles non-array input gracefully', () => {
347+ expect(() => mod.embedOpenRouterMedia(null)).not.toThrow();
348+ expect(() => mod.embedOpenRouterMedia('string')).not.toThrow();
349+ });
350+
351+ test('skips messages with string content', () => {
352+ const messages = [{ role: 'user', content: 'just text' }];
353+ mod.embedOpenRouterMedia(messages);
354+ expect(messages[0].content).toBe('just text');
355+ });
356+});
357+
358+
359+describe('cachingSystemPromptForOpenRouter', () => {
360+ test('adds cache_control to string system message', () => {
361+ const messages = [{ role: 'system', content: 'You are helpful.' }];
362+ mod.cachingSystemPromptForOpenRouter(messages);
363+ expect(messages[0].content).toEqual([
364+ { type: 'text', text: 'You are helpful.', cache_control: { type: 'ephemeral' } },
365+ ]);
366+ });
367+
368+ test('adds cache_control with TTL', () => {
369+ const messages = [{ role: 'system', content: 'System prompt' }];
370+ mod.cachingSystemPromptForOpenRouter(messages, '300');
371+ expect(messages[0].content[0].cache_control).toEqual({ type: 'ephemeral', ttl: '300' });
372+ });
373+
374+ test('adds cache_control to last text part of array content', () => {
375+ const messages = [{
376+ role: 'system',
377+ content: [
378+ { type: 'text', text: 'first' },
379+ { type: 'text', text: 'second' },
380+ ],
381+ }];
382+ mod.cachingSystemPromptForOpenRouter(messages);
383+ expect(messages[0].content[0].cache_control).toBeUndefined();
384+ expect(messages[0].content[1].cache_control).toEqual({ type: 'ephemeral' });
385+ });
386+
387+ test('skips if system message already has cache_control', () => {
388+ const messages = [{ role: 'system', content: 'prompt', cache_control: { type: 'ephemeral' } }];
389+ mod.cachingSystemPromptForOpenRouter(messages);
390+ // content should remain a string, not converted
391+ expect(messages[0].content).toBe('prompt');
392+ });
393+
394+ test('skips if array content already has cache_control', () => {
395+ const messages = [{
396+ role: 'system',
397+ content: [{ type: 'text', text: 'cached', cache_control: { type: 'ephemeral' } }],
398+ }];
399+ mod.cachingSystemPromptForOpenRouter(messages);
400+ // Should not add another cache_control
401+ expect(messages[0].content).toHaveLength(1);
402+ });
403+
404+ test('does nothing with empty array', () => {
405+ expect(() => mod.cachingSystemPromptForOpenRouter([])).not.toThrow();
406+ });
407+
408+ test('does nothing without system message', () => {
409+ const messages = [{ role: 'user', content: 'hi' }];
410+ mod.cachingSystemPromptForOpenRouter(messages);
411+ expect(messages[0].content).toBe('hi');
412+ });
413+});
414+
415+
416+describe('convertAI21Messages', () => {
417+ const names = makeNames('Bot', 'User');
418+
419+ test('returns empty array for non-array input', () => {
420+ expect(mod.convertAI21Messages(null, names)).toEqual([]);
421+ expect(mod.convertAI21Messages('string', names)).toEqual([]);
422+ });
423+
424+ test('extracts leading system messages into merged system prompt', () => {
425+ const messages = [
426+ { role: 'system', content: 'You are a bot.' },
427+ { role: 'system', content: 'Be helpful.' },
428+ { role: 'user', content: 'Hello' },
429+ ];
430+ const result = mod.convertAI21Messages(messages, names);
431+ expect(result[0]).toEqual({ role: 'system', content: 'You are a bot.\n\nBe helpful.' });
432+ expect(result[1]).toEqual({ role: 'user', content: 'Hello' });
433+ });
434+
435+ test('prepends character name to example_assistant system messages', () => {
436+ const messages = [
437+ { role: 'system', name: 'example_assistant', content: 'I greet you.' },
438+ { role: 'user', content: 'Hi' },
439+ ];
440+ const result = mod.convertAI21Messages(messages, names);
441+ expect(result[0].content).toContain('Bot: I greet you.');
442+ });
443+
444+ test('does not double-prepend if name already present', () => {
445+ const messages = [
446+ { role: 'system', name: 'example_assistant', content: 'Bot: I greet you.' },
447+ { role: 'user', content: 'Hi' },
448+ ];
449+ const result = mod.convertAI21Messages(messages, names);
450+ expect(result[0].content).not.toContain('Bot: Bot:');
451+ });
452+
453+ test('merges consecutive same-role messages', () => {
454+ const messages = [
455+ { role: 'user', content: 'First' },
456+ { role: 'user', content: 'Second' },
457+ { role: 'assistant', content: 'Reply' },
458+ ];
459+ const result = mod.convertAI21Messages(messages, names);
460+ expect(result).toHaveLength(2);
461+ expect(result[0].content).toBe('First\n\nSecond');
462+ });
463+
464+ test('prepends name to non-system messages and deletes name property', () => {
465+ const messages = [
466+ { role: 'user', name: 'Alice', content: 'Hello' },
467+ ];
468+ const result = mod.convertAI21Messages(messages, names);
469+ expect(result[0].content).toBe('Alice: Hello');
470+ expect(result[0].name).toBeUndefined();
471+ });
472+
473+ test('inserts placeholder when all messages are system', () => {
474+ const messages = [
475+ { role: 'system', content: 'Setup' },
476+ ];
477+ const result = mod.convertAI21Messages(messages, names);
478+ // After extracting the system message, array is empty, so placeholder is inserted
479+ expect(result).toHaveLength(2);
480+ expect(result[0]).toEqual({ role: 'system', content: 'Setup' });
481+ expect(result[1].role).toBe('user');
482+ });
483+});
484+
485+
486+describe('convertCohereMessages', () => {
487+ const names = makeNames('Bot', 'User');
488+
489+ test('inserts placeholder for empty messages', () => {
490+ const messages = [];
491+ const result = mod.convertCohereMessages(messages, names);
492+ expect(result.chatHistory).toHaveLength(1);
493+ expect(result.chatHistory[0].role).toBe('user');
494+ });
495+
496+ test('prepends character name to example_assistant system messages', () => {
497+ const messages = [
498+ { role: 'system', name: 'example_assistant', content: 'Greetings' },
499+ ];
500+ const result = mod.convertCohereMessages(messages, names);
501+ expect(result.chatHistory[0].content).toBe('Bot: Greetings');
502+ });
503+
504+ test('prepends user name to example_user system messages', () => {
505+ const messages = [
506+ { role: 'system', name: 'example_user', content: 'Hello there' },
507+ ];
508+ const result = mod.convertCohereMessages(messages, names);
509+ expect(result.chatHistory[0].content).toBe('User: Hello there');
510+ });
511+
512+ test('prepends name to non-system messages', () => {
513+ const messages = [
514+ { role: 'assistant', name: 'NPC', content: 'I am an NPC' },
515+ ];
516+ const result = mod.convertCohereMessages(messages, names);
517+ expect(result.chatHistory[0].content).toBe('NPC: I am an NPC');
518+ expect(result.chatHistory[0].name).toBeUndefined();
519+ });
520+
521+ test('handles tool_calls by extracting function names', () => {
522+ const messages = [
523+ { role: 'assistant', tool_calls: [{ function: { name: 'search' } }, { function: { name: 'fetch' } }] },
524+ ];
525+ const result = mod.convertCohereMessages(messages, names);
526+ expect(result.chatHistory[0].content).toContain('search, fetch');
527+ });
528+});
529+
530+
531+describe('convertXAIMessages', () => {
532+ const names = makeNames('Char', 'Player');
533+
534+ test('returns empty array for non-array input', () => {
535+ expect(mod.convertXAIMessages(null, names)).toEqual([]);
536+ });
537+
538+ test('prepends char name to assistant messages', () => {
539+ const messages = [
540+ { role: 'assistant', name: 'Char', content: 'Hello' },
541+ ];
542+ const result = mod.convertXAIMessages(messages, names);
543+ expect(result[0].content).toBe('Char: Hello');
544+ expect(result[0].name).toBeUndefined();
545+ });
546+
547+ test('skips user role messages entirely', () => {
548+ const messages = [
549+ { role: 'user', name: 'Someone', content: 'Hello' },
550+ ];
551+ const result = mod.convertXAIMessages(messages, names);
552+ expect(result[0].content).toBe('Hello');
553+ expect(result[0].name).toBe('Someone');
554+ });
555+
556+ test('handles group names - does not double prefix', () => {
557+ const groupNames = makeNames('Char', 'Player', ['Alice', 'Bob']);
558+ const messages = [
559+ { role: 'assistant', name: 'SomeNPC', content: 'Alice: speaking as Alice' },
560+ ];
561+ const result = mod.convertXAIMessages(messages, groupNames);
562+ // Starts with group name, so charName prefix should not be added
563+ expect(result[0].content).toBe('Alice: speaking as Alice');
564+ });
565+});
566+
567+
568+describe('mergeMessages', () => {
569+ const names = makeNames('Bot', 'User');
570+
571+ test('squashes consecutive same-role messages', () => {
572+ const messages = [
573+ { role: 'user', content: 'A' },
574+ { role: 'user', content: 'B' },
575+ { role: 'assistant', content: 'C' },
576+ ];
577+ const result = mod.mergeMessages(messages, names);
578+ expect(result).toHaveLength(2);
579+ expect(result[0].content).toBe('A\n\nB');
580+ });
581+
582+ test('inserts placeholder for empty messages', () => {
583+ const result = mod.mergeMessages([], names);
584+ expect(result).toHaveLength(1);
585+ expect(result[0].role).toBe('user');
586+ });
587+
588+ test('removes name property and prepends to content for non-system', () => {
589+ const messages = [
590+ { role: 'assistant', name: 'NPC', content: 'dialogue' },
591+ ];
592+ const result = mod.mergeMessages(messages, names);
593+ expect(result[0].content).toBe('NPC: dialogue');
594+ expect(result[0].name).toBeUndefined();
595+ });
596+
597+ test('strict mode forces mid-prompt system to user', () => {
598+ const messages = [
599+ { role: 'system', content: 'Setup' },
600+ { role: 'system', content: 'More setup' },
601+ { role: 'user', content: 'Hi' },
602+ ];
603+ const result = mod.mergeMessages(messages, names, { strict: true });
604+ // First system stays, second should become user and merge
605+ expect(result[0].role).toBe('system');
606+ expect(result.filter(m => m.role === 'system')).toHaveLength(1);
607+ });
608+
609+ test('single mode forces all roles to user', () => {
610+ const messages = [
611+ { role: 'system', content: 'Setup' },
612+ { role: 'user', content: 'Hello' },
613+ { role: 'assistant', content: 'Response' },
614+ ];
615+ const result = mod.mergeMessages(messages, names, { single: true });
616+ expect(result.every(m => m.role === 'user')).toBe(true);
617+ });
618+
619+ test('single mode prepends charName to assistant, userName to user', () => {
620+ const messages = [
621+ { role: 'user', content: 'Hello' },
622+ { role: 'assistant', content: 'Hi back' },
623+ ];
624+ const result = mod.mergeMessages(messages, names, { single: true });
625+ // Both become user and get merged
626+ expect(result[0].content).toContain('User: Hello');
627+ expect(result[0].content).toContain('Bot: Hi back');
628+ });
629+
630+ test('tools=false removes tool_calls and tool_call_id', () => {
631+ const messages = [
632+ { role: 'assistant', content: 'calling', tool_calls: [{ id: '1' }] },
633+ { role: 'tool', content: 'result', tool_call_id: '1' },
634+ ];
635+ const result = mod.mergeMessages(messages, names, { tools: false });
636+ expect(result[0].tool_calls).toBeUndefined();
637+ // tool role should be converted to user
638+ const toolMsg = result.find(m => m.content === 'result' || m.content?.includes?.('result'));
639+ expect(toolMsg).toBeDefined();
640+ });
641+
642+ test('flattens array content and preserves image URLs via tokens', () => {
643+ const imageContent = { type: 'image_url', image_url: { url: 'data:image/png;base64,abc' } };
644+ const messages = [
645+ { role: 'user', content: [{ type: 'text', text: 'Look at this' }, imageContent] },
646+ ];
647+ const result = mod.mergeMessages(messages, names);
648+ // Content should be reconstituted with image preserved
649+ expect(Array.isArray(result[0].content)).toBe(true);
650+ const types = result[0].content.map(c => c.type);
651+ expect(types).toContain('text');
652+ expect(types).toContain('image_url');
653+ });
654+});
655+
656+
657+describe('postProcessPrompt', () => {
658+ const names = makeNames('Bot', 'User');
659+
660+ test('NONE type returns messages unchanged', () => {
661+ const messages = [{ role: 'user', content: 'hi' }];
662+ expect(mod.postProcessPrompt(messages, '', names)).toBe(messages);
663+ });
664+
665+ test('MERGE type merges consecutive same-role messages', () => {
666+ const messages = [
667+ { role: 'user', content: 'A' },
668+ { role: 'user', content: 'B' },
669+ ];
670+ const result = mod.postProcessPrompt(messages, 'merge', names);
671+ expect(result).toHaveLength(1);
672+ expect(result[0].content).toBe('A\n\nB');
673+ });
674+
675+ test('deprecated CLAUDE type works same as MERGE', () => {
676+ const messages = [
677+ { role: 'user', content: 'A' },
678+ { role: 'user', content: 'B' },
679+ ];
680+ const result = mod.postProcessPrompt(messages, 'claude', names);
681+ expect(result).toHaveLength(1);
682+ });
683+});
684+
685+
686+describe('addOpenRouterSignatures', () => {
687+ test('handles non-array input gracefully', () => {
688+ expect(() => mod.addOpenRouterSignatures(null, 'model')).not.toThrow();
689+ });
690+
691+ test('detects google model format', () => {
692+ const messages = [{ role: 'assistant', content: 'hi', signature: 'sig123' }];
693+ mod.addOpenRouterSignatures(messages, 'google/gemini-2.5-pro');
694+ expect(messages[0].reasoning_details).toBeDefined();
695+ expect(messages[0].reasoning_details[0].format).toBe('google-gemini-v1');
696+ });
697+
698+ test('detects anthropic model format', () => {
699+ const messages = [{ role: 'assistant', content: 'hi', signature: 'sig123' }];
700+ mod.addOpenRouterSignatures(messages, 'anthropic/claude-sonnet-4');
701+ expect(messages[0].reasoning_details).toBeDefined();
702+ expect(messages[0].reasoning_details[0].format).toBe('anthropic-claude-v1');
703+ });
704+
705+ test('removes signature property from messages', () => {
706+ const messages = [{ role: 'assistant', content: 'hi', signature: 'sig123' }];
707+ mod.addOpenRouterSignatures(messages, 'anthropic/claude-sonnet-4');
708+ expect(messages[0].signature).toBeUndefined();
709+ });
710+
711+ test('removes signature property from tool_calls', () => {
712+ const messages = [{
713+ role: 'assistant',
714+ content: '',
715+ tool_calls: [{ id: 'tc1', function: { name: 'f' }, signature: 'toolsig' }],
716+ }];
717+ mod.addOpenRouterSignatures(messages, 'anthropic/claude-sonnet-4');
718+ expect(messages[0].tool_calls[0].signature).toBeUndefined();
719+ });
720+});
721+
722+
723+describe('getPromptNames', () => {
724+ test('extracts names from request body', () => {
725+ const request = { body: { char_name: 'Bot', user_name: 'User', group_names: ['Alice', 'Bob'] } };
726+ const names = mod.getPromptNames(request);
727+ expect(names.charName).toBe('Bot');
728+ expect(names.userName).toBe('User');
729+ expect(names.groupNames).toEqual(['Alice', 'Bob']);
730+ });
731+
732+ test('defaults to empty strings and array when missing', () => {
733+ const request = { body: {} };
734+ const names = mod.getPromptNames(request);
735+ expect(names.charName).toBe('');
736+ expect(names.userName).toBe('');
737+ expect(names.groupNames).toEqual([]);
738+ });
739+
740+ test('startsWithGroupName checks message prefix', () => {
741+ const request = { body: { char_name: '', user_name: '', group_names: ['Alice', 'Bob'] } };
742+ const names = mod.getPromptNames(request);
743+ expect(names.startsWithGroupName('Alice: hello')).toBe(true);
744+ expect(names.startsWithGroupName('Charlie: hello')).toBe(false);
745+ });
746+
747+ test('coerces non-string group_names to strings', () => {
748+ const request = { body: { group_names: [123, null] } };
749+ const names = mod.getPromptNames(request);
750+ expect(names.groupNames).toEqual(['123', 'null']);
751+ });
752+});
753+
754+
755+describe('convertClaudePrompt', () => {
756+ test('returns empty string for empty messages', () => {
757+ const result = mod.convertClaudePrompt([], false, '', false, false, '', false);
758+ expect(result).toBe('');
759+ });
760+
761+ test('basic conversion with Human/Assistant prefixes', () => {
762+ const messages = [
763+ { role: 'system', content: 'You are helpful.' },
764+ { role: 'user', content: 'Hello' },
765+ { role: 'assistant', content: 'Hi there' },
766+ ];
767+ const result = mod.convertClaudePrompt(messages, false, '', false, false, '', false);
768+ expect(result).toContain('Hello');
769+ expect(result).toContain('Hi there');
770+ expect(result).toContain('\n\nHuman: ');
771+ expect(result).toContain('\n\nAssistant: ');
772+ });
773+
774+ test('adds assistant postfix when requested', () => {
775+ const messages = [
776+ { role: 'user', content: 'Hello' },
777+ ];
778+ const result = mod.convertClaudePrompt(messages, true, '', false, false, '', false);
779+ expect(result).toMatch(/\n\nAssistant: $/);
780+ });
781+
782+ test('adds assistant prefill when provided', () => {
783+ const messages = [
784+ { role: 'user', content: 'Hello' },
785+ ];
786+ const result = mod.convertClaudePrompt(messages, true, 'Sure, I', false, false, '', false);
787+ expect(result).toMatch(/\n\nAssistant: Sure, I$/);
788+ });
789+
790+ test('system prompt mode sets first message role to system', () => {
791+ const messages = [
792+ { role: 'system', content: 'System prompt' },
793+ { role: 'user', content: 'Hello' },
794+ ];
795+ mod.convertClaudePrompt(messages, false, '', true, true, '', false);
796+ // First message should remain system (no prefix)
797+ expect(messages[0].role).toBe('system');
798+ });
799+
800+ test('exclude prefixes mode sets non-last messages to system', () => {
801+ const messages = [
802+ { role: 'user', content: 'First' },
803+ { role: 'assistant', content: 'Second' },
804+ { role: 'user', content: 'Third' },
805+ ];
806+ const result = mod.convertClaudePrompt(messages, false, '', false, false, '', true);
807+ // Non-last messages should have been set to system role (no Human/Assistant prefix)
808+ // Last message keeps its original role
809+ expect(result).toContain('Third');
810+ });
811+
812+ test('stringifies tool_calls into content', () => {
813+ const messages = [
814+ { role: 'assistant', content: 'Let me check', tool_calls: [{ id: '1', function: { name: 'search' } }] },
815+ { role: 'user', content: 'OK' },
816+ ];
817+ const result = mod.convertClaudePrompt(messages, false, '', false, false, '', false);
818+ expect(result).toContain('search');
819+ });
820+});
821+
822+
823+describe('convertClaudeMessages', () => {
824+ const names = makeNames('Bot', 'User');
825+
826+ test('extracts leading system messages when useSysPrompt is true', () => {
827+ const messages = [
828+ { role: 'system', content: 'System instruction' },
829+ { role: 'user', content: 'Hello' },
830+ ];
831+ const result = mod.convertClaudeMessages(messages, '', true, false, names);
832+ expect(result.systemPrompt).toHaveLength(1);
833+ expect(result.systemPrompt[0]).toEqual({ type: 'text', text: 'System instruction' });
834+ expect(result.messages[0].role).toBe('user');
835+ });
836+
837+ test('inserts placeholder when all messages are system and useSysPrompt is true', () => {
838+ const messages = [
839+ { role: 'system', content: 'Only system' },
840+ ];
841+ const result = mod.convertClaudeMessages(messages, '', true, false, names);
842+ expect(result.messages).toHaveLength(1);
843+ expect(result.messages[0].role).toBe('user');
844+ });
845+
846+ test('converts system messages to user role after extraction', () => {
847+ const messages = [
848+ { role: 'user', content: 'Hi' },
849+ { role: 'system', content: 'Mid-prompt system' },
850+ { role: 'assistant', content: 'Reply' },
851+ ];
852+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
853+ // system messages should become user
854+ const roles = result.messages.map(m => m.role);
855+ expect(roles).not.toContain('system');
856+ });
857+
858+ test('merges consecutive same-role messages', () => {
859+ const messages = [
860+ { role: 'user', content: 'A' },
861+ { role: 'user', content: 'B' },
862+ { role: 'assistant', content: 'C' },
863+ ];
864+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
865+ // Two user messages should be merged
866+ expect(result.messages.filter(m => m.role === 'user')).toHaveLength(1);
867+ });
868+
869+ test('converts string content to array of text parts', () => {
870+ const messages = [
871+ { role: 'user', content: 'Hello' },
872+ ];
873+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
874+ expect(Array.isArray(result.messages[0].content)).toBe(true);
875+ expect(result.messages[0].content[0]).toEqual({ type: 'text', text: 'Hello' });
876+ });
877+
878+ test('converts image_url content to Claude base64 format', () => {
879+ const messages = [
880+ { role: 'user', content: [
881+ { type: 'text', text: 'Look' },
882+ { type: 'image_url', image_url: { url: 'data:image/png;base64,abc123' } },
883+ ] },
884+ ];
885+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
886+ const imagePart = result.messages[0].content.find(c => c.type === 'image');
887+ expect(imagePart).toBeDefined();
888+ expect(imagePart.source.type).toBe('base64');
889+ expect(imagePart.source.media_type).toBe('image/png');
890+ expect(imagePart.source.data).toBe('abc123');
891+ });
892+
893+ test('moves images from assistant to next user message', () => {
894+ const messages = [
895+ { role: 'assistant', content: [
896+ { type: 'text', text: 'Here is an image' },
897+ { type: 'image_url', image_url: { url: 'data:image/png;base64,abc' } },
898+ ] },
899+ { role: 'user', content: 'Thanks' },
900+ ];
901+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
902+ // Assistant message should not have images
903+ const assistantImages = result.messages
904+ .filter(m => m.role === 'assistant')
905+ .flatMap(m => m.content)
906+ .filter(c => c.type === 'image');
907+ expect(assistantImages).toHaveLength(0);
908+ });
909+
910+ test('adds prefill as trailing assistant message', () => {
911+ const messages = [
912+ { role: 'user', content: 'Hello' },
913+ ];
914+ const result = mod.convertClaudeMessages(messages, 'Sure, I will ', false, false, names);
915+ const last = result.messages[result.messages.length - 1];
916+ expect(last.role).toBe('assistant');
917+ // Prefill should be trimmed on the right
918+ expect(last.content[0].text).toBe('Sure, I will');
919+ });
920+
921+ test('converts tool_calls to tool_use format', () => {
922+ const messages = [
923+ { role: 'user', content: 'search for cats' },
924+ { role: 'assistant', content: '', tool_calls: [
925+ { id: 'tc1', function: { name: 'search', arguments: '{"q":"cats"}' } },
926+ ] },
927+ ];
928+ const result = mod.convertClaudeMessages(messages, '', false, true, names);
929+ const assistantContent = result.messages.find(m => m.role === 'assistant')?.content;
930+ const toolUse = assistantContent?.find(c => c.type === 'tool_use');
931+ expect(toolUse).toBeDefined();
932+ expect(toolUse.name).toBe('search');
933+ expect(toolUse.input).toEqual({ q: 'cats' });
934+ });
935+
936+ test('converts tool messages to tool_result format', () => {
937+ const messages = [
938+ { role: 'user', content: 'search' },
939+ { role: 'assistant', content: '', tool_calls: [
940+ { id: 'tc1', function: { name: 'search', arguments: '{}' } },
941+ ] },
942+ { role: 'tool', content: 'Found results', tool_call_id: 'tc1' },
943+ ];
944+ const result = mod.convertClaudeMessages(messages, '', false, true, names);
945+ const userContent = result.messages
946+ .filter(m => m.role === 'user')
947+ .flatMap(m => m.content);
948+ const toolResult = userContent.find(c => c.type === 'tool_result');
949+ expect(toolResult).toBeDefined();
950+ expect(toolResult.content).toBe('Found results');
951+ });
952+
953+ test('replaces empty text content with zero-width space', () => {
954+ const messages = [
955+ { role: 'user', content: [{ type: 'text', text: '' }] },
956+ ];
957+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
958+ expect(result.messages[0].content[0].text).toBe('\u200b');
959+ });
960+
961+ test('prepends example_assistant name with charName in system prompt', () => {
962+ const messages = [
963+ { role: 'system', name: 'example_assistant', content: 'Greetings' },
964+ { role: 'user', content: 'Hi' },
965+ ];
966+ const result = mod.convertClaudeMessages(messages, '', true, false, names);
967+ expect(result.systemPrompt[0].text).toBe('Bot: Greetings');
968+ });
969+
970+ test('removes name, tool_calls, and tool_call_id properties from output', () => {
971+ const messages = [
972+ { role: 'user', name: 'Alice', content: 'Hello' },
973+ ];
974+ const result = mod.convertClaudeMessages(messages, '', false, false, names);
975+ const msg = result.messages[0];
976+ expect(msg.name).toBeUndefined();
977+ expect(msg.tool_calls).toBeUndefined();
978+ expect(msg.tool_call_id).toBeUndefined();
979+ });
980+});
981+
982+
983+describe('convertGooglePrompt', () => {
984+ const names = makeNames('Bot', 'User');
985+
986+ test('extracts leading system messages into system_instruction', () => {
987+ const messages = [
988+ { role: 'system', content: 'Be helpful' },
989+ { role: 'system', content: 'Be concise' },
990+ { role: 'user', content: 'Hello' },
991+ ];
992+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', true, names);
993+ expect(result.system_instruction.parts).toEqual([
994+ { text: 'Be helpful' },
995+ { text: 'Be concise' },
996+ ]);
997+ });
998+
999+ test('converts assistant role to model role', () => {
1000+ const messages = [
1001+ { role: 'user', content: 'Hi' },
1002+ { role: 'assistant', content: 'Hello' },
1003+ ];
1004+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1005+ expect(result.contents[1].role).toBe('model');
1006+ });
1007+
1008+ test('converts system and tool roles to user role', () => {
1009+ const messages = [
1010+ { role: 'system', content: 'System' },
1011+ { role: 'tool', content: 'Tool result', tool_call_id: 'tc1' },
1012+ { role: 'user', content: 'Hi' },
1013+ ];
1014+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1015+ // Both system and tool should become user
1016+ const roles = result.contents.map(c => c.role);
1017+ expect(roles).not.toContain('system');
1018+ expect(roles).not.toContain('tool');
1019+ });
1020+
1021+ test('merges consecutive same-role messages', () => {
1022+ const messages = [
1023+ { role: 'user', content: 'A' },
1024+ { role: 'user', content: 'B' },
1025+ { role: 'assistant', content: 'Reply' },
1026+ ];
1027+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1028+ expect(result.contents.filter(c => c.role === 'user')).toHaveLength(1);
1029+ });
1030+
1031+ test('converts image_url to inlineData', () => {
1032+ const messages = [
1033+ { role: 'user', content: [
1034+ { type: 'text', text: 'Look' },
1035+ { type: 'image_url', image_url: { url: 'data:image/jpeg;base64,/9j/abc' } },
1036+ ] },
1037+ ];
1038+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1039+ const parts = result.contents[0].parts;
1040+ const inlineData = parts.find(p => p.inlineData);
1041+ expect(inlineData).toBeDefined();
1042+ expect(inlineData.inlineData.mimeType).toBe('image/jpeg');
1043+ expect(inlineData.inlineData.data).toBe('/9j/abc');
1044+ });
1045+
1046+ test('converts tool_calls to functionCall parts', () => {
1047+ const messages = [
1048+ { role: 'user', content: 'search cats' },
1049+ { role: 'assistant', tool_calls: [
1050+ { id: 'tc1', function: { name: 'search', arguments: '{"q":"cats"}' } },
1051+ ] },
1052+ ];
1053+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1054+ const modelParts = result.contents.find(c => c.role === 'model')?.parts;
1055+ const funcCall = modelParts?.find(p => p.functionCall);
1056+ expect(funcCall).toBeDefined();
1057+ expect(funcCall.functionCall.name).toBe('search');
1058+ });
1059+
1060+ test('converts tool_call_id to functionResponse parts', () => {
1061+ const messages = [
1062+ { role: 'user', content: 'search' },
1063+ { role: 'assistant', tool_calls: [
1064+ { id: 'tc1', function: { name: 'search', arguments: '{}' } },
1065+ ] },
1066+ { role: 'tool', content: 'Results here', tool_call_id: 'tc1' },
1067+ ];
1068+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1069+ const userParts = result.contents
1070+ .filter(c => c.role === 'user')
1071+ .flatMap(c => c.parts);
1072+ const funcResp = userParts.find(p => p.functionResponse);
1073+ expect(funcResp).toBeDefined();
1074+ expect(funcResp.functionResponse.name).toBe('search');
1075+ });
1076+
1077+ test('prepends example names when useSysPrompt is true', () => {
1078+ const messages = [
1079+ { role: 'system', name: 'example_assistant', content: 'Greetings' },
1080+ { role: 'user', content: 'Hi' },
1081+ ];
1082+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', true, names);
1083+ expect(result.system_instruction.parts[0].text).toBe('Bot: Greetings');
1084+ });
1085+
1086+ test('does not extract system if useSysPrompt is false', () => {
1087+ const messages = [
1088+ { role: 'system', content: 'System' },
1089+ { role: 'user', content: 'Hi' },
1090+ ];
1091+ const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
1092+ expect(result.system_instruction.parts).toHaveLength(0);
1093+ // System message should be in contents as user
1094+ expect(result.contents[0].role).toBe('user');
1095+ });
1096+});
1097+
1098+
1099+describe('convertMistralMessages', () => {
1100+ const names = makeNames('Bot', 'User');
1101+
1102+ test('returns empty array for non-array input', () => {
1103+ expect(mod.convertMistralMessages(null, names)).toEqual([]);
1104+ });
1105+
1106+ test('prepends charName to example_assistant system messages', () => {
1107+ const messages = [
1108+ { role: 'system', name: 'example_assistant', content: 'Greetings' },
1109+ { role: 'user', content: 'Hi' },
1110+ ];
1111+ const result = mod.convertMistralMessages(messages, names);
1112+ expect(result[0].content).toBe('Bot: Greetings');
1113+ expect(result[0].name).toBeUndefined();
1114+ });
1115+
1116+ test('prepends userName to example_user system messages', () => {
1117+ const messages = [
1118+ { role: 'system', name: 'example_user', content: 'Hello there' },
1119+ { role: 'user', content: 'Hi' },
1120+ ];
1121+ const result = mod.convertMistralMessages(messages, names);
1122+ expect(result[0].content).toBe('User: Hello there');
1123+ });
1124+
1125+ test('prepends name to non-system messages', () => {
1126+ const messages = [
1127+ { role: 'assistant', name: 'NPC', content: 'dialogue' },
1128+ ];
1129+ const result = mod.convertMistralMessages(messages, names);
1130+ expect(result[0].content).toBe('NPC: dialogue');
1131+ expect(result[0].name).toBeUndefined();
1132+ });
1133+
1134+ test('hashes tool call IDs', () => {
1135+ const messages = [
1136+ { role: 'assistant', content: 'calling', tool_calls: [{ id: 'original-id', function: { name: 'f' } }] },
1137+ { role: 'tool', content: 'result', tool_call_id: 'original-id' },
1138+ ];
1139+ const result = mod.convertMistralMessages(messages, names);
1140+ // IDs should be hashed to 9-char hex
1141+ expect(result[0].tool_calls[0].id).toMatch(/^[a-f0-9]{9}$/);
1142+ expect(result[1].tool_call_id).toMatch(/^[a-f0-9]{9}$/);
1143+ // Both should match (same input -> same hash)
1144+ expect(result[0].tool_calls[0].id).toBe(result[1].tool_call_id);
1145+ });
1146+
1147+ test('changes system to user when following assistant', () => {
1148+ const messages = [
1149+ { role: 'user', content: 'Hi' },
1150+ { role: 'assistant', content: 'Hello' },
1151+ { role: 'system', content: 'Narrator text' },
1152+ ];
1153+ const result = mod.convertMistralMessages(messages, names);
1154+ expect(result[2].role).toBe('user');
1155+ });
1156+
1157+ test('merges user message after tool into previous user message', () => {
1158+ const messages = [
1159+ { role: 'user', content: 'search cats' },
1160+ { role: 'assistant', content: 'calling', tool_calls: [{ id: 'tc1', function: { name: 'f' } }] },
1161+ { role: 'tool', content: 'result', tool_call_id: 'tc1' },
1162+ { role: 'user', content: 'thanks' },
1163+ ];
1164+ const result = mod.convertMistralMessages(messages, names);
1165+ // The 'thanks' user message should be merged into the first user message
1166+ expect(result[0].content).toContain('search cats');
1167+ expect(result[0].content).toContain('thanks');
1168+ });
1169+});
1170+
1171+
1172+describe('cachingAtDepthForClaude', () => {
1173+ test('adds cache_control at specified depth', () => {
1174+ const messages = [
1175+ { role: 'user', content: [{ type: 'text', text: 'A' }] },
1176+ { role: 'assistant', content: [{ type: 'text', text: 'B' }] },
1177+ { role: 'user', content: [{ type: 'text', text: 'C' }] },
1178+ { role: 'assistant', content: [{ type: 'text', text: 'D' }] },
1179+ { role: 'user', content: [{ type: 'text', text: 'E' }] },
1180+ ];
1181+ mod.cachingAtDepthForClaude(messages, 0, '300');
1182+ // Depth 0 should be the last non-assistant message (working backwards)
1183+ const cached = messages.filter(m =>
1184+ m.content.some(c => c.cache_control),
1185+ );
1186+ expect(cached.length).toBeGreaterThan(0);
1187+ const cacheControl = cached[0].content[cached[0].content.length - 1].cache_control;
1188+ expect(cacheControl).toEqual({ type: 'ephemeral', ttl: '300' });
1189+ });
1190+
1191+ test('skips trailing assistant messages (prefill)', () => {
1192+ const messages = [
1193+ { role: 'user', content: [{ type: 'text', text: 'A' }] },
1194+ { role: 'assistant', content: [{ type: 'text', text: 'B' }] },
1195+ { role: 'assistant', content: [{ type: 'text', text: 'Prefill' }] },
1196+ ];
1197+ mod.cachingAtDepthForClaude(messages, 0, '300');
1198+ // The trailing assistant prefill should not get cache_control
1199+ const lastMsg = messages[messages.length - 1];
1200+ expect(lastMsg.content[0].cache_control).toBeUndefined();
1201+ });
1202+
1203+ test('does not modify messages when depth exceeds message count', () => {
1204+ const messages = [
1205+ { role: 'user', content: [{ type: 'text', text: 'A' }] },
1206+ ];
1207+ mod.cachingAtDepthForClaude(messages, 10, '300');
1208+ expect(messages[0].content[0].cache_control).toBeUndefined();
1209+ });
1210+});
1211+
1212+
1213+describe('cachingAtDepthForOpenRouterClaude', () => {
1214+ test('adds cache_control to string content by wrapping in array', () => {
1215+ const messages = [
1216+ { role: 'user', content: 'A' },
1217+ { role: 'assistant', content: 'B' },
1218+ { role: 'user', content: 'C' },
1219+ ];
1220+ mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
1221+ // Find which message got cached
1222+ const cached = messages.find(m =>
1223+ Array.isArray(m.content) && m.content.some(c => c.cache_control),
1224+ );
1225+ expect(cached).toBeDefined();
1226+ expect(cached.content[0].type).toBe('text');
1227+ expect(cached.content[0].cache_control).toEqual({ type: 'ephemeral', ttl: '300' });
1228+ });
1229+
1230+ test('adds cache_control to array content on last part', () => {
1231+ const messages = [
1232+ { role: 'user', content: [{ type: 'text', text: 'A' }, { type: 'text', text: 'B' }] },
1233+ { role: 'assistant', content: [{ type: 'text', text: 'Reply' }] },
1234+ { role: 'user', content: [{ type: 'text', text: 'C' }] },
1235+ ];
1236+ mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
1237+ const cached = messages.find(m =>
1238+ m.content.some?.(c => c.cache_control),
1239+ );
1240+ expect(cached).toBeDefined();
1241+ });
1242+
1243+ test('skips system messages for depth counting', () => {
1244+ const messages = [
1245+ { role: 'system', content: 'System prompt' },
1246+ { role: 'user', content: 'A' },
1247+ { role: 'assistant', content: 'B' },
1248+ { role: 'user', content: 'C' },
1249+ ];
1250+ mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
1251+ // System message should not get cache_control
1252+ expect(messages[0].content).toBe('System prompt');
1253+ });
1254+
1255+ test('skips trailing assistant prefill', () => {
1256+ const messages = [
1257+ { role: 'user', content: 'A' },
1258+ { role: 'assistant', content: 'Prefill' },
1259+ ];
1260+ mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
1261+ expect(typeof messages[1].content).toBe('string');
1262+ });
1263+});