@scoutqa/mastra-core 0.24.6-fork.1

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

@@ -0,0 +1,348 @@
+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>({ models, telemetry_settings, _internal, modelStreamSpan, ...rest }: OuterLLMRun<Tools, OUTPUT>, llmExecutionStep: any): import("../../..").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, {
+    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, {
+            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, {
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        steps: any[];
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        sources?: any[] | undefined;
+        files?: any[] | undefined;
+        toolCalls?: any[] | undefined;
+        toolResults?: any[] | undefined;
+        reasoningText?: string | undefined;
+        staticToolCalls?: any[] | undefined;
+        dynamicToolCalls?: any[] | undefined;
+        staticToolResults?: any[] | undefined;
+        dynamicToolResults?: any[] | undefined;
+    }, {
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        steps: any[];
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        sources?: any[] | undefined;
+        files?: 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>;
+        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, {
+        id?: string | undefined;
+        providerMetadata?: Record<string, any> | undefined;
+        headers?: Record<string, string> | undefined;
+        model?: string | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | undefined;
+        modelMetadata?: {
+            modelId: string;
+            modelVersion: string;
+            modelProvider: string;
+        } | undefined;
+    }, {
+        id?: string | undefined;
+        providerMetadata?: Record<string, any> | undefined;
+        headers?: Record<string, string> | undefined;
+        model?: string | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | 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;
+        headers?: Record<string, string> | undefined;
+        request?: Record<string, any> | undefined;
+        logprobs?: any;
+        totalUsage?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: 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?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    output: {
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        steps: any[];
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        sources?: any[] | undefined;
+        files?: 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;
+        headers?: Record<string, string> | undefined;
+        model?: string | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | undefined;
+        modelMetadata?: {
+            modelId: string;
+            modelVersion: string;
+            modelProvider: 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?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        } | undefined;
+    };
+}, {
+    output: {
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+            reasoningTokens?: number | undefined;
+            cachedInputTokens?: number | undefined;
+        };
+        steps: any[];
+        text?: string | undefined;
+        reasoning?: any[] | undefined;
+        sources?: any[] | undefined;
+        files?: 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;
+        headers?: Record<string, string> | undefined;
+        model?: string | undefined;
+        request?: Record<string, any> | undefined;
+        timestamp?: Date | undefined;
+        modelId?: string | undefined;
+        modelMetadata?: {
+            modelId: string;
+            modelVersion: string;
+            modelProvider: 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?: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: 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;AAGpB,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,kBAAkB,EAAE,SAAS,EAAE,eAAe,EAAE,GAAG,IAAI,EAAE,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,EAC/F,gBAAgB,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHA6HtB"}

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

@@ -0,0 +1,58 @@
+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, controller, runId, streamState, modelSpanTracker, _internal, }: OuterLLMRun<Tools, OUTPUT>): import("../../..").Step<"toolCallStep", import("zod").ZodObject<any, import("zod").UnknownKeysParam, import("zod").ZodTypeAny, {
+    [x: string]: any;
+}, {
+    [x: string]: any;
+}>, import("zod").ZodObject<{
+    toolCallId: import("zod").ZodString;
+    toolName: import("zod").ZodString;
+    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;
+    args: Record<string, any>;
+    providerMetadata?: Record<string, any> | undefined;
+    providerExecuted?: boolean | undefined;
+    output?: any;
+}, {
+    toolCallId: string;
+    toolName: string;
+    args: Record<string, any>;
+    providerMetadata?: Record<string, any> | undefined;
+    providerExecuted?: boolean | undefined;
+    output?: any;
+}>, import("zod").ZodObject<{
+    toolCallId: import("zod").ZodString;
+    toolName: import("zod").ZodString;
+    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>;
+} & {
+    result: import("zod").ZodAny;
+    error: import("zod").ZodOptional<import("zod").ZodAny>;
+}, "strip", import("zod").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;
+}>, 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,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAKhE,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,EACA,KAAK,EACL,WAAW,EACX,OAAO,EACP,kBAAkB,EAClB,MAAM,EACN,UAAU,EACV,KAAK,EACL,WAAW,EACX,gBAAgB,EAChB,SAAS,GACV,EAAE,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gKAmS5B"}