705 lines
20 KiB
TypeScript
705 lines
20 KiB
TypeScript
import { describe, expect, it } from 'vitest';
|
|
import { applyStreamingPartDeltaToMessage, normalizeOpencodeSessionMessages } from '@/lib/opencode-message';
|
|
|
|
describe('opencode message normalization', () => {
|
|
it('keeps reasoning deltas as thinking content when the full part has not arrived yet', () => {
|
|
const message = applyStreamingPartDeltaToMessage(null, {
|
|
sessionID: 'ses_1',
|
|
messageID: 'msg_assistant',
|
|
partID: 'part_reasoning',
|
|
field: 'text',
|
|
delta: 'Reviewing the project flow.',
|
|
part: {
|
|
id: 'part_reasoning',
|
|
type: 'reasoning',
|
|
},
|
|
});
|
|
|
|
expect(message).toEqual(expect.objectContaining({
|
|
id: 'msg_assistant',
|
|
role: 'assistant',
|
|
content: [
|
|
{
|
|
type: 'thinking',
|
|
id: 'part_reasoning',
|
|
thinking: 'Reviewing the project flow.',
|
|
},
|
|
],
|
|
}));
|
|
});
|
|
|
|
it('normalizes provider reasoning, reasoning_content, and reasoning_text aliases', () => {
|
|
const messages = normalizeOpencodeSessionMessages([{
|
|
id: 'msg_reasoning_aliases',
|
|
role: 'assistant',
|
|
reasoning: 'first',
|
|
reasoning_content: 'second',
|
|
content: [
|
|
{ type: 'reasoning', reasoning_text: 'third' },
|
|
{ type: 'text', text: 'answer' },
|
|
],
|
|
}]);
|
|
|
|
expect(messages[0]?.content).toEqual([
|
|
{ type: 'thinking', thinking: 'first' },
|
|
{ type: 'thinking', thinking: 'third' },
|
|
{ type: 'text', text: 'answer' },
|
|
]);
|
|
});
|
|
|
|
it('surfaces a completed assistant message with no visible content as an error', () => {
|
|
const messages = normalizeOpencodeSessionMessages([
|
|
{
|
|
info: {
|
|
id: 'msg_empty_assistant',
|
|
role: 'assistant',
|
|
sessionID: 'ses_1',
|
|
time: { created: 1747040000000, completed: 1747040001000 },
|
|
},
|
|
parts: [
|
|
{ id: 'step_start', type: 'step-start' },
|
|
{ id: 'step_finish', type: 'step-finish' },
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(messages).toEqual([
|
|
expect.objectContaining({
|
|
id: 'msg_empty_assistant',
|
|
role: 'assistant',
|
|
isError: true,
|
|
errorMessage: '模型没有返回任何内容。请重试，或切换到支持图片输入的模型。',
|
|
content: [{
|
|
type: 'text',
|
|
text: '模型没有返回任何内容。请重试，或切换到支持图片输入的模型。',
|
|
}],
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('retains bounded runtime tool evidence without exposing raw tool state', () => {
|
|
const messages = normalizeOpencodeSessionMessages([
|
|
{
|
|
info: {
|
|
id: 'msg_tool_evidence',
|
|
role: 'assistant',
|
|
time: { created: 1747040000000, completed: 1747040001000 },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'tool_build',
|
|
callID: 'call_build',
|
|
type: 'tool',
|
|
tool: 'bash',
|
|
state: {
|
|
status: 'completed',
|
|
input: { command: 'pnpm build' },
|
|
output: 'build completed',
|
|
metadata: { exit: 0 },
|
|
time: { start: 1747040000000, end: 1747040000500 },
|
|
},
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(messages[0]?._toolEvidence).toEqual([
|
|
expect.objectContaining({
|
|
id: 'tool_build',
|
|
toolCallId: 'call_build',
|
|
name: 'bash',
|
|
status: 'completed',
|
|
inputSummary: expect.stringContaining('pnpm build'),
|
|
exitCode: 0,
|
|
}),
|
|
]);
|
|
});
|
|
|
|
it('preserves bounded user runtime context and only the true synthetic bit', () => {
|
|
const [message] = normalizeOpencodeSessionMessages([{
|
|
info: {
|
|
id: 'msg_user',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_000 },
|
|
agent: 'game-development',
|
|
model: {
|
|
providerID: 'niancode-user-models',
|
|
modelID: 'qwen3.7-plus',
|
|
variant: 'high',
|
|
},
|
|
system: 'SECRET SYSTEM PROMPT',
|
|
},
|
|
parts: [
|
|
{ id: 'part_visible', type: 'text', text: 'Visible request', synthetic: false },
|
|
{ id: 'part_hidden', type: 'text', text: 'Injected context', synthetic: true },
|
|
],
|
|
}]);
|
|
|
|
expect(message?._runtimeContext).toEqual({
|
|
agent: 'game-development',
|
|
model: 'niancode-user-models/qwen3.7-plus',
|
|
variant: 'high',
|
|
});
|
|
expect(message?.content).toEqual([
|
|
{ id: 'part_visible', type: 'text', text: 'Visible request' },
|
|
{ id: 'part_hidden', type: 'text', text: 'Injected context', synthetic: true },
|
|
]);
|
|
expect(JSON.stringify(message)).not.toContain('SECRET SYSTEM PROMPT');
|
|
});
|
|
|
|
it('drops oversized runtime identifiers instead of retaining arbitrary metadata', () => {
|
|
const [message] = normalizeOpencodeSessionMessages([{
|
|
info: {
|
|
id: 'msg_user',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_000 },
|
|
agent: 'a'.repeat(200),
|
|
model: {
|
|
providerID: 'provider',
|
|
modelID: 'model',
|
|
variant: 'v'.repeat(200),
|
|
},
|
|
},
|
|
parts: [{ type: 'text', text: 'Hello' }],
|
|
}]);
|
|
|
|
expect(message?._runtimeContext).toEqual({ model: 'provider/model' });
|
|
});
|
|
|
|
it('renders only a persisted command invocation and its whitelisted context', () => {
|
|
const [message] = normalizeOpencodeSessionMessages([{
|
|
info: {
|
|
id: 'msg_command',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_000 },
|
|
agent: 'game-development',
|
|
model: {
|
|
providerID: 'niancode-user-models',
|
|
modelID: 'qwen3.7-plus',
|
|
},
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'prt_invocation',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: ' raw arguments ',
|
|
contextPartIDs: ['prt_context', 'prt_image'],
|
|
},
|
|
{
|
|
id: 'prt_template',
|
|
type: 'text',
|
|
text: 'PRIVATE EXPANDED TEMPLATE',
|
|
synthetic: true,
|
|
},
|
|
{
|
|
id: 'prt_context',
|
|
type: 'text',
|
|
text: 'Bounded selected path context',
|
|
synthetic: true,
|
|
},
|
|
{
|
|
id: 'prt_image',
|
|
type: 'file',
|
|
mime: 'image/webp',
|
|
filename: 'screen.webp',
|
|
url: 'data:image/webp;base64,QUFB',
|
|
},
|
|
{
|
|
id: 'prt_plugin',
|
|
type: 'text',
|
|
text: 'PRIVATE PLUGIN TEXT',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
}]);
|
|
|
|
expect(message?.content?.[0]).toEqual({
|
|
id: 'prt_invocation',
|
|
type: 'text',
|
|
text: '/Review raw arguments ',
|
|
});
|
|
expect(JSON.stringify(message)).toContain('Bounded selected path context');
|
|
expect(message?._attachedFiles ?? []).toHaveLength(1);
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE EXPANDED TEMPLATE');
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE PLUGIN TEXT');
|
|
expect(JSON.stringify(message)).not.toContain('contextPartIDs');
|
|
});
|
|
|
|
it('fails closed when a command invocation marker is malformed or duplicated', () => {
|
|
const messages = normalizeOpencodeSessionMessages([
|
|
{
|
|
info: {
|
|
id: 'msg_malformed',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_000 },
|
|
agent: 'game-development',
|
|
model: { providerID: 'provider', modelID: 'model' },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'prt_bad',
|
|
type: 'command-invocation',
|
|
command: '',
|
|
arguments: '',
|
|
contextPartIDs: ['not-a-part-id'],
|
|
},
|
|
{ id: 'prt_template', type: 'text', text: 'PRIVATE MALFORMED TEMPLATE', synthetic: true },
|
|
],
|
|
},
|
|
{
|
|
info: {
|
|
id: 'msg_duplicated',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_001 },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'prt_first',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_context'],
|
|
},
|
|
{
|
|
id: 'prt_second',
|
|
type: 'command-invocation',
|
|
command: 'Explain',
|
|
arguments: '',
|
|
contextPartIDs: [],
|
|
},
|
|
{
|
|
id: 'prt_context',
|
|
type: 'text',
|
|
text: 'PRIVATE DUPLICATED TEMPLATE',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
info: {
|
|
id: 'msg_control',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_002 },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'prt_control',
|
|
type: 'command-invocation',
|
|
command: 'Review\u0000hidden',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_control_context'],
|
|
},
|
|
{
|
|
id: 'prt_control_context',
|
|
type: 'text',
|
|
text: 'PRIVATE CONTROL TEMPLATE',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
info: {
|
|
id: 'msg_invalid_marker_id',
|
|
role: 'user',
|
|
time: { created: 1_700_000_000_003 },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'arbitrary-renderer-id',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_invalid_id_context'],
|
|
},
|
|
{
|
|
id: 'prt_invalid_id_context',
|
|
type: 'text',
|
|
text: 'PRIVATE INVALID ID TEMPLATE',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(messages).toHaveLength(4);
|
|
for (const message of messages) {
|
|
expect(message.content).toEqual([{
|
|
type: 'text',
|
|
text: '[Project command metadata unavailable]',
|
|
}]);
|
|
expect(message._attachedFiles ?? []).toEqual([]);
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE');
|
|
}
|
|
});
|
|
|
|
it('fails closed for command markers on every non-user role', () => {
|
|
const messages = normalizeOpencodeSessionMessages(
|
|
['assistant', 'system', 'unknown-runtime-role'].map((role, index) => ({
|
|
info: {
|
|
id: `msg_non_user_${index}`,
|
|
role,
|
|
time: { created: 1_700_000_001_000 + index },
|
|
},
|
|
parts: [
|
|
{
|
|
id: `prt_marker_${index}`,
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '--private',
|
|
contextPartIDs: [`prt_private_${index}`, `prt_file_${index}`, `prt_tool_${index}`],
|
|
},
|
|
{
|
|
id: `prt_private_${index}`,
|
|
type: 'text',
|
|
text: `PRIVATE_ROLE_${index}`,
|
|
synthetic: true,
|
|
},
|
|
{
|
|
id: `prt_file_${index}`,
|
|
type: 'file',
|
|
mime: 'image/png',
|
|
filename: 'private.png',
|
|
url: 'data:image/png;base64,QUFB',
|
|
},
|
|
{
|
|
id: `prt_tool_${index}`,
|
|
type: 'tool',
|
|
tool: 'bash',
|
|
state: { input: { command: 'print-private-data' } },
|
|
},
|
|
],
|
|
})),
|
|
);
|
|
|
|
expect(messages).toHaveLength(3);
|
|
for (const message of messages) {
|
|
expect(message.content).toEqual([{
|
|
type: 'text',
|
|
text: '[Project command metadata unavailable]',
|
|
}]);
|
|
expect(message._attachedFiles ?? []).toEqual([]);
|
|
expect(message._toolEvidence ?? []).toEqual([]);
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE_ROLE');
|
|
expect(JSON.stringify(message)).not.toContain('print-private-data');
|
|
expect(JSON.stringify(message)).not.toContain('--private');
|
|
}
|
|
});
|
|
|
|
it('never renders tool or reasoning parts referenced by a valid user command marker', () => {
|
|
const [message] = normalizeOpencodeSessionMessages([{
|
|
info: {
|
|
id: 'msg_user_unsafe_context',
|
|
role: 'user',
|
|
time: { created: 1_700_000_001_500 },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'prt_user_unsafe_marker',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: 'safe arguments',
|
|
contextPartIDs: [
|
|
'prt_user_safe_text',
|
|
'prt_user_private_reasoning',
|
|
'prt_user_private_tool',
|
|
],
|
|
},
|
|
{
|
|
id: 'prt_user_safe_text',
|
|
type: 'text',
|
|
text: 'Visible selected context',
|
|
synthetic: true,
|
|
},
|
|
{
|
|
id: 'prt_user_private_reasoning',
|
|
type: 'reasoning',
|
|
text: 'PRIVATE_REASONING',
|
|
},
|
|
{
|
|
id: 'prt_user_private_tool',
|
|
callID: 'call_user_private_tool',
|
|
type: 'tool',
|
|
tool: 'bash',
|
|
state: {
|
|
status: 'completed',
|
|
input: { command: 'PRIVATE_TOOL_INPUT' },
|
|
},
|
|
},
|
|
],
|
|
}]);
|
|
|
|
expect(message?.content).toEqual([
|
|
{
|
|
id: 'prt_user_unsafe_marker',
|
|
type: 'text',
|
|
text: '/Review safe arguments',
|
|
},
|
|
{
|
|
id: 'prt_user_safe_text',
|
|
type: 'text',
|
|
text: 'Visible selected context',
|
|
synthetic: true,
|
|
},
|
|
]);
|
|
expect(message?._toolEvidence ?? []).toEqual([]);
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE_REASONING');
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE_TOOL_INPUT');
|
|
});
|
|
|
|
it('fails closed for malformed structured-like and legacy command marker shapes', () => {
|
|
const messages = normalizeOpencodeSessionMessages([
|
|
{
|
|
id: 'msg_missing_info',
|
|
role: 'user',
|
|
parts: [
|
|
{
|
|
id: 'prt_missing_info',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_missing_info_private'],
|
|
},
|
|
{
|
|
id: 'prt_missing_info_private',
|
|
type: 'text',
|
|
text: 'PRIVATE_MISSING_INFO',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
info: {
|
|
id: 'msg_non_array_parts',
|
|
role: 'user',
|
|
time: { created: 1_700_000_002_000 },
|
|
},
|
|
parts: {
|
|
marker: {
|
|
id: 'prt_non_array',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_non_array_private'],
|
|
},
|
|
privatePart: {
|
|
id: 'prt_non_array_private',
|
|
type: 'text',
|
|
text: 'PRIVATE_NON_ARRAY_PARTS',
|
|
synthetic: true,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
id: 'msg_legacy_array',
|
|
role: 'user',
|
|
content: [
|
|
{
|
|
id: 'prt_legacy_marker',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_legacy_private'],
|
|
},
|
|
{
|
|
id: 'prt_legacy_private',
|
|
type: 'text',
|
|
text: 'PRIVATE_LEGACY_ARRAY',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
id: 'msg_array_info',
|
|
info: [],
|
|
parts: [
|
|
{
|
|
id: 'prt_array_info_marker',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: ['prt_array_info_private'],
|
|
},
|
|
{
|
|
id: 'prt_array_info_private',
|
|
type: 'text',
|
|
text: 'PRIVATE_ARRAY_INFO',
|
|
synthetic: true,
|
|
},
|
|
],
|
|
},
|
|
{
|
|
id: 'msg_ordinary_legacy',
|
|
role: 'assistant',
|
|
content: 'Ordinary legacy content',
|
|
},
|
|
]);
|
|
|
|
expect(messages).toHaveLength(5);
|
|
for (const message of messages.slice(0, 4)) {
|
|
expect(message.content).toEqual([{
|
|
type: 'text',
|
|
text: '[Project command metadata unavailable]',
|
|
}]);
|
|
expect(message._attachedFiles ?? []).toEqual([]);
|
|
expect(message._toolEvidence ?? []).toEqual([]);
|
|
expect(JSON.stringify(message)).not.toContain('PRIVATE');
|
|
expect(JSON.stringify(message)).not.toContain('command-invocation');
|
|
}
|
|
expect(messages[4]?.content).toEqual([{
|
|
type: 'text',
|
|
text: 'Ordinary legacy content',
|
|
}]);
|
|
});
|
|
|
|
it('preserves legacy normalization for structured-like records without a command marker', () => {
|
|
const messages = normalizeOpencodeSessionMessages([
|
|
{
|
|
id: 'msg_legacy_info',
|
|
role: 'assistant',
|
|
text: 'Legacy info content',
|
|
info: { source: 'legacy-adapter' },
|
|
},
|
|
{
|
|
id: 'msg_legacy_parts',
|
|
role: 'assistant',
|
|
text: 'Legacy parts content',
|
|
parts: { source: 'legacy-adapter' },
|
|
},
|
|
]);
|
|
|
|
expect(messages).toEqual([
|
|
{
|
|
id: 'msg_legacy_info',
|
|
role: 'assistant',
|
|
timestamp: undefined,
|
|
content: [{ type: 'text', text: 'Legacy info content' }],
|
|
},
|
|
{
|
|
id: 'msg_legacy_parts',
|
|
role: 'assistant',
|
|
timestamp: undefined,
|
|
content: [{ type: 'text', text: 'Legacy parts content' }],
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('requires string arguments and enforces command selector bounds', () => {
|
|
const invalidArguments: unknown[] = [undefined, null, 42, { private: true }];
|
|
const messages = normalizeOpencodeSessionMessages([
|
|
...invalidArguments.map((argumentsValue, index) => ({
|
|
info: {
|
|
id: `msg_bad_arguments_${index}`,
|
|
role: 'user',
|
|
time: { created: 1_700_000_003_000 + index },
|
|
},
|
|
parts: [{
|
|
id: `prt_bad_arguments_${index}`,
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
...(argumentsValue === undefined ? {} : { arguments: argumentsValue }),
|
|
contextPartIDs: [],
|
|
}],
|
|
})),
|
|
{
|
|
info: { id: 'msg_whitespace_command', role: 'user' },
|
|
parts: [{
|
|
id: 'prt_whitespace_command',
|
|
type: 'command-invocation',
|
|
command: ' Review',
|
|
arguments: '',
|
|
contextPartIDs: [],
|
|
}],
|
|
},
|
|
{
|
|
info: { id: 'msg_leading_slash_command', role: 'user' },
|
|
parts: [{
|
|
id: 'prt_leading_slash_command',
|
|
type: 'command-invocation',
|
|
command: '/Review',
|
|
arguments: '',
|
|
contextPartIDs: [],
|
|
}],
|
|
},
|
|
{
|
|
info: { id: 'msg_oversized_arguments', role: 'user' },
|
|
parts: [{
|
|
id: 'prt_oversized_arguments',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: 'a'.repeat(8_193),
|
|
contextPartIDs: [],
|
|
}],
|
|
},
|
|
{
|
|
info: { id: 'msg_too_many_context_ids', role: 'user' },
|
|
parts: [{
|
|
id: 'prt_too_many_context_ids',
|
|
type: 'command-invocation',
|
|
command: 'Review',
|
|
arguments: '',
|
|
contextPartIDs: Array.from({ length: 65 }, (_, index) => `prt_context_${index}`),
|
|
}],
|
|
},
|
|
]);
|
|
|
|
expect(messages).toHaveLength(8);
|
|
for (const message of messages) {
|
|
expect(message.content).toEqual([{
|
|
type: 'text',
|
|
text: '[Project command metadata unavailable]',
|
|
}]);
|
|
expect(message._attachedFiles ?? []).toEqual([]);
|
|
}
|
|
});
|
|
|
|
it('does not mistake a large ordinary tool payload for command metadata', () => {
|
|
const [message] = normalizeOpencodeSessionMessages([{
|
|
info: {
|
|
id: 'msg_large_tool_payload',
|
|
role: 'assistant',
|
|
time: { created: 1_700_000_005_000 },
|
|
},
|
|
parts: [
|
|
{
|
|
id: 'prt_visible_result',
|
|
type: 'text',
|
|
text: 'Visible assistant result',
|
|
},
|
|
{
|
|
id: 'prt_large_tool',
|
|
callID: 'call_large_tool',
|
|
type: 'tool',
|
|
tool: 'inspect',
|
|
state: {
|
|
status: 'completed',
|
|
input: Array.from({ length: 4_100 }, (_, index) => ({ index })),
|
|
output: 'Inspection complete',
|
|
},
|
|
},
|
|
],
|
|
}]);
|
|
|
|
expect(message?.content).toEqual([
|
|
{
|
|
id: 'prt_visible_result',
|
|
type: 'text',
|
|
text: 'Visible assistant result',
|
|
},
|
|
expect.objectContaining({
|
|
id: 'call_large_tool',
|
|
type: 'tool_use',
|
|
name: 'inspect',
|
|
}),
|
|
]);
|
|
expect(message?._toolEvidence).toEqual([
|
|
expect.objectContaining({
|
|
id: 'prt_large_tool',
|
|
toolCallId: 'call_large_tool',
|
|
name: 'inspect',
|
|
status: 'completed',
|
|
}),
|
|
]);
|
|
});
|
|
});
|