@mastra/core 1.0.0-beta.21 → 1.0.0-beta.22

package/dist/loop/workflows/agentic-execution/llm-mapping-step.d.ts

@@ -1,22 +1,6 @@
 import type { ToolSet } from '../../../_types/@internal_ai-sdk-v5/dist/index.js';
-import z from 'zod';
-import type { OutputSchema } from '../../../stream/base/schema.js';
 import type { OuterLLMRun } from '../../types.js';
-export declare function createLLMMappingStep<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema = undefined>({ models, _internal, ...rest }: OuterLLMRun<Tools, OUTPUT>, llmExecutionStep: any): import("../../../workflows").Step<"llmExecutionMappingStep", z.ZodObject<any, z.UnknownKeysParam, z.ZodTypeAny, {
-    [x: string]: any;
-}, {
-    [x: string]: any;
-}>, z.ZodArray<z.ZodObject<{
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    args: z.ZodRecord<z.ZodString, z.ZodAny>;
-    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    output: z.ZodOptional<z.ZodAny>;
-} & {
-    result: z.ZodAny;
-    error: z.ZodOptional<z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
+export declare function createLLMMappingStep<Tools extends ToolSet = ToolSet, OUTPUT = undefined>({ models, _internal, ...rest }: OuterLLMRun<Tools, OUTPUT>, llmExecutionStep: any): import("../../../workflows").Step<"llmExecutionMappingStep", any, {
     toolCallId: string;
     args: Record<string, any>;
     toolName: string;
@@ -25,219 +9,14 @@ export declare function createLLMMappingStep<Tools extends ToolSet = ToolSet, OU
     result?: any;
     providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
-}, {
-    toolCallId: string;
-    args: Record<string, any>;
-    toolName: string;
-    error?: any;
-    output?: any;
-    result?: any;
-    providerMetadata?: Record<string, any> | undefined;
-    providerExecuted?: boolean | undefined;
-}>, "many">, z.ZodObject<{
-    messageId: z.ZodString;
-    messages: z.ZodObject<{
-        all: z.ZodArray<z.ZodAny, "many">;
-        user: z.ZodArray<z.ZodAny, "many">;
-        nonUser: z.ZodArray<z.ZodAny, "many">;
-    }, "strip", z.ZodTypeAny, {
-        user: any[];
-        all: any[];
-        nonUser: any[];
-    }, {
-        user: any[];
-        all: any[];
-        nonUser: any[];
-    }>;
-    output: z.ZodObject<{
-        text: z.ZodOptional<z.ZodString>;
-        reasoning: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        reasoningText: z.ZodOptional<z.ZodString>;
-        files: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        toolCalls: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        toolResults: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        sources: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        staticToolCalls: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        dynamicToolCalls: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        staticToolResults: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        dynamicToolResults: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
-        usage: z.ZodObject<{
-            inputTokens: z.ZodNumber;
-            outputTokens: z.ZodNumber;
-            totalTokens: z.ZodNumber;
-            reasoningTokens: z.ZodOptional<z.ZodNumber>;
-            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        }, {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        }>;
-        steps: z.ZodArray<z.ZodAny, "many">;
-    }, "strip", z.ZodTypeAny, {
-        steps: any[];
-        usage: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        };
-        reasoning?: any[] | undefined;
-        text?: string | undefined;
-        sources?: any[] | undefined;
-        files?: any[] | undefined;
-        toolCalls?: any[] | undefined;
-        toolResults?: any[] | undefined;
-        reasoningText?: string | undefined;
-        dynamicToolCalls?: any[] | undefined;
-        dynamicToolResults?: any[] | undefined;
-        staticToolCalls?: any[] | undefined;
-        staticToolResults?: any[] | undefined;
-    }, {
-        steps: any[];
-        usage: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        };
-        reasoning?: any[] | undefined;
-        text?: string | undefined;
-        sources?: any[] | undefined;
-        files?: any[] | undefined;
-        toolCalls?: any[] | undefined;
-        toolResults?: any[] | undefined;
-        reasoningText?: string | undefined;
-        dynamicToolCalls?: any[] | undefined;
-        dynamicToolResults?: any[] | undefined;
-        staticToolCalls?: any[] | undefined;
-        staticToolResults?: any[] | undefined;
-    }>;
-    metadata: z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        model: z.ZodOptional<z.ZodString>;
-        modelId: z.ZodOptional<z.ZodString>;
-        modelMetadata: z.ZodOptional<z.ZodObject<{
-            modelId: z.ZodString;
-            modelVersion: z.ZodString;
-            modelProvider: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            modelId: string;
-            modelVersion: string;
-            modelProvider: string;
-        }, {
-            modelId: string;
-            modelVersion: string;
-            modelProvider: string;
-        }>>;
-        timestamp: z.ZodOptional<z.ZodDate>;
-        providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        request: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, "strip", z.ZodTypeAny, {
-        providerMetadata?: Record<string, any> | undefined;
-        id?: string | undefined;
-        modelId?: string | undefined;
-        model?: string | undefined;
-        request?: Record<string, any> | undefined;
-        headers?: Record<string, string> | undefined;
-        timestamp?: Date | undefined;
-        modelMetadata?: {
-            modelId: string;
-            modelVersion: string;
-            modelProvider: string;
-        } | undefined;
-    }, {
-        providerMetadata?: Record<string, any> | undefined;
-        id?: string | undefined;
-        modelId?: string | undefined;
-        model?: string | undefined;
-        request?: Record<string, any> | undefined;
-        headers?: Record<string, string> | undefined;
-        timestamp?: Date | undefined;
-        modelMetadata?: {
-            modelId: string;
-            modelVersion: string;
-            modelProvider: string;
-        } | undefined;
-    }>;
-    stepResult: z.ZodObject<{
-        reason: z.ZodString;
-        warnings: z.ZodArray<z.ZodAny, "many">;
-        isContinued: z.ZodBoolean;
-        logprobs: z.ZodOptional<z.ZodAny>;
-        totalUsage: z.ZodOptional<z.ZodObject<{
-            inputTokens: z.ZodNumber;
-            outputTokens: z.ZodNumber;
-            totalTokens: z.ZodNumber;
-            reasoningTokens: z.ZodOptional<z.ZodNumber>;
-            cachedInputTokens: z.ZodOptional<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        }, {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        }>>;
-        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-        messageId: z.ZodOptional<z.ZodString>;
-        request: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    }, "strip", z.ZodTypeAny, {
-        reason: string;
-        warnings: any[];
-        isContinued: boolean;
-        messageId?: string | undefined;
-        request?: Record<string, any> | undefined;
-        totalUsage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        } | undefined;
-        headers?: Record<string, string> | undefined;
-        logprobs?: any;
-    }, {
-        reason: string;
-        warnings: any[];
-        isContinued: boolean;
-        messageId?: string | undefined;
-        request?: Record<string, any> | undefined;
-        totalUsage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        } | undefined;
-        headers?: Record<string, string> | undefined;
-        logprobs?: any;
-    }>;
-    processorRetryCount: z.ZodOptional<z.ZodNumber>;
-    processorRetryFeedback: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
+}[], {
     metadata: {
         providerMetadata?: Record<string, any> | undefined;
         id?: string | undefined;
         modelId?: string | undefined;
         model?: string | undefined;
-        request?: Record<string, any> | undefined;
         headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
         timestamp?: Date | undefined;
         modelMetadata?: {
             modelId: string;
@@ -246,25 +25,25 @@ export declare function createLLMMappingStep<Tools extends ToolSet = ToolSet, OU
         } | undefined;
     };
     output: {
-        steps: any[];
         usage: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
             reasoningTokens?: number | undefined;
             cachedInputTokens?: number | undefined;
         };
+        steps: any[];
         reasoning?: any[] | undefined;
         text?: string | undefined;
         sources?: any[] | undefined;
         files?: any[] | undefined;
         toolCalls?: any[] | undefined;
         toolResults?: any[] | undefined;
-        reasoningText?: string | undefined;
         dynamicToolCalls?: any[] | undefined;
         dynamicToolResults?: any[] | undefined;
         staticToolCalls?: any[] | undefined;
         staticToolResults?: any[] | undefined;
+        reasoningText?: string | undefined;
     };
     messageId: string;
     messages: {
@@ -274,81 +53,21 @@ export declare function createLLMMappingStep<Tools extends ToolSet = ToolSet, OU
     };
     stepResult: {
         reason: string;
-        warnings: any[];
         isContinued: boolean;
+        warnings: any[];
         messageId?: string | undefined;
-        request?: Record<string, any> | undefined;
-        totalUsage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        } | undefined;
         headers?: Record<string, string> | undefined;
         logprobs?: any;
-    };
-    processorRetryCount?: number | undefined;
-    processorRetryFeedback?: string | undefined;
-}, {
-    metadata: {
-        providerMetadata?: Record<string, any> | undefined;
-        id?: string | undefined;
-        modelId?: string | undefined;
-        model?: string | undefined;
-        request?: Record<string, any> | undefined;
-        headers?: Record<string, string> | undefined;
-        timestamp?: Date | undefined;
-        modelMetadata?: {
-            modelId: string;
-            modelVersion: string;
-            modelProvider: string;
-        } | undefined;
-    };
-    output: {
-        steps: any[];
-        usage: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
-            reasoningTokens?: number | undefined;
-            cachedInputTokens?: number | undefined;
-        };
-        reasoning?: any[] | undefined;
-        text?: string | undefined;
-        sources?: any[] | undefined;
-        files?: any[] | undefined;
-        toolCalls?: any[] | undefined;
-        toolResults?: any[] | undefined;
-        reasoningText?: string | undefined;
-        dynamicToolCalls?: any[] | undefined;
-        dynamicToolResults?: any[] | undefined;
-        staticToolCalls?: any[] | undefined;
-        staticToolResults?: any[] | undefined;
-    };
-    messageId: string;
-    messages: {
-        user: any[];
-        all: any[];
-        nonUser: any[];
-    };
-    stepResult: {
-        reason: string;
-        warnings: any[];
-        isContinued: boolean;
-        messageId?: string | undefined;
         request?: Record<string, any> | undefined;
         totalUsage?: {
-            inputTokens: number;
-            outputTokens: number;
-            totalTokens: number;
+            inputTokens?: number | undefined;
+            outputTokens?: number | undefined;
+            totalTokens?: number | undefined;
             reasoningTokens?: number | undefined;
             cachedInputTokens?: number | undefined;
         } | undefined;
-        headers?: Record<string, string> | undefined;
-        logprobs?: any;
     };
     processorRetryCount?: number | undefined;
     processorRetryFeedback?: string | undefined;
-}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, import("../../../workflows").DefaultEngineType>;
+}, unknown, unknown, import("../../../workflows").DefaultEngineType>;
 //# sourceMappingURL=llm-mapping-step.d.ts.map

package/dist/loop/workflows/agentic-execution/llm-mapping-step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"llm-mapping-step.d.ts","sourceRoot":"","sources":["../../../../src/loop/workflows/agentic-execution/llm-mapping-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,CAAC,MAAM,KAAK,CAAC;AAMpB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAIhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,EAAE,MAAM,SAAS,YAAY,GAAG,SAAS,EAC3G,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAC1D,gBAAgB,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0HAkNtB"}
+{"version":3,"file":"llm-mapping-step.d.ts","sourceRoot":"","sources":["../../../../src/loop/workflows/agentic-execution/llm-mapping-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAUnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,wBAAgB,oBAAoB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,EAAE,MAAM,GAAG,SAAS,EACtF,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,IAAI,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAC1D,gBAAgB,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAkNtB"}

package/dist/loop/workflows/agentic-execution/tool-call-step.d.ts

@@ -1,51 +1,12 @@
 import type { ToolSet } from '../../../_types/@internal_ai-sdk-v5/dist/index.js';
-import z from 'zod';
-import type { OutputSchema } from '../../../stream/base/schema.js';
 import type { OuterLLMRun } from '../../types.js';
-export declare function createToolCallStep<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema | undefined = undefined>({ tools, messageList, options, outputWriter, controller, runId, streamState, modelSpanTracker, _internal, logger, }: OuterLLMRun<Tools, OUTPUT>): import("../../../workflows").Step<"toolCallStep", z.ZodObject<any, z.UnknownKeysParam, z.ZodTypeAny, {
-    [x: string]: any;
-}, {
-    [x: string]: any;
-}>, z.ZodObject<{
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    args: z.ZodRecord<z.ZodString, z.ZodAny>;
-    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    output: z.ZodOptional<z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    toolCallId: string;
-    args: Record<string, any>;
-    toolName: string;
-    output?: any;
-    providerMetadata?: Record<string, any> | undefined;
-    providerExecuted?: boolean | undefined;
-}, {
+export declare function createToolCallStep<Tools extends ToolSet = ToolSet, OUTPUT = undefined>({ tools, messageList, options, outputWriter, controller, runId, streamState, modelSpanTracker, _internal, logger, }: OuterLLMRun<Tools, OUTPUT>): import("../../../workflows").Step<"toolCallStep", any, {
     toolCallId: string;
     args: Record<string, any>;
     toolName: string;
     output?: any;
     providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
-}>, z.ZodObject<{
-    toolCallId: z.ZodString;
-    toolName: z.ZodString;
-    args: z.ZodRecord<z.ZodString, z.ZodAny>;
-    providerMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
-    providerExecuted: z.ZodOptional<z.ZodBoolean>;
-    output: z.ZodOptional<z.ZodAny>;
-} & {
-    result: z.ZodAny;
-    error: z.ZodOptional<z.ZodAny>;
-}, "strip", z.ZodTypeAny, {
-    toolCallId: string;
-    args: Record<string, any>;
-    toolName: string;
-    error?: any;
-    output?: any;
-    result?: any;
-    providerMetadata?: Record<string, any> | undefined;
-    providerExecuted?: boolean | undefined;
 }, {
     toolCallId: string;
     args: Record<string, any>;
@@ -55,5 +16,5 @@ export declare function createToolCallStep<Tools extends ToolSet = ToolSet, OUTP
     result?: any;
     providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
-}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, import("../../../workflows").DefaultEngineType>;
+}, unknown, unknown, import("../../../workflows").DefaultEngineType>;
 //# sourceMappingURL=tool-call-step.d.ts.map

package/dist/loop/workflows/agentic-execution/tool-call-step.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool-call-step.d.ts","sourceRoot":"","sources":["../../../../src/loop/workflows/agentic-execution/tool-call-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAmB/C,wBAAgB,kBAAkB,CAChC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EACnD,EACA,KAAK,EACL,WAAW,EACX,OAAO,EACP,YAAY,EACZ,UAAU,EACV,KAAK,EACL,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,MAAM,GACP,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0HAgY5B"}
+{"version":3,"file":"tool-call-step.d.ts","sourceRoot":"","sources":["../../../../src/loop/workflows/agentic-execution/tool-call-step.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAQnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAmB/C,wBAAgB,kBAAkB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,EACtF,KAAK,EACL,WAAW,EACX,OAAO,EACP,YAAY,EACZ,UAAU,EACV,KAAK,EACL,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,MAAM,GACP,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;qEAwY5B"}