@blurt-blockchain/blurt-mcp-server 0.4.0

package/dist/tools/getReferrals.js

@@ -0,0 +1,39 @@
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+/** Tool: get-referrals (Blurt) — accounts referred by a referrer. */
+export function registerGetReferrals(server, client) {
+    registerBlurtTool(server, "get-referrals", {
+        title: "Get a referrer's affiliated Blurt accounts",
+        description: "List the Blurt accounts that signed up through a given referrer (the beBlurt referral/affiliate " +
+            "system), plus the total count. Use this when the user asks 'who did X refer', 'how many accounts " +
+            "did X bring', or to measure a referrer's onboarding impact. Parameters: referrer (the referrer " +
+            "account name), limit (1-100, default 50). Returns: total (the referrer's total affiliated accounts) " +
+            "and a list of referred accounts, each with account name, campaign_id and creation date (most recent " +
+            "first).",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            referrer: z.string().min(3).describe("Referrer account name (e.g., 'beblurt')"),
+            limit: z.number().int().min(1).max(100).default(50).describe("Max referred accounts to return"),
+        },
+    }, async ({ referrer, limit }) => {
+        logger.debug(`get-referrals: ${referrer}, limit=${limit}`);
+        try {
+            const [accounts, count] = await Promise.all([
+                client.nexus.referralAccounts({ referrer, campaign_id: null, limit }),
+                client.nexus.referralAccountsCount({ referrer }),
+            ]);
+            const summary = {
+                referrer,
+                total: count.count,
+                returned: accounts.length,
+                accounts,
+            };
+            return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[get-referrals] Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Error retrieving referrals for ${referrer}` }], isError: true };
+        }
+    });
+}

package/dist/tools/getVoteValue.js

@@ -0,0 +1,67 @@
+// Logger
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { getBlurtPrice } from "../utils/price.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+/**
+ * Tool: get-vote-value (Blurt — estimated upvote value)
+ *
+ * Purpose
+ *   Estimate how much an account's upvote is worth, at a given voting weight,
+ *   in BLURT and (best-effort) USD.
+ *
+ * Parameters (inputSchema)
+ *   - username (string, required) — voter account
+ *   - weight   (number, 1..100, default 100) — voting weight in percent
+ *
+ * Behavior
+ *   Combines client.tools.getAccountMana, getDynamicGlobalProperties and the
+ *   post reward fund via client.tools.getAccountVoteValue. The estimate assumes
+ *   a fresh vote on an empty post past the reverse-auction window (full value).
+ *
+ * Returns
+ *   JSON: { account, weight_percent, current_mana_percent, vote_value_blurt, vote_value_usd, price_usd }
+ */
+export function registerGetVoteValue(server, client) {
+    registerBlurtTool(server, "get-vote-value", {
+        title: "Estimate a Blurt upvote value",
+        description: "Estimate how much an account's upvote is worth right now, in BLURT and USD. " +
+            "Use this when the user asks 'how much is my (or someone's) vote worth' — useful for curators sizing their impact " +
+            "or authors estimating the support a vote brings. " +
+            "Parameters: username (the voter), weight (voting strength in percent, 1-100, default 100). " +
+            "The estimate assumes a vote on a fresh post past the reverse-auction window, so it reflects the account's current " +
+            "full voting power at that weight. Returns: account, weight_percent, current_mana_percent (remaining voting power, " +
+            "100% = fully charged), vote_value_blurt, vote_value_usd (best-effort, null if the price feed is down) and the " +
+            "price_usd used. Caveat: the value scales with the account's mana, which depletes with each vote and regenerates " +
+            "over ~5 days, so it varies over time — treat it as a current snapshot, not a fixed figure.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            username: z.string().min(3).describe("Voter account (e.g., 'nalexadre')"),
+            weight: z.number().int().min(1).max(100).default(100)
+                .describe("Voting weight in percent (1-100)"),
+        },
+    }, async ({ username, weight }) => {
+        logger.debug(`get-vote-value: ${username} @ ${weight}%`);
+        try {
+            const vote = await client.read.estimateVoteValue(username, weight);
+            const price = await getBlurtPrice().catch((e) => {
+                logger.warn(`get-vote-value: price feed unavailable (${e.message})`);
+                return null;
+            });
+            const summary = {
+                ...vote,
+                vote_value_usd: price ? Number((vote.vote_value_blurt * price.price_usd).toFixed(5)) : null,
+                price_usd: price?.price_usd ?? null,
+            };
+            logger.info(`Vote value for ${username}@${weight}%: ${vote.vote_value_blurt} BLURT`);
+            return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[get-vote-value] Error: ${e.stack}`);
+            return {
+                content: [{ type: "text", text: `Error estimating vote value for ${username}` }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/getWitness.js

@@ -0,0 +1,46 @@
+// Logger
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+/**
+ * Tool: get-witness (Blurt — single witness details + health)
+ */
+export function registerGetWitness(server, client) {
+    registerBlurtTool(server, "get-witness", {
+        title: "Get Blurt witness details",
+        description: "Get details and a health read for a single Blurt witness (block producer) by account name. " +
+            "Use this when the user asks about a specific witness — its support, reliability, node version, " +
+            "or whether it is up to date and producing blocks. Parameter: username. Returns: vote weight " +
+            "(approx BLURT backing), lifetime missed blocks, running node version, last confirmed block and " +
+            "how far behind the chain head it is, whether block production is enabled (a null signing key " +
+            "means disabled), the configured chain properties (fees, block size), and a short health summary. " +
+            "Use list-witnesses to see the ranked set.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            username: z.string().min(3).describe("Witness account name (e.g., 'nalexadre')"),
+        },
+    }, async ({ username }) => {
+        logger.debug(`get-witness: ${username}`);
+        try {
+            const model = await client.read.getWitnessSummary(username);
+            // Simple health read remains MCP-local presentation.
+            const health = [];
+            if (!model.enabled)
+                health.push("block production DISABLED (null signing key)");
+            else if (model.blocks_behind_head > 1200)
+                health.push(`possibly inactive: ${model.blocks_behind_head} blocks behind head`);
+            else
+                health.push("actively confirming blocks");
+            const summary = {
+                ...model,
+                vote_weight_blurt: Math.round(model.vote_weight_blurt),
+                health: health.join("; "),
+            };
+            return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[get-witness] Error: ${e.stack}`);
+            return { content: [{ type: "text", text: `Error retrieving witness ${username}` }], isError: true };
+        }
+    });
+}

package/dist/tools/listCommunities.js

@@ -0,0 +1,90 @@
+// Logger
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+/**
+ * Tool: list-communities (Blurt — Nexus communities directory)
+ *
+ * Purpose
+ *   List Blurt communities, sorted by rank, recency or subscriber count, with
+ *   optional text search and pagination.
+ *
+ * Parameters (inputSchema)
+ *   - sort     (enum, default "rank") — "rank" | "new" | "subs"
+ *   - query    (string | null, optional) — text search on community name/title
+ *   - limit    (number, 1..100, default 20)
+ *   - last     (string | null, optional) — pagination cursor (last community name)
+ *   - observer (string | null, optional) — observer account (subscription context)
+ *
+ * Behavior
+ *   Calls: client.nexus.listCommunities({ last, limit, query, sort, observer })
+ *
+ * Returns
+ *   - Human-readable summary (name, title, subscribers, authors, pending payout)
+ *   - Full JSON of the NexusCommunity[] for deeper analysis
+ */
+export function registerListCommunities(server, client) {
+    registerBlurtTool(server, "list-communities", {
+        title: "List Blurt communities",
+        description: "List Blurt communities — topic-based groups where users publish and moderate posts — via the Nexus L2 API. " +
+            "Use this for community discovery: e.g. 'what are the most popular or active communities', or to find a community " +
+            "by name/topic before calling get-community or filtering posts by it. " +
+            "Parameters: sort ('rank' = curated activity ranking, 'new' = recently created, 'subs' = most subscribers; default 'rank'), " +
+            "query (optional text filter on name/title), limit (1-100, default 20), " +
+            "last (pagination cursor: pass the last community 'name' from the previous page to get the next one), " +
+            "observer (optional account, adds the caller's subscription context). " +
+            "Returns a readable summary (name, title, subscribers, author count, pending posts and payout) plus the full JSON array. " +
+            "Note: a community 'name' looks like 'blurt-192372' and is the id used by get-community and as a post category.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            sort: z.enum(["rank", "new", "subs"]).default("rank")
+                .describe("Sort order: rank, new, or subs (subscriber count)"),
+            query: z.string().nullable().optional()
+                .describe("Optional text search on community name/title"),
+            limit: z.number().int().min(1).max(100).default(20)
+                .describe("Number of communities to return (max 100)"),
+            last: z.string().nullable().optional()
+                .describe("Pagination cursor: last community name from a previous page"),
+            observer: z.string().nullable().optional()
+                .describe("Observer account (affects subscription context)"),
+        },
+    }, async ({ sort, query, limit, last, observer }) => {
+        logger.debug(`list-communities: sort=${sort}, query=${query}, limit=${limit}, last=${last}, observer=${observer}`);
+        try {
+            const communities = await client.nexus.listCommunities({
+                last: last ?? undefined,
+                limit,
+                query: query ?? null,
+                sort,
+                observer: observer ?? null,
+            });
+            if (!communities || communities.length === 0) {
+                logger.warn(`No communities found (sort=${sort}, query=${query})`);
+                return { content: [{ type: "text", text: "No communities found." }] };
+            }
+            const summary = communities
+                .map((c, i) => {
+                return `${i + 1}. ${c.name} — ${c.title}
+    - subscribers: ${c.subscribers}
+    - authors: ${c.num_authors}
+    - pending posts: ${c.num_pending}
+    - pending payout: ${c.sum_pending} BLURT
+    - lang: ${c.lang}${c.is_nsfw ? " (NSFW)" : ""}`;
+            })
+                .join("\n\n");
+            return {
+                content: [
+                    { type: "text", text: `Communities (${sort}, limit=${limit})\n${summary}` },
+                    { type: "text", text: JSON.stringify(communities, null, 2) },
+                ],
+            };
+        }
+        catch (e) {
+            logger.error(`[list-communities] Error: ${e.stack}`);
+            return {
+                content: [{ type: "text", text: "Error retrieving communities." }],
+                isError: true,
+            };
+        }
+    });
+}

package/dist/tools/listWitnesses.js

@@ -0,0 +1,48 @@
+// Logger
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+/**
+ * Tool: list-witnesses (Blurt — top witnesses by vote)
+ */
+export function registerListWitnesses(server, client) {
+    registerBlurtTool(server, "list-witnesses", {
+        title: "List Blurt witnesses",
+        description: "List Blurt witnesses (block producers) ranked by vote weight. Use this for governance " +
+            "questions: 'who are the top witnesses', 'who produces blocks', or to inspect the consensus " +
+            "set. Parameter: limit (1-100, default 20). For each witness returns: rank, owner, approximate " +
+            "vote weight in BLURT (the Blurt Power backing its votes), lifetime missed blocks, running node " +
+            "version, last confirmed block, whether it is actively producing (a disabled witness uses a null " +
+            "signing key), and its URL. Use get-witness for a single-witness deep dive.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            limit: z.number().int().min(1).max(100).default(20)
+                .describe("Number of witnesses to return, ranked by votes (max 100)"),
+        },
+    }, async ({ limit }) => {
+        logger.debug(`list-witnesses: limit=${limit}`);
+        try {
+            const witnesses = await client.read.listWitnessSummaries(limit);
+            if (!witnesses || witnesses.length === 0) {
+                return { content: [{ type: "text", text: "No witnesses found." }] };
+            }
+            const summary = witnesses
+                .map((w) => `${w.rank}. ${w.owner}${w.enabled ? "" : " (DISABLED)"}
+    - vote weight: ${Math.round(w.vote_weight_blurt).toLocaleString("en-US")} BLURT
+    - missed blocks: ${w.missed_blocks_lifetime}
+    - version: ${w.running_version}
+    - last confirmed block: ${w.last_confirmed_block_num}
+    - url: ${w.url}`)
+                .join("\n\n");
+            return {
+                content: [
+                    { type: "text", text: `Top ${witnesses.length} Blurt witnesses by vote\n${summary}` },
+                ],
+            };
+        }
+        catch (e) {
+            logger.error(`[list-witnesses] Error: ${e.stack}`);
+            return { content: [{ type: "text", text: "Error retrieving witnesses." }], isError: true };
+        }
+    });
+}

package/dist/tools/lookupAccounts.js

@@ -0,0 +1,30 @@
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+/** Tool: lookup-accounts (Blurt) — autocomplete account names by prefix. */
+export function registerLookupAccounts(server, client) {
+    registerBlurtTool(server, "lookup-accounts", {
+        title: "Look up Blurt account names by prefix",
+        description: "Find Blurt account names that start with a given prefix (alphabetical autocomplete). Use this when " +
+            "the user gives a partial or uncertain account name, wants to discover accounts by prefix, or to " +
+            "confirm an exact username before another call. Parameters: prefix (the starting characters), limit " +
+            "(1-100, default 20). Returns: the matching account names in alphabetical order. This only matches " +
+            "the start of the name; it is not a full-text search.",
+        annotations: { readOnlyHint: true },
+        inputSchema: {
+            prefix: z.string().min(1).describe("Start of the account name (e.g., 'nale')"),
+            limit: z.number().int().min(1).max(100).default(20).describe("Max names to return"),
+        },
+    }, async ({ prefix, limit }) => {
+        logger.debug(`lookup-accounts: ${prefix}, limit=${limit}`);
+        try {
+            const names = await client.condenser.lookupAccounts(prefix.toLowerCase(), limit);
+            const summary = { prefix, count: names.length, accounts: names };
+            return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[lookup-accounts] Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Error looking up accounts for '${prefix}'` }], isError: true };
+        }
+    });
+}

package/dist/tools/mute.js

@@ -0,0 +1,39 @@
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { mute, withinCap, dryRunDefault } from "../utils/signer.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+const CAP_MAX = 30;
+const CAP_WINDOW_MS = 60 * 60 * 1000;
+/** Tool: blurt-mute (Blurt — WRITE) — mute/unmute an account. */
+export function registerMute(server, client, ctx) {
+    registerBlurtTool(server, "blurt-mute", {
+        title: "Mute or unmute a Blurt account",
+        description: "WRITE operation (custom_json `follow` with 'ignore', signed with the local posting key): mute " +
+            "(ignore) or unmute another Blurt account for the configured account, so its content is hidden in " +
+            "compatible frontends. Use this when the user asks to mute/ignore or unmute someone. Parameters: " +
+            "account, action ('mute' or 'unmute', default 'mute'), dry_run (default follows BLURT_DRY_RUN_DEFAULT; false when unset). Available only on " +
+            "the local stdio server; rate-limited.",
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            account: z.string().min(3).describe("Account to mute/unmute"),
+            action: z.enum(["mute", "unmute"]).default("mute")
+                .describe("'mute' to ignore the account's content, 'unmute' to undo (default 'mute')"),
+            dry_run: z.boolean().default(dryRunDefault()).describe("Preview only, without broadcasting"),
+        },
+    }, async ({ account, action, dry_run }) => {
+        logger.debug(`blurt-mute: ${action} ${account} (dry_run=${dry_run})`);
+        try {
+            if (!dry_run && !withinCap("mute", CAP_MAX, CAP_WINDOW_MS)) {
+                return { content: [{ type: "text", text: `Rate limit reached for mute (max ${CAP_MAX}/hour).` }], isError: true };
+            }
+            const result = await mute(client, ctx, { account, action, dryRun: dry_run });
+            if (result.done)
+                logger.info(`${action} @${account} (tx ${result.tx_id}).`);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[blurt-mute] Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Error trying to ${action} ${account}` }], isError: true };
+        }
+    });
+}

package/dist/tools/post.js

@@ -0,0 +1,42 @@
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { post, withinCap, dryRunDefault } from "../utils/signer.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+const CAP_MAX = 10;
+const CAP_WINDOW_MS = 60 * 60 * 1000;
+/** Tool: blurt-post (Blurt — WRITE) — publish a top-level post. */
+export function registerPost(server, client, ctx) {
+    registerBlurtTool(server, "blurt-post", {
+        title: "Publish a new Blurt post",
+        description: "WRITE operation (signs a top-level `comment` with the local posting key): publish a new blog post " +
+            "as the configured account. Use this when the user asks to publish / create a post (not a reply — " +
+            "for replies use blurt-comment). Parameters: title, body (markdown), tags (1-8 lowercase tags; the " +
+            "first is the post's main category), dry_run (default follows BLURT_DRY_RUN_DEFAULT; false when unset — when true, previews the exact post " +
+            "WITHOUT broadcasting). A unique permlink is generated from the title, 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: {
+            title: z.string().min(1).max(255).describe("Post title"),
+            body: z.string().min(1).describe("Post body (markdown)"),
+            tags: z.array(z.string().min(1)).min(1).max(8)
+                .describe("1-8 tags; the first is the main category (e.g., ['blurt','intro'])"),
+            dry_run: z.boolean().default(dryRunDefault()).describe("Preview the final post only, without broadcasting"),
+        },
+    }, async ({ title, body, tags, dry_run }) => {
+        logger.debug(`blurt-post: "${title}" tags=${tags.join(",")} (dry_run=${dry_run})`);
+        try {
+            if (!dry_run && !withinCap("post", CAP_MAX, CAP_WINDOW_MS)) {
+                return { content: [{ type: "text", text: `Rate limit reached for post (max ${CAP_MAX}/hour).` }], isError: true };
+            }
+            const result = await post(client, ctx, { title, body, tags, dryRun: dry_run });
+            if (result.posted)
+                logger.info(`Published @${result.author}/${result.permlink} (tx ${result.tx_id}).`);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[blurt-post] Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Error publishing post "${title}"` }], isError: true };
+        }
+    });
+}

package/dist/tools/readNotifications.js

@@ -0,0 +1,35 @@
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { readNotifications, withinCap, dryRunDefault } from "../utils/signer.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+const CAP_MAX = 30;
+const CAP_WINDOW_MS = 60 * 60 * 1000;
+/** Tool: blurt-read-notifications (Blurt — WRITE) — mark notifications as read. */
+export function registerReadNotifications(server, client, ctx) {
+    registerBlurtTool(server, "blurt-read-notifications", {
+        title: "Mark Blurt notifications as read",
+        description: "WRITE operation (custom_json `notify` setLastRead, signed with the local posting key): mark the " +
+            "configured account's notifications as read up to now. Use this when the user asks to clear / mark " +
+            "their notifications as read. Pair with get-account-notifications to read them first. Parameter: " +
+            "dry_run (default follows BLURT_DRY_RUN_DEFAULT; false when unset). Available only on the local stdio server; rate-limited.",
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            dry_run: z.boolean().default(dryRunDefault()).describe("Preview only, without broadcasting"),
+        },
+    }, async ({ dry_run }) => {
+        logger.debug(`blurt-read-notifications (dry_run=${dry_run})`);
+        try {
+            if (!dry_run && !withinCap("read-notifications", CAP_MAX, CAP_WINDOW_MS)) {
+                return { content: [{ type: "text", text: `Rate limit reached for read-notifications (max ${CAP_MAX}/hour).` }], isError: true };
+            }
+            const result = await readNotifications(client, ctx, { dryRun: dry_run });
+            if (result.done)
+                logger.info(`Marked notifications read for @${result.account} (tx ${result.tx_id}).`);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[blurt-read-notifications] Error: ${e.message}`);
+            return { content: [{ type: "text", text: "Error marking notifications as read." }], isError: true };
+        }
+    });
+}

package/dist/tools/reblog.js

@@ -0,0 +1,39 @@
+import logger from "../utils/logger.js";
+import { z } from "zod";
+import { reblog, withinCap, dryRunDefault } from "../utils/signer.js";
+import { registerBlurtTool } from "../contracts/registerBlurtTool.js";
+const CAP_MAX = 30;
+const CAP_WINDOW_MS = 60 * 60 * 1000;
+/** Tool: blurt-reblog (Blurt — WRITE) — reblog (re-share) a post. */
+export function registerReblog(server, client, ctx) {
+    registerBlurtTool(server, "blurt-reblog", {
+        title: "Reblog (re-share) a Blurt post",
+        description: "WRITE operation (custom_json `reblog`, signed with the local posting key): reblog (re-share) a Blurt " +
+            "post to the configured account's blog, so its followers see it. Use this when the user asks to " +
+            "reblog/re-share a post. Identify the post by author + permlink. Parameters: author, permlink, undo " +
+            "(default false — set true to remove a previous reblog), dry_run (default follows BLURT_DRY_RUN_DEFAULT; false when unset). Available only on " +
+            "the local stdio server; rate-limited.",
+        annotations: { readOnlyHint: false, destructiveHint: false },
+        inputSchema: {
+            author: z.string().min(1).describe("Author of the post to reblog"),
+            permlink: z.string().min(1).describe("Permlink of the post to reblog"),
+            undo: z.boolean().default(false).describe("Remove a previous reblog instead of adding one"),
+            dry_run: z.boolean().default(dryRunDefault()).describe("Preview only, without broadcasting"),
+        },
+    }, async ({ author, permlink, undo, dry_run }) => {
+        logger.debug(`blurt-reblog: ${author}/${permlink} undo=${undo} (dry_run=${dry_run})`);
+        try {
+            if (!dry_run && !withinCap("reblog", CAP_MAX, CAP_WINDOW_MS)) {
+                return { content: [{ type: "text", text: `Rate limit reached for reblog (max ${CAP_MAX}/hour).` }], isError: true };
+            }
+            const result = await reblog(client, ctx, { author, permlink, undo, dryRun: dry_run });
+            if (result.done)
+                logger.info(`Reblog ${author}/${permlink} undo=${undo} (tx ${result.tx_id}).`);
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            logger.error(`[blurt-reblog] Error: ${e.message}`);
+            return { content: [{ type: "text", text: `Error reblogging ${author}/${permlink}` }], isError: true };
+        }
+    });
+}