@nookplot/runtime 0.5.30 → 0.5.32

package/dist/__tests__/autonomous.actionDispatch.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=autonomous.actionDispatch.test.d.ts.map

package/dist/__tests__/autonomous.actionDispatch.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomous.actionDispatch.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/autonomous.actionDispatch.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/autonomous.actionDispatch.test.js

@@ -0,0 +1,570 @@
+/**
+ * Action dispatch tests for AutonomousAgent.handleActionRequest.
+ *
+ * Tests that each action type calls the correct runtime manager method
+ * with the right arguments. Uses mock runtime + mock prepareSignRelay.
+ */
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createMockRuntime } from "./helpers/mockRuntime.js";
+import { AutonomousAgent } from "../autonomous.js";
+// Mock prepareSignRelay at module level
+vi.mock("../signing.js", () => ({
+    prepareSignRelay: vi.fn().mockResolvedValue({ txHash: "0xRELAY_TX" }),
+    signForwardRequest: vi.fn(),
+}));
+import { prepareSignRelay } from "../signing.js";
+const mockPrepareSignRelay = vi.mocked(prepareSignRelay);
+let runtime;
+let callbacks;
+let agent;
+beforeEach(() => {
+    vi.clearAllMocks();
+    const mock = createMockRuntime();
+    runtime = mock.runtime;
+    callbacks = mock.callbacks;
+    agent = new AutonomousAgent(runtime, { verbose: false });
+    agent.start();
+});
+/** Helper: dispatch an action request and wait for processing */
+async function dispatchAction(actionType, payload, suggestedContent, actionId) {
+    const event = { agentId: "agent_1", actionType, payload, suggestedContent, actionId };
+    callbacks.actionCb(event);
+    // Allow async handler to settle
+    await new Promise((r) => setTimeout(r, 10));
+}
+// ── On-chain via runtime managers ──────────────────────────────
+describe("on-chain actions via runtime managers", () => {
+    it("create_post / publish calls memory.publishKnowledge", async () => {
+        await dispatchAction("create_post", { community: "general", title: "Test" }, "Post body");
+        expect(runtime.memory.publishKnowledge).toHaveBeenCalledWith(expect.objectContaining({ title: "Test", body: "Post body", community: "general" }));
+    });
+    it("publish is alias for create_post", async () => {
+        await dispatchAction("publish", { community: "sci" }, "My insight");
+        expect(runtime.memory.publishKnowledge).toHaveBeenCalled();
+    });
+    it("post_reply calls memory.publishComment", async () => {
+        await dispatchAction("post_reply", { parentCid: "Qm_parent", community: "general" }, "Nice post!");
+        expect(runtime.memory.publishComment).toHaveBeenCalledWith(expect.objectContaining({ parentCid: "Qm_parent", body: "Nice post!", community: "general" }));
+    });
+    it("vote calls memory.vote", async () => {
+        await dispatchAction("vote", { cid: "Qm_cid", voteType: "up" });
+        expect(runtime.memory.vote).toHaveBeenCalledWith(expect.objectContaining({ cid: "Qm_cid", type: "up" }));
+    });
+    it("follow_agent calls social.follow", async () => {
+        await dispatchAction("follow_agent", { targetAddress: "0xTARGET" });
+        expect(runtime.social.follow).toHaveBeenCalledWith("0xTARGET");
+    });
+    it("attest_agent calls social.attest", async () => {
+        await dispatchAction("attest_agent", { targetAddress: "0xTARGET" }, "Great work!");
+        expect(runtime.social.attest).toHaveBeenCalledWith("0xTARGET", "Great work!");
+    });
+    it("list_service calls marketplace.createListing", async () => {
+        await dispatchAction("list_service", { category: "dev" }, "Build APIs");
+        expect(runtime.marketplace.createListing).toHaveBeenCalledWith(expect.objectContaining({ title: "Build APIs", category: "dev" }));
+    });
+    it("create_agreement calls marketplace.createAgreement", async () => {
+        await dispatchAction("create_agreement", { listingId: 42 }, "Build me an API");
+        expect(runtime.marketplace.createAgreement).toHaveBeenCalledWith(expect.objectContaining({ listingId: 42, terms: "Build me an API" }));
+    });
+    it("deliver_work calls marketplace.deliver", async () => {
+        await dispatchAction("deliver_work", { agreementId: 5 }, "Qm_delivery_cid");
+        expect(runtime.marketplace.deliver).toHaveBeenCalledWith(5, "Qm_delivery_cid");
+    });
+    it("settle_agreement calls marketplace.settle", async () => {
+        await dispatchAction("settle_agreement", { agreementId: 5 });
+        expect(runtime.marketplace.settle).toHaveBeenCalledWith(5);
+    });
+    it("dispute_agreement calls marketplace.dispute", async () => {
+        await dispatchAction("dispute_agreement", { agreementId: 5 });
+        expect(runtime.marketplace.dispute).toHaveBeenCalledWith(5);
+    });
+    it("cancel_agreement calls marketplace.cancel", async () => {
+        await dispatchAction("cancel_agreement", { agreementId: 5 });
+        expect(runtime.marketplace.cancel).toHaveBeenCalledWith(5);
+    });
+    it("expire_dispute calls marketplace.expireDispute", async () => {
+        await dispatchAction("expire_dispute", { agreementId: 5 });
+        expect(runtime.marketplace.expireDispute).toHaveBeenCalledWith(5);
+    });
+    it("expire_delivered calls marketplace.expireDelivered", async () => {
+        await dispatchAction("expire_delivered", { agreementId: 5 });
+        expect(runtime.marketplace.expireDelivered).toHaveBeenCalledWith(5);
+    });
+});
+// ── On-chain via prepareSignRelay ────────────────────────────
+describe("on-chain actions via prepareSignRelay", () => {
+    it("create_community calls prepareSignRelay with /v1/prepare/community", async () => {
+        await dispatchAction("create_community", { slug: "ai", name: "AI Agents" }, "An AI community");
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/community", expect.objectContaining({ slug: "ai", name: "AI Agents" }));
+    });
+    it("propose_guild calls prepareSignRelay with /v1/prepare/guild", async () => {
+        await dispatchAction("propose_guild", { name: "BuilderGuild", members: ["0xA", "0xB", "0xC"] }, "A builder guild");
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild", expect.objectContaining({ name: "BuilderGuild", members: ["0xA", "0xB", "0xC"] }));
+    });
+    it("propose_clique is alias for propose_guild", async () => {
+        await dispatchAction("propose_clique", { name: "Clique", members: ["0xA", "0xB"] }, "desc");
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild", expect.anything());
+    });
+    it("create_project does 2-step discover + prepare", async () => {
+        vi.mocked(runtime.connection.request).mockResolvedValueOnce({ discoveryId: "disc_1" });
+        await dispatchAction("create_project", { projectId: "proj_1", name: "My Project" }, "Project desc");
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/projects/discover", expect.anything());
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/project", expect.objectContaining({ discoveryId: "disc_1", projectId: "proj_1" }));
+    });
+    it("claim_bounty calls prepareSignRelay with /v1/prepare/bounty/:id/claim", async () => {
+        await dispatchAction("claim_bounty", { bountyId: "42" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/42/claim", {});
+    });
+    it("claim is alias for claim_bounty", async () => {
+        await dispatchAction("claim", { bountyId: "99" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/99/claim", {});
+    });
+    it("create_bounty calls prepareSignRelay with /v1/prepare/bounty", async () => {
+        await dispatchAction("create_bounty", { tokenRewardAmount: "100" }, "Fix the bug");
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty", expect.objectContaining({ title: "Fix the bug", tokenRewardAmount: "100" }));
+    });
+    it("create_bundle calls prepareSignRelay with /v1/prepare/bundle", async () => {
+        await dispatchAction("create_bundle", { name: "Research Bundle" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bundle", expect.objectContaining({ name: "Research Bundle" }));
+    });
+    it("approve_bounty_claimer calls prepareSignRelay with /v1/prepare/bounty/:id/approve-claimer", async () => {
+        await dispatchAction("approve_bounty_claimer", { bountyId: "10", claimer: "0xCLAIMER" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/approve-claimer", { claimer: "0xCLAIMER" });
+    });
+    it("approve_bounty_work calls prepareSignRelay with /v1/prepare/bounty/:id/approve", async () => {
+        await dispatchAction("approve_bounty_work", { bountyId: "10" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/approve", {});
+    });
+    it("dispute_bounty_work calls prepareSignRelay with /v1/prepare/bounty/:id/dispute", async () => {
+        await dispatchAction("dispute_bounty_work", { bountyId: "10" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/dispute", {});
+    });
+    it("cancel_bounty calls prepareSignRelay with /v1/prepare/bounty/:id/cancel", async () => {
+        await dispatchAction("cancel_bounty", { bountyId: "10" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/cancel", {});
+    });
+    it("unclaim_bounty calls prepareSignRelay with /v1/prepare/bounty/:id/unclaim", async () => {
+        await dispatchAction("unclaim_bounty", { bountyId: "10" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/bounty/10/unclaim", {});
+    });
+    it("deploy_preview calls prepareSignRelay with /v1/prepare/project/:id/deployment", async () => {
+        await dispatchAction("deploy_preview", { projectId: "proj_1" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/project/proj_1/deployment", expect.objectContaining({ prepaidHours: 2 }));
+    });
+    it("join_guild / approve_guild calls prepareSignRelay with /v1/prepare/guild/:id/approve", async () => {
+        await dispatchAction("join_guild", { guildId: 5 });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild/5/approve", {});
+    });
+    it("reject_guild calls prepareSignRelay with /v1/prepare/guild/:id/reject", async () => {
+        await dispatchAction("reject_guild", { guildId: 5 });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild/5/reject", {});
+    });
+    it("leave_guild calls prepareSignRelay with /v1/prepare/guild/:id/leave", async () => {
+        await dispatchAction("leave_guild", { guildId: 5 });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/guild/5/leave", {});
+    });
+    it("update_service calls prepareSignRelay with /v1/prepare/service/update", async () => {
+        await dispatchAction("update_service", { listingId: "list_1", title: "Updated" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/service/update", expect.objectContaining({ listingId: "list_1" }));
+    });
+    it("create_listing calls prepareSignRelay with /v1/prepare/service/list", async () => {
+        await dispatchAction("create_listing", { title: "Service", category: "dev" });
+        expect(mockPrepareSignRelay).toHaveBeenCalledWith(runtime.connection, "/v1/prepare/service/list", expect.anything());
+    });
+});
+// ── Off-chain messaging ──────────────────────────────────────
+describe("off-chain messaging actions", () => {
+    it("reply with channelId sends to channel", async () => {
+        await dispatchAction("reply", { channelId: "ch_1" }, "Hello channel!");
+        expect(runtime.channels.send).toHaveBeenCalledWith("ch_1", "Hello channel!");
+    });
+    it("reply with to sends DM", async () => {
+        await dispatchAction("reply", { to: "0xTARGET" }, "Hello DM!");
+        expect(runtime.inbox.send).toHaveBeenCalledWith(expect.objectContaining({ to: "0xTARGET", content: "Hello DM!" }));
+    });
+    it("send_dm calls inbox.send", async () => {
+        await dispatchAction("send_dm", { recipientAddress: "0xTARGET" }, "Hey!");
+        expect(runtime.inbox.send).toHaveBeenCalledWith(expect.objectContaining({ to: "0xTARGET", content: "Hey!" }));
+    });
+    it("send_message with to sends DM", async () => {
+        await dispatchAction("send_message", { to: "0xTARGET" }, "Collaboration time!");
+        expect(runtime.inbox.send).toHaveBeenCalled();
+    });
+    it("send_message with channelId sends to channel", async () => {
+        await dispatchAction("send_message", { channelId: "ch_2" }, "Hi team!");
+        expect(runtime.channels.send).toHaveBeenCalledWith("ch_2", "Hi team!");
+    });
+    it("acknowledge sends to project channel", async () => {
+        await dispatchAction("acknowledge", { projectId: "proj_1" });
+        expect(runtime.channels.sendToProject).toHaveBeenCalledWith("proj_1", expect.any(String));
+    });
+    it("accept sends to project channel", async () => {
+        await dispatchAction("accept", { projectId: "proj_1" });
+        expect(runtime.channels.sendToProject).toHaveBeenCalledWith("proj_1", expect.any(String));
+    });
+    it("execute with channelId sends to channel", async () => {
+        await dispatchAction("execute", { channelId: "ch_1" }, "Executing task...");
+        expect(runtime.channels.send).toHaveBeenCalledWith("ch_1", "Executing task...");
+    });
+    it("execute with to sends DM", async () => {
+        await dispatchAction("execute", { to: "0xTARGET" }, "Done!");
+        expect(runtime.inbox.send).toHaveBeenCalled();
+    });
+    it("propose_collab sends DM", async () => {
+        await dispatchAction("propose_collab", { targetAddress: "0xTARGET" }, "Let's work together!");
+        expect(runtime.inbox.send).toHaveBeenCalledWith(expect.objectContaining({ to: "0xTARGET", content: "Let's work together!" }));
+    });
+});
+// ── Off-chain social ─────────────────────────────────────────
+describe("off-chain social actions", () => {
+    it("follow calls social.follow", async () => {
+        await dispatchAction("follow", { targetAddress: "0xTARGET" });
+        expect(runtime.social.follow).toHaveBeenCalledWith("0xTARGET");
+    });
+    it("follow_back calls social.follow", async () => {
+        await dispatchAction("follow_back", { senderAddress: "0xFOLLOWER" });
+        expect(runtime.social.follow).toHaveBeenCalledWith("0xFOLLOWER");
+    });
+    it("attest calls social.attest", async () => {
+        await dispatchAction("attest", { targetAddress: "0xTARGET" }, "Excellent contributor");
+        expect(runtime.social.attest).toHaveBeenCalledWith("0xTARGET", "Excellent contributor");
+    });
+    it("attest_back calls social.attest", async () => {
+        await dispatchAction("attest_back", { senderAddress: "0xATTESTER" });
+        expect(runtime.social.attest).toHaveBeenCalledWith("0xATTESTER", "Valued collaborator");
+    });
+});
+// ── Off-chain project actions ────────────────────────────────
+describe("off-chain project actions", () => {
+    it("review calls projects.submitReview", async () => {
+        await dispatchAction("review", { projectId: "proj_1", commitId: "abc", verdict: "approve" }, "LGTM");
+        expect(runtime.projects.submitReview).toHaveBeenCalledWith("proj_1", "abc", "approve", "LGTM");
+    });
+    it("comment calls projects.submitReview with verdict=comment", async () => {
+        await dispatchAction("comment", { projectId: "proj_1", commitId: "abc" }, "Looks fine");
+        expect(runtime.projects.submitReview).toHaveBeenCalledWith("proj_1", "abc", "comment", "Looks fine");
+    });
+    it("request_ai_review calls projects.requestAIReview", async () => {
+        await dispatchAction("request_ai_review", { projectId: "proj_1", commitId: "abc" });
+        expect(runtime.projects.requestAIReview).toHaveBeenCalledWith("proj_1", "abc");
+    });
+    it("commit_files calls projects.commitFiles", async () => {
+        const files = [{ path: "src/main.ts", content: "console.log('hi')" }];
+        await dispatchAction("commit_files", { projectId: "proj_1", files }, "Initial commit");
+        expect(runtime.projects.commitFiles).toHaveBeenCalledWith("proj_1", files, "Initial commit");
+    });
+    it("gateway_commit is alias for commit_files", async () => {
+        const files = [{ path: "index.ts", content: "export {}" }];
+        await dispatchAction("gateway_commit", { projectId: "proj_1", files });
+        expect(runtime.projects.commitFiles).toHaveBeenCalled();
+    });
+    it("add_collaborator calls projects.addCollaborator", async () => {
+        await dispatchAction("add_collaborator", { projectId: "proj_1", collaboratorAddress: "0xCOLLAB", role: "editor" });
+        expect(runtime.projects.addCollaborator).toHaveBeenCalledWith("proj_1", "0xCOLLAB", "editor");
+    });
+    it("create_task calls projects.createTask", async () => {
+        await dispatchAction("create_task", { projectId: "proj_1" }, "Implement feature X");
+        expect(runtime.projects.createTask).toHaveBeenCalledWith("proj_1", expect.objectContaining({ title: "Implement feature X" }));
+    });
+    it("assign_task calls projects.assignTask", async () => {
+        await dispatchAction("assign_task", { projectId: "proj_1", taskId: "task_1", assigneeAddress: "0xWORKER" });
+        expect(runtime.projects.assignTask).toHaveBeenCalledWith("proj_1", "task_1", "0xWORKER");
+    });
+    it("complete_task calls projects.updateTask with status=completed", async () => {
+        await dispatchAction("complete_task", { projectId: "proj_1", taskId: "task_1" });
+        expect(runtime.projects.updateTask).toHaveBeenCalledWith("proj_1", "task_1", expect.objectContaining({ status: "completed" }));
+    });
+    it("update_task calls projects.updateTask with provided updates", async () => {
+        await dispatchAction("update_task", { projectId: "proj_1", taskId: "task_1", status: "in_progress", priority: "high" });
+        expect(runtime.projects.updateTask).toHaveBeenCalledWith("proj_1", "task_1", expect.objectContaining({ status: "in_progress", priority: "high" }));
+    });
+    it("link_project_to_guild performs 3-step linking", async () => {
+        vi.mocked(runtime.guilds.get).mockResolvedValueOnce({ members: [{ address: "0xMEMBER", status: 2 }] });
+        await dispatchAction("link_project_to_guild", { projectId: "proj_1", guildId: 5 });
+        expect(runtime.guilds.linkProject).toHaveBeenCalledWith(5, "proj_1");
+        expect(runtime.projects.setGuildAttribution).toHaveBeenCalledWith("proj_1", "5");
+        expect(runtime.projects.addCollaborator).toHaveBeenCalledWith("proj_1", "0xMEMBER", "editor");
+    });
+});
+// ── Off-chain HTTP actions ───────────────────────────────────
+describe("off-chain HTTP actions", () => {
+    it("apply_bounty calls connection.request POST", async () => {
+        await dispatchAction("apply_bounty", { bountyId: "42" }, "I can do this!");
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/apply", expect.objectContaining({ message: "I can do this!" }));
+    });
+    it("submit_bounty_work calls connection.request POST", async () => {
+        await dispatchAction("submit_bounty_work", { bountyId: "42" }, "Here is my work");
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/submissions", expect.anything());
+    });
+    it("approve_bounty_application calls connection.request POST", async () => {
+        await dispatchAction("approve_bounty_application", { bountyId: "42", applicationId: "app_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/applications/app_1/approve", {});
+    });
+    it("reject_bounty_application calls connection.request POST", async () => {
+        await dispatchAction("reject_bounty_application", { bountyId: "42", applicationId: "app_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/applications/app_1/reject", {});
+    });
+    it("select_bounty_submission calls connection.request POST", async () => {
+        await dispatchAction("select_bounty_submission", { bountyId: "42", submissionId: "sub_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/bounties/42/submissions/sub_1/select", {});
+    });
+    it("accept_invitation calls connection.request POST", async () => {
+        await dispatchAction("accept_invitation", { invitationId: "inv_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/teams/invitations/inv_1/accept", {});
+    });
+    it("decline_invitation calls connection.request POST", async () => {
+        await dispatchAction("decline_invitation", { invitationId: "inv_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/teams/invitations/inv_1/decline", {});
+    });
+    it("grant calls connection.request POST with grant-access", async () => {
+        await dispatchAction("grant", { projectId: "proj_1", bountyId: "42", requestId: "req_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/projects/proj_1/bounties/42/grant-access", { requestId: "req_1" });
+    });
+    it("deny calls connection.request POST with deny-access", async () => {
+        await dispatchAction("deny", { projectId: "proj_1", bountyId: "42", requestId: "req_1" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/projects/proj_1/bounties/42/deny-access", { requestId: "req_1" });
+    });
+});
+// ── Real-world actions ───────────────────────────────────────
+describe("real-world actions", () => {
+    it("egress_request calls tools.httpRequest", async () => {
+        await dispatchAction("egress_request", { url: "https://api.example.com/data", method: "GET" });
+        expect(runtime.tools.httpRequest).toHaveBeenCalledWith("https://api.example.com/data", "GET", expect.anything());
+    });
+    it("http_request is alias for egress_request", async () => {
+        await dispatchAction("http_request", { url: "https://example.com", method: "POST" });
+        expect(runtime.tools.httpRequest).toHaveBeenCalled();
+    });
+    it("execute_tool calls tools.executeTool", async () => {
+        await dispatchAction("execute_tool", { toolName: "my_tool", args: { key: "val" } });
+        expect(runtime.tools.executeTool).toHaveBeenCalledWith("my_tool", { key: "val" });
+    });
+    it("connect_mcp_server calls tools.connectMcpServer", async () => {
+        await dispatchAction("connect_mcp_server", { serverUrl: "https://mcp.example.com", serverName: "test" });
+        expect(runtime.tools.connectMcpServer).toHaveBeenCalledWith("https://mcp.example.com", "test");
+    });
+    it("disconnect_mcp_server calls tools.disconnectMcpServer", async () => {
+        await dispatchAction("disconnect_mcp_server", { serverId: "mcp_1" });
+        expect(runtime.tools.disconnectMcpServer).toHaveBeenCalledWith("mcp_1");
+    });
+    it("call_mcp_tool calls tools.executeTool", async () => {
+        await dispatchAction("call_mcp_tool", { toolName: "mcp_tool_1", args: { x: 1 } });
+        expect(runtime.tools.executeTool).toHaveBeenCalledWith("mcp_tool_1", { x: 1 });
+    });
+    it("register_webhook calls tools.registerWebhook", async () => {
+        await dispatchAction("register_webhook", { source: "github" });
+        expect(runtime.tools.registerWebhook).toHaveBeenCalledWith("github", expect.anything());
+    });
+});
+// ── Strategy / knowledge actions ─────────────────────────────
+describe("strategy and knowledge actions", () => {
+    it("publish_insight calls insights.publish", async () => {
+        await dispatchAction("publish_insight", { title: "Insight", body: "Content" });
+        expect(runtime.insights.publish).toHaveBeenCalledWith(expect.objectContaining({ title: "Insight", body: "Content" }));
+    });
+    it("cite_insight calls insights.cite", async () => {
+        await dispatchAction("cite_insight", { insightId: "ins_1" });
+        expect(runtime.insights.cite).toHaveBeenCalledWith("ins_1", undefined, undefined);
+    });
+    it("apply_insight calls insights.apply", async () => {
+        await dispatchAction("apply_insight", { insightId: "ins_1" });
+        expect(runtime.insights.apply).toHaveBeenCalledWith("ins_1", undefined, undefined);
+    });
+    it("workspace_create calls workspaces.create", async () => {
+        await dispatchAction("workspace_create", { name: "My Workspace" });
+        expect(runtime.workspaces.create).toHaveBeenCalledWith(expect.objectContaining({ name: "My Workspace" }));
+    });
+    it("workspace_set calls workspaces.setState", async () => {
+        await dispatchAction("workspace_set", { workspaceId: "ws_1", key: "status", value: "active" });
+        expect(runtime.workspaces.setState).toHaveBeenCalledWith("ws_1", "status", "active");
+    });
+    it("workspace_snapshot calls workspaces.createSnapshot", async () => {
+        await dispatchAction("workspace_snapshot", { workspaceId: "ws_1" });
+        expect(runtime.workspaces.createSnapshot).toHaveBeenCalledWith("ws_1", undefined);
+    });
+    it("propose_action calls workspaces.createProposal", async () => {
+        await dispatchAction("propose_action", { workspaceId: "ws_1", title: "Upgrade deps" });
+        expect(runtime.workspaces.createProposal).toHaveBeenCalledWith("ws_1", expect.objectContaining({ title: "Upgrade deps" }));
+    });
+    it("vote_proposal calls workspaces.vote", async () => {
+        await dispatchAction("vote_proposal", { workspaceId: "ws_1", proposalId: "prop_1", vote: true });
+        expect(runtime.workspaces.vote).toHaveBeenCalledWith("ws_1", "prop_1", true, undefined);
+    });
+    it("cancel_proposal calls workspaces.cancelProposal", async () => {
+        await dispatchAction("cancel_proposal", { workspaceId: "ws_1", proposalId: "prop_1" });
+        expect(runtime.workspaces.cancelProposal).toHaveBeenCalledWith("ws_1", "prop_1");
+    });
+});
+// ── Treasury actions ─────────────────────────────────────────
+describe("treasury actions", () => {
+    it("deposit_treasury calls guilds.depositTreasury", async () => {
+        await dispatchAction("deposit_treasury", { guildId: "5", amount: 100 });
+        expect(runtime.guilds.depositTreasury).toHaveBeenCalledWith("5", 100, undefined);
+    });
+    it("withdraw_treasury calls guilds.withdrawTreasury", async () => {
+        await dispatchAction("withdraw_treasury", { guildId: "5", amount: 50 });
+        expect(runtime.guilds.withdrawTreasury).toHaveBeenCalledWith("5", 50, undefined);
+    });
+    it("fund_bounty_from_treasury calls guilds.fundBountyFromTreasury", async () => {
+        await dispatchAction("fund_bounty_from_treasury", { guildId: "5", bountyId: "10", amount: 25 });
+        expect(runtime.guilds.fundBountyFromTreasury).toHaveBeenCalledWith("5", "10", 25, undefined);
+    });
+    it("distribute_revenue calls guilds.distributeRevenue", async () => {
+        await dispatchAction("distribute_revenue", { guildId: "5" });
+        expect(runtime.guilds.distributeRevenue).toHaveBeenCalledWith("5", undefined);
+    });
+});
+// ── Swarm actions ────────────────────────────────────────────
+describe("swarm actions", () => {
+    it("create_swarm calls swarms.create", async () => {
+        await dispatchAction("create_swarm", { title: "Data Collection", subtasks: [{ title: "Collect A" }] });
+        expect(runtime.swarms.create).toHaveBeenCalledWith(expect.objectContaining({ title: "Data Collection" }));
+    });
+    it("claim_subtask calls swarms.claimSubtask", async () => {
+        await dispatchAction("claim_subtask", { subtaskId: "st_1" });
+        expect(runtime.swarms.claimSubtask).toHaveBeenCalledWith("st_1");
+    });
+    it("submit_swarm_result calls swarms.submitResult", async () => {
+        await dispatchAction("submit_swarm_result", { subtaskId: "st_1" });
+        expect(runtime.swarms.submitResult).toHaveBeenCalledWith("st_1", undefined, undefined);
+    });
+    it("aggregate_swarm calls swarms.aggregate", async () => {
+        await dispatchAction("aggregate_swarm", { swarmId: "swarm_1" });
+        expect(runtime.swarms.aggregate).toHaveBeenCalledWith("swarm_1", undefined);
+    });
+});
+// ── Specialization actions ───────────────────────────────────
+describe("specialization actions", () => {
+    it("record_gap calls specialization.recordGap", async () => {
+        await dispatchAction("record_gap", { queryText: "How to deploy to k8s?" });
+        expect(runtime.specialization.recordGap).toHaveBeenCalledWith(expect.objectContaining({ queryText: "How to deploy to k8s?" }));
+    });
+    it("update_proficiency calls specialization.updateProficiency", async () => {
+        await dispatchAction("update_proficiency", { skillDomain: "typescript", proficiency: 85 });
+        expect(runtime.specialization.updateProficiency).toHaveBeenCalledWith("typescript", 85);
+    });
+    it("generate_recommendations calls specialization.generateRecommendations", async () => {
+        await dispatchAction("generate_recommendations", {});
+        expect(runtime.specialization.generateRecommendations).toHaveBeenCalled();
+    });
+    it("dismiss_recommendation calls specialization.dismissRecommendation", async () => {
+        await dispatchAction("dismiss_recommendation", { recommendationId: "rec_1" });
+        expect(runtime.specialization.dismissRecommendation).toHaveBeenCalledWith("rec_1");
+    });
+});
+// ── Intent actions ───────────────────────────────────────────
+describe("intent actions", () => {
+    it("create_intent calls intents.create", async () => {
+        await dispatchAction("create_intent", { title: "Need a logo" });
+        expect(runtime.intents.create).toHaveBeenCalledWith(expect.objectContaining({ title: "Need a logo" }));
+    });
+    it("browse_intents calls intents.list", async () => {
+        await dispatchAction("browse_intents", { status: "open" });
+        expect(runtime.intents.list).toHaveBeenCalledWith(expect.objectContaining({ status: "open", limit: 20 }));
+    });
+    it("submit_proposal calls intents.submitProposal", async () => {
+        await dispatchAction("submit_proposal", { intentId: "intent_1" }, "I can help");
+        expect(runtime.intents.submitProposal).toHaveBeenCalledWith("intent_1", expect.objectContaining({ description: "I can help" }));
+    });
+    it("accept_proposal calls intents.acceptProposal", async () => {
+        await dispatchAction("accept_proposal", { intentId: "intent_1", proposalId: "prop_1" });
+        expect(runtime.intents.acceptProposal).toHaveBeenCalledWith("intent_1", "prop_1");
+    });
+    it("cancel_intent calls intents.cancel", async () => {
+        await dispatchAction("cancel_intent", { intentId: "intent_1" });
+        expect(runtime.intents.cancel).toHaveBeenCalledWith("intent_1");
+    });
+    it("complete_intent calls intents.complete", async () => {
+        await dispatchAction("complete_intent", { intentId: "intent_1" });
+        expect(runtime.intents.complete).toHaveBeenCalledWith("intent_1");
+    });
+    it("withdraw_proposal calls intents.withdrawProposal", async () => {
+        await dispatchAction("withdraw_proposal", { intentId: "intent_1", proposalId: "prop_1" });
+        expect(runtime.intents.withdrawProposal).toHaveBeenCalledWith("intent_1", "prop_1");
+    });
+});
+// ── Token launch actions ─────────────────────────────────────
+describe("token launch actions", () => {
+    it("preview_token_launch calls connection.request POST", async () => {
+        await dispatchAction("preview_token_launch", { tokenName: "MyCoin", tokenTicker: "MYC" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/clawnch/preview", expect.objectContaining({ tokenName: "MyCoin", tokenTicker: "MYC" }));
+    });
+    it("launch_token calls connection.request POST", async () => {
+        await dispatchAction("launch_token", { tokenName: "MyCoin", tokenTicker: "MYC" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/clawnch/launch", expect.objectContaining({ tokenName: "MyCoin", tokenTicker: "MYC" }));
+    });
+    it("claim_clawnch_fees calls connection.request POST", async () => {
+        await dispatchAction("claim_clawnch_fees", { tokenAddress: "0xTOKEN" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("POST", "/v1/clawnch/claim-fees", { tokenAddress: "0xTOKEN" });
+    });
+    it("get_token_analytics calls connection.request GET", async () => {
+        await dispatchAction("get_token_analytics", { tokenAddress: "0xTOKEN" });
+        expect(runtime.connection.request).toHaveBeenCalledWith("GET", "/v1/clawnch/analytics/token/0xTOKEN");
+    });
+});
+// ── Oracle actions ───────────────────────────────────────────
+describe("oracle actions", () => {
+    it("query_oracle project calls oracle.getProjectSignals", async () => {
+        await dispatchAction("query_oracle", { entityType: "project", entityId: "proj_1" });
+        expect(runtime.oracle.getProjectSignals).toHaveBeenCalledWith("proj_1");
+    });
+    it("query_oracle agent calls oracle.getAgentSignals", async () => {
+        await dispatchAction("query_oracle", { entityType: "agent", entityId: "0xAGENT" });
+        expect(runtime.oracle.getAgentSignals).toHaveBeenCalledWith("0xAGENT");
+    });
+    it("query_oracle intent calls oracle.getIntentSignals", async () => {
+        await dispatchAction("query_oracle", { entityType: "intent", entityId: "intent_1" });
+        expect(runtime.oracle.getIntentSignals).toHaveBeenCalledWith("intent_1");
+    });
+    it("query_oracle guild calls oracle.getGuildSignals", async () => {
+        await dispatchAction("query_oracle", { entityType: "guild", entityId: "guild_1" });
+        expect(runtime.oracle.getGuildSignals).toHaveBeenCalledWith("guild_1");
+    });
+});
+// ── Marketplace review + messages ────────────────────────────
+describe("marketplace review and messages", () => {
+    it("submit_review calls marketplace.submitReview", async () => {
+        await dispatchAction("submit_review", { agreementId: 5, rating: 4 }, "Good work!");
+        expect(runtime.marketplace.submitReview).toHaveBeenCalledWith(5, 4, "Good work!");
+    });
+    it("send_agreement_message calls marketplace.sendAgreementMessage", async () => {
+        await dispatchAction("send_agreement_message", { agreementId: 5, messageType: "revision_request" }, "Please fix X");
+        expect(runtime.marketplace.sendAgreementMessage).toHaveBeenCalledWith(5, "revision_request", "Please fix X", undefined);
+    });
+});
+// ── Matching actions ─────────────────────────────────────────
+describe("matching actions", () => {
+    it("find_agents calls matching.findAgents", async () => {
+        await dispatchAction("find_agents", { skills: ["typescript", "react"] });
+        expect(runtime.matching.findAgents).toHaveBeenCalledWith(["typescript", "react"], expect.anything());
+    });
+    it("assemble_team calls matching.assembleTeam", async () => {
+        await dispatchAction("assemble_team", {}, "Build a web3 dashboard");
+        expect(runtime.matching.assembleTeam).toHaveBeenCalledWith(expect.objectContaining({ description: "Build a web3 dashboard" }));
+    });
+});
+// ── Error cases and lifecycle ────────────────────────────────
+describe("error cases and action lifecycle", () => {
+    it("unknown action rejects delegated action", async () => {
+        await dispatchAction("totally_unknown_action", {}, undefined, "action_42");
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("action_42", expect.stringContaining("Unknown"));
+    });
+    it("actionId triggers proactive.completeAction on success", async () => {
+        await dispatchAction("follow", { targetAddress: "0xTARGET" }, undefined, "action_99");
+        expect(runtime.proactive.completeAction).toHaveBeenCalledWith("action_99", "0xMOCK_TX", expect.anything());
+    });
+    it("missing required field throws and rejects delegated action", async () => {
+        await dispatchAction("send_dm", {}, undefined, "action_fail");
+        expect(runtime.proactive.rejectDelegatedAction).toHaveBeenCalledWith("action_fail", expect.stringContaining("requires"));
+    });
+    it("custom onAction handler bypasses default dispatch", async () => {
+        const customHandler = vi.fn().mockResolvedValue(undefined);
+        const customAgent = new AutonomousAgent(runtime, { onAction: customHandler, verbose: false });
+        customAgent.start();
+        callbacks.actionCb({ agentId: "a1", actionType: "follow", payload: { targetAddress: "0x1" } });
+        await new Promise((r) => setTimeout(r, 10));
+        expect(customHandler).toHaveBeenCalled();
+        expect(runtime.social.follow).not.toHaveBeenCalled();
+    });
+});
+//# sourceMappingURL=autonomous.actionDispatch.test.js.map