@agentmemory/agentmemory 0.7.8 → 0.8.0

package/dist/{src-Ct05bSXw.mjs → src-qOdKVNQz.mjs}

@@ -39,10 +39,16 @@ function loadEnvFile() {
 }
 function detectProvider(env) {
 	const maxTokens = parseInt(env["MAX_TOKENS"] || "4096", 10);
+	if (env["MINIMAX_API_KEY"]) return {
+		provider: "minimax",
+		model: env["MINIMAX_MODEL"] || "MiniMax-M2.7",
+		maxTokens
+	};
 	if (env["ANTHROPIC_API_KEY"]) return {
 		provider: "anthropic",
 		model: env["ANTHROPIC_MODEL"] || "claude-sonnet-4-20250514",
-		maxTokens
+		maxTokens,
+		baseURL: env["ANTHROPIC_BASE_URL"]
 	};
 	if (env["GEMINI_API_KEY"]) return {
 		provider: "gemini",
@@ -156,7 +162,8 @@ const VALID_PROVIDERS = new Set([
 	"anthropic",
 	"gemini",
 	"openrouter",
-	"agent-sdk"
+	"agent-sdk",
+	"minimax"
 ]);
 function loadFallbackConfig() {
 	return { providers: (getMergedEnv()["FALLBACK_PROVIDERS"] || "").split(",").map((p) => p.trim()).filter((p) => Boolean(p) && VALID_PROVIDERS.has(p)) };
@@ -195,8 +202,11 @@ var AnthropicProvider = class {
 	client;
 	model;
 	maxTokens;
-	constructor(apiKey, model, maxTokens) {
-		this.client = new Anthropic({ apiKey });
+	constructor(apiKey, model, maxTokens, baseURL) {
+		this.client = new Anthropic({
+			apiKey,
+			...baseURL ? { baseURL } : {}
+		});
 		this.model = model;
 		this.maxTokens = maxTokens;
 	}
@@ -219,6 +229,67 @@ var AnthropicProvider = class {
 	}
 };
 
+//#endregion
+//#region src/providers/minimax.ts
+/**
+* MiniMax provider using raw fetch to call MiniMax's Anthropic-compatible API.
+*
+* The Anthropic SDK automatically injects `x-stainless-*` headers that MiniMax
+* rejects with 403. This provider bypasses the SDK and calls the API directly.
+*
+* Required env vars:
+*   MINIMAX_API_KEY  — your MiniMax API key
+*   MINIMAX_MODEL    — model name (default: MiniMax-M2.7)
+*   MAX_TOKENS       — max output tokens (default: 800; MiniMax-M2.7 needs ≤800)
+*
+* Optional:
+*   MINIMAX_BASE_URL — base URL without path (default: https://api.minimaxi.com/anthropic)
+*/
+var MinimaxProvider = class {
+	name = "minimax";
+	apiKey;
+	model;
+	maxTokens;
+	baseUrl;
+	constructor(apiKey, model, maxTokens) {
+		this.apiKey = apiKey;
+		this.model = model;
+		this.maxTokens = maxTokens;
+		this.baseUrl = process.env["MINIMAX_BASE_URL"] || "https://api.minimaxi.com/anthropic";
+	}
+	async compress(systemPrompt, userPrompt) {
+		return this.call(systemPrompt, userPrompt);
+	}
+	async summarize(systemPrompt, userPrompt) {
+		return this.call(systemPrompt, userPrompt);
+	}
+	async call(systemPrompt, userPrompt) {
+		const url = `${this.baseUrl}/v1/messages`;
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"x-api-key": this.apiKey,
+				"anthropic-version": "2023-06-01"
+			},
+			body: JSON.stringify({
+				model: this.model,
+				max_tokens: this.maxTokens,
+				system: systemPrompt,
+				messages: [{
+					role: "user",
+					content: userPrompt
+				}]
+			})
+		});
+		if (!response.ok) {
+			const text = await response.text();
+			throw new Error(`MiniMax API error ${response.status}: ${text}`);
+		}
+		return ((await response.json()).content?.find((b) => b.type === "text"))?.text ?? "";
+	}
+};
+
 //#endregion
 //#region src/providers/openrouter.ts
 var OpenRouterProvider = class {
@@ -646,7 +717,8 @@ function createFallbackProvider(config, fallbackConfig) {
 }
 function createBaseProvider(config) {
 	switch (config.provider) {
-		case "anthropic": return new AnthropicProvider(requireEnvVar("ANTHROPIC_API_KEY"), config.model, config.maxTokens);
+		case "minimax": return new MinimaxProvider(requireEnvVar("MINIMAX_API_KEY"), config.model, config.maxTokens);
+		case "anthropic": return new AnthropicProvider(requireEnvVar("ANTHROPIC_API_KEY"), config.model, config.maxTokens, config.baseURL);
 		case "gemini": return new OpenRouterProvider(requireEnvVar("GEMINI_API_KEY"), 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");
 		default: return new AgentSDKProvider();
@@ -2122,23 +2194,56 @@ function registerSearchFunction(sdk, kv) {
 	}, async (data) => {
 		const ctx = getContext();
 		const idx = getSearchIndex();
+		if (typeof data?.query !== "string" || !data.query.trim()) throw new Error("mem::search: query must be a non-empty string");
+		const query = data.query.trim();
+		const MAX_LIMIT = 100;
+		let effectiveLimit = 20;
+		if (data.limit !== void 0) {
+			if (!Number.isInteger(data.limit) || data.limit < 1) throw new Error("mem::search: limit must be a positive integer");
+			effectiveLimit = Math.min(data.limit, MAX_LIMIT);
+		}
+		const projectFilter = typeof data.project === "string" && data.project.length > 0 ? data.project : void 0;
+		const cwdFilter = typeof data.cwd === "string" && data.cwd.length > 0 ? data.cwd : void 0;
 		if (idx.size === 0) {
 			const count = await rebuildIndex(kv);
 			ctx.logger.info("Search index rebuilt", { entries: count });
 		}
-		const results = idx.search(data.query, data.limit || 20);
-		const enriched = [];
+		const filtering = !!(projectFilter || cwdFilter);
+		const fetchLimit = filtering ? Math.max(effectiveLimit * 10, 100) : effectiveLimit;
+		const results = idx.search(query, fetchLimit);
+		const sessionCache = /* @__PURE__ */ new Map();
+		const loadSession = async (sessionId) => {
+			if (sessionCache.has(sessionId)) return sessionCache.get(sessionId);
+			const s = await kv.get(KV.sessions, sessionId);
+			sessionCache.set(sessionId, s ?? null);
+			return s ?? null;
+		};
+		const candidates = [];
 		for (const r of results) {
-			const obs = await kv.get(KV.observations(r.sessionId), r.obsId);
+			if (candidates.length >= effectiveLimit) break;
+			if (filtering) {
+				const s = await loadSession(r.sessionId);
+				if (!s) continue;
+				if (projectFilter && s.project !== projectFilter) continue;
+				if (cwdFilter && s.cwd !== cwdFilter) continue;
+			}
+			candidates.push(r);
+		}
+		const obsResults = await Promise.all(candidates.map((r) => kv.get(KV.observations(r.sessionId), r.obsId)));
+		const enriched = [];
+		for (let i = 0; i < candidates.length; i++) {
+			const obs = obsResults[i];
 			if (obs) enriched.push({
 				observation: obs,
-				score: r.score,
-				sessionId: r.sessionId
+				score: candidates[i].score,
+				sessionId: candidates[i].sessionId
 			});
 		}
 		ctx.logger.info("Search completed", {
-			query: data.query,
-			results: enriched.length
+			query,
+			results: enriched.length,
+			hasProjectFilter: !!projectFilter,
+			hasCwdFilter: !!cwdFilter
 		});
 		return { results: enriched };
 	});
@@ -3804,7 +3909,7 @@ function registerAutoForgetFunction(sdk, kv) {
 
 //#endregion
 //#region src/version.ts
-const VERSION = "0.7.8";
+const VERSION = "0.8.0";
 
 //#endregion
 //#region src/functions/export-import.ts
@@ -3909,7 +4014,8 @@ function registerExportImportFunction(sdk, kv) {
 			"0.7.5",
 			"0.7.6",
 			"0.7.7",
-			"0.7.8"
+			"0.7.9",
+			"0.8.0"
 		]).has(importData.version)) return {
 			success: false,
 			error: `Unsupported export version: ${importData.version}`
@@ -10032,9 +10138,32 @@ function registerApiTriggers(sdk, kv, secret, metricsStore, provider) {
 	sdk.registerFunction({ id: "api::search" }, async (req) => {
 		const authErr = checkAuth$1(req, secret);
 		if (authErr) return authErr;
+		const body = req.body ?? {};
+		if (typeof body.query !== "string" || !body.query.trim()) return {
+			status_code: 400,
+			body: { error: "query is required and must be a non-empty string" }
+		};
+		if (body.limit !== void 0 && (!Number.isInteger(body.limit) || body.limit < 1)) return {
+			status_code: 400,
+			body: { error: "limit must be a positive integer" }
+		};
+		if (body.project !== void 0 && typeof body.project !== "string") return {
+			status_code: 400,
+			body: { error: "project must be a string" }
+		};
+		if (body.cwd !== void 0 && typeof body.cwd !== "string") return {
+			status_code: 400,
+			body: { error: "cwd must be a string" }
+		};
+		const payload = {
+			query: body.query.trim(),
+			limit: body.limit,
+			project: body.project,
+			cwd: body.cwd
+		};
 		return {
 			status_code: 200,
-			body: await sdk.trigger("mem::search", req.body)
+			body: await sdk.trigger("mem::search", payload)
 		};
 	});
 	sdk.registerTrigger({
@@ -14727,4 +14856,4 @@ main().catch((err) => {
 
 //#endregion
 export {  };
-//# sourceMappingURL=src-Ct05bSXw.mjs.map
+//# sourceMappingURL=src-qOdKVNQz.mjs.map