@blurt-blockchain/blurt-mcp-server 0.4.0

package/dist/contracts/toolRegistry.js

@@ -0,0 +1,384 @@
+import { z } from "zod";
+export const TOOL_RESULT_CONTRACT = "blurt-mcp.tool-result.v1";
+export const TOOL_RESULT_OUTPUT_SCHEMA = {
+    data: z.unknown().describe("Tool-specific result payload. The exact shape is tool-specific until v1 schemas are finalized."),
+    meta: z.object({
+        contract: z.literal(TOOL_RESULT_CONTRACT),
+        tool: z.string(),
+        sources: z.array(z.enum(["layer1", "nexus", "external", "mixed", "mcp"])),
+        retrieved_at: z.string().describe("ISO-8601 timestamp when the MCP server produced this result."),
+        freshness: z.object({
+            cache: z.enum(["none", "short", "medium", "external"]),
+            ttl_seconds: z.number().nullable(),
+        }),
+        confidence: z.enum(["high", "medium", "low"]),
+        caveats: z.array(z.string()),
+    }),
+};
+const read = "read";
+const writeLocal = "write-local";
+const v1 = "v1-candidate";
+export const TOOL_REGISTRY = {
+    "get-account": {
+        name: "get-account",
+        title: "Get account profile and wallet summary",
+        description: "Structured account identity, wallet, stake, witness vote count and rewards summary.",
+        source: "mixed",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Show me @nalexadre's Blurt account and wallet."],
+        caveats: ["Combines Layer 1 account state with Nexus profile data."],
+    },
+    "get-account-history": {
+        name: "get-account-history",
+        title: "Get raw account operation history",
+        description: "Recent Layer 1 operations for an account, optionally filtered by operation type.",
+        source: "layer1",
+        safety: read,
+        cache: "none",
+        stability: v1,
+        examples: ["Show the latest 10 transfer operations for @beblurt."],
+    },
+    "get-account-posts": {
+        name: "get-account-posts",
+        title: "Get account-related posts",
+        description: "Nexus account posts, blog, comments, replies, feed or payout items.",
+        source: "nexus",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Show @nalexadre's latest posts."],
+    },
+    "get-post": {
+        name: "get-post",
+        title: "Get post or discussion",
+        description: "Nexus post summary or full discussion tree for an author/permlink.",
+        source: "nexus",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Open nalexadre/how-ai-can-help-curation-on-blurt-1759501073717."],
+    },
+    "get-publications": {
+        name: "get-publications",
+        title: "Get ranked publications",
+        description: "Nexus ranked posts for discovery by sort/tag.",
+        source: "nexus",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["What is trending under #blurt?"],
+    },
+    "get-blurt-price": {
+        name: "get-blurt-price",
+        title: "Get BLURT market price",
+        description: "Current BLURT USD/BTC price from the configured public price feed.",
+        source: "external",
+        safety: read,
+        cache: "external",
+        stability: v1,
+        examples: ["What is the current BLURT price?"],
+        caveats: ["External price feed is best-effort and may be temporarily unavailable."],
+    },
+    "get-chain-status": {
+        name: "get-chain-status",
+        title: "Get chain and market status",
+        description: "Network, supply, reward and market dashboard for Blurt.",
+        source: "mixed",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Give me a Blurt network health snapshot."],
+    },
+    "list-communities": {
+        name: "list-communities",
+        title: "List communities",
+        description: "Nexus community discovery by rank, newness or subscribers.",
+        source: "nexus",
+        safety: read,
+        cache: "medium",
+        stability: v1,
+        examples: ["What are the most popular Blurt communities?"],
+    },
+    "get-community": {
+        name: "get-community",
+        title: "Get community details",
+        description: "Nexus details for a single Blurt community.",
+        source: "nexus",
+        safety: read,
+        cache: "medium",
+        stability: v1,
+        examples: ["Show details for community blurt-101010."],
+    },
+    "get-post-votes": {
+        name: "get-post-votes",
+        title: "Get post votes",
+        description: "Layer 1 active votes on a post/comment ranked by rshares.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Who were the biggest voters on this post?"],
+    },
+    "get-vote-value": {
+        name: "get-vote-value",
+        title: "Estimate account vote value",
+        description: "Estimated current upvote value for an account at a given weight.",
+        source: "mixed",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["How much is a 100% vote from @nalexadre worth?"],
+        caveats: ["Vote value depends on current mana and reward-pool state."],
+    },
+    "list-witnesses": {
+        name: "list-witnesses",
+        title: "List witnesses",
+        description: "Layer 1 witness ranking and production metadata.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["List the top 10 Blurt witnesses."],
+    },
+    "get-witness": {
+        name: "get-witness",
+        title: "Get witness health",
+        description: "Layer 1 witness details and health summary for one account.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Is @nalexadre's witness healthy?"],
+    },
+    "get-account-witness-votes": {
+        name: "get-account-witness-votes",
+        title: "Get account witness votes",
+        description: "Witnesses supported by an account and any witness proxy.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Which witnesses does @nalexadre vote for?"],
+    },
+    "get-account-relationships": {
+        name: "get-account-relationships",
+        title: "Get social relationship counts",
+        description: "Follower/following counts and samples for an account.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Who follows @nalexadre?"],
+    },
+    "get-pending-rewards": {
+        name: "get-pending-rewards",
+        title: "Get unclaimed rewards",
+        description: "Pending reward balances currently claimable by an account.",
+        source: "mixed",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["How much can @nalexadre claim right now?"],
+    },
+    "get-account-subscriptions": {
+        name: "get-account-subscriptions",
+        title: "Get community subscriptions",
+        description: "Communities an account is subscribed to and its role in them.",
+        source: "nexus",
+        safety: read,
+        cache: "medium",
+        stability: v1,
+        examples: ["Which communities does @nalexadre belong to?"],
+    },
+    "compare-accounts": {
+        name: "compare-accounts",
+        title: "Compare accounts",
+        description: "Side-by-side account metrics for stake, reach, output and rewards.",
+        source: "mixed",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Compare @nalexadre, @megadrive and @beblurt."],
+    },
+    "get-referrals": {
+        name: "get-referrals",
+        title: "Get referred accounts",
+        description: "beBlurt referral accounts and total count for a referrer.",
+        source: "nexus",
+        safety: read,
+        cache: "medium",
+        stability: v1,
+        examples: ["How many accounts did @beblurt refer?"],
+    },
+    "get-account-notifications": {
+        name: "get-account-notifications",
+        title: "Get notifications",
+        description: "Nexus notifications and unread count for an account.",
+        source: "nexus",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Do I have recent Blurt notifications?"],
+    },
+    "get-post-reblogs": {
+        name: "get-post-reblogs",
+        title: "Get post reblogs",
+        description: "Accounts that reblogged a post.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Who reblogged this post?"],
+    },
+    "get-delegations": {
+        name: "get-delegations",
+        title: "Get outgoing delegations",
+        description: "Outgoing Blurt Power delegations for an account.",
+        source: "layer1",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Who does @beblurt delegate to?"],
+    },
+    "lookup-accounts": {
+        name: "lookup-accounts",
+        title: "Lookup account names",
+        description: "Alphabetical account-name autocomplete by prefix.",
+        source: "layer1",
+        safety: read,
+        cache: "medium",
+        stability: v1,
+        examples: ["Find accounts starting with nale."],
+    },
+    search: {
+        name: "search",
+        title: "Search Blurt resources",
+        description: "Map a free-form query to blurt:// resource links.",
+        source: "mcp",
+        safety: read,
+        cache: "none",
+        stability: v1,
+        examples: ["Search for @nalexadre or posts:blurt."],
+    },
+    fetch: {
+        name: "fetch",
+        title: "Fetch Blurt resource",
+        description: "Resolve a blurt:// URI or shorthand id to raw JSON.",
+        source: "mixed",
+        safety: read,
+        cache: "short",
+        stability: v1,
+        examples: ["Fetch blurt://account/nalexadre."],
+    },
+    "blurt-claim-rewards": {
+        name: "blurt-claim-rewards",
+        title: "Claim rewards locally",
+        description: "Claim pending rewards using the configured local posting key.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Claim my pending rewards after dry-run preview."],
+    },
+    "blurt-upvote": {
+        name: "blurt-upvote",
+        title: "Upvote locally",
+        description: "Broadcast a local posting-key vote operation.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Upvote this post at 25% after dry-run."],
+    },
+    "blurt-comment": {
+        name: "blurt-comment",
+        title: "Comment locally",
+        description: "Broadcast a local posting-key comment/reply operation.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Publish this reviewed reply."],
+    },
+    "blurt-post": {
+        name: "blurt-post",
+        title: "Post locally",
+        description: "Broadcast a local posting-key top-level post operation.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Publish this reviewed post."],
+    },
+    "blurt-follow": {
+        name: "blurt-follow",
+        title: "Follow locally",
+        description: "Broadcast a local posting-key follow/unfollow custom_json.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Follow this account after preview."],
+    },
+    "blurt-mute": {
+        name: "blurt-mute",
+        title: "Mute locally",
+        description: "Broadcast a local posting-key mute/unmute custom_json.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Mute this account after preview."],
+    },
+    "blurt-subscribe-community": {
+        name: "blurt-subscribe-community",
+        title: "Subscribe to community locally",
+        description: "Broadcast a local posting-key community subscription custom_json.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Subscribe me to this community after preview."],
+    },
+    "blurt-reblog": {
+        name: "blurt-reblog",
+        title: "Reblog locally",
+        description: "Broadcast a local posting-key reblog/undo custom_json.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Reblog this post after preview."],
+    },
+    "blurt-read-notifications": {
+        name: "blurt-read-notifications",
+        title: "Mark notifications read locally",
+        description: "Broadcast a local posting-key notification read marker.",
+        source: "layer1",
+        safety: writeLocal,
+        cache: "none",
+        stability: v1,
+        examples: ["Mark notifications as read after I review them."],
+    },
+};
+export const READ_TOOL_NAMES = Object.values(TOOL_REGISTRY)
+    .filter((tool) => tool.safety === "read")
+    .map((tool) => tool.name)
+    .sort();
+export const WRITE_TOOL_NAMES = Object.values(TOOL_REGISTRY)
+    .filter((tool) => tool.safety === "write-local")
+    .map((tool) => tool.name)
+    .sort();
+export function toolSources(tool) {
+    return Array.isArray(tool.source) ? [...tool.source] : [tool.source];
+}
+export function ttlSeconds(cache) {
+    switch (cache) {
+        case "short": return 60;
+        case "medium": return 300;
+        case "external": return 60;
+        case "none": return null;
+    }
+}

package/dist/resources/blurtResource.js

@@ -0,0 +1,82 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { utils as blurtUtils } from "@beblurt/dblurt";
+function jsonContents(uri, data) {
+    return {
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify(data, null, 2),
+            },
+        ],
+    };
+}
+export function registerBlurtResources(server, client) {
+    // 1) Account: blurt://account/{username}
+    server.registerResource("blurt-account", new ResourceTemplate("blurt://account/{username}", { list: undefined }), {
+        title: "Blurt Account",
+        description: "Blurt account information (JSON).",
+        mimeType: "application/json",
+    }, async (uri, { username }) => {
+        const [account] = await client.condenser.getAccounts([username]);
+        if (!account) {
+            throw Object.assign(new Error("Resource not found"), { code: -32002 });
+        }
+        return jsonContents(uri, account);
+    });
+    // 2) History: blurt://history/{username}?limit=&ops=vote,comment
+    server.registerResource("blurt-history", new ResourceTemplate("blurt://history/{username}", { list: undefined }), {
+        title: "Blurt Account History",
+        description: "Blurt account history, filterable by operation types via ?ops=.",
+        mimeType: "application/json",
+    }, async (uri, { username }) => {
+        const u = new URL(uri.href);
+        const limit = Math.max(1, Math.min(1000, Number(u.searchParams.get("limit") ?? 50)));
+        const opsCsv = u.searchParams.get("ops") ?? "";
+        let bitmask;
+        if (opsCsv) {
+            const opEnum = blurtUtils.operationOrders;
+            const selected = opsCsv
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean)
+                .map((name) => opEnum[name])
+                .filter((v) => typeof v === "number");
+            bitmask = blurtUtils.makeBitMaskFilter(selected);
+        }
+        const history = await client.condenser.getAccountHistory(username, -1, limit, bitmask);
+        return jsonContents(uri, history);
+    });
+    // 3) Publications: blurt://posts/{by}/{tag}?limit=
+    // by ∈ trending|hot|created|promoted|payout|payout_comments|muted (Nexus ranked posts)
+    server.registerResource("blurt-posts", new ResourceTemplate("blurt://posts/{by}/{tag}", { list: undefined }), {
+        title: "Blurt Publications",
+        description: "Ranked posts (Nexus getRankedPosts) by sort and tag. Parameters: {by}/{tag}?limit=",
+        mimeType: "application/json",
+    }, async (uri, { by, tag }) => {
+        const u = new URL(uri.href);
+        const limit = Math.max(1, Math.min(100, Number(u.searchParams.get("limit") ?? 20)));
+        // Aligned with the `fetch` tool and `get-publications`: single Nexus data source.
+        const posts = await client.nexus.getRankedPosts({
+            sort: by,
+            limit,
+            tag: tag ?? null,
+        });
+        return jsonContents(uri, posts);
+    });
+    // 4) Post / Discussion: blurt://post/{author}/{permlink}?with_comments=true
+    server.registerResource("blurt-post", new ResourceTemplate("blurt://post/{author}/{permlink}", { list: undefined }), {
+        title: "Blurt Post or Discussion",
+        description: "Single Blurt post or full discussion via ?with_comments=true (JSON).",
+        mimeType: "application/json",
+    }, async (uri, { author, permlink }) => {
+        const u = new URL(uri.href);
+        const withComments = u.searchParams.get("with_comments") === "true";
+        if (withComments) {
+            const discussion = await client.nexus.getDiscussion(author, permlink);
+            return jsonContents(uri, discussion);
+        }
+        const post = await client.nexus.getPost({ author: author, permlink: permlink });
+        return jsonContents(uri, post);
+    });
+}

package/dist/server-stdio.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import "./utils/loadEnv.js"; // must run before anything reads process.env
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import logger from "./utils/logger.js";
+import { buildServer } from "./buildServer.js";
+import { liveBlurtClient, startNodeChecker } from "./utils/rpc.js";
+import { createWriteContext } from "./utils/signer.js";
+/**
+ * Local stdio entrypoint: run the Blurt MCP server as a child process for desktop
+ * AI apps that launch a "local MCP server" via a command (e.g. Claude Desktop's
+ * claude_desktop_config.json) — no HTTP server, no bridge.
+ *
+ * The MCP protocol uses stdout; all logs go to stderr (see utils/logger.ts), so
+ * they never corrupt the stream.
+ */
+async function main() {
+    // Keep the client pointed at the healthiest RPC nodes (liveBlurtClient follows it).
+    startNodeChecker();
+    // Enable write tools only if a valid posting key is configured. If a key is
+    // present but invalid (wrong format/authority), refuse to start (fail closed).
+    let write;
+    try {
+        write = (await createWriteContext(liveBlurtClient)) ?? undefined;
+    }
+    catch (e) {
+        logger.error(`Refusing to start — ${e.message}`);
+        process.exit(1);
+    }
+    const server = buildServer(liveBlurtClient, { write });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    logger.info(`Blurt MCP server running on stdio${write ? " (write enabled)" : " (read-only)"}`);
+}
+main().catch((err) => {
+    logger.error("Fatal stdio server error: " + err.stack);
+    process.exit(1);
+});

package/dist/server.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import "./utils/loadEnv.js"; // must run before anything reads process.env
+import logger from "./utils/logger.js";
+import { createApp } from "./app.js";
+import { liveBlurtClient, startNodeChecker } from "./utils/rpc.js";
+import { assertNoKeyForHttp, createWriteContext } from "./utils/signer.js";
+async function main() {
+    // The HTTP server stays read-only by default. If a posting key is present,
+    // assertNoKeyForHttp either refuses startup or returns true only after the
+    // operator sets the exact unsafe override value.
+    let write;
+    try {
+        const unsafeHttpSigning = assertNoKeyForHttp();
+        if (unsafeHttpSigning) {
+            write = (await createWriteContext(liveBlurtClient)) ?? undefined;
+            if (!write) {
+                throw new Error("Unsafe HTTP signing override is set, but no valid write context could be created.");
+            }
+        }
+    }
+    catch (e) {
+        logger.error(e.message);
+        process.exit(1);
+    }
+    const PORT = process.env.PORT || 3000;
+    createApp({ write }).listen(PORT, () => {
+        logger.info(`MCP Stateless Streamable HTTP server running on http://localhost:${PORT}/mcp${write ? " (UNSAFE HTTP WRITE ENABLED)" : ""}`);
+        // Continuously score the RPC nodes and keep the client on the healthiest ones.
+        startNodeChecker();
+    });
+}
+main().catch((err) => {
+    logger.error("Fatal HTTP server error: " + err.stack);
+    process.exit(1);
+});

package/dist/tools/claimRewards.js

@@ -0,0 +1,48 @@
+// Logger
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { claimRewards, withinCap, dryRunDefault } from "../utils/signer.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+const CAP_MAX = 6;
+const CAP_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * Tool: blurt-claim-rewards (Blurt — WRITE)
+ *
+ * Signs a claim_reward_balance with the local posting key. Only registered on the
+ * local stdio server by default when a validated posting key is present.
+ */
+export function registerClaimRewards(server, client, ctx) {
+    registerBlurtTool(server, "blurt-claim-rewards", {
+        title: "Claim pending Blurt rewards",
+        description: "WRITE operation (signs a claim_reward_balance with the local posting key): claim the configured " +
+            "account's pending author/curation rewards, moving them from the reward pool into its balance and " +
+            "Blurt Power. Use this when the user asks to claim/collect their pending rewards. It only ever acts on " +
+            "the configured account (no parameter targets another account), and is available only on the local " +
+            "stdio server. Parameter: dry_run (default follows BLURT_DRY_RUN_DEFAULT; false when unset) — when true, previews the pending amounts WITHOUT " +
+            "broadcasting. Returns the pending amounts and, when executed, the transaction id. " +
+            "Note: rate-limited; the posting key cannot move funds, only claim/social actions.",
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            dry_run: z.boolean().default(dryRunDefault()).describe("Preview only, without broadcasting the transaction"),
+        },
+    }, async ({ dry_run }) => {
+        logger.debug(`blurt-claim-rewards called (dry_run=${dry_run})`);
+        try {
+            if (!dry_run && !withinCap("claim-rewards", CAP_MAX, CAP_WINDOW_MS)) {
+                return {
+                    content: [{ type: "text", text: `Rate limit reached for claim-rewards (max ${CAP_MAX}/hour).` }],
+                    isError: true,
+                };
+            }
+            const result = await claimRewards(client, ctx, dry_run);
+            if (result.claimed)
+                logger.info(`Claimed rewards for @${result.account} (tx ${result.tx_id}).`);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            // Never include the key or signed payload in errors.
+            logger.error(`[blurt-claim-rewards] Error: ${e.message}`);
+            return { content: [{ type: "text", text: "Error claiming rewards." }], isError: true };
+        }
+    });
+}

package/dist/tools/comment.js

@@ -0,0 +1,58 @@
+// Logger
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { comment, withinCap, dryRunDefault } from "../utils/signer.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+const CAP_MAX = 10;
+const CAP_WINDOW_MS = 60 * 60 * 1000; // 1 hour
+/**
+ * Tool: blurt-comment (Blurt — WRITE)
+ *
+ * Signs a `comment` (reply) with the local posting key. Only registered on the
+ * local stdio server by default when a validated posting key is present.
+ *
+ * The comment is stamped with `json_metadata.app = "blurt-mcp/<version>"` and a
+ * `via [Blurt-MCP](…)` footer is appended to the body.
+ */
+export function registerComment(server, client, ctx) {
+    registerBlurtTool(server, "blurt-comment", {
+        title: "Comment on (reply to) a Blurt post",
+        description: "WRITE operation (signs a `comment` with the local posting key): post a reply to a Blurt post or " +
+            "comment as the configured account. Use this when the user asks to comment on / reply to a specific " +
+            "post. Identify the parent by parent_author + parent_permlink. Parameters: parent_author, " +
+            "parent_permlink, body (the markdown comment text), dry_run (default follows BLURT_DRY_RUN_DEFAULT; false when unset — when true, previews the " +
+            "exact body that would be posted WITHOUT broadcasting). A unique permlink is generated automatically, " +
+            "the body is tagged with the blurt-mcp app and a short attribution footer, and only the configured " +
+            "account posts. Available only on the local stdio server; rate-limited. Posts are public and permanent.",
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            parent_author: z.string().min(1).describe("Author of the post/comment being replied to"),
+            parent_permlink: z.string().min(1).describe("Permlink of the post/comment being replied to"),
+            body: z.string().min(1).describe("The comment text (markdown)"),
+            dry_run: z.boolean().default(dryRunDefault()).describe("Preview the final body only, without broadcasting"),
+        },
+    }, async ({ parent_author, parent_permlink, body, dry_run }) => {
+        logger.debug(`blurt-comment: reply to ${parent_author}/${parent_permlink} (dry_run=${dry_run})`);
+        try {
+            if (!dry_run && !withinCap("comment", CAP_MAX, CAP_WINDOW_MS)) {
+                return {
+                    content: [{ type: "text", text: `Rate limit reached for comment (max ${CAP_MAX}/hour).` }],
+                    isError: true,
+                };
+            }
+            const result = await comment(client, ctx, {
+                parentAuthor: parent_author,
+                parentPermlink: parent_permlink,
+                body,
+                dryRun: dry_run,
+            });
+            if (result.posted)
+                logger.info(`Commented on ${parent_author}/${parent_permlink} (tx ${result.tx_id}).`);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[blurt-comment] Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Error commenting on ${parent_author}/${parent_permlink}` }], isError: true };
+        }
+    });
+}