@mastra/core 1.4.0 → 1.5.0-alpha.1

package/dist/{chunk-4XSAZPPS.js → chunk-A7V2NSY3.js}

@@ -1,19 +1,19 @@
-import { extractLines, createWorkspaceTools, BM25Index } from './chunk-4EHGOATH.js';
 import { DefaultVoice } from './chunk-LHRHOPUC.js';
 import { PUBSUB_SYMBOL, STREAM_FORMAT_SYMBOL } from './chunk-2QXNHEDL.js';
-import { InMemoryStore } from './chunk-7NKUSQEV.js';
-import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-AY6DBRS3.js';
+import { extractLines, createWorkspaceTools, BM25Index } from './chunk-FZ5DRHKE.js';
+import { InMemoryStore } from './chunk-YIN5F7VO.js';
+import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-OHLVZVIK.js';
 import { parsePartialJson, isDeepEqualData, stepCountIs } from './chunk-UTLWS5LV.js';
 import { generateId, asSchema, jsonSchema, APICallError, tool } from './chunk-CPLRD2VP.js';
 import { executeHook } from './chunk-L54GIUCB.js';
-import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-FLPEGTEK.js';
-import { MastraLLMV1 } from './chunk-RZ4CIIZR.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-AIRMLZ43.js';
+import { MastraLLMV1 } from './chunk-6DUTLERJ.js';
 import { noopLogger } from './chunk-PSCMWPLC.js';
 import { PubSub } from './chunk-BVUMKER5.js';
-import { isZodType, removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, selectFields, delay } from './chunk-AXHBJ4GX.js';
-import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-Y3TQ52UE.js';
+import { isZodType, removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, selectFields, delay } from './chunk-NN26FSKL.js';
+import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-33TGTTTS.js';
 import { ToolStream } from './chunk-DD2VNRQM.js';
-import { Tool, createTool } from './chunk-RS6CZXGA.js';
+import { Tool, createTool } from './chunk-BQHWJLXU.js';
 import { RequestContext, MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY } from './chunk-CCLV5CAA.js';
 import { MastraError, getErrorFromUnknown } from './chunk-FJEVLHJT.js';
 import { zodToJsonSchema } from './chunk-PJKCPRYF.js';
@@ -1282,7 +1282,7 @@ var ProcessorRunner = class _ProcessorRunner {
   /**
    * Process a stream part through all output processors with state management
    */
-  async processPart(part, processorStates, tracingContext, requestContext, messageList, retryCount = 0) {
+  async processPart(part, processorStates, tracingContext, requestContext, messageList, retryCount = 0, writer) {
     if (!this.outputProcessors.length) {
       return { part, blocked: false };
     }
@@ -1355,7 +1355,8 @@ var ProcessorRunner = class _ProcessorRunner {
               tracingContext: { currentSpan: state.span },
               requestContext,
               messageList,
-              retryCount
+              retryCount,
+              writer
             });
             processedPart = result;
             state.addOutputPart(processedPart);
@@ -1395,11 +1396,14 @@ var ProcessorRunner = class _ProcessorRunner {
       return { part, blocked: false };
     }
   }
-  async runOutputProcessorsForStream(streamResult, tracingContext) {
+  async runOutputProcessorsForStream(streamResult, tracingContext, writer) {
     return new ReadableStream({
       start: async (controller) => {
         const reader = streamResult.fullStream.getReader();
         const processorStates = /* @__PURE__ */ new Map();
+        const streamWriter = writer ?? {
+          custom: async (data) => controller.enqueue(data)
+        };
         try {
           while (true) {
             const { done, value } = await reader.read();
@@ -1413,7 +1417,7 @@ var ProcessorRunner = class _ProcessorRunner {
               reason,
               tripwireOptions,
               processorId
-            } = await this.processPart(value, processorStates, tracingContext);
+            } = await this.processPart(value, processorStates, tracingContext, void 0, void 0, 0, streamWriter);
             if (blocked) {
               void this.logger.debug(`[Agent:${this.agentName}] - Stream part blocked by output processor`, {
                 reason,
@@ -2668,6 +2672,9 @@ var MastraModelOutput = class extends MastraBase {
                   structuredOutputProcessorState.customState.controller = controller;
                 }
               }
+              const streamWriter = {
+                custom: async (data) => controller.enqueue(data)
+              };
               const {
                 part: processed,
                 blocked,
@@ -2679,7 +2686,9 @@ var MastraModelOutput = class extends MastraBase {
                 processorStates,
                 options.tracingContext,
                 options.requestContext,
-                self.messageList
+                self.messageList,
+                0,
+                streamWriter
               );
               if (blocked) {
                 controller.enqueue({
@@ -5554,7 +5563,7 @@ async function executeConditional(engine, params) {
     }
   });
   const results = await Promise.all(
-    stepsToRun.map(async (step, index) => {
+    stepsToRun.map(async (step) => {
       const currStepResult = stepResults[step.step.id];
       const isRestartStep = restart ? !!restart.activeStepsPath[step.step.id] : void 0;
       if (currStepResult && timeTravel && timeTravel.executionPath.length > 0) {
@@ -5579,7 +5588,7 @@ async function executeConditional(engine, params) {
         executionContext: {
           workflowId,
           runId,
-          executionPath: [...executionContext.executionPath, index],
+          executionPath: [...executionContext.executionPath, entry.steps.indexOf(step)],
           activeStepsPath: executionContext.activeStepsPath,
           suspendedPaths: executionContext.suspendedPaths,
           resumeLabels: executionContext.resumeLabels,
@@ -6081,6 +6090,48 @@ async function executeForeach(engine, params) {
 }
 
 // src/workflows/handlers/entry.ts
+function buildResumedBlockResult(entrySteps, stepResults, executionContext, opts) {
+  const stepsToCheck = opts?.onlyExecutedSteps ? entrySteps.filter((s) => s.type === "step" && stepResults[s.step.id] !== void 0) : entrySteps;
+  const allComplete = stepsToCheck.every((s) => {
+    if (s.type === "step") {
+      const r = stepResults[s.step.id];
+      return r && r.status === "success";
+    }
+    return true;
+  });
+  let result;
+  if (allComplete) {
+    result = {
+      status: "success",
+      output: entrySteps.reduce((acc, s) => {
+        if (s.type === "step") {
+          const r = stepResults[s.step.id];
+          if (r && r.status === "success") {
+            acc[s.step.id] = r.output;
+          }
+        }
+        return acc;
+      }, {})
+    };
+  } else {
+    const stillSuspended = entrySteps.find((s) => s.type === "step" && stepResults[s.step.id]?.status === "suspended");
+    const suspendData = stillSuspended && stillSuspended.type === "step" ? stepResults[stillSuspended.step.id]?.suspendPayload : {};
+    result = {
+      status: "suspended",
+      payload: suspendData,
+      suspendPayload: suspendData,
+      suspendedAt: Date.now()
+    };
+  }
+  if (result.status === "suspended") {
+    entrySteps.forEach((s, stepIndex) => {
+      if (s.type === "step" && stepResults[s.step.id]?.status === "suspended") {
+        executionContext.suspendedPaths[s.step.id] = [...executionContext.executionPath, stepIndex];
+      }
+    });
+  }
+  return result;
+}
 async function persistStepUpdate(engine, params) {
   const {
     workflowId,
@@ -6209,49 +6260,7 @@ async function executeEntry(engine, params) {
     });
     engine.applyMutableContext(executionContext, resumedStepResult.mutableContext);
     Object.assign(stepResults, resumedStepResult.stepResults);
-    const allParallelStepsComplete = entry.steps.every((parallelStep) => {
-      if (parallelStep.type === "step") {
-        const stepResult = stepResults[parallelStep.step.id];
-        return stepResult && stepResult.status === "success";
-      }
-      return true;
-    });
-    if (allParallelStepsComplete) {
-      execResults = {
-        status: "success",
-        output: entry.steps.reduce((acc, parallelStep) => {
-          if (parallelStep.type === "step") {
-            const stepResult = stepResults[parallelStep.step.id];
-            if (stepResult && stepResult.status === "success") {
-              acc[parallelStep.step.id] = stepResult.output;
-            }
-          }
-          return acc;
-        }, {})
-      };
-    } else {
-      const stillSuspended = entry.steps.find((parallelStep) => {
-        if (parallelStep.type === "step") {
-          const stepResult = stepResults[parallelStep.step.id];
-          return stepResult && stepResult.status === "suspended";
-        }
-        return false;
-      });
-      execResults = {
-        status: "suspended",
-        payload: stillSuspended && stillSuspended.type === "step" ? stepResults[stillSuspended.step.id]?.suspendPayload : {}
-      };
-    }
-    if (execResults.status === "suspended") {
-      entry.steps.forEach((parallelStep, stepIndex) => {
-        if (parallelStep.type === "step") {
-          const stepResult = stepResults[parallelStep.step.id];
-          if (stepResult && stepResult.status === "suspended") {
-            executionContext.suspendedPaths[parallelStep.step.id] = [...executionContext.executionPath, stepIndex];
-          }
-        }
-      });
-    }
+    execResults = buildResumedBlockResult(entry.steps, stepResults, executionContext);
     return {
       result: execResults,
       stepResults,
@@ -6278,6 +6287,79 @@ async function executeEntry(engine, params) {
       disableScorers,
       perStep
     });
+  } else if (resume?.resumePath?.length && entry.type === "conditional") {
+    const idx = resume.resumePath.shift();
+    const branchStep = entry.steps[idx];
+    let branchResult;
+    if (branchStep.type !== "step") {
+      branchResult = await executeEntry(engine, {
+        workflowId,
+        runId,
+        resourceId,
+        entry: branchStep,
+        prevStep,
+        serializedStepGraph,
+        stepResults,
+        resume,
+        executionContext: {
+          workflowId,
+          runId,
+          executionPath: [...executionContext.executionPath, idx],
+          suspendedPaths: executionContext.suspendedPaths,
+          resumeLabels: executionContext.resumeLabels,
+          retryConfig: executionContext.retryConfig,
+          activeStepsPath: executionContext.activeStepsPath,
+          state: executionContext.state
+        },
+        tracingContext,
+        pubsub,
+        abortController,
+        requestContext,
+        outputWriter,
+        disableScorers,
+        perStep
+      });
+    } else {
+      const resumePrevOutput = stepResults[branchStep.step.id]?.payload ?? prevOutput;
+      branchResult = await engine.executeStep({
+        workflowId,
+        runId,
+        resourceId,
+        step: branchStep.step,
+        prevOutput: resumePrevOutput,
+        stepResults,
+        serializedStepGraph,
+        resume,
+        restart,
+        timeTravel,
+        executionContext: {
+          workflowId,
+          runId,
+          executionPath: [...executionContext.executionPath, idx],
+          suspendedPaths: executionContext.suspendedPaths,
+          resumeLabels: executionContext.resumeLabels,
+          retryConfig: executionContext.retryConfig,
+          activeStepsPath: executionContext.activeStepsPath,
+          state: executionContext.state
+        },
+        tracingContext,
+        pubsub,
+        abortController,
+        requestContext,
+        outputWriter,
+        disableScorers,
+        perStep
+      });
+    }
+    engine.applyMutableContext(executionContext, branchResult.mutableContext);
+    Object.assign(stepResults, branchResult.stepResults);
+    execResults = buildResumedBlockResult(entry.steps, stepResults, executionContext, { onlyExecutedSteps: true });
+    return {
+      result: execResults,
+      stepResults,
+      mutableContext: engine.buildMutableContext(executionContext),
+      requestContext: branchResult.requestContext
+    };
   } else if (entry.type === "conditional") {
     execResults = await engine.executeConditional({
       workflowId,
@@ -11750,16 +11832,6 @@ Analyse the suspended tools: ${JSON.stringify(suspendedTools)}, using the messag
     }
   });
 }
-
-// src/loop/workflows/errors.ts
-var ToolNotFoundError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ToolNotFoundError";
-  }
-};
-
-// src/loop/workflows/agentic-execution/llm-mapping-step.ts
 function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep) {
   const processorRunner = rest.outputProcessors?.length && rest.logger ? new ProcessorRunner({
     inputProcessors: [],
@@ -11769,6 +11841,7 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
     processorStates: rest.processorStates
   }) : void 0;
   const tracingContext = rest.modelSpanTracker?.getTracingContext();
+  const streamWriter = rest.outputWriter ? { custom: async (data) => rest.outputWriter(data) } : void 0;
   async function processAndEnqueueChunk(chunk) {
     if (processorRunner && rest.processorStates) {
       const {
@@ -11782,7 +11855,9 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
         rest.processorStates,
         tracingContext,
         rest.requestContext,
-        rest.messageList
+        rest.messageList,
+        0,
+        streamWriter
       );
       if (blocked) {
         rest.controller.enqueue({
@@ -11794,13 +11869,16 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
             processorId
           }
         });
-        return;
+        return null;
       }
       if (processed) {
         rest.controller.enqueue(processed);
+        return processed;
       }
+      return null;
     } else {
       rest.controller.enqueue(chunk);
+      return chunk;
     }
   }
   return createStep({
@@ -11809,6 +11887,20 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
     outputSchema: llmIterationOutputSchema,
     execute: async ({ inputData, getStepResult: getStepResult2, bail }) => {
       const initialResult = getStepResult2(llmExecutionStep);
+      async function getProviderMetadataWithModelOutput(toolCall) {
+        const tool2 = rest.tools?.[toolCall.toolName];
+        let modelOutput;
+        if (tool2?.toModelOutput && toolCall.result != null) {
+          modelOutput = await tool2.toModelOutput(toolCall.result);
+        }
+        const existingMastra = toolCall.providerMetadata?.mastra;
+        const providerMetadata = {
+          ...toolCall.providerMetadata,
+          ...modelOutput != null ? { mastra: { ...existingMastra, modelOutput } } : {}
+        };
+        const hasMetadata = Object.keys(providerMetadata).length > 0;
+        return hasMetadata ? providerMetadata : void 0;
+      }
       if (inputData?.some((toolCall) => toolCall?.result === void 0)) {
         const errorResults = inputData.filter((toolCall) => toolCall?.error);
         const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
@@ -11826,7 +11918,8 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
                 providerMetadata: toolCall.providerMetadata
               }
             };
-            await processAndEnqueueChunk(chunk);
+            const processed = await processAndEnqueueChunk(chunk);
+            if (processed) await rest.options?.onChunk?.(processed);
           }
           const msg = {
             id: toolResultMessageId || "",
@@ -11851,9 +11944,8 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
           };
           rest.messageList.add(msg, "response");
         }
-        const allErrorsAreToolNotFound = errorResults?.length > 0 && errorResults.every((tc) => tc.error instanceof ToolNotFoundError);
         const hasPendingHITL = inputData.some((tc) => tc.result === void 0 && !tc.error);
-        if (allErrorsAreToolNotFound && !hasPendingHITL) {
+        if (errorResults?.length > 0 && !hasPendingHITL) {
           const successfulResults = inputData.filter((tc) => tc.result !== void 0);
           if (successfulResults.length) {
             for (const toolCall of successfulResults) {
@@ -11870,7 +11962,8 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
                   providerExecuted: toolCall.providerExecuted
                 }
               };
-              await processAndEnqueueChunk(chunk);
+              const processed = await processAndEnqueueChunk(chunk);
+              if (processed) await rest.options?.onChunk?.(processed);
             }
             const successMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
             const successMessage = {
@@ -11878,17 +11971,22 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
               role: "assistant",
               content: {
                 format: 2,
-                parts: successfulResults.map((toolCall) => ({
-                  type: "tool-invocation",
-                  toolInvocation: {
-                    state: "result",
-                    toolCallId: toolCall.toolCallId,
-                    toolName: toolCall.toolName,
-                    args: toolCall.args,
-                    result: toolCall.result
-                  },
-                  ...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
-                }))
+                parts: await Promise.all(
+                  successfulResults.map(async (toolCall) => {
+                    const providerMetadata = await getProviderMetadataWithModelOutput(toolCall);
+                    return {
+                      type: "tool-invocation",
+                      toolInvocation: {
+                        state: "result",
+                        toolCallId: toolCall.toolCallId,
+                        toolName: toolCall.toolName,
+                        args: toolCall.args,
+                        result: toolCall.result
+                      },
+                      ...providerMetadata ? { providerMetadata } : {}
+                    };
+                  })
+                )
               },
               createdAt: /* @__PURE__ */ new Date()
             };
@@ -11932,14 +12030,8 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
               providerExecuted: toolCall.providerExecuted
             }
           };
-          await processAndEnqueueChunk(chunk);
-          if (supportedLanguageModelSpecifications.includes(initialResult?.metadata?.modelVersion)) {
-            await rest.options?.onChunk?.({
-              chunk: convertMastraChunkToAISDKv5({
-                chunk
-              })
-            });
-          }
+          const processed = await processAndEnqueueChunk(chunk);
+          if (processed) await rest.options?.onChunk?.(processed);
         }
         const toolResultMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
         const toolResultMessage = {
@@ -11947,19 +12039,22 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
           role: "assistant",
           content: {
             format: 2,
-            parts: inputData.map((toolCall) => {
-              return {
-                type: "tool-invocation",
-                toolInvocation: {
-                  state: "result",
-                  toolCallId: toolCall.toolCallId,
-                  toolName: toolCall.toolName,
-                  args: toolCall.args,
-                  result: toolCall.result
-                },
-                ...toolCall.providerMetadata ? { providerMetadata: toolCall.providerMetadata } : {}
-              };
-            })
+            parts: await Promise.all(
+              inputData.map(async (toolCall) => {
+                const providerMetadata = await getProviderMetadataWithModelOutput(toolCall);
+                return {
+                  type: "tool-invocation",
+                  toolInvocation: {
+                    state: "result",
+                    toolCallId: toolCall.toolCallId,
+                    toolName: toolCall.toolName,
+                    args: toolCall.args,
+                    result: toolCall.result
+                  },
+                  ...providerMetadata ? { providerMetadata } : {}
+                };
+              })
+            )
           },
           createdAt: /* @__PURE__ */ new Date()
         };
@@ -11977,6 +12072,16 @@ function createLLMMappingStep({ models, _internal, ...rest }, llmExecutionStep)
     }
   });
 }
+
+// src/loop/workflows/errors.ts
+var ToolNotFoundError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolNotFoundError";
+  }
+};
+
+// src/loop/workflows/agentic-execution/tool-call-step.ts
 function createToolCallStep({
   tools,
   messageList,
@@ -12237,7 +12342,8 @@ function createToolCallStep({
         } else if (isResumeToolCall) {
           await removeToolMetadata(inputData.toolName, "suspension");
         }
-        const resumeDataToPassToToolOptions = toolRequiresApproval && Object.keys(resumeData).length === 1 && "approved" in resumeData ? void 0 : resumeData;
+        const isAgentTool = inputData.toolName?.startsWith("agent-");
+        const resumeDataToPassToToolOptions = !isAgentTool && toolRequiresApproval && Object.keys(resumeData).length === 1 && "approved" in resumeData ? void 0 : resumeData;
         const toolOptions = {
           abortSignal: options?.abortSignal,
           toolCallId: inputData.toolCallId,
@@ -12247,6 +12353,8 @@ function createToolCallStep({
           tracingContext: modelSpanTracker?.getTracingContext(),
           // Pass workspace from _internal (set by llmExecutionStep via prepareStep/processInputStep)
           workspace: _internal?.stepWorkspace,
+          // Forward requestContext so tools receive values set by the workflow step
+          requestContext,
           suspend: async (suspendPayload, options2) => {
             if (options2?.requireToolApproval) {
               controller.enqueue({
@@ -12336,7 +12444,7 @@ function createToolCallStep({
           },
           resumeData: resumeDataToPassToToolOptions
         };
-        if (resumeDataToPassToToolOptions && inputData.toolName?.startsWith("agent-") && !isResumeToolCall) {
+        if (resumeDataToPassToToolOptions && isAgentTool && !isResumeToolCall) {
           let suspendedToolRunId = "";
           const messages = messageList.get.all.db();
           const assistantMessages = [...messages].reverse().filter((message) => message.role === "assistant");
@@ -12668,13 +12776,14 @@ function workflowLoopStream({
       const run = await agenticLoopWorkflow.createRun({
         runId
       });
-      const requestContext = new RequestContext();
+      const requestContext = rest.requestContext ?? new RequestContext();
       if (requireToolApproval) {
         requestContext.set("__mastra_requireToolApproval", true);
       }
       const executionResult = resumeContext ? await run.resume({
         resumeData: resumeContext.resumeData,
         tracingContext: rest.modelSpanTracker?.getTracingContext(),
+        requestContext,
         label: toolCallId
       }) : await run.start({
         inputData: initialData,
@@ -14548,12 +14657,11 @@ async function createNetworkLoop({
                 }
               ],
               format: 2,
-              ...requireApprovalMetadata || suspendedTools ? {
-                metadata: {
-                  ...requireApprovalMetadata ? { requireApprovalMetadata } : {},
-                  ...suspendedTools ? { suspendedTools } : {}
-                }
-              } : {}
+              metadata: {
+                mode: "network",
+                ...requireApprovalMetadata ? { requireApprovalMetadata } : {},
+                ...suspendedTools ? { suspendedTools } : {}
+              }
             },
             createdAt: /* @__PURE__ */ new Date(),
             threadId: initData?.threadId || runId,
@@ -14832,8 +14940,9 @@ async function createNetworkLoop({
             content: {
               parts: [{ type: "text", text: finalResult }],
               format: 2,
-              ...suspendPayload ? {
-                metadata: {
+              metadata: {
+                mode: "network",
+                ...suspendPayload ? {
                   suspendedTools: {
                     [inputData.primitiveId]: {
                       args: input,
@@ -14848,8 +14957,8 @@ async function createNetworkLoop({
                       toolCallId: inputData.primitiveId
                     }
                   }
-                }
-              } : {}
+                } : {}
+              }
             },
             createdAt: /* @__PURE__ */ new Date(),
             threadId: initData?.threadId || runId,
@@ -15141,7 +15250,10 @@ async function createNetworkLoop({
                         })
                       }
                     ],
-                    format: 2
+                    format: 2,
+                    metadata: {
+                      mode: "network"
+                    }
                   },
                   createdAt: /* @__PURE__ */ new Date(),
                   threadId: initData.threadId || runId,
@@ -15306,7 +15418,10 @@ async function createNetworkLoop({
                     })
                   }
                 ],
-                format: 2
+                format: 2,
+                metadata: {
+                  mode: "network"
+                }
               },
               createdAt: /* @__PURE__ */ new Date(),
               threadId: initData.threadId || runId,
@@ -15353,7 +15468,10 @@ async function createNetworkLoop({
                   })
                 }
               ],
-              format: 2
+              format: 2,
+              metadata: {
+                mode: "network"
+              }
             },
             createdAt: /* @__PURE__ */ new Date(),
             threadId: initData.threadId || runId,
@@ -16366,6 +16484,17 @@ ${skillInstructions}`;
     });
   }
   // ===========================================================================
+  // Helpers
+  // ===========================================================================
+  /**
+   * Mark a tool as never requiring approval.
+   * Skill tools are internal plumbing and should bypass requireToolApproval.
+   */
+  withNoApproval(tool2) {
+    tool2.needsApprovalFn = () => false;
+    return tool2;
+  }
+  // ===========================================================================
   // Processor Interface
   // ===========================================================================
   /**
@@ -16401,13 +16530,13 @@ ${skillInstructions}`;
     }
     const skillTools = {};
     if (hasSkills) {
-      skillTools["skill-activate"] = this.createSkillActivateTool();
-      skillTools["skill-search"] = this.createSkillSearchTool();
+      skillTools["skill-activate"] = this.withNoApproval(this.createSkillActivateTool());
+      skillTools["skill-search"] = this.withNoApproval(this.createSkillSearchTool());
     }
     if (this._activatedSkills.size > 0) {
-      skillTools["skill-read-reference"] = this.createSkillReadReferenceTool();
-      skillTools["skill-read-script"] = this.createSkillReadScriptTool();
-      skillTools["skill-read-asset"] = this.createSkillReadAssetTool();
+      skillTools["skill-read-reference"] = this.withNoApproval(this.createSkillReadReferenceTool());
+      skillTools["skill-read-script"] = this.withNoApproval(this.createSkillReadScriptTool());
+      skillTools["skill-read-asset"] = this.withNoApproval(this.createSkillReadAssetTool());
     }
     return {
       messageList,
@@ -16686,7 +16815,7 @@ var AgentLegacyHandler = class {
               model: titleModel,
               instructions: titleInstructions
             } = this.capabilities.resolveTitleGenerationConfig(config?.generateTitle);
-            if (shouldGenerate && !threadExists && userMessage) {
+            if (shouldGenerate && !thread2.title && userMessage) {
               promises.push(
                 this.capabilities.genTitle(userMessage, requestContext, { currentSpan: agentSpan }, titleModel, titleInstructions).then((title) => {
                   if (title) {
@@ -17658,6 +17787,7 @@ var coreToolSchema = z.object({
   ]),
   outputSchema: z.union([z.record(z.string(), z.any()), z.any()]).optional(),
   execute: z.optional(z.function(z.tuple([z.any(), z.any()]), z.promise(z.any()))),
+  toModelOutput: z.optional(z.function(z.tuple([z.any()]), z.any())),
   type: z.union([z.literal("function"), z.literal("provider-defined"), z.undefined()]).optional(),
   args: z.record(z.string(), z.any()).optional()
 });
@@ -19291,7 +19421,7 @@ ${errorMessages}`,
           });
         }
       }
-      return `New Thread ${(/* @__PURE__ */ new Date()).toISOString()}`;
+      return void 0;
     } catch (e) {
       this.logger.error("Error generating title:", e);
       return void 0;
@@ -19300,6 +19430,13 @@ ${errorMessages}`,
   __setMemory(memory) {
     this.#memory = memory;
   }
+  __setWorkspace(workspace) {
+    this.#workspace = workspace;
+    if (this.#mastra && workspace && typeof workspace !== "function") {
+      workspace.__setLogger(this.logger);
+      this.#mastra.addWorkspace(workspace);
+    }
+  }
   /**
    * Retrieves and converts memory tools to CoreTool format.
    * @internal
@@ -19698,6 +19835,7 @@ ${errorMessages}`,
           // manually wrap agent tools with tracing, so that we can pass the
           // current tool span onto the agent to maintain continuity of the trace
           execute: async (inputData, context) => {
+            const savedMastraMemory = requestContext.get("MastraMemory");
             try {
               this.logger.debug(`[Agent:${this.name}] - Executing agent as tool ${agentName}`, {
                 name: agentName,
@@ -19846,8 +19984,14 @@ ${errorMessages}`,
                 }
                 result = { text: fullText };
               }
+              if (savedMastraMemory !== void 0) {
+                requestContext.set("MastraMemory", savedMastraMemory);
+              }
               return result;
             } catch (err) {
+              if (savedMastraMemory !== void 0) {
+                requestContext.set("MastraMemory", savedMastraMemory);
+              }
               const mastraError = new MastraError(
                 {
                   id: "AGENT_AGENT_TOOL_EXECUTION_FAILED",
@@ -20168,7 +20312,7 @@ ${errorMessages}`,
       mastraProxy,
       autoResumeSuspendedTools
     });
-    return this.formatTools({
+    const allTools = {
       ...assignedTools,
       ...memoryTools,
       ...toolsetTools,
@@ -20176,7 +20320,8 @@ ${errorMessages}`,
       ...agentTools,
       ...workflowTools,
       ...workspaceTools
-    });
+    };
+    return this.formatTools(allTools);
   }
   /**
    * Formats and validates tool names to comply with naming restrictions.
@@ -20639,7 +20784,7 @@ ${errorMessages}`,
           model: titleModel,
           instructions: titleInstructions
         } = this.resolveTitleGenerationConfig(config.generateTitle);
-        if (shouldGenerate && !threadExists) {
+        if (shouldGenerate && !thread.title) {
           const userMessage = this.getMostRecentUserMessage(messageList.get.all.ui());
           if (userMessage) {
             const title = await this.genTitle(
@@ -24513,6 +24658,35 @@ https://mastra.ai/en/docs/memory/overview`
   listTools(_config) {
     return {};
   }
+  /**
+   * Cached promise for the embedding dimension probe.
+   * Stored as a promise to deduplicate concurrent calls.
+   */
+  _embeddingDimensionPromise;
+  /**
+   * Probe the embedder to determine its actual output dimension.
+   * The result is cached so subsequent calls are free.
+   */
+  async getEmbeddingDimension() {
+    if (!this.embedder) return void 0;
+    if (!this._embeddingDimensionPromise) {
+      this._embeddingDimensionPromise = (async () => {
+        try {
+          const result = await this.embedder.doEmbed({
+            values: ["a"],
+            ...this.embedderOptions || {}
+          });
+          return result.embeddings[0]?.length;
+        } catch (e) {
+          console.warn(
+            `[Mastra Memory] Failed to probe embedder for dimension, falling back to default. This may cause index name mismatches if the embedder uses non-default dimensions. Error: ${e}`
+          );
+          return void 0;
+        }
+      })();
+    }
+    return this._embeddingDimensionPromise;
+  }
   /**
    * Get the index name for semantic recall embeddings.
    * This is used to ensure consistency between the Memory class and SemanticRecall processor.
@@ -24585,7 +24759,7 @@ https://mastra.ai/en/docs/memory/overview`
         source: "memory",
         resourceId
       }),
-      title: title || `New Thread ${(/* @__PURE__ */ new Date()).toISOString()}`,
+      title: title || "",
       resourceId,
       createdAt: /* @__PURE__ */ new Date(),
       updatedAt: /* @__PURE__ */ new Date(),
@@ -24702,7 +24876,8 @@ https://mastra.ai/en/docs/memory/overview`
       const hasSemanticRecall = configuredProcessors.some((p) => !isProcessorWorkflow(p) && p.id === "semantic-recall");
       if (!hasSemanticRecall) {
         const semanticConfig = typeof effectiveConfig.semanticRecall === "object" ? effectiveConfig.semanticRecall : {};
-        const indexName = this.getEmbeddingIndexName();
+        const embeddingDimension = await this.getEmbeddingDimension();
+        const indexName = this.getEmbeddingIndexName(embeddingDimension);
         processors.push(
           new SemanticRecall({
             storage: memoryStore,
@@ -24760,7 +24935,8 @@ https://mastra.ai/en/docs/memory/overview`
       const hasSemanticRecall = configuredProcessors.some((p) => !isProcessorWorkflow(p) && p.id === "semantic-recall");
       if (!hasSemanticRecall) {
         const semanticRecallConfig = typeof effectiveConfig.semanticRecall === "object" ? effectiveConfig.semanticRecall : {};
-        const indexName = this.getEmbeddingIndexName();
+        const embeddingDimension = await this.getEmbeddingDimension();
+        const indexName = this.getEmbeddingIndexName(embeddingDimension);
         processors.push(
           new SemanticRecall({
             storage: memoryStore,
@@ -25109,5 +25285,5 @@ 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, 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, getThreadOMMetadata, getZodErrors, globalEmbeddingCache, hydrateSerializedStepErrors, isObservationalMemoryEnabled, isProcessor, isProcessorWorkflow, isSupportedLanguageModel, loop, mapVariable, memoryDefaultOptions, parseMemoryRequestContext, removeWorkingMemoryTags, resolveThreadIdFromArgs, runChecks, runCompletionScorers, runCountDeprecationMessage, runDefaultCompletionCheck, runValidation, setThreadOMMetadata, supportedLanguageModelSpecifications, tryGenerateWithJsonFallback, tryStreamWithJsonFallback, validateStepInput, validateStepRequestContext, validateStepResumeData, validateStepStateData, validateStepSuspendData };
-//# sourceMappingURL=chunk-4XSAZPPS.js.map
-//# sourceMappingURL=chunk-4XSAZPPS.js.map
+//# sourceMappingURL=chunk-A7V2NSY3.js.map
+//# sourceMappingURL=chunk-A7V2NSY3.js.map