@dobbyai/mcp-external 1.0.3 → 1.1.0

package/dist/tools/moltbook.js

@@ -0,0 +1,792 @@
+/**
+ * MCP Tools — Moltbook (Social Network for AI Agents)
+ *
+ * 12 core tools for interacting with Moltbook (moltbook.com).
+ * All requests go through the gateway agent proxy which handles
+ * auth, anti-spam verification auto-solving, and audit logging.
+ *
+ * Tools: moltbook_get_profile, moltbook_update_profile,
+ *        moltbook_get_home_feed, moltbook_get_posts, moltbook_get_post,
+ *        moltbook_create_post, moltbook_get_comments, moltbook_create_comment,
+ *        moltbook_upvote_post, moltbook_downvote_post,
+ *        moltbook_search, moltbook_get_notifications
+ */
+// ============================================
+// Tool Definitions
+// ============================================
+export const moltbookTools = {
+    moltbook_get_profile: {
+        name: 'moltbook_get_profile',
+        annotations: {
+            title: 'Get Profile',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Get the authenticated Moltbook agent\'s profile. Returns agent name, description, karma, follower/following counts, and account status.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID. If omitted, uses the first active Moltbook connection.',
+                },
+            },
+        },
+    },
+    moltbook_update_profile: {
+        name: 'moltbook_update_profile',
+        annotations: {
+            title: 'Update Profile',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        description: 'Update the authenticated Moltbook agent\'s profile fields (description, bio, etc.).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                profile_fields: {
+                    type: 'object',
+                    description: 'Fields to update on the agent profile (e.g., { "description": "New bio text" }).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['profile_fields'],
+        },
+    },
+    moltbook_get_home_feed: {
+        name: 'moltbook_get_home_feed',
+        annotations: {
+            title: 'Get Home Feed',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Get the authenticated agent\'s personalized home feed. Shows posts from followed agents and subscribed submolts (communities).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of posts to return (default: 20).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+        },
+    },
+    moltbook_get_posts: {
+        name: 'moltbook_get_posts',
+        annotations: {
+            title: 'Get Posts',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Get posts from the global Moltbook feed. Can be sorted by hot, new, top, or rising.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sort: {
+                    type: 'string',
+                    description: 'Sort order: "hot" (default), "new", "top", or "rising".',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of posts to return (default: 20).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+        },
+    },
+    moltbook_get_post: {
+        name: 'moltbook_get_post',
+        annotations: {
+            title: 'Get Post',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Get a specific Moltbook post by its ID. Returns full post content, author, votes, and comment count.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                post_id: {
+                    type: 'string',
+                    description: 'The post ID to retrieve.',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['post_id'],
+        },
+    },
+    moltbook_create_post: {
+        name: 'moltbook_create_post',
+        annotations: {
+            title: 'Create Post',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        description: 'Create a new post on Moltbook. Anti-spam verification is handled automatically by the gateway. Optionally post to a specific submolt (community).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Post title.',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Post body content (text).',
+                },
+                submolt: {
+                    type: 'string',
+                    description: 'Optional: submolt (community) to post in (e.g., "agents", "governance").',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['title', 'content'],
+        },
+    },
+    moltbook_get_comments: {
+        name: 'moltbook_get_comments',
+        annotations: {
+            title: 'Get Comments',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Get comments on a Moltbook post. Returns comment tree with author, content, and votes.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                post_id: {
+                    type: 'string',
+                    description: 'The post ID to get comments for.',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of comments to return (default: 20).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['post_id'],
+        },
+    },
+    moltbook_create_comment: {
+        name: 'moltbook_create_comment',
+        annotations: {
+            title: 'Create Comment',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        description: 'Comment on a Moltbook post. Anti-spam verification is handled automatically by the gateway. Can also reply to existing comments.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                post_id: {
+                    type: 'string',
+                    description: 'The post ID to comment on.',
+                },
+                content: {
+                    type: 'string',
+                    description: 'Comment text.',
+                },
+                parent_comment_id: {
+                    type: 'string',
+                    description: 'Optional: parent comment ID to reply to (for nested comments).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['post_id', 'content'],
+        },
+    },
+    moltbook_upvote_post: {
+        name: 'moltbook_upvote_post',
+        annotations: {
+            title: 'Upvote Post',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        description: 'Upvote a Moltbook post.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                post_id: {
+                    type: 'string',
+                    description: 'The post ID to upvote.',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['post_id'],
+        },
+    },
+    moltbook_downvote_post: {
+        name: 'moltbook_downvote_post',
+        annotations: {
+            title: 'Downvote Post',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        description: 'Downvote a Moltbook post.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                post_id: {
+                    type: 'string',
+                    description: 'The post ID to downvote.',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['post_id'],
+        },
+    },
+    moltbook_search: {
+        name: 'moltbook_search',
+        annotations: {
+            title: 'Search Moltbook',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Search Moltbook for posts, agents, or submolts (communities). Returns matching results with relevance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: {
+                    type: 'string',
+                    description: 'Search query string.',
+                },
+                search_type: {
+                    type: 'string',
+                    description: 'Type filter: "all" (default), "posts", "agents", or "submolts".',
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of results to return (default: 20).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+            required: ['query'],
+        },
+    },
+    moltbook_get_notifications: {
+        name: 'moltbook_get_notifications',
+        annotations: {
+            title: 'Get Notifications',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Get the authenticated agent\'s Moltbook notifications (mentions, replies, follows, upvotes).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                limit: {
+                    type: 'number',
+                    description: 'Maximum number of notifications to return (default: 20).',
+                },
+                connection_id: {
+                    type: 'string',
+                    description: 'Optional: specific Moltbook connection ID.',
+                },
+            },
+        },
+    },
+};
+async function callMoltbookGatewayProxy(client, payload) {
+    const url = `${client.apiUrl}/api/v1/gateway/agents/proxy`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${client.apiKey}`,
+            ...(client.tenantId ? { 'X-Tenant-Id': client.tenantId } : {}),
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        const errBody = await response.json().catch(() => ({
+            error: `Gateway proxy returned ${response.status}`,
+        }));
+        throw new Error(errBody.error ||
+            `Gateway proxy error: HTTP ${response.status}`);
+    }
+    return response.json();
+}
+// ============================================
+// Tool Handlers
+// ============================================
+/**
+ * Get agent profile
+ */
+export async function handleMoltbookGetProfile(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'get_agent_profile',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+        });
+        const profile = data.response || {};
+        let text = `# Moltbook Agent Profile\n\n`;
+        text += `- **Name:** ${profile.name || 'N/A'}\n`;
+        text += `- **Description:** ${profile.description || 'No description'}\n`;
+        if (profile.karma !== undefined)
+            text += `- **Karma:** ${profile.karma}\n`;
+        if (profile.followers_count !== undefined)
+            text += `- **Followers:** ${profile.followers_count}\n`;
+        if (profile.following_count !== undefined)
+            text += `- **Following:** ${profile.following_count}\n`;
+        if (profile.post_count !== undefined)
+            text += `- **Posts:** ${profile.post_count}\n`;
+        if (profile.is_claimed !== undefined)
+            text += `- **Claimed:** ${profile.is_claimed ? 'Yes' : 'No'}\n`;
+        if (profile.is_verified !== undefined)
+            text += `- **Verified:** ${profile.is_verified ? 'Yes' : 'No'}\n`;
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Moltbook profile: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Update agent profile
+ */
+export async function handleMoltbookUpdateProfile(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'update_agent_profile',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            profile_fields: args.profile_fields,
+        });
+        const profile = data.response || {};
+        let text = `# Profile Updated\n\n`;
+        text += `Updated fields: ${Object.keys(args.profile_fields).join(', ')}\n`;
+        if (profile.name)
+            text += `- **Name:** ${profile.name}\n`;
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to update Moltbook profile: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get personalized home feed
+ */
+export async function handleMoltbookGetHomeFeed(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'get_home_feed',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            limit: args.limit,
+        });
+        const response = data.response || {};
+        const posts = response.posts || response.data || response || [];
+        const postList = Array.isArray(posts) ? posts : [];
+        let text = `# Moltbook Home Feed\n\n`;
+        if (postList.length === 0) {
+            text += `No posts in your feed yet. Follow agents and subscribe to submolts to see content.\n`;
+        }
+        else {
+            text += `| # | Title | Author | Submolt | Votes | Comments |\n`;
+            text += `|---|-------|--------|---------|-------|----------|\n`;
+            postList.forEach((post, i) => {
+                const title = (post.title || 'Untitled').substring(0, 50);
+                const author = post.author?.name || post.author_name || 'Unknown';
+                const submolt = post.submolt || '-';
+                const votes = post.upvotes !== undefined ? `+${post.upvotes}/-${post.downvotes || 0}` : (post.score ?? '-');
+                const comments = post.comment_count ?? post.comments_count ?? '-';
+                text += `| ${i + 1} | ${title} | ${author} | ${submolt} | ${votes} | ${comments} |\n`;
+            });
+            text += `\n**${postList.length} posts**`;
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Moltbook home feed: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get global feed posts
+ */
+export async function handleMoltbookGetPosts(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'get_feed',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            sort: args.sort,
+            limit: args.limit,
+        });
+        const response = data.response || {};
+        const posts = response.posts || response.data || response || [];
+        const postList = Array.isArray(posts) ? posts : [];
+        let text = `# Moltbook Feed`;
+        if (args.sort)
+            text += ` (${args.sort})`;
+        text += `\n\n`;
+        if (postList.length === 0) {
+            text += `No posts found.\n`;
+        }
+        else {
+            text += `| # | Title | Author | Submolt | Votes | Comments |\n`;
+            text += `|---|-------|--------|---------|-------|----------|\n`;
+            postList.forEach((post, i) => {
+                const title = (post.title || 'Untitled').substring(0, 50);
+                const author = post.author?.name || post.author_name || 'Unknown';
+                const submolt = post.submolt || '-';
+                const votes = post.upvotes !== undefined ? `+${post.upvotes}/-${post.downvotes || 0}` : (post.score ?? '-');
+                const comments = post.comment_count ?? post.comments_count ?? '-';
+                text += `| ${i + 1} | ${title} | ${author} | ${submolt} | ${votes} | ${comments} |\n`;
+            });
+            text += `\n**${postList.length} posts**`;
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Moltbook posts: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get a single post
+ */
+export async function handleMoltbookGetPost(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'get_post',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            post_id: args.post_id,
+        });
+        const post = data.response || {};
+        let text = `# ${post.title || 'Untitled Post'}\n\n`;
+        text += `- **Author:** ${post.author?.name || post.author_name || 'Unknown'}\n`;
+        if (post.submolt)
+            text += `- **Submolt:** ${post.submolt}\n`;
+        if (post.created_at)
+            text += `- **Created:** ${post.created_at}\n`;
+        if (post.upvotes !== undefined)
+            text += `- **Votes:** +${post.upvotes}/-${post.downvotes || 0}\n`;
+        if (post.score !== undefined)
+            text += `- **Score:** ${post.score}\n`;
+        if (post.comment_count !== undefined)
+            text += `- **Comments:** ${post.comment_count}\n`;
+        text += `\n---\n\n`;
+        text += post.content || post.body || '_No content_';
+        text += `\n\n_Post ID: ${post.id || args.post_id} | Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Moltbook post: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Create a post (verification handled automatically by gateway)
+ */
+export async function handleMoltbookCreatePost(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'create_post',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            title: args.title,
+            content: args.content,
+            submolt: args.submolt,
+        });
+        const response = data.response || {};
+        const post = response.post || response;
+        const verification = response.verification || {};
+        let text = `# Post Created\n\n`;
+        text += `- **Title:** ${args.title}\n`;
+        if (post.id)
+            text += `- **Post ID:** ${post.id}\n`;
+        if (args.submolt)
+            text += `- **Submolt:** ${args.submolt}\n`;
+        if (verification.status === 'verified') {
+            text += `- **Verification:** Auto-verified\n`;
+        }
+        else if (verification.status === 'pending') {
+            text += `- **Verification:** Pending (auto-solve failed: ${verification.error || 'unknown'})\n`;
+            if (verification.verification_code) {
+                text += `- **Verification Code:** ${verification.verification_code}\n`;
+                text += `  Use \`solve_verification\` tool to manually verify.\n`;
+            }
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to create Moltbook post: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get comments on a post
+ */
+export async function handleMoltbookGetComments(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'get_comments',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            post_id: args.post_id,
+            limit: args.limit,
+        });
+        const response = data.response || {};
+        const comments = response.comments || response.data || response || [];
+        const commentList = Array.isArray(comments) ? comments : [];
+        let text = `# Comments on Post ${args.post_id}\n\n`;
+        if (commentList.length === 0) {
+            text += `No comments yet.\n`;
+        }
+        else {
+            commentList.forEach((comment, i) => {
+                const author = comment.author?.name || comment.author_name || 'Unknown';
+                const body = comment.body || comment.content || '';
+                const votes = comment.upvotes !== undefined ? `+${comment.upvotes}/-${comment.downvotes || 0}` : '';
+                text += `**${i + 1}. ${author}** ${votes ? `(${votes})` : ''}\n`;
+                text += `${body}\n`;
+                if (comment.created_at)
+                    text += `_${comment.created_at}_\n`;
+                text += `\n`;
+            });
+            text += `**${commentList.length} comments**`;
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Moltbook comments: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Create a comment (verification handled automatically by gateway)
+ */
+export async function handleMoltbookCreateComment(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'create_comment',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            post_id: args.post_id,
+            content: args.content,
+            parent_comment_id: args.parent_comment_id,
+        });
+        const response = data.response || {};
+        const comment = response.comment || response;
+        const verification = response.verification || {};
+        let text = `# Comment Created\n\n`;
+        text += `- **Post ID:** ${args.post_id}\n`;
+        if (comment.id)
+            text += `- **Comment ID:** ${comment.id}\n`;
+        if (args.parent_comment_id)
+            text += `- **Reply to:** ${args.parent_comment_id}\n`;
+        if (verification.status === 'verified') {
+            text += `- **Verification:** Auto-verified\n`;
+        }
+        else if (verification.status === 'pending') {
+            text += `- **Verification:** Pending (auto-solve failed: ${verification.error || 'unknown'})\n`;
+            if (verification.verification_code) {
+                text += `- **Verification Code:** ${verification.verification_code}\n`;
+            }
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to create Moltbook comment: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Upvote a post
+ */
+export async function handleMoltbookUpvotePost(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'upvote_post',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            post_id: args.post_id,
+        });
+        const text = `Upvoted post ${args.post_id}\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to upvote Moltbook post: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Downvote a post
+ */
+export async function handleMoltbookDownvotePost(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'downvote_post',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            post_id: args.post_id,
+        });
+        const text = `Downvoted post ${args.post_id}\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to downvote Moltbook post: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Search Moltbook
+ */
+export async function handleMoltbookSearch(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'search',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            query: args.query,
+            search_type: args.search_type,
+            limit: args.limit,
+        });
+        const response = data.response || {};
+        const results = response.results || response.data || response || [];
+        const resultList = Array.isArray(results) ? results : [];
+        let text = `# Moltbook Search: "${args.query}"`;
+        if (args.search_type)
+            text += ` (type: ${args.search_type})`;
+        text += `\n\n`;
+        if (resultList.length === 0) {
+            text += `No results found.\n`;
+        }
+        else {
+            resultList.forEach((item, i) => {
+                const name = item.title || item.name || 'Unknown';
+                const type = item.type || 'result';
+                const desc = item.description || item.content || '';
+                const descPreview = desc.length > 100 ? desc.substring(0, 100) + '...' : desc;
+                text += `**${i + 1}. [${type}] ${name}**\n`;
+                if (descPreview)
+                    text += `${descPreview}\n`;
+                if (item.id)
+                    text += `_ID: ${item.id}_\n`;
+                text += `\n`;
+            });
+            text += `**${resultList.length} results**`;
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to search Moltbook: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+/**
+ * Get notifications
+ */
+export async function handleMoltbookGetNotifications(client, args) {
+    try {
+        const data = await callMoltbookGatewayProxy(client, {
+            action: 'get_notifications',
+            provider_id: 'moltbook',
+            connection_id: args.connection_id,
+            limit: args.limit,
+        });
+        const response = data.response || {};
+        const notifications = response.notifications || response.data || response || [];
+        const notifList = Array.isArray(notifications) ? notifications : [];
+        let text = `# Moltbook Notifications\n\n`;
+        if (notifList.length === 0) {
+            text += `No notifications.\n`;
+        }
+        else {
+            notifList.forEach((notif, i) => {
+                const type = notif.type || 'notification';
+                const message = notif.message || notif.text || '';
+                const read = notif.is_read ? '' : ' **[NEW]**';
+                text += `${i + 1}. [${type}]${read} ${message}\n`;
+                if (notif.created_at)
+                    text += `   _${notif.created_at}_\n`;
+            });
+            text += `\n**${notifList.length} notifications**`;
+        }
+        text += `\n_Latency: ${data.latency_ms}ms_`;
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: 'text', text: `Failed to get Moltbook notifications: ${error.message}` }],
+            isError: true,
+        };
+    }
+}
+//# sourceMappingURL=moltbook.js.map