versionhq 1.1.8__py3-none-any.whl → 1.1.9.0__py3-none-any.whl

versionhq/__init__.py

@@ -15,9 +15,10 @@ from versionhq.llm.model import LLM
 from versionhq.task.model import Task, TaskOutput
 from versionhq.team.model import Team, TeamOutput
 from versionhq.tool.model import Tool
+from versionhq.tool.composio import Composio
 
 
-__version__ = "1.1.8"
+__version__ = "1.1.9.0"
 __all__ = [
     "Agent",
     "Customer",
@@ -33,4 +34,5 @@ __all__ = [
     "Team",
     "TeamOutput",
     "Tool",
+    "Composio"
 ]

versionhq/agent/model.py

@@ -15,7 +15,7 @@ from versionhq.llm.llm_vars import LLM_VARS
 from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
 from versionhq.task import TaskOutputFormat
 from versionhq.task.model import ResponseField
-from versionhq.tool.model import Tool, ToolCalled
+from versionhq.tool.model import Tool, ToolSet
 from versionhq.tool.tool_handler import ToolHandler
 
 load_dotenv(override=True)

versionhq/clients/workflow/model.py

@@ -117,15 +117,6 @@ class MessagingWorkflow(ABC, BaseModel):
         description="store metrics that used to predict and track the performance of this workflow."
     )
 
-
-    @property
-    def name(self):
-        if self.customer.id:
-            return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
-        else:
-            return f"Workflow ID: {self.id} - on {self.product.id}"
-
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -160,3 +151,11 @@ class MessagingWorkflow(ABC, BaseModel):
         self.agents = agents
         self.team = team
         self.updated_at = datetime.datetime.now()
+
+
+    @property
+    def name(self):
+        if self.customer.id:
+            return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
+        else:
+            return f"Workflow ID: {self.id} - on {self.product.id}"

versionhq/task/model.py

@@ -12,7 +12,7 @@ from pydantic_core import PydanticCustomError
 from versionhq._utils.process_config import process_config
 from versionhq.task import TaskOutputFormat
 from versionhq.task.log_handler import TaskOutputStorageHandler
-from versionhq.tool.model import Tool, ToolCalled
+from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils.logger import Logger
 
 
@@ -76,18 +76,6 @@ class TaskOutput(BaseModel):
     def __str__(self) -> str:
         return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
 
-    @property
-    def json(self) -> Optional[str]:
-        if self.output_format != TaskOutputFormat.JSON:
-            raise ValueError(
-                """
-                Invalid output format requested.
-                If you would like to access the JSON output,
-                pleae make sure to set the output_json property for the task
-                """
-            )
-        return json.dumps(self.json_dict)
-
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -112,6 +100,19 @@ class TaskOutput(BaseModel):
         return json.dumps(self.json_dict) if self.json_dict else self.raw[0: 127]
 
 
+    @property
+    def json(self) -> Optional[str]:
+        if self.output_format != TaskOutputFormat.JSON:
+            raise ValueError(
+                """
+                Invalid output format requested.
+                If you would like to access the JSON output,
+                pleae make sure to set the output_json property for the task
+                """
+            )
+        return json.dumps(self.json_dict)
+
+
 
 class Task(BaseModel):
     """
@@ -140,7 +141,7 @@ class Task(BaseModel):
 
     # task setup
     context: Optional[List["Task"]] = Field(default=None, description="other tasks whose outputs should be used as context")
-    tools_called: Optional[List[ToolCalled]] = Field(default_factory=list, description="tools that the agent can use for this task")
+    tools_called: Optional[List[ToolSet]] = Field(default_factory=list, description="tools that the agent can use for this task")
     take_tool_res_as_final: bool = Field(default=False, description="when set True, tools res will be stored in the `TaskOutput`")
     allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
 
@@ -157,63 +158,6 @@ class Task(BaseModel):
     delegations: int = 0
 
 
-    @property
-    def output_prompt(self) -> str:
-        """
-        Draft prompts on the output format by converting `output_field_list` to dictionary.
-        """
-
-        output_prompt, output_formats_to_follow = "", dict()
-        for item in self.output_field_list:
-            output_formats_to_follow[item.title] = f"<Return your answer in {item.type.__name__}>"
-
-        output_prompt = f"""
-Your outputs MUST adhere to the following format and should NOT include any irrelevant elements:
-{output_formats_to_follow}
-        """
-        return output_prompt
-
-
-    @property
-    def expected_output_formats(self) -> List[TaskOutputFormat]:
-        """
-        Return output formats in list with the ENUM item.
-        `TaskOutputFormat.RAW` is set as default.
-        """
-        outputs = [TaskOutputFormat.RAW,]
-        if self.expected_output_json:
-            outputs.append(TaskOutputFormat.JSON)
-        if self.expected_output_pydantic:
-            outputs.append(TaskOutputFormat.PYDANTIC)
-        return outputs
-
-
-    @property
-    def key(self) -> str:
-        output_format = (
-            TaskOutputFormat.JSON
-            if self.expected_output_json == True
-            else (
-                TaskOutputFormat.PYDANTIC
-                if self.expected_output_pydantic == True
-                else TaskOutputFormat.RAW
-            )
-        )
-        source = [self.description, output_format]
-        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
-
-
-    @property
-    def summary(self) -> str:
-        return f"""
-        Task ID: {str(self.id)}
-        "Description": {self.description}
-        "Prompt": {self.output_prompt}
-        "Tools": {", ".join([tool_called.tool.name for tool_called in self.tools_called])}
-        """
-
-
-    # validators
     @model_validator(mode="before")
     @classmethod
     def process_model_config(cls, values: Dict[str, Any]):
@@ -399,7 +343,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         """
         Run the core execution logic of the task.
         To speed up the process, when the format is not expected to return, we will skip the conversion process.
-        When the task is allowed to delegate to another agent, we will select a responsible one in order of manager_agent > peer_agent > anoymous agent.
+        When the task is allowed to delegate to another agent, we will select a responsible one in order of manager > peer_agent > anoymous agent.
         """
         from versionhq.agent.model import Agent
         from versionhq.team.model import Team
@@ -410,8 +354,9 @@ Your outputs MUST adhere to the following format and should NOT include any irre
             agent_to_delegate = None
 
             if hasattr(agent, "team") and isinstance(agent.team, Team):
-                if agent.team.manager_agent:
-                    agent_to_delegate = agent.team.manager_agent
+                if agent.team.managers:
+                    idling_manager_agents = [manager.agent for manager in agent.team.managers if manager.task is None]
+                    agent_to_delegate = idling_manager_agents[0] if idling_manager_agents else agent.team.managers[0]
                 else:
                     peers = [member.agent for member in agent.team.members if member.is_manager == False and member.agent.id is not agent.id]
                     if len(peers) > 0:
@@ -466,6 +411,63 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         self._task_output_handler.update(task=self, task_index=task_index, was_replayed=was_replayed, inputs=inputs)
 
 
+    @property
+    def output_prompt(self) -> str:
+        """
+        Draft prompts on the output format by converting `output_field_list` to dictionary.
+        """
+
+        output_prompt, output_formats_to_follow = "", dict()
+        for item in self.output_field_list:
+            output_formats_to_follow[item.title] = f"<Return your answer in {item.type.__name__}>"
+
+        output_prompt = f"""
+Your outputs MUST adhere to the following format and should NOT include any irrelevant elements:
+{output_formats_to_follow}
+        """
+        return output_prompt
+
+
+    @property
+    def expected_output_formats(self) -> List[TaskOutputFormat]:
+        """
+        Return output formats in list with the ENUM item.
+        `TaskOutputFormat.RAW` is set as default.
+        """
+        outputs = [TaskOutputFormat.RAW,]
+        if self.expected_output_json:
+            outputs.append(TaskOutputFormat.JSON)
+        if self.expected_output_pydantic:
+            outputs.append(TaskOutputFormat.PYDANTIC)
+        return outputs
+
+
+    @property
+    def key(self) -> str:
+        output_format = (
+            TaskOutputFormat.JSON
+            if self.expected_output_json == True
+            else (
+                TaskOutputFormat.PYDANTIC
+                if self.expected_output_pydantic == True
+                else TaskOutputFormat.RAW
+            )
+        )
+        source = [self.description, output_format]
+        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
+
+
+    @property
+    def summary(self) -> str:
+        return f"""
+        Task ID: {str(self.id)}
+        "Description": {self.description}
+        "Prompt": {self.output_prompt}
+        "Tools": {", ".join([tool_called.tool.name for tool_called in self.tools_called])}
+        """
+
+
+
 
 class ConditionalTask(Task):
     """

versionhq/team/model.py

@@ -113,6 +113,9 @@ class TeamMember(ABC, BaseModel):
     is_manager: bool = Field(default=False)
     task: Optional[Task] = Field(default=None)
 
+    def update(self, task: Task):
+        self.task = task
+
 
 class Team(BaseModel):
     """
@@ -158,41 +161,6 @@ class Team(BaseModel):
         return self.name if self.name is not None else self.id.__str__
 
 
-    @property
-    def key(self) -> str:
-        source = [str(member.agent.id.__str__) for member in self.members] + [str(task.id.__str__) for task in self.tasks]
-        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
-
-
-    @property
-    def manager_agent(self) -> Agent:
-        manager_agent = [member.agent for member in self.members if member.is_manager == True]
-        return manager_agent[0] if len(manager_agent) > 0 else None
-
-
-    @property
-    def manager_task(self) -> Task:
-        """
-        Aside from the team task, return the task that the `manager_agent` needs to handle.
-        The task is set as second priority following to the team tasks.
-        """
-        task = [member.task for member in self.members if member.is_manager == True]
-        return task[0] if len(task) > 0 else None
-
-
-    @property
-    def tasks(self):
-        """
-        Return all the tasks that the team needs to handle in order of priority:
-        1. team tasks,
-        2. manager_task,
-        3. members' tasks
-        """
-        sorted_member_tasks = [member.task for member in self.members if member.is_manager == True] + [member.task for member in self.members if member.is_manager == False]
-        return self.team_tasks + sorted_member_tasks if len(self.team_tasks) > 0 else sorted_member_tasks
-
-
-    # validators
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -201,6 +169,21 @@ class Team(BaseModel):
             raise PydanticCustomError("may_not_set_field", "The 'id' field cannot be set by the user.", {})
 
 
+    @model_validator(mode="after")
+    def assess_tasks(self):
+        """
+        Validates if the model recognize all tasks that the team needs to handle.
+        """
+
+        if self.tasks:
+            if all(task in self.tasks for task in self.team_tasks) == False:
+                raise PydanticCustomError("task_validation_error", "`team_tasks` needs to be recognized in the task.", {})
+
+            if len(self.tasks) != len(self.team_tasks) + len([member for member in self.members if member.task is not None]):
+                raise PydanticCustomError("task_validation_error", "Some tasks are missing.", {})
+        return self
+
+
     @model_validator(mode="after")
     def check_manager_llm(self):
         """
@@ -208,37 +191,29 @@ class Team(BaseModel):
         """
 
         if self.process == TaskHandlingProcess.hierarchical:
-            if self.manager_agent is None:
+            if self.managers is None:
                 raise PydanticCustomError(
-                    "missing_manager_llm_or_manager_agent",
-                    "Attribute `manager_llm` or `manager_agent` is required when using hierarchical process.",
+                    "missing_manager_llm_or_manager",
+                    "Attribute `manager_llm` or `manager` is required when using hierarchical process.",
                     {},
                 )
 
-            if (self.manager_agent is not None) and (
-                self.members.count(self.manager_agent) > 0
-            ):
-                raise PydanticCustomError(
-                    "manager_agent_in_agents",
-                    "Manager agent should not be included in agents list.",
-                    {},
-                )
+            if self.managers and (self.manager_tasks is None or self.team_tasks is None):
+                raise PydanticCustomError("missing_manager_task", "manager needs to have at least one manager task or team task.", {})
+
         return self
 
 
     @model_validator(mode="after")
     def validate_tasks(self):
         """
-        Every team member should have a task to handle.
+        Sequential task processing without any team tasks require a task-agent pairing.
         """
-        if self.process == TaskHandlingProcess.sequential:
+
+        if self.process == TaskHandlingProcess.sequential and self.team_tasks is None:
             for member in self.members:
                 if member.task is None:
-                    raise PydanticCustomError(
-                        "missing_agent_in_task",
-                        f"Sequential process error: Agent is missing in the task with the following description: {member.task.description}",
-                        {},
-                    )
+                    raise PydanticCustomError("missing_agent_in_task", "Sequential process error: Agent is missing the task", {})
         return self
 
     @model_validator(mode="after")
@@ -249,34 +224,64 @@ class Team(BaseModel):
 
         async_task_count = 0
         for task in reversed(self.tasks):
-            if task.async_execution:
+            if not task:
+                break
+            elif task.async_execution:
                 async_task_count += 1
             else:
                 break
 
         if async_task_count > 1:
-            raise PydanticCustomError(
-                "async_task_count",
-                "The team must end with max. one asynchronous task.",
-                {},
-            )
+            raise PydanticCustomError("async_task_count", "The team must end with max. one asynchronous task.", {})
         return self
 
+
     def _get_responsible_agent(self, task: Task) -> Agent:
-        res = [member.agent for member in self.members if member.task.id == task.id]
-        return None if len(res) == 0 else res[0]
+        if task is None:
+            return None
+        else:
+            res = [member.agent for member in self.members if member.task and member.task.id == task.id]
+            return None if len(res) == 0 else res[0]
+
+
+    def _handle_team_planning(self) -> None:
+        """
+        Form a team considering agents and tasks given, and update `self.members` field:
+            1. Idling managers to take the team tasks.
+            2. Idling members to take the remaining tasks starting from the team tasks to member tasks.
+            3. Create agents to handle the rest tasks.
+        """
 
-    # setup team planner
-    def _handle_team_planning(self):
         team_planner = TeamPlanner(tasks=self.tasks, planner_llm=self.planning_llm)
-        result = team_planner._handle_task_planning()
+        idling_managers: List[TeamMember] = [member for member in self.members if member.task is None and member.is_manager is True]
+        idling_members: List[TeamMember] =  [member for member in self.members if member.task is None and member.is_manager is False]
+        unassigned_tasks: List[Task] = self.member_tasks_without_agent
+        new_team_members: List[TeamMember] = []
+
+        if self.team_tasks:
+            candidates = idling_managers + idling_members
+            if candidates:
+                i = 0
+                while i < len(candidates):
+                    if self.team_tasks[i]:
+                        candidates[i].task = self.team_tasks[i]
+                        i += 1
+
+                if len(self.team_tasks) > i:
+                    for item in self.team_tasks[i:]:
+                        if item not in unassigned_tasks:
+                            unassigned_tasks = [item, ] + unassigned_tasks
 
-        if result is not None:
-            for task in self.tasks:
-                task_id = task.id
-                task.description += (
-                    result[task_id] if hasattr(result, str(task_id)) else result
-                )
+            else:
+                for item in self.team_tasks:
+                    if item not in unassigned_tasks:
+                        unassigned_tasks = [item, ] + unassigned_tasks
+
+        if unassigned_tasks:
+            new_team_members = team_planner._handle_assign_agents(unassigned_tasks=unassigned_tasks)
+
+        if new_team_members:
+            self.members += new_team_members
 
 
     # task execution
@@ -333,9 +338,11 @@ class Team(BaseModel):
                 token_sum = agent._token_process.get_summary()
                 total_usage_metrics.add_usage_metrics(token_sum)
 
-        if self.manager_agent and hasattr(self.manager_agent, "_token_process"):
-            token_sum = self.manager_agent._token_process.get_summary()
-            total_usage_metrics.add_usage_metrics(token_sum)
+        if self.managers:
+            for manager in self.managers:
+                if hasattr(manager.agent, "_token_process"):
+                    token_sum = manager.agent._token_process.get_summary()
+                    total_usage_metrics.add_usage_metrics(token_sum)
 
         self.usage_metrics = total_usage_metrics
         return total_usage_metrics
@@ -366,7 +373,7 @@ class Team(BaseModel):
 
             responsible_agent = self._get_responsible_agent(task)
             if responsible_agent is None:
-                responsible_agent = self.manager_agent if self.manager_agent else self.members[0].agent
+                self._handle_team_planning()
 
             if isinstance(task, ConditionalTask):
                 skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
@@ -377,13 +384,13 @@ class Team(BaseModel):
             # self._log_task_start(task, responsible_agent)
 
             if task.async_execution:
-                context = create_raw_outputs(tasks=[task, ],task_outputs=([last_sync_output,] if last_sync_output else []))
+                context = create_raw_outputs(tasks=[task, ], task_outputs=([last_sync_output,] if last_sync_output else []))
                 future = task.execute_async(agent=responsible_agent, context=context, tools=responsible_agent.tools)
                 futures.append((task, future, task_index))
             else:
                 context = create_raw_outputs(tasks=[task,], task_outputs=([last_sync_output,] if last_sync_output else [] ))
                 task_output = task.execute_sync(agent=responsible_agent, context=context, tools=responsible_agent.tools)
-                if responsible_agent is self.manager_agent:
+                if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 
                 task_outputs.append(task_output)
@@ -400,15 +407,15 @@ class Team(BaseModel):
     def kickoff(self, kwargs_before: Optional[Dict[str, str]] = None, kwargs_after: Optional[Dict[str, Any]] = None) -> TeamOutput:
         """
         Kickoff the team:
-        0. Plan the team action if we have `team_tasks` using `planning_llm`.
+        0. Assign an agent to a task - using conditions (manager prioritizes team_tasks) and planning_llm.
         1. Address `before_kickoff_callbacks` if any.
-        2. Handle team members' tasks in accordance with the `process`.
+        2. Handle team members' tasks in accordance with the process.
         3. Address `after_kickoff_callbacks` if any.
         """
 
         metrics: List[UsageMetrics] = []
 
-        if len(self.team_tasks) > 0 or self.planning_llm is not None:
+        if self.team_tasks or self.member_tasks_without_agent:
             self._handle_team_planning()
 
         if kwargs_before is not None:
@@ -450,3 +457,51 @@ class Team(BaseModel):
             self.usage_metrics.add_usage_metrics(metric)
 
         return result
+
+
+    @property
+    def key(self) -> str:
+        source = [str(member.agent.id.__str__) for member in self.members] + [str(task.id.__str__) for task in self.tasks]
+        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
+
+
+    @property
+    def managers(self) -> List[TeamMember] | None:
+        managers = [member for member in self.members if member.is_manager == True]
+        return managers if len(managers) > 0 else None
+
+
+    @property
+    def manager_tasks(self) -> List[Task] | None:
+        """
+        Tasks (incl. team tasks) handled by managers in the team.
+        """
+        if self.managers:
+            tasks = [manager.task for manager in self.managers if manager.task is not None]
+            return tasks if len(tasks) > 0 else None
+
+        return None
+
+
+    @property
+    def tasks(self):
+        """
+        Return all the tasks that the team needs to handle in order of priority:
+        1. team tasks, -> assigned to the member
+        2. manager_task,
+        3. members' tasks
+        """
+
+        team_tasks = self.team_tasks
+        manager_tasks = [member.task for member in self.members if member.is_manager == True and member.task is not None and member.task not in team_tasks]
+        member_tasks = [member.task for member in self.members if member.is_manager == False and member.task is not None and member.task not in team_tasks]
+
+        return team_tasks + manager_tasks + member_tasks
+
+
+    @property
+    def member_tasks_without_agent(self) -> List[Task] | None:
+        if self.members:
+            return [member.task for member in self.members if member.agent is None]
+
+        return None

versionhq/team/team_planner.py

@@ -3,37 +3,80 @@ from dotenv import load_dotenv
 from typing import Any, List, Optional
 from pydantic import BaseModel, Field
 
-from versionhq.agent.model import Agent
-from versionhq.task.model import Task, ResponseField
-
 load_dotenv(override=True)
 
 
 class TeamPlanner:
     """
-    (Optional) Plan how the team should handle multiple tasks using LLM.
+    Assign agents to multiple tasks.
     """
 
+    from versionhq.task.model import Task, ResponseField, TaskOutput
+    from versionhq.agent.model import Agent
+
+
     def __init__(self, tasks: List[Task], planner_llm: Optional[Any] = None):
         self.tasks = tasks
-        self.planner_llm = (
-            planner_llm if planner_llm != None else os.environ.get("LITELLM_MODEL_NAME")
+        self.planner_llm = planner_llm if planner_llm else os.environ.get("LITELLM_MODEL_NAME")
+
+
+    def _handle_assign_agents(self, unassigned_tasks: List[Task]) -> List[Any]:
+        """
+        Build an agent and assign it a task, then return a list of TeamMember connecting the agent created and the task given.
+        """
+
+        from versionhq.agent.model import Agent
+        from versionhq.task.model import Task, ResponseField
+        from versionhq.team.model import TeamMember
+
+        new_member_list: List[TeamMember] = []
+        agent_creator = Agent(
+            role="agent_creator",
+            goal="build an ai agent that can competitively handle the task given",
+            llm=self.planner_llm,
         )
 
-    def _handle_task_planning(self) -> BaseModel:
+        for unassgined_task in unassigned_tasks:
+            task = Task(
+                description=f"""
+                    Based on the following task summary, draft a AI agent's role and goal in concise manner.
+                    Task summary: {unassgined_task.summary}
+                """,
+                expected_output_json=True,
+                output_field_list=[
+                    ResponseField(title="goal", type=str, required=True),
+                    ResponseField(title="role", type=str, required=True),
+                ],
+            )
+            res = task.execute_sync(agent=agent_creator)
+            agent = Agent(
+                role=res.json_dict["role"] if "role" in res.json_dict else res.raw,
+                goal=res.json_dict["goal"] if "goal" in res.json_dict else task.description
+            )
+            if agent.id:
+                team_member = TeamMember(agent=agent, task=unassgined_task, is_manager=False)
+                new_member_list.append(team_member)
+
+        return new_member_list
+
+
+
+    def _handle_task_planning(self, context: Optional[str] = None, tools: Optional[str] = None) -> TaskOutput:
         """
         Handles the team planning by creating detailed step-by-step plans for each task.
         """
 
-        planning_agent = Agent(
-            role="Task Execution Planner",
-            goal="Your goal is to create an extremely detailed, step-by-step plan based on the tasks and tools available to each agent so that they can perform the tasks in an exemplary manner",
-            backstory="You have a strong ability to design efficient organizational structures and task processes, minimizing unnecessary steps.",
+        from versionhq.agent.model import Agent
+        from versionhq.task.model import Task, ResponseField
+
+        team_planner = Agent(
+            role="team planner",
+            goal="Plan extremely detailed, step-by-step plan based on the tasks and tools available to each agent so that they can perform the tasks in an exemplary manner and assign a task to each agent.",
             llm=self.planner_llm,
         )
 
         task_summary_list = [task.summary for task in self.tasks]
-        task_to_handle = Task(
+        task = Task(
             description=f"""
                 Based on the following task summaries, create the most descriptive plan that the team can execute most efficiently. Take all the task summaries - task's description and tools available - into consideration. Your answer only contains a dictionary.
 
@@ -42,14 +85,9 @@ class TeamPlanner:
             expected_output_json=False,
             expected_output_pydantic=True,
             output_field_list=[
-                ResponseField(title=f"{task.id}", type=str, required=True)
+                ResponseField(title="task", type=str, required=True)
                 for task in self.tasks
             ],
         )
-        task_output = task_to_handle.execute_sync(agent=planning_agent)
-
-        if isinstance(task_output.pydantic, BaseModel):
-            return task_output.pydantic
-
-        else:
-            return None
+        output = task.execute_sync(agent=team_planner, context=context, tools=tools)
+        return output