@mastra/core 0.2.0-alpha.93 → 0.2.0-alpha.95

package/README.md

@@ -29,15 +29,13 @@ For comprehensive documentation, visit our [official documentation](https://mast
 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: {
-    provider: 'openai',
-    model: 'gpt-4',
-  },
+  model: openai('gpt-4o-mini'),
   tools: {}, // Optional tools
 });
 ```
@@ -49,10 +47,12 @@ const agent = new Agent({
 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 { embed } from '@mastra/core/embeddings/openai';
+import { openai } from '@ai-sdk/openai';
+import { embed } from 'ai';
 
-const embeddings = await embed('text to embed', {
-  model: 'text-embedding-3-small',
+const embeddings = await embed({
+  model: openai.embedding('text-embedding-3-small'),
+  value: 'text to embed',
 });
 ```
 
@@ -89,7 +89,10 @@ const memory = new MastraMemory({
 });
 ```
 
-[More memory documentation →](https://mastra.ai/docs/reference/memory/overview)
+**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`)
 

package/dist/action/index.d.ts

@@ -1,5 +1,5 @@
 import 'zod';
-export { I as IAction, aT as IExecutionContext, d as MastraPrimitives } from '../index-B48181D5.js';
+export { I as IAction, ah as IExecutionContext, c as MastraPrimitives } from '../index-CBxGSZZE.js';
 import '../index-CBZ2mk2H.js';
 import '../telemetry-oCUM52DG.js';
 import '../vector/index.js';
@@ -14,5 +14,3 @@ import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';
 import '../metric-D2V4CR8D.js';
 import 'sift';
-import '../embeddings/model/providers/embedder.js';
-import '../types-M16hSruO.js';

package/dist/agent/index.d.ts

@@ -1,17 +1,15 @@
 import 'ai';
 import 'json-schema';
 import 'zod';
-export { A as Agent } from '../index-B48181D5.js';
+export { A as Agent } from '../index-CBxGSZZE.js';
 import '../base.js';
 import '../metric-D2V4CR8D.js';
 import '../telemetry-oCUM52DG.js';
+import 'sift';
 import '../index-CBZ2mk2H.js';
 import 'pino';
 import 'stream';
-import 'sift';
-import '../embeddings/model/providers/embedder.js';
 import '../vector/index.js';
-import '../types-M16hSruO.js';
 import '@opentelemetry/api';
 import '@opentelemetry/sdk-node';
 import '@opentelemetry/sdk-trace-base';

package/dist/agent/index.js

@@ -1,9 +1,7 @@
-export { Agent } from '../chunk-JWVCENG2.js';
-import '../chunk-SDKEPBBH.js';
-import '../chunk-RI3ECMVF.js';
-import '../chunk-6ZVFVYLE.js';
+export { Agent } from '../chunk-JY322VLW.js';
+import '../chunk-4ZUSEHLH.js';
 import '../chunk-KNPBNSJ7.js';
+import '../chunk-HBTQNIAX.js';
 import '../chunk-G4MCO7XF.js';
 import '../chunk-ICMEXHKD.js';
-import '../chunk-HBTQNIAX.js';
 import '../chunk-AJJZUHB4.js';

package/dist/{chunk-SDKEPBBH.js → chunk-4ZUSEHLH.js}

@@ -1,6 +1,5 @@
-import { hasActiveTelemetry } from './chunk-6ZVFVYLE.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
-import { trace, SpanStatusCode } from '@opentelemetry/api';
+import { trace, context, SpanStatusCode, SpanKind } from '@opentelemetry/api';
 import { getNodeAutoInstrumentations } from '@opentelemetry/auto-instrumentations-node';
 import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
 import { Resource } from '@opentelemetry/resources';
@@ -8,6 +7,104 @@ import { NodeSDK } from '@opentelemetry/sdk-node';
 import { ConsoleSpanExporter, AlwaysOnSampler, AlwaysOffSampler, TraceIdRatioBasedSampler, ParentBasedSampler } from '@opentelemetry/sdk-trace-base';
 import { ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
 
+function hasActiveTelemetry() {
+  try {
+    return !!trace.getTracer("default-tracer");
+  } catch {
+    return false;
+  }
+}
+__name(hasActiveTelemetry, "hasActiveTelemetry");
+
+// src/telemetry/telemetry.decorators.ts
+function withSpan(options) {
+  return function(_target, propertyKey, descriptor) {
+    if (!descriptor || typeof descriptor === "number") return;
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
+    descriptor.value = function(...args) {
+      if (options?.skipIfNoTelemetry && !hasActiveTelemetry()) {
+        return originalMethod.apply(this, args);
+      }
+      const tracer = trace.getTracer("default-tracer");
+      let spanName;
+      let spanKind;
+      if (typeof options === "string") {
+        spanName = options;
+      } else if (options) {
+        spanName = options.spanName || methodName;
+        spanKind = options.spanKind;
+      } else {
+        spanName = methodName;
+      }
+      const span = tracer.startSpan(spanName, {
+        kind: spanKind
+      });
+      const ctx = trace.setSpan(context.active(), span);
+      args.forEach((arg, index) => {
+        try {
+          span.setAttribute(`${spanName}.argument.${index}`, JSON.stringify(arg));
+        } catch (e) {
+          span.setAttribute(`${spanName}.argument.${index}`, "[Not Serializable]");
+        }
+      });
+      let result;
+      try {
+        result = context.with(ctx, () => originalMethod.apply(this, args));
+        if (result instanceof Promise) {
+          return result.then((resolvedValue) => {
+            try {
+              span.setAttribute(`${spanName}.result`, JSON.stringify(resolvedValue));
+            } catch (e) {
+              span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+            }
+            return resolvedValue;
+          }).finally(() => span.end());
+        }
+        try {
+          span.setAttribute(`${spanName}.result`, JSON.stringify(result));
+        } catch (e) {
+          span.setAttribute(`${spanName}.result`, "[Not Serializable]");
+        }
+        return result;
+      } catch (error) {
+        span.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+        if (error instanceof Error) {
+          span.recordException(error);
+        }
+        throw error;
+      } finally {
+        if (!(result instanceof Promise)) {
+          span.end();
+        }
+      }
+    };
+    return descriptor;
+  };
+}
+__name(withSpan, "withSpan");
+function InstrumentClass(options) {
+  return function(target) {
+    const methods = Object.getOwnPropertyNames(target.prototype);
+    methods.forEach((method) => {
+      if (options?.excludeMethods?.includes(method) || method === "constructor") return;
+      if (options?.methodFilter && !options.methodFilter(method)) return;
+      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, method);
+      if (descriptor && typeof descriptor.value === "function") {
+        Object.defineProperty(target.prototype, method, withSpan({
+          spanName: options?.prefix ? `${options.prefix}.${method}` : method,
+          skipIfNoTelemetry: true,
+          spanKind: options?.spanKind || SpanKind.INTERNAL
+        })(target, method, descriptor));
+      }
+    });
+    return target;
+  };
+}
+__name(InstrumentClass, "InstrumentClass");
 var sdkInstance = null;
 var _Telemetry = class _Telemetry {
   constructor(config) {
@@ -143,29 +240,29 @@ var _Telemetry = class _Telemetry {
   * @param context Additional context for the trace
   * @returns Wrapped method with tracing
   */
-  traceMethod(method, context) {
-    const { skipIfNoTelemetry = true } = context;
+  traceMethod(method, context2) {
+    const { skipIfNoTelemetry = true } = context2;
     if (skipIfNoTelemetry && !hasActiveTelemetry()) {
       return method;
     }
     return async (...args) => {
-      const span = this.tracer.startSpan(context.spanName);
+      const span = this.tracer.startSpan(context2.spanName);
       try {
-        if (context.attributes) {
-          span.setAttributes(context.attributes);
+        if (context2.attributes) {
+          span.setAttributes(context2.attributes);
         }
         args.forEach((arg, index) => {
           try {
-            span.setAttribute(`${context.spanName}.argument.${index}`, JSON.stringify(arg));
+            span.setAttribute(`${context2.spanName}.argument.${index}`, JSON.stringify(arg));
           } catch (e) {
-            span.setAttribute(`${context.spanName}.argument.${index}`, "[Not Serializable]");
+            span.setAttribute(`${context2.spanName}.argument.${index}`, "[Not Serializable]");
           }
         });
         const result = await method(...args);
         try {
-          span.setAttribute(`${context.spanName}.result`, JSON.stringify(result));
+          span.setAttribute(`${context2.spanName}.result`, JSON.stringify(result));
         } catch (e) {
-          span.setAttribute(`${context.spanName}.result`, "[Not Serializable]");
+          span.setAttribute(`${context2.spanName}.result`, "[Not Serializable]");
         }
         span.end();
         return result;
@@ -185,4 +282,4 @@ __name(_Telemetry, "Telemetry");
 __publicField(_Telemetry, "isInitialized", false);
 var Telemetry = _Telemetry;
 
-export { Telemetry };
+export { InstrumentClass, Telemetry, hasActiveTelemetry, withSpan };

package/dist/{chunk-F7ILHRX5.js → chunk-5DZIXJRV.js}

@@ -1,4 +1,4 @@
-import { MastraVector } from './chunk-HH5JIATB.js';
+import { MastraVector } from './chunk-MBOUQZQT.js';
 import { BaseFilterTranslator } from './chunk-4LJFWC2Q.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
 import { createClient } from '@libsql/client';

package/dist/chunk-AE3H2QEY.js

@@ -0,0 +1 @@
+

package/dist/{chunk-IE37CBXB.js → chunk-G4LP2IJU.js}

@@ -46,9 +46,7 @@ For example:
 new Memory({
   storage,
   vector,
-  embedder: new OpenAIEmbedder({ // <- this is required
-    model: "text-embedding-3-small",
-  })
+  embedder: openai("text-embedding-3-small") // example
 });
 `);
     }