@agentmemory/agentmemory 0.9.18 → 0.9.19

package/dist/{src-C7vygXCj.mjs → src-2wwYDPGA.mjs}

@@ -1,6 +1,6 @@
 import { a as STREAM, c as jaccardSimilarity, i as KV, n as bootLog, o as fingerprintId, r as logger, s as generateId, t as VERSION } from "./cli.mjs";
 import { a as isManagedImagePath, getImageRefCount, i as getMaxBytes, n as IMAGES_DIR, r as deleteImage, t as withKeyedLock } from "./image-refs-R3tin9MR.mjs";
-import { _ as loadTeamConfig, a as getConsolidationDecayDays, c as isAutoCompressEnabled, d as isGraphExtractionEnabled, f as loadClaudeBridgeConfig, g as loadSnapshotConfig, h as loadFallbackConfig, i as detectLlmProviderKind, l as isConsolidationEnabled, m as loadEmbeddingConfig, n as getVisibleTools, o as getEnvVar, p as loadConfig, r as detectEmbeddingProvider, t as getAllTools, u as isContextInjectionEnabled } from "./tools-registry-BFKFKmYh.mjs";
+import { _ as loadTeamConfig, a as getConsolidationDecayDays, c as isAutoCompressEnabled, d as isGraphExtractionEnabled, f as loadClaudeBridgeConfig, g as loadSnapshotConfig, h as loadFallbackConfig, i as detectLlmProviderKind, l as isConsolidationEnabled, m as loadEmbeddingConfig, n as getVisibleTools, o as getEnvVar, p as loadConfig, r as detectEmbeddingProvider, t as getAllTools, u as isContextInjectionEnabled } from "./tools-registry-Dz8ssuMf.mjs";
 import { createRequire } from "node:module";
 import { execFile } from "node:child_process";
 import { constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
@@ -197,11 +197,63 @@ var NoopProvider = class {
 	}
 };
 
+//#endregion
+//#region src/providers/_openai-shared.ts
+const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com";
+const DEFAULT_AZURE_API_VERSION = "2024-08-01-preview";
+function detectAzure(baseUrl) {
+	try {
+		return new URL(baseUrl).hostname.endsWith(".openai.azure.com");
+	} catch {
+		return false;
+	}
+}
+function azureStyleOf(baseUrl) {
+	try {
+		const u = new URL(baseUrl);
+		if (/\/openai\/deployments\//.test(u.pathname)) return "legacy";
+		return "v1";
+	} catch {
+		return "v1";
+	}
+}
+function legacyAzureUrl(baseUrl, path, apiVersion) {
+	const url = new URL(baseUrl);
+	url.pathname = `${url.pathname.replace(/\/+$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+	url.searchParams.set("api-version", apiVersion);
+	return url.toString();
+}
+function v1AzureUrl(baseUrl, path) {
+	const url = new URL(baseUrl);
+	const route = path.startsWith("/") ? path.slice(1) : path;
+	url.pathname = `${url.pathname.replace(/\/?openai(?:\/v1)?\/?$/, "").replace(/\/+$/, "")}/openai/v1/${route}`;
+	return url.toString();
+}
+function buildChatUrl(baseUrl, isAzure, azureApiVersion) {
+	if (isAzure) return azureStyleOf(baseUrl) === "legacy" ? legacyAzureUrl(baseUrl, "/chat/completions", azureApiVersion) : v1AzureUrl(baseUrl, "/chat/completions");
+	return `${baseUrl}/v1/chat/completions`;
+}
+function buildEmbeddingUrl(baseUrl, isAzure, azureApiVersion) {
+	if (isAzure) return azureStyleOf(baseUrl) === "legacy" ? legacyAzureUrl(baseUrl, "/embeddings", azureApiVersion) : v1AzureUrl(baseUrl, "/embeddings");
+	return `${baseUrl}/v1/embeddings`;
+}
+function buildAuthHeaders(apiKey, isAzure) {
+	if (isAzure) return {
+		"Content-Type": "application/json",
+		"api-key": apiKey
+	};
+	return {
+		"Content-Type": "application/json",
+		Authorization: `Bearer ${apiKey}`
+	};
+}
+function normalizeBaseUrl(raw) {
+	return (raw || DEFAULT_OPENAI_BASE_URL).replace(/\/+$/, "");
+}
+
 //#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.
 *
@@ -248,7 +300,7 @@ var OpenAIProvider = class {
 		this.apiKey = apiKey;
 		this.model = model;
 		this.maxTokens = maxTokens;
-		this.baseUrl = (baseURL || getEnvVar("OPENAI_BASE_URL") || DEFAULT_BASE_URL$1).replace(/\/+$/, "");
+		this.baseUrl = normalizeBaseUrl(baseURL || getEnvVar("OPENAI_BASE_URL"));
 		this.reasoningEffort = getEnvVar("OPENAI_REASONING_EFFORT") || void 0;
 		this.timeoutMs = resolveTimeout();
 		this.azureApiVersion = getEnvVar("OPENAI_API_VERSION") || DEFAULT_AZURE_API_VERSION;
@@ -260,25 +312,8 @@ var OpenAIProvider = class {
 	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 url = buildChatUrl(this.baseUrl, this.isAzure, this.azureApiVersion);
 		const body = {
 			model: this.model,
 			max_tokens: this.maxTokens,
@@ -295,7 +330,7 @@ var OpenAIProvider = class {
 		try {
 			response = await fetchWithTimeout(url, {
 				method: "POST",
-				headers: this.buildHeaders(),
+				headers: buildAuthHeaders(this.apiKey, this.isAzure),
 				body: JSON.stringify(body)
 			}, this.timeoutMs);
 		} catch (err) {
@@ -329,13 +364,6 @@ function parsePositiveInt(raw) {
 	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
@@ -565,7 +593,6 @@ function l2Normalize(vec) {
 
 //#endregion
 //#region src/providers/embedding/openai.ts
-const DEFAULT_BASE_URL = "https://api.openai.com";
 const DEFAULT_MODEL$1 = "text-embedding-3-small";
 /**
 * Known OpenAI embedding model dimensions. Extend as new models ship.
@@ -589,11 +616,20 @@ function resolveDimensions(model, override) {
 /**
 * OpenAI-compatible embedding provider.
 *
+* Shares transport (URL builder, auth header, Azure detection) with
+* the OpenAI LLM provider via `_openai-shared` (#371). Same env knobs
+* pick up automatically: when `OPENAI_BASE_URL` points at an Azure
+* resource (`.openai.azure.com` hostname) the embedding request uses
+* Azure's `/embeddings` path with the `api-version` query param and
+* `api-key` header instead of `Authorization: Bearer`.
+*
 * Required env vars:
 *   OPENAI_API_KEY            — API key
 *
 * Optional:
-*   OPENAI_BASE_URL           — base URL without path (default: https://api.openai.com)
+*   OPENAI_BASE_URL           — base URL without path (default: https://api.openai.com).
+*                               Azure: https://<resource>.openai.azure.com/openai/deployments/<deployment>
+*   OPENAI_API_VERSION        — Azure api-version query param (default: 2024-08-01-preview)
 *   OPENAI_EMBEDDING_MODEL    — model name (default: text-embedding-3-small)
 *   OPENAI_EMBEDDING_DIMENSIONS — override reported dimensions (required for
 *                                 custom / self-hosted models not in the
@@ -605,24 +641,25 @@ var OpenAIEmbeddingProvider = class {
 	apiKey;
 	baseUrl;
 	model;
+	isAzure;
+	azureApiVersion;
 	constructor(apiKey) {
 		this.apiKey = apiKey || getEnvVar("OPENAI_API_KEY") || "";
 		if (!this.apiKey) throw new Error("OPENAI_API_KEY is required");
-		this.baseUrl = getEnvVar("OPENAI_BASE_URL") || DEFAULT_BASE_URL;
+		this.baseUrl = normalizeBaseUrl(getEnvVar("OPENAI_BASE_URL"));
 		this.model = getEnvVar("OPENAI_EMBEDDING_MODEL") || DEFAULT_MODEL$1;
 		this.dimensions = resolveDimensions(this.model, getEnvVar("OPENAI_EMBEDDING_DIMENSIONS"));
+		this.isAzure = detectAzure(this.baseUrl);
+		this.azureApiVersion = getEnvVar("OPENAI_API_VERSION") || DEFAULT_AZURE_API_VERSION;
 	}
 	async embed(text) {
 		const [result] = await this.embedBatch([text]);
 		return result;
 	}
 	async embedBatch(texts) {
-		const response = await fetchWithTimeout(`${this.baseUrl}/v1/embeddings`, {
+		const response = await fetchWithTimeout(buildEmbeddingUrl(this.baseUrl, this.isAzure, this.azureApiVersion), {
 			method: "POST",
-			headers: {
-				Authorization: `Bearer ${this.apiKey}`,
-				"Content-Type": "application/json"
-			},
+			headers: buildAuthHeaders(this.apiKey, this.isAzure),
 			body: JSON.stringify({
 				model: this.model,
 				input: texts
@@ -1154,7 +1191,7 @@ var GraphRetrieval = class {
 		const results = [];
 		const visitedObs = /* @__PURE__ */ new Set();
 		for (const startNode of matchingNodes) {
-			const paths = this.bfsTraversal(startNode, allNodes, allEdges, maxDepth);
+			const paths = this.dijkstraTraversal(startNode, allNodes, allEdges, maxDepth);
 			for (const path of paths) {
 				const lastNode = path[path.length - 1].node;
 				for (const obsId of lastNode.sourceObservationIds) {
@@ -1194,7 +1231,7 @@ var GraphRetrieval = class {
 		const results = [];
 		const visitedObs = new Set(obsIds);
 		for (const node of linkedNodes) {
-			const paths = this.bfsTraversal(node, allNodes, allEdges, maxDepth);
+			const paths = this.dijkstraTraversal(node, allNodes, allEdges, maxDepth);
 			for (const path of paths) {
 				const lastNode = path[path.length - 1].node;
 				for (const obsId of lastNode.sourceObservationIds) {
@@ -1266,37 +1303,104 @@ var GraphRetrieval = class {
 		}
 		return latest;
 	}
-	bfsTraversal(startNode, allNodes, allEdges, maxDepth) {
-		const paths = [];
-		const visited = /* @__PURE__ */ new Set();
-		const queue = [{
+	dijkstraTraversal(startNode, allNodes, allEdges, maxDepth) {
+		const nodeIndex = /* @__PURE__ */ new Map();
+		for (const n of allNodes) nodeIndex.set(n.id, n);
+		const adjacency = /* @__PURE__ */ new Map();
+		for (const edge of allEdges) {
+			const a = edge.sourceNodeId;
+			const b = edge.targetNodeId;
+			if (!adjacency.has(a)) adjacency.set(a, []);
+			if (!adjacency.has(b)) adjacency.set(b, []);
+			adjacency.get(a).push({
+				neighborId: b,
+				edge
+			});
+			adjacency.get(b).push({
+				neighborId: a,
+				edge
+			});
+		}
+		const dist = /* @__PURE__ */ new Map();
+		const pathTo = /* @__PURE__ */ new Map();
+		dist.set(startNode.id, 0);
+		pathTo.set(startNode.id, [{ node: startNode }]);
+		const heap = new MinHeap((a, b) => a.cost - b.cost);
+		heap.push({
 			nodeId: startNode.id,
 			depth: 0,
-			path: [{ node: startNode }]
-		}];
-		visited.add(startNode.id);
-		while (queue.length > 0) {
-			const { nodeId, depth, path } = queue.shift();
-			paths.push(path);
+			cost: 0
+		});
+		while (heap.size() > 0) {
+			const { nodeId, depth, cost } = heap.pop();
+			if (cost > (dist.get(nodeId) ?? Infinity)) continue;
 			if (depth >= maxDepth) continue;
-			const neighborEdges = allEdges.filter((e) => e.sourceNodeId === nodeId || e.targetNodeId === nodeId);
-			for (const edge of neighborEdges) {
-				const nextId = edge.sourceNodeId === nodeId ? edge.targetNodeId : edge.sourceNodeId;
-				if (visited.has(nextId)) continue;
-				visited.add(nextId);
-				const nextNode = allNodes.find((n) => n.id === nextId);
+			const neighbors = adjacency.get(nodeId) ?? [];
+			for (const { neighborId, edge } of neighbors) {
+				const nextNode = nodeIndex.get(neighborId);
 				if (!nextNode) continue;
-				queue.push({
-					nodeId: nextId,
-					depth: depth + 1,
-					path: [...path, {
+				const newCost = cost + 1 / Math.max(edge.weight, .01);
+				if (newCost < (dist.get(neighborId) ?? Infinity)) {
+					dist.set(neighborId, newCost);
+					pathTo.set(neighborId, [...pathTo.get(nodeId), {
 						node: nextNode,
 						edge
-					}]
-				});
+					}]);
+					heap.push({
+						nodeId: neighborId,
+						depth: depth + 1,
+						cost: newCost
+					});
+				}
 			}
 		}
-		return paths;
+		pathTo.delete(startNode.id);
+		return Array.from(pathTo.values());
+	}
+};
+var MinHeap = class {
+	heap = [];
+	constructor(compare) {
+		this.compare = compare;
+	}
+	size() {
+		return this.heap.length;
+	}
+	push(value) {
+		this.heap.push(value);
+		this.bubbleUp(this.heap.length - 1);
+	}
+	pop() {
+		if (this.heap.length === 0) return void 0;
+		const top = this.heap[0];
+		const last = this.heap.pop();
+		if (this.heap.length > 0) {
+			this.heap[0] = last;
+			this.sinkDown(0);
+		}
+		return top;
+	}
+	bubbleUp(i) {
+		while (i > 0) {
+			const parent = i - 1 >> 1;
+			if (this.compare(this.heap[i], this.heap[parent]) < 0) {
+				[this.heap[i], this.heap[parent]] = [this.heap[parent], this.heap[i]];
+				i = parent;
+			} else break;
+		}
+	}
+	sinkDown(i) {
+		const n = this.heap.length;
+		while (true) {
+			const left = 2 * i + 1;
+			const right = 2 * i + 2;
+			let smallest = i;
+			if (left < n && this.compare(this.heap[left], this.heap[smallest]) < 0) smallest = left;
+			if (right < n && this.compare(this.heap[right], this.heap[smallest]) < 0) smallest = right;
+			if (smallest === i) break;
+			[this.heap[i], this.heap[smallest]] = [this.heap[smallest], this.heap[i]];
+			i = smallest;
+		}
 	}
 };
 
@@ -5896,7 +6000,8 @@ function registerExportImportFunction(sdk, kv) {
 			"0.9.15",
 			"0.9.16",
 			"0.9.17",
-			"0.9.18"
+			"0.9.18",
+			"0.9.19"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -13724,6 +13829,112 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 			middleware_function_ids: ["middleware::api-auth"]
 		}
 	});
+	sdk.registerFunction("api::session::commit", async (req) => {
+		const body = req.body ?? {};
+		const sha = asNonEmptyString$1(body.sha);
+		if (!sha) return {
+			status_code: 400,
+			body: { error: "sha is required and must be a non-empty string" }
+		};
+		const sessionId = asNonEmptyString$1(body.sessionId) ?? void 0;
+		const branch = asNonEmptyString$1(body.branch) ?? void 0;
+		const repo = asNonEmptyString$1(body.repo) ?? void 0;
+		const message = asNonEmptyString$1(body.message) ?? void 0;
+		const author = asNonEmptyString$1(body.author) ?? void 0;
+		const authoredAt = asNonEmptyString$1(body.authoredAt) ?? void 0;
+		const files = Array.isArray(body.files) ? body.files.filter((f) => typeof f === "string" && f.length > 0) : void 0;
+		const link = await withKeyedLock(`commit:${sha}`, async () => {
+			const existing = await kv.get(KV.commits, sha);
+			const sessionSet = new Set(existing?.sessionIds ?? []);
+			if (sessionId) sessionSet.add(sessionId);
+			const merged = {
+				sha,
+				shortSha: existing?.shortSha ?? sha.slice(0, 7),
+				branch: branch ?? existing?.branch,
+				repo: repo ?? existing?.repo,
+				message: message ?? existing?.message,
+				author: author ?? existing?.author,
+				authoredAt: authoredAt ?? existing?.authoredAt,
+				files: files ?? existing?.files,
+				sessionIds: Array.from(sessionSet),
+				linkedAt: existing?.linkedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await kv.set(KV.commits, sha, merged);
+			return merged;
+		});
+		if (sessionId) await withKeyedLock(`session:${sessionId}`, async () => {
+			const session = await kv.get(KV.sessions, sessionId);
+			if (!session) return;
+			const shaSet = new Set(session.commitShas ?? []);
+			shaSet.add(sha);
+			session.commitShas = Array.from(shaSet);
+			await kv.set(KV.sessions, sessionId, session);
+		});
+		return {
+			status_code: 200,
+			body: { commit: link }
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::session::commit",
+		config: {
+			api_path: "/agentmemory/session/commit",
+			http_method: "POST",
+			middleware_function_ids: ["middleware::api-auth"]
+		}
+	});
+	sdk.registerFunction("api::session::by-commit", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const sha = asNonEmptyString$1(req.query_params?.["sha"]);
+		if (!sha) return {
+			status_code: 400,
+			body: { error: "sha is required and must be a non-empty string" }
+		};
+		const link = await kv.get(KV.commits, sha);
+		if (!link) return {
+			status_code: 404,
+			body: { error: "no sessions linked to this commit" }
+		};
+		return {
+			status_code: 200,
+			body: {
+				commit: link,
+				sessions: (await Promise.all((link.sessionIds ?? []).map((sid) => kv.get(KV.sessions, sid)))).filter((s) => s !== null)
+			}
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::session::by-commit",
+		config: {
+			api_path: "/agentmemory/session/by-commit",
+			http_method: "GET",
+			middleware_function_ids: ["middleware::api-auth"]
+		}
+	});
+	sdk.registerFunction("api::commits", async (req) => {
+		const authErr = checkAuth(req, secret);
+		if (authErr) return authErr;
+		const branch = asNonEmptyString$1(req.query_params?.["branch"]);
+		const repo = asNonEmptyString$1(req.query_params?.["repo"]);
+		const rawLimit = parseOptionalInt(req.query_params?.["limit"]);
+		const limit = Math.max(1, Math.min(500, rawLimit ?? 100));
+		return {
+			status_code: 200,
+			body: { commits: (await kv.list(KV.commits)).filter((c) => !branch || c.branch === branch).filter((c) => !repo || c.repo === repo).sort((a, b) => (a.linkedAt ?? "") < (b.linkedAt ?? "") ? 1 : -1).slice(0, limit) }
+		};
+	});
+	sdk.registerTrigger({
+		type: "http",
+		function_id: "api::commits",
+		config: {
+			api_path: "/agentmemory/commits",
+			http_method: "GET",
+			middleware_function_ids: ["middleware::api-auth"]
+		}
+	});
 	sdk.registerFunction("api::sessions", async (req) => {
 		const authErr = checkAuth(req, secret);
 		if (authErr) return authErr;
@@ -17705,6 +17916,49 @@ function registerMcpEndpoints(sdk, kv, secret) {
 						}] }
 					};
 				}
+				case "memory_commit_lookup": {
+					const sha = asNonEmptyString(args.sha);
+					if (!sha) return {
+						status_code: 400,
+						body: { error: "sha required" }
+					};
+					const link = await kv.get(KV.commits, sha);
+					if (!link) return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify({
+								commit: null,
+								sessions: []
+							}, null, 2)
+						}] }
+					};
+					const linkRecord = link;
+					const sessions = (await Promise.all((linkRecord.sessionIds ?? []).map((sid) => kv.get(KV.sessions, sid)))).filter((s) => s !== null);
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify({
+								commit: link,
+								sessions
+							}, null, 2)
+						}] }
+					};
+				}
+				case "memory_commits": {
+					const branch = typeof args.branch === "string" ? args.branch : void 0;
+					const repo = typeof args.repo === "string" ? args.repo : void 0;
+					const limit = Math.max(1, Math.min(500, asNumber(args.limit, 100) ?? 100));
+					const filtered = (await kv.list(KV.commits)).filter((c) => !branch || c.branch === branch).filter((c) => !repo || c.repo === repo).sort((a, b) => (a.linkedAt ?? "") < (b.linkedAt ?? "") ? 1 : -1).slice(0, limit);
+					return {
+						status_code: 200,
+						body: { content: [{
+							type: "text",
+							text: JSON.stringify({ commits: filtered }, null, 2)
+						}] }
+					};
+				}
 				default: return {
 					status_code: 400,
 					body: { error: `Unknown tool: ${name}` }
@@ -18617,7 +18871,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: 121 endpoints at http://localhost:${config.restPort}/agentmemory/*`);
+	bootLog(`REST API: 124 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);
@@ -18685,4 +18939,4 @@ main().catch((err) => {
 
 //#endregion
 export {  };
-//# sourceMappingURL=src-C7vygXCj.mjs.map
+//# sourceMappingURL=src-2wwYDPGA.mjs.map