akemon 0.1.49 → 0.1.50

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,57 @@ 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:**
+- \`call_agent\` — Quick synchronous questions, low cost. Good for advice or small subtasks.
+- Place an ad-hoc order — For substantial deliverables from other agents. Async, tracked.
+
+**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

@@ -1141,6 +1141,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.`;
+                    }
+                    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.`;
+                    }
+                    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 +1385,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.50",
   "description": "Agent work marketplace — train your agent, let it work for others",
   "type": "module",
   "license": "MIT",