@agentmemory/agentmemory 0.9.16 → 0.9.17

package/dist/index.mjs

@@ -68,6 +68,12 @@ function hasRealValue(v) {
 }
 function detectProvider(env) {
 	const maxTokens = parseInt(env["MAX_TOKENS"] || "4096", 10);
+	if (hasRealValue(env["OPENAI_API_KEY"]) && env["OPENAI_API_KEY_FOR_LLM"] !== "false") return {
+		provider: "openai",
+		model: env["OPENAI_MODEL"] || "gpt-4o-mini",
+		maxTokens,
+		baseURL: env["OPENAI_BASE_URL"]
+	};
 	if (hasRealValue(env["MINIMAX_API_KEY"])) return {
 		provider: "minimax",
 		model: env["MINIMAX_MODEL"] || "MiniMax-M2.7",
@@ -93,7 +99,7 @@ function detectProvider(env) {
 		maxTokens
 	};
 	if (!(env["AGENTMEMORY_ALLOW_AGENT_SDK"] === "true")) {
-		process.stderr.write("[agentmemory] No LLM provider key found (ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY, MINIMAX_API_KEY). LLM-backed compression and summarization are DISABLED — using no-op provider. This is the safe default: the agent-sdk fallback used to spawn Claude Agent SDK child sessions which inherit Claude Code's plugin hooks and cause infinite Stop-hook recursion (#149 follow-up). To opt in to the agent-sdk fallback anyway, set both AGENTMEMORY_AUTO_COMPRESS=true AND AGENTMEMORY_ALLOW_AGENT_SDK=true — but be aware it will burn your Claude Pro allocation and may still recurse if you use it from inside Claude Code itself.\n");
+		process.stderr.write("[agentmemory] No LLM provider key found (ANTHROPIC_API_KEY, GEMINI_API_KEY, OPENROUTER_API_KEY, MINIMAX_API_KEY, OPENAI_API_KEY). LLM-backed compression and summarization are DISABLED — using no-op provider. This is the safe default: the agent-sdk fallback used to spawn Claude Agent SDK child sessions which inherit Claude Code's plugin hooks and cause infinite Stop-hook recursion (#149 follow-up). To opt in to the agent-sdk fallback anyway, set both AGENTMEMORY_AUTO_COMPRESS=true AND AGENTMEMORY_ALLOW_AGENT_SDK=true — but be aware it will burn your Claude Pro allocation and may still recurse if you use it from inside Claude Code itself.\n");
 		return {
 			provider: "noop",
 			model: "noop",
@@ -133,7 +139,7 @@ function getEnvVar(key) {
 }
 function detectLlmProviderKind() {
 	const env = getMergedEnv();
-	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"])) return "llm";
+	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"]) && env["OPENAI_API_KEY_FOR_LLM"] !== "false") return "llm";
 	return "noop";
 }
 function loadEmbeddingConfig() {
@@ -215,7 +221,8 @@ const VALID_PROVIDERS = new Set([
 	"gemini",
 	"openrouter",
 	"agent-sdk",
-	"minimax"
+	"minimax",
+	"openai"
 ]);
 function loadFallbackConfig() {
 	const env = getMergedEnv();
@@ -398,6 +405,137 @@ var NoopProvider = class {
 	}
 };
 
+//#endregion
+//#region src/providers/openai.ts
+const DEFAULT_BASE_URL$1 = "https://api.openai.com";
+const DEFAULT_TIMEOUT_MS = 6e4;
+const DEFAULT_AZURE_API_VERSION = "2024-08-01-preview";
+/**
+* OpenAI-compatible LLM provider.
+*
+* Uses raw fetch (no SDK) to support any OpenAI-compatible endpoint:
+*   - OpenAI official
+*   - Azure OpenAI (auto-detected from .openai.azure.com host)
+*   - DeepSeek
+*   - 硅基流动 (SiliconFlow)
+*   - vLLM / LM Studio / Ollama (with OpenAI compatibility layer)
+*   - Any other proxy implementing /v1/chat/completions
+*
+* Required env vars:
+*   OPENAI_API_KEY  — API key
+*
+* Optional:
+*   OPENAI_BASE_URL          — base URL without path (default: https://api.openai.com).
+*                              Azure: https://<resource>.openai.azure.com/openai/deployments/<deployment>
+*   OPENAI_MODEL             — model name (default: gpt-4o-mini)
+*   OPENAI_API_VERSION       — Azure api-version query param (default: 2024-08-01-preview)
+*   OPENAI_TIMEOUT_MS        — outbound fetch timeout in ms (default: 60000)
+*   MAX_TOKENS               — max output tokens (default: from config or 4096)
+*   OPENAI_REASONING_EFFORT  — "low" | "medium" | "high" | "none"
+*                              Passthrough for reasoning models (e.g. Ollama Cloud
+*                              thinking models). Set to "none" to ensure
+*                              message.content is populated instead of only
+*                              message.reasoning.
+*/
+var OpenAIProvider = class {
+	name = "openai";
+	apiKey;
+	model;
+	maxTokens;
+	baseUrl;
+	reasoningEffort;
+	timeoutMs;
+	isAzure;
+	azureApiVersion;
+	constructor(apiKey, model, maxTokens, baseURL) {
+		this.apiKey = apiKey;
+		this.model = model;
+		this.maxTokens = maxTokens;
+		this.baseUrl = (baseURL || getEnvVar("OPENAI_BASE_URL") || DEFAULT_BASE_URL$1).replace(/\/+$/, "");
+		this.reasoningEffort = getEnvVar("OPENAI_REASONING_EFFORT") || void 0;
+		this.timeoutMs = parseTimeout(getEnvVar("OPENAI_TIMEOUT_MS"));
+		this.azureApiVersion = getEnvVar("OPENAI_API_VERSION") || DEFAULT_AZURE_API_VERSION;
+		this.isAzure = detectAzure(this.baseUrl);
+	}
+	async compress(systemPrompt, userPrompt) {
+		return this.call(systemPrompt, userPrompt);
+	}
+	async summarize(systemPrompt, userPrompt) {
+		return this.call(systemPrompt, userPrompt);
+	}
+	buildUrl() {
+		if (this.isAzure) {
+			const sep = this.baseUrl.includes("?") ? "&" : "?";
+			return `${this.baseUrl}/chat/completions${sep}api-version=${encodeURIComponent(this.azureApiVersion)}`;
+		}
+		return `${this.baseUrl}/v1/chat/completions`;
+	}
+	buildHeaders() {
+		if (this.isAzure) return {
+			"Content-Type": "application/json",
+			"api-key": this.apiKey
+		};
+		return {
+			"Content-Type": "application/json",
+			Authorization: `Bearer ${this.apiKey}`
+		};
+	}
+	async call(systemPrompt, userPrompt) {
+		const url = this.buildUrl();
+		const body = {
+			model: this.model,
+			max_tokens: this.maxTokens,
+			messages: [{
+				role: "system",
+				content: systemPrompt
+			}, {
+				role: "user",
+				content: userPrompt
+			}]
+		};
+		if (this.reasoningEffort) body.reasoning_effort = this.reasoningEffort;
+		const ac = new AbortController();
+		const t = setTimeout(() => ac.abort(), this.timeoutMs);
+		let response;
+		try {
+			response = await fetch(url, {
+				method: "POST",
+				headers: this.buildHeaders(),
+				body: JSON.stringify(body),
+				signal: ac.signal
+			});
+		} catch (err) {
+			if (ac.signal.aborted || err instanceof Error && err.name === "AbortError") throw new Error(`OpenAI API request timed out after ${this.timeoutMs}ms — set OPENAI_TIMEOUT_MS to raise the bound or check the provider status.`);
+			throw err;
+		} finally {
+			clearTimeout(t);
+		}
+		if (!response.ok) {
+			const text = await response.text();
+			throw new Error(`OpenAI API error (${response.status}): ${text}`);
+		}
+		const data = await response.json();
+		const message = data.choices?.[0]?.message;
+		const content = message?.content;
+		if (content) return content;
+		const reasoning = message?.reasoning;
+		if (reasoning) return reasoning;
+		throw new Error(`OpenAI returned unexpected response: ${JSON.stringify(data).slice(0, 200)}`);
+	}
+};
+function parseTimeout(raw) {
+	if (!raw) return DEFAULT_TIMEOUT_MS;
+	const n = parseInt(raw, 10);
+	return Number.isFinite(n) && n > 0 ? n : DEFAULT_TIMEOUT_MS;
+}
+function detectAzure(baseUrl) {
+	try {
+		return new URL(baseUrl).hostname.endsWith(".openai.azure.com");
+	} catch {
+		return false;
+	}
+}
+
 //#endregion
 //#region src/providers/openrouter.ts
 var OpenRouterProvider = class {
@@ -983,6 +1121,11 @@ function createBaseProvider(config) {
 			return new OpenRouterProvider(geminiKey, config.model, config.maxTokens, "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions");
 		}
 		case "openrouter": return new OpenRouterProvider(requireEnvVar("OPENROUTER_API_KEY"), config.model, config.maxTokens, "https://openrouter.ai/api/v1/chat/completions");
+		case "openai": {
+			const openaiKey = getEnvVar("OPENAI_API_KEY");
+			if (!openaiKey) throw new Error("OPENAI_API_KEY is required for the openai provider");
+			return new OpenAIProvider(openaiKey, config.model, config.maxTokens, config.baseURL);
+		}
 		case "noop": return new NoopProvider();
 		default: return new AgentSDKProvider();
 	}
@@ -5967,7 +6110,7 @@ function registerAutoForgetFunction(sdk, kv) {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.16";
+const VERSION = "0.9.17";
 
 //#endregion
 //#region src/functions/export-import.ts
@@ -6101,7 +6244,8 @@ function registerExportImportFunction(sdk, kv) {
 			"0.9.13",
 			"0.9.14",
 			"0.9.15",
-			"0.9.16"
+			"0.9.16",
+			"0.9.17"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -19676,6 +19820,11 @@ async function main() {
 			serviceName: OTEL_CONFIG.serviceName,
 			serviceVersion: OTEL_CONFIG.serviceVersion,
 			metricsExportIntervalMs: OTEL_CONFIG.metricsExportIntervalMs
+		},
+		telemetry: {
+			project_name: "agentmemory",
+			language: "node",
+			framework: "iii-sdk"
 		}
 	});
 	const kv = new StateKV(sdk);
@@ -19835,7 +19984,7 @@ async function main() {
 		console.warn(`[agentmemory] Failed to backfill memories into BM25:`, err);
 	}
 	bootLog(`Ready. ${embeddingProvider ? "Triple-stream (BM25+Vector+Graph)" : "BM25+Graph"} search active.`);
-	bootLog(`REST API: 107 endpoints at http://localhost:${config.restPort}/agentmemory/*`);
+	bootLog(`REST API: 121 endpoints at http://localhost:${config.restPort}/agentmemory/*`);
 	bootLog(`MCP surface (opt-in via \`npx @agentmemory/mcp\`): ${getAllTools().length} tools · 6 resources · 3 prompts`);
 	const viewerServer = startViewerServer(config.restPort + 2, kv, sdk, secret, config.restPort);
 	const autoForgetIntervalMs = parseInt(process.env.AUTO_FORGET_INTERVAL_MS || "3600000", 10);