@vettly/mcp 0.1.1

package/README.md

@@ -0,0 +1,122 @@
+# @vettly/mcp
+
+MCP (Model Context Protocol) server for Vettly content moderation API. Enables AI assistants like Claude to moderate content, validate policies, and review moderation decisions.
+
+## Installation
+
+```bash
+npm install @vettly/mcp
+# or
+npx @vettly/mcp
+```
+
+## Configuration
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "vettly": {
+      "command": "npx",
+      "args": ["-y", "@vettly/mcp"],
+      "env": {
+        "VETTLY_API_KEY": "vettly_live_xxx"
+      }
+    }
+  }
+}
+```
+
+### Environment Variables
+
+- `VETTLY_API_KEY` (required) - Your Vettly API key
+- `VETTLY_API_URL` (optional) - API URL (defaults to `https://api.vettly.dev`)
+
+## Available Tools
+
+### `moderate_content`
+
+Check content against a Vettly moderation policy.
+
+**Parameters:**
+- `content` (required) - The content to moderate
+- `policyId` (required) - The policy ID to use
+- `contentType` (optional) - `text`, `image`, or `video` (default: `text`)
+
+**Example:**
+```
+Moderate this text: "Hello world" using policy "default-policy"
+```
+
+### `validate_policy`
+
+Validate a policy YAML without saving it.
+
+**Parameters:**
+- `yamlContent` (required) - The YAML policy content to validate
+
+**Example:**
+```
+Validate this policy YAML:
+name: my-policy
+rules:
+  - category: hate_speech
+    threshold: 0.7
+    action: block
+```
+
+### `list_policies`
+
+List all available moderation policies in your account.
+
+**Parameters:** None
+
+### `get_usage_stats`
+
+Get usage statistics including request counts, costs, and moderation outcomes.
+
+**Parameters:**
+- `days` (optional) - Number of days to include (1-365, default: 30)
+
+### `get_recent_decisions`
+
+Get recent moderation decisions with optional filtering.
+
+**Parameters:**
+- `limit` (optional) - Number of decisions to return (1-50, default: 10)
+- `flagged` (optional) - Filter by flagged status
+- `policyId` (optional) - Filter by policy ID
+- `contentType` (optional) - Filter by content type
+
+## Resources
+
+### `vettly://policies`
+
+Read-only list of all available moderation policies.
+
+### `vettly://policies/{policyId}`
+
+Read-only access to a specific policy's YAML configuration.
+
+## Programmatic Usage
+
+```typescript
+import { createVettlyMcpServer } from '@vettly/mcp';
+
+const server = createVettlyMcpServer({
+  apiKey: process.env.VETTLY_API_KEY!,
+  apiUrl: 'https://api.vettly.dev', // optional
+});
+
+// Connect to your transport
+server.connect(transport);
+```
+
+## Links
+
+- [Vettly Documentation](https://docs.vettly.dev)
+- [Get an API Key](https://vettly.dev)
+- [MCP Specification](https://modelcontextprotocol.io)

package/dist/bin/vettly-mcp.cjs

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/bin/vettly-mcp.ts
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// src/server.ts
+var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_sdk = require("@vettly/sdk");
+
+// src/tools/moderate.ts
+var import_zod = require("zod");
+var ModerateInputSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1).max(1e5).describe("The content to moderate (text content, or URL for images/video)"),
+  policyId: import_zod.z.string().min(1).describe("The policy ID to use for moderation"),
+  contentType: import_zod.z.enum(["text", "image", "video"]).default("text").describe("Type of content being moderated")
+});
+function registerModerateTool(server, client) {
+  server.tool(
+    "moderate_content",
+    "Check text, image, or video content against a Vettly moderation policy. Returns safety assessment with category scores.",
+    {
+      content: ModerateInputSchema.shape.content,
+      policyId: ModerateInputSchema.shape.policyId,
+      contentType: ModerateInputSchema.shape.contentType
+    },
+    async (args) => {
+      const input = ModerateInputSchema.parse(args);
+      try {
+        const result = await client.check({
+          content: input.content,
+          policyId: input.policyId,
+          contentType: input.contentType
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  decisionId: result.decisionId,
+                  safe: result.safe,
+                  flagged: result.flagged,
+                  action: result.action,
+                  categories: result.categories,
+                  provider: result.provider,
+                  latency: result.latency,
+                  cost: result.cost
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Moderation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/validate.ts
+var import_zod2 = require("zod");
+var ValidateInputSchema = import_zod2.z.object({
+  yamlContent: import_zod2.z.string().min(1).describe("The YAML policy content to validate")
+});
+function registerValidateTool(server, client) {
+  server.tool(
+    "validate_policy",
+    "Validate a Vettly policy YAML without saving it. Returns validation results with any syntax or configuration errors.",
+    {
+      yamlContent: ValidateInputSchema.shape.yamlContent
+    },
+    async (args) => {
+      const input = ValidateInputSchema.parse(args);
+      try {
+        const result = await client.validatePolicy(input.yamlContent);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/list-policies.ts
+function registerListPoliciesTool(server, client) {
+  server.tool(
+    "list_policies",
+    "List all moderation policies available in your Vettly account.",
+    {},
+    async () => {
+      try {
+        const result = await client.listPolicies();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to list policies: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/usage-stats.ts
+var import_zod3 = require("zod");
+var UsageStatsInputSchema = import_zod3.z.object({
+  days: import_zod3.z.number().min(1).max(365).default(30).describe("Number of days to include in statistics")
+});
+function registerUsageStatsTool(server, client) {
+  server.tool(
+    "get_usage_stats",
+    "Get usage statistics for your Vettly account including request counts, costs, and moderation outcomes.",
+    {
+      days: UsageStatsInputSchema.shape.days
+    },
+    async (args) => {
+      const input = UsageStatsInputSchema.parse(args);
+      try {
+        const result = await client.getUsageStats(input.days);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to get usage stats: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/decisions.ts
+var import_zod4 = require("zod");
+var DecisionsInputSchema = import_zod4.z.object({
+  limit: import_zod4.z.number().min(1).max(50).default(10).describe("Number of decisions to return"),
+  flagged: import_zod4.z.boolean().optional().describe("Filter to only flagged content (true) or safe content (false)"),
+  policyId: import_zod4.z.string().optional().describe("Filter by specific policy ID"),
+  contentType: import_zod4.z.enum(["text", "image", "video"]).optional().describe("Filter by content type")
+});
+function registerDecisionsTool(server, client) {
+  server.tool(
+    "get_recent_decisions",
+    "Get recent moderation decisions with optional filtering by outcome, content type, or policy.",
+    {
+      limit: DecisionsInputSchema.shape.limit,
+      flagged: DecisionsInputSchema.shape.flagged,
+      policyId: DecisionsInputSchema.shape.policyId,
+      contentType: DecisionsInputSchema.shape.contentType
+    },
+    async (args) => {
+      const input = DecisionsInputSchema.parse(args);
+      try {
+        const result = await client.listDecisions({ limit: input.limit });
+        let decisions = result.decisions || result;
+        if (input.flagged !== void 0) {
+          decisions = decisions.filter((d) => d.flagged === input.flagged);
+        }
+        if (input.policyId) {
+          decisions = decisions.filter((d) => d.policyId === input.policyId);
+        }
+        if (input.contentType) {
+          decisions = decisions.filter((d) => d.contentType === input.contentType);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ decisions }, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to get decisions: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerTools(server, client) {
+  registerModerateTool(server, client);
+  registerValidateTool(server, client);
+  registerListPoliciesTool(server, client);
+  registerUsageStatsTool(server, client);
+  registerDecisionsTool(server, client);
+}
+
+// src/resources/policies.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+function registerPolicyResources(server, client) {
+  server.resource(
+    "policies",
+    "vettly://policies",
+    {
+      description: "List of all available moderation policies",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        const result = await client.listPolicies();
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Failed to list policies: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "policy",
+    new import_mcp.ResourceTemplate("vettly://policies/{policyId}", { list: void 0 }),
+    {
+      description: "A specific moderation policy with its YAML configuration",
+      mimeType: "application/x-yaml"
+    },
+    async (uri, { policyId }) => {
+      try {
+        const result = await client.getPolicy(policyId);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/x-yaml",
+              text: result.yamlContent || result.yaml || JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Failed to get policy: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerResources(server, client) {
+  registerPolicyResources(server, client);
+}
+
+// src/server.ts
+function createVettlyMcpServer(config) {
+  const client = new import_sdk.ModerationClient({
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl
+  });
+  const server = new import_mcp2.McpServer({
+    name: "vettly",
+    version: "0.1.0"
+  });
+  registerTools(server, client);
+  registerResources(server, client);
+  return server;
+}
+
+// src/bin/vettly-mcp.ts
+async function main() {
+  const apiKey = process.env.VETTLY_API_KEY;
+  if (!apiKey) {
+    console.error("Error: VETTLY_API_KEY environment variable is required");
+    console.error("");
+    console.error("Usage:");
+    console.error("  VETTLY_API_KEY=vettly_live_xxx npx @vettly/mcp");
+    console.error("");
+    console.error("Or configure in Claude Desktop:");
+    console.error("  {");
+    console.error('    "mcpServers": {');
+    console.error('      "vettly": {');
+    console.error('        "command": "npx",');
+    console.error('        "args": ["-y", "@vettly/mcp"],');
+    console.error('        "env": { "VETTLY_API_KEY": "vettly_live_xxx" }');
+    console.error("      }");
+    console.error("    }");
+    console.error("  }");
+    process.exit(1);
+  }
+  const server = createVettlyMcpServer({
+    apiKey,
+    apiUrl: process.env.VETTLY_API_URL
+  });
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/dist/bin/vettly-mcp.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/vettly-mcp.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/bin/vettly-mcp.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import {
+  createVettlyMcpServer
+} from "../chunk-VZJIPBOX.js";
+
+// src/bin/vettly-mcp.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function main() {
+  const apiKey = process.env.VETTLY_API_KEY;
+  if (!apiKey) {
+    console.error("Error: VETTLY_API_KEY environment variable is required");
+    console.error("");
+    console.error("Usage:");
+    console.error("  VETTLY_API_KEY=vettly_live_xxx npx @vettly/mcp");
+    console.error("");
+    console.error("Or configure in Claude Desktop:");
+    console.error("  {");
+    console.error('    "mcpServers": {');
+    console.error('      "vettly": {');
+    console.error('        "command": "npx",');
+    console.error('        "args": ["-y", "@vettly/mcp"],');
+    console.error('        "env": { "VETTLY_API_KEY": "vettly_live_xxx" }');
+    console.error("      }");
+    console.error("    }");
+    console.error("  }");
+    process.exit(1);
+  }
+  const server = createVettlyMcpServer({
+    apiKey,
+    apiUrl: process.env.VETTLY_API_URL
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/dist/chunk-VZJIPBOX.js

@@ -0,0 +1,330 @@
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ModerationClient } from "@vettly/sdk";
+
+// src/tools/moderate.ts
+import { z } from "zod";
+var ModerateInputSchema = z.object({
+  content: z.string().min(1).max(1e5).describe("The content to moderate (text content, or URL for images/video)"),
+  policyId: z.string().min(1).describe("The policy ID to use for moderation"),
+  contentType: z.enum(["text", "image", "video"]).default("text").describe("Type of content being moderated")
+});
+function registerModerateTool(server, client) {
+  server.tool(
+    "moderate_content",
+    "Check text, image, or video content against a Vettly moderation policy. Returns safety assessment with category scores.",
+    {
+      content: ModerateInputSchema.shape.content,
+      policyId: ModerateInputSchema.shape.policyId,
+      contentType: ModerateInputSchema.shape.contentType
+    },
+    async (args) => {
+      const input = ModerateInputSchema.parse(args);
+      try {
+        const result = await client.check({
+          content: input.content,
+          policyId: input.policyId,
+          contentType: input.contentType
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  decisionId: result.decisionId,
+                  safe: result.safe,
+                  flagged: result.flagged,
+                  action: result.action,
+                  categories: result.categories,
+                  provider: result.provider,
+                  latency: result.latency,
+                  cost: result.cost
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Moderation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/validate.ts
+import { z as z2 } from "zod";
+var ValidateInputSchema = z2.object({
+  yamlContent: z2.string().min(1).describe("The YAML policy content to validate")
+});
+function registerValidateTool(server, client) {
+  server.tool(
+    "validate_policy",
+    "Validate a Vettly policy YAML without saving it. Returns validation results with any syntax or configuration errors.",
+    {
+      yamlContent: ValidateInputSchema.shape.yamlContent
+    },
+    async (args) => {
+      const input = ValidateInputSchema.parse(args);
+      try {
+        const result = await client.validatePolicy(input.yamlContent);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/list-policies.ts
+function registerListPoliciesTool(server, client) {
+  server.tool(
+    "list_policies",
+    "List all moderation policies available in your Vettly account.",
+    {},
+    async () => {
+      try {
+        const result = await client.listPolicies();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to list policies: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/usage-stats.ts
+import { z as z3 } from "zod";
+var UsageStatsInputSchema = z3.object({
+  days: z3.number().min(1).max(365).default(30).describe("Number of days to include in statistics")
+});
+function registerUsageStatsTool(server, client) {
+  server.tool(
+    "get_usage_stats",
+    "Get usage statistics for your Vettly account including request counts, costs, and moderation outcomes.",
+    {
+      days: UsageStatsInputSchema.shape.days
+    },
+    async (args) => {
+      const input = UsageStatsInputSchema.parse(args);
+      try {
+        const result = await client.getUsageStats(input.days);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to get usage stats: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/decisions.ts
+import { z as z4 } from "zod";
+var DecisionsInputSchema = z4.object({
+  limit: z4.number().min(1).max(50).default(10).describe("Number of decisions to return"),
+  flagged: z4.boolean().optional().describe("Filter to only flagged content (true) or safe content (false)"),
+  policyId: z4.string().optional().describe("Filter by specific policy ID"),
+  contentType: z4.enum(["text", "image", "video"]).optional().describe("Filter by content type")
+});
+function registerDecisionsTool(server, client) {
+  server.tool(
+    "get_recent_decisions",
+    "Get recent moderation decisions with optional filtering by outcome, content type, or policy.",
+    {
+      limit: DecisionsInputSchema.shape.limit,
+      flagged: DecisionsInputSchema.shape.flagged,
+      policyId: DecisionsInputSchema.shape.policyId,
+      contentType: DecisionsInputSchema.shape.contentType
+    },
+    async (args) => {
+      const input = DecisionsInputSchema.parse(args);
+      try {
+        const result = await client.listDecisions({ limit: input.limit });
+        let decisions = result.decisions || result;
+        if (input.flagged !== void 0) {
+          decisions = decisions.filter((d) => d.flagged === input.flagged);
+        }
+        if (input.policyId) {
+          decisions = decisions.filter((d) => d.policyId === input.policyId);
+        }
+        if (input.contentType) {
+          decisions = decisions.filter((d) => d.contentType === input.contentType);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ decisions }, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to get decisions: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerTools(server, client) {
+  registerModerateTool(server, client);
+  registerValidateTool(server, client);
+  registerListPoliciesTool(server, client);
+  registerUsageStatsTool(server, client);
+  registerDecisionsTool(server, client);
+}
+
+// src/resources/policies.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerPolicyResources(server, client) {
+  server.resource(
+    "policies",
+    "vettly://policies",
+    {
+      description: "List of all available moderation policies",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        const result = await client.listPolicies();
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Failed to list policies: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "policy",
+    new ResourceTemplate("vettly://policies/{policyId}", { list: void 0 }),
+    {
+      description: "A specific moderation policy with its YAML configuration",
+      mimeType: "application/x-yaml"
+    },
+    async (uri, { policyId }) => {
+      try {
+        const result = await client.getPolicy(policyId);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/x-yaml",
+              text: result.yamlContent || result.yaml || JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Failed to get policy: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerResources(server, client) {
+  registerPolicyResources(server, client);
+}
+
+// src/server.ts
+function createVettlyMcpServer(config) {
+  const client = new ModerationClient({
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl
+  });
+  const server = new McpServer({
+    name: "vettly",
+    version: "0.1.0"
+  });
+  registerTools(server, client);
+  registerResources(server, client);
+  return server;
+}
+
+export {
+  createVettlyMcpServer
+};

package/dist/index.cjs

@@ -0,0 +1,356 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createVettlyMcpServer: () => createVettlyMcpServer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_mcp2 = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_sdk = require("@vettly/sdk");
+
+// src/tools/moderate.ts
+var import_zod = require("zod");
+var ModerateInputSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1).max(1e5).describe("The content to moderate (text content, or URL for images/video)"),
+  policyId: import_zod.z.string().min(1).describe("The policy ID to use for moderation"),
+  contentType: import_zod.z.enum(["text", "image", "video"]).default("text").describe("Type of content being moderated")
+});
+function registerModerateTool(server, client) {
+  server.tool(
+    "moderate_content",
+    "Check text, image, or video content against a Vettly moderation policy. Returns safety assessment with category scores.",
+    {
+      content: ModerateInputSchema.shape.content,
+      policyId: ModerateInputSchema.shape.policyId,
+      contentType: ModerateInputSchema.shape.contentType
+    },
+    async (args) => {
+      const input = ModerateInputSchema.parse(args);
+      try {
+        const result = await client.check({
+          content: input.content,
+          policyId: input.policyId,
+          contentType: input.contentType
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                {
+                  decisionId: result.decisionId,
+                  safe: result.safe,
+                  flagged: result.flagged,
+                  action: result.action,
+                  categories: result.categories,
+                  provider: result.provider,
+                  latency: result.latency,
+                  cost: result.cost
+                },
+                null,
+                2
+              )
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Moderation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/validate.ts
+var import_zod2 = require("zod");
+var ValidateInputSchema = import_zod2.z.object({
+  yamlContent: import_zod2.z.string().min(1).describe("The YAML policy content to validate")
+});
+function registerValidateTool(server, client) {
+  server.tool(
+    "validate_policy",
+    "Validate a Vettly policy YAML without saving it. Returns validation results with any syntax or configuration errors.",
+    {
+      yamlContent: ValidateInputSchema.shape.yamlContent
+    },
+    async (args) => {
+      const input = ValidateInputSchema.parse(args);
+      try {
+        const result = await client.validatePolicy(input.yamlContent);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/list-policies.ts
+function registerListPoliciesTool(server, client) {
+  server.tool(
+    "list_policies",
+    "List all moderation policies available in your Vettly account.",
+    {},
+    async () => {
+      try {
+        const result = await client.listPolicies();
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to list policies: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/usage-stats.ts
+var import_zod3 = require("zod");
+var UsageStatsInputSchema = import_zod3.z.object({
+  days: import_zod3.z.number().min(1).max(365).default(30).describe("Number of days to include in statistics")
+});
+function registerUsageStatsTool(server, client) {
+  server.tool(
+    "get_usage_stats",
+    "Get usage statistics for your Vettly account including request counts, costs, and moderation outcomes.",
+    {
+      days: UsageStatsInputSchema.shape.days
+    },
+    async (args) => {
+      const input = UsageStatsInputSchema.parse(args);
+      try {
+        const result = await client.getUsageStats(input.days);
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to get usage stats: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/decisions.ts
+var import_zod4 = require("zod");
+var DecisionsInputSchema = import_zod4.z.object({
+  limit: import_zod4.z.number().min(1).max(50).default(10).describe("Number of decisions to return"),
+  flagged: import_zod4.z.boolean().optional().describe("Filter to only flagged content (true) or safe content (false)"),
+  policyId: import_zod4.z.string().optional().describe("Filter by specific policy ID"),
+  contentType: import_zod4.z.enum(["text", "image", "video"]).optional().describe("Filter by content type")
+});
+function registerDecisionsTool(server, client) {
+  server.tool(
+    "get_recent_decisions",
+    "Get recent moderation decisions with optional filtering by outcome, content type, or policy.",
+    {
+      limit: DecisionsInputSchema.shape.limit,
+      flagged: DecisionsInputSchema.shape.flagged,
+      policyId: DecisionsInputSchema.shape.policyId,
+      contentType: DecisionsInputSchema.shape.contentType
+    },
+    async (args) => {
+      const input = DecisionsInputSchema.parse(args);
+      try {
+        const result = await client.listDecisions({ limit: input.limit });
+        let decisions = result.decisions || result;
+        if (input.flagged !== void 0) {
+          decisions = decisions.filter((d) => d.flagged === input.flagged);
+        }
+        if (input.policyId) {
+          decisions = decisions.filter((d) => d.policyId === input.policyId);
+        }
+        if (input.contentType) {
+          decisions = decisions.filter((d) => d.contentType === input.contentType);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ decisions }, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to get decisions: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerTools(server, client) {
+  registerModerateTool(server, client);
+  registerValidateTool(server, client);
+  registerListPoliciesTool(server, client);
+  registerUsageStatsTool(server, client);
+  registerDecisionsTool(server, client);
+}
+
+// src/resources/policies.ts
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+function registerPolicyResources(server, client) {
+  server.resource(
+    "policies",
+    "vettly://policies",
+    {
+      description: "List of all available moderation policies",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      try {
+        const result = await client.listPolicies();
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/json",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Failed to list policies: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+  server.resource(
+    "policy",
+    new import_mcp.ResourceTemplate("vettly://policies/{policyId}", { list: void 0 }),
+    {
+      description: "A specific moderation policy with its YAML configuration",
+      mimeType: "application/x-yaml"
+    },
+    async (uri, { policyId }) => {
+      try {
+        const result = await client.getPolicy(policyId);
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "application/x-yaml",
+              text: result.yamlContent || result.yaml || JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              mimeType: "text/plain",
+              text: `Failed to get policy: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+          ]
+        };
+      }
+    }
+  );
+}
+
+// src/resources/index.ts
+function registerResources(server, client) {
+  registerPolicyResources(server, client);
+}
+
+// src/server.ts
+function createVettlyMcpServer(config) {
+  const client = new import_sdk.ModerationClient({
+    apiKey: config.apiKey,
+    apiUrl: config.apiUrl
+  });
+  const server = new import_mcp2.McpServer({
+    name: "vettly",
+    version: "0.1.0"
+  });
+  registerTools(server, client);
+  registerResources(server, client);
+  return server;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createVettlyMcpServer
+});

package/dist/index.d.cts

@@ -0,0 +1,9 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+interface VettlyMcpConfig {
+    apiKey: string;
+    apiUrl?: string;
+}
+declare function createVettlyMcpServer(config: VettlyMcpConfig): McpServer;
+
+export { type VettlyMcpConfig, createVettlyMcpServer };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+interface VettlyMcpConfig {
+    apiKey: string;
+    apiUrl?: string;
+}
+declare function createVettlyMcpServer(config: VettlyMcpConfig): McpServer;
+
+export { type VettlyMcpConfig, createVettlyMcpServer };

package/dist/index.js

@@ -0,0 +1,6 @@
+import {
+  createVettlyMcpServer
+} from "./chunk-VZJIPBOX.js";
+export {
+  createVettlyMcpServer
+};

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@vettly/mcp",
+  "version": "0.1.1",
+  "mcpName": "io.github.code-with-brian/vettly",
+  "description": "MCP server for Vettly content moderation API",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "vettly-mcp": "./dist/bin/vettly-mcp.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/bin/vettly-mcp.ts --format esm,cjs --dts --clean",
+    "dev": "tsup src/index.ts src/bin/vettly-mcp.ts --format esm --watch",
+    "test": "bun test",
+    "prepublishOnly": "bun run build"
+  },
+  "keywords": [
+    "mcp",
+    "mcp-server",
+    "model-context-protocol",
+    "vettly",
+    "content-moderation",
+    "moderation",
+    "content-safety",
+    "trust-safety",
+    "ai",
+    "claude",
+    "cursor",
+    "anthropic",
+    "ugc-moderation",
+    "text-moderation",
+    "image-moderation",
+    "video-moderation",
+    "hate-speech-detection",
+    "nsfw-detection",
+    "csam-detection",
+    "spam-detection"
+  ],
+  "author": "Vettly",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/brian-nextaura/vettly-docs.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://vettly.dev",
+  "publishConfig": {
+    "access": "public",
+    "name": "@nextauralabs/vettly-mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/brian-nextaura/vettly-docs/issues"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "@vettly/sdk": "workspace:*",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}