@mastra/core 1.1.0 → 1.2.0-alpha.0

package/dist/{chunk-FVVQY6UU.js → chunk-FAJYC6PA.js}

@@ -1,11 +1,11 @@
-import { extractLines, createWorkspaceTools } from './chunk-4KQEQ4NM.js';
+import { extractLines, createWorkspaceTools, BM25Index } from './chunk-NS33UC72.js';
 import { DefaultVoice } from './chunk-MQB7XFXP.js';
-import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-YEQB4VUA.js';
-import { InMemoryStore } from './chunk-H4C5NORS.js';
+import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-2QXNHEDL.js';
+import { InMemoryStore } from './chunk-OQPAOUDS.js';
 import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-HIP5W3LZ.js';
 import { parsePartialJson, isDeepEqualData, stepCountIs } from './chunk-UTLWS5LV.js';
 import { generateId, asSchema, jsonSchema, APICallError, tool } from './chunk-CPLRD2VP.js';
-import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-VAJRNUEF.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-SPVI7HCP.js';
 import { MastraLLMV1 } from './chunk-2CVY7S66.js';
 import { noopLogger } from './chunk-PSCMWPLC.js';
 import { PubSub } from './chunk-BVUMKER5.js';
@@ -601,7 +601,7 @@ function prepareToolsAndToolChoice({
   if (Object.keys(tools || {}).length === 0) {
     return {
       tools: void 0,
-      toolChoice: void 0
+      toolChoice: toolChoice === "none" ? { type: "none" } : void 0
     };
   }
   const filteredTools = activeTools != null ? Object.entries(tools || {}).filter(([name]) => activeTools.includes(name)) : Object.entries(tools || {});
@@ -5066,6 +5066,43 @@ function hydrateSerializedStepErrors(steps) {
   }
   return steps;
 }
+function cleanSingleResult(result) {
+  const { __state: _state, metadata, ...rest } = result;
+  if (metadata && typeof metadata === "object" && !Array.isArray(metadata)) {
+    const { nestedRunId: _nestedRunId, ...userMetadata } = metadata;
+    if (Object.keys(userMetadata).length > 0) {
+      return { ...rest, metadata: userMetadata };
+    }
+  }
+  return rest;
+}
+function cleanStepResult(stepResult) {
+  if (stepResult === null || stepResult === void 0) {
+    return stepResult;
+  }
+  if (typeof stepResult !== "object") {
+    return stepResult;
+  }
+  if (Array.isArray(stepResult)) {
+    return stepResult.map((item) => {
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        return cleanSingleResult(item);
+      }
+      return item;
+    });
+  }
+  const result = stepResult;
+  const cleaned = cleanSingleResult(result);
+  if (Array.isArray(cleaned.output)) {
+    cleaned.output = cleaned.output.map((item) => {
+      if (item && typeof item === "object" && !Array.isArray(item)) {
+        return cleanSingleResult(item);
+      }
+      return item;
+    });
+  }
+  return cleaned;
+}
 
 // src/workflows/handlers/control-flow.ts
 async function executeParallel(engine, params) {
@@ -7245,10 +7282,28 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
     return errorInstance.toJSON();
   }
   async fmtReturnValue(_pubsub, stepResults, lastOutput, error) {
+    const cleanStepResults = {};
+    for (const [stepId, stepResult] of Object.entries(stepResults)) {
+      if (stepResult && typeof stepResult === "object" && !Array.isArray(stepResult) && "metadata" in stepResult) {
+        const { metadata, ...rest } = stepResult;
+        if (metadata) {
+          const { nestedRunId: _nestedRunId, ...userMetadata } = metadata;
+          if (Object.keys(userMetadata).length > 0) {
+            cleanStepResults[stepId] = { ...rest, metadata: userMetadata };
+          } else {
+            cleanStepResults[stepId] = rest;
+          }
+        } else {
+          cleanStepResults[stepId] = stepResult;
+        }
+      } else {
+        cleanStepResults[stepId] = stepResult;
+      }
+    }
     const base = {
       status: lastOutput.status,
-      steps: stepResults,
-      input: stepResults.input
+      steps: cleanStepResults,
+      input: cleanStepResults.input
     };
     if (lastOutput.status === "success") {
       base.result = lastOutput.output;
@@ -9001,7 +9056,9 @@ var Workflow = class extends MastraBase {
       const stepGraph = serializedStepGraph.find((stepGraph2) => stepGraph2?.step?.id === step);
       finalSteps[step] = steps[step];
       if (stepGraph && stepGraph?.step?.component === "WORKFLOW") {
-        const nestedSteps = await this.getWorkflowRunSteps({ runId, workflowId: step });
+        const stepResult = steps[step];
+        const nestedRunId = stepResult?.metadata?.nestedRunId ?? runId;
+        const nestedSteps = await this.getWorkflowRunSteps({ runId: nestedRunId, workflowId: step });
         if (nestedSteps) {
           const updatedNestedSteps = Object.entries(nestedSteps).reduce(
             (acc, [key, value]) => {
@@ -9081,11 +9138,16 @@ var Workflow = class extends MastraBase {
     const fieldsSet = new Set(fields ?? []);
     let steps = {};
     if (includeAllFields || fieldsSet.has("steps")) {
+      let rawSteps;
       if (withNestedWorkflows) {
-        steps = await this.getWorkflowRunSteps({ runId, workflowId: this.id });
+        rawSteps = await this.getWorkflowRunSteps({ runId, workflowId: this.id });
       } else {
         const { input, ...stepsOnly } = snapshotState.context || {};
-        steps = stepsOnly;
+        rawSteps = stepsOnly;
+      }
+      const { __state: _removedTopLevelState, ...stepsWithoutTopLevelState } = rawSteps;
+      for (const [stepId, stepResult] of Object.entries(stepsWithoutTopLevelState)) {
+        steps[stepId] = cleanStepResult(stepResult);
       }
     }
     const result = {
@@ -13388,6 +13450,17 @@ var MastraLLMVNext = class extends MastraBase {
 var PRIMITIVE_TYPES = z10.enum(["agent", "workflow", "none", "tool"]);
 
 // src/loop/network/index.ts
+async function safeParseLLMJson(text) {
+  if (!text?.trim()) {
+    return null;
+  }
+  const preprocessed = escapeUnescapedControlCharsInJsonStrings(text);
+  const { value, state } = await parsePartialJson(preprocessed);
+  if (state === "successful-parse" || state === "repaired-parse") {
+    return value;
+  }
+  return null;
+}
 function filterMessagesForSubAgent(messages) {
   return messages.filter((msg) => {
     if (msg.role === "user") return true;
@@ -14211,10 +14284,8 @@ async function createNetworkLoop({
         });
         throw mastraError;
       }
-      let input;
-      try {
-        input = JSON.parse(inputData.prompt);
-      } catch {
+      const input = await safeParseLLMJson(inputData.prompt);
+      if (input === null) {
         const logger = mastra?.getLogger();
         logger?.warn(
           `Workflow execution step received invalid JSON prompt for workflow "${inputData.primitiveId}". Prompt was: "${inputData.prompt}". Returning error to routing agent for retry.`
@@ -14510,10 +14581,8 @@ async function createNetworkLoop({
         throw mastraError;
       }
       const toolId = tool2.id;
-      let inputDataToUse;
-      try {
-        inputDataToUse = JSON.parse(inputData.prompt);
-      } catch {
+      const inputDataToUse = await safeParseLLMJson(inputData.prompt);
+      if (inputDataToUse === null) {
         logger?.warn(
           `Tool execution step received invalid JSON prompt for tool "${toolId}". Prompt was: "${inputData.prompt}". Returning error to routing agent for retry.`
         );
@@ -15107,8 +15176,8 @@ async function networkLoop({
                 }
               });
               const object = await result.object;
-              const resumeDataFromLLM = JSON.parse(object.resumeData);
-              if (Object.keys(resumeDataFromLLM).length > 0) {
+              const resumeDataFromLLM = await safeParseLLMJson(object.resumeData);
+              if (resumeDataFromLLM !== null && typeof resumeDataFromLLM === "object" && Object.keys(resumeDataFromLLM).length > 0) {
                 resumeDataFromTask = resumeDataFromLLM;
                 runIdFromTask = firstSuspendedTool.runId;
               }
@@ -22590,6 +22659,289 @@ var ToolCallFilter = class {
     return messages;
   }
 };
+var TOOL_SEARCH_TOKENIZE_OPTIONS = {
+  lowercase: true,
+  removePunctuation: false,
+  minLength: 2,
+  stopwords: /* @__PURE__ */ new Set(),
+  splitPattern: /[\s\-_.,;:!?()[\]{}'"]+/
+};
+var ToolSearchProcessor = class {
+  id = "tool-search";
+  name = "Tool Search Processor";
+  description = "Enables dynamic tool discovery and loading via search";
+  allTools;
+  searchConfig;
+  ttl;
+  /** BM25 index for tool search */
+  bm25Index;
+  /** Map from tool ID to full description (for result formatting) */
+  toolDescriptions = /* @__PURE__ */ new Map();
+  /**
+   * Thread-scoped state management for loaded tools with TTL support.
+   * Instance-scoped to prevent cross-processor interference.
+   * Maps threadId -> ThreadState (tools + timestamp)
+   */
+  threadLoadedTools = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.allTools = options.tools;
+    this.searchConfig = {
+      topK: options.search?.topK ?? 5,
+      minScore: options.search?.minScore ?? 0
+    };
+    this.ttl = options.ttl ?? 36e5;
+    this.bm25Index = new BM25Index({}, TOOL_SEARCH_TOKENIZE_OPTIONS);
+    this.indexTools();
+    if (this.ttl > 0) {
+      this.scheduleCleanup();
+    }
+  }
+  /**
+   * 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 the set of loaded tool names for the current thread.
+   * Updates the lastAccessed timestamp for TTL management.
+   */
+  getLoadedToolNames(threadId) {
+    if (!this.threadLoadedTools.has(threadId)) {
+      this.threadLoadedTools.set(threadId, {
+        tools: /* @__PURE__ */ new Set(),
+        lastAccessed: Date.now()
+      });
+    }
+    const state = this.threadLoadedTools.get(threadId);
+    state.lastAccessed = Date.now();
+    return state.tools;
+  }
+  /**
+   * Get loaded tools as Tool objects for the current thread.
+   */
+  getLoadedTools(threadId) {
+    const loadedNames = this.getLoadedToolNames(threadId);
+    const loadedTools = {};
+    for (const toolName of loadedNames) {
+      const tool2 = this.allTools[toolName] || Object.values(this.allTools).find((t) => t.id === toolName);
+      if (tool2) {
+        loadedTools[toolName] = tool2;
+      }
+    }
+    return loadedTools;
+  }
+  /**
+   * Clear loaded tools for a specific thread (useful for testing).
+   *
+   * @param threadId - The thread ID to clear, or 'default' if not provided
+   */
+  clearState(threadId = "default") {
+    this.threadLoadedTools.delete(threadId);
+  }
+  /**
+   * Clear all thread state for this processor instance (useful for testing).
+   */
+  clearAllState() {
+    this.threadLoadedTools.clear();
+  }
+  /**
+   * Clean up stale thread state based on TTL.
+   * Removes threads that haven't been accessed within the TTL period.
+   *
+   * @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.threadLoadedTools.entries()) {
+      if (now - state.lastAccessed > this.ttl) {
+        this.threadLoadedTools.delete(threadId);
+        cleanedCount++;
+      }
+    }
+    return cleanedCount;
+  }
+  /**
+   * Schedule periodic cleanup of stale thread state.
+   * Runs cleanup every TTL/2 milliseconds to prevent unbounded memory growth.
+   */
+  scheduleCleanup() {
+    const cleanupInterval = Math.max(this.ttl / 2, 6e4);
+    const intervalId = setInterval(() => {
+      this.cleanupStaleState();
+    }, cleanupInterval);
+    if (intervalId.unref) {
+      intervalId.unref();
+    }
+  }
+  /**
+   * Get statistics about current thread state (useful for monitoring).
+   *
+   * @returns Object with thread count and oldest access time
+   */
+  getStateStats() {
+    if (this.threadLoadedTools.size === 0) {
+      return { threadCount: 0, oldestAccessTime: null };
+    }
+    let oldest = Date.now();
+    for (const state of this.threadLoadedTools.values()) {
+      if (state.lastAccessed < oldest) {
+        oldest = state.lastAccessed;
+      }
+    }
+    return {
+      threadCount: this.threadLoadedTools.size,
+      oldestAccessTime: oldest
+    };
+  }
+  /**
+   * Manually trigger cleanup of stale state (useful for testing and monitoring).
+   *
+   * @returns Number of threads cleaned up
+   */
+  cleanupNow() {
+    return this.cleanupStaleState();
+  }
+  /**
+   * Index all tools into the BM25 index
+   */
+  indexTools() {
+    for (const tool2 of Object.values(this.allTools)) {
+      const name = tool2.id;
+      const description = tool2.description || "";
+      this.bm25Index.add(name, `${name} ${description}`);
+      this.toolDescriptions.set(name, description);
+    }
+  }
+  /**
+   * Search for tools matching the query using BM25 ranking
+   * with name-match boosting.
+   *
+   * @param query - Search keywords
+   * @returns Array of matching tools with scores, sorted by relevance
+   */
+  searchTools(query) {
+    if (this.bm25Index.size === 0) return [];
+    const bm25Results = this.bm25Index.search(query, this.searchConfig.topK * 2, 0);
+    if (bm25Results.length === 0) return [];
+    const queryTokens = query.toLowerCase().split(/[\s\-_.,;:!?()[\]{}'"]+/).filter((t) => t.length > 1);
+    const boostedResults = bm25Results.map((result) => {
+      let score = result.score;
+      const nameLower = result.id.toLowerCase();
+      for (const term of queryTokens) {
+        if (nameLower === term) {
+          score += 5;
+        } else if (nameLower.includes(term)) {
+          score += 2;
+        }
+      }
+      return { id: result.id, score };
+    });
+    return boostedResults.sort((a, b) => b.score - a.score).filter((r) => r.score > this.searchConfig.minScore).slice(0, this.searchConfig.topK).map((r) => {
+      const description = this.toolDescriptions.get(r.id) || "";
+      return {
+        name: r.id,
+        description: description.length > 150 ? description.slice(0, 147) + "..." : description,
+        score: Math.round(r.score * 100) / 100
+      };
+    });
+  }
+  async processInputStep(args) {
+    const { tools, messageList } = args;
+    const threadId = this.getThreadId(args);
+    const loadedToolNames = this.getLoadedToolNames(threadId);
+    messageList.addSystem(
+      "To discover available tools, call search_tools with a keyword query. To add a tool to the conversation, call load_tool with the tool name. Tools must be loaded before they can be used."
+    );
+    const searchTool = createTool({
+      id: "search_tools",
+      description: "Search for available tools by keyword. Use this when you need a capability you don't currently have. Returns a list of matching tools with their names and descriptions. After finding a useful tool, use load_tool to make it available.",
+      inputSchema: z.object({
+        query: z.string().describe('Search keywords (e.g., "weather", "github issue", "database query")')
+      }),
+      outputSchema: z.object({
+        results: z.array(
+          z.object({
+            name: z.string(),
+            description: z.string(),
+            score: z.number()
+          })
+        ),
+        message: z.string()
+      }),
+      execute: async ({ query }) => {
+        const results = this.searchTools(query);
+        if (results.length === 0) {
+          return {
+            results: [],
+            message: `No tools found matching "${query}". Try different keywords.`
+          };
+        }
+        return {
+          results,
+          message: `Found ${results.length} tool(s). Use load_tool with the exact tool name to make it available.`
+        };
+      }
+    });
+    const loadTool = createTool({
+      id: "load_tool",
+      description: "Load a specific tool into your context. Call this after finding a tool with search_tools. Once loaded, the tool will be available for use. Args: toolName - The exact name of the tool to load (from search results).",
+      inputSchema: z.object({
+        toolName: z.string().describe("The exact name of the tool to load (from search results)")
+      }),
+      outputSchema: z.object({
+        success: z.boolean(),
+        message: z.string(),
+        toolName: z.string().optional()
+      }),
+      execute: async ({ toolName }) => {
+        const matchingTool = this.allTools[toolName] ?? Object.values(this.allTools).find((tool2) => tool2.id === toolName);
+        if (!matchingTool) {
+          const availableToolNames = Object.keys(this.allTools).concat(
+            Object.values(this.allTools).map((t) => t.id).filter((id) => !this.allTools[id])
+          );
+          const suggestions = availableToolNames.filter(
+            (name) => name.toLowerCase().includes(toolName.toLowerCase()) || toolName.toLowerCase().includes(name.toLowerCase())
+          );
+          let message = `Tool "${toolName}" not found.`;
+          if (suggestions.length > 0) {
+            message += ` Did you mean: ${suggestions.slice(0, 3).join(", ")}?`;
+          } else {
+            message += " Use search_tools to find available tools.";
+          }
+          return {
+            success: false,
+            message
+          };
+        }
+        if (loadedToolNames.has(toolName)) {
+          return {
+            success: true,
+            message: `Tool "${toolName}" is already loaded and available.`,
+            toolName
+          };
+        }
+        loadedToolNames.add(toolName);
+        return {
+          success: true,
+          message: `Tool "${toolName}" loaded successfully. It will be available on your next turn.`,
+          toolName
+        };
+      }
+    });
+    const loadedTools = this.getLoadedTools(threadId);
+    return {
+      tools: {
+        search_tools: searchTool,
+        load_tool: loadTool,
+        ...tools ?? {},
+        ...loadedTools
+      }
+    };
+  }
+};
 
 // src/memory/working-memory-utils.ts
 var WORKING_MEMORY_START_TAG = "<working_memory>";
@@ -24027,6 +24379,6 @@ var MockMemory = class extends MastraMemory {
   }
 };
 
-export { Agent, BaseProcessor, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, EventEmitterPubSub, 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, TripWire, UnicodeNormalizer, WORKING_MEMORY_END_TAG, WORKING_MEMORY_START_TAG, Workflow, WorkflowRunOutput, WorkingMemory, augmentWithInit, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, formatCheckFeedback, formatCompletionFeedback, formatValidationFeedback, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, globalEmbeddingCache, hydrateSerializedStepErrors, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runValidation, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepRequestContext, validateStepResumeData, validateStepStateData, validateStepSuspendData };
-//# sourceMappingURL=chunk-FVVQY6UU.js.map
-//# sourceMappingURL=chunk-FVVQY6UU.js.map
+export { Agent, BaseProcessor, BatchPartsProcessor, ChunkFrom, DefaultExecutionEngine, EventEmitterPubSub, 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, augmentWithInit, cleanStepResult, cloneStep, cloneWorkflow, convertFullStreamChunkToMastra, convertFullStreamChunkToUIMessageStream, convertMastraChunkToAISDKv5, createDeprecationProxy, createScorer, createStep, createTimeTravelExecutionParams, createWorkflow, extractWorkingMemoryContent, extractWorkingMemoryTags, formatCheckFeedback, formatCompletionFeedback, formatValidationFeedback, generateFinalResult, generateStructuredFinalResult, getResumeLabelsByStepId, getStepIds, getStepResult, getZodErrors, globalEmbeddingCache, hydrateSerializedStepErrors, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runValidation, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepRequestContext, validateStepResumeData, validateStepStateData, validateStepSuspendData };
+//# sourceMappingURL=chunk-FAJYC6PA.js.map
+//# sourceMappingURL=chunk-FAJYC6PA.js.map