versionhq 1.2.0.4__py3-none-any.whl → 1.2.1.1__py3-none-any.whl

versionhq/__init__.py

@@ -8,6 +8,7 @@ from dotenv import load_dotenv
 load_dotenv(override=True)
 
 from versionhq.agent.model import Agent
+from versionhq.agent_network.model import AgentNetwork, NetworkOutput, Formation, Member, TaskHandlingProcess
 from versionhq.llm.model import LLM
 from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES, PARAMS, PROVIDERS, MODELS
 from versionhq.clients.customer.model import Customer
@@ -16,10 +17,9 @@ from versionhq.clients.workflow.model import MessagingWorkflow, MessagingCompone
 from versionhq.knowledge.model import Knowledge, KnowledgeStorage
 from versionhq.knowledge.source import PDFKnowledgeSource, CSVKnowledgeSource, JSONKnowledgeSource, TextFileKnowledgeSource, ExcelKnowledgeSource, StringKnowledgeSource
 from versionhq.knowledge.source_docling import DoclingSource
-from versionhq.network.model import TaskStatus, TaskGraph, Node, Edge, DependencyType
+from versionhq.task_graph.model import TaskStatus, TaskGraph, Node, Edge, DependencyType
 from versionhq.task.model import Task, TaskOutput, ResponseField, TaskExecutionType
 from versionhq.task.evaluate import Evaluation, EvaluationItem
-from versionhq.team.model import Team, TeamOutput, Formation, Member, TaskHandlingProcess
 from versionhq.tool.model import Tool, ToolSet
 from versionhq.tool.cache_handler import CacheHandler
 from versionhq.tool.tool_handler import ToolHandler
@@ -30,10 +30,16 @@ from versionhq.memory.model import ShortTermMemory,LongTermMemory, UserMemory, M
 from versionhq.task.formation import form_agent_network
 
 
-__version__ = "1.2.0.4"
+__version__ = "1.2.1.1"
 __all__ = [
     "Agent",
 
+    "AgentNetwork",
+    "NetworkOutput",
+    "Formation",
+    "Member",
+    "TaskHandlingProcess",
+
     "LLM",
     "LLM_CONTEXT_WINDOW_SIZES",
     "PARAMS",
@@ -70,12 +76,6 @@ __all__ = [
     "Evaluation",
     "EvaluationItem",
 
-    "Team",
-    "TeamOutput",
-    "Formation",
-    "Member",
-    "TaskHandlingProcess",
-
     "Tool",
     "ToolSet",
     "CacheHandler",

versionhq/_utils/logger.py

@@ -38,7 +38,7 @@ class Printer:
 class Logger(BaseModel):
     """
     Control CLI messages.
-    Color: red = error, yellow = warning, blue = info (from vhq), green = info (from third party)
+    Color: red = error, yellow = warning, blue = info (from vhq), green = info (from third parties)
     """
 
     verbose: bool = Field(default=True)

versionhq/agent/inhouse_agents.py

@@ -39,3 +39,10 @@ vhq_formation_planner = Agent(
         "Random is a formation where a single agent handles tasks, asking help from other agents without sharing its memory or knowledge. Typical usecase is that an email agent drafts promo message for the given audience, asking insights on tones from other email agents which oversee other customer clusters, or an agent calls the external, third party agent to deploy the campaign. ",
     ]
 )
+
+
+vhq_agent_creator = Agent(
+    role="vhq-Agent Creator",
+    goal="build an agent that can handle the given task",
+    llm="gemini/gemini-2.0-flash-exp",
+)

versionhq/agent/model.py

@@ -95,7 +95,7 @@ class Agent(BaseModel):
     user_prompt_template: Optional[str] = Field(default=None, description="user prompt template")
 
     # task execution rules
-    team: Optional[List[Any]] = Field(default=None, description="Team to which the agent belongs")
+    network: Optional[List[Any]] = Field(default=None, description="store a list of agent networks that the agent belong as a member")
     allow_delegation: bool = Field(default=False,description="if the agent can delegate the task to another agent or ask some help")
     max_retry_limit: int = Field(default=2 ,description="max. number of retry for the task execution when an error occurs")
     maxit: Optional[int] = Field(default=25,description="max. number of total optimization loops conducted when an error occurs")
@@ -553,7 +553,7 @@ class Agent(BaseModel):
 
 
         ## comment out for now
-        # if self.team and self.team._train:
+        # if self.network and self.network._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
         # else:
         #     task_prompt = self._use_trained_data(task_prompt=task_prompt)

versionhq/{team → agent_network}/model.py

@@ -1,7 +1,6 @@
 import uuid
 import warnings
 from enum import Enum
-from dotenv import load_dotenv
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Callable, Optional, Tuple
@@ -10,9 +9,8 @@ from pydantic._internal._generate_schema import GenerateSchema
 from pydantic_core import PydanticCustomError, core_schema
 
 from versionhq.agent.model import Agent
-from versionhq.task.model import Task, TaskOutput, TaskExecutionType
+from versionhq.task.model import Task, TaskOutput, TaskExecutionType, ResponseField
 from versionhq.task.formatter import create_raw_outputs
-from versionhq.team.team_planner import TeamPlanner
 from versionhq._utils.logger import Logger
 from versionhq._utils.usage_metrics import UsageMetrics
 
@@ -27,73 +25,62 @@ def match_type(self, obj):
 
 GenerateSchema.match_type = match_type
 warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
-load_dotenv(override=True)
-
-# agentops = None
-# if os.environ.get("AGENTOPS_API_KEY"):
-#     try:
-#         import agentops  # type: ignore
-#     except ImportError:
-#         pass
-
 
 
 class Formation(str, Enum):
     UNDEFINED = 0
     SOLO = 1
     SUPERVISING = 2
-    NETWORK = 3
+    SQUAD = 3
     RANDOM = 4
     HYBRID = 10
 
 
 class TaskHandlingProcess(str, Enum):
     """
-    Class representing the different processes that can be used to tackle multiple tasks.
+    A class representing task handling processes to tackle multiple tasks.
+    When the agent network has multiple tasks that connect with edges, follow the edge conditions.
     """
-    sequential = "sequential"
-    hierarchical = "hierarchical"
-    consensual = "consensual"
+    SEQUENT = 1
+    HIERARCHY = 2
+    CONSENSUAL = 3 # either from managers or peers or (human) - most likely controlled by edge
 
 
-class TeamOutput(TaskOutput):
+class NetworkOutput(TaskOutput):
     """
-    A class to store output from the team, inherited from TaskOutput class.
+    A class to store output from the network, inherited from TaskOutput class.
     """
 
-    team_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store the team ID that generate the TeamOutput")
+    network_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store the network ID as an identifier that generate the output")
     task_description: str = Field(default=None, description="store initial request (task description) from the client")
-    task_outputs: list[TaskOutput] = Field(default=list, description="store outputs of all tasks that the team has executed")
-    token_usage: UsageMetrics = Field(default=dict, description="processed token summary")
-
+    task_outputs: list[TaskOutput] = Field(default=list, description="store TaskOutput objects of all tasks that the network has executed")
+    # token_usage: UsageMetrics = Field(default=dict, description="processed token summary")
 
     def return_all_task_outputs(self) -> List[Dict[str, Any]]:
         res = [output.json_dict for output in self.task_outputs]
         return res
 
-
     def __str__(self):
         return (str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw)
 
-
     def __getitem__(self, key):
         if self.pydantic and hasattr(self.pydantic, key):
             return getattr(self.pydantic, key)
         elif self.json_dict and key in self.json_dict:
             return self.json_dict[key]
         else:
-            raise KeyError(f"Key '{key}' not found in the team output.")
+            raise KeyError(f"Key '{key}' not found in the output.")
 
 
 
 class Member(BaseModel):
     """
-    A class to store a member in the network and connect the agent as a member with tasks and sharable settings.
+    A class to store a member (agent) in the network, with its tasks and memory/knowledge share settings.
     """
     agent: Agent | None = Field(default=None)
     is_manager: bool = Field(default=False)
-    can_share_knowledge: bool = Field(default=True, description="whether to share the agent's knowledge in the team")
-    can_share_memory: bool = Field(default=True, description="whether to share the agent's memory in the team")
+    can_share_knowledge: bool = Field(default=True, description="whether to share the agent's knowledge in the network")
+    can_share_memory: bool = Field(default=True, description="whether to share the agent's memory in the network")
     tasks: Optional[List[Task]] = Field(default_factory=list, description="tasks explicitly assigned to the agent")
 
     @property
@@ -101,9 +88,10 @@ class Member(BaseModel):
         return bool(self.tasks)
 
 
-class Team(BaseModel):
+class AgentNetwork(BaseModel):
     """
-    A class to store agent network that shares knowledge, memory and tools among the members.
+    A class to store a agent network with agent members and their tasks.
+    Tasks can be 1. multiple individual tasks, 2. multiple dependant tasks connected via TaskGraph, and 3. hybrid.
     """
 
     __hash__ = object.__hash__
@@ -118,21 +106,20 @@ class Team(BaseModel):
     should_reform: bool = Field(default=False, description="True if task exe. failed or eval scores below threshold")
 
     # formation planning
-    planner_llm: Optional[Any] = Field(default=None, description="llm to generate and evaluate formation")
-    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="tasks without dedicated agents to handle")
+    network_tasks: Optional[List[Task]] = Field(default_factory=list, description="tasks without dedicated agents")
 
     # task execution rules
     prompt_file: str = Field(default="", description="absolute path to the prompt json file")
-    process: TaskHandlingProcess = Field(default=TaskHandlingProcess.sequential)
+    process: TaskHandlingProcess = Field(default=TaskHandlingProcess.SEQUENT)
 
     # callbacks
     pre_launch_callbacks: List[Callable[[Optional[Dict[str, Any]]], Optional[Dict[str, Any]]]] = Field(
         default_factory=list,
-        description="list of callback functions to be executed before the team launch. i.e., adjust inputs"
+        description="list of callback functions to be executed before the network launch. i.e., adjust inputs"
     )
-    post_launch_callbacks: List[Callable[[TeamOutput], TeamOutput]] = Field(
+    post_launch_callbacks: List[Callable[[NetworkOutput], NetworkOutput]] = Field(
         default_factory=list,
-        description="list of callback functions to be executed after the team launch. i.e., store the result in repo"
+        description="list of callback functions to be executed after the network launch. i.e., store the result in repo"
     )
     step_callback: Optional[Any] = Field(default=None, description="callback to be executed after each step for all agents execution")
 
@@ -156,39 +143,37 @@ class Team(BaseModel):
     @model_validator(mode="after")
     def assess_tasks(self):
         """
-        Validates if the model recognize all tasks that the team needs to handle.
+        Validates if the model recognize all tasks that the network 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 all(task in self.tasks for task in self.network_tasks) == False:
+                raise PydanticCustomError("task_validation_error", "`network_tasks` needs to be recognized in the task.", {})
 
 
             num_member_tasks = 0
             for member in self.members:
                 num_member_tasks += len(member.tasks)
 
-            # if len(self.tasks) != len(self.team_tasks) + num_member_tasks:
+            # if len(self.tasks) != len(self.network_tasks) + num_member_tasks:
             #     raise PydanticCustomError("task_validation_error", "Some tasks are missing.", {})
         return self
 
 
     @model_validator(mode="after")
-    def check_manager_llm(self):
+    def check_manager(self):
         """
-        Check if the team has a manager
+        Check if the agent network has a manager
         """
-
-        if self.process == TaskHandlingProcess.hierarchical or self.formation == Formation.SUPERVISING:
+        if self.process == TaskHandlingProcess.HIERARCHY or self.formation == Formation.SUPERVISING:
             if not self.managers:
                 self._logger.log(level="error", message="The process or formation created needs at least 1 manager agent.", color="red")
-                raise PydanticCustomError(
-                    "missing_manager_llm_or_manager","Attribute `manager_llm` or `manager` is required when using hierarchical process.", {})
+                raise PydanticCustomError("missing_manager", "`manager` is required when using hierarchical process.", {})
 
-            ## comment out for the formation flexibilities
-            # if self.managers and (self.manager_tasks is None or self.team_tasks is None):
-            #     self._logger.log(level="error", message="The manager is idling. At least 1 task needs to be assigned to the manager.", color="red")
-            #     raise PydanticCustomError("missing_manager_task", "manager needs to have at least one manager task or team task.", {})
+        ## comment out for the formation flexibilities
+        # if self.managers and (self.manager_tasks is None or self.network_tasks is None):
+        #     self._logger.log(level="error", message="The manager is idling. At least 1 task needs to be assigned to the manager.", color="red")
+        #     raise PydanticCustomError("missing_manager_task", "manager needs to have at least one manager task or network task.", {})
 
         return self
 
@@ -196,9 +181,9 @@ class Team(BaseModel):
     @model_validator(mode="after")
     def validate_task_member_paring(self):
         """
-        Sequential task processing without any team tasks require a task-agent pairing.
+        Sequential task processing without any network_tasks require a task-agent pairing.
         """
-        if self.process == TaskHandlingProcess.sequential and self.team_tasks is None:
+        if self.process == TaskHandlingProcess.SEQUENT and self.network_tasks is None:
             for task in self.tasks:
                 if not [member.task == task for member in self.members]:
                     self._logger.log(level="error", message=f"The following task needs a dedicated agent to be assinged: {task.description}", color="red")
@@ -208,7 +193,7 @@ class Team(BaseModel):
     @model_validator(mode="after")
     def validate_end_with_at_most_one_async_task(self):
         """
-        Validates that the team completes max. one asynchronous task by counting tasks traversed backward
+        Validates that the agent network completes max. one asynchronous task by counting tasks traversed backward
         """
 
         async_task_count = 0
@@ -221,10 +206,43 @@ class Team(BaseModel):
                 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 agent network must end with at maximum one asynchronous task.", {})
         return self
 
 
+    @staticmethod
+    def handle_assigning_agents(unassigned_tasks: List[Task]) -> List[Member]:
+        """
+        Build an agent and assign it with a task. Return a list of Member connecting the agent created and the task given.
+        """
+
+        from versionhq.agent.inhouse_agents import vhq_agent_creator
+
+        new_member_list: List[Member] = []
+
+        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}
+                """,
+                response_fields=[
+                    ResponseField(title="goal", data_type=str, required=True),
+                    ResponseField(title="role", data_type=str, required=True),
+                ],
+            )
+            res = task.execute(agent=vhq_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:
+                member = Member(agent=agent, tasks=[unassgined_task], is_manager=False)
+                new_member_list.append(member)
+
+        return new_member_list
+
+
     def _get_responsible_agent(self, task: Task) -> Agent | None:
         if task is None:
             return None
@@ -238,17 +256,16 @@ class Team(BaseModel):
 
     def _assign_tasks(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.
+        Form a agent network considering given agents and tasks, and update `self.members` field:
+            1. Idling managers to take the network tasks.
+            2. Idling members to take the remaining tasks starting from the network tasks to member tasks.
             3. Create agents to handle the rest tasks.
         """
 
-        team_planner = TeamPlanner(tasks=self.tasks, planner_llm=self.planner_llm)
         idling_managers: List[Member] = [member for member in self.members if member.is_idling and member.is_manager == True]
         idling_members: List[Member] =  [member for member in self.members if member.is_idling and member.is_manager == False]
-        unassigned_tasks: List[Task] = self.team_tasks + self.member_tasks_without_agent if self.team_tasks else self.member_tasks_without_agent
-        new_team_members: List[Member] = []
+        unassigned_tasks: List[Task] = self.network_tasks + self.member_tasks_without_agent if self.network_tasks else self.member_tasks_without_agent
+        new_members: List[Member] = []
 
         if idling_managers:
             idling_managers[0].tasks.extend(unassigned_tasks)
@@ -257,9 +274,9 @@ class Team(BaseModel):
             idling_members[0].tasks.extend(unassigned_tasks)
 
         else:
-            new_team_members = team_planner._handle_assign_agents(unassigned_tasks=unassigned_tasks)
-            if new_team_members:
-                self.members += new_team_members
+            new_members = self.handle_assigning_agents(unassigned_tasks=unassigned_tasks)
+            if new_members:
+                self.members += new_members
 
 
     # task execution
@@ -278,34 +295,9 @@ class Team(BaseModel):
         return task_outputs
 
 
-    def _create_team_output(self, task_outputs: List[TaskOutput], lead_task_output: TaskOutput = None) -> TeamOutput:
-        """
-        Take the output of the first task or the lead task output as the team output `raw` value.
-        Note that `tasks` are already sorted by the importance.
-        """
-
-        if not task_outputs:
-            self._logger.log(level="error", message="Missing task outcomes. Failed to launch the task.", color="red")
-            raise ValueError("Failed to launch tasks")
-
-        final_task_output = lead_task_output if lead_task_output is not None else task_outputs[0] #! REFINEME
-        # final_string_output = final_task_output.raw
-        # self._finish_execution(final_string_output)
-        token_usage = self._calculate_usage_metrics()
-
-        return TeamOutput(
-            team_id=self.id,
-            raw=final_task_output.raw,
-            json_dict=final_task_output.json_dict,
-            pydantic=final_task_output.pydantic,
-            task_outputs=task_outputs,
-            token_usage=token_usage,
-        )
-
-
     def _calculate_usage_metrics(self) -> UsageMetrics:
         """
-        Calculate and return the usage metrics that consumed by the team.
+        Calculate and return the usage metrics that consumed by the agent network.
         """
         total_usage_metrics = UsageMetrics()
 
@@ -325,12 +317,12 @@ class Team(BaseModel):
         return total_usage_metrics
 
 
-    def _execute_tasks(self, tasks: List[Task], start_index: Optional[int] = 0, was_replayed: bool = False) -> TeamOutput:
+    def _execute_tasks(self, tasks: List[Task], start_index: Optional[int] = 0, was_replayed: bool = False) -> NetworkOutput:
         """
-        Executes tasks sequentially and returns the final output in TeamOutput class.
+        Executes tasks sequentially and returns the final output in NetworkOutput class.
         When we have a manager agent, we will start from executing manager agent's tasks.
         Priority:
-        1. Team tasks > 2. Manager task > 3. Member tasks (in order of index)
+        1. Network tasks > 2. Manager task > 3. Member tasks (in order of index)
         """
 
         task_outputs: List[TaskOutput] = []
@@ -367,52 +359,58 @@ class Team(BaseModel):
             else:
                 context = create_raw_outputs(tasks=[task,], task_outputs=([last_sync_output,] if last_sync_output else [] ))
                 task_output = task.execute(agent=responsible_agent, context=context)
+
                 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, self._inputs)
 
 
         if futures:
             task_outputs = self._process_async_tasks(futures, was_replayed)
 
-        return self._create_team_output(task_outputs, lead_task_output)
+        if not task_outputs:
+            self._logger.log(level="error", message="Missing task outputs.", color="red")
+            raise ValueError("Missing task outputs")
+
+        final_task_output = lead_task_output if lead_task_output is not None else task_outputs[0] #! REFINEME
 
+        # token_usage = self._calculate_usage_metrics() #! combining with Eval
 
-    def launch(self, kwargs_pre: Optional[Dict[str, str]] = None, kwargs_post: Optional[Dict[str, Any]] = None) -> TeamOutput:
+        return NetworkOutput(
+            network_id=self.id,
+            raw=final_task_output.raw,
+            json_dict=final_task_output.json_dict,
+            pydantic=final_task_output.pydantic,
+            task_outputs=task_outputs,
+            # token_usage=token_usage,
+        )
+
+
+    def launch(self, kwargs_pre: Optional[Dict[str, str]] = None, kwargs_post: Optional[Dict[str, Any]] = None) -> NetworkOutput:
         """
-        Confirm and launch the formation - execute tasks and record outputs.
-        0. Assign an agent to a task - using conditions (manager prioritizes team_tasks) and planner_llm.
-        1. Address `pre_launch_callbacks` if any.
-        2. Handle team members' tasks in accordance with the process.
-        3. Address `post_launch_callbacks` if any.
+        Launch the agent network - executing tasks and recording their outputs.
         """
 
         metrics: List[UsageMetrics] = []
 
-        if self.team_tasks or self.member_tasks_without_agent:
+        if self.network_tasks or self.member_tasks_without_agent:
             self._assign_tasks()
 
         if kwargs_pre is not None:
             for func in self.pre_launch_callbacks:
                 func(**kwargs_pre)
 
-        # self._execution_span = self._telemetry.team_execution_span(self, inputs)
-        # self._task_output_handler.reset()
-        # self._logging_color = "bold_purple"
-        # i18n = I18N(prompt_file=self.prompt_file)
-
         for member in self.members:
             agent = member.agent
-            agent.team = self
+            agent.network = self
 
             if self.step_callback:
                 agent.callbacks.append(self.step_callback)
 
         if self.process is None:
-            self.process = TaskHandlingProcess.sequential
+            self.process = TaskHandlingProcess.SEQUENT
 
         result = self._execute_tasks(self.tasks)
 
@@ -443,7 +441,7 @@ class Team(BaseModel):
     @property
     def manager_tasks(self) -> List[Task]:
         """
-        Tasks (incl. team tasks) handled by managers in the team.
+        Tasks (incl. network tasks) handled by managers in the agent network.
         """
         res = list()
 
@@ -458,22 +456,22 @@ class Team(BaseModel):
     @property
     def tasks(self) -> List[Task]:
         """
-        Return all the tasks that the team needs to handle in order of priority:
-        1. team tasks, -> assigned to the member
+        Return all the tasks that the agent network needs to handle in order of priority:
+        1. network_tasks, -> assigned to the member
         2. manager_task,
         3. members' tasks
         """
 
-        team_tasks = self.team_tasks
+        network_tasks = self.network_tasks
         manager_tasks = self.manager_tasks
         member_tasks = []
 
         for member in self.members:
             if member.is_manager == False and member.tasks:
-                a = [item for item in member.tasks if item not in team_tasks and item not in manager_tasks]
+                a = [item for item in member.tasks if item not in network_tasks and item not in manager_tasks]
                 member_tasks += a
 
-        return team_tasks + manager_tasks + member_tasks
+        return network_tasks + manager_tasks + member_tasks
 
 
     @property

versionhq/clients/workflow/model.py

@@ -1,7 +1,7 @@
 import uuid
 from abc import ABC
-from datetime import date, datetime, time, timedelta
-from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+from datetime import datetime
+from typing import Any, Dict, List, Optional
 from typing_extensions import Self
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 from pydantic_core import PydanticCustomError
@@ -9,7 +9,7 @@ from pydantic_core import PydanticCustomError
 from versionhq.clients.product.model import Product
 from versionhq.clients.customer.model import Customer
 from versionhq.agent.model import Agent
-from versionhq.team.model import Team
+from versionhq.agent_network.model import AgentNetwork
 from versionhq.tool.composio_tool_vars import ComposioAppName
 
 
@@ -102,8 +102,8 @@ class MessagingWorkflow(ABC, BaseModel):
     messaging_components: List[MessagingComponent] = Field(default_factory=list, description="store messaging components in the workflow")
 
     # responsible tean or agents
-    team: Optional[Team] = Field(default=None, description="store a responsibile team to autopilot the workflow")
-    agents: Optional[List[Agent]] = Field(default=None, description="store responsible agents. None when the team exists")
+    agent_network: Optional[AgentNetwork] = Field(default=None, description="store a responsibile agent network to autopilot the workflow")
+    agents: Optional[List[Agent]] = Field(default=None, description="store responsible agents. None when the `agent_network` fields has a value")
 
     # metrics
     destination: Optional[ComposioAppName | str] = Field(default=None, description="destination service to launch the workflow")
@@ -140,16 +140,16 @@ class MessagingWorkflow(ABC, BaseModel):
         return self
 
 
-    def reassign_agent_or_team(self, agents: List[Agent] = None, team: Team = None) -> None:
+    def reassign_agent(self, agents: List[Agent] = None, agent_network: AgentNetwork = None) -> None:
         """
-        Fire unresponsible agents/team and assign new one.
+        Switch agents
         """
 
-        if not agents and not team:
-            raise ValueError("Need to add at least 1 agent or team.")
+        if not agents and not agent_network:
+            raise ValueError("Missing agent or agent network to assign.")
 
         self.agents = agents
-        self.team = team
+        self.agent_network = agent_network
         self.updated_at = datetime.datetime.now()
 
 

versionhq/knowledge/source.py

@@ -265,7 +265,7 @@ class PDFKnowledgeSource(BaseFileKnowledgeSource):
                 import os
                 os.system("uv add pdfplumber --optional pdfplumber")
             except:
-                raise ImportError("pdfplumber is not installed. Please install it with: uv add pdfplumber --optional pdfplumber")
+                raise ImportError("pdfplumber is not installed. Please install it with: $ uv add versionhq[pdfplumber]")
 
 
     def add(self) -> None:
@@ -394,7 +394,7 @@ class ExcelKnowledgeSource(BaseFileKnowledgeSource):
             except:
                 missing_package = str(e).split()[-1]
                 raise ImportError(
-                    f"{missing_package} is not installed. Please install it with: pip install {missing_package}"
+                    f"{missing_package} is not installed. Please install it with: $ uv add versionhq[{missing_package}]"
                 )
 
 

versionhq/knowledge/source_docling.py

@@ -56,7 +56,7 @@ class DoclingSource(BaseKnowledgeSource):
             super().__init__(*args, **kwargs)
 
         else:
-            raise ImportError("The docling package is required. Please install the package using: $ uv add docling.")
+            raise ImportError("The docling package is required. Please install the package using: $ uv add versionhq[docling]")
         # else:
         #     super().__init__(*args, **kwargs)
 

versionhq/memory/model.py

@@ -125,7 +125,7 @@ class ShortTermMemory(Memory):
 
                     from versionhq.storage.mem0_storage import Mem0Storage
                 except:
-                    raise ImportError("Mem0 is not installed. Please install it with `uv pip install mem0ai`.")
+                    raise ImportError("Mem0 is not installed. Please install it with `$ uv add versionhq[mem0ai]`.")
 
             storage = Mem0Storage(type="stm", agent=agent)
         else: