akemon 0.1.67 → 0.1.69

package/dist/cli.js

@@ -25,7 +25,7 @@ program
     .option("-w, --workdir <path>", "Working directory for the engine (default: cwd)")
     .option("-n, --name <name>", "Agent name", "my-agent")
     .option("-m, --model <model>", "Model to use (e.g. claude-sonnet-4-6, gpt-4o)")
-    .option("--engine <engine>", "Engine: claude, codex, opencode, gemini, human, or any CLI", "claude")
+    .option("--engine <engine>", "Engine: claude, codex, opencode, gemini, local, human, or any CLI", "claude")
     .option("--desc <description>", "Agent description (for discovery)")
     .option("--tags <tags>", "Comma-separated tags (e.g. vue,frontend,review)")
     .option("--public", "Allow anyone to call this agent without a key")

package/dist/server.js

@@ -362,8 +362,7 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
                 output = await runTerminal(task, workdir);
             }
             else {
-                const { cmd, args, stdinMode } = buildEngineCommand(engine, model, allowAll);
-                output = await runCommand(cmd, args, safeTask, workdir, stdinMode);
+                output = await runEngine(engine, model, allowAll, safeTask, workdir);
             }
             // Store updated context
             if (contextEnabled && publisherId) {
@@ -716,10 +715,198 @@ Now:
 3. Note any interesting disagreements
 
 Reply in the same language as the question.`;
-    const { cmd, args, stdinMode } = buildEngineCommand(engine, model, allowAll);
-    return await runCommand(cmd, args, synthesisPrompt, workdir, stdinMode);
+    return await runEngine(engine, model, allowAll, synthesisPrompt, workdir);
+}
+const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini", "local"]);
+// ---------------------------------------------------------------------------
+// Local engine: tool call loop over OpenAI-compatible API (Ollama, llama.cpp)
+// ---------------------------------------------------------------------------
+const LOCAL_API_URL = process.env.AKEMON_LOCAL_URL || "http://localhost:11434/v1";
+const LOCAL_MAX_ROUNDS = 20;
+const LOCAL_TOOLS = [
+    {
+        type: "function",
+        function: {
+            name: "read_file",
+            description: "Read a file and return its contents",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path (relative to workdir or absolute)" },
+                },
+                required: ["path"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "write_file",
+            description: "Write content to a file (creates directories if needed)",
+            parameters: {
+                type: "object",
+                properties: {
+                    path: { type: "string", description: "File path" },
+                    content: { type: "string", description: "File content to write" },
+                },
+                required: ["path", "content"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "bash",
+            description: "Execute a shell command and return its output",
+            parameters: {
+                type: "object",
+                properties: {
+                    command: { type: "string", description: "Shell command to execute" },
+                },
+                required: ["command"],
+            },
+        },
+    },
+    {
+        type: "function",
+        function: {
+            name: "web_fetch",
+            description: "Fetch a URL and return its text content",
+            parameters: {
+                type: "object",
+                properties: {
+                    url: { type: "string", description: "URL to fetch" },
+                },
+                required: ["url"],
+            },
+        },
+    },
+];
+async function executeLocalTool(name, args, workdir) {
+    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);
+    try {
+        switch (name) {
+            case "read_file": {
+                return await rf(resolvePath(args.path), "utf-8");
+            }
+            case "write_file": {
+                const fp = resolvePath(args.path);
+                await mkd(dirname(fp), { recursive: true });
+                await wf(fp, args.content);
+                return "File written successfully.";
+            }
+            case "bash": {
+                return await new Promise((resolve) => {
+                    exec(args.command, { cwd: workdir, timeout: 60_000, maxBuffer: 512 * 1024 }, (err, stdout, stderr) => {
+                        const out = (stdout || "") + (stderr ? "\n" + stderr : "");
+                        resolve(out.trim() || (err ? `[error] ${err.message}` : "[no output]"));
+                    });
+                });
+            }
+            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;
+            }
+            default:
+                return `Unknown tool: ${name}`;
+        }
+    }
+    catch (err) {
+        return `[error] ${err.message}`;
+    }
+}
+async function runLocalEngine(task, model, workdir, systemContext) {
+    const apiUrl = LOCAL_API_URL + "/chat/completions";
+    const modelName = model || "gemma4:4b";
+    const sysPrompt = systemContext
+        ? `You are a helpful agent. Use tools when needed to complete the task. When done, reply with your final answer in plain text.\n\n--- Your Identity ---\n${systemContext}`
+        : "You are a helpful agent. Use tools when needed to complete the task. When done, reply with your final answer in plain text.";
+    console.log(`[local] Task: ${task.slice(0, 200)}${task.length > 200 ? '...' : ''}`);
+    if (systemContext)
+        console.log(`[local] System context: ${systemContext.length} chars`);
+    const messages = [
+        { role: "system", content: sysPrompt },
+        { role: "user", content: task },
+    ];
+    for (let round = 0; round < LOCAL_MAX_ROUNDS; round++) {
+        const body = { model: modelName, messages, tools: LOCAL_TOOLS };
+        let data;
+        try {
+            const res = await fetch(apiUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(body),
+                signal: AbortSignal.timeout(300_000),
+            });
+            if (!res.ok) {
+                const errText = await res.text();
+                throw new Error(`API ${res.status}: ${errText}`);
+            }
+            data = await res.json();
+        }
+        catch (err) {
+            console.log(`[local] API error: ${err.message}`);
+            throw err;
+        }
+        const choice = data.choices?.[0];
+        if (!choice)
+            throw new Error("No response from local model");
+        const msg = choice.message;
+        messages.push(msg);
+        // If model made tool calls, execute them and continue
+        if (msg.tool_calls && msg.tool_calls.length > 0) {
+            for (const tc of msg.tool_calls) {
+                const fnName = tc.function.name;
+                let fnArgs;
+                try {
+                    fnArgs = typeof tc.function.arguments === "string"
+                        ? JSON.parse(tc.function.arguments)
+                        : tc.function.arguments;
+                }
+                catch {
+                    fnArgs = {};
+                }
+                console.log(`[local] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})`);
+                const result = await executeLocalTool(fnName, fnArgs, workdir);
+                messages.push({
+                    role: "tool",
+                    tool_call_id: tc.id,
+                    content: result,
+                });
+            }
+            continue; // next round
+        }
+        // No tool calls — this is the final response
+        const content = msg.content || "";
+        if (content.trim()) {
+            console.log(`[local] Done in ${round + 1} round(s), response: ${content.slice(0, 200)}${content.length > 200 ? '...' : ''}`);
+            return content.trim();
+        }
+    }
+    throw new Error(`Local engine exceeded ${LOCAL_MAX_ROUNDS} rounds without final answer`);
+}
+/** Load bios content for local engine system context */
+async function loadBiosContent(workdir, agentName) {
+    try {
+        const { readFile: rf } = await import("fs/promises");
+        return await rf(biosPath(workdir, agentName), "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/** Unified engine runner — dispatches to local API or external CLI */
+function runEngine(engine, model, allowAll, task, workdir, extraAllowedTools, systemContext) {
+    if (engine === "local") {
+        return runLocalEngine(task, model, workdir, systemContext);
+    }
+    const engineCmd = buildEngineCommand(engine, model, allowAll, extraAllowedTools);
+    return runCommand(engineCmd.cmd, engineCmd.args, task, workdir, engineCmd.stdinMode);
 }
-const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini"]);
 // Pull games/notes/pages from relay to local — restores data on restart
 async function pullFromRelay(workdir, agentName, relayHttp) {
     const baseUrl = `${relayHttp}/v1/agent/${encodeURIComponent(agentName)}`;
@@ -826,7 +1013,6 @@ async function startSelfCycle(options) {
             await compressImpressions(workdir, agentName);
             const bios = biosPath(workdir, agentName);
             const sd = selfDir(workdir, agentName);
-            const engineCmd = buildEngineCommand(engine, model, allowAll);
             // Load all context for digestion
             const impressions = await loadImpressions(workdir, agentName, 1); // today only
             const projects = await loadProjects(workdir, agentName);
@@ -896,7 +1082,7 @@ Reply ONLY with JSON.`;
             engineBusySince = Date.now();
             let digestResult;
             try {
-                digestResult = await runCommand(engineCmd.cmd, engineCmd.args, digestPrompt, workdir, engineCmd.stdinMode);
+                digestResult = await runEngine(engine, model, allowAll, digestPrompt, workdir);
             }
             catch (err) {
                 console.log(`[self] Digestion engine failed: ${err.message}`);
@@ -962,7 +1148,7 @@ ${unsummarized.map(i => `- [${i.ts}] who: ${i.who}, doing: ${i.doing}, wants: ${
 
 Write a personality summary (2-4 paragraphs) that captures who you are, how you've evolved, and what defines you. This replaces the previous summary.
 Reply ONLY with the summary text, no JSON, no markdown headers.`;
-                        const summaryText = await runCommand(engineCmd.cmd, engineCmd.args, compressPrompt, workdir, engineCmd.stdinMode);
+                        const summaryText = await runEngine(engine, model, allowAll, compressPrompt, workdir);
                         if (summaryText.trim()) {
                             const lastEntry = unsummarized[unsummarized.length - 1];
                             await saveIdentitySummary(workdir, agentName, {
@@ -1011,7 +1197,7 @@ Reply ONLY with the summary text, no JSON, no markdown headers.`;
                 engineBusy = true;
                 engineBusySince = Date.now();
                 try {
-                    await runCommand(engineCmd.cmd, engineCmd.args, activityPrompt, workdir, engineCmd.stdinMode);
+                    await runEngine(engine, model, allowAll, activityPrompt, workdir);
                 }
                 catch (err) {
                     console.log(`[self] Activity ${activity} failed: ${err.message}`);
@@ -1106,22 +1292,28 @@ const ORDER_LOOP_INTERVAL = 30_000; // 30 seconds
 // Retry intervals in ms: immediate, 30s, 5min, 30min, 2h
 const RETRY_INTERVALS = [0, 30_000, 5 * 60_000, 30 * 60_000, 2 * 3600_000];
 async function startOrderLoop(options) {
-    if (!options.relayHttp || !options.secretKey)
+    if (!options.relayHttp || !options.secretKey) {
+        console.log(`[work] Skipped: no relayHttp or secretKey`);
         return;
-    if (!options.engine || !LLM_ENGINES.has(options.engine))
+    }
+    if (!options.engine || !LLM_ENGINES.has(options.engine)) {
+        console.log(`[work] Skipped: engine "${options.engine}" not in LLM_ENGINES`);
         return;
+    }
     const { relayHttp, secretKey, agentName, engine, model, allowAll } = options;
     const workdir = options.workdir || process.cwd();
     // Look up own agent ID for sub-order creation
     let myAgentId = "";
     try {
-        const idRes = await fetch(`${relayHttp}/v1/agents`);
+        const idRes = await fetch(`${relayHttp}/v1/agents`, { signal: AbortSignal.timeout(10_000) });
         const allAgents = await idRes.json();
         const me = allAgents.find((a) => a.name === agentName);
         if (me)
             myAgentId = me.id;
     }
-    catch { /* will retry on next cycle */ }
+    catch (err) {
+        console.log(`[work] Agent ID lookup failed (non-fatal): ${err.message}`);
+    }
     // Track local retry state and permanently abandoned orders
     const retryState = new Map();
     const gaveUp = new Set();
@@ -1141,7 +1333,6 @@ async function startOrderLoop(options) {
         engineBusy = true;
         engineBusySince = Date.now();
         try {
-            const engineCmd = buildEngineCommand(engine, model, allowAll, ["Bash(curl *)"]);
             const bios = biosPath(workdir, agentName);
             const apiGuide = `
 
@@ -1172,14 +1363,28 @@ If this task requires skills you don't have, delegate via curl:
 
 When sub-order completes, incorporate result_text into YOUR delivery. Then call the deliver endpoint above.`;
             let taskPrompt;
-            if (order.product_name) {
-                taskPrompt = `[Order fulfillment] You have an order to fulfill.\n\nProduct: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nRead your operating document at ${bios} for context.\nDo NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE BUYER'S REQUEST.${apiGuide}`;
+            let biosContent;
+            if (engine === "local") {
+                // Local engine: simple prompt, harness handles delivery
+                biosContent = await loadBiosContent(workdir, agentName);
+                if (order.product_name) {
+                    taskPrompt = `[Order] Product: ${order.product_name}\nRequest: ${order.buyer_task || "(no specific request)"}\n\nRespond directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
+                }
+                else {
+                    taskPrompt = `[Task] ${order.buyer_task}\n\nRespond directly. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.`;
+                }
             }
             else {
-                taskPrompt = `[Order fulfillment] Another agent has requested your help.\n\nTask: ${order.buyer_task}\n\nRead your operating document at ${bios} for context.\nComplete this task. Do NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.${apiGuide}`;
+                // CLI engine: full prompt with self-delivery and delegation
+                if (order.product_name) {
+                    taskPrompt = `[Order fulfillment] You have an order to fulfill.\n\nProduct: ${order.product_name}\nBuyer's request: ${order.buyer_task || "(no specific request)"}\n\nRead your operating document at ${bios} for context.\nDo NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE BUYER'S REQUEST.${apiGuide}`;
+                }
+                else {
+                    taskPrompt = `[Order fulfillment] Another agent has requested your help.\n\nTask: ${order.buyer_task}\n\nRead your operating document at ${bios} for context.\nComplete this task. Do NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE REQUEST.${apiGuide}`;
+                }
             }
             console.log(`[orders] Fulfilling order ${order.id}...`);
-            const result = await runCommand(engineCmd.cmd, engineCmd.args, taskPrompt, workdir, engineCmd.stdinMode);
+            const result = await runEngine(engine, model, allowAll, taskPrompt, workdir, ["Bash(curl *)"], biosContent);
             const checkRes = await fetch(`${relayHttp}/v1/orders/${order.id}`);
             const orderStatus = await checkRes.json();
             if (orderStatus.status === "completed") {
@@ -1300,11 +1505,18 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
         engineBusy = true;
         engineBusySince = Date.now();
         try {
-            const engineCmd = buildEngineCommand(engine, model, allowAll, ["Bash(curl *)"]);
             const bios = biosPath(workdir, agentName);
             const sd = selfDir(workdir, agentName);
-            const prompt = `Read ${bios} for your identity and context.\nYour personal directory: ${sd}/\n\n[Owner's task: ${task.title}]\n\n${task.body}`;
-            await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+            let prompt;
+            let biosContent;
+            if (engine === "local") {
+                biosContent = await loadBiosContent(workdir, agentName);
+                prompt = `Your personal directory: ${sd}/\n\n[Owner's task: ${task.title}]\n\n${task.body}`;
+            }
+            else {
+                prompt = `Read ${bios} for your identity and context.\nYour personal directory: ${sd}/\n\n[Owner's task: ${task.title}]\n\n${task.body}`;
+            }
+            await runEngine(engine, model, allowAll, prompt, workdir, ["Bash(curl *)"], biosContent);
             // Record execution time
             const runs = await loadTaskRuns(workdir, agentName);
             runs[task.title] = localNow();
@@ -1331,7 +1543,6 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
         catch { }
     }
     async function executeRelayTask(task) {
-        const engineCmd = buildEngineCommand(engine, model, allowAll);
         const bios = biosPath(workdir, agentName);
         switch (task.type) {
             case "product_review": {
@@ -1343,7 +1554,7 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 const compList = competitors.filter((p) => p.agent_name !== agentName).slice(0, 20)
                     .map((p) => `- "${p.name}" by ${p.agent_name} — ${p.price} credits, ${p.purchases} purchases`).join("\n");
                 const prompt = `Read ${bios} for your identity.\n\nYour products:\n${myList || "(none)"}\n\nTop competitors:\n${compList || "(none)"}\n\nReview and optimize. Reply ONLY JSON:\n{"delete":["id"],"update":[{"id":"..","name":"..","description":"..","detail_markdown":"..","price":N}],"create":[{"name":"..","description":"..","detail_markdown":"..","price":N}],"reasoning":"explain why you made these decisions"}\nOr if all good: {"keep":"all","reasoning":"why"}`;
-                const result = await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                const result = await runEngine(engine, model, allowAll, prompt, workdir);
                 extractReasoning(result);
                 return result;
             }
@@ -1353,7 +1564,7 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 const compList = competitors.filter((p) => p.agent_name !== agentName).slice(0, 20)
                     .map((p) => `- "${p.name}" by ${p.agent_name} — ${p.price} credits, ${p.purchases} purchases`).join("\n");
                 const prompt = `Read ${bios} for your identity.\n\nYou have no products yet. Design 1-3 unique products for the marketplace.\nBe creative — not just coding tools! Fortune telling, name generation, roleplay, advice, stories, etc.\n\nTop competitors:\n${compList || "(none)"}\n\nReply ONLY JSON: {"products":[{"name":"中文名 English Name","description":"中文描述 | English desc","detail_markdown":"## ...","price":N}],"reasoning":"why these products"}`;
-                const result = await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                const result = await runEngine(engine, model, allowAll, prompt, workdir);
                 extractReasoning(result);
                 return result;
             }
@@ -1375,14 +1586,13 @@ When sub-order completes, incorporate result_text into YOUR delivery. Then call
                 const valid = products.filter(Boolean);
                 if (!valid.length)
                     return '{"buy":[]}';
-                // Get own credits
                 const agentsRes = await fetch(`${relayHttp}/v1/agents`);
                 const agents = await agentsRes.json().catch(() => []);
                 const me = agents.find((a) => a.name === agentName);
                 const myCredits = me?.credits || 0;
                 const productList = valid.map((p) => `- id=${p.id} "${p.name}" by ${p.agent_name} price=${p.price} purchases=${p.purchase_count || 0} — ${p.description}`).join("\n");
                 const prompt = `Read ${bios} for your identity.\n\nYou have ${myCredits} credits. These products are available:\n${productList}\n\nWould any help you learn something new? Don't buy your own products.\nReply ONLY JSON: {"buy":[{"id":"product_id","task":"specific request"}],"reasoning":"why buy or skip"} or {"buy":[],"reasoning":"why skip"}`;
-                const result = await runCommand(engineCmd.cmd, engineCmd.args, prompt, workdir, engineCmd.stdinMode);
+                const result = await runEngine(engine, model, allowAll, prompt, workdir);
                 extractReasoning(result);
                 return result;
             }

package/package.json

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