@mastra/core 1.16.1-alpha.1 → 1.17.0

package/dist/{chunk-WJWWFBKT.js → chunk-IYSW4VN7.js}

@@ -1,16 +1,16 @@
 import { DefaultVoice } from './chunk-YDLGEJ7W.js';
 import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-2QXNHEDL.js';
-import { createWorkspaceTools, createSkillTools, getTiktoken, BM25Index } from './chunk-J3NJXIJ4.js';
-import { InMemoryStore } from './chunk-RGOEP34Y.js';
+import { createWorkspaceTools, createSkillTools, getTiktoken, BM25Index } from './chunk-ABA3KD3X.js';
+import { InMemoryStore } from './chunk-CYQ2TNSK.js';
 import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType, sanitizeToolName } from './chunk-SLZ3WO42.js';
 import { parsePartialJson, isDeepEqualData, stepCountIs } from './chunk-2PHG443D.js';
 import { generateId, APICallError, tool, asSchema } from './chunk-6PALJNKG.js';
+import { EventEmitterPubSub } from './chunk-X2HAI3OX.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-X672Z4KM.js';
-import { MastraLLMV1 } from './chunk-XKOCRXCP.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-KFYDUUVH.js';
+import { MastraLLMV1 } from './chunk-ZOJZL62I.js';
 import { noopLogger } from './chunk-PSCMWPLC.js';
-import { EventEmitterPubSub } from './chunk-X2HAI3OX.js';
-import { removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, generateEmptyFromSchema, selectFields, delay } from './chunk-ZJMETLCP.js';
+import { removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, generateEmptyFromSchema, selectFields, delay } from './chunk-FWDG2WUV.js';
 import { resolveObservabilityContext, EntityType, createObservabilityContext, getRootExportSpan, getOrCreateSpan, wrapMastra, executeWithContext, executeWithContextSync } from './chunk-CT4YYQI3.js';
 import { ToolStream } from './chunk-DD2VNRQM.js';
 import { Tool, createTool, isMastraTool, isProviderTool, getProviderToolName, isProviderDefinedTool } from './chunk-GRMC2OYN.js';
@@ -28,6 +28,8 @@ import EventEmitter2, { EventEmitter } from 'events';
 import { wrapSchemaWithNullTransform, isZodType, prepareJsonSchemaForOpenAIStrictMode } from '@mastra/schema-compat';
 import { isEmpty } from 'radash';
 import { isAbortError, injectJsonInstructionIntoMessages } from '@ai-sdk/provider-utils-v5';
+import { existsSync, statSync, readFileSync } from 'fs';
+import { normalize, isAbsolute, resolve, basename, dirname, join } from 'path';
 import xxhash from 'xxhash-wasm';
 import { LRUCache } from 'lru-cache';
 
@@ -214,8 +216,8 @@ var MastraAgentNetworkStream = class extends ReadableStream$1 {
       resolve: null,
       reject: null
     };
-    deferredPromise.promise = new Promise((resolve, reject) => {
-      deferredPromise.resolve = resolve;
+    deferredPromise.promise = new Promise((resolve2, reject) => {
+      deferredPromise.resolve = resolve2;
       deferredPromise.reject = reject;
     });
     const objectDeferredPromise = {
@@ -223,8 +225,8 @@ var MastraAgentNetworkStream = class extends ReadableStream$1 {
       resolve: null,
       reject: null
     };
-    objectDeferredPromise.promise = new Promise((resolve, reject) => {
-      objectDeferredPromise.resolve = resolve;
+    objectDeferredPromise.promise = new Promise((resolve2, reject) => {
+      objectDeferredPromise.resolve = resolve2;
       objectDeferredPromise.reject = reject;
     });
     let objectStreamController = null;
@@ -551,13 +553,13 @@ var DelayedPromise = class {
     if (this._promise) {
       return this._promise;
     }
-    this._promise = new Promise((resolve, reject) => {
+    this._promise = new Promise((resolve2, reject) => {
       if (this.status.type === "resolved") {
-        resolve(this.status.value);
+        resolve2(this.status.value);
       } else if (this.status.type === "rejected") {
         reject(this.status.error);
       }
-      this._resolve = resolve;
+      this._resolve = resolve2;
       this._reject = reject;
     });
     return this._promise;
@@ -7612,7 +7614,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
    * @param _workflowId - The workflow ID (for constructing platform-specific IDs)
    */
   async executeSleepDuration(duration, _sleepId, _workflowId) {
-    await new Promise((resolve) => setTimeout(resolve, duration < 0 ? 0 : duration));
+    await new Promise((resolve2) => setTimeout(resolve2, duration < 0 ? 0 : duration));
   }
   /**
    * Execute sleep until a specific date. Override to use platform-specific sleep primitives.
@@ -7623,7 +7625,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
    */
   async executeSleepUntilDate(date, _sleepUntilId, _workflowId) {
     const time = date.getTime() - Date.now();
-    await new Promise((resolve) => setTimeout(resolve, time < 0 ? 0 : time));
+    await new Promise((resolve2) => setTimeout(resolve2, time < 0 ? 0 : time));
   }
   /**
    * Wrap a durable operation (like dynamic sleep function evaluation).
@@ -7787,7 +7789,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
   async executeStepWithRetry(stepId, runStep, params) {
     for (let i = 0; i < params.retries + 1; i++) {
       if (i > 0 && params.delay) {
-        await new Promise((resolve) => setTimeout(resolve, params.delay));
+        await new Promise((resolve2) => setTimeout(resolve2, params.delay));
       }
       try {
         const result = await this.wrapDurableOperation(stepId, runStep);
@@ -8365,8 +8367,8 @@ function createStepFromAgent(params, agentOrToolOptions) {
     }) => {
       const observabilityContext = resolveObservabilityContext(rest);
       let streamPromise = {};
-      streamPromise.promise = new Promise((resolve, reject) => {
-        streamPromise.resolve = resolve;
+      streamPromise.promise = new Promise((resolve2, reject) => {
+        streamPromise.resolve = resolve2;
         streamPromise.reject = reject;
       });
       let structuredResult = null;
@@ -11453,8 +11455,8 @@ async function runCompletionScorers(scorers, context, options) {
   const startTime = Date.now();
   const results = [];
   let timedOut = false;
-  const timeoutPromise = new Promise((resolve) => {
-    setTimeout(() => resolve("timeout"), timeout);
+  const timeoutPromise = new Promise((resolve2) => {
+    setTimeout(() => resolve2("timeout"), timeout);
   });
   if (parallel) {
     const scorerPromises = scorers.map((scorer) => runSingleScorer(scorer, context));
@@ -16772,7 +16774,7 @@ async function networkLoop({
         processorRunner,
         { requestContext }
       );
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      await new Promise((resolve2) => setTimeout(resolve2, 10));
       if (isComplete) {
         return {
           ...inputData,
@@ -18134,14 +18136,14 @@ var SaveQueueManager = class _SaveQueueManager {
    * @returns A promise that resolves when the debounced save completes.
    */
   debounceSave(threadId, messageList, memoryConfig) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       if (this.saveDebounceTimers.has(threadId)) {
         clearTimeout(this.saveDebounceTimers.get(threadId));
       }
       this.saveDebounceTimers.set(
         threadId,
         setTimeout(() => {
-          this.enqueueSave(threadId, messageList, memoryConfig).then(resolve).catch((err) => {
+          this.enqueueSave(threadId, messageList, memoryConfig).then(resolve2).catch((err) => {
             this.logger?.error?.("Error in debounceSave", { err, threadId });
             reject(err);
           }).finally(() => {
@@ -24833,6 +24835,200 @@ var ToolCallFilter = class {
     return messages;
   }
 };
+var INSTRUCTION_FILE_NAMES = ["AGENTS.md", "CLAUDE.md", "CONTEXT.md"];
+var PATH_FIELDS = ["path", "file", "filePath", "target", "targetPath", "dest", "destination"];
+var REMINDER_TYPE = "dynamic-agents-md";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isInstructionFileName(name) {
+  return INSTRUCTION_FILE_NAMES.some((instructionFileName) => instructionFileName.toLowerCase() === name.toLowerCase());
+}
+function toAbsolutePath(candidatePath) {
+  return normalize(isAbsolute(candidatePath) ? candidatePath : resolve(process.cwd(), candidatePath));
+}
+function findInstructionFileForPath(candidatePath, pathExists, isDirectory) {
+  const absoluteCandidatePath = toAbsolutePath(candidatePath);
+  const candidateName = basename(absoluteCandidatePath);
+  if (isInstructionFileName(candidateName)) {
+    return absoluteCandidatePath;
+  }
+  let currentDir = absoluteCandidatePath;
+  if (!pathExists(currentDir) || !isDirectory(currentDir)) {
+    currentDir = dirname(currentDir);
+  }
+  let previousDir;
+  while (currentDir && currentDir !== previousDir) {
+    for (const instructionFileName of INSTRUCTION_FILE_NAMES) {
+      const instructionFilePath = join(currentDir, instructionFileName);
+      if (pathExists(instructionFilePath)) {
+        return instructionFilePath;
+      }
+    }
+    previousDir = currentDir;
+    currentDir = dirname(currentDir);
+  }
+  return void 0;
+}
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function escapeXmlAttribute(value) {
+  return escapeXml(value).replaceAll('"', "&quot;");
+}
+function getMessageText(message) {
+  const parts = isRecord(message.content) ? message.content.parts : void 0;
+  if (!Array.isArray(parts)) {
+    return "";
+  }
+  return parts.filter((part) => isRecord(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}
+function getReminderMarkup(reminderText, instructionPath) {
+  return `<system-reminder type="${REMINDER_TYPE}" path="${escapeXmlAttribute(instructionPath)}">${escapeXml(reminderText)}</system-reminder>`;
+}
+function getCompletedToolCalls(messageList) {
+  const completed = [];
+  for (const message of messageList.get.all.db()) {
+    const parts = isRecord(message.content) ? message.content.parts : void 0;
+    if (!Array.isArray(parts)) {
+      continue;
+    }
+    for (const part of parts) {
+      if (!isRecord(part) || part.type !== "tool-invocation") {
+        continue;
+      }
+      const invocation = part.toolInvocation;
+      if (!invocation || invocation.state !== "result" || typeof invocation.toolCallId !== "string") {
+        continue;
+      }
+      completed.push({
+        toolCallId: invocation.toolCallId,
+        args: invocation.args
+      });
+    }
+  }
+  return completed;
+}
+function parseInvocationArgs(args) {
+  if (isRecord(args)) {
+    return args;
+  }
+  if (typeof args !== "string") {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(args);
+    return isRecord(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var AgentsMDInjector = class {
+  id = "agents-md-injector";
+  name = "Agents.md Injector";
+  description = "Injects AGENTS.md reminders when instruction file operations are detected";
+  processorIndex = 0;
+  reminderText;
+  pathExists;
+  isDirectory;
+  readFile;
+  getIgnoredInstructionPaths;
+  constructor(options) {
+    this.reminderText = options.reminderText;
+    this.pathExists = options.pathExists ?? existsSync;
+    this.isDirectory = options.isDirectory ?? ((path) => {
+      try {
+        return statSync(path).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    this.readFile = options.readFile ?? ((path) => readFileSync(path, "utf-8"));
+    this.getIgnoredInstructionPaths = options.getIgnoredInstructionPaths;
+  }
+  async processInputStep(args) {
+    const { messageList, rotateResponseMessageId } = args;
+    const messages = messageList.get.all.db();
+    const completedToolCalls = getCompletedToolCalls(messageList);
+    const instructionPath = this.findReferencedInstructionPath(completedToolCalls);
+    if (!instructionPath || this.isIgnoredInstructionPath(args, instructionPath)) {
+      return messageList;
+    }
+    const reminderText = this.getReminderText(instructionPath);
+    if (!reminderText) {
+      return messageList;
+    }
+    const reminderMarkup = getReminderMarkup(reminderText, instructionPath);
+    if (this.hasReminderAlready(messages, reminderMarkup)) {
+      return messageList;
+    }
+    if (args.writer) {
+      const chunk = {
+        type: "data-system-reminder",
+        data: {
+          message: reminderText,
+          reminderType: REMINDER_TYPE,
+          path: instructionPath
+        },
+        transient: true
+      };
+      await args.writer.custom(chunk);
+    }
+    messageList.add(reminderMarkup, "user");
+    rotateResponseMessageId?.();
+    return messageList;
+  }
+  getReminderText(instructionPath) {
+    try {
+      const content = this.readFile(instructionPath).trim();
+      if (content.length > 0) {
+        return content;
+      }
+    } catch {
+    }
+    return this.reminderText?.trim() || void 0;
+  }
+  isIgnoredInstructionPath(args, instructionPath) {
+    const ignoredPaths = this.getIgnoredInstructionPaths?.(args) ?? [];
+    const normalizedInstructionPath = toAbsolutePath(instructionPath);
+    return ignoredPaths.some((path) => toAbsolutePath(path) === normalizedInstructionPath);
+  }
+  findReferencedInstructionPath(toolCalls) {
+    if (!Array.isArray(toolCalls)) {
+      return void 0;
+    }
+    for (const toolCall of toolCalls) {
+      const path = this.findInstructionPathInInvocation(toolCall);
+      if (path) {
+        return path;
+      }
+    }
+    return void 0;
+  }
+  findInstructionPathInInvocation(invocation) {
+    if (!isRecord(invocation)) {
+      return void 0;
+    }
+    const args = parseInvocationArgs(invocation.args);
+    if (!args) {
+      return void 0;
+    }
+    for (const field of PATH_FIELDS) {
+      const value = args[field];
+      if (typeof value !== "string" || value.trim().length === 0) {
+        continue;
+      }
+      const instructionPath = findInstructionFileForPath(value, this.pathExists, this.isDirectory);
+      if (instructionPath) {
+        return instructionPath;
+      }
+    }
+    return void 0;
+  }
+  hasReminderAlready(messages, reminderMarkup) {
+    return messages.some((message) => message.role === "user" && getMessageText(message).includes(reminderMarkup));
+  }
+};
 var TOOL_SEARCH_TOKENIZE_OPTIONS = {
   lowercase: true,
   removePunctuation: false,
@@ -25116,6 +25312,259 @@ var ToolSearchProcessor = class {
     };
   }
 };
+var SkillSearchProcessor = class {
+  id = "skill-search";
+  name = "Skill Search Processor";
+  description = "Enables on-demand skill discovery and loading via search";
+  workspace;
+  searchConfig;
+  ttl;
+  cleanupIntervalId;
+  /**
+   * Thread-scoped state management for loaded skills with TTL support.
+   * Maps threadId -> ThreadState (skills + timestamp)
+   */
+  threadLoadedSkills = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.workspace = options.workspace;
+    this.searchConfig = {
+      topK: options.search?.topK ?? 5,
+      minScore: options.search?.minScore ?? 0
+    };
+    this.ttl = options.ttl ?? 36e5;
+    if (this.ttl > 0) {
+      this.scheduleCleanup();
+    }
+  }
+  /**
+   * Dispose of this processor, clearing the cleanup interval and all thread state.
+   * Call this when the processor is no longer needed to prevent timer leaks.
+   */
+  dispose() {
+    if (this.cleanupIntervalId) {
+      clearInterval(this.cleanupIntervalId);
+      this.cleanupIntervalId = void 0;
+    }
+    this.clearAllState();
+  }
+  /**
+   * Get the workspace skills interface
+   */
+  get skills() {
+    return this.workspace.skills;
+  }
+  /**
+   * Get the thread ID from the request context, or use 'default' as fallback.
+   */
+  getThreadId(args) {
+    return args.requestContext?.get(MASTRA_THREAD_ID_KEY) || "default";
+  }
+  /**
+   * Get or create thread state for the given thread.
+   * Updates the lastAccessed timestamp for TTL management.
+   */
+  getThreadState(threadId) {
+    if (!this.threadLoadedSkills.has(threadId)) {
+      this.threadLoadedSkills.set(threadId, {
+        skills: /* @__PURE__ */ new Map(),
+        lastAccessed: Date.now()
+      });
+    }
+    const state = this.threadLoadedSkills.get(threadId);
+    state.lastAccessed = Date.now();
+    return state;
+  }
+  /**
+   * Clear loaded skills for a specific thread.
+   */
+  clearState(threadId = "default") {
+    this.threadLoadedSkills.delete(threadId);
+  }
+  /**
+   * Clear all thread state for this processor instance.
+   */
+  clearAllState() {
+    this.threadLoadedSkills.clear();
+  }
+  /**
+   * Clean up stale thread state based on TTL.
+   * @returns Number of threads cleaned up
+   */
+  cleanupStaleState() {
+    if (this.ttl <= 0) return 0;
+    const now = Date.now();
+    let cleanedCount = 0;
+    for (const [threadId, state] of this.threadLoadedSkills.entries()) {
+      if (now - state.lastAccessed > this.ttl) {
+        this.threadLoadedSkills.delete(threadId);
+        cleanedCount++;
+      }
+    }
+    return cleanedCount;
+  }
+  /**
+   * Schedule periodic cleanup of stale thread state.
+   */
+  scheduleCleanup() {
+    const cleanupInterval = Math.max(this.ttl / 2, 6e4);
+    this.cleanupIntervalId = setInterval(() => {
+      this.cleanupStaleState();
+    }, cleanupInterval);
+    if (this.cleanupIntervalId.unref) {
+      this.cleanupIntervalId.unref();
+    }
+  }
+  /**
+   * Get statistics about current thread state.
+   */
+  getStateStats() {
+    if (this.threadLoadedSkills.size === 0) {
+      return { threadCount: 0, oldestAccessTime: null };
+    }
+    let oldest = Date.now();
+    for (const state of this.threadLoadedSkills.values()) {
+      if (state.lastAccessed < oldest) {
+        oldest = state.lastAccessed;
+      }
+    }
+    return {
+      threadCount: this.threadLoadedSkills.size,
+      oldestAccessTime: oldest
+    };
+  }
+  /**
+   * Manually trigger cleanup of stale state.
+   * @returns Number of threads cleaned up
+   */
+  cleanupNow() {
+    return this.cleanupStaleState();
+  }
+  async processInputStep(args) {
+    const { tools, messageList } = args;
+    const threadId = this.getThreadId(args);
+    const threadState = this.getThreadState(threadId);
+    const skills = this.skills;
+    if (!skills) {
+      return { tools };
+    }
+    if (args.stepNumber === 0) {
+      await skills.maybeRefresh({ requestContext: args.requestContext });
+    }
+    messageList.addSystem(
+      "To discover available skills, call search_skills with a keyword query. To load a skill's instructions, call load_skill with the skill name. Loaded skills provide context and instructions for the conversation."
+    );
+    const searchSkillTool = createTool({
+      id: "search_skills",
+      description: "Search for available skills by keyword. Returns a list of matching skills with their names and descriptions. After finding a useful skill, use load_skill to load its instructions.",
+      inputSchema: z.object({
+        query: z.string().describe('Search keywords (e.g., "api design", "testing", "deployment")')
+      }),
+      outputSchema: z.object({
+        results: z.array(
+          z.object({
+            name: z.string(),
+            description: z.string(),
+            score: z.number()
+          })
+        ),
+        message: z.string()
+      }),
+      execute: async ({ query }) => {
+        const searchResults = await skills.search(query, {
+          topK: this.searchConfig.topK,
+          minScore: this.searchConfig.minScore
+        });
+        if (searchResults.length === 0) {
+          return {
+            results: [],
+            message: `No skills found matching "${query}". Try different keywords.`
+          };
+        }
+        const seen = /* @__PURE__ */ new Set();
+        const uniqueResults = searchResults.filter((r) => {
+          if (seen.has(r.skillName)) return false;
+          seen.add(r.skillName);
+          return true;
+        });
+        const skillList = await skills.list();
+        const metaMap = new Map(skillList.map((s) => [s.name, s]));
+        const results = uniqueResults.map((r) => {
+          const meta = metaMap.get(r.skillName);
+          const description = meta?.description ?? "";
+          return {
+            name: r.skillName,
+            description: description.length > 150 ? description.slice(0, 147) + "..." : description,
+            score: Math.round(r.score * 100) / 100
+          };
+        });
+        return {
+          results,
+          message: `Found ${results.length} skill(s). Use load_skill with the exact skill name to load its instructions.`
+        };
+      }
+    });
+    const loadSkillTool = createTool({
+      id: "load_skill",
+      description: "Load a skill's full instructions into the conversation. Call this after finding a skill with search_skills. The skill's instructions will be available as context.",
+      inputSchema: z.object({
+        skillName: z.string().describe("The exact name of the skill to load (from search results)")
+      }),
+      outputSchema: z.object({
+        success: z.boolean(),
+        message: z.string(),
+        skillName: z.string().optional()
+      }),
+      execute: async ({ skillName }) => {
+        if (threadState.skills.has(skillName)) {
+          return {
+            success: true,
+            message: `Skill "${skillName}" is already loaded.`,
+            skillName
+          };
+        }
+        const skill = await skills.get(skillName);
+        if (!skill) {
+          const allSkills = await skills.list();
+          const suggestions = allSkills.filter(
+            (s) => s.name.toLowerCase().includes(skillName.toLowerCase()) || skillName.toLowerCase().includes(s.name.toLowerCase())
+          ).slice(0, 3);
+          let message = `Skill "${skillName}" not found.`;
+          if (suggestions.length > 0) {
+            message += ` Did you mean: ${suggestions.map((s) => s.name).join(", ")}?`;
+          } else {
+            message += " Use search_skills to find available skills.";
+          }
+          return { success: false, message };
+        }
+        threadState.skills.set(skillName, skill.instructions);
+        return {
+          success: true,
+          message: `Skill "${skillName}" loaded. Its instructions are now available as context.`,
+          skillName
+        };
+      }
+    });
+    for (const [skillName, instructions] of threadState.skills) {
+      messageList.addSystem(`[Skill: ${skillName}]
+
+${instructions}`);
+    }
+    const metaTools = { search_skills: searchSkillTool, load_skill: loadSkillTool };
+    if (tools) {
+      for (const key of Object.keys(tools)) {
+        if (key in metaTools) {
+          console.warn(`[SkillSearchProcessor] User tool "${key}" conflicts with meta-tool and will be shadowed.`);
+        }
+      }
+    }
+    return {
+      tools: {
+        ...tools ?? {},
+        ...metaTools
+      }
+    };
+  }
+};
 
 // src/memory/working-memory-utils.ts
 var WORKING_MEMORY_START_TAG = "<working_memory>";
@@ -25283,7 +25732,7 @@ var MessageHistory = class {
       return messageList;
     }
     await this.persistMessages({ messages: messagesToSave, threadId, resourceId });
-    await new Promise((resolve) => setTimeout(resolve, 10));
+    await new Promise((resolve2) => setTimeout(resolve2, 10));
     return messageList;
   }
   /**
@@ -26729,6 +27178,6 @@ var MockMemory = class extends MastraMemory {
   }
 };
 
-export { Agent, BaseProcessor, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MastraScorer, MemoryProcessor, MessageContentSchema, MessageHistory, MessagePartSchema, MockMemory, ModerationProcessor, PIIDetector, ProcessorInputPhaseSchema, ProcessorInputStepPhaseSchema, ProcessorMessageContentSchema, ProcessorMessageSchema, ProcessorOutputResultPhaseSchema, ProcessorOutputStepPhaseSchema, ProcessorOutputStreamPhaseSchema, ProcessorRunner, ProcessorState, ProcessorStepInputSchema, ProcessorStepOutputSchema, ProcessorStepSchema, PromptInjectionDetector, ReasoningPartSchema, Run, SemanticRecall, SkillsProcessor, SourcePartSchema, StepStartPartSchema, StructuredOutputProcessor, SystemPromptScrubber, TextPartSchema, TokenLimiterProcessor, ToolCallFilter, ToolInvocationPartSchema, ToolSearchProcessor, TripWire, UnicodeNormalizer, WORKING_MEMORY_END_TAG, WORKING_MEMORY_START_TAG, Workflow, WorkflowRunOutput, WorkingMemory, WorkspaceInstructionsProcessor, augmentWithInit, cleanStepResult, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, formatCheckFeedback, formatCompletionFeedback, formatStreamCompletionFeedback, formatValidationFeedback, forwardAgentStreamChunk, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getThreadOMMetadata, globalEmbeddingCache, hydrateSerializedStepErrors, isObservationalMemoryEnabled, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runStreamCompletionScorers, runValidation, setThreadOMMetadata, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepRequestContext, validateStepResumeData, validateStepStateData, validateStepSuspendData };
-//# sourceMappingURL=chunk-WJWWFBKT.js.map
-//# sourceMappingURL=chunk-WJWWFBKT.js.map
+export { Agent, AgentsMDInjector, BaseProcessor, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, ExecutionEngine, FilePartSchema, ImagePartSchema, LanguageDetector, MastraAgentNetworkStream, MastraMemory, MastraModelOutput, MastraScorer, MemoryProcessor, MessageContentSchema, MessageHistory, MessagePartSchema, MockMemory, ModerationProcessor, PIIDetector, ProcessorInputPhaseSchema, ProcessorInputStepPhaseSchema, ProcessorMessageContentSchema, ProcessorMessageSchema, ProcessorOutputResultPhaseSchema, ProcessorOutputStepPhaseSchema, ProcessorOutputStreamPhaseSchema, ProcessorRunner, ProcessorState, ProcessorStepInputSchema, ProcessorStepOutputSchema, ProcessorStepSchema, PromptInjectionDetector, ReasoningPartSchema, Run, SemanticRecall, SkillSearchProcessor, SkillsProcessor, SourcePartSchema, StepStartPartSchema, StructuredOutputProcessor, SystemPromptScrubber, TextPartSchema, TokenLimiterProcessor, ToolCallFilter, ToolInvocationPartSchema, ToolSearchProcessor, TripWire, UnicodeNormalizer, WORKING_MEMORY_END_TAG, WORKING_MEMORY_START_TAG, Workflow, WorkflowRunOutput, WorkingMemory, WorkspaceInstructionsProcessor, augmentWithInit, cleanStepResult, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, formatCheckFeedback, formatCompletionFeedback, formatStreamCompletionFeedback, formatValidationFeedback, forwardAgentStreamChunk, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getThreadOMMetadata, globalEmbeddingCache, hydrateSerializedStepErrors, isObservationalMemoryEnabled, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runStreamCompletionScorers, runValidation, setThreadOMMetadata, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepRequestContext, validateStepResumeData, validateStepStateData, validateStepSuspendData };
+//# sourceMappingURL=chunk-IYSW4VN7.js.map
+//# sourceMappingURL=chunk-IYSW4VN7.js.map