@mastra/core 0.0.0-storage-20250225005900

package/dist/base-eWkcLLSb.d.ts

@@ -0,0 +1,139 @@
+import * as _opentelemetry_api from '@opentelemetry/api';
+import { Tracer, Span } from '@opentelemetry/api';
+import { R as RegisteredLogger, L as Logger } from './index-C5uPdbs4.js';
+import { SpanExporter } from '@opentelemetry/sdk-trace-base';
+
+/** Sampling strategy configuration for OpenTelemetry */
+type SamplingStrategy = {
+    /** Sample traces based on a probability between 0 and 1 */
+    type: 'ratio';
+    /** Probability between 0 and 1 (e.g., 0.1 for 10% sampling) */
+    probability: number;
+} | {
+    /** Sample all traces */
+    type: 'always_on';
+} | {
+    /** Don't sample any traces */
+    type: 'always_off';
+} | {
+    /** Use parent sampling decision if available, otherwise use root sampler */
+    type: 'parent_based';
+    /** Configuration for the root sampler when no parent context exists */
+    root: {
+        /** Probability between 0 and 1 for the root sampler */
+        probability: number;
+    };
+};
+/** Configuration options for OpenTelemetry */
+type OtelConfig = {
+    /** Name of the service for telemetry identification */
+    serviceName?: string;
+    /** Whether telemetry is enabled. Defaults to true */
+    enabled?: boolean;
+    /** Name of the tracer to use. Defaults to 'mastra-tracer' */
+    tracerName?: string;
+    /** Sampling configuration to control trace data volume */
+    sampling?: SamplingStrategy;
+    /** Export configuration for sending telemetry data */
+    export?: {
+        /** Export to an OTLP (OpenTelemetry Protocol) endpoint */
+        type: 'otlp';
+        /** OTLP endpoint URL */
+        endpoint?: string;
+        /** Optional headers for OTLP requests */
+        headers?: Record<string, string>;
+    } | {
+        /** Export to console for development/debugging */
+        type: 'console';
+    } | {
+        type: 'custom';
+        tracerName?: string;
+        exporter: SpanExporter;
+    };
+};
+
+declare global {
+    var __TELEMETRY__: Telemetry | undefined;
+}
+declare class Telemetry {
+    tracer: Tracer;
+    name: string;
+    private constructor();
+    /**
+     * @deprecated This method does not do anything
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Initialize telemetry with the given configuration
+     * @param config - Optional telemetry configuration object
+     * @returns Telemetry instance that can be used for tracing
+     */
+    static init(config?: OtelConfig): Telemetry;
+    /**
+     * Get the global telemetry instance
+     * @throws {Error} If telemetry has not been initialized
+     * @returns {Telemetry} The global telemetry instance
+     */
+    static get(): Telemetry;
+    /**
+     * Wraps a class instance with telemetry tracing
+     * @param instance The class instance to wrap
+     * @param options Optional configuration for tracing
+     * @returns Wrapped instance with all methods traced
+     */
+    traceClass<T extends object>(instance: T, options?: {
+        /** Base name for spans (e.g. 'integration', 'agent') */
+        spanNamePrefix?: string;
+        /** Additional attributes to add to all spans */
+        attributes?: Record<string, string>;
+        /** Methods to exclude from tracing */
+        excludeMethods?: string[];
+        /** Skip tracing if telemetry is not active */
+        skipIfNoTelemetry?: boolean;
+    }): T;
+    /**
+     * method to trace individual methods with proper context
+     * @param method The method to trace
+     * @param context Additional context for the trace
+     * @returns Wrapped method with tracing
+     */
+    traceMethod<TMethod extends Function>(method: TMethod, context: {
+        spanName: string;
+        attributes?: Record<string, string>;
+        skipIfNoTelemetry?: boolean;
+        parentSpan?: Span;
+    }): TMethod;
+    getBaggageTracer(): Tracer;
+}
+
+declare class MastraBase {
+    component: RegisteredLogger;
+    protected logger: Logger;
+    name?: string;
+    telemetry?: Telemetry;
+    constructor({ component, name }: {
+        component?: RegisteredLogger;
+        name?: string;
+    });
+    /**
+     * Set the logger for the agent
+     * @param logger
+     */
+    __setLogger(logger: Logger): void;
+    /**
+     * Set the telemetry for the
+     * @param telemetry
+     */
+    __setTelemetry(telemetry: Telemetry): void;
+    /**
+     * Get the telemetry on the vector
+     * @returns telemetry
+     */
+    __getTelemetry(): Telemetry | undefined;
+    get experimental_telemetry(): {
+        tracer: _opentelemetry_api.Tracer;
+        isEnabled: boolean;
+    } | undefined;
+}
+
+export { MastraBase as M, type OtelConfig as O, type SamplingStrategy as S, Telemetry as T };

package/dist/base.d.ts

@@ -0,0 +1,6 @@
+import '@opentelemetry/api';
+import './index-C5uPdbs4.js';
+export { M as MastraBase } from './base-eWkcLLSb.js';
+import 'pino';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';

package/dist/base.js

@@ -0,0 +1 @@
+export { MastraBase } from './chunk-6RDA4JYW.js';

package/dist/bundler/index.d.ts

@@ -0,0 +1,28 @@
+import { M as MastraBase } from '../base-eWkcLLSb.js';
+import '@opentelemetry/api';
+import '../index-C5uPdbs4.js';
+import 'pino';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+
+interface IBundler {
+    loadEnvVars(): Promise<Map<string, string>>;
+    getEnvFiles(): Promise<string[]>;
+    bundle(entryFile: string, outputDirectory: string): Promise<void>;
+    prepare(outputDirectory: string): Promise<void>;
+    writePackageJson(outputDirectory: string, dependencies: Map<string, string>): Promise<void>;
+}
+declare abstract class MastraBundler extends MastraBase implements IBundler {
+    constructor({ name, component }: {
+        name: string;
+        component?: 'BUNDLER' | 'DEPLOYER';
+    });
+    loadEnvVars(): Promise<Map<string, string>>;
+    abstract prepare(outputDirectory: string): Promise<void>;
+    abstract writePackageJson(outputDirectory: string, dependencies: Map<string, string>): Promise<void>;
+    abstract writeInstrumentationFile(outputDirectory: string): Promise<void>;
+    abstract getEnvFiles(): Promise<string[]>;
+    abstract bundle(entryFile: string, outputDirectory: string): Promise<void>;
+}
+
+export { type IBundler, MastraBundler };

package/dist/bundler/index.js

@@ -0,0 +1 @@
+export { MastraBundler } from '../chunk-YUOADWSP.js';

package/dist/chunk-4IIE6KIC.js

@@ -0,0 +1,10 @@
+import { MastraBase } from './chunk-6RDA4JYW.js';
+
+// src/vector/index.ts
+var MastraVector = class extends MastraBase {
+  constructor() {
+    super({ name: "MastraVector", component: "VECTOR" });
+  }
+};
+
+export { MastraVector };

package/dist/chunk-4ZNSY7J7.js

@@ -0,0 +1,215 @@
+import { TABLE_WORKFLOW_SNAPSHOT, TABLE_EVALS, TABLE_MESSAGES, TABLE_THREADS, TABLE_TRACES } from './chunk-RG66XEJT.js';
+import { MastraBase } from './chunk-6RDA4JYW.js';
+
+// src/storage/base.ts
+var MastraStorage = class extends MastraBase {
+  /** @deprecated import from { TABLE_WORKFLOW_SNAPSHOT } '@mastra/core/storage' instead */
+  static TABLE_WORKFLOW_SNAPSHOT = TABLE_WORKFLOW_SNAPSHOT;
+  /** @deprecated import from { TABLE_EVALS } '@mastra/core/storage' instead */
+  static TABLE_EVALS = TABLE_EVALS;
+  /** @deprecated import from { TABLE_MESSAGES } '@mastra/core/storage' instead */
+  static TABLE_MESSAGES = TABLE_MESSAGES;
+  /** @deprecated import from { TABLE_THREADS } '@mastra/core/storage' instead */
+  static TABLE_THREADS = TABLE_THREADS;
+  /** @deprecated import { TABLE_TRACES } from '@mastra/core/storage' instead */
+  static TABLE_TRACES = TABLE_TRACES;
+  hasInitialized = null;
+  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 (await this.hasInitialized) {
+      return;
+    }
+    this.hasInitialized = Promise.all([
+      this.createTable({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        schema: {
+          workflow_name: {
+            type: "text"
+          },
+          run_id: {
+            type: "text"
+          },
+          snapshot: {
+            type: "text"
+          },
+          createdAt: {
+            type: "timestamp"
+          },
+          updatedAt: {
+            type: "timestamp"
+          }
+        }
+      }),
+      this.createTable({
+        tableName: 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: 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: 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: 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: 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: 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);
+  }
+};
+
+export { MastraStorage };