From 997d95b087918bff58414ec48478cf8747807896 Mon Sep 17 00:00:00 2001 From: Dmitrii Zhukov Date: Mon, 19 Oct 2026 12:28:34 +0000 Subject: [PATCH 1/5] fix(config): treat placeholder provider keys as unset when picking the LLM provider Doctor reports keys such as sk-ant-... or your-key-here as missing, but the daemon accepted any non-empty value. It picked a provider for a placeholder and sent that string with every request, and a placeholder GEMINI_API_KEY shadowed a real GOOGLE_API_KEY. Move the placeholder rule from doctor into config, widen it to any value ending in "..." as .env.example ships them, and apply it both to provider detection and to the key each provider sends. OPENAI_API_KEY keeps any non-empty value while OPENAI_BASE_URL is a plain-http address, because local servers ignore it and the README tells users to put any string there. Signed-off-by: Dmitrii Zhukov --- src/cli/doctor-diagnostics.ts | 30 +--- src/config.ts | 56 +++++-- src/providers/index.ts | 8 +- test/provider-placeholder-keys.test.ts | 193 +++++++++++++++++++++++++ 4 files changed, 242 insertions(+), 45 deletions(-) create mode 100644 test/provider-placeholder-keys.test.ts diff --git a/src/cli/doctor-diagnostics.ts b/src/cli/doctor-diagnostics.ts index 78705d60c8..965a99166c 100644 --- a/src/cli/doctor-diagnostics.ts +++ b/src/cli/doctor-diagnostics.ts @@ -16,6 +16,8 @@ // agentmemory doctor --all # apply every available fix without prompting (CI) // agentmemory doctor --dry-run # show what each fix WOULD do; execute nothing +import { isRealProviderKey } from "../config.js"; + export type DiagnosticStatus = { ok: boolean; /** Short status detail (one line). Shown alongside the check name. */ @@ -75,17 +77,6 @@ export type DiagnosticId = (typeof DIAGNOSTIC_IDS)[number]; // Pure helpers (no I/O) — exported for direct unit testing. // --------------------------------------------------------------------------- -/** Common placeholder values shipped in .env.example. */ -const PLACEHOLDER_VALUES = new Set([ - "", - "your-key-here", - "sk-ant-...", - "sk-...", - "changeme", - "todo", - "xxx", -]); - const PROVIDER_KEY_NAMES = [ "ANTHROPIC_API_KEY", "OPENAI_API_KEY", @@ -118,25 +109,12 @@ export function parseEnvFile(content: string): Record { /** Returns the list of provider keys that look real (non-placeholder). */ export function realProviderKeys(env: Record): string[] { - return PROVIDER_KEY_NAMES.filter((k) => { - const v = (env[k] ?? "").trim(); - if (!v) return false; - if (PLACEHOLDER_VALUES.has(v.toLowerCase())) return false; - // Reject values that are just dots/placeholders like "xxxx-xxxx". - if (/^x+$/i.test(v.replace(/[-_]/g, ""))) return false; - return true; - }); + return PROVIDER_KEY_NAMES.filter((k) => isRealProviderKey(env, k)); } /** Returns the list of provider key NAMES that exist but are placeholders. */ export function placeholderProviderKeys(env: Record): string[] { - return PROVIDER_KEY_NAMES.filter((k) => { - const v = (env[k] ?? "").trim(); - if (!v) return false; - if (PLACEHOLDER_VALUES.has(v.toLowerCase())) return true; - if (/^x+$/i.test(v.replace(/[-_]/g, ""))) return true; - return false; - }); + return PROVIDER_KEY_NAMES.filter((k) => (env[k] ?? "").trim() !== "" && !isRealProviderKey(env, k)); } /** diff --git a/src/config.ts b/src/config.ts index 649917f9d4..0f42b8a2f4 100644 --- a/src/config.ts +++ b/src/config.ts @@ -74,8 +74,29 @@ export function __resetEnvFileCache(): void { envFileCache = undefined; } -function hasRealValue(v: string | undefined): v is string { - return typeof v === "string" && v.trim().length > 0; +const PLACEHOLDER_KEY_VALUES = new Set(["your-key-here", "changeme", "todo"]); + +function hasRealKey(value: string | undefined): boolean { + const v = value?.trim().toLowerCase(); + return ( + !!v && + !v.endsWith("...") && + !PLACEHOLDER_KEY_VALUES.has(v) && + !/^x+$/.test(v.replace(/[-_]/g, "")) + ); +} + +function hasRealOpenAIKey(env: Record): boolean { + return /^http:\/\//i.test(env["OPENAI_BASE_URL"]?.trim() ?? "") + ? !!env["OPENAI_API_KEY"]?.trim() + : hasRealKey(env["OPENAI_API_KEY"]); +} + +export function isRealProviderKey( + env: Record, + key: string, +): boolean { + return key === "OPENAI_API_KEY" ? hasRealOpenAIKey(env) : hasRealKey(env[key]); } // Hydrate ~/.agentmemory/.env into process.env at boot. loadEnvFile() is @@ -118,7 +139,7 @@ function detectProvider(env: Record): ProviderConfig { const maxTokens = parseInt(env["MAX_TOKENS"] || "4096", 10); // OpenAI-compatible: supports OpenAI, DeepSeek, SiliconFlow, Azure, vLLM, LM Studio - if (hasRealValue(env["OPENAI_API_KEY"]) && env["OPENAI_API_KEY_FOR_LLM"] !== "false") { + if (hasRealOpenAIKey(env) && env["OPENAI_API_KEY_FOR_LLM"] !== "false") { const model = env["OPENAI_MODEL"] || "gpt-5.6-luna"; warnIfPremiumModel(env, "OPENAI_MODEL", model); return { @@ -130,7 +151,7 @@ function detectProvider(env: Record): ProviderConfig { } // MiniMax: Anthropic-compatible API, requires raw fetch to avoid SDK stainless headers - if (hasRealValue(env["MINIMAX_API_KEY"])) { + if (hasRealKey(env["MINIMAX_API_KEY"])) { return { provider: "minimax", model: env["MINIMAX_MODEL"] || "MiniMax-M3", @@ -138,7 +159,7 @@ function detectProvider(env: Record): ProviderConfig { }; } - if (hasRealValue(env["ANTHROPIC_API_KEY"])) { + if (hasRealKey(env["ANTHROPIC_API_KEY"])) { return { provider: "anthropic", model: env["ANTHROPIC_MODEL"] || "claude-sonnet-5", @@ -146,8 +167,8 @@ function detectProvider(env: Record): ProviderConfig { baseURL: env["ANTHROPIC_BASE_URL"], }; } - if (hasRealValue(env["GEMINI_API_KEY"]) || hasRealValue(env["GOOGLE_API_KEY"])) { - if (!hasRealValue(env["GEMINI_API_KEY"]) && hasRealValue(env["GOOGLE_API_KEY"])) { + if (hasRealKey(env["GEMINI_API_KEY"]) || hasRealKey(env["GOOGLE_API_KEY"])) { + if (!hasRealKey(env["GEMINI_API_KEY"]) && hasRealKey(env["GOOGLE_API_KEY"])) { process.stderr.write( "[agentmemory] GOOGLE_API_KEY detected — treating as GEMINI_API_KEY. " + "Set GEMINI_API_KEY in ~/.agentmemory/.env to silence this warning.\n", @@ -159,7 +180,7 @@ function detectProvider(env: Record): ProviderConfig { maxTokens, }; } - if (hasRealValue(env["OPENROUTER_API_KEY"])) { + if (hasRealKey(env["OPENROUTER_API_KEY"])) { const model = env["OPENROUTER_MODEL"] || "anthropic/claude-sonnet-5"; warnIfPremiumModel(env, "OPENROUTER_MODEL", model); return { @@ -244,6 +265,11 @@ export function getEnvVar(key: string): string | undefined { return getMergedEnv()[key]; } +export function getProviderKey(key: string): string | undefined { + const env = getMergedEnv(); + return isRealProviderKey(env, key) ? env[key] : undefined; +} + export function isSessionSweepEnabled(): boolean { return getMergedEnv()["AGENTMEMORY_SESSION_SWEEP_ENABLED"] !== "false"; } @@ -286,7 +312,7 @@ export function getStateBackend(): "file" | "redis" { export function getRedisUrl(): string | undefined { const value = getMergedEnv()["AGENTMEMORY_REDIS_URL"]; - return hasRealValue(value) ? value.trim() : undefined; + return value?.trim() || undefined; } export function getAuditRetentionMonths(): number { @@ -304,12 +330,12 @@ export function detectLlmProviderKind( env: Record = getMergedEnv(), ): "llm" | "noop" { if ( - hasRealValue(env["ANTHROPIC_API_KEY"]) || - hasRealValue(env["GEMINI_API_KEY"]) || - hasRealValue(env["GOOGLE_API_KEY"]) || - hasRealValue(env["OPENROUTER_API_KEY"]) || - hasRealValue(env["MINIMAX_API_KEY"]) || - (hasRealValue(env["OPENAI_API_KEY"]) && + hasRealKey(env["ANTHROPIC_API_KEY"]) || + hasRealKey(env["GEMINI_API_KEY"]) || + hasRealKey(env["GOOGLE_API_KEY"]) || + hasRealKey(env["OPENROUTER_API_KEY"]) || + hasRealKey(env["MINIMAX_API_KEY"]) || + (hasRealOpenAIKey(env) && env["OPENAI_API_KEY_FOR_LLM"] !== "false") || env["AGENTMEMORY_ALLOW_AGENT_SDK"] === "true" ) { diff --git a/src/providers/index.ts b/src/providers/index.ts index 4245e03ad1..a2c71ccbd0 100644 --- a/src/providers/index.ts +++ b/src/providers/index.ts @@ -11,12 +11,12 @@ import { OpenAIProvider } from "./openai.js"; import { OpenRouterProvider } from "./openrouter.js"; import { ResilientProvider } from "./resilient.js"; import { FallbackChainProvider } from "./fallback-chain.js"; -import { getEnvVar } from "../config.js"; +import { getEnvVar, getProviderKey } from "../config.js"; export { createEmbeddingProvider, createImageEmbeddingProvider } from "./embedding/index.js"; function requireEnvVar(key: string): string { - const value = getEnvVar(key); + const value = getProviderKey(key); if (!value) { throw new Error( `Missing required environment variable: ${key}. Set it in ~/.agentmemory/.env or as an environment variable.`, @@ -95,7 +95,7 @@ function createBaseProvider(config: ProviderConfig): MemoryProvider { ); case "gemini": { const geminiKey = - getEnvVar("GEMINI_API_KEY") || getEnvVar("GOOGLE_API_KEY"); + getProviderKey("GEMINI_API_KEY") || getProviderKey("GOOGLE_API_KEY"); if (!geminiKey) { throw new Error( "GEMINI_API_KEY (or GOOGLE_API_KEY) is required for the gemini provider", @@ -116,7 +116,7 @@ function createBaseProvider(config: ProviderConfig): MemoryProvider { "https://openrouter.ai/api/v1/chat/completions", ); case "openai": { - const openaiKey = getEnvVar("OPENAI_API_KEY"); + const openaiKey = getProviderKey("OPENAI_API_KEY"); if (!openaiKey) { throw new Error( "OPENAI_API_KEY is required for the openai provider", diff --git a/test/provider-placeholder-keys.test.ts b/test/provider-placeholder-keys.test.ts new file mode 100644 index 0000000000..baa9703941 --- /dev/null +++ b/test/provider-placeholder-keys.test.ts @@ -0,0 +1,193 @@ +import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"; +import { mkdtempSync, readFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; + +const fakeHome = mkdtempSync(join(tmpdir(), "agentmemory-placeholder-")); + +vi.mock("node:os", async (importOriginal) => { + const actual = await importOriginal(); + return { ...actual, homedir: () => fakeHome }; +}); + +const PROVIDER_ENV = /(API_KEY|_KEY$|_TOKEN$|PROVIDER|_BASE_URL$|^AGENTMEMORY_ALLOW_AGENT_SDK$|^OLLAMA)/; + +describe("placeholder provider keys", () => { + const saved: Record = {}; + + beforeEach(() => { + vi.resetModules(); + vi.spyOn(process.stderr, "write").mockImplementation(() => true); + for (const key of Object.keys(process.env)) { + if (PROVIDER_ENV.test(key)) { + saved[key] = process.env[key]; + delete process.env[key]; + } + } + }); + + afterEach(() => { + for (const key of Object.keys(process.env)) { + if (PROVIDER_ENV.test(key)) delete process.env[key]; + } + for (const [key, value] of Object.entries(saved)) { + if (value !== undefined) process.env[key] = value; + } + vi.restoreAllMocks(); + vi.unstubAllGlobals(); + }); + + it.each([ + ["ANTHROPIC_API_KEY", "sk-ant-..."], + ["OPENAI_API_KEY", "sk-..."], + ["OPENROUTER_API_KEY", "changeme"], + ["MINIMAX_API_KEY", "your-key-here"], + ["GEMINI_API_KEY", "xxxx-xxxx"], + ["GOOGLE_API_KEY", "your-key-here"], + ["OPENROUTER_API_KEY", "CHANGEME"], + ["ANTHROPIC_API_KEY", "todo"], + ["GEMINI_API_KEY", "XXXX-XXXX"], + ["OPENROUTER_API_KEY", "sk-or-v1-..."], + ])("does not pick a provider for %s=%s", async (key, value) => { + process.env[key] = value; + const { loadConfig, detectLlmProviderKind } = await import("../src/config.js"); + + expect(loadConfig().provider.provider).toBe("noop"); + expect(detectLlmProviderKind()).toBe("noop"); + }); + + it("rejects every sample value in .env.example", async () => { + const { isRealProviderKey } = await import("../src/config.js"); + const example = readFileSync(join(import.meta.dirname, "..", ".env.example"), "utf-8"); + const samples = [...example.matchAll(/^#\s*([A-Z_]+_API_KEY)=(\S+)/gm)]; + + expect(samples.length).toBeGreaterThan(0); + for (const [, key, value] of samples) { + expect(isRealProviderKey({ [key]: value }, key), `${key}=${value}`).toBe(false); + } + }); + + it("keeps a dummy OpenAI key for a plain-http OPENAI_BASE_URL", async () => { + process.env["OPENAI_API_KEY"] = "xxx"; + process.env["OPENAI_BASE_URL"] = "http://localhost:11434/v1"; + const fetchMock = vi.fn(async () => + new Response(JSON.stringify({ choices: [{ message: { content: "ok" } }] }), { + status: 200, + headers: { "Content-Type": "application/json" }, + }), + ); + vi.stubGlobal("fetch", fetchMock); + const { loadConfig, detectLlmProviderKind } = await import("../src/config.js"); + const { createProvider } = await import("../src/providers/index.js"); + const { realProviderKeys, placeholderProviderKeys } = await import( + "../src/cli/doctor-diagnostics.js" + ); + + const config = loadConfig(); + expect(config.provider.provider).toBe("openai"); + expect(detectLlmProviderKind()).toBe("llm"); + await createProvider(config.provider).compress("system", "user"); + const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit]; + expect(String(url)).toContain("localhost:11434"); + expect((init.headers as Record)["Authorization"]).toBe("Bearer xxx"); + + const env = { OPENAI_API_KEY: "xxx", OPENAI_BASE_URL: "http://localhost:11434/v1" }; + expect(realProviderKeys(env)).toEqual(["OPENAI_API_KEY"]); + expect(placeholderProviderKeys(env)).toEqual([]); + }); + + it("keeps a dummy OpenAI key for a plain-http server on another host", async () => { + process.env["OPENAI_API_KEY"] = "xxx"; + process.env["OPENAI_BASE_URL"] = "http://vllm.lan:8000/v1"; + const { loadConfig, detectLlmProviderKind } = await import("../src/config.js"); + const { realProviderKeys } = await import("../src/cli/doctor-diagnostics.js"); + + expect(loadConfig().provider.provider).toBe("openai"); + expect(detectLlmProviderKind()).toBe("llm"); + expect( + realProviderKeys({ OPENAI_API_KEY: "xxx", OPENAI_BASE_URL: "http://vllm.lan:8000/v1" }), + ).toEqual(["OPENAI_API_KEY"]); + }); + + it("keeps a sample OpenAI key for a plain-http OPENAI_BASE_URL", async () => { + process.env["OPENAI_API_KEY"] = "sk-..."; + process.env["OPENAI_BASE_URL"] = "http://localhost:11434/v1"; + const { loadConfig, detectLlmProviderKind } = await import("../src/config.js"); + const { realProviderKeys } = await import("../src/cli/doctor-diagnostics.js"); + + expect(loadConfig().provider.provider).toBe("openai"); + expect(detectLlmProviderKind()).toBe("llm"); + expect( + realProviderKeys({ OPENAI_API_KEY: "sk-...", OPENAI_BASE_URL: "http://localhost:11434/v1" }), + ).toEqual(["OPENAI_API_KEY"]); + }); + + it("does not keep a placeholder OpenAI key for an https OPENAI_BASE_URL", async () => { + process.env["OPENAI_API_KEY"] = "sk-..."; + process.env["OPENAI_BASE_URL"] = "https://api.openai.com"; + const { loadConfig, detectLlmProviderKind } = await import("../src/config.js"); + const { placeholderProviderKeys } = await import("../src/cli/doctor-diagnostics.js"); + + expect(loadConfig().provider.provider).toBe("noop"); + expect(detectLlmProviderKind()).toBe("noop"); + expect( + placeholderProviderKeys({ OPENAI_API_KEY: "sk-...", OPENAI_BASE_URL: "https://api.openai.com" }), + ).toEqual(["OPENAI_API_KEY"]); + }); + + it("keeps OPENAI_BASE_URL from excusing other placeholder keys", async () => { + process.env["ANTHROPIC_API_KEY"] = "sk-ant-..."; + process.env["OPENAI_BASE_URL"] = "http://localhost:11434/v1"; + const { loadConfig, detectLlmProviderKind } = await import("../src/config.js"); + const { placeholderProviderKeys } = await import("../src/cli/doctor-diagnostics.js"); + + expect(loadConfig().provider.provider).toBe("noop"); + expect(detectLlmProviderKind()).toBe("noop"); + expect( + placeholderProviderKeys({ ANTHROPIC_API_KEY: "sk-ant-...", OPENAI_BASE_URL: "http://localhost:11434/v1" }), + ).toEqual(["ANTHROPIC_API_KEY"]); + }); + + it.each([ + ["anthropic", "ANTHROPIC_API_KEY", "sk-ant-..."], + ["minimax", "MINIMAX_API_KEY", "changeme"], + ["openrouter", "OPENROUTER_API_KEY", "sk-or-..."], + ["openai", "OPENAI_API_KEY", "sk-..."], + ] as const)("does not build the %s provider from a placeholder %s", async (provider, key, value) => { + process.env[key] = value; + const { createProvider } = await import("../src/providers/index.js"); + + expect(() => createProvider({ provider, model: "m", maxTokens: 1 })).toThrow(key); + }); + + it("still picks a provider for a real key", async () => { + process.env["ANTHROPIC_API_KEY"] = "sk-ant-api03-abc123"; + const { loadConfig } = await import("../src/config.js"); + + expect(loadConfig().provider.provider).toBe("anthropic"); + }); + + it("sends GOOGLE_API_KEY when GEMINI_API_KEY is a placeholder", async () => { + process.env["GEMINI_API_KEY"] = "your-key-here"; + process.env["GOOGLE_API_KEY"] = "AIzaRealKey123"; + const fetchMock = vi.fn(async () => + new Response(JSON.stringify({ choices: [{ message: { content: "ok" } }] }), { + status: 200, + headers: { "Content-Type": "application/json" }, + }), + ); + vi.stubGlobal("fetch", fetchMock); + const { loadConfig } = await import("../src/config.js"); + const { createProvider } = await import("../src/providers/index.js"); + + const config = loadConfig(); + expect(config.provider.provider).toBe("gemini"); + await createProvider(config.provider).compress("system", "user"); + + const init = fetchMock.mock.calls[0][1] as RequestInit; + expect((init.headers as Record)["Authorization"]).toBe("Bearer AIzaRealKey123"); + expect(process.stderr.write).toHaveBeenCalledWith( + expect.stringContaining("GOOGLE_API_KEY detected"), + ); + }); +}); From a328619ddbd938e59cf8e174e6529848d8af7824 Mon Sep 17 00:00:00 2001 From: Dmitrii Zhukov Date: Tue, 27 Oct 2026 09:13:14 +0000 Subject: [PATCH 2/5] refactor(doctor): drop the placeholder strip now that provider detection skips placeholders detectLlmProviderKind already treats placeholder keys as unset, so deleting them before the check changed nothing. The test title claimed the daemon disagrees, which is no longer true. Signed-off-by: Dmitrii Zhukov --- src/cli/doctor-diagnostics.ts | 1 - test/cli-doctor-fixes.test.ts | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/src/cli/doctor-diagnostics.ts b/src/cli/doctor-diagnostics.ts index ebbb7f5cb1..b2b5d2dfaa 100644 --- a/src/cli/doctor-diagnostics.ts +++ b/src/cli/doctor-diagnostics.ts @@ -170,7 +170,6 @@ export function buildDiagnostics(effects: DoctorEffects): Diagnostic[] { for (const [k, v] of Object.entries(effects.processEnv())) { if (v !== undefined) env[k] = v; } - for (const k of placeholderProviderKeys(env)) delete env[k]; if (detectLlmProviderKind(env) !== "llm") { return { ok: false, diff --git a/test/cli-doctor-fixes.test.ts b/test/cli-doctor-fixes.test.ts index 414835175e..63bdf54c38 100644 --- a/test/cli-doctor-fixes.test.ts +++ b/test/cli-doctor-fixes.test.ts @@ -263,7 +263,7 @@ describe("doctor v2 diagnostic catalog", () => { ).toEqual({ ok: true, detail: "agent-sdk fallback, no API key" }); }); - it("treats a placeholder exported in the environment as missing, unlike the daemon", async () => { + it("treats a placeholder exported in the environment as missing, like the daemon", async () => { expect( ( await statusFor( From 958c6e95e0dc864442959b34657718bf4b3cf3e7 Mon Sep 17 00:00:00 2001 From: Dmitrii Zhukov Date: Tue, 27 Oct 2026 09:26:24 +0000 Subject: [PATCH 3/5] fix(doctor): pass OPENAI_BASE_URL to the per-key provider check The plain-http exception for OPENAI_API_KEY depends on OPENAI_BASE_URL, so without it a local-server key like xxx was dropped and doctor reported the agent-sdk fallback while the daemon picked openai. Signed-off-by: Dmitrii Zhukov --- src/cli/doctor-diagnostics.ts | 1 + test/cli-doctor-fixes.test.ts | 9 +++++++++ 2 files changed, 10 insertions(+) diff --git a/src/cli/doctor-diagnostics.ts b/src/cli/doctor-diagnostics.ts index b2b5d2dfaa..7707f05b59 100644 --- a/src/cli/doctor-diagnostics.ts +++ b/src/cli/doctor-diagnostics.ts @@ -183,6 +183,7 @@ export function buildDiagnostics(effects: DoctorEffects): Diagnostic[] { detectLlmProviderKind({ [k]: env[k], OPENAI_API_KEY_FOR_LLM: env.OPENAI_API_KEY_FOR_LLM, + OPENAI_BASE_URL: env.OPENAI_BASE_URL, }) === "llm", ); const fromEnv = real.filter((k) => file[k] !== env[k]); diff --git a/test/cli-doctor-fixes.test.ts b/test/cli-doctor-fixes.test.ts index 63bdf54c38..5f07222eb8 100644 --- a/test/cli-doctor-fixes.test.ts +++ b/test/cli-doctor-fixes.test.ts @@ -273,6 +273,15 @@ describe("doctor v2 diagnostic catalog", () => { ).ok, ).toBe(false); }); + + it("names a placeholder OpenAI key behind a plain-http base URL, like the daemon", async () => { + expect( + await statusFor({ OPENAI_API_KEY: "xxx" }, { OPENAI_BASE_URL: "http://localhost:11434/v1" }), + ).toEqual({ ok: true, detail: "found: OPENAI_API_KEY" }); + expect( + await statusFor({ OPENAI_API_KEY: "xxx", OPENAI_BASE_URL: "http://localhost:11434/v1" }, {}), + ).toEqual({ ok: true, detail: "found: OPENAI_API_KEY" }); + }); }); it("engine-version-mismatch fails when iii reports the wrong version", async () => { From 4faf5317d7f02343f3230012c126d5f9fc721fda Mon Sep 17 00:00:00 2001 From: Dmitrii Zhukov Date: Wed, 4 Nov 2026 09:28:49 +0000 Subject: [PATCH 4/5] test(config): pin the empty key behind a plain-http base URL, both real Gemini keys and blank keys The plain-http rule counts only a non-empty OPENAI_API_KEY, the Gemini provider prefers GEMINI_API_KEY without a warning when both keys are real, and a blank or space-padded key is not real; each had a surviving mutant. Signed-off-by: Dmitrii Zhukov --- test/provider-placeholder-keys.test.ts | 39 ++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/test/provider-placeholder-keys.test.ts b/test/provider-placeholder-keys.test.ts index 4244d7e469..cfae1c11b9 100644 --- a/test/provider-placeholder-keys.test.ts +++ b/test/provider-placeholder-keys.test.ts @@ -48,6 +48,8 @@ describe("placeholder provider keys", () => { ["anthropic", "ANTHROPIC_API_KEY", "todo"], ["gemini", "GEMINI_API_KEY", "XXXX-XXXX"], ["openrouter", "OPENROUTER_API_KEY", "sk-or-v1-..."], + ["anthropic", "ANTHROPIC_API_KEY", " "], + ["anthropic", "ANTHROPIC_API_KEY", "sk-ant-... "], ])("runs zero-LLM when %s is chosen but %s=%s", async (provider, key, value) => { process.env["AGENTMEMORY_LLM_PROVIDER"] = provider; process.env[key] = value; @@ -115,6 +117,18 @@ describe("placeholder provider keys", () => { expect(placeholderProviderKeys(env)).toEqual([]); }); + it("does not count a missing OpenAI key behind a plain-http OPENAI_BASE_URL", async () => { + process.env["AGENTMEMORY_LLM_PROVIDER"] = "openai"; + process.env["OPENAI_BASE_URL"] = "http://localhost:11434/v1"; + const { loadConfig, detectLlmProviderKind, llmOptInHint } = await import("../src/config.js"); + const { realProviderKeys } = await import("../src/cli/doctor-diagnostics.js"); + + expect(loadConfig().provider.provider).toBe("noop"); + expect(detectLlmProviderKind()).toBe("noop"); + expect(llmOptInHint()).toContain("OPENAI_API_KEY is not"); + expect(realProviderKeys({ OPENAI_BASE_URL: "http://localhost:11434/v1" })).toEqual([]); + }); + it("keeps a dummy OpenAI key for a plain-http server on another host", async () => { process.env["AGENTMEMORY_LLM_PROVIDER"] = "openai"; process.env["OPENAI_API_KEY"] = "xxx"; @@ -191,6 +205,31 @@ describe("placeholder provider keys", () => { expect(loadConfig().provider.provider).toBe("anthropic"); }); + it("sends GEMINI_API_KEY without a warning when both Gemini keys are real", async () => { + process.env["AGENTMEMORY_LLM_PROVIDER"] = "gemini"; + process.env["GEMINI_API_KEY"] = "AIzaGeminiKey456"; + process.env["GOOGLE_API_KEY"] = "AIzaRealKey123"; + const fetchMock = vi.fn(async () => + new Response(JSON.stringify({ choices: [{ message: { content: "ok" } }] }), { + status: 200, + headers: { "Content-Type": "application/json" }, + }), + ); + vi.stubGlobal("fetch", fetchMock); + const { loadConfig } = await import("../src/config.js"); + const { createProvider } = await import("../src/providers/index.js"); + + const config = loadConfig(); + expect(config.provider.provider).toBe("gemini"); + await createProvider(config.provider).compress("system", "user"); + + const init = fetchMock.mock.calls[0][1] as RequestInit; + expect((init.headers as Record)["Authorization"]).toBe("Bearer AIzaGeminiKey456"); + expect(process.stderr.write).not.toHaveBeenCalledWith( + expect.stringContaining("GOOGLE_API_KEY detected"), + ); + }); + it("sends GOOGLE_API_KEY when GEMINI_API_KEY is a placeholder", async () => { process.env["AGENTMEMORY_LLM_PROVIDER"] = "gemini"; process.env["GEMINI_API_KEY"] = "your-key-here"; From c137db61825dc6816a036e737a9067985e348a4a Mon Sep 17 00:00:00 2001 From: Dmitrii Zhukov Date: Wed, 4 Nov 2026 09:39:53 +0000 Subject: [PATCH 5/5] test(config): pin an empty OpenAI key behind a plain-http base URL and a real key starting with x An empty or blank OPENAI_API_KEY next to a plain-http base URL is not a key, and a real key such as xai-... is not taken for the xxxx placeholder; both had a surviving mutant. Signed-off-by: Dmitrii Zhukov --- test/provider-placeholder-keys.test.ts | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/test/provider-placeholder-keys.test.ts b/test/provider-placeholder-keys.test.ts index cfae1c11b9..1066fd0a24 100644 --- a/test/provider-placeholder-keys.test.ts +++ b/test/provider-placeholder-keys.test.ts @@ -117,16 +117,17 @@ describe("placeholder provider keys", () => { expect(placeholderProviderKeys(env)).toEqual([]); }); - it("does not count a missing OpenAI key behind a plain-http OPENAI_BASE_URL", async () => { + it.each([undefined, "", " "])("does not count OPENAI_API_KEY=%j behind a plain-http OPENAI_BASE_URL", async (key) => { process.env["AGENTMEMORY_LLM_PROVIDER"] = "openai"; process.env["OPENAI_BASE_URL"] = "http://localhost:11434/v1"; + if (key !== undefined) process.env["OPENAI_API_KEY"] = key; const { loadConfig, detectLlmProviderKind, llmOptInHint } = await import("../src/config.js"); const { realProviderKeys } = await import("../src/cli/doctor-diagnostics.js"); expect(loadConfig().provider.provider).toBe("noop"); expect(detectLlmProviderKind()).toBe("noop"); expect(llmOptInHint()).toContain("OPENAI_API_KEY is not"); - expect(realProviderKeys({ OPENAI_BASE_URL: "http://localhost:11434/v1" })).toEqual([]); + expect(realProviderKeys({ OPENAI_API_KEY: key ?? "", OPENAI_BASE_URL: "http://localhost:11434/v1" })).toEqual([]); }); it("keeps a dummy OpenAI key for a plain-http server on another host", async () => { @@ -197,12 +198,15 @@ describe("placeholder provider keys", () => { expect(() => createProvider({ provider, model: "m", maxTokens: 1 })).toThrow(key); }); - it("still uses the chosen provider with a real key", async () => { - process.env["AGENTMEMORY_LLM_PROVIDER"] = "anthropic"; - process.env["ANTHROPIC_API_KEY"] = "sk-ant-api03-abc123"; + it.each([ + ["anthropic", "ANTHROPIC_API_KEY", "sk-ant-api03-abc123"], + ["openai", "OPENAI_API_KEY", "xai-abc123def"], + ] as const)("still uses the chosen %s provider with a real %s", async (provider, key, value) => { + process.env["AGENTMEMORY_LLM_PROVIDER"] = provider; + process.env[key] = value; const { loadConfig } = await import("../src/config.js"); - expect(loadConfig().provider.provider).toBe("anthropic"); + expect(loadConfig().provider.provider).toBe(provider); }); it("sends GEMINI_API_KEY without a warning when both Gemini keys are real", async () => {