@agentmemory/agentmemory 0.9.16 → 0.9.18

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();
@@ -318,6 +325,20 @@ var AnthropicProvider = class {
 	}
 };
 
+//#endregion
+//#region src/providers/_fetch.ts
+function fetchWithTimeout(url, init, timeoutMs) {
+	const parsed = timeoutMs ?? Number.parseInt(getEnvVar("AGENTMEMORY_LLM_TIMEOUT_MS") ?? "60000", 10);
+	const ms = Number.isFinite(parsed) && parsed > 0 ? parsed : 6e4;
+	const ctl = new AbortController();
+	const signal = init.signal ? AbortSignal.any([init.signal, ctl.signal]) : ctl.signal;
+	const t = setTimeout(() => ctl.abort(), ms);
+	return fetch(url, {
+		...init,
+		signal
+	}).finally(() => clearTimeout(t));
+}
+
 //#endregion
 //#region src/providers/minimax.ts
 /**
@@ -353,8 +374,7 @@ var MinimaxProvider = class {
 		return this.call(systemPrompt, userPrompt);
 	}
 	async call(systemPrompt, userPrompt) {
-		const url = `${this.baseUrl}/v1/messages`;
-		const response = await fetch(url, {
+		const response = await fetchWithTimeout(`${this.baseUrl}/v1/messages`, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
@@ -398,6 +418,146 @@ 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 (OpenAI-scoped alias,
+*                              takes precedence over AGENTMEMORY_LLM_TIMEOUT_MS
+*                              for back-compat with the v0.9.17 shipping name).
+*   AGENTMEMORY_LLM_TIMEOUT_MS — outbound fetch timeout in ms shared across all
+*                              raw-fetch LLM + embedding providers. Used when
+*                              OPENAI_TIMEOUT_MS is not set. 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 = resolveTimeout();
+		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;
+		let response;
+		try {
+			response = await fetchWithTimeout(url, {
+				method: "POST",
+				headers: this.buildHeaders(),
+				body: JSON.stringify(body)
+			}, this.timeoutMs);
+		} catch (err) {
+			if (err instanceof Error && err.name === "AbortError") throw new Error(`OpenAI API request timed out after ${this.timeoutMs}ms — set OPENAI_TIMEOUT_MS (or AGENTMEMORY_LLM_TIMEOUT_MS) to raise the bound or check the provider status.`);
+			throw err;
+		}
+		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 resolveTimeout() {
+	const openai = parsePositiveInt(getEnvVar("OPENAI_TIMEOUT_MS"));
+	if (openai !== void 0) return openai;
+	const globalMs = parsePositiveInt(getEnvVar("AGENTMEMORY_LLM_TIMEOUT_MS"));
+	if (globalMs !== void 0) return globalMs;
+	return DEFAULT_TIMEOUT_MS;
+}
+function parsePositiveInt(raw) {
+	if (!raw) return void 0;
+	const trimmed = raw.trim();
+	if (!/^\d+$/.test(trimmed)) return void 0;
+	const n = Number(trimmed);
+	return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+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 {
@@ -420,7 +580,7 @@ var OpenRouterProvider = class {
 		return this.call(systemPrompt, userPrompt);
 	}
 	async call(systemPrompt, userPrompt) {
-		const response = await fetch(this.baseUrl, {
+		const response = await fetchWithTimeout(this.baseUrl, {
 			method: "POST",
 			headers: {
 				"Content-Type": "application/json",
@@ -589,7 +749,7 @@ var GeminiEmbeddingProvider = class {
 		const results = [];
 		for (let i = 0; i < texts.length; i += BATCH_LIMIT) {
 			const chunk = texts.slice(i, i + BATCH_LIMIT);
-			const response = await fetch(`${API_BASE}?key=${this.apiKey}`, {
+			const response = await fetchWithTimeout(`${API_BASE}?key=${this.apiKey}`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({ requests: chunk.map((t) => ({
@@ -678,8 +838,7 @@ var OpenAIEmbeddingProvider = class {
 		return result;
 	}
 	async embedBatch(texts) {
-		const url = `${this.baseUrl}/v1/embeddings`;
-		const response = await fetch(url, {
+		const response = await fetchWithTimeout(`${this.baseUrl}/v1/embeddings`, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${this.apiKey}`,
@@ -714,7 +873,7 @@ var VoyageEmbeddingProvider = class {
 		return result;
 	}
 	async embedBatch(texts) {
-		const response = await fetch(API_URL$2, {
+		const response = await fetchWithTimeout(API_URL$2, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${this.apiKey}`,
@@ -750,7 +909,7 @@ var CohereEmbeddingProvider = class {
 		return result;
 	}
 	async embedBatch(texts) {
-		const response = await fetch(API_URL$1, {
+		const response = await fetchWithTimeout(API_URL$1, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${this.apiKey}`,
@@ -788,7 +947,7 @@ var OpenRouterEmbeddingProvider = class {
 		return result;
 	}
 	async embedBatch(texts) {
-		const response = await fetch(API_URL, {
+		const response = await fetchWithTimeout(API_URL, {
 			method: "POST",
 			headers: {
 				Authorization: `Bearer ${this.apiKey}`,
@@ -983,6 +1142,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();
 	}
@@ -4400,7 +4564,11 @@ function registerContextFunction(sdk, kv, tokenBudget) {
 	sdk.registerFunction("mem::context", async (data) => {
 		const budget = data.budget || tokenBudget;
 		const blocks = [];
-		const [pinnedSlots, profile] = await Promise.all([isSlotsEnabled() ? listPinnedSlots(kv).catch(() => []) : Promise.resolve([]), kv.get(KV.profiles, data.project).catch(() => null)]);
+		const [pinnedSlots, profile, lessons] = await Promise.all([
+			isSlotsEnabled() ? listPinnedSlots(kv).catch(() => []) : Promise.resolve([]),
+			kv.get(KV.profiles, data.project).catch(() => null),
+			kv.list(KV.lessons).catch(() => [])
+		]);
 		const slotContent = renderPinnedContext(pinnedSlots);
 		if (slotContent) blocks.push({
 			type: "memory",
@@ -4424,6 +4592,24 @@ function registerContextFunction(sdk, kv, tokenBudget) {
 				});
 			}
 		}
+		const relevantLessons = lessons.filter((l) => !l.deleted && (!l.project || l.project === data.project)).sort((a, b) => {
+			const scoreA = (a.project === data.project ? 1.5 : 1) * a.confidence;
+			return (b.project === data.project ? 1.5 : 1) * b.confidence - scoreA;
+		}).slice(0, 10);
+		if (relevantLessons.length > 0) {
+			const lessonsContent = `## Lessons Learned\n${relevantLessons.map((l) => `- (${l.confidence.toFixed(2)}) ${l.content}${l.context ? ` — ${l.context}` : ""}`).join("\n")}`;
+			const mostRecent = relevantLessons.reduce((acc, l) => {
+				const t = new Date(l.lastReinforcedAt || l.updatedAt).getTime();
+				return t > acc ? t : acc;
+			}, 0);
+			blocks.push({
+				type: "memory",
+				content: lessonsContent,
+				tokens: estimateTokens$1(lessonsContent),
+				recency: mostRecent,
+				sourceIds: relevantLessons.map((l) => l.id)
+			});
+		}
 		const sessions = (await kv.list(KV.sessions)).filter((s) => s.project === data.project && s.id !== data.sessionId).sort((a, b) => new Date(b.startedAt).getTime() - new Date(a.startedAt).getTime()).slice(0, 10);
 		const summariesPerSession = await Promise.all(sessions.map((s) => kv.get(KV.summaries, s.id).catch(() => null)));
 		const sessionsNeedingObs = [];
@@ -5246,6 +5432,46 @@ const DEFAULTS$1 = {
 	lowImportanceThreshold: 3,
 	maxObservationsPerProject: 1e4
 };
+function isValidRecoveryResult(result) {
+	if (!result || typeof result !== "object") return false;
+	if (!("success" in result)) return true;
+	return result.success !== false;
+}
+function isCompressedObservation(observation) {
+	return "title" in observation && typeof observation.title === "string" && observation.title.length > 0;
+}
+async function recoverStaleSession(sdk, sessionId) {
+	try {
+		const result = await sdk.trigger({
+			function_id: "event::session::stopped",
+			payload: { sessionId }
+		});
+		if (!isValidRecoveryResult(result)) {
+			logger.warn("Stale session recovery failed", {
+				sessionId,
+				result
+			});
+			return false;
+		}
+		return true;
+	} catch (err) {
+		logger.warn("Stale session recovery failed", {
+			sessionId,
+			error: err instanceof Error ? err.message : String(err)
+		});
+		return false;
+	}
+}
+async function runRecoveredSessionConsolidation(sdk) {
+	try {
+		await sdk.trigger({
+			function_id: "mem::consolidate-pipeline",
+			payload: { tier: "all" }
+		});
+	} catch (err) {
+		logger.warn("Recovered session consolidation failed", { error: err instanceof Error ? err.message : String(err) });
+	}
+}
 function registerEvictFunction(sdk, kv) {
 	sdk.registerFunction("mem::evict", async (data) => {
 		const dryRun = data?.dryRun ?? false;
@@ -5264,6 +5490,7 @@ function registerEvictFunction(sdk, kv) {
 			nonLatestMemories: 0,
 			dryRun
 		};
+		let recoveredStaleSessions = 0;
 		const sessions = await kv.list(KV.sessions).catch(() => []);
 		const summaries = await kv.list(KV.summaries).catch(() => []);
 		const summaryIds = new Set(summaries.map((s) => s.sessionId));
@@ -5271,6 +5498,23 @@ function registerEvictFunction(sdk, kv) {
 			if (!session.startedAt) continue;
 			if (now - new Date(session.startedAt).getTime() > cfg.staleSessionDays * MS_PER_DAY$1 && !summaryIds.has(session.id)) if (dryRun) stats.staleSessions++;
 			else {
+				const observations = await kv.list(KV.observations(session.id)).catch((err) => {
+					logger.warn("Stale session observation scan failed", {
+						sessionId: session.id,
+						error: err instanceof Error ? err.message : String(err)
+					});
+					return null;
+				});
+				if (!observations) continue;
+				let recovered = false;
+				if (observations.some(isCompressedObservation)) {
+					recovered = await recoverStaleSession(sdk, session.id);
+					if (!recovered) continue;
+					recoveredStaleSessions++;
+				} else if (observations.length > 0) {
+					logger.warn("Stale session has no compressed observations", { sessionId: session.id });
+					continue;
+				}
 				try {
 					await kv.delete(KV.sessions, session.id);
 					stats.staleSessions++;
@@ -5284,11 +5528,12 @@ function registerEvictFunction(sdk, kv) {
 				}
 				await recordAudit(kv, "delete", "mem::evict", [session.id], {
 					resource: "session",
-					reason: "stale_session_without_summary",
+					reason: recovered ? "stale_session_recovered_then_evicted" : "stale_session_without_summary",
 					dryRun
 				});
 			}
 		}
+		if (!dryRun && recoveredStaleSessions > 0) await runRecoveredSessionConsolidation(sdk);
 		const projectObs = /* @__PURE__ */ new Map();
 		for (const session of sessions) {
 			const compressed = (await kv.list(KV.observations(session.id)).catch(() => [])).filter((o) => o.title);
@@ -5967,7 +6212,7 @@ function registerAutoForgetFunction(sdk, kv) {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.16";
+const VERSION = "0.9.18";
 
 //#endregion
 //#region src/functions/export-import.ts
@@ -6101,7 +6346,9 @@ function registerExportImportFunction(sdk, kv) {
 			"0.9.13",
 			"0.9.14",
 			"0.9.15",
-			"0.9.16"
+			"0.9.16",
+			"0.9.17",
+			"0.9.18"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -19368,7 +19615,38 @@ function registerMcpEndpoints(sdk, kv, secret) {
 
 //#endregion
 //#region src/viewer/server.ts
+function loadViewerFavicon() {
+	const base = dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		join(base, "..", "src", "viewer", "favicon.svg"),
+		join(base, "..", "viewer", "favicon.svg"),
+		join(base, "viewer", "favicon.svg")
+	];
+	for (const path of candidates) try {
+		return readFileSync(path);
+	} catch {}
+	return null;
+}
 const ALLOWED_ORIGINS = (process.env.VIEWER_ALLOWED_ORIGINS || "http://localhost:3111,http://localhost:3113,http://127.0.0.1:3111,http://127.0.0.1:3113").split(",").map((o) => o.trim());
+const ALLOWED_HOSTS_OVERRIDE = (process.env.VIEWER_ALLOWED_HOSTS || "").split(",").map((h) => h.trim().toLowerCase()).filter(Boolean);
+function buildAllowedHosts(origins, listenPort) {
+	const hosts = /* @__PURE__ */ new Set();
+	for (const o of origins) try {
+		const parsed = new URL(o);
+		if (parsed.host) hosts.add(parsed.host.toLowerCase());
+	} catch {}
+	hosts.add(`localhost:${listenPort}`);
+	hosts.add(`127.0.0.1:${listenPort}`);
+	hosts.add(`[::1]:${listenPort}`);
+	for (const h of ALLOWED_HOSTS_OVERRIDE) hosts.add(h);
+	return hosts;
+}
+function isHostAllowed(headerHost, allowed) {
+	if (typeof headerHost !== "string") return false;
+	const lower = headerHost.toLowerCase().trim();
+	if (!lower) return false;
+	return allowed.has(lower);
+}
 function corsHeaders(req) {
 	const origin = req.headers.origin || "";
 	const allowed = ALLOWED_ORIGINS.includes(origin) ? origin : ALLOWED_ORIGINS[0];
@@ -19412,7 +19690,17 @@ const MAX_VIEWER_PORT_RETRIES = 10;
 function startViewerServer(port, _kv, _sdk, secret, restPort) {
 	const resolvedRestPort = restPort ?? port - 2;
 	const requestedPort = port;
+	let allowedHosts = null;
 	const server = createServer(async (req, res) => {
+		if (!allowedHosts) {
+			const addr = server.address();
+			allowedHosts = buildAllowedHosts(ALLOWED_ORIGINS, addr && typeof addr === "object" && "port" in addr ? addr.port : port);
+		}
+		if (!isHostAllowed(req.headers.host, allowedHosts)) {
+			res.writeHead(403, { "Content-Type": "text/plain" });
+			res.end("forbidden host");
+			return;
+		}
 		const raw = req.url || "/";
 		const qIdx = raw.indexOf("?");
 		const pathname = qIdx >= 0 ? raw.slice(0, qIdx) : raw;
@@ -19441,6 +19729,20 @@ function startViewerServer(port, _kv, _sdk, secret, restPort) {
 			res.end("viewer not found");
 			return;
 		}
+		if (method === "GET" && pathname === "/favicon.svg") {
+			const favicon = loadViewerFavicon();
+			if (favicon) {
+				res.writeHead(200, {
+					"Content-Type": "image/svg+xml",
+					"Cache-Control": "public, max-age=3600"
+				});
+				res.end(favicon);
+				return;
+			}
+			res.writeHead(404, { "Content-Type": "text/plain" });
+			res.end("favicon not found");
+			return;
+		}
 		try {
 			await proxyToRestApi(resolvedRestPort, pathname, qs, method, req, res, secret);
 		} catch (err) {
@@ -19676,6 +19978,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 +20142,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);