@mastra/core 1.3.0 → 1.4.0

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

@@ -1,19 +1,19 @@
-import { extractLines, createWorkspaceTools, BM25Index } from './chunk-2GWTJFVM.js';
+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-JNE2ABVB.js';
-import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-ILQXPZCD.js';
+import { InMemoryStore } from './chunk-7NKUSQEV.js';
+import { MessageList, coreContentToString, DefaultGeneratedFile, DefaultGeneratedFileWithType } from './chunk-AY6DBRS3.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-BXLLXTT4.js';
-import { MastraLLMV1 } from './chunk-VM25PDSW.js';
+import { executeHook } from './chunk-L54GIUCB.js';
+import { resolveModelConfig, ModelRouterEmbeddingModel, ModelRouterLanguageModel } from './chunk-FLPEGTEK.js';
+import { MastraLLMV1 } from './chunk-RZ4CIIZR.js';
 import { noopLogger } from './chunk-PSCMWPLC.js';
 import { PubSub } from './chunk-BVUMKER5.js';
-import { executeHook } from './chunk-L54GIUCB.js';
-import { isZodType, removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, selectFields, delay } from './chunk-ZHFM7HCQ.js';
+import { isZodType, removeUndefinedValues, ensureToolProperties, makeCoreTool, createMastraProxy, deepMerge, selectFields, delay } from './chunk-AXHBJ4GX.js';
+import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-Y3TQ52UE.js';
 import { ToolStream } from './chunk-DD2VNRQM.js';
 import { Tool, createTool } from './chunk-RS6CZXGA.js';
-import { getOrCreateSpan, wrapMastra, executeWithContextSync } from './chunk-Y3TQ52UE.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';
@@ -990,6 +990,45 @@ function resolveThreadIdFromArgs(args) {
   if (args?.threadId) return { id: args.threadId };
   return void 0;
 }
+var CLAUDE_46_PATTERN = /[^0-9]4[.-]6/;
+function isMaybeClaude46(model) {
+  if (typeof model === "function") return true;
+  if (Array.isArray(model)) {
+    return model.some((m) => isMaybeClaude46(m.model ?? m));
+  }
+  if (typeof model === "string") {
+    return model.startsWith("anthropic") && CLAUDE_46_PATTERN.test(model);
+  }
+  if (model && typeof model === "object" && "provider" in model && "modelId" in model) {
+    const { provider, modelId } = model;
+    return provider.startsWith("anthropic") && CLAUDE_46_PATTERN.test(modelId);
+  }
+  return true;
+}
+var TrailingAssistantGuard = class {
+  id = "trailing-assistant-guard";
+  name = "Trailing Assistant Guard";
+  processInputStep({ messages, structuredOutput }) {
+    const willUseResponseFormat = structuredOutput?.schema && !structuredOutput?.model && !structuredOutput?.jsonPromptInjection;
+    if (!willUseResponseFormat) return;
+    const lastMessage = messages[messages.length - 1];
+    if (!lastMessage || lastMessage.role !== "assistant") return;
+    return {
+      messages: [
+        ...messages,
+        {
+          id: randomUUID(),
+          role: "user",
+          content: {
+            format: 2,
+            parts: [{ type: "text", text: "Generate the structured response." }]
+          },
+          createdAt: /* @__PURE__ */ new Date()
+        }
+      ]
+    };
+  }
+};
 
 // src/processors/runner.ts
 var ProcessorState = class {
@@ -1117,11 +1156,23 @@ var ProcessorRunner = class _ProcessorRunner {
       );
     }
     if (result.status !== "success") {
+      const details = [];
+      if (result.status === "failed") {
+        if (result.error) {
+          details.push(result.error.message || JSON.stringify(result.error));
+        }
+        for (const [stepId, step] of Object.entries(result.steps)) {
+          if (step.status === "failed" && step.error?.message) {
+            details.push(`step ${stepId}: ${step.error.message}`);
+          }
+        }
+      }
+      const detailStr = details.length > 0 ? ` \u2014 ${details.join("; ")}` : "";
       throw new MastraError({
         category: "USER",
         domain: "AGENT",
         id: "PROCESSOR_WORKFLOW_FAILED",
-        text: `Processor workflow ${workflow.id} failed with status: ${result.status}`
+        text: `Processor workflow ${workflow.id} failed with status: ${result.status}${detailStr}`
       });
     }
     const output = result.result;
@@ -1541,7 +1592,8 @@ var ProcessorRunner = class _ProcessorRunner {
       structuredOutput: args.structuredOutput,
       retryCount: args.retryCount ?? 0
     };
-    for (const [index, processorOrWorkflow] of this.inputProcessors.entries()) {
+    const processors = stepInput.model && isMaybeClaude46(stepInput.model) ? [...this.inputProcessors, new TrailingAssistantGuard()] : this.inputProcessors;
+    for (const [index, processorOrWorkflow] of processors.entries()) {
       const processableMessages = messageList.get.all.db();
       const idsBeforeProcessing = processableMessages.map((m) => m.id);
       const check = messageList.makeMessageSourceChecker();
@@ -5823,6 +5875,8 @@ async function executeForeach(engine, params) {
   const prevForeachOutput = prevPayload?.suspendPayload?.__workflow_meta?.foreachOutput || [];
   const prevResumeLabels = prevPayload?.suspendPayload?.__workflow_meta?.resumeLabels || {};
   const resumeLabels = getResumeLabelsByStepId(prevResumeLabels, step.id);
+  const totalCount = prevOutput.length;
+  let completedCount = 0;
   for (let i = 0; i < prevOutput.length; i += concurrency) {
     const items = prevOutput.slice(i, i + concurrency);
     const itemsResults = await Promise.all(
@@ -5873,7 +5927,36 @@ async function executeForeach(engine, params) {
         const execResults = { status, error, suspendPayload, suspendedAt, endedAt, output };
         if (execResults.status === "suspended") {
           foreachIndexObj[i + resultIndex] = execResults;
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: {
+              type: "workflow-step-progress",
+              payload: {
+                id: step.id,
+                completedCount,
+                totalCount,
+                currentIndex: i + resultIndex,
+                iterationStatus: "suspended"
+              }
+            }
+          });
         } else {
+          completedCount++;
+          await pubsub.publish(`workflow.events.v2.${runId}`, {
+            type: "watch",
+            runId,
+            data: {
+              type: "workflow-step-progress",
+              payload: {
+                id: step.id,
+                completedCount,
+                totalCount,
+                currentIndex: i + resultIndex,
+                iterationStatus: "failed"
+              }
+            }
+          });
           await pubsub.publish(`workflow.events.v2.${runId}`, {
             type: "watch",
             runId,
@@ -5899,6 +5982,22 @@ async function executeForeach(engine, params) {
           return result;
         }
       } else {
+        completedCount++;
+        await pubsub.publish(`workflow.events.v2.${runId}`, {
+          type: "watch",
+          runId,
+          data: {
+            type: "workflow-step-progress",
+            payload: {
+              id: step.id,
+              completedCount,
+              totalCount,
+              currentIndex: i + resultIndex,
+              iterationStatus: "success",
+              iterationOutput: result?.output
+            }
+          }
+        });
         const indexResumeLabel = Object.keys(resumeLabels).find(
           (key) => resumeLabels[key]?.foreachIndex === i + resultIndex
         );
@@ -11052,6 +11151,7 @@ function executeStreamWithFallbackModels(models, logger) {
     let index = 0;
     let finalResult;
     let done = false;
+    let lastError;
     for (const modelConfig of models) {
       index++;
       const maxRetries = modelConfig.maxRetries || 0;
@@ -11070,6 +11170,7 @@ function executeStreamWithFallbackModels(models, logger) {
           if (err instanceof TripWire) {
             throw err;
           }
+          lastError = err;
           attempt++;
           logger?.error(`Error executing model ${modelConfig.model.modelId}, attempt ${attempt}====`, err);
           if (attempt > maxRetries) {
@@ -11081,8 +11182,10 @@ function executeStreamWithFallbackModels(models, logger) {
       }
     }
     if (typeof finalResult === "undefined") {
-      logger?.error("Exhausted all fallback models and reached the maximum number of retries.");
-      throw new Error("Exhausted all fallback models and reached the maximum number of retries.");
+      const lastErrMsg = lastError instanceof Error ? lastError.message : String(lastError);
+      const errorMessage = `Exhausted all fallback models and reached the maximum number of retries. Last error: ${lastErrMsg}`;
+      logger?.error(errorMessage);
+      throw new Error(errorMessage, { cause: lastError });
     }
     return finalResult;
   };
@@ -11647,6 +11750,16 @@ 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: [],
@@ -11738,6 +11851,60 @@ 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) {
+          const successfulResults = inputData.filter((tc) => tc.result !== void 0);
+          if (successfulResults.length) {
+            for (const toolCall of successfulResults) {
+              const chunk = {
+                type: "tool-result",
+                runId: rest.runId,
+                from: "AGENT" /* AGENT */,
+                payload: {
+                  args: toolCall.args,
+                  toolCallId: toolCall.toolCallId,
+                  toolName: toolCall.toolName,
+                  result: toolCall.result,
+                  providerMetadata: toolCall.providerMetadata,
+                  providerExecuted: toolCall.providerExecuted
+                }
+              };
+              await processAndEnqueueChunk(chunk);
+            }
+            const successMessageId = rest.experimental_generateMessageId?.() || _internal?.generateId?.();
+            const successMessage = {
+              id: successMessageId || "",
+              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 } : {}
+                }))
+              },
+              createdAt: /* @__PURE__ */ new Date()
+            };
+            rest.messageList.add(successMessage, "response");
+          }
+          initialResult.stepResult.isContinued = true;
+          initialResult.stepResult.reason = "tool-calls";
+          return {
+            ...initialResult,
+            messages: {
+              all: rest.messageList.get.all.aiV5.model(),
+              user: rest.messageList.get.input.aiV5.model(),
+              nonUser: rest.messageList.get.response.aiV5.model()
+            }
+          };
+        }
         if (initialResult.stepResult.reason !== "retry") {
           initialResult.stepResult.isContinued = false;
         }
@@ -11963,7 +12130,14 @@ function createToolCallStep({
         };
       }
       if (!tool2) {
-        throw new Error(`Tool ${inputData.toolName} not found`);
+        const availableToolNames = Object.keys(stepTools || {});
+        const availableToolsStr = availableToolNames.length > 0 ? ` Available tools: ${availableToolNames.join(", ")}` : "";
+        return {
+          error: new ToolNotFoundError(
+            `Tool "${inputData.toolName}" not found.${availableToolsStr}. Call tools by their exact name only \u2014 never add prefixes, namespaces, or colons.`
+          ),
+          ...inputData
+        };
       }
       if (tool2 && "onInputAvailable" in tool2) {
         try {
@@ -16197,9 +16371,9 @@ ${skillInstructions}`;
   /**
    * Process input step - inject available skills and provide skill tools
    */
-  async processInputStep({ messageList, tools, stepNumber }) {
+  async processInputStep({ messageList, tools, stepNumber, requestContext }) {
     if (stepNumber === 0) {
-      await this.skills?.maybeRefresh();
+      await this.skills?.maybeRefresh({ requestContext });
     }
     const skillsList = await this.skills?.list();
     const hasSkills = skillsList && skillsList.length > 0;
@@ -24172,6 +24346,14 @@ function augmentWithInit(storage) {
 }
 
 // src/memory/memory.ts
+function extractModelIdString(model) {
+  if (typeof model === "string") return model;
+  if (typeof model === "function") return void 0;
+  if (model && typeof model === "object" && "id" in model && typeof model.id === "string") {
+    return model.id;
+  }
+  return void 0;
+}
 var MemoryProcessor = class extends MastraBase {
   /**
    * Process a list of messages and return a filtered or transformed list.
@@ -24618,7 +24800,7 @@ https://mastra.ai/en/docs/memory/overview`
    * @returns Serializable memory configuration
    */
   getConfig() {
-    const { generateTitle, workingMemory, threads, ...restConfig } = this.threadConfig;
+    const { generateTitle, workingMemory, threads, observationalMemory, ...restConfig } = this.threadConfig;
     const config = {
       vector: this.vector?.id,
       options: {
@@ -24655,8 +24837,62 @@ https://mastra.ai/en/docs/memory/overview`
       const { telemetry, ...rest } = this.embedderOptions;
       config.embedderOptions = rest;
     }
+    if (observationalMemory !== void 0) {
+      config.observationalMemory = this.serializeObservationalMemory(observationalMemory);
+    }
     return config;
   }
+  /**
+   * Serialize observational memory config to a JSON-safe representation.
+   * Model references that aren't string IDs are dropped (non-serializable).
+   */
+  serializeObservationalMemory(om) {
+    if (typeof om === "boolean") {
+      return om;
+    }
+    if (om.enabled === false) {
+      return false;
+    }
+    const result = {
+      scope: om.scope,
+      shareTokenBudget: om.shareTokenBudget
+    };
+    const topModelId = extractModelIdString(om.model);
+    if (topModelId) {
+      result.model = topModelId;
+    }
+    if (om.observation) {
+      const obs = om.observation;
+      result.observation = {
+        messageTokens: obs.messageTokens,
+        modelSettings: obs.modelSettings,
+        providerOptions: obs.providerOptions,
+        maxTokensPerBatch: obs.maxTokensPerBatch,
+        bufferTokens: obs.bufferTokens,
+        bufferActivation: obs.bufferActivation,
+        blockAfter: obs.blockAfter
+      };
+      const obsModelId = extractModelIdString(obs.model);
+      if (obsModelId) {
+        result.observation.model = obsModelId;
+      }
+    }
+    if (om.reflection) {
+      const ref = om.reflection;
+      result.reflection = {
+        observationTokens: ref.observationTokens,
+        modelSettings: ref.modelSettings,
+        providerOptions: ref.providerOptions,
+        blockAfter: ref.blockAfter,
+        bufferActivation: ref.bufferActivation
+      };
+      const refModelId = extractModelIdString(ref.model);
+      if (refModelId) {
+        result.reflection.model = refModelId;
+      }
+    }
+    return result;
+  }
 };
 var isZodObject = (v) => v instanceof ZodObject;
 var MockMemory = class extends MastraMemory {
@@ -24873,5 +25109,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-SIZEIYNH.js.map
-//# sourceMappingURL=chunk-SIZEIYNH.js.map
+//# sourceMappingURL=chunk-4XSAZPPS.js.map
+//# sourceMappingURL=chunk-4XSAZPPS.js.map