@mastra/core 0.17.0-alpha.3 → 0.17.0-alpha.5

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

@@ -0,0 +1,311 @@
+import type { ToolSet } from 'ai-v5';
+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 = undefined>({ models, telemetry_settings, _internal, modelStreamSpan, ...rest }: OuterLLMRun<Tools, OUTPUT>, llmExecutionStep: any): import("../../..").Step<"llmExecutionMappingStep", 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, {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, any>;
+    error?: any;
+    providerMetadata?: Record<string, any> | undefined;
+    providerExecuted?: boolean | undefined;
+    output?: any;
+    result?: any;
+}, {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, any>;
+    error?: any;
+    providerMetadata?: Record<string, any> | undefined;
+    providerExecuted?: boolean | undefined;
+    output?: any;
+    result?: any;
+}>, "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, {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }, {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }>;
+        steps: z.ZodArray<z.ZodAny, "many">;
+    }, "strip", z.ZodTypeAny, {
+        steps: any[];
+        usage: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        files?: any[] | undefined;
+        sources?: any[] | undefined;
+        toolCalls?: any[] | undefined;
+        toolResults?: any[] | undefined;
+        reasoningText?: string | undefined;
+        staticToolCalls?: any[] | undefined;
+        dynamicToolCalls?: any[] | undefined;
+        staticToolResults?: any[] | undefined;
+        dynamicToolResults?: any[] | undefined;
+    }, {
+        steps: any[];
+        usage: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        files?: any[] | undefined;
+        sources?: any[] | undefined;
+        toolCalls?: any[] | undefined;
+        toolResults?: any[] | undefined;
+        reasoningText?: string | undefined;
+        staticToolCalls?: any[] | undefined;
+        dynamicToolCalls?: any[] | undefined;
+        staticToolResults?: any[] | undefined;
+        dynamicToolResults?: any[] | undefined;
+    }>;
+    metadata: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodString>;
+        modelId: z.ZodOptional<z.ZodString>;
+        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, {
+        id?: string | undefined;
+        providerMetadata?: Record<string, any> | undefined;
+        model?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | undefined;
+    }, {
+        id?: string | undefined;
+        providerMetadata?: Record<string, any> | undefined;
+        model?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: 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, {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        }, {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: 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;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        logprobs?: any;
+        totalUsage?: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }, {
+        reason: string;
+        warnings: any[];
+        isContinued: boolean;
+        messageId?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        logprobs?: any;
+        totalUsage?: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    output: {
+        steps: any[];
+        usage: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        files?: any[] | undefined;
+        sources?: any[] | undefined;
+        toolCalls?: any[] | undefined;
+        toolResults?: any[] | undefined;
+        reasoningText?: string | undefined;
+        staticToolCalls?: any[] | undefined;
+        dynamicToolCalls?: any[] | undefined;
+        staticToolResults?: any[] | undefined;
+        dynamicToolResults?: any[] | undefined;
+    };
+    messageId: string;
+    metadata: {
+        id?: string | undefined;
+        providerMetadata?: Record<string, any> | undefined;
+        model?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | undefined;
+    };
+    messages: {
+        user: any[];
+        all: any[];
+        nonUser: any[];
+    };
+    stepResult: {
+        reason: string;
+        warnings: any[];
+        isContinued: boolean;
+        messageId?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        logprobs?: any;
+        totalUsage?: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+}, {
+    output: {
+        steps: any[];
+        usage: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        files?: any[] | undefined;
+        sources?: any[] | undefined;
+        toolCalls?: any[] | undefined;
+        toolResults?: any[] | undefined;
+        reasoningText?: string | undefined;
+        staticToolCalls?: any[] | undefined;
+        dynamicToolCalls?: any[] | undefined;
+        staticToolResults?: any[] | undefined;
+        dynamicToolResults?: any[] | undefined;
+    };
+    messageId: string;
+    metadata: {
+        id?: string | undefined;
+        providerMetadata?: Record<string, any> | undefined;
+        model?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | undefined;
+    };
+    messages: {
+        user: any[];
+        all: any[];
+        nonUser: any[];
+    };
+    stepResult: {
+        reason: string;
+        warnings: any[];
+        isContinued: boolean;
+        messageId?: string | undefined;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        logprobs?: any;
+        totalUsage?: {
+            totalTokens: number;
+            inputTokens: number;
+            outputTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+}>, z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>, import("../../..").DefaultEngineType>;
+//# sourceMappingURL=llm-mapping-step.d.ts.map

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

@@ -0,0 +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,OAAO,CAAC;AACrC,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAIhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,wBAAgB,oBAAoB,CAClC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EAEnD,EAAE,MAAM,EAAE,kBAAkB,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,IAAI,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAC/F,gBAAgB,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHAgHtB"}

package/dist/loop/{workflow → workflows/agentic-execution}/tool-call-step.d.ts

@@ -1,32 +1,32 @@
 import type { ToolSet } from 'ai-v5';
-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, telemetry_settings, writer }: OuterLLMRun<Tools, OUTPUT>): import("../..").Step<"toolCallStep", import("zod").ZodObject<{
+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, telemetry_settings, writer }: OuterLLMRun<Tools, OUTPUT>): import("../../..").Step<"toolCallStep", import("zod").ZodObject<{
     toolCallId: import("zod").ZodString;
     toolName: import("zod").ZodString;
-    args: import("zod").ZodAny;
-    providerMetadata: import("zod").ZodAny;
+    args: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>;
+    providerMetadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
     providerExecuted: import("zod").ZodOptional<import("zod").ZodBoolean>;
     output: import("zod").ZodOptional<import("zod").ZodAny>;
 }, "strip", import("zod").ZodTypeAny, {
     toolCallId: string;
     toolName: string;
-    providerMetadata?: any;
+    args: Record<string, any>;
+    providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
     output?: any;
-    args?: any;
 }, {
     toolCallId: string;
     toolName: string;
-    providerMetadata?: any;
+    args: Record<string, any>;
+    providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
     output?: any;
-    args?: any;
 }>, import("zod").ZodObject<{
     toolCallId: import("zod").ZodString;
     toolName: import("zod").ZodString;
-    args: import("zod").ZodAny;
-    providerMetadata: import("zod").ZodAny;
+    args: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>;
+    providerMetadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
     providerExecuted: import("zod").ZodOptional<import("zod").ZodBoolean>;
     output: import("zod").ZodOptional<import("zod").ZodAny>;
 } & {
@@ -35,20 +35,20 @@ export declare function createToolCallStep<Tools extends ToolSet = ToolSet, OUTP
 }, "strip", import("zod").ZodTypeAny, {
     toolCallId: string;
     toolName: string;
+    args: Record<string, any>;
     error?: any;
-    providerMetadata?: any;
+    providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
     output?: any;
-    args?: any;
     result?: any;
 }, {
     toolCallId: string;
     toolName: string;
+    args: Record<string, any>;
     error?: any;
-    providerMetadata?: any;
+    providerMetadata?: Record<string, any> | undefined;
     providerExecuted?: boolean | undefined;
     output?: any;
-    args?: any;
     result?: any;
-}>, import("zod").ZodType<any, import("zod").ZodTypeDef, any>, import("zod").ZodType<any, import("zod").ZodTypeDef, any>, import("../..").DefaultEngineType>;
+}>, import("zod").ZodType<any, import("zod").ZodTypeDef, any>, import("zod").ZodType<any, import("zod").ZodTypeDef, any>, import("../../..").DefaultEngineType>;
 //# sourceMappingURL=tool-call-step.d.ts.map

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

@@ -0,0 +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,EAAmB,OAAO,EAAE,MAAM,OAAO,CAAC;AACtD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAGhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,wBAAgB,kBAAkB,CAChC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EACnD,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gKA4GxF"}