diff --git a/src/cli/doctor-diagnostics.ts b/src/cli/doctor-diagnostics.ts index 8cc84f7845..b7bea3868f 100644 --- a/src/cli/doctor-diagnostics.ts +++ b/src/cli/doctor-diagnostics.ts @@ -16,7 +16,14 @@ // agentmemory doctor --all # apply every available fix without prompting (CI) // agentmemory doctor --dry-run # show what each fix WOULD do; execute nothing -import { detectLlmProviderKind, embeddingOptInHint, LLM_PROVIDER_KEYS, llmOptInHint, parseEnvContent } from "../config.js"; +import { + detectLlmProviderKind, + embeddingOptInHint, + isRealProviderKey, + LLM_PROVIDER_KEYS, + llmOptInHint, + parseEnvContent, +} from "../config.js"; export type DiagnosticStatus = { ok: boolean; @@ -91,17 +98,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", @@ -115,25 +111,12 @@ export const parseEnvFile = parseEnvContent; /** 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)); } /** @@ -210,7 +193,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") { const hint = llmOptInHint(env); if (hint) return { ok: false, detail: hint }; diff --git a/src/config.ts b/src/config.ts index 53823f19c7..4841361beb 100644 --- a/src/config.ts +++ b/src/config.ts @@ -86,6 +86,31 @@ 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 // otherwise only consumed via getMergedEnv(), which the many modules that // read raw process.env["X"] never call — so .env-only values were silently @@ -152,7 +177,7 @@ function selectedLlmProviderValue(env: Record): stri } function llmProviderHasKey(env: Record, name: LlmProviderName): boolean { - return LLM_PROVIDER_KEYS[name].some((k) => hasRealValue(env[k])); + return LLM_PROVIDER_KEYS[name].some((k) => isRealProviderKey(env, k)); } export function envFileLabel(path: string = ENV_FILE): string { @@ -174,7 +199,7 @@ export function llmOptInHint(env: Record = getMerged if (env["AGENTMEMORY_ALLOW_AGENT_SDK"] === "true") return null; const withKey = LLM_PROVIDER_NAMES.filter((name) => llmProviderHasKey(env, name)); if (withKey.length === 0) return null; - const keys = withKey.flatMap((name) => LLM_PROVIDER_KEYS[name].filter((k) => hasRealValue(env[k]))); + const keys = withKey.flatMap((name) => LLM_PROVIDER_KEYS[name].filter((k) => isRealProviderKey(env, k))); return `Found ${keys.join(", ")}, but agentmemory sends nothing to an LLM provider until you choose one for it. To turn on LLM summaries and compression, add AGENTMEMORY_LLM_PROVIDER=${withKey[0]} to ${envFileLabel()}.`; } @@ -220,7 +245,7 @@ function detectProvider(env: Record): ProviderConfig { baseURL: env["ANTHROPIC_BASE_URL"], }; case "gemini": - if (!hasRealValue(env["GEMINI_API_KEY"])) { + if (!hasRealKey(env["GEMINI_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", @@ -317,6 +342,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"; } 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/cli-doctor-fixes.test.ts b/test/cli-doctor-fixes.test.ts index 90d88d94f5..37428eebac 100644 --- a/test/cli-doctor-fixes.test.ts +++ b/test/cli-doctor-fixes.test.ts @@ -266,7 +266,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( @@ -276,6 +276,21 @@ 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( + { AGENTMEMORY_LLM_PROVIDER: "openai", OPENAI_API_KEY: "xxx" }, + { OPENAI_BASE_URL: "http://localhost:11434/v1" }, + ), + ).toEqual({ ok: true, detail: "found: OPENAI_API_KEY" }); + expect( + await statusFor( + { AGENTMEMORY_LLM_PROVIDER: "openai", 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 () => { diff --git a/test/provider-placeholder-keys.test.ts b/test/provider-placeholder-keys.test.ts new file mode 100644 index 0000000000..1066fd0a24 --- /dev/null +++ b/test/provider-placeholder-keys.test.ts @@ -0,0 +1,261 @@ +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", "ANTHROPIC_API_KEY", "sk-ant-..."], + ["openai", "OPENAI_API_KEY", "sk-..."], + ["openrouter", "OPENROUTER_API_KEY", "changeme"], + ["minimax", "MINIMAX_API_KEY", "your-key-here"], + ["gemini", "GEMINI_API_KEY", "xxxx-xxxx"], + ["gemini", "GOOGLE_API_KEY", "your-key-here"], + ["openrouter", "OPENROUTER_API_KEY", "CHANGEME"], + ["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; + const { loadConfig, detectLlmProviderKind, llmOptInHint } = await import("../src/config.js"); + + expect(loadConfig().provider.provider).toBe("noop"); + expect(detectLlmProviderKind()).toBe("noop"); + expect(llmOptInHint()).toContain(`AGENTMEMORY_LLM_PROVIDER=${provider} is set, but`); + }); + + it("does not offer a provider whose only key is a placeholder", async () => { + process.env["ANTHROPIC_API_KEY"] = "sk-ant-..."; + process.env["GEMINI_API_KEY"] = "your-key-here"; + process.env["GOOGLE_API_KEY"] = "AIzaRealKey123"; + const { llmOptInHint } = await import("../src/config.js"); + + const hint = llmOptInHint(); + expect(hint).toContain("Found GOOGLE_API_KEY,"); + expect(hint).toContain("AGENTMEMORY_LLM_PROVIDER=gemini"); + expect(hint).not.toContain("ANTHROPIC_API_KEY"); + expect(hint).not.toContain("GEMINI_API_KEY"); + + delete process.env["GOOGLE_API_KEY"]; + expect(llmOptInHint()).toBeNull(); + }); + + 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["AGENTMEMORY_LLM_PROVIDER"] = "openai"; + 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.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_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 () => { + process.env["AGENTMEMORY_LLM_PROVIDER"] = "openai"; + 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["AGENTMEMORY_LLM_PROVIDER"] = "openai"; + 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["AGENTMEMORY_LLM_PROVIDER"] = "openai"; + 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["AGENTMEMORY_LLM_PROVIDER"] = "anthropic"; + 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.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(provider); + }); + + 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"; + 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"), + ); + }); +});