@privacyscrubber/sdk 2.4.5 → 2.4.7

package/index.d.ts

@@ -120,6 +120,14 @@ export interface IpHoldings {
     trademark: string;
 }
 
+export interface AgenticProtocolMetadata {
+    protocolsSupported: string[];
+    agentCardUrl: string;
+    ztdsStandardCardUrl: string;
+    regulatorySafeHarbor: string[];
+    zeroCleartextEgress: boolean;
+}
+
 export interface AuditTelemetry {
     totalCount: number;
     entities: Record<string, number>;
@@ -128,6 +136,7 @@ export interface AuditTelemetry {
     frameworksList: string[];
     statutoryCitations?: StatutoryCitation[];
     ipHoldings?: IpHoldings;
+    agenticProtocol?: AgenticProtocolMetadata;
 }
 
 export interface SanitizeResult {
@@ -256,17 +265,67 @@ export interface ProcurementMemoOptions {
  */
 export function generateProcurementMemo(options?: ProcurementMemoOptions): string;
 
+export const SDK_VERSION: string;
+export const PSR2_VERSION: 'PSR-2';
+export const PSR2_STATEMENTS: {
+    measured: string[];
+    byDesign: string[];
+    limits: string[];
+};
+export const DEVOPS_SECRETS_DETECTOR: Array<{
+    name: string;
+    regex: RegExp;
+    label: string;
+}>;
+
+export interface Psr2Receipt {
+    version: string;
+    timestamp: string;
+    outputSha256: string | null;
+    manifestSha256: string;
+    entityCounts: string;
+    tokensTotal: number;
+    tokensPresentInOutput: number | null;
+    canonical: string;
+    receiptSha256: string;
+}
+
+export function buildPsr2Receipt(tokenMap?: Record<string, string>, timestamp?: string): Psr2Receipt;
+export function psr2Lines(receipt: Psr2Receipt): string[];
+export function _resetCommunityNoticeForTesting(): void;
+export function _resetDevSecretNoticeForTesting(): void;
+
 /**
  * Sanitizes input text, masking all PII and secrets with zero network requests.
  */
 export function sanitize(text: string, options?: SanitizeOptions): SanitizeResult;
 export function scrub(text: string, options?: SanitizeOptions): SanitizeResult;
 
+export interface SanitizeObjectResult<T = any> {
+    sanitized: T;
+    tokenMap: Record<string, string>;
+    count: number;
+    executionMs: number;
+    telemetry: AuditTelemetry;
+    auditReceipt: string;
+}
+
+/**
+ * Recursively sanitizes all string values within an object, array, Map, or Set.
+ */
+export function sanitizeObject<T = any>(obj: T, options?: SanitizeOptions): SanitizeObjectResult<T>;
+
 /**
  * Restores masked tokens in AI outputs back to original plaintext in-memory.
  */
 export function restore(aiResponse: string, tokenMap: Record<string, string>): RestoreResult;
 export function unscrub(aiResponse: string, tokenMap: Record<string, string>): RestoreResult;
+export function desanitize(aiResponse: string, tokenMap: Record<string, string>): RestoreResult;
+
+/**
+ * Recursively restores all masked tokens within a sanitized object, array, Map, or Set.
+ */
+export function restoreObject<T = any>(obj: T, tokenMap?: Record<string, string>): T;
 
 export interface EngineConfig {
     licenseKey?: string;
@@ -279,23 +338,98 @@ export interface EngineConfig {
     tokenLabelMap?: Record<string, string>;
     generateReceipt?: boolean;
     initialSessionMap?: Record<string, string>;
+    ignoreList?: string[] | Set<string>;
+    maxSessionTokens?: number;
 }
 
 export class PrivacyScrubberEngine {
+    sessionMap: Record<string, string>;
+    ignoreList: Set<string>;
     constructor(config?: EngineConfig);
     setLicenseKey(key: string): LicenseValidationResult;
-    sanitize(text: string, options?: SanitizeOptions & { persistSession?: boolean }): SanitizeResult;
+    sanitize(text: string, options?: SanitizeOptions & { persistSession?: boolean; maxSessionTokens?: number }): SanitizeResult;
     restore(aiResponse: string, tokenMap?: Record<string, string> | null): RestoreResult;
     resetSession(): void;
+    markFalsePositive(token: string): { success: boolean; token?: string; original?: string; ignoreListSize?: number; reason?: string };
+    clearIgnoreList(): 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>;
 }
 
 /**
- * Transparent zero-trust wrapper for OpenAI SDK client.
+ * Transparent zero-trust wrapper for OpenAI SDK client (chat.completions.create & responses.create).
  */
 export function wrapOpenAI<T = any>(openaiClient: T, options?: SanitizeOptions): T;
 
+/**
+ * Transparent zero-trust wrapper for Anthropic SDK client (messages.create).
+ */
+export function wrapAnthropic<T = any>(anthropicClient: T, options?: SanitizeOptions): T;
+
+/**
+ * Transparent zero-trust wrapper for Google Gemini SDKs (@google/genai and @google/generative-ai).
+ * Sanitizes string/Part[]/Content[] prompts and systemInstruction in RAM and restores tokens in sync and streaming responses.
+ */
+export function wrapGemini<T = any>(geminiClientOrModel: T, options?: SanitizeOptions & { engine?: PrivacyScrubberEngine }): T;
+export const wrapGoogleGenAI: typeof wrapGemini;
+
+/**
+ * Universal drop-in HTTP/SSE fetch wrapper for any OpenAI-compatible or custom LLM SDK
+ * (OpenAI, Anthropic, OpenRouter, Groq, DeepSeek, Mistral, Together, Ollama, Cloudflare AI Gateway).
+ */
+export interface PrivacyFetchOptions extends SanitizeOptions {
+    fetch?: typeof fetch;
+    engine?: PrivacyScrubberEngine;
+    sanitizeInputs?: boolean;
+    sanitizeOutputs?: boolean;
+    streamingOptions?: any;
+    onSanitized?: (telemetry: { url: string; tokenMap: Record<string, string>; tokenCount: number }) => void;
+}
+export function createPrivacyFetch(options?: PrivacyFetchOptions): typeof fetch & { engine: PrivacyScrubberEngine };
+
+/**
+ * OpenAI Agents SDK (@openai/agents) compatible InputGuardrail and OutputGuardrail factory.
+ */
+export interface OpenAIAgentGuardrailsOptions extends SanitizeOptions {
+    engine?: PrivacyScrubberEngine;
+    inputGuardrailName?: string;
+    outputGuardrailName?: string;
+    tripwireOnCritical?: boolean;
+    tripwireOnAnyPii?: boolean;
+    tripwireOnOutputLeak?: boolean;
+    mutateInPlace?: boolean;
+}
+export interface OpenAIAgentGuardrailsResult {
+    inputGuardrail: {
+        name: string;
+        execute: (args: { input: any; context?: any; agent?: any }) => Promise<{
+            tripwireTriggered: boolean;
+            outputInfo: {
+                scrubbedInput: any;
+                tokenMap: Record<string, string>;
+                tokenCount: number;
+                riskLevel: string;
+                frameworks?: string[];
+                telemetry: AuditTelemetry;
+            };
+        }>;
+    };
+    outputGuardrail: {
+        name: string;
+        execute: (args: { agentOutput: any; context?: any; agent?: any }) => Promise<{
+            tripwireTriggered: boolean;
+            outputInfo: {
+                restoredOutput: any;
+                restoredCount: number;
+            };
+        }>;
+    };
+    inputGuardrails: Array<OpenAIAgentGuardrailsResult['inputGuardrail']>;
+    outputGuardrails: Array<OpenAIAgentGuardrailsResult['outputGuardrail']>;
+    engine: PrivacyScrubberEngine;
+}
+export function createOpenAIAgentGuardrails(options?: OpenAIAgentGuardrailsOptions): OpenAIAgentGuardrailsResult;
+
 /**
  * Transparent zero-trust wrapper for Vercel AI SDK language models.
  * Sanitizes prompts in local RAM and detokenizes streaming and final outputs.
@@ -595,11 +729,15 @@ export function unscrubText(
 };
 
 declare const defaultExport: {
+    SDK_VERSION: typeof SDK_VERSION;
     clean: typeof clean;
     sanitize: typeof sanitize;
+    sanitizeObject: typeof sanitizeObject;
     scrub: typeof scrub;
     restore: typeof restore;
+    restoreObject: typeof restoreObject;
     unscrub: typeof unscrub;
+    desanitize: typeof desanitize;
     StreamingDetokenizer: typeof StreamingDetokenizer;
     createStreamTokenRestorer: typeof createStreamTokenRestorer;
     createNodeStreamTokenRestorer: typeof createNodeStreamTokenRestorer;
@@ -610,13 +748,28 @@ declare const defaultExport: {
     validateLicense: typeof validateLicense;
     validateLicenseKey: typeof validateLicenseKey;
     buildAuditTelemetry: typeof buildAuditTelemetry;
+    buildCisoAuditTelemetry: typeof buildCisoAuditTelemetry;
     formatAuditReceipt: typeof formatAuditReceipt;
+    generateAuditReport: typeof generateAuditReport;
+    PSR2_VERSION: typeof PSR2_VERSION;
+    PSR2_STATEMENTS: typeof PSR2_STATEMENTS;
+    buildPsr2Receipt: typeof buildPsr2Receipt;
+    psr2Lines: typeof psr2Lines;
+    formatCefEvent: typeof formatCefEvent;
+    formatSyslogEvent: typeof formatSyslogEvent;
+    formatJsonlEvent: typeof formatJsonlEvent;
+    createAuditLogger: typeof createAuditLogger;
     generateProcurementMemo: typeof generateProcurementMemo;
     PrivacyScrubberEngine: typeof PrivacyScrubberEngine;
     PrivacyScrubberLicenseError: typeof PrivacyScrubberLicenseError;
     wrapOpenAI: typeof wrapOpenAI;
+    wrapAnthropic: typeof wrapAnthropic;
+    wrapGemini: typeof wrapGemini;
+    wrapGoogleGenAI: typeof wrapGoogleGenAI;
     wrapAiModel: typeof wrapAiModel;
     wrapAiSdk: typeof wrapAiSdk;
+    createPrivacyFetch: typeof createPrivacyFetch;
+    createOpenAIAgentGuardrails: typeof createOpenAIAgentGuardrails;
     createLangChainTransform: typeof createLangChainTransform;
     createDocumentTransformer: typeof createDocumentTransformer;
     createLangChainDocumentTransformer: typeof createLangChainDocumentTransformer;
@@ -628,6 +781,7 @@ declare const defaultExport: {
     createGuardedTools: typeof createGuardedTools;
     scrubText: typeof scrubText;
     unscrubText: typeof unscrubText;
+    DEVOPS_SECRETS_DETECTOR: typeof DEVOPS_SECRETS_DETECTOR;
     stripExifMetadata: typeof stripExifMetadata;
     redactImageBoundingBoxes: typeof redactImageBoundingBoxes;
     generateSvgRedactionOverlay: typeof generateSvgRedactionOverlay;