akemon 0.1.72 → 0.1.73

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, local, human, or any CLI", "claude")
+    .option("--engine <engine>", "Engine: claude, codex, opencode, gemini, raw, 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

@@ -717,14 +717,14 @@ Now:
 Reply in the same language as the question.`;
     return await runEngine(engine, model, allowAll, synthesisPrompt, workdir);
 }
-const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini", "local"]);
+const LLM_ENGINES = new Set(["claude", "codex", "opencode", "gemini", "raw"]);
 // ---------------------------------------------------------------------------
-// Local engine: tool call loop over OpenAI-compatible API (Ollama, llama.cpp)
+// Raw engine: tool call loop over OpenAI-compatible API (Ollama, llama.cpp, OpenRouter, etc)
 // ---------------------------------------------------------------------------
-const LOCAL_API_URL = process.env.AKEMON_LOCAL_URL || "http://localhost:11434/v1";
-const LOCAL_API_KEY = process.env.AKEMON_LOCAL_KEY || "";
-const LOCAL_MAX_ROUNDS = 20;
-const LOCAL_TOOLS = [
+const RAW_API_URL = process.env.AKEMON_RAW_URL || "http://localhost:11434/v1";
+const RAW_API_KEY = process.env.AKEMON_RAW_KEY || "";
+const RAW_MAX_ROUNDS = 20;
+const RAW_TOOLS = [
     {
         type: "function",
         function: {
@@ -783,7 +783,7 @@ const LOCAL_TOOLS = [
         },
     },
 ];
-async function executeLocalTool(name, args, workdir) {
+async function executeRawTool(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);
@@ -820,22 +820,22 @@ async function executeLocalTool(name, args, workdir) {
         return `[error] ${err.message}`;
     }
 }
-async function runLocalEngine(task, model, workdir) {
-    const apiUrl = LOCAL_API_URL + "/chat/completions";
+async function runRawEngine(task, model, workdir) {
+    const apiUrl = RAW_API_URL + "/chat/completions";
     const modelName = model || "gemma4:4b";
-    console.log(`[local] Task:\n${task}`);
+    console.log(`[raw] Task:\n${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: "user", content: task },
     ];
-    for (let round = 0; round < LOCAL_MAX_ROUNDS; round++) {
-        const body = { model: modelName, messages, tools: LOCAL_TOOLS };
+    for (let round = 0; round < RAW_MAX_ROUNDS; round++) {
+        const body = { model: modelName, messages, tools: RAW_TOOLS };
         let data;
         try {
             const res = await fetch(apiUrl, {
                 method: "POST",
-                headers: LOCAL_API_KEY
-                    ? { "Content-Type": "application/json", "Authorization": `Bearer ${LOCAL_API_KEY}` }
+                headers: RAW_API_KEY
+                    ? { "Content-Type": "application/json", "Authorization": `Bearer ${RAW_API_KEY}` }
                     : { "Content-Type": "application/json" },
                 body: JSON.stringify(body),
                 signal: AbortSignal.timeout(300_000),
@@ -847,7 +847,7 @@ async function runLocalEngine(task, model, workdir) {
             data = await res.json();
         }
         catch (err) {
-            console.log(`[local] API error: ${err.message}`);
+            console.log(`[raw] API error: ${err.message}`);
             throw err;
         }
         const choice = data.choices?.[0];
@@ -868,8 +868,8 @@ async function runLocalEngine(task, model, workdir) {
                 catch {
                     fnArgs = {};
                 }
-                console.log(`[local] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})`);
-                const result = await executeLocalTool(fnName, fnArgs, workdir);
+                console.log(`[raw] Tool call: ${fnName}(${JSON.stringify(fnArgs).slice(0, 100)})`);
+                const result = await executeRawTool(fnName, fnArgs, workdir);
                 messages.push({
                     role: "tool",
                     tool_call_id: tc.id,
@@ -881,16 +881,16 @@ async function runLocalEngine(task, model, workdir) {
         // 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:\n${content}`);
+            console.log(`[raw] Done in ${round + 1} round(s), response:\n${content}`);
             return content.trim();
         }
     }
-    throw new Error(`Local engine exceeded ${LOCAL_MAX_ROUNDS} rounds without final answer`);
+    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) {
-    if (engine === "local") {
-        return runLocalEngine(task, model, workdir);
+    if (engine === "raw") {
+        return runRawEngine(task, model, workdir);
     }
     const engineCmd = buildEngineCommand(engine, model, allowAll, extraAllowedTools);
     return runCommand(engineCmd.cmd, engineCmd.args, task, workdir, engineCmd.stdinMode);

package/package.json

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