botguard 0.1.0

package/dist/client.d.ts

@@ -0,0 +1,40 @@
+import OpenAI from 'openai';
+import { BotGuardConfig, ShieldResult } from './types';
+export declare class BotGuard {
+    private client;
+    private config;
+    chat: ChatNamespace;
+    constructor(config: BotGuardConfig);
+    get openai(): OpenAI;
+    get baseURL(): string;
+    get apiKey(): string;
+    get timeout(): number;
+}
+declare class ChatNamespace {
+    completions: Completions;
+    constructor(guard: BotGuard);
+}
+declare class Completions {
+    private guard;
+    constructor(guard: BotGuard);
+    create(params: {
+        model: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        stream?: false;
+        [key: string]: any;
+    }): Promise<ShieldResult<OpenAI.Chat.ChatCompletion>>;
+    create(params: {
+        model: string;
+        messages: Array<{
+            role: string;
+            content: string;
+        }>;
+        stream: true;
+        [key: string]: any;
+    }): Promise<AsyncIterable<ShieldResult>>;
+    private createStream;
+}
+export {};

package/dist/client.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotGuard = void 0;
+const openai_1 = __importDefault(require("openai"));
+const DEFAULT_API_URL = 'https://agentguard-api-8ae872ce8db9.herokuapp.com';
+function extractShield(data) {
+    const meta = data?._shield || {};
+    return {
+        action: meta.action || 'allowed',
+        reason: meta.reason,
+        confidence: meta.confidence,
+        analysisPath: meta.analysisPath,
+        matchedPatterns: meta.matchedPatterns,
+        piiDetections: meta.piiDetections,
+        guardrailViolation: meta.guardrailViolation,
+        policyViolation: meta.policyViolation,
+        latencyMs: meta.responseTimeMs,
+        blocked: (meta.action || 'allowed') !== 'allowed',
+    };
+}
+class BotGuard {
+    constructor(config) {
+        this.config = {
+            shieldId: config.shieldId,
+            apiKey: config.apiKey,
+            apiUrl: (config.apiUrl || DEFAULT_API_URL).replace(/\/$/, ''),
+            timeout: config.timeout || 120000,
+        };
+        const baseURL = `${this.config.apiUrl}/api/gateway/${this.config.shieldId}/v1`;
+        this.client = new openai_1.default({
+            apiKey: this.config.apiKey,
+            baseURL,
+            timeout: this.config.timeout,
+        });
+        this.chat = new ChatNamespace(this);
+    }
+    get openai() {
+        return this.client;
+    }
+    get baseURL() {
+        return `${this.config.apiUrl}/api/gateway/${this.config.shieldId}/v1`;
+    }
+    get apiKey() {
+        return this.config.apiKey;
+    }
+    get timeout() {
+        return this.config.timeout;
+    }
+}
+exports.BotGuard = BotGuard;
+class ChatNamespace {
+    constructor(guard) {
+        this.completions = new Completions(guard);
+    }
+}
+class Completions {
+    constructor(guard) {
+        this.guard = guard;
+    }
+    async create(params) {
+        if (params.stream) {
+            return this.createStream(params);
+        }
+        const url = `${this.guard.baseURL}/chat/completions`;
+        const { stream: _, ...body } = params;
+        const resp = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.guard.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ ...body, stream: false }),
+            signal: AbortSignal.timeout(this.guard.timeout),
+        });
+        if (!resp.ok) {
+            const errBody = await resp.text();
+            throw new Error(`BotGuard API error (${resp.status}): ${errBody}`);
+        }
+        const data = await resp.json();
+        const shield = extractShield(data);
+        return {
+            response: data,
+            shield,
+            blocked: shield.blocked,
+            content: data?.choices?.[0]?.message?.content || null,
+        };
+    }
+    async createStream(params) {
+        const url = `${this.guard.baseURL}/chat/completions`;
+        const { stream: _, ...body } = params;
+        const resp = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${this.guard.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ ...body, stream: true }),
+            signal: AbortSignal.timeout(this.guard.timeout),
+        });
+        if (!resp.ok) {
+            const errBody = await resp.text();
+            throw new Error(`BotGuard API error (${resp.status}): ${errBody}`);
+        }
+        const reader = resp.body?.getReader();
+        if (!reader) {
+            throw new Error('No response body');
+        }
+        const decoder = new TextDecoder();
+        async function* iterate() {
+            let buffer = '';
+            let shieldVerdict = {
+                action: 'allowed',
+                blocked: false,
+            };
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || '';
+                for (const line of lines) {
+                    if (!line.startsWith('data: '))
+                        continue;
+                    const payload = line.slice(6).trim();
+                    if (payload === '[DONE]')
+                        return;
+                    try {
+                        const chunkData = JSON.parse(payload);
+                        if (chunkData._shield) {
+                            shieldVerdict = extractShield(chunkData);
+                        }
+                        const content = chunkData?.choices?.[0]?.delta?.content || null;
+                        yield {
+                            response: chunkData,
+                            shield: shieldVerdict,
+                            blocked: shieldVerdict.blocked,
+                            content,
+                        };
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+            }
+        }
+        return iterate();
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { BotGuard } from './client';
+export { ShieldResult, ShieldVerdict, BotGuardConfig } from './types';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BotGuard = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "BotGuard", { enumerable: true, get: function () { return client_1.BotGuard; } });

package/dist/types.d.ts

@@ -0,0 +1,27 @@
+export interface ShieldVerdict {
+    action: string;
+    reason?: string;
+    confidence?: number;
+    analysisPath?: string;
+    matchedPatterns?: string[];
+    piiDetections?: Array<{
+        type: string;
+        value: string;
+    }>;
+    guardrailViolation?: string;
+    policyViolation?: string;
+    latencyMs?: number;
+    blocked: boolean;
+}
+export interface ShieldResult<T = any> {
+    response: T;
+    shield: ShieldVerdict;
+    blocked: boolean;
+    content: string | null;
+}
+export interface BotGuardConfig {
+    shieldId: string;
+    apiKey: string;
+    apiUrl?: string;
+    timeout?: number;
+}

package/dist/types.js

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

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "botguard",
+  "version": "0.1.0",
+  "description": "BotGuard SDK — secure your LLM applications with multi-tier threat detection",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["llm", "security", "guardrails", "ai-safety", "prompt-injection", "openai"],
+  "license": "MIT",
+  "peerDependencies": {
+    "openai": ">=4.0.0"
+  },
+  "devDependencies": {
+    "openai": "^4.77.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}