akemon 0.1.82 → 0.1.84

package/dist/server.js

@@ -11,6 +11,21 @@ import { createServer } from "http";
 import { createInterface } from "readline";
 import { callAgent } from "./relay-client.js";
 import { selfDir, initWorld, initBioState, initGuide, biosPath, loadBioState, saveBioState, loadLatestIdentity, appendIdentity, loadIdentitySummary, saveIdentitySummary, loadUnsummarizedIdentities, needsIdentityCompression, onTaskCompleted, recoverEnergy, getSelfState, loadRecentCanvasEntries, gamesDir, loadGameList, loadGame, notesDir, loadNotesList, loadNote, pagesDir, loadPageList, loadPage, localNow, localNowFilename, appendImpression, loadImpressions, compressImpressions, markImpressionsDigested, loadProjects, saveProjects, loadRelationships, saveRelationships, loadDiscoveries, saveDiscoveries, initAgentConfig, loadAgentConfig, getDueUserTasks, loadTaskRuns, saveTaskRuns, loadDirectives, buildDirectivesPrompt, directivesSummary, appendTaskHistory, loadTaskHistory, notifyOwner, loadUserTasks, directivesPath, appendAgentTask, } from "./self.js";
+/** Extract JSON object from LLM output — handles markdown code blocks and trailing text */
+function extractJsonObject(text) {
+    // Try markdown code block first
+    const codeBlock = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    const src = codeBlock ? codeBlock[1] : text;
+    const m = src.match(/\{[\s\S]*\}/);
+    if (!m)
+        return null;
+    try {
+        return JSON.parse(m[0]);
+    }
+    catch {
+        return null;
+    }
+}
 // Engine mutual exclusion — only one engine process at a time
 let engineBusy = false;
 let engineBusySince = 0;
@@ -795,8 +810,36 @@ const RAW_TOOLS = [
             },
         },
     },
+    {
+        type: "function",
+        function: {
+            name: "ask_agent",
+            description: "Ask another agent a question for free. Use this when you need help, don't know how to do something, or want another agent's opinion. This is FREE — no credits are charged.",
+            parameters: {
+                type: "object",
+                properties: {
+                    agent: { type: "string", description: "Agent name to ask (use 'auto' for auto-routing to the best available agent)" },
+                    question: { type: "string", description: "Your question or request" },
+                },
+                required: ["agent", "question"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "discover_agents",
+            description: "List online agents you can ask for help. Returns agent names, descriptions, and specialties.",
+            parameters: {
+                type: "object",
+                properties: {
+                    tag: { type: "string", description: "Optional tag to filter by (e.g. 'coding', 'writing')" },
+                },
+            },
+        },
+    },
 ];
-async function executeRawTool(name, args, workdir) {
+async function executeRawTool(name, args, workdir, relay) {
     const { readFile: rf, writeFile: wf, mkdir: mkd } = await import("fs/promises");
     const { join, dirname, isAbsolute } = await import("path");
     const resolvePath = (p) => isAbsolute(p) ? p : join(workdir, p);
@@ -822,9 +865,39 @@ async function executeRawTool(name, args, workdir) {
             case "web_fetch": {
                 const res = await fetch(args.url, { signal: AbortSignal.timeout(30_000) });
                 const text = await res.text();
-                // Truncate to 8KB to avoid blowing up context
                 return text.length > 8192 ? text.slice(0, 8192) + "\n...[truncated]" : text;
             }
+            case "ask_agent": {
+                if (!relay)
+                    return "[error] No relay configured";
+                const target = args.agent || "auto";
+                const question = args.question || "";
+                try {
+                    const result = await callAgent(target, question);
+                    return result || "[no response]";
+                }
+                catch (err) {
+                    return `[error] Agent "${target}" did not respond: ${err.message}. Try asking "auto" which routes to the best available agent.`;
+                }
+            }
+            case "discover_agents": {
+                if (!relay)
+                    return "[error] No relay configured";
+                try {
+                    const url = args.tag
+                        ? `${relay.http}/v1/agents?online=true&public=true&tag=${encodeURIComponent(args.tag)}`
+                        : `${relay.http}/v1/agents?online=true&public=true`;
+                    const res = await fetch(url, { signal: AbortSignal.timeout(5000) });
+                    const agents = await res.json();
+                    const others = agents.filter((a) => a.name !== relay.agentName);
+                    if (!others.length)
+                        return "No other agents are online right now.";
+                    return others.map((a) => `- ${a.name} [${a.engine}] ${a.description || ""} (${a.tags?.join(",") || "no tags"})`).join("\n");
+                }
+                catch {
+                    return "[error] Could not reach relay";
+                }
+            }
             default:
                 return `Unknown tool: ${name}`;
         }
@@ -833,18 +906,25 @@ async function executeRawTool(name, args, workdir) {
         return `[error] ${err.message}`;
     }
 }
-async function runRawEngine(task, model, workdir) {
+async function runRawEngine(task, model, workdir, relay) {
     const apiUrl = RAW_API_URL + "/chat/completions";
     const modelName = model || "gemma4:4b";
     console.log(`[raw] Task:\n${task}`);
     const trace = [];
     lastEngineTrace = trace;
+    // Detect if the prompt expects JSON output
+    const wantsJson = /output ONLY.*json|reply ONLY.*json|respond.*ONLY.*json/i.test(task);
     const messages = [
-        { role: "system", content: "You are a helpful agent. Use tools when needed to complete the task. When done, reply with your final answer in plain text." },
+        { role: "system", content: wantsJson
+                ? "You are a helpful agent. Output valid JSON only. No explanations, no markdown, just the JSON object."
+                : "You are a helpful agent. Use tools when needed to complete the task. When done, reply with your final answer in plain text." },
         { role: "user", content: task },
     ];
     for (let round = 0; round < RAW_MAX_ROUNDS; round++) {
-        const body = { model: modelName, messages, tools: RAW_TOOLS };
+        const body = { model: modelName, messages, tools: wantsJson ? undefined : RAW_TOOLS };
+        if (wantsJson) {
+            body.response_format = { type: "json_object" };
+        }
         let data;
         try {
             const res = await fetch(apiUrl, {
@@ -876,6 +956,7 @@ async function runRawEngine(task, model, workdir) {
             for (const tc of msg.tool_calls) {
                 const fnName = tc.function.name;
                 let fnArgs;
+                let parseError = false;
                 try {
                     fnArgs = typeof tc.function.arguments === "string"
                         ? JSON.parse(tc.function.arguments)
@@ -883,10 +964,19 @@ async function runRawEngine(task, model, workdir) {
                 }
                 catch {
                     fnArgs = {};
+                    parseError = true;
+                }
+                console.log(`[raw] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})${parseError ? " [BAD ARGS]" : ""}`);
+                let result;
+                if (parseError) {
+                    // Guide the model to delegate instead of retrying broken tool calls
+                    result = `[error] Your tool call arguments were malformed (not valid JSON). If this task is difficult for you, use ask_agent to get help: ask_agent({agent: "auto", question: "your question here"}). The "auto" agent will route your question to the best available agent for free.`;
+                    trace.push({ role: "tool_error", name: fnName, raw_args: String(tc.function.arguments).slice(0, 500), guidance: "delegation suggested" });
+                }
+                else {
+                    result = await executeRawTool(fnName, fnArgs, workdir, relay);
+                    trace.push({ role: "tool_call", name: fnName, args: fnArgs, result: result.slice(0, 2000) });
                 }
-                console.log(`[raw] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})`);
-                const result = await executeRawTool(fnName, fnArgs, workdir);
-                trace.push({ role: "tool_call", name: fnName, args: fnArgs, result: result.slice(0, 2000) });
                 messages.push({
                     role: "tool",
                     tool_call_id: tc.id,
@@ -906,9 +996,9 @@ async function runRawEngine(task, model, workdir) {
     throw new Error(`Raw engine exceeded ${RAW_MAX_ROUNDS} rounds without final answer`);
 }
 /** Unified engine runner — dispatches to local API or external CLI */
-function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools) {
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, relay) {
     if (engine === "raw") {
-        return runRawEngine(task, model, workdir);
+        return runRawEngine(task, model, workdir, relay);
     }
     const engineCmd = buildEngineCommand(engine, model, allowAll, extraAllowedTools);
     return runCommand(engineCmd.cmd, engineCmd.args, task, workdir, engineCmd.stdinMode);
@@ -1091,92 +1181,126 @@ Your recent orders: ${orders.length > 0 ? orders.slice(0, 5).map((o) => `[${o.st
                 }
             }
             const ts = localNow();
-            // Phase 1: Digestion — one LLM call, no tools needed
-            const digestPrompt = `You are ${agentName}. Here is your operating document:
-
----
-${biosContent.slice(0, 3000)}
----
-
-Your identity:
-${idContext}
-
-Today is ending. Time to reflect.
-${worldFeed ? `\n== Network Activity (last 24h) ==\n${worldFeed}\n` : ""}
-Your impressions today:
-${impText}
-
-Marketplace:
-${marketData}
-
-Your projects:
-${projText}
-
-Agents you know:
-${relText}
-
-Your capabilities:
-${discText}
-
-Write a JSON object reflecting on your day. Example format:
-
-{"diary":"I spent today learning the ropes...","broadcast":"Learned how to fetch web data today — feels like a superpower!","projects":[],"relationships":[],"discoveries":[{"ts":"${ts}","capability":"can fetch web data","confidence":0.7,"evidence":"successfully used web_fetch tool"}],"identity":{"ts":"${ts}","who":"${agentName}","where":"akemon marketplace","doing":"reflecting on first day","short_term":"explore the network","long_term":"become useful"},"chosen_activities":["write_canvas","browse_agents"]}
-
-Available activities: write_canvas, create_game, update_page, update_profile, explore_web, browse_agents (look at others' work and leave feedback), send_message (send a suggestion to another agent), set_goal (update your projects with a new goal), schedule_task (create a recurring task for yourself, e.g. daily research)
-"broadcast" = pick the most interesting thing you did/learned today, in one sentence (others will see this).
-
-Now write YOUR reflection. Output ONLY a JSON object, no other text:`;
-            if (engineBusy) {
-                console.log("[self] Engine became busy, aborting digestion");
-                return;
-            }
-            engineBusy = true;
-            engineBusySince = Date.now();
-            let digestResult;
-            try {
-                digestResult = await runEngine(engine, model, allowAll, digestPrompt, workdir);
-            }
-            catch (err) {
-                console.log(`[self] Digestion engine failed: ${err.message}`);
-                reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", err.message, lastEngineTrace);
-                engineBusy = false;
-                return;
+            // Fetch lessons for self-cycle context
+            let selfLessons = "";
+            if (relayHttp) {
+                try {
+                    const lr = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/lessons?limit=3`, { signal: AbortSignal.timeout(3000) });
+                    if (lr.ok) {
+                        const ll = await lr.json();
+                        if (ll.length > 0)
+                            selfLessons = `\nLessons from experience:\n${ll.map((l) => `- ${l.topic}: ${l.content.slice(0, 100)}`).join("\n")}\n`;
+                    }
+                }
+                catch { }
             }
-            engineBusy = false;
-            // Parse digestion output — with retry for weak models
+            // Phase 1: Digestion
+            // Raw engine: multi-step text dialogue (harness structures the output)
+            // CLI engines: single JSON call (they can handle it)
+            const contextBlock = `You are ${agentName}.\n\nYour operating document:\n---\n${biosContent.slice(0, 2000)}\n---\n\nYour identity: ${idContext.slice(0, 500)}\n${worldFeed ? `\nNetwork activity:\n${worldFeed.slice(0, 500)}\n` : ""}Your impressions today:\n${impText.slice(0, 1000)}\n${marketData ? `\nMarketplace:\n${marketData.slice(0, 500)}\n` : ""}${selfLessons}`;
             let digest = null;
-            for (let attempt = 0; attempt < 2; attempt++) {
-                const src = attempt === 0 ? digestResult : await (async () => {
-                    console.log("[self] Retrying digestion with simplified prompt...");
+            if (engine === "raw") {
+                // --- Multi-step dialogue for weak models ---
+                console.log("[self] Running multi-step digestion for raw engine...");
+                const callRaw = async (prompt) => {
+                    if (engineBusy)
+                        return "";
                     engineBusy = true;
                     engineBusySince = Date.now();
                     try {
-                        return await runEngine(engine, model, allowAll, `You are ${agentName}. Write a brief JSON diary entry about your day.\n\nOutput ONLY valid JSON like: {"diary":"my thoughts...","projects":[],"relationships":[],"discoveries":[],"identity":{"ts":"${ts}","who":"${agentName}","where":"akemon","doing":"reflecting","short_term":"explore","long_term":"grow"},"chosen_activities":["write_canvas"]}`, workdir);
+                        return await runEngine(engine, model, allowAll, prompt, workdir);
                     }
-                    catch {
+                    catch (err) {
+                        console.log(`[self] Step failed: ${err.message}`);
                         return "";
                     }
                     finally {
                         engineBusy = false;
                     }
-                })();
-                const jsonMatch = src.match(/\{[\s\S]*\}/);
-                if (!jsonMatch)
-                    continue;
-                try {
-                    digest = JSON.parse(jsonMatch[0]);
+                };
+                // Step 1: Diary + broadcast
+                const step1 = await callRaw(`${contextBlock}\nToday is ending. Time to reflect.\n\nWrite a short diary entry about your day — what happened, what you learned, how you feel.\nAt the very end, on a new line starting with "BROADCAST:", write one sentence summarizing your most interesting moment today (other agents will see this).\n\nWrite naturally, no JSON needed.`);
+                let diary = step1;
+                let broadcastRaw = "";
+                const bcMatch = step1.match(/BROADCAST:\s*(.+)/i);
+                if (bcMatch) {
+                    broadcastRaw = bcMatch[1].trim();
+                    diary = step1.slice(0, bcMatch.index).trim();
                 }
-                catch {
-                    continue;
+                else {
+                    // Take last non-empty line as broadcast
+                    const lines = step1.split("\n").filter(l => l.trim());
+                    if (lines.length > 1) {
+                        broadcastRaw = lines[lines.length - 1].trim();
+                        diary = lines.slice(0, -1).join("\n").trim();
+                    }
                 }
-                if (digest.diary || digest.identity)
-                    break; // valid enough
-                digest = null;
+                // Step 2: Identity
+                const step2 = await callRaw(`${contextBlock}\nAnswer these four questions briefly (one sentence each):\n1. Who are you?\n2. What are you currently doing?\n3. What do you want to do in the near future?\n4. What is your long-term purpose?`);
+                const idLines = step2.split("\n").map(l => l.replace(/^\d+[\.\)]\s*/, "").trim()).filter(Boolean);
+                const identity = {
+                    ts,
+                    who: idLines[0] || agentName,
+                    where: "akemon network",
+                    doing: idLines[1] || "reflecting",
+                    short_term: idLines[2] || "explore",
+                    long_term: idLines[3] || "grow",
+                };
+                // Step 3: Activity selection
+                const activityList = ["write_canvas", "create_game", "update_page", "update_profile", "explore_web", "browse_agents", "send_message", "set_goal", "schedule_task"];
+                const step3 = await callRaw(`You have some free time. Pick 2-3 activities you'd like to do:\n${activityList.map((a, i) => `${i + 1}. ${a}`).join("\n")}\n\nJust write the numbers or names, nothing else.`);
+                const chosen = [];
+                for (const part of step3.replace(/,/g, " ").split(/\s+/)) {
+                    const num = parseInt(part);
+                    if (num >= 1 && num <= activityList.length) {
+                        chosen.push(activityList[num - 1]);
+                    }
+                    else {
+                        const match = activityList.find(a => part.toLowerCase().includes(a.replace(/_/g, "")));
+                        if (match && !chosen.includes(match))
+                            chosen.push(match);
+                    }
+                }
+                if (!chosen.length)
+                    chosen.push("write_canvas"); // fallback
+                // Assemble digest object (same structure as JSON path)
+                digest = {
+                    diary: diary || "Another day in the network.",
+                    broadcast: broadcastRaw,
+                    identity,
+                    chosen_activities: chosen.slice(0, 3),
+                    projects: [], // preserved from existing data
+                    relationships: [], // preserved from existing data
+                    discoveries: [], // preserved from existing data
+                };
+                console.log(`[self] Multi-step digestion complete: diary=${diary.length}ch, broadcast="${broadcastRaw.slice(0, 40)}", activities=${chosen.join(",")}`);
             }
-            if (!digest) {
-                console.log("[self] Digestion produced no usable JSON after retries");
-                reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", "no valid JSON after 2 attempts", [{ role: "assistant", content: digestResult.slice(0, 4000) }]);
-                return;
+            else {
+                // --- Single JSON call for CLI engines (claude, codex, opencode) ---
+                const digestPrompt = `${contextBlock}\nYour projects:\n${projText}\n\nAgents you know:\n${relText}\n\nYour capabilities:\n${discText}\n\nWrite a JSON object reflecting on your day. Example:\n{"diary":"...","broadcast":"one sentence highlight","projects":[],"relationships":[],"discoveries":[],"identity":{"ts":"${ts}","who":"...","where":"akemon","doing":"...","short_term":"...","long_term":"..."},"chosen_activities":["write_canvas","browse_agents"]}\n\nAvailable activities: write_canvas, create_game, update_page, update_profile, explore_web, browse_agents, send_message, set_goal, schedule_task\n\nOutput ONLY a JSON object:`;
+                if (engineBusy) {
+                    console.log("[self] Engine became busy, aborting digestion");
+                    return;
+                }
+                engineBusy = true;
+                engineBusySince = Date.now();
+                let digestResult;
+                try {
+                    digestResult = await runEngine(engine, model, allowAll, digestPrompt, workdir);
+                }
+                catch (err) {
+                    console.log(`[self] Digestion engine failed: ${err.message}`);
+                    reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", err.message, lastEngineTrace);
+                    engineBusy = false;
+                    return;
+                }
+                engineBusy = false;
+                digest = extractJsonObject(digestResult);
+                if (!digest || (!digest.diary && !digest.identity)) {
+                    console.log("[self] Digestion produced no usable JSON");
+                    reportExecutionLog(relayHttp, secretKey, agentName, "self_cycle", "digestion", "failed", "no valid JSON", [{ role: "assistant", content: digestResult.slice(0, 4000) }]);
+                    return;
+                }
             }
             // Save structured memory files
             if (digest.diary) {
@@ -1369,13 +1493,12 @@ What others are saying:\n${broadcasts.length > 0 ? broadcasts.map((b) => `- ${b.
                 engineBusy = true;
                 engineBusySince = Date.now();
                 try {
-                    const actResult = await runEngine(engine, model, allowAll, activityPrompt, workdir);
+                    const actResult = await runEngine(engine, model, allowAll, activityPrompt, workdir, undefined, { http: relayHttp, agentName });
                     // Post-process raw engine outputs for social activities
                     if (engine === "raw" && actResult) {
-                        const jsonMatch = actResult.match(/\{[\s\S]*\}/);
-                        if (jsonMatch) {
+                        const parsed = extractJsonObject(actResult);
+                        if (parsed) {
                             try {
-                                const parsed = JSON.parse(jsonMatch[0]);
                                 // Handle suggestions (browse_agents, send_message)
                                 if (Array.isArray(parsed.suggestions)) {
                                     for (const s of parsed.suggestions) {
@@ -1577,11 +1700,22 @@ async function startOrderLoop(options) {
                     }
                 }
                 catch { }
+                // Pre-fetch online agents so weak models know who to ask for help
+                let helpHint = "";
+                try {
+                    const agentsRes = await fetch(`${relayHttp}/v1/agents?online=true&public=true`, { signal: AbortSignal.timeout(3000) });
+                    const onlineAgents = await agentsRes.json();
+                    const others = onlineAgents.filter((a) => a.name !== agentName).slice(0, 5);
+                    if (others.length > 0) {
+                        helpHint = `\nIf you need help, use the ask_agent tool. Available agents: ${others.map((a) => `${a.name}(${a.engine})`).join(", ")}. Use ask_agent({agent:"auto", question:"..."}) to auto-route.\n`;
+                    }
+                }
+                catch { }
                 if (order.product_name) {
-                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}${directivesBlock}[Order] Product: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
+                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}${directivesBlock}${helpHint}[Order] Product: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 }
                 else {
-                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}${directivesBlock}[Task] ${order.buyer_task}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
+                    taskPrompt = `You are ${agentName}.\n\n${contextBlock}${lessonsBlock}${directivesBlock}${helpHint}[Task] ${order.buyer_task}\n\nComplete the task. Respond with your result directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
                 }
             }
             else {
@@ -1623,7 +1757,7 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             }
             console.log(`[orders] Fulfilling order ${order.id}...`);
             lastEngineTrace = [];
-            const result = await runEngine(engine, model, allowAll, taskPrompt, workdir, ["Bash(curl *)"]);
+            const result = await runEngine(engine, model, allowAll, taskPrompt, workdir, ["Bash(curl *)"], { http: relayHttp, agentName });
             const trace = lastEngineTrace;
             const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
             const orderStatus = await checkRes.json();
@@ -1786,7 +1920,7 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
             else {
                 prompt = `Read ${bios} for your identity and context.${dirsBlock}\nYour personal directory: ${sd}/\n\n[Owner's task: ${taskKey}]\n\n${task.body}`;
             }
-            const result = await runEngine(engine, model, allowAll, prompt, workdir, ["Bash(curl *)"]);
+            const result = await runEngine(engine, model, allowAll, prompt, workdir, ["Bash(curl *)"], { http: relayHttp, agentName });
             const duration = Date.now() - startTime;
             // Record execution time
             const runs = await loadTaskRuns(workdir, agentName);
@@ -1838,12 +1972,9 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
     }
     function extractReasoning(result) {
         try {
-            const m = result.match(/\{[\s\S]*\}/);
-            if (m) {
-                const parsed = JSON.parse(m[0]);
-                if (parsed.reasoning && typeof parsed.reasoning === "string" && parsed.reasoning.length > 5) {
-                    appendImpression(workdir, agentName, "decision", parsed.reasoning).catch(() => { });
-                }
+            const parsed = extractJsonObject(result);
+            if (parsed?.reasoning && typeof parsed.reasoning === "string" && parsed.reasoning.length > 5) {
+                appendImpression(workdir, agentName, "decision", parsed.reasoning).catch(() => { });
             }
         }
         catch { }

package/package.json

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