Skip to content

Self-evolving Context Database for AI Agents. Unify Agent Memory, Knowledge RAG and Skills.

7.3 KB
Raw Blame
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);
});