Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.
Python agent-contextagent-memoryagent-pluginsagentic-ragcontext-databasedsh-pluginknowledge-basememorymemory-managementself-evolvingvector-database
import assert from "node:assert/strict";
import test from "node:test";
import {
applyZcodeCaptureResult,
buildZcodeCapturePlan,
} from "../hosts/zcode-capture.mjs";
const turns = [
{ role: "user", content: "question", turnId: "turn-001" },
{ role: "assistant", content: "answer", turnId: "turn-001" },
];
test("capture plan maps host identity to the OpenViking turn_id contract", () => {
const plan = buildZcodeCapturePlan(turns, {});
assert.deepEqual(plan.payloads, [
{ role: "user", content: "question", turn_id: "turn-001" },
{ role: "assistant", content: "answer", turn_id: "turn-001" },
]);
assert.equal(plan.payloads[0].turnId, undefined);
});
test("acknowledgements and slash commands never reach the server", () => {
const plan = buildZcodeCapturePlan([
{ role: "user", content: "/compact", turnId: "turn-001" },
{ role: "assistant", content: "好的", turnId: "turn-001" },
{ role: "user", content: "real question", turnId: "turn-002" },
{ role: "assistant", content: "real answer", turnId: "turn-002" },
], {});
assert.deepEqual(plan.payloads, [
{ role: "user", content: "real question", turn_id: "turn-002" },
{ role: "assistant", content: "real answer", turn_id: "turn-002" },
]);
});
test("injected blocks cleanZcodeText does not know are stripped before sending", () => {
const plan = buildZcodeCapturePlan([{
role: "assistant",
content: "answer body <relevant-memory score=\"0.9\">recalled</relevant-memory>",
turnId: "turn-001",
}], {});
assert.ok(!plan.payloads[0].content.includes("recalled"));
assert.ok(plan.payloads[0].content.startsWith("answer body"));
});
test("a fully filtered turn still lets the cursor advance past it", () => {
const turnsWithNoise = [
{ role: "user", content: "ok", turnId: "turn-001" },
{ role: "user", content: "real question", turnId: "turn-002" },
{ role: "assistant", content: "real answer", turnId: "turn-002" },
];
const plan = buildZcodeCapturePlan(turnsWithNoise, {});
const next = applyZcodeCaptureResult({}, plan, { sent: 2, queued: 0, failed: 0 });
assert.equal(next.lastTurnId, "turn-002");
});
test("oversized turns are truncated to captureMaxLength before they are sent", () => {
const long = "a question that repeats. ".repeat(100);
const plan = buildZcodeCapturePlan(
[{ role: "user", content: long, turnId: "turn-001" }],
{},
{ captureMaxLength: 200 },
);
assert.equal(plan.payloads.length, 1);
assert.ok(plan.payloads[0].content.length <= 200);
assert.ok(plan.payloads[0].content.endsWith("[truncated]"));
// Without a host turn id the key is hashed from the turn itself, so it must
// follow the raw text: a later captureMaxLength cannot make the turn look new.
const hashed = [{ role: "user", content: long }];
const narrow = buildZcodeCapturePlan(hashed, {}, { captureMaxLength: 200 });
const wider = buildZcodeCapturePlan(hashed, {}, { captureMaxLength: 24000 });
assert.equal(wider.candidates[0].dedupKey, narrow.candidates[0].dedupKey);
assert.equal(wider.payloads[0].content, long.trim());
});
test("Zcode filters the full turn before capping the payload", () => {
const turn = { role: "user", content: `Remember ${"x".repeat(100)} SECRET123`, turnId: "turn-001" };
const plan = buildZcodeCapturePlan([turn], {}, {
captureMaxLength: 64,
captureFilters: ["d/SECRET123/"],
});
assert.deepEqual(plan.payloads, []);
});
test("non-retryable failure keeps cursor, dedup, and pending prompt unchanged", () => {
const state = {
lastTurnId: "turn-000",
capturedTurnIds: [],
pendingPrompt: { prompt: "question", hash: "prompt-hash" },
};
const plan = buildZcodeCapturePlan(turns, state);
const next = applyZcodeCaptureResult(state, plan, {
sent: 0,
queued: 0,
failed: 2,
});
assert.equal(next.lastTurnId, "turn-000");
assert.deepEqual(next.capturedTurnIds, []);
assert.deepEqual(next.pendingPrompt, state.pendingPrompt);
assert.equal(next.captured, 0);
});
test("only the acknowledged contiguous prefix updates dedup and cursor state", () => {
const state = {
lastTurnId: "turn-000",
capturedTurnIds: [],
pendingPrompt: { prompt: "question" },
};
const plan = buildZcodeCapturePlan(turns, state);
const next = applyZcodeCaptureResult(state, plan, {
sent: 1,
queued: 0,
failed: 1,
});
assert.deepEqual(next.capturedTurnIds, ["turn-001:user"]);
assert.equal(next.lastTurnId, "turn-000");
assert.equal(next.pendingPrompt, null);
});
test("successful capture records every dedup key and suppresses repeated Stop", () => {
const state = {
capturedTurnIds: [],
pendingPrompt: { prompt: "question" },
};
const firstPlan = buildZcodeCapturePlan(turns, state);
const next = applyZcodeCaptureResult(state, firstPlan, {
sent: 2,
queued: 0,
failed: 0,
});
assert.deepEqual(next.capturedTurnIds, [
"turn-001:user",
"turn-001:assistant",
]);
assert.equal(next.lastTurnId, "turn-001");
assert.equal(next.pendingPrompt, null);
const repeatedPlan = buildZcodeCapturePlan(turns, next);
assert.equal(repeatedPlan.toSend.length, 0);
assert.equal(repeatedPlan.payloads.length, 0);
});
test("capture plan deduplicates identical messages within one rollout batch", () => {
const duplicatePrompt = { role: "user", content: "same prompt", turnId: "turn-001" };
const turnsWithRetries = [
...Array.from({ length: 10 }, () => duplicatePrompt),
...Array.from({ length: 5 }, (_, index) => ({
role: "assistant",
content: `assistant fragment ${index}`,
turnId: "turn-001",
})),
];
const plan = buildZcodeCapturePlan(turnsWithRetries, {});
assert.equal(plan.payloads.length, 6);
assert.deepEqual(plan.payloads.map(({ role, content }) => ({ role, content })), [
{ role: "user", content: "same prompt" },
...Array.from({ length: 5 }, (_, index) => ({
role: "assistant",
content: `assistant fragment ${index}`,
})),
]);
});
test("queued messages are acknowledged like sent messages", () => {
const plan = buildZcodeCapturePlan(turns, {});
const next = applyZcodeCaptureResult({}, plan, {
sent: 0,
queued: 2,
failed: 0,
});
assert.equal(next.lastTurnId, "turn-001");
assert.deepEqual(next.capturedTurnIds, [
"turn-001:user",
"turn-001:assistant",
]);
});
test("repeated prompt text clears only after the latest matching user is acknowledged", () => {
const repeatedTurns = [
{ role: "user", content: "same question", turnId: "turn-001" },
{ role: "assistant", content: "first answer", turnId: "turn-001" },
{ role: "user", content: "same question", turnId: "turn-002" },
{ role: "assistant", content: "second answer", turnId: "turn-002" },
];
const state = {
capturedTurnIds: [],
pendingPrompt: { prompt: "same question" },
};
const plan = buildZcodeCapturePlan(repeatedTurns, state);
const partial = applyZcodeCaptureResult(state, plan, {
sent: 2,
queued: 0,
failed: 2,
});
assert.equal(partial.lastTurnId, "turn-001");
assert.deepEqual(partial.pendingPrompt, state.pendingPrompt);
const retryPlan = buildZcodeCapturePlan(repeatedTurns.slice(2), partial);
const complete = applyZcodeCaptureResult(partial, retryPlan, {
sent: 2,
queued: 0,
failed: 0,
});
assert.equal(complete.lastTurnId, "turn-002");
assert.equal(complete.pendingPrompt, null);
});