safetygates 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safetygates",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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,34 @@
  * Licensed under the MIT License
  */
 
-export interface GateResult {
-  label: boolean;
-  confidence: number;
-}
-
 export interface ClassifyResult {
-  results: Record<string, GateResult>;
+  safe: boolean;
+  confidence: number;
+  categories: {
+    toxic: number;
+    spam: number;
+    hate: number;
+    nsfw: number;
+    harassment: number;
+  };
   latency_us: number;
 }
 
 export interface BatchClassifyResult {
-  results: Array<Record<string, GateResult>>;
+  results: Array<{
+    toxic: number;
+    spam: number;
+    hate: number;
+    nsfw: number;
+    harassment: number;
+  }>;
   total_latency_us: number;
   items_per_second: number;
 }
 
-export interface GateInfo {
-  id: string;
-  category: string;
-  description: string;
-  threshold: number;
-}
-
-export interface GatesListResult {
-  gates: GateInfo[];
-}
-
 export interface HealthResult {
   status: string;
   gates_loaded: number;
-  available_gates: string[];
 }
 
 export interface SafetyGatesOptions {
@@ -43,19 +40,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 +50,19 @@ export declare class SafetyGates {
   constructor(apiKey: string, options?: SafetyGatesOptions);
 
   /**
-   * Classify a single text
+   * Classify text for safety
    */
-  classify(text: string, gates?: string[]): Promise<ClassifyResult>;
+  classify(text: string): Promise<ClassifyResult>;
 
   /**
    * Classify multiple texts in batch
    */
-  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[]): Promise<BatchClassifyResult>;
 
   /**
-   * Get available gates
+   * Check if text is safe (convenience method)
    */
-  listGates(): Promise<GatesListResult>;
+  isSafe(text: string): 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);
@@ -129,87 +109,56 @@ class SafetyGates {
   /**
    * Classify a single text
    * @param {string} text - Text to classify
-   * @param {string[]} gates - Gates to check (default: ['toxic'])
    * @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
    */
-  async classify(text, gates = ['toxic']) {
+  async classify(text) {
     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');
-    }
 
-    return this._request('POST', '/v1/classify', { text, gates });
+    return this._request('POST', '/v1/classify', { text });
   }
 
   /**
    * Classify multiple texts in batch
    * @param {string[]} texts - Array of texts to classify (max 10,000)
-   * @param {string[]} gates - Gates to check (default: ['toxic'])
    * @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}`);
    * });
    */
-  async classifyBatch(texts, gates = ['toxic']) {
+  async classifyBatch(texts) {
     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');
-    }
 
-    return this._request('POST', '/v1/classify/batch', { texts, gates });
+    return this._request('POST', '/v1/classify/batch', { texts });
   }
 
   /**
-   * 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)
    * @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');
    * }
    */
-  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) {
+    const result = await this.classify(text);
+    return result.safe;
   }
 
   /**
@@ -221,8 +170,7 @@ class SafetyGates {
   }
 }
 
-// Export class and constants
+// Export class
 module.exports = SafetyGates;
 module.exports.SafetyGates = SafetyGates;
 module.exports.SafetyGatesError = SafetyGatesError;
-module.exports.GATES = GATES;