@privacyscrubber/sdk 2.2.0 → 2.2.2

package/index.d.ts

@@ -34,6 +34,7 @@ export type PiiProfile =
     | 'Insurance'
     | 'Accounting'
     | 'Pharma'
+    | 'Biotech'
     | 'Underwriting'
     | 'Crypto'
     | 'Cloud'
@@ -69,12 +70,15 @@ export interface SanitizeOptions {
     generateReceipt?: boolean;
     /** Throw PrivacyScrubberLicenseError when free tier limits are reached (Default: true). */
     throwOnLimit?: boolean;
+    /** Strategy when free tier limit is exceeded: 'throw' (default) or 'truncate' (soft limit with notification). */
+    onLimit?: 'throw' | 'truncate';
 }
 
 export interface LicenseMetadata {
     isPro: boolean;
     tier: 'PRO' | 'TEAMS' | 'SDK' | 'ENTERPRISE' | 'OEM' | 'FREE';
     limit: number;
+    wasTruncated?: boolean;
     upgradeUrl?: string;
     recommendation?: string;
 }
@@ -132,6 +136,24 @@ export function validateLicenseKey(key: string): 'PRO' | 'TEAMS' | 'SDK' | 'ENTE
 export function buildAuditTelemetry(currentTokenMap?: Record<string, string> | string[]): AuditTelemetry;
 export function formatAuditReceipt(telemetry: AuditTelemetry): string;
 
+export interface ProcurementMemoOptions {
+    /** Target application or pipeline name (Default: 'Internal AI Applications & LLM Pipelines'). */
+    appName?: string;
+    /** Team or developer name (Default: 'Engineering / AI Platform Team'). */
+    developer?: string;
+    /** Output format: 'markdown' or 'text' (Default: 'markdown'). */
+    format?: 'markdown' | 'text';
+    /** Number of engineers on the team (Default: 10). */
+    teamSize?: number;
+    /** Estimated monthly prompt volume (Default: '50M - 500M characters/month'). */
+    estimatedVolume?: string;
+}
+
+/**
+ * Generates an executive CISO & Legal Procurement Memo for enterprise approval of @privacyscrubber/sdk.
+ */
+export function generateProcurementMemo(options?: ProcurementMemoOptions): string;
+
 /**
  * Sanitizes input text, masking all PII and secrets with zero network requests.
  */
@@ -163,6 +185,8 @@ export class PrivacyScrubberEngine {
     sanitize(text: string, options?: SanitizeOptions & { persistSession?: boolean }): SanitizeResult;
     restore(aiResponse: string, tokenMap?: Record<string, string> | null): RestoreResult;
     resetSession(): void;
+    createStreamRestorer(tokenMap?: Record<string, string> | null, options?: any): StreamTokenRestorer;
+    wrapStream<T = any>(stream: AsyncIterable<T>, tokenMap?: Record<string, string> | null, options?: any): AsyncGenerator<any, void, unknown>;
 }
 
 /**
@@ -287,6 +311,94 @@ export function restoreToFile(filePath: string, content: string, tokenMapOrOptio
  */
 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 | Uint8Array | any): string;
+    /** Feeds an incoming chunk and returns de-tokenized text. */
+    feed(chunk: string | Uint8Array | any): string;
+    /** Alias for feed. */
+    process(chunk: string | Uint8Array | any): string;
+    /** Flushes any buffered incomplete tokens at the end of the stream. */
+    flush(): string;
+    /** Wraps an async iterable LLM stream yielding de-tokenized chunks in real-time. */
+    wrapStream<T = any>(asyncIterable: AsyncIterable<T>): AsyncGenerator<any, void, unknown>;
+    /** Converts to a native Node.js Transform stream for .pipe() or stream.pipeline(). */
+    toNodeTransform(): any;
+    /** Underlying StreamingDetokenizer instance. */
+    detokenizer: StreamingDetokenizer;
+}
+
+/**
+ * High-performance streaming de-tokenization engine with sliding-window chunk boundary buffering.
+ */
+export class StreamingDetokenizer {
+    constructor(tokenMap?: Record<string, string>, options?: any);
+    feed(chunk: string | Uint8Array | any): string;
+    process(chunk: string | Uint8Array | any): string;
+    flush(): string;
+    toNodeTransform(): any;
+    wrapStream<T = any>(asyncIterable: AsyncIterable<T>): AsyncGenerator<any, void, unknown>;
+}
+
+/**
+ * Builds an ultra-fast streaming token replacement function preserving all whitespace.
+ */
+export function buildStreamReplacer(tokenMap?: Record<string, string>): (text: string) => string;
+
+/**
+ * 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().
+ * @param options - Optional configuration.
+ */
+export function createStreamTokenRestorer(tokenMap?: Record<string, string>, options?: any): StreamTokenRestorer;
+
+/**
+ * Creates a Node.js native Transform stream for backend streaming pipelines (stream.pipeline / .pipe()).
+ * @param tokenMap - Map of token bindings returned from sanitize().
+ * @param options - Optional configuration.
+ */
+export function createNodeStreamTokenRestorer(tokenMap?: Record<string, string>, options?: any): any;
+
+/**
+ * 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<any, 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,
@@ -311,14 +423,23 @@ export function unscrubText(
 };
 
 declare const defaultExport: {
+    clean: typeof clean;
     sanitize: typeof sanitize;
     scrub: typeof scrub;
     restore: typeof restore;
     unscrub: typeof unscrub;
+    StreamingDetokenizer: typeof StreamingDetokenizer;
+    createStreamTokenRestorer: typeof createStreamTokenRestorer;
+    createNodeStreamTokenRestorer: typeof createNodeStreamTokenRestorer;
+    buildStreamReplacer: typeof buildStreamReplacer;
+    wrapAiStream: typeof wrapAiStream;
+    withPrivacyScrubber: typeof withPrivacyScrubber;
+    createExpressMiddleware: typeof createExpressMiddleware;
     validateLicense: typeof validateLicense;
     validateLicenseKey: typeof validateLicenseKey;
     buildAuditTelemetry: typeof buildAuditTelemetry;
     formatAuditReceipt: typeof formatAuditReceipt;
+    generateProcurementMemo: typeof generateProcurementMemo;
     PrivacyScrubberEngine: typeof PrivacyScrubberEngine;
     PrivacyScrubberLicenseError: typeof PrivacyScrubberLicenseError;
     wrapOpenAI: typeof wrapOpenAI;
@@ -332,3 +453,4 @@ declare const defaultExport: {
 };
 
 export default defaultExport;
+