qwed-open-responses 0.1.0

package/README.md

@@ -0,0 +1,135 @@
+# QWED Open Responses (Node.js)
+
+[![npm version](https://badge.fury.io/js/qwed-open-responses.svg)](https://badge.fury.io/js/qwed-open-responses)
+[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+**Verification guards for AI agent outputs in Node.js/Express applications.**
+
+## Installation
+
+```bash
+npm install qwed-open-responses
+```
+
+## Quick Start
+
+```typescript
+import express from 'express';
+import { createQWEDMiddleware, ToolGuard, SafetyGuard } from 'qwed-open-responses';
+
+const app = express();
+app.use(express.json());
+
+// Add verification middleware
+app.use(createQWEDMiddleware({
+  guards: [new ToolGuard(), new SafetyGuard()],
+  blockOnFailure: true,
+}));
+
+app.post('/api/agent', (req, res) => {
+  // Response will be verified before sending
+  res.json({
+    tool_calls: [
+      { name: 'search', arguments: { query: 'weather' } }
+    ]
+  });
+});
+```
+
+## Guards
+
+### ToolGuard
+
+Blocks dangerous tool calls.
+
+```typescript
+const guard = new ToolGuard({
+  blockedTools: ['execute_shell', 'delete_file'],
+  allowedTools: ['search', 'calculator'], // Whitelist mode
+});
+```
+
+### SafetyGuard
+
+Detects PII and prompt injection.
+
+```typescript
+const guard = new SafetyGuard({
+  checkPii: true,
+  checkInjection: true,
+});
+```
+
+### SchemaGuard
+
+Validates JSON structure.
+
+```typescript
+const guard = new SchemaGuard({
+  type: 'object',
+  required: ['name', 'age'],
+});
+```
+
+### MathGuard
+
+Verifies calculations.
+
+```typescript
+const guard = new MathGuard({ tolerance: 0.01 });
+```
+
+## Middleware Options
+
+```typescript
+createQWEDMiddleware({
+  guards: [],              // Guards to apply
+  blockOnFailure: true,    // Block failed responses
+  verbose: false,          // Log verification results
+  skipPaths: ['/health'],  // Paths to skip
+  onError: (result, req, res) => {
+    // Custom error handler
+  },
+});
+```
+
+## Verify Request Bodies
+
+```typescript
+import { verifyRequestBody, ToolGuard } from 'qwed-open-responses';
+
+app.post('/api/execute',
+  verifyRequestBody({ guards: [new ToolGuard()] }),
+  (req, res) => {
+    // Request body is verified
+  }
+);
+```
+
+## Direct Verification
+
+```typescript
+import { ResponseVerifier, ToolGuard } from 'qwed-open-responses';
+
+const verifier = new ResponseVerifier([new ToolGuard()]);
+
+const result = verifier.verify({
+  tool_calls: [{ name: 'search', arguments: {} }]
+});
+
+if (result.verified) {
+  console.log('✅ Safe to execute');
+} else {
+  console.log('❌ Blocked:', result.blockReason);
+}
+```
+
+## Links
+
+- **GitHub:** [QWED-AI/qwed-open-responses](https://github.com/QWED-AI/qwed-open-responses)
+- **PyPI (Python):** [qwed-open-responses](https://pypi.org/project/qwed-open-responses/)
+- **Docs:** [docs.qwedai.com](https://docs.qwedai.com/docs/open-responses/overview)
+
+## License
+
+Apache 2.0

package/dist/guards.d.ts

@@ -0,0 +1,73 @@
+/**
+ * QWED Open Responses - Guards
+ */
+import { GuardResult, ParsedResponse } from './types';
+/**
+ * Base class for all guards.
+ */
+export declare abstract class BaseGuard {
+    abstract name: string;
+    abstract description: string;
+    abstract check(response: ParsedResponse, context?: Record<string, any>): GuardResult;
+    protected passResult(message?: string, details?: Record<string, any>): GuardResult;
+    protected failResult(message: string, details?: Record<string, any>, severity?: 'error' | 'warning'): GuardResult;
+}
+/**
+ * Tool Guard - Blocks dangerous tool calls.
+ */
+export declare class ToolGuard extends BaseGuard {
+    name: string;
+    description: string;
+    private blockedTools;
+    private allowedTools;
+    private dangerousPatterns;
+    private static DEFAULT_BLOCKED_TOOLS;
+    private static DEFAULT_DANGEROUS_PATTERNS;
+    constructor(options?: {
+        blockedTools?: string[];
+        allowedTools?: string[];
+        useDefaultBlocklist?: boolean;
+        dangerousPatterns?: RegExp[];
+    });
+    check(response: ParsedResponse, context?: Record<string, any>): GuardResult;
+    private extractToolCalls;
+}
+/**
+ * Schema Guard - Validates JSON schema.
+ */
+export declare class SchemaGuard extends BaseGuard {
+    name: string;
+    description: string;
+    private schema;
+    constructor(schema: Record<string, any>);
+    check(response: ParsedResponse, context?: Record<string, any>): GuardResult;
+}
+/**
+ * Safety Guard - Comprehensive safety checks.
+ */
+export declare class SafetyGuard extends BaseGuard {
+    name: string;
+    description: string;
+    private checkPii;
+    private checkInjection;
+    private static PII_PATTERNS;
+    private static INJECTION_PATTERNS;
+    constructor(options?: {
+        checkPii?: boolean;
+        checkInjection?: boolean;
+    });
+    check(response: ParsedResponse, context?: Record<string, any>): GuardResult;
+    private extractContent;
+}
+/**
+ * Math Guard - Verifies calculations.
+ */
+export declare class MathGuard extends BaseGuard {
+    name: string;
+    description: string;
+    private tolerance;
+    constructor(options?: {
+        tolerance?: number;
+    });
+    check(response: ParsedResponse, context?: Record<string, any>): GuardResult;
+}

package/dist/guards.js

@@ -0,0 +1,228 @@
+"use strict";
+/**
+ * QWED Open Responses - Guards
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathGuard = exports.SafetyGuard = exports.SchemaGuard = exports.ToolGuard = exports.BaseGuard = void 0;
+/**
+ * Base class for all guards.
+ */
+class BaseGuard {
+    passResult(message, details) {
+        return {
+            guardName: this.name,
+            passed: true,
+            message: message || `${this.name} passed`,
+            details,
+            severity: 'info',
+        };
+    }
+    failResult(message, details, severity = 'error') {
+        return {
+            guardName: this.name,
+            passed: false,
+            message,
+            details,
+            severity,
+        };
+    }
+}
+exports.BaseGuard = BaseGuard;
+/**
+ * Tool Guard - Blocks dangerous tool calls.
+ */
+class ToolGuard extends BaseGuard {
+    constructor(options = {}) {
+        super();
+        this.name = 'ToolGuard';
+        this.description = 'Validates tool calls for safety';
+        const { blockedTools = [], allowedTools, useDefaultBlocklist = true, dangerousPatterns = [], } = options;
+        this.blockedTools = new Set(blockedTools);
+        if (useDefaultBlocklist) {
+            ToolGuard.DEFAULT_BLOCKED_TOOLS.forEach(t => this.blockedTools.add(t));
+        }
+        this.allowedTools = allowedTools ? new Set(allowedTools) : null;
+        this.dangerousPatterns = [
+            ...ToolGuard.DEFAULT_DANGEROUS_PATTERNS,
+            ...dangerousPatterns,
+        ];
+    }
+    check(response, context) {
+        const toolCalls = this.extractToolCalls(response);
+        if (toolCalls.length === 0) {
+            return this.passResult('No tool calls to verify');
+        }
+        for (const call of toolCalls) {
+            const toolName = call.toolName || call.tool_name || call.name || 'unknown';
+            const args = call.arguments || {};
+            // Check blocked list
+            if (this.blockedTools.has(toolName)) {
+                return this.failResult(`BLOCKED: Tool '${toolName}' is not allowed`, { blockedTool: toolName });
+            }
+            // Check allowed list (whitelist mode)
+            if (this.allowedTools && !this.allowedTools.has(toolName)) {
+                return this.failResult(`BLOCKED: Tool '${toolName}' is not in allowed list`, {
+                    tool: toolName,
+                    allowed: Array.from(this.allowedTools),
+                });
+            }
+            // Check dangerous patterns
+            const argsStr = JSON.stringify(args);
+            for (const pattern of this.dangerousPatterns) {
+                if (pattern.test(argsStr)) {
+                    return this.failResult('BLOCKED: Dangerous pattern detected in tool arguments', {
+                        tool: toolName,
+                        pattern: pattern.source,
+                    });
+                }
+            }
+        }
+        return this.passResult(`All ${toolCalls.length} tool call(s) verified`);
+    }
+    extractToolCalls(response) {
+        const calls = [];
+        if (response.type === 'tool_call') {
+            calls.push(response);
+        }
+        if (response.toolCalls || response.tool_calls) {
+            calls.push(...(response.toolCalls || response.tool_calls || []));
+        }
+        return calls;
+    }
+}
+exports.ToolGuard = ToolGuard;
+ToolGuard.DEFAULT_BLOCKED_TOOLS = new Set([
+    'execute_shell', 'shell', 'bash', 'cmd', 'exec', 'eval',
+    'delete_file', 'remove_file', 'write_file', 'modify_file',
+    'send_email', 'transfer_money', 'make_payment',
+]);
+ToolGuard.DEFAULT_DANGEROUS_PATTERNS = [
+    /DROP\s+TABLE/i,
+    /DELETE\s+FROM/i,
+    /TRUNCATE\s+TABLE/i,
+    /rm\s+-rf/i,
+    /rmdir\s+\/s/i,
+    /eval\s*\(/i,
+    /exec\s*\(/i,
+    /__import__/i,
+];
+/**
+ * Schema Guard - Validates JSON schema.
+ */
+class SchemaGuard extends BaseGuard {
+    constructor(schema) {
+        super();
+        this.name = 'SchemaGuard';
+        this.description = 'Validates response against JSON Schema';
+        this.schema = schema;
+    }
+    check(response, context) {
+        const data = response.output || response;
+        // Basic type checking (full JSON Schema validation would need ajv)
+        if (this.schema.type === 'object' && typeof data !== 'object') {
+            return this.failResult('Expected object type');
+        }
+        if (this.schema.required) {
+            const missing = this.schema.required.filter((field) => !(field in data));
+            if (missing.length > 0) {
+                return this.failResult(`Missing required fields: ${missing.join(', ')}`, { missing });
+            }
+        }
+        return this.passResult('Schema validation passed');
+    }
+}
+exports.SchemaGuard = SchemaGuard;
+/**
+ * Safety Guard - Comprehensive safety checks.
+ */
+class SafetyGuard extends BaseGuard {
+    constructor(options = {}) {
+        super();
+        this.name = 'SafetyGuard';
+        this.description = 'Comprehensive safety checks';
+        this.checkPii = options.checkPii ?? true;
+        this.checkInjection = options.checkInjection ?? true;
+    }
+    check(response, context) {
+        const content = this.extractContent(response);
+        const issues = [];
+        if (this.checkPii) {
+            for (const [type, pattern] of Object.entries(SafetyGuard.PII_PATTERNS)) {
+                if (pattern.test(content)) {
+                    issues.push(`PII detected: ${type}`);
+                }
+            }
+        }
+        if (this.checkInjection) {
+            for (const pattern of SafetyGuard.INJECTION_PATTERNS) {
+                if (pattern.test(content)) {
+                    return this.failResult('BLOCKED: Prompt injection detected', { pattern: pattern.source });
+                }
+            }
+        }
+        if (issues.length > 0) {
+            return this.failResult(`Safety issues detected: ${issues.join(', ')}`, { issues }, 'warning');
+        }
+        return this.passResult('All safety checks passed');
+    }
+    extractContent(response) {
+        const parts = [];
+        if (typeof response.content === 'string')
+            parts.push(response.content);
+        if (typeof response.output === 'string')
+            parts.push(response.output);
+        if (typeof response.text === 'string')
+            parts.push(response.text);
+        if (typeof response.output === 'object')
+            parts.push(JSON.stringify(response.output));
+        if (response.arguments)
+            parts.push(JSON.stringify(response.arguments));
+        return parts.join(' ');
+    }
+}
+exports.SafetyGuard = SafetyGuard;
+SafetyGuard.PII_PATTERNS = {
+    email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/,
+    phone: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/,
+    ssn: /\b\d{3}-\d{2}-\d{4}\b/,
+    creditCard: /\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/,
+};
+SafetyGuard.INJECTION_PATTERNS = [
+    /ignore\s+(previous|all|above)\s+(instructions?|prompts?)/i,
+    /disregard\s+(previous|all|above)/i,
+    /forget\s+(everything|all|your\s+instructions)/i,
+    /you\s+are\s+now\s+/i,
+    /pretend\s+(you|to\s+be)/i,
+];
+/**
+ * Math Guard - Verifies calculations.
+ */
+class MathGuard extends BaseGuard {
+    constructor(options = {}) {
+        super();
+        this.name = 'MathGuard';
+        this.description = 'Verifies mathematical calculations';
+        this.tolerance = options.tolerance ?? 0.01;
+    }
+    check(response, context) {
+        const data = response.output || response;
+        if (typeof data !== 'object') {
+            return this.passResult('No calculations to verify');
+        }
+        // Check common total patterns
+        if ('total' in data && 'subtotal' in data) {
+            const subtotal = Number(data.subtotal) || 0;
+            const tax = Number(data.tax) || 0;
+            const shipping = Number(data.shipping) || 0;
+            const discount = Number(data.discount) || 0;
+            const total = Number(data.total);
+            const expected = subtotal + tax + shipping - discount;
+            if (Math.abs(expected - total) > this.tolerance) {
+                return this.failResult(`Total mismatch: expected ${expected}, got ${total}`, { expected, actual: total });
+            }
+        }
+        return this.passResult('Math verification passed');
+    }
+}
+exports.MathGuard = MathGuard;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guards.js","sourceRoot":"","sources":["../src/guards.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QWED Open Responses - Guards\n */\n\nimport { GuardResult, ParsedResponse } from './types';\n\n/**\n * Base class for all guards.\n */\nexport abstract class BaseGuard {\n    abstract name: string;\n    abstract description: string;\n\n    abstract check(response: ParsedResponse, context?: Record<string, any>): GuardResult;\n\n    protected passResult(message?: string, details?: Record<string, any>): GuardResult {\n        return {\n            guardName: this.name,\n            passed: true,\n            message: message || `${this.name} passed`,\n            details,\n            severity: 'info',\n        };\n    }\n\n    protected failResult(message: string, details?: Record<string, any>, severity: 'error' | 'warning' = 'error'): GuardResult {\n        return {\n            guardName: this.name,\n            passed: false,\n            message,\n            details,\n            severity,\n        };\n    }\n}\n\n/**\n * Tool Guard - Blocks dangerous tool calls.\n */\nexport class ToolGuard extends BaseGuard {\n    name = 'ToolGuard';\n    description = 'Validates tool calls for safety';\n\n    private blockedTools: Set<string>;\n    private allowedTools: Set<string> | null;\n    private dangerousPatterns: RegExp[];\n\n    private static DEFAULT_BLOCKED_TOOLS = new Set([\n        'execute_shell', 'shell', 'bash', 'cmd', 'exec', 'eval',\n        'delete_file', 'remove_file', 'write_file', 'modify_file',\n        'send_email', 'transfer_money', 'make_payment',\n    ]);\n\n    private static DEFAULT_DANGEROUS_PATTERNS = [\n        /DROP\\s+TABLE/i,\n        /DELETE\\s+FROM/i,\n        /TRUNCATE\\s+TABLE/i,\n        /rm\\s+-rf/i,\n        /rmdir\\s+\\/s/i,\n        /eval\\s*\\(/i,\n        /exec\\s*\\(/i,\n        /__import__/i,\n    ];\n\n    constructor(options: {\n        blockedTools?: string[];\n        allowedTools?: string[];\n        useDefaultBlocklist?: boolean;\n        dangerousPatterns?: RegExp[];\n    } = {}) {\n        super();\n\n        const {\n            blockedTools = [],\n            allowedTools,\n            useDefaultBlocklist = true,\n            dangerousPatterns = [],\n        } = options;\n\n        this.blockedTools = new Set(blockedTools);\n        if (useDefaultBlocklist) {\n            ToolGuard.DEFAULT_BLOCKED_TOOLS.forEach(t => this.blockedTools.add(t));\n        }\n\n        this.allowedTools = allowedTools ? new Set(allowedTools) : null;\n        this.dangerousPatterns = [\n            ...ToolGuard.DEFAULT_DANGEROUS_PATTERNS,\n            ...dangerousPatterns,\n        ];\n    }\n\n    check(response: ParsedResponse, context?: Record<string, any>): GuardResult {\n        const toolCalls = this.extractToolCalls(response);\n\n        if (toolCalls.length === 0) {\n            return this.passResult('No tool calls to verify');\n        }\n\n        for (const call of toolCalls) {\n            const toolName = call.toolName || call.tool_name || call.name || 'unknown';\n            const args = call.arguments || {};\n\n            // Check blocked list\n            if (this.blockedTools.has(toolName)) {\n                return this.failResult(`BLOCKED: Tool '${toolName}' is not allowed`, { blockedTool: toolName });\n            }\n\n            // Check allowed list (whitelist mode)\n            if (this.allowedTools && !this.allowedTools.has(toolName)) {\n                return this.failResult(`BLOCKED: Tool '${toolName}' is not in allowed list`, {\n                    tool: toolName,\n                    allowed: Array.from(this.allowedTools),\n                });\n            }\n\n            // Check dangerous patterns\n            const argsStr = JSON.stringify(args);\n            for (const pattern of this.dangerousPatterns) {\n                if (pattern.test(argsStr)) {\n                    return this.failResult('BLOCKED: Dangerous pattern detected in tool arguments', {\n                        tool: toolName,\n                        pattern: pattern.source,\n                    });\n                }\n            }\n        }\n\n        return this.passResult(`All ${toolCalls.length} tool call(s) verified`);\n    }\n\n    private extractToolCalls(response: ParsedResponse): any[] {\n        const calls: any[] = [];\n\n        if (response.type === 'tool_call') {\n            calls.push(response);\n        }\n\n        if (response.toolCalls || response.tool_calls) {\n            calls.push(...(response.toolCalls || response.tool_calls || []));\n        }\n\n        return calls;\n    }\n}\n\n/**\n * Schema Guard - Validates JSON schema.\n */\nexport class SchemaGuard extends BaseGuard {\n    name = 'SchemaGuard';\n    description = 'Validates response against JSON Schema';\n\n    private schema: Record<string, any>;\n\n    constructor(schema: Record<string, any>) {\n        super();\n        this.schema = schema;\n    }\n\n    check(response: ParsedResponse, context?: Record<string, any>): GuardResult {\n        const data = response.output || response;\n\n        // Basic type checking (full JSON Schema validation would need ajv)\n        if (this.schema.type === 'object' && typeof data !== 'object') {\n            return this.failResult('Expected object type');\n        }\n\n        if (this.schema.required) {\n            const missing = this.schema.required.filter((field: string) => !(field in data));\n            if (missing.length > 0) {\n                return this.failResult(`Missing required fields: ${missing.join(', ')}`, { missing });\n            }\n        }\n\n        return this.passResult('Schema validation passed');\n    }\n}\n\n/**\n * Safety Guard - Comprehensive safety checks.\n */\nexport class SafetyGuard extends BaseGuard {\n    name = 'SafetyGuard';\n    description = 'Comprehensive safety checks';\n\n    private checkPii: boolean;\n    private checkInjection: boolean;\n\n    private static PII_PATTERNS = {\n        email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}/,\n        phone: /\\b\\d{3}[-.]?\\d{3}[-.]?\\d{4}\\b/,\n        ssn: /\\b\\d{3}-\\d{2}-\\d{4}\\b/,\n        creditCard: /\\b\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}\\b/,\n    };\n\n    private static INJECTION_PATTERNS = [\n        /ignore\\s+(previous|all|above)\\s+(instructions?|prompts?)/i,\n        /disregard\\s+(previous|all|above)/i,\n        /forget\\s+(everything|all|your\\s+instructions)/i,\n        /you\\s+are\\s+now\\s+/i,\n        /pretend\\s+(you|to\\s+be)/i,\n    ];\n\n    constructor(options: { checkPii?: boolean; checkInjection?: boolean } = {}) {\n        super();\n        this.checkPii = options.checkPii ?? true;\n        this.checkInjection = options.checkInjection ?? true;\n    }\n\n    check(response: ParsedResponse, context?: Record<string, any>): GuardResult {\n        const content = this.extractContent(response);\n        const issues: string[] = [];\n\n        if (this.checkPii) {\n            for (const [type, pattern] of Object.entries(SafetyGuard.PII_PATTERNS)) {\n                if (pattern.test(content)) {\n                    issues.push(`PII detected: ${type}`);\n                }\n            }\n        }\n\n        if (this.checkInjection) {\n            for (const pattern of SafetyGuard.INJECTION_PATTERNS) {\n                if (pattern.test(content)) {\n                    return this.failResult('BLOCKED: Prompt injection detected', { pattern: pattern.source });\n                }\n            }\n        }\n\n        if (issues.length > 0) {\n            return this.failResult(`Safety issues detected: ${issues.join(', ')}`, { issues }, 'warning');\n        }\n\n        return this.passResult('All safety checks passed');\n    }\n\n    private extractContent(response: ParsedResponse): string {\n        const parts: string[] = [];\n\n        if (typeof response.content === 'string') parts.push(response.content);\n        if (typeof response.output === 'string') parts.push(response.output);\n        if (typeof response.text === 'string') parts.push(response.text);\n\n        if (typeof response.output === 'object') parts.push(JSON.stringify(response.output));\n        if (response.arguments) parts.push(JSON.stringify(response.arguments));\n\n        return parts.join(' ');\n    }\n}\n\n/**\n * Math Guard - Verifies calculations.\n */\nexport class MathGuard extends BaseGuard {\n    name = 'MathGuard';\n    description = 'Verifies mathematical calculations';\n\n    private tolerance: number;\n\n    constructor(options: { tolerance?: number } = {}) {\n        super();\n        this.tolerance = options.tolerance ?? 0.01;\n    }\n\n    check(response: ParsedResponse, context?: Record<string, any>): GuardResult {\n        const data = response.output || response;\n\n        if (typeof data !== 'object') {\n            return this.passResult('No calculations to verify');\n        }\n\n        // Check common total patterns\n        if ('total' in data && 'subtotal' in data) {\n            const subtotal = Number(data.subtotal) || 0;\n            const tax = Number(data.tax) || 0;\n            const shipping = Number(data.shipping) || 0;\n            const discount = Number(data.discount) || 0;\n            const total = Number(data.total);\n\n            const expected = subtotal + tax + shipping - discount;\n\n            if (Math.abs(expected - total) > this.tolerance) {\n                return this.failResult(\n                    `Total mismatch: expected ${expected}, got ${total}`,\n                    { expected, actual: total }\n                );\n            }\n        }\n\n        return this.passResult('Math verification passed');\n    }\n}\n"]}

package/dist/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * QWED Open Responses - Express Middleware
+ *
+ * Verification guards for AI agent outputs in Express.js applications.
+ */
+import { Request, Response, RequestHandler } from 'express';
+export * from './guards';
+export * from './types';
+export * from './verifier';
+import { ResponseVerifier, VerificationResult } from './verifier';
+import { BaseGuard, ToolGuard, SchemaGuard, SafetyGuard } from './guards';
+export interface QWEDMiddlewareOptions {
+    /** Guards to apply to all requests */
+    guards?: BaseGuard[];
+    /** Block requests that fail verification */
+    blockOnFailure?: boolean;
+    /** Custom error handler */
+    onError?: (error: VerificationResult, req: Request, res: Response) => void;
+    /** Log verification results */
+    verbose?: boolean;
+    /** Paths to skip verification */
+    skipPaths?: string[];
+}
+/**
+ * Create QWED verification middleware for Express.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createQWEDMiddleware, ToolGuard, SafetyGuard } from 'qwed-open-responses';
+ *
+ * const app = express();
+ *
+ * app.use(createQWEDMiddleware({
+ *   guards: [new ToolGuard(), new SafetyGuard()],
+ *   blockOnFailure: true,
+ * }));
+ * ```
+ */
+export declare function createQWEDMiddleware(options?: QWEDMiddlewareOptions): RequestHandler;
+/**
+ * Middleware to verify incoming request bodies.
+ */
+export declare function verifyRequestBody(options?: QWEDMiddlewareOptions): RequestHandler;
+/**
+ * Middleware to verify tool calls in AI agent requests.
+ */
+export declare function verifyToolCalls(options?: QWEDMiddlewareOptions): RequestHandler;
+declare const _default: {
+    createQWEDMiddleware: typeof createQWEDMiddleware;
+    verifyRequestBody: typeof verifyRequestBody;
+    verifyToolCalls: typeof verifyToolCalls;
+    ResponseVerifier: typeof ResponseVerifier;
+    ToolGuard: typeof ToolGuard;
+    SchemaGuard: typeof SchemaGuard;
+    SafetyGuard: typeof SafetyGuard;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,130 @@
+"use strict";
+/**
+ * QWED Open Responses - Express Middleware
+ *
+ * Verification guards for AI agent outputs in Express.js applications.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQWEDMiddleware = createQWEDMiddleware;
+exports.verifyRequestBody = verifyRequestBody;
+exports.verifyToolCalls = verifyToolCalls;
+// Re-export all guards and types
+__exportStar(require("./guards"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./verifier"), exports);
+const verifier_1 = require("./verifier");
+const guards_1 = require("./guards");
+/**
+ * Create QWED verification middleware for Express.
+ *
+ * @example
+ * ```typescript
+ * import express from 'express';
+ * import { createQWEDMiddleware, ToolGuard, SafetyGuard } from 'qwed-open-responses';
+ *
+ * const app = express();
+ *
+ * app.use(createQWEDMiddleware({
+ *   guards: [new ToolGuard(), new SafetyGuard()],
+ *   blockOnFailure: true,
+ * }));
+ * ```
+ */
+function createQWEDMiddleware(options = {}) {
+    const { guards = [], blockOnFailure = true, onError, verbose = false, skipPaths = [], } = options;
+    const verifier = new verifier_1.ResponseVerifier(guards);
+    return (req, res, next) => {
+        // Skip certain paths
+        if (skipPaths.some(path => req.path.startsWith(path))) {
+            return next();
+        }
+        // Store original json method
+        const originalJson = res.json.bind(res);
+        // Override json to verify before sending
+        res.json = (body) => {
+            const result = verifier.verify(body);
+            if (verbose) {
+                console.log(`[QWED] ${req.method} ${req.path} -> ${result.verified ? 'PASS' : 'FAIL'}`);
+            }
+            // Attach verification result to response
+            res._qwedVerification = result;
+            if (!result.verified && blockOnFailure) {
+                if (onError) {
+                    onError(result, req, res);
+                    return res;
+                }
+                return originalJson({
+                    error: 'Response verification failed',
+                    code: 'QWED_VERIFICATION_FAILED',
+                    details: result.guardResults.filter(g => !g.passed).map(g => ({
+                        guard: g.guardName,
+                        message: g.message,
+                    })),
+                });
+            }
+            return originalJson(body);
+        };
+        next();
+    };
+}
+/**
+ * Middleware to verify incoming request bodies.
+ */
+function verifyRequestBody(options = {}) {
+    const { guards = [], blockOnFailure = true, verbose = false, } = options;
+    const verifier = new verifier_1.ResponseVerifier(guards);
+    return (req, res, next) => {
+        if (!req.body) {
+            return next();
+        }
+        const result = verifier.verify(req.body);
+        if (verbose) {
+            console.log(`[QWED] Request body ${req.method} ${req.path} -> ${result.verified ? 'PASS' : 'FAIL'}`);
+        }
+        req._qwedVerification = result;
+        if (!result.verified && blockOnFailure) {
+            return res.status(422).json({
+                error: 'Request verification failed',
+                code: 'QWED_REQUEST_BLOCKED',
+                details: result.guardResults.filter(g => !g.passed).map(g => ({
+                    guard: g.guardName,
+                    message: g.message,
+                })),
+            });
+        }
+        next();
+    };
+}
+/**
+ * Middleware to verify tool calls in AI agent requests.
+ */
+function verifyToolCalls(options = {}) {
+    const toolGuard = new guards_1.ToolGuard();
+    const guards = [toolGuard, ...(options.guards || [])];
+    return verifyRequestBody({ ...options, guards });
+}
+// Default export
+exports.default = {
+    createQWEDMiddleware,
+    verifyRequestBody,
+    verifyToolCalls,
+    ResponseVerifier: verifier_1.ResponseVerifier,
+    ToolGuard: guards_1.ToolGuard,
+    SchemaGuard: guards_1.SchemaGuard,
+    SafetyGuard: guards_1.SafetyGuard,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * QWED Open Responses - Express Middleware\n * \n * Verification guards for AI agent outputs in Express.js applications.\n */\n\nimport { Request, Response, NextFunction, RequestHandler } from 'express';\n\n// Re-export all guards and types\nexport * from './guards';\nexport * from './types';\nexport * from './verifier';\n\nimport { ResponseVerifier, VerificationResult } from './verifier';\nimport { BaseGuard, ToolGuard, SchemaGuard, SafetyGuard } from './guards';\n\nexport interface QWEDMiddlewareOptions {\n    /** Guards to apply to all requests */\n    guards?: BaseGuard[];\n    /** Block requests that fail verification */\n    blockOnFailure?: boolean;\n    /** Custom error handler */\n    onError?: (error: VerificationResult, req: Request, res: Response) => void;\n    /** Log verification results */\n    verbose?: boolean;\n    /** Paths to skip verification */\n    skipPaths?: string[];\n}\n\n/**\n * Create QWED verification middleware for Express.\n * \n * @example\n * ```typescript\n * import express from 'express';\n * import { createQWEDMiddleware, ToolGuard, SafetyGuard } from 'qwed-open-responses';\n * \n * const app = express();\n * \n * app.use(createQWEDMiddleware({\n *   guards: [new ToolGuard(), new SafetyGuard()],\n *   blockOnFailure: true,\n * }));\n * ```\n */\nexport function createQWEDMiddleware(options: QWEDMiddlewareOptions = {}): RequestHandler {\n    const {\n        guards = [],\n        blockOnFailure = true,\n        onError,\n        verbose = false,\n        skipPaths = [],\n    } = options;\n\n    const verifier = new ResponseVerifier(guards);\n\n    return (req: Request, res: Response, next: NextFunction) => {\n        // Skip certain paths\n        if (skipPaths.some(path => req.path.startsWith(path))) {\n            return next();\n        }\n\n        // Store original json method\n        const originalJson = res.json.bind(res);\n\n        // Override json to verify before sending\n        res.json = (body: any) => {\n            const result = verifier.verify(body);\n\n            if (verbose) {\n                console.log(`[QWED] ${req.method} ${req.path} -> ${result.verified ? 'PASS' : 'FAIL'}`);\n            }\n\n            // Attach verification result to response\n            (res as any)._qwedVerification = result;\n\n            if (!result.verified && blockOnFailure) {\n                if (onError) {\n                    onError(result, req, res);\n                    return res;\n                }\n\n                return originalJson({\n                    error: 'Response verification failed',\n                    code: 'QWED_VERIFICATION_FAILED',\n                    details: result.guardResults.filter(g => !g.passed).map(g => ({\n                        guard: g.guardName,\n                        message: g.message,\n                    })),\n                });\n            }\n\n            return originalJson(body);\n        };\n\n        next();\n    };\n}\n\n/**\n * Middleware to verify incoming request bodies.\n */\nexport function verifyRequestBody(options: QWEDMiddlewareOptions = {}): RequestHandler {\n    const {\n        guards = [],\n        blockOnFailure = true,\n        verbose = false,\n    } = options;\n\n    const verifier = new ResponseVerifier(guards);\n\n    return (req: Request, res: Response, next: NextFunction) => {\n        if (!req.body) {\n            return next();\n        }\n\n        const result = verifier.verify(req.body);\n\n        if (verbose) {\n            console.log(`[QWED] Request body ${req.method} ${req.path} -> ${result.verified ? 'PASS' : 'FAIL'}`);\n        }\n\n        (req as any)._qwedVerification = result;\n\n        if (!result.verified && blockOnFailure) {\n            return res.status(422).json({\n                error: 'Request verification failed',\n                code: 'QWED_REQUEST_BLOCKED',\n                details: result.guardResults.filter(g => !g.passed).map(g => ({\n                    guard: g.guardName,\n                    message: g.message,\n                })),\n            });\n        }\n\n        next();\n    };\n}\n\n/**\n * Middleware to verify tool calls in AI agent requests.\n */\nexport function verifyToolCalls(options: QWEDMiddlewareOptions = {}): RequestHandler {\n    const toolGuard = new ToolGuard();\n    const guards = [toolGuard, ...(options.guards || [])];\n\n    return verifyRequestBody({ ...options, guards });\n}\n\n// Default export\nexport default {\n    createQWEDMiddleware,\n    verifyRequestBody,\n    verifyToolCalls,\n    ResponseVerifier,\n    ToolGuard,\n    SchemaGuard,\n    SafetyGuard,\n};\n"]}

package/dist/types.d.ts

@@ -0,0 +1,35 @@
+/**
+ * QWED Open Responses - Types
+ */
+export interface GuardResult {
+    guardName: string;
+    passed: boolean;
+    message?: string;
+    details?: Record<string, any>;
+    severity: 'error' | 'warning' | 'info';
+}
+export interface VerificationResult {
+    verified: boolean;
+    response: any;
+    guardsPassed: number;
+    guardsFailed: number;
+    guardResults: GuardResult[];
+    blocked: boolean;
+    blockReason?: string;
+    timestamp: string;
+}
+export interface ToolCall {
+    type?: string;
+    toolName?: string;
+    tool_name?: string;
+    name?: string;
+    arguments?: Record<string, any>;
+}
+export interface ParsedResponse {
+    type?: string;
+    content?: string;
+    output?: any;
+    toolCalls?: ToolCall[];
+    tool_calls?: ToolCall[];
+    [key: string]: any;
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * QWED Open Responses - Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBOztHQUVHIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBRV0VEIE9wZW4gUmVzcG9uc2VzIC0gVHlwZXNcbiAqL1xuXG5leHBvcnQgaW50ZXJmYWNlIEd1YXJkUmVzdWx0IHtcbiAgICBndWFyZE5hbWU6IHN0cmluZztcbiAgICBwYXNzZWQ6IGJvb2xlYW47XG4gICAgbWVzc2FnZT86IHN0cmluZztcbiAgICBkZXRhaWxzPzogUmVjb3JkPHN0cmluZywgYW55PjtcbiAgICBzZXZlcml0eTogJ2Vycm9yJyB8ICd3YXJuaW5nJyB8ICdpbmZvJztcbn1cblxuZXhwb3J0IGludGVyZmFjZSBWZXJpZmljYXRpb25SZXN1bHQge1xuICAgIHZlcmlmaWVkOiBib29sZWFuO1xuICAgIHJlc3BvbnNlOiBhbnk7XG4gICAgZ3VhcmRzUGFzc2VkOiBudW1iZXI7XG4gICAgZ3VhcmRzRmFpbGVkOiBudW1iZXI7XG4gICAgZ3VhcmRSZXN1bHRzOiBHdWFyZFJlc3VsdFtdO1xuICAgIGJsb2NrZWQ6IGJvb2xlYW47XG4gICAgYmxvY2tSZWFzb24/OiBzdHJpbmc7XG4gICAgdGltZXN0YW1wOiBzdHJpbmc7XG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgVG9vbENhbGwge1xuICAgIHR5cGU/OiBzdHJpbmc7XG4gICAgdG9vbE5hbWU/OiBzdHJpbmc7XG4gICAgdG9vbF9uYW1lPzogc3RyaW5nO1xuICAgIG5hbWU/OiBzdHJpbmc7XG4gICAgYXJndW1lbnRzPzogUmVjb3JkPHN0cmluZywgYW55Pjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBQYXJzZWRSZXNwb25zZSB7XG4gICAgdHlwZT86IHN0cmluZztcbiAgICBjb250ZW50Pzogc3RyaW5nO1xuICAgIG91dHB1dD86IGFueTtcbiAgICB0b29sQ2FsbHM/OiBUb29sQ2FsbFtdO1xuICAgIHRvb2xfY2FsbHM/OiBUb29sQ2FsbFtdO1xuICAgIFtrZXk6IHN0cmluZ106IGFueTtcbn1cbiJdfQ==

package/dist/verifier.d.ts

@@ -0,0 +1,25 @@
+/**
+ * QWED Open Responses - Response Verifier
+ */
+import { BaseGuard } from './guards';
+import { VerificationResult, GuardResult } from './types';
+export { VerificationResult, GuardResult };
+/**
+ * Main verifier for AI responses.
+ */
+export declare class ResponseVerifier {
+    private defaultGuards;
+    private strictMode;
+    constructor(guards?: BaseGuard[], options?: {
+        strictMode?: boolean;
+    });
+    /**
+     * Verify a response against guards.
+     */
+    verify(response: any, guards?: BaseGuard[], context?: Record<string, any>): VerificationResult;
+    /**
+     * Verify a tool call.
+     */
+    verifyToolCall(toolName: string, args: Record<string, any>, guards?: BaseGuard[]): VerificationResult;
+    private parseResponse;
+}

package/dist/verifier.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * QWED Open Responses - Response Verifier
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseVerifier = void 0;
+/**
+ * Main verifier for AI responses.
+ */
+class ResponseVerifier {
+    constructor(guards = [], options = {}) {
+        this.defaultGuards = guards;
+        this.strictMode = options.strictMode ?? true;
+    }
+    /**
+     * Verify a response against guards.
+     */
+    verify(response, guards, context) {
+        const guardsToUse = guards ?? this.defaultGuards;
+        const parsedResponse = this.parseResponse(response);
+        const guardResults = [];
+        let guardsPassed = 0;
+        let guardsFailed = 0;
+        let blocked = false;
+        let blockReason;
+        for (const guard of guardsToUse) {
+            try {
+                const result = guard.check(parsedResponse, context);
+                guardResults.push(result);
+                if (result.passed) {
+                    guardsPassed++;
+                }
+                else {
+                    guardsFailed++;
+                    if (result.severity === 'error' && this.strictMode) {
+                        blocked = true;
+                        blockReason = result.message;
+                    }
+                }
+            }
+            catch (error) {
+                guardResults.push({
+                    guardName: guard.name,
+                    passed: false,
+                    message: `Guard error: ${error instanceof Error ? error.message : String(error)}`,
+                    severity: 'error',
+                });
+                guardsFailed++;
+            }
+        }
+        return {
+            verified: guardsFailed === 0,
+            response: parsedResponse,
+            guardsPassed,
+            guardsFailed,
+            guardResults,
+            blocked,
+            blockReason,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Verify a tool call.
+     */
+    verifyToolCall(toolName, args, guards) {
+        const toolCall = {
+            type: 'tool_call',
+            toolName,
+            arguments: args,
+        };
+        return this.verify(toolCall, guards);
+    }
+    parseResponse(response) {
+        if (typeof response === 'object' && response !== null) {
+            return response;
+        }
+        if (typeof response === 'string') {
+            try {
+                return JSON.parse(response);
+            }
+            catch {
+                return { type: 'text', content: response };
+            }
+        }
+        return { type: 'unknown', raw: String(response) };
+    }
+}
+exports.ResponseVerifier = ResponseVerifier;
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "qwed-open-responses",
+    "version": "0.1.0",
+    "description": "Verification guards for AI agent outputs - Works with OpenAI, LangChain, Express.js",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist",
+        "README.md",
+        "LICENSE"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "test": "jest",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "ai",
+        "verification",
+        "openai",
+        "responses-api",
+        "agents",
+        "tool-calling",
+        "structured-outputs",
+        "llm",
+        "safety",
+        "express",
+        "middleware",
+        "qwed"
+    ],
+    "author": "QWED-AI <team@qwedai.com>",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/QWED-AI/qwed-open-responses.git"
+    },
+    "bugs": {
+        "url": "https://github.com/QWED-AI/qwed-open-responses/issues"
+    },
+    "homepage": "https://github.com/QWED-AI/qwed-open-responses#readme",
+    "devDependencies": {
+        "@types/express": "^4.17.21",
+        "@types/node": "^20.10.0",
+        "typescript": "^5.3.0",
+        "jest": "^29.7.0",
+        "@types/jest": "^29.5.11"
+    },
+    "peerDependencies": {
+        "express": "^4.18.0 || ^5.0.0"
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    }
+}