@mastra/core 0.1.27-unstable.1 → 0.2.0-alpha.100

package/README.md

@@ -1,8 +1,180 @@
 # @mastra/core
 
-This is a guide to developing the core package.
+The core foundation of the Mastra framework, providing essential components and interfaces for building AI-powered applications.
 
-### Install Dependencies for Core Package
+## Installation
 
-1. Navigate to the core directory:`cd packages/core`
-2. Install the dependencies:`pnpm install`
+```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

@@ -1,60 +1,16 @@
-import { UserContent } from 'ai';
-import { Integration } from '../integration';
-import { Logger } from '../logger';
-import { AllTools, ToolApi } from '../tools/types';
-import { LLM } from '../llm';
-import { ModelConfig, StructuredOutput } from '../llm/types';
-export declare class Agent<TTools, TIntegrations extends Integration[] | undefined = undefined, TKeys extends keyof AllTools<TTools, TIntegrations> = keyof AllTools<TTools, TIntegrations>> {
-    name: string;
-    readonly llm: LLM<TTools, TIntegrations, TKeys>;
-    readonly instructions: string;
-    readonly model: ModelConfig;
-    readonly enabledTools: Partial<Record<TKeys, boolean>>;
-    logger: Logger;
-    constructor(config: {
-        name: string;
-        instructions: string;
-        model: ModelConfig;
-        enabledTools?: Partial<Record<TKeys, boolean>>;
-    });
-    /**
-     * Set the concrete tools for the agent
-     * @param tools
-     */
-    __setTools(tools: Record<TKeys, ToolApi>): void;
-    /**
-     * Set the logger for the agent
-     * @param logger
-     */
-    __setLogger(logger: Logger): void;
-    text({ messages, onStepFinish, maxSteps, }: {
-        messages: UserContent[];
-        onStepFinish?: (step: string) => void;
-        maxSteps?: number;
-    }): Promise<import("ai").GenerateTextResult<{}>>;
-    textObject({ messages, structuredOutput, onStepFinish, maxSteps, }: {
-        messages: UserContent[];
-        structuredOutput: StructuredOutput;
-        onStepFinish?: (step: string) => void;
-        maxSteps?: number;
-    }): Promise<import("ai").GenerateObjectResult<{
-        [x: string]: any;
-    }>>;
-    stream({ messages, onStepFinish, onFinish, maxSteps, }: {
-        messages: UserContent[];
-        onStepFinish?: (step: string) => void;
-        onFinish?: (result: string) => Promise<void> | void;
-        maxSteps?: number;
-    }): Promise<import("ai").StreamTextResult<{}>>;
-    streamObject({ messages, structuredOutput, onStepFinish, onFinish, maxSteps, }: {
-        messages: UserContent[];
-        structuredOutput: StructuredOutput;
-        onStepFinish?: (step: string) => void;
-        onFinish?: (result: string) => Promise<void> | void;
-        maxSteps?: number;
-    }): Promise<import("ai").StreamObjectResult<{
-        [x: string]: any;
-    }, {
-        [x: string]: any;
-    }, never>>;
-}
+import 'ai';
+import 'json-schema';
+import 'zod';
+export { A as Agent } from '../index-Cwb-5AzX.js';
+import '../base.js';
+import '../metric-BWeQNZt6.js';
+import '../telemetry-oCUM52DG.js';
+import 'sift';
+import '../index-CBZ2mk2H.js';
+import 'pino';
+import 'stream';
+import '../vector/index.js';
+import '@opentelemetry/api';
+import '@opentelemetry/sdk-node';
+import '@opentelemetry/sdk-trace-base';
+import '../tts/index.js';

package/dist/agent/index.js

@@ -0,0 +1,7 @@
+export { Agent } from '../chunk-QXH6EK72.js';
+import '../chunk-4ZUSEHLH.js';
+import '../chunk-KNPBNSJ7.js';
+import '../chunk-G4MCO7XF.js';
+import '../chunk-ICMEXHKD.js';
+import '../chunk-HBTQNIAX.js';
+import '../chunk-AJJZUHB4.js';

package/dist/base.d.ts

@@ -0,0 +1,46 @@
+import * as _opentelemetry_api from '@opentelemetry/api';
+import { R as RegisteredLogger, L as Logger, a as LogLevel } from './index-CBZ2mk2H.js';
+import { T as Telemetry } from './telemetry-oCUM52DG.js';
+import 'pino';
+import 'stream';
+import '@opentelemetry/sdk-node';
+import '@opentelemetry/sdk-trace-base';
+
+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;
+    /**
+     * Internal logging helper that formats and sends logs to the configured logger
+     * @param level - Severity level of the log
+     * @param message - Main log message
+     * @param opts - Optional object for the log
+     */
+    log(level: LogLevel, message: string, opts?: Record<string, any>): 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 };

package/dist/base.js

@@ -0,0 +1,3 @@
+export { MastraBase } from './chunk-G4MCO7XF.js';
+import './chunk-ICMEXHKD.js';
+import './chunk-AJJZUHB4.js';

package/dist/bundler/index.d.ts

@@ -0,0 +1,29 @@
+import { MastraBase } from '../base.js';
+import '@opentelemetry/api';
+import '../index-CBZ2mk2H.js';
+import 'pino';
+import 'stream';
+import '../telemetry-oCUM52DG.js';
+import '@opentelemetry/sdk-node';
+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 getEnvFiles(): Promise<string[]>;
+    abstract bundle(entryFile: string, outputDirectory: string): Promise<void>;
+}
+
+export { type IBundler, MastraBundler };

package/dist/bundler/index.js

@@ -0,0 +1,4 @@
+export { MastraBundler } from '../chunk-MCB4M5W4.js';
+import '../chunk-G4MCO7XF.js';
+import '../chunk-ICMEXHKD.js';
+import '../chunk-AJJZUHB4.js';

package/dist/chunk-42DYOLDV.js

@@ -0,0 +1,96 @@
+import { createTool } from './chunk-VOUPGVRD.js';
+import { __name, __publicField } from './chunk-AJJZUHB4.js';
+import { z } from 'zod';
+
+// src/integration/integration.ts
+var _Integration = class _Integration {
+  constructor() {
+    __publicField(this, "name", "Integration");
+    __publicField(this, "workflows");
+    this.workflows = {};
+  }
+  /**
+  * Workflows
+  */
+  registerWorkflow(name, fn) {
+    if (this.workflows[name]) {
+      throw new Error(`Sync function "${name}" already registered`);
+    }
+    this.workflows[name] = fn;
+  }
+  getWorkflows({ serialized }) {
+    if (serialized) {
+      return Object.entries(this.workflows).reduce((acc, [k, v]) => {
+        return {
+          ...acc,
+          [k]: {
+            name: v.name
+          }
+        };
+      }, {});
+    }
+    return this.workflows;
+  }
+  /**
+  * TOOLS
+  */
+  getStaticTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getTools(_params) {
+    throw new Error("Method not implemented.");
+  }
+  async getApiClient() {
+    throw new Error("Method not implemented");
+  }
+};
+__name(_Integration, "Integration");
+var Integration = _Integration;
+var _OpenAPIToolset = class _OpenAPIToolset {
+  constructor() {
+    __publicField(this, "authType", "API_KEY");
+  }
+  get toolSchemas() {
+    return {};
+  }
+  get toolDocumentations() {
+    return {};
+  }
+  get baseClient() {
+    return {};
+  }
+  async getApiClient() {
+    throw new Error("API not implemented");
+  }
+  _generateIntegrationTools() {
+    const { client, ...clientMethods } = this.baseClient;
+    const schemas = this.toolSchemas;
+    const documentations = this.toolDocumentations;
+    const tools = Object.keys(clientMethods).reduce((acc, key) => {
+      const comment = documentations[key]?.comment;
+      const fallbackComment = `Execute ${key}`;
+      const tool = createTool({
+        id: key,
+        inputSchema: schemas[key] || z.object({}),
+        description: comment || fallbackComment,
+        // documentation: doc || fallbackComment,
+        execute: /* @__PURE__ */ __name(async ({ context }) => {
+          const client2 = await this.getApiClient();
+          const value = client2[key];
+          return value({
+            ...context
+          });
+        }, "execute")
+      });
+      return {
+        ...acc,
+        [key]: tool
+      };
+    }, {});
+    return tools;
+  }
+};
+__name(_OpenAPIToolset, "OpenAPIToolset");
+var OpenAPIToolset = _OpenAPIToolset;
+
+export { Integration, OpenAPIToolset };

package/dist/chunk-4LJFWC2Q.js

@@ -0,0 +1,216 @@
+import { __name, __publicField } from './chunk-AJJZUHB4.js';
+
+// src/filter/base.ts
+var _a;
+var BaseFilterTranslator = (_a = class {
+  /**
+  * Operator type checks
+  */
+  isOperator(key) {
+    return key.startsWith("$");
+  }
+  isLogicalOperator(key) {
+    return _a.DEFAULT_OPERATORS.logical.includes(key);
+  }
+  isBasicOperator(key) {
+    return _a.DEFAULT_OPERATORS.basic.includes(key);
+  }
+  isNumericOperator(key) {
+    return _a.DEFAULT_OPERATORS.numeric.includes(key);
+  }
+  isArrayOperator(key) {
+    return _a.DEFAULT_OPERATORS.array.includes(key);
+  }
+  isElementOperator(key) {
+    return _a.DEFAULT_OPERATORS.element.includes(key);
+  }
+  isRegexOperator(key) {
+    return _a.DEFAULT_OPERATORS.regex.includes(key);
+  }
+  isFieldOperator(key) {
+    return this.isOperator(key) && !this.isLogicalOperator(key);
+  }
+  isCustomOperator(key) {
+    const support = this.getSupportedOperators();
+    return support.custom?.includes(key) ?? false;
+  }
+  getSupportedOperators() {
+    return _a.DEFAULT_OPERATORS;
+  }
+  isValidOperator(key) {
+    const support = this.getSupportedOperators();
+    const allSupported = Object.values(support).flat();
+    return allSupported.includes(key);
+  }
+  /**
+  * Value normalization for comparison operators
+  */
+  normalizeComparisonValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "number" && Object.is(value, -0)) {
+      return 0;
+    }
+    return value;
+  }
+  /**
+  * Helper method to simulate $all operator using $and + $eq when needed.
+  * Some vector stores don't support $all natively.
+  */
+  simulateAllOperator(field, values) {
+    return {
+      $and: values.map((value) => ({
+        [field]: {
+          $in: [
+            this.normalizeComparisonValue(value)
+          ]
+        }
+      }))
+    };
+  }
+  /**
+  * Utility functions for type checking
+  */
+  isPrimitive(value) {
+    return value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  isRegex(value) {
+    return value instanceof RegExp;
+  }
+  isEmpty(obj) {
+    return obj === null || obj === undefined || typeof obj === "object" && Object.keys(obj).length === 0;
+  }
+  /**
+  * Helper to handle array value normalization consistently
+  */
+  normalizeArrayValues(values) {
+    return values.map((value) => this.normalizeComparisonValue(value));
+  }
+  validateFilter(filter) {
+    const validation = this.validateFilterSupport(filter);
+    if (!validation.supported) {
+      throw new Error(validation.messages.join(", "));
+    }
+  }
+  /**
+  * Validates if a filter structure is supported by the specific vector DB
+  * and returns detailed validation information.
+  */
+  validateFilterSupport(node, path = "") {
+    const messages = [];
+    if (this.isPrimitive(node) || this.isEmpty(node)) {
+      return {
+        supported: true,
+        messages: []
+      };
+    }
+    if (Array.isArray(node)) {
+      const arrayResults = node.map((item) => this.validateFilterSupport(item, path));
+      const arrayMessages = arrayResults.flatMap((r) => r.messages);
+      return {
+        supported: arrayResults.every((r) => r.supported),
+        messages: arrayMessages
+      };
+    }
+    const nodeObj = node;
+    let isSupported = true;
+    for (const [key, value] of Object.entries(nodeObj)) {
+      const newPath = path ? `${path}.${key}` : key;
+      if (this.isOperator(key)) {
+        if (!this.isValidOperator(key)) {
+          isSupported = false;
+          messages.push(_a.ErrorMessages.UNSUPPORTED_OPERATOR(key));
+          continue;
+        }
+        if (!path && !this.isLogicalOperator(key)) {
+          isSupported = false;
+          messages.push(_a.ErrorMessages.INVALID_TOP_LEVEL_OPERATOR(key));
+          continue;
+        }
+        if (key === "$elemMatch" && (typeof value !== "object" || Array.isArray(value))) {
+          isSupported = false;
+          messages.push(_a.ErrorMessages.ELEM_MATCH_REQUIRES_OBJECT);
+          continue;
+        }
+        if (this.isLogicalOperator(key)) {
+          if (key === "$not") {
+            if (Array.isArray(value) || typeof value !== "object") {
+              isSupported = false;
+              messages.push(_a.ErrorMessages.NOT_REQUIRES_OBJECT);
+              continue;
+            }
+            if (this.isEmpty(value)) {
+              isSupported = false;
+              messages.push(_a.ErrorMessages.NOT_CANNOT_BE_EMPTY);
+              continue;
+            }
+            continue;
+          }
+          if (path && !this.isLogicalOperator(path.split(".").pop())) {
+            isSupported = false;
+            messages.push(_a.ErrorMessages.INVALID_LOGICAL_OPERATOR_LOCATION(key, newPath));
+            continue;
+          }
+          if (Array.isArray(value)) {
+            const hasDirectOperators = value.some((item) => typeof item === "object" && Object.keys(item).length === 1 && this.isFieldOperator(Object.keys(item)[0]));
+            if (hasDirectOperators) {
+              isSupported = false;
+              messages.push(_a.ErrorMessages.INVALID_LOGICAL_OPERATOR_CONTENT(newPath));
+              continue;
+            }
+          }
+        }
+      }
+      const nestedValidation = this.validateFilterSupport(value, newPath);
+      if (!nestedValidation.supported) {
+        isSupported = false;
+        messages.push(...nestedValidation.messages);
+      }
+    }
+    return {
+      supported: isSupported,
+      messages
+    };
+  }
+}, __name(_a, "BaseFilterTranslator"), __publicField(_a, "BASIC_OPERATORS", [
+  "$eq",
+  "$ne"
+]), __publicField(_a, "NUMERIC_OPERATORS", [
+  "$gt",
+  "$gte",
+  "$lt",
+  "$lte"
+]), __publicField(_a, "ARRAY_OPERATORS", [
+  "$in",
+  "$nin",
+  "$all",
+  "$elemMatch"
+]), __publicField(_a, "LOGICAL_OPERATORS", [
+  "$and",
+  "$or",
+  "$not",
+  "$nor"
+]), __publicField(_a, "ELEMENT_OPERATORS", [
+  "$exists"
+]), __publicField(_a, "REGEX_OPERATORS", [
+  "$regex",
+  "$options"
+]), __publicField(_a, "DEFAULT_OPERATORS", {
+  logical: _a.LOGICAL_OPERATORS,
+  basic: _a.BASIC_OPERATORS,
+  numeric: _a.NUMERIC_OPERATORS,
+  array: _a.ARRAY_OPERATORS,
+  element: _a.ELEMENT_OPERATORS,
+  regex: _a.REGEX_OPERATORS
+}), __publicField(_a, "ErrorMessages", {
+  UNSUPPORTED_OPERATOR: /* @__PURE__ */ __name((op) => `Unsupported operator: ${op}`, "UNSUPPORTED_OPERATOR"),
+  INVALID_LOGICAL_OPERATOR_LOCATION: /* @__PURE__ */ __name((op, path) => `Logical operator ${op} cannot be used at field level: ${path}`, "INVALID_LOGICAL_OPERATOR_LOCATION"),
+  NOT_REQUIRES_OBJECT: `$not operator requires an object`,
+  NOT_CANNOT_BE_EMPTY: `$not operator cannot be empty`,
+  INVALID_LOGICAL_OPERATOR_CONTENT: /* @__PURE__ */ __name((path) => `Logical operators must contain field conditions, not direct operators: ${path}`, "INVALID_LOGICAL_OPERATOR_CONTENT"),
+  INVALID_TOP_LEVEL_OPERATOR: /* @__PURE__ */ __name((op) => `Invalid top-level operator: ${op}`, "INVALID_TOP_LEVEL_OPERATOR"),
+  ELEM_MATCH_REQUIRES_OBJECT: `$elemMatch requires an object with conditions`
+}), _a);
+
+export { BaseFilterTranslator };