feat: enhance sub-agent functionality (#27)

* feat: enhance sub-agent functionality with context memory and error handling

* feat: improve agent memory formatting and enhance supervisor message structure

* refactor: streamline content handling in getStringContent and improve error message structure

* chore: add changeset

Author: omeraplak

.changeset/fuzzy-guests-repair.md

@@ -0,0 +1,14 @@
+---
+"@voltagent/core": patch
+---
+
+fix: improve sub-agent context sharing for sequential task execution - #30
+
+Enhanced the Agent system to properly handle context sharing between sub-agents, enabling reliable sequential task execution. The changes include:
+
+- Adding `contextMessages` parameter to `getSystemMessage` method
+- Refactoring `prepareAgentsMemory` to properly format conversation history
+- Ensuring conversation context is correctly passed between delegated tasks
+- Enhancing system prompts to better handle sequential workflows
+
+This fixes issues where the second agent in a sequence would not have access to the first agent's output, causing failures in multi-step workflows.

packages/core/src/agent/index.spec.ts

@@ -27,12 +27,14 @@ type MockModelType = { modelId: string; [key: string]: any };
 function getStringContent(content: any): string {
   if (typeof content === "string") {
     return content;
-  } else if (Array.isArray(content)) {
+  }
+  if (Array.isArray(content)) {
     return content
       .map((part) => {
         if (typeof part === "string") {
           return part;
-        } else if (part && typeof part === "object" && "type" in part) {
+        }
+        if (part && typeof part === "object" && "type" in part) {
           if (part.type === "text" && "text" in part) {
             return part.text;
           }

packages/core/src/agent/index.ts

@@ -143,9 +143,11 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
   protected async getSystemMessage({
     input,
     historyEntryId,
+    contextMessages,
   }: {
     input?: string | BaseMessage[];
     historyEntryId: string;
+    contextMessages: BaseMessage[];
   }): Promise<BaseMessage> {
     let description = this.description;
 
@@ -172,7 +174,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
 
       try {
         const context = await this.retriever.retrieve(input);
-        if (context && context.trim()) {
+        if (context?.trim()) {
           description = `${description}\n\nRelevant Context:\n${context}`;
 
           // Update the event
@@ -199,7 +201,16 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
 
     // If the agent has sub-agents, generate supervisor system message
     if (this.subAgentManager.hasSubAgents()) {
-      description = this.subAgentManager.generateSupervisorSystemMessage(description);
+      // Fetch recent agent history for the sub-agents
+      const agentsMemory = await this.prepareAgentsMemory(contextMessages);
+
+      // Generate the supervisor message with the agents memory inserted
+      description = this.subAgentManager.generateSupervisorSystemMessage(description, agentsMemory);
+
+      return {
+        role: "system",
+        content: description,
+      };
     }
 
     return {
@@ -208,6 +219,32 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
     };
   }
 
+  /**
+   * Prepare agents memory for the supervisor system message
+   * This fetches and formats recent interactions with sub-agents
+   */
+  private async prepareAgentsMemory(contextMessages: BaseMessage[]): Promise<string> {
+    try {
+      // Get all sub-agents
+      const subAgents = this.subAgentManager.getSubAgents();
+      if (subAgents.length === 0) return "";
+
+      // Format the agent histories into a readable format
+      const formattedMemory = contextMessages
+        .filter((p) => p.role !== "system")
+        .filter((p) => p.role === "assistant" && !p.content.toString().includes("toolCallId"))
+        .map((message) => {
+          return `${message.role}: ${message.content}`;
+        })
+        .join("\n\n");
+
+      return formattedMemory || "No previous agent interactions found.";
+    } catch (error) {
+      console.warn("Error preparing agents memory:", error);
+      return "Error retrieving agent history.";
+    }
+  }
+
   /**
    * Add input to messages array based on type
    */
@@ -449,7 +486,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
   };
 
   /**
-   * Tool event creator
+   * Fix delete operator usage for better performance
    */
   private addToolEvent = async (
     context: OperationContext,
@@ -466,19 +503,21 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       ...(data.metadata || {}),
     };
 
-    if (data.toolId) {
-      metadata.toolId = data.toolId;
-      delete data.toolId;
+    // Extract data fields to use while avoiding parameter reassignment
+    const { toolId, input, output, error, errorMessage } = data;
+
+    if (toolId) {
+      metadata.toolId = toolId;
     }
 
     const eventData: Partial<StandardEventData> = {
       affectedNodeId: toolNodeId,
       status: status as any,
       timestamp: new Date().toISOString(),
-      input: data.input,
-      output: data.output,
-      error: data.error,
-      errorMessage: data.errorMessage,
+      input,
+      output,
+      error,
+      errorMessage,
       metadata,
     };
 
@@ -543,14 +582,16 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       ...(data.metadata || {}),
     };
 
-    if (data.usage) {
-      metadata.usage = data.usage;
-      delete data.usage;
+    // Extract data fields to use while avoiding parameter reassignment
+    const { usage, ...standardData } = data;
+
+    if (usage) {
+      metadata.usage = usage;
     }
 
-    // Create new data
-    const standardData: Partial<StandardEventData> = {
-      ...data,
+    // Create new data with metadata
+    const eventData: Partial<StandardEventData> = {
+      ...standardData,
       metadata,
     };
 
@@ -560,7 +601,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       status,
       NodeType.AGENT,
       this.id,
-      standardData,
+      eventData,
       "agent",
       context,
     );
@@ -603,6 +644,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       const systemMessage = await this.getSystemMessage({
         input,
         historyEntryId: context.historyEntry.id,
+        contextMessages,
       });
 
       // Combine messages
@@ -783,6 +825,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       const systemMessage = await this.getSystemMessage({
         input,
         historyEntryId: context.historyEntry.id,
+        contextMessages,
       });
 
       // Combine messages
@@ -988,6 +1031,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       const systemMessage = await this.getSystemMessage({
         input,
         historyEntryId: context.historyEntry.id,
+        contextMessages,
       });
 
       // Combine messages
@@ -1107,6 +1151,7 @@ export class Agent<TProvider extends { llm: LLMProvider<any> }> {
       const systemMessage = await this.getSystemMessage({
         input,
         historyEntryId: context.historyEntry.id,
+        contextMessages,
       });
 
       // Combine messages

packages/core/src/agent/subagent/index.spec.ts

@@ -1,4 +1,5 @@
-import { SubAgentManager } from ".";
+import { SubAgentManager } from "./index";
+import type { Agent } from "../index";
 import type { AgentHandoffOptions } from "../types";
 
 // Creating a Mock Agent class
@@ -109,24 +110,36 @@ describe("SubAgentManager", () => {
   });
 
   describe("generateSupervisorSystemMessage", () => {
-    it("should return original description when no sub-agents", () => {
+    it("should return the original description if no sub-agents", () => {
+      const subAgentManager = new SubAgentManager("TestAgent");
       const description = "Original description";
+
+      // Call with empty agentsMemory string (default parameter)
       expect(subAgentManager.generateSupervisorSystemMessage(description)).toBe(description);
     });
 
-    it("should return supervisor message when has sub-agents", () => {
-      subAgentManager.addSubAgent(mockAgent1);
-      subAgentManager.addSubAgent(mockAgent2);
-
+    it("should generate a supervisor message when sub-agents exist", () => {
+      const subAgentAgent1 = {
+        id: "agent1",
+        name: "Agent 1",
+        description: "First agent",
+      } as Agent<any>;
+      const subAgentAgent2 = {
+        id: "agent2",
+        name: "Agent 2",
+        description: "Second agent",
+      } as Agent<any>;
+
+      const subAgentManager = new SubAgentManager("TestAgent", [subAgentAgent1, subAgentAgent2]);
       const description = "Original description";
+
+      // Call with empty agentsMemory string (default parameter)
       const result = subAgentManager.generateSupervisorSystemMessage(description);
 
-      expect(result).toContain("supervisor agent");
-      expect(result).toContain("Math Agent");
-      expect(result).toContain("Writing Agent");
-      expect(result).toContain(
-        "Provide a final answer to the User when you have a response from all agents.",
-      );
+      expect(result).toContain("You are a supervisor agent");
+      expect(result).toContain("Agent 1: First agent");
+      expect(result).toContain("Agent 2: Second agent");
+      expect(result).toContain("<agents_memory>");
     });
   });
 
@@ -199,7 +212,10 @@ describe("SubAgentManager", () => {
           targetAgents: ["non-existent-agent"],
           context: {},
         }),
-      ).rejects.toThrow("No valid target agents found");
+      ).resolves.toMatchObject({
+        error: "Failed to delegate task: No valid target agents found. Available agents: ",
+        status: "error",
+      });
     });
 
     it("should execute and return results when valid agents exist", async () => {
@@ -209,8 +225,20 @@ describe("SubAgentManager", () => {
       const handoffToMultipleSpy = jest
         .spyOn(subAgentManager, "handoffToMultiple")
         .mockResolvedValue([
-          { result: "Result 1", conversationId: "conv1", messages: [] },
-          { result: "Result 2", conversationId: "conv2", messages: [] },
+          {
+            result: "Result 1",
+            conversationId: "conv1",
+            messages: [],
+            error: undefined,
+            status: "success",
+          },
+          {
+            result: "Result 2",
+            conversationId: "conv2",
+            messages: [],
+            error: undefined,
+            status: "success",
+          },
         ]);
 
       const tool = subAgentManager.createDelegateTool();
@@ -223,8 +251,20 @@ describe("SubAgentManager", () => {
 
       expect(handoffToMultipleSpy).toHaveBeenCalled();
       expect(result).toEqual([
-        { agentName: "Math Agent", response: "Result 1", conversationId: "conv1" },
-        { agentName: "Writing Agent", response: "Result 2", conversationId: "conv2" },
+        {
+          agentName: "Math Agent",
+          response: "Result 1",
+          conversationId: "conv1",
+          error: undefined,
+          status: "success",
+        },
+        {
+          agentName: "Writing Agent",
+          response: "Result 2",
+          conversationId: "conv2",
+          error: undefined,
+          status: "success",
+        },
       ]);
     });
   });