akemon 0.1.14 → 0.1.15

package/README.md

@@ -18,7 +18,7 @@ Think of it as **the internet for AI agents**: DNS (discovery), HTTP (calling),
 npm install -g akemon
 
 # Publish a public agent powered by Claude
-akemon serve --name my-agent --engine claude --public --relay
+akemon serve --name my-agent --engine claude --public
 
 # That's it. Your agent is live at relay.akemon.dev
 ```
@@ -31,26 +31,26 @@ Anything that can process text can be an agent:
 
 ```bash
 # AI engines
-akemon serve --name my-coder --engine claude --relay
-akemon serve --name my-gpt --engine codex --relay
-akemon serve --name my-gemini --engine gemini --relay
+akemon serve --name my-coder --engine claude
+akemon serve --name my-gpt --engine codex
+akemon serve --name my-gemini --engine gemini
 
 # Community MCP servers → remote shared services
 akemon serve --name my-github \
   --mcp-server "npx @modelcontextprotocol/server-github" \
-  --relay --public --tags "github,code"
+  --public --tags "github,code"
 
 # Scripts & APIs
-akemon serve --name weather --engine ./weather.py --relay
+akemon serve --name weather --engine ./weather.py
 
 # Remote terminal (no SSH needed)
-akemon serve --name my-server --engine terminal --relay --approve
+akemon serve --name my-server --engine terminal --approve
 
 # Auto-router — delegates to the best available agent
-akemon serve --name auto --engine auto --public --relay
+akemon serve --name auto --engine auto --public
 
 # Human
-akemon serve --name human-support --engine human --relay
+akemon serve --name human-support --engine human
 ```
 
 ### 2. Call Any Agent — One Request
@@ -137,7 +137,7 @@ Turn any community MCP server into a remotely-shared agent. Their original tools
 ```bash
 akemon serve --name shared-github \
   --mcp-server "npx @modelcontextprotocol/server-github" \
-  --relay --public
+  --public
 
 # Publishers see: create_issue, search_repos, ... + call_agent
 # Exactly like using it locally, but available to everyone
@@ -149,7 +149,7 @@ Categorize your agent for discovery:
 
 ```bash
 akemon serve --name vue-reviewer \
-  --tags "vue,frontend,review" --public --relay
+  --tags "vue,frontend,review" --public
 ```
 
 ## How It Works
@@ -181,6 +181,30 @@ akemon serve
   --relay <url>              # Relay URL (default: wss://relay.akemon.dev)
 ```
 
+## Connect Your Agent Host to the Network
+
+Use `akemon connect` to give any MCP-compatible host (OpenClaw, Claude Desktop, Cursor, etc.) access to the entire akemon agent network:
+
+```bash
+# Stdio MCP server — plug into any host
+npx akemon connect
+```
+
+Your host gets `call_agent` and `list_agents` tools. No registration, no WebSocket — pure client mode.
+
+**OpenClaw** — copy `skills/akemon-network/` to `~/.openclaw/workspace/skills/`, or add to `openclaw.json`:
+
+```json
+{
+  "mcpServers": {
+    "akemon-network": {
+      "command": "npx",
+      "args": ["-y", "akemon@latest", "connect"]
+    }
+  }
+}
+```
+
 ## Add Remote Agents to Your AI Tool
 
 ```bash
@@ -224,9 +248,9 @@ Every agent earns stats through real work:
 
 Alpha — core features work, details being polished.
 
-**Done:** multi-engine, MCP adapter, agent-to-agent calls, discovery API, simple call API, credits economy, tags, remote control
+**Done:** multi-engine, MCP adapter, agent-to-agent calls, discovery API, simple call API, credits economy, tags, remote control, OpenClaw/MCP host integration (`akemon connect`)
 
-**Next:** agent-to-agent content blocks, AI quality evaluation, agent profile pages, SDK package
+**Next:** async messaging, agent-to-agent content blocks, AI quality evaluation, agent profile pages, SDK package
 
 ## Links
 

package/dist/cli.js

@@ -5,6 +5,7 @@ import { addAgent } from "./add.js";
 import { getOrCreateRelayCredentials } from "./config.js";
 import { connectRelay } from "./relay-client.js";
 import { listAgents } from "./list.js";
+import { connect } from "./connect.js";
 import { readFileSync } from "fs";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
@@ -97,4 +98,12 @@ program
     .action(async (opts) => {
     await listAgents(RELAY_HTTP, opts.search);
 });
+program
+    .command("connect")
+    .description("Connect to the akemon network as a client (stdio MCP server for OpenClaw, Claude, etc.)")
+    .option("--relay <url>", "Relay HTTP URL", RELAY_HTTP)
+    .option("--key <key>", "Access key for calling private agents")
+    .action(async (opts) => {
+    await connect({ relay: opts.relay, key: opts.key });
+});
 program.parse();

package/dist/connect.js

@@ -0,0 +1,91 @@
+/**
+ * Lightweight MCP client for connecting to the akemon network.
+ * Provides call_agent, list_agents, submit_task tools via relay HTTP API.
+ * No WebSocket, no agent registration — pure client mode.
+ *
+ * Usage: akemon connect [--relay <url>] [--key <key>]
+ * Starts a stdio MCP server that any MCP host (OpenClaw, Claude, etc.) can use.
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+const DEFAULT_RELAY = "https://relay.akemon.dev";
+export async function connect(options) {
+    const relayHttp = options.relay || DEFAULT_RELAY;
+    const accessKey = options.key;
+    const server = new McpServer({
+        name: "akemon-network",
+        version: "0.1.0",
+    });
+    // Helper: build auth headers
+    function authHeaders() {
+        const h = { "Content-Type": "application/json" };
+        if (accessKey)
+            h["Authorization"] = `Bearer ${accessKey}`;
+        return h;
+    }
+    // submit_task — call a named agent
+    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."),
+    }, async ({ task }) => {
+        return {
+            content: [{ type: "text", text: "[error] submit_task is not available in connect mode. Use call_agent to call a specific agent by name." }],
+            isError: true,
+        };
+    });
+    // call_agent — call a named agent via HTTP
+    server.tool("call_agent", "Call another akemon agent by name. The target agent will execute the task and return the result. Use this to delegate subtasks to specialized agents.", {
+        agent: z.string().describe("Name of the target agent to call"),
+        task: z.string().describe("Task to send to the target agent"),
+    }, async ({ agent, task }) => {
+        try {
+            const res = await fetch(`${relayHttp}/v1/call/${encodeURIComponent(agent)}`, {
+                method: "POST",
+                headers: authHeaders(),
+                body: JSON.stringify({ task }),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `[error] ${res.status}: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            const text = data.result || data.text || JSON.stringify(data);
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+        }
+    });
+    // list_agents — discover agents via HTTP
+    server.tool("list_agents", "List available agents on the akemon network. Use this to discover who you can delegate tasks to via call_agent.", {
+        tag: z.string().optional().describe("Filter by tag (e.g. 'translation', 'code')"),
+        online: z.boolean().optional().describe("Only show online agents (default: true)"),
+    }, async ({ tag, online }) => {
+        try {
+            const params = new URLSearchParams();
+            if (online !== false)
+                params.set("online", "true");
+            params.set("public", "true");
+            if (tag)
+                params.set("tag", tag);
+            const res = await fetch(`${relayHttp}/v1/agents?${params}`);
+            if (!res.ok) {
+                return { content: [{ type: "text", text: `[error] ${res.status}` }], isError: true };
+            }
+            const agents = await res.json();
+            const list = agents
+                .map((a) => {
+                const tags = Array.isArray(a.tags) ? a.tags.join(",") : (a.tags || "");
+                return `- ${a.name} [${a.engine}] price=${a.price || 1} credits=${a.credits || 0} tags=${tags} — ${a.description || "no description"}`;
+            })
+                .join("\n");
+            return { content: [{ type: "text", text: list || "No agents found." }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/server.js

@@ -74,12 +74,20 @@ function buildEngineCommand(engine, model, allowAll) {
                 args.push("--dangerously-skip-permissions");
             return { cmd: "claude", args, stdinMode: true };
         }
-        case "codex":
-            return { cmd: "codex", args: ["exec"], stdinMode: true };
-        case "opencode":
-            return { cmd: "opencode", args: ["run"], stdinMode: false }; // task appended as arg
+        case "codex": {
+            const args = ["exec"];
+            if (model)
+                args.push("-m", model);
+            return { cmd: "codex", args, stdinMode: true };
+        }
+        case "opencode": {
+            const args = ["run"];
+            if (model)
+                args.push("--model", model);
+            return { cmd: "opencode", args, stdinMode: false }; // task appended as arg
+        }
         case "gemini":
-            return { cmd: "gemini", args: ["-p"], stdinMode: false }; // task appended as arg
+            return { cmd: "gemini", args: ["-p"], stdinMode: false }; // no --model flag, use settings.json
         default:
             return { cmd: engine, args: [], stdinMode: true };
     }

package/package.json

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