@mastra/core 0.2.0 → 0.2.1

package/dist/{chunk-K4DFI76V.js → chunk-CUIUUULJ.js}

@@ -1,19 +1,22 @@
-import { InstrumentClass } from './chunk-FGZVE4CM.js';
+import { InstrumentClass } from './chunk-4ZRHVG25.js';
 import { delay } from './chunk-55GTEVHJ.js';
 import { MastraBase } from './chunk-AWEACB2T.js';
 import { RegisteredLogger, LogLevel } from './chunk-O2VP5JBC.js';
-import { executeHook } from './chunk-MLWGYRJR.js';
+import { executeHook } from './chunk-BB4KXGBU.js';
 import { __decoratorStart, __decorateElement, __runInitializers } from './chunk-C6A6W6XS.js';
-import { generateText, jsonSchema, generateObject, streamText, streamObject } from 'ai';
 import { randomUUID } from 'crypto';
-import 'json-schema';
 import { z } from 'zod';
+import { generateText, jsonSchema, generateObject, streamText, streamObject } from 'ai';
 
+// src/llm/model/base.ts
 var MastraLLMBase = class extends MastraBase {
   // @ts-ignore
   #mastra;
   #model;
-  constructor({ name, model }) {
+  constructor({
+    name,
+    model
+  }) {
     super({
       component: RegisteredLogger.LLM,
       name
@@ -31,7 +34,7 @@ var MastraLLMBase = class extends MastraBase {
   }
   convertToMessages(messages) {
     if (Array.isArray(messages)) {
-      return messages.map((m) => {
+      return messages.map(m => {
         if (typeof m === "string") {
           return {
             role: "user",
@@ -41,12 +44,10 @@ var MastraLLMBase = class extends MastraBase {
         return m;
       });
     }
-    return [
-      {
-        role: "user",
-        content: messages
-      }
-    ];
+    return [{
+      role: "user",
+      content: messages
+    }];
   }
   __registerPrimitives(p) {
     if (p.telemetry) {
@@ -58,35 +59,55 @@ var MastraLLMBase = class extends MastraBase {
     this.#mastra = p;
   }
   async __text(input) {
-    this.logger.debug(`[LLMs:${this.name}] Generating text.`, { input });
+    this.logger.debug(`[LLMs:${this.name}] Generating text.`, {
+      input
+    });
     throw new Error("Method not implemented.");
   }
   async __textObject(input) {
-    this.logger.debug(`[LLMs:${this.name}] Generating object.`, { input });
+    this.logger.debug(`[LLMs:${this.name}] Generating object.`, {
+      input
+    });
     throw new Error("Method not implemented.");
   }
   async generate(messages, options = {}) {
-    this.logger.debug(`[LLMs:${this.name}] Generating text.`, { messages, options });
+    this.logger.debug(`[LLMs:${this.name}] Generating text.`, {
+      messages,
+      options
+    });
     throw new Error("Method not implemented.");
   }
   async __stream(input) {
-    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, { input });
+    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, {
+      input
+    });
     throw new Error("Method not implemented.");
   }
   async __streamObject(input) {
-    this.logger.debug(`[LLMs:${this.name}] Streaming object.`, { input });
+    this.logger.debug(`[LLMs:${this.name}] Streaming object.`, {
+      input
+    });
     throw new Error("Method not implemented.");
   }
   async stream(messages, options = {}) {
-    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, { messages, options });
+    this.logger.debug(`[LLMs:${this.name}] Streaming text.`, {
+      messages,
+      options
+    });
     throw new Error("Method not implemented.");
   }
 };
 var MastraLLM = class extends MastraLLMBase {
   #model;
   #mastra;
-  constructor({ model, mastra }) {
-    super({ name: "aisdk", model });
+  constructor({
+    model,
+    mastra
+  }) {
+    super({
+      name: "aisdk",
+      model
+    });
     this.#model = model;
     if (mastra) {
       this.#mastra = mastra;
@@ -113,42 +134,42 @@ var MastraLLM = class extends MastraLLMBase {
   getModel() {
     return this.#model;
   }
-  convertTools({ tools, runId } = {}) {
+  convertTools({
+    tools,
+    runId
+  } = {}) {
     this.logger.debug("Starting tool conversion for LLM");
-    const converted = Object.entries(tools || {}).reduce(
-      (memo, value) => {
-        const k = value[0];
-        const tool = value[1];
-        if (tool) {
-          memo[k] = {
-            description: tool.description,
-            parameters: tool.inputSchema,
-            execute: async (props) => {
-              try {
-                this.logger.debug("Executing tool", {
-                  tool: k,
-                  props
-                });
-                return tool.execute({
-                  context: props,
-                  mastra: this.#mastra,
-                  runId
-                });
-              } catch (error) {
-                this.logger.error("Error executing tool", {
-                  tool: k,
-                  props,
-                  error
-                });
-                throw error;
-              }
+    const converted = Object.entries(tools || {}).reduce((memo, value) => {
+      const k = value[0];
+      const tool = value[1];
+      if (tool) {
+        memo[k] = {
+          description: tool.description,
+          parameters: tool.inputSchema,
+          execute: async props => {
+            try {
+              this.logger.debug("Executing tool", {
+                tool: k,
+                props
+              });
+              return tool.execute({
+                context: props,
+                mastra: this.#mastra,
+                runId
+              });
+            } catch (error) {
+              this.logger.error("Error executing tool", {
+                tool: k,
+                props,
+                error
+              });
+              throw error;
             }
-          };
-        }
-        return memo;
-      },
-      {}
-    );
+          }
+        };
+      }
+      return memo;
+    }, {});
     this.logger.debug(`Converted tools for LLM`);
     return converted;
   }
@@ -169,7 +190,10 @@ var MastraLLM = class extends MastraLLMBase {
       maxSteps,
       tools: Object.keys(tools || convertedTools || {})
     });
-    const finalTools = convertedTools || this.convertTools({ tools, runId });
+    const finalTools = convertedTools || this.convertTools({
+      tools,
+      runId
+    });
     const argsForExecute = {
       model,
       temperature,
@@ -178,7 +202,7 @@ var MastraLLM = class extends MastraLLMBase {
       },
       toolChoice,
       maxSteps,
-      onStepFinish: async (props) => {
+      onStepFinish: async props => {
         onStepFinish?.(JSON.stringify(props, null, 2));
         this.logger.debug("[LLM] - Step Change:", {
           text: props?.text,
@@ -212,8 +236,13 @@ var MastraLLM = class extends MastraLLMBase {
     toolChoice = "auto"
   }) {
     const model = this.#model;
-    this.logger.debug(`[LLM] - Generating a text object`, { runId });
-    const finalTools = convertedTools || this.convertTools({ tools, runId });
+    this.logger.debug(`[LLM] - Generating a text object`, {
+      runId
+    });
+    const finalTools = convertedTools || this.convertTools({
+      tools,
+      runId
+    });
     const argsForExecute = {
       model,
       temperature,
@@ -222,7 +251,7 @@ var MastraLLM = class extends MastraLLMBase {
       },
       maxSteps,
       toolChoice,
-      onStepFinish: async (props) => {
+      onStepFinish: async props => {
         onStepFinish?.(JSON.stringify(props, null, 2));
         this.logger.debug("[LLM] - Step Change:", {
           text: props?.text,
@@ -233,7 +262,9 @@ var MastraLLM = class extends MastraLLMBase {
           runId
         });
         if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", { runId });
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
           await delay(10 * 1e3);
         }
       }
@@ -275,7 +306,10 @@ var MastraLLM = class extends MastraLLMBase {
       maxSteps,
       tools: Object.keys(tools || convertedTools || {})
     });
-    const finalTools = convertedTools || this.convertTools({ tools, runId });
+    const finalTools = convertedTools || this.convertTools({
+      tools,
+      runId
+    });
     const argsForExecute = {
       model,
       temperature,
@@ -284,7 +318,7 @@ var MastraLLM = class extends MastraLLMBase {
       },
       maxSteps,
       toolChoice,
-      onStepFinish: async (props) => {
+      onStepFinish: async props => {
         onStepFinish?.(JSON.stringify(props, null, 2));
         this.logger.debug("[LLM] - Stream Step Change:", {
           text: props?.text,
@@ -295,11 +329,13 @@ var MastraLLM = class extends MastraLLMBase {
           runId
         });
         if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", { runId });
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
           await delay(10 * 1e3);
         }
       },
-      onFinish: async (props) => {
+      onFinish: async props => {
         onFinish?.(JSON.stringify(props, null, 2));
         this.logger.debug("[LLM] - Stream Finished:", {
           text: props?.text,
@@ -336,7 +372,10 @@ var MastraLLM = class extends MastraLLMBase {
       maxSteps,
       tools: Object.keys(tools || convertedTools || {})
     });
-    const finalTools = convertedTools || this.convertTools({ tools, runId });
+    const finalTools = convertedTools || this.convertTools({
+      tools,
+      runId
+    });
     const argsForExecute = {
       model,
       temperature,
@@ -345,7 +384,7 @@ var MastraLLM = class extends MastraLLMBase {
       },
       maxSteps,
       toolChoice,
-      onStepFinish: async (props) => {
+      onStepFinish: async props => {
         onStepFinish?.(JSON.stringify(props, null, 2));
         this.logger.debug("[LLM] - Stream Step Change:", {
           text: props?.text,
@@ -356,11 +395,13 @@ var MastraLLM = class extends MastraLLMBase {
           runId
         });
         if (props?.response?.headers?.["x-ratelimit-remaining-tokens"] && parseInt(props?.response?.headers?.["x-ratelimit-remaining-tokens"], 10) < 2e3) {
-          this.logger.warn("Rate limit approaching, waiting 10 seconds", { runId });
+          this.logger.warn("Rate limit approaching, waiting 10 seconds", {
+            runId
+          });
           await delay(10 * 1e3);
         }
       },
-      onFinish: async (props) => {
+      onFinish: async props => {
         onFinish?.(JSON.stringify(props, null, 2));
         this.logger.debug("[LLM] - Stream Finished:", {
           text: props?.text,
@@ -477,13 +518,17 @@ var Agent = class extends (_a = MastraBase) {
   metrics;
   evals;
   constructor(config) {
-    super({ component: RegisteredLogger.AGENT });
+    super({
+      component: RegisteredLogger.AGENT
+    });
     this.name = config.name;
     this.instructions = config.instructions;
     if (!config.model) {
       throw new Error(`LanugageModel is required to create an Agent. Please provider the 'model'.`);
     }
-    this.llm = new MastraLLM({ model: config.model });
+    this.llm = new MastraLLM({
+      model: config.model
+    });
     this.tools = {};
     this.metrics = {};
     this.evals = {};
@@ -513,7 +558,10 @@ var Agent = class extends (_a = MastraBase) {
   }
   __updateInstructions(newInstructions) {
     this.instructions = newInstructions;
-    this.logger.debug(`[Agents:${this.name}] Instructions updated.`, { model: this.model, name: this.name });
+    this.logger.debug(`[Agents:${this.name}] Instructions updated.`, {
+      model: this.model,
+      name: this.name
+    });
   }
   __registerPrimitives(p) {
     if (p.telemetry) {
@@ -524,7 +572,10 @@ var Agent = class extends (_a = MastraBase) {
     }
     this.llm.__registerPrimitives(p);
     this.#mastra = p;
-    this.logger.debug(`[Agents:${this.name}] initialized.`, { model: this.model, name: this.name });
+    this.logger.debug(`[Agents:${this.name}] initialized.`, {
+      model: this.model,
+      name: this.name
+    });
   }
   /**
    * Set the concrete tools for the agent
@@ -532,25 +583,29 @@ var Agent = class extends (_a = MastraBase) {
    */
   __setTools(tools) {
     this.tools = tools;
-    this.logger.debug(`[Agents:${this.name}] Tools set for agent ${this.name}`, { model: this.model, name: this.name });
+    this.logger.debug(`[Agents:${this.name}] Tools set for agent ${this.name}`, {
+      model: this.model,
+      name: this.name
+    });
   }
-  async generateTitleFromUserMessage({ message }) {
-    const { object } = await this.llm.__textObject({
-      messages: [
-        {
-          role: "system",
-          content: `
+  async generateTitleFromUserMessage({
+    message
+  }) {
+    const {
+      object
+    } = await this.llm.__textObject({
+      messages: [{
+        role: "system",
+        content: `
 
       - you will generate a short title based on the first message a user begins a conversation with
       - ensure it is not more than 80 characters long
       - the title should be a summary of the user's message
       - do not use quotes or colons`
-        },
-        {
-          role: "user",
-          content: JSON.stringify(message)
-        }
-      ],
+      }, {
+        role: "user",
+        content: JSON.stringify(message)
+      }],
       structuredOutput: z.object({
         title: z.string()
       })
@@ -558,7 +613,7 @@ var Agent = class extends (_a = MastraBase) {
     return object.title;
   }
   getMostRecentUserMessage(messages) {
-    const userMessages = messages.filter((message) => message.role === "user");
+    const userMessages = messages.filter(message => message.role === "user");
     return userMessages.at(-1);
   }
   async genTitle(userMessage) {
@@ -597,7 +652,9 @@ var Agent = class extends (_a = MastraBase) {
           memoryConfig
         });
       } else {
-        thread = await memory.getThreadById({ threadId });
+        thread = await memory.getThreadById({
+          threadId
+        });
         if (!thread) {
           this.logger.debug(`Thread with id ${threadId} not found, creating new thread for agent ${this.name}`, {
             runId: runId || this.name
@@ -613,10 +670,10 @@ var Agent = class extends (_a = MastraBase) {
       }
       const newMessages = userMessage ? [userMessage] : userMessages;
       if (thread) {
-        const messages = newMessages.map((u) => {
+        const messages = newMessages.map(u => {
           return {
             id: this.getMemory()?.generateId(),
-            createdAt: /* @__PURE__ */ new Date(),
+            createdAt: /* @__PURE__ */new Date(),
             threadId: thread.id,
             ...u,
             content: u.content,
@@ -627,7 +684,7 @@ var Agent = class extends (_a = MastraBase) {
         const memoryMessages = threadId && memory ? (await memory.rememberMessages({
           threadId,
           config: memoryConfig,
-          vectorMessageSearch: messages.slice(-1).map((m) => {
+          vectorMessageSearch: messages.slice(-1).map(m => {
             if (typeof m === `string`) {
               return m;
             }
@@ -636,19 +693,24 @@ var Agent = class extends (_a = MastraBase) {
 `)
         })).messages : [];
         if (memory) {
-          await memory.saveMessages({ messages, memoryConfig });
+          await memory.saveMessages({
+            messages,
+            memoryConfig
+          });
         }
         this.log(LogLevel.DEBUG, "Saved messages to memory", {
           threadId: thread.id,
           runId
         });
-        const memorySystemMessage = memory && threadId ? await memory.getSystemMessage({ threadId, memoryConfig }) : null;
+        const memorySystemMessage = memory && threadId ? await memory.getSystemMessage({
+          threadId,
+          memoryConfig
+        }) : null;
         return {
           threadId: thread.id,
-          messages: [
-            {
-              role: "system",
-              content: `
+          messages: [{
+            role: "system",
+            content: `
 
              Analyze this message to determine if the user is referring to a previous conversation with the LLM.
              Specifically, identify if the user wants to reference specific information from that chat or if they want the LLM to use the previous chat messages as context for the current conversation.
@@ -656,13 +718,14 @@ var Agent = class extends (_a = MastraBase) {
              Return dates in ISO format.
              If no specific dates are mentioned but time periods are (like "last week" or "past month"), calculate the appropriate date range.
              For the end date, return the date 1 day after the end of the time period.
-             Today's date is ${(/* @__PURE__ */ new Date()).toISOString()} and the time is ${(/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour: "numeric", minute: "numeric", hour12: true })} ${memorySystemMessage ? `
+             Today's date is ${(/* @__PURE__ */new Date()).toISOString()} and the time is ${(/* @__PURE__ */new Date()).toLocaleTimeString("en-US", {
+              hour: "numeric",
+              minute: "numeric",
+              hour12: true
+            })} ${memorySystemMessage ? `
 
 ${memorySystemMessage}` : ""}`
-            },
-            ...this.sanitizeResponseMessages(memoryMessages),
-            ...newMessages
-          ]
+          }, ...this.sanitizeResponseMessages(memoryMessages), ...newMessages]
         };
       }
       return {
@@ -670,7 +733,10 @@ ${memorySystemMessage}` : ""}`
         messages: userMessages
       };
     }
-    return { threadId: threadId || "", messages: userMessages };
+    return {
+      threadId: threadId || "",
+      messages: userMessages
+    };
   }
   async saveResponse({
     result,
@@ -679,37 +745,36 @@ ${memorySystemMessage}` : ""}`
     runId,
     memoryConfig
   }) {
-    const { response } = result;
+    const {
+      response
+    } = result;
     try {
       if (response.messages) {
         const ms = Array.isArray(response.messages) ? response.messages : [response.messages];
         const responseMessagesWithoutIncompleteToolCalls = this.sanitizeResponseMessages(ms);
         const memory = this.getMemory();
         if (memory) {
-          this.logger.debug(
-            `[Agent:${this.name}] - Memory persistence: store=${this.getMemory()?.constructor.name} threadId=${threadId}`,
-            {
-              runId,
-              resourceId,
-              threadId,
-              memoryStore: this.getMemory()?.constructor.name
-            }
-          );
+          this.logger.debug(`[Agent:${this.name}] - Memory persistence: store=${this.getMemory()?.constructor.name} threadId=${threadId}`, {
+            runId,
+            resourceId,
+            threadId,
+            memoryStore: this.getMemory()?.constructor.name
+          });
           await memory.saveMessages({
             memoryConfig,
-            messages: responseMessagesWithoutIncompleteToolCalls.map((message) => {
+            messages: responseMessagesWithoutIncompleteToolCalls.map(message => {
               const messageId = randomUUID();
               let toolCallIds;
               let toolCallArgs;
               let toolNames;
               let type = "text";
               if (message.role === "tool") {
-                toolCallIds = message.content.map((content) => content.toolCallId);
+                toolCallIds = message.content.map(content => content.toolCallId);
                 type = "tool-result";
               }
               if (message.role === "assistant") {
                 const assistantContent = message.content;
-                const assistantToolCalls = assistantContent.map((content) => {
+                const assistantToolCalls = assistantContent.map(content => {
                   if (content.type === "tool-call") {
                     return {
                       toolCallId: content.toolCallId,
@@ -719,9 +784,9 @@ ${memorySystemMessage}` : ""}`
                   }
                   return void 0;
                 })?.filter(Boolean);
-                toolCallIds = assistantToolCalls?.map((toolCall) => toolCall.toolCallId);
-                toolCallArgs = assistantToolCalls?.map((toolCall) => toolCall.toolArgs);
-                toolNames = assistantToolCalls?.map((toolCall) => toolCall.toolName);
+                toolCallIds = assistantToolCalls?.map(toolCall => toolCall.toolCallId);
+                toolCallArgs = assistantToolCalls?.map(toolCall => toolCall.toolArgs);
+                toolNames = assistantToolCalls?.map(toolCall => toolCall.toolName);
                 type = assistantContent?.[0]?.type;
               }
               return {
@@ -729,7 +794,7 @@ ${memorySystemMessage}` : ""}`
                 threadId,
                 role: message.role,
                 content: message.content,
-                createdAt: /* @__PURE__ */ new Date(),
+                createdAt: /* @__PURE__ */new Date(),
                 toolCallIds: toolCallIds?.length ? toolCallIds : void 0,
                 toolCallArgs: toolCallArgs?.length ? toolCallArgs : void 0,
                 toolNames: toolNames?.length ? toolNames : void 0,
@@ -767,10 +832,10 @@ ${memorySystemMessage}` : ""}`
         }
       }
     }
-    const messagesBySanitizedContent = messages.map((message) => {
+    const messagesBySanitizedContent = messages.map(message => {
       if (message.role !== "assistant" && message.role !== `tool` && message.role !== `user`) return message;
       if (typeof message.content === "string") return message;
-      const sanitizedContent = message.content.filter((content) => {
+      const sanitizedContent = message.content.filter(content => {
         if (content.type === `tool-call`) {
           return toolResultIds.includes(content.toolCallId);
         }
@@ -787,12 +852,12 @@ ${memorySystemMessage}` : ""}`
         content: sanitizedContent
       };
     });
-    return messagesBySanitizedContent.filter((message) => {
+    return messagesBySanitizedContent.filter(message => {
       if (typeof message.content === `string`) {
         return message.content !== "";
       }
       if (Array.isArray(message.content)) {
-        return message.content.length && message.content.every((c) => {
+        return message.content.length && message.content.every(c => {
           if (c.type === `text`) {
             return c.text && c.text !== "";
           }
@@ -807,41 +872,40 @@ ${memorySystemMessage}` : ""}`
     // threadId,
     runId
   }) {
-    this.logger.debug(`[Agents:${this.name}] - Assigning tools`, { runId });
-    const converted = Object.entries(this.tools || {}).reduce(
-      (memo, value) => {
-        const k = value[0];
-        const tool = this.tools[k];
-        if (tool) {
-          memo[k] = {
-            description: tool.description,
-            parameters: tool.inputSchema,
-            execute: async (args) => {
-              try {
-                this.logger.debug(`[Agent:${this.name}] - Executing tool ${k}`, {
-                  name: k,
-                  description: tool.description,
-                  args
-                });
-                return tool.execute({
-                  context: args,
-                  mastra: this.#mastra,
-                  runId
-                });
-              } catch (err) {
-                this.logger.error(`[Agent:${this.name}] - Failed execution`, {
-                  error: err,
-                  runId
-                });
-                throw err;
-              }
+    this.logger.debug(`[Agents:${this.name}] - Assigning tools`, {
+      runId
+    });
+    const converted = Object.entries(this.tools || {}).reduce((memo, value) => {
+      const k = value[0];
+      const tool = this.tools[k];
+      if (tool) {
+        memo[k] = {
+          description: tool.description,
+          parameters: tool.inputSchema,
+          execute: async args => {
+            try {
+              this.logger.debug(`[Agent:${this.name}] - Executing tool ${k}`, {
+                name: k,
+                description: tool.description,
+                args
+              });
+              return tool.execute({
+                context: args,
+                mastra: this.#mastra,
+                runId
+              });
+            } catch (err) {
+              this.logger.error(`[Agent:${this.name}] - Failed execution`, {
+                error: err,
+                runId
+              });
+              throw err;
             }
-          };
-        }
-        return memo;
-      },
-      {}
-    );
+          }
+        };
+      }
+      return memo;
+    }, {});
     const toolsFromToolsetsConverted = {
       ...converted
     };
@@ -850,13 +914,13 @@ ${memorySystemMessage}` : ""}`
       this.logger.debug(`[Agent:${this.name}] - Adding tools from toolsets ${Object.keys(toolsets || {}).join(", ")}`, {
         runId
       });
-      toolsFromToolsets.forEach((toolset) => {
+      toolsFromToolsets.forEach(toolset => {
         Object.entries(toolset).forEach(([toolName, tool]) => {
           const toolObj = tool;
           toolsFromToolsetsConverted[toolName] = {
             description: toolObj.description || "",
             parameters: toolObj.inputSchema,
-            execute: async (args) => {
+            execute: async args => {
               try {
                 this.logger.debug(`[Agent:${this.name}] - Executing tool ${toolName}`, {
                   name: toolName,
@@ -890,7 +954,9 @@ ${memorySystemMessage}` : ""}`
   }) {
     let coreMessages = [];
     let threadIdToUse = threadId;
-    this.log(LogLevel.DEBUG, `Saving user messages in memory for agent ${this.name}`, { runId });
+    this.log(LogLevel.DEBUG, `Saving user messages in memory for agent ${this.name}`, {
+      runId
+    });
     const saveMessageResponse = await this.saveMemory({
       threadId,
       resourceId,
@@ -899,7 +965,10 @@ ${memorySystemMessage}` : ""}`
     });
     coreMessages = saveMessageResponse.messages;
     threadIdToUse = saveMessageResponse.threadId;
-    return { coreMessages, threadIdToUse };
+    return {
+      coreMessages,
+      threadIdToUse
+    };
   }
   __primitive({
     messages,
@@ -913,24 +982,23 @@ ${memorySystemMessage}` : ""}`
     return {
       before: async () => {
         if (process.env.NODE_ENV !== "test") {
-          this.logger.debug(`[Agents:${this.name}] - Starting generation`, { runId });
+          this.logger.debug(`[Agents:${this.name}] - Starting generation`, {
+            runId
+          });
         }
         const systemMessage = {
           role: "system",
-          content: `${this.instructions}. Today's date is ${(/* @__PURE__ */ new Date()).toISOString()}`
+          content: `${this.instructions}. Today's date is ${(/* @__PURE__ */new Date()).toISOString()}`
         };
         let coreMessages = messages;
         let threadIdToUse = threadId;
         if (this.getMemory() && resourceId) {
-          this.logger.debug(
-            `[Agent:${this.name}] - Memory persistence enabled: store=${this.getMemory()?.constructor.name}, resourceId=${resourceId}`,
-            {
-              runId,
-              resourceId,
-              threadId: threadIdToUse,
-              memoryStore: this.getMemory()?.constructor.name
-            }
-          );
+          this.logger.debug(`[Agent:${this.name}] - Memory persistence enabled: store=${this.getMemory()?.constructor.name}, resourceId=${resourceId}`, {
+            runId,
+            resourceId,
+            threadId: threadIdToUse,
+            memoryStore: this.getMemory()?.constructor.name
+          });
           const preExecuteResult = await this.preExecute({
             resourceId,
             runId,
@@ -952,7 +1020,7 @@ ${memorySystemMessage}` : ""}`
           }
           this.logger.debug(`[Agent:${this.name}] - Enhancing tools: ${reasons.join(", ")}`, {
             runId,
-            toolsets: toolsets ? Object.keys(toolsets) : undefined,
+            toolsets: toolsets ? Object.keys(toolsets) : void 0,
             hasMemory: !!this.getMemory(),
             hasResourceId: !!resourceId
           });
@@ -962,8 +1030,12 @@ ${memorySystemMessage}` : ""}`
             runId
           });
         }
-        const messageObjects = [systemMessage, ...context || [], ...coreMessages];
-        return { messageObjects, convertedTools, threadId: threadIdToUse };
+        const messageObjects = [systemMessage, ...(context || []), ...coreMessages];
+        return {
+          messageObjects,
+          convertedTools,
+          threadId: threadIdToUse
+        };
       },
       after: async ({
         result,
@@ -978,7 +1050,7 @@ ${memorySystemMessage}` : ""}`
           toolResults: result?.toolResults,
           toolCalls: result?.toolCalls,
           usage: result?.usage,
-          steps: result?.steps?.map((s) => {
+          steps: result?.steps?.map(s => {
             return {
               stepType: s?.stepType,
               text: result?.text,
@@ -1013,7 +1085,7 @@ ${memorySystemMessage}` : ""}`
           }
         }
         if (Object.keys(this.evals || {}).length > 0) {
-          const input = messages.map((message) => message.content).join("\n");
+          const input = messages.map(message => message.content).join("\n");
           const runIdToUse = runId2 || crypto.randomUUID();
           for (const metric of Object.values(this.evals || {})) {
             executeHook("onGeneration" /* ON_GENERATION */, {
@@ -1044,14 +1116,12 @@ ${memorySystemMessage}` : ""}`
   } = {}) {
     let messagesToUse = [];
     if (typeof messages === `string`) {
-      messagesToUse = [
-        {
-          role: "user",
-          content: messages
-        }
-      ];
+      messagesToUse = [{
+        role: "user",
+        content: messages
+      }];
     } else {
-      messagesToUse = messages.map((message) => {
+      messagesToUse = messages.map(message => {
         if (typeof message === `string`) {
           return {
             role: "user",
@@ -1062,7 +1132,10 @@ ${memorySystemMessage}` : ""}`
       });
     }
     const runIdToUse = runId || randomUUID();
-    const { before, after } = this.__primitive({
+    const {
+      before,
+      after
+    } = this.__primitive({
       messages: messagesToUse,
       context,
       threadId: threadIdInFn,
@@ -1071,7 +1144,11 @@ ${memorySystemMessage}` : ""}`
       runId: runIdToUse,
       toolsets
     });
-    const { threadId, messageObjects, convertedTools } = await before();
+    const {
+      threadId,
+      messageObjects,
+      convertedTools
+    } = await before();
     if (output === "text") {
       const result2 = await this.llm.__text({
         messages: messageObjects,
@@ -1084,7 +1161,13 @@ ${memorySystemMessage}` : ""}`
         toolChoice
       });
       const outputText2 = result2.text;
-      await after({ result: result2, threadId, memoryConfig: memoryOptions, outputText: outputText2, runId: runIdToUse });
+      await after({
+        result: result2,
+        threadId,
+        memoryConfig: memoryOptions,
+        outputText: outputText2,
+        runId: runIdToUse
+      });
       return result2;
     }
     const result = await this.llm.__textObject({
@@ -1099,7 +1182,13 @@ ${memorySystemMessage}` : ""}`
       toolChoice
     });
     const outputText = JSON.stringify(result.object);
-    await after({ result, threadId, memoryConfig: memoryOptions, outputText, runId: runIdToUse });
+    await after({
+      result,
+      threadId,
+      memoryConfig: memoryOptions,
+      outputText,
+      runId: runIdToUse
+    });
     return result;
   }
   async stream(messages, {
@@ -1119,14 +1208,12 @@ ${memorySystemMessage}` : ""}`
     const runIdToUse = runId || randomUUID();
     let messagesToUse = [];
     if (typeof messages === `string`) {
-      messagesToUse = [
-        {
-          role: "user",
-          content: messages
-        }
-      ];
+      messagesToUse = [{
+        role: "user",
+        content: messages
+      }];
     } else {
-      messagesToUse = messages.map((message) => {
+      messagesToUse = messages.map(message => {
         if (typeof message === `string`) {
           return {
             role: "user",
@@ -1136,7 +1223,10 @@ ${memorySystemMessage}` : ""}`
         return message;
       });
     }
-    const { before, after } = this.__primitive({
+    const {
+      before,
+      after
+    } = this.__primitive({
       messages: messagesToUse,
       context,
       threadId: threadIdInFn,
@@ -1145,7 +1235,11 @@ ${memorySystemMessage}` : ""}`
       runId: runIdToUse,
       toolsets
     });
-    const { threadId, messageObjects, convertedTools } = await before();
+    const {
+      threadId,
+      messageObjects,
+      convertedTools
+    } = await before();
     if (output === "text") {
       this.logger.debug(`Starting agent ${this.name} llm stream call`, {
         runId
@@ -1156,11 +1250,17 @@ ${memorySystemMessage}` : ""}`
         tools: this.tools,
         convertedTools,
         onStepFinish,
-        onFinish: async (result) => {
+        onFinish: async result => {
           try {
             const res = JSON.parse(result) || {};
             const outputText = res.text;
-            await after({ result: res, threadId, memoryConfig: memoryOptions, outputText, runId: runIdToUse });
+            await after({
+              result: res,
+              threadId,
+              memoryConfig: memoryOptions,
+              outputText,
+              runId: runIdToUse
+            });
           } catch (e) {
             this.logger.error("Error saving memory on finish", {
               error: e,
@@ -1184,11 +1284,17 @@ ${memorySystemMessage}` : ""}`
       structuredOutput: output,
       convertedTools,
       onStepFinish,
-      onFinish: async (result) => {
+      onFinish: async result => {
         try {
           const res = JSON.parse(result) || {};
           const outputText = JSON.stringify(res.object);
-          await after({ result: res, threadId, memoryConfig: memoryOptions, outputText, runId: runIdToUse });
+          await after({
+            result: res,
+            threadId,
+            memoryConfig: memoryOptions,
+            outputText,
+            runId: runIdToUse
+          });
         } catch (e) {
           this.logger.error("Error saving memory on finish", {
             error: e,
@@ -1203,8 +1309,11 @@ ${memorySystemMessage}` : ""}`
     });
   }
 };
-_init = __decoratorStart(_a);
-Agent = __decorateElement(_init, 0, "Agent", _Agent_decorators, Agent);
-__runInitializers(_init, 1, Agent);
+Agent = /*@__PURE__*/(_ => {
+  _init = __decoratorStart(_a);
+  Agent = __decorateElement(_init, 0, "Agent", _Agent_decorators, Agent);
+  __runInitializers(_init, 1, Agent);
+  return Agent;
+})();
 
 export { Agent };