@mastra/core 0.0.0-a2a-20250421213654

package/LICENSE.md

@@ -0,0 +1,46 @@
+# Elastic License 2.0 (ELv2)
+
+Copyright (c) 2025 Mastra AI, Inc.
+
+**Acceptance**
+By using the software, you agree to all of the terms and conditions below.
+
+**Copyright License**
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below
+
+**Limitations**
+You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor’s trademarks is subject to applicable law.
+
+**Patents**
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+**Notices**
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
+
+**No Other Rights**
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+**Termination**
+If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
+
+**No Liability**
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
+
+**Definitions**
+The _licensor_ is the entity offering these terms, and the _software_ is the software the licensor makes available under these terms, including any portion of it.
+
+_you_ refers to the individual or entity agreeing to these terms.
+
+_your company_ is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. _control_ means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+_your licenses_ are all the licenses granted to you for the software under these terms.
+
+_use_ means anything you do with the software requiring one of your licenses.
+
+_trademark_ means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,182 @@
+# @mastra/core
+
+The core foundation of the Mastra framework, providing essential components and interfaces for building AI-powered applications.
+
+## Installation
+
+```bash
+npm install @mastra/core
+```
+
+## Overview
+
+`@mastra/core` is the foundational package of the Mastra framework, providing:
+
+- Core abstractions and interfaces
+- AI agent management and execution
+- Integration with multiple AI providers
+- Workflow orchestration
+- Memory and vector store management
+- Telemetry and logging infrastructure
+- Text-to-speech capabilities
+
+For comprehensive documentation, visit our [official documentation](https://mastra.ai/docs).
+
+## Core Components
+
+### Agents (`/agent`)
+
+Agents are autonomous AI entities that can understand instructions, use tools, and complete tasks. They encapsulate LLM interactions and can maintain conversation history, use provided tools, and follow specific behavioral guidelines through instructions.
+
+```typescript
+import { Agent } from '@mastra/core/agent';
+import { openai } from '@ai-sdk/openai';
+
+const agent = new Agent({
+  name: 'my-agent',
+  instructions: 'Your task-specific instructions',
+  model: openai('gpt-4o-mini'),
+  tools: {}, // Optional tools
+});
+```
+
+[Agent documentation →](https://mastra.ai/docs/agents/overview)
+
+### Workflows (`/workflows`)
+
+Workflows orchestrate complex AI tasks by combining multiple actions into a coherent sequence. They handle state management, error recovery, and can include conditional logic and parallel execution.
+
+```typescript
+import { Workflow } from '@mastra/core';
+
+const workflow = new Workflow({
+  name: 'my-workflow',
+  steps: [
+    // Workflow steps
+  ],
+});
+```
+
+[Workflow documentation →](https://mastra.ai/docs/workflows/overview)
+
+### Memory (`/memory`)
+
+Memory management provides persistent storage and retrieval of AI interactions. It supports different storage backends and enables context-aware conversations and long-term learning.
+
+```typescript
+import { Memory } from '@mastra/memory';
+import { Agent } from '@mastra/core/agent';
+import { openai } from '@ai-sdk/openai';
+
+const agent = new Agent({
+  name: 'Project Manager',
+  instructions: 'You are a project manager assistant.',
+  model: openai('gpt-4o-mini'),
+  memory: new Memory({
+    options: {
+      lastMessages: 20,
+      semanticRecall: {
+        topK: 3,
+        messageRange: { before: 2, after: 1 },
+      },
+    },
+  }),
+});
+```
+
+[Memory documentation →](https://mastra.ai/reference/memory/Memory)
+
+### Tools (`/tools`)
+
+Tools are functions that agents can use to interact with external systems or perform specific tasks. Each tool has a clear description and schema, making it easy for AI to understand and use them effectively.
+
+```typescript
+import { createTool } from '@mastra/core/tools';
+import { z } from 'zod';
+
+const weatherInfo = createTool({
+  id: 'Get Weather Information',
+  inputSchema: z.object({
+    city: z.string(),
+  }),
+  description: 'Fetches the current weather information for a given city',
+  execute: async ({ context: { city } }) => {
+    // Tool implementation
+  },
+});
+```
+
+[Tools documentation →](https://mastra.ai/docs/agents/adding-tools)
+
+### Evals (`/eval`)
+
+The evaluation system enables quantitative assessment of AI outputs. Create custom metrics to measure specific aspects of AI performance, from response quality to task completion accuracy.
+
+```typescript
+import { Agent } from '@mastra/core/agent';
+import { openai } from '@ai-sdk/openai';
+import { SummarizationMetric } from '@mastra/evals/llm';
+import { ContentSimilarityMetric, ToneConsistencyMetric } from '@mastra/evals/nlp';
+
+const model = openai('gpt-4o');
+
+const agent = new Agent({
+  name: 'ContentWriter',
+  instructions: 'You are a content writer that creates accurate summaries',
+  model,
+  evals: {
+    summarization: new SummarizationMetric(model),
+    contentSimilarity: new ContentSimilarityMetric(),
+    tone: new ToneConsistencyMetric(),
+  },
+});
+```
+
+[More evals documentation →](https://mastra.ai/docs/evals/overview)
+
+### Logger (`/logger`)
+
+The logging system provides structured, leveled logging with multiple transport options. It supports debug information, performance monitoring, and error tracking across your AI applications.
+
+```typescript
+import { createLogger, LogLevel } from '@mastra/core';
+
+const logger = createLogger({
+  name: 'MyApp',
+  level: LogLevel.INFO,
+});
+```
+
+[More logging documentation →](https://mastra.ai/reference/observability/logging)
+
+### Telemetry (`/telemetry`)
+
+Telemetry provides OpenTelemetry (Otel) integration for comprehensive monitoring of your AI systems. Track latency, success rates, and system health with distributed tracing and metrics collection.
+
+```typescript
+import { Mastra } from '@mastra/core';
+
+const mastra = new Mastra({
+  telemetry: {
+    serviceName: 'my-service',
+    enabled: true,
+    sampling: {
+      type: 'ratio',
+      probability: 0.5,
+    },
+    export: {
+      type: 'otlp',
+      endpoint: 'https://otel-collector.example.com/v1/traces',
+    },
+  },
+});
+```
+
+[More Telemetry documentation →](https://mastra.ai/reference/observability/telemetry)
+
+## Additional Resources
+
+- [Getting Started Guide](https://mastra.ai/docs/getting-started/installation)
+- [API Reference](https://mastra.ai/reference)
+- [Examples](https://mastra.ai/docs/examples)
+- [Deployment Guide](https://mastra.ai/docs/deployment/overview)

package/agent.d.ts

@@ -0,0 +1 @@
+export * from './dist/agent';

package/base.d.ts

@@ -0,0 +1 @@
+export * from './dist/base.d.cts';

package/bundler.d.ts

@@ -0,0 +1 @@
+export * from './dist/bundler';

package/deployer.d.ts

@@ -0,0 +1 @@
+export * from './dist/deployer';

package/di.d.ts

@@ -0,0 +1 @@
+export * from './dist/di';

package/dist/agent/index.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkBBDXZGCM_cjs = require('../chunk-BBDXZGCM.cjs');
+
+
+
+Object.defineProperty(exports, "Agent", {
+  enumerable: true,
+  get: function () { return chunkBBDXZGCM_cjs.Agent; }
+});

package/dist/agent/index.d.cts

@@ -0,0 +1,23 @@
+export { Message as AiMessageType } from 'ai';
+import 'json-schema';
+import 'zod';
+export { j as Agent, k as AgentConfig, aM as AgentGenerateOptions, aN as AgentStreamOptions, aG as MastraLanguageModel, aH as ToolsInput, aL as ToolsetsInput } from '../base-xpk2ifTz.cjs';
+import '../base-BihKcqDY.cjs';
+import '../di/index.cjs';
+import '../types-BtMyV38I.cjs';
+import 'sift';
+import '../index-CquI0inB.cjs';
+import 'stream';
+import 'pino';
+import '@opentelemetry/api';
+import 'xstate';
+import 'node:events';
+import '../vector/index.cjs';
+import '../vector/filter/index.cjs';
+import '@opentelemetry/sdk-trace-base';
+import '../tts/index.cjs';
+import '../deployer/index.cjs';
+import '../bundler/index.cjs';
+import 'hono';
+import 'hono/cors';
+import 'hono-openapi';

package/dist/agent/index.d.ts

@@ -0,0 +1,23 @@
+export { Message as AiMessageType } from 'ai';
+import 'json-schema';
+import 'zod';
+export { j as Agent, k as AgentConfig, aM as AgentGenerateOptions, aN as AgentStreamOptions, aG as MastraLanguageModel, aH as ToolsInput, aL as ToolsetsInput } from '../base-BlGpZfLc.js';
+import '../base-DT2poiVK.js';
+import '../di/index.js';
+import '../types-BtMyV38I.js';
+import 'sift';
+import '../index-CquI0inB.js';
+import 'stream';
+import 'pino';
+import '@opentelemetry/api';
+import 'xstate';
+import 'node:events';
+import '../vector/index.js';
+import '../vector/filter/index.js';
+import '@opentelemetry/sdk-trace-base';
+import '../tts/index.js';
+import '../deployer/index.js';
+import '../bundler/index.js';
+import 'hono';
+import 'hono/cors';
+import 'hono-openapi';

package/dist/agent/index.js

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

package/dist/base-BihKcqDY.d.cts

@@ -0,0 +1,146 @@
+import * as _opentelemetry_api from '@opentelemetry/api';
+import { Tracer, Span, Context } from '@opentelemetry/api';
+import { R as RegisteredLogger, L as Logger } from './index-CquI0inB.cjs';
+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;
+    /** Whether to disable local export */
+    disableLocalExport?: boolean;
+    /** Export configuration for sending telemetry data */
+    export?: {
+        /** Export to an OTLP (OpenTelemetry Protocol) endpoint */
+        type: 'otlp';
+        /** Whether to use gRPC or HTTP for OTLP */
+        protocol?: 'grpc' | 'http';
+        /** 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;
+    static getActiveSpan(): Span | undefined;
+    /**
+     * 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;
+    static setBaggage(baggage: Record<string, string>, ctx?: Context): Context;
+    static withContext(ctx: Context, fn: () => void): void;
+    /**
+     * 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 };