@mastra/core 0.0.0-storage-20250225005900

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ehindero Israel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,180 @@
+# @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 { openai } from '@ai-sdk/openai';
+import { Agent } from '@mastra/core/agent';
+
+const agent = new Agent({
+  name: 'my-agent',
+  instructions: 'Your task-specific instructions',
+  model: openai('gpt-4o-mini'),
+  tools: {}, // Optional tools
+});
+```
+
+[More agent documentation →](https://mastra.ai/docs/reference/agents/overview)
+
+### Embeddings (`/embeddings`)
+
+The embeddings module provides a unified interface for converting text into vector representations across multiple AI providers. These vectors are essential for semantic search, similarity comparisons, and other NLP tasks.
+
+```typescript
+import { openai } from '@ai-sdk/openai';
+import { embed } from 'ai';
+
+const embeddings = await embed({
+  model: openai.embedding('text-embedding-3-small'),
+  value: 'text to embed',
+});
+```
+
+Supported providers right now are OpenAI, Cohere, Amazon Bedrock, Google AI, Mistral, and Voyage.
+
+[More embeddings documentation →](https://mastra.ai/docs/reference/embeddings/overview)
+
+### Evaluations (`/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 { Metric, evaluate } from '@mastra/core';
+
+class CustomMetric extends Metric {
+  async measure(input: string, output: string): Promise<MetricResult> {
+    // Your evaluation logic
+    return { score: 0.95 };
+  }
+}
+```
+
+[More evaluations documentation →](https://mastra.ai/docs/reference/eval/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 { MastraMemory } from '@mastra/core';
+
+const memory = new MastraMemory({
+  // Memory configuration
+});
+```
+
+**Note:** this is the base `MastraMemory` class. This class in `@mastra/core` is intended to be extended when developing custom agent memory strategies.
+To use a premade memory strategy (recommended), with long and short term memory built in, use `import { Memory } from "@mastra/memory"` instead.
+
+[Visit the memory documentation to use Memory in your project →](https://mastra.ai/docs/reference/memory/overview)
+
+### Vector Stores (`/vector`)
+
+Vector stores provide the infrastructure for storing and querying vector embeddings. They support semantic search, similarity matching, and efficient vector operations across different backend implementations.
+
+```typescript
+import { MastraVector } from '@mastra/core';
+
+class CustomVectorStore extends MastraVector {
+  // Vector store implementation
+}
+```
+
+[More vector stores documentation →](https://mastra.ai/docs/reference/vector/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
+  ],
+});
+```
+
+[More workflows documentation →](https://mastra.ai/docs/reference/workflows/overview)
+
+### 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 { ToolAction } from '@mastra/core';
+
+const tool = new ToolAction({
+  name: 'tool-name',
+  description: 'Tool description',
+  execute: async context => {
+    // Tool implementation
+  },
+});
+```
+
+[More tools documentation →](https://mastra.ai/docs/reference/tools/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/docs/reference/observability/logging)
+
+### Telemetry (`/telemetry`)
+
+Telemetry provides OpenTelemetry integration for comprehensive monitoring of your AI systems. Track latency, success rates, and system health with distributed tracing and metrics collection.
+
+```typescript
+import { Telemetry } from '@mastra/core';
+
+const telemetry = Telemetry.init({
+  serviceName: 'my-service',
+});
+```
+
+[More Telemetry documentation →](https://mastra.ai/docs/reference/observability/telemetry)
+
+## Additional Resources
+
+- [Getting Started Guide](https://mastra.ai/docs/getting-started/installation)
+- [API Reference](https://mastra.ai/docs/reference)
+- [Examples](https://mastra.ai/docs/examples)
+- [Deployment Guide](https://mastra.ai/docs/deployment/overview)

package/dist/agent/index.d.ts

@@ -0,0 +1,15 @@
+import 'ai';
+import 'json-schema';
+import 'zod';
+export { A as Agent } from '../base-CHNzbTDj.js';
+import '../base-eWkcLLSb.js';
+import '../types-m9RryK9a.js';
+import '../voice/index.js';
+import 'sift';
+import '../vector/index.js';
+import '@opentelemetry/api';
+import '../index-C5uPdbs4.js';
+import 'pino';
+import 'stream';
+import '@opentelemetry/sdk-trace-base';
+import '../tts/index.js';

package/dist/agent/index.js

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