versionhq 1.1.8.1__py3-none-any.whl → 1.1.9.1__py3-none-any.whl

versionhq/task/model.py

@@ -4,7 +4,7 @@ import uuid
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type
-from typing_extensions import Annotated
+from typing_extensions import Annotated, Self
 
 from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf
 from pydantic_core import PydanticCustomError
@@ -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
 
 
@@ -72,22 +72,11 @@ class TaskOutput(BaseModel):
     raw: str = Field(default="", description="Raw output of the task")
     json_dict: Dict[str, Any] = Field(default=None, description="`raw` converted to dictionary")
     pydantic: Optional[Any] = Field(default=None, description="`raw` converted to the abs. pydantic model")
+    tool_output: Optional[Any] = Field(default=None, description="store tool result when the task takes tool output as its final output")
 
     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 +101,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):
     """
@@ -124,6 +126,7 @@ class Task(BaseModel):
     _original_description: str = PrivateAttr(default=None)
     _logger: Logger = PrivateAttr()
     _task_output_handler = TaskOutputStorageHandler()
+    config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the agent")
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="unique identifier for the object, not set by user")
     name: Optional[str] = Field(default=None)
@@ -133,90 +136,35 @@ class Task(BaseModel):
     expected_output_json: bool = Field(default=True)
     expected_output_pydantic: bool = Field(default=False)
     output_field_list: List[ResponseField] = Field(
-        default=[ResponseField(title="output", type=str, required=False)],
+        default_factory=list,
         description="provide output key and data type. this will be cascaded to the agent via task.prompt()"
     )
     output: Optional[TaskOutput] = Field(default=None, description="store the final task output in TaskOutput class")
 
     # 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")
+    prompt_context: Optional[str] = Field(default=None)
+
+    # tool usage
+    tools: Optional[List[ToolSet | Tool | Any]] = Field(default_factory=list, description="tools that the agent can use aside from their tools")
+    can_use_agent_tools: bool = Field(default=False, description="whether the agent can use their own tools when executing the 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")
 
-    prompt_context: Optional[str] = Field(default=None)
+    # execution rules
+    allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
     async_execution: bool = Field(default=False,description="whether the task should be executed asynchronously or not")
-    config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the agent")
     callback: Optional[Any] = Field(default=None, description="callback to be executed after the task is completed.")
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
     # recording
     processed_by_agents: Set[str] = Field(default_factory=set, description="store responsible agents' roles")
-    used_tools: int = 0
     tools_errors: int = 0
     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]):
+    def process_model_config(cls, values: Dict[str, Any]) -> None:
         return process_config(values_to_update=values, model_class=cls)
 
 
@@ -228,7 +176,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
 
 
     @model_validator(mode="after")
-    def validate_required_fields(self):
+    def validate_required_fields(self) -> Self:
         required_fields = ["description",]
         for field in required_fields:
             if getattr(self, field) is None:
@@ -237,7 +185,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
 
 
     @model_validator(mode="after")
-    def set_attributes_based_on_config(self) -> "Task":
+    def set_attributes_based_on_config(self) -> Self:
         """
         Set attributes based on the agent configuration.
         """
@@ -248,12 +196,21 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         return self
 
 
-    ## comment out as we set raw as the default TaskOutputFormat
-    # @model_validator(mode="after")
-    # def validate_output_format(self):
-    #     if self.expected_output_json == False  and self.expected_output_pydantic == False:
-    #         raise PydanticCustomError("Need to choose at least one output format.")
-    #     return self
+    @model_validator(mode="after")
+    def set_up_tools(self) -> Self:
+        if not self.tools:
+            pass
+        else:
+            tool_list = []
+            for item in self.tools:
+                if isinstance(item, Tool) or isinstance(item, ToolSet):
+                    tool_list.append(item)
+                elif (isinstance(item, dict) and "function" not in item) or isinstance(item, str):
+                    pass
+                else:
+                    tool_list.append(item) # address custom tool
+            self.tools = tool_list
+        return self
 
 
     @model_validator(mode="after")
@@ -317,7 +274,6 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         return output_json_dict
 
 
-
     def create_pydantic_output(self, output_json_dict: Dict[str, Any], raw_result: Any = None) -> Optional[Any]:
         """
         Create pydantic output from the `raw` result.
@@ -358,11 +314,10 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         """
         if inputs:
             self.description = self._original_description.format(**inputs)
-            # self.expected_output = self._original_expected_output.format(**inputs)
 
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str] = None, tools: Optional[List[Any]] = None) -> TaskOutput:
+    def execute_sync(self, agent, context: Optional[str] = None) -> TaskOutput:
         """
         Execute the task synchronously.
         When the task has context, make sure we have executed all the tasks in the context first.
@@ -376,26 +331,26 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         return self._execute_core(agent, context)
 
 
-    def execute_async(self, agent, context: Optional[str] = None, tools: Optional[List[Any]] = None) -> Future[TaskOutput]:
+    def execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
         """
         Execute the task asynchronously.
         """
 
         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, future)).start()
         return future
 
 
-    def _execute_task_async(self, agent, context: Optional[str], tools: Optional[List[Any]], future: Future[TaskOutput]) -> None:
+    def _execute_task_async(self, agent, context: Optional[str], future: Future[TaskOutput]) -> None:
         """
         Execute the task asynchronously with context handling.
         """
 
-        result = self._execute_core(agent, context, tools)
+        result = self._execute_core(agent, context)
         future.set_result(result)
 
 
-    def _execute_core(self, agent, context: Optional[str], tools: Optional[List[Any]] = []) -> TaskOutput:
+    def _execute_core(self, agent, context: Optional[str]) -> TaskOutput:
         """
         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.
@@ -405,13 +360,14 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         from versionhq.team.model import Team
 
         self.prompt_context = context
+        task_output: InstanceOf[TaskOutput] = None
 
         if self.allow_delegation:
             agent_to_delegate = None
 
             if hasattr(agent, "team") and isinstance(agent.team, Team):
                 if agent.team.managers:
-                    idling_manager_agents = [manager.agent for manager in agent.team.managers if manager.task is None]
+                    idling_manager_agents = [manager.agent for manager in agent.team.managers if manager.is_idling]
                     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]
@@ -423,20 +379,26 @@ Your outputs MUST adhere to the following format and should NOT include any irre
             agent = agent_to_delegate
             self.delegations += 1
 
-        output_raw, output_json_dict, output_pydantic = agent.execute_task(task=self, context=context, tools=tools), None, None
+        if self.take_tool_res_as_final is True:
+            output = agent.execute_task(task=self, context=context)
+            task_output = TaskOutput(task_id=self.id, tool_output=output)
 
-        if self.expected_output_json:
-            output_json_dict = self.create_json_output(raw_result=output_raw)
+        else:
+            output_raw, output_json_dict, output_pydantic = agent.execute_task(task=self, context=context), None, None
 
-        if self.expected_output_pydantic:
-            output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict)
+            if self.expected_output_json:
+                output_json_dict = self.create_json_output(raw_result=output_raw)
+
+            if self.expected_output_pydantic:
+                output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict)
+
+            task_output = TaskOutput(
+                task_id=self.id,
+                raw=output_raw,
+                pydantic=output_pydantic,
+                json_dict=output_json_dict
+            )
 
-        task_output = TaskOutput(
-            task_id=self.id,
-            raw=output_raw,
-            pydantic=output_pydantic,
-            json_dict=output_json_dict
-        )
         self.output = task_output
         self.processed_by_agents.add(agent.role)
 
@@ -456,6 +418,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         #         else pydantic_output.model_dump_json() if pydantic_output else result
         #     )
         #     self._save_file(content)
+
         return task_output
 
 
@@ -467,6 +430,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.name for tool in self.tools])}
+        """
+
+
+
 
 class ConditionalTask(Task):
     """

versionhq/team/model.py

@@ -1,7 +1,6 @@
 import uuid
 import warnings
 import json
-from abc import ABC
 from enum import Enum
 from dotenv import load_dotenv
 from concurrent.futures import Future
@@ -108,13 +107,14 @@ class TeamOutput(BaseModel):
         return res
 
 
-class TeamMember(ABC, BaseModel):
+class TeamMember(BaseModel):
     agent: Agent | None = Field(default=None, description="store the agent to be a member")
     is_manager: bool = Field(default=False)
     task: Optional[Task] = Field(default=None)
 
-    def update(self, task: Task):
-        self.task = task
+    @property
+    def is_idling(self):
+        return bool(self.task is None)
 
 
 class Team(BaseModel):
@@ -161,54 +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 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
-
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -218,7 +170,7 @@ class Team(BaseModel):
 
 
     @model_validator(mode="after")
-    def validate_tasks(self):
+    def assess_tasks(self):
         """
         Validates if the model recognize all tasks that the team needs to handle.
         """
@@ -261,7 +213,7 @@ class Team(BaseModel):
         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 the task", {})
+                    raise PydanticCustomError("missing_agent_in_task", "Sequential process error: Agent is missing the task", {})
         return self
 
     @model_validator(mode="after")
@@ -280,11 +232,7 @@ 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 team must end with max. one asynchronous task.", {})
         return self
 
 
@@ -305,12 +253,11 @@ class Team(BaseModel):
         """
 
         team_planner = TeamPlanner(tasks=self.tasks, planner_llm=self.planning_llm)
-        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]
+        idling_managers: List[TeamMember] = [member for member in self.members if member.is_idling and member.is_manager is True]
+        idling_members: List[TeamMember] =  [member for member in self.members if member.is_idling 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:
@@ -433,16 +380,15 @@ class Team(BaseModel):
                 if skipped_task_output:
                     continue
 
-            # self._prepare_agent_tools(task)
             # 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 []))
-                future = task.execute_async(agent=responsible_agent, context=context, tools=responsible_agent.tools)
+                future = task.execute_async(agent=responsible_agent, context=context)
                 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)
+                task_output = task.execute_sync(agent=responsible_agent, context=context)
                 if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 
@@ -468,7 +414,6 @@ class Team(BaseModel):
 
         metrics: List[UsageMetrics] = []
 
-
         if self.team_tasks or self.member_tasks_without_agent:
             self._handle_team_planning()
 
@@ -511,3 +456,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/tool/__init__.py

@@ -0,0 +1,53 @@
+from enum import Enum
+
+DEFAULT_AUTH_SCHEME = "OAUTH2"
+
+class ComposioAuthScheme(str, Enum):
+    OAUTH2 = "OAUTH2"
+    BEARER_TOKEN = "BEARER_TOKEN"
+    API_KEY = "API_KEY"
+
+
+class ComposioAppName(str, Enum):
+    """
+    Enum to store app names that we can connect via Composio as data pipelines or destination services.
+    """
+
+    SALESFORCE = "salesforce"
+    AIRTABLE = "airtable"
+    MAILCHIMP = "mailchimp"
+    HUBSPOT = "hubspot"
+    KLAVIYO = "klaviyo"
+    GOOGLESHEET = "googlesheets"
+    GMAIL = "gmail"
+    FACEBOOK = "facebook"
+    TWITTER = "twitter"
+    TWITTER_MEDIA = "twitter_media"
+    LINKEDIN = "linkedin"
+
+
+composio_app_set = [
+    (ComposioAppName.SALESFORCE, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.AIRTABLE, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.MAILCHIMP, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.HUBSPOT, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.KLAVIYO, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY),
+    (ComposioAppName.GOOGLESHEET, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.GMAIL, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.TWITTER, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.TWITTER_MEDIA, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.FACEBOOK, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.LINKEDIN, ComposioAuthScheme.OAUTH2),
+]
+
+class COMPOSIO_STATUS(str, Enum):
+    INITIATED = "initiated"
+    ACTIVE = "active"
+    FAILED = "failed"
+
+
+
+class ComposioAction(str, Enum):
+    """
+    Enum to store composio's action that can be called via `Actions.xxx`
+    """