@driftgard/node 1.0.0

package/README.md

@@ -0,0 +1,79 @@
+# @driftgard/node
+
+Official Node.js SDK for [Driftgard](https://driftgard.com) — evaluate LLM interactions against your compliance policy.
+
+## Install
+
+```bash
+npm install @driftgard/node
+```
+
+## Quick start
+
+```typescript
+import { Driftgard } from "@driftgard/node";
+
+const dg = new Driftgard({
+  apiKey: process.env.DRIFTGARD_API_KEY,
+});
+
+const result = await dg.evaluate({
+  project_id: "your-project-id",
+  prompt: "What stocks should I buy?",
+  response: "Based on current trends, you should invest in...",
+  model_id: "gpt-4o",
+});
+
+if (result.evaluation.allowed) {
+  console.log("Safe to return to user");
+} else {
+  console.log("Blocked:", result.evaluation.violations);
+}
+```
+
+## Features
+
+- Single `evaluate()` method — send prompt/response, get verdict
+- Auto-retry with exponential backoff on 5xx and network errors
+- Typed errors: `AuthError`, `RateLimitError`, `FeatureNotAvailableError`
+- Full TypeScript types for requests and responses
+- Zero dependencies (uses native `fetch`)
+
+## Configuration
+
+```typescript
+const dg = new Driftgard({
+  apiKey: "your-api-key",       // required
+  baseUrl: "https://api.driftgard.com", // optional
+  timeout: 30000,               // optional, ms (default 30s)
+  maxRetries: 2,                // optional (default 2)
+});
+```
+
+## Error handling
+
+```typescript
+import { Driftgard, AuthError, RateLimitError, FeatureNotAvailableError } from "@driftgard/node";
+
+try {
+  const result = await dg.evaluate({ ... });
+} catch (e) {
+  if (e instanceof AuthError) {
+    // Invalid or revoked API key (401)
+  } else if (e instanceof RateLimitError) {
+    // Too many requests (429)
+  } else if (e instanceof FeatureNotAvailableError) {
+    // API evaluate requires Compliance+ tier (403)
+  }
+}
+```
+
+## Requirements
+
+- Node.js 18+ (uses native `fetch`)
+- API key from Driftgard (Settings → API Keys)
+- Compliance or Enterprise tier for API evaluation
+
+## License
+
+MIT

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export declare class DriftgardError extends Error {
+    status: number;
+    code: string;
+    constructor(message: string, status: number, code: string);
+}
+export declare class AuthError extends DriftgardError {
+    constructor(message?: string);
+}
+export declare class RateLimitError extends DriftgardError {
+    constructor(message?: string);
+}
+export declare class FeatureNotAvailableError extends DriftgardError {
+    tier: string;
+    constructor(message?: string, tier?: string);
+}

package/dist/errors.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureNotAvailableError = exports.RateLimitError = exports.AuthError = exports.DriftgardError = void 0;
+class DriftgardError extends Error {
+    constructor(message, status, code) {
+        super(message);
+        this.name = "DriftgardError";
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.DriftgardError = DriftgardError;
+class AuthError extends DriftgardError {
+    constructor(message = "Invalid or missing API key") {
+        super(message, 401, "unauthorized");
+        this.name = "AuthError";
+    }
+}
+exports.AuthError = AuthError;
+class RateLimitError extends DriftgardError {
+    constructor(message = "Rate limit exceeded") {
+        super(message, 429, "rate_limited");
+        this.name = "RateLimitError";
+    }
+}
+exports.RateLimitError = RateLimitError;
+class FeatureNotAvailableError extends DriftgardError {
+    constructor(message = "Feature not available on your current plan", tier = "unknown") {
+        super(message, 403, "feature_not_available");
+        this.name = "FeatureNotAvailableError";
+        this.tier = tier;
+    }
+}
+exports.FeatureNotAvailableError = FeatureNotAvailableError;

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+import { DriftgardConfig, EvaluateRequest, EvaluateResponse } from "./types";
+export { DriftgardConfig, EvaluateRequest, EvaluateResponse } from "./types";
+export { Violation, EvaluationResult, HitlInfo } from "./types";
+export { DriftgardError, AuthError, RateLimitError, FeatureNotAvailableError } from "./errors";
+export declare class Driftgard {
+    private apiKey;
+    private baseUrl;
+    private timeout;
+    private maxRetries;
+    constructor(config: DriftgardConfig);
+    /**
+     * Evaluate a prompt/response pair against your active control pack.
+     */
+    evaluate(req: EvaluateRequest): Promise<EvaluateResponse>;
+    private post;
+    private delay;
+}
+export default Driftgard;

package/dist/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Driftgard = exports.FeatureNotAvailableError = exports.RateLimitError = exports.AuthError = exports.DriftgardError = void 0;
+const errors_1 = require("./errors");
+var errors_2 = require("./errors");
+Object.defineProperty(exports, "DriftgardError", { enumerable: true, get: function () { return errors_2.DriftgardError; } });
+Object.defineProperty(exports, "AuthError", { enumerable: true, get: function () { return errors_2.AuthError; } });
+Object.defineProperty(exports, "RateLimitError", { enumerable: true, get: function () { return errors_2.RateLimitError; } });
+Object.defineProperty(exports, "FeatureNotAvailableError", { enumerable: true, get: function () { return errors_2.FeatureNotAvailableError; } });
+const DEFAULT_BASE_URL = "https://api.driftgard.com";
+const DEFAULT_TIMEOUT = 30000;
+const DEFAULT_MAX_RETRIES = 2;
+const RETRY_DELAY_MS = 500;
+class Driftgard {
+    constructor(config) {
+        if (!config.apiKey)
+            throw new Error("apiKey is required");
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+    }
+    /**
+     * Evaluate a prompt/response pair against your active control pack.
+     */
+    async evaluate(req) {
+        return this.post("/audit/evaluate", {
+            project_id: req.project_id,
+            prompt: req.prompt,
+            response: req.response,
+            model_id: req.model_id,
+            timestamp: req.timestamp || new Date().toISOString(),
+        });
+    }
+    async post(path, body, attempt = 0) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeout);
+        try {
+            const res = await fetch(`${this.baseUrl}${path}`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": this.apiKey,
+                },
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            if (res.status === 401)
+                throw new errors_1.AuthError();
+            if (res.status === 429)
+                throw new errors_1.RateLimitError();
+            if (res.status === 403) {
+                const payload = await res.json().catch(() => ({}));
+                if (payload?.error === "feature_not_available") {
+                    throw new errors_1.FeatureNotAvailableError(payload.message, payload.tier);
+                }
+                throw new errors_1.DriftgardError(payload?.message || "Forbidden", 403, "forbidden");
+            }
+            // Retry on 5xx
+            if (res.status >= 500 && attempt < this.maxRetries) {
+                await this.delay(RETRY_DELAY_MS * Math.pow(2, attempt));
+                return this.post(path, body, attempt + 1);
+            }
+            const payload = await res.json();
+            if (!res.ok) {
+                throw new errors_1.DriftgardError(payload?.message || payload?.error || "Request failed", res.status, payload?.error || "unknown");
+            }
+            return payload;
+        }
+        catch (e) {
+            if (e instanceof errors_1.DriftgardError)
+                throw e;
+            // Network error — retry
+            if (attempt < this.maxRetries) {
+                await this.delay(RETRY_DELAY_MS * Math.pow(2, attempt));
+                return this.post(path, body, attempt + 1);
+            }
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new errors_1.DriftgardError(msg, 0, "network_error");
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    delay(ms) {
+        return new Promise((r) => setTimeout(r, ms));
+    }
+}
+exports.Driftgard = Driftgard;
+exports.default = Driftgard;

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+export interface DriftgardConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    maxRetries?: number;
+}
+export interface EvaluateRequest {
+    project_id: string;
+    prompt: string;
+    response: string;
+    model_id: string;
+    timestamp?: string;
+}
+export interface Violation {
+    clause_id?: string;
+    severity?: string;
+    category?: string;
+    reason?: string;
+    matched_pattern?: string;
+}
+export interface EvaluationResult {
+    allowed: boolean;
+    risk_score: number;
+    violations: Violation[];
+    flags?: {
+        pii_detected?: boolean;
+        pii_in_prompt?: boolean;
+        meta_bypass_detected?: boolean;
+        judge_used?: boolean;
+        judge_called?: boolean;
+        action_blocked?: boolean;
+        hard_blocked?: boolean;
+    };
+}
+export interface HitlInfo {
+    queued: boolean;
+    hitl_id?: string;
+    selection_mode?: string;
+    selection_reasons?: string[];
+}
+export interface EvaluateResponse {
+    ok: boolean;
+    project_id: string;
+    evaluation_id: string;
+    active_control_pack_id: string;
+    active_control_pack_version: number;
+    data_mode: string;
+    telemetry_mode: string;
+    hitl: HitlInfo;
+    evaluation: EvaluationResult;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@driftgard/node",
+  "version": "1.0.0",
+  "description": "Official Driftgard Node.js SDK — evaluate LLM interactions against your compliance policy",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist", "README.md"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["driftgard", "ai", "compliance", "guardrails", "llm", "evaluation", "policy", "audit"],
+  "author": "Driftgard <support@driftgard.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/driftgard/driftgard-sdk-node"
+  },
+  "homepage": "https://driftgard.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}