Tony Gies
760263b78a
* 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>
1264 lines
50 KiB
JavaScript
1264 lines
50 KiB
JavaScript
import { describe, test, expect, jest, beforeAll } from '@jest/globals';
|
|
|
|
jest.unstable_mockModule('../src/util.js', () => ({
|
|
getConfigValue: jest.fn((_key, defaultValue) => defaultValue),
|
|
tryParse: (str) => { try { return JSON.parse(str); } catch { return undefined; } },
|
|
}));
|
|
|
|
/** @type {import('../src/prompt-converters.js')} */
|
|
let mod;
|
|
|
|
beforeAll(async () => {
|
|
mod = await import('../src/prompt-converters.js');
|
|
});
|
|
|
|
function makeNames(charName = '', userName = '', groupNames = []) {
|
|
return {
|
|
charName,
|
|
userName,
|
|
groupNames,
|
|
startsWithGroupName(message) {
|
|
return this.groupNames.some(name => message.startsWith(`${name}: `));
|
|
},
|
|
};
|
|
}
|
|
|
|
|
|
describe('addAssistantPrefix', () => {
|
|
test('returns empty array unchanged', () => {
|
|
expect(mod.addAssistantPrefix([], [], 'prefix')).toEqual([]);
|
|
});
|
|
|
|
test('sets property on last message when it is assistant and no tools', () => {
|
|
const prompt = [
|
|
{ role: 'user', content: 'hi' },
|
|
{ role: 'assistant', content: 'hello' },
|
|
];
|
|
mod.addAssistantPrefix(prompt, [], 'prefix');
|
|
expect(prompt[1].prefix).toBe(true);
|
|
});
|
|
|
|
test('does not set property when tools are present', () => {
|
|
const prompt = [
|
|
{ role: 'user', content: 'hi' },
|
|
{ role: 'assistant', content: 'hello' },
|
|
];
|
|
mod.addAssistantPrefix(prompt, [{ type: 'function' }], 'prefix');
|
|
expect(prompt[1].prefix).toBeUndefined();
|
|
});
|
|
|
|
test('does not set property when last message is not assistant', () => {
|
|
const prompt = [
|
|
{ role: 'assistant', content: 'hello' },
|
|
{ role: 'user', content: 'hi' },
|
|
];
|
|
mod.addAssistantPrefix(prompt, [], 'prefix');
|
|
expect(prompt[0].prefix).toBeUndefined();
|
|
expect(prompt[1].prefix).toBeUndefined();
|
|
});
|
|
|
|
test('does not set property when a tool role message exists in prompt', () => {
|
|
const prompt = [
|
|
{ role: 'user', content: 'hi' },
|
|
{ role: 'tool', content: 'result' },
|
|
{ role: 'assistant', content: 'hello' },
|
|
];
|
|
mod.addAssistantPrefix(prompt, [], 'prefix');
|
|
expect(prompt[2].prefix).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertTextCompletionPrompt', () => {
|
|
test('passes through string input unchanged', () => {
|
|
expect(mod.convertTextCompletionPrompt('raw prompt')).toBe('raw prompt');
|
|
});
|
|
|
|
test('converts basic message array to text format', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'You are helpful.' },
|
|
{ role: 'user', content: 'Hello' },
|
|
{ role: 'assistant', content: 'Hi there' },
|
|
];
|
|
const result = mod.convertTextCompletionPrompt(messages);
|
|
expect(result).toBe(
|
|
'System: You are helpful.\nuser: Hello\nassistant: Hi there\nassistant:',
|
|
);
|
|
});
|
|
|
|
test('uses name instead of role for named system messages', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'Narrator', content: 'Once upon a time' },
|
|
];
|
|
const result = mod.convertTextCompletionPrompt(messages);
|
|
expect(result).toBe('Narrator: Once upon a time\nassistant:');
|
|
});
|
|
|
|
test('handles empty array', () => {
|
|
expect(mod.convertTextCompletionPrompt([])).toBe('\nassistant:');
|
|
});
|
|
});
|
|
|
|
|
|
describe('calculateClaudeBudgetTokens', () => {
|
|
describe('adaptive model (Opus 4.6+)', () => {
|
|
test('auto returns null', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(8192, 'auto', true, true)).toBeNull();
|
|
});
|
|
|
|
test('min returns "low"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'min', true, true)).toBe('low'));
|
|
test('low returns "low"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'low', true, true)).toBe('low'));
|
|
test('medium returns "medium"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'medium', true, true)).toBe('medium'));
|
|
test('high returns "high"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'high', true, true)).toBe('high'));
|
|
test('max returns "max"', () => expect(mod.calculateClaudeBudgetTokens(8192, 'max', true, true)).toBe('max'));
|
|
});
|
|
|
|
describe('traditional model', () => {
|
|
test('auto returns null', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(8192, 'auto', true, false)).toBeNull();
|
|
});
|
|
|
|
test('min returns 1024 regardless of maxTokens', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(100, 'min', true, false)).toBe(1024);
|
|
expect(mod.calculateClaudeBudgetTokens(100000, 'min', true, false)).toBe(1024);
|
|
});
|
|
|
|
test('low is 10% of maxTokens, floored to 1024', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(50000, 'low', true, false)).toBe(5000);
|
|
// 10% of 5000 = 500, but floor is 1024
|
|
expect(mod.calculateClaudeBudgetTokens(5000, 'low', true, false)).toBe(1024);
|
|
});
|
|
|
|
test('medium is 25% of maxTokens', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(40000, 'medium', true, false)).toBe(10000);
|
|
});
|
|
|
|
test('high is 50% of maxTokens', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(40000, 'high', true, false)).toBe(20000);
|
|
});
|
|
|
|
test('max is 95% of maxTokens', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(40000, 'max', true, false)).toBe(38000);
|
|
});
|
|
|
|
test('non-streaming caps at 21333', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(100000, 'max', false, false)).toBe(21333);
|
|
});
|
|
|
|
test('streaming does not cap at 21333', () => {
|
|
expect(mod.calculateClaudeBudgetTokens(100000, 'max', true, false)).toBe(95000);
|
|
});
|
|
});
|
|
});
|
|
|
|
|
|
describe('calculateGoogleBudgetTokens', () => {
|
|
test('returns null for unrecognized model', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(8192, 'medium', 'gpt-4')).toBeNull();
|
|
});
|
|
|
|
describe('gemini-3 flash', () => {
|
|
test('auto returns null', () => expect(mod.calculateGoogleBudgetTokens(8192, 'auto', 'gemini-3.5-flash')).toBeNull());
|
|
test('min returns minimal', () => expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-3.5-flash')).toBe('minimal'));
|
|
test('low returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'low', 'gemini-3.5-flash')).toBe('low'));
|
|
test('medium returns medium', () => expect(mod.calculateGoogleBudgetTokens(8192, 'medium', 'gemini-3.5-flash')).toBe('medium'));
|
|
test('high returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'high', 'gemini-3.5-flash')).toBe('high'));
|
|
test('max returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'max', 'gemini-3.5-flash')).toBe('high'));
|
|
});
|
|
|
|
describe('gemini-3 pro', () => {
|
|
test('auto returns null', () => expect(mod.calculateGoogleBudgetTokens(8192, 'auto', 'gemini-3.0-pro')).toBeNull());
|
|
test('min returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-3.0-pro')).toBe('low'));
|
|
test('low returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'low', 'gemini-3.0-pro')).toBe('low'));
|
|
test('medium returns low', () => expect(mod.calculateGoogleBudgetTokens(8192, 'medium', 'gemini-3.0-pro')).toBe('low'));
|
|
test('high returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'high', 'gemini-3.0-pro')).toBe('high'));
|
|
test('max returns high', () => expect(mod.calculateGoogleBudgetTokens(8192, 'max', 'gemini-3.0-pro')).toBe('high'));
|
|
});
|
|
|
|
describe('flash (non-gemini-3)', () => {
|
|
test('auto returns -1', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(8192, 'auto', 'gemini-2.0-flash')).toBe(-1);
|
|
});
|
|
|
|
test('min returns 0', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-2.0-flash')).toBe(0);
|
|
});
|
|
|
|
test('caps at 24576', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(500000, 'max', 'gemini-2.0-flash')).toBe(24576);
|
|
});
|
|
});
|
|
|
|
describe('flash-lite', () => {
|
|
test('min returns 0', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-2.0-flash-lite')).toBe(0);
|
|
});
|
|
|
|
test('floors at 512', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(1000, 'low', 'gemini-2.0-flash-lite')).toBe(512);
|
|
});
|
|
});
|
|
|
|
describe('pro (non-gemini-3)', () => {
|
|
test('min returns 128', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(8192, 'min', 'gemini-2.5-pro')).toBe(128);
|
|
});
|
|
|
|
test('floors at 128', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(500, 'low', 'gemini-2.5-pro')).toBe(128);
|
|
});
|
|
|
|
test('caps at 32768', () => {
|
|
expect(mod.calculateGoogleBudgetTokens(500000, 'max', 'gemini-2.5-pro')).toBe(32768);
|
|
});
|
|
});
|
|
|
|
describe('model matching priority', () => {
|
|
// flash-lite must match before flash
|
|
test('flash-lite matches before flash', () => {
|
|
// flash-lite min = 0, flash min = 0 too, so use a differentiating case
|
|
// flash-lite low floors at 512, flash low does not
|
|
expect(mod.calculateGoogleBudgetTokens(1000, 'low', 'gemini-2.0-flash-lite')).toBe(512);
|
|
expect(mod.calculateGoogleBudgetTokens(1000, 'low', 'gemini-2.0-flash')).toBe(100);
|
|
});
|
|
});
|
|
});
|
|
|
|
|
|
describe('addReasoningContentToToolCalls', () => {
|
|
test('adds reasoning_content to messages with tool_calls', () => {
|
|
const messages = [
|
|
{ role: 'assistant', tool_calls: [{ id: '1', function: { name: 'f' } }] },
|
|
];
|
|
mod.addReasoningContentToToolCalls(messages);
|
|
expect(messages[0].reasoning_content).toBe('');
|
|
});
|
|
|
|
test('does not overwrite existing reasoning_content', () => {
|
|
const messages = [
|
|
{ role: 'assistant', tool_calls: [{ id: '1' }], reasoning_content: 'existing' },
|
|
];
|
|
mod.addReasoningContentToToolCalls(messages);
|
|
expect(messages[0].reasoning_content).toBe('existing');
|
|
});
|
|
|
|
test('skips messages without tool_calls', () => {
|
|
const messages = [{ role: 'user', content: 'hi' }];
|
|
mod.addReasoningContentToToolCalls(messages);
|
|
expect(messages[0].reasoning_content).toBeUndefined();
|
|
});
|
|
|
|
test('handles non-array input gracefully', () => {
|
|
expect(() => mod.addReasoningContentToToolCalls(null)).not.toThrow();
|
|
expect(() => mod.addReasoningContentToToolCalls('string')).not.toThrow();
|
|
});
|
|
});
|
|
|
|
|
|
describe('embedOpenRouterMedia', () => {
|
|
test('converts audio data URLs to input_audio format', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'audio_url',
|
|
audio_url: { url: 'data:audio/wav;base64,AAAA' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages);
|
|
expect(messages[0].content[0]).toEqual({
|
|
type: 'input_audio',
|
|
input_audio: { format: 'wav', data: 'AAAA' },
|
|
});
|
|
});
|
|
|
|
test('defaults to mp3 for unknown audio mime types', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'audio_url',
|
|
audio_url: { url: 'data:audio/ogg;base64,BBBB' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages);
|
|
expect(messages[0].content[0].input_audio.format).toBe('mp3');
|
|
});
|
|
|
|
test('skips non-data-URL audio', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'audio_url',
|
|
audio_url: { url: 'https://example.com/audio.mp3' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages);
|
|
expect(messages[0].content[0].type).toBe('audio_url');
|
|
});
|
|
|
|
test('keeps video_url type for video data URLs', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'video_url',
|
|
video_url: { url: 'data:video/mp4;base64,CCCC' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages);
|
|
expect(messages[0].content[0].type).toBe('video_url');
|
|
});
|
|
|
|
test('skips non-data-URL video', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'video_url',
|
|
video_url: { url: 'https://example.com/video.mp4' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages);
|
|
expect(messages[0].content[0].type).toBe('video_url');
|
|
});
|
|
|
|
test('respects audio=false option', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'audio_url',
|
|
audio_url: { url: 'data:audio/wav;base64,AAAA' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages, { audio: false, video: true });
|
|
expect(messages[0].content[0].type).toBe('audio_url');
|
|
});
|
|
|
|
test('respects video=false option', () => {
|
|
const messages = [{
|
|
role: 'user',
|
|
content: [{
|
|
type: 'video_url',
|
|
video_url: { url: 'data:video/mp4;base64,CCCC' },
|
|
}],
|
|
}];
|
|
mod.embedOpenRouterMedia(messages, { audio: true, video: false });
|
|
expect(messages[0].content[0].type).toBe('video_url');
|
|
});
|
|
|
|
test('handles non-array input gracefully', () => {
|
|
expect(() => mod.embedOpenRouterMedia(null)).not.toThrow();
|
|
expect(() => mod.embedOpenRouterMedia('string')).not.toThrow();
|
|
});
|
|
|
|
test('skips messages with string content', () => {
|
|
const messages = [{ role: 'user', content: 'just text' }];
|
|
mod.embedOpenRouterMedia(messages);
|
|
expect(messages[0].content).toBe('just text');
|
|
});
|
|
});
|
|
|
|
|
|
describe('cachingSystemPromptForOpenRouter', () => {
|
|
test('adds cache_control to string system message', () => {
|
|
const messages = [{ role: 'system', content: 'You are helpful.' }];
|
|
mod.cachingSystemPromptForOpenRouter(messages);
|
|
expect(messages[0].content).toEqual([
|
|
{ type: 'text', text: 'You are helpful.', cache_control: { type: 'ephemeral' } },
|
|
]);
|
|
});
|
|
|
|
test('adds cache_control with TTL', () => {
|
|
const messages = [{ role: 'system', content: 'System prompt' }];
|
|
mod.cachingSystemPromptForOpenRouter(messages, '300');
|
|
expect(messages[0].content[0].cache_control).toEqual({ type: 'ephemeral', ttl: '300' });
|
|
});
|
|
|
|
test('adds cache_control to last text part of array content', () => {
|
|
const messages = [{
|
|
role: 'system',
|
|
content: [
|
|
{ type: 'text', text: 'first' },
|
|
{ type: 'text', text: 'second' },
|
|
],
|
|
}];
|
|
mod.cachingSystemPromptForOpenRouter(messages);
|
|
expect(messages[0].content[0].cache_control).toBeUndefined();
|
|
expect(messages[0].content[1].cache_control).toEqual({ type: 'ephemeral' });
|
|
});
|
|
|
|
test('skips if system message already has cache_control', () => {
|
|
const messages = [{ role: 'system', content: 'prompt', cache_control: { type: 'ephemeral' } }];
|
|
mod.cachingSystemPromptForOpenRouter(messages);
|
|
// content should remain a string, not converted
|
|
expect(messages[0].content).toBe('prompt');
|
|
});
|
|
|
|
test('skips if array content already has cache_control', () => {
|
|
const messages = [{
|
|
role: 'system',
|
|
content: [{ type: 'text', text: 'cached', cache_control: { type: 'ephemeral' } }],
|
|
}];
|
|
mod.cachingSystemPromptForOpenRouter(messages);
|
|
// Should not add another cache_control
|
|
expect(messages[0].content).toHaveLength(1);
|
|
});
|
|
|
|
test('does nothing with empty array', () => {
|
|
expect(() => mod.cachingSystemPromptForOpenRouter([])).not.toThrow();
|
|
});
|
|
|
|
test('does nothing without system message', () => {
|
|
const messages = [{ role: 'user', content: 'hi' }];
|
|
mod.cachingSystemPromptForOpenRouter(messages);
|
|
expect(messages[0].content).toBe('hi');
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertAI21Messages', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('returns empty array for non-array input', () => {
|
|
expect(mod.convertAI21Messages(null, names)).toEqual([]);
|
|
expect(mod.convertAI21Messages('string', names)).toEqual([]);
|
|
});
|
|
|
|
test('extracts leading system messages into merged system prompt', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'You are a bot.' },
|
|
{ role: 'system', content: 'Be helpful.' },
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertAI21Messages(messages, names);
|
|
expect(result[0]).toEqual({ role: 'system', content: 'You are a bot.\n\nBe helpful.' });
|
|
expect(result[1]).toEqual({ role: 'user', content: 'Hello' });
|
|
});
|
|
|
|
test('prepends character name to example_assistant system messages', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_assistant', content: 'I greet you.' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertAI21Messages(messages, names);
|
|
expect(result[0].content).toContain('Bot: I greet you.');
|
|
});
|
|
|
|
test('does not double-prepend if name already present', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_assistant', content: 'Bot: I greet you.' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertAI21Messages(messages, names);
|
|
expect(result[0].content).not.toContain('Bot: Bot:');
|
|
});
|
|
|
|
test('merges consecutive same-role messages', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'First' },
|
|
{ role: 'user', content: 'Second' },
|
|
{ role: 'assistant', content: 'Reply' },
|
|
];
|
|
const result = mod.convertAI21Messages(messages, names);
|
|
expect(result).toHaveLength(2);
|
|
expect(result[0].content).toBe('First\n\nSecond');
|
|
});
|
|
|
|
test('prepends name to non-system messages and deletes name property', () => {
|
|
const messages = [
|
|
{ role: 'user', name: 'Alice', content: 'Hello' },
|
|
];
|
|
const result = mod.convertAI21Messages(messages, names);
|
|
expect(result[0].content).toBe('Alice: Hello');
|
|
expect(result[0].name).toBeUndefined();
|
|
});
|
|
|
|
test('inserts placeholder when all messages are system', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'Setup' },
|
|
];
|
|
const result = mod.convertAI21Messages(messages, names);
|
|
// After extracting the system message, array is empty, so placeholder is inserted
|
|
expect(result).toHaveLength(2);
|
|
expect(result[0]).toEqual({ role: 'system', content: 'Setup' });
|
|
expect(result[1].role).toBe('user');
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertCohereMessages', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('inserts placeholder for empty messages', () => {
|
|
const messages = [];
|
|
const result = mod.convertCohereMessages(messages, names);
|
|
expect(result.chatHistory).toHaveLength(1);
|
|
expect(result.chatHistory[0].role).toBe('user');
|
|
});
|
|
|
|
test('prepends character name to example_assistant system messages', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_assistant', content: 'Greetings' },
|
|
];
|
|
const result = mod.convertCohereMessages(messages, names);
|
|
expect(result.chatHistory[0].content).toBe('Bot: Greetings');
|
|
});
|
|
|
|
test('prepends user name to example_user system messages', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_user', content: 'Hello there' },
|
|
];
|
|
const result = mod.convertCohereMessages(messages, names);
|
|
expect(result.chatHistory[0].content).toBe('User: Hello there');
|
|
});
|
|
|
|
test('prepends name to non-system messages', () => {
|
|
const messages = [
|
|
{ role: 'assistant', name: 'NPC', content: 'I am an NPC' },
|
|
];
|
|
const result = mod.convertCohereMessages(messages, names);
|
|
expect(result.chatHistory[0].content).toBe('NPC: I am an NPC');
|
|
expect(result.chatHistory[0].name).toBeUndefined();
|
|
});
|
|
|
|
test('handles tool_calls by extracting function names', () => {
|
|
const messages = [
|
|
{ role: 'assistant', tool_calls: [{ function: { name: 'search' } }, { function: { name: 'fetch' } }] },
|
|
];
|
|
const result = mod.convertCohereMessages(messages, names);
|
|
expect(result.chatHistory[0].content).toContain('search, fetch');
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertXAIMessages', () => {
|
|
const names = makeNames('Char', 'Player');
|
|
|
|
test('returns empty array for non-array input', () => {
|
|
expect(mod.convertXAIMessages(null, names)).toEqual([]);
|
|
});
|
|
|
|
test('prepends char name to assistant messages', () => {
|
|
const messages = [
|
|
{ role: 'assistant', name: 'Char', content: 'Hello' },
|
|
];
|
|
const result = mod.convertXAIMessages(messages, names);
|
|
expect(result[0].content).toBe('Char: Hello');
|
|
expect(result[0].name).toBeUndefined();
|
|
});
|
|
|
|
test('skips user role messages entirely', () => {
|
|
const messages = [
|
|
{ role: 'user', name: 'Someone', content: 'Hello' },
|
|
];
|
|
const result = mod.convertXAIMessages(messages, names);
|
|
expect(result[0].content).toBe('Hello');
|
|
expect(result[0].name).toBe('Someone');
|
|
});
|
|
|
|
test('handles group names - does not double prefix', () => {
|
|
const groupNames = makeNames('Char', 'Player', ['Alice', 'Bob']);
|
|
const messages = [
|
|
{ role: 'assistant', name: 'SomeNPC', content: 'Alice: speaking as Alice' },
|
|
];
|
|
const result = mod.convertXAIMessages(messages, groupNames);
|
|
// Starts with group name, so charName prefix should not be added
|
|
expect(result[0].content).toBe('Alice: speaking as Alice');
|
|
});
|
|
});
|
|
|
|
|
|
describe('mergeMessages', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('squashes consecutive same-role messages', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'user', content: 'B' },
|
|
{ role: 'assistant', content: 'C' },
|
|
];
|
|
const result = mod.mergeMessages(messages, names);
|
|
expect(result).toHaveLength(2);
|
|
expect(result[0].content).toBe('A\n\nB');
|
|
});
|
|
|
|
test('inserts placeholder for empty messages', () => {
|
|
const result = mod.mergeMessages([], names);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].role).toBe('user');
|
|
});
|
|
|
|
test('removes name property and prepends to content for non-system', () => {
|
|
const messages = [
|
|
{ role: 'assistant', name: 'NPC', content: 'dialogue' },
|
|
];
|
|
const result = mod.mergeMessages(messages, names);
|
|
expect(result[0].content).toBe('NPC: dialogue');
|
|
expect(result[0].name).toBeUndefined();
|
|
});
|
|
|
|
test('strict mode forces mid-prompt system to user', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'Setup' },
|
|
{ role: 'system', content: 'More setup' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.mergeMessages(messages, names, { strict: true });
|
|
// First system stays, second should become user and merge
|
|
expect(result[0].role).toBe('system');
|
|
expect(result.filter(m => m.role === 'system')).toHaveLength(1);
|
|
});
|
|
|
|
test('single mode forces all roles to user', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'Setup' },
|
|
{ role: 'user', content: 'Hello' },
|
|
{ role: 'assistant', content: 'Response' },
|
|
];
|
|
const result = mod.mergeMessages(messages, names, { single: true });
|
|
expect(result.every(m => m.role === 'user')).toBe(true);
|
|
});
|
|
|
|
test('single mode prepends charName to assistant, userName to user', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hello' },
|
|
{ role: 'assistant', content: 'Hi back' },
|
|
];
|
|
const result = mod.mergeMessages(messages, names, { single: true });
|
|
// Both become user and get merged
|
|
expect(result[0].content).toContain('User: Hello');
|
|
expect(result[0].content).toContain('Bot: Hi back');
|
|
});
|
|
|
|
test('tools=false removes tool_calls and tool_call_id', () => {
|
|
const messages = [
|
|
{ role: 'assistant', content: 'calling', tool_calls: [{ id: '1' }] },
|
|
{ role: 'tool', content: 'result', tool_call_id: '1' },
|
|
];
|
|
const result = mod.mergeMessages(messages, names, { tools: false });
|
|
expect(result[0].tool_calls).toBeUndefined();
|
|
// tool role should be converted to user
|
|
const toolMsg = result.find(m => m.content === 'result' || m.content?.includes?.('result'));
|
|
expect(toolMsg).toBeDefined();
|
|
});
|
|
|
|
test('flattens array content and preserves image URLs via tokens', () => {
|
|
const imageContent = { type: 'image_url', image_url: { url: 'data:image/png;base64,abc' } };
|
|
const messages = [
|
|
{ role: 'user', content: [{ type: 'text', text: 'Look at this' }, imageContent] },
|
|
];
|
|
const result = mod.mergeMessages(messages, names);
|
|
// Content should be reconstituted with image preserved
|
|
expect(Array.isArray(result[0].content)).toBe(true);
|
|
const types = result[0].content.map(c => c.type);
|
|
expect(types).toContain('text');
|
|
expect(types).toContain('image_url');
|
|
});
|
|
});
|
|
|
|
|
|
describe('postProcessPrompt', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('NONE type returns messages unchanged', () => {
|
|
const messages = [{ role: 'user', content: 'hi' }];
|
|
expect(mod.postProcessPrompt(messages, '', names)).toBe(messages);
|
|
});
|
|
|
|
test('MERGE type merges consecutive same-role messages', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'user', content: 'B' },
|
|
];
|
|
const result = mod.postProcessPrompt(messages, 'merge', names);
|
|
expect(result).toHaveLength(1);
|
|
expect(result[0].content).toBe('A\n\nB');
|
|
});
|
|
|
|
test('deprecated CLAUDE type works same as MERGE', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'user', content: 'B' },
|
|
];
|
|
const result = mod.postProcessPrompt(messages, 'claude', names);
|
|
expect(result).toHaveLength(1);
|
|
});
|
|
});
|
|
|
|
|
|
describe('addOpenRouterSignatures', () => {
|
|
test('handles non-array input gracefully', () => {
|
|
expect(() => mod.addOpenRouterSignatures(null, 'model')).not.toThrow();
|
|
});
|
|
|
|
test('detects google model format', () => {
|
|
const messages = [{ role: 'assistant', content: 'hi', signature: 'sig123' }];
|
|
mod.addOpenRouterSignatures(messages, 'google/gemini-2.5-pro');
|
|
expect(messages[0].reasoning_details).toBeDefined();
|
|
expect(messages[0].reasoning_details[0].format).toBe('google-gemini-v1');
|
|
});
|
|
|
|
test('detects anthropic model format', () => {
|
|
const messages = [{ role: 'assistant', content: 'hi', signature: 'sig123' }];
|
|
mod.addOpenRouterSignatures(messages, 'anthropic/claude-sonnet-4');
|
|
expect(messages[0].reasoning_details).toBeDefined();
|
|
expect(messages[0].reasoning_details[0].format).toBe('anthropic-claude-v1');
|
|
});
|
|
|
|
test('removes signature property from messages', () => {
|
|
const messages = [{ role: 'assistant', content: 'hi', signature: 'sig123' }];
|
|
mod.addOpenRouterSignatures(messages, 'anthropic/claude-sonnet-4');
|
|
expect(messages[0].signature).toBeUndefined();
|
|
});
|
|
|
|
test('removes signature property from tool_calls', () => {
|
|
const messages = [{
|
|
role: 'assistant',
|
|
content: '',
|
|
tool_calls: [{ id: 'tc1', function: { name: 'f' }, signature: 'toolsig' }],
|
|
}];
|
|
mod.addOpenRouterSignatures(messages, 'anthropic/claude-sonnet-4');
|
|
expect(messages[0].tool_calls[0].signature).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
|
|
describe('getPromptNames', () => {
|
|
test('extracts names from request body', () => {
|
|
const request = { body: { char_name: 'Bot', user_name: 'User', group_names: ['Alice', 'Bob'] } };
|
|
const names = mod.getPromptNames(request);
|
|
expect(names.charName).toBe('Bot');
|
|
expect(names.userName).toBe('User');
|
|
expect(names.groupNames).toEqual(['Alice', 'Bob']);
|
|
});
|
|
|
|
test('defaults to empty strings and array when missing', () => {
|
|
const request = { body: {} };
|
|
const names = mod.getPromptNames(request);
|
|
expect(names.charName).toBe('');
|
|
expect(names.userName).toBe('');
|
|
expect(names.groupNames).toEqual([]);
|
|
});
|
|
|
|
test('startsWithGroupName checks message prefix', () => {
|
|
const request = { body: { char_name: '', user_name: '', group_names: ['Alice', 'Bob'] } };
|
|
const names = mod.getPromptNames(request);
|
|
expect(names.startsWithGroupName('Alice: hello')).toBe(true);
|
|
expect(names.startsWithGroupName('Charlie: hello')).toBe(false);
|
|
});
|
|
|
|
test('coerces non-string group_names to strings', () => {
|
|
const request = { body: { group_names: [123, null] } };
|
|
const names = mod.getPromptNames(request);
|
|
expect(names.groupNames).toEqual(['123', 'null']);
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertClaudePrompt', () => {
|
|
test('returns empty string for empty messages', () => {
|
|
const result = mod.convertClaudePrompt([], false, '', false, false, '', false);
|
|
expect(result).toBe('');
|
|
});
|
|
|
|
test('basic conversion with Human/Assistant prefixes', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'You are helpful.' },
|
|
{ role: 'user', content: 'Hello' },
|
|
{ role: 'assistant', content: 'Hi there' },
|
|
];
|
|
const result = mod.convertClaudePrompt(messages, false, '', false, false, '', false);
|
|
expect(result).toContain('Hello');
|
|
expect(result).toContain('Hi there');
|
|
expect(result).toContain('\n\nHuman: ');
|
|
expect(result).toContain('\n\nAssistant: ');
|
|
});
|
|
|
|
test('adds assistant postfix when requested', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertClaudePrompt(messages, true, '', false, false, '', false);
|
|
expect(result).toMatch(/\n\nAssistant: $/);
|
|
});
|
|
|
|
test('adds assistant prefill when provided', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertClaudePrompt(messages, true, 'Sure, I', false, false, '', false);
|
|
expect(result).toMatch(/\n\nAssistant: Sure, I$/);
|
|
});
|
|
|
|
test('system prompt mode sets first message role to system', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'System prompt' },
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
mod.convertClaudePrompt(messages, false, '', true, true, '', false);
|
|
// First message should remain system (no prefix)
|
|
expect(messages[0].role).toBe('system');
|
|
});
|
|
|
|
test('exclude prefixes mode sets non-last messages to system', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'First' },
|
|
{ role: 'assistant', content: 'Second' },
|
|
{ role: 'user', content: 'Third' },
|
|
];
|
|
const result = mod.convertClaudePrompt(messages, false, '', false, false, '', true);
|
|
// Non-last messages should have been set to system role (no Human/Assistant prefix)
|
|
// Last message keeps its original role
|
|
expect(result).toContain('Third');
|
|
});
|
|
|
|
test('stringifies tool_calls into content', () => {
|
|
const messages = [
|
|
{ role: 'assistant', content: 'Let me check', tool_calls: [{ id: '1', function: { name: 'search' } }] },
|
|
{ role: 'user', content: 'OK' },
|
|
];
|
|
const result = mod.convertClaudePrompt(messages, false, '', false, false, '', false);
|
|
expect(result).toContain('search');
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertClaudeMessages', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('extracts leading system messages when useSysPrompt is true', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'System instruction' },
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', true, false, names);
|
|
expect(result.systemPrompt).toHaveLength(1);
|
|
expect(result.systemPrompt[0]).toEqual({ type: 'text', text: 'System instruction' });
|
|
expect(result.messages[0].role).toBe('user');
|
|
});
|
|
|
|
test('inserts placeholder when all messages are system and useSysPrompt is true', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'Only system' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', true, false, names);
|
|
expect(result.messages).toHaveLength(1);
|
|
expect(result.messages[0].role).toBe('user');
|
|
});
|
|
|
|
test('converts system messages to user role after extraction', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hi' },
|
|
{ role: 'system', content: 'Mid-prompt system' },
|
|
{ role: 'assistant', content: 'Reply' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
// system messages should become user
|
|
const roles = result.messages.map(m => m.role);
|
|
expect(roles).not.toContain('system');
|
|
});
|
|
|
|
test('merges consecutive same-role messages', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'user', content: 'B' },
|
|
{ role: 'assistant', content: 'C' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
// Two user messages should be merged
|
|
expect(result.messages.filter(m => m.role === 'user')).toHaveLength(1);
|
|
});
|
|
|
|
test('converts string content to array of text parts', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
expect(Array.isArray(result.messages[0].content)).toBe(true);
|
|
expect(result.messages[0].content[0]).toEqual({ type: 'text', text: 'Hello' });
|
|
});
|
|
|
|
test('converts image_url content to Claude base64 format', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [
|
|
{ type: 'text', text: 'Look' },
|
|
{ type: 'image_url', image_url: { url: 'data:image/png;base64,abc123' } },
|
|
] },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
const imagePart = result.messages[0].content.find(c => c.type === 'image');
|
|
expect(imagePart).toBeDefined();
|
|
expect(imagePart.source.type).toBe('base64');
|
|
expect(imagePart.source.media_type).toBe('image/png');
|
|
expect(imagePart.source.data).toBe('abc123');
|
|
});
|
|
|
|
test('moves images from assistant to next user message', () => {
|
|
const messages = [
|
|
{ role: 'assistant', content: [
|
|
{ type: 'text', text: 'Here is an image' },
|
|
{ type: 'image_url', image_url: { url: 'data:image/png;base64,abc' } },
|
|
] },
|
|
{ role: 'user', content: 'Thanks' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
// Assistant message should not have images
|
|
const assistantImages = result.messages
|
|
.filter(m => m.role === 'assistant')
|
|
.flatMap(m => m.content)
|
|
.filter(c => c.type === 'image');
|
|
expect(assistantImages).toHaveLength(0);
|
|
});
|
|
|
|
test('adds prefill as trailing assistant message', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, 'Sure, I will ', false, false, names);
|
|
const last = result.messages[result.messages.length - 1];
|
|
expect(last.role).toBe('assistant');
|
|
// Prefill should be trimmed on the right
|
|
expect(last.content[0].text).toBe('Sure, I will');
|
|
});
|
|
|
|
test('converts tool_calls to tool_use format', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'search for cats' },
|
|
{ role: 'assistant', content: '', tool_calls: [
|
|
{ id: 'tc1', function: { name: 'search', arguments: '{"q":"cats"}' } },
|
|
] },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, true, names);
|
|
const assistantContent = result.messages.find(m => m.role === 'assistant')?.content;
|
|
const toolUse = assistantContent?.find(c => c.type === 'tool_use');
|
|
expect(toolUse).toBeDefined();
|
|
expect(toolUse.name).toBe('search');
|
|
expect(toolUse.input).toEqual({ q: 'cats' });
|
|
});
|
|
|
|
test('converts tool messages to tool_result format', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'search' },
|
|
{ role: 'assistant', content: '', tool_calls: [
|
|
{ id: 'tc1', function: { name: 'search', arguments: '{}' } },
|
|
] },
|
|
{ role: 'tool', content: 'Found results', tool_call_id: 'tc1' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, true, names);
|
|
const userContent = result.messages
|
|
.filter(m => m.role === 'user')
|
|
.flatMap(m => m.content);
|
|
const toolResult = userContent.find(c => c.type === 'tool_result');
|
|
expect(toolResult).toBeDefined();
|
|
expect(toolResult.content).toBe('Found results');
|
|
});
|
|
|
|
test('replaces empty text content with zero-width space', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [{ type: 'text', text: '' }] },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
expect(result.messages[0].content[0].text).toBe('\u200b');
|
|
});
|
|
|
|
test('prepends example_assistant name with charName in system prompt', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_assistant', content: 'Greetings' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', true, false, names);
|
|
expect(result.systemPrompt[0].text).toBe('Bot: Greetings');
|
|
});
|
|
|
|
test('removes name, tool_calls, and tool_call_id properties from output', () => {
|
|
const messages = [
|
|
{ role: 'user', name: 'Alice', content: 'Hello' },
|
|
];
|
|
const result = mod.convertClaudeMessages(messages, '', false, false, names);
|
|
const msg = result.messages[0];
|
|
expect(msg.name).toBeUndefined();
|
|
expect(msg.tool_calls).toBeUndefined();
|
|
expect(msg.tool_call_id).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertGooglePrompt', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('extracts leading system messages into system_instruction', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'Be helpful' },
|
|
{ role: 'system', content: 'Be concise' },
|
|
{ role: 'user', content: 'Hello' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', true, names);
|
|
expect(result.system_instruction.parts).toEqual([
|
|
{ text: 'Be helpful' },
|
|
{ text: 'Be concise' },
|
|
]);
|
|
});
|
|
|
|
test('converts assistant role to model role', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hi' },
|
|
{ role: 'assistant', content: 'Hello' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
expect(result.contents[1].role).toBe('model');
|
|
});
|
|
|
|
test('converts system and tool roles to user role', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'System' },
|
|
{ role: 'tool', content: 'Tool result', tool_call_id: 'tc1' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
// Both system and tool should become user
|
|
const roles = result.contents.map(c => c.role);
|
|
expect(roles).not.toContain('system');
|
|
expect(roles).not.toContain('tool');
|
|
});
|
|
|
|
test('merges consecutive same-role messages', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'user', content: 'B' },
|
|
{ role: 'assistant', content: 'Reply' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
expect(result.contents.filter(c => c.role === 'user')).toHaveLength(1);
|
|
});
|
|
|
|
test('converts image_url to inlineData', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [
|
|
{ type: 'text', text: 'Look' },
|
|
{ type: 'image_url', image_url: { url: 'data:image/jpeg;base64,/9j/abc' } },
|
|
] },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
const parts = result.contents[0].parts;
|
|
const inlineData = parts.find(p => p.inlineData);
|
|
expect(inlineData).toBeDefined();
|
|
expect(inlineData.inlineData.mimeType).toBe('image/jpeg');
|
|
expect(inlineData.inlineData.data).toBe('/9j/abc');
|
|
});
|
|
|
|
test('converts tool_calls to functionCall parts', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'search cats' },
|
|
{ role: 'assistant', tool_calls: [
|
|
{ id: 'tc1', function: { name: 'search', arguments: '{"q":"cats"}' } },
|
|
] },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
const modelParts = result.contents.find(c => c.role === 'model')?.parts;
|
|
const funcCall = modelParts?.find(p => p.functionCall);
|
|
expect(funcCall).toBeDefined();
|
|
expect(funcCall.functionCall.name).toBe('search');
|
|
});
|
|
|
|
test('converts tool_call_id to functionResponse parts', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'search' },
|
|
{ role: 'assistant', tool_calls: [
|
|
{ id: 'tc1', function: { name: 'search', arguments: '{}' } },
|
|
] },
|
|
{ role: 'tool', content: 'Results here', tool_call_id: 'tc1' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
const userParts = result.contents
|
|
.filter(c => c.role === 'user')
|
|
.flatMap(c => c.parts);
|
|
const funcResp = userParts.find(p => p.functionResponse);
|
|
expect(funcResp).toBeDefined();
|
|
expect(funcResp.functionResponse.name).toBe('search');
|
|
});
|
|
|
|
test('prepends example names when useSysPrompt is true', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_assistant', content: 'Greetings' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', true, names);
|
|
expect(result.system_instruction.parts[0].text).toBe('Bot: Greetings');
|
|
});
|
|
|
|
test('does not extract system if useSysPrompt is false', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'System' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertGooglePrompt(messages, 'gemini-2.0-flash', false, names);
|
|
expect(result.system_instruction.parts).toHaveLength(0);
|
|
// System message should be in contents as user
|
|
expect(result.contents[0].role).toBe('user');
|
|
});
|
|
});
|
|
|
|
|
|
describe('convertMistralMessages', () => {
|
|
const names = makeNames('Bot', 'User');
|
|
|
|
test('returns empty array for non-array input', () => {
|
|
expect(mod.convertMistralMessages(null, names)).toEqual([]);
|
|
});
|
|
|
|
test('prepends charName to example_assistant system messages', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_assistant', content: 'Greetings' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertMistralMessages(messages, names);
|
|
expect(result[0].content).toBe('Bot: Greetings');
|
|
expect(result[0].name).toBeUndefined();
|
|
});
|
|
|
|
test('prepends userName to example_user system messages', () => {
|
|
const messages = [
|
|
{ role: 'system', name: 'example_user', content: 'Hello there' },
|
|
{ role: 'user', content: 'Hi' },
|
|
];
|
|
const result = mod.convertMistralMessages(messages, names);
|
|
expect(result[0].content).toBe('User: Hello there');
|
|
});
|
|
|
|
test('prepends name to non-system messages', () => {
|
|
const messages = [
|
|
{ role: 'assistant', name: 'NPC', content: 'dialogue' },
|
|
];
|
|
const result = mod.convertMistralMessages(messages, names);
|
|
expect(result[0].content).toBe('NPC: dialogue');
|
|
expect(result[0].name).toBeUndefined();
|
|
});
|
|
|
|
test('hashes tool call IDs', () => {
|
|
const messages = [
|
|
{ role: 'assistant', content: 'calling', tool_calls: [{ id: 'original-id', function: { name: 'f' } }] },
|
|
{ role: 'tool', content: 'result', tool_call_id: 'original-id' },
|
|
];
|
|
const result = mod.convertMistralMessages(messages, names);
|
|
// IDs should be hashed to 9-char hex
|
|
expect(result[0].tool_calls[0].id).toMatch(/^[a-f0-9]{9}$/);
|
|
expect(result[1].tool_call_id).toMatch(/^[a-f0-9]{9}$/);
|
|
// Both should match (same input -> same hash)
|
|
expect(result[0].tool_calls[0].id).toBe(result[1].tool_call_id);
|
|
});
|
|
|
|
test('changes system to user when following assistant', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'Hi' },
|
|
{ role: 'assistant', content: 'Hello' },
|
|
{ role: 'system', content: 'Narrator text' },
|
|
];
|
|
const result = mod.convertMistralMessages(messages, names);
|
|
expect(result[2].role).toBe('user');
|
|
});
|
|
|
|
test('merges user message after tool into previous user message', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'search cats' },
|
|
{ role: 'assistant', content: 'calling', tool_calls: [{ id: 'tc1', function: { name: 'f' } }] },
|
|
{ role: 'tool', content: 'result', tool_call_id: 'tc1' },
|
|
{ role: 'user', content: 'thanks' },
|
|
];
|
|
const result = mod.convertMistralMessages(messages, names);
|
|
// The 'thanks' user message should be merged into the first user message
|
|
expect(result[0].content).toContain('search cats');
|
|
expect(result[0].content).toContain('thanks');
|
|
});
|
|
});
|
|
|
|
|
|
describe('cachingAtDepthForClaude', () => {
|
|
test('adds cache_control at specified depth', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [{ type: 'text', text: 'A' }] },
|
|
{ role: 'assistant', content: [{ type: 'text', text: 'B' }] },
|
|
{ role: 'user', content: [{ type: 'text', text: 'C' }] },
|
|
{ role: 'assistant', content: [{ type: 'text', text: 'D' }] },
|
|
{ role: 'user', content: [{ type: 'text', text: 'E' }] },
|
|
];
|
|
mod.cachingAtDepthForClaude(messages, 0, '300');
|
|
// Depth 0 should be the last non-assistant message (working backwards)
|
|
const cached = messages.filter(m =>
|
|
m.content.some(c => c.cache_control),
|
|
);
|
|
expect(cached.length).toBeGreaterThan(0);
|
|
const cacheControl = cached[0].content[cached[0].content.length - 1].cache_control;
|
|
expect(cacheControl).toEqual({ type: 'ephemeral', ttl: '300' });
|
|
});
|
|
|
|
test('skips trailing assistant messages (prefill)', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [{ type: 'text', text: 'A' }] },
|
|
{ role: 'assistant', content: [{ type: 'text', text: 'B' }] },
|
|
{ role: 'assistant', content: [{ type: 'text', text: 'Prefill' }] },
|
|
];
|
|
mod.cachingAtDepthForClaude(messages, 0, '300');
|
|
// The trailing assistant prefill should not get cache_control
|
|
const lastMsg = messages[messages.length - 1];
|
|
expect(lastMsg.content[0].cache_control).toBeUndefined();
|
|
});
|
|
|
|
test('does not modify messages when depth exceeds message count', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [{ type: 'text', text: 'A' }] },
|
|
];
|
|
mod.cachingAtDepthForClaude(messages, 10, '300');
|
|
expect(messages[0].content[0].cache_control).toBeUndefined();
|
|
});
|
|
});
|
|
|
|
|
|
describe('cachingAtDepthForOpenRouterClaude', () => {
|
|
test('adds cache_control to string content by wrapping in array', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'assistant', content: 'B' },
|
|
{ role: 'user', content: 'C' },
|
|
];
|
|
mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
|
|
// Find which message got cached
|
|
const cached = messages.find(m =>
|
|
Array.isArray(m.content) && m.content.some(c => c.cache_control),
|
|
);
|
|
expect(cached).toBeDefined();
|
|
expect(cached.content[0].type).toBe('text');
|
|
expect(cached.content[0].cache_control).toEqual({ type: 'ephemeral', ttl: '300' });
|
|
});
|
|
|
|
test('adds cache_control to array content on last part', () => {
|
|
const messages = [
|
|
{ role: 'user', content: [{ type: 'text', text: 'A' }, { type: 'text', text: 'B' }] },
|
|
{ role: 'assistant', content: [{ type: 'text', text: 'Reply' }] },
|
|
{ role: 'user', content: [{ type: 'text', text: 'C' }] },
|
|
];
|
|
mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
|
|
const cached = messages.find(m =>
|
|
m.content.some?.(c => c.cache_control),
|
|
);
|
|
expect(cached).toBeDefined();
|
|
});
|
|
|
|
test('skips system messages for depth counting', () => {
|
|
const messages = [
|
|
{ role: 'system', content: 'System prompt' },
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'assistant', content: 'B' },
|
|
{ role: 'user', content: 'C' },
|
|
];
|
|
mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
|
|
// System message should not get cache_control
|
|
expect(messages[0].content).toBe('System prompt');
|
|
});
|
|
|
|
test('skips trailing assistant prefill', () => {
|
|
const messages = [
|
|
{ role: 'user', content: 'A' },
|
|
{ role: 'assistant', content: 'Prefill' },
|
|
];
|
|
mod.cachingAtDepthForOpenRouterClaude(messages, 0, '300');
|
|
expect(typeof messages[1].content).toBe('string');
|
|
});
|
|
});
|