@mastra/core/dist/processor-provider/index.js

import { It as LanguageDetector, Lt as PIIDetector, Mt as SystemPromptScrubber, Nt as TokenLimiterProcessor, Pt as BatchPartsProcessor, Rt as PromptInjectionDetector, kt as ToolCallFilter, qn as UnicodeNormalizer, zt as ModerationProcessor } from "../agent-Dj30gJa3.js";
import { z } from "zod/v4";
//#region src/processor-provider/types.ts
/**
* All processor phases.
*/
const ALL_PROCESSOR_PHASES = [
	"processInput",
	"processInputStep",
	"processOutputStream",
	"processOutputResult",
	"processOutputStep",
	"processToolResult"
];
//#endregion
//#region src/processor-provider/phase-filtered-processor.ts
/**
* Wraps an existing Processor and only exposes the selected phases.
* Unselected phase methods are left undefined, so the runner/step-creator skips them.
*/
var PhaseFilteredProcessor = class {
	id;
	name;
	description;
	processorIndex;
	#inner;
	#enabledPhases;
	constructor(inner, enabledPhases) {
		this.#inner = inner;
		this.#enabledPhases = new Set(enabledPhases);
		this.id = inner.id;
		this.name = inner.name;
		this.description = inner.description;
		if (this.#enabledPhases.has("processInput") && inner.processInput) this.processInput = inner.processInput.bind(inner);
		if (this.#enabledPhases.has("processInputStep") && inner.processInputStep) this.processInputStep = inner.processInputStep.bind(inner);
		if (this.#enabledPhases.has("processOutputStream") && inner.processOutputStream) this.processOutputStream = inner.processOutputStream.bind(inner);
		if (this.#enabledPhases.has("processOutputResult") && inner.processOutputResult) this.processOutputResult = inner.processOutputResult.bind(inner);
		if (this.#enabledPhases.has("processOutputStep") && inner.processOutputStep) this.processOutputStep = inner.processOutputStep.bind(inner);
		if (this.#enabledPhases.has("processToolResult") && inner.processToolResult) this.processToolResult = inner.processToolResult.bind(inner);
	}
	processInput;
	processInputStep;
	processOutputStream;
	processOutputResult;
	processOutputStep;
	processToolResult;
	__registerMastra(mastra) {
		this.#inner.__registerMastra?.(mastra);
	}
};
//#endregion
//#region src/processor-provider/providers/index.ts
const structuredOutputOptionsSchema = z.object({ jsonPromptInjection: z.union([z.boolean(), z.enum([
	"system",
	"inline",
	"auto"
])]).optional() }).optional();
const providerOptionsSchema = z.record(z.string(), z.any()).optional();
const unicodeNormalizerProvider = {
	info: {
		id: "unicode-normalizer",
		name: "Unicode Normalizer",
		description: "Normalizes Unicode text by stripping control characters, collapsing whitespace, and trimming."
	},
	configSchema: z.object({
		stripControlChars: z.boolean().optional(),
		preserveEmojis: z.boolean().optional(),
		collapseWhitespace: z.boolean().optional(),
		trim: z.boolean().optional()
	}),
	availablePhases: ["processInput"],
	createProcessor(config) {
		return new UnicodeNormalizer(config);
	}
};
const tokenLimiterProvider = {
	info: {
		id: "token-limiter",
		name: "Token Limiter",
		description: "Limits the number of tokens in messages, supporting both input filtering and output truncation."
	},
	configSchema: z.object({
		limit: z.number(),
		strategy: z.enum(["truncate", "abort"]).optional(),
		countMode: z.enum(["cumulative", "part"]).optional()
	}),
	availablePhases: [
		"processInput",
		"processOutputStream",
		"processOutputResult"
	],
	createProcessor(config) {
		return new TokenLimiterProcessor(config);
	}
};
const toolCallFilterProvider = {
	info: {
		id: "tool-call-filter",
		name: "Tool Call Filter",
		description: "Filters out tool calls and results from messages, optionally targeting specific tools."
	},
	configSchema: z.object({
		exclude: z.array(z.string()).optional(),
		filterAfterToolSteps: z.number().optional(),
		preserveModelOutput: z.boolean().optional()
	}),
	availablePhases: ["processInput"],
	createProcessor(config) {
		return new ToolCallFilter(config);
	}
};
const batchPartsProvider = {
	info: {
		id: "batch-parts",
		name: "Batch Parts",
		description: "Batches multiple stream parts together to reduce stream overhead."
	},
	configSchema: z.object({
		batchSize: z.number().optional(),
		maxWaitTime: z.number().optional(),
		emitOnNonText: z.boolean().optional()
	}),
	availablePhases: ["processOutputStream"],
	createProcessor(config) {
		return new BatchPartsProcessor(config);
	}
};
const moderationProvider = {
	info: {
		id: "moderation",
		name: "Moderation",
		description: "Evaluates content against configurable moderation categories for content safety."
	},
	configSchema: z.object({
		model: z.string(),
		categories: z.array(z.string()).optional(),
		threshold: z.number().optional(),
		strategy: z.enum([
			"block",
			"warn",
			"filter"
		]).optional(),
		instructions: z.string().optional(),
		includeScores: z.boolean().optional(),
		chunkWindow: z.number().optional(),
		structuredOutputOptions: structuredOutputOptionsSchema,
		providerOptions: providerOptionsSchema
	}),
	availablePhases: [
		"processInput",
		"processOutputResult",
		"processOutputStream"
	],
	createProcessor(config) {
		return new ModerationProcessor(config);
	}
};
const promptInjectionDetectorProvider = {
	info: {
		id: "prompt-injection-detector",
		name: "Prompt Injection Detector",
		description: "Identifies and handles prompt injection attacks, jailbreaks, and data exfiltration attempts."
	},
	configSchema: z.object({
		model: z.string(),
		detectionTypes: z.array(z.string()).optional(),
		threshold: z.number().optional(),
		strategy: z.enum([
			"block",
			"warn",
			"filter",
			"rewrite"
		]).optional(),
		instructions: z.string().optional(),
		includeScores: z.boolean().optional(),
		structuredOutputOptions: structuredOutputOptionsSchema,
		providerOptions: providerOptionsSchema
	}),
	availablePhases: ["processInput"],
	createProcessor(config) {
		return new PromptInjectionDetector(config);
	}
};
const piiDetectorProvider = {
	info: {
		id: "pii-detector",
		name: "PII Detector",
		description: "Identifies and redacts personally identifiable information for privacy compliance."
	},
	configSchema: z.object({
		model: z.string(),
		detectionTypes: z.array(z.string()).optional(),
		threshold: z.number().optional(),
		strategy: z.enum([
			"block",
			"warn",
			"filter",
			"redact"
		]).optional(),
		redactionMethod: z.enum([
			"mask",
			"hash",
			"remove",
			"placeholder"
		]).optional(),
		instructions: z.string().optional(),
		includeDetections: z.boolean().optional(),
		preserveFormat: z.boolean().optional(),
		structuredOutputOptions: structuredOutputOptionsSchema,
		providerOptions: providerOptionsSchema
	}),
	availablePhases: ["processInput"],
	createProcessor(config) {
		return new PIIDetector(config);
	}
};
const languageDetectorProvider = {
	info: {
		id: "language-detector",
		name: "Language Detector",
		description: "Detects the language of input text and optionally translates it to a target language."
	},
	configSchema: z.object({
		model: z.string(),
		targetLanguages: z.array(z.string()),
		threshold: z.number().optional(),
		strategy: z.enum([
			"detect",
			"translate",
			"block",
			"warn"
		]).optional(),
		preserveOriginal: z.boolean().optional(),
		instructions: z.string().optional(),
		minTextLength: z.number().optional(),
		includeDetectionDetails: z.boolean().optional(),
		translationQuality: z.enum([
			"speed",
			"quality",
			"balanced"
		]).optional(),
		providerOptions: providerOptionsSchema
	}),
	availablePhases: ["processInput"],
	createProcessor(config) {
		return new LanguageDetector(config);
	}
};
const systemPromptScrubberProvider = {
	info: {
		id: "system-prompt-scrubber",
		name: "System Prompt Scrubber",
		description: "Detects and removes system prompt leakage from model outputs."
	},
	configSchema: z.object({
		model: z.string(),
		strategy: z.enum([
			"block",
			"warn",
			"filter",
			"redact"
		]).optional(),
		customPatterns: z.array(z.string()).optional(),
		includeDetections: z.boolean().optional(),
		instructions: z.string().optional(),
		redactionMethod: z.enum([
			"mask",
			"placeholder",
			"remove"
		]).optional(),
		placeholderText: z.string().optional(),
		structuredOutputOptions: structuredOutputOptionsSchema
	}),
	availablePhases: ["processOutputStream", "processOutputResult"],
	createProcessor(config) {
		return new SystemPromptScrubber(config);
	}
};
const BUILT_IN_PROCESSOR_PROVIDERS = {
	"unicode-normalizer": unicodeNormalizerProvider,
	"token-limiter": tokenLimiterProvider,
	"tool-call-filter": toolCallFilterProvider,
	"batch-parts": batchPartsProvider,
	moderation: moderationProvider,
	"prompt-injection-detector": promptInjectionDetectorProvider,
	"pii-detector": piiDetectorProvider,
	"language-detector": languageDetectorProvider,
	"system-prompt-scrubber": systemPromptScrubberProvider
};
//#endregion
export { ALL_PROCESSOR_PHASES, BUILT_IN_PROCESSOR_PROVIDERS, PhaseFilteredProcessor, batchPartsProvider, languageDetectorProvider, moderationProvider, piiDetectorProvider, promptInjectionDetectorProvider, systemPromptScrubberProvider, tokenLimiterProvider, toolCallFilterProvider, unicodeNormalizerProvider };

//# sourceMappingURL=index.js.map