sopo-mcp 1.0.0

package/src/resources/platform.resources.ts

@@ -0,0 +1,163 @@
+/**
+ * Sopo MCP Server — Resources
+ * 
+ * MCP Resources provide read-only context to AI models about the Sopo platform.
+ * These are data sources the AI can read at any time to understand the system.
+ */
+
+import { sopoGet } from '../sopo-client.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+export function registerResources(server: McpServer): void {
+
+  // ── Platform Overview Resource ────────────────────────────────
+  server.resource(
+    'sopo-platform-overview',
+    'sopo://platform/overview',
+    {
+      description: 'Overview of the Sopo API Gateway platform, its architecture, domain model, and available API endpoints.',
+      mimeType: 'text/markdown',
+    },
+    async () => ({
+      contents: [{
+        uri: 'sopo://platform/overview',
+        mimeType: 'text/markdown',
+        text: `# Sopo API Gateway Platform
+
+## What is Sopo?
+Sopo is a full-featured **API Gateway management platform**. It allows users to create and manage API gateways that route, load-balance, and apply middleware to incoming HTTP requests.
+
+## Architecture
+- **Backend** (Node.js/TypeScript + Express): The BFF (Backend-for-Frontend) layer that exposes REST APIs and proxies GraphQL to Hasura.
+- **Hasura**: GraphQL engine connected to PostgreSQL (metadata) and ClickHouse (logs/metrics).
+- **Go Gateway Server**: The actual reverse proxy that processes live traffic based on the configuration defined via the Backend.
+- **Frontend** (Next.js): Dashboard UI for managing gateways.
+
+## Domain Model (Hierarchy)
+\`\`\`
+User
+  └── Gateway (API Gateway instance)
+        ├── Service (upstream backend)
+        │     └── ServiceTarget (URL + weight for load balancing)
+        ├── GatewayRoute (path → service mapping)
+        │     └── AggregateRequest (parallel sub-requests)
+        ├── GatewayPlugin (middleware: auth, rate-limit, cors, etc.)
+        └── Collection (organizational group, Pro mode only)
+\`\`\`
+
+## Key Concepts
+- **Gateway**: A logical API gateway that users create. Has modes: "single" (simple) and "pro" (collections).
+- **Service**: Represents an upstream backend with health checking and load balancing configuration.
+- **ServiceTarget**: An actual URL endpoint for a service. Multiple targets enable load balancing.
+- **GatewayRoute**: Maps an incoming path/method to a downstream service.
+- **AggregateRequest**: Defines sub-requests for parallel fan-out on a single route.
+- **GatewayPlugin**: Middleware (e.g., apikey, rate_limit, cors) attached to a gateway or route. Mutually exclusive: gateway_id OR route_id.
+- **Collection**: Organizational grouping of routes/services (Pro mode only).
+- **UserProfile**: Contains the user's slug (URL namespace).
+
+## Available API Endpoints
+All protected routes require a valid JWT Bearer token.
+
+### System
+- \`GET /health\` — Health check
+
+### Gateway CRUD (/api/v1/gateways)
+- POST / — Create gateway
+- GET / — List gateways
+- PATCH /:id — Update gateway
+- DELETE /:id — Delete gateway
+
+### Service CRUD (/api/v1/services)
+- POST / — Create service (requires gateway_id)
+- GET / — List services
+- PATCH /:id — Update service
+- DELETE /:id — Delete service
+
+### Service Targets CRUD (/api/v1/service-targets)
+- POST / — Create target (requires service_id)
+- GET / — List targets
+- PATCH /:id — Update target
+- DELETE /:id — Delete target
+
+### Gateway Routes CRUD (/api/v1/gateway-routes)
+- POST / — Create route (requires gateway_id + service_id)
+- GET / — List routes
+- PATCH /:id — Update route
+- DELETE /:id — Delete route
+
+### Aggregate Requests CRUD (/api/v1/aggregate-requests)
+- POST / — Create aggregate request (requires route_id + service_id)
+- GET / — List aggregate requests
+- PATCH /:id — Update aggregate request
+- DELETE /:id — Delete aggregate request
+
+### Gateway Plugins CRUD (/api/v1/gateway-plugins)
+- POST / — Create plugin (requires gateway_id XOR route_id)
+- GET / — List plugins
+- PATCH /:id — Update plugin
+- DELETE /:id — Delete plugin
+
+### Collections CRUD (/api/v1/collections)
+- POST / — Create collection (requires gateway_id)
+- GET / — List collections
+- PATCH /:id — Update collection
+- DELETE /:id — Delete collection
+
+### User Profiles (/api/v1/user-profiles)
+- POST / — Create profile (set slug)
+- GET / — Get profile
+- PATCH / — Update slug
+- DELETE / — Delete profile
+
+### Logs & Metrics (/api/v1/logs)
+- GET /requests — Recent request logs
+- GET /hourly-metrics — Hourly aggregated metrics
+- GET /hourly-metrics-mv — Hourly metrics (materialized view)
+
+### Stats (/api/v1/stats)
+- GET /resources — Resource counts (gateways, services, routes, plugins)
+`,
+      }],
+    })
+  );
+
+  // ── Dynamic Resource: Current Gateway Config ──────────────────
+  server.resource(
+    'sopo-gateway-config',
+    'sopo://gateways/current-config',
+    {
+      description: 'Live snapshot of all gateways and their configuration owned by the authenticated user.',
+      mimeType: 'application/json',
+    },
+    async () => {
+      const result = await sopoGet('/api/v1/gateways');
+      return {
+        contents: [{
+          uri: 'sopo://gateways/current-config',
+          mimeType: 'application/json',
+          text: JSON.stringify(result.success ? result.data : { error: result.error }, null, 2),
+        }],
+      };
+    }
+  );
+
+  // ── Dynamic Resource: Current Stats ───────────────────────────
+  server.resource(
+    'sopo-resource-stats',
+    'sopo://stats/resources',
+    {
+      description: 'Live resource counts for the authenticated user (gateways, services, routes, plugins).',
+      mimeType: 'application/json',
+    },
+    async () => {
+      const result = await sopoGet('/api/v1/stats/resources');
+      return {
+        contents: [{
+          uri: 'sopo://stats/resources',
+          mimeType: 'application/json',
+          text: JSON.stringify(result.success ? result.data : { error: result.error }, null, 2),
+        }],
+      };
+    }
+  );
+}

package/src/sopo-client.ts

@@ -0,0 +1,180 @@
+/**
+ * Sopo MCP Server — HTTP Client
+ * 
+ * Handles all communication with the Sopo Backend REST API.
+ * Manages authentication headers and error normalization.
+ */
+
+export interface SopoConfig {
+  backendUrl: string;
+  accessToken: string;
+}
+
+export interface SopoResponse<T = any> {
+  success: boolean;
+  data?: T;
+  error?: string;
+  statusCode: number;
+}
+
+let config: SopoConfig | null = null;
+let storedRefreshToken: string | null = null;
+
+export function configureSopoClient(cfg: SopoConfig): void {
+  config = cfg;
+}
+
+/**
+ * Updates the access token at runtime (e.g., after login or token refresh).
+ * All subsequent API calls will use the new token.
+ */
+export function updateAccessToken(newToken: string): void {
+  if (!config) {
+    throw new Error('Sopo client not configured. Call configureSopoClient() first.');
+  }
+  config.accessToken = newToken;
+}
+
+/**
+ * Stores the refresh token in memory for automatic token refresh.
+ */
+export function setRefreshToken(token: string): void {
+  storedRefreshToken = token;
+}
+
+/**
+ * Retrieves the stored refresh token (if any).
+ */
+export function getRefreshToken(): string | null {
+  return storedRefreshToken;
+}
+
+function getConfig(): SopoConfig {
+  if (!config) {
+    throw new Error('Sopo client not configured. Call configureSopoClient() first.');
+  }
+  return config;
+}
+
+/**
+ * Returns the backend base URL for direct fetch calls (e.g., auth endpoints).
+ */
+export function getBackendUrl(): string {
+  return getConfig().backendUrl;
+}
+
+function buildHeaders(): Record<string, string> {
+  const cfg = getConfig();
+  return {
+    'Content-Type': 'application/json',
+    'Authorization': cfg.accessToken.startsWith('Bearer ')
+      ? cfg.accessToken
+      : `Bearer ${cfg.accessToken}`,
+  };
+}
+
+/**
+ * Performs a GET request to the Sopo Backend.
+ */
+export async function sopoGet<T = any>(path: string): Promise<SopoResponse<T>> {
+  const cfg = getConfig();
+  const url = `${cfg.backendUrl}${path}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: buildHeaders(),
+    });
+
+    const body = await response.json().catch(() => null);
+
+    if (!response.ok) {
+      const errorMsg = body?.error?.message || body?.message || `HTTP ${response.status}`;
+      return { success: false, error: errorMsg, statusCode: response.status };
+    }
+
+    return { success: true, data: body as T, statusCode: response.status };
+  } catch (err: any) {
+    return { success: false, error: err.message || 'Network error', statusCode: 0 };
+  }
+}
+
+/**
+ * Performs a POST request to the Sopo Backend.
+ */
+export async function sopoPost<T = any>(path: string, body: any): Promise<SopoResponse<T>> {
+  const cfg = getConfig();
+  const url = `${cfg.backendUrl}${path}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: buildHeaders(),
+      body: JSON.stringify(body),
+    });
+
+    const responseBody = await response.json().catch(() => null);
+
+    if (!response.ok) {
+      const errorMsg = responseBody?.error?.message || responseBody?.message || `HTTP ${response.status}`;
+      return { success: false, error: errorMsg, statusCode: response.status };
+    }
+
+    return { success: true, data: responseBody as T, statusCode: response.status };
+  } catch (err: any) {
+    return { success: false, error: err.message || 'Network error', statusCode: 0 };
+  }
+}
+
+/**
+ * Performs a PATCH request to the Sopo Backend.
+ */
+export async function sopoPatch<T = any>(path: string, body: any): Promise<SopoResponse<T>> {
+  const cfg = getConfig();
+  const url = `${cfg.backendUrl}${path}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'PATCH',
+      headers: buildHeaders(),
+      body: JSON.stringify(body),
+    });
+
+    const responseBody = await response.json().catch(() => null);
+
+    if (!response.ok) {
+      const errorMsg = responseBody?.error?.message || responseBody?.message || `HTTP ${response.status}`;
+      return { success: false, error: errorMsg, statusCode: response.status };
+    }
+
+    return { success: true, data: responseBody as T, statusCode: response.status };
+  } catch (err: any) {
+    return { success: false, error: err.message || 'Network error', statusCode: 0 };
+  }
+}
+
+/**
+ * Performs a DELETE request to the Sopo Backend.
+ */
+export async function sopoDelete<T = any>(path: string): Promise<SopoResponse<T>> {
+  const cfg = getConfig();
+  const url = `${cfg.backendUrl}${path}`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'DELETE',
+      headers: buildHeaders(),
+    });
+
+    const responseBody = await response.json().catch(() => null);
+
+    if (!response.ok) {
+      const errorMsg = responseBody?.error?.message || responseBody?.message || `HTTP ${response.status}`;
+      return { success: false, error: errorMsg, statusCode: response.status };
+    }
+
+    return { success: true, data: responseBody as T, statusCode: response.status };
+  } catch (err: any) {
+    return { success: false, error: err.message || 'Network error', statusCode: 0 };
+  }
+}

package/src/tools/aggregate-request.tools.ts

@@ -0,0 +1,83 @@
+/**
+ * Sopo MCP Server — Aggregate Request Tools
+ * 
+ * CRUD tools for managing Aggregate Requests (parallel sub-requests on a single route).
+ */
+
+import { z } from 'zod';
+import { sopoGet, sopoPost, sopoPatch, sopoDelete } from '../sopo-client.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+export function registerAggregateRequestTools(server: McpServer): void {
+
+  // ── List Aggregate Requests ───────────────────────────────────
+  server.tool(
+    'list_aggregate_requests',
+    'List all aggregate request configurations. Returns id, route_id, service_id, key_name, method, target_path, and timeout.',
+    {},
+    async () => {
+      const result = await sopoGet('/api/v1/aggregate-requests');
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }] };
+    }
+  );
+
+  // ── Create Aggregate Request ──────────────────────────────────
+  server.tool(
+    'create_aggregate_request',
+    'Define a sub-request for parallel execution on a gateway route. Requires route_id, service_id, and key_name. Both IDs must reference existing resources.',
+    {
+      route_id: z.string().uuid().describe('UUID of the parent gateway route (must exist)'),
+      service_id: z.string().uuid().describe('UUID of the service to call (must exist)'),
+      key_name: z.string().describe('Key name for the response merge (e.g. "users")'),
+      method: z.string().optional().describe('HTTP method for this sub-request'),
+      target_path: z.string().optional().describe('Target path for this sub-request'),
+      timeout: z.string().optional().describe('Timeout for this sub-request'),
+    },
+    async (args) => {
+      const result = await sopoPost('/api/v1/aggregate-requests', args);
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error creating aggregate request: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: `Aggregate request created:\n${JSON.stringify(result.data, null, 2)}` }] };
+    }
+  );
+
+  // ── Update Aggregate Request ──────────────────────────────────
+  server.tool(
+    'update_aggregate_request',
+    'Update an aggregate request configuration by UUID.',
+    {
+      id: z.string().uuid().describe('UUID of the aggregate request'),
+      method: z.string().optional().describe('New HTTP method'),
+      target_path: z.string().optional().describe('New target path'),
+      timeout: z.string().optional().describe('New timeout'),
+    },
+    async (args) => {
+      const { id, ...body } = args;
+      const result = await sopoPatch(`/api/v1/aggregate-requests/${id}`, body);
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error updating aggregate request: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: `Aggregate request updated:\n${JSON.stringify(result.data, null, 2)}` }] };
+    }
+  );
+
+  // ── Delete Aggregate Request ──────────────────────────────────
+  server.tool(
+    'delete_aggregate_request',
+    'Delete an aggregate request by its UUID.',
+    {
+      id: z.string().uuid().describe('UUID of the aggregate request to delete'),
+    },
+    async (args) => {
+      const result = await sopoDelete(`/api/v1/aggregate-requests/${args.id}`);
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error deleting aggregate request: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: `Aggregate request deleted successfully.` }] };
+    }
+  );
+}

package/src/tools/auth.tools.ts

@@ -0,0 +1,187 @@
+/**
+ * Sopo MCP Server — Authentication Tools
+ * 
+ * Provides login and token refresh capabilities so the AI can
+ * authenticate automatically without requiring manual token setup.
+ */
+
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import {
+  getBackendUrl,
+  updateAccessToken,
+  setRefreshToken,
+  getRefreshToken,
+} from '../sopo-client.js';
+
+/**
+ * Registers authentication tools on the MCP server.
+ */
+export function registerAuthTools(server: McpServer): void {
+
+  // ── Login with Email & Password ──────────────────────────────
+  server.tool(
+    'sopo_login',
+    'Sign in to Sopo with email and password. On success, the access token is automatically configured for all subsequent API calls. You do NOT need to set any token manually after this.',
+    {
+      email: z.string().email().describe('User email address'),
+      password: z.string().min(1).describe('User password'),
+    },
+    async ({ email, password }) => {
+      try {
+        const backendUrl = getBackendUrl();
+        const response = await fetch(`${backendUrl}/auth/signin/email-password`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ email, password }),
+        });
+
+        const body = await response.json().catch(() => null);
+
+        if (!response.ok) {
+          const errorMsg = body?.error?.message || body?.message || `HTTP ${response.status}`;
+          return {
+            content: [{ type: 'text' as const, text: `❌ Login failed: ${errorMsg}` }],
+          };
+        }
+
+        // Extract access token from response
+        const accessToken = body?.session?.accessToken;
+        if (!accessToken) {
+          return {
+            content: [{ type: 'text' as const, text: '❌ Login succeeded but no access token was returned. Response: ' + JSON.stringify(body) }],
+          };
+        }
+
+        // Update the client with the new access token
+        updateAccessToken(accessToken);
+
+        // Try to extract refresh token from response body or Set-Cookie header
+        const refreshTokenFromBody = body?.session?.refreshToken;
+        const setCookieHeader = response.headers.get('set-cookie');
+        let refreshTokenValue = refreshTokenFromBody;
+
+        if (!refreshTokenValue && setCookieHeader) {
+          // Parse sopo_refresh_token from Set-Cookie header
+          const match = setCookieHeader.match(/sopo_refresh_token=([^;]+)/);
+          if (match) {
+            refreshTokenValue = match[1];
+          }
+        }
+
+        if (refreshTokenValue) {
+          setRefreshToken(refreshTokenValue);
+        }
+
+        const userName = body?.session?.user?.displayName || body?.session?.user?.email || email;
+        const expiresIn = body?.session?.accessTokenExpiresIn;
+        const hasRefresh = !!refreshTokenValue;
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: `✅ Login successful!\n\n` +
+              `👤 User: ${userName}\n` +
+              `🔑 Access Token: configured automatically\n` +
+              `⏱️ Expires in: ${expiresIn ? `${expiresIn} seconds` : 'unknown'}\n` +
+              `🔄 Refresh Token: ${hasRefresh ? 'stored (auto-refresh available)' : 'not available (login again when token expires)'}\n\n` +
+              `All API calls will now use this session. You can start managing gateways, services, and routes.`,
+          }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{ type: 'text' as const, text: `❌ Login error: ${err.message || 'Network error'}` }],
+        };
+      }
+    }
+  );
+
+  // ── Refresh Access Token ─────────────────────────────────────
+  server.tool(
+    'sopo_refresh_token',
+    'Refresh the current access token using the stored refresh token. Call this when API calls start returning 401 Unauthorized errors. The new access token is automatically configured.',
+    {},
+    async () => {
+      try {
+        const currentRefreshToken = getRefreshToken();
+
+        if (!currentRefreshToken) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: '❌ No refresh token available. Please use `sopo_login` to sign in first.',
+            }],
+          };
+        }
+
+        const backendUrl = getBackendUrl();
+        const response = await fetch(`${backendUrl}/auth/token`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ refreshToken: currentRefreshToken }),
+        });
+
+        const body = await response.json().catch(() => null);
+
+        if (!response.ok) {
+          const errorMsg = body?.error?.message || body?.message || `HTTP ${response.status}`;
+          // Clear the stored refresh token since it's invalid
+          setRefreshToken('');
+          return {
+            content: [{
+              type: 'text' as const,
+              text: `❌ Token refresh failed: ${errorMsg}\n\nPlease use \`sopo_login\` to sign in again.`,
+            }],
+          };
+        }
+
+        // Extract new access token
+        const accessToken = body?.session?.accessToken || body?.accessToken;
+        if (!accessToken) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: '❌ Token refresh succeeded but no access token was returned. Response: ' + JSON.stringify(body),
+            }],
+          };
+        }
+
+        // Update the client with the new access token
+        updateAccessToken(accessToken);
+
+        // Update refresh token if a new one was provided
+        const newRefreshToken = body?.session?.refreshToken || body?.refreshToken;
+        const setCookieHeader = response.headers.get('set-cookie');
+
+        if (newRefreshToken) {
+          setRefreshToken(newRefreshToken);
+        } else if (setCookieHeader) {
+          const match = setCookieHeader.match(/sopo_refresh_token=([^;]+)/);
+          if (match) {
+            setRefreshToken(match[1]);
+          }
+        }
+
+        const expiresIn = body?.session?.accessTokenExpiresIn || body?.accessTokenExpiresIn;
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: `✅ Token refreshed successfully!\n\n` +
+              `🔑 New Access Token: configured automatically\n` +
+              `⏱️ Expires in: ${expiresIn ? `${expiresIn} seconds` : 'unknown'}\n` +
+              `🔄 Refresh Token: updated\n\n` +
+              `All API calls will now use the new token.`,
+          }],
+        };
+      } catch (err: any) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: `❌ Token refresh error: ${err.message || 'Network error'}`,
+          }],
+        };
+      }
+    }
+  );
+}

package/src/tools/collection.tools.ts

@@ -0,0 +1,80 @@
+/**
+ * Sopo MCP Server — Collection Tools
+ * 
+ * CRUD tools for managing Collections (organizational groups for routes/services in Pro mode).
+ */
+
+import { z } from 'zod';
+import { sopoGet, sopoPost, sopoPatch, sopoDelete } from '../sopo-client.js';
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+export function registerCollectionTools(server: McpServer): void {
+
+  // ── List Collections ──────────────────────────────────────────
+  server.tool(
+    'list_collections',
+    'List all collections (organizational groupings for Pro mode gateways). Returns id, gateway_id, name, and description.',
+    {},
+    async () => {
+      const result = await sopoGet('/api/v1/collections');
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }] };
+    }
+  );
+
+  // ── Create Collection ─────────────────────────────────────────
+  server.tool(
+    'create_collection',
+    'Create a new collection inside a gateway (Pro mode). Requires gateway_id and name.',
+    {
+      gateway_id: z.string().uuid().describe('UUID of the parent gateway (must exist)'),
+      name: z.string().describe('Collection name (e.g. "v1", "auth-apis")'),
+      description: z.string().optional().describe('Description of the collection'),
+    },
+    async (args) => {
+      const result = await sopoPost('/api/v1/collections', args);
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error creating collection: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: `Collection created:\n${JSON.stringify(result.data, null, 2)}` }] };
+    }
+  );
+
+  // ── Update Collection ─────────────────────────────────────────
+  server.tool(
+    'update_collection',
+    'Update a collection by UUID. You can change name, description, or is_active.',
+    {
+      id: z.string().uuid().describe('UUID of the collection'),
+      name: z.string().optional().describe('New name'),
+      description: z.string().optional().describe('New description'),
+      is_active: z.boolean().optional().describe('Active status'),
+    },
+    async (args) => {
+      const { id, ...body } = args;
+      const result = await sopoPatch(`/api/v1/collections/${id}`, body);
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error updating collection: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: `Collection updated:\n${JSON.stringify(result.data, null, 2)}` }] };
+    }
+  );
+
+  // ── Delete Collection ─────────────────────────────────────────
+  server.tool(
+    'delete_collection',
+    'Delete a collection by its UUID.',
+    {
+      id: z.string().uuid().describe('UUID of the collection to delete'),
+    },
+    async (args) => {
+      const result = await sopoDelete(`/api/v1/collections/${args.id}`);
+      if (!result.success) {
+        return { content: [{ type: 'text', text: `Error deleting collection: ${result.error}` }], isError: true };
+      }
+      return { content: [{ type: 'text', text: `Collection deleted successfully.` }] };
+    }
+  );
+}