chore: import upstream snapshot with attribution

tests/unit/compression/llm-compressor-engine.test.ts

@@ -0,0 +1,110 @@
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  llmCompressorEngine,
+  setLlmCompressorBackend,
+  type LlmCompressorBackend,
+} from "../../../open-sse/services/compression/engines/llm/index.ts";
+
+// T05/C3 — opt-in LLM-tier compressor. Default-off / no-op; fail-open; code & system protected.
+
+// A fake backend that halves prose length (always shorter for len >= 2).
+const halveBackend: LlmCompressorBackend = async (text) =>
+  text.slice(0, Math.max(1, Math.floor(text.length / 2)));
+
+const throwingBackend: LlmCompressorBackend = async () => {
+  throw new Error("backend boom");
+};
+
+function body(messages: unknown[]) {
+  return { messages } as Record<string, unknown>;
+}
+
+afterEach(() => setLlmCompressorBackend(null));
+
+describe("llmCompressorEngine (T05/C3)", () => {
+  it("is a pass-through with the default (no-op) backend even when enabled", async () => {
+    const input = body([{ role: "user", content: "some prose that could be compressed" }]);
+    const out = await llmCompressorEngine.applyAsync!(input, {
+      stepConfig: { enabled: true, minTokens: 0 },
+    });
+    assert.equal(out.compressed, false);
+    assert.equal(out.body, input, "default no-op backend must not mutate the body");
+  });
+
+  it("does nothing when not enabled, even with a compressing backend", async () => {
+    setLlmCompressorBackend(halveBackend);
+    const input = body([{ role: "user", content: "lots of prose here to compress" }]);
+    const off = await llmCompressorEngine.applyAsync!(input, { stepConfig: { minTokens: 0 } });
+    assert.equal(off.compressed, false);
+    assert.equal(off.body, input);
+  });
+
+  it("compresses prose when enabled with a real backend, protecting code + system messages", async () => {
+    setLlmCompressorBackend(halveBackend);
+    const code = "```js\nconst secret = 42;\n```";
+    const input = body([
+      { role: "system", content: "You are a careful assistant. Do not change me." },
+      {
+        role: "user",
+        content: `Here is a long explanation in prose.\n\n${code}\n\nAnd more prose after.`,
+      },
+    ]);
+    const out = await llmCompressorEngine.applyAsync!(input, {
+      stepConfig: { enabled: true, minTokens: 0 },
+    });
+    assert.equal(out.compressed, true);
+    const msgs = (out.body as { messages: Array<{ role: string; content: string }> }).messages;
+    // System message untouched.
+    assert.equal(msgs[0].content, "You are a careful assistant. Do not change me.");
+    // The fenced code block survives verbatim (never sent to the backend).
+    assert.ok(msgs[1].content.includes(code), "code block must be preserved verbatim");
+    // The user message got shorter overall.
+    assert.ok(msgs[1].content.length < (input.messages as { content: string }[])[1].content.length);
+  });
+
+  it("fail-opens: a throwing backend leaves the body unchanged", async () => {
+    setLlmCompressorBackend(throwingBackend);
+    const input = body([{ role: "user", content: "prose that the backend will choke on" }]);
+    const out = await llmCompressorEngine.applyAsync!(input, {
+      stepConfig: { enabled: true, minTokens: 0 },
+    });
+    assert.equal(out.compressed, false);
+    assert.equal(
+      (out.body as { messages: { content: string }[] }).messages[0].content,
+      "prose that the backend will choke on"
+    );
+  });
+
+  it("respects the minTokens floor (skips small prompts)", async () => {
+    setLlmCompressorBackend(halveBackend);
+    const input = body([{ role: "user", content: "tiny" }]);
+    const out = await llmCompressorEngine.applyAsync!(input, {
+      stepConfig: { enabled: true, minTokens: 2000 },
+    });
+    assert.equal(out.compressed, false);
+  });
+
+  it("sync apply is always a no-op pass-through", () => {
+    const input = body([{ role: "user", content: "anything" }]);
+    const out = llmCompressorEngine.apply(input);
+    assert.equal(out.compressed, false);
+    assert.equal(out.body, input);
+  });
+
+  it("validateConfig accepts valid config and rejects bad fields", () => {
+    assert.equal(llmCompressorEngine.validateConfig({ enabled: false }).valid, true);
+    assert.equal(
+      llmCompressorEngine.validateConfig({ enabled: true, compressionRate: 0.5, minTokens: 1000 }).valid,
+      true
+    );
+    assert.equal(llmCompressorEngine.validateConfig({ enabled: "yes" }).valid, false);
+    assert.equal(llmCompressorEngine.validateConfig({ compressionRate: 2 }).valid, false);
+    assert.equal(llmCompressorEngine.validateConfig({ minTokens: -1 }).valid, false);
+  });
+
+  it("defaults to disabled in its config schema (opt-in)", () => {
+    const enabledField = llmCompressorEngine.getConfigSchema!().find((f) => f.key === "enabled");
+    assert.equal(enabledField?.defaultValue, false);
+  });
+});