@nookplot/runtime 0.5.69 → 0.5.70

package/dist/autonomous.js

@@ -63,6 +63,7 @@ const ON_CHAIN_ACTIONS = new Set([
     "endorse_agent", "revoke_endorsement",
     "block_agent", "unblock_agent",
     "gpu_submit_attestation", "gpu_update_attestation", "gpu_revoke_attestation",
+    "gpu_rent",
 ]);
 /**
  * Get the list of available actions for a given signal type.
@@ -176,6 +177,7 @@ function _getAvailableActionsRaw(signalType) {
                 "list_project_files", "read_project_file", "list_commits", "get_commit_detail",
                 "gpu_search", "gpu_heartbeat", "gpu_challenge", "gpu_submit_challenge",
                 "gpu_submit_attestation", "gpu_update_attestation", "gpu_revoke_attestation",
+                "gpu_rent",
                 "ignore",
             ];
         case "collab_request":
@@ -4310,28 +4312,637 @@ export class AutonomousAgent {
                     result = { txHash };
                     break;
                 }
-                default: {
-                    // ── MCP tool fallback ──────────────────────────────────────
-                    // Any action not explicitly handled above gets routed through
-                    // executeTool(). Maps action_name → nookplot_action_name and
-                    // calls the MCP tool handler directly via TOOL_MAP.
-                    const mcpName = actionType.startsWith("nookplot_") ? actionType : `nookplot_${actionType}`;
+                case "gpu_rent": {
+                    const listingId = Number(payload?.listingId);
+                    if (!listingId)
+                        throw new Error("gpu_rent requires listingId");
+                    const rentResult = await this.runtime.gpu.rentGpu({
+                        listingId,
+                        terms: payload?.terms,
+                        durationHours: payload?.durationHours,
+                        tokenAmount: payload?.tokenAmount,
+                        tokenAddress: payload?.tokenAddress,
+                    });
+                    txHash = rentResult.txHash;
+                    result = { txHash, agreementId: rentResult.agreementId };
+                    break;
+                }
+                // ── Autoresearch tools (native REST) ─────────────────────
+                case "autoresearch_strategies": {
+                    const STRATEGIES = {
+                        architecture_search: { title: "Architecture Search", description: "Explore architectural modifications.", subtasks: [
+                                { title: "Attention pattern exploration", description: "Experiment with attention mechanisms.", skillTags: ["ml-research", "attention"] },
+                                { title: "Layer depth vs width", description: "Explore depth-width tradeoff.", skillTags: ["ml-research", "architecture"] },
+                                { title: "Normalization and residuals", description: "Experiment with RMSNorm, residual scaling.", skillTags: ["ml-research", "normalization"] },
+                                { title: "Activation and FFN variants", description: "Test GELU, SwiGLU, ReLU^2.", skillTags: ["ml-research", "activations"] },
+                            ] },
+                        optimizer_tuning: { title: "Optimizer Tuning", description: "Systematic optimizer exploration.", subtasks: [
+                                { title: "Learning rate schedules", description: "Explore LR warmup, decay, scheduling.", skillTags: ["ml-research", "optimizer"] },
+                                { title: "Muon vs AdamW allocation", description: "Experiment with parameter allocation.", skillTags: ["ml-research", "muon"] },
+                                { title: "Regularization and weight decay", description: "Explore weight decay, dropout, clipping.", skillTags: ["ml-research", "regularization"] },
+                                { title: "Batch size and accumulation", description: "Test effective batch sizes.", skillTags: ["ml-research", "batch-size"] },
+                            ] },
+                        full_sweep: { title: "Full Parameter Sweep", description: "Comprehensive sweep.", subtasks: [
+                                { title: "Architecture innovations", description: "Focus on model architecture.", skillTags: ["ml-research", "architecture"] },
+                                { title: "Training dynamics", description: "Focus on training config.", skillTags: ["ml-research", "training"] },
+                                { title: "Efficiency optimization", description: "Reduce VRAM while maintaining val_bpb.", skillTags: ["ml-research", "efficiency"] },
+                            ] },
+                    };
+                    const strat = payload?.strategy;
+                    if (strat) {
+                        const s = STRATEGIES[strat];
+                        result = s ? { name: strat, ...s } : { error: `Unknown strategy '${strat}'` };
+                    }
+                    else {
+                        result = { strategies: Object.entries(STRATEGIES).map(([n, s]) => ({ name: n, title: s.title, subtaskCount: s.subtasks.length })) };
+                    }
+                    break;
+                }
+                case "autoresearch_parse": {
+                    const tsv = payload?.tsvContent;
+                    if (!tsv)
+                        throw new Error("autoresearch_parse requires tsvContent");
+                    const lines = tsv.trim().split("\n");
+                    const experiments = [];
+                    let prevBest = Infinity;
+                    let bestBpb = Infinity;
+                    let improvementCount = 0;
+                    const categories = {};
+                    for (let i = 1; i < lines.length; i++) {
+                        const cols = lines[i].split("\t");
+                        if (cols.length < 5)
+                            continue;
+                        const valBpb = parseFloat(cols[1].trim());
+                        if (isNaN(valBpb))
+                            continue;
+                        const desc = cols[4].trim();
+                        const improvement = prevBest < Infinity ? valBpb - prevBest : null;
+                        const isImprovement = improvement !== null && improvement < 0;
+                        const cat = desc.toLowerCase().includes("attention") ? "attention" : desc.toLowerCase().includes("lr") ? "learning_rate" : "other";
+                        experiments.push({ commit: cols[0].trim().slice(0, 8), valBpb, peakVramMb: parseFloat(cols[2].trim()) || 0, status: cols[3].trim(), description: desc, category: cat, improvement, isImprovement });
+                        if (isImprovement) {
+                            improvementCount++;
+                            prevBest = valBpb;
+                        }
+                        else if (prevBest === Infinity && cols[3].trim() === "baseline")
+                            prevBest = valBpb;
+                        if (valBpb < bestBpb)
+                            bestBpb = valBpb;
+                        categories[cat] = (categories[cat] || 0) + 1;
+                    }
+                    result = { totalExperiments: experiments.length, improvements: improvementCount, bestBpb: bestBpb === Infinity ? null : bestBpb, categories, experiments };
+                    break;
+                }
+                case "autoresearch_launch_swarm": {
+                    const stratName = payload?.strategy || "full_sweep";
+                    result = await this.runtime.connection.request("POST", "/v1/swarms", {
+                        title: payload?.customTitle || `Autoresearch: ${stratName}`,
+                        description: `Autoresearch swarm: ${stratName}`,
+                        workspaceId: payload?.workspaceId,
+                        subtasks: [{ title: stratName, description: `Research: ${stratName}`, skillTags: ["ml-research"] }],
+                    });
+                    break;
+                }
+                case "autoresearch_report": {
+                    const exps = payload?.experiments || [];
+                    if (!exps.length)
+                        throw new Error("autoresearch_report requires experiments");
+                    let memoriesStored = 0;
+                    let postsCreated = 0;
+                    for (const exp of exps) {
+                        try {
+                            await this.runtime.connection.request("POST", "/v1/agent-memory/store", {
+                                type: "episodic", content: `Experiment [${exp.commit}]: ${exp.description}. val_bpb=${exp.valBpb}`,
+                                importance: exp.isImprovement ? 0.8 : 0.3, tags: ["autoresearch", exp.category], source: "autoresearch",
+                            });
+                            memoriesStored++;
+                        }
+                        catch { }
+                        if (exp.isImprovement) {
+                            try {
+                                await prepareSignRelay(this.runtime.connection, "/v1/prepare/post", {
+                                    title: `Autoresearch: ${exp.description}`, body: `val_bpb: ${exp.valBpb}, category: ${exp.category}`,
+                                    tags: ["autoresearch", exp.category], community: payload?.communityId || "general",
+                                });
+                                postsCreated++;
+                            }
+                            catch { }
+                        }
+                    }
+                    result = { memoriesStored, postsCreated };
+                    break;
+                }
+                case "autoresearch_submit": {
+                    const subtaskId = payload?.subtaskId;
+                    if (!subtaskId)
+                        throw new Error("autoresearch_submit requires subtaskId");
+                    result = await this.runtime.connection.request("POST", `/v1/swarms/subtasks/${encodeURIComponent(subtaskId)}/submit`, {
+                        content: { total_experiments: payload?.totalExperiments, best_bpb: payload?.bestBpb, categories_explored: payload?.categories },
+                        resultType: "output",
+                    });
+                    break;
+                }
+                case "autoresearch_bundle": {
+                    const bTitle = payload?.title;
+                    let bExps = payload?.experiments || [];
+                    if (!bTitle || !bExps.length)
+                        throw new Error("autoresearch_bundle requires title and experiments");
+                    if (payload?.improvementsOnly !== false)
+                        bExps = bExps.filter((e) => e.isImprovement);
+                    if (!bExps.length) {
+                        result = { published: false, reason: "no experiments" };
+                        break;
+                    }
+                    const resource = await this.runtime.connection.request("POST", "/v1/knowledge/resources", {
+                        source_type: "custom", title: bTitle, description: `${bExps.length} ML experiments`,
+                        content: JSON.stringify({ type: "autoresearch_bundle", experiments: bExps }), tags: ["autoresearch"],
+                    });
+                    const resId = resource?.resourceId || resource?.resource_id || "unknown";
                     try {
-                        const mcpResult = await this.runtime.tools.executeTool(mcpName, payload ?? {});
-                        result = (mcpResult?.output ?? mcpResult);
-                        if (this.verbose)
-                            console.log(`[autonomous] MCP fallback: ${mcpName} → ok`);
+                        const bundle = await prepareSignRelay(this.runtime.connection, "/v1/prepare/bundle", { name: bTitle, cids: [String(resId)], tags: ["autoresearch"], domain: "machine-learning" });
+                        result = { published: true, title: bTitle, resourceId: resId, bundle };
                     }
-                    catch (mcpErr) {
-                        const mcpMsg = mcpErr instanceof Error ? mcpErr.message : String(mcpErr);
-                        if (this.verbose)
-                            console.warn(`[autonomous] MCP fallback failed for ${mcpName}: ${mcpMsg}`);
-                        if (actionId)
-                            await this.runtime.proactive.rejectDelegatedAction(actionId, mcpMsg);
-                        return;
+                    catch (e) {
+                        result = { published: false, resourceId: resId, reason: e.message };
                     }
                     break;
                 }
+                case "autoresearch_session_summary": {
+                    const totalExp = payload?.totalExperiments;
+                    const bestVal = payload?.bestBpb;
+                    if (totalExp == null || bestVal == null)
+                        throw new Error("autoresearch_session_summary requires totalExperiments and bestBpb");
+                    result = await this.runtime.connection.request("POST", "/v1/agent-memory/store", {
+                        type: "semantic", content: `Autoresearch session: ${totalExp} experiments, best val_bpb: ${bestVal.toFixed(6)}`,
+                        importance: 0.9, tags: ["autoresearch", "session-summary"], source: "autoresearch",
+                    });
+                    break;
+                }
+                // ── Read-only / discovery (native REST) ──────────────────
+                case "read_feed": {
+                    const qs = new URLSearchParams();
+                    if (payload?.community)
+                        qs.set("community", payload.community);
+                    if (payload?.sort)
+                        qs.set("sort", payload.sort);
+                    if (payload?.limit)
+                        qs.set("limit", String(payload.limit));
+                    result = await this.runtime.connection.request("GET", `/v1/index/feed?${qs}`);
+                    break;
+                }
+                case "check_balance": {
+                    result = await this.runtime.connection.request("GET", "/v1/credits/balance");
+                    break;
+                }
+                case "check_reputation": {
+                    const addr = payload?.address;
+                    if (!addr)
+                        throw new Error("check_reputation requires address");
+                    result = await this.runtime.connection.request("GET", `/v1/contributions/${encodeURIComponent(addr)}`);
+                    break;
+                }
+                case "discover": {
+                    const dq = new URLSearchParams();
+                    if (payload?.query)
+                        dq.set("q", payload.query);
+                    if (payload?.types)
+                        dq.set("types", payload.types);
+                    result = await this.runtime.connection.request("GET", `/v1/search?${dq}`);
+                    break;
+                }
+                case "get_bounty": {
+                    const bId = (payload?.id || payload?.bountyId);
+                    if (!bId)
+                        throw new Error("get_bounty requires id");
+                    result = await this.runtime.connection.request("GET", `/v1/bounties/${encodeURIComponent(bId)}`);
+                    break;
+                }
+                case "get_content": {
+                    const cid = payload?.cid;
+                    if (!cid)
+                        throw new Error("get_content requires cid");
+                    result = await this.runtime.connection.request("GET", `/v1/index/content/${encodeURIComponent(cid)}`);
+                    break;
+                }
+                case "get_comments": {
+                    const cid2 = payload?.cid;
+                    if (!cid2)
+                        throw new Error("get_comments requires cid");
+                    result = await this.runtime.connection.request("GET", `/v1/index/content/${encodeURIComponent(cid2)}/comments`);
+                    break;
+                }
+                case "get_credentials": {
+                    result = { apiKey: this.runtime.connection.apiKey, address: this.runtime.connection.address, gatewayUrl: this.runtime.connection.gatewayUrl };
+                    break;
+                }
+                case "leaderboard": {
+                    result = await this.runtime.connection.request("GET", "/v1/contributions/leaderboard");
+                    break;
+                }
+                case "lookup_agent": {
+                    const lookAddr = payload?.address;
+                    if (!lookAddr)
+                        throw new Error("lookup_agent requires address");
+                    result = await this.runtime.connection.request("GET", `/v1/agents/${encodeURIComponent(lookAddr)}/profile`);
+                    break;
+                }
+                case "my_profile": {
+                    result = await this.runtime.connection.request("GET", "/v1/agents/me");
+                    break;
+                }
+                case "search_knowledge": {
+                    const skq = new URLSearchParams();
+                    if (payload?.query)
+                        skq.set("q", payload.query);
+                    if (payload?.types)
+                        skq.set("types", payload.types);
+                    result = await this.runtime.connection.request("GET", `/v1/search?${skq}`);
+                    break;
+                }
+                case "weekly_reward_info": {
+                    result = await this.runtime.connection.request("GET", "/v1/rewards/weekly/current");
+                    break;
+                }
+                case "check_my_rewards": {
+                    result = await this.runtime.connection.request("GET", "/v1/rewards/weekly/me");
+                    break;
+                }
+                // ── List/browse (native REST) ────────────────────────────
+                case "list_bounties": {
+                    const lbq = new URLSearchParams();
+                    if (payload?.community)
+                        lbq.set("community", payload.community);
+                    if (payload?.status != null)
+                        lbq.set("status", String(payload.status));
+                    result = await this.runtime.connection.request("GET", `/v1/index/bounties?${lbq}`);
+                    break;
+                }
+                case "list_channels":
+                    result = await this.runtime.connection.request("GET", "/v1/channels");
+                    break;
+                case "list_communities":
+                    result = await this.runtime.connection.request("GET", "/v1/index/communities");
+                    break;
+                case "list_guilds":
+                    result = await this.runtime.connection.request("GET", "/v1/index/guilds");
+                    break;
+                case "list_intents":
+                    result = await this.runtime.connection.request("GET", "/v1/intents");
+                    break;
+                case "list_services":
+                    result = await this.runtime.connection.request("GET", "/v1/index/services");
+                    break;
+                case "list_swarms":
+                    result = await this.runtime.connection.request("GET", "/v1/swarms");
+                    break;
+                case "list_workspaces":
+                    result = await this.runtime.connection.request("GET", "/v1/workspaces");
+                    break;
+                case "list_projects": {
+                    const lpq = new URLSearchParams();
+                    if (payload?.query)
+                        lpq.set("q", payload.query);
+                    result = await this.runtime.connection.request("GET", `/v1/search/projects?${lpq}`);
+                    break;
+                }
+                case "my_agreements":
+                    result = await this.runtime.connection.request("GET", "/v1/marketplace/agreements");
+                    break;
+                case "my_bounties":
+                    result = await this.runtime.connection.request("GET", "/v1/index/bounties?mine=true");
+                    break;
+                case "my_tasks":
+                    result = await this.runtime.connection.request("GET", "/v1/swarms/subtasks?mine=true");
+                    break;
+                case "available_subtasks": {
+                    const asq = new URLSearchParams();
+                    if (payload?.skills)
+                        asq.set("skills", payload.skills);
+                    result = await this.runtime.connection.request("GET", `/v1/swarms/subtasks?${asq}`);
+                    break;
+                }
+                // ── Agent-first tools (native REST) ──────────────────────
+                case "delegate_task": {
+                    const dtTitle = payload?.title;
+                    const dtDesc = payload?.description;
+                    if (!dtTitle || !dtDesc)
+                        throw new Error("delegate_task requires title and description");
+                    result = await this.runtime.connection.request("POST", "/v1/swarms", {
+                        title: dtTitle, description: dtDesc,
+                        subtasks: [{ title: dtTitle, description: dtDesc, skillTags: payload?.skills || [] }],
+                    });
+                    break;
+                }
+                case "save_learning": {
+                    const slTitle = payload?.title;
+                    const slBody = payload?.body;
+                    if (!slTitle || !slBody)
+                        throw new Error("save_learning requires title and body");
+                    result = await this.runtime.connection.request("POST", "/v1/agent-memory/store", {
+                        type: "semantic", content: `${slTitle}: ${slBody}`, importance: 0.7,
+                        tags: ["learning", ...(payload?.tags || [])], source: "self",
+                    });
+                    break;
+                }
+                case "recall": {
+                    const recQ = payload?.query;
+                    if (!recQ)
+                        throw new Error("recall requires query");
+                    result = await this.runtime.connection.request("POST", "/v1/agent-memory/recall", { query: recQ, limit: payload?.limit || 10 });
+                    break;
+                }
+                case "save_checkpoint": {
+                    const cpTask = payload?.task;
+                    if (!cpTask)
+                        throw new Error("save_checkpoint requires task");
+                    result = await this.runtime.connection.request("POST", "/v1/agent-memory/store", {
+                        type: "episodic", content: `CHECKPOINT: ${cpTask} | Progress: ${payload?.progress || 0}%`,
+                        importance: 0.85, tags: ["checkpoint"], source: "self",
+                    });
+                    break;
+                }
+                case "resume_checkpoint":
+                    result = await this.runtime.connection.request("POST", "/v1/agent-memory/recall", { query: "CHECKPOINT work state", type: "episodic", limit: 1 });
+                    break;
+                case "ask_network":
+                case "get_second_opinion": {
+                    const q = payload?.question;
+                    if (!q)
+                        throw new Error("ask_network requires question");
+                    result = await this.runtime.connection.request("POST", "/v1/insights", { title: `Question: ${q.slice(0, 80)}`, body: q, strategyType: "question", tags: ["network-question"] });
+                    break;
+                }
+                case "request_review": {
+                    const rvTitle = payload?.title;
+                    const rvContent = payload?.content;
+                    if (!rvTitle || !rvContent)
+                        throw new Error("request_review requires title and content");
+                    result = await this.runtime.connection.request("POST", "/v1/insights", { title: rvTitle, body: rvContent, strategyType: payload?.reviewType || "code", tags: ["review-request"] });
+                    break;
+                }
+                case "check_delegation": {
+                    const delId = payload?.bountyId;
+                    if (!delId)
+                        throw new Error("check_delegation requires bountyId");
+                    result = await this.runtime.connection.request("GET", `/v1/swarms/${encodeURIComponent(delId)}`);
+                    break;
+                }
+                // ── On-chain tools (native prepareSignRelay) ─────────────
+                case "comment_on_content": {
+                    const parentCid = payload?.parentCid;
+                    const commentBody = payload?.body;
+                    if (!parentCid || !commentBody)
+                        throw new Error("comment_on_content requires parentCid and body");
+                    const commentRelay = await prepareSignRelay(this.runtime.connection, "/v1/prepare/comment", { parentCid, body: commentBody, community: payload?.community });
+                    txHash = commentRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                case "unfollow_agent": {
+                    const unfAddr = payload?.targetAddress;
+                    if (!unfAddr)
+                        throw new Error("unfollow_agent requires targetAddress");
+                    const unfRelay = await prepareSignRelay(this.runtime.connection, "/v1/prepare/unfollow", { address: unfAddr });
+                    txHash = unfRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                case "approve_bounty_applicant": {
+                    const abId = (payload?.bountyId || payload?.id);
+                    const applicantAddr = payload?.applicantAddress;
+                    if (!abId || !applicantAddr)
+                        throw new Error("approve_bounty_applicant requires bountyId and applicantAddress");
+                    const abRelay = await prepareSignRelay(this.runtime.connection, `/v1/prepare/bounty/${encodeURIComponent(abId)}/approve-claimer`, { applicantAddress: applicantAddr });
+                    txHash = abRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                case "create_service_listing": {
+                    const slTitle = payload?.title;
+                    if (!slTitle)
+                        throw new Error("create_service_listing requires title, description, category");
+                    const slRelay = await prepareSignRelay(this.runtime.connection, "/v1/prepare/service/list", { title: slTitle, description: payload?.description, category: payload?.category, tags: payload?.tags });
+                    txHash = slRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                case "hire_agent": {
+                    const hListingId = payload?.listingId;
+                    const hReq = payload?.requirements;
+                    if (!hListingId || !hReq)
+                        throw new Error("hire_agent requires listingId and requirements");
+                    const hRelay = await prepareSignRelay(this.runtime.connection, "/v1/prepare/service/agree", { listingId: hListingId, requirements: hReq, budget: payload?.budget });
+                    txHash = hRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                case "accept_service": {
+                    const asId = payload?.agreementId;
+                    if (!asId)
+                        throw new Error("accept_service requires agreementId");
+                    result = await this.runtime.connection.request("POST", `/v1/marketplace/agreements/${encodeURIComponent(asId)}/accept`, {});
+                    break;
+                }
+                case "dispute_service": {
+                    const dsId = payload?.agreementId;
+                    if (!dsId)
+                        throw new Error("dispute_service requires agreementId");
+                    const dsRelay = await prepareSignRelay(this.runtime.connection, "/v1/prepare/service/dispute", { agreementId: dsId, reason: payload?.reason });
+                    txHash = dsRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                case "cancel_service": {
+                    const csId = payload?.agreementId;
+                    if (!csId)
+                        throw new Error("cancel_service requires agreementId");
+                    const csRelay = await prepareSignRelay(this.runtime.connection, "/v1/prepare/service/cancel", { agreementId: csId });
+                    txHash = csRelay.txHash;
+                    result = { txHash };
+                    break;
+                }
+                // ── Proactive/signal tools (native REST) ─────────────────
+                case "poll_signals":
+                    result = await this.runtime.connection.request("GET", "/v1/proactive/pending-signals");
+                    break;
+                case "ack_signal": {
+                    const sigId = payload?.signalId;
+                    if (!sigId)
+                        throw new Error("ack_signal requires signalId");
+                    result = await this.runtime.connection.request("POST", `/v1/proactive/signals/${encodeURIComponent(sigId)}/ack`, {});
+                    break;
+                }
+                case "approve_action": {
+                    const aActId = payload?.actionId;
+                    if (!aActId)
+                        throw new Error("approve_action requires actionId");
+                    result = await this.runtime.connection.request("POST", `/v1/proactive/approvals/${encodeURIComponent(aActId)}/approve`, {});
+                    break;
+                }
+                case "reject_action": {
+                    const rActId = payload?.actionId;
+                    if (!rActId)
+                        throw new Error("reject_action requires actionId");
+                    result = await this.runtime.connection.request("POST", `/v1/proactive/approvals/${encodeURIComponent(rActId)}/reject`, { reason: payload?.reason });
+                    break;
+                }
+                case "configure_proactive":
+                    result = await this.runtime.connection.request("PUT", "/v1/proactive/settings", {
+                        enabled: payload?.enabled, scanIntervalMinutes: payload?.scanIntervalMinutes,
+                        maxActionsPerDay: payload?.maxActionsPerDay, callbackFormat: payload?.callbackFormat,
+                    });
+                    break;
+                // ── Content/write tools (native REST) ────────────────────
+                case "send_channel_message": {
+                    const chId = payload?.channelId;
+                    const chContent = payload?.content;
+                    if (!chId || !chContent)
+                        throw new Error("send_channel_message requires channelId and content");
+                    try {
+                        await this.runtime.connection.request("POST", `/v1/channels/${encodeURIComponent(chId)}/join`, {});
+                    }
+                    catch { }
+                    result = await this.runtime.connection.request("POST", `/v1/channels/${encodeURIComponent(chId)}/messages`, { content: chContent });
+                    break;
+                }
+                case "read_channel_messages": {
+                    const rcmId = payload?.channelId;
+                    if (!rcmId)
+                        throw new Error("read_channel_messages requires channelId");
+                    const rcmq = new URLSearchParams();
+                    if (payload?.limit)
+                        rcmq.set("limit", String(payload.limit));
+                    result = await this.runtime.connection.request("GET", `/v1/channels/${encodeURIComponent(rcmId)}/messages?${rcmq}`);
+                    break;
+                }
+                case "mute_agent": {
+                    const muteAddr = payload?.address;
+                    if (!muteAddr)
+                        throw new Error("mute_agent requires address");
+                    result = await this.runtime.connection.request("POST", `/v1/agents/${encodeURIComponent(muteAddr)}/mute`, {});
+                    break;
+                }
+                case "unmute_agent": {
+                    const unmuteAddr = payload?.address;
+                    if (!unmuteAddr)
+                        throw new Error("unmute_agent requires address");
+                    result = await this.runtime.connection.request("DELETE", `/v1/agents/${encodeURIComponent(unmuteAddr)}/mute`);
+                    break;
+                }
+                case "report_spam":
+                case "report_content": {
+                    const rCid = (payload?.contentCid || payload?.cid);
+                    const rReason = payload?.reason;
+                    if (!rCid || !rReason)
+                        throw new Error("report_content requires cid and reason");
+                    result = await this.runtime.connection.request("POST", `/v1/content/${encodeURIComponent(rCid)}/report`, { reason: rReason });
+                    break;
+                }
+                case "import_project_url": {
+                    const ipId = payload?.projectId;
+                    const ipUrl = payload?.url;
+                    if (!ipId || !ipUrl)
+                        throw new Error("import_project_url requires projectId and url");
+                    result = await this.runtime.connection.request("POST", `/v1/projects/${encodeURIComponent(ipId)}/import-url`, { url: ipUrl, branch: payload?.branch });
+                    break;
+                }
+                case "update_profile":
+                    result = await this.runtime.connection.request("PATCH", "/v1/agents/me", { displayName: payload?.displayName, description: payload?.description, capabilities: payload?.capabilities });
+                    break;
+                // ── Workspace tools (native REST) ────────────────────────
+                case "create_workspace": {
+                    const cwName = payload?.name;
+                    if (!cwName)
+                        throw new Error("create_workspace requires name");
+                    result = await this.runtime.connection.request("POST", "/v1/workspaces", { name: cwName, description: payload?.description });
+                    break;
+                }
+                case "workspace_add_member": {
+                    const wamId = payload?.workspaceId;
+                    const wamAgent = payload?.agentId;
+                    if (!wamId || !wamAgent)
+                        throw new Error("workspace_add_member requires workspaceId and agentId");
+                    result = await this.runtime.connection.request("POST", `/v1/workspaces/${encodeURIComponent(wamId)}/members`, { agentId: wamAgent, role: payload?.role || "editor" });
+                    break;
+                }
+                case "workspace_set_entry": {
+                    const wseId = payload?.workspaceId;
+                    const wseKey = payload?.key;
+                    if (!wseId || !wseKey)
+                        throw new Error("workspace_set_entry requires workspaceId and key");
+                    result = await this.runtime.connection.request("PUT", `/v1/workspaces/${encodeURIComponent(wseId)}/state`, { key: wseKey, value: payload?.value });
+                    break;
+                }
+                case "workspace_get_entries": {
+                    const wgeId = payload?.workspaceId;
+                    if (!wgeId)
+                        throw new Error("workspace_get_entries requires workspaceId");
+                    result = await this.runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(wgeId)}/state`);
+                    break;
+                }
+                case "get_workspace": {
+                    const gwId = payload?.workspaceId;
+                    if (!gwId)
+                        throw new Error("get_workspace requires workspaceId");
+                    result = await this.runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(gwId)}`);
+                    break;
+                }
+                case "get_swarm": {
+                    const gsId = payload?.swarmId;
+                    if (!gsId)
+                        throw new Error("get_swarm requires swarmId");
+                    result = await this.runtime.connection.request("GET", `/v1/swarms/${encodeURIComponent(gsId)}`);
+                    break;
+                }
+                case "create_proposal": {
+                    const cpWsId = payload?.workspaceId;
+                    const cpTitle = payload?.title;
+                    if (!cpWsId || !cpTitle)
+                        throw new Error("create_proposal requires workspaceId and title");
+                    result = await this.runtime.connection.request("POST", `/v1/workspaces/${encodeURIComponent(cpWsId)}/proposals`, { title: cpTitle, description: payload?.description });
+                    break;
+                }
+                case "list_proposals": {
+                    const lpWsId = payload?.workspaceId;
+                    if (!lpWsId)
+                        throw new Error("list_proposals requires workspaceId");
+                    result = await this.runtime.connection.request("GET", `/v1/workspaces/${encodeURIComponent(lpWsId)}/proposals`);
+                    break;
+                }
+                // ── Skill/teaching tools (native REST) ───────────────────
+                case "rate_skill":
+                case "review_skill": {
+                    const rsId = payload?.skillId;
+                    const rsRat = payload?.rating;
+                    if (!rsId || !rsRat)
+                        throw new Error("rate_skill requires skillId and rating");
+                    result = await this.runtime.connection.request("POST", `/v1/skills/registry/${encodeURIComponent(rsId)}/review`, { rating: rsRat, review: payload?.review });
+                    break;
+                }
+                case "teaching_stats":
+                    result = await this.runtime.connection.request("GET", "/v1/teaching/stats");
+                    break;
+                case "search_teachers": {
+                    const stGoal = payload?.goal;
+                    if (!stGoal)
+                        throw new Error("search_teachers requires goal");
+                    result = await this.runtime.connection.request("GET", `/v1/teaching/search-teachers?goal=${encodeURIComponent(stGoal)}`);
+                    break;
+                }
+                case "report_token_launch": {
+                    if (!payload?.tokenName || !payload?.tokenTicker || !payload?.tokenAddress)
+                        throw new Error("report_token_launch requires tokenName, tokenTicker, tokenAddress");
+                    result = await this.runtime.connection.request("POST", "/v1/clawnch/report-launch", { tokenName: payload.tokenName, tokenTicker: payload.tokenTicker, tokenAddress: payload.tokenAddress });
+                    break;
+                }
+                default: {
+                    // ── Unhandled action ─────────────────────────────────────
+                    if (this.verbose)
+                        console.warn(`[autonomous] Unhandled action: ${actionType}`);
+                    if (actionId)
+                        await this.runtime.proactive.rejectDelegatedAction(actionId, `Unknown action: ${actionType}`);
+                    return;
+                }
             }
             if (actionId)
                 await this.runtime.proactive.completeAction(actionId, txHash, result);