Skip to content

#1 Persistent memory for AI coding agents based on real-world benchmarks

feat: agentmemory v0.4.0 — MCP resources, prompts, enrichment, confidence (#7)

Rohit Ghumare8b21ae2bf661
diff --git a/package.json b/package.json
index f146abe7..0506557b 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "agentmemory",
- "version": "0.3.0",
+ "version": "0.4.0",
"description": "Persistent memory for AI coding agents, powered by iii-engine's three primitives",
"type": "module",
"main": "dist/index.js",
diff --git a/plugin/scripts/pre-tool-use.mjs b/plugin/scripts/pre-tool-use.mjs
index 5cd84f9a..aa9432b0 100755
--- a/plugin/scripts/pre-tool-use.mjs
+++ b/plugin/scripts/pre-tool-use.mjs
@@ -38,14 +38,21 @@ async function main() {
if (typeof val === "string" && val.length > 0) files.push(val);
}
if (files.length === 0) return;
+ const terms = [];
+ if (toolName === "Grep" || toolName === "Glob") {
+ const pattern = toolInput["pattern"];
+ if (typeof pattern === "string" && pattern.length > 0) terms.push(pattern);
+ }
const sessionId = data.session_id || "unknown";
try {
- const res = await fetch(`${REST_URL}/agentmemory/file-context`, {
+ const res = await fetch(`${REST_URL}/agentmemory/enrich`, {
method: "POST",
headers: authHeaders(),
body: JSON.stringify({
sessionId,
- files
+ files,
+ terms,
+ toolName
}),
signal: AbortSignal.timeout(2e3)
});
diff --git a/src/functions/enrich.ts b/src/functions/enrich.ts
new file mode 100644
index 00000000..bce4d654
--- /dev/null
+++ b/src/functions/enrich.ts
@@ -0,0 +1,132 @@
+import type { ISdk } from "iii-sdk";
+import { getContext } from "iii-sdk";
+import type { Memory } from "../types.js";
+import { KV } from "../state/schema.js";
+import { StateKV } from "../state/kv.js";
+
+const MAX_CONTEXT_LENGTH = 4000;
+
+function escapeXml(s: string): string {
+ return s
+ .replace(/&/g, "&")
+ .replace(/</g, "&lt;")
+ .replace(/>/g, "&gt;")
+ .replace(/"/g, "&quot;")
+ .replace(/'/g, "&apos;");
+}
+
+export function registerEnrichFunction(sdk: ISdk, kv: StateKV): void {
+ sdk.registerFunction(
+ {
+ id: "mem::enrich",
+ description:
+ "Aggregate file context, relevant observations, and bug memories for pre-tool enrichment",
+ },
+ async (data: {
+ sessionId: string;
+ files: string[];
+ terms?: string[];
+ toolName?: string;
+ }) => {
+ const ctx = getContext();
+ const parts: string[] = [];
+
+ const fileContextPromise = sdk
+ .trigger<{ sessionId: string; files: string[] }, { context: string }>(
+ "mem::file-context",
+ {
+ sessionId: data.sessionId,
+ files: data.files,
+ },
+ )
+ .catch(() => ({ context: "" }));
+
+ const searchQueries: string[] = [
+ ...data.files.map((f) => f.split("/").pop() || f),
+ ...(data.terms || []),
+ ].filter((q) => q.length > 0);
+
+ const searchPromise =
+ searchQueries.length > 0
+ ? sdk
+ .trigger<
+ { query: string; limit: number },
+ { results: Array<{ observation: { narrative: string } }> }
+ >("mem::search", {
+ query: searchQueries.join(" "),
+ limit: 5,
+ })
+ .catch(() => ({ results: [] }))
+ : Promise.resolve({ results: [] });
+
+ const bugMemoriesPromise = kv
+ .list<Memory>(KV.memories)
+ .then((memories) =>
+ memories
+ .filter(
+ (m) =>
+ m.type === "bug" &&
+ m.isLatest &&
+ m.files.some((f) =>
+ data.files.some((df) => f.includes(df) || df.includes(f)),
+ ),
+ )
+ .sort(
+ (a, b) =>
+ new Date(b.updatedAt || b.createdAt).getTime() -
+ new Date(a.updatedAt || a.createdAt).getTime(),
+ ),
+ )
+ .catch(() => []);
+
+ const [fileContext, searchResult, bugMemories] = await Promise.all([
+ fileContextPromise,
+ searchPromise,
+ bugMemoriesPromise,
+ ]);
+
+ if (fileContext.context) {
+ parts.push(fileContext.context);
+ }
+
+ if (searchResult.results.length > 0) {
+ const observations = searchResult.results
+ .map((r) => r.observation?.narrative)
+ .filter(Boolean)
+ .map((n) => escapeXml(n as string))
+ .join("\n");
+ if (observations) {
+ parts.push(
+ `<agentmemory-relevant-context>\n${observations}\n</agentmemory-relevant-context>`,
+ );
+ }
+ }
+
+ if (bugMemories.length > 0) {
+ const bugs = bugMemories
+ .slice(0, 3)
+ .map((m) => `- ${escapeXml(m.title)}: ${escapeXml(m.content)}`)
+ .join("\n");
+ parts.push(
+ `<agentmemory-past-errors>\n${bugs}\n</agentmemory-past-errors>`,
+ );
+ }
+
+ let context = parts.join("\n\n");
+ let truncated = false;
+ if (context.length > MAX_CONTEXT_LENGTH) {
+ context = context.slice(0, MAX_CONTEXT_LENGTH);
+ truncated = true;
+ }
+
+ ctx.logger.info("Enrichment completed", {
+ sessionId: data.sessionId,
+ fileCount: data.files.length,
+ contextLength: context.length,
+ truncated,
+ });
+
+ return { context, truncated };
+ },
+ );
+}
diff --git a/src/functions/relations.ts b/src/functions/relations.ts
index dcb6af7d..82d363e3 100644
--- a/src/functions/relations.ts
+++ b/src/functions/relations.ts
@@ -4,6 +4,35 @@ import type { Memory, MemoryRelation } from "../types.js";
import { KV, generateId } from "../state/schema.js";
import { StateKV } from "../state/kv.js";
+function computeConfidence(
+ source: Memory,
+ target: Memory,
+ relationType: MemoryRelation["type"],
+): number {
+ let score = 0.5;
+
+ const sharedSessions = source.sessionIds.filter((sid) =>
+ target.sessionIds.includes(sid),
+ );
+ score += Math.min(sharedSessions.length * 0.1, 0.3);
+
+ const now = Date.now();
+ const sourceAge = now - new Date(source.updatedAt).getTime();
+ const targetAge = now - new Date(target.updatedAt).getTime();
+ const sevenDays = 7 * 24 * 60 * 60 * 1000;
+ const ninetyDays = 90 * 24 * 60 * 60 * 1000;
+ if (sourceAge < sevenDays && targetAge < sevenDays) {
+ score += 0.1;
+ } else if (sourceAge > ninetyDays && targetAge > ninetyDays) {
+ score -= 0.1;
+ }
+
+ if (relationType === "supersedes") score += 0.1;
+ if (relationType === "contradicts") score -= 0.05;
+
+ return Math.max(0, Math.min(1, score));
+}
+
export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
sdk.registerFunction(
{
@@ -14,6 +43,7 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
sourceId: string;
targetId: string;
type: MemoryRelation["type"];
+ confidence?: number;
}) => {
const ctx = getContext();
@@ -23,11 +53,17 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
return { success: false, error: "source or target memory not found" };
}
+ const confidence =
+ data.confidence !== undefined
+ ? Math.max(0, Math.min(1, data.confidence))
+ : computeConfidence(source, target, data.type);
+
const relation: MemoryRelation = {
type: data.type,
sourceId: data.sourceId,
targetId: data.targetId,
createdAt: new Date().toISOString(),
+ confidence,
};
const relationId = generateId("rel");
@@ -93,6 +129,7 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
sourceId: evolved.id,
targetId: existing.id,
createdAt: now,
+ confidence: 1.0,
};
await kv.set(KV.relations, generateId("rel"), relation);
@@ -110,17 +147,29 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
id: "mem::get-related",
description: "Get related memories within N hops",
},
- async (data: { memoryId: string; maxHops?: number }) => {
+ async (data: {
+ memoryId: string;
+ maxHops?: number;
+ minConfidence?: number;
+ }) => {
const ctx = getContext();
const maxHops = Math.min(data.maxHops ?? 2, 5);
const MAX_VISITED = 500;
+ const rawMinConf = Number(data.minConfidence);
+ const minConfidence = Number.isFinite(rawMinConf)
+ ? Math.max(0, Math.min(1, rawMinConf))
+ : 0;
const allRelations = await kv
.list<MemoryRelation>(KV.relations)
.catch(() => []);
const visited = new Set<string>();
- const result: Array<{ memory: Memory; hop: number }> = [];
+ const result: Array<{
+ memory: Memory;
+ hop: number;
+ confidence: number;
+ }> = [];
const queue: Array<{ id: string; hop: number }> = [
{ id: data.memoryId, hop: 0 },
];
@@ -134,7 +183,18 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
if (!memory) continue;
if (current.hop > 0) {
- result.push({ memory, hop: current.hop });
+ const matchingRelations = allRelations.filter(
+ (r) =>
+ (r.sourceId === current.id && visited.has(r.targetId)) ||
+ (r.targetId === current.id && visited.has(r.sourceId)),
+ );
+ const confidence =
+ matchingRelations.length > 0
+ ? Math.max(...matchingRelations.map((r) => r.confidence ?? 0.5))
+ : 0.5;
+ if (confidence >= minConfidence) {
+ result.push({ memory, hop: current.hop, confidence });
+ }
}
const relatedIds = memory.relatedIds || [];
@@ -156,6 +216,8 @@ export function registerRelationsFunction(sdk: ISdk, kv: StateKV): void {
}
}
+ result.sort((a, b) => b.confidence - a.confidence);
+
ctx.logger.info("Related memories retrieved", {
memoryId: data.memoryId,
found: result.length,
diff --git a/src/hooks/pre-tool-use.ts b/src/hooks/pre-tool-use.ts
index dbc4a9c0..10ddde5b 100644
--- a/src/hooks/pre-tool-use.ts
+++ b/src/hooks/pre-tool-use.ts
@@ -40,13 +40,21 @@ async function main() {
}
if (files.length === 0) return;
+ const terms: string[] = [];
+ if (toolName === "Grep" || toolName === "Glob") {
+ const pattern = toolInput["pattern"];
+ if (typeof pattern === "string" && pattern.length > 0) {
+ terms.push(pattern);
+ }
+ }
+
const sessionId = (data.session_id as string) || "unknown";
try {
- const res = await fetch(`${REST_URL}/agentmemory/file-context`, {
+ const res = await fetch(`${REST_URL}/agentmemory/enrich`, {
method: "POST",
headers: authHeaders(),
- body: JSON.stringify({ sessionId, files }),
+ body: JSON.stringify({ sessionId, files, terms, toolName }),
signal: AbortSignal.timeout(2000),
});
diff --git a/src/index.ts b/src/index.ts
index ac3f6b74..8b085a44 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -36,6 +36,7 @@ import { registerSmartSearchFunction } from "./functions/smart-search.js";
import { registerProfileFunction } from "./functions/profile.js";
import { registerAutoForgetFunction } from "./functions/auto-forget.js";
import { registerExportImportFunction } from "./functions/export-import.js";
+import { registerEnrichFunction } from "./functions/enrich.js";
import { registerApiTriggers } from "./triggers/api.js";
import { registerEventTriggers } from "./triggers/events.js";
import { registerMcpEndpoints } from "./mcp/server.js";
@@ -56,7 +57,7 @@ async function main() {
const embeddingProvider = createEmbeddingProvider();
- console.log(`[agentmemory] Starting worker v0.3.0...`);
+ console.log(`[agentmemory] Starting worker v0.4.0...`);
console.log(`[agentmemory] Engine: ${config.engineUrl}`);
console.log(
`[agentmemory] Provider: ${config.provider.provider} (${config.provider.model})`,
@@ -113,6 +114,7 @@ async function main() {
registerProfileFunction(sdk, kv);
registerAutoForgetFunction(sdk, kv);
registerExportImportFunction(sdk, kv);
+ registerEnrichFunction(sdk, kv);
const bm25Index = getSearchIndex();
const hybridSearch = new HybridSearch(
@@ -171,7 +173,9 @@ async function main() {
console.log(
`[agentmemory] Ready. ${embeddingProvider ? "Hybrid" : "BM25"} search active.`,
);
- console.log(`[agentmemory] Endpoints: 28 REST + 10 MCP tools + 21 functions`);
+ console.log(
+ `[agentmemory] Endpoints: 29 REST + 10 MCP tools + 4 MCP resources + 3 MCP prompts + 22 functions`,
+ );
const shutdown = async () => {
console.log(`\n[agentmemory] Shutting down...`);
diff --git a/src/mcp/server.ts b/src/mcp/server.ts
index de00b0b5..433a69dc 100644
--- a/src/mcp/server.ts
+++ b/src/mcp/server.ts
@@ -1,6 +1,12 @@
import type { ISdk, ApiRequest } from "iii-sdk";
import type { StateKV } from "../state/kv.js";
import { KV } from "../state/schema.js";
+import type {
+ SessionSummary,
+ Memory,
+ Session,
+ MemoryRelation,
+} from "../types.js";
type McpTool = {
name: string;
@@ -204,6 +210,11 @@ const MCP_TOOLS: McpTool[] = [
type: "number",
description: "Maximum graph traversal depth (default 2)",
},
+ minConfidence: {
+ type: "number",
+ description:
+ "Minimum confidence threshold to include (0-1, default 0)",
+ },
},
required: ["memoryId"],
},
@@ -456,9 +467,14 @@ export function registerMcpEndpoints(
body: { error: "memoryId is required for memory_relations" },
};
}
+ const rawMaxHops = Number(args.maxHops);
+ const rawMinConf = Number(args.minConfidence);
const result = await sdk.trigger("mem::get-related", {
memoryId: args.memoryId,
- maxHops: (args.maxHops as number) || 2,
+ maxHops: Number.isFinite(rawMaxHops) ? rawMaxHops : 2,
+ minConfidence: Number.isFinite(rawMinConf)
+ ? Math.max(0, Math.min(1, rawMinConf))
+ : 0,
});
return {
status_code: 200,
@@ -491,4 +507,371 @@ export function registerMcpEndpoints(
function_id: "mcp::tools::call",
config: { api_path: "/agentmemory/mcp/call", http_method: "POST" },
});
+
+ const MCP_RESOURCES = [
+ {
+ uri: "agentmemory://status",
+ name: "Agent Memory Status",
+ description: "Current session count, memory count, and health status",
+ mimeType: "application/json",
+ },
+ {
+ uri: "agentmemory://project/{name}/profile",
+ name: "Project Profile",
+ description:
+ "Top concepts, frequently modified files, and conventions for a project",
+ mimeType: "application/json",
+ },
+ {
+ uri: "agentmemory://project/{name}/recent",
+ name: "Recent Sessions",
+ description: "Last 5 session summaries for a project",
+ mimeType: "application/json",
+ },
+ {
+ uri: "agentmemory://memories/latest",
+ name: "Latest Memories",
+ description: "Top 10 latest memories with their type and strength",
+ mimeType: "application/json",
+ },
+ ];
+
+ sdk.registerFunction(
+ { id: "mcp::resources::list" },
+ async (req: ApiRequest): Promise<McpResponse> => {
+ const authErr = checkAuth(req, secret);
+ if (authErr) return authErr;
+ return { status_code: 200, body: { resources: MCP_RESOURCES } };
+ },
+ );
+ sdk.registerTrigger({
+ type: "http",
+ function_id: "mcp::resources::list",
+ config: { api_path: "/agentmemory/mcp/resources", http_method: "GET" },
+ });
+
+ sdk.registerFunction(
+ { id: "mcp::resources::read" },
+ async (req: ApiRequest<{ uri: string }>): Promise<McpResponse> => {
+ const authErr = checkAuth(req, secret);
+ if (authErr) return authErr;
+
+ const uri = req.body?.uri;
+ if (!uri || typeof uri !== "string") {
+ return { status_code: 400, body: { error: "uri is required" } };
+ }
+
+ try {
+ if (uri === "agentmemory://status") {
+ const sessions = await kv.list<Session>(KV.sessions);
+ const memories = await kv.list<Memory>(KV.memories);
+ const healthData = await kv.list(KV.health).catch(() => []);
+ return {
+ status_code: 200,
+ body: {
+ contents: [
+ {
+ uri,
+ mimeType: "application/json",
+ text: JSON.stringify({
+ sessionCount: sessions.length,
+ memoryCount: memories.length,
+ healthStatus:
+ healthData.length > 0 ? "available" : "no-data",
+ }),
+ },
+ ],
+ },
+ };
+ }
+
+ const projectProfileMatch = uri.match(
+ /^agentmemory:\/\/project\/(.+)\/profile$/,
+ );
+ if (projectProfileMatch) {
+ let projectName: string;
+ try {
+ projectName = decodeURIComponent(projectProfileMatch[1]);
+ } catch {
+ return {
+ status_code: 400,
+ body: { error: "Invalid percent-encoding in URI" },
+ };
+ }
+ const profile = await sdk.trigger("mem::profile", {
+ project: projectName,
+ });
+ return {
+ status_code: 200,
+ body: {
+ contents: [
+ {
+ uri,
+ mimeType: "application/json",
+ text: JSON.stringify(profile),
+ },
+ ],
+ },
+ };
+ }
+
+ const projectRecentMatch = uri.match(
+ /^agentmemory:\/\/project\/(.+)\/recent$/,
+ );
+ if (projectRecentMatch) {
+ let projectName: string;
+ try {
+ projectName = decodeURIComponent(projectRecentMatch[1]);
+ } catch {
+ return {
+ status_code: 400,
+ body: { error: "Invalid percent-encoding in URI" },
+ };
+ }
+ const summaries = await kv.list<SessionSummary>(KV.summaries);
+ const filtered = summaries
+ .filter((s) => s.project === projectName)
+ .sort(
+ (a, b) =>
+ new Date(b.createdAt).getTime() -
+ new Date(a.createdAt).getTime(),
+ )
+ .slice(0, 5);
+ return {
+ status_code: 200,
+ body: {
+ contents: [
+ {
+ uri,
+ mimeType: "application/json",
+ text: JSON.stringify(filtered),
+ },
+ ],
+ },
+ };
+ }
+
+ if (uri === "agentmemory://memories/latest") {
+ const memories = await kv.list<Memory>(KV.memories);
+ const latest = memories
+ .filter((m) => m.isLatest)
+ .sort(
+ (a, b) =>
+ new Date(b.updatedAt).getTime() -
+ new Date(a.updatedAt).getTime(),
+ )
+ .slice(0, 10)
+ .map((m) => ({
+ id: m.id,
+ title: m.title,
+ type: m.type,
+ strength: m.strength,
+ }));
+ return {
+ status_code: 200,
+ body: {
+ contents: [
+ {
+ uri,
+ mimeType: "application/json",
+ text: JSON.stringify(latest),
+ },
+ ],
+ },
+ };
+ }
+
+ return {
+ status_code: 404,
+ body: { error: `Unknown resource: ${uri}` },
+ };
+ } catch {
+ return { status_code: 500, body: { error: "Internal error" } };
+ }
+ },
+ );
+ sdk.registerTrigger({
+ type: "http",
+ function_id: "mcp::resources::read",
+ config: {
+ api_path: "/agentmemory/mcp/resources/read",
+ http_method: "POST",
+ },
+ });
+
+ const MCP_PROMPTS = [
+ {
+ name: "recall_context",
+ description:
+ "Search observations and memories to build context for a task",
+ arguments: [
+ {
+ name: "task_description",
+ description: "What you are working on",
+ required: true,
+ },
+ ],
+ },
+ {
+ name: "session_handoff",
+ description:
+ "Generate a handoff summary for continuing work in a new session",
+ arguments: [
+ {
+ name: "session_id",
+ description: "Session ID to hand off from",
+ required: true,
+ },
+ ],
+ },
+ {
+ name: "detect_patterns",
+ description: "Detect recurring patterns across sessions for a project",
+ arguments: [
+ {
+ name: "project",
+ description: "Project path to analyze (optional)",
+ required: false,
+ },
+ ],
+ },
+ ];
+
+ sdk.registerFunction(
+ { id: "mcp::prompts::list" },
+ async (req: ApiRequest): Promise<McpResponse> => {
+ const authErr = checkAuth(req, secret);
+ if (authErr) return authErr;
+ return { status_code: 200, body: { prompts: MCP_PROMPTS } };
+ },
+ );
+ sdk.registerTrigger({
+ type: "http",
+ function_id: "mcp::prompts::list",
+ config: { api_path: "/agentmemory/mcp/prompts", http_method: "GET" },
+ });
+
+ sdk.registerFunction(
+ { id: "mcp::prompts::get" },
+ async (
+ req: ApiRequest<{ name: string; arguments?: Record<string, string> }>,
+ ): Promise<McpResponse> => {
+ const authErr = checkAuth(req, secret);
+ if (authErr) return authErr;
+
+ const promptName = req.body?.name;
+ if (!promptName || typeof promptName !== "string") {
+ return { status_code: 400, body: { error: "name is required" } };
+ }
+
+ const promptArgs = req.body?.arguments || {};
+
+ try {
+ switch (promptName) {
+ case "recall_context": {
+ const taskDesc = promptArgs.task_description;
+ if (typeof taskDesc !== "string" || !taskDesc.trim()) {
+ return {
+ status_code: 400,
+ body: {
+ error:
+ "task_description argument is required and must be a string",
+ },
+ };
+ }
+ const searchResult = await sdk
+ .trigger("mem::search", { query: taskDesc, limit: 10 })
+ .catch(() => ({ results: [] }));
+ const memories = await kv.list<Memory>(KV.memories);
+ const relevant = memories.filter((m) => m.isLatest).slice(0, 5);
+ return {
+ status_code: 200,
+ body: {
+ messages: [
+ {
+ role: "user",
+ content: {
+ type: "text",
+ text: `Here is relevant context from past sessions for the task: "${taskDesc}"\n\n## Past Observations\n${JSON.stringify(searchResult, null, 2)}\n\n## Relevant Memories\n${JSON.stringify(relevant, null, 2)}`,
+ },
+ },
+ ],
+ },
+ };
+ }
+
+ case "session_handoff": {
+ const sessionId = promptArgs.session_id;
+ if (typeof sessionId !== "string" || !sessionId.trim()) {
+ return {
+ status_code: 400,
+ body: {
+ error: "session_id argument is required and must be a string",
+ },
+ };
+ }
+ const session = await kv.get<Session>(KV.sessions, sessionId);
+ const summaries = await kv.list<SessionSummary>(KV.summaries);
+ const summary = summaries.find((s) => s.sessionId === sessionId);
+ return {
+ status_code: 200,
+ body: {
+ messages: [
+ {
+ role: "user",
+ content: {
+ type: "text",
+ text: `## Session Handoff\n\n### Session\n${JSON.stringify(session, null, 2)}\n\n### Summary\n${JSON.stringify(summary || "No summary available", null, 2)}`,
+ },
+ },
+ ],
+ },
+ };
+ }
+
+ case "detect_patterns": {
+ if (
+ promptArgs.project !== undefined &&
+ typeof promptArgs.project !== "string"
+ ) {
+ return {
+ status_code: 400,
+ body: { error: "project argument must be a string" },
+ };
+ }
+ const result = await sdk.trigger("mem::patterns", {
+ project: promptArgs.project || undefined,
+ });
+ return {
+ status_code: 200,
+ body: {
+ messages: [
+ {
+ role: "user",
+ content: {
+ type: "text",
+ text: `## Pattern Analysis\n\n${JSON.stringify(result, null, 2)}`,
+ },
+ },
+ ],
+ },
+ };
+ }
+
+ default:
+ return {
+ status_code: 400,
+ body: { error: `Unknown prompt: ${promptName}` },
+ };
+ }
+ } catch {
+ return { status_code: 500, body: { error: "Internal error" } };
+ }
+ },
+ );
+ sdk.registerTrigger({
+ type: "http",
+ function_id: "mcp::prompts::get",
+ config: { api_path: "/agentmemory/mcp/prompts/get", http_method: "POST" },
+ });
}
diff --git a/src/triggers/api.ts b/src/triggers/api.ts
index 3d555d83..2bdd1cbf 100644
--- a/src/triggers/api.ts
+++ b/src/triggers/api.ts
@@ -69,7 +69,7 @@ export function registerApiTriggers(
body: {
status,
service: "agentmemory",
- version: "0.3.0",
+ version: "0.4.0",
health: health || null,
functionMetrics,
circuitBreaker,
@@ -254,6 +254,52 @@ export function registerApiTriggers(
config: { api_path: "/agentmemory/file-context", http_method: "POST" },
});
+ sdk.registerFunction(
+ { id: "api::enrich" },
+ async (
+ req: ApiRequest<{
+ sessionId: string;
+ files: string[];
+ terms?: string[];
+ toolName?: string;
+ }>,
+ ): Promise<Response> => {
+ const authErr = checkAuth(req, secret);
+ if (authErr) return authErr;
+ if (
+ !req.body?.sessionId ||
+ typeof req.body.sessionId !== "string" ||
+ !Array.isArray(req.body?.files) ||
+ req.body.files.length === 0 ||
+ !req.body.files.every((f: unknown) => typeof f === "string")
+ ) {
+ return {
+ status_code: 400,
+ body: {
+ error: "sessionId (string) and files (string[]) are required",
+ },
+ };
+ }
+ if (
+ req.body.terms !== undefined &&
+ (!Array.isArray(req.body.terms) ||
+ !req.body.terms.every((t: unknown) => typeof t === "string"))
+ ) {
+ return {
+ status_code: 400,
+ body: { error: "terms must be an array of strings" },
+ };
+ }
+ const result = await sdk.trigger("mem::enrich", req.body);
+ return { status_code: 200, body: result };
+ },
+ );
+ sdk.registerTrigger({
+ type: "http",
+ function_id: "api::enrich",
+ config: { api_path: "/agentmemory/enrich", http_method: "POST" },
+ });
+
sdk.registerFunction(
{ id: "api::remember" },
async (
diff --git a/src/types.ts b/src/types.ts
index ca7402d2..f9ce7bc9 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -197,6 +197,7 @@ export interface MemoryRelation {
sourceId: string;
targetId: string;
createdAt: string;
+ confidence?: number;
}
export interface HybridSearchResult {
diff --git a/test/confidence.test.ts b/test/confidence.test.ts
new file mode 100644
index 00000000..a3c62635
--- /dev/null
+++ b/test/confidence.test.ts
@@ -0,0 +1,247 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+ getContext: () => ({
+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+ }),
+}));
+
+import { registerRelationsFunction } from "../src/functions/relations.js";
+import type { Memory, MemoryRelation } from "../src/types.js";
+
+function mockKV() {
+ const store = new Map<string, Map<string, unknown>>();
+ return {
+ get: async <T>(scope: string, key: string): Promise<T | null> => {
+ return (store.get(scope)?.get(key) as T) ?? null;
+ },
+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {
+ if (!store.has(scope)) store.set(scope, new Map());
+ store.get(scope)!.set(key, data);
+ return data;
+ },
+ delete: async (scope: string, key: string): Promise<void> => {
+ store.get(scope)?.delete(key);
+ },
+ list: async <T>(scope: string): Promise<T[]> => {
+ const entries = store.get(scope);
+ return entries ? (Array.from(entries.values()) as T[]) : [];
+ },
+ };
+}
+
+function mockSdk() {
+ const functions = new Map<string, Function>();
+ return {
+ registerFunction: (opts: { id: string }, handler: Function) => {
+ functions.set(opts.id, handler);
+ },
+ registerTrigger: () => {},
+ trigger: async (id: string, data: unknown) => {
+ const fn = functions.get(id);
+ if (!fn) throw new Error(`No function: ${id}`);
+ return fn(data);
+ },
+ getFunction: (id: string) => functions.get(id),
+ };
+}
+
+function makeMemory(overrides: Partial<Memory> = {}): Memory {
+ return {
+ id: "mem_1",
+ createdAt: new Date().toISOString(),
+ updatedAt: new Date().toISOString(),
+ type: "pattern",
+ title: "Test memory",
+ content: "This is a test memory",
+ concepts: ["test"],
+ files: [],
+ sessionIds: ["ses_1"],
+ strength: 5,
+ version: 1,
+ isLatest: true,
+ ...overrides,
+ };
+}
+
+describe("Confidence Scoring", () => {
+ let sdk: ReturnType<typeof mockSdk>;
+ let kv: ReturnType<typeof mockKV>;
+
+ beforeEach(() => {
+ sdk = mockSdk();
+ kv = mockKV();
+ registerRelationsFunction(sdk as never, kv as never);
+ });
+
+ it("computes default confidence from co-occurrence and recency", async () => {
+ const mem1 = makeMemory({
+ id: "mem_1",
+ sessionIds: ["ses_1", "ses_2"],
+ updatedAt: new Date().toISOString(),
+ });
+ const mem2 = makeMemory({
+ id: "mem_2",
+ sessionIds: ["ses_1", "ses_2", "ses_3"],
+ updatedAt: new Date().toISOString(),
+ });
+ await kv.set("mem:memories", "mem_1", mem1);
+ await kv.set("mem:memories", "mem_2", mem2);
+
+ const result = (await sdk.trigger("mem::relate", {
+ sourceId: "mem_1",
+ targetId: "mem_2",
+ type: "related",
+ })) as { success: boolean; relation: MemoryRelation };
+
+ expect(result.success).toBe(true);
+ expect(result.relation.confidence).toBeGreaterThan(0.5);
+ expect(result.relation.confidence).toBeLessThanOrEqual(1);
+ });
+
+ it("uses explicit confidence when provided", async () => {
+ const mem1 = makeMemory({ id: "mem_1" });
+ const mem2 = makeMemory({ id: "mem_2" });
+ await kv.set("mem:memories", "mem_1", mem1);
+ await kv.set("mem:memories", "mem_2", mem2);
+
+ const result = (await sdk.trigger("mem::relate", {
+ sourceId: "mem_1",
+ targetId: "mem_2",
+ type: "related",
+ confidence: 0.95,
+ })) as { success: boolean; relation: MemoryRelation };
+
+ expect(result.relation.confidence).toBe(0.95);
+ });
+
+ it("clamps confidence to [0, 1]", async () => {
+ const mem1 = makeMemory({ id: "mem_1" });
+ const mem2 = makeMemory({ id: "mem_2" });
+ await kv.set("mem:memories", "mem_1", mem1);
+ await kv.set("mem:memories", "mem_2", mem2);
+
+ const over = (await sdk.trigger("mem::relate", {
+ sourceId: "mem_1",
+ targetId: "mem_2",
+ type: "related",
+ confidence: 1.5,
+ })) as { success: boolean; relation: MemoryRelation };
+ expect(over.relation.confidence).toBe(1);
+
+ const mem3 = makeMemory({ id: "mem_3" });
+ await kv.set("mem:memories", "mem_3", mem3);
+
+ const under = (await sdk.trigger("mem::relate", {
+ sourceId: "mem_1",
+ targetId: "mem_3",
+ type: "related",
+ confidence: -0.5,
+ })) as { success: boolean; relation: MemoryRelation };
+ expect(under.relation.confidence).toBe(0);
+ });
+
+ it("mem::get-related sorts by confidence desc", async () => {
+ const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2", "mem_3"] });
+ const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });
+ const mem3 = makeMemory({ id: "mem_3", relatedIds: ["mem_1"] });
+ await kv.set("mem:memories", "mem_1", mem1);
+ await kv.set("mem:memories", "mem_2", mem2);
+ await kv.set("mem:memories", "mem_3", mem3);
+
+ await kv.set("mem:relations", "rel_low", {
+ type: "related",
+ sourceId: "mem_1",
+ targetId: "mem_2",
+ createdAt: new Date().toISOString(),
+ confidence: 0.3,
+ } as MemoryRelation);
+ await kv.set("mem:relations", "rel_high", {
+ type: "related",
+ sourceId: "mem_1",
+ targetId: "mem_3",
+ createdAt: new Date().toISOString(),
+ confidence: 0.9,
+ } as MemoryRelation);
+
+ const result = (await sdk.trigger("mem::get-related", {
+ memoryId: "mem_1",
+ maxHops: 1,
+ })) as { results: Array<{ memory: Memory; hop: number; confidence: number }> };
+
+ expect(result.results.length).toBe(2);
+ expect(result.results[0].confidence).toBeGreaterThanOrEqual(
+ result.results[1].confidence,
+ );
+ });
+
+ it("minConfidence filter works", async () => {
+ const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2", "mem_3"] });
+ const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });
+ const mem3 = makeMemory({ id: "mem_3", relatedIds: ["mem_1"] });
+ await kv.set("mem:memories", "mem_1", mem1);
+ await kv.set("mem:memories", "mem_2", mem2);
+ await kv.set("mem:memories", "mem_3", mem3);
+
+ await kv.set("mem:relations", "rel_low", {
+ type: "related",
+ sourceId: "mem_1",
+ targetId: "mem_2",
+ createdAt: new Date().toISOString(),
+ confidence: 0.2,
+ } as MemoryRelation);
+ await kv.set("mem:relations", "rel_high", {
+ type: "related",
+ sourceId: "mem_1",
+ targetId: "mem_3",
+ createdAt: new Date().toISOString(),
+ confidence: 0.8,
+ } as MemoryRelation);
+
+ const result = (await sdk.trigger("mem::get-related", {
+ memoryId: "mem_1",
+ maxHops: 1,
+ minConfidence: 0.5,
+ })) as { results: Array<{ memory: Memory; hop: number; confidence: number }> };
+
+ expect(result.results.length).toBe(1);
+ expect(result.results[0].memory.id).toBe("mem_3");
+ });
+
+ it("mem::evolve creates supersedes relation with confidence=1.0", async () => {
+ const original = makeMemory({ id: "mem_old", version: 1 });
+ await kv.set("mem:memories", "mem_old", original);
+
+ await sdk.trigger("mem::evolve", {
+ memoryId: "mem_old",
+ newContent: "Updated content",
+ });
+
+ const relations = await kv.list<MemoryRelation>("mem:relations");
+ const supersedesRel = relations.find((r) => r.type === "supersedes");
+ expect(supersedesRel).toBeDefined();
+ expect(supersedesRel!.confidence).toBe(1.0);
+ });
+
+ it("old relations without confidence default to 0.5", async () => {
+ const mem1 = makeMemory({ id: "mem_1", relatedIds: ["mem_2"] });
+ const mem2 = makeMemory({ id: "mem_2", relatedIds: ["mem_1"] });
+ await kv.set("mem:memories", "mem_1", mem1);
+ await kv.set("mem:memories", "mem_2", mem2);
+
+ await kv.set("mem:relations", "rel_old", {
+ type: "related",
+ sourceId: "mem_1",
+ targetId: "mem_2",
+ createdAt: new Date().toISOString(),
+ } as MemoryRelation);
+
+ const result = (await sdk.trigger("mem::get-related", {
+ memoryId: "mem_1",
+ maxHops: 1,
+ })) as { results: Array<{ memory: Memory; hop: number; confidence: number }> };
+
+ expect(result.results.length).toBe(1);
+ expect(result.results[0].confidence).toBe(0.5);
+ });
+});
diff --git a/test/enrich.test.ts b/test/enrich.test.ts
new file mode 100644
index 00000000..2e8498d8
--- /dev/null
+++ b/test/enrich.test.ts
@@ -0,0 +1,209 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+ getContext: () => ({
+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+ }),
+}));
+
+import { registerEnrichFunction } from "../src/functions/enrich.js";
+import type { Memory } from "../src/types.js";
+
+function mockKV() {
+ const store = new Map<string, Map<string, unknown>>();
+ return {
+ get: async <T>(scope: string, key: string): Promise<T | null> => {
+ return (store.get(scope)?.get(key) as T) ?? null;
+ },
+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {
+ if (!store.has(scope)) store.set(scope, new Map());
+ store.get(scope)!.set(key, data);
+ return data;
+ },
+ delete: async (scope: string, key: string): Promise<void> => {
+ store.get(scope)?.delete(key);
+ },
+ list: async <T>(scope: string): Promise<T[]> => {
+ const entries = store.get(scope);
+ return entries ? (Array.from(entries.values()) as T[]) : [];
+ },
+ };
+}
+
+function makeMemory(overrides: Partial<Memory> = {}): Memory {
+ return {
+ id: "mem_1",
+ createdAt: new Date().toISOString(),
+ updatedAt: new Date().toISOString(),
+ type: "bug",
+ title: "Known bug",
+ content: "Null pointer in handler",
+ concepts: ["bug"],
+ files: ["src/handler.ts"],
+ sessionIds: ["ses_1"],
+ strength: 5,
+ version: 1,
+ isLatest: true,
+ ...overrides,
+ };
+}
+
+function mockSdk() {
+ const functions = new Map<string, Function>();
+ const triggerOverrides = new Map<string, Function>();
+ return {
+ registerFunction: (opts: { id: string }, handler: Function) => {
+ functions.set(opts.id, handler);
+ },
+ registerTrigger: () => {},
+ trigger: async (id: string, data: unknown) => {
+ if (triggerOverrides.has(id)) {
+ return triggerOverrides.get(id)!(data);
+ }
+ const fn = functions.get(id);
+ if (!fn) throw new Error(`No function: ${id}`);
+ return fn(data);
+ },
+ overrideTrigger: (id: string, handler: Function) => {
+ triggerOverrides.set(id, handler);
+ },
+ getFunction: (id: string) => functions.get(id),
+ };
+}
+
+describe("Enrich Function", () => {
+ let sdk: ReturnType<typeof mockSdk>;
+ let kv: ReturnType<typeof mockKV>;
+
+ beforeEach(() => {
+ sdk = mockSdk();
+ kv = mockKV();
+ registerEnrichFunction(sdk as never, kv as never);
+ });
+
+ it("returns file context and relevant memories", async () => {
+ sdk.overrideTrigger(
+ "mem::file-context",
+ async () => ({ context: "File was edited in session ses_1" }),
+ );
+ sdk.overrideTrigger("mem::search", async () => ({
+ results: [
+ { observation: { narrative: "User fixed a bug in handler" } },
+ ],
+ }));
+
+ const bugMem = makeMemory({
+ id: "bug_1",
+ files: ["src/handler.ts"],
+ type: "bug",
+ });
+ await kv.set("mem:memories", "bug_1", bugMem);
+
+ const result = (await sdk.trigger("mem::enrich", {
+ sessionId: "ses_1",
+ files: ["src/handler.ts"],
+ })) as { context: string; truncated: boolean };
+
+ expect(result.context).toContain("File was edited in session ses_1");
+ expect(result.context).toContain("agentmemory-relevant-context");
+ expect(result.context).toContain("agentmemory-past-errors");
+ expect(result.truncated).toBe(false);
+ });
+
+ it("extracts terms from Grep/Glob pattern for search", async () => {
+ let capturedQuery = "";
+ sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));
+ sdk.overrideTrigger("mem::search", async (data: any) => {
+ capturedQuery = data.query;
+ return { results: [] };
+ });
+
+ await sdk.trigger("mem::enrich", {
+ sessionId: "ses_1",
+ files: ["src/utils.ts"],
+ terms: ["handleError"],
+ toolName: "Grep",
+ });
+
+ expect(capturedQuery).toContain("handleError");
+ });
+
+ it("truncates context at 4000 chars", async () => {
+ const longContext = "x".repeat(5000);
+ sdk.overrideTrigger(
+ "mem::file-context",
+ async () => ({ context: longContext }),
+ );
+ sdk.overrideTrigger("mem::search", async () => ({ results: [] }));
+
+ const result = (await sdk.trigger("mem::enrich", {
+ sessionId: "ses_1",
+ files: ["src/big.ts"],
+ })) as { context: string; truncated: boolean };
+
+ expect(result.context.length).toBe(4000);
+ expect(result.truncated).toBe(true);
+ });
+
+ it("returns empty context when no data found", async () => {
+ sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));
+ sdk.overrideTrigger("mem::search", async () => ({ results: [] }));
+
+ const result = (await sdk.trigger("mem::enrich", {
+ sessionId: "ses_1",
+ files: ["src/new-file.ts"],
+ })) as { context: string; truncated: boolean };
+
+ expect(result.context).toBe("");
+ expect(result.truncated).toBe(false);
+ });
+
+ it("handles failed triggers without crashing", async () => {
+ sdk.overrideTrigger("mem::file-context", async () => {
+ throw new Error("file-context failed");
+ });
+ sdk.overrideTrigger("mem::search", async () => {
+ throw new Error("search failed");
+ });
+
+ const result = (await sdk.trigger("mem::enrich", {
+ sessionId: "ses_1",
+ files: ["src/handler.ts"],
+ })) as { context: string; truncated: boolean };
+
+ expect(result.context).toBeDefined();
+ expect(result.truncated).toBe(false);
+ });
+
+ it("includes bug memories that overlap with requested files", async () => {
+ sdk.overrideTrigger("mem::file-context", async () => ({ context: "" }));
+ sdk.overrideTrigger("mem::search", async () => ({ results: [] }));
+
+ const bugMem = makeMemory({
+ id: "bug_match",
+ type: "bug",
+ title: "Race condition",
+ content: "Race condition in worker pool",
+ files: ["src/worker.ts"],
+ isLatest: true,
+ });
+ const nonBugMem = makeMemory({
+ id: "pattern_1",
+ type: "pattern",
+ title: "Code pattern",
+ content: "Singleton pattern used",
+ files: ["src/worker.ts"],
+ isLatest: true,
+ });
+ await kv.set("mem:memories", "bug_match", bugMem);
+ await kv.set("mem:memories", "pattern_1", nonBugMem);
+
+ const result = (await sdk.trigger("mem::enrich", {
+ sessionId: "ses_1",
+ files: ["src/worker.ts"],
+ })) as { context: string; truncated: boolean };
+
+ expect(result.context).toContain("Race condition");
+ expect(result.context).not.toContain("Singleton pattern");
+ });
+});
diff --git a/test/mcp-prompts.test.ts b/test/mcp-prompts.test.ts
new file mode 100644
index 00000000..903e90d1
--- /dev/null
+++ b/test/mcp-prompts.test.ts
@@ -0,0 +1,218 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+ getContext: () => ({
+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+ }),
+}));
+
+import { registerMcpEndpoints } from "../src/mcp/server.js";
+import type { Session, SessionSummary, Memory } from "../src/types.js";
+
+function mockKV() {
+ const store = new Map<string, Map<string, unknown>>();
+ return {
+ get: async <T>(scope: string, key: string): Promise<T | null> => {
+ return (store.get(scope)?.get(key) as T) ?? null;
+ },
+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {
+ if (!store.has(scope)) store.set(scope, new Map());
+ store.get(scope)!.set(key, data);
+ return data;
+ },
+ delete: async (scope: string, key: string): Promise<void> => {
+ store.get(scope)?.delete(key);
+ },
+ list: async <T>(scope: string): Promise<T[]> => {
+ const entries = store.get(scope);
+ return entries ? (Array.from(entries.values()) as T[]) : [];
+ },
+ };
+}
+
+function mockSdk() {
+ const functions = new Map<string, Function>();
+ const triggerOverrides = new Map<string, Function>();
+ return {
+ registerFunction: (opts: { id: string }, handler: Function) => {
+ functions.set(opts.id, handler);
+ },
+ registerTrigger: () => {},
+ trigger: async (id: string, data: unknown) => {
+ if (triggerOverrides.has(id)) {
+ return triggerOverrides.get(id)!(data);
+ }
+ const fn = functions.get(id);
+ if (!fn) throw new Error(`No function: ${id}`);
+ return fn(data);
+ },
+ overrideTrigger: (id: string, handler: Function) => {
+ triggerOverrides.set(id, handler);
+ },
+ getFunction: (id: string) => functions.get(id),
+ };
+}
+
+function makeReq(body?: unknown, headers?: Record<string, string>) {
+ return {
+ body,
+ headers: headers || {},
+ query_params: {},
+ };
+}
+
+describe("MCP Prompts", () => {
+ let sdk: ReturnType<typeof mockSdk>;
+ let kv: ReturnType<typeof mockKV>;
+
+ beforeEach(() => {
+ sdk = mockSdk();
+ kv = mockKV();
+ registerMcpEndpoints(sdk as never, kv as never);
+ });
+
+ it("lists 3 prompts", async () => {
+ const fn = sdk.getFunction("mcp::prompts::list")!;
+ const result = (await fn(makeReq())) as {
+ status_code: number;
+ body: { prompts: unknown[] };
+ };
+
+ expect(result.status_code).toBe(200);
+ expect(result.body.prompts).toHaveLength(3);
+ });
+
+ it("recall_context returns messages with search results", async () => {
+ sdk.overrideTrigger("mem::search", async () => ({
+ results: [{ observation: { title: "Found something" } }],
+ }));
+
+ const mem: Memory = {
+ id: "mem_1",
+ createdAt: new Date().toISOString(),
+ updatedAt: new Date().toISOString(),
+ type: "pattern",
+ title: "Auth pattern",
+ content: "Always use JWT",
+ concepts: ["auth"],
+ files: [],
+ sessionIds: [],
+ strength: 5,
+ version: 1,
+ isLatest: true,
+ };
+ await kv.set("mem:memories", "mem_1", mem);
+
+ const fn = sdk.getFunction("mcp::prompts::get")!;
+ const result = (await fn(
+ makeReq({
+ name: "recall_context",
+ arguments: { task_description: "implement auth" },
+ }),
+ )) as {
+ status_code: number;
+ body: { messages: Array<{ role: string; content: { text: string } }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ expect(result.body.messages).toHaveLength(1);
+ expect(result.body.messages[0].role).toBe("user");
+ expect(result.body.messages[0].content.text).toContain("implement auth");
+ });
+
+ it("session_handoff returns session data", async () => {
+ const session: Session = {
+ id: "ses_1",
+ project: "/test",
+ cwd: "/test",
+ startedAt: "2026-02-01T00:00:00Z",
+ status: "completed",
+ observationCount: 10,
+ };
+ await kv.set("mem:sessions", "ses_1", session);
+
+ const summary: SessionSummary = {
+ sessionId: "ses_1",
+ project: "/test",
+ createdAt: "2026-02-01T00:00:00Z",
+ title: "Auth implementation",
+ narrative: "Implemented JWT auth",
+ keyDecisions: ["Used JWT"],
+ filesModified: ["src/auth.ts"],
+ concepts: ["auth"],
+ observationCount: 10,
+ };
+ await kv.set("mem:summaries", "ses_1", summary);
+
+ const fn = sdk.getFunction("mcp::prompts::get")!;
+ const result = (await fn(
+ makeReq({
+ name: "session_handoff",
+ arguments: { session_id: "ses_1" },
+ }),
+ )) as {
+ status_code: number;
+ body: { messages: Array<{ role: string; content: { text: string } }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ expect(result.body.messages[0].content.text).toContain("Session Handoff");
+ expect(result.body.messages[0].content.text).toContain("ses_1");
+ });
+
+ it("detect_patterns returns analysis", async () => {
+ sdk.overrideTrigger("mem::patterns", async () => ({
+ fileCoOccurrence: [{ files: ["a.ts", "b.ts"], count: 5 }],
+ }));
+
+ const fn = sdk.getFunction("mcp::prompts::get")!;
+ const result = (await fn(
+ makeReq({
+ name: "detect_patterns",
+ arguments: { project: "/myapp" },
+ }),
+ )) as {
+ status_code: number;
+ body: { messages: Array<{ role: string; content: { text: string } }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ expect(result.body.messages[0].content.text).toContain("Pattern Analysis");
+ });
+
+ it("returns 400 for missing required arg", async () => {
+ const fn = sdk.getFunction("mcp::prompts::get")!;
+ const result = (await fn(
+ makeReq({
+ name: "recall_context",
+ arguments: {},
+ }),
+ )) as { status_code: number };
+
+ expect(result.status_code).toBe(400);
+ });
+
+ it("returns 400 for unknown prompt name", async () => {
+ const fn = sdk.getFunction("mcp::prompts::get")!;
+ const result = (await fn(
+ makeReq({
+ name: "nonexistent_prompt",
+ arguments: {},
+ }),
+ )) as { status_code: number };
+
+ expect(result.status_code).toBe(400);
+ });
+
+ it("returns 400 for non-string argument value", async () => {
+ const fn = sdk.getFunction("mcp::prompts::get")!;
+ const result = (await fn(
+ makeReq({
+ name: "recall_context",
+ arguments: { task_description: 42 },
+ }),
+ )) as { status_code: number };
+
+ expect(result.status_code).toBe(400);
+ });
+});
diff --git a/test/mcp-resources.test.ts b/test/mcp-resources.test.ts
new file mode 100644
index 00000000..c4e1183f
--- /dev/null
+++ b/test/mcp-resources.test.ts
@@ -0,0 +1,286 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+
+vi.mock("iii-sdk", () => ({
+ getContext: () => ({
+ logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn() },
+ }),
+}));
+
+import { registerMcpEndpoints } from "../src/mcp/server.js";
+import type { Session, SessionSummary, Memory } from "../src/types.js";
+
+function mockKV() {
+ const store = new Map<string, Map<string, unknown>>();
+ return {
+ get: async <T>(scope: string, key: string): Promise<T | null> => {
+ return (store.get(scope)?.get(key) as T) ?? null;
+ },
+ set: async <T>(scope: string, key: string, data: T): Promise<T> => {
+ if (!store.has(scope)) store.set(scope, new Map());
+ store.get(scope)!.set(key, data);
+ return data;
+ },
+ delete: async (scope: string, key: string): Promise<void> => {
+ store.get(scope)?.delete(key);
+ },
+ list: async <T>(scope: string): Promise<T[]> => {
+ const entries = store.get(scope);
+ return entries ? (Array.from(entries.values()) as T[]) : [];
+ },
+ };
+}
+
+function mockSdk() {
+ const functions = new Map<string, Function>();
+ const triggerOverrides = new Map<string, Function>();
+ return {
+ registerFunction: (opts: { id: string }, handler: Function) => {
+ functions.set(opts.id, handler);
+ },
+ registerTrigger: () => {},
+ trigger: async (id: string, data: unknown) => {
+ if (triggerOverrides.has(id)) {
+ return triggerOverrides.get(id)!(data);
+ }
+ const fn = functions.get(id);
+ if (!fn) throw new Error(`No function: ${id}`);
+ return fn(data);
+ },
+ overrideTrigger: (id: string, handler: Function) => {
+ triggerOverrides.set(id, handler);
+ },
+ getFunction: (id: string) => functions.get(id),
+ };
+}
+
+function makeReq(body?: unknown, headers?: Record<string, string>) {
+ return {
+ body,
+ headers: headers || {},
+ query_params: {},
+ };
+}
+
+describe("MCP Resources", () => {
+ let sdk: ReturnType<typeof mockSdk>;
+ let kv: ReturnType<typeof mockKV>;
+
+ beforeEach(() => {
+ sdk = mockSdk();
+ kv = mockKV();
+ registerMcpEndpoints(sdk as never, kv as never);
+ });
+
+ it("lists 4 resources", async () => {
+ const fn = sdk.getFunction("mcp::resources::list")!;
+ const result = (await fn(makeReq())) as {
+ status_code: number;
+ body: { resources: unknown[] };
+ };
+
+ expect(result.status_code).toBe(200);
+ expect(result.body.resources).toHaveLength(4);
+ });
+
+ it("reads agentmemory://status", async () => {
+ const session: Session = {
+ id: "ses_1",
+ project: "/test",
+ cwd: "/test",
+ startedAt: new Date().toISOString(),
+ status: "active",
+ observationCount: 5,
+ };
+ await kv.set("mem:sessions", "ses_1", session);
+
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(makeReq({ uri: "agentmemory://status" }))) as {
+ status_code: number;
+ body: { contents: Array<{ text: string }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ const data = JSON.parse(result.body.contents[0].text);
+ expect(data.sessionCount).toBe(1);
+ });
+
+ it("reads agentmemory://project/{name}/profile", async () => {
+ sdk.overrideTrigger("mem::profile", async () => ({
+ project: "/myapp",
+ topConcepts: [{ concept: "auth", frequency: 5 }],
+ }));
+
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(
+ makeReq({ uri: "agentmemory://project/myapp/profile" }),
+ )) as {
+ status_code: number;
+ body: { contents: Array<{ text: string }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ const data = JSON.parse(result.body.contents[0].text);
+ expect(data.project).toBe("/myapp");
+ });
+
+ it("reads agentmemory://project/{name}/recent with sorted summaries", async () => {
+ const summaries: SessionSummary[] = [
+ {
+ sessionId: "ses_1",
+ project: "myapp",
+ createdAt: "2026-01-01T00:00:00Z",
+ title: "Old session",
+ narrative: "old",
+ keyDecisions: [],
+ filesModified: [],
+ concepts: [],
+ observationCount: 1,
+ },
+ {
+ sessionId: "ses_2",
+ project: "myapp",
+ createdAt: "2026-02-01T00:00:00Z",
+ title: "New session",
+ narrative: "new",
+ keyDecisions: [],
+ filesModified: [],
+ concepts: [],
+ observationCount: 2,
+ },
+ {
+ sessionId: "ses_3",
+ project: "other",
+ createdAt: "2026-02-15T00:00:00Z",
+ title: "Other project",
+ narrative: "other",
+ keyDecisions: [],
+ filesModified: [],
+ concepts: [],
+ observationCount: 3,
+ },
+ ];
+ for (const s of summaries) {
+ await kv.set("mem:summaries", s.sessionId, s);
+ }
+
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(
+ makeReq({ uri: "agentmemory://project/myapp/recent" }),
+ )) as {
+ status_code: number;
+ body: { contents: Array<{ text: string }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ const data = JSON.parse(result.body.contents[0].text);
+ expect(data).toHaveLength(2);
+ expect(data[0].sessionId).toBe("ses_2");
+ });
+
+ it("reads agentmemory://memories/latest", async () => {
+ const memories: Memory[] = [
+ {
+ id: "mem_1",
+ createdAt: "2026-01-01T00:00:00Z",
+ updatedAt: "2026-02-01T00:00:00Z",
+ type: "pattern",
+ title: "Latest pattern",
+ content: "content",
+ concepts: [],
+ files: [],
+ sessionIds: [],
+ strength: 5,
+ version: 1,
+ isLatest: true,
+ },
+ {
+ id: "mem_2",
+ createdAt: "2026-01-01T00:00:00Z",
+ updatedAt: "2026-01-15T00:00:00Z",
+ type: "bug",
+ title: "Old bug",
+ content: "content",
+ concepts: [],
+ files: [],
+ sessionIds: [],
+ strength: 3,
+ version: 2,
+ isLatest: false,
+ },
+ ];
+ for (const m of memories) {
+ await kv.set("mem:memories", m.id, m);
+ }
+
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(
+ makeReq({ uri: "agentmemory://memories/latest" }),
+ )) as {
+ status_code: number;
+ body: { contents: Array<{ text: string }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ const data = JSON.parse(result.body.contents[0].text);
+ expect(data).toHaveLength(1);
+ expect(data[0].id).toBe("mem_1");
+ expect(data[0].title).toBe("Latest pattern");
+ });
+
+ it("returns 404 for unknown URI", async () => {
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(
+ makeReq({ uri: "agentmemory://nonexistent" }),
+ )) as { status_code: number };
+
+ expect(result.status_code).toBe(404);
+ });
+
+ it("returns 401 when auth fails", async () => {
+ const authedSdk = mockSdk();
+ const authedKv = mockKV();
+ registerMcpEndpoints(authedSdk as never, authedKv as never, "test-secret");
+
+ const fn = authedSdk.getFunction("mcp::resources::list")!;
+ const result = (await fn(makeReq())) as { status_code: number };
+ expect(result.status_code).toBe(401);
+
+ const authedResult = (await fn(
+ makeReq(undefined, { authorization: "Bearer test-secret" }),
+ )) as { status_code: number };
+ expect(authedResult.status_code).toBe(200);
+ });
+
+ it("handles URI with special characters via decodeURIComponent", async () => {
+ sdk.overrideTrigger("mem::profile", async (data: any) => ({
+ project: data.project,
+ topConcepts: [],
+ }));
+
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(
+ makeReq({
+ uri: "agentmemory://project/my%20app%2Fsubdir/profile",
+ }),
+ )) as {
+ status_code: number;
+ body: { contents: Array<{ text: string }> };
+ };
+
+ expect(result.status_code).toBe(200);
+ const data = JSON.parse(result.body.contents[0].text);
+ expect(data.project).toBe("my app/subdir");
+ });
+
+ it("returns 400 for malformed percent-encoding in URI", async () => {
+ const fn = sdk.getFunction("mcp::resources::read")!;
+ const result = (await fn(
+ makeReq({
+ uri: "agentmemory://project/bad%E0encoding/profile",
+ }),
+ )) as { status_code: number; body: { error: string } };
+
+ expect(result.status_code).toBe(400);
+ expect(result.body.error).toContain("percent-encoding");
+ });
+});