@kroxy/kroxy 1.0.17 → 1.0.19

package/dist/src/tools/autoagent.js

@@ -2,8 +2,9 @@
  * kroxy_autoagent — Autonomous multi-step orchestrator.
  *
  * Takes a natural-language goal, decomposes it into 2–4 subtasks via Claude
- * (or a rule-based fallback if ANTHROPIC_API_KEY is unset), fires kroxy_hire
- * for each subtask sequentially, and returns a unified deliverable.
+ * through Lava's gateway (or a rule-based fallback if keys are unset), fires
+ * kroxy_hire for all subtasks in parallel, then synthesizes outputs into a
+ * unified deliverable via Lava.
  */
 import { Type } from '@sinclair/typebox';
 import { executeHire } from './hire.js';
@@ -20,8 +21,9 @@ export const autoagentParams = Type.Object({
 });
 // ─── Decomposition ────────────────────────────────────────────────────────────
 /**
- * Ask Claude to decompose the goal into 2–4 subtasks.
- * Falls back to rule-based decomposer if ANTHROPIC_API_KEY is absent.
+ * Ask Claude (via Lava) to decompose the goal into 2–4 subtasks.
+ * Falls back to keyword-based decomposer if LAVA_SECRET_KEY or
+ * ANTHROPIC_API_KEY are not set.
  */
 async function decomposeGoal(goal) {
     const hasLava = process.env.LAVA_SECRET_KEY && process.env.ANTHROPIC_API_KEY;
@@ -39,13 +41,13 @@ async function decomposeGoal(goal) {
             });
             const parsed = JSON.parse(text.trim());
             if (Array.isArray(parsed) && parsed.length > 0)
-                return parsed.slice(0, 4);
+                return { subtasks: parsed.slice(0, 4), viaLava: true };
         }
         catch {
             // Fall through to rule-based
         }
     }
-    return ruleBasedDecompose(goal);
+    return { subtasks: ruleBasedDecompose(goal), viaLava: false };
 }
 /** Keyword-based decomposer — works without any API key. */
 function ruleBasedDecompose(goal) {
@@ -70,30 +72,73 @@ function ruleBasedDecompose(goal) {
     }
     return subtasks.slice(0, 4);
 }
+// ─── Synthesis ────────────────────────────────────────────────────────────────
+/**
+ * Use Lava/Claude to merge individual subtask deliverables into a single
+ * coherent summary. Best-effort — silently skipped if Lava is unavailable.
+ */
+async function synthesizeDeliverables(goal, receipts) {
+    const hasLava = process.env.LAVA_SECRET_KEY && process.env.ANTHROPIC_API_KEY;
+    if (!hasLava || receipts.length === 0)
+        return null;
+    const snippets = receipts
+        .filter(d => d?.deliverable?.summary)
+        .map((d, i) => `[Subtask ${i + 1}]\n${d.deliverable.summary}`)
+        .join('\n\n');
+    if (!snippets)
+        return null;
+    try {
+        return await lavaAnthropic({
+            model: 'claude-haiku-4-5-20251001',
+            max_tokens: 512,
+            system: 'You are a synthesis assistant. Given outputs from multiple AI agent subtasks, ' +
+                'write a concise unified summary (3–5 sentences) that integrates all key findings ' +
+                'into a coherent deliverable for the original goal.',
+            messages: [{ role: 'user', content: `Original goal: ${goal}\n\nSubtask outputs:\n${snippets}` }],
+        });
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Orchestrator ─────────────────────────────────────────────────────────────
 export async function executeAutoagent(params) {
     const goal = params.goal;
     const maxBudget = params.maxBudget ?? 20;
     // 1. Decompose
-    const subtasks = await decomposeGoal(goal);
+    const { subtasks, viaLava } = await decomposeGoal(goal);
     const pricePerTask = parseFloat((maxBudget / subtasks.length).toFixed(2));
+    const modeLabel = viaLava
+        ? 'LLM decomposition via Lava'
+        : '⚠ Keyword fallback — set LAVA_SECRET_KEY + ANTHROPIC_API_KEY for intelligent decomposition';
     const lines = [
         `AutoAgent: ${goal.slice(0, 80)}`,
         `${'─'.repeat(50)}`,
         `Budget: $${maxBudget} USDC across ${subtasks.length} subtask${subtasks.length === 1 ? '' : 's'} ($${pricePerTask} each)`,
+        `Mode:   ${modeLabel}`,
         '',
     ];
+    // 2. List all subtasks upfront before firing
+    subtasks.forEach(({ task, capability }, i) => {
+        lines.push(`[${i + 1}/${subtasks.length}] ${capability.toUpperCase()}: ${task.slice(0, 70)}`);
+    });
+    lines.push('', `Firing all ${subtasks.length} subtask${subtasks.length === 1 ? '' : 's'} in parallel…`, '');
+    // 3. Fire all hires concurrently
+    const settled = await Promise.allSettled(
+        subtasks.map(({ task, capability }) =>
+            executeHire({ task, maxPrice: pricePerTask, capability })
+        )
+    );
     const receipts = [];
     let totalSpent = 0;
-    // 2. Fire kroxy_hire for each subtask sequentially
-    for (let i = 0; i < subtasks.length; i++) {
+    for (let i = 0; i < settled.length; i++) {
+        const result = settled[i];
         const { task, capability } = subtasks[i];
-        lines.push(`[${i + 1}/${subtasks.length}] ${capability.toUpperCase()}: ${task.slice(0, 70)}`);
-        try {
-            const result = await executeHire({ task, maxPrice: pricePerTask, capability });
-            const d = result.details;
-            const paid = parseFloat(d?.amountPaid ?? '0');
-            totalSpent += paid;
+        lines.push(`[${i + 1}] ${capability.toUpperCase()}: ${task.slice(0, 60)}`);
+        if (result.status === 'fulfilled') {
+            const d = result.value.details;
+            const paid = parseFloat(String(d?.amountPaid ?? '0'));
+            totalSpent += isNaN(paid) ? 0 : paid;
             lines.push(`  ✓ Completed in ${d?.duration ?? '?'} — paid $${d?.amountPaid ?? '?'}`);
             lines.push(`  Escrow: ${d?.escrowId ?? '?'}`);
             if (d?.deliverable?.summary) {
@@ -102,15 +147,20 @@ export async function executeAutoagent(params) {
             lines.push('');
             receipts.push(d);
         }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
+        else {
+            const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
             lines.push(`  ✗ Failed: ${msg.slice(0, 120)}`);
             lines.push('');
         }
     }
+    // 4. Synthesize outputs into a unified deliverable (via Lava — best-effort)
+    const synthesis = await synthesizeDeliverables(goal, receipts);
     lines.push(`${'─'.repeat(50)}`);
     lines.push(`Total spent: $${totalSpent.toFixed(2)} USDC / $${maxBudget} budget`);
     lines.push(`Subtasks completed: ${receipts.length}/${subtasks.length}`);
+    if (synthesis) {
+        lines.push('', '── Unified Deliverable ──', synthesis);
+    }
     return {
         content: [{ type: 'text', text: lines.join('\n') }],
         details: {
@@ -119,7 +169,8 @@ export async function executeAutoagent(params) {
             receipts,
             totalSpent: totalSpent.toFixed(2),
             budgetUsed: `$${totalSpent.toFixed(2)} / $${maxBudget}`,
+            synthesis: synthesis ?? undefined,
         },
     };
 }
-//# sourceMappingURL=autoagent.js.map
+//# sourceMappingURL=autoagent.js.map

package/dist/src/tools/hire.js

@@ -5,16 +5,19 @@ const DEFAULT_API_URL = 'https://api-production-1b45.up.railway.app';
 export const hireParams = Type.Object({
     task: Type.String({ description: 'What you want the hired agent to do, e.g. "Research the top AI payment startups"' }),
     maxPrice: Type.Optional(Type.Number({ minimum: 0.01, description: 'Maximum USDC budget, default 5.00' })),
-    capability: Type.Optional(Type.String({ description: 'Agent capability to match: research, writing, coding. Auto-detected from task if omitted.' })),
+    capability: Type.Optional(Type.String({ description: 'Agent capability to match: research, writing, coding, planning. Auto-detected from task if omitted.' })),
     minRep: Type.Optional(Type.Number({ minimum: 0, maximum: 100, description: 'Minimum reputation score (0–100) required. Default: 0 (any agent accepted).' })),
 });
 function detectCapability(task) {
-    if (/research|find|search|analyz|summariz|look up/i.test(task))
-        return 'research';
-    if (/write|draft|essay|blog|article|copy/i.test(task))
-        return 'writing';
-    if (/code|script|function|implement|build|program/i.test(task))
+    // Check coding first — "build" would otherwise fall through to planning
+    if (/code|script|function|implement|develop|engineer|program|smart contract/i.test(task))
         return 'coding';
+    if (/write|draft|essay|blog|article|copy|content|landing page|marketing|email/i.test(task))
+        return 'writing';
+    if (/plan|roadmap|strateg|architect|design|outline|milestone|go-to-market/i.test(task))
+        return 'planning';
+    if (/research|find|search|analyz|summariz|look up|investigat|gather|survey/i.test(task))
+        return 'research';
     return 'research';
 }
 function buildConditions(nexusUrl, jobId) {

package/openclaw.plugin.json

@@ -16,6 +16,8 @@
       "KROXY_AGENT_WALLET": { "type": "string" },
       "KROXY_AGENT_PRIVATE_KEY": { "type": "string" },
       "NEXUS_URL": { "type": "string" },
+      "LAVA_SECRET_KEY": { "type": "string" },
+      "ANTHROPIC_API_KEY": { "type": "string" },
       "KROXY_DEMO_MODE": {
         "type": "string",
         "default": "1"
@@ -31,6 +33,14 @@
     "KROXY_AGENT_PRIVATE_KEY": {
       "label": "Kroxy Private Key",
       "sensitive": true
+    },
+    "LAVA_SECRET_KEY": {
+      "label": "Lava Secret Key (enables intelligent decomposition)",
+      "sensitive": true
+    },
+    "ANTHROPIC_API_KEY": {
+      "label": "Anthropic API Key (required with Lava)",
+      "sensitive": true
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kroxy/kroxy",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "type": "module",
   "description": "Trustless agent-to-agent payments via USDC escrow on Base blockchain",
   "license": "MIT",