@mastra/core 0.10.3 → 0.10.4-alpha.0

package/dist/chunk-TRJIWZKM.js

@@ -0,0 +1,390 @@
+import { MastraError } from './chunk-PVGSY24V.js';
+import { isVercelTool } from './chunk-C4LMN2IR.js';
+import { MastraBase } from './chunk-5IEKR756.js';
+import { RuntimeContext } from './chunk-SGGPJWRQ.js';
+import { createHash } from 'crypto';
+import jsonSchemaToZod from 'json-schema-to-zod';
+import { z } from 'zod';
+import { convertZodSchemaToAISDKSchema, OpenAIReasoningSchemaCompatLayer, OpenAISchemaCompatLayer, GoogleSchemaCompatLayer, AnthropicSchemaCompatLayer, DeepSeekSchemaCompatLayer, MetaSchemaCompatLayer, applyCompatLayer } from '@mastra/schema-compat';
+
+var CoreToolBuilder = class extends MastraBase {
+  originalTool;
+  options;
+  logType;
+  constructor(input) {
+    super({ name: "CoreToolBuilder" });
+    this.originalTool = input.originalTool;
+    this.options = input.options;
+    this.logType = input.logType;
+  }
+  // Helper to get parameters based on tool type
+  getParameters = () => {
+    if (isVercelTool(this.originalTool)) {
+      return this.originalTool.parameters ?? z.object({});
+    }
+    return this.originalTool.inputSchema ?? z.object({});
+  };
+  // For provider-defined tools, we need to include all required properties
+  buildProviderTool(tool) {
+    if ("type" in tool && tool.type === "provider-defined" && "id" in tool && typeof tool.id === "string" && tool.id.includes(".")) {
+      return {
+        type: "provider-defined",
+        id: tool.id,
+        args: "args" in this.originalTool ? this.originalTool.args : {},
+        description: tool.description,
+        parameters: convertZodSchemaToAISDKSchema(this.getParameters()),
+        execute: this.originalTool.execute ? this.createExecute(
+          this.originalTool,
+          { ...this.options, description: this.originalTool.description },
+          this.logType
+        ) : void 0
+      };
+    }
+    return void 0;
+  }
+  createLogMessageOptions({ agentName, toolName, type }) {
+    if (!agentName) {
+      return {
+        start: `Executing tool ${toolName}`,
+        error: `Failed tool execution`
+      };
+    }
+    const prefix = `[Agent:${agentName}]`;
+    const toolType = type === "toolset" ? "toolset" : "tool";
+    return {
+      start: `${prefix} - Executing ${toolType} ${toolName}`,
+      error: `${prefix} - Failed ${toolType} execution`
+    };
+  }
+  createExecute(tool, options, logType) {
+    const { logger, mastra: _mastra, memory: _memory, runtimeContext, ...rest } = options;
+    const { start, error } = this.createLogMessageOptions({
+      agentName: options.agentName,
+      toolName: options.name,
+      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,
+          runtimeContext: options.runtimeContext ?? new RuntimeContext()
+        },
+        execOptions
+      ) ?? void 0;
+    };
+    return async (args, execOptions) => {
+      let logger2 = options.logger || this.logger;
+      try {
+        logger2.debug(start, { ...rest, args });
+        return await execFunction(args, execOptions);
+      } catch (err) {
+        const mastraError = new MastraError(
+          {
+            id: "TOOL_EXECUTION_FAILED",
+            domain: "TOOL" /* TOOL */,
+            category: "USER" /* USER */,
+            details: {
+              error,
+              args,
+              model: rest.model?.modelId ?? ""
+            }
+          },
+          err
+        );
+        logger2.trackException(mastraError);
+        logger2.error(error, { ...rest, error: mastraError, args });
+        throw mastraError;
+      }
+    };
+  }
+  build() {
+    const providerTool = this.buildProviderTool(this.originalTool);
+    if (providerTool) {
+      return providerTool;
+    }
+    const definition = {
+      type: "function",
+      description: this.originalTool.description,
+      parameters: this.getParameters(),
+      execute: this.originalTool.execute ? this.createExecute(
+        this.originalTool,
+        { ...this.options, description: this.originalTool.description },
+        this.logType
+      ) : void 0
+    };
+    const model = this.options.model;
+    const schemaCompatLayers = [];
+    if (model) {
+      schemaCompatLayers.push(
+        new OpenAIReasoningSchemaCompatLayer(model),
+        new OpenAISchemaCompatLayer(model),
+        new GoogleSchemaCompatLayer(model),
+        new AnthropicSchemaCompatLayer(model),
+        new DeepSeekSchemaCompatLayer(model),
+        new MetaSchemaCompatLayer(model)
+      );
+    }
+    const processedSchema = applyCompatLayer({
+      schema: this.getParameters(),
+      compatLayers: schemaCompatLayers,
+      mode: "aiSdkSchema"
+    });
+    return {
+      ...definition,
+      parameters: processedSchema
+    };
+  }
+};
+
+// src/utils.ts
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+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});`)(z);
+}
+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(originalTool, options, logType) {
+  return new CoreToolBuilder({ originalTool, options, logType }).build();
+}
+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);
+    }
+  });
+}
+function checkEvalStorageFields(traceObject, logger) {
+  const missingFields = [];
+  if (!traceObject.input) missingFields.push("input");
+  if (!traceObject.output) missingFields.push("output");
+  if (!traceObject.agentName) missingFields.push("agent_name");
+  if (!traceObject.metricName) missingFields.push("metric_name");
+  if (!traceObject.instructions) missingFields.push("instructions");
+  if (!traceObject.globalRunId) missingFields.push("global_run_id");
+  if (!traceObject.runId) missingFields.push("run_id");
+  if (missingFields.length > 0) {
+    if (logger) {
+      logger.warn("Skipping evaluation storage due to missing required fields", {
+        missingFields,
+        runId: traceObject.runId,
+        agentName: traceObject.agentName
+      });
+    } else {
+      console.warn("Skipping evaluation storage due to missing required fields", {
+        missingFields,
+        runId: traceObject.runId,
+        agentName: traceObject.agentName
+      });
+    }
+    return false;
+  }
+  return true;
+}
+function detectSingleMessageCharacteristics(message) {
+  if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
+  message.role === "data" || // UI-only role
+  "toolInvocations" in message || // UI-specific field
+  "parts" in message || // UI-specific field
+  "experimental_attachments" in message)) {
+    return "has-ui-specific-parts";
+  } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
+  "experimental_providerMetadata" in message || "providerOptions" in message)) {
+    return "has-core-specific-parts";
+  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
+    return "message";
+  } else {
+    return "other";
+  }
+}
+function isUiMessage(message) {
+  return detectSingleMessageCharacteristics(message) === `has-ui-specific-parts`;
+}
+function isCoreMessage(message) {
+  return [`has-core-specific-parts`, `message`].includes(detectSingleMessageCharacteristics(message));
+}
+var SQL_IDENTIFIER_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function parseSqlIdentifier(name, kind = "identifier") {
+  if (!SQL_IDENTIFIER_PATTERN.test(name) || name.length > 63) {
+    throw new Error(
+      `Invalid ${kind}: ${name}. Must start with a letter or underscore, contain only letters, numbers, or underscores, and be at most 63 characters long.`
+    );
+  }
+  return name;
+}
+function parseFieldKey(key) {
+  if (!key) throw new Error("Field key cannot be empty");
+  const segments = key.split(".");
+  for (const segment of segments) {
+    if (!SQL_IDENTIFIER_PATTERN.test(segment) || segment.length > 63) {
+      throw new Error(`Invalid field key segment: ${segment} in ${key}`);
+    }
+  }
+  return key;
+}
+
+export { checkEvalStorageFields, createMastraProxy, deepMerge, delay, ensureToolProperties, isCoreMessage, isUiMessage, isZodType, makeCoreTool, maskStreamTags, parseFieldKey, parseSqlIdentifier, resolveSerializedZodOutput };

package/dist/{chunk-ZPOETARN.js → chunk-V6I25JEV.js}

@@ -1,5 +1,5 @@
 import { InstrumentClass } from './chunk-EWDGXKOQ.js';
-import { MastraBase } from './chunk-JOCKZ2US.js';
+import { MastraBase } from './chunk-5IEKR756.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 
 // src/tts/index.ts

package/dist/{chunk-IBIGJYTD.cjs → chunk-VAOBU5SY.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
 var chunkBB6DPGIV_cjs = require('./chunk-BB6DPGIV.cjs');
-var chunkMVXVUMLA_cjs = require('./chunk-MVXVUMLA.cjs');
+var chunkMHN2BI4P_cjs = require('./chunk-MHN2BI4P.cjs');
 var chunk4Z3OU5RY_cjs = require('./chunk-4Z3OU5RY.cjs');
-var chunkVHZPWE5L_cjs = require('./chunk-VHZPWE5L.cjs');
-var chunkRFAN7FAT_cjs = require('./chunk-RFAN7FAT.cjs');
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
+var chunkZIZ3CVHN_cjs = require('./chunk-ZIZ3CVHN.cjs');
 var chunkLABUWBKX_cjs = require('./chunk-LABUWBKX.cjs');
 var crypto = require('crypto');
 var EventEmitter = require('events');
@@ -16,10 +16,10 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 var EventEmitter__default = /*#__PURE__*/_interopDefault(EventEmitter);
 
 // src/workflows/execution-engine.ts
-var ExecutionEngine = class extends chunkVHZPWE5L_cjs.MastraBase {
+var ExecutionEngine = class extends chunkP3Q73CAW_cjs.MastraBase {
   mastra;
   constructor({ mastra }) {
-    super({ name: "ExecutionEngine", component: chunkRFAN7FAT_cjs.RegisteredLogger.WORKFLOW });
+    super({ name: "ExecutionEngine", component: chunkZIZ3CVHN_cjs.RegisteredLogger.WORKFLOW });
     this.mastra = mastra;
   }
   __registerMastra(mastra) {
@@ -720,7 +720,7 @@ var DefaultExecutionEngine = class extends ExecutionEngine {
 
 // src/workflows/workflow.ts
 function createStep(params) {
-  if (params instanceof chunkMVXVUMLA_cjs.Agent) {
+  if (params instanceof chunkMHN2BI4P_cjs.Agent) {
     return {
       id: params.name,
       // @ts-ignore
@@ -838,7 +838,7 @@ function cloneWorkflow(workflow, opts) {
   wf.commit();
   return wf;
 }
-var Workflow = class extends chunkVHZPWE5L_cjs.MastraBase {
+var Workflow = class extends chunkP3Q73CAW_cjs.MastraBase {
   id;
   description;
   inputSchema;
@@ -862,7 +862,7 @@ var Workflow = class extends chunkVHZPWE5L_cjs.MastraBase {
     retryConfig,
     steps
   }) {
-    super({ name: id, component: chunkRFAN7FAT_cjs.RegisteredLogger.WORKFLOW });
+    super({ name: id, component: chunkZIZ3CVHN_cjs.RegisteredLogger.WORKFLOW });
     this.id = id;
     this.description = description;
     this.inputSchema = inputSchema;

package/dist/{chunk-X6VHQCYN.cjs → chunk-W5I6MEVU.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
 var chunkTICDQWVJ_cjs = require('./chunk-TICDQWVJ.cjs');
-var chunkVHZPWE5L_cjs = require('./chunk-VHZPWE5L.cjs');
+var chunkP3Q73CAW_cjs = require('./chunk-P3Q73CAW.cjs');
 
 // src/storage/base.ts
-var MastraStorage = class extends chunkVHZPWE5L_cjs.MastraBase {
+var MastraStorage = class extends chunkP3Q73CAW_cjs.MastraBase {
   /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
   static TABLE_WORKFLOW_SNAPSHOT = chunkTICDQWVJ_cjs.TABLE_WORKFLOW_SNAPSHOT;
   /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */

package/dist/{chunk-677GIYFF.js → chunk-YCYAVLYR.js}

@@ -1,4 +1,4 @@
-import { isUiMessage, isCoreMessage } from './chunk-Y5BGCPNZ.js';
+import { isUiMessage, isCoreMessage } from './chunk-TRJIWZKM.js';
 import { randomUUID } from 'crypto';
 import { convertToCoreMessages } from 'ai';
 import { convertUint8ArrayToBase64, convertBase64ToUint8Array } from '@ai-sdk/provider-utils';

package/dist/{chunk-TIPFGQCO.js → chunk-YKJZX7TE.js}

@@ -1,7 +1,7 @@
 import { augmentWithInit } from './chunk-YOQP5T77.js';
 import { InstrumentClass, Telemetry } from './chunk-EWDGXKOQ.js';
-import { noopLogger } from './chunk-OBEALYTK.js';
-import { ConsoleLogger, LogLevel } from './chunk-XXVGT7SJ.js';
+import { noopLogger } from './chunk-DO5R43AJ.js';
+import { ConsoleLogger, LogLevel } from './chunk-5YDTZN2X.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
 
 // src/mastra/index.ts
@@ -436,7 +436,13 @@ do:
   }
   async getLogsByRunId({
     runId,
-    transportId
+    transportId,
+    fromDate,
+    toDate,
+    logLevel,
+    filters,
+    page,
+    perPage
   }) {
     if (!transportId) {
       throw new Error("Transport ID is required");
@@ -446,18 +452,23 @@ do:
     }
     return await this.#logger.getLogsByRunId({
       runId,
-      transportId
+      transportId,
+      fromDate,
+      toDate,
+      logLevel,
+      filters,
+      page,
+      perPage
     });
   }
-  async getLogs(transportId) {
+  async getLogs(transportId, params) {
     if (!transportId) {
       throw new Error("Transport ID is required");
     }
     if (!this.#logger?.getLogs) {
       throw new Error("Logger is not set");
     }
-    console.log(this.#logger);
-    return await this.#logger.getLogs(transportId);
+    return await this.#logger.getLogs(transportId, params);
   }
   /**
    * Get all registered MCP server instances.

package/dist/{chunk-RFAN7FAT.cjs → chunk-ZIZ3CVHN.cjs}

@@ -38,17 +38,40 @@ var MastraLogger = class {
   getTransports() {
     return this.transports;
   }
-  async getLogs(transportId) {
+  trackException(_error) {
+  }
+  async getLogs(transportId, params) {
     if (!transportId || !this.transports.has(transportId)) {
-      return [];
+      return { logs: [], total: 0, page: params?.page ?? 1, perPage: params?.perPage ?? 100, hasMore: false };
     }
-    return this.transports.get(transportId).getLogs() ?? [];
+    return this.transports.get(transportId).getLogs(params) ?? {
+      logs: [],
+      total: 0,
+      page: params?.page ?? 1,
+      perPage: params?.perPage ?? 100,
+      hasMore: false
+    };
   }
-  async getLogsByRunId({ transportId, runId }) {
+  async getLogsByRunId({
+    transportId,
+    runId,
+    fromDate,
+    toDate,
+    logLevel,
+    filters,
+    page,
+    perPage
+  }) {
     if (!transportId || !this.transports.has(transportId) || !runId) {
-      return [];
+      return { logs: [], total: 0, page: page ?? 1, perPage: perPage ?? 100, hasMore: false };
     }
-    return this.transports.get(transportId).getLogsByRunId({ runId }) ?? [];
+    return this.transports.get(transportId).getLogsByRunId({ runId, fromDate, toDate, logLevel, filters, page, perPage }) ?? {
+      logs: [],
+      total: 0,
+      page: page ?? 1,
+      perPage: perPage ?? 100,
+      hasMore: false
+    };
   }
 };
 
@@ -82,11 +105,11 @@ var ConsoleLogger = class extends MastraLogger {
       console.error(message, ...args);
     }
   }
-  async getLogs(_transportId) {
-    return [];
+  async getLogs(_transportId, _params) {
+    return { logs: [], total: 0, page: _params?.page ?? 1, perPage: _params?.perPage ?? 100, hasMore: false };
   }
   async getLogsByRunId(_args) {
-    return [];
+    return { logs: [], total: 0, page: _args.page ?? 1, perPage: _args.perPage ?? 100, hasMore: false };
   }
 };
 

package/dist/{chunk-PKYG5CWB.cjs → chunk-ZZLBNB3U.cjs}

@@ -1,9 +1,9 @@
 'use strict';
 
-var chunkCYJF6U6B_cjs = require('./chunk-CYJF6U6B.cjs');
+var chunkFEYYOBBG_cjs = require('./chunk-FEYYOBBG.cjs');
 
 // src/deployer/index.ts
-var MastraDeployer = class extends chunkCYJF6U6B_cjs.MastraBundler {
+var MastraDeployer = class extends chunkFEYYOBBG_cjs.MastraBundler {
   constructor({ name }) {
     super({ component: "DEPLOYER", name });
   }

package/dist/deployer/index.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-var chunkPKYG5CWB_cjs = require('../chunk-PKYG5CWB.cjs');
+var chunkZZLBNB3U_cjs = require('../chunk-ZZLBNB3U.cjs');
 
 
 
 Object.defineProperty(exports, "MastraDeployer", {
   enumerable: true,
-  get: function () { return chunkPKYG5CWB_cjs.MastraDeployer; }
+  get: function () { return chunkZZLBNB3U_cjs.MastraDeployer; }
 });

package/dist/deployer/index.d.cts

@@ -1,7 +1,8 @@
 import { MastraBundler, IBundler } from '../bundler/index.cjs';
-import '../base-BY9WFI65.cjs';
+import '../base-CO-L7hF9.cjs';
 import '@opentelemetry/api';
-import '../logger-BF2Sn7JX.cjs';
+import '../logger-CpL0z5v_.cjs';
+import '../error/index.cjs';
 import 'stream';
 import '@opentelemetry/sdk-trace-base';
 

package/dist/deployer/index.d.ts

@@ -1,7 +1,8 @@
 import { MastraBundler, IBundler } from '../bundler/index.js';
-import '../base-C0yUw8BC.js';
+import '../base-Bi9KB0TN.js';
 import '@opentelemetry/api';
-import '../logger-BF2Sn7JX.js';
+import '../logger-DtVDdb81.js';
+import '../error/index.js';
 import 'stream';
 import '@opentelemetry/sdk-trace-base';
 

package/dist/deployer/index.js

@@ -1 +1 @@
-export { MastraDeployer } from '../chunk-XJCP3SLA.js';
+export { MastraDeployer } from '../chunk-JNMQKJH4.js';