@mastra/core 0.16.4-alpha.2 → 0.17.0-alpha.4

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,EAAqB,MAAM,uBAAuB,CAAC;AAG1E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAK3C,UAAU,iBAAiB,CAAC,KAAK,SAAS,OAAO,GAAG,OAAO,EAAE,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,CAC9G,SAAQ,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC;IAC9B,UAAU,EAAE,+BAA+B,CAAC,SAAS,CAAC,CAAC;IACvD,MAAM,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC;CACnC;AAED,wBAAgB,yBAAyB,CACvC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EACnD,MAAM,EAAE,iBAAiB,CAAC,KAAK,EAAE,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAgJzC"}

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,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,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,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,eAAe,CAAA;KAAE;IAqBvF,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC;IAO9B,IAAI,KAAK,UAER;CACF"}

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

@@ -0,0 +1,439 @@
+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';
+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> {
+    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>[];
+}
+export interface LLMIterationMetadata {
+    id?: string;
+    model?: string;
+    modelId?: string;
+    timestamp?: Date;
+    providerMetadata?: SharedV2ProviderMetadata;
+    headers?: Record<string, string>;
+    request?: LanguageModelRequestMetadata;
+}
+export interface LLMIterationData<Tools extends ToolSet = ToolSet> {
+    messageId: string;
+    messages: {
+        all: ModelMessage[];
+        user: ModelMessage[];
+        nonUser: ModelMessage[];
+    };
+    output: LLMIterationOutput<Tools>;
+    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, {
+        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;
+}>;
+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, {
+            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;
+    };
+}>;
+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/{workflow → workflows}/stream.d.ts

@@ -3,5 +3,5 @@ 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';
-export declare function workflowLoopStream<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema | undefined = undefined>({ telemetry_settings, model, toolChoice, modelSettings, _internal, modelStreamSpan, llmAISpan, messageId, ...rest }: LoopRun<Tools, OUTPUT>): ReadableStream<ChunkType>;
+export declare function workflowLoopStream<Tools extends ToolSet = ToolSet, OUTPUT extends OutputSchema | undefined = undefined>({ telemetry_settings, models, toolChoice, modelSettings, _internal, modelStreamSpan, llmAISpan, messageId, runId, messageList, startTimestamp, ...rest }: LoopRun<Tools, OUTPUT>): ReadableStream<ChunkType>;
 //# 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;AACrC,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,wBAAgB,kBAAkB,CAChC,KAAK,SAAS,OAAO,GAAG,OAAO,EAC/B,MAAM,SAAS,YAAY,GAAG,SAAS,GAAG,SAAS,EACnD,EACA,kBAAkB,EAClB,MAAM,EACN,UAAU,EACV,aAAa,EACb,SAAS,EACT,eAAe,EACf,SAAS,EACT,SAAS,EACT,KAAK,EACL,WAAW,EACX,cAAc,EACd,GAAG,IAAI,EACR,EAAE,OAAO,CAAC,KAAK,EAAE,MAAM,CAAC,6BAmHxB"}

package/dist/mastra/index.cjs

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

package/dist/mastra/index.js

@@ -1,3 +1,3 @@
-export { Mastra } from '../chunk-YYZT5JKX.js';
+export { Mastra } from '../chunk-BY37WSX5.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/memory/index.cjs

@@ -1,20 +1,20 @@
 'use strict';
 
-var chunkVH3RNDZA_cjs = require('../chunk-VH3RNDZA.cjs');
+var chunkRNJ4GD7U_cjs = require('../chunk-RNJ4GD7U.cjs');
 
 
 
 Object.defineProperty(exports, "MastraMemory", {
   enumerable: true,
-  get: function () { return chunkVH3RNDZA_cjs.MastraMemory; }
+  get: function () { return chunkRNJ4GD7U_cjs.MastraMemory; }
 });
 Object.defineProperty(exports, "MemoryProcessor", {
   enumerable: true,
-  get: function () { return chunkVH3RNDZA_cjs.MemoryProcessor; }
+  get: function () { return chunkRNJ4GD7U_cjs.MemoryProcessor; }
 });
 Object.defineProperty(exports, "memoryDefaultOptions", {
   enumerable: true,
-  get: function () { return chunkVH3RNDZA_cjs.memoryDefaultOptions; }
+  get: function () { return chunkRNJ4GD7U_cjs.memoryDefaultOptions; }
 });
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/memory/index.js

@@ -1,3 +1,3 @@
-export { MastraMemory, MemoryProcessor, memoryDefaultOptions } from '../chunk-BVE3UPHV.js';
+export { MastraMemory, MemoryProcessor, memoryDefaultOptions } from '../chunk-VXJFKEON.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/network/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkYLR7PB3B_cjs = require('../chunk-YLR7PB3B.cjs');
+var chunkBGAJ72HJ_cjs = require('../chunk-BGAJ72HJ.cjs');
 var chunkC73WLCY3_cjs = require('../chunk-C73WLCY3.cjs');
 var chunkABRPHTOG_cjs = require('../chunk-ABRPHTOG.cjs');
 var chunkKXCUCBEI_cjs = require('../chunk-KXCUCBEI.cjs');
@@ -21,7 +21,7 @@ var AgentNetwork = class extends chunkKXCUCBEI_cjs.MastraBase {
     this.#instructions = config.instructions;
     this.#agents = config.agents;
     this.#model = config.model;
-    this.#routingAgent = new chunkYLR7PB3B_cjs.Agent({
+    this.#routingAgent = new chunkBGAJ72HJ_cjs.Agent({
       name: config.name,
       instructions: this.getInstructions(),
       model: this.#model,

package/dist/network/index.js

@@ -1,4 +1,4 @@
-import { Agent } from '../chunk-CF3TI576.js';
+import { Agent } from '../chunk-UWUM3F3X.js';
 import { MastraError } from '../chunk-MCOVMKIS.js';
 import { createTool } from '../chunk-BJGHUKKM.js';
 import { MastraBase } from '../chunk-6GF5M4GX.js';