@mastra/server 0.0.0-fix-thread-list-20251105222841 → 0.0.0-fix-issue-10434-concurrent-write-corruption-20251124213939

package/dist/{chunk-M6KNPIZZ.cjs → chunk-BM7RP6NK.cjs}

@@ -1,17 +1,20 @@
 'use strict';
 
+var chunk7WTETKRM_cjs = require('./chunk-7WTETKRM.cjs');
 var chunkX6C7BUWN_cjs = require('./chunk-X6C7BUWN.cjs');
 var chunk2PLXW4ZX_cjs = require('./chunk-2PLXW4ZX.cjs');
 var chunkLPM6BBAX_cjs = require('./chunk-LPM6BBAX.cjs');
-var chunkSRAPUMPM_cjs = require('./chunk-SRAPUMPM.cjs');
-var chunkLWLSQ2W4_cjs = require('./chunk-LWLSQ2W4.cjs');
+var chunkUZ6CYAOG_cjs = require('./chunk-UZ6CYAOG.cjs');
+var chunkMWQQRVQC_cjs = require('./chunk-MWQQRVQC.cjs');
+var chunk2NW6POYK_cjs = require('./chunk-2NW6POYK.cjs');
+var chunkUJNHKFBR_cjs = require('./chunk-UJNHKFBR.cjs');
 var chunkV5WWQN7P_cjs = require('./chunk-V5WWQN7P.cjs');
 var chunk64ITUOXI_cjs = require('./chunk-64ITUOXI.cjs');
 var chunkO7I5CWRX_cjs = require('./chunk-O7I5CWRX.cjs');
 var agent = require('@mastra/core/agent');
 var memory = require('@mastra/core/memory');
 var utils = require('@mastra/core/utils');
-var zod = require('zod');
+var z19 = require('zod');
 var z42 = require('zod/v4');
 var v3 = require('zod/v3');
 var tools = require('@mastra/core/tools');
@@ -25,6 +28,8 @@ var llm = require('@mastra/core/llm');
 var os = require('os');
 var workflows = require('@mastra/core/workflows');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
   var n = Object.create(null);
@@ -43,6 +48,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
+var z19__default = /*#__PURE__*/_interopDefault(z19);
 var z42__namespace = /*#__PURE__*/_interopNamespace(z42);
 
 // ../../node_modules/.pnpm/@vercel+oidc@3.0.3/node_modules/@vercel/oidc/dist/get-context.js
@@ -737,24 +743,24 @@ var require_ignore = chunkO7I5CWRX_cjs.__commonJS({
 // src/server/handlers/agent-builder.ts
 var agent_builder_exports = {};
 chunkO7I5CWRX_cjs.__export(agent_builder_exports, {
-  cancelAgentBuilderActionRunHandler: () => cancelAgentBuilderActionRunHandler,
-  createAgentBuilderActionRunHandler: () => createAgentBuilderActionRunHandler,
-  getAgentBuilderActionByIdHandler: () => getAgentBuilderActionByIdHandler,
-  getAgentBuilderActionRunByIdHandler: () => getAgentBuilderActionRunByIdHandler,
-  getAgentBuilderActionRunExecutionResultHandler: () => getAgentBuilderActionRunExecutionResultHandler,
-  getAgentBuilderActionRunsHandler: () => getAgentBuilderActionRunsHandler,
-  getAgentBuilderActionsHandler: () => getAgentBuilderActionsHandler,
-  observeStreamAgentBuilderActionHandler: () => observeStreamAgentBuilderActionHandler,
-  observeStreamLegacyAgentBuilderActionHandler: () => observeStreamLegacyAgentBuilderActionHandler,
-  observeStreamVNextAgentBuilderActionHandler: () => observeStreamVNextAgentBuilderActionHandler,
-  resumeAgentBuilderActionHandler: () => resumeAgentBuilderActionHandler,
-  resumeAsyncAgentBuilderActionHandler: () => resumeAsyncAgentBuilderActionHandler,
-  resumeStreamAgentBuilderActionHandler: () => resumeStreamAgentBuilderActionHandler,
-  startAgentBuilderActionRunHandler: () => startAgentBuilderActionRunHandler,
-  startAsyncAgentBuilderActionHandler: () => startAsyncAgentBuilderActionHandler,
-  streamAgentBuilderActionHandler: () => streamAgentBuilderActionHandler,
-  streamLegacyAgentBuilderActionHandler: () => streamLegacyAgentBuilderActionHandler,
-  streamVNextAgentBuilderActionHandler: () => streamVNextAgentBuilderActionHandler
+  CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE: () => CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE,
+  CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE: () => CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE,
+  GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE: () => GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE,
+  GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE: () => GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE,
+  GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE: () => GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE,
+  LIST_AGENT_BUILDER_ACTIONS_ROUTE: () => LIST_AGENT_BUILDER_ACTIONS_ROUTE,
+  LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE: () => LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE,
+  OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE: () => OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE,
+  OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE: () => OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE,
+  OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE: () => OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE,
+  RESUME_AGENT_BUILDER_ACTION_ROUTE: () => RESUME_AGENT_BUILDER_ACTION_ROUTE,
+  RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE: () => RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE,
+  RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE: () => RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE,
+  START_AGENT_BUILDER_ACTION_RUN_ROUTE: () => START_AGENT_BUILDER_ACTION_RUN_ROUTE,
+  START_ASYNC_AGENT_BUILDER_ACTION_ROUTE: () => START_ASYNC_AGENT_BUILDER_ACTION_ROUTE,
+  STREAM_AGENT_BUILDER_ACTION_ROUTE: () => STREAM_AGENT_BUILDER_ACTION_ROUTE,
+  STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE: () => STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE,
+  STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE: () => STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE
 });
 
 // ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/Options.js
@@ -857,7 +863,7 @@ function parseArrayDef(def, refs) {
   const res = {
     type: "array"
   };
-  if (def.type?._def && def.type?._def?.typeName !== zod.ZodFirstPartyTypeKind.ZodAny) {
+  if (def.type?._def && def.type?._def?.typeName !== z19.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -1398,7 +1404,7 @@ function parseRecordDef(def, refs) {
   if (refs.target === "openAi") {
     console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
   }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       type: "object",
       required: def.keyType._def.values,
@@ -1422,20 +1428,20 @@ function parseRecordDef(def, refs) {
   if (refs.target === "openApi3") {
     return schema;
   }
-  if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+  if (def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
     const { type, ...keyType } = parseStringDef(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+  } else if (def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === z19.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
     const { type, ...keyType } = parseBrandedDef(def.keyType._def, refs);
     return {
       ...schema,
@@ -1835,73 +1841,73 @@ var parseReadonlyDef = (def, refs) => {
 // ../../node_modules/.pnpm/zod-to-json-schema@3.24.6_zod@3.25.76/node_modules/zod-to-json-schema/dist/esm/selectParser.js
 var selectParser = (def, typeName, refs) => {
   switch (typeName) {
-    case zod.ZodFirstPartyTypeKind.ZodString:
+    case z19.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNumber:
+    case z19.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodObject:
+    case z19.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBigInt:
+    case z19.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBoolean:
+    case z19.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef();
-    case zod.ZodFirstPartyTypeKind.ZodDate:
+    case z19.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUndefined:
+    case z19.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodNull:
+    case z19.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodArray:
+    case z19.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnion:
-    case zod.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case z19.ZodFirstPartyTypeKind.ZodUnion:
+    case z19.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodIntersection:
+    case z19.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodTuple:
+    case z19.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodRecord:
+    case z19.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLiteral:
+    case z19.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodEnum:
+    case z19.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef(def);
-    case zod.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case z19.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef(def);
-    case zod.ZodFirstPartyTypeKind.ZodNullable:
+    case z19.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodOptional:
+    case z19.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodMap:
+    case z19.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodSet:
+    case z19.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLazy:
+    case z19.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case zod.ZodFirstPartyTypeKind.ZodPromise:
+    case z19.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNaN:
-    case zod.ZodFirstPartyTypeKind.ZodNever:
+    case z19.ZodFirstPartyTypeKind.ZodNaN:
+    case z19.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodEffects:
+    case z19.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodAny:
+    case z19.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnknown:
+    case z19.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef(refs);
-    case zod.ZodFirstPartyTypeKind.ZodDefault:
+    case z19.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBranded:
+    case z19.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodReadonly:
+    case z19.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodCatch:
+    case z19.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodPipeline:
+    case z19.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodFunction:
-    case zod.ZodFirstPartyTypeKind.ZodVoid:
-    case zod.ZodFirstPartyTypeKind.ZodSymbol:
+    case z19.ZodFirstPartyTypeKind.ZodFunction:
+    case z19.ZodFirstPartyTypeKind.ZodVoid:
+    case z19.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)();
@@ -2038,7 +2044,7 @@ function patchRecordSchemas(schema) {
   const def = schema._zod?.def;
   if (def?.type === "record" && def.keyType && !def.valueType) {
     def.valueType = def.keyType;
-    def.keyType = zod.z.string();
+    def.keyType = z19.z.string();
   }
   if (!def) return schema;
   if (def.type === "object" && def.shape) {
@@ -2080,9 +2086,9 @@ function patchRecordSchemas(schema) {
 }
 function zodToJsonSchema2(zodSchema5, target = "jsonSchema7", strategy = "relative") {
   const fn = "toJSONSchema";
-  if (fn in zod.z) {
+  if (fn in z19.z) {
     patchRecordSchemas(zodSchema5);
-    return zod.z[fn](zodSchema5, {
+    return z19.z[fn](zodSchema5, {
       unrepresentable: "any",
       override: (ctx) => {
         const def = ctx.zodSchema?._def || ctx.zodSchema?._zod?.def;
@@ -4006,11 +4012,11 @@ var NoObjectGeneratedError = class extends chunkLPM6BBAX_cjs.AISDKError {
   }
 };
 _a4 = symbol4;
-var dataContentSchema = zod.z.union([
-  zod.z.string(),
-  zod.z.instanceof(Uint8Array),
-  zod.z.instanceof(ArrayBuffer),
-  zod.z.custom(
+var dataContentSchema = z19.z.union([
+  z19.z.string(),
+  z19.z.instanceof(Uint8Array),
+  z19.z.instanceof(ArrayBuffer),
+  z19.z.custom(
     // Buffer might not be available in some environments such as CloudFlare:
     (value) => {
       var _a172, _b8;
@@ -4019,102 +4025,102 @@ var dataContentSchema = zod.z.union([
     { message: "Must be a Buffer" }
   )
 ]);
-var jsonValueSchema = zod.z.lazy(
-  () => zod.z.union([
-    zod.z.null(),
-    zod.z.string(),
-    zod.z.number(),
-    zod.z.boolean(),
-    zod.z.record(zod.z.string(), jsonValueSchema),
-    zod.z.array(jsonValueSchema)
+var jsonValueSchema = z19.z.lazy(
+  () => z19.z.union([
+    z19.z.null(),
+    z19.z.string(),
+    z19.z.number(),
+    z19.z.boolean(),
+    z19.z.record(z19.z.string(), jsonValueSchema),
+    z19.z.array(jsonValueSchema)
   ])
 );
-var providerMetadataSchema = zod.z.record(
-  zod.z.string(),
-  zod.z.record(zod.z.string(), jsonValueSchema)
+var providerMetadataSchema = z19.z.record(
+  z19.z.string(),
+  z19.z.record(z19.z.string(), jsonValueSchema)
 );
-var toolResultContentSchema = zod.z.array(
-  zod.z.union([
-    zod.z.object({ type: zod.z.literal("text"), text: zod.z.string() }),
-    zod.z.object({
-      type: zod.z.literal("image"),
-      data: zod.z.string(),
-      mimeType: zod.z.string().optional()
+var toolResultContentSchema = z19.z.array(
+  z19.z.union([
+    z19.z.object({ type: z19.z.literal("text"), text: z19.z.string() }),
+    z19.z.object({
+      type: z19.z.literal("image"),
+      data: z19.z.string(),
+      mimeType: z19.z.string().optional()
     })
   ])
 );
-var textPartSchema = zod.z.object({
-  type: zod.z.literal("text"),
-  text: zod.z.string(),
+var textPartSchema = z19.z.object({
+  type: z19.z.literal("text"),
+  text: z19.z.string(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var imagePartSchema = zod.z.object({
-  type: zod.z.literal("image"),
-  image: zod.z.union([dataContentSchema, zod.z.instanceof(URL)]),
-  mimeType: zod.z.string().optional(),
+var imagePartSchema = z19.z.object({
+  type: z19.z.literal("image"),
+  image: z19.z.union([dataContentSchema, z19.z.instanceof(URL)]),
+  mimeType: z19.z.string().optional(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var filePartSchema = zod.z.object({
-  type: zod.z.literal("file"),
-  data: zod.z.union([dataContentSchema, zod.z.instanceof(URL)]),
-  filename: zod.z.string().optional(),
-  mimeType: zod.z.string(),
+var filePartSchema = z19.z.object({
+  type: z19.z.literal("file"),
+  data: z19.z.union([dataContentSchema, z19.z.instanceof(URL)]),
+  filename: z19.z.string().optional(),
+  mimeType: z19.z.string(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var reasoningPartSchema = zod.z.object({
-  type: zod.z.literal("reasoning"),
-  text: zod.z.string(),
+var reasoningPartSchema = z19.z.object({
+  type: z19.z.literal("reasoning"),
+  text: z19.z.string(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var redactedReasoningPartSchema = zod.z.object({
-  type: zod.z.literal("redacted-reasoning"),
-  data: zod.z.string(),
+var redactedReasoningPartSchema = z19.z.object({
+  type: z19.z.literal("redacted-reasoning"),
+  data: z19.z.string(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var toolCallPartSchema = zod.z.object({
-  type: zod.z.literal("tool-call"),
-  toolCallId: zod.z.string(),
-  toolName: zod.z.string(),
-  args: zod.z.unknown(),
+var toolCallPartSchema = z19.z.object({
+  type: z19.z.literal("tool-call"),
+  toolCallId: z19.z.string(),
+  toolName: z19.z.string(),
+  args: z19.z.unknown(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var toolResultPartSchema = zod.z.object({
-  type: zod.z.literal("tool-result"),
-  toolCallId: zod.z.string(),
-  toolName: zod.z.string(),
-  result: zod.z.unknown(),
+var toolResultPartSchema = z19.z.object({
+  type: z19.z.literal("tool-result"),
+  toolCallId: z19.z.string(),
+  toolName: z19.z.string(),
+  result: z19.z.unknown(),
   content: toolResultContentSchema.optional(),
-  isError: zod.z.boolean().optional(),
+  isError: z19.z.boolean().optional(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var coreSystemMessageSchema = zod.z.object({
-  role: zod.z.literal("system"),
-  content: zod.z.string(),
+var coreSystemMessageSchema = z19.z.object({
+  role: z19.z.literal("system"),
+  content: z19.z.string(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var coreUserMessageSchema = zod.z.object({
-  role: zod.z.literal("user"),
-  content: zod.z.union([
-    zod.z.string(),
-    zod.z.array(zod.z.union([textPartSchema, imagePartSchema, filePartSchema]))
+var coreUserMessageSchema = z19.z.object({
+  role: z19.z.literal("user"),
+  content: z19.z.union([
+    z19.z.string(),
+    z19.z.array(z19.z.union([textPartSchema, imagePartSchema, filePartSchema]))
   ]),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var coreAssistantMessageSchema = zod.z.object({
-  role: zod.z.literal("assistant"),
-  content: zod.z.union([
-    zod.z.string(),
-    zod.z.array(
-      zod.z.union([
+var coreAssistantMessageSchema = z19.z.object({
+  role: z19.z.literal("assistant"),
+  content: z19.z.union([
+    z19.z.string(),
+    z19.z.array(
+      z19.z.union([
         textPartSchema,
         filePartSchema,
         reasoningPartSchema,
@@ -4126,13 +4132,13 @@ var coreAssistantMessageSchema = zod.z.object({
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-var coreToolMessageSchema = zod.z.object({
-  role: zod.z.literal("tool"),
-  content: zod.z.array(toolResultPartSchema),
+var coreToolMessageSchema = z19.z.object({
+  role: z19.z.literal("tool"),
+  content: z19.z.array(toolResultPartSchema),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
-zod.z.union([
+z19.z.union([
   coreSystemMessageSchema,
   coreUserMessageSchema,
   coreAssistantMessageSchema,
@@ -4342,125 +4348,125 @@ chunkLPM6BBAX_cjs.createIdGenerator({
   prefix: "msg",
   size: 24
 });
-var ClientOrServerImplementationSchema = zod.z.object({
-  name: zod.z.string(),
-  version: zod.z.string()
+var ClientOrServerImplementationSchema = z19.z.object({
+  name: z19.z.string(),
+  version: z19.z.string()
 }).passthrough();
-var BaseParamsSchema = zod.z.object({
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
+var BaseParamsSchema = z19.z.object({
+  _meta: z19.z.optional(z19.z.object({}).passthrough())
 }).passthrough();
 var ResultSchema = BaseParamsSchema;
-var RequestSchema = zod.z.object({
-  method: zod.z.string(),
-  params: zod.z.optional(BaseParamsSchema)
+var RequestSchema = z19.z.object({
+  method: z19.z.string(),
+  params: z19.z.optional(BaseParamsSchema)
 });
-var ServerCapabilitiesSchema = zod.z.object({
-  experimental: zod.z.optional(zod.z.object({}).passthrough()),
-  logging: zod.z.optional(zod.z.object({}).passthrough()),
-  prompts: zod.z.optional(
-    zod.z.object({
-      listChanged: zod.z.optional(zod.z.boolean())
+var ServerCapabilitiesSchema = z19.z.object({
+  experimental: z19.z.optional(z19.z.object({}).passthrough()),
+  logging: z19.z.optional(z19.z.object({}).passthrough()),
+  prompts: z19.z.optional(
+    z19.z.object({
+      listChanged: z19.z.optional(z19.z.boolean())
     }).passthrough()
   ),
-  resources: zod.z.optional(
-    zod.z.object({
-      subscribe: zod.z.optional(zod.z.boolean()),
-      listChanged: zod.z.optional(zod.z.boolean())
+  resources: z19.z.optional(
+    z19.z.object({
+      subscribe: z19.z.optional(z19.z.boolean()),
+      listChanged: z19.z.optional(z19.z.boolean())
     }).passthrough()
   ),
-  tools: zod.z.optional(
-    zod.z.object({
-      listChanged: zod.z.optional(zod.z.boolean())
+  tools: z19.z.optional(
+    z19.z.object({
+      listChanged: z19.z.optional(z19.z.boolean())
     }).passthrough()
   )
 }).passthrough();
 ResultSchema.extend({
-  protocolVersion: zod.z.string(),
+  protocolVersion: z19.z.string(),
   capabilities: ServerCapabilitiesSchema,
   serverInfo: ClientOrServerImplementationSchema,
-  instructions: zod.z.optional(zod.z.string())
+  instructions: z19.z.optional(z19.z.string())
 });
 var PaginatedResultSchema = ResultSchema.extend({
-  nextCursor: zod.z.optional(zod.z.string())
+  nextCursor: z19.z.optional(z19.z.string())
 });
-var ToolSchema = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.optional(zod.z.string()),
-  inputSchema: zod.z.object({
-    type: zod.z.literal("object"),
-    properties: zod.z.optional(zod.z.object({}).passthrough())
+var ToolSchema = z19.z.object({
+  name: z19.z.string(),
+  description: z19.z.optional(z19.z.string()),
+  inputSchema: z19.z.object({
+    type: z19.z.literal("object"),
+    properties: z19.z.optional(z19.z.object({}).passthrough())
   }).passthrough()
 }).passthrough();
 PaginatedResultSchema.extend({
-  tools: zod.z.array(ToolSchema)
+  tools: z19.z.array(ToolSchema)
 });
-var TextContentSchema = zod.z.object({
-  type: zod.z.literal("text"),
-  text: zod.z.string()
+var TextContentSchema = z19.z.object({
+  type: z19.z.literal("text"),
+  text: z19.z.string()
 }).passthrough();
-var ImageContentSchema = zod.z.object({
-  type: zod.z.literal("image"),
-  data: zod.z.string().base64(),
-  mimeType: zod.z.string()
+var ImageContentSchema = z19.z.object({
+  type: z19.z.literal("image"),
+  data: z19.z.string().base64(),
+  mimeType: z19.z.string()
 }).passthrough();
-var ResourceContentsSchema = zod.z.object({
+var ResourceContentsSchema = z19.z.object({
   /**
    * The URI of this resource.
    */
-  uri: zod.z.string(),
+  uri: z19.z.string(),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: zod.z.optional(zod.z.string())
+  mimeType: z19.z.optional(z19.z.string())
 }).passthrough();
 var TextResourceContentsSchema = ResourceContentsSchema.extend({
-  text: zod.z.string()
+  text: z19.z.string()
 });
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
-  blob: zod.z.string().base64()
+  blob: z19.z.string().base64()
 });
-var EmbeddedResourceSchema = zod.z.object({
-  type: zod.z.literal("resource"),
-  resource: zod.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
+var EmbeddedResourceSchema = z19.z.object({
+  type: z19.z.literal("resource"),
+  resource: z19.z.union([TextResourceContentsSchema, BlobResourceContentsSchema])
 }).passthrough();
 ResultSchema.extend({
-  content: zod.z.array(
-    zod.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
+  content: z19.z.array(
+    z19.z.union([TextContentSchema, ImageContentSchema, EmbeddedResourceSchema])
   ),
-  isError: zod.z.boolean().default(false).optional()
+  isError: z19.z.boolean().default(false).optional()
 }).or(
   ResultSchema.extend({
-    toolResult: zod.z.unknown()
+    toolResult: z19.z.unknown()
   })
 );
 var JSONRPC_VERSION = "2.0";
-var JSONRPCRequestSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()])
+var JSONRPCRequestSchema = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION),
+  id: z19.z.union([z19.z.string(), z19.z.number().int()])
 }).merge(RequestSchema).strict();
-var JSONRPCResponseSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()]),
+var JSONRPCResponseSchema = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION),
+  id: z19.z.union([z19.z.string(), z19.z.number().int()]),
   result: ResultSchema
 }).strict();
-var JSONRPCErrorSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()]),
-  error: zod.z.object({
-    code: zod.z.number().int(),
-    message: zod.z.string(),
-    data: zod.z.optional(zod.z.unknown())
+var JSONRPCErrorSchema = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION),
+  id: z19.z.union([z19.z.string(), z19.z.number().int()]),
+  error: z19.z.object({
+    code: z19.z.number().int(),
+    message: z19.z.string(),
+    data: z19.z.optional(z19.z.unknown())
   })
 }).strict();
-var JSONRPCNotificationSchema = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION)
+var JSONRPCNotificationSchema = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION)
 }).merge(
-  zod.z.object({
-    method: zod.z.string(),
-    params: zod.z.optional(BaseParamsSchema)
+  z19.z.object({
+    method: z19.z.string(),
+    params: z19.z.optional(BaseParamsSchema)
   })
 ).strict();
-zod.z.union([
+z19.z.union([
   JSONRPCRequestSchema,
   JSONRPCNotificationSchema,
   JSONRPCResponseSchema,
@@ -10038,26 +10044,26 @@ function convertJsonSchemaToZod2(schema) {
   }
   if (schema.const !== void 0) {
     if (typeof schema.const === "string") {
-      return addMetadata(zod.z.literal(schema.const), schema);
+      return addMetadata(z19.z.literal(schema.const), schema);
     } else if (typeof schema.const === "number") {
-      return addMetadata(zod.z.literal(schema.const), schema);
+      return addMetadata(z19.z.literal(schema.const), schema);
     } else if (typeof schema.const === "boolean") {
-      return addMetadata(zod.z.literal(schema.const), schema);
+      return addMetadata(z19.z.literal(schema.const), schema);
     } else if (schema.const === null) {
-      return addMetadata(zod.z.null(), schema);
+      return addMetadata(z19.z.null(), schema);
     }
-    return addMetadata(zod.z.literal(schema.const), schema);
+    return addMetadata(z19.z.literal(schema.const), schema);
   }
   if (schema.type) {
     switch (schema.type) {
       case "string": {
         if (schema.enum) {
           if (schema.enum.length === 0) {
-            return addMetadata(zod.z.string(), schema);
+            return addMetadata(z19.z.string(), schema);
           }
-          return addMetadata(zod.z.enum(schema.enum), schema);
+          return addMetadata(z19.z.enum(schema.enum), schema);
         }
-        let stringSchema = zod.z.string();
+        let stringSchema = z19.z.string();
         if (schema.minLength !== void 0) {
           stringSchema = stringSchema.min(schema.minLength);
         }
@@ -10074,18 +10080,18 @@ function convertJsonSchemaToZod2(schema) {
       case "integer": {
         if (schema.enum) {
           if (schema.enum.length === 0) {
-            return addMetadata(zod.z.number(), schema);
+            return addMetadata(z19.z.number(), schema);
           }
-          const options = schema.enum.map((val) => zod.z.literal(val));
+          const options = schema.enum.map((val) => z19.z.literal(val));
           if (options.length === 1) {
             return addMetadata(options[0], schema);
           }
           if (options.length >= 2) {
-            const unionSchema = zod.z.union([options[0], options[1], ...options.slice(2)]);
+            const unionSchema = z19.z.union([options[0], options[1], ...options.slice(2)]);
             return addMetadata(unionSchema, schema);
           }
         }
-        let numberSchema = schema.type === "integer" ? zod.z.number().int() : zod.z.number();
+        let numberSchema = schema.type === "integer" ? z19.z.number().int() : z19.z.number();
         if (schema.minimum !== void 0) {
           numberSchema = numberSchema.min(schema.minimum);
         }
@@ -10106,20 +10112,20 @@ function convertJsonSchemaToZod2(schema) {
       case "boolean":
         if (schema.enum) {
           if (schema.enum.length === 0) {
-            return addMetadata(zod.z.boolean(), schema);
+            return addMetadata(z19.z.boolean(), schema);
           }
-          const options = schema.enum.map((val) => zod.z.literal(val));
+          const options = schema.enum.map((val) => z19.z.literal(val));
           if (options.length === 1) {
             return addMetadata(options[0], schema);
           }
           if (options.length >= 2) {
-            const unionSchema = zod.z.union([options[0], options[1], ...options.slice(2)]);
+            const unionSchema = z19.z.union([options[0], options[1], ...options.slice(2)]);
             return addMetadata(unionSchema, schema);
           }
         }
-        return addMetadata(zod.z.boolean(), schema);
+        return addMetadata(z19.z.boolean(), schema);
       case "null":
-        return addMetadata(zod.z.null(), schema);
+        return addMetadata(z19.z.null(), schema);
       case "object":
         if (schema.properties) {
           const shape = {};
@@ -10142,19 +10148,19 @@ function convertJsonSchemaToZod2(schema) {
           }
           let zodSchema5;
           if (schema.additionalProperties !== false) {
-            zodSchema5 = zod.z.object(shape).passthrough();
+            zodSchema5 = z19.z.object(shape).passthrough();
           } else {
-            zodSchema5 = zod.z.object(shape);
+            zodSchema5 = z19.z.object(shape);
           }
           return addMetadata(zodSchema5, schema);
         }
-        return addMetadata(zod.z.object({}), schema);
+        return addMetadata(z19.z.object({}), schema);
       case "array": {
         let arraySchema;
         if (schema.items) {
-          arraySchema = zod.z.array(convertJsonSchemaToZod2(schema.items));
+          arraySchema = z19.z.array(convertJsonSchemaToZod2(schema.items));
         } else {
-          arraySchema = zod.z.array(zod.z.any());
+          arraySchema = z19.z.array(z19.z.any());
         }
         if (schema.minItems !== void 0) {
           arraySchema = arraySchema.min(schema.minItems);
@@ -10187,18 +10193,18 @@ function convertJsonSchemaToZod2(schema) {
   }
   if (schema.enum) {
     if (schema.enum.length === 0) {
-      return addMetadata(zod.z.never(), schema);
+      return addMetadata(z19.z.never(), schema);
     }
     const allStrings = schema.enum.every((val) => typeof val === "string");
     if (allStrings) {
-      return addMetadata(zod.z.enum(schema.enum), schema);
+      return addMetadata(z19.z.enum(schema.enum), schema);
     } else {
-      const options = schema.enum.map((val) => zod.z.literal(val));
+      const options = schema.enum.map((val) => z19.z.literal(val));
       if (options.length === 1) {
         return addMetadata(options[0], schema);
       }
       if (options.length >= 2) {
-        const unionSchema = zod.z.union([options[0], options[1], ...options.slice(2)]);
+        const unionSchema = z19.z.union([options[0], options[1], ...options.slice(2)]);
         return addMetadata(unionSchema, schema);
       }
     }
@@ -10206,15 +10212,15 @@ function convertJsonSchemaToZod2(schema) {
   if (schema.anyOf && schema.anyOf.length >= 2) {
     const schemas = schema.anyOf.map(convertJsonSchemaToZod2);
     return addMetadata(
-      zod.z.union([schemas[0], schemas[1], ...schemas.slice(2)]),
+      z19.z.union([schemas[0], schemas[1], ...schemas.slice(2)]),
       schema
     );
   }
   if (schema.allOf) {
     return addMetadata(
       schema.allOf.reduce(
-        (acc, s) => zod.z.intersection(acc, convertJsonSchemaToZod2(s)),
-        zod.z.object({})
+        (acc, s) => z19.z.intersection(acc, convertJsonSchemaToZod2(s)),
+        z19.z.object({})
       ),
       schema
     );
@@ -10222,11 +10228,11 @@ function convertJsonSchemaToZod2(schema) {
   if (schema.oneOf && schema.oneOf.length >= 2) {
     const schemas = schema.oneOf.map(convertJsonSchemaToZod2);
     return addMetadata(
-      zod.z.union([schemas[0], schemas[1], ...schemas.slice(2)]),
+      z19.z.union([schemas[0], schemas[1], ...schemas.slice(2)]),
       schema
     );
   }
-  return addMetadata(zod.z.any(), schema);
+  return addMetadata(z19.z.any(), schema);
 }
 var __create = Object.create;
 var __defProp3 = Object.defineProperty;
@@ -10685,7 +10691,7 @@ function parseArrayDef3(def, refs) {
   const res = {
     type: "array"
   };
-  if (def.type?._def && def.type?._def?.typeName !== zod.ZodFirstPartyTypeKind.ZodAny) {
+  if (def.type?._def && def.type?._def?.typeName !== z19.ZodFirstPartyTypeKind.ZodAny) {
     res.items = parseDef3(def.type._def, {
       ...refs,
       currentPath: [...refs.currentPath, "items"]
@@ -11202,7 +11208,7 @@ function parseRecordDef3(def, refs) {
   if (refs.target === "openAi") {
     console.warn("Warning: OpenAI may not support records in schemas! Try an array of key-value pairs instead.");
   }
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
+  if (refs.target === "openApi3" && def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       type: "object",
       required: def.keyType._def.values,
@@ -11226,20 +11232,20 @@ function parseRecordDef3(def, refs) {
   if (refs.target === "openApi3") {
     return schema;
   }
-  if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
+  if (def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
     const { type, ...keyType } = parseStringDef3(def.keyType._def, refs);
     return {
       ...schema,
       propertyNames: keyType
     };
-  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodEnum) {
+  } else if (def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodEnum) {
     return {
       ...schema,
       propertyNames: {
         enum: def.keyType._def.values
       }
     };
-  } else if (def.keyType?._def.typeName === zod.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === zod.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
+  } else if (def.keyType?._def.typeName === z19.ZodFirstPartyTypeKind.ZodBranded && def.keyType._def.type._def.typeName === z19.ZodFirstPartyTypeKind.ZodString && def.keyType._def.type._def.checks?.length) {
     const { type, ...keyType } = parseBrandedDef3(def.keyType._def, refs);
     return {
       ...schema,
@@ -11605,73 +11611,73 @@ var parseReadonlyDef3 = (def, refs) => {
 };
 var selectParser3 = (def, typeName, refs) => {
   switch (typeName) {
-    case zod.ZodFirstPartyTypeKind.ZodString:
+    case z19.ZodFirstPartyTypeKind.ZodString:
       return parseStringDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNumber:
+    case z19.ZodFirstPartyTypeKind.ZodNumber:
       return parseNumberDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodObject:
+    case z19.ZodFirstPartyTypeKind.ZodObject:
       return parseObjectDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBigInt:
+    case z19.ZodFirstPartyTypeKind.ZodBigInt:
       return parseBigintDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBoolean:
+    case z19.ZodFirstPartyTypeKind.ZodBoolean:
       return parseBooleanDef3();
-    case zod.ZodFirstPartyTypeKind.ZodDate:
+    case z19.ZodFirstPartyTypeKind.ZodDate:
       return parseDateDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUndefined:
+    case z19.ZodFirstPartyTypeKind.ZodUndefined:
       return parseUndefinedDef3(refs);
-    case zod.ZodFirstPartyTypeKind.ZodNull:
+    case z19.ZodFirstPartyTypeKind.ZodNull:
       return parseNullDef3(refs);
-    case zod.ZodFirstPartyTypeKind.ZodArray:
+    case z19.ZodFirstPartyTypeKind.ZodArray:
       return parseArrayDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnion:
-    case zod.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
+    case z19.ZodFirstPartyTypeKind.ZodUnion:
+    case z19.ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
       return parseUnionDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodIntersection:
+    case z19.ZodFirstPartyTypeKind.ZodIntersection:
       return parseIntersectionDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodTuple:
+    case z19.ZodFirstPartyTypeKind.ZodTuple:
       return parseTupleDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodRecord:
+    case z19.ZodFirstPartyTypeKind.ZodRecord:
       return parseRecordDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLiteral:
+    case z19.ZodFirstPartyTypeKind.ZodLiteral:
       return parseLiteralDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodEnum:
+    case z19.ZodFirstPartyTypeKind.ZodEnum:
       return parseEnumDef3(def);
-    case zod.ZodFirstPartyTypeKind.ZodNativeEnum:
+    case z19.ZodFirstPartyTypeKind.ZodNativeEnum:
       return parseNativeEnumDef3(def);
-    case zod.ZodFirstPartyTypeKind.ZodNullable:
+    case z19.ZodFirstPartyTypeKind.ZodNullable:
       return parseNullableDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodOptional:
+    case z19.ZodFirstPartyTypeKind.ZodOptional:
       return parseOptionalDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodMap:
+    case z19.ZodFirstPartyTypeKind.ZodMap:
       return parseMapDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodSet:
+    case z19.ZodFirstPartyTypeKind.ZodSet:
       return parseSetDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodLazy:
+    case z19.ZodFirstPartyTypeKind.ZodLazy:
       return () => def.getter()._def;
-    case zod.ZodFirstPartyTypeKind.ZodPromise:
+    case z19.ZodFirstPartyTypeKind.ZodPromise:
       return parsePromiseDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodNaN:
-    case zod.ZodFirstPartyTypeKind.ZodNever:
+    case z19.ZodFirstPartyTypeKind.ZodNaN:
+    case z19.ZodFirstPartyTypeKind.ZodNever:
       return parseNeverDef3(refs);
-    case zod.ZodFirstPartyTypeKind.ZodEffects:
+    case z19.ZodFirstPartyTypeKind.ZodEffects:
       return parseEffectsDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodAny:
+    case z19.ZodFirstPartyTypeKind.ZodAny:
       return parseAnyDef3(refs);
-    case zod.ZodFirstPartyTypeKind.ZodUnknown:
+    case z19.ZodFirstPartyTypeKind.ZodUnknown:
       return parseUnknownDef3(refs);
-    case zod.ZodFirstPartyTypeKind.ZodDefault:
+    case z19.ZodFirstPartyTypeKind.ZodDefault:
       return parseDefaultDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodBranded:
+    case z19.ZodFirstPartyTypeKind.ZodBranded:
       return parseBrandedDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodReadonly:
+    case z19.ZodFirstPartyTypeKind.ZodReadonly:
       return parseReadonlyDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodCatch:
+    case z19.ZodFirstPartyTypeKind.ZodCatch:
       return parseCatchDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodPipeline:
+    case z19.ZodFirstPartyTypeKind.ZodPipeline:
       return parsePipelineDef3(def, refs);
-    case zod.ZodFirstPartyTypeKind.ZodFunction:
-    case zod.ZodFirstPartyTypeKind.ZodVoid:
-    case zod.ZodFirstPartyTypeKind.ZodSymbol:
+    case z19.ZodFirstPartyTypeKind.ZodFunction:
+    case z19.ZodFirstPartyTypeKind.ZodVoid:
+    case z19.ZodFirstPartyTypeKind.ZodSymbol:
       return void 0;
     default:
       return /* @__PURE__ */ ((_) => void 0)();
@@ -13169,11 +13175,11 @@ var NoObjectGeneratedError3 = class extends AISDKError3 {
   }
 };
 _a422 = symbol422;
-var dataContentSchema3 = zod.z.union([
-  zod.z.string(),
-  zod.z.instanceof(Uint8Array),
-  zod.z.instanceof(ArrayBuffer),
-  zod.z.custom(
+var dataContentSchema3 = z19.z.union([
+  z19.z.string(),
+  z19.z.instanceof(Uint8Array),
+  z19.z.instanceof(ArrayBuffer),
+  z19.z.custom(
     // Buffer might not be available in some environments such as CloudFlare:
     (value) => {
       var _a172, _b8;
@@ -13182,102 +13188,102 @@ var dataContentSchema3 = zod.z.union([
     { message: "Must be a Buffer" }
   )
 ]);
-var jsonValueSchema3 = zod.z.lazy(
-  () => zod.z.union([
-    zod.z.null(),
-    zod.z.string(),
-    zod.z.number(),
-    zod.z.boolean(),
-    zod.z.record(zod.z.string(), jsonValueSchema3),
-    zod.z.array(jsonValueSchema3)
+var jsonValueSchema3 = z19.z.lazy(
+  () => z19.z.union([
+    z19.z.null(),
+    z19.z.string(),
+    z19.z.number(),
+    z19.z.boolean(),
+    z19.z.record(z19.z.string(), jsonValueSchema3),
+    z19.z.array(jsonValueSchema3)
   ])
 );
-var providerMetadataSchema3 = zod.z.record(
-  zod.z.string(),
-  zod.z.record(zod.z.string(), jsonValueSchema3)
+var providerMetadataSchema3 = z19.z.record(
+  z19.z.string(),
+  z19.z.record(z19.z.string(), jsonValueSchema3)
 );
-var toolResultContentSchema2 = zod.z.array(
-  zod.z.union([
-    zod.z.object({ type: zod.z.literal("text"), text: zod.z.string() }),
-    zod.z.object({
-      type: zod.z.literal("image"),
-      data: zod.z.string(),
-      mimeType: zod.z.string().optional()
+var toolResultContentSchema2 = z19.z.array(
+  z19.z.union([
+    z19.z.object({ type: z19.z.literal("text"), text: z19.z.string() }),
+    z19.z.object({
+      type: z19.z.literal("image"),
+      data: z19.z.string(),
+      mimeType: z19.z.string().optional()
     })
   ])
 );
-var textPartSchema3 = zod.z.object({
-  type: zod.z.literal("text"),
-  text: zod.z.string(),
+var textPartSchema3 = z19.z.object({
+  type: z19.z.literal("text"),
+  text: z19.z.string(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var imagePartSchema3 = zod.z.object({
-  type: zod.z.literal("image"),
-  image: zod.z.union([dataContentSchema3, zod.z.instanceof(URL)]),
-  mimeType: zod.z.string().optional(),
+var imagePartSchema3 = z19.z.object({
+  type: z19.z.literal("image"),
+  image: z19.z.union([dataContentSchema3, z19.z.instanceof(URL)]),
+  mimeType: z19.z.string().optional(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var filePartSchema3 = zod.z.object({
-  type: zod.z.literal("file"),
-  data: zod.z.union([dataContentSchema3, zod.z.instanceof(URL)]),
-  filename: zod.z.string().optional(),
-  mimeType: zod.z.string(),
+var filePartSchema3 = z19.z.object({
+  type: z19.z.literal("file"),
+  data: z19.z.union([dataContentSchema3, z19.z.instanceof(URL)]),
+  filename: z19.z.string().optional(),
+  mimeType: z19.z.string(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var reasoningPartSchema3 = zod.z.object({
-  type: zod.z.literal("reasoning"),
-  text: zod.z.string(),
+var reasoningPartSchema3 = z19.z.object({
+  type: z19.z.literal("reasoning"),
+  text: z19.z.string(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var redactedReasoningPartSchema2 = zod.z.object({
-  type: zod.z.literal("redacted-reasoning"),
-  data: zod.z.string(),
+var redactedReasoningPartSchema2 = z19.z.object({
+  type: z19.z.literal("redacted-reasoning"),
+  data: z19.z.string(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var toolCallPartSchema3 = zod.z.object({
-  type: zod.z.literal("tool-call"),
-  toolCallId: zod.z.string(),
-  toolName: zod.z.string(),
-  args: zod.z.unknown(),
+var toolCallPartSchema3 = z19.z.object({
+  type: z19.z.literal("tool-call"),
+  toolCallId: z19.z.string(),
+  toolName: z19.z.string(),
+  args: z19.z.unknown(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var toolResultPartSchema3 = zod.z.object({
-  type: zod.z.literal("tool-result"),
-  toolCallId: zod.z.string(),
-  toolName: zod.z.string(),
-  result: zod.z.unknown(),
+var toolResultPartSchema3 = z19.z.object({
+  type: z19.z.literal("tool-result"),
+  toolCallId: z19.z.string(),
+  toolName: z19.z.string(),
+  result: z19.z.unknown(),
   content: toolResultContentSchema2.optional(),
-  isError: zod.z.boolean().optional(),
+  isError: z19.z.boolean().optional(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var coreSystemMessageSchema2 = zod.z.object({
-  role: zod.z.literal("system"),
-  content: zod.z.string(),
+var coreSystemMessageSchema2 = z19.z.object({
+  role: z19.z.literal("system"),
+  content: z19.z.string(),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var coreUserMessageSchema2 = zod.z.object({
-  role: zod.z.literal("user"),
-  content: zod.z.union([
-    zod.z.string(),
-    zod.z.array(zod.z.union([textPartSchema3, imagePartSchema3, filePartSchema3]))
+var coreUserMessageSchema2 = z19.z.object({
+  role: z19.z.literal("user"),
+  content: z19.z.union([
+    z19.z.string(),
+    z19.z.array(z19.z.union([textPartSchema3, imagePartSchema3, filePartSchema3]))
   ]),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var coreAssistantMessageSchema2 = zod.z.object({
-  role: zod.z.literal("assistant"),
-  content: zod.z.union([
-    zod.z.string(),
-    zod.z.array(
-      zod.z.union([
+var coreAssistantMessageSchema2 = z19.z.object({
+  role: z19.z.literal("assistant"),
+  content: z19.z.union([
+    z19.z.string(),
+    z19.z.array(
+      z19.z.union([
         textPartSchema3,
         filePartSchema3,
         reasoningPartSchema3,
@@ -13289,13 +13295,13 @@ var coreAssistantMessageSchema2 = zod.z.object({
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-var coreToolMessageSchema2 = zod.z.object({
-  role: zod.z.literal("tool"),
-  content: zod.z.array(toolResultPartSchema3),
+var coreToolMessageSchema2 = z19.z.object({
+  role: z19.z.literal("tool"),
+  content: z19.z.array(toolResultPartSchema3),
   providerOptions: providerMetadataSchema3.optional(),
   experimental_providerMetadata: providerMetadataSchema3.optional()
 });
-zod.z.union([
+z19.z.union([
   coreSystemMessageSchema2,
   coreUserMessageSchema2,
   coreAssistantMessageSchema2,
@@ -13505,125 +13511,125 @@ createIdGenerator3({
   prefix: "msg",
   size: 24
 });
-var ClientOrServerImplementationSchema3 = zod.z.object({
-  name: zod.z.string(),
-  version: zod.z.string()
+var ClientOrServerImplementationSchema3 = z19.z.object({
+  name: z19.z.string(),
+  version: z19.z.string()
 }).passthrough();
-var BaseParamsSchema3 = zod.z.object({
-  _meta: zod.z.optional(zod.z.object({}).passthrough())
+var BaseParamsSchema3 = z19.z.object({
+  _meta: z19.z.optional(z19.z.object({}).passthrough())
 }).passthrough();
 var ResultSchema3 = BaseParamsSchema3;
-var RequestSchema3 = zod.z.object({
-  method: zod.z.string(),
-  params: zod.z.optional(BaseParamsSchema3)
+var RequestSchema3 = z19.z.object({
+  method: z19.z.string(),
+  params: z19.z.optional(BaseParamsSchema3)
 });
-var ServerCapabilitiesSchema3 = zod.z.object({
-  experimental: zod.z.optional(zod.z.object({}).passthrough()),
-  logging: zod.z.optional(zod.z.object({}).passthrough()),
-  prompts: zod.z.optional(
-    zod.z.object({
-      listChanged: zod.z.optional(zod.z.boolean())
+var ServerCapabilitiesSchema3 = z19.z.object({
+  experimental: z19.z.optional(z19.z.object({}).passthrough()),
+  logging: z19.z.optional(z19.z.object({}).passthrough()),
+  prompts: z19.z.optional(
+    z19.z.object({
+      listChanged: z19.z.optional(z19.z.boolean())
     }).passthrough()
   ),
-  resources: zod.z.optional(
-    zod.z.object({
-      subscribe: zod.z.optional(zod.z.boolean()),
-      listChanged: zod.z.optional(zod.z.boolean())
+  resources: z19.z.optional(
+    z19.z.object({
+      subscribe: z19.z.optional(z19.z.boolean()),
+      listChanged: z19.z.optional(z19.z.boolean())
     }).passthrough()
   ),
-  tools: zod.z.optional(
-    zod.z.object({
-      listChanged: zod.z.optional(zod.z.boolean())
+  tools: z19.z.optional(
+    z19.z.object({
+      listChanged: z19.z.optional(z19.z.boolean())
     }).passthrough()
   )
 }).passthrough();
 ResultSchema3.extend({
-  protocolVersion: zod.z.string(),
+  protocolVersion: z19.z.string(),
   capabilities: ServerCapabilitiesSchema3,
   serverInfo: ClientOrServerImplementationSchema3,
-  instructions: zod.z.optional(zod.z.string())
+  instructions: z19.z.optional(z19.z.string())
 });
 var PaginatedResultSchema3 = ResultSchema3.extend({
-  nextCursor: zod.z.optional(zod.z.string())
+  nextCursor: z19.z.optional(z19.z.string())
 });
-var ToolSchema3 = zod.z.object({
-  name: zod.z.string(),
-  description: zod.z.optional(zod.z.string()),
-  inputSchema: zod.z.object({
-    type: zod.z.literal("object"),
-    properties: zod.z.optional(zod.z.object({}).passthrough())
+var ToolSchema3 = z19.z.object({
+  name: z19.z.string(),
+  description: z19.z.optional(z19.z.string()),
+  inputSchema: z19.z.object({
+    type: z19.z.literal("object"),
+    properties: z19.z.optional(z19.z.object({}).passthrough())
   }).passthrough()
 }).passthrough();
 PaginatedResultSchema3.extend({
-  tools: zod.z.array(ToolSchema3)
+  tools: z19.z.array(ToolSchema3)
 });
-var TextContentSchema3 = zod.z.object({
-  type: zod.z.literal("text"),
-  text: zod.z.string()
+var TextContentSchema3 = z19.z.object({
+  type: z19.z.literal("text"),
+  text: z19.z.string()
 }).passthrough();
-var ImageContentSchema3 = zod.z.object({
-  type: zod.z.literal("image"),
-  data: zod.z.string().base64(),
-  mimeType: zod.z.string()
+var ImageContentSchema3 = z19.z.object({
+  type: z19.z.literal("image"),
+  data: z19.z.string().base64(),
+  mimeType: z19.z.string()
 }).passthrough();
-var ResourceContentsSchema3 = zod.z.object({
+var ResourceContentsSchema3 = z19.z.object({
   /**
    * The URI of this resource.
    */
-  uri: zod.z.string(),
+  uri: z19.z.string(),
   /**
    * The MIME type of this resource, if known.
    */
-  mimeType: zod.z.optional(zod.z.string())
+  mimeType: z19.z.optional(z19.z.string())
 }).passthrough();
 var TextResourceContentsSchema3 = ResourceContentsSchema3.extend({
-  text: zod.z.string()
+  text: z19.z.string()
 });
 var BlobResourceContentsSchema3 = ResourceContentsSchema3.extend({
-  blob: zod.z.string().base64()
+  blob: z19.z.string().base64()
 });
-var EmbeddedResourceSchema3 = zod.z.object({
-  type: zod.z.literal("resource"),
-  resource: zod.z.union([TextResourceContentsSchema3, BlobResourceContentsSchema3])
+var EmbeddedResourceSchema3 = z19.z.object({
+  type: z19.z.literal("resource"),
+  resource: z19.z.union([TextResourceContentsSchema3, BlobResourceContentsSchema3])
 }).passthrough();
 ResultSchema3.extend({
-  content: zod.z.array(
-    zod.z.union([TextContentSchema3, ImageContentSchema3, EmbeddedResourceSchema3])
+  content: z19.z.array(
+    z19.z.union([TextContentSchema3, ImageContentSchema3, EmbeddedResourceSchema3])
   ),
-  isError: zod.z.boolean().default(false).optional()
+  isError: z19.z.boolean().default(false).optional()
 }).or(
   ResultSchema3.extend({
-    toolResult: zod.z.unknown()
+    toolResult: z19.z.unknown()
   })
 );
 var JSONRPC_VERSION3 = "2.0";
-var JSONRPCRequestSchema3 = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION3),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()])
+var JSONRPCRequestSchema3 = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION3),
+  id: z19.z.union([z19.z.string(), z19.z.number().int()])
 }).merge(RequestSchema3).strict();
-var JSONRPCResponseSchema3 = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION3),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()]),
+var JSONRPCResponseSchema3 = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION3),
+  id: z19.z.union([z19.z.string(), z19.z.number().int()]),
   result: ResultSchema3
 }).strict();
-var JSONRPCErrorSchema3 = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION3),
-  id: zod.z.union([zod.z.string(), zod.z.number().int()]),
-  error: zod.z.object({
-    code: zod.z.number().int(),
-    message: zod.z.string(),
-    data: zod.z.optional(zod.z.unknown())
+var JSONRPCErrorSchema3 = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION3),
+  id: z19.z.union([z19.z.string(), z19.z.number().int()]),
+  error: z19.z.object({
+    code: z19.z.number().int(),
+    message: z19.z.string(),
+    data: z19.z.optional(z19.z.unknown())
   })
 }).strict();
-var JSONRPCNotificationSchema3 = zod.z.object({
-  jsonrpc: zod.z.literal(JSONRPC_VERSION3)
+var JSONRPCNotificationSchema3 = z19.z.object({
+  jsonrpc: z19.z.literal(JSONRPC_VERSION3)
 }).merge(
-  zod.z.object({
-    method: zod.z.string(),
-    params: zod.z.optional(BaseParamsSchema3)
+  z19.z.object({
+    method: z19.z.string(),
+    params: z19.z.optional(BaseParamsSchema3)
   })
 ).strict();
-zod.z.union([
+z19.z.union([
   JSONRPCRequestSchema3,
   JSONRPCNotificationSchema3,
   JSONRPCResponseSchema3,
@@ -13795,7 +13801,7 @@ function convertSchemaToZod(schema) {
   } else {
     const jsonSchemaToConvert = "jsonSchema" in schema ? schema.jsonSchema : schema;
     try {
-      if ("toJSONSchema" in zod.z) {
+      if ("toJSONSchema" in z19.z) {
         return convertJsonSchemaToZod(jsonSchemaToConvert);
       } else {
         return convertJsonSchemaToZod2(jsonSchemaToConvert);
@@ -13812,12 +13818,12 @@ ${e2.stack}` : "\nUnknown error object"));
 // ../memory/dist/index.js
 var updateWorkingMemoryTool = (memoryConfig) => {
   const schema = memoryConfig?.workingMemory?.schema;
-  let inputSchema = zod.z.object({
-    memory: zod.z.string().describe(`The Markdown formatted working memory content to store. This MUST be a string. Never pass an object.`)
+  let inputSchema = z19.z.object({
+    memory: z19.z.string().describe(`The Markdown formatted working memory content to store. This MUST be a string. Never pass an object.`)
   });
   if (schema) {
-    inputSchema = zod.z.object({
-      memory: schema instanceof zod.ZodObject ? schema : convertSchemaToZod({ jsonSchema: schema }).describe(
+    inputSchema = z19.z.object({
+      memory: schema instanceof z19.ZodObject ? schema : convertSchemaToZod({ jsonSchema: schema }).describe(
         `The JSON formatted working memory content to store.`
       )
     });
@@ -13829,7 +13835,7 @@ var updateWorkingMemoryTool = (memoryConfig) => {
     execute: async (inputData, context) => {
       const threadId = context?.agent?.threadId;
       const resourceId = context?.agent?.resourceId;
-      const memory = context?.mastra?.memory || context?.memory;
+      const memory = context?.memory;
       if (!threadId || !memory || !resourceId) {
         throw new Error("Thread ID, Memory instance, and resourceId are required for working memory updates");
       }
@@ -13859,21 +13865,21 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => {
   return tools.createTool({
     id: "update-working-memory",
     description: "Update the working memory with new information.",
-    inputSchema: zod.z.object({
-      newMemory: zod.z.string().optional().describe(
+    inputSchema: z19.z.object({
+      newMemory: z19.z.string().optional().describe(
         `The ${config.workingMemory?.schema ? "JSON" : "Markdown"} formatted working memory content to store`
       ),
-      searchString: zod.z.string().optional().describe(
+      searchString: z19.z.string().optional().describe(
         "The working memory string to find. Will be replaced with the newMemory string. If this is omitted or doesn't exist, the newMemory string will be appended to the end of your working memory. Replacing single lines at a time is encouraged for greater accuracy. If updateReason is not 'append-new-memory', this search string must be provided or the tool call will be rejected."
       ),
-      updateReason: zod.z.enum(["append-new-memory", "clarify-existing-memory", "replace-irrelevant-memory"]).optional().describe(
+      updateReason: z19.z.enum(["append-new-memory", "clarify-existing-memory", "replace-irrelevant-memory"]).optional().describe(
         "The reason you're updating working memory. Passing any value other than 'append-new-memory' requires a searchString to be provided. Defaults to append-new-memory"
       )
     }),
     execute: async (inputData, context) => {
       const threadId = context?.agent?.threadId;
       const resourceId = context?.agent?.resourceId;
-      const memory = context?.mastra?.memory || context?.memory;
+      const memory = context?.memory;
       if (!threadId || !memory || !resourceId) {
         throw new Error("Thread ID, Memory instance, and resourceId are required for working memory updates");
       }
@@ -13919,7 +13925,7 @@ var __experimental_updateWorkingMemoryToolVNext = (config) => {
 var CHARS_PER_TOKEN = 4;
 var DEFAULT_MESSAGE_RANGE = { before: 1, after: 1 };
 var DEFAULT_TOP_K = 4;
-var isZodObject = (v) => v instanceof zod.ZodObject;
+var isZodObject = (v) => v instanceof z19.ZodObject;
 var Memory = class extends memory.MastraMemory {
   constructor(config = {}) {
     super({ name: "Memory", ...config });
@@ -16873,192 +16879,192 @@ z42.z.union([
 
 // ../agent-builder/dist/index.js
 var UNIT_KINDS = ["mcp-server", "tool", "workflow", "agent", "integration", "network", "other"];
-var TemplateUnitSchema = zod.z.object({
-  kind: zod.z.enum(UNIT_KINDS),
-  id: zod.z.string(),
-  file: zod.z.string()
+var TemplateUnitSchema = z19.z.object({
+  kind: z19.z.enum(UNIT_KINDS),
+  id: z19.z.string(),
+  file: z19.z.string()
 });
-zod.z.object({
-  slug: zod.z.string(),
-  ref: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  units: zod.z.array(TemplateUnitSchema)
+z19.z.object({
+  slug: z19.z.string(),
+  ref: z19.z.string().optional(),
+  description: z19.z.string().optional(),
+  units: z19.z.array(TemplateUnitSchema)
 });
-var AgentBuilderInputSchema = zod.z.object({
-  repo: zod.z.string().describe("Git URL or local path of the template repo"),
-  ref: zod.z.string().optional().describe("Tag/branch/commit to checkout (defaults to main/master)"),
-  slug: zod.z.string().optional().describe("Slug for branch/scripts; defaults to inferred from repo"),
-  targetPath: zod.z.string().optional().describe("Project path to merge into; defaults to current directory"),
-  variables: zod.z.record(zod.z.string()).optional().describe("Environment variables to set in .env file")
+var AgentBuilderInputSchema = z19.z.object({
+  repo: z19.z.string().describe("Git URL or local path of the template repo"),
+  ref: z19.z.string().optional().describe("Tag/branch/commit to checkout (defaults to main/master)"),
+  slug: z19.z.string().optional().describe("Slug for branch/scripts; defaults to inferred from repo"),
+  targetPath: z19.z.string().optional().describe("Project path to merge into; defaults to current directory"),
+  variables: z19.z.record(z19.z.string()).optional().describe("Environment variables to set in .env file")
 });
-zod.z.object({
-  slug: zod.z.string(),
-  commitSha: zod.z.string(),
-  templateDir: zod.z.string(),
-  units: zod.z.array(TemplateUnitSchema)
+z19.z.object({
+  slug: z19.z.string(),
+  commitSha: z19.z.string(),
+  templateDir: z19.z.string(),
+  units: z19.z.array(TemplateUnitSchema)
 });
-var CopiedFileSchema = zod.z.object({
-  source: zod.z.string(),
-  destination: zod.z.string(),
-  unit: zod.z.object({
-    kind: zod.z.enum(UNIT_KINDS),
-    id: zod.z.string()
+var CopiedFileSchema = z19.z.object({
+  source: z19.z.string(),
+  destination: z19.z.string(),
+  unit: z19.z.object({
+    kind: z19.z.enum(UNIT_KINDS),
+    id: z19.z.string()
   })
 });
-var ConflictSchema = zod.z.object({
-  unit: zod.z.object({
-    kind: zod.z.enum(UNIT_KINDS),
-    id: zod.z.string()
+var ConflictSchema = z19.z.object({
+  unit: z19.z.object({
+    kind: z19.z.enum(UNIT_KINDS),
+    id: z19.z.string()
   }),
-  issue: zod.z.string(),
-  sourceFile: zod.z.string(),
-  targetFile: zod.z.string()
+  issue: z19.z.string(),
+  sourceFile: z19.z.string(),
+  targetFile: z19.z.string()
 });
-var FileCopyInputSchema = zod.z.object({
-  orderedUnits: zod.z.array(TemplateUnitSchema),
-  templateDir: zod.z.string(),
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
-  variables: zod.z.record(zod.z.string()).optional()
+var FileCopyInputSchema = z19.z.object({
+  orderedUnits: z19.z.array(TemplateUnitSchema),
+  templateDir: z19.z.string(),
+  commitSha: z19.z.string(),
+  slug: z19.z.string(),
+  targetPath: z19.z.string().optional(),
+  variables: z19.z.record(z19.z.string()).optional()
 });
-var FileCopyResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  copiedFiles: zod.z.array(CopiedFileSchema),
-  conflicts: zod.z.array(ConflictSchema),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+var FileCopyResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  copiedFiles: z19.z.array(CopiedFileSchema),
+  conflicts: z19.z.array(ConflictSchema),
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-var ConflictResolutionSchema = zod.z.object({
-  unit: zod.z.object({
-    kind: zod.z.enum(UNIT_KINDS),
-    id: zod.z.string()
+var ConflictResolutionSchema = z19.z.object({
+  unit: z19.z.object({
+    kind: z19.z.enum(UNIT_KINDS),
+    id: z19.z.string()
   }),
-  issue: zod.z.string(),
-  resolution: zod.z.string()
+  issue: z19.z.string(),
+  resolution: z19.z.string()
 });
-var IntelligentMergeInputSchema = zod.z.object({
-  conflicts: zod.z.array(ConflictSchema),
-  copiedFiles: zod.z.array(CopiedFileSchema),
-  templateDir: zod.z.string(),
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
-  branchName: zod.z.string().optional()
+var IntelligentMergeInputSchema = z19.z.object({
+  conflicts: z19.z.array(ConflictSchema),
+  copiedFiles: z19.z.array(CopiedFileSchema),
+  templateDir: z19.z.string(),
+  commitSha: z19.z.string(),
+  slug: z19.z.string(),
+  targetPath: z19.z.string().optional(),
+  branchName: z19.z.string().optional()
 });
-var IntelligentMergeResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  message: zod.z.string(),
-  conflictsResolved: zod.z.array(ConflictResolutionSchema),
-  error: zod.z.string().optional()
+var IntelligentMergeResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  applied: z19.z.boolean(),
+  message: z19.z.string(),
+  conflictsResolved: z19.z.array(ConflictResolutionSchema),
+  error: z19.z.string().optional()
 });
-var ValidationResultsSchema = zod.z.object({
-  valid: zod.z.boolean(),
-  errorsFixed: zod.z.number(),
-  remainingErrors: zod.z.number(),
-  errors: zod.z.array(zod.z.any()).optional()
+var ValidationResultsSchema = z19.z.object({
+  valid: z19.z.boolean(),
+  errorsFixed: z19.z.number(),
+  remainingErrors: z19.z.number(),
+  errors: z19.z.array(z19.z.any()).optional()
   // Include specific validation errors
 });
-var ValidationFixInputSchema = zod.z.object({
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
-  templateDir: zod.z.string(),
-  orderedUnits: zod.z.array(TemplateUnitSchema),
-  copiedFiles: zod.z.array(CopiedFileSchema),
-  conflictsResolved: zod.z.array(ConflictResolutionSchema).optional(),
-  maxIterations: zod.z.number().optional().default(5)
+var ValidationFixInputSchema = z19.z.object({
+  commitSha: z19.z.string(),
+  slug: z19.z.string(),
+  targetPath: z19.z.string().optional(),
+  templateDir: z19.z.string(),
+  orderedUnits: z19.z.array(TemplateUnitSchema),
+  copiedFiles: z19.z.array(CopiedFileSchema),
+  conflictsResolved: z19.z.array(ConflictResolutionSchema).optional(),
+  maxIterations: z19.z.number().optional().default(5)
 });
-var ValidationFixResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  message: zod.z.string(),
+var ValidationFixResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  applied: z19.z.boolean(),
+  message: z19.z.string(),
   validationResults: ValidationResultsSchema,
-  error: zod.z.string().optional()
+  error: z19.z.string().optional()
 });
-var ApplyResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  branchName: zod.z.string().optional(),
-  message: zod.z.string(),
+var ApplyResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  applied: z19.z.boolean(),
+  branchName: z19.z.string().optional(),
+  message: z19.z.string(),
   validationResults: ValidationResultsSchema.optional(),
-  error: zod.z.string().optional(),
-  errors: zod.z.array(zod.z.string()).optional(),
-  stepResults: zod.z.object({
-    cloneSuccess: zod.z.boolean().optional(),
-    analyzeSuccess: zod.z.boolean().optional(),
-    discoverSuccess: zod.z.boolean().optional(),
-    orderSuccess: zod.z.boolean().optional(),
-    prepareBranchSuccess: zod.z.boolean().optional(),
-    packageMergeSuccess: zod.z.boolean().optional(),
-    installSuccess: zod.z.boolean().optional(),
-    copySuccess: zod.z.boolean().optional(),
-    mergeSuccess: zod.z.boolean().optional(),
-    validationSuccess: zod.z.boolean().optional(),
-    filesCopied: zod.z.number(),
-    conflictsSkipped: zod.z.number(),
-    conflictsResolved: zod.z.number()
+  error: z19.z.string().optional(),
+  errors: z19.z.array(z19.z.string()).optional(),
+  stepResults: z19.z.object({
+    cloneSuccess: z19.z.boolean().optional(),
+    analyzeSuccess: z19.z.boolean().optional(),
+    discoverSuccess: z19.z.boolean().optional(),
+    orderSuccess: z19.z.boolean().optional(),
+    prepareBranchSuccess: z19.z.boolean().optional(),
+    packageMergeSuccess: z19.z.boolean().optional(),
+    installSuccess: z19.z.boolean().optional(),
+    copySuccess: z19.z.boolean().optional(),
+    mergeSuccess: z19.z.boolean().optional(),
+    validationSuccess: z19.z.boolean().optional(),
+    filesCopied: z19.z.number(),
+    conflictsSkipped: z19.z.number(),
+    conflictsResolved: z19.z.number()
   }).optional()
 });
-var CloneTemplateResultSchema = zod.z.object({
-  templateDir: zod.z.string(),
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional(),
-  targetPath: zod.z.string().optional()
+var CloneTemplateResultSchema = z19.z.object({
+  templateDir: z19.z.string(),
+  commitSha: z19.z.string(),
+  slug: z19.z.string(),
+  success: z19.z.boolean().optional(),
+  error: z19.z.string().optional(),
+  targetPath: z19.z.string().optional()
 });
-var PackageAnalysisSchema = zod.z.object({
-  name: zod.z.string().optional(),
-  version: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  dependencies: zod.z.record(zod.z.string()).optional(),
-  devDependencies: zod.z.record(zod.z.string()).optional(),
-  peerDependencies: zod.z.record(zod.z.string()).optional(),
-  scripts: zod.z.record(zod.z.string()).optional(),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
+var PackageAnalysisSchema = z19.z.object({
+  name: z19.z.string().optional(),
+  version: z19.z.string().optional(),
+  description: z19.z.string().optional(),
+  dependencies: z19.z.record(z19.z.string()).optional(),
+  devDependencies: z19.z.record(z19.z.string()).optional(),
+  peerDependencies: z19.z.record(z19.z.string()).optional(),
+  scripts: z19.z.record(z19.z.string()).optional(),
+  success: z19.z.boolean().optional(),
+  error: z19.z.string().optional()
 });
-var DiscoveryResultSchema = zod.z.object({
-  units: zod.z.array(TemplateUnitSchema),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
+var DiscoveryResultSchema = z19.z.object({
+  units: z19.z.array(TemplateUnitSchema),
+  success: z19.z.boolean().optional(),
+  error: z19.z.string().optional()
 });
-var OrderedUnitsSchema = zod.z.object({
-  orderedUnits: zod.z.array(TemplateUnitSchema),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
+var OrderedUnitsSchema = z19.z.object({
+  orderedUnits: z19.z.array(TemplateUnitSchema),
+  success: z19.z.boolean().optional(),
+  error: z19.z.string().optional()
 });
-var PackageMergeInputSchema = zod.z.object({
-  commitSha: zod.z.string(),
-  slug: zod.z.string(),
-  targetPath: zod.z.string().optional(),
+var PackageMergeInputSchema = z19.z.object({
+  commitSha: z19.z.string(),
+  slug: z19.z.string(),
+  targetPath: z19.z.string().optional(),
   packageInfo: PackageAnalysisSchema
 });
-var PackageMergeResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  applied: zod.z.boolean(),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+var PackageMergeResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  applied: z19.z.boolean(),
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-var InstallInputSchema = zod.z.object({
-  targetPath: zod.z.string().describe("Path to the project to install packages in")
+var InstallInputSchema = z19.z.object({
+  targetPath: z19.z.string().describe("Path to the project to install packages in")
 });
-var InstallResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  error: zod.z.string().optional()
+var InstallResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  error: z19.z.string().optional()
 });
-var PrepareBranchInputSchema = zod.z.object({
-  slug: zod.z.string(),
-  commitSha: zod.z.string().optional(),
+var PrepareBranchInputSchema = z19.z.object({
+  slug: z19.z.string(),
+  commitSha: z19.z.string().optional(),
   // from clone-template if relevant
-  targetPath: zod.z.string().optional()
+  targetPath: z19.z.string().optional()
 });
-var PrepareBranchResultSchema = zod.z.object({
-  branchName: zod.z.string(),
-  success: zod.z.boolean().optional(),
-  error: zod.z.string().optional()
+var PrepareBranchResultSchema = z19.z.object({
+  branchName: z19.z.string(),
+  success: z19.z.boolean().optional(),
+  error: z19.z.string().optional()
 });
 var exec = util.promisify(child_process.exec);
 var execFile = util.promisify(child_process.execFile);
@@ -17746,6 +17752,7 @@ export const weatherAgent = new Agent({
   tools: { weatherTool },
   memory: new Memory({
     storage: new LibSQLStore({
+      id: 'mastra-memory-storage',
       url: 'file:../mastra.db', // ask user what database to use, use this as the default
     }),
   }),
@@ -17913,6 +17920,7 @@ export const mastra = new Mastra({
   workflows: { weatherWorkflow },
   agents: { weatherAgent },
   storage: new LibSQLStore({
+    id: 'mastra-storage',
     // stores observability, evals, ... into memory storage, if it needs to persist, change to file:../mastra.db
     url: ":memory:",
   }),
@@ -17939,23 +17947,23 @@ export const mastra = new Mastra({
       readFile: tools.createTool({
         id: "read-file",
         description: "Read contents of a file with optional line range selection.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to read"),
-          startLine: zod.z.number().optional().describe("Starting line number (1-indexed)"),
-          endLine: zod.z.number().optional().describe("Ending line number (1-indexed, inclusive)"),
-          encoding: zod.z.string().default("utf-8").describe("File encoding")
+        inputSchema: z19.z.object({
+          filePath: z19.z.string().describe("Path to the file to read"),
+          startLine: z19.z.number().optional().describe("Starting line number (1-indexed)"),
+          endLine: z19.z.number().optional().describe("Ending line number (1-indexed, inclusive)"),
+          encoding: z19.z.string().default("utf-8").describe("File encoding")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          content: zod.z.string().optional(),
-          lines: zod.z.array(zod.z.string()).optional(),
-          metadata: zod.z.object({
-            size: zod.z.number(),
-            totalLines: zod.z.number(),
-            encoding: zod.z.string(),
-            lastModified: zod.z.string()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          content: z19.z.string().optional(),
+          lines: z19.z.array(z19.z.string()).optional(),
+          metadata: z19.z.object({
+            size: z19.z.number(),
+            totalLines: z19.z.number(),
+            encoding: z19.z.string(),
+            lastModified: z19.z.string()
           }).optional(),
-          error: zod.z.string().optional()
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.readFile({ ...inputData, projectPath });
@@ -17964,18 +17972,18 @@ export const mastra = new Mastra({
       writeFile: tools.createTool({
         id: "write-file",
         description: "Write content to a file, with options for creating directories.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to write"),
-          content: zod.z.string().describe("Content to write to the file"),
-          createDirs: zod.z.boolean().default(true).describe("Create parent directories if they don't exist"),
-          encoding: zod.z.string().default("utf-8").describe("File encoding")
+        inputSchema: z19.z.object({
+          filePath: z19.z.string().describe("Path to the file to write"),
+          content: z19.z.string().describe("Content to write to the file"),
+          createDirs: z19.z.boolean().default(true).describe("Create parent directories if they don't exist"),
+          encoding: z19.z.string().default("utf-8").describe("File encoding")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          filePath: zod.z.string(),
-          bytesWritten: zod.z.number().optional(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          filePath: z19.z.string(),
+          bytesWritten: z19.z.number().optional(),
+          message: z19.z.string(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.writeFile({ ...inputData, projectPath });
@@ -17984,30 +17992,30 @@ export const mastra = new Mastra({
       listDirectory: tools.createTool({
         id: "list-directory",
         description: "List contents of a directory with filtering and metadata options.",
-        inputSchema: zod.z.object({
-          path: zod.z.string().describe("Directory path to list"),
-          recursive: zod.z.boolean().default(false).describe("List subdirectories recursively"),
-          includeHidden: zod.z.boolean().default(false).describe("Include hidden files and directories"),
-          pattern: zod.z.string().default("*").describe("Glob pattern to filter files"),
-          maxDepth: zod.z.number().default(10).describe("Maximum recursion depth"),
-          includeMetadata: zod.z.boolean().default(true).describe("Include file metadata")
+        inputSchema: z19.z.object({
+          path: z19.z.string().describe("Directory path to list"),
+          recursive: z19.z.boolean().default(false).describe("List subdirectories recursively"),
+          includeHidden: z19.z.boolean().default(false).describe("Include hidden files and directories"),
+          pattern: z19.z.string().default("*").describe("Glob pattern to filter files"),
+          maxDepth: z19.z.number().default(10).describe("Maximum recursion depth"),
+          includeMetadata: z19.z.boolean().default(true).describe("Include file metadata")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          items: zod.z.array(
-            zod.z.object({
-              name: zod.z.string(),
-              path: zod.z.string(),
-              type: zod.z.enum(["file", "directory", "symlink"]),
-              size: zod.z.number().optional(),
-              lastModified: zod.z.string().optional(),
-              permissions: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          items: z19.z.array(
+            z19.z.object({
+              name: z19.z.string(),
+              path: z19.z.string(),
+              type: z19.z.enum(["file", "directory", "symlink"]),
+              size: z19.z.number().optional(),
+              lastModified: z19.z.string().optional(),
+              permissions: z19.z.string().optional()
             })
           ),
-          totalItems: zod.z.number(),
-          path: zod.z.string(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
+          totalItems: z19.z.number(),
+          path: z19.z.string(),
+          message: z19.z.string(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.listDirectory({ ...inputData, projectPath });
@@ -18016,23 +18024,23 @@ export const mastra = new Mastra({
       executeCommand: tools.createTool({
         id: "execute-command",
         description: "Execute shell commands with proper error handling and output capture.",
-        inputSchema: zod.z.object({
-          command: zod.z.string().describe("Shell command to execute"),
-          workingDirectory: zod.z.string().optional().describe("Working directory for command execution"),
-          timeout: zod.z.number().default(3e4).describe("Timeout in milliseconds"),
-          captureOutput: zod.z.boolean().default(true).describe("Capture command output"),
-          shell: zod.z.string().optional().describe("Shell to use (defaults to system shell)"),
-          env: zod.z.record(zod.z.string()).optional().describe("Environment variables")
+        inputSchema: z19.z.object({
+          command: z19.z.string().describe("Shell command to execute"),
+          workingDirectory: z19.z.string().optional().describe("Working directory for command execution"),
+          timeout: z19.z.number().default(3e4).describe("Timeout in milliseconds"),
+          captureOutput: z19.z.boolean().default(true).describe("Capture command output"),
+          shell: z19.z.string().optional().describe("Shell to use (defaults to system shell)"),
+          env: z19.z.record(z19.z.string()).optional().describe("Environment variables")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          exitCode: zod.z.number().optional(),
-          stdout: zod.z.string().optional(),
-          stderr: zod.z.string().optional(),
-          command: zod.z.string(),
-          workingDirectory: zod.z.string().optional(),
-          executionTime: zod.z.number().optional(),
-          error: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          exitCode: z19.z.number().optional(),
+          stdout: z19.z.string().optional(),
+          stderr: z19.z.string().optional(),
+          command: z19.z.string(),
+          workingDirectory: z19.z.string().optional(),
+          executionTime: z19.z.number().optional(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.executeCommand({
@@ -18045,35 +18053,35 @@ export const mastra = new Mastra({
       taskManager: tools.createTool({
         id: "task-manager",
         description: "Create and manage structured task lists for coding sessions. Use this for complex multi-step tasks to track progress and ensure thoroughness.",
-        inputSchema: zod.z.object({
-          action: zod.z.enum(["create", "update", "list", "complete", "remove"]).describe("Task management action"),
-          tasks: zod.z.array(
-            zod.z.object({
-              id: zod.z.string().describe("Unique task identifier"),
-              content: zod.z.string().describe("Task description, optional if just updating the status").optional(),
-              status: zod.z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
-              priority: zod.z.enum(["high", "medium", "low"]).default("medium").describe("Task priority"),
-              dependencies: zod.z.array(zod.z.string()).optional().describe("IDs of tasks this depends on"),
-              notes: zod.z.string().optional().describe("Additional notes or context")
+        inputSchema: z19.z.object({
+          action: z19.z.enum(["create", "update", "list", "complete", "remove"]).describe("Task management action"),
+          tasks: z19.z.array(
+            z19.z.object({
+              id: z19.z.string().describe("Unique task identifier"),
+              content: z19.z.string().describe("Task description, optional if just updating the status").optional(),
+              status: z19.z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
+              priority: z19.z.enum(["high", "medium", "low"]).default("medium").describe("Task priority"),
+              dependencies: z19.z.array(z19.z.string()).optional().describe("IDs of tasks this depends on"),
+              notes: z19.z.string().optional().describe("Additional notes or context")
             })
           ).optional().describe("Tasks to create or update"),
-          taskId: zod.z.string().optional().describe("Specific task ID for single task operations")
+          taskId: z19.z.string().optional().describe("Specific task ID for single task operations")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          tasks: zod.z.array(
-            zod.z.object({
-              id: zod.z.string(),
-              content: zod.z.string(),
-              status: zod.z.string(),
-              priority: zod.z.string(),
-              dependencies: zod.z.array(zod.z.string()).optional(),
-              notes: zod.z.string().optional(),
-              createdAt: zod.z.string(),
-              updatedAt: zod.z.string()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          tasks: z19.z.array(
+            z19.z.object({
+              id: z19.z.string(),
+              content: z19.z.string(),
+              status: z19.z.string(),
+              priority: z19.z.string(),
+              dependencies: z19.z.array(z19.z.string()).optional(),
+              notes: z19.z.string().optional(),
+              createdAt: z19.z.string(),
+              updatedAt: z19.z.string()
             })
           ),
-          message: zod.z.string()
+          message: z19.z.string()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.manageTaskList(inputData);
@@ -18083,32 +18091,32 @@ export const mastra = new Mastra({
       multiEdit: tools.createTool({
         id: "multi-edit",
         description: "Perform multiple search-replace operations on one or more files in a single atomic operation.",
-        inputSchema: zod.z.object({
-          operations: zod.z.array(
-            zod.z.object({
-              filePath: zod.z.string().describe("Path to the file to edit"),
-              edits: zod.z.array(
-                zod.z.object({
-                  oldString: zod.z.string().describe("Exact text to replace"),
-                  newString: zod.z.string().describe("Replacement text"),
-                  replaceAll: zod.z.boolean().default(false).describe("Replace all occurrences")
+        inputSchema: z19.z.object({
+          operations: z19.z.array(
+            z19.z.object({
+              filePath: z19.z.string().describe("Path to the file to edit"),
+              edits: z19.z.array(
+                z19.z.object({
+                  oldString: z19.z.string().describe("Exact text to replace"),
+                  newString: z19.z.string().describe("Replacement text"),
+                  replaceAll: z19.z.boolean().default(false).describe("Replace all occurrences")
                 })
               ).describe("List of edit operations for this file")
             })
           ).describe("File edit operations to perform"),
-          createBackup: zod.z.boolean().default(false).describe("Create backup files before editing")
+          createBackup: z19.z.boolean().default(false).describe("Create backup files before editing")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          results: zod.z.array(
-            zod.z.object({
-              filePath: zod.z.string(),
-              editsApplied: zod.z.number(),
-              errors: zod.z.array(zod.z.string()),
-              backup: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          results: z19.z.array(
+            z19.z.object({
+              filePath: z19.z.string(),
+              editsApplied: z19.z.number(),
+              errors: z19.z.array(z19.z.string()),
+              backup: z19.z.string().optional()
             })
           ),
-          message: zod.z.string()
+          message: z19.z.string()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.performMultiEdit({ ...inputData, projectPath });
@@ -18117,23 +18125,23 @@ export const mastra = new Mastra({
       replaceLines: tools.createTool({
         id: "replace-lines",
         description: "Replace specific line ranges in files with new content. IMPORTANT: This tool replaces ENTIRE lines, not partial content within lines. Lines are 1-indexed.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to edit"),
-          startLine: zod.z.number().describe("Starting line number to replace (1-indexed, inclusive). Count from the first line = 1"),
-          endLine: zod.z.number().describe(
+        inputSchema: z19.z.object({
+          filePath: z19.z.string().describe("Path to the file to edit"),
+          startLine: z19.z.number().describe("Starting line number to replace (1-indexed, inclusive). Count from the first line = 1"),
+          endLine: z19.z.number().describe(
             "Ending line number to replace (1-indexed, inclusive). To replace single line, use same number as startLine"
           ),
-          newContent: zod.z.string().describe(
+          newContent: z19.z.string().describe(
             'New content to replace the lines with. Use empty string "" to delete lines completely. For multiline content, include \\n characters'
           ),
-          createBackup: zod.z.boolean().default(false).describe("Create backup file before editing")
+          createBackup: z19.z.boolean().default(false).describe("Create backup file before editing")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          message: zod.z.string(),
-          linesReplaced: zod.z.number().optional(),
-          backup: zod.z.string().optional(),
-          error: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          message: z19.z.string(),
+          linesReplaced: z19.z.number().optional(),
+          backup: z19.z.string().optional(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.replaceLines({ ...inputData, projectPath });
@@ -18143,26 +18151,26 @@ export const mastra = new Mastra({
       showFileLines: tools.createTool({
         id: "show-file-lines",
         description: "Show specific lines from a file with line numbers. Useful for debugging before using replaceLines.",
-        inputSchema: zod.z.object({
-          filePath: zod.z.string().describe("Path to the file to examine"),
-          startLine: zod.z.number().optional().describe("Starting line number to show (1-indexed). If not provided, shows all lines"),
-          endLine: zod.z.number().optional().describe(
+        inputSchema: z19.z.object({
+          filePath: z19.z.string().describe("Path to the file to examine"),
+          startLine: z19.z.number().optional().describe("Starting line number to show (1-indexed). If not provided, shows all lines"),
+          endLine: z19.z.number().optional().describe(
             "Ending line number to show (1-indexed, inclusive). If not provided but startLine is, shows only that line"
           ),
-          context: zod.z.number().default(2).describe("Number of context lines to show before and after the range")
+          context: z19.z.number().default(2).describe("Number of context lines to show before and after the range")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          lines: zod.z.array(
-            zod.z.object({
-              lineNumber: zod.z.number(),
-              content: zod.z.string(),
-              isTarget: zod.z.boolean().describe("Whether this line is in the target range")
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          lines: z19.z.array(
+            z19.z.object({
+              lineNumber: z19.z.number(),
+              content: z19.z.string(),
+              isTarget: z19.z.boolean().describe("Whether this line is in the target range")
             })
           ),
-          totalLines: zod.z.number(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
+          totalLines: z19.z.number(),
+          message: z19.z.string(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.showFileLines({ ...inputData, projectPath });
@@ -18172,40 +18180,40 @@ export const mastra = new Mastra({
       smartSearch: tools.createTool({
         id: "smart-search",
         description: "Intelligent search across codebase with context awareness and pattern matching.",
-        inputSchema: zod.z.object({
-          query: zod.z.string().describe("Search query or pattern"),
-          type: zod.z.enum(["text", "regex", "fuzzy", "semantic"]).default("text").describe("Type of search to perform"),
-          scope: zod.z.object({
-            paths: zod.z.array(zod.z.string()).optional().describe("Specific paths to search"),
-            fileTypes: zod.z.array(zod.z.string()).optional().describe("File extensions to include"),
-            excludePaths: zod.z.array(zod.z.string()).optional().describe("Paths to exclude"),
-            maxResults: zod.z.number().default(50).describe("Maximum number of results")
+        inputSchema: z19.z.object({
+          query: z19.z.string().describe("Search query or pattern"),
+          type: z19.z.enum(["text", "regex", "fuzzy", "semantic"]).default("text").describe("Type of search to perform"),
+          scope: z19.z.object({
+            paths: z19.z.array(z19.z.string()).optional().describe("Specific paths to search"),
+            fileTypes: z19.z.array(z19.z.string()).optional().describe("File extensions to include"),
+            excludePaths: z19.z.array(z19.z.string()).optional().describe("Paths to exclude"),
+            maxResults: z19.z.number().default(50).describe("Maximum number of results")
           }).optional(),
-          context: zod.z.object({
-            beforeLines: zod.z.number().default(2).describe("Lines of context before match"),
-            afterLines: zod.z.number().default(2).describe("Lines of context after match"),
-            includeDefinitions: zod.z.boolean().default(false).describe("Include function/class definitions")
+          context: z19.z.object({
+            beforeLines: z19.z.number().default(2).describe("Lines of context before match"),
+            afterLines: z19.z.number().default(2).describe("Lines of context after match"),
+            includeDefinitions: z19.z.boolean().default(false).describe("Include function/class definitions")
           }).optional()
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          matches: zod.z.array(
-            zod.z.object({
-              file: zod.z.string(),
-              line: zod.z.number(),
-              column: zod.z.number().optional(),
-              match: zod.z.string(),
-              context: zod.z.object({
-                before: zod.z.array(zod.z.string()),
-                after: zod.z.array(zod.z.string())
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          matches: z19.z.array(
+            z19.z.object({
+              file: z19.z.string(),
+              line: z19.z.number(),
+              column: z19.z.number().optional(),
+              match: z19.z.string(),
+              context: z19.z.object({
+                before: z19.z.array(z19.z.string()),
+                after: z19.z.array(z19.z.string())
               }),
-              relevance: zod.z.number().optional()
+              relevance: z19.z.number().optional()
             })
           ),
-          summary: zod.z.object({
-            totalMatches: zod.z.number(),
-            filesSearched: zod.z.number(),
-            patterns: zod.z.array(zod.z.string())
+          summary: z19.z.object({
+            totalMatches: z19.z.number(),
+            filesSearched: z19.z.number(),
+            patterns: z19.z.array(z19.z.string())
           })
         }),
         execute: async (inputData) => {
@@ -18215,31 +18223,31 @@ export const mastra = new Mastra({
       validateCode: tools.createTool({
         id: "validate-code",
         description: "Validates code using a fast hybrid approach: syntax \u2192 semantic \u2192 lint. RECOMMENDED: Always provide specific files for optimal performance and accuracy.",
-        inputSchema: zod.z.object({
-          projectPath: zod.z.string().optional().describe("Path to the project to validate (defaults to current project)"),
-          validationType: zod.z.array(zod.z.enum(["types", "lint", "schemas", "tests", "build"])).describe('Types of validation to perform. Recommended: ["types", "lint"] for code quality'),
-          files: zod.z.array(zod.z.string()).optional().describe(
+        inputSchema: z19.z.object({
+          projectPath: z19.z.string().optional().describe("Path to the project to validate (defaults to current project)"),
+          validationType: z19.z.array(z19.z.enum(["types", "lint", "schemas", "tests", "build"])).describe('Types of validation to perform. Recommended: ["types", "lint"] for code quality'),
+          files: z19.z.array(z19.z.string()).optional().describe(
             "RECOMMENDED: Specific files to validate (e.g., files you created/modified). Uses hybrid validation: fast syntax check \u2192 semantic types \u2192 ESLint. Without files, falls back to slower CLI validation."
           )
         }),
-        outputSchema: zod.z.object({
-          valid: zod.z.boolean(),
-          errors: zod.z.array(
-            zod.z.object({
-              type: zod.z.enum(["typescript", "eslint", "schema", "test", "build"]),
-              severity: zod.z.enum(["error", "warning", "info"]),
-              message: zod.z.string(),
-              file: zod.z.string().optional(),
-              line: zod.z.number().optional(),
-              column: zod.z.number().optional(),
-              code: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          valid: z19.z.boolean(),
+          errors: z19.z.array(
+            z19.z.object({
+              type: z19.z.enum(["typescript", "eslint", "schema", "test", "build"]),
+              severity: z19.z.enum(["error", "warning", "info"]),
+              message: z19.z.string(),
+              file: z19.z.string().optional(),
+              line: z19.z.number().optional(),
+              column: z19.z.number().optional(),
+              code: z19.z.string().optional()
             })
           ),
-          summary: zod.z.object({
-            totalErrors: zod.z.number(),
-            totalWarnings: zod.z.number(),
-            validationsPassed: zod.z.array(zod.z.string()),
-            validationsFailed: zod.z.array(zod.z.string())
+          summary: z19.z.object({
+            totalErrors: z19.z.number(),
+            totalWarnings: z19.z.number(),
+            validationsPassed: z19.z.array(z19.z.string()),
+            validationsFailed: z19.z.array(z19.z.string())
           })
         }),
         execute: async (inputData) => {
@@ -18256,31 +18264,31 @@ export const mastra = new Mastra({
       webSearch: tools.createTool({
         id: "web-search",
         description: "Search the web for current information and return structured results.",
-        inputSchema: zod.z.object({
-          query: zod.z.string().describe("Search query"),
-          maxResults: zod.z.number().default(10).describe("Maximum number of results to return"),
-          region: zod.z.string().default("us").describe("Search region/country code"),
-          language: zod.z.string().default("en").describe("Search language"),
-          includeImages: zod.z.boolean().default(false).describe("Include image results"),
-          dateRange: zod.z.enum(["day", "week", "month", "year", "all"]).default("all").describe("Date range filter")
+        inputSchema: z19.z.object({
+          query: z19.z.string().describe("Search query"),
+          maxResults: z19.z.number().default(10).describe("Maximum number of results to return"),
+          region: z19.z.string().default("us").describe("Search region/country code"),
+          language: z19.z.string().default("en").describe("Search language"),
+          includeImages: z19.z.boolean().default(false).describe("Include image results"),
+          dateRange: z19.z.enum(["day", "week", "month", "year", "all"]).default("all").describe("Date range filter")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          query: zod.z.string(),
-          results: zod.z.array(
-            zod.z.object({
-              title: zod.z.string(),
-              url: zod.z.string(),
-              snippet: zod.z.string(),
-              domain: zod.z.string(),
-              publishDate: zod.z.string().optional(),
-              relevanceScore: zod.z.number().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          query: z19.z.string(),
+          results: z19.z.array(
+            z19.z.object({
+              title: z19.z.string(),
+              url: z19.z.string(),
+              snippet: z19.z.string(),
+              domain: z19.z.string(),
+              publishDate: z19.z.string().optional(),
+              relevanceScore: z19.z.number().optional()
             })
           ),
-          totalResults: zod.z.number(),
-          searchTime: zod.z.number(),
-          suggestions: zod.z.array(zod.z.string()).optional(),
-          error: zod.z.string().optional()
+          totalResults: z19.z.number(),
+          searchTime: z19.z.number(),
+          suggestions: z19.z.array(z19.z.string()).optional(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.webSearch(inputData);
@@ -18290,27 +18298,27 @@ export const mastra = new Mastra({
       attemptCompletion: tools.createTool({
         id: "attempt-completion",
         description: "Signal that you believe the requested task has been completed and provide a summary.",
-        inputSchema: zod.z.object({
-          summary: zod.z.string().describe("Summary of what was accomplished"),
-          changes: zod.z.array(
-            zod.z.object({
-              type: zod.z.enum(["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]),
-              description: zod.z.string(),
-              path: zod.z.string().optional()
+        inputSchema: z19.z.object({
+          summary: z19.z.string().describe("Summary of what was accomplished"),
+          changes: z19.z.array(
+            z19.z.object({
+              type: z19.z.enum(["file_created", "file_modified", "file_deleted", "command_executed", "dependency_added"]),
+              description: z19.z.string(),
+              path: z19.z.string().optional()
             })
           ).describe("List of changes made"),
-          validation: zod.z.object({
-            testsRun: zod.z.boolean().default(false),
-            buildsSuccessfully: zod.z.boolean().default(false),
-            manualTestingRequired: zod.z.boolean().default(false)
+          validation: z19.z.object({
+            testsRun: z19.z.boolean().default(false),
+            buildsSuccessfully: z19.z.boolean().default(false),
+            manualTestingRequired: z19.z.boolean().default(false)
           }).describe("Validation status"),
-          nextSteps: zod.z.array(zod.z.string()).optional().describe("Suggested next steps or follow-up actions")
+          nextSteps: z19.z.array(z19.z.string()).optional().describe("Suggested next steps or follow-up actions")
         }),
-        outputSchema: zod.z.object({
-          completionId: zod.z.string(),
-          status: zod.z.enum(["completed", "needs_review", "needs_testing"]),
-          summary: zod.z.string(),
-          confidence: zod.z.number().min(0).max(100)
+        outputSchema: z19.z.object({
+          completionId: z19.z.string(),
+          status: z19.z.enum(["completed", "needs_review", "needs_testing"]),
+          summary: z19.z.string(),
+          confidence: z19.z.number().min(0).max(100)
         }),
         execute: async (inputData) => {
           return await _AgentBuilderDefaults.signalCompletion(inputData);
@@ -18319,24 +18327,24 @@ export const mastra = new Mastra({
       manageProject: tools.createTool({
         id: "manage-project",
         description: "Handles project management including creating project structures, managing dependencies, and package operations.",
-        inputSchema: zod.z.object({
-          action: zod.z.enum(["create", "install", "upgrade"]).describe("The action to perform"),
-          features: zod.z.array(zod.z.string()).optional().describe('Mastra features to include (e.g., ["agents", "memory", "workflows"])'),
-          packages: zod.z.array(
-            zod.z.object({
-              name: zod.z.string(),
-              version: zod.z.string().optional()
+        inputSchema: z19.z.object({
+          action: z19.z.enum(["create", "install", "upgrade"]).describe("The action to perform"),
+          features: z19.z.array(z19.z.string()).optional().describe('Mastra features to include (e.g., ["agents", "memory", "workflows"])'),
+          packages: z19.z.array(
+            z19.z.object({
+              name: z19.z.string(),
+              version: z19.z.string().optional()
             })
           ).optional().describe("Packages to install/upgrade")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          installed: zod.z.array(zod.z.string()).optional(),
-          upgraded: zod.z.array(zod.z.string()).optional(),
-          warnings: zod.z.array(zod.z.string()).optional(),
-          message: zod.z.string().optional(),
-          details: zod.z.string().optional(),
-          error: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          installed: z19.z.array(z19.z.string()).optional(),
+          upgraded: z19.z.array(z19.z.string()).optional(),
+          warnings: z19.z.array(z19.z.string()).optional(),
+          message: z19.z.string().optional(),
+          details: z19.z.string().optional(),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           const { action, features, packages } = inputData;
@@ -18386,19 +18394,19 @@ export const mastra = new Mastra({
       manageServer: tools.createTool({
         id: "manage-server",
         description: "Manages the Mastra server - start, stop, restart, and check status, use the terminal tool to make curl requests to the server. There is an openapi spec for the server at http://localhost:{port}/openapi.json",
-        inputSchema: zod.z.object({
-          action: zod.z.enum(["start", "stop", "restart", "status"]).describe("Server management action"),
-          port: zod.z.number().optional().default(4200).describe("Port to run the server on")
+        inputSchema: z19.z.object({
+          action: z19.z.enum(["start", "stop", "restart", "status"]).describe("Server management action"),
+          port: z19.z.number().optional().default(4200).describe("Port to run the server on")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          status: zod.z.enum(["running", "stopped", "starting", "stopping", "unknown"]),
-          pid: zod.z.number().optional(),
-          port: zod.z.number().optional(),
-          url: zod.z.string().optional(),
-          message: zod.z.string().optional(),
-          stdout: zod.z.array(zod.z.string()).optional().describe("Server output lines captured during startup"),
-          error: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          status: z19.z.enum(["running", "stopped", "starting", "stopping", "unknown"]),
+          pid: z19.z.number().optional(),
+          port: z19.z.number().optional(),
+          url: z19.z.string().optional(),
+          message: z19.z.string().optional(),
+          stdout: z19.z.array(z19.z.string()).optional().describe("Server output lines captured during startup"),
+          error: z19.z.string().optional()
         }),
         execute: async (inputData) => {
           const { action, port } = inputData;
@@ -18468,23 +18476,23 @@ export const mastra = new Mastra({
       httpRequest: tools.createTool({
         id: "http-request",
         description: "Makes HTTP requests to the Mastra server or external APIs for testing and integration",
-        inputSchema: zod.z.object({
-          method: zod.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method"),
-          url: zod.z.string().describe("Full URL or path (if baseUrl provided)"),
-          baseUrl: zod.z.string().optional().describe("Base URL for the server (e.g., http://localhost:4200)"),
-          headers: zod.z.record(zod.z.string()).optional().describe("HTTP headers"),
-          body: zod.z.any().optional().describe("Request body (will be JSON stringified if object)"),
-          timeout: zod.z.number().optional().default(3e4).describe("Request timeout in milliseconds")
+        inputSchema: z19.z.object({
+          method: z19.z.enum(["GET", "POST", "PUT", "DELETE", "PATCH"]).describe("HTTP method"),
+          url: z19.z.string().describe("Full URL or path (if baseUrl provided)"),
+          baseUrl: z19.z.string().optional().describe("Base URL for the server (e.g., http://localhost:4200)"),
+          headers: z19.z.record(z19.z.string()).optional().describe("HTTP headers"),
+          body: z19.z.any().optional().describe("Request body (will be JSON stringified if object)"),
+          timeout: z19.z.number().optional().default(3e4).describe("Request timeout in milliseconds")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          status: zod.z.number().optional(),
-          statusText: zod.z.string().optional(),
-          headers: zod.z.record(zod.z.string()).optional(),
-          data: zod.z.any().optional(),
-          error: zod.z.string().optional(),
-          url: zod.z.string(),
-          method: zod.z.string()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          status: z19.z.number().optional(),
+          statusText: z19.z.string().optional(),
+          headers: z19.z.record(z19.z.string()).optional(),
+          data: z19.z.any().optional(),
+          error: z19.z.string().optional(),
+          url: z19.z.string(),
+          method: z19.z.string()
         }),
         execute: async (inputData) => {
           const { method, url, baseUrl, headers, body, timeout } = inputData;
@@ -20018,6 +20026,7 @@ var AgentBuilder = class extends agent.Agent {
 ${config.instructions}` : "";
     const combinedInstructions = additionalInstructions + AgentBuilderDefaults.DEFAULT_INSTRUCTIONS(config.projectPath);
     const agentConfig = {
+      id: "agent-builder",
       name: "agent-builder",
       description: "An AI agent specialized in generating Mastra agents, tools, and workflows from natural language requirements.",
       instructions: combinedInstructions,
@@ -20296,13 +20305,13 @@ Return the actual exported names of the units, as well as the file names.`,
       - If a directory doesn't exist or has no files, return an empty array
 
       Return the analysis in the exact format specified in the output schema.`;
-      const output = zod.z.object({
-        agents: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-        workflows: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-        tools: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-        mcp: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-        networks: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional(),
-        other: zod.z.array(zod.z.object({ name: zod.z.string(), file: zod.z.string() })).optional()
+      const output = z19.z.object({
+        agents: z19.z.array(z19.z.object({ name: z19.z.string(), file: z19.z.string() })).optional(),
+        workflows: z19.z.array(z19.z.object({ name: z19.z.string(), file: z19.z.string() })).optional(),
+        tools: z19.z.array(z19.z.object({ name: z19.z.string(), file: z19.z.string() })).optional(),
+        mcp: z19.z.array(z19.z.object({ name: z19.z.string(), file: z19.z.string() })).optional(),
+        networks: z19.z.array(z19.z.object({ name: z19.z.string(), file: z19.z.string() })).optional(),
+        other: z19.z.array(z19.z.object({ name: z19.z.string(), file: z19.z.string() })).optional()
       });
       const result = isV2 ? await agent.tryGenerateWithJsonFallback(agent$1, prompt, {
         structuredOutput: {
@@ -20874,14 +20883,14 @@ var intelligentMergeStep = workflows.createStep({
       const copyFileTool = tools.createTool({
         id: "copy-file",
         description: "Copy a file from template to target project (use only for edge cases - most files are already copied programmatically).",
-        inputSchema: zod.z.object({
-          sourcePath: zod.z.string().describe("Path to the source file relative to template directory"),
-          destinationPath: zod.z.string().describe("Path to the destination file relative to target project")
+        inputSchema: z19.z.object({
+          sourcePath: z19.z.string().describe("Path to the source file relative to template directory"),
+          destinationPath: z19.z.string().describe("Path to the destination file relative to target project")
         }),
-        outputSchema: zod.z.object({
-          success: zod.z.boolean(),
-          message: zod.z.string(),
-          error: zod.z.string().optional()
+        outputSchema: z19.z.object({
+          success: z19.z.boolean(),
+          message: z19.z.string(),
+          error: z19.z.string().optional()
         }),
         execute: async (input) => {
           try {
@@ -21297,7 +21306,7 @@ Start by running validateCode with all validation types to get a complete pictur
 
 Previous iterations may have fixed some issues, so start by re-running validateCode to see the current state, then fix any remaining issues.`;
         const isV2 = model.specificationVersion === "v2";
-        const output = zod.z.object({ success: zod.z.boolean() });
+        const output = z19.z.object({ success: z19.z.boolean() });
         const result = isV2 ? await agent.tryStreamWithJsonFallback(validationAgent, iterationPrompt, {
           structuredOutput: {
             schema: output
@@ -21567,35 +21576,35 @@ var determineConflictStrategy = (_unit, _targetFile) => {
 var shouldAbortWorkflow = (stepResult) => {
   return stepResult?.success === false || stepResult?.error;
 };
-var TaskSchema = zod.z.array(
-  zod.z.object({
-    id: zod.z.string().describe("Unique task ID using kebab-case"),
-    content: zod.z.string().describe("Specific, actionable task description"),
-    status: zod.z.enum(["pending", "in_progress", "completed", "blocked"]).default("pending"),
-    priority: zod.z.enum(["high", "medium", "low"]).describe("Task priority"),
-    dependencies: zod.z.array(zod.z.string()).optional().describe("IDs of tasks this depends on"),
-    notes: zod.z.string().describe("Detailed implementation notes and specifics")
+var TaskSchema = z19.z.array(
+  z19.z.object({
+    id: z19.z.string().describe("Unique task ID using kebab-case"),
+    content: z19.z.string().describe("Specific, actionable task description"),
+    status: z19.z.enum(["pending", "in_progress", "completed", "blocked"]).default("pending"),
+    priority: z19.z.enum(["high", "medium", "low"]).describe("Task priority"),
+    dependencies: z19.z.array(z19.z.string()).optional().describe("IDs of tasks this depends on"),
+    notes: z19.z.string().describe("Detailed implementation notes and specifics")
   })
 );
-var QuestionSchema = zod.z.array(
-  zod.z.object({
-    id: zod.z.string().describe("Unique question ID"),
-    question: zod.z.string().describe("Clear, specific question for the user"),
-    type: zod.z.enum(["choice", "text", "boolean"]).describe("Type of answer expected"),
-    options: zod.z.array(zod.z.string()).optional().describe("Options for choice questions"),
-    context: zod.z.string().optional().describe("Additional context or explanation")
+var QuestionSchema = z19.z.array(
+  z19.z.object({
+    id: z19.z.string().describe("Unique question ID"),
+    question: z19.z.string().describe("Clear, specific question for the user"),
+    type: z19.z.enum(["choice", "text", "boolean"]).describe("Type of answer expected"),
+    options: z19.z.array(z19.z.string()).optional().describe("Options for choice questions"),
+    context: z19.z.string().optional().describe("Additional context or explanation")
   })
 );
-var PlanningIterationResultSchema = zod.z.object({
-  success: zod.z.boolean(),
+var PlanningIterationResultSchema = z19.z.object({
+  success: z19.z.boolean(),
   tasks: TaskSchema,
   questions: QuestionSchema,
-  reasoning: zod.z.string(),
-  planComplete: zod.z.boolean(),
-  message: zod.z.string(),
-  error: zod.z.string().optional(),
-  allPreviousQuestions: zod.z.array(zod.z.any()).optional(),
-  allPreviousAnswers: zod.z.record(zod.z.string()).optional()
+  reasoning: z19.z.string(),
+  planComplete: z19.z.boolean(),
+  message: z19.z.string(),
+  error: z19.z.string().optional(),
+  allPreviousQuestions: z19.z.array(z19.z.any()).optional(),
+  allPreviousAnswers: z19.z.record(z19.z.string()).optional()
 });
 var taskPlanningPrompts = {
   planningAgent: {
@@ -21671,180 +21680,180 @@ Create specific tasks and identify any questions that need user clarification.`
     approvalMessage: (tasksCount) => `Please review and approve the ${tasksCount} task(s) for execution:`
   }
 };
-var WorkflowBuilderInputSchema = zod.z.object({
-  workflowName: zod.z.string().optional().describe("Name of the workflow to create or edit"),
-  action: zod.z.enum(["create", "edit"]).describe("Action to perform: create new or edit existing workflow"),
-  description: zod.z.string().optional().describe("Description of what the workflow should do"),
-  requirements: zod.z.string().optional().describe("Detailed requirements for the workflow"),
-  projectPath: zod.z.string().optional().describe("Path to the Mastra project (defaults to current directory)")
+var WorkflowBuilderInputSchema = z19.z.object({
+  workflowName: z19.z.string().optional().describe("Name of the workflow to create or edit"),
+  action: z19.z.enum(["create", "edit"]).describe("Action to perform: create new or edit existing workflow"),
+  description: z19.z.string().optional().describe("Description of what the workflow should do"),
+  requirements: z19.z.string().optional().describe("Detailed requirements for the workflow"),
+  projectPath: z19.z.string().optional().describe("Path to the Mastra project (defaults to current directory)")
 });
-var DiscoveredWorkflowSchema = zod.z.object({
-  name: zod.z.string(),
-  file: zod.z.string(),
-  description: zod.z.string().optional(),
-  inputSchema: zod.z.any().optional(),
-  outputSchema: zod.z.any().optional(),
-  steps: zod.z.array(zod.z.string()).optional()
+var DiscoveredWorkflowSchema = z19.z.object({
+  name: z19.z.string(),
+  file: z19.z.string(),
+  description: z19.z.string().optional(),
+  inputSchema: z19.z.any().optional(),
+  outputSchema: z19.z.any().optional(),
+  steps: z19.z.array(z19.z.string()).optional()
 });
-var WorkflowDiscoveryResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  workflows: zod.z.array(DiscoveredWorkflowSchema),
-  mastraIndexExists: zod.z.boolean(),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+var WorkflowDiscoveryResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  workflows: z19.z.array(DiscoveredWorkflowSchema),
+  mastraIndexExists: z19.z.boolean(),
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-var ProjectDiscoveryResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  structure: zod.z.object({
-    hasWorkflowsDir: zod.z.boolean(),
-    hasAgentsDir: zod.z.boolean(),
-    hasToolsDir: zod.z.boolean(),
-    hasMastraIndex: zod.z.boolean(),
-    existingWorkflows: zod.z.array(zod.z.string()),
-    existingAgents: zod.z.array(zod.z.string()),
-    existingTools: zod.z.array(zod.z.string())
+var ProjectDiscoveryResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  structure: z19.z.object({
+    hasWorkflowsDir: z19.z.boolean(),
+    hasAgentsDir: z19.z.boolean(),
+    hasToolsDir: z19.z.boolean(),
+    hasMastraIndex: z19.z.boolean(),
+    existingWorkflows: z19.z.array(z19.z.string()),
+    existingAgents: z19.z.array(z19.z.string()),
+    existingTools: z19.z.array(z19.z.string())
   }),
-  dependencies: zod.z.record(zod.z.string()),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+  dependencies: z19.z.record(z19.z.string()),
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-var WorkflowResearchResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  documentation: zod.z.object({
-    workflowPatterns: zod.z.array(zod.z.string()),
-    stepExamples: zod.z.array(zod.z.string()),
-    bestPractices: zod.z.array(zod.z.string())
+var WorkflowResearchResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  documentation: z19.z.object({
+    workflowPatterns: z19.z.array(z19.z.string()),
+    stepExamples: z19.z.array(z19.z.string()),
+    bestPractices: z19.z.array(z19.z.string())
   }),
-  webResources: zod.z.array(
-    zod.z.object({
-      title: zod.z.string(),
-      url: zod.z.string(),
-      snippet: zod.z.string(),
-      relevance: zod.z.number()
+  webResources: z19.z.array(
+    z19.z.object({
+      title: z19.z.string(),
+      url: z19.z.string(),
+      snippet: z19.z.string(),
+      relevance: z19.z.number()
     })
   ),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-var TaskManagementResultSchema = zod.z.object({
-  success: zod.z.boolean(),
+var TaskManagementResultSchema = z19.z.object({
+  success: z19.z.boolean(),
   tasks: TaskSchema,
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-var TaskExecutionInputSchema = zod.z.object({
-  action: zod.z.enum(["create", "edit"]),
-  workflowName: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  requirements: zod.z.string().optional(),
+var TaskExecutionInputSchema = z19.z.object({
+  action: z19.z.enum(["create", "edit"]),
+  workflowName: z19.z.string().optional(),
+  description: z19.z.string().optional(),
+  requirements: z19.z.string().optional(),
   tasks: TaskSchema,
-  discoveredWorkflows: zod.z.array(zod.z.any()),
-  projectStructure: zod.z.any(),
-  research: zod.z.any(),
-  projectPath: zod.z.string().optional()
+  discoveredWorkflows: z19.z.array(z19.z.any()),
+  projectStructure: z19.z.any(),
+  research: z19.z.any(),
+  projectPath: z19.z.string().optional()
 });
-var TaskExecutionSuspendSchema = zod.z.object({
+var TaskExecutionSuspendSchema = z19.z.object({
   questions: QuestionSchema,
-  currentProgress: zod.z.string(),
-  completedTasks: zod.z.array(zod.z.string()),
-  message: zod.z.string()
+  currentProgress: z19.z.string(),
+  completedTasks: z19.z.array(z19.z.string()),
+  message: z19.z.string()
 });
-var TaskExecutionResumeSchema = zod.z.object({
-  answers: zod.z.array(
-    zod.z.object({
-      questionId: zod.z.string(),
-      answer: zod.z.string()
+var TaskExecutionResumeSchema = z19.z.object({
+  answers: z19.z.array(
+    z19.z.object({
+      questionId: z19.z.string(),
+      answer: z19.z.string()
     })
   )
 });
-var TaskExecutionResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  filesModified: zod.z.array(zod.z.string()),
-  validationResults: zod.z.object({
-    passed: zod.z.boolean(),
-    errors: zod.z.array(zod.z.string()),
-    warnings: zod.z.array(zod.z.string())
+var TaskExecutionResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  filesModified: z19.z.array(z19.z.string()),
+  validationResults: z19.z.object({
+    passed: z19.z.boolean(),
+    errors: z19.z.array(z19.z.string()),
+    warnings: z19.z.array(z19.z.string())
   }),
-  completedTasks: zod.z.array(zod.z.string()),
-  message: zod.z.string(),
-  error: zod.z.string().optional()
+  completedTasks: z19.z.array(z19.z.string()),
+  message: z19.z.string(),
+  error: z19.z.string().optional()
 });
-zod.z.object({
+z19.z.object({
   questions: QuestionSchema
 });
-zod.z.object({
-  answers: zod.z.record(zod.z.string()),
-  hasAnswers: zod.z.boolean()
+z19.z.object({
+  answers: z19.z.record(z19.z.string()),
+  hasAnswers: z19.z.boolean()
 });
-var WorkflowBuilderResultSchema = zod.z.object({
-  success: zod.z.boolean(),
-  action: zod.z.enum(["create", "edit"]),
-  workflowName: zod.z.string().optional(),
-  workflowFile: zod.z.string().optional(),
+var WorkflowBuilderResultSchema = z19.z.object({
+  success: z19.z.boolean(),
+  action: z19.z.enum(["create", "edit"]),
+  workflowName: z19.z.string().optional(),
+  workflowFile: z19.z.string().optional(),
   discovery: WorkflowDiscoveryResultSchema.optional(),
   projectStructure: ProjectDiscoveryResultSchema.optional(),
   research: WorkflowResearchResultSchema.optional(),
   planning: PlanningIterationResultSchema.optional(),
   taskManagement: TaskManagementResultSchema.optional(),
   execution: TaskExecutionResultSchema.optional(),
-  needsUserInput: zod.z.boolean().optional(),
+  needsUserInput: z19.z.boolean().optional(),
   questions: QuestionSchema.optional(),
-  message: zod.z.string(),
-  nextSteps: zod.z.array(zod.z.string()).optional(),
-  error: zod.z.string().optional()
+  message: z19.z.string(),
+  nextSteps: z19.z.array(z19.z.string()).optional(),
+  error: z19.z.string().optional()
 });
-var TaskExecutionIterationInputSchema = (taskLength) => zod.z.object({
-  status: zod.z.enum(["in_progress", "completed", "needs_clarification"]).describe('Status - only use "completed" when ALL remaining tasks are finished'),
-  progress: zod.z.string().describe("Current progress description"),
-  completedTasks: zod.z.array(zod.z.string()).describe("List of ALL completed task IDs (including previously completed ones)"),
-  totalTasksRequired: zod.z.number().describe(`Total number of tasks that must be completed (should be ${taskLength})`),
-  tasksRemaining: zod.z.array(zod.z.string()).describe("List of task IDs that still need to be completed"),
-  filesModified: zod.z.array(zod.z.string()).describe("List of files that were created or modified - use these exact paths for validateCode tool"),
+var TaskExecutionIterationInputSchema = (taskLength) => z19.z.object({
+  status: z19.z.enum(["in_progress", "completed", "needs_clarification"]).describe('Status - only use "completed" when ALL remaining tasks are finished'),
+  progress: z19.z.string().describe("Current progress description"),
+  completedTasks: z19.z.array(z19.z.string()).describe("List of ALL completed task IDs (including previously completed ones)"),
+  totalTasksRequired: z19.z.number().describe(`Total number of tasks that must be completed (should be ${taskLength})`),
+  tasksRemaining: z19.z.array(z19.z.string()).describe("List of task IDs that still need to be completed"),
+  filesModified: z19.z.array(z19.z.string()).describe("List of files that were created or modified - use these exact paths for validateCode tool"),
   questions: QuestionSchema.optional().describe("Questions for user if clarification is needed"),
-  message: zod.z.string().describe("Summary of work completed or current status"),
-  error: zod.z.string().optional().describe("Any errors encountered")
+  message: z19.z.string().describe("Summary of work completed or current status"),
+  error: z19.z.string().optional().describe("Any errors encountered")
 });
-var PlanningIterationInputSchema = zod.z.object({
-  action: zod.z.enum(["create", "edit"]),
-  workflowName: zod.z.string().optional(),
-  description: zod.z.string().optional(),
-  requirements: zod.z.string().optional(),
-  discoveredWorkflows: zod.z.array(DiscoveredWorkflowSchema),
+var PlanningIterationInputSchema = z19.z.object({
+  action: z19.z.enum(["create", "edit"]),
+  workflowName: z19.z.string().optional(),
+  description: z19.z.string().optional(),
+  requirements: z19.z.string().optional(),
+  discoveredWorkflows: z19.z.array(DiscoveredWorkflowSchema),
   projectStructure: ProjectDiscoveryResultSchema,
   research: WorkflowResearchResultSchema,
-  userAnswers: zod.z.record(zod.z.string()).optional()
+  userAnswers: z19.z.record(z19.z.string()).optional()
 });
-var PlanningIterationSuspendSchema = zod.z.object({
+var PlanningIterationSuspendSchema = z19.z.object({
   questions: QuestionSchema,
-  message: zod.z.string(),
-  currentPlan: zod.z.object({
+  message: z19.z.string(),
+  currentPlan: z19.z.object({
     tasks: TaskSchema,
-    reasoning: zod.z.string()
+    reasoning: z19.z.string()
   })
 });
-var PlanningIterationResumeSchema = zod.z.object({
-  answers: zod.z.record(zod.z.string())
+var PlanningIterationResumeSchema = z19.z.object({
+  answers: z19.z.record(z19.z.string())
 });
-var PlanningAgentOutputSchema = zod.z.object({
+var PlanningAgentOutputSchema = z19.z.object({
   tasks: TaskSchema,
   questions: QuestionSchema.optional(),
-  reasoning: zod.z.string().describe("Explanation of the plan and any questions"),
-  planComplete: zod.z.boolean().describe("Whether the plan is ready for execution (no more questions)")
+  reasoning: z19.z.string().describe("Explanation of the plan and any questions"),
+  planComplete: z19.z.boolean().describe("Whether the plan is ready for execution (no more questions)")
 });
-var TaskApprovalOutputSchema = zod.z.object({
-  approved: zod.z.boolean(),
+var TaskApprovalOutputSchema = z19.z.object({
+  approved: z19.z.boolean(),
   tasks: TaskSchema,
-  message: zod.z.string(),
-  userFeedback: zod.z.string().optional()
+  message: z19.z.string(),
+  userFeedback: z19.z.string().optional()
 });
-var TaskApprovalSuspendSchema = zod.z.object({
+var TaskApprovalSuspendSchema = z19.z.object({
   taskList: TaskSchema,
-  summary: zod.z.string(),
-  message: zod.z.string()
+  summary: z19.z.string(),
+  message: z19.z.string()
 });
-var TaskApprovalResumeSchema = zod.z.object({
-  approved: zod.z.boolean(),
-  modifications: zod.z.string().optional()
+var TaskApprovalResumeSchema = z19.z.object({
+  approved: z19.z.boolean(),
+  modifications: z19.z.string().optional()
 });
 var planningIterationStep = workflows.createStep({
   id: "planning-iteration",
@@ -21884,6 +21893,7 @@ var planningIterationStep = workflows.createStep({
     try {
       const model = await resolveModel({ requestContext });
       const planningAgent = new agent.Agent({
+        id: "workflow-planning-agent",
         model,
         instructions: taskPlanningPrompts.planningAgent.instructions({
           storedQAPairs
@@ -22222,7 +22232,7 @@ export const mastra = new Mastra({
     sendEmailWorkflow,      // Use camelCase for keys
     dataProcessingWorkflow
   },
-  storage: new LibSQLStore({ url: 'file:./mastra.db' }), // Required for suspend/resume
+  storage: new LibSQLStore({ id: 'mastra-storage', url: 'file:./mastra.db' }), // Required for suspend/resume
 });
 \`\`\`
 
@@ -22437,35 +22447,35 @@ ${context.resumeData ? `USER PROVIDED ANSWERS: ${JSON.stringify(context.resumeDa
 var restrictedTaskManager = tools.createTool({
   id: "task-manager",
   description: "View and update your pre-loaded task list. You can only mark tasks as in_progress or completed, not create new tasks.",
-  inputSchema: zod.z.object({
-    action: zod.z.enum(["list", "update", "complete"]).describe("List tasks, update status, or mark complete - tasks are pre-loaded"),
-    tasks: zod.z.array(
-      zod.z.object({
-        id: zod.z.string().describe("Task ID - must match existing task"),
-        content: zod.z.string().optional().describe("Task content (read-only)"),
-        status: zod.z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
-        priority: zod.z.enum(["high", "medium", "low"]).optional().describe("Task priority (read-only)"),
-        dependencies: zod.z.array(zod.z.string()).optional().describe("Task dependencies (read-only)"),
-        notes: zod.z.string().optional().describe("Additional notes or progress updates")
+  inputSchema: z19.z.object({
+    action: z19.z.enum(["list", "update", "complete"]).describe("List tasks, update status, or mark complete - tasks are pre-loaded"),
+    tasks: z19.z.array(
+      z19.z.object({
+        id: z19.z.string().describe("Task ID - must match existing task"),
+        content: z19.z.string().optional().describe("Task content (read-only)"),
+        status: z19.z.enum(["pending", "in_progress", "completed", "blocked"]).describe("Task status"),
+        priority: z19.z.enum(["high", "medium", "low"]).optional().describe("Task priority (read-only)"),
+        dependencies: z19.z.array(z19.z.string()).optional().describe("Task dependencies (read-only)"),
+        notes: z19.z.string().optional().describe("Additional notes or progress updates")
       })
     ).optional().describe("Tasks to update (status and notes only)"),
-    taskId: zod.z.string().optional().describe("Specific task ID for single task operations")
+    taskId: z19.z.string().optional().describe("Specific task ID for single task operations")
   }),
-  outputSchema: zod.z.object({
-    success: zod.z.boolean(),
-    tasks: zod.z.array(
-      zod.z.object({
-        id: zod.z.string(),
-        content: zod.z.string(),
-        status: zod.z.string(),
-        priority: zod.z.string(),
-        dependencies: zod.z.array(zod.z.string()).optional(),
-        notes: zod.z.string().optional(),
-        createdAt: zod.z.string(),
-        updatedAt: zod.z.string()
+  outputSchema: z19.z.object({
+    success: z19.z.boolean(),
+    tasks: z19.z.array(
+      z19.z.object({
+        id: z19.z.string(),
+        content: z19.z.string(),
+        status: z19.z.string(),
+        priority: z19.z.string(),
+        dependencies: z19.z.array(z19.z.string()).optional(),
+        notes: z19.z.string().optional(),
+        createdAt: z19.z.string(),
+        updatedAt: z19.z.string()
       })
     ),
-    message: zod.z.string()
+    message: z19.z.string()
   }),
   execute: async (input) => {
     const adaptedContext = {
@@ -22610,6 +22620,7 @@ var workflowResearchStep = workflows.createStep({
     try {
       const model = await resolveModel({ requestContext });
       const researchAgent = new agent.Agent({
+        id: "workflow-research-agent",
         model,
         instructions: workflowBuilderPrompts.researchAgent.instructions,
         name: "Workflow Research Agent"
@@ -22930,144 +22941,599 @@ var agentBuilderWorkflows = {
   "merge-template": agentBuilderTemplateWorkflow,
   "workflow-builder": workflowBuilderWorkflow
 };
+var actionIdPathParams = z19__default.default.object({
+  actionId: z19__default.default.string().describe("Unique identifier for the agent-builder action")
+});
+var actionRunPathParams = z19__default.default.object({
+  actionId: z19__default.default.string().describe("Unique identifier for the agent-builder action"),
+  runId: z19__default.default.string().describe("Unique identifier for the action run")
+});
+var streamAgentBuilderBodySchema = chunk7WTETKRM_cjs.streamWorkflowBodySchema;
+var streamLegacyAgentBuilderBodySchema = chunk7WTETKRM_cjs.streamLegacyWorkflowBodySchema;
+var resumeAgentBuilderBodySchema = chunk7WTETKRM_cjs.resumeBodySchema;
+var startAsyncAgentBuilderBodySchema = chunk7WTETKRM_cjs.startAsyncWorkflowBodySchema;
 
 // src/server/handlers/agent-builder.ts
-function createAgentBuilderWorkflowHandler(workflowHandlerFn, logMessage) {
-  return async (builderArgs) => {
-    const { actionId, ...actionArgs } = builderArgs;
-    const mastra = actionArgs.mastra;
+var LIST_AGENT_BUILDER_ACTIONS_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "GET",
+  path: "/api/agent-builder",
+  responseType: "json",
+  responseSchema: chunk7WTETKRM_cjs.listWorkflowsResponseSchema,
+  summary: "List agent-builder actions",
+  description: "Returns a list of all available agent-builder actions",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra } = ctx;
     const logger = mastra.getLogger();
     try {
-      chunkLWLSQ2W4_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
-      if (actionId && !chunkLWLSQ2W4_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      logger.info("Listing agent builder actions");
+      return await chunk7WTETKRM_cjs.LIST_WORKFLOWS_ROUTE.handler(ctx);
+    } catch (error) {
+      logger.error("Error listing agent builder actions", { error });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error getting agent builder workflows");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  responseSchema: chunk7WTETKRM_cjs.workflowInfoSchema,
+  summary: "Get action by ID",
+  description: "Returns details for a specific agent-builder action",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
         throw new chunk64ITUOXI_cjs.HTTPException(400, {
           message: `Invalid agent-builder action: ${actionId}. Valid actions are: ${Object.keys(agentBuilderWorkflows).join(", ")}`
         });
       }
-      logger.info(logMessage, { actionId, ...actionArgs });
-      try {
-        const handlerArgs = {
-          ...actionArgs,
-          workflowId: actionId
-          // Map actionId to workflowId
-        };
-        const result = await workflowHandlerFn(handlerArgs);
-        return result;
-      } finally {
-        chunkLWLSQ2W4_cjs.WorkflowRegistry.cleanup();
-      }
+      logger.info("Getting agent builder action by ID", { actionId });
+      return await chunk7WTETKRM_cjs.GET_WORKFLOW_BY_ID_ROUTE.handler({ ...ctx, workflowId: actionId });
     } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`${logMessage} failed`, {
-        error: errorMessage,
-        stack: error instanceof Error ? error.stack : void 0
+      logger.error("Error getting agent builder action by ID", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error getting agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId/runs",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk7WTETKRM_cjs.listWorkflowRunsQuerySchema,
+  responseSchema: chunk7WTETKRM_cjs.workflowRunsResponseSchema,
+  summary: "List action runs",
+  description: "Returns a paginated list of execution runs for the specified action",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Listing agent builder action runs", { actionId });
+      return await chunk7WTETKRM_cjs.LIST_WORKFLOW_RUNS_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
       });
-      throw error;
+    } catch (error) {
+      logger.error("Error listing agent builder action runs", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error getting agent builder action runs");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
     }
-  };
-}
-var getAgentBuilderActionsHandler = createAgentBuilderWorkflowHandler(async () => {
-  try {
-    const registryWorkflows = chunkLWLSQ2W4_cjs.WorkflowRegistry.getAllWorkflows();
-    const _workflows = Object.entries(registryWorkflows).reduce(
-      (acc, [key, workflow]) => {
-        acc[key] = chunkLWLSQ2W4_cjs.getWorkflowInfo(workflow);
-        return acc;
-      },
-      {}
-    );
-    return _workflows;
-  } catch (error) {
-    return chunkV5WWQN7P_cjs.handleError(error, "Error getting agent builder workflows");
   }
-}, "Getting agent builder actions");
-var getAgentBuilderActionByIdHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.getWorkflowByIdHandler,
-  "Getting agent builder action by ID"
-);
-var getAgentBuilderActionRunByIdHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.getWorkflowRunByIdHandler,
-  "Getting agent builder action run by ID"
-);
-var getAgentBuilderActionRunExecutionResultHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.getWorkflowRunExecutionResultHandler,
-  "Getting agent builder action run execution result"
-);
-var createAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.createWorkflowRunHandler,
-  "Creating agent builder action run"
-);
-var startAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.startAsyncWorkflowHandler,
-  "Starting async agent builder action"
-);
-var startAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.startWorkflowRunHandler,
-  "Starting agent builder action run"
-);
-var streamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.streamWorkflowHandler,
-  "Streaming agent builder action"
-);
-var streamLegacyAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.streamLegacyWorkflowHandler,
-  "Streaming legacy agent builder action"
-);
-var streamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.streamVNextWorkflowHandler,
-  "Streaming VNext agent builder action"
-);
-var observeStreamLegacyAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.observeStreamLegacyWorkflowHandler,
-  "Observing legacy stream for agent builder action"
-);
-var observeStreamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.observeStreamWorkflowHandler,
-  "Observing stream for agent builder action"
-);
-var observeStreamVNextAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.observeStreamVNextWorkflowHandler,
-  "Observing VNext stream for agent builder action"
-);
-var resumeAsyncAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.resumeAsyncWorkflowHandler,
-  "Resuming async agent builder action"
-);
-var resumeAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.resumeWorkflowHandler,
-  "Resuming agent builder action"
-);
-var resumeStreamAgentBuilderActionHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.resumeStreamWorkflowHandler,
-  "Resuming stream for agent builder action"
-);
-var getAgentBuilderActionRunsHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.listWorkflowRunsHandler,
-  "Getting agent builder action runs"
-);
-var cancelAgentBuilderActionRunHandler = createAgentBuilderWorkflowHandler(
-  chunkSRAPUMPM_cjs.cancelWorkflowRunHandler,
-  "Cancelling agent builder action run"
-);
+});
+var GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId/runs/:runId",
+  responseType: "json",
+  pathParamSchema: actionRunPathParams,
+  responseSchema: chunk7WTETKRM_cjs.workflowRunResponseSchema,
+  summary: "Get action run by ID",
+  description: "Returns details for a specific action run",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Getting agent builder action run by ID", { actionId, runId });
+      return await chunk7WTETKRM_cjs.GET_WORKFLOW_RUN_BY_ID_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error getting agent builder action run", { error, actionId, runId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error getting agent builder action run");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "GET",
+  path: "/api/agent-builder/:actionId/runs/:runId/execution-result",
+  responseType: "json",
+  pathParamSchema: actionRunPathParams,
+  responseSchema: chunk7WTETKRM_cjs.workflowExecutionResultSchema,
+  summary: "Get action execution result",
+  description: "Returns the final execution result of a completed action run",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Getting agent builder action run execution result", { actionId, runId });
+      return await chunk7WTETKRM_cjs.GET_WORKFLOW_RUN_EXECUTION_RESULT_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error getting execution result", { error, actionId, runId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error getting agent builder action execution result");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/create-run",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.optionalRunIdSchema,
+  responseSchema: chunk7WTETKRM_cjs.createWorkflowRunResponseSchema,
+  summary: "Create action run",
+  description: "Creates a new action execution instance with an optional custom run ID",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Creating agent builder action run", { actionId, runId });
+      return await chunk7WTETKRM_cjs.CREATE_WORKFLOW_RUN_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error creating agent builder action run", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error creating agent builder action run");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var STREAM_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/stream",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: streamAgentBuilderBodySchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "Stream action execution",
+  description: "Executes an action and streams the results in real-time",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Streaming agent builder action", { actionId, runId });
+      return await chunk7WTETKRM_cjs.STREAM_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error streaming agent builder action", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error streaming agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/streamVNext",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: streamAgentBuilderBodySchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "Stream action execution (v2)",
+  description: "Executes an action using the v2 streaming API and streams the results in real-time",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Streaming agent builder action (v2)", { actionId, runId });
+      return await chunk7WTETKRM_cjs.STREAM_VNEXT_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error streaming agent builder action (v2)", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error streaming agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var START_ASYNC_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/start-async",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.optionalRunIdSchema,
+  bodySchema: startAsyncAgentBuilderBodySchema,
+  responseSchema: chunk7WTETKRM_cjs.workflowExecutionResultSchema,
+  summary: "Start action asynchronously",
+  description: "Starts an action execution asynchronously without streaming results",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Starting agent builder action asynchronously", { actionId, runId });
+      return await chunk7WTETKRM_cjs.START_ASYNC_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error starting agent builder action asynchronously", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error starting agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var START_AGENT_BUILDER_ACTION_RUN_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/start",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: startAsyncAgentBuilderBodySchema,
+  responseSchema: chunk7WTETKRM_cjs.workflowControlResponseSchema,
+  summary: "Start specific action run",
+  description: "Starts execution of a specific action run by ID",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Starting specific agent builder action run", { actionId, runId });
+      return await chunk7WTETKRM_cjs.START_WORKFLOW_RUN_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error starting agent builder action run", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error starting agent builder action run");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/observe",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "Observe action stream",
+  description: "Observes and streams updates from an already running action execution",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Observing agent builder action stream", { actionId, runId });
+      return await chunk7WTETKRM_cjs.OBSERVE_STREAM_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error observing agent builder action stream", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error observing agent builder action stream");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/observe-streamVNext",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "Observe action stream (v2)",
+  description: "Observes and streams updates from an already running action execution using v2 streaming API",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Observing agent builder action stream (v2)", { actionId, runId });
+      return await chunk7WTETKRM_cjs.OBSERVE_STREAM_VNEXT_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error observing agent builder action stream (v2)", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error observing agent builder action stream");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/resume-async",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: resumeAgentBuilderBodySchema,
+  responseSchema: chunk7WTETKRM_cjs.workflowExecutionResultSchema,
+  summary: "Resume action asynchronously",
+  description: "Resumes a suspended action execution asynchronously without streaming",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, step, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Resuming agent builder action asynchronously", { actionId, runId, step });
+      return await chunk7WTETKRM_cjs.RESUME_ASYNC_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error resuming agent builder action asynchronously", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error resuming agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var RESUME_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/resume",
+  responseType: "json",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: resumeAgentBuilderBodySchema,
+  responseSchema: chunk7WTETKRM_cjs.workflowControlResponseSchema,
+  summary: "Resume action",
+  description: "Resumes a suspended action execution from a specific step",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, step, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Resuming agent builder action", { actionId, runId, step });
+      return await chunk7WTETKRM_cjs.RESUME_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error resuming agent builder action", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error resuming agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/resume-stream",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: resumeAgentBuilderBodySchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "Resume action stream",
+  description: "Resumes a suspended action execution and continues streaming results",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, step, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Resuming agent builder action stream", { actionId, runId, step });
+      return await chunk7WTETKRM_cjs.RESUME_STREAM_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error resuming agent builder action stream", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error resuming agent builder action stream");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/runs/:runId/cancel",
+  responseType: "json",
+  pathParamSchema: actionRunPathParams,
+  responseSchema: chunk7WTETKRM_cjs.workflowControlResponseSchema,
+  summary: "Cancel action run",
+  description: "Cancels an in-progress action execution",
+  tags: ["Agent Builder"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Cancelling agent builder action run", { actionId, runId });
+      return await chunk7WTETKRM_cjs.CANCEL_WORKFLOW_RUN_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error cancelling agent builder action run", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error cancelling agent builder action run");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/stream-legacy",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  bodySchema: streamLegacyAgentBuilderBodySchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "[DEPRECATED] Stream agent-builder action with legacy format",
+  description: "Legacy endpoint for streaming agent-builder action execution. Use /api/agent-builder/:actionId/stream instead.",
+  tags: ["Agent Builder", "Legacy"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId, requestContext } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Streaming agent builder action (legacy)", { actionId, runId });
+      return await chunk7WTETKRM_cjs.STREAM_LEGACY_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId,
+        requestContext
+      });
+    } catch (error) {
+      logger.error("Error streaming agent builder action (legacy)", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error streaming agent builder action");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
+var OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = chunkUJNHKFBR_cjs.createRoute({
+  method: "POST",
+  path: "/api/agent-builder/:actionId/observe-stream-legacy",
+  responseType: "stream",
+  pathParamSchema: actionIdPathParams,
+  queryParamSchema: chunk2NW6POYK_cjs.runIdSchema,
+  responseSchema: chunkMWQQRVQC_cjs.streamResponseSchema,
+  summary: "[DEPRECATED] Observe agent-builder action stream with legacy format",
+  description: "Legacy endpoint for observing agent-builder action stream. Use /api/agent-builder/:actionId/observe instead.",
+  tags: ["Agent Builder", "Legacy"],
+  handler: async (ctx) => {
+    const { mastra, actionId, runId } = ctx;
+    const logger = mastra.getLogger();
+    try {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.registerTemporaryWorkflows(agentBuilderWorkflows, mastra);
+      if (actionId && !chunkUZ6CYAOG_cjs.WorkflowRegistry.isAgentBuilderWorkflow(actionId)) {
+        throw new chunk64ITUOXI_cjs.HTTPException(400, { message: `Invalid agent-builder action: ${actionId}` });
+      }
+      logger.info("Observing agent builder action stream (legacy)", { actionId, runId });
+      return await chunk7WTETKRM_cjs.OBSERVE_STREAM_LEGACY_WORKFLOW_ROUTE.handler({
+        ...ctx,
+        workflowId: actionId
+      });
+    } catch (error) {
+      logger.error("Error observing agent builder action stream (legacy)", { error, actionId });
+      return chunkV5WWQN7P_cjs.handleError(error, "Error observing agent builder action stream");
+    } finally {
+      chunkUZ6CYAOG_cjs.WorkflowRegistry.cleanup();
+    }
+  }
+});
 
+exports.CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE = CANCEL_AGENT_BUILDER_ACTION_RUN_ROUTE;
+exports.CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE = CREATE_AGENT_BUILDER_ACTION_RUN_ROUTE;
+exports.GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE = GET_AGENT_BUILDER_ACTION_BY_ID_ROUTE;
+exports.GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE = GET_AGENT_BUILDER_ACTION_RUN_BY_ID_ROUTE;
+exports.GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE = GET_AGENT_BUILDER_ACTION_RUN_EXECUTION_RESULT_ROUTE;
+exports.LIST_AGENT_BUILDER_ACTIONS_ROUTE = LIST_AGENT_BUILDER_ACTIONS_ROUTE;
+exports.LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE = LIST_AGENT_BUILDER_ACTION_RUNS_ROUTE;
+exports.OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE = OBSERVE_STREAM_AGENT_BUILDER_ACTION_ROUTE;
+exports.OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = OBSERVE_STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE;
+exports.OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE = OBSERVE_STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE;
+exports.RESUME_AGENT_BUILDER_ACTION_ROUTE = RESUME_AGENT_BUILDER_ACTION_ROUTE;
+exports.RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE = RESUME_ASYNC_AGENT_BUILDER_ACTION_ROUTE;
+exports.RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE = RESUME_STREAM_AGENT_BUILDER_ACTION_ROUTE;
+exports.START_AGENT_BUILDER_ACTION_RUN_ROUTE = START_AGENT_BUILDER_ACTION_RUN_ROUTE;
+exports.START_ASYNC_AGENT_BUILDER_ACTION_ROUTE = START_ASYNC_AGENT_BUILDER_ACTION_ROUTE;
+exports.STREAM_AGENT_BUILDER_ACTION_ROUTE = STREAM_AGENT_BUILDER_ACTION_ROUTE;
+exports.STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE = STREAM_LEGACY_AGENT_BUILDER_ACTION_ROUTE;
+exports.STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE = STREAM_VNEXT_AGENT_BUILDER_ACTION_ROUTE;
 exports.agent_builder_exports = agent_builder_exports;
-exports.cancelAgentBuilderActionRunHandler = cancelAgentBuilderActionRunHandler;
-exports.createAgentBuilderActionRunHandler = createAgentBuilderActionRunHandler;
-exports.getAgentBuilderActionByIdHandler = getAgentBuilderActionByIdHandler;
-exports.getAgentBuilderActionRunByIdHandler = getAgentBuilderActionRunByIdHandler;
-exports.getAgentBuilderActionRunExecutionResultHandler = getAgentBuilderActionRunExecutionResultHandler;
-exports.getAgentBuilderActionRunsHandler = getAgentBuilderActionRunsHandler;
-exports.getAgentBuilderActionsHandler = getAgentBuilderActionsHandler;
-exports.observeStreamAgentBuilderActionHandler = observeStreamAgentBuilderActionHandler;
-exports.observeStreamLegacyAgentBuilderActionHandler = observeStreamLegacyAgentBuilderActionHandler;
-exports.observeStreamVNextAgentBuilderActionHandler = observeStreamVNextAgentBuilderActionHandler;
-exports.resumeAgentBuilderActionHandler = resumeAgentBuilderActionHandler;
-exports.resumeAsyncAgentBuilderActionHandler = resumeAsyncAgentBuilderActionHandler;
-exports.resumeStreamAgentBuilderActionHandler = resumeStreamAgentBuilderActionHandler;
-exports.startAgentBuilderActionRunHandler = startAgentBuilderActionRunHandler;
-exports.startAsyncAgentBuilderActionHandler = startAsyncAgentBuilderActionHandler;
-exports.streamAgentBuilderActionHandler = streamAgentBuilderActionHandler;
-exports.streamLegacyAgentBuilderActionHandler = streamLegacyAgentBuilderActionHandler;
-exports.streamVNextAgentBuilderActionHandler = streamVNextAgentBuilderActionHandler;
-//# sourceMappingURL=chunk-M6KNPIZZ.cjs.map
-//# sourceMappingURL=chunk-M6KNPIZZ.cjs.map
+//# sourceMappingURL=chunk-BM7RP6NK.cjs.map
+//# sourceMappingURL=chunk-BM7RP6NK.cjs.map