228 lines
12 KiB
JavaScript
228 lines
12 KiB
JavaScript
import { test } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { createHash } from 'node:crypto';
|
|
import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
|
|
import { tmpdir } from 'node:os';
|
|
import { join } from 'node:path';
|
|
|
|
import { createKimiProvider } from '../packages/core/src/providers/kimi.ts';
|
|
|
|
function drain(gen) {
|
|
const values = [];
|
|
let step = gen.next();
|
|
while (!step.done) {
|
|
values.push(step.value);
|
|
step = gen.next();
|
|
}
|
|
return { values, ret: step.value };
|
|
}
|
|
|
|
function writeKimiFixture() {
|
|
const root = mkdtempSync(join(tmpdir(), 'obelisk-kimi-'));
|
|
const sessionDir = join(root, 'sessions', 'workspace-1', 'session-native-1');
|
|
const mainDir = join(sessionDir, 'agents', 'main');
|
|
const childDir = join(sessionDir, 'agents', 'agent-7');
|
|
mkdirSync(mainDir, { recursive: true });
|
|
mkdirSync(childDir, { recursive: true });
|
|
writeFileSync(join(sessionDir, 'state.json'), JSON.stringify({
|
|
title: 'Kimi fixture',
|
|
createdAt: '2026-07-20T10:00:00.000Z',
|
|
updatedAt: '2026-07-20T10:01:00.000Z',
|
|
workDir: '/tmp/kimi-project',
|
|
agents: {
|
|
main: { type: 'main' },
|
|
'agent-7': { type: 'sub', parentAgentId: 'main', labels: { profile: 'explore' } },
|
|
},
|
|
}));
|
|
|
|
const mainRecords = [
|
|
{ type: 'metadata', protocol_version: '1.5', created_at: 1753005600000 },
|
|
{ type: 'config.update', time: 1753005600100, modelAlias: 'kimi-k2' },
|
|
{ type: 'context.append_message', time: 1753005601000, message: { role: 'user', content: [{ type: 'text', text: 'inspect the project' }], toolCalls: [], origin: { kind: 'user' } } },
|
|
{ type: 'context.append_loop_event', time: 1753005602000, event: { type: 'step.begin', uuid: 'step-1', turnId: '0' } },
|
|
{ type: 'context.append_loop_event', time: 1753005602100, event: { type: 'content.part', uuid: 'thinking-1', stepUuid: 'step-1', part: { type: 'thinking', thinking: 'I should inspect it' } } },
|
|
{ type: 'context.append_loop_event', time: 1753005602200, event: { type: 'tool.call', uuid: 'tool-event-1', stepUuid: 'step-1', toolCallId: 'call-1', name: 'Read', args: { file_path: '/tmp/kimi-project/a.ts' } } },
|
|
{ type: 'context.append_loop_event', time: 1753005602300, event: { type: 'tool.result', parentUuid: 'tool-result-1', toolCallId: 'call-1', result: { output: 'agent_id: agent-7\nfile body', isError: false } } },
|
|
{ type: 'context.append_loop_event', time: 1753005602500, event: { type: 'content.part', uuid: 'text-1', stepUuid: 'step-1', part: { type: 'text', text: 'done' } } },
|
|
{ type: 'context.append_loop_event', time: 1753005603000, event: { type: 'step.end', uuid: 'step-1', usage: { inputOther: 7, inputCacheRead: 3, inputCacheCreation: 2, output: 3 } } },
|
|
{ type: 'context.apply_compaction', time: 1753005604000, summary: 'Earlier work summary', compactedCount: 2 },
|
|
];
|
|
writeFileSync(join(mainDir, 'wire.jsonl'), mainRecords.map((record) => JSON.stringify(record)).join('\n') + '\n');
|
|
|
|
const childRecords = [
|
|
{ type: 'metadata', protocol_version: '1.5', created_at: 1753005600000 },
|
|
{ type: 'context.append_message', time: 1753005602400, message: { role: 'user', content: [{ type: 'text', text: 'child prompt' }], toolCalls: [], origin: { kind: 'system_trigger', name: 'subagent' } } },
|
|
];
|
|
writeFileSync(join(childDir, 'wire.jsonl'), childRecords.map((record) => JSON.stringify(record)).join('\n') + '\n');
|
|
return { root, sessionDir };
|
|
}
|
|
|
|
test('kimi provider discovers a changed session directory and returns a stable cursor', () => {
|
|
const { root, sessionDir } = writeKimiFixture();
|
|
const provider = createKimiProvider({ rootDir: root });
|
|
const units = provider.discover({ lastCursor: () => null });
|
|
|
|
assert.equal(units.length, 1);
|
|
assert.equal(units[0].key, sessionDir);
|
|
assert.equal(units[0].sessionId, 'kimi:session-native-1');
|
|
assert.match(units[0].meta.currentCursor, /^\d+(?:\.\d+)?:\d+$/);
|
|
|
|
const unchanged = provider.discover({ lastCursor: () => units[0].meta.currentCursor });
|
|
assert.deepEqual(unchanged, []);
|
|
});
|
|
|
|
test('kimi provider folds main and subagent wire logs into the existing record language', () => {
|
|
const { root } = writeKimiFixture();
|
|
const provider = createKimiProvider({ rootDir: root });
|
|
const unit = provider.discover({ lastCursor: () => null })[0];
|
|
const { values, ret } = drain(provider.parse(unit, null));
|
|
const byKind = (kind) => values.filter((record) => record.kind === kind);
|
|
|
|
const goldenRecords = values.map((record) => record.kind === 'session'
|
|
? { ...record, jsonl_path: '<fixture-wire>' }
|
|
: record);
|
|
assert.equal(
|
|
createHash('sha256').update(JSON.stringify(goldenRecords)).digest('hex'),
|
|
'ce3c70798bbc50e438605d86eafb28482630ee38dc2baa41a695975c84646822',
|
|
'complete yielded record sequence changed',
|
|
);
|
|
|
|
assert.deepEqual(values[0], { kind: 'delete-session', sessionId: 'kimi:session-native-1' });
|
|
assert.equal(ret, unit.meta.currentCursor);
|
|
|
|
const session = byKind('session')[0];
|
|
assert.deepEqual(
|
|
(({ id, title, project, source, countMode }) => ({ id, title, project, source, countMode }))(session),
|
|
{
|
|
id: 'kimi:session-native-1',
|
|
title: 'Kimi fixture',
|
|
project: '-tmp-kimi-project',
|
|
source: 'kimi',
|
|
countMode: 'total',
|
|
},
|
|
);
|
|
|
|
const messages = byKind('message');
|
|
assert.deepEqual(messages.map((message) => [message.role, message.content_type, message.text]), [
|
|
['user', 'text', 'inspect the project'],
|
|
['assistant', 'thinking', 'I should inspect it'],
|
|
['assistant', 'tool_use', null],
|
|
['assistant', 'text', 'done'],
|
|
['user', 'text', 'child prompt'],
|
|
]);
|
|
assert.equal(messages.at(-1).agent_id, 'kimi:session-native-1:agent-7');
|
|
assert.equal(messages.at(-1).is_sidechain, 1);
|
|
assert.equal(messages.find((message) => message.text === 'done').input_tokens, 12);
|
|
assert.equal(messages.find((message) => message.text === 'done').output_tokens, 3);
|
|
|
|
assert.deepEqual(byKind('tool_call').map((record) => [record.id, record.name, record.file_path]), [
|
|
['kimi:session-native-1:main:call-1', 'Read', '/tmp/kimi-project/a.ts'],
|
|
]);
|
|
assert.deepEqual(byKind('tool_result').map((record) => [record.tool_use_id, record.is_error]), [
|
|
['kimi:session-native-1:main:call-1', 0],
|
|
]);
|
|
assert.deepEqual(byKind('summary').map((record) => record.content), ['Earlier work summary']);
|
|
assert.deepEqual(byKind('subagent').map((record) => [record.agent_id, record.parent_tool_use_id, record.agent_type]), [
|
|
['kimi:session-native-1:agent-7', 'kimi:session-native-1:main:call-1', 'explore'],
|
|
]);
|
|
});
|
|
|
|
test('kimi provider ignores a torn final wire line until it is completed', () => {
|
|
const { root, sessionDir } = writeKimiFixture();
|
|
const wirePath = join(sessionDir, 'agents', 'main', 'wire.jsonl');
|
|
writeFileSync(wirePath, readFileSync(wirePath, 'utf8') + '{"type":"context.append_message"');
|
|
const provider = createKimiProvider({ rootDir: root });
|
|
const unit = provider.discover({ lastCursor: () => null })[0];
|
|
|
|
const { values, ret } = drain(provider.parse(unit, null));
|
|
|
|
assert.equal(values.filter(record => record.kind === 'message').length, 5);
|
|
assert.equal(ret, unit.meta.currentCursor);
|
|
});
|
|
|
|
test('kimi provider replays clear and undo markers with Kimi transcript semantics', () => {
|
|
const root = mkdtempSync(join(tmpdir(), 'obelisk-kimi-undo-'));
|
|
const sessionDir = join(root, 'sessions', 'workspace-1', 'session-undo-1');
|
|
const mainDir = join(sessionDir, 'agents', 'main');
|
|
mkdirSync(mainDir, { recursive: true });
|
|
writeFileSync(join(sessionDir, 'state.json'), JSON.stringify({
|
|
workDir: '/tmp/kimi-undo',
|
|
agents: { main: { type: 'main' } },
|
|
}));
|
|
const records = [
|
|
{ type: 'metadata', protocol_version: '1.5', created_at: 1753005600000 },
|
|
{ type: 'context.append_message', time: 1, message: { role: 'user', content: 'before clear', toolCalls: [], origin: { kind: 'user' } } },
|
|
{ type: 'context.append_loop_event', time: 2, event: { type: 'content.part', uuid: 'before-answer', stepUuid: 's1', part: { type: 'text', text: 'kept answer' } } },
|
|
{ type: 'context.clear', time: 3 },
|
|
{ type: 'context.append_message', time: 4, message: { role: 'user', content: 'undone prompt', toolCalls: [], origin: { kind: 'user' } } },
|
|
{ type: 'context.append_message', time: 5, message: { role: 'user', content: 'persistent injection', toolCalls: [], origin: { kind: 'injection' } } },
|
|
{ type: 'context.append_message', time: 6, message: { role: 'user', content: 'ephemeral system trigger', toolCalls: [], origin: { kind: 'system_trigger' } } },
|
|
{ type: 'context.append_loop_event', time: 7, event: { type: 'content.part', uuid: 'undone-answer', stepUuid: 's2', part: { type: 'text', text: 'undone answer' } } },
|
|
{ type: 'context.undo', time: 8, count: 1 },
|
|
];
|
|
writeFileSync(join(mainDir, 'wire.jsonl'), records.map(record => JSON.stringify(record)).join('\n') + '\n');
|
|
const provider = createKimiProvider({ rootDir: root });
|
|
const unit = provider.discover({ lastCursor: () => null })[0];
|
|
|
|
const { values } = drain(provider.parse(unit, null));
|
|
assert.deepEqual(
|
|
values.filter(record => record.kind === 'message').map(record => record.text),
|
|
['before clear', 'kept answer', 'persistent injection'],
|
|
);
|
|
assert.equal(values.find(record => record.kind === 'session').message_count, 3);
|
|
});
|
|
|
|
test('kimi provider scopes changed-path discovery to one session and bypasses an unchanged cursor', () => {
|
|
const root = mkdtempSync(join(tmpdir(), 'obelisk-kimi-changed-path-'));
|
|
const firstDir = join(root, 'sessions', 'workspace-1', 'session-1');
|
|
const secondDir = join(root, 'sessions', 'workspace-1', 'session-2');
|
|
for (const sessionDir of [firstDir, secondDir]) {
|
|
mkdirSync(join(sessionDir, 'agents', 'main'), { recursive: true });
|
|
writeFileSync(join(sessionDir, 'state.json'), JSON.stringify({ workDir: '/tmp/project' }));
|
|
writeFileSync(join(sessionDir, 'agents', 'main', 'wire.jsonl'), '{"type":"metadata"}\n');
|
|
}
|
|
const provider = createKimiProvider({ rootDir: root });
|
|
const initial = provider.discover({ lastCursor: () => null });
|
|
const cursorByKey = new Map(initial.map(unit => [unit.key, unit.meta.currentCursor]));
|
|
|
|
const units = provider.discover({
|
|
lastCursor: key => cursorByKey.get(key) ?? null,
|
|
changedPaths: [join(firstDir, 'state.json')],
|
|
});
|
|
|
|
assert.deepEqual(units.map(unit => unit.key), [firstDir]);
|
|
});
|
|
|
|
test('kimi provider maps protocol-1.0 embedded tool calls and results', () => {
|
|
const root = mkdtempSync(join(tmpdir(), 'obelisk-kimi-legacy-tools-'));
|
|
const sessionDir = join(root, 'sessions', 'workspace-1', 'session-tools-1');
|
|
const mainDir = join(sessionDir, 'agents', 'main');
|
|
mkdirSync(mainDir, { recursive: true });
|
|
writeFileSync(join(sessionDir, 'state.json'), JSON.stringify({ workDir: '/tmp/tools' }));
|
|
const records = [
|
|
{ type: 'metadata', protocol_version: '1.0', created_at: 1 },
|
|
{ type: 'context.append_message', time: 2, message: {
|
|
role: 'assistant', content: [],
|
|
toolCalls: [{ type: 'function', id: 'legacy-call', function: { name: 'Read', arguments: '{"file_path":"/tmp/tools/a.ts"}' } }],
|
|
} },
|
|
{ type: 'context.append_message', time: 3, message: {
|
|
role: 'tool', content: [{ type: 'text', text: 'legacy result' }], toolCalls: [], toolCallId: 'legacy-call',
|
|
} },
|
|
];
|
|
writeFileSync(join(mainDir, 'wire.jsonl'), records.map(record => JSON.stringify(record)).join('\n') + '\n');
|
|
const provider = createKimiProvider({ rootDir: root });
|
|
const unit = provider.discover({ lastCursor: () => null })[0];
|
|
|
|
const { values } = drain(provider.parse(unit, null));
|
|
assert.deepEqual(values.filter(record => record.kind === 'tool_call').map(record => ({
|
|
id: record.id, name: record.name, file_path: record.file_path,
|
|
})), [{
|
|
id: 'kimi:session-tools-1:main:legacy-call', name: 'Read', file_path: '/tmp/tools/a.ts',
|
|
}]);
|
|
assert.deepEqual(values.filter(record => record.kind === 'tool_result').map(record => ({
|
|
tool_use_id: record.tool_use_id, content: record.content,
|
|
})), [{
|
|
tool_use_id: 'kimi:session-tools-1:main:legacy-call', content: 'legacy result',
|
|
}]);
|
|
});
|