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

package/dist/{chunk-JWVCENG2.js → chunk-JY322VLW.js}

@@ -1,12 +1,427 @@
-import { LLM } from './chunk-RI3ECMVF.js';
-import { InstrumentClass } from './chunk-6ZVFVYLE.js';
+import { InstrumentClass } from './chunk-4ZUSEHLH.js';
+import { delay } from './chunk-KNPBNSJ7.js';
+import { executeHook, AvailableHooks } from './chunk-HBTQNIAX.js';
 import { MastraBase } from './chunk-G4MCO7XF.js';
 import { RegisteredLogger, LogLevel } from './chunk-ICMEXHKD.js';
-import { executeHook, AvailableHooks } from './chunk-HBTQNIAX.js';
-import { __name, __publicField, __privateAdd, __privateSet, __privateGet } from './chunk-AJJZUHB4.js';
+import { __name, __privateAdd, __privateSet, __privateGet, __publicField } from './chunk-AJJZUHB4.js';
 import { randomUUID } from 'crypto';
 import { z } from 'zod';
+import { generateText, jsonSchema, generateObject, streamText, streamObject } from 'ai';
 
+// src/llm/model/base.ts
+var _mastra, _model;
+var _MastraLLMBase = class _MastraLLMBase extends MastraBase {
+  constructor({ name, model }) {
+    super({
+      component: RegisteredLogger.LLM,
+      name
+    });
+    // @ts-ignore
+    __privateAdd(this, _mastra);
+    __privateAdd(this, _model);
+    __privateSet(this, _model, model);
+  }
+  getProvider() {
+    return __privateGet(this, _model).provider;
+  }
+  convertToMessages(messages) {
+    if (Array.isArray(messages)) {
+      return messages.map((m) => {
+        if (typeof m === "string") {
+          return {
+            role: "user",
+            content: m
+          };
+        }
+        return m;
+      });
+    }
+    return [
+      {
+        role: "user",
+        content: messages
+      }
+    ];
+  }
+  __registerPrimitives(p) {
+    if (p.telemetry) {
+      this.__setTelemetry(p.telemetry);
+    }
+    if (p.logger) {
+      this.__setLogger(p.logger);
+    }
+    __privateSet(this, _mastra, p);
+  }
+  async __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
+    });
+    throw new Error("Method not implemented.");
+  }
+  async generate(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
+    });
+    throw new Error("Method not implemented.");
+  }
+  async __streamObject(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
+    });
+    throw new Error("Method not implemented.");
+  }
+};
+_mastra = new WeakMap();
+_model = new WeakMap();
+__name(_MastraLLMBase, "MastraLLMBase");
+var MastraLLMBase = _MastraLLMBase;
+var _model2, _mastra2;
+var _MastraLLM = class _MastraLLM extends MastraLLMBase {
+  constructor({ model, mastra }) {
+    super({
+      name: "aisdk",
+      model
+    });
+    __privateAdd(this, _model2);
+    __privateAdd(this, _mastra2);
+    __privateSet(this, _model2, model);
+    if (mastra) {
+      __privateSet(this, _mastra2, mastra);
+      if (mastra.logger) {
+        this.__setLogger(mastra.logger);
+      }
+    }
+  }
+  __registerPrimitives(p) {
+    if (p.telemetry) {
+      this.__setTelemetry(p.telemetry);
+    }
+    if (p.logger) {
+      this.__setLogger(p.logger);
+    }
+    __privateSet(this, _mastra2, p);
+  }
+  getProvider() {
+    return __privateGet(this, _model2).provider;
+  }
+  convertTools(tools) {
+    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: /* @__PURE__ */ __name(async (props) => {
+            try {
+              this.logger.debug("Executing tool", {
+                tool: k,
+                props
+              });
+              return tool.execute({
+                context: props,
+                mastra: __privateGet(this, _mastra2)
+              });
+            } catch (error) {
+              this.logger.error("Error executing tool", {
+                tool: k,
+                props,
+                error
+              });
+              throw error;
+            }
+          }, "execute")
+        };
+      }
+      return memo;
+    }, {});
+    this.logger.debug(`Converted tools for LLM`);
+    return converted;
+  }
+  async __text({ runId, messages, maxSteps, tools, convertedTools, temperature, toolChoice = "auto", onStepFinish }) {
+    const model = __privateGet(this, _model2);
+    this.logger.debug(`[LLM] - Generating text`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      toolChoice,
+      maxSteps,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          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");
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish")
+    };
+    return await generateText({
+      messages,
+      ...argsForExecute,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async __textObject({ messages, onStepFinish, maxSteps = 5, tools, convertedTools, structuredOutput, runId, temperature, toolChoice = "auto" }) {
+    const model = __privateGet(this, _model2);
+    this.logger.debug(`[LLM] - Generating a text object`, {
+      runId
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      toolChoice,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          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
+          });
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish")
+    };
+    let schema;
+    let output = "object";
+    if (typeof structuredOutput.parse === "function") {
+      schema = structuredOutput;
+      if (schema instanceof z.ZodArray) {
+        output = "array";
+        schema = schema._def.type;
+      }
+    } else {
+      schema = jsonSchema(structuredOutput);
+    }
+    return await generateObject({
+      messages,
+      ...argsForExecute,
+      output,
+      schema,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async __stream({ messages, onStepFinish, onFinish, maxSteps = 5, tools, convertedTools, runId, temperature, toolChoice = "auto" }) {
+    const model = __privateGet(this, _model2);
+    this.logger.debug(`[LLM] - Streaming text`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      toolChoice,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          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
+          });
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish"),
+      onFinish: /* @__PURE__ */ __name(async (props) => {
+        onFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Finished:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+      }, "onFinish")
+    };
+    return await streamText({
+      messages,
+      ...argsForExecute,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async __streamObject({ messages, onStepFinish, onFinish, maxSteps = 5, tools, convertedTools, structuredOutput, runId, temperature, toolChoice = "auto" }) {
+    const model = __privateGet(this, _model2);
+    this.logger.debug(`[LLM] - Streaming structured output`, {
+      runId,
+      messages,
+      maxSteps,
+      tools: Object.keys(tools || convertedTools || {})
+    });
+    const finalTools = convertedTools || this.convertTools(tools);
+    const argsForExecute = {
+      model,
+      temperature,
+      tools: {
+        ...finalTools
+      },
+      maxSteps,
+      toolChoice,
+      onStepFinish: /* @__PURE__ */ __name(async (props) => {
+        onStepFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Step Change:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          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
+          });
+          await delay(10 * 1e3);
+        }
+      }, "onStepFinish"),
+      onFinish: /* @__PURE__ */ __name(async (props) => {
+        onFinish?.(JSON.stringify(props, null, 2));
+        this.logger.debug("[LLM] - Stream Finished:", {
+          text: props?.text,
+          toolCalls: props?.toolCalls,
+          toolResults: props?.toolResults,
+          finishReason: props?.finishReason,
+          usage: props?.usage,
+          runId
+        });
+      }, "onFinish")
+    };
+    let schema;
+    let output = "object";
+    if (typeof structuredOutput.parse === "function") {
+      schema = structuredOutput;
+      if (schema instanceof z.ZodArray) {
+        output = "array";
+        schema = schema._def.type;
+      }
+    } else {
+      schema = jsonSchema(structuredOutput);
+    }
+    return streamObject({
+      messages,
+      ...argsForExecute,
+      output,
+      schema,
+      experimental_telemetry: this.experimental_telemetry
+    });
+  }
+  async generate(messages, { maxSteps = 5, onStepFinish, tools, convertedTools, runId, output = "text", temperature } = {}) {
+    const msgs = this.convertToMessages(messages);
+    if (output === "text") {
+      return await this.__text({
+        messages: msgs,
+        onStepFinish,
+        maxSteps,
+        tools,
+        convertedTools,
+        runId,
+        temperature
+      });
+    }
+    return await this.__textObject({
+      messages: msgs,
+      structuredOutput: output,
+      onStepFinish,
+      maxSteps,
+      tools,
+      convertedTools,
+      runId
+    });
+  }
+  async stream(messages, { maxSteps = 5, onFinish, onStepFinish, tools, convertedTools, runId, output = "text", temperature } = {}) {
+    const msgs = this.convertToMessages(messages);
+    if (output === "text") {
+      return await this.__stream({
+        messages: msgs,
+        onStepFinish,
+        onFinish,
+        maxSteps,
+        tools,
+        convertedTools,
+        runId,
+        temperature
+      });
+    }
+    return await this.__streamObject({
+      messages: msgs,
+      structuredOutput: output,
+      onStepFinish,
+      onFinish,
+      maxSteps,
+      tools,
+      convertedTools,
+      runId,
+      temperature
+    });
+  }
+};
+_model2 = new WeakMap();
+_mastra2 = new WeakMap();
+__name(_MastraLLM, "MastraLLM");
+var MastraLLM = _MastraLLM;
+
+// src/agent/index.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -18,41 +433,35 @@ function _ts_metadata(k, v) {
   if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
 __name(_ts_metadata, "_ts_metadata");
-var _mastra, _memory;
+var _mastra3, _memory;
 var _Agent = class _Agent extends MastraBase {
   constructor(config) {
     super({
       component: RegisteredLogger.AGENT
     });
     __publicField(this, "name");
-    // @ts-ignore
     __publicField(this, "llm");
     __publicField(this, "instructions");
     __publicField(this, "model");
-    __privateAdd(this, _mastra);
+    __privateAdd(this, _mastra3);
     __privateAdd(this, _memory);
     __publicField(this, "tools");
     __publicField(this, "metrics");
     this.name = config.name;
     this.instructions = config.instructions;
-    if (!config.model && !config.llm) {
-      throw new Error("Either model or llm is required");
-    }
-    if (config.llm) {
-      this.llm = config.llm;
-    } else if (config.model) {
-      this.model = config.model;
-      this.llm = new LLM({
-        model: config.model
-      });
+    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.tools = {};
     this.metrics = {};
     if (config.tools) {
       this.tools = config.tools;
     }
     if (config.mastra) {
-      __privateSet(this, _mastra, config.mastra);
+      __privateSet(this, _mastra3, config.mastra);
     }
     if (config.metrics) {
       this.metrics = config.metrics;
@@ -65,7 +474,7 @@ var _Agent = class _Agent extends MastraBase {
     return Boolean(__privateGet(this, _memory));
   }
   getMemory() {
-    return __privateGet(this, _memory) ?? __privateGet(this, _mastra)?.memory;
+    return __privateGet(this, _memory) ?? __privateGet(this, _mastra3)?.memory;
   }
   __registerPrimitives(p) {
     if (p.telemetry) {
@@ -75,7 +484,7 @@ var _Agent = class _Agent extends MastraBase {
       this.__setLogger(p.logger);
     }
     this.llm.__registerPrimitives(p);
-    __privateSet(this, _mastra, p);
+    __privateSet(this, _mastra3, p);
     this.logger.debug(`[Agents:${this.name}] initialized.`, {
       model: this.model,
       name: this.name
@@ -285,11 +694,11 @@ ${memorySystemMessage}` : ""}`
         const responseMessagesWithoutIncompleteToolCalls = this.sanitizeResponseMessages(ms);
         const memory = this.getMemory();
         if (memory) {
-          this.logger.debug(`[Agent:${this.name}] - Memory persistence: store=${__privateGet(this, _mastra)?.memory?.constructor.name} threadId=${threadId}`, {
+          this.logger.debug(`[Agent:${this.name}] - Memory persistence: store=${__privateGet(this, _mastra3)?.memory?.constructor.name} threadId=${threadId}`, {
             runId,
             resourceId,
             threadId,
-            memoryStore: __privateGet(this, _mastra)?.memory?.constructor.name
+            memoryStore: __privateGet(this, _mastra3)?.memory?.constructor.name
           });
           await memory.saveMessages({
             memoryConfig,
@@ -388,7 +797,7 @@ ${memorySystemMessage}` : ""}`
               });
               return tool.execute({
                 context: args,
-                mastra: __privateGet(this, _mastra)
+                mastra: __privateGet(this, _mastra3)
               });
             } catch (err) {
               this.logger.error(`[Agent:${this.name}] - Failed execution`, {
@@ -474,11 +883,11 @@ ${memorySystemMessage}` : ""}`
         let coreMessages = messages;
         let threadIdToUse = threadId;
         if (this.getMemory() && resourceId) {
-          this.logger.debug(`[Agent:${this.name}] - Memory persistence enabled: store=${__privateGet(this, _mastra)?.memory?.constructor.name}, resourceId=${resourceId}`, {
+          this.logger.debug(`[Agent:${this.name}] - Memory persistence enabled: store=${__privateGet(this, _mastra3)?.memory?.constructor.name}, resourceId=${resourceId}`, {
             runId,
             resourceId,
             threadId: threadIdToUse,
-            memoryStore: __privateGet(this, _mastra)?.memory?.constructor.name
+            memoryStore: __privateGet(this, _mastra3)?.memory?.constructor.name
           });
           const preExecuteResult = await this.preExecute({
             resourceId,
@@ -579,7 +988,7 @@ ${memorySystemMessage}` : ""}`
       }, "after")
     };
   }
-  async generate(messages, { context, threadId: threadIdInFn, memoryOptions, resourceId, maxSteps = 5, onStepFinish, runId, toolsets, output = "text", temperature } = {}) {
+  async generate(messages, { context, threadId: threadIdInFn, memoryOptions, resourceId, maxSteps = 5, onStepFinish, runId, toolsets, output = "text", temperature, toolChoice = "auto" } = {}) {
     let messagesToUse = [];
     if (typeof messages === `string`) {
       messagesToUse = [
@@ -618,7 +1027,8 @@ ${memorySystemMessage}` : ""}`
         onStepFinish,
         maxSteps,
         runId: runIdToUse,
-        temperature
+        temperature,
+        toolChoice
       });
       const outputText2 = result2.text;
       await after({
@@ -638,7 +1048,8 @@ ${memorySystemMessage}` : ""}`
       onStepFinish,
       maxSteps,
       runId: runIdToUse,
-      temperature
+      temperature,
+      toolChoice
     });
     const outputText = JSON.stringify(result.object);
     await after({
@@ -650,7 +1061,7 @@ ${memorySystemMessage}` : ""}`
     });
     return result;
   }
-  async stream(messages, { context, threadId: threadIdInFn, memoryOptions, resourceId, maxSteps = 5, onFinish, onStepFinish, runId, toolsets, output = "text", temperature } = {}) {
+  async stream(messages, { context, threadId: threadIdInFn, memoryOptions, resourceId, maxSteps = 5, onFinish, onStepFinish, runId, toolsets, output = "text", temperature, toolChoice = "auto" } = {}) {
     const runIdToUse = runId || randomUUID();
     let messagesToUse = [];
     if (typeof messages === `string`) {
@@ -711,7 +1122,8 @@ ${memorySystemMessage}` : ""}`
           onFinish?.(result);
         }, "onFinish"),
         maxSteps,
-        runId
+        runId,
+        toolChoice
       });
     }
     this.logger.debug(`Starting agent ${this.name} llm streamObject call`, {
@@ -744,11 +1156,12 @@ ${memorySystemMessage}` : ""}`
         onFinish?.(result);
       }, "onFinish"),
       maxSteps,
-      runId
+      runId,
+      toolChoice
     });
   }
 };
-_mastra = new WeakMap();
+_mastra3 = new WeakMap();
 _memory = new WeakMap();
 __name(_Agent, "Agent");
 var Agent = _Agent;

package/dist/{chunk-ECUVL2G5.js → chunk-K3N7KJHH.js}

@@ -1,4 +1,4 @@
-import { InstrumentClass } from './chunk-6ZVFVYLE.js';
+import { InstrumentClass } from './chunk-4ZUSEHLH.js';
 import { MastraBase } from './chunk-G4MCO7XF.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
 

package/dist/chunk-MBOUQZQT.js

@@ -0,0 +1,16 @@
+import { MastraBase } from './chunk-G4MCO7XF.js';
+import { __name } from './chunk-AJJZUHB4.js';
+
+// src/vector/index.ts
+var _MastraVector = class _MastraVector extends MastraBase {
+  constructor() {
+    super({
+      name: "MastraVector",
+      component: "VECTOR"
+    });
+  }
+};
+__name(_MastraVector, "MastraVector");
+var MastraVector = _MastraVector;
+
+export { MastraVector };

package/dist/{chunk-GGYXCZUW.js → chunk-N44BCOWP.js}

@@ -1,4 +1,4 @@
-import { Agent } from './chunk-JWVCENG2.js';
+import { Agent } from './chunk-JY322VLW.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
 import { CohereClient } from 'cohere-ai';
 
@@ -40,18 +40,10 @@ __name(createSimilarityPrompt, "createSimilarityPrompt");
 
 // src/relevance/mastra-agent/index.ts
 var _MastraAgentRelevanceScorer = class _MastraAgentRelevanceScorer {
-  constructor(provider, name, model) {
+  constructor(name, model) {
     __publicField(this, "agent");
-    const modelConfig = {
-      provider,
-      ...model ? {
-        model
-      } : {
-        name
-      }
-    };
     this.agent = new Agent({
-      name: `Relevance Scorer ${provider} ${name}`,
+      name: `Relevance Scorer ${name}`,
       instructions: `You are a specialized agent for evaluating the relevance of text to queries.
 Your task is to rate how well a text passage answers a given query.
 Output only a number between 0 and 1, where:
@@ -62,7 +54,7 @@ Consider:
 - Completeness of information
 - Quality and specificity
 Always return just the number, no explanation.`,
-      model: modelConfig
+      model
     });
   }
   async getRelevanceScore(query, text) {

package/dist/{chunk-WBPDZBUT.js → chunk-TYIBRZOY.js}

@@ -1,6 +1,4 @@
-import { Telemetry } from './chunk-SDKEPBBH.js';
-import { LLM } from './chunk-RI3ECMVF.js';
-import { InstrumentClass } from './chunk-6ZVFVYLE.js';
+import { InstrumentClass, Telemetry } from './chunk-4ZUSEHLH.js';
 import { LogLevel, createLogger, noopLogger } from './chunk-ICMEXHKD.js';
 import { __name, __publicField } from './chunk-AJJZUHB4.js';
 
@@ -147,8 +145,7 @@ var _Mastra = class _Mastra {
           memory: this.memory,
           agents: this.agents,
           tts: this.tts,
-          vectors: this.vectors,
-          llm: this.LLM
+          vectors: this.vectors
         });
         this.workflows[key] = workflow;
       });
@@ -157,18 +154,6 @@ var _Mastra = class _Mastra {
       logger
     });
   }
-  LLM(modelConfig) {
-    const llm = new LLM({
-      model: modelConfig
-    });
-    if (this.telemetry) {
-      llm.__setTelemetry(this.telemetry);
-    }
-    if (this.getLogger) {
-      llm.__setLogger(this.getLogger());
-    }
-    return llm;
-  }
   getAgent(name) {
     const agent = this.agents?.[name];
     if (!agent) {