Never stop coding. Free MIT AI gateway: one endpoint, 375 providers (150+ free), 1,400+ models Kimi, Claude, GPT, Gemini, GLM, DeepSeek, MiniMax. Works with Claude Code, Codex, Cursor, OpenCode, Cline & Copilot. Quota-aware auto-fallback, RTK+Caveman compression saves 15-95% tokens, MCP/A2A, Desktop/PWA. Built by 900+ contributors
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
import { describe, it, beforeEach, afterEach, after } from "node:test";
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import type { CavemanOutputModeConfig } from "../../../open-sse/services/compression/types.ts";
const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-compression-db-"));
const ORIGINAL_DATA_DIR = process.env.DATA_DIR;
process.env.DATA_DIR = TEST_DATA_DIR;
const core = await import("../../../src/lib/db/core.ts");
const { getCompressionSettings, updateCompressionSettings } =
await import("../../../src/lib/db/compression.ts");
beforeEach(() => {
core.resetDbInstance();
fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
});
afterEach(() => {
core.resetDbInstance();
});
after(() => {
core.resetDbInstance();
fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
if (ORIGINAL_DATA_DIR === undefined) {
delete process.env.DATA_DIR;
} else {
process.env.DATA_DIR = ORIGINAL_DATA_DIR;
}
});
describe("getCompressionSettings", () => {
it("returns default settings structure", async () => {
const settings = await getCompressionSettings();
assert.equal(typeof settings.enabled, "boolean");
assert.equal(typeof settings.defaultMode, "string");
assert.equal(typeof settings.autoTriggerTokens, "number");
assert.equal(typeof settings.cacheMinutes, "number");
assert.equal(typeof settings.preserveSystemPrompt, "boolean");
assert.equal(typeof settings.comboOverrides, "object");
assert.equal(typeof settings.lite, "object");
assert.equal(typeof settings.ultra, "object");
});
it("has correct default values", async () => {
const settings = await getCompressionSettings();
assert.equal(settings.enabled, false);
assert.equal(settings.defaultMode, "off");
assert.equal(settings.autoTriggerTokens, 0);
assert.equal(settings.cacheMinutes, 5);
assert.equal(settings.preserveSystemPrompt, true);
assert.equal(settings.preserveSystemPromptMode, "always");
assert.deepEqual(settings.liveZone, { enabled: false });
assert.deepEqual(settings.comboOverrides, {});
assert.equal(settings.lite?.compressToolResults, true);
assert.equal(settings.lite?.maxToolLength, undefined);
assert.equal(settings.ultra?.enabled, false);
assert.equal(settings.ultra?.compressionRate, 0.5);
assert.equal(settings.ultra?.minScoreThreshold, 0.3);
assert.equal(settings.ultra?.slmFallbackToAggressive, true);
assert.equal(settings.ultra?.maxTokensPerMessage, 0);
});
});
describe("updateCompressionSettings", () => {
it("updates enabled flag", async () => {
await updateCompressionSettings({ enabled: true } as any);
const settings = await getCompressionSettings();
assert.equal(settings.enabled, true);
// Reset
await updateCompressionSettings({ enabled: false } as any);
});
it("persists the Lite proactive tool-result truncation switch across reload", async () => {
await updateCompressionSettings({ lite: { compressToolResults: false } });
core.resetDbInstance();
const settings = await getCompressionSettings();
assert.equal(settings.lite?.compressToolResults, false);
});
it("persists Lite maxToolLength across reload and keeps the truncation switch", async () => {
await updateCompressionSettings({
lite: { compressToolResults: true, maxToolLength: 8000 },
});
core.resetDbInstance();
const settings = await getCompressionSettings();
assert.equal(settings.lite?.compressToolResults, true);
assert.equal(settings.lite?.maxToolLength, 8000);
});
it("keeps a stored Lite maxToolLength when a later write only toggles truncation", async () => {
await updateCompressionSettings({
lite: { compressToolResults: true, maxToolLength: 8000 },
});
core.resetDbInstance();
await updateCompressionSettings({ lite: { compressToolResults: false } });
core.resetDbInstance();
const settings = await getCompressionSettings();
assert.equal(settings.lite?.compressToolResults, false);
assert.equal(settings.lite?.maxToolLength, 8000);
});
it("clears a stored Lite maxToolLength when the write sends null", async () => {
await updateCompressionSettings({
lite: { compressToolResults: true, maxToolLength: 8000 },
});
core.resetDbInstance();
await updateCompressionSettings({
lite: { compressToolResults: true, maxToolLength: null },
} as Parameters<typeof updateCompressionSettings>[0]);
core.resetDbInstance();
const settings = await getCompressionSettings();
assert.equal(settings.lite?.compressToolResults, true);
assert.equal(settings.lite?.maxToolLength, undefined);
});
describe("a partial cavemanOutputMode write", () => {
const writeThenRead = async (cavemanOutputMode: Partial<CavemanOutputModeConfig>) => {
core.resetDbInstance();
await updateCompressionSettings({ cavemanOutputMode } as Parameters<
typeof updateCompressionSettings
>[0]);
core.resetDbInstance();
return (await getCompressionSettings()).cavemanOutputMode;
};
const seedStoredRow = (value: unknown) =>
core
.getDbInstance()
.prepare("INSERT OR REPLACE INTO key_value (namespace, key, value) VALUES (?, ?, ?)")
.run("compression", "cavemanOutputMode", value);
it("keeps the stored enabled and intensity when it only sends autoClarity", async () => {
await updateCompressionSettings({
cavemanOutputMode: { enabled: true, intensity: "ultra", autoClarity: true },
});
assert.deepEqual(await writeThenRead({ autoClarity: false }), {
enabled: true,
intensity: "ultra",
autoClarity: false,
});
});
it("keeps a stored autoClarity false when it only sends enabled", async () => {
await updateCompressionSettings({
cavemanOutputMode: { enabled: false, intensity: "full", autoClarity: false },
});
assert.deepEqual(await writeThenRead({ enabled: true }), {
enabled: true,
intensity: "full",
autoClarity: false,
});
});
it("applies each sent field over the stored row, and an empty write changes nothing", async () => {
await updateCompressionSettings({
cavemanOutputMode: { enabled: true, intensity: "ultra", autoClarity: false },
});
assert.deepEqual(await writeThenRead({ enabled: false }), {
enabled: false,
intensity: "ultra",
autoClarity: false,
});
assert.deepEqual(await writeThenRead({ autoClarity: true }), {
enabled: false,
intensity: "ultra",
autoClarity: true,
});
assert.deepEqual(await writeThenRead({ enabled: true, intensity: "lite" }), {
enabled: true,
intensity: "lite",
autoClarity: true,
});
assert.deepEqual(await writeThenRead({}), {
enabled: true,
intensity: "lite",
autoClarity: true,
});
});
it("takes each present-but-invalid field from the stored row", async () => {
await updateCompressionSettings({
cavemanOutputMode: { enabled: true, intensity: "ultra", autoClarity: false },
});
const invalid = { enabled: "yes", intensity: "mega", autoClarity: 1 };
assert.deepEqual(
await writeThenRead(invalid as unknown as Partial<CavemanOutputModeConfig>),
{
enabled: true,
intensity: "ultra",
autoClarity: false,
}
);
});
it("keeps the valid fields of a partially populated stored row", async () => {
seedStoredRow(JSON.stringify({ intensity: "ultra", autoClarity: false }));
assert.deepEqual(await writeThenRead({ enabled: true }), {
enabled: true,
intensity: "ultra",
autoClarity: false,
});
});
it("treats a non-text, unparseable, or null stored row as absent", async () => {
seedStoredRow(
Buffer.from(JSON.stringify({ enabled: true, intensity: "ultra", autoClarity: true }))
);
assert.deepEqual(await writeThenRead({ autoClarity: false }), {
enabled: false,
intensity: "lite",
autoClarity: false,
});
seedStoredRow("{not valid json");
assert.deepEqual(await writeThenRead({ enabled: true }), {
enabled: true,
intensity: "lite",
autoClarity: true,
});
seedStoredRow("null");
assert.deepEqual(await writeThenRead({ autoClarity: false }), {
enabled: false,
intensity: "lite",
autoClarity: false,
});
});
});
it("updates defaultMode", async () => {
await updateCompressionSettings({ defaultMode: "lite" } as any);
const settings = await getCompressionSettings();
assert.equal(settings.defaultMode, "lite");
// Reset
await updateCompressionSettings({ defaultMode: "off" } as any);
});
it("round-trips preserveSystemPromptMode and ignores unknown tokens (T05/C5)", async () => {
await updateCompressionSettings({ preserveSystemPromptMode: "never" } as any);
let settings = await getCompressionSettings();
assert.equal(settings.preserveSystemPromptMode, "never");
await updateCompressionSettings({ preserveSystemPromptMode: "whenNoCache" } as any);
settings = await getCompressionSettings();
assert.equal(settings.preserveSystemPromptMode, "whenNoCache");
// An unknown persisted token is rejected on read and falls back to the safe
// default mode ("always"), never crashing the settings load.
await updateCompressionSettings({ preserveSystemPromptMode: "garbage" } as any);
settings = await getCompressionSettings();
assert.equal(settings.preserveSystemPromptMode, "always");
// Reset
await updateCompressionSettings({ preserveSystemPromptMode: "always" } as any);
});
it("updates autoTriggerTokens", async () => {
await updateCompressionSettings({ autoTriggerTokens: 5000 } as any);
const settings = await getCompressionSettings();
assert.equal(settings.autoTriggerTokens, 5000);
// Reset
await updateCompressionSettings({ autoTriggerTokens: 0 } as any);
});
it("round-trips cache-aligned live-zone compression", async () => {
await updateCompressionSettings({ liveZone: { enabled: true } });
let settings = await getCompressionSettings();
assert.deepEqual(settings.liveZone, { enabled: true });
await updateCompressionSettings({ liveZone: { enabled: false } });
settings = await getCompressionSettings();
assert.deepEqual(settings.liveZone, { enabled: false });
});
it("updates multiple settings at once", async () => {
await updateCompressionSettings({
enabled: true,
defaultMode: "lite",
autoTriggerTokens: 1000,
cacheMinutes: 10,
} as any);
const settings = await getCompressionSettings();
assert.equal(settings.enabled, true);
assert.equal(settings.defaultMode, "lite");
assert.equal(settings.autoTriggerTokens, 1000);
assert.equal(settings.cacheMinutes, 10);
// Reset all
await updateCompressionSettings({
enabled: false,
defaultMode: "off",
autoTriggerTokens: 0,
cacheMinutes: 5,
} as any);
});
it("preserves unmodified settings", async () => {
const before = await getCompressionSettings();
await updateCompressionSettings({ enabled: true } as any);
const after = await getCompressionSettings();
assert.equal(after.enabled, true);
assert.equal(after.defaultMode, before.defaultMode);
assert.equal(after.cacheMinutes, before.cacheMinutes);
// Reset
await updateCompressionSettings({ enabled: false } as any);
});
it("updates and normalizes ultra config", async () => {
await updateCompressionSettings({
defaultMode: "ultra",
ultra: {
enabled: true,
compressionRate: 0.25,
minScoreThreshold: 0.4,
slmFallbackToAggressive: false,
modelPath: " /tmp/model.onnx ",
maxTokensPerMessage: 512,
},
} as any);
const settings = await getCompressionSettings();
assert.equal(settings.defaultMode, "ultra");
assert.equal(settings.ultra?.enabled, true);
assert.equal(settings.ultra?.compressionRate, 0.25);
assert.equal(settings.ultra?.minScoreThreshold, 0.4);
assert.equal(settings.ultra?.slmFallbackToAggressive, false);
assert.equal(settings.ultra?.modelPath, "/tmp/model.onnx");
assert.equal(settings.ultra?.maxTokensPerMessage, 512);
});
it("round-trips ultraEngine + ultraSlmPrewarm (Phase 4 B), defaulting off", async () => {
const before = await getCompressionSettings();
assert.equal(before.ultraEngine, "heuristic");
assert.equal(before.ultraSlmPrewarm, false);
await updateCompressionSettings({
ultraEngine: "slm",
ultraSlmPrewarm: true,
} as any);
const after = await getCompressionSettings();
assert.equal(after.ultraEngine, "slm");
assert.equal(after.ultraSlmPrewarm, true);
});
});