@dexto/core 1.1.10 → 1.2.0

package/dist/plugins/manager.js

@@ -0,0 +1,363 @@
+import "../chunk-C6A6W6XS.js";
+import { logger } from "../logger/index.js";
+import { DextoRuntimeError, ErrorScope, ErrorType } from "../errors/index.js";
+import { PluginErrorCode } from "./error-codes.js";
+import { loadPluginModule, resolvePluginPath } from "./loader.js";
+import { getContext } from "../utils/async-context.js";
+class PluginManager {
+  plugins = /* @__PURE__ */ new Map();
+  pluginsByExtensionPoint = /* @__PURE__ */ new Map();
+  options;
+  initialized = false;
+  /** Default timeout for plugin execution (milliseconds) */
+  static DEFAULT_TIMEOUT = 5e3;
+  constructor(options) {
+    this.options = options;
+    logger.debug("PluginManager created");
+  }
+  /**
+   * Register a built-in plugin
+   * Called by the built-in plugin registry before initialize()
+   *
+   * @param name - Plugin name
+   * @param PluginClass - Plugin class constructor
+   * @param config - Plugin configuration
+   */
+  registerBuiltin(name, PluginClass, config) {
+    if (this.initialized) {
+      throw new DextoRuntimeError(
+        PluginErrorCode.PLUGIN_CONFIGURATION_INVALID,
+        ErrorScope.PLUGIN,
+        ErrorType.SYSTEM,
+        "Cannot register built-in plugins after initialization"
+      );
+    }
+    const plugin = new PluginClass();
+    const loadedPlugin = {
+      plugin,
+      config: {
+        name,
+        module: `<builtin:${name}>`,
+        enabled: config.enabled ?? true,
+        blocking: config.blocking,
+        priority: config.priority,
+        config: config.config ?? void 0
+      }
+    };
+    this.plugins.set(name, loadedPlugin);
+    logger.debug(`Built-in plugin registered: ${name}`);
+  }
+  /**
+   * Initialize all plugins from configuration
+   * Loads custom plugins, validates priorities, sorts by priority, and calls initialize()
+   *
+   * @param customPlugins - Array of custom plugin configurations from YAML
+   * @throws {DextoRuntimeError} If any plugin fails to load or initialize (fail-fast)
+   */
+  async initialize(customPlugins = []) {
+    if (this.initialized) {
+      throw new DextoRuntimeError(
+        PluginErrorCode.PLUGIN_CONFIGURATION_INVALID,
+        ErrorScope.PLUGIN,
+        ErrorType.SYSTEM,
+        "PluginManager already initialized"
+      );
+    }
+    const priorities = /* @__PURE__ */ new Set();
+    const allPlugins = [...this.plugins.values(), ...customPlugins.map((c) => ({ config: c }))];
+    for (const item of allPlugins) {
+      const config = "config" in item ? item.config : item;
+      if (!config.enabled) continue;
+      if (priorities.has(config.priority)) {
+        throw new DextoRuntimeError(
+          PluginErrorCode.PLUGIN_DUPLICATE_PRIORITY,
+          ErrorScope.PLUGIN,
+          ErrorType.USER,
+          `Duplicate plugin priority: ${config.priority}. Each plugin must have a unique priority.`,
+          {
+            priority: config.priority,
+            hint: "Ensure all enabled plugins (built-in and custom) have unique priority values."
+          }
+        );
+      }
+      priorities.add(config.priority);
+    }
+    for (const pluginConfig of customPlugins) {
+      if (!pluginConfig.enabled) {
+        logger.debug(`Skipping disabled plugin: ${pluginConfig.name}`);
+        continue;
+      }
+      try {
+        const modulePath = resolvePluginPath(pluginConfig.module, this.options.configDir);
+        const PluginClass = await loadPluginModule(modulePath, pluginConfig.name);
+        const plugin = new PluginClass();
+        const loadedPlugin = {
+          plugin,
+          config: pluginConfig
+        };
+        this.plugins.set(pluginConfig.name, loadedPlugin);
+        logger.info(`Custom plugin loaded: ${pluginConfig.name}`);
+      } catch (error) {
+        throw new DextoRuntimeError(
+          PluginErrorCode.PLUGIN_INITIALIZATION_FAILED,
+          ErrorScope.PLUGIN,
+          ErrorType.SYSTEM,
+          `Failed to load plugin '${pluginConfig.name}': ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    for (const [name, loadedPlugin] of this.plugins.entries()) {
+      if (!loadedPlugin.config.enabled) continue;
+      try {
+        if (loadedPlugin.plugin.initialize) {
+          await loadedPlugin.plugin.initialize(loadedPlugin.config.config || {});
+          logger.debug(`Plugin initialized: ${name}`);
+        }
+      } catch (error) {
+        throw new DextoRuntimeError(
+          PluginErrorCode.PLUGIN_INITIALIZATION_FAILED,
+          ErrorScope.PLUGIN,
+          ErrorType.SYSTEM,
+          `Plugin '${name}' initialization failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    for (const loadedPlugin of this.plugins.values()) {
+      if (!loadedPlugin.config.enabled) continue;
+      this.registerToExtensionPoints(loadedPlugin);
+    }
+    for (const [extensionPoint, plugins] of this.pluginsByExtensionPoint.entries()) {
+      plugins.sort((a, b) => a.config.priority - b.config.priority);
+      logger.debug(
+        `Extension point '${extensionPoint}': ${plugins.length} plugin(s) registered`,
+        {
+          plugins: plugins.map((p) => ({
+            name: p.config.name,
+            priority: p.config.priority
+          }))
+        }
+      );
+    }
+    this.initialized = true;
+    logger.info(`PluginManager initialized with ${this.plugins.size} plugin(s)`);
+  }
+  /**
+   * Register a plugin to the extension points it implements
+   */
+  registerToExtensionPoints(loadedPlugin) {
+    const extensionPoints = [
+      "beforeLLMRequest",
+      "beforeToolCall",
+      "afterToolResult",
+      "beforeResponse"
+    ];
+    for (const point of extensionPoints) {
+      if (typeof loadedPlugin.plugin[point] === "function") {
+        if (!this.pluginsByExtensionPoint.has(point)) {
+          this.pluginsByExtensionPoint.set(point, []);
+        }
+        this.pluginsByExtensionPoint.get(point).push(loadedPlugin);
+      }
+    }
+  }
+  /**
+   * Execute all plugins at a specific extension point
+   * Plugins execute sequentially in priority order
+   *
+   * @param extensionPoint - Which extension point to execute
+   * @param payload - Payload for this extension point (must be an object)
+   * @param options - Options for building execution context
+   * @returns Modified payload after all plugins execute
+   * @throws {DextoRuntimeError} If a blocking plugin cancels execution or payload is not an object
+   */
+  async executePlugins(extensionPoint, payload, options) {
+    const plugins = this.pluginsByExtensionPoint.get(extensionPoint) || [];
+    if (plugins.length === 0) {
+      return payload;
+    }
+    if (payload === null || typeof payload !== "object") {
+      throw new DextoRuntimeError(
+        PluginErrorCode.PLUGIN_INVALID_SHAPE,
+        ErrorScope.PLUGIN,
+        ErrorType.USER,
+        `Payload for ${extensionPoint} must be an object (got ${payload === null ? "null" : typeof payload})`,
+        { extensionPoint, payloadType: typeof payload }
+      );
+    }
+    let currentPayload = { ...payload };
+    const asyncCtx = getContext();
+    const llmConfig = options.stateManager.getLLMConfig(options.sessionId);
+    const context = {
+      sessionId: options.sessionId ?? void 0,
+      userId: asyncCtx?.userId ?? void 0,
+      tenantId: asyncCtx?.tenantId ?? void 0,
+      llmConfig,
+      logger,
+      abortSignal: options.abortSignal ?? void 0,
+      agent: {
+        sessionManager: options.sessionManager,
+        mcpManager: options.mcpManager,
+        toolManager: options.toolManager,
+        stateManager: options.stateManager,
+        agentEventBus: this.options.agentEventBus,
+        storageManager: this.options.storageManager
+      }
+    };
+    for (const { plugin, config } of plugins) {
+      const method = plugin[extensionPoint];
+      if (!method) continue;
+      const startTime = Date.now();
+      try {
+        const result = await this.executeWithTimeout(
+          method.call(plugin, currentPayload, context),
+          config.name,
+          PluginManager.DEFAULT_TIMEOUT
+        );
+        const duration = Date.now() - startTime;
+        logger.debug(`Plugin '${config.name}' executed at ${extensionPoint}`, {
+          ok: result.ok,
+          cancelled: result.cancel,
+          duration,
+          hasModifications: !!result.modify
+        });
+        if (result.notices && result.notices.length > 0) {
+          for (const notice of result.notices) {
+            const level = notice.kind === "block" || notice.kind === "warn" ? "warn" : "info";
+            logger[level](`Plugin notice (${notice.kind}): ${notice.message}`, {
+              plugin: config.name,
+              code: notice.code,
+              details: notice.details
+            });
+          }
+        }
+        if (!result.ok) {
+          logger.warn(`Plugin '${config.name}' returned error`, {
+            message: result.message
+          });
+          if (config.blocking && result.cancel) {
+            throw new DextoRuntimeError(
+              PluginErrorCode.PLUGIN_BLOCKED_EXECUTION,
+              ErrorScope.PLUGIN,
+              ErrorType.FORBIDDEN,
+              result.message || `Operation blocked by plugin '${config.name}'`,
+              {
+                plugin: config.name,
+                extensionPoint,
+                notices: result.notices
+              }
+            );
+          }
+          continue;
+        }
+        if (result.modify) {
+          currentPayload = { ...currentPayload, ...result.modify };
+          logger.debug(`Plugin '${config.name}' modified payload`, {
+            keys: Object.keys(result.modify)
+          });
+        }
+        if (result.cancel && config.blocking) {
+          throw new DextoRuntimeError(
+            PluginErrorCode.PLUGIN_BLOCKED_EXECUTION,
+            ErrorScope.PLUGIN,
+            ErrorType.FORBIDDEN,
+            result.message || `Operation cancelled by plugin '${config.name}'`,
+            {
+              plugin: config.name,
+              extensionPoint,
+              notices: result.notices
+            }
+          );
+        }
+      } catch (error) {
+        const duration = Date.now() - startTime;
+        if (error instanceof DextoRuntimeError) {
+          throw error;
+        }
+        logger.error(`Plugin '${config.name}' threw error`, {
+          error: error instanceof Error ? error.message : String(error),
+          duration
+        });
+        if (config.blocking) {
+          throw new DextoRuntimeError(
+            PluginErrorCode.PLUGIN_EXECUTION_FAILED,
+            ErrorScope.PLUGIN,
+            ErrorType.SYSTEM,
+            `Plugin '${config.name}' failed: ${error instanceof Error ? error.message : String(error)}`,
+            {
+              plugin: config.name,
+              extensionPoint
+            }
+          );
+        }
+        logger.debug(`Non-blocking plugin error, continuing execution`);
+      }
+    }
+    return currentPayload;
+  }
+  /**
+   * Execute a promise with timeout, properly clearing timer on completion
+   * Prevents timer leaks and unhandled rejections from Promise.race
+   */
+  async executeWithTimeout(promise, pluginName, ms) {
+    let timer;
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => {
+        reject(
+          new DextoRuntimeError(
+            PluginErrorCode.PLUGIN_EXECUTION_TIMEOUT,
+            ErrorScope.PLUGIN,
+            ErrorType.TIMEOUT,
+            `Plugin '${pluginName}' execution timed out after ${ms}ms`
+          )
+        );
+      }, ms);
+      promise.then(
+        (val) => {
+          if (timer) clearTimeout(timer);
+          resolve(val);
+        },
+        (err) => {
+          if (timer) clearTimeout(timer);
+          reject(err);
+        }
+      );
+    });
+  }
+  /**
+   * Cleanup all plugins
+   * Called when agent shuts down
+   */
+  async cleanup() {
+    for (const [name, loadedPlugin] of this.plugins.entries()) {
+      if (loadedPlugin.plugin.cleanup) {
+        try {
+          await loadedPlugin.plugin.cleanup();
+          logger.debug(`Plugin cleaned up: ${name}`);
+        } catch (error) {
+          logger.error(`Plugin cleanup failed: ${name}`, {
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    logger.info("PluginManager cleanup complete");
+  }
+  /**
+   * Get plugin statistics
+   */
+  getStats() {
+    const enabled = Array.from(this.plugins.values()).filter((p) => p.config.enabled).length;
+    const byExtensionPoint = {};
+    for (const [point, plugins] of this.pluginsByExtensionPoint.entries()) {
+      byExtensionPoint[point] = plugins.length;
+    }
+    return {
+      total: this.plugins.size,
+      enabled,
+      byExtensionPoint
+    };
+  }
+}
+export {
+  PluginManager
+};

package/dist/plugins/registrations/builtins.cjs

@@ -0,0 +1,51 @@
+"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 builtins_exports = {};
+__export(builtins_exports, {
+  registerBuiltInPlugins: () => registerBuiltInPlugins
+});
+module.exports = __toCommonJS(builtins_exports);
+var import_content_policy = require("../builtins/content-policy.js");
+var import_response_sanitizer = require("../builtins/response-sanitizer.js");
+function registerBuiltInPlugins(args) {
+  const cp = args.config.plugins?.contentPolicy;
+  if (cp && typeof cp === "object" && cp.enabled !== false) {
+    args.pluginManager.registerBuiltin("content-policy", import_content_policy.ContentPolicyPlugin, {
+      name: "content-policy",
+      enabled: cp.enabled ?? true,
+      priority: cp.priority,
+      blocking: cp.blocking ?? true,
+      config: cp
+    });
+  }
+  const rs = args.config.plugins?.responseSanitizer;
+  if (rs && typeof rs === "object" && rs.enabled !== false) {
+    args.pluginManager.registerBuiltin("response-sanitizer", import_response_sanitizer.ResponseSanitizerPlugin, {
+      name: "response-sanitizer",
+      enabled: rs.enabled ?? true,
+      priority: rs.priority,
+      blocking: rs.blocking ?? false,
+      config: rs
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerBuiltInPlugins
+});

package/dist/plugins/registrations/builtins.d.ts

@@ -0,0 +1,17 @@
+import type { PluginManager } from '../manager.js';
+import type { ValidatedAgentConfig } from '../../agent/schemas.js';
+/**
+ * Register all built-in plugins with the PluginManager
+ * Called during agent initialization before custom plugins are loaded
+ *
+ * Built-in plugins are referenced by name in the config (e.g., contentPolicy, responseSanitizer)
+ * and activated based on presence of their configuration object.
+ *
+ * @param pluginManager - The PluginManager instance
+ * @param config - Validated agent configuration
+ */
+export declare function registerBuiltInPlugins(args: {
+    pluginManager: PluginManager;
+    config: ValidatedAgentConfig;
+}): void;
+//# sourceMappingURL=builtins.d.ts.map

package/dist/plugins/registrations/builtins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../../src/plugins/registrations/builtins.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAInE;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IACzC,aAAa,EAAE,aAAa,CAAC;IAC7B,MAAM,EAAE,oBAAoB,CAAC;CAChC,GAAG,IAAI,CAwBP"}

package/dist/plugins/registrations/builtins.js

@@ -0,0 +1,28 @@
+import "../../chunk-C6A6W6XS.js";
+import { ContentPolicyPlugin } from "../builtins/content-policy.js";
+import { ResponseSanitizerPlugin } from "../builtins/response-sanitizer.js";
+function registerBuiltInPlugins(args) {
+  const cp = args.config.plugins?.contentPolicy;
+  if (cp && typeof cp === "object" && cp.enabled !== false) {
+    args.pluginManager.registerBuiltin("content-policy", ContentPolicyPlugin, {
+      name: "content-policy",
+      enabled: cp.enabled ?? true,
+      priority: cp.priority,
+      blocking: cp.blocking ?? true,
+      config: cp
+    });
+  }
+  const rs = args.config.plugins?.responseSanitizer;
+  if (rs && typeof rs === "object" && rs.enabled !== false) {
+    args.pluginManager.registerBuiltin("response-sanitizer", ResponseSanitizerPlugin, {
+      name: "response-sanitizer",
+      enabled: rs.enabled ?? true,
+      priority: rs.priority,
+      blocking: rs.blocking ?? false,
+      config: rs
+    });
+  }
+}
+export {
+  registerBuiltInPlugins
+};

package/dist/plugins/schemas.cjs

@@ -0,0 +1,61 @@
+"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 schemas_exports = {};
+__export(schemas_exports, {
+  BuiltInPluginConfigSchema: () => BuiltInPluginConfigSchema,
+  CustomPluginConfigSchema: () => CustomPluginConfigSchema,
+  PluginsConfigSchema: () => PluginsConfigSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+const CustomPluginConfigSchema = import_zod.z.object({
+  name: import_zod.z.string().describe("Unique name for the plugin"),
+  module: import_zod.z.string().describe(
+    "Absolute path to plugin module (use ${{dexto.agent_dir}} for agent-relative paths)"
+  ),
+  enabled: import_zod.z.boolean().default(true).describe("Whether this plugin is enabled"),
+  blocking: import_zod.z.boolean().describe("If true, plugin errors will halt execution"),
+  priority: import_zod.z.number().int().describe("Execution priority (lower runs first)"),
+  config: import_zod.z.record(import_zod.z.any()).optional().describe("Plugin-specific configuration")
+}).strict();
+const BuiltInPluginConfigSchema = import_zod.z.object({
+  priority: import_zod.z.number().int().describe("Execution priority (lower runs first)"),
+  blocking: import_zod.z.boolean().optional().describe("If true, plugin errors will halt execution"),
+  enabled: import_zod.z.boolean().default(true).describe("Whether this plugin is enabled")
+  // Plugin-specific config fields are defined per-plugin
+}).passthrough().describe("Configuration for a built-in plugin");
+const PluginsConfigSchema = import_zod.z.object({
+  // Built-in plugins - referenced by name
+  contentPolicy: BuiltInPluginConfigSchema.optional().describe(
+    "Content policy plugin for input validation and sanitization"
+  ),
+  responseSanitizer: BuiltInPluginConfigSchema.optional().describe(
+    "Response sanitizer plugin for output sanitization"
+  ),
+  // Custom plugins - array of plugin configurations
+  custom: import_zod.z.array(CustomPluginConfigSchema).default([]).describe("Array of custom plugin configurations")
+}).strict().default({
+  custom: []
+}).describe("Plugin system configuration");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BuiltInPluginConfigSchema,
+  CustomPluginConfigSchema,
+  PluginsConfigSchema
+});

package/dist/plugins/schemas.d.ts

@@ -0,0 +1,138 @@
+import { z } from 'zod';
+/**
+ * Schema for custom plugin configuration (loaded from file paths)
+ */
+export declare const CustomPluginConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    module: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    blocking: z.ZodBoolean;
+    priority: z.ZodNumber;
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    priority: number;
+    enabled: boolean;
+    blocking: boolean;
+    module: string;
+    config?: Record<string, any> | undefined;
+}, {
+    name: string;
+    priority: number;
+    blocking: boolean;
+    module: string;
+    config?: Record<string, any> | undefined;
+    enabled?: boolean | undefined;
+}>;
+/**
+ * Schema for built-in plugin configuration
+ * Built-in plugins don't need module paths - they're referenced by name
+ */
+export declare const BuiltInPluginConfigSchema: z.ZodObject<{
+    priority: z.ZodNumber;
+    blocking: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    priority: z.ZodNumber;
+    blocking: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    priority: z.ZodNumber;
+    blocking: z.ZodOptional<z.ZodBoolean>;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
+/**
+ * Main plugins configuration schema
+ * Supports both built-in plugins (by name) and custom plugins (with module paths)
+ */
+export declare const PluginsConfigSchema: z.ZodDefault<z.ZodObject<{
+    contentPolicy: z.ZodOptional<z.ZodObject<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    responseSanitizer: z.ZodOptional<z.ZodObject<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough">>>;
+    custom: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        module: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        blocking: z.ZodBoolean;
+        priority: z.ZodNumber;
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        priority: number;
+        enabled: boolean;
+        blocking: boolean;
+        module: string;
+        config?: Record<string, any> | undefined;
+    }, {
+        name: string;
+        priority: number;
+        blocking: boolean;
+        module: string;
+        config?: Record<string, any> | undefined;
+        enabled?: boolean | undefined;
+    }>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    custom: {
+        name: string;
+        priority: number;
+        enabled: boolean;
+        blocking: boolean;
+        module: string;
+        config?: Record<string, any> | undefined;
+    }[];
+    contentPolicy?: z.objectOutputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    responseSanitizer?: z.objectOutputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    custom?: {
+        name: string;
+        priority: number;
+        blocking: boolean;
+        module: string;
+        config?: Record<string, any> | undefined;
+        enabled?: boolean | undefined;
+    }[] | undefined;
+    contentPolicy?: z.objectInputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+    responseSanitizer?: z.objectInputType<{
+        priority: z.ZodNumber;
+        blocking: z.ZodOptional<z.ZodBoolean>;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>>;
+export type PluginsConfig = z.input<typeof PluginsConfigSchema>;
+export type ValidatedPluginsConfig = z.output<typeof PluginsConfigSchema>;
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/plugins/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;EAaxB,CAAC;AAEd;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;gCAQc,CAAC;AAErD;;;GAGG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoBY,CAAC;AAE7C,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC"}