@privacyscrubber/sdk 2.4.4 → 2.4.6

package/index.cjs

@@ -32,6 +32,16 @@ if (scrubberPkg && typeof scrubberPkg.init === 'function') {
     scrubberPkg.init();
 }
 
+const SDK_VERSION = (() => {
+    try {
+        const pkgJson = require('./package.json');
+        if (pkgJson && typeof pkgJson.version === 'string') {
+            return pkgJson.version;
+        }
+    } catch (_) {}
+    return '2.4.6';
+})();
+
 /**
  * Built-in patterns for DevOps & Cloud Secrets detection.
  */
@@ -540,8 +550,17 @@ function sanitize(text, options = {}) {
         wasTruncated = true;
     }
 
+    // Filter user-supplied custom rules against catastrophic backtracking (PS-VDP-2026-10-002 parity)
+    const nestedQuantifierRegex = /\([^)]*(\+|\*|\{\d+,?\d*\})\)[+*]|\([^)]*(\+|\*|\{\d+,?\d*\})\)\{\d+,?\d*\}|\([^)]*\|[^)]*\)(?:[+*]|\{\d+,?\d*\})/;
+    const safeCustomRules = (Array.isArray(customRules) ? customRules : []).filter(r => {
+        const pat = typeof r === 'string' ? r : (r && (r.pattern || (r.regex && r.regex.source)));
+        if (!pat || typeof pat !== 'string' || pat.length > 500) return false;
+        if (nestedQuantifierRegex.test(pat)) return false;
+        return true;
+    });
+
     // Auto-inject DevOps Secrets rules when in Dev profile or when detectSecrets is requested
-    const activeRules = [...customRules];
+    const activeRules = [...safeCustomRules];
     if (profile.toLowerCase() === 'dev' || detectSecrets === true) {
         DEVOPS_SECRETS_DETECTOR.forEach(rule => {
             activeRules.push({
@@ -713,6 +732,21 @@ function sanitizeObject(obj, options = {}) {
 
     const mergedSessionMap = { ...(options.existingSessionMap || {}) };
     let totalCount = 0;
+    const seen = new WeakMap();
+
+    function isNonPlainObject(val) {
+        return (
+            val instanceof Date ||
+            val instanceof RegExp ||
+            val instanceof Error ||
+            val instanceof Promise ||
+            val instanceof WeakMap ||
+            val instanceof WeakSet ||
+            (typeof URL !== 'undefined' && val instanceof URL) ||
+            ArrayBuffer.isView(val) ||
+            (typeof ArrayBuffer !== 'undefined' && val instanceof ArrayBuffer)
+        );
+    }
 
     function traverseAndSanitize(val) {
         if (val === null || val === undefined) return val;
@@ -727,20 +761,42 @@ function sanitizeObject(obj, options = {}) {
             totalCount += res.count;
             return res.scrubbedText;
         }
+        if (typeof val !== 'object') return val;
+        if (isNonPlainObject(val)) return val;
+        if (seen.has(val)) return seen.get(val);
+
         if (Array.isArray(val)) {
-            return val.map(item => traverseAndSanitize(item));
+            const outArr = [];
+            seen.set(val, outArr);
+            for (let i = 0; i < val.length; i++) {
+                outArr.push(traverseAndSanitize(val[i]));
+            }
+            return outArr;
         }
-        if (val instanceof Date || val instanceof RegExp) {
-            return val;
+        if (val instanceof Map) {
+            const outMap = new Map();
+            seen.set(val, outMap);
+            for (const [k, v] of val.entries()) {
+                outMap.set(k, traverseAndSanitize(v));
+            }
+            return outMap;
         }
-        if (typeof val === 'object') {
-            const out = {};
-            for (const [k, v] of Object.entries(val)) {
-                out[k] = traverseAndSanitize(v);
+        if (val instanceof Set) {
+            const outSet = new Set();
+            seen.set(val, outSet);
+            for (const item of val.values()) {
+                outSet.add(traverseAndSanitize(item));
             }
-            return out;
+            return outSet;
         }
-        return val;
+
+        const out = {};
+        seen.set(val, out);
+        for (const [k, v] of Object.entries(val)) {
+            if (k === '__proto__' || k === 'constructor' || k === 'prototype') continue;
+            out[k] = traverseAndSanitize(v);
+        }
+        return out;
     }
 
     const sanitizedResult = traverseAndSanitize(obj);
@@ -770,23 +826,62 @@ function sanitizeObject(obj, options = {}) {
  * @param {Record<string, string>} tokenMap - Token map returned from sanitize() or sanitizeObject().
  * @returns {any} - Restored object with original values.
  */
-function restoreObject(obj, tokenMap = {}) {
+function restoreObject(obj, tokenMap = {}, _seen = null) {
     if (obj === null || obj === undefined) return obj;
     if (typeof obj === 'string') {
         const res = restore(obj, tokenMap);
         return res.restoredText;
     }
+    if (typeof obj !== 'object') return obj;
+    if (
+        obj instanceof Date ||
+        obj instanceof RegExp ||
+        obj instanceof Error ||
+        obj instanceof Promise ||
+        obj instanceof WeakMap ||
+        obj instanceof WeakSet ||
+        (typeof URL !== 'undefined' && obj instanceof URL) ||
+        ArrayBuffer.isView(obj) ||
+        (typeof ArrayBuffer !== 'undefined' && obj instanceof ArrayBuffer)
+    ) {
+        return obj;
+    }
+
+    const seen = _seen || new WeakMap();
+    if (seen.has(obj)) return seen.get(obj);
+
     if (Array.isArray(obj)) {
-        return obj.map(item => restoreObject(item, tokenMap));
+        const outArr = [];
+        seen.set(obj, outArr);
+        for (let i = 0; i < obj.length; i++) {
+            outArr.push(restoreObject(obj[i], tokenMap, seen));
+        }
+        return outArr;
     }
-    if (typeof obj === 'object' && !(obj instanceof Date) && !(obj instanceof RegExp)) {
-        const out = {};
-        for (const [k, v] of Object.entries(obj)) {
-            out[k] = restoreObject(v, tokenMap);
+    if (obj instanceof Map) {
+        const outMap = new Map();
+        seen.set(obj, outMap);
+        for (const [k, v] of obj.entries()) {
+            outMap.set(k, restoreObject(v, tokenMap, seen));
         }
-        return out;
+        return outMap;
+    }
+    if (obj instanceof Set) {
+        const outSet = new Set();
+        seen.set(obj, outSet);
+        for (const item of obj.values()) {
+            outSet.add(restoreObject(item, tokenMap, seen));
+        }
+        return outSet;
     }
-    return obj;
+
+    const out = {};
+    seen.set(obj, out);
+    for (const [k, v] of Object.entries(obj)) {
+        if (k === '__proto__' || k === 'constructor' || k === 'prototype') continue;
+        out[k] = restoreObject(v, tokenMap, seen);
+    }
+    return out;
 }
 
 /**
@@ -829,12 +924,16 @@ class PrivacyScrubberEngine {
                 .forEach(v => mergedIgnoreList.add(v));
         }
 
+        const effectiveExistingMap = options.persistSession !== false
+            ? { ...this.sessionMap, ...(options.existingSessionMap || {}) }
+            : (options.existingSessionMap || {});
+
         const mergedOptions = {
             profile: options.profile || this.defaultProfile,
             licenseKey: options.licenseKey || this.licenseKey,
             customRules: [...this.customRules, ...(options.customRules || [])],
             tokenLabelMap: { ...this.tokenLabelMap, ...(options.tokenLabelMap || {}) },
-            existingSessionMap: options.persistSession !== false ? this.sessionMap : (options.existingSessionMap || {}),
+            existingSessionMap: effectiveExistingMap,
             generateReceipt: options.generateReceipt !== undefined ? options.generateReceipt : this.generateReceipt,
             throwOnLimit: options.throwOnLimit !== undefined ? options.throwOnLimit : true,
             detectSecrets: options.detectSecrets !== undefined ? options.detectSecrets : false,
@@ -934,68 +1033,229 @@ class PrivacyScrubberEngine {
  * @returns {object} Wrapped OpenAI client.
  */
 function wrapOpenAI(openaiClient, options = {}) {
-    if (!openaiClient || !openaiClient.chat || !openaiClient.chat.completions) {
+    const hasChatCompletions = !!(openaiClient && openaiClient.chat && openaiClient.chat.completions && typeof openaiClient.chat.completions.create === 'function');
+    const hasResponses = !!(openaiClient && openaiClient.responses && typeof openaiClient.responses.create === 'function');
+    if (!hasChatCompletions && !hasResponses) {
         throw new Error('[PrivacyScrubber] Invalid OpenAI client instance passed to wrapOpenAI.');
     }
 
     const engine = new PrivacyScrubberEngine(options);
-    const originalCreate = openaiClient.chat.completions.create.bind(openaiClient.chat.completions);
 
-    openaiClient.chat.completions.create = async function(params, requestOptions) {
-        if (!params || !Array.isArray(params.messages)) {
-            return originalCreate(params, requestOptions);
+    function sanitizeMessageContent(content, sessionTokenMap) {
+        if (typeof content === 'string') {
+            const res = engine.sanitize(content, { existingSessionMap: sessionTokenMap });
+            Object.assign(sessionTokenMap, res.tokenMap);
+            return res.scrubbedText;
+        }
+        if (Array.isArray(content)) {
+            return content.map(chunk => {
+                if (chunk && (chunk.type === 'text' || chunk.type === 'input_text') && typeof chunk.text === 'string') {
+                    const res = engine.sanitize(chunk.text, { existingSessionMap: sessionTokenMap });
+                    Object.assign(sessionTokenMap, res.tokenMap);
+                    return { ...chunk, text: res.scrubbedText };
+                }
+                return chunk;
+            });
         }
+        return content;
+    }
 
-        const sessionTokenMap = {};
-        const sanitizedMessages = params.messages.map(msg => {
-            if (typeof msg.content === 'string') {
-                const res = engine.sanitize(msg.content, { existingSessionMap: sessionTokenMap });
+    if (hasChatCompletions) {
+        const originalCreate = openaiClient.chat.completions.create.bind(openaiClient.chat.completions);
+
+        openaiClient.chat.completions.create = async function(params, requestOptions) {
+            if (!params || !Array.isArray(params.messages)) {
+                return originalCreate(params, requestOptions);
+            }
+
+            const sessionTokenMap = options.persistSession === false ? {} : { ...engine.sessionMap };
+            const sanitizedMessages = params.messages.map(msg => ({
+                ...msg,
+                content: sanitizeMessageContent(msg.content, sessionTokenMap)
+            }));
+
+            const modifiedParams = { ...params, messages: sanitizedMessages };
+            const response = await originalCreate(modifiedParams, requestOptions);
+
+            // Streaming support: transparently de-tokenize async iterable chunks
+            if (params.stream) {
+                const detok = new StreamingDetokenizer(sessionTokenMap);
+                return detok.wrapStream(response);
+            }
+
+            if (response && Array.isArray(response.choices)) {
+                response.choices.forEach(choice => {
+                    if (choice.message) {
+                        if (typeof choice.message.content === 'string') {
+                            choice.message.content = engine.restore(choice.message.content, sessionTokenMap).restoredText;
+                        } else if (Array.isArray(choice.message.content)) {
+                            choice.message.content = choice.message.content.map(chunk => {
+                                if (chunk && chunk.type === 'text' && typeof chunk.text === 'string') {
+                                    return { ...chunk, text: engine.restore(chunk.text, sessionTokenMap).restoredText };
+                                }
+                                return chunk;
+                            });
+                        }
+                    }
+                });
+            }
+
+            return response;
+        };
+    }
+
+    if (hasResponses) {
+        const originalResponsesCreate = openaiClient.responses.create.bind(openaiClient.responses);
+
+        openaiClient.responses.create = async function(params, requestOptions) {
+            if (!params || typeof params !== 'object') {
+                return originalResponsesCreate(params, requestOptions);
+            }
+
+            const sessionTokenMap = options.persistSession === false ? {} : { ...engine.sessionMap };
+            const modifiedParams = { ...params };
+
+            if (typeof modifiedParams.instructions === 'string') {
+                const res = engine.sanitize(modifiedParams.instructions, { existingSessionMap: sessionTokenMap });
                 Object.assign(sessionTokenMap, res.tokenMap);
-                return { ...msg, content: res.scrubbedText };
-            } else if (Array.isArray(msg.content)) {
-                const sanitizedChunks = msg.content.map(chunk => {
-                    if (chunk && chunk.type === 'text' && typeof chunk.text === 'string') {
-                        const res = engine.sanitize(chunk.text, { existingSessionMap: sessionTokenMap });
+                modifiedParams.instructions = res.scrubbedText;
+            }
+
+            if (typeof modifiedParams.input === 'string') {
+                const res = engine.sanitize(modifiedParams.input, { existingSessionMap: sessionTokenMap });
+                Object.assign(sessionTokenMap, res.tokenMap);
+                modifiedParams.input = res.scrubbedText;
+            } else if (Array.isArray(modifiedParams.input)) {
+                modifiedParams.input = modifiedParams.input.map(item => {
+                    if (typeof item === 'string') {
+                        const res = engine.sanitize(item, { existingSessionMap: sessionTokenMap });
                         Object.assign(sessionTokenMap, res.tokenMap);
-                        return { ...chunk, text: res.scrubbedText };
+                        return res.scrubbedText;
+                    }
+                    if (item && typeof item === 'object') {
+                        return {
+                            ...item,
+                            ...(item.content !== undefined && { content: sanitizeMessageContent(item.content, sessionTokenMap) }),
+                            ...(typeof item.text === 'string' && {
+                                text: (() => {
+                                    const res = engine.sanitize(item.text, { existingSessionMap: sessionTokenMap });
+                                    Object.assign(sessionTokenMap, res.tokenMap);
+                                    return res.scrubbedText;
+                                })()
+                            })
+                        };
                     }
-                    return chunk;
+                    return item;
                 });
-                return { ...msg, content: sanitizedChunks };
             }
-            return msg;
-        });
 
-        const modifiedParams = { ...params, messages: sanitizedMessages };
+            const response = await originalResponsesCreate(modifiedParams, requestOptions);
+
+            if (params.stream) {
+                const detok = new StreamingDetokenizer(sessionTokenMap);
+                return detok.wrapStream(response);
+            }
+
+            if (response && typeof response === 'object') {
+                if (typeof response.output_text === 'string') {
+                    try {
+                        response.output_text = engine.restore(response.output_text, sessionTokenMap).restoredText;
+                    } catch (_) {}
+                }
+                if (Array.isArray(response.output)) {
+                    response.output.forEach(outItem => {
+                        if (outItem && Array.isArray(outItem.content)) {
+                            outItem.content.forEach(block => {
+                                if (block && typeof block.text === 'string') {
+                                    block.text = engine.restore(block.text, sessionTokenMap).restoredText;
+                                }
+                            });
+                        }
+                    });
+                }
+            }
+
+            return response;
+        };
+    }
+
+    return openaiClient;
+}
+
+/**
+ * Transparent Zero-Trust wrapper for Anthropic SDK (@anthropic-ai/sdk).
+ * Automatically scrubs system prompts and user/assistant messages in local RAM
+ * before sending to Anthropic, and restores masked tokens in both synchronous
+ * and streaming responses.
+ *
+ * @param {object} anthropicClient - Instance of Anthropic SDK (e.g. new Anthropic()).
+ * @param {object} [options={}] - PrivacyScrubber configuration.
+ * @returns {object} Wrapped Anthropic client.
+ */
+function wrapAnthropic(anthropicClient, options = {}) {
+    if (!anthropicClient || !anthropicClient.messages || typeof anthropicClient.messages.create !== 'function') {
+        throw new Error('[PrivacyScrubber] Invalid Anthropic client instance passed to wrapAnthropic.');
+    }
+
+    const engine = new PrivacyScrubberEngine(options);
+    const originalCreate = anthropicClient.messages.create.bind(anthropicClient.messages);
+
+    function sanitizeAnthropicContent(content, sessionTokenMap) {
+        if (typeof content === 'string') {
+            const res = engine.sanitize(content, { existingSessionMap: sessionTokenMap });
+            Object.assign(sessionTokenMap, res.tokenMap);
+            return res.scrubbedText;
+        }
+        if (Array.isArray(content)) {
+            return content.map(block => {
+                if (block && block.type === 'text' && typeof block.text === 'string') {
+                    const res = engine.sanitize(block.text, { existingSessionMap: sessionTokenMap });
+                    Object.assign(sessionTokenMap, res.tokenMap);
+                    return { ...block, text: res.scrubbedText };
+                }
+                return block;
+            });
+        }
+        return content;
+    }
+
+    anthropicClient.messages.create = async function(params, requestOptions) {
+        if (!params || !Array.isArray(params.messages)) {
+            return originalCreate(params, requestOptions);
+        }
+
+        const sessionTokenMap = {};
+        const modifiedParams = { ...params };
+
+        if (modifiedParams.system !== undefined) {
+            modifiedParams.system = sanitizeAnthropicContent(modifiedParams.system, sessionTokenMap);
+        }
+
+        modifiedParams.messages = params.messages.map(msg => ({
+            ...msg,
+            content: sanitizeAnthropicContent(msg.content, sessionTokenMap)
+        }));
+
         const response = await originalCreate(modifiedParams, requestOptions);
 
-        // Streaming support: transparently de-tokenize async iterable chunks
         if (params.stream) {
             const detok = new StreamingDetokenizer(sessionTokenMap);
             return detok.wrapStream(response);
         }
 
-        if (response && Array.isArray(response.choices)) {
-            response.choices.forEach(choice => {
-                if (choice.message) {
-                    if (typeof choice.message.content === 'string') {
-                        choice.message.content = engine.restore(choice.message.content, sessionTokenMap).restoredText;
-                    } else if (Array.isArray(choice.message.content)) {
-                        choice.message.content = choice.message.content.map(chunk => {
-                            if (chunk && chunk.type === 'text' && typeof chunk.text === 'string') {
-                                return { ...chunk, text: engine.restore(chunk.text, sessionTokenMap).restoredText };
-                            }
-                            return chunk;
-                        });
-                    }
+        if (response && Array.isArray(response.content)) {
+            response.content = response.content.map(block => {
+                if (block && block.type === 'text' && typeof block.text === 'string') {
+                    return { ...block, text: engine.restore(block.text, sessionTokenMap).restoredText };
                 }
+                return block;
             });
         }
 
         return response;
     };
 
-    return openaiClient;
+    return anthropicClient;
 }
 
 /**
@@ -1014,25 +1274,43 @@ function wrapAiModel(model, options = {}) {
         throw new Error('[PrivacyScrubber] Invalid model instance passed to wrapAiModel.');
     }
 
-    const engine = new PrivacyScrubberEngine(options);
+    const engine = options.engine || new PrivacyScrubberEngine(options);
+    const sharedSessionMap = {};
     const wrapped = Object.create(model);
 
     function sanitizePromptParts(prompt, sessionMap) {
+        if (typeof prompt === 'string') {
+            const res = engine.sanitize(prompt, { existingSessionMap: sessionMap, persistSession: false });
+            Object.assign(sessionMap, res.tokenMap);
+            return res.scrubbedText;
+        }
         if (!Array.isArray(prompt)) return prompt;
         return prompt.map(msg => {
             if (!msg) return msg;
             if (typeof msg.content === 'string') {
-                const res = engine.sanitize(msg.content, { existingSessionMap: sessionMap });
+                const res = engine.sanitize(msg.content, { existingSessionMap: sessionMap, persistSession: false });
                 Object.assign(sessionMap, res.tokenMap);
                 return { ...msg, content: res.scrubbedText };
             }
             if (Array.isArray(msg.content)) {
                 const newContent = msg.content.map(part => {
-                    if (part && part.type === 'text' && typeof part.text === 'string') {
-                        const res = engine.sanitize(part.text, { existingSessionMap: sessionMap });
+                    if (part && (part.type === 'text' || part.type === 'reasoning') && typeof part.text === 'string') {
+                        const res = engine.sanitize(part.text, { existingSessionMap: sessionMap, persistSession: false });
                         Object.assign(sessionMap, res.tokenMap);
                         return { ...part, text: res.scrubbedText };
                     }
+                    if (part && part.type === 'tool-result') {
+                        if (typeof part.result === 'string') {
+                            const res = engine.sanitize(part.result, { existingSessionMap: sessionMap, persistSession: false });
+                            Object.assign(sessionMap, res.tokenMap);
+                            return { ...part, result: res.scrubbedText };
+                        }
+                        if (part.output && typeof part.output.value === 'string') {
+                            const res = engine.sanitize(part.output.value, { existingSessionMap: sessionMap, persistSession: false });
+                            Object.assign(sessionMap, res.tokenMap);
+                            return { ...part, output: { ...part.output, value: res.scrubbedText } };
+                        }
+                    }
                     return part;
                 });
                 return { ...msg, content: newContent };
@@ -1041,16 +1319,41 @@ function wrapAiModel(model, options = {}) {
         });
     }
 
+    function createScopedTokenMap(prompt) {
+        const sessionTokenMap = options.persistSession ? { ...sharedSessionMap } : {};
+        if (!options.persistSession && prompt && Object.keys(sharedSessionMap).length > 0) {
+            const s = typeof prompt === 'string' ? prompt : JSON.stringify(prompt);
+            for (const [tok, orig] of Object.entries(sharedSessionMap)) {
+                if (s.includes(tok)) sessionTokenMap[tok] = orig;
+            }
+        }
+        return sessionTokenMap;
+    }
+
     if (typeof model.doGenerate === 'function') {
         wrapped.doGenerate = async function(params) {
-            const sessionTokenMap = {};
+            const sessionTokenMap = createScopedTokenMap(params?.prompt);
             const sanitizedParams = {
                 ...params,
                 prompt: sanitizePromptParts(params.prompt, sessionTokenMap)
             };
+            Object.assign(sharedSessionMap, sessionTokenMap);
             const result = await model.doGenerate(sanitizedParams);
-            if (result && typeof result.text === 'string') {
-                result.text = engine.restore(result.text, sessionTokenMap).restoredText;
+            if (result) {
+                if (typeof result.text === 'string') {
+                    result.text = engine.restore(result.text, sessionTokenMap).restoredText;
+                }
+                if (typeof result.reasoning === 'string') {
+                    result.reasoning = engine.restore(result.reasoning, sessionTokenMap).restoredText;
+                }
+                if (Array.isArray(result.content)) {
+                    result.content = result.content.map(part => {
+                        if (part && (part.type === 'text' || part.type === 'reasoning') && typeof part.text === 'string') {
+                            return { ...part, text: engine.restore(part.text, sessionTokenMap).restoredText };
+                        }
+                        return part;
+                    });
+                }
             }
             return result;
         };
@@ -1058,43 +1361,87 @@ function wrapAiModel(model, options = {}) {
 
     if (typeof model.doStream === 'function') {
         wrapped.doStream = async function(params) {
-            const sessionTokenMap = {};
+            const sessionTokenMap = createScopedTokenMap(params?.prompt);
             const sanitizedParams = {
                 ...params,
                 prompt: sanitizePromptParts(params.prompt, sessionTokenMap)
             };
+            Object.assign(sharedSessionMap, sessionTokenMap);
             const result = await model.doStream(sanitizedParams);
             if (result && result.stream) {
                 const detok = new StreamingDetokenizer(sessionTokenMap);
                 const originalStream = result.stream;
+                let usesV2Delta = false;
 
                 if (typeof originalStream.pipeThrough === 'function' && typeof TransformStream !== 'undefined') {
                     result.stream = originalStream.pipeThrough(new TransformStream({
                         transform(chunk, controller) {
-                            if (chunk && chunk.type === 'text-delta' && typeof chunk.textDelta === 'string') {
-                                const restored = detok.feed(chunk.textDelta);
-                                if (restored) controller.enqueue({ ...chunk, textDelta: restored });
-                            } else {
-                                controller.enqueue(chunk);
+                            if (chunk && (chunk.type === 'text-delta' || chunk.type === 'reasoning' || chunk.type === 'reasoning-delta')) {
+                                if (typeof chunk.textDelta === 'string') {
+                                    const restored = detok.feed(chunk.textDelta);
+                                    if (restored) {
+                                        controller.enqueue({
+                                            ...chunk,
+                                            textDelta: restored,
+                                            ...(typeof chunk.delta === 'string' ? { delta: restored } : {})
+                                        });
+                                    }
+                                    return;
+                                }
+                                if (typeof chunk.delta === 'string') {
+                                    usesV2Delta = true;
+                                    const restored = detok.feed(chunk.delta);
+                                    if (restored) {
+                                        controller.enqueue({ ...chunk, delta: restored, textDelta: restored });
+                                    }
+                                    return;
+                                }
                             }
+                            controller.enqueue(chunk);
                         },
                         flush(controller) {
                             const rem = detok.flush();
-                            if (rem) controller.enqueue({ type: 'text-delta', textDelta: rem });
+                            if (rem) {
+                                controller.enqueue(
+                                    usesV2Delta
+                                        ? { type: 'text-delta', delta: rem, textDelta: rem }
+                                        : { type: 'text-delta', textDelta: rem, delta: rem }
+                                );
+                            }
                         }
                     }));
                 } else if (typeof originalStream[Symbol.asyncIterator] === 'function') {
                     async function* wrappedAsyncIterable() {
                         for await (const chunk of originalStream) {
-                            if (chunk && chunk.type === 'text-delta' && typeof chunk.textDelta === 'string') {
-                                const restored = detok.feed(chunk.textDelta);
-                                if (restored) yield { ...chunk, textDelta: restored };
-                            } else {
-                                yield chunk;
+                            if (chunk && (chunk.type === 'text-delta' || chunk.type === 'reasoning' || chunk.type === 'reasoning-delta')) {
+                                if (typeof chunk.textDelta === 'string') {
+                                    const restored = detok.feed(chunk.textDelta);
+                                    if (restored) {
+                                        yield {
+                                            ...chunk,
+                                            textDelta: restored,
+                                            ...(typeof chunk.delta === 'string' ? { delta: restored } : {})
+                                        };
+                                    }
+                                    continue;
+                                }
+                                if (typeof chunk.delta === 'string') {
+                                    usesV2Delta = true;
+                                    const restored = detok.feed(chunk.delta);
+                                    if (restored) {
+                                        yield { ...chunk, delta: restored, textDelta: restored };
+                                    }
+                                    continue;
+                                }
                             }
+                            yield chunk;
                         }
                         const rem = detok.flush();
-                        if (rem) yield { type: 'text-delta', textDelta: rem };
+                        if (rem) {
+                            yield usesV2Delta
+                                ? { type: 'text-delta', delta: rem, textDelta: rem }
+                                : { type: 'text-delta', textDelta: rem, delta: rem };
+                        }
                     }
                     result.stream = wrappedAsyncIterable();
                 }
@@ -1108,6 +1455,631 @@ function wrapAiModel(model, options = {}) {
 
 const wrapAiSdk = wrapAiModel;
 
+/**
+ * Transparent Zero-Trust wrapper for Google Gemini SDKs:
+ * - Official @google/genai SDK (GoogleGenAI instance with client.models.generateContent / generateContentStream)
+ * - Legacy @google/generative-ai SDK (GenerativeModel or GoogleGenerativeAI instance)
+ *
+ * Automatically scrubs string, Part[], and Content[] prompts as well as systemInstruction in local RAM,
+ * and restores masked tokens in both synchronous and streaming responses.
+ *
+ * @param {object} geminiClientOrModel - GoogleGenAI instance, GenerativeModel instance, or GoogleGenerativeAI client.
+ * @param {object} [options={}] - PrivacyScrubber configuration options.
+ * @returns {object} Wrapped Gemini client or model.
+ */
+function wrapGemini(geminiClientOrModel, options = {}) {
+    if (!geminiClientOrModel || typeof geminiClientOrModel !== 'object') {
+        throw new Error('[PrivacyScrubber] Invalid Gemini client or model passed to wrapGemini.');
+    }
+
+    const engine = options.engine || new PrivacyScrubberEngine(options);
+    const sharedSessionMap = {};
+
+    function sanitizeGeminiContentNode(node, sessionTokenMap) {
+        if (node === null || node === undefined) return node;
+        if (typeof node === 'string') {
+            const res = engine.sanitize(node, { existingSessionMap: sessionTokenMap });
+            Object.assign(sessionTokenMap, res.tokenMap);
+            return res.scrubbedText;
+        }
+        if (Array.isArray(node)) {
+            return node.map(item => sanitizeGeminiContentNode(item, sessionTokenMap));
+        }
+        if (typeof node === 'object') {
+            const copy = { ...node };
+            if (typeof copy.text === 'string') {
+                const res = engine.sanitize(copy.text, { existingSessionMap: sessionTokenMap });
+                Object.assign(sessionTokenMap, res.tokenMap);
+                copy.text = res.scrubbedText;
+            }
+            if (Array.isArray(copy.parts)) {
+                copy.parts = copy.parts.map(p => sanitizeGeminiContentNode(p, sessionTokenMap));
+            }
+            if (copy.contents !== undefined) {
+                copy.contents = sanitizeGeminiContentNode(copy.contents, sessionTokenMap);
+            }
+            if (copy.systemInstruction !== undefined) {
+                copy.systemInstruction = sanitizeGeminiContentNode(copy.systemInstruction, sessionTokenMap);
+            }
+            if (copy.config && typeof copy.config === 'object') {
+                copy.config = { ...copy.config };
+                if (copy.config.systemInstruction !== undefined) {
+                    copy.config.systemInstruction = sanitizeGeminiContentNode(copy.config.systemInstruction, sessionTokenMap);
+                }
+            }
+            return copy;
+        }
+        return node;
+    }
+
+    function restoreGeminiResponseObject(respObj, sessionTokenMap, detok = null) {
+        if (!respObj || typeof respObj !== 'object') return respObj;
+        const restoreFn = (str) => detok ? detok.feed(str) : engine.restore(str, sessionTokenMap).restoredText;
+
+        let combinedText = '';
+        if (Array.isArray(respObj.candidates)) {
+            respObj.candidates = respObj.candidates.map(cand => {
+                if (!cand || typeof cand !== 'object') return cand;
+                const candCopy = { ...cand };
+                if (candCopy.content && Array.isArray(candCopy.content.parts)) {
+                    candCopy.content = {
+                        ...candCopy.content,
+                        parts: candCopy.content.parts.map(part => {
+                            if (part && typeof part.text === 'string') {
+                                const restoredText = restoreFn(part.text);
+                                combinedText += restoredText;
+                                return { ...part, text: restoredText };
+                            }
+                            return part;
+                        })
+                    };
+                }
+                return candCopy;
+            });
+        }
+
+        if (typeof respObj.text === 'function') {
+            const origTextFn = respObj.text.bind(respObj);
+            respObj.text = () => {
+                if (combinedText) return combinedText;
+                const raw = origTextFn();
+                return typeof raw === 'string' ? restoreFn(raw) : raw;
+            };
+        } else if (typeof respObj.text === 'string') {
+            const restored = combinedText || restoreFn(respObj.text);
+            try {
+                Object.defineProperty(respObj, 'text', {
+                    value: restored,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            } catch (_) {
+                respObj.text = restored;
+            }
+        } else if (combinedText) {
+            try {
+                Object.defineProperty(respObj, 'text', {
+                    value: combinedText,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            } catch (_) {}
+        }
+
+        if (respObj.response && typeof respObj.response === 'object') {
+            restoreGeminiResponseObject(respObj.response, sessionTokenMap, detok);
+        }
+
+        return respObj;
+    }
+
+    function wrapGeminiStreamResult(streamResult, sessionTokenMap) {
+        const detok = new StreamingDetokenizer(sessionTokenMap);
+
+        async function* wrapAsyncChunks(iterable) {
+            let lastChunkTemplate = null;
+            for await (const chunk of iterable) {
+                if (!chunk) continue;
+                lastChunkTemplate = chunk;
+                if (typeof chunk === 'string') {
+                    const out = detok.feed(chunk);
+                    if (out) yield out;
+                } else if (typeof chunk === 'object') {
+                    const cloned = Object.create(Object.getPrototypeOf(chunk));
+                    Object.assign(cloned, chunk);
+                    restoreGeminiResponseObject(cloned, sessionTokenMap, detok);
+                    yield cloned;
+                } else {
+                    yield chunk;
+                }
+            }
+            const tail = detok.flush();
+            if (tail) {
+                if (lastChunkTemplate && typeof lastChunkTemplate === 'object') {
+                    const finalChunk = {
+                        ...lastChunkTemplate,
+                        candidates: [{ content: { role: 'model', parts: [{ text: tail }] } }],
+                        text: tail
+                    };
+                    if (typeof lastChunkTemplate.text === 'function') {
+                        finalChunk.text = () => tail;
+                    }
+                    yield finalChunk;
+                } else {
+                    yield tail;
+                }
+            }
+        }
+
+        if (streamResult && typeof streamResult[Symbol.asyncIterator] === 'function') {
+            return wrapAsyncChunks(streamResult);
+        }
+        if (streamResult && streamResult.stream && typeof streamResult.stream[Symbol.asyncIterator] === 'function') {
+            const wrappedStream = wrapAsyncChunks(streamResult.stream);
+            const wrappedResponse = streamResult.response && typeof streamResult.response.then === 'function'
+                ? streamResult.response.then(r => restoreGeminiResponseObject(r, sessionTokenMap))
+                : streamResult.response;
+            return {
+                ...streamResult,
+                stream: wrappedStream,
+                response: wrappedResponse
+            };
+        }
+        return streamResult;
+    }
+
+    function wrapTargetObject(target) {
+        if (typeof target.generateContent === 'function') {
+            const origGen = target.generateContent.bind(target);
+            target.generateContent = async function(req, ...rest) {
+                const sessionTokenMap = { ...sharedSessionMap };
+                const sanitizedReq = sanitizeGeminiContentNode(req, sessionTokenMap);
+                Object.assign(sharedSessionMap, sessionTokenMap);
+                const res = await origGen(sanitizedReq, ...rest);
+                return restoreGeminiResponseObject(res, sessionTokenMap);
+            };
+        }
+        if (typeof target.generateContentStream === 'function') {
+            const origStream = target.generateContentStream.bind(target);
+            target.generateContentStream = async function(req, ...rest) {
+                const sessionTokenMap = { ...sharedSessionMap };
+                const sanitizedReq = sanitizeGeminiContentNode(req, sessionTokenMap);
+                Object.assign(sharedSessionMap, sessionTokenMap);
+                const streamRes = await origStream(sanitizedReq, ...rest);
+                return wrapGeminiStreamResult(streamRes, sessionTokenMap);
+            };
+        }
+    }
+
+    if (geminiClientOrModel.models && typeof geminiClientOrModel.models === 'object') {
+        wrapTargetObject(geminiClientOrModel.models);
+    }
+    if (typeof geminiClientOrModel.generateContent === 'function' || typeof geminiClientOrModel.generateContentStream === 'function') {
+        wrapTargetObject(geminiClientOrModel);
+    }
+    if (typeof geminiClientOrModel.getGenerativeModel === 'function') {
+        const origGetModel = geminiClientOrModel.getGenerativeModel.bind(geminiClientOrModel);
+        geminiClientOrModel.getGenerativeModel = function(modelParams, ...rest) {
+            const sessionTokenMap = { ...sharedSessionMap };
+            const sanitizedParams = sanitizeGeminiContentNode(modelParams, sessionTokenMap);
+            Object.assign(sharedSessionMap, sessionTokenMap);
+            const modelInstance = origGetModel(sanitizedParams, ...rest);
+            if (modelInstance && typeof modelInstance === 'object') {
+                wrapTargetObject(modelInstance);
+            }
+            return modelInstance;
+        };
+    }
+
+    geminiClientOrModel._ztdsEngine = engine;
+    return geminiClientOrModel;
+}
+
+const wrapGoogleGenAI = wrapGemini;
+
+/**
+ * Creates a universal Zero-Trust HTTP/SSE `fetch` wrapper for any LLM provider or SDK
+ * (OpenAI, Anthropic, OpenRouter, Groq, DeepSeek, Mistral, Together, Ollama, Cloudflare AI Gateway).
+ *
+ * Automatically sanitizes outbound JSON request bodies (`messages`, `prompt`, `input`, `contents`, `system`)
+ * in local RAM before network transmission, and transparently de-tokenizes both JSON responses
+ * and Server-Sent Events (`text/event-stream`) streams in real time.
+ *
+ * Usage:
+ *   const client = new OpenAI({ fetch: createPrivacyFetch({ profile: 'General' }) });
+ *
+ * @param {object} [options={}] - Configuration options.
+ * @returns {Function} Drop-in `fetch(input, init)` replacement.
+ */
+function createPrivacyFetch(options = {}) {
+    const engine = options.engine || new PrivacyScrubberEngine(options);
+    const baseFetch = options.fetch || (typeof globalThis !== 'undefined' && globalThis.fetch);
+    const sanitizeInputs = options.sanitizeInputs !== false;
+    const sanitizeOutputs = options.sanitizeOutputs !== false;
+
+    const PROMPT_KEYS = new Set([
+        'messages', 'prompt', 'input', 'contents', 'system',
+        'systemInstruction', 'system_instruction', 'instructions', 'text', 'content'
+    ]);
+    const SAFE_SKIP_KEYS = new Set([
+        'model', 'role', 'type', 'id', 'object', 'finish_reason', 'stop_reason',
+        'encoding_format', 'response_format', 'tool_choice', 'stream'
+    ]);
+
+    function sanitizeJsonNode(node, sessionTokenMap) {
+        if (node === null || node === undefined) return node;
+        if (typeof node === 'string') {
+            if (!node.trim()) return node;
+            const res = engine.sanitize(node, { existingSessionMap: sessionTokenMap });
+            Object.assign(sessionTokenMap, res.tokenMap);
+            return res.scrubbedText;
+        }
+        if (Array.isArray(node)) {
+            return node.map(item => sanitizeJsonNode(item, sessionTokenMap));
+        }
+        if (typeof node === 'object') {
+            const out = {};
+            for (const [k, v] of Object.entries(node)) {
+                if (k === '__proto__' || k === 'constructor' || k === 'prototype') continue;
+                if (SAFE_SKIP_KEYS.has(k)) {
+                    out[k] = v;
+                } else if (PROMPT_KEYS.has(k) || typeof v === 'object') {
+                    out[k] = sanitizeJsonNode(v, sessionTokenMap);
+                } else {
+                    out[k] = v;
+                }
+            }
+            return out;
+        }
+        return node;
+    }
+
+    function detokenizeSseJsonPayload(parsed, detok) {
+        if (!parsed || typeof parsed !== 'object') return parsed;
+        if (Array.isArray(parsed.choices)) {
+            parsed.choices = parsed.choices.map(choice => {
+                if (!choice || typeof choice !== 'object') return choice;
+                const c = { ...choice };
+                if (c.delta && typeof c.delta === 'object') {
+                    c.delta = { ...c.delta };
+                    if (typeof c.delta.content === 'string') {
+                        c.delta.content = detok.feed(c.delta.content);
+                    }
+                    if (typeof c.delta.reasoning_content === 'string') {
+                        c.delta.reasoning_content = detok.feed(c.delta.reasoning_content);
+                    }
+                    if (typeof c.delta.text === 'string') {
+                        c.delta.text = detok.feed(c.delta.text);
+                    }
+                }
+                if (typeof c.text === 'string') {
+                    c.text = detok.feed(c.text);
+                }
+                return c;
+            });
+        }
+        if (parsed.delta && typeof parsed.delta === 'object') {
+            parsed.delta = { ...parsed.delta };
+            if (typeof parsed.delta.text === 'string') {
+                parsed.delta.text = detok.feed(parsed.delta.text);
+            }
+            if (typeof parsed.delta.partial_json === 'string') {
+                parsed.delta.partial_json = detok.feed(parsed.delta.partial_json);
+            }
+        } else if (typeof parsed.delta === 'string') {
+            parsed.delta = detok.feed(parsed.delta);
+        }
+        if (Array.isArray(parsed.candidates)) {
+            parsed.candidates = parsed.candidates.map(cand => {
+                if (cand && cand.content && Array.isArray(cand.content.parts)) {
+                    return {
+                        ...cand,
+                        content: {
+                            ...cand.content,
+                            parts: cand.content.parts.map(p =>
+                                (p && typeof p.text === 'string') ? { ...p, text: detok.feed(p.text) } : p
+                            )
+                        }
+                    };
+                }
+                return cand;
+            });
+        }
+        if (typeof parsed.response === 'string') {
+            parsed.response = detok.feed(parsed.response);
+        }
+        return parsed;
+    }
+
+    const privacyFetch = async function(input, init = {}) {
+        if (typeof baseFetch !== 'function') {
+            throw new Error('[PrivacyScrubber] No global fetch implementation found; pass { fetch } to createPrivacyFetch.');
+        }
+
+        const sessionTokenMap = { ...engine.sessionMap };
+        let modifiedInit = init ? { ...init } : {};
+
+        if (sanitizeInputs && modifiedInit && typeof modifiedInit.body === 'string') {
+            const trimmed = modifiedInit.body.trim();
+            if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+                try {
+                    const parsed = JSON.parse(modifiedInit.body);
+                    const sanitizedBody = sanitizeJsonNode(parsed, sessionTokenMap);
+                    modifiedInit.body = JSON.stringify(sanitizedBody);
+                    if (modifiedInit.headers) {
+                        if (typeof Headers !== 'undefined' && modifiedInit.headers instanceof Headers) {
+                            const h = new Headers(modifiedInit.headers);
+                            h.delete('content-length');
+                            modifiedInit.headers = h;
+                        } else if (typeof modifiedInit.headers === 'object' && !Array.isArray(modifiedInit.headers)) {
+                            const h = { ...modifiedInit.headers };
+                            delete h['content-length'];
+                            delete h['Content-Length'];
+                            modifiedInit.headers = h;
+                        }
+                    }
+                    if (typeof options.onSanitized === 'function') {
+                        try {
+                            options.onSanitized({
+                                url: typeof input === 'string' ? input : (input && input.url) || '',
+                                tokenMap: sessionTokenMap,
+                                tokenCount: Object.keys(sessionTokenMap).length
+                            });
+                        } catch (_) {}
+                    }
+                } catch (_) {}
+            }
+        }
+
+        const response = await baseFetch(input, modifiedInit);
+        if (!sanitizeOutputs || !response || Object.keys(sessionTokenMap).length === 0) {
+            return response;
+        }
+
+        const contentType = (response.headers && typeof response.headers.get === 'function')
+            ? (response.headers.get('content-type') || '').toLowerCase()
+            : '';
+
+        if (contentType.includes('text/event-stream') && response.body && typeof response.body.pipeThrough === 'function' && typeof TransformStream !== 'undefined') {
+            const detok = new StreamingDetokenizer(sessionTokenMap, options.streamingOptions);
+            const decoder = new TextDecoder();
+            const encoder = new TextEncoder();
+            let lineBuffer = '';
+
+            const processSseLine = (line) => {
+                if (!line.startsWith('data:')) return line;
+                const dataPayload = line.slice(5).trim();
+                if (!dataPayload || dataPayload === '[DONE]') {
+                    const rem = detok.flush();
+                    return rem ? `data: ${JSON.stringify({ choices: [{ index: 0, delta: { content: rem } }] })}\n\n${line}` : line;
+                }
+                if (dataPayload.startsWith('{')) {
+                    try {
+                        const parsed = JSON.parse(dataPayload);
+                        const restoredObj = detokenizeSseJsonPayload(parsed, detok);
+                        return `data: ${JSON.stringify(restoredObj)}`;
+                    } catch (_) {
+                        return `data: ${detok.feed(dataPayload)}`;
+                    }
+                }
+                return `data: ${detok.feed(dataPayload)}`;
+            };
+
+            const transformedBody = response.body.pipeThrough(new TransformStream({
+                transform(chunk, controller) {
+                    const str = typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
+                    lineBuffer += str;
+                    const lines = lineBuffer.split(/\r?\n/);
+                    lineBuffer = lines.pop() || '';
+                    if (lines.length > 0) {
+                        const outLines = lines.map(processSseLine).join('\n') + '\n';
+                        controller.enqueue(encoder.encode(outLines));
+                    }
+                },
+                flush(controller) {
+                    let finalOut = '';
+                    if (lineBuffer) {
+                        finalOut += processSseLine(lineBuffer) + '\n';
+                        lineBuffer = '';
+                    }
+                    const rem = detok.flush();
+                    if (rem) {
+                        finalOut += `data: ${JSON.stringify({ choices: [{ index: 0, delta: { content: rem } }] })}\n\n`;
+                    }
+                    if (finalOut) {
+                        controller.enqueue(encoder.encode(finalOut));
+                    }
+                }
+            }));
+
+            if (typeof Response !== 'undefined') {
+                return new Response(transformedBody, {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: response.headers
+                });
+            }
+            return { ...response, body: transformedBody };
+        }
+
+        if (contentType.includes('application/json') || typeof response.json === 'function') {
+            try {
+                const rawText = typeof response.text === 'function'
+                    ? await response.text()
+                    : JSON.stringify(await response.json());
+                const parsed = JSON.parse(rawText);
+                const restoredObj = restoreObject(parsed, sessionTokenMap);
+                const restoredText = JSON.stringify(restoredObj);
+                if (typeof Response !== 'undefined') {
+                    const headers = new Headers(response.headers || {});
+                    headers.delete('content-length');
+                    return new Response(restoredText, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers
+                    });
+                }
+                return {
+                    ...response,
+                    text: async () => restoredText,
+                    json: async () => restoredObj
+                };
+            } catch (_) {
+                return response;
+            }
+        }
+
+        return response;
+    };
+
+    privacyFetch.engine = engine;
+    return privacyFetch;
+}
+
+/**
+ * Creates OpenAI Agents SDK (@openai/agents) compatible InputGuardrail and OutputGuardrail objects.
+ *
+ * Supports two operating modes:
+ * 1. Sanitization & Telemetry Mode (default): Scrubs PII/secrets into engine.sessionMap and attaches
+ *    CISO compliance telemetry to `outputInfo` while allowing execution (`tripwireTriggered: false`).
+ * 2. Strict Tripwire Mode (`tripwireOnCritical: true` or `tripwireOnAnyPii: true`): Triggers the
+ *    OpenAI Agents SDK guardrail tripwire (`tripwireTriggered: true`) to halt agent execution when
+ *    critical secrets/PII or any PII are detected.
+ *
+ * @param {object} [options={}] - Configuration options.
+ * @returns {object} `{ inputGuardrail, outputGuardrail, inputGuardrails, outputGuardrails, engine }`
+ */
+function createOpenAIAgentGuardrails(options = {}) {
+    const engine = options.engine || new PrivacyScrubberEngine(options);
+    const tripwireOnCritical = options.tripwireOnCritical === true;
+    const tripwireOnAnyPii = options.tripwireOnAnyPii === true;
+
+    function extractAndScrubAgentInput(input, sessionTokenMap) {
+        if (typeof input === 'string') {
+            const res = engine.sanitize(input, { existingSessionMap: sessionTokenMap });
+            Object.assign(sessionTokenMap, res.tokenMap);
+            return { scrubbedInput: res.scrubbedText, count: res.count };
+        }
+        if (Array.isArray(input)) {
+            let totalCount = 0;
+            const scrubbedList = input.map(item => {
+                if (typeof item === 'string') {
+                    const r = engine.sanitize(item, { existingSessionMap: sessionTokenMap });
+                    Object.assign(sessionTokenMap, r.tokenMap);
+                    totalCount += r.count;
+                    return r.scrubbedText;
+                }
+                if (item && typeof item === 'object') {
+                    const copy = { ...item };
+                    if (typeof copy.content === 'string') {
+                        const r = engine.sanitize(copy.content, { existingSessionMap: sessionTokenMap });
+                        Object.assign(sessionTokenMap, r.tokenMap);
+                        totalCount += r.count;
+                        copy.content = r.scrubbedText;
+                        if (options.mutateInPlace !== false) item.content = r.scrubbedText;
+                    } else if (Array.isArray(copy.content)) {
+                        copy.content = copy.content.map(part => {
+                            if (part && typeof part.text === 'string') {
+                                const r = engine.sanitize(part.text, { existingSessionMap: sessionTokenMap });
+                                Object.assign(sessionTokenMap, r.tokenMap);
+                                totalCount += r.count;
+                                if (options.mutateInPlace !== false) part.text = r.scrubbedText;
+                                return { ...part, text: r.scrubbedText };
+                            }
+                            return part;
+                        });
+                    }
+                    return copy;
+                }
+                return item;
+            });
+            return { scrubbedInput: scrubbedList, count: totalCount };
+        }
+        return { scrubbedInput: input, count: 0 };
+    }
+
+    const inputGuardrail = {
+        name: options.inputGuardrailName || 'PrivacyScrubber ZTDS Input Guardrail',
+        async execute({ input, context } = {}) {
+            const sessionTokenMap = { ...engine.sessionMap };
+            const { scrubbedInput, count } = extractAndScrubAgentInput(input, sessionTokenMap);
+            Object.assign(engine.sessionMap, sessionTokenMap);
+
+            if (context && typeof context === 'object') {
+                context.ztdsTokenMap = engine.sessionMap;
+                context.ztdsScrubbedInput = scrubbedInput;
+            }
+
+            const telemetry = buildAuditTelemetry(sessionTokenMap);
+            const isCritical = telemetry.riskLevel && telemetry.riskLevel.includes('CRITICAL');
+            const tripwireTriggered = Boolean(
+                (tripwireOnAnyPii && count > 0) ||
+                (tripwireOnCritical && count > 0 && isCritical)
+            );
+
+            return {
+                tripwireTriggered,
+                outputInfo: {
+                    scrubbedInput,
+                    tokenMap: { ...sessionTokenMap },
+                    tokenCount: count,
+                    riskLevel: telemetry.riskLevel,
+                    frameworks: telemetry.frameworksList,
+                    telemetry
+                }
+            };
+        }
+    };
+
+    const outputGuardrail = {
+        name: options.outputGuardrailName || 'PrivacyScrubber ZTDS Output Guardrail',
+        async execute({ agentOutput, context } = {}) {
+            const activeMap = (context && context.ztdsTokenMap) || engine.sessionMap || {};
+            let restoredOutput = agentOutput;
+            let restoredCount = 0;
+
+            if (typeof agentOutput === 'string') {
+                const res = engine.restore(agentOutput, activeMap);
+                restoredOutput = res.restoredText;
+                restoredCount = res.restoredCount;
+            } else if (agentOutput && typeof agentOutput === 'object') {
+                restoredOutput = restoreObject(agentOutput, activeMap);
+                if (options.mutateInPlace !== false) {
+                    Object.assign(agentOutput, restoredOutput);
+                }
+            }
+
+            if (context && typeof context === 'object') {
+                context.ztdsRestoredOutput = restoredOutput;
+            }
+
+            let leakDetected = false;
+            if (options.tripwireOnOutputLeak === true && typeof restoredOutput === 'string') {
+                const check = engine.sanitize(restoredOutput, { persistSession: false });
+                leakDetected = check.count > 0;
+            }
+
+            return {
+                tripwireTriggered: leakDetected,
+                outputInfo: {
+                    restoredOutput,
+                    restoredCount
+                }
+            };
+        }
+    };
+
+    return {
+        inputGuardrail,
+        outputGuardrail,
+        inputGuardrails: [inputGuardrail],
+        outputGuardrails: [outputGuardrail],
+        engine
+    };
+}
+
 /**
  * Framework middleware helper for LangChain / LlamaIndex pipelines.
  */
@@ -1747,9 +2719,11 @@ class StreamingDetokenizer {
      */
     async* wrapStream(asyncIterable) {
         let lastOpenAIChunk = null;
+        let lastResponsesDeltaChunk = null;
+        let lastAnthropicDeltaChunk = null;
         for await (const chunk of asyncIterable) {
             if (chunk === null || chunk === undefined) continue;
-            // Handle OpenAI chunk object
+            // Handle OpenAI chat.completions chunk object
             if (chunk.choices && Array.isArray(chunk.choices) && chunk.choices[0]?.delta?.content !== undefined) {
                 lastOpenAIChunk = chunk;
                 const delta = chunk.choices[0].delta.content;
@@ -1767,6 +2741,55 @@ class StreamingDetokenizer {
                 continue;
             }
 
+            // Handle OpenAI Responses API streaming events (response.output_text.delta / done)
+            if (chunk && typeof chunk === 'object' && typeof chunk.type === 'string' && chunk.type.startsWith('response.')) {
+                if (chunk.type === 'response.output_text.delta' && typeof chunk.delta === 'string') {
+                    lastResponsesDeltaChunk = chunk;
+                    const restored = this.feed(chunk.delta);
+                    if (restored) {
+                        yield { ...chunk, delta: restored };
+                    }
+                    continue;
+                }
+                if (chunk.type === 'response.output_text.done' && typeof chunk.text === 'string') {
+                    const remaining = this.flush();
+                    if (remaining && lastResponsesDeltaChunk) {
+                        yield { ...lastResponsesDeltaChunk, delta: remaining };
+                    }
+                    yield { ...chunk, text: this.replacer(chunk.text) };
+                    continue;
+                }
+                yield chunk;
+                continue;
+            }
+
+            // Handle Anthropic messages.create({ stream: true }) events (content_block_delta / content_block_stop)
+            if (chunk && typeof chunk === 'object' && typeof chunk.type === 'string' && (
+                chunk.type === 'content_block_delta' ||
+                chunk.type === 'content_block_start' ||
+                chunk.type === 'content_block_stop' ||
+                chunk.type === 'message_start' ||
+                chunk.type === 'message_delta' ||
+                chunk.type === 'message_stop'
+            )) {
+                if (chunk.type === 'content_block_delta' && chunk.delta && chunk.delta.type === 'text_delta' && typeof chunk.delta.text === 'string') {
+                    lastAnthropicDeltaChunk = chunk;
+                    const restored = this.feed(chunk.delta.text);
+                    if (restored) {
+                        yield { ...chunk, delta: { ...chunk.delta, text: restored } };
+                    }
+                    continue;
+                }
+                if ((chunk.type === 'content_block_stop' || chunk.type === 'message_stop') && this.pendingBuffer) {
+                    const remaining = this.flush();
+                    if (remaining && lastAnthropicDeltaChunk) {
+                        yield { ...lastAnthropicDeltaChunk, delta: { ...lastAnthropicDeltaChunk.delta, text: remaining } };
+                    }
+                }
+                yield chunk;
+                continue;
+            }
+
             let text = '';
             if (typeof chunk === 'string') {
                 text = chunk;
@@ -1791,6 +2814,10 @@ class StreamingDetokenizer {
                     idx === 0 ? { ...c, delta: { ...c.delta, content: finalChunk } } : c
                 );
                 yield { ...lastOpenAIChunk, choices: clonedChoices };
+            } else if (lastResponsesDeltaChunk) {
+                yield { ...lastResponsesDeltaChunk, delta: finalChunk };
+            } else if (lastAnthropicDeltaChunk) {
+                yield { ...lastAnthropicDeltaChunk, delta: { ...lastAnthropicDeltaChunk.delta, text: finalChunk } };
             } else {
                 yield finalChunk;
             }
@@ -1952,7 +2979,7 @@ function formatCefEvent(eventData = {}) {
     const {
         vendor = 'PrivacyScrubber',
         product = 'ZTDS',
-        version = '2.4.4',
+        version = SDK_VERSION,
         eventClassId = 'PII_REDACTION',
         eventName = 'Zero-Trust PII Sanitization Executed',
         riskLevel = 'LOW EXPOSURE',
@@ -2021,7 +3048,7 @@ function formatSyslogEvent(eventData = {}) {
 function formatJsonlEvent(eventData = {}) {
     const {
         timestamp = new Date().toISOString(),
-        version = '2.4.4',
+        version = SDK_VERSION,
         protocol = 'ZTDS',
         event = 'sanitization',
         riskLevel = 'LOW EXPOSURE',
@@ -2069,12 +3096,22 @@ function createAuditLogger(options = {}) {
     const buffer = [];
 
     if (typeof destination === 'string' && destination.trim()) {
+        if (destination.includes('\0')) {
+            throw new Error('[PrivacyScrubber AuditLogger] Security violation: null byte in destination path.');
+        }
+        const resolvedDest = path.resolve(destination.trim());
+        if (fs.existsSync(resolvedDest)) {
+            const st = fs.lstatSync(resolvedDest);
+            if (st.isSymbolicLink() || !st.isFile()) {
+                throw new Error('[PrivacyScrubber AuditLogger] Security violation: destination must be a regular non-symlink file.');
+            }
+        }
         try {
-            const dir = path.dirname(destination);
+            const dir = path.dirname(resolvedDest);
             if (!fs.existsSync(dir)) {
                 fs.mkdirSync(dir, { recursive: true });
             }
-            fileHandle = destination;
+            fileHandle = resolvedDest;
         } catch {}
     } else if (destination && typeof destination.write === 'function') {
         streamHandle = destination;
@@ -2104,6 +3141,12 @@ function createAuditLogger(options = {}) {
         buffer.push(line);
         if (fileHandle) {
             try {
+                if (fs.existsSync(fileHandle)) {
+                    const st = fs.lstatSync(fileHandle);
+                    if (st.isSymbolicLink() || !st.isFile()) {
+                        throw new Error('Target destination became a symlink or non-regular file.');
+                    }
+                }
                 fs.appendFileSync(fileHandle, line + '\n', 'utf8');
             } catch (e) {
                 console.error('[PrivacyScrubber AuditLogger] File write error:', e);
@@ -2407,11 +3450,41 @@ function applyPatch(filePath, content, options = {}) {
     const {
         tokenMap = null,
         engine = null,
-        createBackup = true
+        createBackup = true,
+        cwd = process.cwd(),
+        allowOutsideWorkspace = false
     } = options;
 
+    if (filePath.includes('\0')) {
+        throw new Error('[applyPatch] Security policy violation — null byte in filePath blocked.');
+    }
+
     const activeTokenMap = tokenMap || (engine && engine.sessionMap) || {};
-    const resolvedPath = path.resolve(process.cwd(), filePath);
+    const workspaceRoot = fs.existsSync(cwd) ? fs.realpathSync(cwd) : path.resolve(cwd);
+    const tmpRoot = fs.existsSync(os.tmpdir()) ? fs.realpathSync(os.tmpdir()) : path.resolve(os.tmpdir());
+    const resolvedPath = path.resolve(workspaceRoot, filePath);
+
+    let checkCursor = resolvedPath;
+    while (!fs.existsSync(checkCursor)) {
+        const parentCursor = path.dirname(checkCursor);
+        if (parentCursor === checkCursor) break;
+        checkCursor = parentCursor;
+    }
+    const realExistingCursor = fs.existsSync(checkCursor) ? fs.realpathSync(checkCursor) : checkCursor;
+    const suffixFromCursor = path.relative(checkCursor, resolvedPath);
+    const canonicalTarget = path.resolve(realExistingCursor, suffixFromCursor);
+
+    if (!allowOutsideWorkspace) {
+        const hasTraversalSegments = /(?:^|[\\/])\.\.(?:[\\/]|$)/.test(String(filePath));
+        const relToWorkspace = path.relative(workspaceRoot, canonicalTarget);
+        const isInsideWorkspace = !relToWorkspace.startsWith('..') && !path.isAbsolute(relToWorkspace);
+        const relToTmp = path.relative(tmpRoot, canonicalTarget);
+        const isInsideTmp = path.isAbsolute(filePath) && !hasTraversalSegments && !relToTmp.startsWith('..') && !path.isAbsolute(relToTmp);
+        if (!isInsideWorkspace && !isInsideTmp) {
+            throw new Error(`[applyPatch] Security policy violation — target 'filePath' resolves outside the active workspace directory (path traversal blocked).`);
+        }
+    }
+
     const restored = unscrub(content, activeTokenMap);
 
     let backupCreated = false;
@@ -2465,6 +3538,32 @@ function createGuardedTools(engineOrOptions = {}, toolConfig = {}) {
 
     const baseCwd = toolConfig.cwd || process.cwd();
     const defaultProfile = toolConfig.profile || engine.defaultProfile || 'Dev';
+    const allowOutsideWorkspace = toolConfig.allowOutsideWorkspace === true;
+
+    function resolveSafeToolPath(inputPath, toolName, paramName = 'filePath') {
+        const workspaceRoot = fs.existsSync(baseCwd) ? fs.realpathSync(baseCwd) : path.resolve(baseCwd);
+        const resolvedPath = path.resolve(workspaceRoot, inputPath);
+        if (allowOutsideWorkspace) return resolvedPath;
+
+        const relToRoot = path.relative(workspaceRoot, resolvedPath);
+        if (relToRoot.startsWith('..') || path.isAbsolute(relToRoot)) {
+            throw new Error(`[${toolName}] Security policy violation — target '${paramName}' resolves outside the active workspace directory (path traversal blocked).`);
+        }
+        let checkCursor = resolvedPath;
+        while (!fs.existsSync(checkCursor)) {
+            const parentCursor = path.dirname(checkCursor);
+            if (parentCursor === checkCursor) break;
+            checkCursor = parentCursor;
+        }
+        if (fs.existsSync(checkCursor)) {
+            const realCheck = fs.realpathSync(checkCursor);
+            const relReal = path.relative(workspaceRoot, realCheck);
+            if (relReal.startsWith('..') || path.isAbsolute(relReal)) {
+                throw new Error(`[${toolName}] Security policy violation — target path symlink escapes the active workspace directory.`);
+            }
+        }
+        return resolvedPath;
+    }
 
     const tools = {
         guardExec: {
@@ -2484,7 +3583,7 @@ function createGuardedTools(engineOrOptions = {}, toolConfig = {}) {
                 if (!command || typeof command !== 'string') {
                     throw new Error('[guard_exec] Missing or invalid parameter: command must be a string.');
                 }
-                const execCwd = cwd ? path.resolve(baseCwd, cwd) : baseCwd;
+                const execCwd = cwd ? resolveSafeToolPath(cwd, 'guard_exec', 'cwd') : baseCwd;
                 let stdout = '';
                 let stderr = '';
                 let exitCode = 0;
@@ -2548,7 +3647,7 @@ function createGuardedTools(engineOrOptions = {}, toolConfig = {}) {
                 if (!filePath || typeof filePath !== 'string') {
                     throw new Error('[guard_read_file] Missing or invalid parameter: filePath must be a string.');
                 }
-                const resolved = path.resolve(baseCwd, filePath);
+                const resolved = resolveSafeToolPath(filePath, 'guard_read_file', 'filePath');
                 if (!fs.existsSync(resolved)) {
                     throw new Error(`[guard_read_file] File not found: ${resolved}`);
                 }
@@ -2639,9 +3738,12 @@ function createGuardedTools(engineOrOptions = {}, toolConfig = {}) {
                 required: ['filePath', 'content']
             },
             execute: async ({ filePath, content, createBackup = true } = {}) => {
-                const patchResult = applyPatch(filePath, content, {
+                const safeFilePath = resolveSafeToolPath(filePath, 'guard_apply_patch', 'filePath');
+                const patchResult = applyPatch(safeFilePath, content, {
                     tokenMap: engine.sessionMap,
-                    createBackup
+                    createBackup,
+                    cwd: baseCwd,
+                    allowOutsideWorkspace
                 });
 
                 const responseText = `[Zero-Trust Agentic Guard: Patch Applied]\n` +
@@ -2670,7 +3772,7 @@ function createGuardedTools(engineOrOptions = {}, toolConfig = {}) {
                 required: []
             },
             execute: async ({ staged = false, cwd, profile = defaultProfile } = {}) => {
-                const repoCwd = cwd ? path.resolve(baseCwd, cwd) : baseCwd;
+                const repoCwd = cwd ? resolveSafeToolPath(cwd, 'guard_git_diff', 'cwd') : baseCwd;
                 const gitCmd = staged ? 'git diff --cached' : 'git diff';
                 let diffOutput = '';
 
@@ -2752,6 +3854,7 @@ const {
 } = require('./vision.cjs');
 
 const _defaultExport = {
+    SDK_VERSION,
     sanitize,
     sanitizeObject,
     scrub,
@@ -2778,8 +3881,13 @@ const _defaultExport = {
     PrivacyScrubberEngine,
     PrivacyScrubberLicenseError,
     wrapOpenAI,
+    wrapAnthropic,
+    wrapGemini,
+    wrapGoogleGenAI,
     wrapAiModel,
     wrapAiSdk,
+    createPrivacyFetch,
+    createOpenAIAgentGuardrails,
     createLangChainTransform,
     createDocumentTransformer,
     createLangChainDocumentTransformer,