sensored

import { createRedactor, preloadPersonNameDetector } from "sensored";

await preloadPersonNameDetector();

const redactor = createRedactor({
  rules: { person_name: { action: "redact" } },
});

import { createRedactor } from "sensored";

const redactor = createRedactor({ presets: ["pii"], rules: {} });

const text = "Contact me at john@example.com or call 555-123-4567.";
const redacted = redactor.redact(text);
// "Contact me at [EMAIL_1] or call [PHONE_1]."

const redactor = createRedactor({
  rules: { person_name_lite: { action: "redact" } },
  semantic: {
    provider: "jev",
    apiKey: process.env.TYPESAFE_API_KEY!,
  },
});

const result = await redactor.redactAsync("Contact John Smith today");
// result.text: "Contact [PERSON_NAME] today"
// result.detections[0].semanticConfirmed: true

const redactor = createRedactor({
  presets: ["pii"],
  rules: {},
  restore: true,
});

const { text, map } = redactor.redact("Email: john@example.com");
// text: "Email: [EMAIL_1]"
// map: { "[EMAIL_1]": "john@example.com" }

const restored = redactor.restore(text, map);
// "Email: john@example.com"

const redactor = createRedactor({ presets: ["pii"], rules: {} });

const stream = redactor.stream(asyncChunks());
for await (const event of stream) {
  if (event.type === "text") {
    process.stdout.write(event.text);
  }
}

// Pino
import pino from "pino";
import { pinoRedact } from "sensored/loggers/pino";

const logger = pino({
  ...pinoRedact({ presets: ["pii"], rules: {} }),
});

// Winston
import winston from "winston";
import { winstonRedact } from "sensored/loggers/winston";

const redact = winstonRedact({ presets: ["pii"], rules: {} });
const redactFormat = winston.format((info) => {
  Object.assign(info, redact(info));
  return info;
})();

// Morgan
import { morganRedact } from "sensored/loggers/morgan";

const stream = morganRedact({ presets: ["pii"], rules: {} }, process.stdout);

// Bunyan
import { bunyanRedact } from "sensored/loggers/bunyan";

const stream = bunyanRedact({ presets: ["pii"], rules: {} }, process.stdout);

// Console
import { wrapConsole } from "sensored/loggers/console";

const restore = wrapConsole({ presets: ["pii"], rules: {} });
console.log("Contact alice@example.com"); // → Contact [EMAIL_1]
restore();

// log4js
import log4js from "log4js";

log4js.configure({
  appenders: {
    stdout: { type: "stdout" },
    redacted: {
      type: "sensored/loggers/log4js",
      appender: "stdout",
      redact: { presets: ["pii"], rules: {} },
    },
  },
  categories: { default: { appenders: ["redacted"], level: "info" } },
});

// OpenAI
import OpenAI from "openai";
import { wrapOpenAI } from "sensored/adapters/openai";

const client = wrapOpenAI(new OpenAI(), { presets: ["pii"], rules: {} });
const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Email john@example.com about order #123" }],
});
// Model receives redacted prompt; response is restored automatically.

// Anthropic
import Anthropic from "@anthropic-ai/sdk";
import { wrapAnthropic } from "sensored/adapters/anthropic";

const client = wrapAnthropic(new Anthropic(), { presets: ["pii"], rules: {} });
const response = await client.messages.create({
  model: "claude-sonnet-4-5-20250514",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Email alice@example.com" }],
});

import { createSession } from "sensored";

const session = createSession({ presets: ["pii"], rules: {} });

const turn1 = session.redact("Email john@example.com");
// "Email [EMAIL_1]"
const turn2 = session.redact("Reply to john@example.com please");
// "Reply to [EMAIL_1] please"

// Restore placeholders in LLM responses
const restored = session.restore("Sure, I emailed [EMAIL_1]");
// "Sure, I emailed john@example.com"

// Access the map for persistence
const map = session.map; // { "[EMAIL_1]": "john@example.com" }

// Reset between conversations (preserves hydration map)
session.reset();

import { createEncryptedSession, LocalVaultProvider } from "sensored/vault";
import { randomBytes } from "node:crypto";

const provider = new LocalVaultProvider({ key: randomBytes(32) });

const session = await createEncryptedSession({
  provider,
  redactorConfig: { presets: ["pii"], rules: {} },
});

session.redact("Email john@example.com"); // "Email [EMAIL_1]"

// Seal the map for persistence
const sealed = await session.seal(); // base64 blob — safe to store

// Reopen later
import { open } from "sensored/vault";
const map = await open(sealed, provider);

session.dispose(); // zeroes the DEK from memory

import { createRedactor, type DetectorDefinition } from "sensored";

const employeeId: DetectorDefinition = {
  id: "employee_id",
  entityType: "employee_id",
  pattern: /\bEMP-\d{6}\b/g,
  replacement: "[EMPLOYEE_ID]",
};

const redactor = createRedactor({
  presets: ["pii"],
  rules: { employee_id: { action: "redact" } },
  detectors: [employeeId],
});

const redactor = createRedactor({
  presets: ["pii"],
  rules: {},
  allowlist: ["john@example.com"],
});

redactor.redact("Contact john@example.com or jane@example.com");
// "Contact john@example.com or [EMAIL_1]."