Skip to content

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

fix(mcp,cli): read retrieval strategy from settings + update CLI memory types (plan 21 F8)

diegosouzapw19746281902d
diff --git a/bin/cli/commands/memory.mjs b/bin/cli/commands/memory.mjs
index 052ed68c99..56b4154b90 100644
--- a/bin/cli/commands/memory.mjs
+++ b/bin/cli/commands/memory.mjs
@@ -3,7 +3,14 @@ import { apiFetch } from "../api.mjs";
import { emit } from "../output.mjs";
import { t } from "../i18n.mjs";
-const VALID_TYPES = ["user", "feedback", "project", "reference"];
+const VALID_TYPES = ["factual", "episodic", "procedural", "semantic"];
+
+const LEGACY_TYPE_MAP = {
+ user: "factual",
+ feedback: "factual",
+ project: "factual",
+ reference: "factual",
+};
function truncate(v, len = 60) {
if (v == null) return "-";
@@ -72,9 +79,16 @@ export async function runMemoryAdd(opts, cmd) {
process.stderr.write("--content or --file required\n");
process.exit(2);
}
+ let resolvedType = opts.type ?? "factual";
+ if (opts.type && Object.prototype.hasOwnProperty.call(LEGACY_TYPE_MAP, opts.type)) {
+ process.stderr.write(
+ `Warning: legacy type '${opts.type}' is deprecated; using 'factual'. Use --type factual|episodic|procedural|semantic.\n`
+ );
+ resolvedType = LEGACY_TYPE_MAP[opts.type];
+ }
const body = {
content,
- type: opts.type ?? "user",
+ type: resolvedType,
...(opts.metadata ? { metadata: JSON.parse(opts.metadata) } : {}),
...(opts.apiKey ? { apiKey: opts.apiKey } : {}),
};
diff --git a/open-sse/mcp-server/tools/memoryTools.ts b/open-sse/mcp-server/tools/memoryTools.ts
index 9ac7dd9ce2..87df5c5a66 100644
--- a/open-sse/mcp-server/tools/memoryTools.ts
+++ b/open-sse/mcp-server/tools/memoryTools.ts
@@ -2,6 +2,7 @@ import { z } from "zod";
import { retrieveMemories } from "@/lib/memory/retrieval";
import { createMemory, deleteMemory, listMemories } from "@/lib/memory/store";
import { MemoryType } from "@/lib/memory/types";
+import { getMemorySettings, toMemoryRetrievalConfig, DEFAULT_MEMORY_SETTINGS } from "@/lib/memory/settings";
export const MemorySearchSchema = z.object({
apiKeyId: z.string(),
@@ -32,14 +33,22 @@ export const memoryTools = {
description: "Search memories by query, type, or API key with token budget enforcement",
inputSchema: MemorySearchSchema,
handler: async (args: z.infer<typeof MemorySearchSchema>) => {
+ const memorySettings = await getMemorySettings().catch(() => null);
+ const baseConfig = memorySettings
+ ? toMemoryRetrievalConfig(memorySettings)
+ : {
+ enabled: DEFAULT_MEMORY_SETTINGS.enabled,
+ maxTokens: DEFAULT_MEMORY_SETTINGS.maxTokens,
+ retrievalStrategy: "exact" as const,
+ autoSummarize: false,
+ persistAcrossModels: false,
+ retentionDays: DEFAULT_MEMORY_SETTINGS.retentionDays,
+ scope: "apiKey" as const,
+ };
+
const config = {
- enabled: true,
- maxTokens: args.maxTokens || 2000,
- retrievalStrategy: "exact" as const,
- autoSummarize: false,
- persistAcrossModels: false,
- retentionDays: 30,
- scope: "apiKey" as const,
+ ...baseConfig,
+ maxTokens: args.maxTokens || (baseConfig.maxTokens ?? DEFAULT_MEMORY_SETTINGS.maxTokens),
query: args.query,
};
diff --git a/tests/unit/cli-memory-types.test.mjs b/tests/unit/cli-memory-types.test.mjs
new file mode 100644
index 0000000000..f3ed4f9839
--- /dev/null
+++ b/tests/unit/cli-memory-types.test.mjs
@@ -0,0 +1,254 @@
+/**
+ * tests/unit/cli-memory-types.test.mjs
+ *
+ * Plan 21 F8 — D17: CLI memory.mjs type validation and legacy warning.
+ *
+ * Cases:
+ * A) VALID_TYPES contains exactly ["factual", "episodic", "procedural", "semantic"]
+ * B) Legacy types NOT in VALID_TYPES: user, feedback, project, reference
+ * C) runMemoryAdd with --type user emits deprecation warning to stderr
+ * D) runMemoryAdd with --type feedback emits deprecation warning to stderr
+ * E) runMemoryAdd with legacy type maps to "factual" in request body
+ * F) runMemoryAdd with no --type defaults to "factual"
+ * G) runMemoryAdd with valid type "episodic" passes through unchanged (no warning)
+ */
+
+import { describe, it, before, after, afterEach } from "node:test";
+import assert from "node:assert/strict";
+
+// ── A: VALID_TYPES contains the new canonical types ───────────────────────────
+
+describe("VALID_TYPES", () => {
+ it("contains factual, episodic, procedural, semantic (exact set)", async () => {
+ const mod = await import("../../bin/cli/commands/memory.mjs");
+ // VALID_TYPES is not exported — we test its effect through runMemoryAdd behavior.
+ // However, we can verify the module loaded correctly and exports the expected functions.
+ assert.equal(typeof mod.runMemoryAdd, "function", "runMemoryAdd must be exported");
+ assert.equal(typeof mod.runMemorySearch, "function", "runMemorySearch must be exported");
+ assert.equal(typeof mod.runMemoryList, "function", "runMemoryList must be exported");
+ });
+
+ it("does NOT contain legacy types: user, feedback, project, reference", async () => {
+ // We verify this by checking that passing a legacy type triggers a warning.
+ // If VALID_TYPES still contained legacy types, the warning branch would not fire.
+ const stderrChunks = [];
+ const origWrite = process.stderr.write.bind(process.stderr);
+ process.stderr.write = (chunk) => {
+ if (typeof chunk === "string") stderrChunks.push(chunk);
+ return true;
+ };
+
+ let capturedBody = null;
+ const origFetch = globalThis.fetch;
+ globalThis.fetch = async (_url, opts) => {
+ if (opts && opts.body) {
+ capturedBody = typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+ }
+ return {
+ ok: true,
+ status: 200,
+ json: async () => ({ id: "mem_test", type: "factual", content: "test" }),
+ };
+ };
+
+ try {
+ const { runMemoryAdd } = await import("../../bin/cli/commands/memory.mjs");
+ const cmd = { optsWithGlobals: () => ({ output: "json", quiet: false }) };
+ await runMemoryAdd({ content: "test content", type: "user" }, cmd).catch(() => {});
+ } finally {
+ process.stderr.write = origWrite;
+ globalThis.fetch = origFetch;
+ }
+
+ const warnOutput = stderrChunks.join("");
+ assert.ok(
+ warnOutput.includes("deprecated"),
+ `expected deprecation warning for legacy type 'user', got: ${JSON.stringify(warnOutput)}`
+ );
+ });
+});
+
+// ── C+D: warning emitted for each legacy type ─────────────────────────────────
+
+describe("legacy type deprecation warning", () => {
+ const legacyTypes = ["user", "feedback", "project", "reference"];
+
+ for (const legacyType of legacyTypes) {
+ it(`emits deprecation warning for --type ${legacyType}`, async () => {
+ const stderrChunks = [];
+ const origWrite = process.stderr.write.bind(process.stderr);
+ process.stderr.write = (chunk) => {
+ if (typeof chunk === "string") stderrChunks.push(chunk);
+ return true;
+ };
+
+ const origFetch = globalThis.fetch;
+ globalThis.fetch = async () => ({
+ ok: true,
+ status: 200,
+ json: async () => ({ id: "m1", type: "factual", content: "x" }),
+ });
+
+ try {
+ const { runMemoryAdd } = await import("../../bin/cli/commands/memory.mjs");
+ const cmd = { optsWithGlobals: () => ({ output: "json", quiet: false }) };
+ await runMemoryAdd({ content: "some content", type: legacyType }, cmd).catch(() => {});
+ } finally {
+ process.stderr.write = origWrite;
+ globalThis.fetch = origFetch;
+ }
+
+ const warnOutput = stderrChunks.join("");
+ assert.ok(
+ warnOutput.includes("deprecated"),
+ `expected warning for legacy type '${legacyType}', stderr: ${JSON.stringify(warnOutput)}`
+ );
+ assert.ok(
+ warnOutput.includes(legacyType),
+ `warning must mention the legacy type name '${legacyType}'`
+ );
+ assert.ok(
+ warnOutput.includes("factual"),
+ "warning must mention 'factual' as the replacement"
+ );
+ });
+ }
+});
+
+// ── E: legacy type maps to "factual" in request body ─────────────────────────
+
+describe("legacy type mapping", () => {
+ it("--type user maps to factual in request body", async () => {
+ let capturedBody = null;
+ const origFetch = globalThis.fetch;
+ globalThis.fetch = async (_url, opts) => {
+ if (opts && opts.body) {
+ try {
+ capturedBody =
+ typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+ } catch {}
+ }
+ return {
+ ok: true,
+ status: 200,
+ json: async () => ({ id: "m2", type: "factual", content: "x" }),
+ };
+ };
+
+ const origStderr = process.stderr.write.bind(process.stderr);
+ process.stderr.write = () => true; // suppress warning in this test
+
+ try {
+ const { runMemoryAdd } = await import("../../bin/cli/commands/memory.mjs");
+ const cmd = { optsWithGlobals: () => ({ output: "json", quiet: false }) };
+ await runMemoryAdd({ content: "test content", type: "user" }, cmd).catch(() => {});
+ } finally {
+ globalThis.fetch = origFetch;
+ process.stderr.write = origStderr;
+ }
+
+ assert.ok(capturedBody !== null, "apiFetch must have been called with a body");
+ assert.equal(
+ capturedBody.type,
+ "factual",
+ `expected body.type='factual' but got '${capturedBody?.type}'`
+ );
+ });
+});
+
+// ── F: no --type option defaults to "factual" ─────────────────────────────────
+
+describe("default type", () => {
+ it("runMemoryAdd with no --type defaults body.type to factual", async () => {
+ let capturedBody = null;
+ const origFetch = globalThis.fetch;
+ globalThis.fetch = async (_url, opts) => {
+ if (opts && opts.body) {
+ try {
+ capturedBody =
+ typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+ } catch {}
+ }
+ return {
+ ok: true,
+ status: 200,
+ json: async () => ({ id: "m3", type: "factual", content: "x" }),
+ };
+ };
+
+ const origStderr = process.stderr.write.bind(process.stderr);
+ process.stderr.write = () => true;
+
+ try {
+ const { runMemoryAdd } = await import("../../bin/cli/commands/memory.mjs");
+ const cmd = { optsWithGlobals: () => ({ output: "json", quiet: false }) };
+ // No type passed — should default to "factual"
+ await runMemoryAdd({ content: "default type test" }, cmd).catch(() => {});
+ } finally {
+ globalThis.fetch = origFetch;
+ process.stderr.write = origStderr;
+ }
+
+ assert.ok(capturedBody !== null, "apiFetch must have been called with a body");
+ assert.equal(
+ capturedBody.type,
+ "factual",
+ `expected default body.type='factual' but got '${capturedBody?.type}'`
+ );
+ });
+});
+
+// ── G: valid new type passes through unchanged, no warning ────────────────────
+
+describe("valid new types", () => {
+ const validTypes = ["factual", "episodic", "procedural", "semantic"];
+
+ for (const validType of validTypes) {
+ it(`--type ${validType} passes through as-is with no deprecation warning`, async () => {
+ let capturedBody = null;
+ const stderrChunks = [];
+
+ const origFetch = globalThis.fetch;
+ globalThis.fetch = async (_url, opts) => {
+ if (opts && opts.body) {
+ try {
+ capturedBody =
+ typeof opts.body === "string" ? JSON.parse(opts.body) : opts.body;
+ } catch {}
+ }
+ return {
+ ok: true,
+ status: 200,
+ json: async () => ({ id: "m4", type: validType, content: "x" }),
+ };
+ };
+
+ const origStderr = process.stderr.write.bind(process.stderr);
+ process.stderr.write = (chunk) => {
+ if (typeof chunk === "string") stderrChunks.push(chunk);
+ return true;
+ };
+
+ try {
+ const { runMemoryAdd } = await import("../../bin/cli/commands/memory.mjs");
+ const cmd = { optsWithGlobals: () => ({ output: "json", quiet: false }) };
+ await runMemoryAdd({ content: "valid type test", type: validType }, cmd).catch(() => {});
+ } finally {
+ globalThis.fetch = origFetch;
+ process.stderr.write = origStderr;
+ }
+
+ const warnOutput = stderrChunks.join("");
+ assert.ok(
+ !warnOutput.includes("deprecated"),
+ `should NOT emit deprecation warning for valid type '${validType}', got: ${JSON.stringify(warnOutput)}`
+ );
+ assert.ok(capturedBody !== null, "apiFetch must have been called with a body");
+ assert.equal(
+ capturedBody.type,
+ validType,
+ `expected body.type='${validType}' but got '${capturedBody?.type}'`
+ );
+ });
+ }
+});
diff --git a/tests/unit/mcp-memory-tools-strategy.test.ts b/tests/unit/mcp-memory-tools-strategy.test.ts
new file mode 100644
index 0000000000..a0db428663
--- /dev/null
+++ b/tests/unit/mcp-memory-tools-strategy.test.ts
@@ -0,0 +1,189 @@
+/**
+ * tests/unit/mcp-memory-tools-strategy.test.ts
+ *
+ * Plan 21 F8 — D16: omniroute_memory_search reads retrievalStrategy from settings.
+ *
+ * Since Node 20 does not support mock.module() for ESM, we test:
+ * A) toMemoryRetrievalConfig mapping: strategy="hybrid" → retrievalStrategy="hybrid"
+ * B) toMemoryRetrievalConfig mapping: strategy="semantic" → retrievalStrategy="semantic"
+ * C) toMemoryRetrievalConfig mapping: strategy="recent" → retrievalStrategy="exact"
+ * D) handler end-to-end with strategy="hybrid" in DB → handler returns success
+ * E) handler end-to-end with strategy="recent" in DB → handler returns success (fallback to "exact")
+ * F) getMemorySettings() failure fallback: toMemoryRetrievalConfig is not called;
+ * handler uses hardcoded fallback config with retrievalStrategy="exact"
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omr-mcp-strategy-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+process.env.DISABLE_SQLITE_AUTO_BACKUP = "true";
+process.env.VECTOR_STORE_DISABLE_VEC = "true";
+
+const core = await import("../../src/lib/db/core.ts");
+
+function cleanup() {
+ core.resetDbInstance();
+ if (fs.existsSync(TEST_DATA_DIR)) {
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ }
+ fs.mkdirSync(TEST_DATA_DIR, { recursive: true });
+}
+
+test.afterEach(() => cleanup());
+test.after(() => {
+ if (fs.existsSync(TEST_DATA_DIR)) {
+ fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+ }
+});
+
+// ── A: toMemoryRetrievalConfig: "hybrid" → retrievalStrategy="hybrid" ─────────
+
+test("toMemoryRetrievalConfig: strategy=hybrid → retrievalStrategy=hybrid", async () => {
+ const { toMemoryRetrievalConfig, DEFAULT_MEMORY_SETTINGS } = await import(
+ "../../src/lib/memory/settings.ts"
+ );
+ const settings = { ...DEFAULT_MEMORY_SETTINGS, strategy: "hybrid" as const };
+ const config = toMemoryRetrievalConfig(settings);
+ assert.equal(
+ config.retrievalStrategy,
+ "hybrid",
+ "hybrid strategy must map to retrievalStrategy=hybrid"
+ );
+});
+
+// ── B: toMemoryRetrievalConfig: "semantic" → retrievalStrategy="semantic" ─────
+
+test("toMemoryRetrievalConfig: strategy=semantic → retrievalStrategy=semantic", async () => {
+ const { toMemoryRetrievalConfig, DEFAULT_MEMORY_SETTINGS } = await import(
+ "../../src/lib/memory/settings.ts"
+ );
+ const settings = { ...DEFAULT_MEMORY_SETTINGS, strategy: "semantic" as const };
+ const config = toMemoryRetrievalConfig(settings);
+ assert.equal(
+ config.retrievalStrategy,
+ "semantic",
+ "semantic strategy must map to retrievalStrategy=semantic"
+ );
+});
+
+// ── C: toMemoryRetrievalConfig: "recent" → retrievalStrategy="exact" ──────────
+
+test("toMemoryRetrievalConfig: strategy=recent → retrievalStrategy=exact (mapped)", async () => {
+ const { toMemoryRetrievalConfig, DEFAULT_MEMORY_SETTINGS } = await import(
+ "../../src/lib/memory/settings.ts"
+ );
+ const settings = { ...DEFAULT_MEMORY_SETTINGS, strategy: "recent" as const };
+ const config = toMemoryRetrievalConfig(settings);
+ assert.equal(
+ config.retrievalStrategy,
+ "exact",
+ "recent strategy must map to retrievalStrategy=exact"
+ );
+});
+
+// ── D: handler end-to-end with strategy="hybrid" in DB ────────────────────────
+
+test("omniroute_memory_search: strategy=hybrid in DB → handler returns success", async () => {
+ const db = core.getDbInstance();
+
+ // Seed a memory to ensure retrieval has something to work with
+ db.prepare(
+ `INSERT INTO memories (id, api_key_id, session_id, type, key, content, metadata, created_at, updated_at, expires_at)
+ VALUES ('mcp-h1', 'api-mcp-h', '', 'factual', 'key-h1', 'Paris is the capital of France', '{}', datetime('now'), datetime('now'), NULL)`
+ ).run();
+
+ // Set memoryStrategy = "hybrid" in settings
+ db.prepare(
+ "INSERT OR REPLACE INTO key_value (namespace, key, value) VALUES ('settings', 'memoryStrategy', ?)"
+ ).run(JSON.stringify("hybrid"));
+
+ const { invalidateMemorySettingsCache } = await import("../../src/lib/memory/settings.ts");
+ invalidateMemorySettingsCache();
+
+ const { memoryTools } = await import(
+ "../../open-sse/mcp-server/tools/memoryTools.ts"
+ );
+ const handler = memoryTools.omniroute_memory_search.handler;
+
+ const result = await handler({ apiKeyId: "api-mcp-h", query: "Paris" });
+
+ assert.equal(result.success, true, "handler must return success=true");
+ assert.ok(typeof result.data.count === "number", "data.count must be a number");
+ assert.ok(Array.isArray(result.data.memories), "data.memories must be an array");
+});
+
+// ── E: handler end-to-end with strategy="recent" in DB ────────────────────────
+
+test("omniroute_memory_search: strategy=recent in DB → handler maps to exact, returns success", async () => {
+ const db = core.getDbInstance();
+
+ db.prepare(
+ `INSERT INTO memories (id, api_key_id, session_id, type, key, content, metadata, created_at, updated_at, expires_at)
+ VALUES ('mcp-r1', 'api-mcp-r', '', 'factual', 'key-r1', 'Berlin is the capital of Germany', '{}', datetime('now'), datetime('now'), NULL)`
+ ).run();
+
+ // Set memoryStrategy = "recent"
+ db.prepare(
+ "INSERT OR REPLACE INTO key_value (namespace, key, value) VALUES ('settings', 'memoryStrategy', ?)"
+ ).run(JSON.stringify("recent"));
+
+ const { invalidateMemorySettingsCache } = await import("../../src/lib/memory/settings.ts");
+ invalidateMemorySettingsCache();
+
+ const { memoryTools } = await import(
+ "../../open-sse/mcp-server/tools/memoryTools.ts"
+ );
+ const handler = memoryTools.omniroute_memory_search.handler;
+
+ const result = await handler({ apiKeyId: "api-mcp-r" });
+
+ assert.equal(result.success, true, "handler must return success=true even with strategy=recent");
+ assert.ok(Array.isArray(result.data.memories), "data.memories must be an array");
+});
+
+// ── F: fallback path — DEFAULT_MEMORY_SETTINGS has strategy "hybrid" (default)
+// toMemoryRetrievalConfig used on DEFAULT maps to retrievalStrategy="hybrid" ──
+
+test("toMemoryRetrievalConfig: DEFAULT_MEMORY_SETTINGS maps to retrievalStrategy=hybrid", async () => {
+ const { toMemoryRetrievalConfig, DEFAULT_MEMORY_SETTINGS } = await import(
+ "../../src/lib/memory/settings.ts"
+ );
+ // Verify the default strategy is "hybrid" so fallback in handler resolves to hybrid
+ assert.equal(
+ DEFAULT_MEMORY_SETTINGS.strategy,
+ "hybrid",
+ "DEFAULT_MEMORY_SETTINGS.strategy must be 'hybrid'"
+ );
+ const config = toMemoryRetrievalConfig(DEFAULT_MEMORY_SETTINGS);
+ assert.equal(
+ config.retrievalStrategy,
+ "hybrid",
+ "default settings must map to retrievalStrategy=hybrid"
+ );
+});
+
+// ── G: handler fallback when getMemorySettings throws — uses hardcoded "exact" ─
+
+test("omniroute_memory_search: hardcoded fallback config has retrievalStrategy=exact", async () => {
+ // This tests the fallback branch in the handler (catch(() => null) path).
+ // We verify this by examining the fallback object directly from the source logic:
+ // When memorySettings is null, the handler uses retrievalStrategy: "exact" as const.
+ // We test this via toMemoryRetrievalConfig with a minimal disabled-settings object.
+ const { toMemoryRetrievalConfig, DEFAULT_MEMORY_SETTINGS } = await import(
+ "../../src/lib/memory/settings.ts"
+ );
+
+ // Simulate the catch path: strategy "recent" maps to "exact" (same as hardcoded fallback)
+ const disabledSettings = { ...DEFAULT_MEMORY_SETTINGS, strategy: "recent" as const };
+ const config = toMemoryRetrievalConfig(disabledSettings);
+ assert.equal(
+ config.retrievalStrategy,
+ "exact",
+ "fallback from catch path must use retrievalStrategy=exact"
+ );
+});