john
426 lines
14 KiB
JavaScript
426 lines
14 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import { createConversationMemoryService, extractConversationMessageText } from './conversation-memory.mjs';
|
|
import { encryptSecret } from './llm-providers.mjs';
|
|
|
|
function createPool({ provider = null } = {}) {
|
|
const state = {
|
|
messages: [],
|
|
memories: [],
|
|
analyzed: new Set(),
|
|
};
|
|
return {
|
|
state,
|
|
async query(sql, params = []) {
|
|
if (sql.includes('INSERT INTO h5_conversation_messages')) {
|
|
for (const row of params[0]) {
|
|
const [
|
|
id,
|
|
userId,
|
|
sessionId,
|
|
messageKey,
|
|
sequenceNo,
|
|
role,
|
|
text,
|
|
rawJson,
|
|
createdAt,
|
|
updatedAt,
|
|
] = row;
|
|
const existing = state.messages.find(
|
|
(item) => item.agent_session_id === sessionId && item.message_key === messageKey,
|
|
);
|
|
const next = {
|
|
id,
|
|
user_id: userId,
|
|
agent_session_id: sessionId,
|
|
message_key: messageKey,
|
|
sequence_no: sequenceNo,
|
|
role,
|
|
text,
|
|
raw_json: rawJson,
|
|
created_at: createdAt,
|
|
updated_at: updatedAt,
|
|
analyzed_at: existing?.analyzed_at ?? null,
|
|
};
|
|
if (existing) Object.assign(existing, next);
|
|
else state.messages.push(next);
|
|
}
|
|
return [{ affectedRows: params[0].length }];
|
|
}
|
|
if (sql.includes('FROM h5_conversation_messages')) {
|
|
const [userId, limit] = params;
|
|
return [
|
|
state.messages
|
|
.filter((item) => item.user_id === userId && item.role === 'user' && item.analyzed_at == null)
|
|
.slice(0, limit),
|
|
];
|
|
}
|
|
if (sql.includes('INSERT INTO h5_user_memory_items')) {
|
|
for (const row of params[0]) {
|
|
const [
|
|
id,
|
|
userId,
|
|
label,
|
|
memoryHash,
|
|
memoryText,
|
|
evidenceMessageId,
|
|
sourceSessionId,
|
|
confidence,
|
|
rawJson,
|
|
createdAt,
|
|
updatedAt,
|
|
] = row;
|
|
state.memories.push({
|
|
id,
|
|
user_id: userId,
|
|
label,
|
|
memory_hash: memoryHash,
|
|
memory_text: memoryText,
|
|
evidence_message_id: evidenceMessageId,
|
|
source_session_id: sourceSessionId,
|
|
confidence,
|
|
raw_json: rawJson,
|
|
created_at: createdAt,
|
|
updated_at: updatedAt,
|
|
});
|
|
}
|
|
return [{ affectedRows: params[0].length }];
|
|
}
|
|
if (sql.includes('UPDATE h5_conversation_messages SET analyzed_at')) {
|
|
const [analyzedAt, ids] = params;
|
|
for (const item of state.messages) {
|
|
if (ids.includes(item.id)) item.analyzed_at = analyzedAt;
|
|
}
|
|
return [{ affectedRows: ids.length }];
|
|
}
|
|
if (sql.includes('FROM h5_user_memory_items')) {
|
|
const [userId, limit] = params;
|
|
return [
|
|
state.memories
|
|
.filter((item) => item.user_id === userId)
|
|
.slice(0, limit)
|
|
.map((item) => ({ ...item, status: 'active' })),
|
|
];
|
|
}
|
|
if (sql.includes('FROM h5_llm_provider_keys')) return [[provider].filter(Boolean)];
|
|
throw new Error(`Unexpected SQL: ${sql}`);
|
|
},
|
|
};
|
|
}
|
|
|
|
test('extractConversationMessageText reads text content and display text', () => {
|
|
assert.equal(
|
|
extractConversationMessageText({ content: [{ type: 'text', text: ' hello ' }] }),
|
|
'hello',
|
|
);
|
|
assert.equal(
|
|
extractConversationMessageText({ content: [], metadata: { displayText: 'fallback' } }),
|
|
'fallback',
|
|
);
|
|
});
|
|
|
|
test('saveAndAnalyze stores messages and fallback memories', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '0';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, { now: () => 1000 });
|
|
|
|
const result = await service.saveAndAnalyze('session-1', 'user-1', [
|
|
{
|
|
id: 'm1',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '我喜欢简洁直接的回答，也关注 AI 产品设计。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
{
|
|
id: 'm2',
|
|
role: 'assistant',
|
|
content: [{ type: 'text', text: '好的。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
|
|
assert.equal(result.saved, 2);
|
|
assert.equal(result.analyzed, 1);
|
|
assert.equal(result.memories, 1);
|
|
assert.equal(pool.state.messages.length, 2);
|
|
assert.equal(pool.state.memories[0].label, 'preference');
|
|
assert.match(pool.state.memories[0].memory_text, /简洁直接/);
|
|
assert.equal(pool.state.messages.find((item) => item.message_key === 'm1')?.analyzed_at, 1000);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze re-analyzes saved session messages even when already marked analyzed', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '0';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, { now: () => 1500 });
|
|
const messages = [{
|
|
id: 'm-remember',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '请记住：我的测试别名是蓝鲸42。只回复已记住。' }],
|
|
metadata: { userVisible: true },
|
|
}];
|
|
|
|
const first = await service.saveAndAnalyze('session-remember', 'user-remember', messages);
|
|
assert.equal(first.analyzed, 1);
|
|
assert.equal(first.memories, 1);
|
|
assert.match(pool.state.memories.at(-1).memory_text, /蓝鲸42/);
|
|
|
|
pool.state.messages[0].analyzed_at = 1500;
|
|
const second = await service.saveAndAnalyze('session-remember', 'user-remember', messages);
|
|
assert.equal(second.analyzed, 1);
|
|
assert.equal(second.memories, 1);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze marks messages analyzed when llm extraction fails and no memory is stored', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '1';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, {
|
|
now: () => 2000,
|
|
llmProviderService: {
|
|
async createChatCompletion() {
|
|
throw new Error('upstream unavailable');
|
|
},
|
|
},
|
|
});
|
|
|
|
const result = await service.saveAndAnalyze('session-2', 'user-2', [
|
|
{
|
|
id: 'm3',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '今天下雨了。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
|
|
assert.equal(result.saved, 1);
|
|
assert.equal(result.memories, 0);
|
|
assert.equal(pool.state.messages.find((item) => item.message_key === 'm3')?.analyzed_at, 2000);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze still uses fallback when llm extraction is unavailable', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '1';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, {
|
|
now: () => 2250,
|
|
llmProviderService: {
|
|
async createChatCompletion() {
|
|
throw new Error('upstream unavailable');
|
|
},
|
|
},
|
|
});
|
|
|
|
const result = await service.saveAndAnalyze('session-fallback', 'user-fallback', [
|
|
{
|
|
id: 'm-fallback',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '我喜欢简洁的回答。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
|
|
assert.equal(result.memories, 1);
|
|
assert.match(pool.state.memories[0].memory_text, /简洁/);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze uses admin effective env for memory extraction model', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '1';
|
|
const pool = createPool();
|
|
const llmCalls = [];
|
|
const service = createConversationMemoryService(pool, {
|
|
now: () => 2600,
|
|
getEffectiveEnv: async () => ({
|
|
MEMIND_CHAT_ROUTER_MODEL_PROVIDER_KEY_ID: 'router-key',
|
|
MEMIND_CHAT_ROUTER_MODEL: 'deepseek-chat',
|
|
}),
|
|
llmProviderService: {
|
|
async createChatCompletion({ providerKeyId, model, messages }) {
|
|
llmCalls.push({ providerKeyId, model, messages });
|
|
return {
|
|
ok: true,
|
|
reply: JSON.stringify({
|
|
memories: [{ label: 'fact', text: '用户叫 John', confidence: 0.9 }],
|
|
}),
|
|
};
|
|
},
|
|
},
|
|
});
|
|
|
|
await service.saveAndAnalyze('session-admin', 'user-admin', [
|
|
{
|
|
id: 'm-admin',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '我是 John。' }],
|
|
},
|
|
]);
|
|
|
|
assert.equal(llmCalls.length, 1);
|
|
assert.equal(llmCalls[0].providerKeyId, 'router-key');
|
|
assert.equal(llmCalls[0].model, 'deepseek-chat');
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze extracts memories through llmProviderService', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '1';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, {
|
|
now: () => 2500,
|
|
llmProviderService: {
|
|
async createChatCompletion({ messages }) {
|
|
assert.match(String(messages?.[0]?.content ?? ''), /长期记忆/);
|
|
return {
|
|
ok: true,
|
|
reply: JSON.stringify({
|
|
memories: [{ label: 'goal', text: '用户计划去日本旅游', confidence: 0.82 }],
|
|
}),
|
|
};
|
|
},
|
|
},
|
|
});
|
|
|
|
const result = await service.saveAndAnalyze('session-llm', 'user-llm', [
|
|
{
|
|
id: 'm-japan',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '我打算带家人去日本玩 5 天。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
|
|
assert.equal(result.memories, 1);
|
|
assert.equal(pool.state.memories[0].label, 'goal');
|
|
assert.match(pool.state.memories[0].memory_text, /日本/);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze respects an empty llm result instead of storing a question through fallback', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '1';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, {
|
|
now: () => 2750,
|
|
llmProviderService: {
|
|
async createChatCompletion({ messages }) {
|
|
assert.match(String(messages?.[0]?.content ?? ''), /问句没有提供答案时不要记录/);
|
|
return {
|
|
ok: true,
|
|
reply: JSON.stringify({ memories: [] }),
|
|
};
|
|
},
|
|
},
|
|
});
|
|
|
|
const result = await service.saveAndAnalyze('session-question', 'user-question', [
|
|
{
|
|
id: 'm-question',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '用户记住的记忆召回灰度测试代号是什么？' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
|
|
assert.equal(result.analyzed, 1);
|
|
assert.equal(result.memories, 0);
|
|
assert.equal(pool.state.memories.length, 0);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|
|
|
|
test('saveAndAnalyze throttles repeated llm extraction warnings', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '1';
|
|
const warnings = [];
|
|
const originalWarn = console.warn;
|
|
console.warn = (...args) => warnings.push(args);
|
|
let currentNow = 4000;
|
|
try {
|
|
const secret = encryptSecret('test-key', 'memory-test-key');
|
|
const pool = createPool({
|
|
provider: {
|
|
api_url: 'https://llm.example.com/v1',
|
|
default_model: 'memory-model',
|
|
api_key_ciphertext: secret.ciphertext,
|
|
api_key_iv: secret.iv,
|
|
api_key_tag: secret.tag,
|
|
},
|
|
});
|
|
const service = createConversationMemoryService(pool, {
|
|
now: () => currentNow,
|
|
encryptionKey: 'memory-test-key',
|
|
llmWarningIntervalMs: 60000,
|
|
fetch: async () => {
|
|
throw new Error('upstream unavailable');
|
|
},
|
|
});
|
|
|
|
await service.saveAndAnalyze('session-warn-1', 'user-warn', [
|
|
{
|
|
id: 'warn-1',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '今天下雨了。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
currentNow += 1000;
|
|
await service.saveAndAnalyze('session-warn-2', 'user-warn', [
|
|
{
|
|
id: 'warn-2',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '明天可能也下雨。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
} finally {
|
|
console.warn = originalWarn;
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
}
|
|
|
|
assert.equal(warnings.length, 1);
|
|
assert.match(String(warnings[0][0]), /conversation-memory/);
|
|
});
|
|
|
|
test('saveAndAnalyze still marks messages analyzed when llm extraction is disabled and fallback stores nothing', async () => {
|
|
const previous = process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = '0';
|
|
const pool = createPool();
|
|
const service = createConversationMemoryService(pool, { now: () => 3000 });
|
|
|
|
const result = await service.saveAndAnalyze('session-3', 'user-3', [
|
|
{
|
|
id: 'm4',
|
|
role: 'user',
|
|
content: [{ type: 'text', text: '今天天气不错。' }],
|
|
metadata: { userVisible: true },
|
|
},
|
|
]);
|
|
|
|
assert.equal(result.saved, 1);
|
|
assert.equal(result.memories, 0);
|
|
assert.equal(pool.state.messages.find((item) => item.message_key === 'm4')?.analyzed_at, 3000);
|
|
|
|
if (previous == null) delete process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED;
|
|
else process.env.USER_CONVERSATION_MEMORY_LLM_ENABLED = previous;
|
|
});
|