safetygates 0.1.1 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "safetygates",
-  "version": "0.1.1",
+  "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,29 +5,36 @@
  * Licensed under the MIT License
  */
 
+export type StrictnessLevel = 'strict' | 'balanced' | 'permissive';
+
+export interface ClassifyOptions {
+  /** Moderation strictness: 'strict', 'balanced' (default), or 'permissive'. Paid tiers only. */
+  strictness?: StrictnessLevel;
+}
+
 export interface ClassifyResult {
+  request_id: string;
   safe: boolean;
   confidence: number;
-  categories: {
-    toxic: number;
-    spam: number;
-    hate: number;
-    nsfw: number;
-    harassment: 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<{
-    toxic: number;
-    spam: number;
-    hate: number;
-    nsfw: number;
-    harassment: number;
-  }>;
+  request_id: string;
+  results: BatchItemResult[];
   total_latency_us: number;
   items_per_second: number;
+  watermark: string | null;
 }
 
 export interface HealthResult {
@@ -51,18 +58,24 @@ export declare class SafetyGates {
 
   /**
    * Classify text for safety
+   * @param text - Text to classify
+   * @param options - Classification options including strictness
    */
-  classify(text: 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[]): Promise<BatchClassifyResult>;
+  classifyBatch(texts: string[], options?: ClassifyOptions): Promise<BatchClassifyResult>;
 
   /**
    * Check if text is safe (convenience method)
+   * @param text - Text to check
+   * @param options - Classification options including strictness
    */
-  isSafe(text: string): Promise<boolean>;
+  isSafe(text: string, options?: ClassifyOptions): Promise<boolean>;
 
   /**
    * Health check

package/src/index.js

@@ -64,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,
       };
@@ -109,24 +109,36 @@ class SafetyGates {
   /**
    * Classify a single text
    * @param {string} text - Text to classify
+   * @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');
    * 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) {
+  async classify(text, options = {}) {
     if (!text || typeof text !== 'string') {
       throw new Error('Text must be a non-empty string');
     }
 
-    return this._request('POST', '/v1/classify', { text });
+    const body = { text };
+    if (options.strictness) {
+      body.strictness = options.strictness;
+    }
+
+    return this._request('POST', '/v1/classify', body);
   }
 
   /**
    * Classify multiple texts in batch
    * @param {string[]} texts - Array of texts to classify (max 10,000)
+   * @param {Object} options - Classification options
+   * @param {string} options.strictness - 'strict', 'balanced' (default), or 'permissive' (paid tiers only)
    * @returns {Promise<BatchClassifyResult>}
    *
    * @example
@@ -134,8 +146,11 @@ class SafetyGates {
    * result.results.forEach((r, i) => {
    *   console.log(`Text ${i}: safe=${r.safe}`);
    * });
+   *
+   * // With strictness (paid tiers only)
+   * const strict = await client.classifyBatch(texts, { strictness: 'strict' });
    */
-  async classifyBatch(texts) {
+  async classifyBatch(texts, options = {}) {
     if (!Array.isArray(texts) || texts.length === 0) {
       throw new Error('Texts must be a non-empty array');
     }
@@ -143,21 +158,33 @@ class SafetyGates {
       throw new Error('Batch size cannot exceed 10,000');
     }
 
-    return this._request('POST', '/v1/classify/batch', { texts });
+    const body = { texts };
+    if (options.strictness) {
+      body.strictness = options.strictness;
+    }
+
+    return this._request('POST', '/v1/classify/batch', body);
   }
 
   /**
    * Check if text is safe (convenience method)
    * @param {string} text - Text to check
+   * @param {Object} options - Classification options
+   * @param {string} options.strictness - 'strict', 'balanced' (default), or 'permissive' (paid tiers only)
    * @returns {Promise<boolean>}
    *
    * @example
    * if (await client.isSafe('hello world')) {
    *   console.log('Content is safe');
    * }
+   *
+   * // With strict moderation
+   * if (await client.isSafe(userInput, { strictness: 'strict' })) {
+   *   // Allow content
+   * }
    */
-  async isSafe(text) {
-    const result = await this.classify(text);
+  async isSafe(text, options = {}) {
+    const result = await this.classify(text, options);
     return result.safe;
   }