@vettly/shared 0.1.9

package/README.md

@@ -0,0 +1,29 @@
+# @nextauralabs/vettly-shared
+
+Shared TypeScript types for the Vettly SDK ecosystem.
+
+## Vettly Packages
+
+| Package | Description |
+|---------|-------------|
+| [@nextauralabs/vettly-sdk](https://npmjs.com/package/@nextauralabs/vettly-sdk) | Core TypeScript SDK |
+| [@nextauralabs/vettly-react](https://npmjs.com/package/@nextauralabs/vettly-react) | React components |
+| [@nextauralabs/vettly-express](https://npmjs.com/package/@nextauralabs/vettly-express) | Express middleware |
+| [@nextauralabs/vettly-nextjs](https://npmjs.com/package/@nextauralabs/vettly-nextjs) | Next.js integration |
+
+## Usage
+
+```typescript
+import type {
+  CheckRequest,
+  CheckResponse,
+  Policy,
+  Category,
+  Action
+} from '@nextauralabs/vettly-shared'
+```
+
+## Links
+
+- [vettly.dev](https://vettly.dev) - Sign up
+- [docs.vettly.dev](https://docs.vettly.dev) - Documentation

package/dist/index.cjs

@@ -0,0 +1,362 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionSchema: () => ActionSchema,
+  CategorySchema: () => CategorySchema,
+  CheckRequestSchema: () => CheckRequestSchema,
+  CheckResponseSchema: () => CheckResponseSchema,
+  ContentItemResultSchema: () => ContentItemResultSchema,
+  ContentTypeSchema: () => ContentTypeSchema,
+  DecisionSchema: () => DecisionSchema,
+  FallbackConfigSchema: () => FallbackConfigSchema,
+  ModerationError: () => ModerationError,
+  MultiModalCheckRequestSchema: () => MultiModalCheckRequestSchema,
+  MultiModalCheckResponseSchema: () => MultiModalCheckResponseSchema,
+  OverrideSchema: () => OverrideSchema,
+  PolicySchema: () => PolicySchema,
+  PolicyValidationError: () => PolicyValidationError,
+  ProviderError: () => ProviderError,
+  ProviderNameSchema: () => ProviderNameSchema,
+  ReplayRequestSchema: () => ReplayRequestSchema,
+  RuleSchema: () => RuleSchema,
+  UseCaseTypeSchema: () => UseCaseTypeSchema,
+  WebhookEndpointSchema: () => WebhookEndpointSchema,
+  WebhookEventTypeSchema: () => WebhookEventTypeSchema,
+  calculatePolicyVersion: () => calculatePolicyVersion,
+  formatCost: () => formatCost,
+  formatLatency: () => formatLatency,
+  generateRequestId: () => generateRequestId,
+  generateUUID: () => generateUUID,
+  hashContent: () => hashContent
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+var import_zod = require("zod");
+var ContentTypeSchema = import_zod.z.enum(["text", "image", "video"]);
+var UseCaseTypeSchema = import_zod.z.enum([
+  "social_post",
+  "comment",
+  "profile",
+  "message",
+  "review",
+  "listing",
+  "bio",
+  "other"
+]);
+var CategorySchema = import_zod.z.enum([
+  "hate_speech",
+  "harassment",
+  "violence",
+  "self_harm",
+  "sexual",
+  "spam",
+  "profanity",
+  "scam",
+  "illegal"
+]);
+var ProviderNameSchema = import_zod.z.enum([
+  "openai",
+  "perspective",
+  "hive",
+  "azure",
+  "bot_detection",
+  "gemini_vision",
+  "mock",
+  "fallback"
+]);
+var ActionSchema = import_zod.z.enum(["block", "warn", "flag", "allow"]);
+var RuleSchema = import_zod.z.object({
+  category: CategorySchema,
+  threshold: import_zod.z.number().min(0).max(1),
+  provider: ProviderNameSchema,
+  action: ActionSchema,
+  priority: import_zod.z.number().optional().default(0),
+  // Custom prompt-based moderation (Pro+ tier only)
+  // When set, uses Gemini Vision for semantic image analysis
+  customPrompt: import_zod.z.string().min(1).max(500).optional(),
+  customCategory: import_zod.z.string().min(1).max(100).optional()
+}).refine(
+  (data) => {
+    const hasPrompt = !!data.customPrompt;
+    const hasCategory = !!data.customCategory;
+    return hasPrompt === hasCategory;
+  },
+  {
+    message: "customPrompt and customCategory must both be set, or both be omitted",
+    path: ["customPrompt"]
+  }
+);
+var OverrideSchema = import_zod.z.object({
+  locale: import_zod.z.string().optional(),
+  region: import_zod.z.string().optional(),
+  data_residency: import_zod.z.string().optional(),
+  provider: ProviderNameSchema.optional()
+});
+var FallbackConfigSchema = import_zod.z.object({
+  provider: ProviderNameSchema,
+  on_timeout: import_zod.z.boolean().optional().default(true),
+  timeout_ms: import_zod.z.number().optional().default(5e3)
+});
+var PolicySchema = import_zod.z.object({
+  name: import_zod.z.string(),
+  version: import_zod.z.string(),
+  rules: import_zod.z.array(RuleSchema),
+  overrides: import_zod.z.array(OverrideSchema).optional(),
+  fallback: FallbackConfigSchema.optional()
+});
+var DecisionSchema = import_zod.z.object({
+  id: import_zod.z.string().uuid(),
+  content: import_zod.z.string(),
+  contentHash: import_zod.z.string(),
+  contentType: ContentTypeSchema,
+  policy: import_zod.z.object({
+    id: import_zod.z.string(),
+    version: import_zod.z.string()
+  }),
+  result: import_zod.z.object({
+    safe: import_zod.z.boolean(),
+    flagged: import_zod.z.boolean(),
+    action: ActionSchema,
+    categories: import_zod.z.array(
+      import_zod.z.object({
+        category: CategorySchema,
+        score: import_zod.z.number(),
+        threshold: import_zod.z.number(),
+        triggered: import_zod.z.boolean()
+      })
+    )
+  }),
+  provider: import_zod.z.object({
+    name: ProviderNameSchema,
+    latency: import_zod.z.number(),
+    cost: import_zod.z.number()
+  }),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional(),
+  timestamp: import_zod.z.string().datetime(),
+  requestId: import_zod.z.string().optional()
+});
+var MultiModalCheckRequestSchema = import_zod.z.object({
+  // Multi-modal content inputs
+  text: import_zod.z.string().max(1e5, "Text exceeds maximum size of 100KB").optional(),
+  images: import_zod.z.array(
+    import_zod.z.string().refine(
+      (val) => {
+        return val.startsWith("http://") || val.startsWith("https://") || val.startsWith("data:image/");
+      },
+      { message: "Images must be URLs or base64 data URIs" }
+    )
+  ).max(10, "Maximum 10 images per request").optional(),
+  video: import_zod.z.string().url("Video must be a valid URL").optional(),
+  // Moderation context
+  context: import_zod.z.object({
+    useCase: UseCaseTypeSchema.default("other"),
+    userId: import_zod.z.string().optional(),
+    userReputation: import_zod.z.number().min(0).max(1).optional(),
+    // 0-1 score
+    locale: import_zod.z.string().optional(),
+    region: import_zod.z.string().optional()
+  }).optional(),
+  // Policy and metadata
+  policyId: import_zod.z.string(),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional(),
+  requestId: import_zod.z.string().optional()
+  // For idempotency
+}).refine(
+  (data) => {
+    return data.text || data.images?.length || data.video;
+  },
+  { message: "At least one of text, images, or video must be provided" }
+);
+var CheckRequestSchema = import_zod.z.object({
+  content: import_zod.z.string().min(1).max(1e5, "Content exceeds maximum size of 100KB"),
+  policyId: import_zod.z.string(),
+  contentType: ContentTypeSchema.optional().default("text"),
+  metadata: import_zod.z.record(import_zod.z.unknown()).optional(),
+  requestId: import_zod.z.string().optional()
+  // For idempotency
+});
+var ContentItemResultSchema = import_zod.z.object({
+  contentType: ContentTypeSchema,
+  contentRef: import_zod.z.string().optional(),
+  // URL or identifier for images/video
+  contentItemId: import_zod.z.string().uuid().optional(),
+  // Database ID for linking evidence
+  safe: import_zod.z.boolean(),
+  flagged: import_zod.z.boolean(),
+  action: ActionSchema,
+  categories: import_zod.z.array(
+    import_zod.z.object({
+      category: CategorySchema,
+      score: import_zod.z.number(),
+      triggered: import_zod.z.boolean()
+    })
+  ),
+  provider: ProviderNameSchema,
+  latency: import_zod.z.number(),
+  cost: import_zod.z.number(),
+  evidence: import_zod.z.object({
+    url: import_zod.z.string().url().optional(),
+    // Signed URL to evidence (screenshot, frame)
+    expiresAt: import_zod.z.string().datetime().optional()
+  }).optional()
+});
+var MultiModalCheckResponseSchema = import_zod.z.object({
+  decisionId: import_zod.z.string().uuid(),
+  safe: import_zod.z.boolean(),
+  // Overall safe if ALL content items are safe
+  flagged: import_zod.z.boolean(),
+  // Overall flagged if ANY content item is flagged
+  action: ActionSchema,
+  // Most severe action across all content
+  results: import_zod.z.array(ContentItemResultSchema),
+  // Per-content-type results
+  totalLatency: import_zod.z.number(),
+  totalCost: import_zod.z.number(),
+  requestId: import_zod.z.string().optional()
+});
+var CheckResponseSchema = import_zod.z.object({
+  decisionId: import_zod.z.string().uuid(),
+  safe: import_zod.z.boolean(),
+  flagged: import_zod.z.boolean(),
+  action: ActionSchema,
+  categories: import_zod.z.array(
+    import_zod.z.object({
+      category: CategorySchema,
+      score: import_zod.z.number(),
+      triggered: import_zod.z.boolean()
+    })
+  ),
+  provider: ProviderNameSchema,
+  latency: import_zod.z.number(),
+  cost: import_zod.z.number(),
+  requestId: import_zod.z.string().optional()
+});
+var ReplayRequestSchema = import_zod.z.object({
+  decisionId: import_zod.z.string().uuid(),
+  policyId: import_zod.z.string()
+});
+var ModerationError = class extends Error {
+  constructor(message, code, statusCode = 500, details) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "ModerationError";
+  }
+};
+var PolicyValidationError = class extends ModerationError {
+  constructor(message, details) {
+    super(message, "POLICY_VALIDATION_ERROR", 400, details);
+    this.name = "PolicyValidationError";
+  }
+};
+var ProviderError = class extends ModerationError {
+  constructor(message, provider, details) {
+    super(message, "PROVIDER_ERROR", 502, { provider, ...details });
+    this.name = "ProviderError";
+  }
+};
+var WebhookEventTypeSchema = import_zod.z.enum([
+  "decision.created",
+  "decision.flagged",
+  "decision.blocked",
+  "policy.created",
+  "policy.updated"
+]);
+var WebhookEndpointSchema = import_zod.z.object({
+  url: import_zod.z.string().url().refine(
+    (url) => {
+      if (process.env.NODE_ENV === "production") {
+        return !url.includes("localhost") && !url.includes("127.0.0.1");
+      }
+      return true;
+    },
+    "Localhost webhooks are not allowed in production"
+  ),
+  events: import_zod.z.array(WebhookEventTypeSchema),
+  description: import_zod.z.string().max(500).optional()
+});
+
+// src/utils.ts
+var import_crypto = __toESM(require("crypto"), 1);
+function hashContent(content) {
+  return import_crypto.default.createHash("sha256").update(content).digest("hex");
+}
+function generateUUID() {
+  return import_crypto.default.randomUUID();
+}
+function generateRequestId() {
+  return `req_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+}
+function calculatePolicyVersion(yaml) {
+  return hashContent(yaml).substring(0, 16);
+}
+function formatCost(cost) {
+  return `$${cost.toFixed(6)}`;
+}
+function formatLatency(ms) {
+  if (ms < 1e3) {
+    return `${ms.toFixed(0)}ms`;
+  }
+  return `${(ms / 1e3).toFixed(2)}s`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionSchema,
+  CategorySchema,
+  CheckRequestSchema,
+  CheckResponseSchema,
+  ContentItemResultSchema,
+  ContentTypeSchema,
+  DecisionSchema,
+  FallbackConfigSchema,
+  ModerationError,
+  MultiModalCheckRequestSchema,
+  MultiModalCheckResponseSchema,
+  OverrideSchema,
+  PolicySchema,
+  PolicyValidationError,
+  ProviderError,
+  ProviderNameSchema,
+  ReplayRequestSchema,
+  RuleSchema,
+  UseCaseTypeSchema,
+  WebhookEndpointSchema,
+  WebhookEventTypeSchema,
+  calculatePolicyVersion,
+  formatCost,
+  formatLatency,
+  generateRequestId,
+  generateUUID,
+  hashContent
+});