@mastra/core 0.1.27-alpha.32 → 0.1.27-alpha.35

package/dist/action/index.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export interface IExecutionContext<TPayload, TContext> {
+    context: TPayload & {
+        machineContext?: TContext;
+    };
+    runId?: string;
+}
+export interface IAction<TId extends string, TSchemaIn extends z.ZodSchema, TSchemaOut extends z.ZodSchema, TContext extends IExecutionContext<z.infer<TSchemaIn>, any>> {
+    id: TId;
+    description?: string;
+    inputSchema?: TSchemaIn;
+    outputSchema?: TSchemaOut;
+    payload?: Partial<z.infer<TSchemaIn>>;
+    execute: (context: TContext) => Promise<z.infer<TSchemaOut>>;
+    [key: string]: any;
+}

package/dist/agent/index.d.ts

@@ -1,43 +1,31 @@
 import { CoreAssistantMessage, CoreMessage, CoreToolMessage, CoreUserMessage, UserContent } from 'ai';
 import { ZodSchema } from 'zod';
-import { Integration } from '../integration';
+import { MastraBase } from '../base';
 import { LLM } from '../llm';
 import { GenerateReturn, ModelConfig, StructuredOutput } from '../llm/types';
-import { Logger } from '../logger';
 import { MastraMemory } from '../memory';
 import { Run } from '../run/types';
-import { Telemetry } from '../telemetry';
-import { AllTools, CoreTool, ToolApi } from '../tools/types';
-export declare class Agent<TTools, TIntegrations extends Integration[] | undefined = undefined, TKeys extends keyof AllTools<TTools, TIntegrations> = keyof AllTools<TTools, TIntegrations>> {
+import { CoreTool, ToolAction } from '../tools/types';
+import { ToolsetsInput } from './types';
+export declare class Agent<TTools extends Record<string, ToolAction<any, any, any, any>> = Record<string, ToolAction<any, any, any, any>>> extends MastraBase {
     #private;
     name: string;
     private memory?;
-    readonly llm: LLM<TTools, TIntegrations, TKeys>;
+    readonly llm: LLM;
     readonly instructions: string;
     readonly model: ModelConfig;
-    readonly enabledTools: Partial<Record<TKeys, boolean>>;
     constructor(config: {
         name: string;
         instructions: string;
         model: ModelConfig;
-        enabledTools?: Partial<Record<TKeys, boolean>>;
+        tools?: TTools;
     });
     /**
      * 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;
+    __setTools(tools: TTools): void;
     __setMemory(memory: MastraMemory): void;
-    /**
-     * Set the telemetry for the agent
-     * @param telemetry
-     */
-    __setTelemetry(telemetry: Telemetry): void;
     generateTitleFromUserMessage({ message }: {
         message: CoreUserMessage;
     }): Promise<any>;
@@ -58,12 +46,11 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         threadId: string;
     }): Promise<void>;
     sanitizeResponseMessages(messages: Array<CoreToolMessage | CoreAssistantMessage>): Array<CoreToolMessage | CoreAssistantMessage>;
-    convertTools({ enabledTools, toolsets, threadId, runId, }: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
-        enabledTools?: Partial<Record<TKeys, boolean>>;
+    convertTools({ toolsets, threadId, runId, }: {
+        toolsets?: ToolsetsInput;
         threadId?: string;
         runId?: string;
-    }): Record<TKeys, CoreTool>;
+    }): Record<string, CoreTool>;
     preExecute({ resourceid, runId, threadId, messages, }: {
         runId?: string;
         threadId?: string;
@@ -74,7 +61,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         threadIdToUse: string;
     }>;
     __primitive({ messages, context, threadId, resourceid, runId, toolsets, }: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
+        toolsets?: ToolsetsInput;
         resourceid?: string;
         threadId?: string;
         context?: CoreMessage[];
@@ -83,7 +70,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
     }): {
         before: () => Promise<{
             messageObjects: CoreMessage[];
-            convertedTools: Record<TKeys, CoreTool> | undefined;
+            convertedTools: Record<string, CoreTool> | undefined;
             threadId: string;
         }>;
         after: ({ result, threadId }: {
@@ -92,7 +79,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         }) => Promise<void>;
     };
     generate<S extends boolean = false, Z extends ZodSchema | undefined = undefined>(messages: string | string[] | CoreMessage[], { schema, stream, context, threadId: threadIdInFn, resourceid, maxSteps, onFinish, onStepFinish, runId, toolsets, }?: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
+        toolsets?: ToolsetsInput;
         resourceid?: string;
         context?: CoreMessage[];
         threadId?: string;
@@ -104,7 +91,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         maxSteps?: number;
     }): Promise<GenerateReturn<S, Z>>;
     text({ messages, context, onStepFinish, maxSteps, threadId: threadIdInFn, resourceid, runId, toolsets, }: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
+        toolsets?: ToolsetsInput;
         resourceid?: string;
         threadId?: string;
         context?: CoreMessage[];
@@ -113,7 +100,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         maxSteps?: number;
     } & Run): Promise<import("ai").GenerateTextResult<{}, never>>;
     textObject({ messages, context, structuredOutput, onStepFinish, maxSteps, threadId: threadIdInFn, resourceid, runId, toolsets, }: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
+        toolsets?: ToolsetsInput;
         context?: CoreMessage[];
         resourceid?: string;
         threadId?: string;
@@ -123,7 +110,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         maxSteps?: number;
     } & Run): Promise<import("ai").GenerateObjectResult<any>>;
     stream({ messages, context, onStepFinish, onFinish, maxSteps, threadId: threadIdInFn, resourceid, runId, toolsets, }: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
+        toolsets?: ToolsetsInput;
         resourceid?: string;
         threadId?: string;
         messages: UserContent[];
@@ -133,7 +120,7 @@ export declare class Agent<TTools, TIntegrations extends Integration[] | undefin
         maxSteps?: number;
     } & Run): Promise<import("ai").StreamTextResult<{}>>;
     streamObject({ messages, context, structuredOutput, onStepFinish, onFinish, maxSteps, threadId: threadIdInFn, resourceid, runId, toolsets, }: {
-        toolsets?: Record<string, Record<TKeys, ToolApi>>;
+        toolsets?: ToolsetsInput;
         resourceid?: string;
         threadId?: string;
         messages: UserContent[];

package/dist/agent/types.d.ts

@@ -0,0 +1,3 @@
+import { ToolAction } from '../tools';
+export type ToolsetsInput = Record<string, Record<string, ToolAction<any, any, any, any>>>;
+export type ToolsInput = Record<string, ToolAction<any, any, any, any>>;

package/dist/base.d.ts

@@ -0,0 +1,31 @@
+import { Logger, LogLevel, RegisteredLogger } from './logger';
+import { Telemetry } from './telemetry';
+export declare class MastraBase {
+    component: RegisteredLogger;
+    logger: Logger;
+    telemetry?: Telemetry;
+    constructor({ component }: {
+        component: RegisteredLogger;
+    });
+    /**
+     * 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 runId - Optional runId for the log
+     */
+    log(level: LogLevel, message: string, runId?: string): void;
+    /**
+     * Set the telemetry for the agent
+     * @param telemetry
+     */
+    __setTelemetry(telemetry: Telemetry): void;
+    get experimental_telemetry(): {
+        tracer: import("@opentelemetry/api").Tracer;
+        isEnabled: boolean;
+    } | undefined;
+}