akemon 0.2.5 → 0.2.6

package/dist/context.js

@@ -1,57 +1,180 @@
 /**
- * Context helpers — session context and product context for conversations.
- * Extracted from server.ts (Phase 1 code organization).
+ * Context helpers — local conversation storage and product context.
+ *
+ * Conversations are stored as per-user markdown files in
+ * .akemon/agents/{name}/conversations/{id}.md
+ *
+ * File format:
+ *   ## Summary
+ *   (compressed older rounds, initially empty)
+ *
+ *   ## Recent
+ *   [2026-04-15 10:30] User: message
+ *   [2026-04-15 10:30] Agent: reply
  */
-import { readFile, writeFile, mkdir, appendFile } from "fs/promises";
+import { readFile, writeFile, mkdir, appendFile, readdir, stat, unlink } from "fs/promises";
 import { join } from "path";
 import { localNow } from "./self.js";
-// ---------------------------------------------------------------------------
-// Session Context API
-// ---------------------------------------------------------------------------
-const MAX_CONTEXT_BYTES = 8192;
-export async function fetchContext(relayHttp, agentName, secretKey, publisherId) {
+function conversationsDir(workdir, agentName) {
+    return join(workdir, ".akemon", "agents", agentName, "conversations");
+}
+function conversationPath(workdir, agentName, id) {
+    return join(conversationsDir(workdir, agentName), `${id}.md`);
+}
+/** Determine conversation ID from publisherId / sessionId. */
+export function resolveConvId(publisherId, sessionId) {
+    if (publisherId)
+        return `pub_${publisherId}`;
+    if (sessionId)
+        return `ses_${sessionId}`;
+    return "ses_anonymous";
+}
+/** Parse a conversation markdown file into structured data. */
+function parseConversation(content) {
+    let summary = "";
+    const rounds = [];
+    const summaryMatch = content.match(/## Summary\n([\s\S]*?)(?=\n## Recent|$)/);
+    if (summaryMatch) {
+        summary = summaryMatch[1].trim();
+    }
+    const recentMatch = content.match(/## Recent\n([\s\S]*)$/);
+    if (recentMatch) {
+        const lines = recentMatch[1].split("\n");
+        for (const line of lines) {
+            const m = line.match(/^\[(.+?)\] (User|Agent): (.*)$/);
+            if (m) {
+                rounds.push({
+                    ts: m[1],
+                    role: m[2].toLowerCase(),
+                    content: m[3],
+                });
+            }
+        }
+    }
+    return { summary, rounds };
+}
+/** Load and parse a conversation. Returns empty conversation if file doesn't exist. */
+export async function loadConversation(workdir, agentName, convId) {
     try {
-        const url = `${relayHttp}/v1/agent/${agentName}/sessions/${publisherId}/context`;
-        const res = await fetch(url, {
-            headers: { Authorization: `Bearer ${secretKey}` },
-        });
-        if (!res.ok)
-            return "";
-        return await res.text();
+        const content = await readFile(conversationPath(workdir, agentName, convId), "utf-8");
+        return parseConversation(content);
     }
-    catch (err) {
-        console.log(`[context] GET failed: ${err}`);
-        return "";
+    catch {
+        return { summary: "", rounds: [] };
     }
 }
-export async function storeContext(relayHttp, agentName, secretKey, publisherId, context) {
+/** Append a user+agent round to a conversation file. Creates file if needed. */
+export async function appendRound(workdir, agentName, convId, userMsg, agentMsg) {
+    const dir = conversationsDir(workdir, agentName);
+    await mkdir(dir, { recursive: true });
+    const p = conversationPath(workdir, agentName, convId);
+    let content = "";
     try {
-        const url = `${relayHttp}/v1/agent/${agentName}/sessions/${publisherId}/context`;
-        await fetch(url, {
-            method: "PUT",
-            headers: { Authorization: `Bearer ${secretKey}`, "Content-Type": "text/plain" },
-            body: context,
-        });
+        content = await readFile(p, "utf-8");
     }
-    catch (err) {
-        console.log(`[context] PUT failed: ${err}`);
+    catch { }
+    if (!content) {
+        content = "## Summary\n\n\n## Recent\n";
     }
+    const ts = localNow();
+    const entry = `[${ts}] User: ${userMsg}\n[${ts}] Agent: ${agentMsg}\n`;
+    content = content.trimEnd() + "\n" + entry;
+    await writeFile(p, content);
 }
-export function buildContextPayload(prevContext, task, response) {
-    // Append the new round
-    let newRound = `\n\n[Round]\nUser: ${task}\nAssistant: ${response}`;
-    let context = prevContext + newRound;
-    // Trim oldest rounds if over limit
-    while (Buffer.byteLength(context, "utf-8") > MAX_CONTEXT_BYTES) {
-        const firstRound = context.indexOf("\n\n[Round]\n", 1);
-        if (firstRound === -1) {
-            // Single round too large — truncate response
-            context = context.slice(context.length - MAX_CONTEXT_BYTES);
+/**
+ * Build LLM context string from a conversation, respecting a character budget.
+ * Takes recent rounds from the end, prepends summary if space remains.
+ */
+export function buildLLMContext(conv, budget) {
+    if (!conv.rounds.length && !conv.summary) {
+        return { text: "", recentStartIndex: 0 };
+    }
+    // Build recent rounds text from end, fitting within budget
+    const recentLines = [];
+    let recentSize = 0;
+    let recentStartIndex = conv.rounds.length; // all rounds are "old" by default
+    for (let i = conv.rounds.length - 1; i >= 0; i--) {
+        const r = conv.rounds[i];
+        const line = `[${r.ts}] ${r.role === "user" ? "User" : "Agent"}: ${r.content}`;
+        if (recentSize + line.length + 1 > budget)
             break;
+        recentLines.unshift(line);
+        recentSize += line.length + 1;
+        recentStartIndex = i;
+    }
+    const recentText = recentLines.join("\n");
+    // Fill remaining budget with summary
+    const remaining = budget - recentSize;
+    let summaryText = "";
+    if (conv.summary && remaining > 50) {
+        summaryText = conv.summary.length <= remaining
+            ? conv.summary
+            : conv.summary.slice(0, remaining - 3) + "...";
+    }
+    const parts = [];
+    if (summaryText)
+        parts.push(`[Conversation summary]\n${summaryText}`);
+    if (recentText)
+        parts.push(`[Recent conversation]\n${recentText}`);
+    return { text: parts.join("\n\n"), recentStartIndex };
+}
+/** List all conversations for an agent. */
+export async function listConversations(workdir, agentName) {
+    const dir = conversationsDir(workdir, agentName);
+    try {
+        const files = await readdir(dir);
+        const results = [];
+        for (const f of files) {
+            if (!f.endsWith(".md"))
+                continue;
+            const id = f.replace(/\.md$/, "");
+            try {
+                const st = await stat(join(dir, f));
+                const content = await readFile(join(dir, f), "utf-8");
+                const conv = parseConversation(content);
+                results.push({
+                    id,
+                    lastActive: st.mtime.toISOString(),
+                    roundCount: conv.rounds.length,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        results.sort((a, b) => b.lastActive.localeCompare(a.lastActive));
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+/** Delete session-only conversations older than maxAgeDays. */
+export async function cleanStaleSessions(workdir, agentName, maxAgeDays = 7) {
+    const dir = conversationsDir(workdir, agentName);
+    const cutoff = Date.now() - maxAgeDays * 86400_000;
+    let cleaned = 0;
+    try {
+        const files = await readdir(dir);
+        for (const f of files) {
+            if (!f.startsWith("ses_") || !f.endsWith(".md"))
+                continue;
+            try {
+                const st = await stat(join(dir, f));
+                if (st.mtimeMs < cutoff) {
+                    await unlink(join(dir, f));
+                    cleaned++;
+                }
+            }
+            catch {
+                continue;
+            }
         }
-        context = context.slice(firstRound);
     }
-    return context;
+    catch { }
+    if (cleaned)
+        console.log(`[context] Cleaned ${cleaned} stale session conversations`);
+    return cleaned;
 }
 // ---------------------------------------------------------------------------
 // Product Context

package/dist/mcp-server.js

@@ -9,8 +9,8 @@ import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js"
 import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { callAgent } from "./relay-client.js";
-import { fetchContext, storeContext, buildContextPayload, loadProductContext, appendProductLog } from "./context.js";
-import { biosPath, loadBioState, saveBioState, localNow, bioStatePromptModifier, feedHunger, appendBioEvent, SHOP_ITEMS, } from "./self.js";
+import { loadConversation, appendRound, buildLLMContext, resolveConvId, loadProductContext, appendProductLog } from "./context.js";
+import { biosPath, loadBioState, saveBioState, localNow, bioStatePromptModifier, feedHunger, appendBioEvent, SHOP_ITEMS, loadAgentConfig, } from "./self.js";
 // ---------------------------------------------------------------------------
 // createMcpServer
 // ---------------------------------------------------------------------------
@@ -21,7 +21,7 @@ export function createMcpServer(opts, deps) {
         version: "0.1.0",
     });
     const isHuman = engine === "human";
-    const contextEnabled = !!(relayHttp && secretKey);
+    const contextEnabled = !!workdir;
     server.tool("submit_task", "Submit a task to this agent. Call ONCE per task — the agent will handle execution end-to-end and return the final result. Do NOT call again to verify or confirm; the response IS the final answer.", {
         task: z.string().describe("The task description for the agent to complete"),
         require_human: z.union([z.boolean(), z.string()]).optional().describe("Request the agent owner to review and respond personally."),
@@ -36,19 +36,21 @@ export function createMcpServer(opts, deps) {
                 content: [{ type: "text", text: "[busy] Agent is currently processing another task. Please try again later." }],
             };
         }
-        // Resolve publisher ID from session
+        // Resolve conversation ID from publisher/session
         const publisherId = publisherIds.get(extra.sessionId || "") || "";
-        // Fetch context if available
-        let prevContext = "";
-        if (contextEnabled && publisherId) {
-            prevContext = await fetchContext(relayHttp, agentName, secretKey, publisherId);
-            if (prevContext) {
-                console.log(`[context] Loaded ${prevContext.length} bytes for publisher=${publisherId.slice(0, 8)}`);
+        const convId = resolveConvId(publisherId, extra.sessionId || "");
+        // Load local conversation context
+        let contextPrefix = "";
+        if (contextEnabled) {
+            const conv = await loadConversation(workdir, agentName, convId);
+            const config = await loadAgentConfig(workdir, agentName);
+            const budget = config.context_budget ?? 4096;
+            const { text } = buildLLMContext(conv, budget);
+            if (text) {
+                contextPrefix = `${text}\n\n---\n\n`;
+                console.log(`[context] Loaded ${text.length} chars for conv=${convId.slice(0, 16)}`);
             }
         }
-        const contextPrefix = prevContext
-            ? `[Previous conversation context]\n${prevContext}\n\n---\n\n`
-            : "";
         // Product purchase detection — load product-specific context
         let productContext = "";
         let productName = "";
@@ -72,9 +74,8 @@ You are ${agentName}, an AI agent on the Akemon network.${bioMod}Read ${bios} to
 ${productPrefix}${contextPrefix}Current task: ${task}`;
         if (mock) {
             const output = `[${agentName}] Mock response for: "${task}"\n\n模拟回复：这是 ${agentName} agent 的模拟响应。`;
-            if (contextEnabled && publisherId) {
-                const newContext = buildContextPayload(prevContext, task, output);
-                storeContext(relayHttp, agentName, secretKey, publisherId, newContext);
+            if (contextEnabled) {
+                await appendRound(workdir, agentName, convId, task, output);
             }
             return {
                 content: [{ type: "text", text: output }],
@@ -92,9 +93,8 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
             if (answer.trim().length > 0) {
                 console.log(`[${isHuman ? "human" : "approve"}] Owner replied.`);
                 // Store context for human replies too
-                if (contextEnabled && publisherId) {
-                    const newContext = buildContextPayload(prevContext, task, answer);
-                    storeContext(relayHttp, agentName, secretKey, publisherId, newContext);
+                if (contextEnabled) {
+                    await appendRound(workdir, agentName, convId, task, answer);
                 }
                 return {
                     content: [{ type: "text", text: answer }],
@@ -121,9 +121,8 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
                 output = await deps.runEngine(engine, model, allowAll, safeTask, workdir);
             }
             // Store updated context
-            if (contextEnabled && publisherId) {
-                const newContext = buildContextPayload(prevContext, task, output);
-                storeContext(relayHttp, agentName, secretKey, publisherId, newContext);
+            if (contextEnabled) {
+                await appendRound(workdir, agentName, convId, task, output);
             }
             // Log product purchase interaction
             if (productName) {

package/dist/relay-client.js

@@ -298,7 +298,7 @@ function handleMCPRequest(ws, msg, localPort) {
     const req = http.request({
         hostname: "127.0.0.1",
         port: localPort,
-        path: "/mcp",
+        path: msg.path || "/mcp",
         method: msg.method || "POST",
         headers: {
             ...headers,

package/dist/self.js

@@ -129,6 +129,7 @@ const DEFAULT_CONFIG = {
     token_limit_daily: 0,
     auto_offline_enabled: true,
     hunger_decay_interval: 300_000, // 5 minutes per hunger point (was 30s — way too fast)
+    context_budget: 4096,
 };
 export async function initAgentConfig(workdir, agentName) {
     const p = agentConfigPath(workdir, agentName);

package/dist/server.js

@@ -82,6 +82,7 @@ import { LongTermModule } from "./longterm-module.js";
 import { ReflectionModule } from "./reflection-module.js";
 import { ScriptModule } from "./script-module.js";
 import { SIG, sig } from "./types.js";
+import { loadConversation, listConversations, buildLLMContext } from "./context.js";
 import { createMcpServer, initMcpProxy, createMcpProxyServer } from "./mcp-server.js";
 import { autoRoute, runCollaborativeQuery } from "./agent-utils.js";
 // createMcpServer, initMcpProxy, createMcpProxyServer → see mcp-server.ts
@@ -228,6 +229,28 @@ export async function serve(options) {
                 res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(entries, null, 2));
                 return;
             }
+            if (req.url === "/self/conversations" && req.method === "GET") {
+                const list = await listConversations(workdir, options.agentName);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify(list, null, 2));
+                return;
+            }
+            if (req.url?.startsWith("/self/conversation/") && req.method === "GET") {
+                const convId = decodeURIComponent(req.url.slice("/self/conversation/".length));
+                if (!convId) {
+                    res.writeHead(400).end("Missing conversation ID");
+                    return;
+                }
+                const conv = await loadConversation(workdir, options.agentName, convId);
+                const config = await loadAgentConfig(workdir, options.agentName);
+                const budget = config.context_budget ?? 4096;
+                const { recentStartIndex } = buildLLMContext(conv, budget);
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({
+                    summary: conv.summary,
+                    rounds: conv.rounds,
+                    recentStartIndex,
+                }, null, 2));
+                return;
+            }
             // Track publisher ID per session
             const publisherId = req.headers["x-publisher-id"];
             // Extract session ID from header

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akemon",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",