@privacyscrubber/sdk 2.2.1 → 2.2.2

package/README.md

@@ -28,7 +28,7 @@ The official Node.js / TypeScript programmatic SDK for [PrivacyScrubber.com](htt
 | **DevOps Secrets Scanning** | **Built-in (AWS, JWT, DBs)** | Custom regex rules | Custom detectors | Custom classifiers |
 | **Cost Predictability** | **Free Tier / Flat $199/mo** | DevOps server maintenance | Pay-per-GB cloud fees | Pay-per-unit API fees |
 
-> 📊 **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).
+> 📊 **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-mcp/blob/main/docs/benchmarks/sdk-vs-presidio.md).
 
 ### 💡 The Breach Math vs SDK Math
 
@@ -139,6 +139,64 @@ export async function POST(req: Request) {
 
 ---
 
+### 3b. Real-Time LLM Streaming De-tokenization (`wrapAiStream`, `createStreamTokenRestorer`, `createNodeStreamTokenRestorer`)
+
+When LLMs stream responses via Server-Sent Events (SSE) or WebSockets, tokens can be split across arbitrary chunk boundaries (e.g. Chunk 1: `"Contact [EM"`, Chunk 2: `"AIL_1] at once"`). `StreamingDetokenizer` uses a zero-latency sliding window buffer to stitch and restore tokens on the fly without delaying stream output:
+
+```typescript
+import { streamText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import { sanitize, wrapAiStream } from '@privacyscrubber/sdk';
+
+export async function POST(req: Request) {
+    const { prompt } = await req.json();
+
+    // 1. Sanitize prompt in RAM
+    const { scrubbedText, tokenMap } = sanitize(prompt, { profile: 'General' });
+
+    // 2. Stream from LLM
+    const { textStream } = streamText({
+        model: openai('gpt-4o'),
+        prompt: scrubbedText,
+    });
+
+    // 3. Wrap stream — split tokens ([EM + AIL_1]) are rehydrated in real-time!
+    const restoredStream = wrapAiStream(textStream, tokenMap);
+
+    // 4. Return SSE stream to client with authentic values restored
+    return new Response(restoredStream);
+}
+```
+
+#### Transparent OpenAI Streaming (`wrapOpenAI` with `stream: true`):
+```typescript
+import OpenAI from 'openai';
+import { wrapOpenAI } from '@privacyscrubber/sdk';
+
+const client = wrapOpenAI(new OpenAI(), { profile: 'Dev' });
+
+const stream = await client.chat.completions.create({
+    model: 'gpt-4o',
+    messages: [{ role: 'user', content: 'Debug AWS_KEY=AKIAIOSFODNN7EXAMPLE for user alice@acme.com' }],
+    stream: true, // Transparent real-time chunk de-tokenization!
+});
+
+for await (const chunk of stream) {
+    process.stdout.write(chunk.choices[0]?.delta?.content || '');
+}
+```
+
+#### Node.js Pipeline Streaming (`createNodeStreamTokenRestorer`):
+```javascript
+import { pipeline } from 'node:stream/promises';
+import { createNodeStreamTokenRestorer } from '@privacyscrubber/sdk';
+
+const restorer = createNodeStreamTokenRestorer(tokenMap);
+await pipeline(readableLlmStream, restorer, clientResponseStream);
+```
+
+---
+
 ### 4. LangChain (LCEL Pipelines & `createLangChainTransform`)
 
 Use the official middleware helper or compose inside LangChain Expression Language (LCEL) chains:

package/cli.js

@@ -13,7 +13,7 @@ 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';
+import { sanitize, restore, generateProcurementMemo, StreamingDetokenizer } from './index.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -21,7 +21,7 @@ const __dirname = path.dirname(__filename);
 const args = process.argv.slice(2);
 
 if (args.includes('--version') || args.includes('-v')) {
-  let version = '2.2.0';
+  let version = '2.2.2';
   try {
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, 'package.json'), 'utf8'));
     version = pkg.version || version;
@@ -30,6 +30,76 @@ if (args.includes('--version') || args.includes('-v')) {
   process.exit(0);
 }
 
+// ── Memo Command: Generate CISO / DPO Procurement Memorandum ──────
+if (args.includes('memo') || args.includes('--memo') || args.includes('--procurement-memo')) {
+  let format = 'markdown';
+  const formatIdx = args.indexOf('--format');
+  if (formatIdx !== -1 && args[formatIdx + 1]) {
+    format = args[formatIdx + 1];
+  }
+  let appName = 'Internal AI Applications & LLM Pipelines';
+  const appIdx = args.indexOf('--app');
+  if (appIdx !== -1 && args[appIdx + 1]) {
+    appName = args[appIdx + 1];
+  }
+  let developer = 'Engineering / AI Platform Team';
+  const devIdx = args.indexOf('--developer') !== -1 ? args.indexOf('--developer') : args.indexOf('--dev');
+  if (devIdx !== -1 && args[devIdx + 1]) {
+    developer = args[devIdx + 1];
+  }
+
+  const memo = generateProcurementMemo({ appName, developer, format });
+  process.stdout.write(memo.endsWith('\n') ? memo : memo + '\n');
+  process.exit(0);
+}
+
+// ── Demo Command: Live In-Memory Benchmark & Zero-Trust Inspection ──
+if (args.includes('demo') || args.includes('--demo')) {
+  const sampleInput = `DevOps Incident Report #4829
+Reporter: Sarah Connor (sarah.connor@cyberdyne.io, +1-415-555-0199, SSN 987-65-4321)
+Host: prod-api-04.us-east-1.internal (10.0.42.15)
+AWS Credentials: AKIAIOSFODNN7EXAMPLE / wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
+Stripe API Key: sk_live_51OzTestDummyStripeKey998877665544332211
+Database URI: postgresql://admin:SuperSecretPassword123@db-prod.internal:5432/production
+Status: Database connection timeout during batch export.`;
+
+  const start = process.hrtime.bigint();
+  const res = sanitize(sampleInput, { profile: 'Dev', detectSecrets: true });
+  const end = process.hrtime.bigint();
+  const durationUs = Number(end - start) / 1000;
+  const durationMs = (durationUs / 1000).toFixed(3);
+
+  const maskedCount = Object.keys(res.tokenMap || {}).length;
+  const border = '═'.repeat(66);
+  const thin = '─'.repeat(66);
+
+  console.log(`
+╔${border}╗
+║  PrivacyScrubber Developer SDK — Live In-Memory Benchmark        ║
+║  Standard: Zero-Trust Data Sanitization (ZTDS)                   ║
+╠${border}╣
+║  Input Characters : ${sampleInput.length.toString().padEnd(44)} ║
+║  Protected Tokens  : ${maskedCount.toString().padEnd(44)} ║
+║  Execution Latency : ${(durationMs + ' ms (' + durationUs.toFixed(0) + ' µs)').padEnd(44)} ║
+║  Network Egress    : 0 bytes (Pure in-memory process RAM)        ║
+║  Risk Level        : ${(res.telemetry?.riskLevel || 'CLEAN').padEnd(44)} ║
+║  Frameworks        : ${(res.telemetry?.frameworksList?.slice(0, 3).join(', ') || 'GDPR, SOC 2, NIST').padEnd(44)} ║
+╟${thin}╢
+║  RAW INPUT PREVIEW:                                              ║
+${sampleInput.split('\n').map(l => `║  ${l.slice(0, 62).padEnd(64)}║`).join('\n')}
+╟${thin}╢
+║  SANITIZED OUTPUT (Safe for LLM Egress):                         ║
+${res.scrubbedText.split('\n').map(l => `║  ${l.slice(0, 62).padEnd(64)}║`).join('\n')}
+╟${thin}╢
+║  NEXT STEPS & PROCUREMENT:                                       ║
+║  * Copy CISO Approval Memo : npx @privacyscrubber/sdk memo       ║
+║  * CI/CD PR Stamp          : cat prompt.txt | sdk --verify-ci    ║
+║  * Unlimited SDK ($199/mo) : https://privacyscrubber.com/pricing  ║
+╚${border}╝
+`);
+  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
 
@@ -37,18 +107,37 @@ Usage:
   npx @privacyscrubber/sdk <fileOrText> [options]
   cat prompt.txt | npx @privacyscrubber/sdk [options]
   npx @privacyscrubber/sdk --verify-ci <fileOrText> [options]
+  npx @privacyscrubber/sdk memo [options]
+  npx @privacyscrubber/sdk demo
+
+Commands:
+  memo                 Generate executive CISO & DPO procurement memo
+  demo                 Run live in-memory benchmark (<0.1ms latency check)
 
 Options:
-  --verify-ci          Generate CI/CD PR verification stamp
-  --profile <name>     Specify detection profile (default: Dev)
+  --verify-ci          Generate CI/CD PR verification stamp (audit receipt)
+  --json               Output structured JSON (scrubbedText, tokenMap, telemetry)
+  --restore, --unscrub Restore masked tokens in text back to original values
+  --stream             Stream de-tokenization chunks in real-time from stdin
+  --token-map <path>   Path to JSON file or inline JSON string of token mappings
+  --profile <name>     Specify detection profile (default: Dev, 30 profiles available)
   --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 prompt.txt | npx @privacyscrubber/sdk --json
   cat build.log | npx @privacyscrubber/sdk --verify-ci
+  npx @privacyscrubber/sdk memo > CISO_APPROVAL_MEMO.md
+  npx @privacyscrubber/sdk demo
   npx @privacyscrubber/sdk "Contact Alice at alice@acme.com" --profile dev
+  echo "Hello [NAME_1]" | npx @privacyscrubber/sdk --restore --token-map '{"[NAME_1]":"Alice"}'
+  cat stream.txt | npx @privacyscrubber/sdk --restore --stream --token-map tokens.json
+
+Commercial Licensing:
+  Developer SDK ($199/mo flat): https://privacyscrubber.com/pricing?tier=sdk&src=cli_help
+  Teams ($99/mo flat):          https://privacyscrubber.com/pricing?tier=teams&src=cli_help
 `);
   process.exit(0);
 }
@@ -66,30 +155,60 @@ if (keyIdx !== -1 && args[keyIdx + 1]) {
 }
 
 const isVerifyCi = args.includes('--verify-ci');
+const isJson = args.includes('--json');
+const isRestore = args.includes('--restore') || args.includes('--unscrub');
+const isStream = args.includes('--stream');
+
+let tokenMap = {};
+const mapIdx = args.indexOf('--token-map');
+if (mapIdx !== -1 && args[mapIdx + 1]) {
+  const mapSource = args[mapIdx + 1];
+  try {
+    if (fs.existsSync(mapSource)) {
+      tokenMap = JSON.parse(fs.readFileSync(mapSource, 'utf8'));
+    } else {
+      tokenMap = JSON.parse(mapSource);
+    }
+  } catch (err) {
+    console.error(`[PrivacyScrubber CLI Error] Failed to parse --token-map: ${err.message}`);
+    process.exit(1);
+  }
+}
 
 // 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); }
+if (mapIdx !== -1) { skipIndices.add(mapIdx); skipIndices.add(mapIdx + 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] === '--verify-ci' || args[i] === '--json' || args[i] === '--restore' || args[i] === '--unscrub') continue;
   if (args[i].startsWith('-')) continue;
   inputArg = args[i];
   break;
 }
 
 function handleExecution(text) {
+  if (isRestore) {
+    const { restoredText, restoredCount } = restore(text, tokenMap);
+    if (isJson) {
+      console.log(JSON.stringify({ restoredText, restoredCount }, null, 2));
+    } else {
+      process.stdout.write(restoredText.endsWith('\n') ? restoredText : restoredText + '\n');
+    }
+    process.exit(0);
+  }
+
   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`);
+      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\n> * **Compliance Spec:** [Zero-Trust Data Sanitization (ZTDS)](https://privacyscrubber.com/solutions/engineering/zero-trust-ai-data-sanitization?src=ci_stamp) | [Developer SDK ($199/mo)](https://privacyscrubber.com/pricing?tier=sdk&src=ci_stamp)`);
       process.exit(0);
     }
 
-    const { scrubbedText, tokenMap, telemetry } = sanitize(text, { profile, detectSecrets: true });
-    const maskedCount = Object.keys(tokenMap || {}).length;
+    const { scrubbedText, tokenMap: resMap, telemetry } = sanitize(text, { profile, detectSecrets: true });
+    const maskedCount = Object.keys(resMap || {}).length;
     const hash = crypto.createHash('sha256').update(scrubbedText).digest('hex').slice(0, 16);
 
     const stamp = `
@@ -97,17 +216,31 @@ function handleExecution(text) {
 > * **Status:** ✅ PASSED · ${maskedCount} item(s) protected (${telemetry?.riskLevel || 'CLEAN'})
 > * **Execution:** Local RAM (<1ms) · 0 Network Egress Bytes
 > * **Audit Hash:** \`${hash}\` (Zero-Trust Verified)
+> * **Compliance Spec:** [Zero-Trust Data Sanitization (ZTDS)](https://privacyscrubber.com/solutions/engineering/zero-trust-ai-data-sanitization?src=ci_stamp) | [Developer SDK ($199/mo)](https://privacyscrubber.com/pricing?tier=sdk&src=ci_stamp)
 `;
     console.log(stamp.trim());
     process.exit(0);
-  } else {
-    if (!text) {
-      process.exit(0);
+  }
+
+  if (!text) {
+    if (isJson) {
+      console.log(JSON.stringify({ scrubbedText: '', tokenMap: {}, count: 0 }, null, 2));
     }
-    const { scrubbedText } = sanitize(text, { profile, detectSecrets: true });
-    process.stdout.write(scrubbedText.endsWith('\n') ? scrubbedText : scrubbedText + '\n');
     process.exit(0);
   }
+
+  const res = sanitize(text, { profile, detectSecrets: true });
+  if (isJson) {
+    console.log(JSON.stringify({
+      scrubbedText: res.scrubbedText,
+      tokenMap: res.tokenMap,
+      count: res.count,
+      telemetry: res.telemetry
+    }, null, 2));
+  } else {
+    process.stdout.write(res.scrubbedText.endsWith('\n') ? res.scrubbedText : res.scrubbedText + '\n');
+  }
+  process.exit(0);
 }
 
 if (inputArg) {
@@ -118,12 +251,26 @@ if (inputArg) {
     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);
-  });
+  if (isStream && isRestore) {
+    const detok = new StreamingDetokenizer(tokenMap);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+      const out = detok.feed(chunk);
+      if (out) process.stdout.write(out);
+    });
+    process.stdin.on('end', () => {
+      const finalOut = detok.flush();
+      if (finalOut) process.stdout.write(finalOut);
+      process.exit(0);
+    });
+  } else {
+    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

@@ -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>;
 }
 
 /**
@@ -292,13 +316,38 @@ export function createGuardedTools(engineOrOptions?: PrivacyScrubberEngine | San
  */
 export interface StreamTokenRestorer {
     /** Pushes an incoming streaming chunk and returns immediately rehydrated text. */
-    push(chunk: string): string;
+    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;
-    /** Returns a standard Web W3C TransformStream for piping Response streams. */
-    asTransformStream(): any;
+    /** 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.
@@ -310,8 +359,16 @@ 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>): StreamTokenRestorer;
+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)
@@ -321,8 +378,8 @@ export function createStreamTokenRestorer(tokenMap?: Record<string, string>): St
  */
 export function wrapAiStream<T = any>(
     stream: AsyncIterable<T> | any,
-    tokenMap: Record<string, string>
-): AsyncGenerator<string, void, unknown>;
+    tokenMap?: Record<string, string>
+): AsyncGenerator<any, void, unknown>;
 
 /**
  * Zero-Trust wrapper for Next.js App Router Route Handlers (route.js / route.ts).
@@ -371,7 +428,10 @@ declare const defaultExport: {
     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;
@@ -379,6 +439,7 @@ declare const defaultExport: {
     validateLicenseKey: typeof validateLicenseKey;
     buildAuditTelemetry: typeof buildAuditTelemetry;
     formatAuditReceipt: typeof formatAuditReceipt;
+    generateProcurementMemo: typeof generateProcurementMemo;
     PrivacyScrubberEngine: typeof PrivacyScrubberEngine;
     PrivacyScrubberLicenseError: typeof PrivacyScrubberLicenseError;
     wrapOpenAI: typeof wrapOpenAI;