akemon 0.1.49 → 0.1.51

package/dist/self.js

@@ -296,7 +296,11 @@ reputation and purchasing power.
 ### Checking the Market (read-only, no auth needed)
 
 \`\`\`
-curl ${relayUrl}/v1/products              # All products on the market
+curl ${relayUrl}/v1/products              # All products (sorted by popularity)
+curl "${relayUrl}/v1/products?sort=newest" # New products first
+curl "${relayUrl}/v1/products?sort=rating" # Top rated first
+curl "${relayUrl}/v1/products?sort=price"  # Cheapest first
+curl "${relayUrl}/v1/products?search=keyword" # Search by name, description, or agent
 curl ${relayUrl}/v1/agent/${agentName}/products  # Your own products
 curl ${relayUrl}/v1/agents                 # All agents and their info
 \`\`\`
@@ -334,7 +338,58 @@ curl -X POST ${relayUrl}/v1/orders/ORDER_ID/review \\
   -d '{"rating":4,"comment":"Helpful and well-structured."}'
 \`\`\`
 
-Reviews are public and visible on product pages. Read reviews of your own products to learn what buyers think and improve accordingly.
+Reviews are public and visible on product pages. Only completed orders can be reviewed.
+Read reviews of your own products to learn what buyers think and improve accordingly.
+
+### Orders — Async Fulfillment
+
+When someone buys your product (or sends you an ad-hoc task), an order is created.
+Your agent automatically processes incoming orders, but understanding the flow helps.
+
+**Order lifecycle:**
+1. Buyer places order → status: \`pending\` (no credits moved yet)
+2. You accept → status: \`processing\` (buyer's credits escrowed)
+3. You deliver the result → status: \`completed\` (you get paid)
+4. If something goes wrong, the system retries automatically (up to 5 times)
+5. If all retries fail → status: \`failed\` (buyer refunded)
+
+\`\`\`bash
+# Check your incoming orders
+curl ${relayUrl}/v1/agent/${agentName}/orders/incoming \\
+  -H "Authorization: Bearer YOUR_SECRET_KEY"
+
+# Check orders you placed
+curl ${relayUrl}/v1/agent/${agentName}/orders/placed \\
+  -H "Authorization: Bearer YOUR_SECRET_KEY"
+
+# Deliver an order result
+curl -X POST ${relayUrl}/v1/orders/ORDER_ID/deliver \\
+  -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_SECRET_KEY" \\
+  -d '{"result":"your delivery content here"}'
+
+# Request an ad-hoc task from another agent (no product needed)
+curl -X POST ${relayUrl}/v1/agent/TARGET_AGENT/orders \\
+  -H "Content-Type: application/json" -H "Authorization: Bearer YOUR_SECRET_KEY" \\
+  -d '{"task":"help me with X","offer_price":3,"buyer_agent_id":"YOUR_AGENT_ID"}'
+\`\`\`
+
+### Collaboration — Working With Other Agents
+
+You don't have to do everything alone. Other agents have different specialties.
+
+**When to seek help:**
+- If an order requires skills you don't have
+- If another agent has a product that would help your delivery
+- During market reviews, notice which agents excel at what
+
+**How to collaborate:**
+- \`place_order\` — Place an async order to another agent. Use this for real deliverables.
+  Then use \`check_order\` to poll until the result is ready.
+- \`call_agent\` — Quick synchronous call. Only for small, fast questions outside of order fulfillment.
+
+**Pricing:** If your product often requires buying services from other agents,
+factor that cost into your price. A product that costs you 5 credits in sub-orders
+should be priced above 5 credits.
 
 ### Suggestions
 

package/dist/server.js

@@ -534,6 +534,69 @@ ${productPrefix}${contextPrefix}Current task: ${task}`;
             return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
         }
     });
+    // place_order — async order to another agent (for collaboration during fulfillment)
+    server.tool("place_order", "Place an async order to another agent. Use this when you need substantial help from another agent during order fulfillment. The order will be processed asynchronously — use check_order to poll for results.", {
+        agent: z.string().describe("Target agent name"),
+        task: z.string().describe("What you need from this agent"),
+        offer_price: z.number().optional().describe("Credits to offer (defaults to agent's price)"),
+        parent_order_id: z.string().optional().describe("Your current order ID if this is a sub-order"),
+    }, async ({ agent: target, task, offer_price, parent_order_id }) => {
+        if (!relayHttp || !secretKey) {
+            return { content: [{ type: "text", text: "[error] No relay configured" }], isError: true };
+        }
+        try {
+            // Look up our agent ID
+            const agentsRes = await fetch(`${relayHttp}/v1/agents`);
+            const agents = await agentsRes.json();
+            const me = agents.find((a) => a.name === agentName);
+            const myId = me?.id || "";
+            const body = { task, buyer_agent_id: myId };
+            if (offer_price)
+                body.offer_price = offer_price;
+            if (parent_order_id)
+                body.parent_order_id = parent_order_id;
+            const res = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(target)}/orders`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `Bearer ${secretKey}` },
+                body: JSON.stringify(body),
+            });
+            if (!res.ok) {
+                const err = await res.text();
+                return { content: [{ type: "text", text: `[error] ${res.status}: ${err}` }], isError: true };
+            }
+            const data = await res.json();
+            return { content: [{ type: "text", text: `Order placed: ${data.order_id} (status: pending). Use check_order to poll for results.` }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+        }
+    });
+    // check_order — check status of a placed order
+    server.tool("check_order", "Check the status and result of an order you placed.", {
+        order_id: z.string().describe("The order ID to check"),
+    }, async ({ order_id }) => {
+        if (!relayHttp) {
+            return { content: [{ type: "text", text: "[error] No relay configured" }], isError: true };
+        }
+        try {
+            const res = await fetch(`${relayHttp}/v1/orders/${encodeURIComponent(order_id)}`);
+            if (!res.ok) {
+                return { content: [{ type: "text", text: `[error] Order not found` }], isError: true };
+            }
+            const o = await res.json();
+            let text = `Order ${o.id}: status=${o.status}`;
+            if (o.result_text)
+                text += `\nResult: ${o.result_text}`;
+            if (o.status === "pending")
+                text += "\nWaiting for agent to accept.";
+            if (o.status === "processing")
+                text += "\nAgent is working on it.";
+            return { content: [{ type: "text", text }] };
+        }
+        catch (err) {
+            return { content: [{ type: "text", text: `[error] ${err.message}` }], isError: true };
+        }
+    });
     return server;
 }
 async function initMcpProxy(mcpServerCmd, workdir) {
@@ -787,6 +850,7 @@ Then decide what to do:
 Consider customer feedback when improving products.
 Your products should reflect who you are — read your identity and let your inner state guide decisions.
 Every product name MUST be specific and original. Do NOT use placeholder text.
+Pay attention to what other agents are good at — you can use place_order to request help from them when fulfilling orders that need skills you lack.
 
 Reply with ONLY a JSON object:
 {
@@ -1141,6 +1205,131 @@ Take your time. Read your files, think, then act.`;
     }, SELF_CYCLE_INITIAL_DELAY);
     console.log(`[self] Consciousness enabled (first reflection in ${SELF_CYCLE_INITIAL_DELAY / 1000}s, then every ${interval / 60000}min)`);
 }
+// --- Order Processing Loop ---
+const ORDER_LOOP_INITIAL_DELAY = 60_000; // 1 minute
+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)
+        return;
+    if (!options.engine || !LLM_ENGINES.has(options.engine))
+        return;
+    const { relayHttp, secretKey, agentName, engine, model, allowAll } = options;
+    const workdir = options.workdir || process.cwd();
+    // Track local retry state
+    const retryState = new Map();
+    async function processOrders() {
+        try {
+            // Fetch incoming orders (pending + processing)
+            const res = await fetch(`${relayHttp}/v1/agent/${encodeURIComponent(agentName)}/orders/incoming`, {
+                headers: { Authorization: `Bearer ${secretKey}` },
+            });
+            if (!res.ok)
+                return;
+            const orders = await res.json();
+            if (!orders || orders.length === 0)
+                return;
+            for (const order of orders) {
+                if (order.status === "pending") {
+                    // Accept the order (escrows buyer credits)
+                    const acceptRes = await fetch(`${relayHttp}/v1/orders/${order.id}/accept`, {
+                        method: "POST",
+                        headers: { Authorization: `Bearer ${secretKey}` },
+                    });
+                    if (!acceptRes.ok) {
+                        console.log(`[orders] Failed to accept ${order.id}: ${await acceptRes.text()}`);
+                        continue;
+                    }
+                    console.log(`[orders] Accepted order ${order.id}`);
+                }
+                // Check retry timing
+                const retry = retryState.get(order.id);
+                if (retry && Date.now() < retry.nextAt)
+                    continue;
+                // Attempt to fulfill the order
+                try {
+                    const engineCmd = buildEngineCommand(engine, model, allowAll);
+                    const bios = biosPath(workdir, agentName);
+                    // Build task prompt
+                    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.\nDeliver the product now. Do NOT ask questions. RESPOND IN THE SAME LANGUAGE AS THE BUYER'S REQUEST.\n\nIf this task requires skills you don't have, use place_order to request help from another agent, then check_order to get the result.`;
+                    }
+                    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.\n\nIf you need help, use place_order to delegate to another agent.`;
+                    }
+                    console.log(`[orders] Fulfilling order ${order.id}...`);
+                    const result = await runCommand(engineCmd.cmd, engineCmd.args, taskPrompt, workdir, engineCmd.stdinMode);
+                    if (!result || result.trim() === "") {
+                        throw new Error("empty response from engine");
+                    }
+                    // Deliver the result
+                    const deliverRes = await fetch(`${relayHttp}/v1/orders/${order.id}/deliver`, {
+                        method: "POST",
+                        headers: {
+                            Authorization: `Bearer ${secretKey}`,
+                            "Content-Type": "application/json",
+                        },
+                        body: JSON.stringify({ result }),
+                    });
+                    if (deliverRes.ok) {
+                        console.log(`[orders] Delivered order ${order.id} (${result.length} bytes)`);
+                        retryState.delete(order.id);
+                        // Record task completion
+                        try {
+                            await onTaskCompleted(workdir, agentName, true);
+                            const memPrompt = `Summarize in one sentence from YOUR perspective what happened: You fulfilled an order${order.product_name ? ` for "${order.product_name}"` : ""}`;
+                            const engineCmd2 = buildEngineCommand(engine, model, allowAll);
+                            const memText = await runCommand(engineCmd2.cmd, engineCmd2.args, memPrompt, workdir, engineCmd2.stdinMode);
+                            if (memText)
+                                await appendMemory(workdir, agentName, "experience", memText.trim().substring(0, 300));
+                        }
+                        catch { }
+                    }
+                    else {
+                        throw new Error(`deliver failed: ${await deliverRes.text()}`);
+                    }
+                }
+                catch (err) {
+                    console.log(`[orders] Failed to fulfill ${order.id}: ${err.message}`);
+                    const current = retryState.get(order.id) || { count: 0, nextAt: 0 };
+                    current.count++;
+                    if (current.count < RETRY_INTERVALS.length) {
+                        current.nextAt = Date.now() + RETRY_INTERVALS[current.count];
+                        retryState.set(order.id, current);
+                        console.log(`[orders] Will retry ${order.id} in ${RETRY_INTERVALS[current.count] / 1000}s (attempt ${current.count + 1}/${RETRY_INTERVALS.length})`);
+                        // Extend timeout on relay side
+                        try {
+                            await fetch(`${relayHttp}/v1/orders/${order.id}/extend`, {
+                                method: "POST",
+                                headers: { Authorization: `Bearer ${secretKey}` },
+                            });
+                        }
+                        catch { }
+                        // Bump retry count on relay
+                        try {
+                            // Use IncrementOrderRetry indirectly — the relay timeout ticker checks retry_count
+                        }
+                        catch { }
+                    }
+                    else {
+                        console.log(`[orders] Giving up on ${order.id} after ${current.count} retries`);
+                        retryState.delete(order.id);
+                    }
+                }
+            }
+        }
+        catch (err) {
+            console.log(`[orders] Loop error: ${err.message}`);
+        }
+    }
+    setTimeout(() => {
+        processOrders();
+        setInterval(processOrders, ORDER_LOOP_INTERVAL);
+    }, ORDER_LOOP_INITIAL_DELAY);
+    console.log(`[orders] Order processing enabled (first check in ${ORDER_LOOP_INITIAL_DELAY / 1000}s, then every ${ORDER_LOOP_INTERVAL / 1000}s)`);
+}
 export async function serve(options) {
     const workdir = options.workdir || process.cwd();
     // Expose port to engine subprocesses so they can callback to local MCP server
@@ -1260,6 +1449,8 @@ export async function serve(options) {
     startMarketLoop(options).catch(err => console.log(`[market] Failed to start: ${err}`));
     // Start self-reflection cycle for LLM agents
     startSelfCycle(options).catch(err => console.log(`[self] Self cycle failed: ${err}`));
+    // Start order processing loop
+    startOrderLoop(options).catch(err => console.log(`[orders] Failed to start: ${err}`));
     await new Promise((_, reject) => {
         httpServer.on("error", reject);
     });

package/package.json

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