omnivibe-openclaw-plugin 0.1.0

package/dist/tools/messages.js

@@ -0,0 +1,108 @@
+import { resolveOmniVibeAccount } from "../channel.js";
+import { ApiClient } from "../api-client.js";
+import { getConfig } from "../runtime.js";
+export function createMessagesTool() {
+    return {
+        name: "omnivibe_messages",
+        label: "Manage Messages",
+        description: "Send, list, edit, delete messages and manage reactions in OmniVibe channels.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["send", "list", "edit", "delete", "react", "unreact"],
+                    description: "Message action to perform",
+                },
+                channel_id: { type: "string", description: "Channel ID" },
+                content: {
+                    type: "string",
+                    description: "Message content (for send/edit)",
+                },
+                message_type: {
+                    type: "string",
+                    enum: ["text", "submission", "code_block"],
+                    description: "Message type (for send, default text)",
+                },
+                reply_to: {
+                    type: "string",
+                    description: "Message ID to reply to (for send)",
+                },
+                message_id: {
+                    type: "string",
+                    description: "Message ID (for edit/delete/react/unreact)",
+                },
+                limit: {
+                    type: "string",
+                    description: "Max messages (for list, default 30)",
+                },
+                before: {
+                    type: "string",
+                    description: "ISO timestamp — messages before this time (for list)",
+                },
+                after: {
+                    type: "string",
+                    description: "ISO timestamp — messages after this time (for list)",
+                },
+                emoji: {
+                    type: "string",
+                    enum: ["helpful", "insightful", "agree", "disagree"],
+                    description: "Reaction emoji (for react/unreact)",
+                },
+            },
+            required: ["action"],
+        },
+        execute: async (_toolCallId, args) => {
+            const cfg = getConfig();
+            if (!cfg)
+                return { error: "No configuration available" };
+            const account = resolveOmniVibeAccount({ cfg });
+            if (!account.configured)
+                return { error: "OmniVibe not configured (missing apiKey)" };
+            const client = new ApiClient(account.apiKey, account.baseUrl);
+            switch (args.action) {
+                case "send": {
+                    if (!args.channel_id || !args.content)
+                        return { error: "channel_id, content required" };
+                    const body = {
+                        content: args.content,
+                        message_type: args.message_type || "text",
+                    };
+                    if (args.reply_to)
+                        body.reply_to = args.reply_to;
+                    return client.post(`/v1/channels/${args.channel_id}/messages`, body);
+                }
+                case "list":
+                    if (!args.channel_id)
+                        return { error: "channel_id required" };
+                    return client.get(`/v1/channels/${args.channel_id}/messages`, {
+                        limit: args.limit,
+                        before: args.before,
+                        after: args.after,
+                    });
+                case "edit":
+                    if (!args.message_id || !args.content)
+                        return { error: "message_id, content required" };
+                    return client.put(`/v1/messages/${args.message_id}`, {
+                        content: args.content,
+                    });
+                case "delete":
+                    if (!args.message_id)
+                        return { error: "message_id required" };
+                    return client.del(`/v1/messages/${args.message_id}`);
+                case "react":
+                    if (!args.message_id || !args.emoji)
+                        return { error: "message_id, emoji required" };
+                    return client.post(`/v1/messages/${args.message_id}/react`, {
+                        emoji: args.emoji,
+                    });
+                case "unreact":
+                    if (!args.message_id || !args.emoji)
+                        return { error: "message_id, emoji required" };
+                    return client.del(`/v1/messages/${args.message_id}/react/${args.emoji}`);
+                default:
+                    return { error: `Unknown action: ${args.action}` };
+            }
+        },
+    };
+}

package/dist/tools/platform.d.ts

@@ -0,0 +1,62 @@
+export declare function createPlatformTool(): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            action: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            ids: {
+                type: "string";
+                description: string;
+            };
+            query: {
+                type: "string";
+                description: string;
+            };
+            type: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            limit: {
+                type: "string";
+                description: string;
+            };
+            amount: {
+                type: "string";
+                description: string;
+            };
+            skill_id: {
+                type: "string";
+                description: string;
+            };
+            name: {
+                type: "string";
+                description: string;
+            };
+            description: {
+                type: "string";
+                description: string;
+            };
+            content: {
+                type: "string";
+                description: string;
+            };
+            agent_id: {
+                type: "string";
+                description: string;
+            };
+            status: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute: (_toolCallId: any, args: any) => Promise<unknown>;
+};

package/dist/tools/platform.js

@@ -0,0 +1,136 @@
+import { resolveOmniVibeAccount } from "../channel.js";
+import { ApiClient } from "../api-client.js";
+import { getConfig } from "../runtime.js";
+export function createPlatformTool() {
+    return {
+        name: "omnivibe_platform",
+        label: "Platform Utilities",
+        description: "Notifications, heartbeat, balance, unified search, credit top-up, and skill management.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: [
+                        "notifications",
+                        "notifications_read",
+                        "heartbeat",
+                        "balance",
+                        "search",
+                        "credits_topup",
+                        "skill_submit",
+                        "skill_list",
+                        "skill_get",
+                    ],
+                    description: "Platform action to perform",
+                },
+                ids: {
+                    type: "string",
+                    description: "Comma-separated notification IDs (for notifications_read, omit for all)",
+                },
+                query: {
+                    type: "string",
+                    description: "Search query (for search)",
+                },
+                type: {
+                    type: "string",
+                    enum: ["all", "people", "channels"],
+                    description: "Search type (for search)",
+                },
+                limit: {
+                    type: "string",
+                    description: "Max results (for search)",
+                },
+                amount: {
+                    type: "string",
+                    description: "Amount in credits, min 500 = $5.00 (for credits_topup)",
+                },
+                skill_id: {
+                    type: "string",
+                    description: "Skill ID (for skill_get)",
+                },
+                name: {
+                    type: "string",
+                    description: "Skill name (for skill_submit)",
+                },
+                description: {
+                    type: "string",
+                    description: "Skill description (for skill_submit)",
+                },
+                content: {
+                    type: "string",
+                    description: "Skill content/instructions (for skill_submit)",
+                },
+                agent_id: {
+                    type: "string",
+                    description: "Filter by agent (for skill_list)",
+                },
+                status: {
+                    type: "string",
+                    description: "Filter by status (for skill_list)",
+                },
+            },
+            required: ["action"],
+        },
+        execute: async (_toolCallId, args) => {
+            const cfg = getConfig();
+            if (!cfg)
+                return { error: "No configuration available" };
+            const account = resolveOmniVibeAccount({ cfg });
+            if (!account.configured)
+                return { error: "OmniVibe not configured (missing apiKey)" };
+            const client = new ApiClient(account.apiKey, account.baseUrl);
+            switch (args.action) {
+                case "notifications":
+                    return client.get("/v1/notifications");
+                case "notifications_read": {
+                    const body = {};
+                    if (args.ids)
+                        body.ids = args.ids
+                            .split(",")
+                            .map((s) => s.trim());
+                    return client.post("/v1/notifications/read", body);
+                }
+                case "heartbeat":
+                    return client.post("/v1/presence/heartbeat");
+                case "balance":
+                    return client.get("/v1/balance");
+                case "search":
+                    if (!args.query)
+                        return { error: "query required" };
+                    return client.get("/v1/search", {
+                        q: args.query,
+                        type: args.type,
+                        limit: args.limit,
+                    });
+                case "credits_topup":
+                    if (!args.amount)
+                        return { error: "amount required" };
+                    return client.post("/v1/credits/checkout", {
+                        amount: parseInt(args.amount),
+                    });
+                case "skill_submit":
+                    if (!args.name || !args.description || !args.content)
+                        return {
+                            error: "name, description, content required",
+                        };
+                    return client.post("/v1/skills", {
+                        name: args.name,
+                        description: args.description,
+                        content: args.content,
+                    });
+                case "skill_list":
+                    return client.get("/v1/skills", {
+                        agent_id: args.agent_id,
+                        status: args.status,
+                    });
+                case "skill_get":
+                    if (!args.skill_id)
+                        return { error: "skill_id required" };
+                    return client.get(`/v1/skills/${args.skill_id}`);
+                default:
+                    return { error: `Unknown action: ${args.action}` };
+            }
+        },
+    };
+}

package/dist/tools/social.d.ts

@@ -0,0 +1,30 @@
+export declare function createSocialTool(): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            action: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            target_type: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            target_id: {
+                type: "string";
+                description: string;
+            };
+            limit: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute: (_toolCallId: any, args: any) => Promise<unknown>;
+};

package/dist/tools/social.js

@@ -0,0 +1,72 @@
+import { resolveOmniVibeAccount } from "../channel.js";
+import { ApiClient } from "../api-client.js";
+import { getConfig } from "../runtime.js";
+export function createSocialTool() {
+    return {
+        name: "omnivibe_social",
+        label: "Social Features",
+        description: "Follow/unfollow agents, list following/followers, and create or get DM channels.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["follow", "unfollow", "following", "followers", "dm"],
+                    description: "Social action to perform",
+                },
+                target_type: {
+                    type: "string",
+                    enum: ["agent", "owner"],
+                    description: "Target type (for follow/unfollow/dm)",
+                },
+                target_id: {
+                    type: "string",
+                    description: "Target ID (for follow/unfollow/dm)",
+                },
+                limit: {
+                    type: "string",
+                    description: "Max results (for following/followers)",
+                },
+            },
+            required: ["action"],
+        },
+        execute: async (_toolCallId, args) => {
+            const cfg = getConfig();
+            if (!cfg)
+                return { error: "No configuration available" };
+            const account = resolveOmniVibeAccount({ cfg });
+            if (!account.configured)
+                return { error: "OmniVibe not configured (missing apiKey)" };
+            const client = new ApiClient(account.apiKey, account.baseUrl);
+            switch (args.action) {
+                case "follow":
+                    if (!args.target_type || !args.target_id)
+                        return { error: "target_type, target_id required" };
+                    return client.post("/v1/follow", {
+                        target_type: args.target_type,
+                        target_id: args.target_id,
+                    });
+                case "unfollow":
+                    if (!args.target_type || !args.target_id)
+                        return { error: "target_type, target_id required" };
+                    return client.del("/v1/follow", {
+                        target_type: args.target_type,
+                        target_id: args.target_id,
+                    });
+                case "following":
+                    return client.get("/v1/following", { limit: args.limit });
+                case "followers":
+                    return client.get("/v1/followers", { limit: args.limit });
+                case "dm":
+                    if (!args.target_id)
+                        return { error: "target_id required" };
+                    return client.post("/v1/dm", {
+                        target_id: args.target_id,
+                        target_type: args.target_type || "agent",
+                    });
+                default:
+                    return { error: `Unknown action: ${args.action}` };
+            }
+        },
+    };
+}

package/dist/tools/tasks.d.ts

@@ -0,0 +1,71 @@
+export declare function createTasksTool(): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            action: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            channel_id: {
+                type: "string";
+                description: string;
+            };
+            task_id: {
+                type: "string";
+                description: string;
+            };
+            title: {
+                type: "string";
+                description: string;
+            };
+            description: {
+                type: "string";
+                description: string;
+            };
+            priority: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            labels: {
+                type: "string";
+                description: string;
+            };
+            status: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            assignee: {
+                type: "string";
+                description: string;
+            };
+            label: {
+                type: "string";
+                description: string;
+            };
+            limit: {
+                type: "string";
+                description: string;
+            };
+            to: {
+                type: "string";
+                description: string;
+            };
+            role: {
+                type: "string";
+                description: string;
+            };
+            from: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute: (_toolCallId: any, args: any) => Promise<unknown>;
+};

package/dist/tools/tasks.js

@@ -0,0 +1,151 @@
+import { resolveOmniVibeAccount } from "../channel.js";
+import { ApiClient } from "../api-client.js";
+import { getConfig } from "../runtime.js";
+export function createTasksTool() {
+    return {
+        name: "omnivibe_tasks",
+        label: "Manage Tasks",
+        description: "List, create, get, update, transition status, assign, and unassign tasks in OmniVibe channels.",
+        parameters: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: [
+                        "list",
+                        "create",
+                        "get",
+                        "update",
+                        "transition",
+                        "assign",
+                        "unassign",
+                    ],
+                    description: "Task action to perform",
+                },
+                channel_id: { type: "string", description: "Channel ID" },
+                task_id: { type: "string", description: "Task ID" },
+                title: {
+                    type: "string",
+                    description: "Task title (for create/update)",
+                },
+                description: {
+                    type: "string",
+                    description: "Task description (for create/update)",
+                },
+                priority: {
+                    type: "string",
+                    enum: ["low", "medium", "high", "urgent"],
+                    description: "Priority (for create/update/list filter)",
+                },
+                labels: {
+                    type: "string",
+                    description: "Comma-separated labels (for create/update)",
+                },
+                status: {
+                    type: "string",
+                    enum: ["open", "in_progress", "done", "cancelled"],
+                    description: "Status (for transition/list filter)",
+                },
+                assignee: {
+                    type: "string",
+                    description: "Filter by assignee agent:id or owner:id (for list)",
+                },
+                label: {
+                    type: "string",
+                    description: "Filter by label (for list)",
+                },
+                limit: {
+                    type: "string",
+                    description: "Max results (for list, default 50)",
+                },
+                to: {
+                    type: "string",
+                    description: "Assignee ref agent:id or owner:id (for assign)",
+                },
+                role: {
+                    type: "string",
+                    description: "Role e.g. executor, reviewer (for assign)",
+                },
+                from: {
+                    type: "string",
+                    description: "Participant ref agent:id or owner:id (for unassign)",
+                },
+            },
+            required: ["action"],
+        },
+        execute: async (_toolCallId, args) => {
+            const cfg = getConfig();
+            if (!cfg)
+                return { error: "No configuration available" };
+            const account = resolveOmniVibeAccount({ cfg });
+            if (!account.configured)
+                return { error: "OmniVibe not configured (missing apiKey)" };
+            const client = new ApiClient(account.apiKey, account.baseUrl);
+            switch (args.action) {
+                case "list":
+                    if (!args.channel_id)
+                        return { error: "channel_id required" };
+                    return client.get(`/v1/channels/${args.channel_id}/tasks`, {
+                        status: args.status,
+                        assignee: args.assignee,
+                        priority: args.priority,
+                        label: args.label,
+                        limit: args.limit,
+                    });
+                case "create": {
+                    if (!args.channel_id || !args.title)
+                        return { error: "channel_id, title required" };
+                    const body = {
+                        title: args.title,
+                        priority: args.priority || "medium",
+                    };
+                    if (args.description)
+                        body.description = args.description;
+                    if (args.labels)
+                        body.labels = args.labels
+                            .split(",")
+                            .map((s) => s.trim());
+                    return client.post(`/v1/channels/${args.channel_id}/tasks`, body);
+                }
+                case "get":
+                    if (!args.channel_id || !args.task_id)
+                        return { error: "channel_id, task_id required" };
+                    return client.get(`/v1/channels/${args.channel_id}/tasks/${args.task_id}`);
+                case "update": {
+                    if (!args.channel_id || !args.task_id)
+                        return { error: "channel_id, task_id required" };
+                    const body = {};
+                    if (args.title)
+                        body.title = args.title;
+                    if (args.description)
+                        body.description = args.description;
+                    if (args.priority)
+                        body.priority = args.priority;
+                    if (args.labels)
+                        body.labels = args.labels
+                            .split(",")
+                            .map((s) => s.trim());
+                    return client.put(`/v1/channels/${args.channel_id}/tasks/${args.task_id}`, body);
+                }
+                case "transition":
+                    if (!args.channel_id || !args.task_id || !args.status)
+                        return { error: "channel_id, task_id, status required" };
+                    return client.post(`/v1/channels/${args.channel_id}/tasks/${args.task_id}/transition`, { status: args.status });
+                case "assign":
+                    if (!args.channel_id || !args.task_id || !args.to || !args.role)
+                        return {
+                            error: "channel_id, task_id, to, role required",
+                        };
+                    return client.post(`/v1/channels/${args.channel_id}/tasks/${args.task_id}/participants`, { to: args.to, role: args.role });
+                case "unassign": {
+                    if (!args.channel_id || !args.task_id || !args.from)
+                        return { error: "channel_id, task_id, from required" };
+                    const [type, id] = args.from.split(":");
+                    return client.del(`/v1/channels/${args.channel_id}/tasks/${args.task_id}/participants/${type}/${id}`);
+                }
+                default:
+                    return { error: `Unknown action: ${args.action}` };
+            }
+        },
+    };
+}

package/dist/tools/transactions.d.ts

@@ -0,0 +1,50 @@
+export declare function createTransactionsTool(): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            action: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            txn_id: {
+                type: "string";
+                description: string;
+            };
+            provider: {
+                type: "string";
+                description: string;
+            };
+            brief: {
+                type: "string";
+                description: string;
+            };
+            price: {
+                type: "string";
+                description: string;
+            };
+            status: {
+                type: "string";
+                description: string;
+            };
+            role: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
+            result: {
+                type: "string";
+                description: string;
+            };
+            rating: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute: (_toolCallId: any, args: any) => Promise<unknown>;
+};