versionhq 1.1.7.9__tar.gz → 1.1.8.1__tar.gz

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.7.9
+Version: 1.1.8.1
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__"]
 
 [project]
 name = "versionhq"
-version = "1.1.7.9"
+version = "1.1.8.1"
 authors = [{ name = "Kuriko Iwai", email = "kuriko@versi0n.io" }]
 description = "LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows"
 readme = "README.md"

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/src/versionhq/__init__.py

@@ -17,7 +17,7 @@ from versionhq.team.model import Team, TeamOutput
 from versionhq.tool.model import Tool
 
 
-__version__ = "1.1.7.9"
+__version__ = "1.1.8.1"
 __all__ = [
     "Agent",
     "Customer",

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/src/versionhq/storage/task_output_storage.py

@@ -11,11 +11,9 @@ from versionhq._utils.logger import Logger
 
 load_dotenv(override=True)
 
-
 def fetch_db_storage_path():
-    project_directory_name = os.environ.get("STORAGE_DIR", Path.cwd().name)
-    app_author = "versionhq"
-    data_dir = Path(appdirs.user_data_dir(project_directory_name, app_author))
+    directory_name = Path.cwd().name
+    data_dir = Path(appdirs.user_data_dir(appname=directory_name, appauthor="Version IO Sdn Bhd.", version=None, roaming=False))
     data_dir.mkdir(parents=True, exist_ok=True)
     return data_dir
 
@@ -39,25 +37,25 @@ class TaskOutputSQLiteStorage:
         Initializes the SQLite database and creates LTM table.
         """
 
-        try:
-            with sqlite3.connect(self.db_path) as conn:
-                cursor = conn.cursor()
-                cursor.execute(
-                    """
-                    CREATE TABLE IF NOT EXISTS task_outputs (
-                        task_id TEXT PRIMARY KEY,
-                        output JSON,
-                        task_index INTEGER,
-                        inputs JSON,
-                        was_replayed BOOLEAN,
-                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
-                    )
+        # try:
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute(
                 """
+                CREATE TABLE IF NOT EXISTS task_outputs (
+                    task_id TEXT PRIMARY KEY,
+                    output JSON,
+                    task_index INTEGER,
+                    inputs JSON,
+                    was_replayed BOOLEAN,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
                 )
-                conn.commit()
+            """
+            )
+            conn.commit()
 
-        except sqlite3.Error as e:
-            self._logger.log(level="error", message=f"DATABASE INITIALIZATION ERROR: {e}", color="red")
+        # except sqlite3.Error as e:
+        #     self._logger.log(level="error", message=f"DATABASE INITIALIZATION ERROR: {e}", color="red")
 
 
     def add(self, task, output: Dict[str, Any], task_index: int, was_replayed: bool = False, inputs: Dict[str, Any] = {}):
@@ -81,13 +79,12 @@ class TaskOutputSQLiteStorage:
         try:
             with sqlite3.connect(self.db_path) as conn:
                 cursor = conn.cursor()
-
                 fields, values = [], []
                 for k, v in kwargs.items():
                     fields.append(f"{k} = ?")
                     values.append(json.dumps(v) if isinstance(v, dict) else v)
 
-                query = f"UPDATE latest_kickoff_task_outputs SET {', '.join(fields)} WHERE task_index = ?"  # nosec
+                query = f"UPDATE latest_kickoff_task_outputs SET {', '.join(fields)} WHERE task_index = ?"
                 values.append(task_index)
                 cursor.execute(query, tuple(values))
                 conn.commit()

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/src/versionhq/task/model.py

@@ -206,10 +206,10 @@ Your outputs MUST adhere to the following format and should NOT include any irre
     @property
     def summary(self) -> str:
         return f"""
-        Task: {self.id} - {self.description}
-        "task_description": {self.description}
-        "task_expected_output": {self.output_prompt}
-        "task_tools": {", ".join([tool_called.tool.name for tool_called in self.tools_called])}
+        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])}
         """
 
 
@@ -382,11 +382,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         """
 
         future: Future[TaskOutput] = Future()
-        threading.Thread(
-            daemon=True,
-            target=self._execute_task_async,
-            args=(agent, context, tools, future),
-        ).start()
+        threading.Thread(daemon=True, target=self._execute_task_async, args=(agent, context, tools, future)).start()
         return future
 
 
@@ -403,7 +399,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
@@ -414,8 +410,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:

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/src/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):
     """
@@ -123,7 +126,7 @@ class Team(BaseModel):
     __hash__ = object.__hash__
     _execution_span: Any = PrivateAttr()
     _logger: Logger = PrivateAttr()
-    # _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
+    _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None)
@@ -165,34 +168,47 @@ class Team(BaseModel):
 
 
     @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
+    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_task(self) -> Task:
+    def manager_tasks(self) -> List[Task] | None:
         """
-        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.
+        Tasks (incl. team tasks) handled by managers in the team.
         """
-        task = [member.task for member in self.members if member.is_manager == True]
-        return task[0] if len(task) > 0 else None
+        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,
+        1. team tasks, -> assigned to the member
         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
+
+        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
 
 
-    # validators
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -201,6 +217,21 @@ class Team(BaseModel):
             raise PydanticCustomError("may_not_set_field", "The 'id' field cannot be set by the user.", {})
 
 
+    @model_validator(mode="after")
+    def validate_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 +239,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", f"Sequential process error: Agent is missing the task", {})
         return self
 
     @model_validator(mode="after")
@@ -249,7 +272,9 @@ 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
@@ -262,21 +287,54 @@ class Team(BaseModel):
             )
         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 +391,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 +426,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,19 +437,18 @@ 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:
+                task_output = task.execute_sync(agent=responsible_agent, context=context, tools=responsible_agent.tools)
+                if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 
                 task_outputs.append(task_output)
                 # self._process_task_result(task, task_output)
-                task._store_execution_log(task_index, was_replayed)
+                task._store_execution_log(task_index, was_replayed, self._inputs)
 
 
         if futures:
@@ -401,15 +460,16 @@ 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:

versionhq-1.1.8.1/src/versionhq/team/team_planner.py

@@ -0,0 +1,93 @@
+import os
+from dotenv import load_dotenv
+from typing import Any, List, Optional
+from pydantic import BaseModel, Field
+
+load_dotenv(override=True)
+
+
+class TeamPlanner:
+    """
+    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 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,
+        )
+
+        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.
+        """
+
+        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 = 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.
+
+                Task summaries: {" ".join(task_summary_list)}
+             """,
+            expected_output_json=False,
+            expected_output_pydantic=True,
+            output_field_list=[
+                ResponseField(title="task", type=str, required=True)
+                for task in self.tasks
+            ],
+        )
+        output = task.execute_sync(agent=team_planner, context=context, tools=tools)
+        return output

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/src/versionhq/tool/model.py

@@ -137,7 +137,6 @@ class Tool(ABC, BaseModel):
         The response will be cascaded to the Task and stored in the TaskOutput.
         """
 
-        print(f"Using the tool: {self.name}")
         result = None
 
         if self.func is not None:

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/src/versionhq.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.7.9
+Version: 1.1.8.1
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/tests/task/task_test.py

@@ -277,4 +277,11 @@ def test_conditional_task():
         assert conditional_res.task_id is conditional_task.id
 
 
+def test_store_task_log():
+    task = Task(
+        description="Analyze the client's business model.",
+        output_field_list=[ResponseField(title="task_1", type=str, required=True),],
+    )
+    assert task._task_output_handler.load() is not None
+
 # tools, token usage

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/tests/team/team_test.py

@@ -1,5 +1,4 @@
 import os
-from pydantic import BaseModel
 
 from versionhq.agent.model import Agent
 from versionhq.task.model import Task, ResponseField, TaskOutput
@@ -61,8 +60,8 @@ def test_form_team():
     assert team.id is not None
     assert team.key is not None
     assert isinstance(team.key, str)
-    assert team.manager_agent is not None
-    assert team.manager_task.id is task_1.id
+    assert team.managers is not None
+    assert task_1 in team.manager_tasks
     assert len(team.tasks) == 2
     for item in team.tasks:
         assert item.id is task_1.id or item.id is task_2.id
@@ -120,35 +119,24 @@ def test_form_team_without_leader():
     assert team.id is not None
     assert team.key is not None
     assert isinstance(team.key, str)
-    assert team.manager_agent is None
-    assert team.manager_task is None
+    assert team.managers is None
+    assert team.manager_tasks is None
     assert len(team.tasks) == 2
     for item in team.tasks:
         assert item.id is task_1.id or item.id is task_2.id
 
 
-def test_kickoff_team_without_leader():
-    agent_a = Agent(
-        role="agent a",
-        goal="My amazing goals",
-        llm=MODEL_NAME
-    )
-
-    agent_b = Agent(
-        role="agent b",
-        goal="My amazing goals",
-        llm=MODEL_NAME
-    )
-
+def test_kickoff_without_leader():
+    agent_a = Agent(role="agent a", goal="My amazing goals", llm=MODEL_NAME)
+    agent_b = Agent(role="agent b", goal="My amazing goals", llm=MODEL_NAME)
     task_1 = Task(
-            description="Analyze the client's business model.",
-            expected_output_json=True,
-            output_field_list=[
-                ResponseField(title="test1", type=str, required=True),
-                ResponseField(title="test2", type=list, required=True),
-            ],
+        description="Analyze the client's business model.",
+        expected_output_json=True,
+        output_field_list=[
+            ResponseField(title="test1", type=str, required=True),
+            ResponseField(title="test2", type=list, required=True),
+        ],
     )
-
     task_2 = Task(
         description="Define the cohort.",
         expected_output_json=True,
@@ -157,7 +145,6 @@ def test_kickoff_team_without_leader():
             ResponseField(title="test2", type=list, required=True),
         ],
     )
-
     team = Team(
         members=[
             TeamMember(agent=agent_a, is_manager=False, task=task_1),
@@ -185,7 +172,6 @@ def test_kickoff_team_without_leader():
     assert res.token_usage.total_tokens == 0 # as we dont set token usage on agent
 
 
-
 def team_kickoff_with_task_callback():
     """
     Each task has callback with callback kwargs.
@@ -236,7 +222,6 @@ def team_kickoff_with_task_callback():
     assert "pytest" in demo_list[1]
 
 
-
 def test_delegate_in_team():
     """
     When the agent belongs to the team, the team manager or peers are prioritized to delegete the task.
@@ -279,7 +264,151 @@ def test_delegate_in_team():
     assert "agent b" in task_1.processed_by_agents
 
 
+def test_kickoff_with_leader():
+    agent_a = Agent(role="agent a", goal="My amazing goals", llm=MODEL_NAME)
+    agent_b = Agent(role="agent b", goal="My amazing goals", llm=MODEL_NAME)
+    task_1 = Task(
+        description="Analyze the client's business model.",
+        output_field_list=[ResponseField(title="task_1", type=str, required=True),],
+    )
+    task_2 = Task(
+        description="Define the cohort timeframe.",
+        output_field_list=[
+            ResponseField(title="task_2_1", type=int, required=True),
+            ResponseField(title="task_2_2", type=list, required=True),
+        ],
+    )
+    team = Team(
+        members=[
+            TeamMember(agent=agent_a, is_manager=False, task=task_1),
+            TeamMember(agent=agent_b, is_manager=True, task=task_2),
+        ],
+    )
+    res = team.kickoff()
+
+    assert isinstance(res, TeamOutput)
+    assert res.team_id is team.id
+    assert res.raw is not None
+    assert res.json_dict is not None
+    assert team.managers[0].agent.id is agent_b.id
+    assert len(res.task_output_list) == 2
+    assert [item.raw is not None for item in res.task_output_list]
+    assert len(team.tasks) == 2
+    assert team.tasks[0].output.raw == res.raw
+
+
+def test_hierarchial_process():
+    """
+    Manager to handle the top priority task first.
+    """
+
+    agent_a = Agent(role="agent a", goal="My amazing goals", llm=MODEL_NAME)
+    agent_b = Agent(role="agent b", goal="My amazing goals", llm=MODEL_NAME)
+    agent_c = Agent(role="agent c", goal="My amazing goals", llm=MODEL_NAME)
+    task_1 = Task(
+        description="Analyze the client's business model.",
+        output_field_list=[ResponseField(title="task_1", type=str, required=True),],
+    )
+    task_2 = Task(
+        description="Define the cohort timeframe.",
+        output_field_list=[
+            ResponseField(title="task_2_1", type=int, required=True),
+            ResponseField(title="task_2_2", type=list, required=True),
+        ],
+    )
+    team = Team(
+        members=[
+            TeamMember(agent=agent_a, is_manager=False, task=task_1),
+            TeamMember(agent=agent_b, is_manager=True, task=task_2),
+            TeamMember(agent=agent_c, is_manager=False)
+        ],
+        process=TaskHandlingProcess.hierarchical
+    )
+    res = team.kickoff()
+
+    assert isinstance(res, TeamOutput)
+    assert res.team_id is team.id
+    assert res.raw is not None
+    assert res.json_dict is not None
+    assert team.managers[0].agent.id is agent_b.id
+    assert len(res.task_output_list) == 2
+    assert [item.raw is not None for item in res.task_output_list]
+    assert len(team.tasks) == 2
+    assert team.tasks[0].output.raw == res.raw
+
+
+def test_handle_team_task():
+    """
+    Make the best team formation with agents and tasks given.
+    """
+
+    agent_a = Agent(role="agent a", goal="My amazing goals", llm=MODEL_NAME)
+    agent_b = Agent(role="agent b", goal="My amazing goals", llm=MODEL_NAME)
+    agent_c = Agent(role="agent c", goal="My amazing goals", llm=MODEL_NAME)
+    team_task = Task(
+        description="Define outbound strategies.",
+        output_field_list=[ResponseField(title="team_task_1", type=str, required=True),],
+    )
+    task_1 = Task(
+        description="Analyze the client's business model.",
+        output_field_list=[ResponseField(title="task_1", type=str, required=True),],
+    )
+    task_2 = Task(
+        description="Define the cohort timeframe.",
+        output_field_list=[
+            ResponseField(title="task_2_1", type=int, required=True),
+            ResponseField(title="task_2_2", type=list, required=True),
+        ],
+    )
+    team_solo = Team(
+        members=[
+            TeamMember(agent=agent_c, is_manager=False)
+        ],
+        team_tasks=[team_task, task_1, task_2, ]
+    )
+    team_flat =  Team(
+        members=[
+            TeamMember(agent=agent_a, is_manager=False, task=task_1),
+            TeamMember(agent=agent_c, is_manager=False)
+        ],
+        team_tasks=[team_task, task_2,]
+    )
+    team_leader =  Team(
+        members=[
+            TeamMember(agent=agent_a, is_manager=False, task=task_1),
+            TeamMember(agent=agent_b, is_manager=True, task=task_2),
+            TeamMember(agent=agent_c, is_manager=False)
+        ],
+        team_tasks=[team_task, ]
+    )
+    team_dual_leaders =  Team(
+        members=[
+            TeamMember(agent=agent_a, is_manager=False, task=task_1),
+            TeamMember(agent=agent_b, is_manager=True, task=task_2),
+            TeamMember(agent=agent_c, is_manager=True)
+        ],
+        team_tasks=[team_task, ]
+    )
+    team_leader_without_task =  Team(
+        members=[
+            TeamMember(agent=agent_a, is_manager=False, task=task_1),
+            TeamMember(agent=agent_b, is_manager=False, task=task_2),
+            TeamMember(agent=agent_c, is_manager=True)
+        ],
+        team_tasks=[team_task,]
+    )
+    teams = [team_solo, team_flat, team_leader, team_dual_leaders, team_leader_without_task]
+
+    for team in teams:
+        res = team.kickoff()
+        assert team._get_responsible_agent(task=team_task) is not None
+        assert isinstance(res, TeamOutput)
+        assert res.team_id is team.id
+        assert team.tasks[0].id is team_task.id
+        assert res.raw is not None
+        assert len(team.members) == 3
+        assert len(team.tasks) == 3
+
 
 if __name__ == "__main__":
-    test_kickoff_team_without_leader()
-# kickoff with teamleader, async, task handling process
+    test_handle_team_task()

{versionhq-1.1.7.9 → versionhq-1.1.8.1}/uv.lock

@@ -1644,7 +1644,7 @@ wheels = [
 
 [[package]]
 name = "versionhq"
-version = "1.1.7.8"
+version = "1.1.8.1"
 source = { editable = "." }
 dependencies = [
     { name = "appdirs" },

versionhq-1.1.7.9/src/versionhq/team/team_planner.py

@@ -1,55 +0,0 @@
-import os
-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.
-    """
-
-    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")
-        )
-
-    def _handle_task_planning(self) -> BaseModel:
-        """
-        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.",
-            llm=self.planner_llm,
-        )
-
-        task_summary_list = [task.summary for task in self.tasks]
-        task_to_handle = 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.
-
-                Task summaries: {" ".join(task_summary_list)}
-             """,
-            expected_output_json=False,
-            expected_output_pydantic=True,
-            output_field_list=[
-                ResponseField(title=f"{task.id}", 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