openred 0.2.0

package/dist/integrations/anthropic.js

@@ -0,0 +1,50 @@
+import { RedactionPipeline } from '../chunk-65T2K4W6.js';
+
+// src/integrations/anthropic.ts
+function wrapAnthropic(client, options = {}) {
+  const autoRestore = options.autoRestore ?? true;
+  const pipeline = new RedactionPipeline({
+    ...options,
+    vault: autoRestore ? true : options.vault ?? false
+  });
+  const vault = pipeline.getVault();
+  const originalCreate = client.messages.create.bind(client.messages);
+  const wrappedCreate = async (params) => {
+    const redactedMessages = params.messages.map((msg) => {
+      if (typeof msg.content === "string") {
+        return { ...msg, content: pipeline.redact(msg.content).text };
+      }
+      if (Array.isArray(msg.content)) {
+        return {
+          ...msg,
+          content: msg.content.map((block) => {
+            if (block.type === "text" && typeof block.text === "string") {
+              return { ...block, text: pipeline.redact(block.text).text };
+            }
+            return block;
+          })
+        };
+      }
+      return msg;
+    });
+    const response = await originalCreate({
+      ...params,
+      messages: redactedMessages
+    });
+    if (autoRestore && vault && response.content) {
+      for (const block of response.content) {
+        if (block.type === "text" && typeof block.text === "string") {
+          block.text = vault.restore(block.text);
+        }
+      }
+    }
+    return response;
+  };
+  const proxy = Object.create(client);
+  proxy.messages = Object.create(client.messages);
+  proxy.messages.create = wrappedCreate;
+  proxy.pipeline = pipeline;
+  return proxy;
+}
+
+export { wrapAnthropic };

package/dist/integrations/langchain.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var chunkVAXUQISI_cjs = require('../chunk-VAXUQISI.cjs');
+
+// src/integrations/langchain.ts
+function wrapLangChain(llm, options = {}) {
+  const autoRestore = options.autoRestore ?? true;
+  const pipeline = new chunkVAXUQISI_cjs.RedactionPipeline({
+    ...options,
+    vault: autoRestore ? true : options.vault ?? false
+  });
+  const vault = pipeline.getVault();
+  const originalInvoke = llm.invoke.bind(llm);
+  const wrappedInvoke = async (input, invokeOptions) => {
+    const redacted = pipeline.redact(input);
+    let response = await originalInvoke(redacted.text, invokeOptions);
+    if (autoRestore && vault && typeof response === "string") {
+      response = vault.restore(response);
+    }
+    return response;
+  };
+  const proxy = Object.create(llm);
+  proxy.invoke = wrappedInvoke;
+  proxy.pipeline = pipeline;
+  return proxy;
+}
+
+exports.wrapLangChain = wrapLangChain;

package/dist/integrations/langchain.d.cts

@@ -0,0 +1,18 @@
+import { R as RedactionPipeline } from '../pipeline-D_6YC4Us.cjs';
+import { d as PipelineConfig } from '../vault-CDr54-Ev.cjs';
+
+interface BaseLLM {
+    invoke(input: string, options?: unknown): Promise<string>;
+}
+interface WrapLangChainOptions extends Partial<PipelineConfig> {
+    autoRestore?: boolean;
+}
+/**
+ * Wraps a LangChain-compatible LLM with PII redaction.
+ * Works with any object that has an invoke(string) method.
+ */
+declare function wrapLangChain<T extends BaseLLM>(llm: T, options?: WrapLangChainOptions): T & {
+    pipeline: RedactionPipeline;
+};
+
+export { type WrapLangChainOptions, wrapLangChain };

package/dist/integrations/langchain.d.ts

@@ -0,0 +1,18 @@
+import { R as RedactionPipeline } from '../pipeline-gWjT4cYU.js';
+import { d as PipelineConfig } from '../vault-CDr54-Ev.js';
+
+interface BaseLLM {
+    invoke(input: string, options?: unknown): Promise<string>;
+}
+interface WrapLangChainOptions extends Partial<PipelineConfig> {
+    autoRestore?: boolean;
+}
+/**
+ * Wraps a LangChain-compatible LLM with PII redaction.
+ * Works with any object that has an invoke(string) method.
+ */
+declare function wrapLangChain<T extends BaseLLM>(llm: T, options?: WrapLangChainOptions): T & {
+    pipeline: RedactionPipeline;
+};
+
+export { type WrapLangChainOptions, wrapLangChain };

package/dist/integrations/langchain.js

@@ -0,0 +1,26 @@
+import { RedactionPipeline } from '../chunk-65T2K4W6.js';
+
+// src/integrations/langchain.ts
+function wrapLangChain(llm, options = {}) {
+  const autoRestore = options.autoRestore ?? true;
+  const pipeline = new RedactionPipeline({
+    ...options,
+    vault: autoRestore ? true : options.vault ?? false
+  });
+  const vault = pipeline.getVault();
+  const originalInvoke = llm.invoke.bind(llm);
+  const wrappedInvoke = async (input, invokeOptions) => {
+    const redacted = pipeline.redact(input);
+    let response = await originalInvoke(redacted.text, invokeOptions);
+    if (autoRestore && vault && typeof response === "string") {
+      response = vault.restore(response);
+    }
+    return response;
+  };
+  const proxy = Object.create(llm);
+  proxy.invoke = wrappedInvoke;
+  proxy.pipeline = pipeline;
+  return proxy;
+}
+
+export { wrapLangChain };

package/dist/integrations/openai.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var chunkVAXUQISI_cjs = require('../chunk-VAXUQISI.cjs');
+
+// src/integrations/openai.ts
+function wrapOpenAI(client, options = {}) {
+  const autoRestore = options.autoRestore ?? true;
+  const pipeline = new chunkVAXUQISI_cjs.RedactionPipeline({
+    ...options,
+    vault: autoRestore ? true : options.vault ?? false
+  });
+  const vault = pipeline.getVault();
+  const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+  const wrappedCreate = async (params) => {
+    const redactedMessages = params.messages.map((msg) => ({
+      ...msg,
+      content: typeof msg.content === "string" ? pipeline.redact(msg.content).text : msg.content
+    }));
+    const response = await originalCreate({
+      ...params,
+      messages: redactedMessages
+    });
+    if (autoRestore && vault && response.choices) {
+      for (const choice of response.choices) {
+        if (choice.message && typeof choice.message.content === "string") {
+          choice.message.content = vault.restore(choice.message.content);
+        }
+      }
+    }
+    return response;
+  };
+  const proxy = Object.create(client);
+  proxy.chat = Object.create(client.chat);
+  proxy.chat.completions = Object.create(client.chat.completions);
+  proxy.chat.completions.create = wrappedCreate;
+  proxy.pipeline = pipeline;
+  return proxy;
+}
+
+exports.wrapOpenAI = wrapOpenAI;

package/dist/integrations/openai.d.cts

@@ -0,0 +1,38 @@
+import { R as RedactionPipeline } from '../pipeline-D_6YC4Us.cjs';
+import { d as PipelineConfig } from '../vault-CDr54-Ev.cjs';
+
+interface ChatMessage {
+    role: string;
+    content: string | null;
+}
+interface Choice {
+    message?: {
+        content?: string | null;
+    };
+    [key: string]: unknown;
+}
+interface ChatCompletion {
+    choices: Choice[];
+    [key: string]: unknown;
+}
+interface CreateParams {
+    messages: ChatMessage[];
+    [key: string]: unknown;
+}
+interface ChatCompletions {
+    create(params: CreateParams): Promise<ChatCompletion>;
+}
+interface Chat {
+    completions: ChatCompletions;
+}
+interface OpenAILike {
+    chat: Chat;
+}
+interface WrapOpenAIOptions extends Partial<PipelineConfig> {
+    autoRestore?: boolean;
+}
+declare function wrapOpenAI<T extends OpenAILike>(client: T, options?: WrapOpenAIOptions): T & {
+    pipeline: RedactionPipeline;
+};
+
+export { type WrapOpenAIOptions, wrapOpenAI };

package/dist/integrations/openai.d.ts

@@ -0,0 +1,38 @@
+import { R as RedactionPipeline } from '../pipeline-gWjT4cYU.js';
+import { d as PipelineConfig } from '../vault-CDr54-Ev.js';
+
+interface ChatMessage {
+    role: string;
+    content: string | null;
+}
+interface Choice {
+    message?: {
+        content?: string | null;
+    };
+    [key: string]: unknown;
+}
+interface ChatCompletion {
+    choices: Choice[];
+    [key: string]: unknown;
+}
+interface CreateParams {
+    messages: ChatMessage[];
+    [key: string]: unknown;
+}
+interface ChatCompletions {
+    create(params: CreateParams): Promise<ChatCompletion>;
+}
+interface Chat {
+    completions: ChatCompletions;
+}
+interface OpenAILike {
+    chat: Chat;
+}
+interface WrapOpenAIOptions extends Partial<PipelineConfig> {
+    autoRestore?: boolean;
+}
+declare function wrapOpenAI<T extends OpenAILike>(client: T, options?: WrapOpenAIOptions): T & {
+    pipeline: RedactionPipeline;
+};
+
+export { type WrapOpenAIOptions, wrapOpenAI };

package/dist/integrations/openai.js

@@ -0,0 +1,38 @@
+import { RedactionPipeline } from '../chunk-65T2K4W6.js';
+
+// src/integrations/openai.ts
+function wrapOpenAI(client, options = {}) {
+  const autoRestore = options.autoRestore ?? true;
+  const pipeline = new RedactionPipeline({
+    ...options,
+    vault: autoRestore ? true : options.vault ?? false
+  });
+  const vault = pipeline.getVault();
+  const originalCreate = client.chat.completions.create.bind(client.chat.completions);
+  const wrappedCreate = async (params) => {
+    const redactedMessages = params.messages.map((msg) => ({
+      ...msg,
+      content: typeof msg.content === "string" ? pipeline.redact(msg.content).text : msg.content
+    }));
+    const response = await originalCreate({
+      ...params,
+      messages: redactedMessages
+    });
+    if (autoRestore && vault && response.choices) {
+      for (const choice of response.choices) {
+        if (choice.message && typeof choice.message.content === "string") {
+          choice.message.content = vault.restore(choice.message.content);
+        }
+      }
+    }
+    return response;
+  };
+  const proxy = Object.create(client);
+  proxy.chat = Object.create(client.chat);
+  proxy.chat.completions = Object.create(client.chat.completions);
+  proxy.chat.completions.create = wrappedCreate;
+  proxy.pipeline = pipeline;
+  return proxy;
+}
+
+export { wrapOpenAI };

package/dist/middleware/express.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+var chunkDWYPLA6C_cjs = require('../chunk-DWYPLA6C.cjs');
+var chunkVAXUQISI_cjs = require('../chunk-VAXUQISI.cjs');
+
+// src/middleware/express.ts
+function piiMiddleware(options = {}) {
+  const pipeline = new chunkVAXUQISI_cjs.RedactionPipeline({
+    ...options,
+    vault: options.passVault ? true : options.vault ?? false
+  });
+  return (req, _res, next) => {
+    if (options.passVault) {
+      req.openredVault = pipeline.getVault() ?? void 0;
+    }
+    if (options.fields && options.fields.length > 0) {
+      for (const fieldPath of options.fields) {
+        const value = chunkDWYPLA6C_cjs.getNestedValue(req, fieldPath);
+        if (typeof value === "string") {
+          chunkDWYPLA6C_cjs.setNestedValue(req, fieldPath, pipeline.redact(value).text);
+        }
+      }
+    } else if (req.body) {
+      chunkDWYPLA6C_cjs.transformStrings(req.body, (s) => pipeline.redact(s).text);
+    }
+    next();
+  };
+}
+
+exports.piiMiddleware = piiMiddleware;

package/dist/middleware/express.d.cts

@@ -0,0 +1,16 @@
+import { d as PipelineConfig, V as Vault } from '../vault-CDr54-Ev.cjs';
+
+interface PiiMiddlewareOptions extends Partial<PipelineConfig> {
+    /** Specific dot-notation field paths to redact. If not set, redacts all string values in body. */
+    fields?: string[];
+    /** Attach vault to req.openredVault for de-redaction in response handlers. */
+    passVault?: boolean;
+}
+interface OpenredRequest {
+    body?: unknown;
+    query?: unknown;
+    openredVault?: Vault;
+}
+declare function piiMiddleware(options?: PiiMiddlewareOptions): (req: OpenredRequest, _res: unknown, next: () => void) => void;
+
+export { type PiiMiddlewareOptions, piiMiddleware };

package/dist/middleware/express.d.ts

@@ -0,0 +1,16 @@
+import { d as PipelineConfig, V as Vault } from '../vault-CDr54-Ev.js';
+
+interface PiiMiddlewareOptions extends Partial<PipelineConfig> {
+    /** Specific dot-notation field paths to redact. If not set, redacts all string values in body. */
+    fields?: string[];
+    /** Attach vault to req.openredVault for de-redaction in response handlers. */
+    passVault?: boolean;
+}
+interface OpenredRequest {
+    body?: unknown;
+    query?: unknown;
+    openredVault?: Vault;
+}
+declare function piiMiddleware(options?: PiiMiddlewareOptions): (req: OpenredRequest, _res: unknown, next: () => void) => void;
+
+export { type PiiMiddlewareOptions, piiMiddleware };

package/dist/middleware/express.js

@@ -0,0 +1,28 @@
+import { getNestedValue, setNestedValue, transformStrings } from '../chunk-ABSJVCYK.js';
+import { RedactionPipeline } from '../chunk-65T2K4W6.js';
+
+// src/middleware/express.ts
+function piiMiddleware(options = {}) {
+  const pipeline = new RedactionPipeline({
+    ...options,
+    vault: options.passVault ? true : options.vault ?? false
+  });
+  return (req, _res, next) => {
+    if (options.passVault) {
+      req.openredVault = pipeline.getVault() ?? void 0;
+    }
+    if (options.fields && options.fields.length > 0) {
+      for (const fieldPath of options.fields) {
+        const value = getNestedValue(req, fieldPath);
+        if (typeof value === "string") {
+          setNestedValue(req, fieldPath, pipeline.redact(value).text);
+        }
+      }
+    } else if (req.body) {
+      transformStrings(req.body, (s) => pipeline.redact(s).text);
+    }
+    next();
+  };
+}
+
+export { piiMiddleware };

package/dist/middleware/fastify.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+var chunkDWYPLA6C_cjs = require('../chunk-DWYPLA6C.cjs');
+var chunkVAXUQISI_cjs = require('../chunk-VAXUQISI.cjs');
+
+// src/middleware/fastify.ts
+function piiFastifyHook(options = {}) {
+  const pipeline = new chunkVAXUQISI_cjs.RedactionPipeline({
+    ...options,
+    vault: options.passVault ? true : options.vault ?? false
+  });
+  return (req, _reply, done) => {
+    if (options.passVault) {
+      req.openredVault = pipeline.getVault() ?? void 0;
+    }
+    if (req.body) {
+      chunkDWYPLA6C_cjs.transformStrings(req.body, (s) => pipeline.redact(s).text);
+    }
+    done();
+  };
+}
+
+exports.piiFastifyHook = piiFastifyHook;

package/dist/middleware/fastify.d.cts

@@ -0,0 +1,27 @@
+import { d as PipelineConfig, V as Vault } from '../vault-CDr54-Ev.cjs';
+
+interface PiiFastifyOptions extends Partial<PipelineConfig> {
+    passVault?: boolean;
+}
+interface FastifyRequest {
+    body?: unknown;
+    openredVault?: Vault;
+}
+interface FastifyReply {
+    [key: string]: unknown;
+}
+/**
+ * Fastify plugin-style hook for PII redaction.
+ *
+ * @example
+ * ```ts
+ * import Fastify from 'fastify';
+ * import { piiFastifyHook } from 'openred/middleware/fastify';
+ *
+ * const app = Fastify();
+ * app.addHook('preHandler', piiFastifyHook({ strategy: 'placeholder' }));
+ * ```
+ */
+declare function piiFastifyHook(options?: PiiFastifyOptions): (req: FastifyRequest, _reply: FastifyReply, done: () => void) => void;
+
+export { type PiiFastifyOptions, piiFastifyHook };

package/dist/middleware/fastify.d.ts

@@ -0,0 +1,27 @@
+import { d as PipelineConfig, V as Vault } from '../vault-CDr54-Ev.js';
+
+interface PiiFastifyOptions extends Partial<PipelineConfig> {
+    passVault?: boolean;
+}
+interface FastifyRequest {
+    body?: unknown;
+    openredVault?: Vault;
+}
+interface FastifyReply {
+    [key: string]: unknown;
+}
+/**
+ * Fastify plugin-style hook for PII redaction.
+ *
+ * @example
+ * ```ts
+ * import Fastify from 'fastify';
+ * import { piiFastifyHook } from 'openred/middleware/fastify';
+ *
+ * const app = Fastify();
+ * app.addHook('preHandler', piiFastifyHook({ strategy: 'placeholder' }));
+ * ```
+ */
+declare function piiFastifyHook(options?: PiiFastifyOptions): (req: FastifyRequest, _reply: FastifyReply, done: () => void) => void;
+
+export { type PiiFastifyOptions, piiFastifyHook };

package/dist/middleware/fastify.js

@@ -0,0 +1,21 @@
+import { transformStrings } from '../chunk-ABSJVCYK.js';
+import { RedactionPipeline } from '../chunk-65T2K4W6.js';
+
+// src/middleware/fastify.ts
+function piiFastifyHook(options = {}) {
+  const pipeline = new RedactionPipeline({
+    ...options,
+    vault: options.passVault ? true : options.vault ?? false
+  });
+  return (req, _reply, done) => {
+    if (options.passVault) {
+      req.openredVault = pipeline.getVault() ?? void 0;
+    }
+    if (req.body) {
+      transformStrings(req.body, (s) => pipeline.redact(s).text);
+    }
+    done();
+  };
+}
+
+export { piiFastifyHook };

package/dist/pipeline-D_6YC4Us.d.cts

@@ -0,0 +1,16 @@
+import { d as PipelineConfig, a as PIIDetector, e as RedactionResult, V as Vault } from './vault-CDr54-Ev.cjs';
+
+declare class RedactionPipeline {
+    private detectors;
+    private strategyFn;
+    private vault;
+    private config;
+    constructor(config?: Partial<PipelineConfig>);
+    addDetector(detector: PIIDetector): void;
+    redact(text: string): RedactionResult;
+    /** Get the vault instance (only available if vault: true). */
+    getVault(): Vault | null;
+    private applyLists;
+}
+
+export { RedactionPipeline as R };

package/dist/pipeline-gWjT4cYU.d.ts

@@ -0,0 +1,16 @@
+import { d as PipelineConfig, a as PIIDetector, e as RedactionResult, V as Vault } from './vault-CDr54-Ev.js';
+
+declare class RedactionPipeline {
+    private detectors;
+    private strategyFn;
+    private vault;
+    private config;
+    constructor(config?: Partial<PipelineConfig>);
+    addDetector(detector: PIIDetector): void;
+    redact(text: string): RedactionResult;
+    /** Get the vault instance (only available if vault: true). */
+    getVault(): Vault | null;
+    private applyLists;
+}
+
+export { RedactionPipeline as R };

package/dist/vault-CDr54-Ev.d.cts

@@ -0,0 +1,80 @@
+type PIIType = 'EMAIL' | 'PHONE' | 'SSN' | 'CREDIT_CARD' | 'IP_ADDRESS' | 'DATE_OF_BIRTH' | 'ADDRESS' | 'URL' | (string & {});
+type ConfidenceLevel = 'high' | 'medium' | 'low';
+interface PIIMatch {
+    type: PIIType;
+    value: string;
+    start: number;
+    end: number;
+    confidence: number;
+    detector: string;
+}
+interface PIIDetector {
+    name: string;
+    type: PIIType;
+    confidence: ConfidenceLevel;
+    detect(text: string, context?: DetectionContext): PIIMatch[];
+}
+interface DetectionContext {
+    locale?: string;
+}
+type RedactorFn = (match: PIIMatch) => string;
+type RedactionStrategy = 'placeholder' | 'hash' | 'mask' | 'category' | RedactorFn;
+interface TokenMapping {
+    original: string;
+    replacement: string;
+    type: PIIType;
+    confidence: number;
+}
+interface RedactionResult {
+    text: string;
+    matches: PIIMatch[];
+    tokens: TokenMapping[];
+    stats: {
+        totalDetected: number;
+        byType: Record<string, number>;
+        processingTimeMs: number;
+    };
+}
+interface VaultEntry {
+    original: string;
+    replacement: string;
+    type: PIIType;
+}
+interface AggregatorConfig {
+    overlapResolution: 'longest' | 'highest-confidence' | 'first';
+    minConfidence: number;
+    mergeAdjacent: boolean;
+}
+interface PipelineConfig {
+    detectors: PIIDetector[];
+    locale?: string;
+    minConfidence?: number;
+    strategy?: RedactionStrategy;
+    vault?: boolean;
+    vaultTTL?: number;
+    allowList?: string[];
+    denyList?: string[];
+    overlapResolution?: 'longest' | 'highest-confidence' | 'first';
+    onDetection?: (match: PIIMatch) => void;
+    onRedaction?: (result: RedactionResult) => void;
+}
+
+declare class Vault {
+    private replacementToOriginal;
+    private originalToReplacement;
+    private ttl?;
+    private timers;
+    constructor(options?: {
+        ttl?: number;
+    });
+    store(original: string, replacement: string, type: PIIType): void;
+    getReplacementFor(original: string): string | undefined;
+    restore(text: string): string;
+    getMapping(): Map<string, VaultEntry>;
+    getEntries(): VaultEntry[];
+    clear(): void;
+    export(): string;
+    import(data: string): void;
+}
+
+export { type AggregatorConfig as A, type ConfidenceLevel as C, type DetectionContext as D, type PIIMatch as P, type RedactorFn as R, type TokenMapping as T, Vault as V, type PIIDetector as a, type RedactionStrategy as b, type PIIType as c, type PipelineConfig as d, type RedactionResult as e, type VaultEntry as f };