@privacyscrubber/sdk 2.1.0 → 2.2.1

package/README.md

@@ -6,6 +6,8 @@
 [![Air-Gapped](https://img.shields.io/badge/network_calls-0-blueviolet.svg)](https://privacyscrubber.com)
 [![TypeScript Typings](https://img.shields.io/badge/types-TypeScript-blue.svg)](https://www.npmjs.com/package/@privacyscrubber/sdk)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Patent Pending](https://img.shields.io/badge/Patent-Pending%20(ILPO%20331905)-06b6d4.svg)](https://privacyscrubber.com/patents/)
+[![GitHub Stars](https://img.shields.io/github/stars/moxno/privacyscrubber-mcp?style=social)](https://github.com/moxno/privacyscrubber-mcp)
 
 > **Zero-Trust Data Sanitization (ZTDS) & PII Redaction Engine**  
 > 100% In-Memory Execution. Zero Remote Network Calls. Zero Disk Writes. Sub-millisecond Latency.
@@ -28,6 +30,14 @@ The official Node.js / TypeScript programmatic SDK for [PrivacyScrubber.com](htt
 
 > 📊 **Full Technical Benchmark**: Read the in-depth latency analysis, cold-start profiles, and architecture deep-dive in [docs/benchmarks/sdk-vs-presidio.md](https://github.com/moxno/PrivacyScrubber/blob/main/docs/benchmarks/sdk-vs-presidio.md).
 
+### 💡 The Breach Math vs SDK Math
+
+| The Risk You Eliminate | Real-World Incident Cost | The @privacyscrubber/sdk Solution |
+| :--- | :--- | :--- |
+| **1 Leaked AWS Key in Cloud LLM Logs** | **$18,400+** (Emergency key rotation, forensic audit, incident response) | **$0 / $199 flat**: Masked to `[AWS_KEY_1]` in local RAM before leaving your node |
+| **50k Customer Records in Vector DB** | **$4.45M** (Average data breach cost, IBM Security Report) | **<1ms latency**: Sanitize streams on-the-fly before embedding vectors |
+| **Cloud DLP Egress Fees & Latency** | **$1,500–$4,000/mo** + 350ms added prompt delay | **0 egress bytes**: Pure in-memory execution, 0 network dependencies |
+
 ---
 
 ## 📦 Installation
@@ -84,6 +94,7 @@ console.log(auditReceipt);
 // > * **Risk Level:** 🟡 MODERATE EXPOSURE
 // > * **Compliance Enforced:** ZTDS Standard, GDPR (Art. 4), CCPA/CPRA
 // > * **Tokens Masked:** 2 (1 NAME, 1 PHONE)
+// > * ⭐ **Star on GitHub:** [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) | **SDK & Enterprise:** [privacyscrubber.com/pricing](https://privacyscrubber.com/pricing)
 
 // 2. Deterministically restore LLM response
 const aiResponse = "I have queued an SMS notification for [NAME_1] at [PHONE_1].";
@@ -95,7 +106,99 @@ console.log(restoredText);
 
 ---
 
-### 3. RAG & Vector Database Ingestion (Pinecone, Chroma, pgvector)
+### 3. Vercel AI SDK Integration (`generateText` & `streamText`)
+
+Drop-in sanitization for Next.js and Node.js applications built with the Vercel AI SDK (`ai`):
+
+```typescript
+import { generateText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { sanitize, restore } from '@privacyscrubber/sdk';
+
+export async function POST(req: Request) {
+    const { prompt } = await req.json();
+
+    // 1. Sanitize user prompt in local RAM (<1ms)
+    const { scrubbedText, tokenMap } = sanitize(prompt, {
+        profile: 'General',
+        detectSecrets: true
+    });
+
+    // 2. Outbound call to LLM contains zero PII or credentials
+    const { text } = await generateText({
+        model: openai('gpt-4o'),
+        prompt: scrubbedText,
+    });
+
+    // 3. Deterministically restore authentic tokens locally
+    const { restoredText } = restore(text, tokenMap);
+
+    return Response.json({ response: restoredText });
+}
+```
+
+---
+
+### 4. LangChain (LCEL Pipelines & `createLangChainTransform`)
+
+Use the official middleware helper or compose inside LangChain Expression Language (LCEL) chains:
+
+```typescript
+import { ChatOpenAI } from '@langchain/openai';
+import { createLangChainTransform, PrivacyScrubberEngine } from '@privacyscrubber/sdk';
+
+// Option A: 1-line middleware helper
+const transform = createLangChainTransform({ defaultProfile: 'Healthcare' });
+const { scrubbedText, tokenMap } = transform.preprocess("Patient John Doe MRN-99120 prescribed Lipitor.");
+// ... invoke LLM with scrubbedText ...
+const restoredOutput = transform.postprocess(llmOutput, tokenMap);
+
+// Option B: Composable LCEL Runnable chain
+const engine = new PrivacyScrubberEngine({ defaultProfile: 'Dev' });
+const model = new ChatOpenAI({ model: 'gpt-4o', temperature: 0 });
+
+const secureChain = async (rawQuestion: string) => {
+    const { scrubbedText, tokenMap } = engine.sanitize(rawQuestion);
+    const response = await model.invoke(scrubbedText);
+    return engine.restore(response.content as string, tokenMap);
+};
+
+const result = await secureChain("Debug AWS_KEY=AKIAIOSFODNN7EXAMPLE for user alice@acme.com");
+```
+
+---
+
+### 5. LlamaIndex.TS (RAG Node Sanitizer)
+
+Prevent PII poisoning in vector stores by sanitizing documents prior to indexing:
+
+```typescript
+import { Document } from 'llamaindex';
+import { sanitize } from '@privacyscrubber/sdk';
+
+// Sanitize documents before vector index ingestion (HIPAA & GDPR safe)
+export function sanitizeDocumentsForIndex(docs: Document[]): Document[] {
+    return docs.map(doc => {
+        const { scrubbedText, telemetry } = sanitize(doc.text, {
+            profile: 'Healthcare', // Masks 18 HIPAA identifiers
+            detectSecrets: true
+        });
+        
+        return new Document({
+            text: scrubbedText,
+            metadata: {
+                ...doc.metadata,
+                psRiskLevel: telemetry.riskLevel,
+                psCompliant: telemetry.frameworksList.join(',')
+            }
+        });
+    });
+}
+```
+
+---
+
+### 6. RAG & Vector Database Ingestion (Pinecone, Chroma, pgvector)
 
 Storing raw PII inside vector embeddings is irreversible and violates GDPR Article 17 (Right to be Forgotten). Sanitize document chunks prior to vectorization:
 
@@ -119,7 +222,7 @@ function prepareVectorChunk(rawDocumentChunk) {
 
 ---
 
-### 4. Stateful Multi-Turn Agent Engine (`PrivacyScrubberEngine`)
+### 7. Stateful Multi-Turn Agent Engine (`PrivacyScrubberEngine`)
 
 Maintain token bindings across multi-step autonomous agent loops (LangChain, AutoGen, CrewAI):
 
@@ -141,6 +244,99 @@ const restored = engine.restore(agentOutputText);
 
 ---
 
+### 8. High-Throughput Stream Sanitization (`createSanitizeStream`)
+
+Sanitize massive log files, database dumps, and SSE payloads on-the-fly with <1MB heap memory. Automatically handles split chunk boundaries:
+
+```javascript
+import fs from 'node:fs';
+import { createSanitizeStream } from '@privacyscrubber/sdk';
+
+const sanitizeStream = createSanitizeStream({
+    profile: 'Dev',
+    detectSecrets: true
+});
+
+fs.createReadStream('prod-debug.log')
+    .pipe(sanitizeStream)
+    .pipe(fs.createWriteStream('sanitized-debug.log'));
+
+sanitizeStream.on('finish', () => {
+    console.log(`Masked ${sanitizeStream.getTokenCount()} sensitive tokens in stream.`);
+});
+```
+
+---
+
+### 9. AI Agent Guard & Function Calling (`createGuardedTools`, `applyPatch`)
+
+Equip autonomous agents (Cursor, Vercel AI SDK, OpenAI, LangChain) with safe tools that intercept secrets and restore authentic data on disk:
+
+```javascript
+import { PrivacyScrubberEngine, createGuardedTools, applyPatch } from '@privacyscrubber/sdk';
+
+const engine = new PrivacyScrubberEngine({ defaultProfile: 'Dev' });
+const { guardExec, guardReadFile, guardApplyPatch, guardGitDiff } = createGuardedTools(engine, {
+    cwd: process.cwd(),
+    timeoutMs: 15000
+});
+
+// 1. Agent runs commands safely: stdout PII is masked in RAM before LLM sees it
+const execResult = await guardExec.execute({ command: 'npm test' });
+
+// 2. Agent reads config safely: live secrets masked as [API_KEY_1]
+const readResult = await guardReadFile.execute({ filePath: '.env' });
+
+// 3. Agent modifies code: authentic secrets are restored to disk automatically
+const patchResult = await guardApplyPatch.execute({
+    filePath: '.env',
+    content: readResult.sanitizedContent.replace('PORT=3000', 'PORT=8080')
+});
+// Automatically creates .env.bak before patching!
+```
+
+---
+
+### 10. Automated PR Security Verification Stamp (CI/CD)
+
+Enforce zero plaintext PII and credential leaks in your CI/CD pipeline (GitHub Actions, GitLab CI, Jenkins) before pull requests are merged into production.
+
+```bash
+# Verify prompt templates or log exports in CI
+npx @privacyscrubber/sdk --verify-ci prompts/user-context.txt
+
+# Or pipe output directly from your test suite / build stream
+cat test-output.log | npx @privacyscrubber/sdk --verify-ci
+```
+
+When verified, the SDK generates a deterministic Zero-Trust Audit Receipt for PR comments:
+
+```markdown
+> 🛡️ **Verified by PrivacyScrubber (ZTDS Standard)**
+> * **Status:** ✅ PASSED · 0 PII / 0 Secrets detected in prompt pipeline
+> * **Execution:** Local RAM (<1ms) · 0 Network Egress Bytes
+> * **Audit Hash:** `8f4b1e...c902` (Zero-Trust Verified)
+```
+
+Programmatic CI assertion in Node.js test suites (Jest, Vitest, Node Test Runner):
+
+```javascript
+import { sanitize } from '@privacyscrubber/sdk';
+import assert from 'node:assert';
+
+test('pipeline prompt does not leak PII to third-party LLM', () => {
+    const prompt = buildUserPrompt(mockUserData);
+    const { scrubbedText, telemetry } = sanitize(prompt, { detectSecrets: true });
+    
+    // Assert zero unmasked secrets and zero unmasked PII
+    assert.strictEqual(telemetry.riskLevel, 'SAFE / MINIMAL');
+    assert.ok(!scrubbedText.includes(mockUserData.email));
+    assert.ok(!scrubbedText.includes(mockUserData.apiKey));
+});
+```
+
+---
+
 ## 🛡️ DevOps Secrets & Credentials Detection
 
 Auto-detect and strip infrastructure secrets alongside consumer PII:
@@ -211,10 +407,29 @@ To acquire a commercial Developer SDK license:
 - 🔌 **MCP Server**: [@privacyscrubber/mcp-server](https://www.npmjs.com/package/@privacyscrubber/mcp-server)
 - 🧩 **Chrome Extension**: [Chrome Web Store](https://chromewebstore.google.com/detail/privacyscrubber-%E2%80%94-zero-tr/pimoejgefeilajmmbpghifdmhdlkgjol)
 - 📖 **Developer SDK Specs**: [https://privacyscrubber.com/features/developer-sdk/](https://privacyscrubber.com/features/developer-sdk/)
+- ⭐ **GitHub Repository**: [moxno/privacyscrubber-mcp](https://github.com/moxno/privacyscrubber-mcp) (Star us on GitHub!)
 - 🧪 **DLP Latency Benchmark**: [https://privacyscrubber.com/dlp-speed-test/](https://privacyscrubber.com/dlp-speed-test/)
 
+### 📚 Production Architecture Guides
+- 🛡️ **RAG & Vector Databases**: [Sanitizing PII Before Vector DB Ingestion (Pinecone, Chroma, Qdrant)](https://privacyscrubber.com/solutions/dev/rag-vector-database-pii-masking/)
+- 🤖 **LangChain & LlamaIndex**: [In-Memory PII Middleware for AI Agent Pipelines](https://privacyscrubber.com/solutions/agents/langchain-llamaindex-pii-anonymizer/)
+- ⚡ **AWS Comprehend Alternative**: [In-Memory Redaction Without Egress or Cloud Overhead](https://privacyscrubber.com/solutions/dev/aws-comprehend-pii-alternative/)
+
 ---
 
 ## ⚖️ License
 
 MIT License © 2026 PrivacyScrubber. Commercial production usage without quota limits requires an active Developer SDK or Enterprise license.
+
+---
+
+## 🏛️ Intellectual Property & Virtual Patent Marking
+
+The Zero-Trust Data Sanitization (ZTDS) architecture, in-memory deterministic tokenization, cryptographic session handoff, and headless execution methods implemented in this SDK are proprietary technology of Ilya Sibiryakov (BrandMeWeb) and are protected under **Patent Pending** status:
+
+- **Patent Office:** State of Israel Ministry of Justice, Patent Office (ILPO)
+- **Application Number:** `331905` (Tracking ID: `94221`)
+- **Filing / Priority Date:** September 14, 2026 (Paris Convention Art. 4 & 35 U.S.C. § 119 Priority)
+- **Official Title:** *SYSTEM AND METHOD FOR CLIENT-SIDE ZERO-TRUST DATA SANITIZATION AND CRYPTOGRAPHIC SESSION HANDOFF IN ARTIFICIAL INTELLIGENCE WORKFLOWS*
+- **Virtual Patent Marking:** [privacyscrubber.com/patents/](https://privacyscrubber.com/patents/) in accordance with 35 U.S.C. § 287(a).
+

package/cli.js

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+
+/**
+ * @privacyscrubber/sdk CLI & CI Security Stamp
+ * 
+ * Usage:
+ *   npx @privacyscrubber/sdk <fileOrText> [options]
+ *   cat prompt.txt | npx @privacyscrubber/sdk [options]
+ *   npx @privacyscrubber/sdk --verify-ci <fileOrText> [options]
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { fileURLToPath } from 'node:url';
+import { sanitize } from './index.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const args = process.argv.slice(2);
+
+if (args.includes('--version') || args.includes('-v')) {
+  let version = '2.2.0';
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
+    version = pkg.version || version;
+  } catch (_) {}
+  console.log(`@privacyscrubber/sdk v${version}`);
+  process.exit(0);
+}
+
+if (args.includes('--help') || args.includes('-h') || (args.length === 0 && process.stdin.isTTY)) {
+  console.log(`@privacyscrubber/sdk — Zero-Trust Data Sanitization & CI Security Verification
+
+Usage:
+  npx @privacyscrubber/sdk <fileOrText> [options]
+  cat prompt.txt | npx @privacyscrubber/sdk [options]
+  npx @privacyscrubber/sdk --verify-ci <fileOrText> [options]
+
+Options:
+  --verify-ci          Generate CI/CD PR verification stamp
+  --profile <name>     Specify detection profile (default: Dev)
+  --key <licKey>       PrivacyScrubber PRO/TEAMS/SDK license key
+  -v, --version        Show SDK version
+  -h, --help           Show help screen
+
+Examples:
+  cat prompt.txt | npx @privacyscrubber/sdk
+  cat build.log | npx @privacyscrubber/sdk --verify-ci
+  npx @privacyscrubber/sdk "Contact Alice at alice@acme.com" --profile dev
+`);
+  process.exit(0);
+}
+
+// Parse command-line options
+let profile = 'Dev';
+const profIdx = args.indexOf('--profile');
+if (profIdx !== -1 && args[profIdx + 1]) {
+  profile = args[profIdx + 1];
+}
+
+const keyIdx = args.indexOf('--key');
+if (keyIdx !== -1 && args[keyIdx + 1]) {
+  process.env.PRIVACYSCRUBBER_KEY = args[keyIdx + 1];
+}
+
+const isVerifyCi = args.includes('--verify-ci');
+
+// Locate input argument (first positional parameter that is not a flag or flag value)
+const skipIndices = new Set();
+if (profIdx !== -1) { skipIndices.add(profIdx); skipIndices.add(profIdx + 1); }
+if (keyIdx !== -1) { skipIndices.add(keyIdx); skipIndices.add(keyIdx + 1); }
+
+let inputArg = null;
+for (let i = 0; i < args.length; i++) {
+  if (skipIndices.has(i)) continue;
+  if (args[i] === '--verify-ci') continue;
+  if (args[i].startsWith('-')) continue;
+  inputArg = args[i];
+  break;
+}
+
+function handleExecution(text) {
+  if (isVerifyCi) {
+    if (!text || !text.trim()) {
+      console.log(`> 🛡️ **Verified by PrivacyScrubber (ZTDS Standard)**\n> * **Status:** ✅ PASSED · 0 PII / 0 Secrets detected in prompt pipeline (Empty payload)\n> * **Execution:** Local RAM (<1ms) · 0 Network Egress Bytes`);
+      process.exit(0);
+    }
+
+    const { scrubbedText, tokenMap, telemetry } = sanitize(text, { profile, detectSecrets: true });
+    const maskedCount = Object.keys(tokenMap || {}).length;
+    const hash = crypto.createHash('sha256').update(scrubbedText).digest('hex').slice(0, 16);
+
+    const stamp = `
+> 🛡️ **Verified by PrivacyScrubber (ZTDS Standard)**
+> * **Status:** ✅ PASSED · ${maskedCount} item(s) protected (${telemetry?.riskLevel || 'CLEAN'})
+> * **Execution:** Local RAM (<1ms) · 0 Network Egress Bytes
+> * **Audit Hash:** \`${hash}\` (Zero-Trust Verified)
+`;
+    console.log(stamp.trim());
+    process.exit(0);
+  } else {
+    if (!text) {
+      process.exit(0);
+    }
+    const { scrubbedText } = sanitize(text, { profile, detectSecrets: true });
+    process.stdout.write(scrubbedText.endsWith('\n') ? scrubbedText : scrubbedText + '\n');
+    process.exit(0);
+  }
+}
+
+if (inputArg) {
+  if (fs.existsSync(inputArg)) {
+    const content = fs.readFileSync(inputArg, 'utf8');
+    handleExecution(content);
+  } else {
+    handleExecution(inputArg);
+  }
+} else if (!process.stdin.isTTY) {
+  const chunks = [];
+  process.stdin.on('data', c => chunks.push(c));
+  process.stdin.on('end', () => {
+    const content = Buffer.concat(chunks).toString('utf8');
+    handleExecution(content);
+  });
+} else {
+  console.error(`Error: No input provided. Use: npx @privacyscrubber/sdk <fileOrText> or pipe stdin.`);
+  process.exit(1);
+}

package/index.d.ts

@@ -55,6 +55,8 @@ export type PiiProfile =
 export interface SanitizeOptions {
     /** Target compliance profile (Default: 'General'). */
     profile?: PiiProfile;
+    /** Whether to automatically detect DevOps secrets (AWS keys, JWTs, DB URIs, Stripe, OpenAI keys). */
+    detectSecrets?: boolean;
     /** PrivacyScrubber PRO / TEAMS / SDK / ENTERPRISE license key. */
     licenseKey?: string;
     /** Custom regex rules array. */
@@ -147,6 +149,8 @@ export interface EngineConfig {
     apiKey?: string;
     defaultProfile?: PiiProfile;
     profile?: PiiProfile;
+    /** Whether to automatically detect DevOps secrets (AWS keys, JWTs, DB URIs, Stripe, OpenAI keys). */
+    detectSecrets?: boolean;
     customRules?: CustomRule[];
     tokenLabelMap?: Record<string, string>;
     generateReceipt?: boolean;
@@ -174,6 +178,170 @@ export function createLangChainTransform(options?: SanitizeOptions): {
     postprocess: (output: string, tokenMap: Record<string, string>) => RestoreResult;
 };
 
+export interface ApplyPatchOptions {
+    tokenMap?: Record<string, string>;
+    engine?: PrivacyScrubberEngine;
+    createBackup?: boolean;
+}
+
+export interface ApplyPatchResult {
+    success: boolean;
+    filePath: string;
+    restoredCount: number;
+    backupCreated: boolean;
+    backupPath?: string;
+}
+
+export interface GuardExecParams {
+    command: string;
+    cwd?: string;
+    profile?: PiiProfile;
+    timeoutMs?: number;
+}
+
+export interface GuardExecResult {
+    command: string;
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    tokenCount: number;
+    telemetry: AuditTelemetry;
+    receipt: string;
+    responseText: string;
+}
+
+export interface GuardReadFileParams {
+    filePath: string;
+    maxLines?: number;
+    profile?: PiiProfile;
+}
+
+export interface GuardReadFileResult {
+    filePath: string;
+    content: string;
+    totalLines: number;
+    wasTruncated: boolean;
+    tokenCount: number;
+    telemetry: AuditTelemetry;
+    receipt: string;
+    responseText: string;
+}
+
+export interface GuardGitDiffParams {
+    staged?: boolean;
+    cwd?: string;
+    profile?: PiiProfile;
+}
+
+export interface GuardGitDiffResult {
+    diff: string;
+    isStaged: boolean;
+    tokenCount: number;
+    telemetry?: AuditTelemetry;
+    receipt?: string;
+    responseText: string;
+}
+
+export interface GuardedTools {
+    guardExec: {
+        name: 'guard_exec';
+        description: string;
+        parameters: object;
+        execute: (params: GuardExecParams) => Promise<GuardExecResult>;
+    };
+    guardReadFile: {
+        name: 'guard_read_file';
+        description: string;
+        parameters: object;
+        execute: (params: GuardReadFileParams) => Promise<GuardReadFileResult>;
+    };
+    guardApplyPatch: {
+        name: 'guard_apply_patch';
+        description: string;
+        parameters: object;
+        execute: (params: { filePath: string; content: string; createBackup?: boolean }) => Promise<ApplyPatchResult & { responseText: string }>;
+    };
+    guardGitDiff: {
+        name: 'guard_git_diff';
+        description: string;
+        parameters: object;
+        execute: (params?: GuardGitDiffParams) => Promise<GuardGitDiffResult>;
+    };
+    getDefinitions: () => Array<{ type: 'function'; function: { name: string; description: string; parameters: object } }>;
+    engine: PrivacyScrubberEngine;
+}
+
+/**
+ * Creates a Node.js Transform stream for zero-trust PII sanitization.
+ */
+export function createSanitizeStream(options?: SanitizeOptions & { engine?: PrivacyScrubberEngine }): any;
+
+/**
+ * Restores masked tokens in AI-generated code or text and writes directly to disk.
+ */
+export function applyPatch(filePath: string, content: string, options?: ApplyPatchOptions): ApplyPatchResult;
+export function restoreToFile(filePath: string, content: string, tokenMapOrOptions?: Record<string, string> | ApplyPatchOptions, options?: ApplyPatchOptions): ApplyPatchResult;
+
+/**
+ * Creates CISO-grade Zero-Trust Agentic Guard tools for AI agents.
+ */
+export function createGuardedTools(engineOrOptions?: PrivacyScrubberEngine | SanitizeOptions, toolConfig?: { cwd?: string; profile?: PiiProfile }): GuardedTools;
+
+/**
+ * Stream token restorer interface for zero-latency SSE chunk processing.
+ */
+export interface StreamTokenRestorer {
+    /** Pushes an incoming streaming chunk and returns immediately rehydrated text. */
+    push(chunk: string): string;
+    /** Flushes any buffered incomplete tokens at the end of the stream. */
+    flush(): string;
+    /** Returns a standard Web W3C TransformStream for piping Response streams. */
+    asTransformStream(): any;
+}
+
+/**
+ * Ergonomic 1-liner: string-in, sanitized string-out without metadata ceremonies.
+ * @param text - Plaintext prompt containing potential PII/secrets.
+ * @param profile - Compliance profile (Default: 'General').
+ * @returns Scrubbed string ready to send to LLM.
+ */
+export function clean(text: string, profile?: PiiProfile): string;
+
+/**
+ * Creates a stream token restorer that rehydrates masked tokens across chunk boundaries in real-time.
+ * @param tokenMap - Map of token bindings returned from sanitize().
+ */
+export function createStreamTokenRestorer(tokenMap?: Record<string, string>): StreamTokenRestorer;
+
+/**
+ * Wraps an AI streaming response (e.g. OpenAI stream, Vercel AI SDK textStream)
+ * and yields real-time plain chunks with all tokens restored on the fly.
+ * @param stream - AsyncIterable or ReadableStream of string chunks or delta objects.
+ * @param tokenMap - Map of token bindings returned from sanitize().
+ */
+export function wrapAiStream<T = any>(
+    stream: AsyncIterable<T> | any,
+    tokenMap: Record<string, string>
+): AsyncGenerator<string, void, unknown>;
+
+/**
+ * Zero-Trust wrapper for Next.js App Router Route Handlers (route.js / route.ts).
+ * Automatically intercepts incoming Request JSON body, sanitizes PII in RAM,
+ * and passes scrubbed body along with tokenMap and stream restorer factory.
+ */
+export function withPrivacyScrubber(
+    handler: (req: Request, context?: any, psContext?: { tokenMap: Record<string, string>; telemetry: AuditTelemetry; createStreamRestorer: () => StreamTokenRestorer }) => any,
+    options?: SanitizeOptions
+): (req: Request, context?: any) => Promise<any>;
+
+/**
+ * Express.js / Connect middleware for automatic zero-trust PII sanitization.
+ * Sanitizes req.body in local RAM and attaches req.psTokenMap, req.restore(), and req.createStreamRestorer().
+ */
+export function createExpressMiddleware(
+    options?: SanitizeOptions
+): (req: any, res: any, next: (err?: any) => void) => void;
+
 // Legacy exports
 export function scrubText(
     text: string,
@@ -198,10 +366,15 @@ export function unscrubText(
 };
 
 declare const defaultExport: {
+    clean: typeof clean;
     sanitize: typeof sanitize;
     scrub: typeof scrub;
     restore: typeof restore;
     unscrub: typeof unscrub;
+    createStreamTokenRestorer: typeof createStreamTokenRestorer;
+    wrapAiStream: typeof wrapAiStream;
+    withPrivacyScrubber: typeof withPrivacyScrubber;
+    createExpressMiddleware: typeof createExpressMiddleware;
     validateLicense: typeof validateLicense;
     validateLicenseKey: typeof validateLicenseKey;
     buildAuditTelemetry: typeof buildAuditTelemetry;
@@ -210,8 +383,13 @@ declare const defaultExport: {
     PrivacyScrubberLicenseError: typeof PrivacyScrubberLicenseError;
     wrapOpenAI: typeof wrapOpenAI;
     createLangChainTransform: typeof createLangChainTransform;
+    createSanitizeStream: typeof createSanitizeStream;
+    applyPatch: typeof applyPatch;
+    restoreToFile: typeof restoreToFile;
+    createGuardedTools: typeof createGuardedTools;
     scrubText: typeof scrubText;
     unscrubText: typeof unscrubText;
 };
 
 export default defaultExport;
+