@dexto/core 1.1.10 → 1.2.0

package/dist/memory/schemas.d.ts

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+export declare const MemorySourceSchema: z.ZodEnum<["user", "system"]>;
+export declare const MemoryMetadataSchema: z.ZodObject<{
+    source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
+export declare const MemorySchema: z.ZodObject<{
+    id: z.ZodString;
+    content: z.ZodString;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    content: string;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: z.objectOutputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    tags?: string[] | undefined;
+}, {
+    id: string;
+    content: string;
+    createdAt: number;
+    updatedAt: number;
+    metadata?: z.objectInputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    tags?: string[] | undefined;
+}>;
+export declare const CreateMemoryInputSchema: z.ZodObject<{
+    content: z.ZodString;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    content: string;
+    metadata?: z.objectOutputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    tags?: string[] | undefined;
+}, {
+    content: string;
+    metadata?: z.objectInputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    tags?: string[] | undefined;
+}>;
+export declare const UpdateMemoryInputSchema: z.ZodObject<{
+    content: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    metadata?: z.objectOutputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    tags?: string[] | undefined;
+    content?: string | undefined;
+}, {
+    metadata?: z.objectInputType<{
+        source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+        pinned: z.ZodOptional<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    tags?: string[] | undefined;
+    content?: string | undefined;
+}>;
+export declare const ListMemoriesOptionsSchema: z.ZodObject<{
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    source: z.ZodOptional<z.ZodEnum<["user", "system"]>>;
+    pinned: z.ZodOptional<z.ZodBoolean>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    tags?: string[] | undefined;
+    source?: "user" | "system" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    pinned?: boolean | undefined;
+}, {
+    tags?: string[] | undefined;
+    source?: "user" | "system" | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
+    pinned?: boolean | undefined;
+}>;
+export type ValidatedMemory = z.output<typeof MemorySchema>;
+export type ValidatedCreateMemoryInput = z.output<typeof CreateMemoryInputSchema>;
+export type ValidatedUpdateMemoryInput = z.output<typeof UpdateMemoryInputSchema>;
+export type ValidatedListMemoriesOptions = z.output<typeof ListMemoriesOptionsSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/memory/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/memory/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,kBAAkB,+BAA8D,CAAC;AAE9F,eAAO,MAAM,oBAAoB;;;;;;;;;gCAMD,CAAC;AAEjC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBwB,CAAC;AAElD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkBY,CAAC;AAEjD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBkB,CAAC;AAEvD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;EASO,CAAC;AAE9C,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,YAAY,CAAC,CAAC;AAC5D,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAClF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAClF,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/memory/schemas.js

@@ -0,0 +1,54 @@
+import "../chunk-C6A6W6XS.js";
+import { z } from "zod";
+const MAX_CONTENT_LENGTH = 1e4;
+const MAX_TAG_LENGTH = 50;
+const MAX_TAGS = 10;
+const MemorySourceSchema = z.enum(["user", "system"]).describe("Source of the memory");
+const MemoryMetadataSchema = z.object({
+  source: MemorySourceSchema.optional().describe("Source of the memory"),
+  pinned: z.boolean().optional().describe("Whether this memory is pinned for auto-loading")
+}).passthrough().describe("Memory metadata");
+const MemorySchema = z.object({
+  id: z.string().min(1).describe("Unique identifier for the memory"),
+  content: z.string().min(1, "Memory content cannot be empty").max(
+    MAX_CONTENT_LENGTH,
+    `Memory content cannot exceed ${MAX_CONTENT_LENGTH} characters`
+  ).describe("The actual memory content"),
+  createdAt: z.number().int().positive().describe("Creation timestamp (Unix ms)"),
+  updatedAt: z.number().int().positive().describe("Last update timestamp (Unix ms)"),
+  tags: z.array(z.string().min(1).max(MAX_TAG_LENGTH)).max(MAX_TAGS).optional().describe("Optional tags for categorization"),
+  metadata: MemoryMetadataSchema.optional().describe("Additional metadata")
+}).strict().describe("Memory item stored in the system");
+const CreateMemoryInputSchema = z.object({
+  content: z.string().min(1, "Memory content cannot be empty").max(
+    MAX_CONTENT_LENGTH,
+    `Memory content cannot exceed ${MAX_CONTENT_LENGTH} characters`
+  ).describe("The memory content"),
+  tags: z.array(z.string().min(1).max(MAX_TAG_LENGTH)).max(MAX_TAGS).optional().describe("Optional tags"),
+  metadata: MemoryMetadataSchema.optional().describe("Optional metadata")
+}).strict().describe("Input for creating a new memory");
+const UpdateMemoryInputSchema = z.object({
+  content: z.string().min(1, "Memory content cannot be empty").max(
+    MAX_CONTENT_LENGTH,
+    `Memory content cannot exceed ${MAX_CONTENT_LENGTH} characters`
+  ).optional().describe("Updated content"),
+  tags: z.array(z.string().min(1).max(MAX_TAG_LENGTH)).max(MAX_TAGS).optional().describe("Updated tags (replaces existing)"),
+  metadata: MemoryMetadataSchema.optional().describe(
+    "Updated metadata (merges with existing)"
+  )
+}).strict().describe("Input for updating an existing memory");
+const ListMemoriesOptionsSchema = z.object({
+  tags: z.array(z.string()).optional().describe("Filter by tags"),
+  source: MemorySourceSchema.optional().describe("Filter by source"),
+  pinned: z.boolean().optional().describe("Filter by pinned status"),
+  limit: z.number().int().positive().optional().describe("Limit number of results"),
+  offset: z.number().int().nonnegative().optional().describe("Skip first N results")
+}).strict().describe("Options for listing memories");
+export {
+  CreateMemoryInputSchema,
+  ListMemoriesOptionsSchema,
+  MemoryMetadataSchema,
+  MemorySchema,
+  MemorySourceSchema,
+  UpdateMemoryInputSchema
+};

package/dist/memory/types.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Core memory types and interfaces
+ */
+/**
+ * Supported memory sources
+ */
+export type MemorySource = 'user' | 'system';
+/**
+ * Memory item stored in the system
+ */
+export interface Memory {
+    /** Unique identifier for the memory */
+    id: string;
+    /** The actual memory content */
+    content: string;
+    /** When the memory was created (Unix timestamp in milliseconds) */
+    createdAt: number;
+    /** When the memory was last updated (Unix timestamp in milliseconds) */
+    updatedAt: number;
+    /** Optional tags for categorization */
+    tags?: string[] | undefined;
+    /** Additional metadata */
+    metadata?: {
+        /** Source of the memory */
+        source?: MemorySource | undefined;
+        /** Whether this memory is pinned (for future hybrid approach) */
+        pinned?: boolean | undefined;
+        /** Any additional custom metadata */
+        [key: string]: unknown;
+    } | undefined;
+}
+/**
+ * Input for creating a new memory
+ */
+export interface CreateMemoryInput {
+    /** The memory content */
+    content: string;
+    /** Optional tags */
+    tags?: string[];
+    /** Optional metadata */
+    metadata?: {
+        source?: MemorySource;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Input for updating an existing memory
+ */
+export interface UpdateMemoryInput {
+    /** Updated content (optional) */
+    content?: string;
+    /** Updated tags (optional, replaces existing) */
+    tags?: string[];
+    /** Updated metadata (optional, merges with existing) */
+    metadata?: {
+        source?: MemorySource;
+        pinned?: boolean;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Options for listing memories
+ */
+export interface ListMemoriesOptions {
+    /** Filter by tags */
+    tags?: string[];
+    /** Filter by source */
+    source?: MemorySource;
+    /** Filter by pinned status */
+    pinned?: boolean;
+    /** Limit number of results */
+    limit?: number;
+    /** Skip first N results */
+    offset?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/memory/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/memory/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,MAAM;IACnB,uCAAuC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB,uCAAuC;IACvC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,0BAA0B;IAC1B,QAAQ,CAAC,EACH;QACI,2BAA2B;QAC3B,MAAM,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;QAClC,iEAAiE;QACjE,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;QAC7B,qCAAqC;QACrC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,GACD,SAAS,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,oBAAoB;IACpB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,wBAAwB;IACxB,QAAQ,CAAC,EAAE;QACP,MAAM,CAAC,EAAE,YAAY,CAAC;QACtB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,CAAC;CACL;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,wDAAwD;IACxD,QAAQ,CAAC,EAAE;QACP,MAAM,CAAC,EAAE,YAAY,CAAC;QACtB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KAC1B,CAAC;CACL;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,qBAAqB;IACrB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,uBAAuB;IACvB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,8BAA8B;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/plugins/builtins/content-policy.cjs

@@ -0,0 +1,112 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var content_policy_exports = {};
+__export(content_policy_exports, {
+  ContentPolicyPlugin: () => ContentPolicyPlugin
+});
+module.exports = __toCommonJS(content_policy_exports);
+const DEFAULTS = {
+  maxInputChars: 0,
+  redactEmails: false,
+  redactApiKeys: false
+};
+const ABUSIVE_PATTERNS = [
+  /\b(?:fuck|shit|bitch|asshole|bastard|cunt|dick|fag|slut|whore|nigger|retard|motherfucker|cock|piss|twat|wank|prick|spastic|chink|gook|kike|spic|wetback|tranny|dyke|homo|queer|faggot|rape|rapist)\b/i
+];
+function containsAbusiveLanguage(text) {
+  return ABUSIVE_PATTERNS.some((pattern) => pattern.test(text));
+}
+class ContentPolicyPlugin {
+  config = DEFAULTS;
+  async initialize(config) {
+    this.config = {
+      maxInputChars: config.maxInputChars ?? DEFAULTS.maxInputChars,
+      redactEmails: config.redactEmails ?? DEFAULTS.redactEmails,
+      redactApiKeys: config.redactApiKeys ?? DEFAULTS.redactApiKeys
+    };
+  }
+  async beforeLLMRequest(payload, _context) {
+    const notices = [];
+    const { text } = payload;
+    if (containsAbusiveLanguage(text)) {
+      const abusiveNotice = {
+        kind: "block",
+        code: "content_policy.abusive_language",
+        message: "Input violates content policy due to abusive language."
+      };
+      notices.push(abusiveNotice);
+      return {
+        ok: false,
+        cancel: true,
+        message: abusiveNotice.message,
+        notices
+      };
+    }
+    let modified = text;
+    if (this.config.maxInputChars > 0 && modified.length > this.config.maxInputChars) {
+      modified = modified.slice(0, this.config.maxInputChars);
+      notices.push({
+        kind: "warn",
+        code: "content_policy.truncated",
+        message: `Input truncated to ${this.config.maxInputChars} characters to meet policy limits.`,
+        details: { originalLength: text.length }
+      });
+    }
+    if (this.config.redactEmails) {
+      const replaced = modified.replace(
+        /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g,
+        "[redacted-email]"
+      );
+      if (replaced !== modified) {
+        notices.push({
+          kind: "info",
+          code: "content_policy.redact_email",
+          message: "Email addresses were redacted from the input."
+        });
+        modified = replaced;
+      }
+    }
+    if (this.config.redactApiKeys) {
+      const replaced = modified.replace(
+        /(api_key|apikey|bearer)\s*[:=]?\s*([A-Za-z0-9_-]{12,})/gi,
+        "$1 [redacted]"
+      );
+      if (replaced !== modified) {
+        notices.push({
+          kind: "info",
+          code: "content_policy.redact_api_key",
+          message: "Potential API keys were redacted from the input."
+        });
+        modified = replaced;
+      }
+    }
+    if (modified !== text || notices.length > 0) {
+      return {
+        ok: true,
+        modify: { text: modified },
+        notices
+      };
+    }
+    return { ok: true };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentPolicyPlugin
+});

package/dist/plugins/builtins/content-policy.d.ts

@@ -0,0 +1,26 @@
+import type { DextoPlugin, PluginResult, BeforeLLMRequestPayload, PluginExecutionContext } from '../types.js';
+/**
+ * Configuration options for the ContentPolicy plugin
+ */
+export interface ContentPolicyConfig {
+    maxInputChars?: number;
+    redactEmails?: boolean;
+    redactApiKeys?: boolean;
+}
+/**
+ * ContentPolicy Plugin
+ *
+ * Enforces content policies on LLM requests including:
+ * - Abusive language detection (blocking)
+ * - Input length limits
+ * - Email address redaction
+ * - API key redaction
+ *
+ * Ported from feat/hooks content-policy hook implementation
+ */
+export declare class ContentPolicyPlugin implements DextoPlugin {
+    private config;
+    initialize(config: Record<string, any>): Promise<void>;
+    beforeLLMRequest(payload: BeforeLLMRequestPayload, _context: PluginExecutionContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=content-policy.d.ts.map

package/dist/plugins/builtins/content-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content-policy.d.ts","sourceRoot":"","sources":["../../../src/plugins/builtins/content-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,WAAW,EACX,YAAY,EAEZ,uBAAuB,EACvB,sBAAsB,EACzB,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CAC3B;AAgBD;;;;;;;;;;GAUG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACnD,OAAO,CAAC,MAAM,CAA2C;IAEnD,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAQtD,gBAAgB,CAClB,OAAO,EAAE,uBAAuB,EAChC,QAAQ,EAAE,sBAAsB,GACjC,OAAO,CAAC,YAAY,CAAC;CA6E3B"}

package/dist/plugins/builtins/content-policy.js

@@ -0,0 +1,89 @@
+import "../../chunk-C6A6W6XS.js";
+const DEFAULTS = {
+  maxInputChars: 0,
+  redactEmails: false,
+  redactApiKeys: false
+};
+const ABUSIVE_PATTERNS = [
+  /\b(?:fuck|shit|bitch|asshole|bastard|cunt|dick|fag|slut|whore|nigger|retard|motherfucker|cock|piss|twat|wank|prick|spastic|chink|gook|kike|spic|wetback|tranny|dyke|homo|queer|faggot|rape|rapist)\b/i
+];
+function containsAbusiveLanguage(text) {
+  return ABUSIVE_PATTERNS.some((pattern) => pattern.test(text));
+}
+class ContentPolicyPlugin {
+  config = DEFAULTS;
+  async initialize(config) {
+    this.config = {
+      maxInputChars: config.maxInputChars ?? DEFAULTS.maxInputChars,
+      redactEmails: config.redactEmails ?? DEFAULTS.redactEmails,
+      redactApiKeys: config.redactApiKeys ?? DEFAULTS.redactApiKeys
+    };
+  }
+  async beforeLLMRequest(payload, _context) {
+    const notices = [];
+    const { text } = payload;
+    if (containsAbusiveLanguage(text)) {
+      const abusiveNotice = {
+        kind: "block",
+        code: "content_policy.abusive_language",
+        message: "Input violates content policy due to abusive language."
+      };
+      notices.push(abusiveNotice);
+      return {
+        ok: false,
+        cancel: true,
+        message: abusiveNotice.message,
+        notices
+      };
+    }
+    let modified = text;
+    if (this.config.maxInputChars > 0 && modified.length > this.config.maxInputChars) {
+      modified = modified.slice(0, this.config.maxInputChars);
+      notices.push({
+        kind: "warn",
+        code: "content_policy.truncated",
+        message: `Input truncated to ${this.config.maxInputChars} characters to meet policy limits.`,
+        details: { originalLength: text.length }
+      });
+    }
+    if (this.config.redactEmails) {
+      const replaced = modified.replace(
+        /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g,
+        "[redacted-email]"
+      );
+      if (replaced !== modified) {
+        notices.push({
+          kind: "info",
+          code: "content_policy.redact_email",
+          message: "Email addresses were redacted from the input."
+        });
+        modified = replaced;
+      }
+    }
+    if (this.config.redactApiKeys) {
+      const replaced = modified.replace(
+        /(api_key|apikey|bearer)\s*[:=]?\s*([A-Za-z0-9_-]{12,})/gi,
+        "$1 [redacted]"
+      );
+      if (replaced !== modified) {
+        notices.push({
+          kind: "info",
+          code: "content_policy.redact_api_key",
+          message: "Potential API keys were redacted from the input."
+        });
+        modified = replaced;
+      }
+    }
+    if (modified !== text || notices.length > 0) {
+      return {
+        ok: true,
+        modify: { text: modified },
+        notices
+      };
+    }
+    return { ok: true };
+  }
+}
+export {
+  ContentPolicyPlugin
+};

package/dist/plugins/builtins/response-sanitizer.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var response_sanitizer_exports = {};
+__export(response_sanitizer_exports, {
+  ResponseSanitizerPlugin: () => ResponseSanitizerPlugin
+});
+module.exports = __toCommonJS(response_sanitizer_exports);
+const DEFAULTS = {
+  redactEmails: false,
+  redactApiKeys: false,
+  maxResponseLength: 0
+};
+class ResponseSanitizerPlugin {
+  redactEmails = DEFAULTS.redactEmails;
+  redactApiKeys = DEFAULTS.redactApiKeys;
+  maxResponseLength = DEFAULTS.maxResponseLength;
+  async initialize(config) {
+    const sanitizerConfig = config;
+    this.redactEmails = sanitizerConfig.redactEmails ?? DEFAULTS.redactEmails;
+    this.redactApiKeys = sanitizerConfig.redactApiKeys ?? DEFAULTS.redactApiKeys;
+    this.maxResponseLength = sanitizerConfig.maxResponseLength ?? DEFAULTS.maxResponseLength;
+  }
+  async beforeResponse(payload, _context) {
+    const notices = [];
+    let modified = payload.content;
+    if (this.redactEmails) {
+      const replaced = modified.replace(
+        /[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g,
+        "[redacted-email]"
+      );
+      if (replaced !== modified) {
+        notices.push({
+          kind: "info",
+          code: "response_sanitizer.redact_email",
+          message: "Email addresses were redacted from the response."
+        });
+        modified = replaced;
+      }
+    }
+    if (this.redactApiKeys) {
+      const replaced = modified.replace(
+        /(api[_-]?key|apikey|token|bearer|secret)\s*[:=]?\s*['"]?([A-Za-z0-9_-]{12,})['"]?/gi,
+        "$1 [redacted]"
+      );
+      if (replaced !== modified) {
+        notices.push({
+          kind: "info",
+          code: "response_sanitizer.redact_api_key",
+          message: "Potential API keys were redacted from the response."
+        });
+        modified = replaced;
+      }
+    }
+    if (this.maxResponseLength > 0 && modified.length > this.maxResponseLength) {
+      const originalLength = modified.length;
+      const suffix = "... [truncated]";
+      if (this.maxResponseLength <= suffix.length) {
+        modified = suffix.slice(0, this.maxResponseLength);
+      } else {
+        const adjustedLength = this.maxResponseLength - suffix.length;
+        modified = modified.slice(0, adjustedLength) + suffix;
+      }
+      notices.push({
+        kind: "warn",
+        code: "response_sanitizer.truncated",
+        message: `Response truncated to ${this.maxResponseLength} characters.`,
+        details: { originalLength }
+      });
+    }
+    if (modified !== payload.content) {
+      const result = {
+        ok: true,
+        modify: { content: modified }
+      };
+      if (notices.length > 0) {
+        result.notices = notices;
+      }
+      return result;
+    }
+    return { ok: true };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ResponseSanitizerPlugin
+});

package/dist/plugins/builtins/response-sanitizer.d.ts

@@ -0,0 +1,25 @@
+import type { DextoPlugin, BeforeResponsePayload, PluginExecutionContext, PluginResult } from '../types.js';
+export interface ResponseSanitizerConfig {
+    redactEmails?: boolean;
+    redactApiKeys?: boolean;
+    maxResponseLength?: number;
+}
+/**
+ * Response sanitizer built-in plugin
+ *
+ * This plugin redacts sensitive information from LLM responses to prevent accidental leakage:
+ * - Email addresses
+ * - API keys and tokens
+ * - Optional: Truncates responses that exceed length limits
+ *
+ * This demonstrates how plugins can modify response content before it's sent to users,
+ * using the beforeResponse extension point.
+ */
+export declare class ResponseSanitizerPlugin implements DextoPlugin {
+    private redactEmails;
+    private redactApiKeys;
+    private maxResponseLength;
+    initialize(config: Record<string, any>): Promise<void>;
+    beforeResponse(payload: BeforeResponsePayload, _context: PluginExecutionContext): Promise<PluginResult>;
+}
+//# sourceMappingURL=response-sanitizer.d.ts.map

package/dist/plugins/builtins/response-sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-sanitizer.d.ts","sourceRoot":"","sources":["../../../src/plugins/builtins/response-sanitizer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,WAAW,EACX,qBAAqB,EACrB,sBAAsB,EACtB,YAAY,EAEf,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,uBAAuB;IACpC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAQD;;;;;;;;;;GAUG;AACH,qBAAa,uBAAwB,YAAW,WAAW;IACvD,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,aAAa,CAAmC;IACxD,OAAO,CAAC,iBAAiB,CAAsC;IAEzD,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAOtD,cAAc,CAChB,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,sBAAsB,GACjC,OAAO,CAAC,YAAY,CAAC;CAyE3B"}