@scoutqa/mastra-core 0.24.6-fork.1

package/dist/loop/workflows/agentic-loop/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/loop/workflows/agentic-loop/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,OAAO,EAAE,MAAM,OAAO,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAGvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAM3C,UAAU,iBAAiB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,EAAE,MAAM,SAAS,YAAY,GAAG,SAAS,CAClG,SAAQ,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC;IAC9B,UAAU,EAAE,+BAA+B,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/D,MAAM,EAAE,cAAc,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;CAC3C;AAED,wBAAgB,yBAAyB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,EAAE,MAAM,SAAS,YAAY,GAAG,SAAS,EAChH,MAAM,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwJzC"}

package/dist/loop/workflows/run-state.d.ts

@@ -0,0 +1,29 @@
+import type { MastraLanguageModelV2 } from '../../llm/model/shared.types.js';
+import type { StreamInternal } from '../types.js';
+type State = {
+    stepResult: Record<string, any> | undefined;
+    responseMetadata: Record<string, any> | undefined;
+    modelMetadata: {
+        modelId: string;
+        modelVersion: string;
+        modelProvider: string;
+    };
+    hasToolCallStreaming: boolean;
+    hasErrored: boolean;
+    reasoningDeltas: string[];
+    textDeltas: string[];
+    isReasoning: boolean;
+    isStreaming: boolean;
+    providerOptions: Record<string, any> | undefined;
+};
+export declare class AgenticRunState {
+    #private;
+    constructor({ _internal, model }: {
+        _internal: StreamInternal;
+        model: MastraLanguageModelV2;
+    });
+    setState(state: Partial<State>): void;
+    get state(): State;
+}
+export {};
+//# sourceMappingURL=run-state.d.ts.map

package/dist/loop/workflows/run-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-state.d.ts","sourceRoot":"","sources":["../../../src/loop/workflows/run-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,KAAK,KAAK,GAAG;IACX,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;IAC5C,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;IAClD,aAAa,EAAE;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC;IACF,oBAAoB,EAAE,OAAO,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;CAClD,CAAC;AAEF,qBAAa,eAAe;;gBAEd,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;QAAE,SAAS,EAAE,cAAc,CAAC;QAAC,KAAK,EAAE,qBAAqB,CAAA;KAAE;IA0B7F,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC;IAO9B,IAAI,KAAK,UAER;CACF"}

package/dist/loop/workflows/schema.d.ts

@@ -0,0 +1,479 @@
+import type { LanguageModelV1LogProbs } from '@ai-sdk/provider';
+import type { ReasoningPart } from '@ai-sdk/provider-utils-v5';
+import type { LanguageModelV2FinishReason, LanguageModelV2CallWarning, SharedV2ProviderMetadata, LanguageModelV2Source } from '@ai-sdk/provider-v5';
+import type { LanguageModelRequestMetadata } from 'ai';
+import type { StepResult, ModelMessage, LanguageModelUsage, ToolSet, TypedToolCall, TypedToolResult, StaticToolCall, StaticToolResult, DynamicToolCall, DynamicToolResult, GeneratedFile } from 'ai-v5';
+import z from 'zod';
+import type { InferSchemaOutput, OutputSchema } from '../../stream/base/schema.js';
+export interface LLMIterationStepResult {
+    reason: LanguageModelV2FinishReason | 'abort';
+    warnings: LanguageModelV2CallWarning[];
+    isContinued: boolean;
+    logprobs?: LanguageModelV1LogProbs;
+    totalUsage: LanguageModelUsage;
+    headers?: Record<string, string>;
+    messageId?: string;
+    request?: LanguageModelRequestMetadata;
+}
+export interface LLMIterationOutput<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema = undefined> {
+    text?: string;
+    reasoning?: ReasoningPart[];
+    reasoningText?: string;
+    files?: GeneratedFile[];
+    toolCalls?: TypedToolCall<Tools>[];
+    toolResults?: TypedToolResult<Tools>[];
+    sources?: LanguageModelV2Source[];
+    staticToolCalls?: StaticToolCall<Tools>[];
+    dynamicToolCalls?: DynamicToolCall[];
+    staticToolResults?: StaticToolResult<Tools>[];
+    dynamicToolResults?: DynamicToolResult[];
+    usage: LanguageModelUsage;
+    steps: StepResult<Tools>[];
+    object?: InferSchemaOutput<OUTPUT>;
+}
+export interface LLMIterationMetadata {
+    id?: string;
+    model?: string;
+    modelId?: string;
+    modelMetadata?: {
+        modelId: string;
+        modelVersion: string;
+        modelProvider: string;
+    };
+    timestamp?: Date;
+    providerMetadata?: SharedV2ProviderMetadata;
+    headers?: Record<string, string>;
+    request?: LanguageModelRequestMetadata;
+}
+export interface LLMIterationData<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema = undefined> {
+    messageId: string;
+    messages: {
+        all: ModelMessage[];
+        user: ModelMessage[];
+        nonUser: ModelMessage[];
+    };
+    output: LLMIterationOutput<Tools, OUTPUT>;
+    metadata: LLMIterationMetadata;
+    stepResult: LLMIterationStepResult;
+}
+export declare const llmIterationStepResultSchema: 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;
+}>;
+export declare const llmIterationOutputSchema: 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;
+    };
+}>;
+export declare const toolCallInputSchema: 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;
+    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;
+}>;
+export declare const toolCallOutputSchema: 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;
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/loop/workflows/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/loop/workflows/schema.ts"],"names":[],"mappings":"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"}

package/dist/loop/workflows/stream.d.ts

@@ -0,0 +1,20 @@
+import { ReadableStream } from 'stream/web';
+import type { ToolSet } from 'ai-v5';
+import type { OutputSchema } from '../../stream/base/schema.js';
+import type { ChunkType } from '../../stream/types.js';
+import type { LoopRun } from '../types.js';
+/**
+ * Check if a ReadableStreamDefaultController is open and can accept data.
+ *
+ * Note: While the ReadableStream spec indicates desiredSize can be:
+ * - positive (ready), 0 (full but open), or null (closed/errored),
+ * our empirical testing shows that after controller.close(), desiredSize becomes 0.
+ * Therefore, we treat both 0 and null as closed states to prevent
+ * "Invalid state: Controller is already closed" errors.
+ *
+ * @param controller - The ReadableStreamDefaultController to check
+ * @returns true if the controller is open and can accept data
+ */
+export declare function isControllerOpen(controller: ReadableStreamDefaultController<any>): boolean;
+export declare function workflowLoopStream<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema | undefined = undefined>({ resumeContext, requireToolApproval, telemetry_settings, models, toolChoice, modelSettings, _internal, modelStreamSpan, messageId, runId, messageList, startTimestamp, streamState, agentId, toolCallId, ...rest }: LoopRun<Tools, OUTPUT>): ReadableStream<ChunkType<OUTPUT>>;
+//# sourceMappingURL=stream.d.ts.map

package/dist/loop/workflows/stream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../src/loop/workflows/stream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAErC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGxC;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,+BAA+B,CAAC,GAAG,CAAC,GAAG,OAAO,CAE1F;AAED,wBAAgB,kBAAkB,CAChC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EACnD,EACA,aAAa,EACb,mBAAmB,EACnB,kBAAkB,EAClB,MAAM,EACN,UAAU,EACV,aAAa,EACb,SAAS,EACT,eAAe,EACf,SAAS,EACT,KAAK,EACL,WAAW,EACX,cAAc,EACd,WAAW,EACX,OAAO,EACP,UAAU,EACV,GAAG,IAAI,EACR,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,qCA2IxB"}

package/dist/mastra/hooks.d.ts

@@ -0,0 +1,6 @@
+import type { Mastra } from '..';
+import type { ScoringHookInput } from '../scores/types.js';
+import type { MastraStorage } from '../storage/index.js';
+export declare function createOnScorerHook(mastra: Mastra): (hookData: ScoringHookInput) => Promise<void>;
+export declare function validateAndSaveScore(storage: MastraStorage, payload: unknown): Promise<void>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/mastra/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/mastra/hooks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,IAAI,CAAC;AAGjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,IACjC,UAAU,gBAAgB,mBA8FzC;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,aAAa,EAAE,OAAO,EAAE,OAAO,iBAGlF"}

package/dist/mastra/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var chunkWNV57BEW_cjs = require('../chunk-WNV57BEW.cjs');
+
+
+
+Object.defineProperty(exports, "Mastra", {
+  enumerable: true,
+  get: function () { return chunkWNV57BEW_cjs.Mastra; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/mastra/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}