@mastra/core 0.5.0-alpha.8 → 0.5.0

package/dist/chunk-43Y7WG5W.cjs

@@ -0,0 +1,335 @@
+'use strict';
+
+var chunk2W2GYEYQ_cjs = require('./chunk-2W2GYEYQ.cjs');
+var crypto = require('crypto');
+var jsonSchemaToZod = require('json-schema-to-zod');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jsonSchemaToZod__default = /*#__PURE__*/_interopDefault(jsonSchemaToZod);
+
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function jsonSchemaPropertiesToTSTypes(value) {
+  if (!value.type) {
+    return zod.z.object({});
+  }
+  let zodType;
+  switch (value.type) {
+    case "string":
+      zodType = zod.z.string().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "number":
+      zodType = zod.z.number().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "integer":
+      zodType = zod.z.number().int().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "boolean":
+      zodType = zod.z.boolean().describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "array":
+      zodType = zod.z.array(jsonSchemaPropertiesToTSTypes(value.items)).describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+      break;
+    case "object":
+      zodType = jsonSchemaToModel(value).describe(
+        (value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : "")
+      );
+      break;
+    case "null":
+      zodType = zod.z.null().describe(value.description || "");
+      break;
+    default:
+      throw new Error(`Unsupported JSON schema type: ${value.type}`);
+  }
+  return zodType;
+}
+function jsonSchemaToModel(jsonSchema) {
+  const properties = jsonSchema.properties;
+  const requiredFields = jsonSchema.required || [];
+  if (!properties) {
+    return zod.z.object({});
+  }
+  const zodSchema = {};
+  for (const [key, _] of Object.entries(properties)) {
+    const value = _;
+    let zodType;
+    if (value.anyOf) {
+      const anyOfTypes = value.anyOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
+      zodType = zod.z.union(anyOfTypes).describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+    } else if (value.allOf) {
+      const allOfTypes = value.allOf.map((schema) => jsonSchemaPropertiesToTSTypes(schema));
+      zodType = zod.z.intersection(
+        allOfTypes[0],
+        allOfTypes.slice(1).reduce((acc, schema) => acc.and(schema), allOfTypes[0])
+      ).describe((value.description || "") + (value.examples ? `
+Examples: ${value.examples.join(", ")}` : ""));
+    } else {
+      if (!value.type) {
+        value.type = "string";
+      }
+      zodType = jsonSchemaPropertiesToTSTypes(value);
+    }
+    if (value.description) {
+      zodType = zodType.describe(value.description);
+    }
+    if (requiredFields.includes(key)) {
+      zodSchema[key] = zodType;
+    } else {
+      zodSchema[key] = zodType.nullable().optional();
+    }
+  }
+  return zod.z.object(zodSchema);
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (!source) return output;
+  Object.keys(source).forEach((key) => {
+    const targetValue = output[key];
+    const sourceValue = source[key];
+    if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+      output[key] = sourceValue;
+    } else if (sourceValue instanceof Object && targetValue instanceof Object && !Array.isArray(sourceValue) && !Array.isArray(targetValue)) {
+      output[key] = deepMerge(targetValue, sourceValue);
+    } else if (sourceValue !== void 0) {
+      output[key] = sourceValue;
+    }
+  });
+  return output;
+}
+async function* maskStreamTags(stream, tag, options = {}) {
+  const { onStart, onEnd, onMask } = options;
+  const openTag = `<${tag}>`;
+  const closeTag = `</${tag}>`;
+  let buffer = "";
+  let fullContent = "";
+  let isMasking = false;
+  let isBuffering = false;
+  const trimOutsideDelimiter = (text, delimiter, trim) => {
+    if (!text.includes(delimiter)) {
+      return text;
+    }
+    const parts = text.split(delimiter);
+    if (trim === `before-start`) {
+      return `${delimiter}${parts[1]}`;
+    }
+    return `${parts[0]}${delimiter}`;
+  };
+  const startsWith = (text, pattern) => {
+    if (pattern.includes(openTag.substring(0, 3))) {
+      pattern = trimOutsideDelimiter(pattern, `<`, `before-start`);
+    }
+    return text.trim().startsWith(pattern.trim());
+  };
+  for await (const chunk of stream) {
+    fullContent += chunk;
+    if (isBuffering) buffer += chunk;
+    const chunkHasTag = startsWith(chunk, openTag);
+    const bufferHasTag = !chunkHasTag && isBuffering && startsWith(openTag, buffer);
+    let toYieldBeforeMaskedStartTag = ``;
+    if (!isMasking && (chunkHasTag || bufferHasTag)) {
+      isMasking = true;
+      isBuffering = false;
+      const taggedTextToMask = trimOutsideDelimiter(buffer, `<`, `before-start`);
+      if (taggedTextToMask !== buffer.trim()) {
+        toYieldBeforeMaskedStartTag = buffer.replace(taggedTextToMask, ``);
+      }
+      buffer = "";
+      onStart?.();
+    }
+    if (!isMasking && !isBuffering && startsWith(openTag, chunk) && chunk.trim() !== "") {
+      isBuffering = true;
+      buffer += chunk;
+      continue;
+    }
+    if (isBuffering && buffer && !startsWith(openTag, buffer)) {
+      yield buffer;
+      buffer = "";
+      isBuffering = false;
+      continue;
+    }
+    if (isMasking && fullContent.includes(closeTag)) {
+      onMask?.(chunk);
+      onEnd?.();
+      isMasking = false;
+      const lastFullContent = fullContent;
+      fullContent = ``;
+      const textUntilEndTag = trimOutsideDelimiter(lastFullContent, closeTag, "after-end");
+      if (textUntilEndTag !== lastFullContent) {
+        yield lastFullContent.replace(textUntilEndTag, ``);
+      }
+      continue;
+    }
+    if (isMasking) {
+      onMask?.(chunk);
+      if (toYieldBeforeMaskedStartTag) {
+        yield toYieldBeforeMaskedStartTag;
+      }
+      continue;
+    }
+    yield chunk;
+  }
+}
+function resolveSerializedZodOutput(schema) {
+  return Function("z", `"use strict";return (${schema});`)(zod.z);
+}
+function isVercelTool(tool) {
+  return !(tool instanceof chunk2W2GYEYQ_cjs.Tool);
+}
+function createLogMessageOptions({ agentName, toolName, tool, type }) {
+  if (!agentName) {
+    return {
+      start: `Executing tool ${toolName}`,
+      error: `Failed tool execution`
+    };
+  }
+  const prefix = `[Agent:${agentName}]`;
+  const vercelPrefix = isVercelTool(tool) ? "Vercel " : "";
+  const toolType = type === "toolset" ? "toolset" : "tool";
+  return {
+    start: `${prefix} - Executing ${vercelPrefix}${toolType} ${toolName}`,
+    error: `${prefix} - Failed ${vercelPrefix}${toolType} execution`
+  };
+}
+function createExecute(tool, options, logType) {
+  const { logger, mastra: _mastra, memory: _memory, ...rest } = options;
+  const { start, error } = createLogMessageOptions({
+    agentName: options.agentName,
+    toolName: options.name,
+    tool,
+    type: logType
+  });
+  const execFunction = async (args, execOptions) => {
+    if (isVercelTool(tool)) {
+      return tool?.execute?.(args, execOptions) ?? void 0;
+    }
+    return tool?.execute?.(
+      {
+        context: args,
+        threadId: options.threadId,
+        resourceId: options.resourceId,
+        mastra: options.mastra,
+        memory: options.memory,
+        runId: options.runId
+      },
+      execOptions
+    ) ?? void 0;
+  };
+  return async (args, execOptions) => {
+    try {
+      logger.debug(start, { ...rest, args });
+      return await execFunction(args, execOptions);
+    } catch (err) {
+      logger.error(error, { ...rest, error: err, args });
+      throw err;
+    }
+  };
+}
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+function createDeterministicId(input) {
+  return crypto.createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function setVercelToolProperties(tool) {
+  const inputSchema = convertVercelToolParameters(tool);
+  const toolId = !("id" in tool) ? tool.description ? `tool-${createDeterministicId(tool.description)}` : `tool-${Math.random().toString(36).substring(2, 9)}` : tool.id;
+  return {
+    ...tool,
+    id: toolId,
+    inputSchema
+  };
+}
+function ensureToolProperties(tools) {
+  const toolsWithProperties = Object.keys(tools).reduce((acc, key) => {
+    const tool = tools?.[key];
+    if (tool) {
+      if (isVercelTool(tool)) {
+        acc[key] = setVercelToolProperties(tool);
+      } else {
+        acc[key] = tool;
+      }
+    }
+    return acc;
+  }, {});
+  return toolsWithProperties;
+}
+function convertVercelToolParameters(tool) {
+  const schema = tool.parameters ?? zod.z.object({});
+  return isZodType(schema) ? schema : resolveSerializedZodOutput(jsonSchemaToZod__default.default(schema));
+}
+function makeCoreTool(tool, options, logType) {
+  const getParameters = () => {
+    if (isVercelTool(tool)) {
+      return convertVercelToolParameters(tool);
+    }
+    return tool.inputSchema ?? zod.z.object({});
+  };
+  return {
+    description: tool.description,
+    parameters: getParameters(),
+    execute: tool.execute ? createExecute(tool, { ...options, description: tool.description }, logType) : void 0
+  };
+}
+function createMastraProxy({ mastra, logger }) {
+  return new Proxy(mastra, {
+    get(target, prop) {
+      const hasProp = Reflect.has(target, prop);
+      if (hasProp) {
+        const value = Reflect.get(target, prop);
+        const isFunction = typeof value === "function";
+        if (isFunction) {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (prop === "logger") {
+        logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
+        return Reflect.apply(target.getLogger, target, []);
+      }
+      if (prop === "telemetry") {
+        logger.warn(`Please use 'getTelemetry' instead, telemetry is deprecated`);
+        return Reflect.apply(target.getTelemetry, target, []);
+      }
+      if (prop === "storage") {
+        logger.warn(`Please use 'getStorage' instead, storage is deprecated`);
+        return Reflect.get(target, "storage");
+      }
+      if (prop === "agents") {
+        logger.warn(`Please use 'getAgents' instead, agents is deprecated`);
+        return Reflect.apply(target.getAgents, target, []);
+      }
+      if (prop === "tts") {
+        logger.warn(`Please use 'getTTS' instead, tts is deprecated`);
+        return Reflect.apply(target.getTTS, target, []);
+      }
+      if (prop === "vectors") {
+        logger.warn(`Please use 'getVectors' instead, vectors is deprecated`);
+        return Reflect.apply(target.getVectors, target, []);
+      }
+      if (prop === "memory") {
+        logger.warn(`Please use 'getMemory' instead, memory is deprecated`);
+        return Reflect.get(target, "memory");
+      }
+      return Reflect.get(target, prop);
+    }
+  });
+}
+
+exports.createMastraProxy = createMastraProxy;
+exports.deepMerge = deepMerge;
+exports.delay = delay;
+exports.ensureToolProperties = ensureToolProperties;
+exports.isVercelTool = isVercelTool;
+exports.jsonSchemaPropertiesToTSTypes = jsonSchemaPropertiesToTSTypes;
+exports.jsonSchemaToModel = jsonSchemaToModel;
+exports.makeCoreTool = makeCoreTool;
+exports.maskStreamTags = maskStreamTags;
+exports.resolveSerializedZodOutput = resolveSerializedZodOutput;

package/dist/{chunk-HBHPTMAC.js → chunk-4Y74D74B.js}

@@ -1,4 +1,5 @@
 import { Tool } from './chunk-ZINPRHAN.js';
+import { createHash } from 'crypto';
 import jsonSchemaToZod from 'json-schema-to-zod';
 import { z } from 'zod';
 
@@ -192,7 +193,7 @@ function createLogMessageOptions({ agentName, toolName, tool, type }) {
   };
 }
 function createExecute(tool, options, logType) {
-  const { logger, ...rest } = options;
+  const { logger, mastra: _mastra, memory: _memory, ...rest } = options;
   const { start, error } = createLogMessageOptions({
     agentName: options.agentName,
     toolName: options.name,
@@ -225,12 +226,45 @@ function createExecute(tool, options, logType) {
     }
   };
 }
+function isZodType(value) {
+  return typeof value === "object" && value !== null && "_def" in value && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
+}
+function createDeterministicId(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function setVercelToolProperties(tool) {
+  const inputSchema = convertVercelToolParameters(tool);
+  const toolId = !("id" in tool) ? tool.description ? `tool-${createDeterministicId(tool.description)}` : `tool-${Math.random().toString(36).substring(2, 9)}` : tool.id;
+  return {
+    ...tool,
+    id: toolId,
+    inputSchema
+  };
+}
+function ensureToolProperties(tools) {
+  const toolsWithProperties = Object.keys(tools).reduce((acc, key) => {
+    const tool = tools?.[key];
+    if (tool) {
+      if (isVercelTool(tool)) {
+        acc[key] = setVercelToolProperties(tool);
+      } else {
+        acc[key] = tool;
+      }
+    }
+    return acc;
+  }, {});
+  return toolsWithProperties;
+}
+function convertVercelToolParameters(tool) {
+  const schema = tool.parameters ?? z.object({});
+  return isZodType(schema) ? schema : resolveSerializedZodOutput(jsonSchemaToZod(schema));
+}
 function makeCoreTool(tool, options, logType) {
   const getParameters = () => {
     if (isVercelTool(tool)) {
-      return tool.parameters instanceof z.ZodType ? tool.parameters : resolveSerializedZodOutput(jsonSchemaToZod(tool.parameters));
+      return convertVercelToolParameters(tool);
     }
-    return tool.inputSchema;
+    return tool.inputSchema ?? z.object({});
   };
   return {
     description: tool.description,
@@ -241,8 +275,14 @@ function makeCoreTool(tool, options, logType) {
 function createMastraProxy({ mastra, logger }) {
   return new Proxy(mastra, {
     get(target, prop) {
-      if (Reflect.has(target, prop)) {
-        return Reflect.get(target, prop);
+      const hasProp = Reflect.has(target, prop);
+      if (hasProp) {
+        const value = Reflect.get(target, prop);
+        const isFunction = typeof value === "function";
+        if (isFunction) {
+          return value.bind(target);
+        }
+        return value;
       }
       if (prop === "logger") {
         logger.warn(`Please use 'getLogger' instead, logger is deprecated`);
@@ -277,4 +317,4 @@ function createMastraProxy({ mastra, logger }) {
   });
 }
 
-export { createMastraProxy, deepMerge, delay, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };
+export { createMastraProxy, deepMerge, delay, ensureToolProperties, isVercelTool, jsonSchemaPropertiesToTSTypes, jsonSchemaToModel, makeCoreTool, maskStreamTags, resolveSerializedZodOutput };

package/dist/chunk-ENT7U27Y.cjs

@@ -0,0 +1,37 @@
+'use strict';
+
+var chunkIIWRJFLQ_cjs = require('./chunk-IIWRJFLQ.cjs');
+
+// src/vector/vector.ts
+var MastraVector = class extends chunkIIWRJFLQ_cjs.MastraBase {
+  constructor() {
+    super({ name: "MastraVector", component: "VECTOR" });
+  }
+  baseKeys = {
+    query: ["queryVector", "topK", "filter", "includeVector"],
+    upsert: ["vectors", "metadata", "ids"],
+    createIndex: ["dimension", "metric"]
+  };
+  normalizeArgs(method, [first, ...rest], extendedKeys = []) {
+    if (typeof first === "object") {
+      return first;
+    }
+    this.logger.warn(
+      `Deprecation Warning: Passing individual arguments to ${method}() is deprecated. Please use an object parameter instead.`
+    );
+    const baseKeys = this.baseKeys[method] || [];
+    const paramKeys = [...baseKeys, ...extendedKeys].slice(0, rest.length);
+    return {
+      indexName: first,
+      ...Object.fromEntries(paramKeys.map((key, i) => [key, rest[i]]))
+    };
+  }
+  async updateIndexById(_indexName, _id, _update) {
+    throw new Error("updateIndexById is not implemented yet");
+  }
+  async deleteIndexById(_indexName, _id) {
+    throw new Error("deleteById is not implemented yet");
+  }
+};
+
+exports.MastraVector = MastraVector;

package/dist/chunk-F5UYWPV4.cjs

@@ -0,0 +1,14 @@
+'use strict';
+
+// src/storage/constants.ts
+var TABLE_WORKFLOW_SNAPSHOT = "mastra_workflow_snapshot";
+var TABLE_EVALS = "mastra_evals";
+var TABLE_MESSAGES = "mastra_messages";
+var TABLE_THREADS = "mastra_threads";
+var TABLE_TRACES = "mastra_traces";
+
+exports.TABLE_EVALS = TABLE_EVALS;
+exports.TABLE_MESSAGES = TABLE_MESSAGES;
+exports.TABLE_THREADS = TABLE_THREADS;
+exports.TABLE_TRACES = TABLE_TRACES;
+exports.TABLE_WORKFLOW_SNAPSHOT = TABLE_WORKFLOW_SNAPSHOT;

package/dist/chunk-FL3GQXQ2.cjs

@@ -0,0 +1,218 @@
+'use strict';
+
+var chunkF5UYWPV4_cjs = require('./chunk-F5UYWPV4.cjs');
+var chunkIIWRJFLQ_cjs = require('./chunk-IIWRJFLQ.cjs');
+
+// src/storage/base.ts
+var MastraStorage = class extends chunkIIWRJFLQ_cjs.MastraBase {
+  /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
+  static TABLE_WORKFLOW_SNAPSHOT = chunkF5UYWPV4_cjs.TABLE_WORKFLOW_SNAPSHOT;
+  /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */
+  static TABLE_EVALS = chunkF5UYWPV4_cjs.TABLE_EVALS;
+  /** @deprecated import from { TABLE_MESSAGES } '@mastra/core/storage' instead */
+  static TABLE_MESSAGES = chunkF5UYWPV4_cjs.TABLE_MESSAGES;
+  /** @deprecated import from { TABLE_THREADS } '@mastra/core/storage' instead */
+  static TABLE_THREADS = chunkF5UYWPV4_cjs.TABLE_THREADS;
+  /** @deprecated import { TABLE_TRACES } from '@mastra/core/storage' instead */
+  static TABLE_TRACES = chunkF5UYWPV4_cjs.TABLE_TRACES;
+  hasInitialized = null;
+  shouldCacheInit = true;
+  constructor({ name }) {
+    super({
+      component: "STORAGE",
+      name
+    });
+  }
+  async __batchInsert({
+    tableName,
+    records
+  }) {
+    await this.init();
+    return this.batchInsert({ tableName, records });
+  }
+  async __getThreadById({ threadId }) {
+    await this.init();
+    return this.getThreadById({ threadId });
+  }
+  async __getThreadsByResourceId({ resourceId }) {
+    await this.init();
+    return this.getThreadsByResourceId({ resourceId });
+  }
+  async __saveThread({ thread }) {
+    await this.init();
+    return this.saveThread({ thread });
+  }
+  async __updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    await this.init();
+    return this.updateThread({ id, title, metadata });
+  }
+  async __deleteThread({ threadId }) {
+    await this.init();
+    return this.deleteThread({ threadId });
+  }
+  async __getMessages({ threadId, selectBy, threadConfig }) {
+    await this.init();
+    return this.getMessages({ threadId, selectBy, threadConfig });
+  }
+  async __saveMessages({ messages }) {
+    await this.init();
+    return this.saveMessages({ messages });
+  }
+  async __getTraces({
+    scope,
+    page,
+    perPage,
+    attributes
+  }) {
+    await this.init();
+    return this.getTraces({ scope, page, perPage, attributes });
+  }
+  async init() {
+    if (this.shouldCacheInit && await this.hasInitialized) {
+      return;
+    }
+    this.hasInitialized = Promise.all([
+      this.createTable({
+        tableName: chunkF5UYWPV4_cjs.TABLE_WORKFLOW_SNAPSHOT,
+        schema: {
+          workflow_name: {
+            type: "text"
+          },
+          run_id: {
+            type: "text"
+          },
+          snapshot: {
+            type: "text"
+          },
+          createdAt: {
+            type: "timestamp"
+          },
+          updatedAt: {
+            type: "timestamp"
+          }
+        }
+      }),
+      this.createTable({
+        tableName: chunkF5UYWPV4_cjs.TABLE_EVALS,
+        schema: {
+          input: {
+            type: "text"
+          },
+          output: {
+            type: "text"
+          },
+          result: {
+            type: "jsonb"
+          },
+          agent_name: {
+            type: "text"
+          },
+          metric_name: {
+            type: "text"
+          },
+          instructions: {
+            type: "text"
+          },
+          test_info: {
+            type: "jsonb",
+            nullable: true
+          },
+          global_run_id: {
+            type: "text"
+          },
+          run_id: {
+            type: "text"
+          },
+          created_at: {
+            type: "timestamp"
+          }
+        }
+      }),
+      this.createTable({
+        tableName: chunkF5UYWPV4_cjs.TABLE_THREADS,
+        schema: {
+          id: { type: "text", nullable: false, primaryKey: true },
+          resourceId: { type: "text", nullable: false },
+          title: { type: "text", nullable: false },
+          metadata: { type: "text", nullable: true },
+          createdAt: { type: "timestamp", nullable: false },
+          updatedAt: { type: "timestamp", nullable: false }
+        }
+      }),
+      this.createTable({
+        tableName: chunkF5UYWPV4_cjs.TABLE_MESSAGES,
+        schema: {
+          id: { type: "text", nullable: false, primaryKey: true },
+          thread_id: { type: "text", nullable: false },
+          content: { type: "text", nullable: false },
+          role: { type: "text", nullable: false },
+          type: { type: "text", nullable: false },
+          createdAt: { type: "timestamp", nullable: false }
+        }
+      }),
+      this.createTable({
+        tableName: chunkF5UYWPV4_cjs.TABLE_TRACES,
+        schema: {
+          id: { type: "text", nullable: false, primaryKey: true },
+          parentSpanId: { type: "text", nullable: true },
+          name: { type: "text", nullable: false },
+          traceId: { type: "text", nullable: false },
+          scope: { type: "text", nullable: false },
+          kind: { type: "integer", nullable: false },
+          attributes: { type: "jsonb", nullable: true },
+          status: { type: "jsonb", nullable: true },
+          events: { type: "jsonb", nullable: true },
+          links: { type: "jsonb", nullable: true },
+          other: { type: "text", nullable: true },
+          startTime: { type: "bigint", nullable: false },
+          endTime: { type: "bigint", nullable: false },
+          createdAt: { type: "timestamp", nullable: false }
+        }
+      })
+    ]).then(() => true);
+    await this.hasInitialized;
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    await this.init();
+    const data = {
+      workflow_name: workflowName,
+      run_id: runId,
+      snapshot,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId, data });
+    await this.insert({
+      tableName: chunkF5UYWPV4_cjs.TABLE_WORKFLOW_SNAPSHOT,
+      record: data
+    });
+  }
+  async loadWorkflowSnapshot({
+    workflowName,
+    runId
+  }) {
+    if (!this.hasInitialized) {
+      await this.init();
+    }
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const d = await this.load({
+      tableName: chunkF5UYWPV4_cjs.TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    return d ? d.snapshot : null;
+  }
+  async __getEvalsByAgentName(agentName, type) {
+    await this.init();
+    return this.getEvalsByAgentName(agentName, type);
+  }
+};
+
+exports.MastraStorage = MastraStorage;

package/dist/chunk-FRQFWZDN.cjs

@@ -0,0 +1,2 @@
+'use strict';
+