neuron-mcp-server 1.0.0 → 1.1.0

package/src/tools/list-campaigns.ts

@@ -0,0 +1,190 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+const messageSource = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("static"), text: z.string().min(1).describe("The message body sent to each contact in the batch") }),
+  z.object({ kind: z.literal("rotation"), messages: z.array(z.string().min(1)).min(1).describe("Pool of messages"), mode: z.enum(["sequential", "random"]).optional().describe("Rotate in order (default) or pick randomly per run") }),
+  z.object({ kind: z.literal("content"), ref: z.string().min(1).describe("A Neuron Note ID; its content becomes the message, fetched live at each run") }),
+  z.object({ kind: z.literal("ai"), prompt: z.string().min(1).describe("Instruction for the message the AI should write"), botId: z.string().uuid().optional().describe("Bot whose system prompt supplies business context"), personaId: z.string().uuid().optional().describe("Persona whose voice the message is written in"), perContact: z.boolean().optional().describe("Generate a distinct message per recipient (slower, more tokens). Default false = one message for the whole batch") }).describe("AI-written message generated live at each run (BYOK-aware)"),
+  z.object({ kind: z.literal("webhook"), url: z.string().url().describe("POSTed { campaignId, listId, contact? }; returns { message } or a bare string"), perContact: z.boolean().optional().describe("Call once per recipient with the contact in the payload. Default false = one call per batch") }).describe("Message fetched from your webhook at each run"),
+]).describe("How the message is resolved live at each batch run: 'static' (fixed), 'rotation' (cycle through several), 'ai' (AI-written), 'webhook' (from your service), or 'content' (a saved Neuron Note).");
+
+const schedule = z.intersection(
+  z.discriminatedUnion("kind", [
+    z.object({ kind: z.literal("interval"), everyMs: z.number().int().min(60_000).describe("Milliseconds between runs, e.g. 86400000 for daily") }),
+    z.object({ kind: z.literal("daily"), hour: z.number().int().min(0).max(23).describe("UTC hour"), minute: z.number().int().min(0).max(59).optional() }),
+    z.object({ kind: z.literal("weekly"), days: z.array(z.number().int().min(0).max(6)).min(1).describe("Days of week, 0=Sun … 6=Sat"), hour: z.number().int().min(0).max(23).describe("UTC hour"), minute: z.number().int().min(0).max(59).optional() }),
+    z.object({ kind: z.literal("monthly"), dayOfMonth: z.number().int().min(1).max(31), hour: z.number().int().min(0).max(23).describe("UTC hour"), minute: z.number().int().min(0).max(59).optional() }),
+  ]),
+  z.object({
+    timezone: z.string().optional().describe("IANA timezone the daily/weekly/monthly time is interpreted in, e.g. 'Africa/Lagos'. Defaults to UTC. Ignored for 'interval'. The schedule holds its local wall-clock time across DST."),
+    endAt: z.string().optional().describe("ISO date; the campaign completes after this"),
+    maxRuns: z.number().int().min(1).optional().describe("Stop after this many runs"),
+  }),
+).describe("When each batch fires. e.g. daily at 9am in Africa/Lagos, or every weekend.");
+
+export function registerListCampaignTools(server: McpServer): void {
+  server.registerTool(
+    "neuron_create_list_campaign",
+    {
+      title: "Create List Campaign",
+      description:
+        "Create a paced campaign that messages the next N un-reached members of a contact list on a schedule. The cursor follows the LIVE list — as members are added or removed, only current members get reached, and nobody is messaged twice per cycle. Multiple campaigns can run on the same or different lists concurrently. On exhaust, either stop or loop (start over after a cooldown).",
+      inputSchema: z.object({
+        listId: z.string().uuid().describe("The contact list to run the campaign over"),
+        name: z.string().max(255).optional().describe("Campaign name (default: 'Campaign')"),
+        sendMode: z.enum(["message", "bot"]).optional().describe("'message' sends a plain broadcast; 'bot' initiates the conversation through a bot (default: 'message')"),
+        botId: z.string().uuid().nullable().optional().describe("Bot to send through when sendMode='bot'; its channel is used"),
+        channelId: z.string().uuid().nullable().optional().describe("WhatsApp channel to send from; falls back to the org default / first connected channel"),
+        messageSource: messageSource,
+        batchSize: z.number().int().min(1).max(1000).optional().describe("How many contacts to message per run (default: 20)"),
+        schedule: schedule,
+        onExhaust: z.enum(["stop", "loop"]).optional().describe("When the whole list has been reached: 'stop' (default) completes the campaign; 'loop' starts a new cycle after loopCooldownMs"),
+        loopCooldownMs: z.number().int().min(0).nullable().optional().describe("Milliseconds to wait before looping (default: 24h)"),
+        startImmediately: z.boolean().optional().describe("Fire the first batch right away (default: true). Set false to wait for the first scheduled slot"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("POST", "/list-campaigns", params));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_list_list_campaigns",
+    {
+      title: "List List Campaigns",
+      description: "List all paced list campaigns for the organization, optionally filtered to a single contact list.",
+      inputSchema: z.object({
+        listId: z.string().uuid().optional().describe("Filter to campaigns on this contact list"),
+      }),
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("GET", "/list-campaigns", undefined, { listId: params.listId }));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_get_list_campaign",
+    {
+      title: "Get List Campaign",
+      description: "Get a paced list campaign with live progress: how many members have been reached this cycle, the current list size, and how many remain.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Campaign ID") }),
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("GET", `/list-campaigns/${params.id}`));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_update_list_campaign",
+    {
+      title: "Update List Campaign",
+      description: "Update a paced list campaign's name, message source, batch size, schedule, exhaust behavior, or send settings. Changing the schedule reschedules the next run.",
+      inputSchema: z.object({
+        id: z.string().uuid().describe("Campaign ID"),
+        name: z.string().max(255).optional(),
+        sendMode: z.enum(["message", "bot"]).optional(),
+        botId: z.string().uuid().nullable().optional(),
+        channelId: z.string().uuid().nullable().optional(),
+        messageSource: messageSource.optional(),
+        batchSize: z.number().int().min(1).max(1000).optional(),
+        schedule: schedule.optional(),
+        onExhaust: z.enum(["stop", "loop"]).optional(),
+        loopCooldownMs: z.number().int().min(0).nullable().optional(),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        const { id, ...body } = params;
+        return jsonResult(await api("PUT", `/list-campaigns/${id}`, body));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_pause_list_campaign",
+    {
+      title: "Pause List Campaign",
+      description: "Pause a paced list campaign. No further batches run until resumed. The cursor is preserved.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Campaign ID") }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("POST", `/list-campaigns/${params.id}/pause`));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_resume_list_campaign",
+    {
+      title: "Resume List Campaign",
+      description: "Resume a paused paced list campaign. It picks up from where the cursor left off.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Campaign ID") }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("POST", `/list-campaigns/${params.id}/resume`));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_run_list_campaign_now",
+    {
+      title: "Run List Campaign Now",
+      description: "Fire the next batch of a paced list campaign immediately (on the next worker tick, ~30s), regardless of its schedule. The schedule continues normally afterward.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Campaign ID") }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("POST", `/list-campaigns/${params.id}/run-now`));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  server.registerTool(
+    "neuron_delete_list_campaign",
+    {
+      title: "Delete List Campaign",
+      description: "Permanently delete a paced list campaign and its reached-set. Does not delete the contacts or the list.",
+      inputSchema: z.object({ id: z.string().uuid().describe("Campaign ID") }),
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    },
+    async (params) => {
+      try {
+        return jsonResult(await api("DELETE", `/list-campaigns/${params.id}`));
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+}

package/src/tools/list-pool.ts

@@ -0,0 +1,389 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+export function registerListPoolTools(server: McpServer): void {
+  // Browse pool
+  server.registerTool(
+    "neuron_browse_list_pool",
+    {
+      title: "Browse List Pool",
+      description: "Browse verified contact lists available in the shared marketplace pool. Filter by category, region, or search term.",
+      inputSchema: z.object({
+        category: z.string().optional().describe("Filter by audience category (e.g., 'delivery', 'tech', 'consumers')"),
+        region: z.string().optional().describe("Filter by geographic region (e.g., 'lagos', 'abuja')"),
+        search: z.string().optional().describe("Search term to filter by description or category"),
+        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 (params) => {
+      try {
+        const result = await api("GET", "/list-pool", undefined, {
+          category: params.category,
+          region: params.region,
+          search: params.search,
+          page: params.page,
+          limit: params.limit,
+        });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Submit to pool
+  server.registerTool(
+    "neuron_submit_to_list_pool",
+    {
+      title: "Submit List to Pool",
+      description: "Submit a contact list to the shared pool marketplace for other organizations to discover and use for ad distribution.",
+      inputSchema: z.object({
+        listId: z.string().describe("Unique identifier (UUID) of the contact list to submit"),
+        channelId: z.string().describe("Unique identifier (UUID) of the WhatsApp channel used for sending messages"),
+        category: z.string().describe("Audience category (e.g., 'delivery', 'tech', 'consumers', 'food')"),
+        description: z.string().optional().describe("Human-readable description of the audience and its characteristics"),
+        demographics: z.object({
+          regions: z.array(z.string()).optional().describe("Geographic regions covered (e.g., ['lagos', 'abuja'])"),
+          tags: z.array(z.string()).optional().describe("Demographic tags describing the audience (e.g., ['young-adults', 'tech-savvy'])"),
+        }).optional().describe("Demographic information about the contact list audience"),
+        pricePerDelivery: z.number().describe("Price per successful message delivery in kobo (e.g., 5000 = NGN 50)"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", "/list-pool", params);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Create ad request
+  server.registerTool(
+    "neuron_create_ad_request",
+    {
+      title: "Create Ad Request",
+      description: "Create an ad distribution request to send a message to contacts in pool lists matching target demographics. Deducts from wallet upon approval.",
+      inputSchema: z.object({
+        message: z.string().describe("The ad message content to distribute to matched contacts"),
+        messageType: z.string().optional().describe("Message content type: 'text', 'image', 'video', or 'document' (default: 'text')"),
+        mediaUrl: z.string().optional().describe("Media URL for non-text messages (required when messageType is 'image', 'video', or 'document')"),
+        targetDemographics: z.object({
+          categories: z.array(z.string()).optional().describe("Target audience categories to match (e.g., ['delivery', 'tech'])"),
+          regions: z.array(z.string()).optional().describe("Target geographic regions to match (e.g., ['lagos', 'abuja'])"),
+        }).describe("Demographic criteria to match against pool list entries"),
+        targetGoal: z.number().describe("Target number of successful message deliveries"),
+        budget: z.number().describe("Total ad budget in kobo (e.g., 500000 = NGN 5,000)"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", "/ad-requests", params);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // List ad requests
+  server.registerTool(
+    "neuron_list_ad_requests",
+    {
+      title: "List Ad Requests",
+      description: "Retrieve all ad requests for the current organization with optional status filtering and pagination.",
+      inputSchema: z.object({
+        status: z.string().optional().describe("Filter by request status: 'draft', 'pending_review', 'approved', 'active', 'paused', 'completed', or 'rejected'"),
+        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 (params) => {
+      try {
+        const result = await api("GET", "/ad-requests", undefined, {
+          status: params.status,
+          page: params.page,
+          limit: params.limit,
+        });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Get ad request analytics
+  server.registerTool(
+    "neuron_get_ad_request_analytics",
+    {
+      title: "Get Ad Request Analytics",
+      description: "Retrieve delivery analytics and performance breakdown for a specific ad request, including delivery rates and cost metrics.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the ad request to get analytics for"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `/ad-requests/${params.adRequestId}/analytics`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Get ad request by ID
+  server.registerTool(
+    "neuron_get_ad_request",
+    {
+      title: "Get Ad Request",
+      description: "Get detailed information about a specific ad request, including pool selections if targeting mode is manual.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the ad request"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `/ad-requests/${params.adRequestId}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Update ad request
+  server.registerTool(
+    "neuron_update_ad_request",
+    {
+      title: "Update Ad Request",
+      description: "Update a draft or rejected ad request. Only draft and rejected ad requests can be edited. Rejected requests revert to draft on update.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the ad request to update"),
+        message: z.string().optional().describe("Updated ad message content"),
+        messageType: z.string().optional().describe("Updated message type: 'text', 'image', 'video', or 'document'"),
+        mediaUrl: z.string().optional().describe("Updated media URL (set to null to clear)"),
+        targetDemographics: z.object({
+          categories: z.array(z.string()).optional().describe("Updated target categories"),
+          regions: z.array(z.string()).optional().describe("Updated target regions"),
+        }).optional().describe("Updated demographic targeting criteria"),
+        targetingMode: z.enum(["auto", "manual"]).optional().describe("Targeting mode: 'auto' for system matching or 'manual' for hand-picked pool entries"),
+        targetType: z.enum(["contacts", "groups"]).optional().describe("Target type: 'contacts' or 'groups'"),
+        selectedPoolEntryIds: z.array(z.string()).optional().describe("Pool entry UUIDs for manual contact targeting"),
+        selectedGroupPoolEntryIds: z.array(z.string()).optional().describe("Group pool entry UUIDs for manual group targeting"),
+        targetGoal: z.number().optional().describe("Updated target number of deliveries"),
+        budget: z.number().optional().describe("Updated budget in kobo"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const { adRequestId, ...body } = params;
+        const result = await api("PUT", `/ad-requests/${adRequestId}`, body);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Delete ad request
+  server.registerTool(
+    "neuron_delete_ad_request",
+    {
+      title: "Delete Ad Request",
+      description: "Permanently delete a draft ad request. Only ad requests in draft status can be deleted.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the draft ad request to delete"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("DELETE", `/ad-requests/${params.adRequestId}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Submit ad request for review
+  server.registerTool(
+    "neuron_submit_ad_request",
+    {
+      title: "Submit Ad Request for Review",
+      description: "Submit a draft ad request for admin review. The request must be in draft status. After submission, an admin must approve it before it can be funded.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the draft ad request to submit"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `/ad-requests/${params.adRequestId}/submit`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Fund ad request from wallet
+  server.registerTool(
+    "neuron_fund_ad_request",
+    {
+      title: "Fund Ad Request",
+      description: "Fund an approved ad request from the organization wallet. This debits the budget amount and activates the campaign for distribution. If wallet balance is insufficient, returns shortfall information instead of an error.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the approved ad request to fund"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `/ad-requests/${params.adRequestId}/fund`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Pause ad request
+  server.registerTool(
+    "neuron_pause_ad_request",
+    {
+      title: "Pause Ad Request",
+      description: "Pause an active ad request campaign. Distribution stops until resumed. Only active ad requests can be paused.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the active ad request to pause"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `/ad-requests/${params.adRequestId}/pause`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Resume ad request
+  server.registerTool(
+    "neuron_resume_ad_request",
+    {
+      title: "Resume Ad Request",
+      description: "Resume a paused ad request campaign. Distribution resumes from where it left off. Only paused ad requests can be resumed.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the paused ad request to resume"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `/ad-requests/${params.adRequestId}/resume`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Stop ad request
+  server.registerTool(
+    "neuron_stop_ad_request",
+    {
+      title: "Stop Ad Request",
+      description: "Stop an active or paused ad request campaign permanently. Any remaining unspent budget is refunded to the organization wallet. This cannot be undone.",
+      inputSchema: z.object({
+        adRequestId: z.string().describe("Unique identifier (UUID) of the ad request to stop"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `/ad-requests/${params.adRequestId}/stop`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}

package/src/tools/media.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { jsonResult, errorResult, getAuthToken, getBaseUrl } from "../client.js";
+import axios from "axios";
+import FormData from "form-data";
+
+export function registerMediaTools(server: McpServer): void {
+  // Upload media
+  server.registerTool(
+    "neuron_upload_media",
+    {
+      title: "Upload Media",
+      description: "Upload a media file (image, video, audio, or document) by providing its base64-encoded content. Returns a URL for use in messages and broadcasts.",
+      inputSchema: z.object({
+        base64: z.string().describe("Base64-encoded file content (without data URI prefix)"),
+        filename: z.string().describe("Original filename including extension (e.g., 'photo.jpg', 'report.pdf')"),
+        mimetype: z.string().describe("MIME type of the file (e.g., 'image/jpeg', 'image/png', 'application/pdf', 'video/mp4')"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const buffer = Buffer.from(params.base64, "base64");
+        const form = new FormData();
+        form.append("file", buffer, {
+          filename: params.filename,
+          contentType: params.mimetype,
+        });
+
+        const token = getAuthToken();
+        const response = await axios.post(`${getBaseUrl()}/media/upload`, form, {
+          headers: {
+            ...form.getHeaders(),
+            ...(token ? { Authorization: `Bearer ${token}` } : {}),
+          },
+          timeout: 60000,
+        });
+
+        return jsonResult(response.data);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}