fix(core): duplicate static tools provided to llm

Author: marinoska

packages/core/src/agent/agent.spec-d.ts

@@ -1091,7 +1091,44 @@ describe("Agent Type System", () => {
       });
 
       // Agent should accept complex tools
-      expectTypeOf(agent).toHaveProperty("tools");
+      expect(agent.getTools()).toHaveLength(1);
+      expect(agent.dynamicTools).toBeUndefined();
+    });
+
+    it("should work with dynamic tools", () => {
+      const complexTool = new Tool({
+        name: "analyzer",
+        description: "Analyze data",
+        parameters: z.object({
+          data: z.array(
+            z.object({
+              id: z.number(),
+              value: z.string(),
+              metadata: z.record(z.unknown()).optional(),
+            }),
+          ),
+          options: z.object({
+            format: z.enum(["json", "csv", "xml"]),
+            includeHeaders: z.boolean().default(true),
+          }),
+        }),
+        execute: async (params) => ({
+          result: `Analyzed ${params.data.length} items`,
+          format: params.options.format,
+        }),
+      });
+
+      const toolsFn = async () => [complexTool];
+      const agent = new Agent({
+        name: "Test",
+        instructions: "Test",
+        model: mockModel,
+        tools: toolsFn,
+      });
+
+      // Agent should accept dynamic tools function
+      expect(agent.getTools()).toHaveLength(0);
+      expect(agent.dynamicTools).toBe(toolsFn);
     });
 
     it("should handle tool execution context types", async () => {

packages/core/src/agent/agent.ts

@@ -244,7 +244,7 @@ export class Agent {
   readonly purpose?: string;
   readonly instructions: InstructionsDynamicValue;
   readonly model: LanguageModel | DynamicValue<LanguageModel>;
-  readonly tools: (Tool<any, any> | Toolkit)[] | DynamicValue<(Tool<any, any> | Toolkit)[]>;
+  readonly dynamicTools?: DynamicValue<(Tool<any, any> | Toolkit)[]>;
   readonly hooks: AgentHooks;
   readonly temperature?: number;
   readonly maxOutputTokens?: number;
@@ -271,7 +271,7 @@ export class Agent {
     this.purpose = options.purpose;
     this.instructions = options.instructions;
     this.model = options.model;
-    this.tools = options.tools || [];
+    this.dynamicTools = typeof options.tools === "function" ? options.tools : undefined;
     this.hooks = options.hooks || {};
     this.temperature = options.temperature;
     this.maxOutputTokens = options.maxOutputTokens;
@@ -312,7 +312,7 @@ export class Agent {
     this.memoryManager = new MemoryManager(this.id, this.memory, {}, this.logger);
 
     // Initialize tool manager with static tools
-    const staticTools = typeof this.tools === "function" ? [] : this.tools || [];
+    const staticTools = typeof options.tools === "function" ? [] : options.tools;
     this.toolManager = new ToolManager(staticTools, this.logger);
     if (options.toolkits) {
       this.toolManager.addItems(options.toolkits);
@@ -1278,10 +1278,6 @@ export class Agent {
     tools: Record<string, any>;
     maxSteps: number;
   }> {
-    // Resolve dynamic values
-    const model = await this.resolveValue(this.model, oc);
-    const agentToolList = await this.resolveValue(this.tools, oc);
-
     // Prepare messages (system + memory + input) as UIMessages
     const buffer = this.getConversationBuffer(oc);
     const uiMessages = await this.prepareMessages(input, oc, options, buffer);
@@ -1304,10 +1300,13 @@ export class Agent {
     // Calculate maxSteps (use provided option or calculate based on subagents)
     const maxSteps = options?.maxSteps ?? this.calculateMaxSteps();
 
+    // Resolve dynamic values
+    const model = await this.resolveValue(this.model, oc);
+    const dynamicToolList = (await this.resolveValue(this.dynamicTools, oc)) || [];
+
     // Merge agent tools with option tools
-    const agentToolsArray = Array.isArray(agentToolList) ? agentToolList : [];
     const optionToolsArray = options?.tools || [];
-    const mergedTools = [...agentToolsArray, ...optionToolsArray];
+    const mergedTools = [...dynamicToolList, ...optionToolsArray];
 
     // Prepare tools with execution context
     const tools = await this.prepareTools(mergedTools, oc, maxSteps, options);