safetygates 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safetygates",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Official SDK for SafetyGates content moderation API",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/index.d.ts

@@ -5,37 +5,41 @@
  * Licensed under the MIT License
  */
 
-export interface GateResult {
-  label: boolean;
-  confidence: number;
+export type StrictnessLevel = 'strict' | 'balanced' | 'permissive';
+
+export interface ClassifyOptions {
+  /** Moderation strictness: 'strict', 'balanced' (default), or 'permissive'. Paid tiers only. */
+  strictness?: StrictnessLevel;
 }
 
 export interface ClassifyResult {
-  results: Record<string, GateResult>;
+  request_id: string;
+  safe: boolean;
+  confidence: number;
+  categories: Record<string, number>;
+  lang: string | null;
+  strictness: StrictnessLevel;
   latency_us: number;
+  watermark: string | null;
+}
+
+export interface BatchItemResult {
+  safe: boolean;
+  categories: Record<string, number>;
+  lang: string | null;
 }
 
 export interface BatchClassifyResult {
-  results: Array<Record<string, GateResult>>;
+  request_id: string;
+  results: BatchItemResult[];
   total_latency_us: number;
   items_per_second: number;
-}
-
-export interface GateInfo {
-  id: string;
-  category: string;
-  description: string;
-  threshold: number;
-}
-
-export interface GatesListResult {
-  gates: GateInfo[];
+  watermark: string | null;
 }
 
 export interface HealthResult {
   status: string;
   gates_loaded: number;
-  available_gates: string[];
 }
 
 export interface SafetyGatesOptions {
@@ -43,19 +47,6 @@ export interface SafetyGatesOptions {
   timeout?: number;
 }
 
-export declare const GATES: {
-  TOXIC: 'toxic';
-  SPAM: 'spam';
-  HATE: 'hate';
-  NSFW: 'nsfw';
-  HARASSMENT: 'harassment';
-  TOXIC_ES: 'toxic_es';
-  SPAM_ES: 'spam_es';
-  HATE_ES: 'hate_es';
-  TOXIC_PT: 'toxic_pt';
-  TOXIC_FR: 'toxic_fr';
-};
-
 export declare class SafetyGatesError extends Error {
   statusCode: number;
   detail: any;
@@ -66,29 +57,25 @@ export declare class SafetyGates {
   constructor(apiKey: string, options?: SafetyGatesOptions);
 
   /**
-   * Classify a single text
+   * Classify text for safety
+   * @param text - Text to classify
+   * @param options - Classification options including strictness
    */
-  classify(text: string, gates?: string[]): Promise<ClassifyResult>;
+  classify(text: string, options?: ClassifyOptions): Promise<ClassifyResult>;
 
   /**
    * Classify multiple texts in batch
+   * @param texts - Array of texts to classify (max 10,000)
+   * @param options - Classification options including strictness
    */
-  classifyBatch(texts: string[], gates?: string[]): Promise<BatchClassifyResult>;
-
-  /**
-   * Check if text is toxic (convenience method)
-   */
-  isToxic(text: string, threshold?: number): Promise<boolean>;
-
-  /**
-   * Check if text is spam (convenience method)
-   */
-  isSpam(text: string, threshold?: number): Promise<boolean>;
+  classifyBatch(texts: string[], options?: ClassifyOptions): Promise<BatchClassifyResult>;
 
   /**
-   * Get available gates
+   * Check if text is safe (convenience method)
+   * @param text - Text to check
+   * @param options - Classification options including strictness
    */
-  listGates(): Promise<GatesListResult>;
+  isSafe(text: string, options?: ClassifyOptions): Promise<boolean>;
 
   /**
    * Health check

package/src/index.js

@@ -20,26 +20,6 @@ const http = require('http');
 const DEFAULT_BASE_URL = 'https://sg-api.cyclecore.ai';
 const DEFAULT_TIMEOUT = 10000;
 
-/**
- * Available classification gates
- */
-const GATES = {
-  // English
-  TOXIC: 'toxic',
-  SPAM: 'spam',
-  HATE: 'hate',
-  NSFW: 'nsfw',
-  HARASSMENT: 'harassment',
-  // Spanish
-  TOXIC_ES: 'toxic_es',
-  SPAM_ES: 'spam_es',
-  HATE_ES: 'hate_es',
-  // Portuguese
-  TOXIC_PT: 'toxic_pt',
-  // French
-  TOXIC_FR: 'toxic_fr',
-};
-
 class SafetyGatesError extends Error {
   constructor(message, statusCode, detail) {
     super(message);
@@ -84,7 +64,7 @@ class SafetyGates {
         headers: {
           'Content-Type': 'application/json',
           'X-API-Key': this.apiKey,
-          'User-Agent': 'safetygates-node/1.0.0',
+          'User-Agent': 'safetygates-node/1.1.0',
         },
         timeout: this.timeout,
       };
@@ -129,87 +109,83 @@ class SafetyGates {
   /**
    * Classify a single text
    * @param {string} text - Text to classify
-   * @param {string[]} gates - Gates to check (default: ['toxic'])
+   * @param {Object} options - Classification options
+   * @param {string} options.strictness - 'strict', 'balanced' (default), or 'permissive' (paid tiers only)
    * @returns {Promise<ClassifyResult>}
    *
    * @example
-   * const result = await client.classify('you suck', ['toxic', 'harassment']);
-   * console.log(result.results.toxic.label); // true
-   * console.log(result.results.toxic.confidence); // 0.92
+   * const result = await client.classify('you suck');
+   * console.log(result.safe);        // false
+   * console.log(result.confidence);  // 0.92
+   *
+   * // With strictness (paid tiers only)
+   * const strict = await client.classify('borderline content', { strictness: 'strict' });
    */
-  async classify(text, gates = ['toxic']) {
+  async classify(text, options = {}) {
     if (!text || typeof text !== 'string') {
       throw new Error('Text must be a non-empty string');
     }
-    if (!Array.isArray(gates) || gates.length === 0) {
-      throw new Error('Gates must be a non-empty array');
+
+    const body = { text };
+    if (options.strictness) {
+      body.strictness = options.strictness;
     }
 
-    return this._request('POST', '/v1/classify', { text, gates });
+    return this._request('POST', '/v1/classify', body);
   }
 
   /**
    * Classify multiple texts in batch
    * @param {string[]} texts - Array of texts to classify (max 10,000)
-   * @param {string[]} gates - Gates to check (default: ['toxic'])
+   * @param {Object} options - Classification options
+   * @param {string} options.strictness - 'strict', 'balanced' (default), or 'permissive' (paid tiers only)
    * @returns {Promise<BatchClassifyResult>}
    *
    * @example
-   * const result = await client.classifyBatch(
-   *   ['hello', 'you suck', 'nice game'],
-   *   ['toxic']
-   * );
+   * const result = await client.classifyBatch(['hello', 'you suck', 'nice game']);
    * result.results.forEach((r, i) => {
-   *   console.log(`Text ${i}: toxic=${r.toxic.label}`);
+   *   console.log(`Text ${i}: safe=${r.safe}`);
    * });
+   *
+   * // With strictness (paid tiers only)
+   * const strict = await client.classifyBatch(texts, { strictness: 'strict' });
    */
-  async classifyBatch(texts, gates = ['toxic']) {
+  async classifyBatch(texts, options = {}) {
     if (!Array.isArray(texts) || texts.length === 0) {
       throw new Error('Texts must be a non-empty array');
     }
     if (texts.length > 10000) {
       throw new Error('Batch size cannot exceed 10,000');
     }
-    if (!Array.isArray(gates) || gates.length === 0) {
-      throw new Error('Gates must be a non-empty array');
+
+    const body = { texts };
+    if (options.strictness) {
+      body.strictness = options.strictness;
     }
 
-    return this._request('POST', '/v1/classify/batch', { texts, gates });
+    return this._request('POST', '/v1/classify/batch', body);
   }
 
   /**
-   * Check if text is toxic (convenience method)
+   * Check if text is safe (convenience method)
    * @param {string} text - Text to check
-   * @param {number} threshold - Confidence threshold (default: 0.5)
+   * @param {Object} options - Classification options
+   * @param {string} options.strictness - 'strict', 'balanced' (default), or 'permissive' (paid tiers only)
    * @returns {Promise<boolean>}
    *
    * @example
-   * if (await client.isToxic('you suck')) {
-   *   console.log('Blocked toxic message');
+   * if (await client.isSafe('hello world')) {
+   *   console.log('Content is safe');
+   * }
+   *
+   * // With strict moderation
+   * if (await client.isSafe(userInput, { strictness: 'strict' })) {
+   *   // Allow content
    * }
    */
-  async isToxic(text, threshold = 0.5) {
-    const result = await this.classify(text, ['toxic']);
-    return result.results.toxic.confidence >= threshold;
-  }
-
-  /**
-   * Check if text is spam (convenience method)
-   * @param {string} text - Text to check
-   * @param {number} threshold - Confidence threshold (default: 0.5)
-   * @returns {Promise<boolean>}
-   */
-  async isSpam(text, threshold = 0.5) {
-    const result = await this.classify(text, ['spam']);
-    return result.results.spam.confidence >= threshold;
-  }
-
-  /**
-   * Get available gates
-   * @returns {Promise<GatesListResult>}
-   */
-  async listGates() {
-    return this._request('GET', '/v1/gates');
+  async isSafe(text, options = {}) {
+    const result = await this.classify(text, options);
+    return result.safe;
   }
 
   /**
@@ -221,8 +197,7 @@ class SafetyGates {
   }
 }
 
-// Export class and constants
+// Export class
 module.exports = SafetyGates;
 module.exports.SafetyGates = SafetyGates;
 module.exports.SafetyGatesError = SafetyGatesError;
-module.exports.GATES = GATES;