@mastra/core 0.13.2 → 0.14.0-alpha.1

package/dist/{chunk-IL5SHDY4.js → chunk-DAMIFZPW.js}

@@ -1,19 +1,20 @@
-import { MastraLLM } from './chunk-TZOR5M7H.js';
-import { DefaultVoice } from './chunk-SSJVFUBZ.js';
-import { MessageList } from './chunk-L6YBPFYF.js';
+import { DefaultVoice } from './chunk-67L5DRLO.js';
+import { MastraLLMV1 } from './chunk-RYCRCJCY.js';
 import { InstrumentClass, Telemetry } from './chunk-RQBS6DFE.js';
+import { MessageList } from './chunk-OPT2L5AM.js';
 import { executeHook } from './chunk-TTELJD4F.js';
-import { ensureToolProperties, makeCoreTool, createMastraProxy } from './chunk-N2KMAW6T.js';
+import { ensureToolProperties, makeCoreTool, createMastraProxy } from './chunk-P7WF6NQU.js';
 import { RuntimeContext } from './chunk-HLRWYUFN.js';
 import { MastraError } from './chunk-4O4YNORN.js';
-import { MastraBase } from './chunk-FUERFM46.js';
-import { RegisteredLogger } from './chunk-6AR2Z5ZG.js';
+import { MastraBase } from './chunk-6GF5M4GX.js';
+import { RegisteredLogger } from './chunk-X3GXU6TZ.js';
 import { __commonJS, __toESM, __decoratorStart, __decorateElement, __runInitializers } from './chunk-3HXBPDKN.js';
 import { context, trace } from '@opentelemetry/api';
 import z3, { z } from 'zod';
 import { get } from 'radash';
-import crypto2, { randomUUID } from 'crypto';
-import { ReadableStream, TransformStream } from 'stream/web';
+import * as crypto2 from 'crypto';
+import { randomUUID } from 'crypto';
+import { ReadableStream as ReadableStream$1, TransformStream } from 'stream/web';
 import EventEmitter from 'events';
 import sift from 'sift';
 import { createActor, assign, fromPromise, setup } from 'xstate';
@@ -92,6 +93,371 @@ var WhenConditionReturnValue = /* @__PURE__ */(WhenConditionReturnValue2 => {
 // src/agent/index.ts
 var import_fast_deep_equal = __toESM(require_fast_deep_equal(), 1);
 
+// src/processors/processors/structured-output.ts
+var StructuredOutputProcessor = class {
+  name = "structured-output";
+  schema;
+  structuringAgent;
+  errorStrategy;
+  fallbackValue;
+  constructor(options) {
+    this.schema = options.schema;
+    this.errorStrategy = options.errorStrategy ?? "strict";
+    this.fallbackValue = options.fallbackValue;
+    this.structuringAgent = new Agent({
+      name: "structured-output-structurer",
+      instructions: options.instructions || this.generateInstructions(),
+      model: options.model
+    });
+  }
+  async processOutputResult(args) {
+    const {
+      messages,
+      abort
+    } = args;
+    const processedMessages = await Promise.all(messages.map(async message => {
+      if (message.role !== "assistant") {
+        return message;
+      }
+      const textContent = this.extractTextContent(message);
+      if (!textContent.trim()) {
+        return message;
+      }
+      try {
+        const structuredResult = await this.structuringAgent.generate(`Extract and structure the key information from the following text according to the specified schema. Keep the original meaning and details:
+
+${textContent}`, {
+          output: this.schema
+        });
+        if (!structuredResult.object) {
+          this.handleError("Structuring failed", "Internal agent did not generate structured output", abort);
+          if (this.errorStrategy === "fallback" && this.fallbackValue !== void 0) {
+            return {
+              ...message,
+              content: {
+                ...message.content,
+                metadata: {
+                  ...(message.content.metadata || {}),
+                  structuredOutput: this.fallbackValue
+                }
+              }
+            };
+          }
+          return message;
+        }
+        return {
+          ...message,
+          content: {
+            ...message.content,
+            parts: [{
+              type: "text",
+              text: textContent
+              // Keep original text unchanged
+            }],
+            metadata: {
+              ...(message.content.metadata || {}),
+              structuredOutput: structuredResult.object
+            }
+          }
+        };
+      } catch (error) {
+        this.handleError("Processing failed", error instanceof Error ? error.message : "Unknown error", abort);
+        if (this.errorStrategy === "fallback" && this.fallbackValue !== void 0) {
+          return {
+            ...message,
+            content: {
+              ...message.content,
+              metadata: {
+                ...(message.content.metadata || {}),
+                structuredOutput: this.fallbackValue
+              }
+            }
+          };
+        }
+        return message;
+      }
+    }));
+    return processedMessages;
+  }
+  /**
+   * Extract text content from a message
+   */
+  extractTextContent(message) {
+    let text = "";
+    if (message.content.parts) {
+      for (const part of message.content.parts) {
+        if (part.type === "text" && "text" in part && typeof part.text === "string") {
+          text += part.text + " ";
+        }
+      }
+    }
+    if (!text.trim() && typeof message.content.content === "string") {
+      text = message.content.content;
+    }
+    return text.trim();
+  }
+  /**
+   * Generate instructions for the structuring agent based on the schema
+   */
+  generateInstructions() {
+    return `You are a data structuring specialist. Your job is to convert unstructured text into a specific JSON format.
+
+TASK: Convert the provided unstructured text into valid JSON that matches the following schema:
+
+REQUIREMENTS:
+- Return ONLY valid JSON, no additional text or explanation
+- Extract relevant information from the input text
+- If information is missing, use reasonable defaults or null values
+- Maintain data types as specified in the schema
+- Be consistent and accurate in your conversions
+
+The input text may be in any format (sentences, bullet points, paragraphs, etc.). Extract the relevant data and structure it according to the schema.`;
+  }
+  /**
+   * Handle errors based on the configured strategy
+   */
+  handleError(context, error, abort) {
+    const message = `[StructuredOutputProcessor] ${context}: ${error}`;
+    console.error(`ERROR from StructuredOutputProcessor: ${message}`);
+    switch (this.errorStrategy) {
+      case "strict":
+        abort(message);
+        break;
+      case "warn":
+        console.warn(message);
+        break;
+      case "fallback":
+        console.info(`${message} (using fallback)`);
+        break;
+    }
+  }
+};
+
+// src/agent/trip-wire.ts
+var TripWire = class extends Error {
+  constructor(reason) {
+    super(reason);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/processors/runner.ts
+var ProcessorState = class {
+  constructor(processorName) {
+    this.processorName = processorName;
+  }
+  accumulatedText = "";
+  customState = {};
+  streamParts = [];
+  // Internal methods for the runner
+  addPart(part) {
+    if (part.type === "text-delta") {
+      this.accumulatedText += part.textDelta;
+    }
+    this.streamParts.push(part);
+  }
+};
+var ProcessorRunner = class {
+  inputProcessors;
+  outputProcessors;
+  logger;
+  agentName;
+  constructor({
+    inputProcessors,
+    outputProcessors,
+    logger,
+    agentName
+  }) {
+    this.inputProcessors = inputProcessors ?? [];
+    this.outputProcessors = outputProcessors ?? [];
+    this.logger = logger;
+    this.agentName = agentName;
+  }
+  async runOutputProcessors(messageList, telemetry) {
+    const responseMessages = messageList.clear.response.v2();
+    let processableMessages = [...responseMessages];
+    const ctx = {
+      abort: () => {
+        throw new TripWire("Tripwire triggered");
+      }
+    };
+    for (const [index, processor] of this.outputProcessors.entries()) {
+      const abort = reason => {
+        throw new TripWire(reason || `Tripwire triggered by ${processor.name}`);
+      };
+      ctx.abort = abort;
+      const processMethod = processor.processOutputResult?.bind(processor);
+      if (!processMethod) {
+        continue;
+      }
+      if (!telemetry) {
+        processableMessages = await processMethod({
+          messages: processableMessages,
+          abort: ctx.abort
+        });
+      } else {
+        await telemetry.traceMethod(async () => {
+          processableMessages = await processMethod({
+            messages: processableMessages,
+            abort: ctx.abort
+          });
+          return processableMessages;
+        }, {
+          spanName: `agent.outputProcessor.${processor.name}`,
+          attributes: {
+            "processor.name": processor.name,
+            "processor.index": index.toString(),
+            "processor.total": this.outputProcessors.length.toString()
+          }
+        })();
+      }
+    }
+    if (processableMessages.length > 0) {
+      messageList.add(processableMessages, "response");
+    }
+    return messageList;
+  }
+  /**
+   * Process a stream part through all output processors with state management
+   */
+  async processPart(part, processorStates) {
+    if (!this.outputProcessors.length) {
+      return {
+        part,
+        blocked: false
+      };
+    }
+    try {
+      let processedPart = part;
+      for (const processor of this.outputProcessors) {
+        try {
+          if (processor.processOutputStream && processedPart) {
+            let state = processorStates.get(processor.name);
+            if (!state) {
+              state = new ProcessorState(processor.name);
+              processorStates.set(processor.name, state);
+            }
+            state.addPart(processedPart);
+            const result = await processor.processOutputStream({
+              part: processedPart,
+              streamParts: state.streamParts,
+              state: state.customState,
+              abort: reason => {
+                throw new TripWire(reason || `Stream part blocked by ${processor.name}`);
+              }
+            });
+            processedPart = result;
+          }
+        } catch (error) {
+          if (error instanceof TripWire) {
+            return {
+              part: null,
+              blocked: true,
+              reason: error.message
+            };
+          }
+          this.logger.error(`[Agent:${this.agentName}] - Output processor ${processor.name} failed:`, error);
+        }
+      }
+      return {
+        part: processedPart,
+        blocked: false
+      };
+    } catch (error) {
+      this.logger.error(`[Agent:${this.agentName}] - Stream part processing failed:`, error);
+      return {
+        part,
+        blocked: false
+      };
+    }
+  }
+  async runOutputProcessorsForStream(streamResult) {
+    return new ReadableStream({
+      start: async controller => {
+        const reader = streamResult.fullStream.getReader();
+        const processorStates = /* @__PURE__ */new Map();
+        try {
+          while (true) {
+            const {
+              done,
+              value
+            } = await reader.read();
+            if (done) {
+              controller.close();
+              break;
+            }
+            const {
+              part: processedPart,
+              blocked,
+              reason
+            } = await this.processPart(value, processorStates);
+            if (blocked) {
+              void this.logger.debug(`[Agent:${this.agentName}] - Stream part blocked by output processor`, {
+                reason,
+                originalPart: value
+              });
+              controller.enqueue({
+                type: "tripwire",
+                tripwireReason: reason || "Output processor blocked content"
+              });
+              controller.close();
+              break;
+            } else if (processedPart !== null) {
+              controller.enqueue(processedPart);
+            }
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      }
+    });
+  }
+  async runInputProcessors(messageList, telemetry) {
+    const userMessages = messageList.clear.input.v2();
+    let processableMessages = [...userMessages];
+    const ctx = {
+      abort: () => {
+        throw new TripWire("Tripwire triggered");
+      }
+    };
+    for (const [index, processor] of this.inputProcessors.entries()) {
+      const abort = reason => {
+        throw new TripWire(reason || `Tripwire triggered by ${processor.name}`);
+      };
+      ctx.abort = abort;
+      const processMethod = processor.processInput?.bind(processor);
+      if (!processMethod) {
+        continue;
+      }
+      if (!telemetry) {
+        processableMessages = await processMethod({
+          messages: processableMessages,
+          abort: ctx.abort
+        });
+      } else {
+        await telemetry.traceMethod(async () => {
+          processableMessages = await processMethod({
+            messages: processableMessages,
+            abort: ctx.abort
+          });
+          return processableMessages;
+        }, {
+          spanName: `agent.inputProcessor.${processor.name}`,
+          attributes: {
+            "processor.name": processor.name,
+            "processor.index": index.toString(),
+            "processor.total": this.inputProcessors.length.toString()
+          }
+        })();
+      }
+    }
+    if (processableMessages.length > 0) {
+      messageList.add(processableMessages, "user");
+    }
+    return messageList;
+  }
+};
+
 // src/scores/hooks.ts
 function runScorer({
   runId,
@@ -209,11 +575,20 @@ function convertFullStreamChunkToMastra(value, ctx) {
         providerMetadata: value.providerMetadata
       }
     };
+  } else if (value.type === "tripwire") {
+    return {
+      type: "tripwire",
+      runId: ctx.runId,
+      from: "AGENT",
+      payload: {
+        tripwireReason: value.tripwireReason
+      }
+    };
   }
 }
 
 // src/stream/MastraAgentStream.ts
-var MastraAgentStream = class extends ReadableStream {
+var MastraAgentStream = class extends ReadableStream$1 {
   #usageCount = {
     promptTokens: 0,
     completionTokens: 0,
@@ -334,56 +709,6 @@ var MastraAgentStream = class extends ReadableStream {
   }
 };
 
-// src/agent/trip-wire.ts
-var TripWire = class extends Error {
-  constructor(reason) {
-    super(reason);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-// src/agent/input-processor/runner.ts
-async function runInputProcessors(processors, messageList, telemetry) {
-  const userMessages = messageList.clear.input.v2();
-  let processableMessages = [...userMessages];
-  const ctx = {
-    abort: () => {
-      throw new TripWire("Tripwire triggered");
-    }
-  };
-  for (const [index, processor] of processors.entries()) {
-    const abort = reason => {
-      throw new TripWire(reason || `Tripwire triggered by ${processor.name}`);
-    };
-    ctx.abort = abort;
-    if (!telemetry) {
-      processableMessages = await processor.process({
-        messages: processableMessages,
-        abort: ctx.abort
-      });
-    } else {
-      await telemetry.traceMethod(async () => {
-        processableMessages = await processor.process({
-          messages: processableMessages,
-          abort: ctx.abort
-        });
-        return processableMessages;
-      }, {
-        spanName: `agent.inputProcessor.${processor.name}`,
-        attributes: {
-          "processor.name": processor.name,
-          "processor.index": index.toString(),
-          "processor.total": processors.length.toString()
-        }
-      })();
-    }
-  }
-  if (processableMessages.length > 0) {
-    messageList.add(processableMessages, "user");
-  }
-  return messageList;
-}
-
 // src/agent/save-queue/index.ts
 var SaveQueueManager = class _SaveQueueManager {
   logger;
@@ -506,7 +831,7 @@ var SaveQueueManager = class _SaveQueueManager {
   }
 };
 
-// src/agent/input-processor/processors/unicode-normalizer.ts
+// src/processors/processors/unicode-normalizer.ts
 var UnicodeNormalizer = class {
   name = "unicode-normalizer";
   options;
@@ -518,7 +843,7 @@ var UnicodeNormalizer = class {
       trim: options.trim ?? true
     };
   }
-  process(args) {
+  processInput(args) {
     try {
       return args.messages.map(message => ({
         ...message,
@@ -562,27 +887,41 @@ var UnicodeNormalizer = class {
     return normalized;
   }
 };
-var ModerationInputProcessor = class _ModerationInputProcessor {
+
+// src/agent/input-processor/processors/unicode-normalizer.ts
+var UnicodeNormalizerInputProcessor = class {
+  name = "unicode-normalizer";
+  processor;
+  constructor(options = {}) {
+    this.processor = new UnicodeNormalizer(options);
+  }
+  process(args) {
+    return this.processor.processInput(args);
+  }
+};
+var ModerationProcessor = class _ModerationProcessor {
   name = "moderation";
   moderationAgent;
   categories;
   threshold;
   strategy;
   includeScores;
+  chunkWindow;
   // Default OpenAI moderation categories
   static DEFAULT_CATEGORIES = ["hate", "hate/threatening", "harassment", "harassment/threatening", "self-harm", "self-harm/intent", "self-harm/instructions", "sexual", "sexual/minors", "violence", "violence/graphic"];
   constructor(options) {
-    this.categories = options.categories || _ModerationInputProcessor.DEFAULT_CATEGORIES;
+    this.categories = options.categories || _ModerationProcessor.DEFAULT_CATEGORIES;
     this.threshold = options.threshold ?? 0.5;
     this.strategy = options.strategy || "block";
     this.includeScores = options.includeScores ?? false;
+    this.chunkWindow = options.chunkWindow ?? 0;
     this.moderationAgent = new Agent({
       name: "content-moderator",
       instructions: options.instructions || this.createDefaultInstructions(),
       model: options.model
     });
   }
-  async process(args) {
+  async processInput(args) {
     try {
       const {
         messages,
@@ -615,11 +954,41 @@ var ModerationInputProcessor = class _ModerationInputProcessor {
       args.abort(`Moderation failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
+  async processOutputResult(args) {
+    return this.processInput(args);
+  }
+  async processOutputStream(args) {
+    try {
+      const {
+        part,
+        streamParts,
+        abort
+      } = args;
+      if (part.type !== "text-delta") {
+        return part;
+      }
+      const contentToModerate = this.buildContextFromChunks(streamParts);
+      const moderationResult = await this.moderateContent(contentToModerate, true);
+      if (this.isModerationFlagged(moderationResult)) {
+        this.handleFlaggedContent(moderationResult, this.strategy, abort);
+        if (this.strategy === "filter") {
+          return null;
+        }
+      }
+      return part;
+    } catch (error) {
+      if (error instanceof TripWire) {
+        throw error;
+      }
+      console.warn("[ModerationProcessor] Stream moderation failed:", error);
+      return args.part;
+    }
+  }
   /**
    * Moderate content using the internal agent
    */
-  async moderateContent(content) {
-    const prompt = this.createModerationPrompt(content);
+  async moderateContent(content, isStream = false) {
+    const prompt = this.createModerationPrompt(content, isStream);
     try {
       const response = await this.moderationAgent.generate(prompt, {
         output: z3.object({
@@ -634,7 +1003,7 @@ var ModerationInputProcessor = class _ModerationInputProcessor {
       const result = response.object;
       return result;
     } catch (error) {
-      console.warn("[ModerationInputProcessor] Agent moderation failed, allowing content:", error);
+      console.warn("[ModerationProcessor] Agent moderation failed, allowing content:", error);
       return {};
     }
   }
@@ -661,10 +1030,10 @@ var ModerationInputProcessor = class _ModerationInputProcessor {
         abort(message);
         break;
       case "warn":
-        console.warn(`[ModerationInputProcessor] ${message}`);
+        console.warn(`[ModerationProcessor] ${message}`);
         break;
       case "filter":
-        console.info(`[ModerationInputProcessor] Filtered message: ${message}`);
+        console.info(`[ModerationProcessor] Filtered message: ${message}`);
         break;
     }
   }
@@ -706,11 +1075,44 @@ Guidelines:
   /**
    * Create moderation prompt for the agent
    */
-  createModerationPrompt(content) {
-    return `Please evaluate the following content for moderation:
+  createModerationPrompt(content, isStream) {
+    return `Please evaluate the following content for moderation, ${isStream ? `this is a stream, so keep in mind you only have the context of the last ${this.chunkWindow} chunks. Make your best judgement on the content.` : ""}:
 
 Content: "${content}"`;
   }
+  /**
+   * Build context string from chunks based on chunkWindow
+   * streamParts includes the current part
+   */
+  buildContextFromChunks(streamParts) {
+    if (this.chunkWindow === 0) {
+      const currentChunk = streamParts[streamParts.length - 1];
+      if (currentChunk && currentChunk.type === "text-delta") {
+        return currentChunk.textDelta;
+      }
+      return "";
+    }
+    const contextChunks = streamParts.slice(-this.chunkWindow);
+    const textContent = contextChunks.filter(part => part.type === "text-delta").map(part => {
+      if (part.type === "text-delta") {
+        return part.textDelta;
+      }
+      return "";
+    }).join("");
+    return textContent;
+  }
+};
+
+// src/agent/input-processor/processors/moderation.ts
+var ModerationInputProcessor = class {
+  name = "moderation";
+  processor;
+  constructor(options) {
+    this.processor = new ModerationProcessor(options);
+  }
+  async process(args) {
+    return this.processor.processInput(args);
+  }
 };
 var PromptInjectionDetector = class _PromptInjectionDetector {
   name = "prompt-injection-detector";
@@ -744,7 +1146,7 @@ var PromptInjectionDetector = class _PromptInjectionDetector {
       model: options.model
     });
   }
-  async process(args) {
+  async processInput(args) {
     try {
       const {
         messages,
@@ -901,6 +1303,18 @@ Content: "${content}"
 ${includeRewrite}`;
   }
 };
+
+// src/agent/input-processor/processors/prompt-injection-detector.ts
+var PromptInjectionDetectorInputProcessor = class {
+  name = "prompt-injection-detector";
+  processor;
+  constructor(options) {
+    this.processor = new PromptInjectionDetector(options);
+  }
+  async process(args) {
+    return this.processor.processInput(args);
+  }
+};
 var PIIDetector = class _PIIDetector {
   name = "pii-detector";
   detectionAgent;
@@ -951,7 +1365,7 @@ var PIIDetector = class _PIIDetector {
       model: options.model
     });
   }
-  async process(args) {
+  async processInput(args) {
     try {
       const {
         messages,
@@ -1200,6 +1614,113 @@ ${this.detectionTypes.map(type => `- ${type}`).join("\n")}
 
 IMPORTANT: IF NO PII IS DETECTED, RETURN AN EMPTY OBJECT, DO NOT INCLUDE ANYTHING ELSE. Do not include any zeros in your response, if the response should be 0, omit it, they will be counted as false.`;
   }
+  /**
+   * Process streaming output chunks for PII detection and redaction
+   */
+  async processOutputStream(args) {
+    const {
+      part,
+      abort
+    } = args;
+    try {
+      if (part.type !== "text-delta") {
+        return part;
+      }
+      const textContent = part.textDelta;
+      if (!textContent.trim()) {
+        return part;
+      }
+      const detectionResult = await this.detectPII(textContent);
+      if (this.isPIIFlagged(detectionResult)) {
+        switch (this.strategy) {
+          case "block":
+            abort(`PII detected in streaming content. Types: ${this.getDetectedTypes(detectionResult).join(", ")}`);
+          case "warn":
+            console.warn(`[PIIDetector] PII detected in streaming content: ${this.getDetectedTypes(detectionResult).join(", ")}`);
+            return part;
+          // Allow content through with warning
+          case "filter":
+            console.info(`[PIIDetector] Filtered streaming part with PII: ${this.getDetectedTypes(detectionResult).join(", ")}`);
+            return null;
+          // Don't emit this part
+          case "redact":
+            if (detectionResult.redacted_content) {
+              console.info(`[PIIDetector] Redacted PII in streaming content: ${this.getDetectedTypes(detectionResult).join(", ")}`);
+              return {
+                ...part,
+                textDelta: detectionResult.redacted_content
+              };
+            } else {
+              console.warn(`[PIIDetector] No redaction available for streaming part, filtering`);
+              return null;
+            }
+          default:
+            return part;
+        }
+      }
+      return part;
+    } catch (error) {
+      if (error instanceof TripWire) {
+        throw error;
+      }
+      console.warn("[PIIDetector] Streaming detection failed, allowing content:", error);
+      return part;
+    }
+  }
+  /**
+   * Process final output result for PII detection and redaction
+   */
+  async processOutputResult({
+    messages,
+    abort
+  }) {
+    try {
+      if (messages.length === 0) {
+        return messages;
+      }
+      const processedMessages = [];
+      for (const message of messages) {
+        const textContent = this.extractTextContent(message);
+        if (!textContent.trim()) {
+          processedMessages.push(message);
+          continue;
+        }
+        const detectionResult = await this.detectPII(textContent);
+        if (this.isPIIFlagged(detectionResult)) {
+          const processedMessage = this.handleDetectedPII(message, detectionResult, this.strategy, abort);
+          if (this.strategy === "filter") {
+            continue;
+          } else if (this.strategy === "redact") {
+            if (processedMessage) {
+              processedMessages.push(processedMessage);
+            } else {
+              processedMessages.push(message);
+            }
+            continue;
+          }
+        }
+        processedMessages.push(message);
+      }
+      return processedMessages;
+    } catch (error) {
+      if (error instanceof TripWire) {
+        throw error;
+      }
+      throw new Error(`PII detection failed: ${error instanceof Error ? error.stack : "Unknown error"}`);
+    }
+  }
+  /**
+   * Get detected PII types from detection result
+   */
+  getDetectedTypes(result) {
+    if (result.detections && result.detections.length > 0) {
+      return [...new Set(result.detections.map(d => d.type))];
+    }
+    if (result.categories) {
+      return Object.entries(result.categories).filter(([_, score]) => typeof score === "number" && score >= this.threshold).map(([type]) => type);
+    }
+    return [];
+  }
   /**
    * Create detection prompt for the agent
    */
@@ -1208,6 +1729,18 @@ IMPORTANT: IF NO PII IS DETECTED, RETURN AN EMPTY OBJECT, DO NOT INCLUDE ANYTHIN
 Content: "${content}"`;
   }
 };
+
+// src/agent/input-processor/processors/pii-detector.ts
+var PIIDetectorInputProcessor = class {
+  name = "pii-detector";
+  processor;
+  constructor(options) {
+    this.processor = new PIIDetector(options);
+  }
+  async process(args) {
+    return this.processor.processInput(args);
+  }
+};
 var LanguageDetector = class _LanguageDetector {
   name = "language-detector";
   detectionAgent;
@@ -1274,7 +1807,7 @@ var LanguageDetector = class _LanguageDetector {
       model: options.model
     });
   }
-  async process(args) {
+  async processInput(args) {
     try {
       const {
         messages,
@@ -1509,6 +2042,18 @@ Target: ${this.targetLanguages.join("/")}${translate}`;
   }
 };
 
+// src/agent/input-processor/processors/language-detector.ts
+var LanguageDetectorInputProcessor = class {
+  name = "language-detector";
+  processor;
+  constructor(options) {
+    this.processor = new LanguageDetector(options);
+  }
+  async process(args) {
+    return this.processor.processInput(args);
+  }
+};
+
 // src/agent/index.ts
 function resolveMaybePromise(value, cb) {
   if (value instanceof Promise) {
@@ -1531,7 +2076,7 @@ function resolveThreadIdFromArgs(args) {
 var _Agent_decorators, _init, _a;
 _Agent_decorators = [InstrumentClass({
   prefix: "agent",
-  excludeMethods: ["hasOwnMemory", "getMemory", "__primitive", "__registerMastra", "__registerPrimitives", "__runInputProcessors", "__setTools", "__setLogger", "__setTelemetry", "log", "getModel", "getInstructions", "getTools", "getLLM", "getWorkflows", "getDefaultGenerateOptions", "getDefaultStreamOptions", "getDescription", "getScorers", "getVoice"]
+  excludeMethods: ["hasOwnMemory", "getMemory", "__primitive", "__registerMastra", "__registerPrimitives", "__runInputProcessors", "__runOutputProcessors", "getProcessorRunner", "__setTools", "__setLogger", "__setTelemetry", "log", "getModel", "getInstructions", "getTools", "getLLM", "getWorkflows", "getDefaultGenerateOptions", "getDefaultStreamOptions", "getDescription", "getScorers", "getVoice"]
 })];
 var Agent = class extends (_a = MastraBase) {
   id;
@@ -1550,6 +2095,7 @@ var Agent = class extends (_a = MastraBase) {
   #scorers;
   #voice;
   #inputProcessors;
+  #outputProcessors;
   // This flag is for agent network messages. We should change the agent network formatting and remove this flag after.
   _agentNetworkAppend = false;
   constructor(config) {
@@ -1611,8 +2157,30 @@ var Agent = class extends (_a = MastraBase) {
     if (config.inputProcessors) {
       this.#inputProcessors = config.inputProcessors;
     }
+    if (config.outputProcessors) {
+      this.#outputProcessors = config.outputProcessors;
+    }
     this._agentNetworkAppend = config._agentNetworkAppend || false;
   }
+  async getProcessorRunner({
+    runtimeContext,
+    inputProcessorOverrides,
+    outputProcessorOverrides
+  }) {
+    const inputProcessors = inputProcessorOverrides ?? (this.#inputProcessors ? typeof this.#inputProcessors === "function" ? await this.#inputProcessors({
+      runtimeContext
+    }) : this.#inputProcessors : []);
+    const outputProcessors = outputProcessorOverrides ?? (this.#outputProcessors ? typeof this.#outputProcessors === "function" ? await this.#outputProcessors({
+      runtimeContext
+    }) : this.#outputProcessors : []);
+    this.logger.debug("outputProcessors", outputProcessors);
+    return new ProcessorRunner({
+      inputProcessors,
+      outputProcessors,
+      logger: this.logger,
+      agentName: this.name
+    });
+  }
   hasOwnMemory() {
     return Boolean(this.#memory);
   }
@@ -1950,7 +2518,7 @@ var Agent = class extends (_a = MastraBase) {
       runtimeContext
     });
     return resolveMaybePromise(modelToUse, resolvedModel => {
-      const llm = new MastraLLM({
+      const llm = new MastraLLMV1({
         model: resolvedModel,
         mastra: this.#mastra
       });
@@ -2238,35 +2806,36 @@ var Agent = class extends (_a = MastraBase) {
   }
   async __runInputProcessors({
     runtimeContext,
-    messageList
+    messageList,
+    inputProcessorOverrides
   }) {
     let tripwireTriggered = false;
     let tripwireReason = "";
-    if (this.#inputProcessors) {
-      const processors = typeof this.#inputProcessors === "function" ? await this.#inputProcessors({
-        runtimeContext
-      }) : this.#inputProcessors;
-      const tracedRunInputProcessors = (processors2, messageList2) => {
+    if (inputProcessorOverrides?.length || this.#inputProcessors) {
+      const runner = await this.getProcessorRunner({
+        runtimeContext,
+        inputProcessorOverrides
+      });
+      const tracedRunInputProcessors = messageList2 => {
         const telemetry = this.#mastra?.getTelemetry();
         if (!telemetry) {
-          return runInputProcessors(processors2, messageList2, void 0);
+          return runner.runInputProcessors(messageList2, void 0);
         }
         return telemetry.traceMethod(async data => {
-          return runInputProcessors(data.processors, data.messageList, telemetry);
+          return runner.runInputProcessors(data.messageList, telemetry);
         }, {
           spanName: `agent.${this.name}.inputProcessors`,
           attributes: {
             "agent.name": this.name,
-            "inputProcessors.count": processors2.length.toString(),
-            "inputProcessors.names": processors2.map(p => p.name).join(",")
+            "inputProcessors.count": runner.inputProcessors.length.toString(),
+            "inputProcessors.names": runner.inputProcessors.map(p => p.name).join(",")
           }
         })({
-          processors: processors2,
           messageList: messageList2
         });
       };
       try {
-        messageList = await tracedRunInputProcessors(processors, messageList);
+        messageList = await tracedRunInputProcessors(messageList);
       } catch (error) {
         if (error instanceof TripWire) {
           tripwireTriggered = true;
@@ -2287,6 +2856,54 @@ var Agent = class extends (_a = MastraBase) {
       tripwireReason
     };
   }
+  async __runOutputProcessors({
+    runtimeContext,
+    messageList,
+    outputProcessorOverrides
+  }) {
+    let tripwireTriggered = false;
+    let tripwireReason = "";
+    if (outputProcessorOverrides?.length || this.#outputProcessors) {
+      const runner = await this.getProcessorRunner({
+        runtimeContext,
+        outputProcessorOverrides
+      });
+      const tracedRunOutputProcessors = messageList2 => {
+        const telemetry = this.#mastra?.getTelemetry();
+        if (!telemetry) {
+          return runner.runOutputProcessors(messageList2, void 0);
+        }
+        return telemetry.traceMethod(async data => {
+          return runner.runOutputProcessors(data.messageList, telemetry);
+        }, {
+          spanName: `agent.${this.name}.outputProcessors`,
+          attributes: {
+            "agent.name": this.name,
+            "outputProcessors.count": runner.outputProcessors.length.toString(),
+            "outputProcessors.names": runner.outputProcessors.map(p => p.name).join(",")
+          }
+        })({
+          messageList: messageList2
+        });
+      };
+      try {
+        messageList = await tracedRunOutputProcessors(messageList);
+      } catch (e) {
+        if (e instanceof TripWire) {
+          tripwireTriggered = true;
+          tripwireReason = e.message;
+          this.logger.debug(`[Agent:${this.name}] - Output processor tripwire triggered: ${e.message}`);
+        } else {
+          throw e;
+        }
+      }
+    }
+    return {
+      messageList,
+      tripwireTriggered,
+      tripwireReason
+    };
+  }
   async getMemoryMessages({
     resourceId,
     threadId,
@@ -3256,14 +3873,92 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
       output,
       ...llmOptions
     } = beforeResult;
+    let finalOutputProcessors = mergedGenerateOptions.outputProcessors;
+    if (mergedGenerateOptions.structuredOutput) {
+      const structuredProcessor = new StructuredOutputProcessor(mergedGenerateOptions.structuredOutput);
+      finalOutputProcessors = finalOutputProcessors ? [...finalOutputProcessors, structuredProcessor] : [structuredProcessor];
+    }
     if (!output || experimental_output) {
       const result2 = await llm.__text({
         ...llmOptions,
         experimental_output
       });
+      const outputProcessorResult2 = await this.__runOutputProcessors({
+        runtimeContext: mergedGenerateOptions.runtimeContext || new RuntimeContext(),
+        outputProcessorOverrides: finalOutputProcessors,
+        messageList: new MessageList({
+          threadId: llmOptions.threadId || "",
+          resourceId: llmOptions.resourceId || ""
+        }).add({
+          role: "assistant",
+          content: [{
+            type: "text",
+            text: result2.text
+          }]
+        }, "response")
+      });
+      if (outputProcessorResult2.tripwireTriggered) {
+        const tripwireResult = {
+          text: "",
+          object: void 0,
+          usage: {
+            totalTokens: 0,
+            promptTokens: 0,
+            completionTokens: 0
+          },
+          finishReason: "other",
+          response: {
+            id: randomUUID(),
+            timestamp: /* @__PURE__ */new Date(),
+            modelId: "tripwire",
+            messages: []
+          },
+          responseMessages: [],
+          toolCalls: [],
+          toolResults: [],
+          warnings: void 0,
+          request: {
+            body: JSON.stringify({
+              messages: []
+            })
+          },
+          experimental_output: void 0,
+          steps: void 0,
+          experimental_providerMetadata: void 0,
+          tripwire: true,
+          tripwireReason: outputProcessorResult2.tripwireReason
+        };
+        return tripwireResult;
+      }
+      const newText2 = outputProcessorResult2.messageList.get.response.v2().map(msg => msg.content.parts.map(part => part.type === "text" ? part.text : "").join("")).join("");
+      result2.text = newText2;
+      if (finalOutputProcessors && finalOutputProcessors.length > 0) {
+        const messages2 = outputProcessorResult2.messageList.get.response.v2();
+        this.logger.debug("Checking messages for experimentalOutput metadata:", messages2.map(m => ({
+          role: m.role,
+          hasContentMetadata: !!m.content.metadata,
+          contentMetadata: m.content.metadata
+        })));
+        const messagesWithStructuredData = messages2.filter(msg => msg.content.metadata && msg.content.metadata.structuredOutput);
+        this.logger.debug("Messages with structured data:", messagesWithStructuredData.length);
+        if (messagesWithStructuredData[0] && messagesWithStructuredData[0].content.metadata?.structuredOutput) {
+          result2.object = messagesWithStructuredData[0].content.metadata.structuredOutput;
+          this.logger.debug("Using structured data from processor metadata for result.object");
+        } else {
+          try {
+            const processedOutput = JSON.parse(newText2);
+            result2.object = processedOutput;
+            this.logger.debug("Using fallback JSON parsing for result.object");
+          } catch (error) {
+            this.logger.warn("Failed to parse processed output as JSON, updating text only", {
+              error
+            });
+          }
+        }
+      }
       await after({
         result: result2,
-        outputText: result2.text
+        outputText: newText2
       });
       return result2;
     }
@@ -3272,9 +3967,64 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
       structuredOutput: output
     });
     const outputText = JSON.stringify(result.object);
+    const outputProcessorResult = await this.__runOutputProcessors({
+      runtimeContext: mergedGenerateOptions.runtimeContext || new RuntimeContext(),
+      messageList: new MessageList({
+        threadId: llmOptions.threadId || "",
+        resourceId: llmOptions.resourceId || ""
+      }).add({
+        role: "assistant",
+        content: [{
+          type: "text",
+          text: outputText
+        }]
+      }, "response")
+    });
+    if (outputProcessorResult.tripwireTriggered) {
+      const tripwireResult = {
+        text: "",
+        object: void 0,
+        usage: {
+          totalTokens: 0,
+          promptTokens: 0,
+          completionTokens: 0
+        },
+        finishReason: "other",
+        response: {
+          id: randomUUID(),
+          timestamp: /* @__PURE__ */new Date(),
+          modelId: "tripwire",
+          messages: []
+        },
+        responseMessages: [],
+        toolCalls: [],
+        toolResults: [],
+        warnings: void 0,
+        request: {
+          body: JSON.stringify({
+            messages: []
+          })
+        },
+        experimental_output: void 0,
+        steps: void 0,
+        experimental_providerMetadata: void 0,
+        tripwire: true,
+        tripwireReason: outputProcessorResult.tripwireReason
+      };
+      return tripwireResult;
+    }
+    const newText = outputProcessorResult.messageList.get.response.v2().map(msg => msg.content.parts.map(part => part.type === "text" ? part.text : "").join("")).join("");
+    try {
+      const processedObject = JSON.parse(newText);
+      result.object = processedObject;
+    } catch (error) {
+      this.logger.warn("Failed to parse processed output as JSON, keeping original result", {
+        error
+      });
+    }
     await after({
       result,
-      outputText,
+      outputText: newText,
       structuredOutput: true
     });
     return result;
@@ -3371,6 +4121,7 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
       });
       const streamResult = llm.__stream({
         ...llmOptions,
+        experimental_output,
         onFinish: async result => {
           try {
             const outputText = result.text;
@@ -3389,8 +4140,7 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
             runId
           });
         },
-        runId,
-        experimental_output
+        runId
       });
       return streamResult;
     }
@@ -3452,16 +4202,47 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
           experimental_output,
           ...llmOptions
         } = await before();
+        let effectiveOutputProcessors = mergedStreamOptions.outputProcessors || (this.#outputProcessors ? typeof this.#outputProcessors === "function" ? await this.#outputProcessors({
+          runtimeContext: mergedStreamOptions.runtimeContext || new RuntimeContext()
+        }) : this.#outputProcessors : []);
+        if (mergedStreamOptions.structuredOutput) {
+          const structuredProcessor = new StructuredOutputProcessor(mergedStreamOptions.structuredOutput);
+          effectiveOutputProcessors = effectiveOutputProcessors ? [...effectiveOutputProcessors, structuredProcessor] : [structuredProcessor];
+        }
         if (output) {
           const streamResult = llm.__streamObject({
             ...llmOptions,
             onFinish: async result => {
-              onResult(result.object);
               try {
                 const outputText = JSON.stringify(result.object);
+                const processedResult = await this.__runOutputProcessors({
+                  runtimeContext: mergedStreamOptions.runtimeContext || new RuntimeContext(),
+                  outputProcessorOverrides: effectiveOutputProcessors,
+                  messageList: new MessageList({
+                    threadId: llmOptions.threadId || "",
+                    resourceId: llmOptions.resourceId || ""
+                  }).add({
+                    role: "assistant",
+                    content: [{
+                      type: "text",
+                      text: outputText
+                    }]
+                  }, "response")
+                });
+                const newText = processedResult.messageList.get.response.v2().map(msg => msg.content.parts.map(part => part.type === "text" ? part.text : "").join("")).join("");
+                try {
+                  const processedObject = JSON.parse(newText);
+                  result.object = processedObject;
+                  onResult(processedObject);
+                } catch (error) {
+                  this.logger.warn("Failed to parse processed output as JSON, keeping original result", {
+                    error
+                  });
+                  onResult(result.object);
+                }
                 await after({
                   result,
-                  outputText,
+                  outputText: newText,
                   structuredOutput: true
                 });
               } catch (e) {
@@ -3469,6 +4250,7 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
                   error: e,
                   runId
                 });
+                onResult(result.object);
               }
               await onFinish?.({
                 ...result,
@@ -3478,33 +4260,97 @@ Message ${msg.threadId && msg.threadId !== threadObject.id ? "from previous conv
             runId,
             structuredOutput: output
           });
-          return streamResult.fullStream;
+          if (effectiveOutputProcessors?.length) {
+            const runner = await this.getProcessorRunner({
+              runtimeContext: mergedStreamOptions.runtimeContext || new RuntimeContext(),
+              outputProcessorOverrides: effectiveOutputProcessors
+            });
+            return runner.runOutputProcessorsForStream(streamResult);
+          }
+          return Promise.resolve(streamResult.fullStream);
         } else {
           const streamResult = llm.__stream({
             ...llmOptions,
+            experimental_output,
             onFinish: async result => {
-              onResult(result.text);
               try {
                 const outputText = result.text;
+                const processedResult = await this.__runOutputProcessors({
+                  runtimeContext: mergedStreamOptions.runtimeContext || new RuntimeContext(),
+                  outputProcessorOverrides: effectiveOutputProcessors,
+                  messageList: new MessageList({
+                    threadId: llmOptions.threadId || "",
+                    resourceId: llmOptions.resourceId || ""
+                  }).add({
+                    role: "assistant",
+                    content: [{
+                      type: "text",
+                      text: outputText
+                    }]
+                  }, "response")
+                });
+                const newText = processedResult.messageList.get.response.v2().map(msg => msg.content.parts.map(part => part.type === "text" ? part.text : "").join("")).join("");
+                result.text = newText;
+                let finalObject;
+                if (effectiveOutputProcessors && effectiveOutputProcessors.length > 0) {
+                  const messages2 = processedResult.messageList.get.response.v2();
+                  const messagesWithStructuredData = messages2.filter(msg => msg.content.metadata && msg.content.metadata.structuredOutput);
+                  if (messagesWithStructuredData[0] && messagesWithStructuredData[0].content.metadata?.structuredOutput) {
+                    finalObject = messagesWithStructuredData[0].content.metadata.structuredOutput;
+                  } else if (experimental_output) {
+                    try {
+                      finalObject = JSON.parse(newText);
+                    } catch (error) {
+                      this.logger.warn("Failed to parse processed experimental_output as JSON, using null", {
+                        error
+                      });
+                      finalObject = null;
+                    }
+                  } else {
+                    finalObject = newText;
+                  }
+                } else if (experimental_output) {
+                  try {
+                    finalObject = JSON.parse(newText);
+                  } catch (error) {
+                    this.logger.warn("Failed to parse processed experimental_output as JSON, using null", {
+                      error
+                    });
+                    finalObject = null;
+                  }
+                } else {
+                  finalObject = newText;
+                }
+                result.object = finalObject;
+                onResult(finalObject);
                 await after({
                   result,
-                  outputText
+                  outputText: newText
                 });
               } catch (e) {
                 this.logger.error("Error saving memory on finish", {
                   error: e,
                   runId
                 });
+                onResult(result.text);
               }
               await onFinish?.({
                 ...result,
                 runId
               });
             },
-            runId,
-            experimental_output
+            runId
           });
-          return streamResult.fullStream;
+          if (effectiveOutputProcessors?.length) {
+            this.logger.debug("running output processors for stream");
+            const runner = await this.getProcessorRunner({
+              runtimeContext: mergedStreamOptions.runtimeContext || new RuntimeContext(),
+              outputProcessorOverrides: effectiveOutputProcessors
+            });
+            return runner.runOutputProcessorsForStream(streamResult);
+          }
+          this.logger.debug("no output processors for stream");
+          return Promise.resolve(streamResult.fullStream);
         }
       }
     });
@@ -6653,6 +7499,6 @@ var LegacyWorkflow = class extends MastraBase {
   }
 };
 
-export { Agent, LanguageDetector, LegacyStep, LegacyWorkflow, ModerationInputProcessor, PIIDetector, PromptInjectionDetector, TripWire, UnicodeNormalizer, WhenConditionReturnValue, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, runScorer, updateStepInHierarchy, workflowToStep };
-//# sourceMappingURL=chunk-IL5SHDY4.js.map
-//# sourceMappingURL=chunk-IL5SHDY4.js.map
+export { Agent, LanguageDetector, LanguageDetectorInputProcessor, LegacyStep, LegacyWorkflow, ModerationInputProcessor, ModerationProcessor, PIIDetector, PIIDetectorInputProcessor, PromptInjectionDetector, PromptInjectionDetectorInputProcessor, StructuredOutputProcessor, TripWire, UnicodeNormalizer, UnicodeNormalizerInputProcessor, WhenConditionReturnValue, agentToStep, getActivePathsAndStatus, getResultActivePaths, getStepResult, getSuspendedPaths, isAgent, isConditionalKey, isErrorEvent, isFinalState, isLimboState, isTransitionEvent, isVariableReference, isWorkflow, mergeChildValue, recursivelyCheckForFinalState, resolveVariables, runScorer, updateStepInHierarchy, workflowToStep };
+//# sourceMappingURL=chunk-DAMIFZPW.js.map
+//# sourceMappingURL=chunk-DAMIFZPW.js.map