neuron-mcp-server 1.0.0 → 1.1.0

package/src/tools/pool.ts

@@ -0,0 +1,293 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, textResult, errorResult } from "../client.js";
+
+export function registerPoolTools(server: McpServer): void {
+  // 1. Browse pool
+  server.registerTool(
+    "neuron_browse_pool",
+    {
+      title: "Browse Pool",
+      description: "Browse the shared marketplace pool of published bots, tools, knowledge bases, and reflections with optional filtering by type, category, tags, or search query.",
+      inputSchema: z.object({
+        query: z.string().optional().describe("Free-text search query to filter pool items by name or description"),
+        type: z.enum(["knowledge_base", "bot_template", "tool_template", "reflection_pack"]).optional().describe("Filter by resource type"),
+        category: z.string().optional().describe("Filter by category name"),
+        tags: z.string().optional().describe("Filter by tags (comma-separated list, e.g., 'ai,chatbot')"),
+        featured: z.boolean().optional().describe("When true, return only featured items"),
+        page: z.number().optional().describe("Page number for pagination (default: 1)"),
+        limit: z.number().optional().describe("Number of items per page (default: 20)"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const queryParams: Record<string, string | number> = {};
+        if (args.query) queryParams.query = args.query;
+        if (args.type) queryParams.type = args.type;
+        if (args.category) queryParams.category = args.category;
+        if (args.tags) queryParams.tags = args.tags;
+        if (args.featured !== undefined) queryParams.featured = args.featured ? "true" : "false";
+        if (args.page !== undefined) queryParams.page = args.page;
+        if (args.limit !== undefined) queryParams.limit = args.limit;
+        const response = await api("GET", "/pool", undefined, queryParams);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 2. Get pool item
+  server.registerTool(
+    "neuron_get_pool_item",
+    {
+      title: "Get Pool Item",
+      description: "Retrieve detailed information about a specific item in the marketplace pool, including its description, category, tags, and install count.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the pool item to retrieve"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const response = await api("GET", `/pool/${args.id}`);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 3. List published items
+  server.registerTool(
+    "neuron_list_published",
+    {
+      title: "List My Published Items",
+      description: "List all items the current organization has published to the marketplace pool.",
+      inputSchema: z.object({}),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async () => {
+      try {
+        const response = await api("GET", "/pool/my");
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 4. List installed items
+  server.registerTool(
+    "neuron_list_installed",
+    {
+      title: "List Installed Items",
+      description: "List all items the current organization has installed from the marketplace pool.",
+      inputSchema: z.object({}),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async () => {
+      try {
+        const response = await api("GET", "/pool/installed");
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 5. Publish to pool
+  server.registerTool(
+    "neuron_publish_to_pool",
+    {
+      title: "Publish to Pool",
+      description: "Publish a bot, tool, knowledge base, or reflection to the shared marketplace pool for other organizations to discover and install.",
+      inputSchema: z.object({
+        type: z.enum(["knowledge_base", "bot_template", "tool_template", "reflection_pack"]).describe("Type of resource to publish to the pool"),
+        sourceId: z.string().describe("Unique identifier (UUID) of the source resource to publish"),
+        name: z.string().describe("Display name for the pool listing"),
+        description: z.string().optional().describe("Detailed description of the resource for the pool listing"),
+        category: z.string().optional().describe("Category name for organizing the resource in the pool"),
+        tags: z.array(z.string()).optional().describe("List of tags for improved discoverability (e.g., ['ai', 'customer-support'])"),
+        setupInstructions: z.string().optional().describe("Step-by-step setup guide shown after installation (tool_template only, max 5000 chars)"),
+        defaultSecrets: z.record(z.string()).optional().describe("Pre-filled secrets auto-populated on install, e.g. { OAUTH2_TOKEN_URL: 'https://...' }"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const response = await api("POST", "/pool", args);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 6. Update pool item
+  server.registerTool(
+    "neuron_update_pool_item",
+    {
+      title: "Update Pool Item",
+      description: "Update a pool item you have published — metadata (name, description, category, tags) and content fields (setupInstructions, defaultSecrets for tool_template items). The underlying resource is re-snapshotted and version is bumped on every update.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the pool item to update"),
+        name: z.string().optional().describe("New display name for the pool listing"),
+        description: z.string().optional().describe("New detailed description for the pool listing"),
+        category: z.string().optional().describe("New category name for the pool listing"),
+        tags: z.array(z.string()).optional().describe("New list of tags for the pool listing"),
+        setupInstructions: z.string().optional().describe("Updated setup guide shown after installation (tool_template only, max 5000 chars)"),
+        defaultSecrets: z.record(z.string()).optional().describe("Updated pre-filled secrets auto-populated on install, e.g. { OAUTH2_TOKEN_URL: 'https://...' }"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const { id, ...updateData } = args;
+        const response = await api("PUT", `/pool/${id}`, updateData);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 7. Unpublish from pool
+  server.registerTool(
+    "neuron_unpublish_from_pool",
+    {
+      title: "Unpublish from Pool",
+      description: "Permanently remove a published item from the marketplace pool. Organizations that installed this item will retain their copies.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the pool item to unpublish"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const response = await api("DELETE", `/pool/${args.id}`);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 8. Install from pool
+  server.registerTool(
+    "neuron_install_from_pool",
+    {
+      title: "Install from Pool",
+      description: "Install a resource from the marketplace pool into the current organization. Choose 'fork' for an independent copy or 'subscribe' to receive future updates from the publisher.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the pool item to install"),
+        mode: z.enum(["fork", "subscribe"]).describe("Installation mode: 'fork' creates an independent copy, 'subscribe' links to publisher updates"),
+        targetBotId: z.string().optional().describe("UUID of the bot to attach the installed resource to (for tool_template or knowledge_base types)"),
+        targetKbId: z.string().optional().describe("UUID of the knowledge base to install into (for knowledge_base types)"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const { id, ...body } = args;
+        const response = await api("POST", `/pool/${id}/install`, body);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 9. Pull pool update
+  server.registerTool(
+    "neuron_pull_pool_update",
+    {
+      title: "Pull Pool Update",
+      description: "Pull the latest updates for a subscribed pool resource to sync with the publisher's changes. Only applies to items installed with 'subscribe' mode.",
+      inputSchema: z.object({
+        installId: z.string().describe("Unique identifier (UUID) of the installed resource to pull updates for"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const response = await api("POST", `/pool/installed/${args.installId}/pull`);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // 10. Toggle featured status
+  server.registerTool(
+    "neuron_toggle_featured",
+    {
+      title: "Toggle Featured Status",
+      description: "Toggle the featured status of a pool item. Featured items appear prominently in the marketplace. Requires admin privileges.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the pool item to feature or unfeature"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      try {
+        const response = await api("POST", `/pool/${args.id}/feature`);
+        return jsonResult(response);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}

package/src/tools/products.ts

@@ -0,0 +1,280 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+const PRICE_NOTE = "Amount in kobo (minor units): ₦1 = 100. Minimum ₦500 = 50000.";
+
+const deliveryEnum = z.enum(["file", "link", "code"]);
+const feePayerEnum = z.enum(["buyer", "seller"]);
+
+const productFields = {
+  title: z.string().describe("Product title shown to buyers"),
+  description: z.string().optional().describe("Rich description / what the buyer gets"),
+  priceMinor: z.number().int().describe(`Current price (charged). ${PRICE_NOTE} Set 0 for a free product (no payment).`),
+  originalPriceMinor: z.number().int().nullable().optional().describe("Optional compare-at / 'was' price (kobo), shown struck through. Must be ≥ current price."),
+  currency: z.string().optional().describe("ISO currency (default NGN)"),
+  channelId: z.string().uuid().nullable().optional().describe("WhatsApp session UUID used to deliver the product (defaults to the org default channel)"),
+  deliveryType: deliveryEnum.describe("How the product is delivered: 'file' (uploaded file), 'link' (URL), or 'code' (text/code)"),
+  deliveryFileUrl: z.string().url().nullable().optional().describe("For deliveryType 'file': the uploaded file URL (upload first with neuron_upload_media)"),
+  deliveryFileName: z.string().nullable().optional().describe("Filename shown in the WhatsApp document"),
+  deliveryText: z.string().nullable().optional().describe("For 'link'/'code': the link or code the buyer receives. Optional note for 'file'."),
+  coverImageUrl: z.string().url().nullable().optional().describe("Cover image URL"),
+  coverEmoji: z.string().nullable().optional().describe("Emoji used as a cover fallback (e.g. 📓)"),
+  coverType: z.enum(["none", "emoji", "image", "color", "gradient"]).optional().describe("How the cover renders"),
+  coverColor: z.string().nullable().optional().describe("Cover colour (hex) for 'color'/'gradient' cover types"),
+  coverColor2: z.string().nullable().optional().describe("Second colour (hex) for 'gradient' cover"),
+  content: z.array(z.any()).optional().describe("Rich product-page content blocks. Ordered array of {type, ...}: heading {text,level}, text {markdown}, image {url,caption}, video {url}, callout {emoji,text}, collapsible {title,blocks[]}, divider {}, button {label,url}, embed {url}, spacer {}"),
+  theme: z.record(z.string()).optional().describe("Per-product theme: { bg, accent, text (hex), mode: 'light'|'dark', layout: 'hero'|'side', coverAspect: '16/10'|'3/2'|'1/1'|'4/5', cta: buy-button label e.g. 'Reserve your hour' }"),
+  checkoutFields: z.array(z.object({ key: z.string(), label: z.string(), type: z.enum(["text", "textarea", "number", "email", "phone", "select"]), required: z.boolean().optional(), placeholder: z.string().optional(), options: z.array(z.string()).optional() })).optional().describe("Custom checkout questions the buyer answers (name, address, specs/customisations…). Their answers are attached to the order and sent to the seller."),
+  kind: z.string().nullable().optional().describe("Short label e.g. 'E-book', 'Presets', 'Service'"),
+  category: z.string().nullable().optional().describe("Category label e.g. 'Productivity'"),
+  codeMode: z.enum(["shared", "pool", "generated"]).optional().describe("For deliveryType 'code': 'shared' (same text to every buyer), 'pool' (a unique code per sale from codes you upload — sells out when empty), or 'generated' (auto-mint a unique license key per sale)"),
+  codes: z.array(z.string()).optional().describe("For codeMode 'pool': the unique codes/keys to add (one gets sent per buyer). Appended to any existing pool."),
+  feePayer: feePayerEnum.optional().describe("'buyer' (fee added on top, seller gets full price — default) or 'seller' (fee deducted)"),
+  enabled: z.boolean().optional().describe("Whether the product is live"),
+  membership: z.boolean().optional().describe("Make this a recurring subscription/membership: it tracks a paid period per buyer, renews from their Neuron wallet when possible (else emails a reminder — no card auto-charge), and marks them lapsed when the period + grace passes. React to membership.started/renewed/lapsed in Flows to deliver whatever the membership grants."),
+  membershipInterval: z.enum(["daily", "weekly", "monthly"]).nullable().optional().describe("Billing period. Required when membership is true."),
+  membershipGraceDays: z.number().int().min(0).optional().describe("Days after the period ends before an unpaid member lapses (and, if a group is attached, is removed from it). Default 1."),
+  membershipGroupSlug: z.string().nullable().optional().describe("OPTIONAL: attach a WhatsApp group as a membership perk. Org-unique handle (lowercase letters, numbers, hyphens); the group is created on the first sale, buyers are added on renewal and removed on lapse. Your connected number must be a group admin. Omit for a membership that isn't group-based."),
+  membershipGroupName: z.string().nullable().optional().describe("Group subject used when the attached group is auto-created (defaults to the product title). Only relevant with membershipGroupSlug."),
+};
+
+export function registerProductsTools(server: McpServer): void {
+  const ro = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+  const write = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+
+  server.registerTool(
+    "neuron_seller_status",
+    {
+      title: "Seller Status",
+      description: "Check whether this account can sell (Pro plan + admin-granted access) and any pending application.",
+      inputSchema: z.object({}),
+      annotations: ro,
+    },
+    async () => {
+      try { return jsonResult(await api("GET", "/sell/status")); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_apply_to_sell",
+    {
+      title: "Apply to Sell",
+      description: "Apply for seller access (digital products). Requires a Pro plan or higher; a platform admin then grants access.",
+      inputSchema: z.object({ pitch: z.string().optional().describe("Short note on what you plan to sell") }),
+      annotations: write,
+    },
+    async (p) => {
+      try { return jsonResult(await api("POST", "/sell/apply", p)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_get_storefront",
+    {
+      title: "Get Storefront",
+      description: "Get this seller's storefront profile (handle, display name, bio, branding) and its public URL.",
+      inputSchema: z.object({}),
+      annotations: ro,
+    },
+    async () => {
+      try { return jsonResult(await api("GET", "/sell/store")); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_update_storefront",
+    {
+      title: "Update Storefront",
+      description: "Create or update the seller storefront (nestuge-style page). Handle is auto-generated from the display name if omitted.",
+      inputSchema: z.object({
+        handle: z.string().optional().describe("URL handle (a-z, 0-9, hyphens). Becomes /s/<handle>."),
+        displayName: z.string().optional().describe("Store display name"),
+        bio: z.string().nullable().optional().describe("Short store bio"),
+        avatarUrl: z.string().url().nullable().optional(),
+        brandColor: z.string().nullable().optional().describe("Hex brand colour e.g. #188A56"),
+        socials: z.record(z.string()).optional().describe("Map of social links e.g. { instagram: 'https://...' }"),
+        enabled: z.boolean().optional().describe("Whether the storefront is public"),
+      }),
+      annotations: write,
+    },
+    async (p) => {
+      try { return jsonResult(await api("PUT", "/sell/store", p)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_list_products",
+    {
+      title: "List Products",
+      description: "List all products for this seller, each with its public checkout URL and price breakdown.",
+      inputSchema: z.object({}),
+      annotations: ro,
+    },
+    async () => {
+      try { return jsonResult(await api("GET", "/sell/products")); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_get_product",
+    {
+      title: "Get Product",
+      description: "Get a single product by id, with its public URL and fee breakdown.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Product UUID") }),
+      annotations: ro,
+    },
+    async (p) => {
+      try { return jsonResult(await api("GET", `/sell/products/${p.id}`)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_create_product",
+    {
+      title: "Create Product",
+      description: `Create a digital product/service with a public checkout link. ${PRICE_NOTE} For 'file' delivery, upload the file first (neuron_upload_media) and pass its URL as deliveryFileUrl. On payment, Neuron confirms it and delivers the product to the buyer's WhatsApp automatically.`,
+      inputSchema: z.object(productFields),
+      annotations: write,
+    },
+    async (p) => {
+      try { return jsonResult(await api("POST", "/sell/products", p)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_update_product",
+    {
+      title: "Update Product",
+      description: "Update any field of a product (price, delivery, cover, enabled, fee payer, …).",
+      inputSchema: z.object({ id: z.string().uuid().describe("Product UUID"), ...Object.fromEntries(Object.entries(productFields).map(([k, v]) => [k, (v as z.ZodTypeAny).optional()])) }),
+      annotations: write,
+    },
+    async (p) => {
+      try { const { id, ...body } = p as { id: string } & Record<string, unknown>; return jsonResult(await api("PUT", `/sell/products/${id}`, body)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_product_members",
+    {
+      title: "Product Members",
+      description: "List the members of a membership product: current (paid-up) or all. Returns each buyer's status (active / lapsed / cancelled), when their period renews, whether they're in the attached WhatsApp group (if one is attached), plus totals.",
+      inputSchema: z.object({
+        id: z.string().uuid().describe("Product UUID (must be a membership product)"),
+        status: z.enum(["active", "all"]).optional().describe("'active' (current members, default) or 'all' (every member ever)"),
+      }),
+      annotations: ro,
+    },
+    async (p) => {
+      try { return jsonResult(await api("GET", `/sell/products/${p.id}/members`, undefined, { status: p.status ?? "active" })); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_add_product_codes",
+    {
+      title: "Add Product Codes",
+      description: "Add more unique codes/keys to a 'pool' code product's stock. Each buyer receives one. Returns the product with the new remaining count.",
+      inputSchema: z.object({
+        id: z.string().uuid().describe("Product UUID"),
+        codes: z.array(z.string()).min(1).describe("Unique codes/keys to append to the pool"),
+      }),
+      annotations: write,
+    },
+    async (p) => {
+      try { return jsonResult(await api("PUT", `/sell/products/${p.id}`, { codes: p.codes })); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_duplicate_product",
+    {
+      title: "Duplicate Product",
+      description: "Clone an existing product into a hidden draft copy (new checkout link, '(copy)' title, reset counters). A 'pool' code product is cloned with an empty pool — restock codes before enabling. Edit the copy with neuron_update_product, then set enabled: true to publish.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Product UUID to clone") }),
+      annotations: write,
+    },
+    async (p) => {
+      try { return jsonResult(await api("POST", `/sell/products/${p.id}/duplicate`, {})); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_delete_product",
+    {
+      title: "Delete Product",
+      description: "Permanently delete a product. Existing orders are retained.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Product UUID") }),
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    },
+    async (p) => {
+      try { return jsonResult(await api("DELETE", `/sell/products/${p.id}`)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_list_orders",
+    {
+      title: "List Orders",
+      description: "List recent product orders (sales) for this seller, with buyer, amount, fee breakdown, and status.",
+      inputSchema: z.object({}),
+      annotations: ro,
+    },
+    async () => {
+      try { return jsonResult(await api("GET", "/sell/orders")); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_refund_order",
+    {
+      title: "Refund Order",
+      description: "Refund a paid order via Paystack. The buyer is refunded and the sale amount is reversed from your wallet.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Order UUID") }),
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    },
+    async (p) => {
+      try { return jsonResult(await api("POST", `/sell/orders/${p.id}/refund`)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_deliver_order",
+    {
+      title: "Deliver Order",
+      description: "Re-send a paid-but-undelivered order to the buyer over WhatsApp/email. Use when a sale settled while no WhatsApp session was connected; connect one first, then deliver.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Order UUID") }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (p) => {
+      try { return jsonResult(await api("POST", `/sell/orders/${p.id}/deliver`)); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_list_reviews",
+    {
+      title: "List Reviews",
+      description: "List verified-purchase reviews across this seller's products (rating, text, buyer, status).",
+      inputSchema: z.object({}),
+      annotations: ro,
+    },
+    async () => {
+      try { return jsonResult(await api("GET", "/sell/reviews")); } catch (e) { return errorResult(e); }
+    },
+  );
+
+  server.registerTool(
+    "neuron_sales_stats",
+    {
+      title: "Sales Stats",
+      description: "Total paid sales count and net revenue (kobo) for this seller.",
+      inputSchema: z.object({}),
+      annotations: ro,
+    },
+    async () => {
+      try { return jsonResult(await api("GET", "/sell/stats")); } catch (e) { return errorResult(e); }
+    },
+  );
+}