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

versionhq/__init__.py

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

versionhq/agent/model.py

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

versionhq/clients/workflow/model.py

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

versionhq/task/model.py

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

versionhq/team/model.py

@@ -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
 
 
@@ -310,7 +258,6 @@ class Team(BaseModel):
         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:
@@ -468,7 +415,6 @@ class Team(BaseModel):
 
         metrics: List[UsageMetrics] = []
 
-
         if self.team_tasks or self.member_tasks_without_agent:
             self._handle_team_planning()
 
@@ -511,3 +457,51 @@ class Team(BaseModel):
             self.usage_metrics.add_usage_metrics(metric)
 
         return result
+
+
+    @property
+    def key(self) -> str:
+        source = [str(member.agent.id.__str__) for member in self.members] + [str(task.id.__str__) for task in self.tasks]
+        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
+
+
+    @property
+    def managers(self) -> List[TeamMember] | None:
+        managers = [member for member in self.members if member.is_manager == True]
+        return managers if len(managers) > 0 else None
+
+
+    @property
+    def manager_tasks(self) -> List[Task] | None:
+        """
+        Tasks (incl. team tasks) handled by managers in the team.
+        """
+        if self.managers:
+            tasks = [manager.task for manager in self.managers if manager.task is not None]
+            return tasks if len(tasks) > 0 else None
+
+        return None
+
+
+    @property
+    def tasks(self):
+        """
+        Return all the tasks that the team needs to handle in order of priority:
+        1. team tasks, -> assigned to the member
+        2. manager_task,
+        3. members' tasks
+        """
+
+        team_tasks = self.team_tasks
+        manager_tasks = [member.task for member in self.members if member.is_manager == True and member.task is not None and member.task not in team_tasks]
+        member_tasks = [member.task for member in self.members if member.is_manager == False and member.task is not None and member.task not in team_tasks]
+
+        return team_tasks + manager_tasks + member_tasks
+
+
+    @property
+    def member_tasks_without_agent(self) -> List[Task] | None:
+        if self.members:
+            return [member.task for member in self.members if member.agent is None]
+
+        return None

versionhq/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`
+    """

versionhq/tool/composio.py

@@ -0,0 +1,149 @@
+import os
+import uuid
+from dotenv import load_dotenv
+from typing import Any, Callable, Type, get_args, get_origin, Optional, Tuple
+
+from pydantic import BaseModel, Field, model_validator, field_validator, UUID4
+from pydantic_core import PydanticCustomError
+
+from composio import ComposioToolSet, Action, App, action
+
+from versionhq.tool import ComposioAppName, ComposioAuthScheme, composio_app_set, COMPOSIO_STATUS
+
+load_dotenv(override=True)
+
+DEFAULT_REDIRECT_URL = os.environ.get("DEFAULT_REDIRECT_URL", None)
+DEFAULT_USER_ID = os.environ.get("DEFAULT_USER_ID", None)
+
+
+class Composio(BaseModel):
+    """
+    Class to handle composio tools.
+    """
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    app_name: str = Field(default=ComposioAppName.HUBSPOT)
+    user_id: str = Field(default=DEFAULT_USER_ID)
+    auth_scheme: str = Field(default=ComposioAuthScheme.OAUTH2)
+    redirect_url: str = Field(default=DEFAULT_REDIRECT_URL, description="redirect url after successful oauth2 connection")
+    connect_request_id: str = Field(default=None, description="store the client's composio id to connect with the app")
+
+    @property
+    def toolset(self) -> ComposioToolSet:
+        return ComposioToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"))
+
+
+    def __name__(self):
+        return self.app_name
+
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+
+
+    # @model_validator("user_id", mode="before")
+    # @classmethod
+    # def _deny_no_user_id(cls, v: Optional[str]) -> None:
+    #     if v is None:
+    #         raise PydanticCustomError("user_id_missing", "Need user_id to connect with the tool", {})
+
+
+    @model_validator(mode="after")
+    def validate_app_name(self):
+        if self.app_name not in ComposioAppName:
+            raise PydanticCustomError("no_app_name", f"The app name {self.app_name} is not valid.", {})
+
+        return self
+
+
+    @model_validator(mode="after")
+    def validate_auth_scheme(self):
+        """
+        Raise error when the client uses auth scheme unavailable for the app.
+        """
+        app_set = next(filter(lambda tup: self.app_name in tup, composio_app_set), None)
+        if not app_set:
+            raise  PydanticCustomError("no_app_set", f"The app set of {self.app_name} is missing.", {})
+
+        else:
+            acceptable_auth_scheme = next(filter(lambda item: self.auth_scheme in item, app_set), None)
+            if acceptable_auth_scheme is None:
+                raise  PydanticCustomError("invalid_auth_scheme", f"The app {self.app_name} must have different auth_scheme.", {})
+
+        return self
+
+
+    # connect with composio to use the tool
+    def connect(self, token: Optional[str] = None, api_key: Optional[str] = None) -> Tuple[str | Any]:
+        """
+        Connect with Composio, retrieve `connect_request_id`, and validate the connection.
+        """
+
+        if not self.user_id:
+            raise PydanticCustomError("user_id_missing", "Need user_id to connect with the tool", {})
+
+
+        connection_request, connected_account = None, None
+
+        if self.auth_scheme == ComposioAuthScheme.API_KEY:
+            collected_from_user = {}
+            collected_from_user["api_key"] = api_key
+            connection_request = self.toolset.initiate_connection(
+                connected_account_params = collected_from_user,
+                app=self.app_name,
+                entity_id=self.user_id,
+                auth_scheme=self.auth_scheme,
+            )
+
+        if self.auth_scheme == ComposioAuthScheme.BEARER_TOKEN:
+            collected_from_user = {}
+            collected_from_user["token"] = token
+            connection_request = self.toolset.initiate_connection(
+                connected_account_params = collected_from_user,
+                app=self.app_name,
+                entity_id=self.user_id,
+                auth_scheme=self.auth_scheme,
+            )
+
+        if self.auth_scheme == ComposioAuthScheme.OAUTH2:
+            connection_request = self.toolset.initiate_connection(
+                app=self.app_name,
+                redirect_url = self.redirect_url, # clients will be redirected to this url after successful auth.
+                entity_id=self.user_id,
+                auth_scheme=self.auth_scheme,
+            )
+
+        # connection_request.wait_until_active(self.toolset.client, timeout=60)
+
+        if connection_request.connectionStatus is not COMPOSIO_STATUS.FAILED:
+            self.connect_request_id = connection_request.connectedAccountId
+            connected_account = self.toolset.get_connected_account(id=self.connect_request_id)
+
+            if connected_account.status is not COMPOSIO_STATUS.FAILED:
+                setattr(self.toolset, "entity_id", self.user_id)
+
+        return connected_account, connected_account.status if connected_account else connection_request.connectionStatus
+
+
+
+
+    # @action(toolname=ComposioAppName.HUBSPOT)
+    # def deploy(self, param1: str, param2: str, execute_request: Callable) -> str:
+    #     """
+    #     Define custom actions
+    #     my custom action description which will be passed to llm
+
+    #     :param param1: param1 description which will be passed to llm
+    #     :param param2: param2 description which will be passed to llm
+    #     :return info: return description
+    #     """
+
+    #     response = execute_request(
+    #         "/my_action_endpoint",
+    #         "GET",
+    #         {} # body can be added here
+    #     )    # execute requests by appending credentials to the request
+    #     return str(response) # complete auth dict is available for local use if needed

versionhq/tool/decorator.py

@@ -1,5 +1,6 @@
 from typing import Callable
 from pydantic import BaseModel
+
 from versionhq.tool.model import Tool
 
 
@@ -13,6 +14,7 @@ def tool(*args):
         def _make_tool(f: Callable) -> Tool:
             if f.__doc__ is None:
                 raise ValueError("Function must have a docstring")
+
             if f.__annotations__ is None:
                 raise ValueError("Function must have type annotations")
 
@@ -26,7 +28,7 @@ def tool(*args):
                     },
                 },
             )
-            return Tool(name=tool_name, func=f, args_schema=args_schema)
+            return Tool(name=tool_name, function=f, args_schema=args_schema)
 
         return _make_tool
 

versionhq/tool/model.py

@@ -1,42 +1,26 @@
-from abc import ABC
+from abc import ABC, abstractmethod
 from inspect import signature
 from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin
-from pydantic import InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
+from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from versionhq._utils.cache_handler import CacheHandler
 
 
-class Tool(ABC, BaseModel):
-    """
-    The function that will be executed when the tool is called.
-    """
+class BaseTool(ABC, BaseModel):
 
-    class ArgsSchema(BaseModel):
+    class _ArgsSchemaPlaceholder(BaseModel):
         pass
 
-    model_config = ConfigDict()
     name: str = Field(default=None)
-    func: Callable = Field(default=None)
+    goal: str = Field(default=None)
+    args_schema: Type[BaseModel] = Field(default_factory=_ArgsSchemaPlaceholder)
     cache_function: Callable = lambda _args=None, _result=None: True
-    args_schema: Type[BaseModel] = Field(default_factory=ArgsSchema)
-    tool_handler: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="store tool_handler to record the usage of this tool. to avoid circular import, set as Dict format",
-    )
-
-    @property
-    def description(self):
-        args_schema = {
-            name: { "description": field.description,  "type": Tool._get_arg_annotations(field.annotation) }
-            for name, field in self.args_schema.model_fields.items()
-        }
-        return f"Tool Name: {self.name}\nTool Arguments: {args_schema}\nTool Description: {self.description}"
 
 
     @field_validator("args_schema", mode="before")
     @classmethod
     def _default_args_schema(cls, v: Type[BaseModel]) -> Type[BaseModel]:
-        if not isinstance(v, cls.ArgsSchema):
+        if not isinstance(v, cls._ArgsSchemaPlaceholder):
             return v
 
         return type(
@@ -49,14 +33,15 @@ class Tool(ABC, BaseModel):
             },
         )
 
-    @model_validator(mode="after")
-    def set_up_tool_handler_instance(self):
-        from versionhq.tool.tool_handler import ToolHandler
 
-        if self.tool_handler:
-            ToolHandler(**self.tool_handler)
+    @abstractmethod
+    def _run(self, *args: Any, **kwargs: Any,) -> Any:
+        """any handling"""
+
+
+    def run(self, *args: Any, **kwargs: Any) -> Any:
+        return self._run(*args, **kwargs)
 
-        return self
 
     @staticmethod
     def _get_arg_annotations(annotation: type[Any] | None) -> str:
@@ -67,11 +52,7 @@ class Tool(ABC, BaseModel):
         args = get_args(annotation)
 
         if origin is None:
-            return (
-                annotation.__name__
-                if hasattr(annotation, "__name__")
-                else str(annotation)
-            )
+            return annotation.__name__ if hasattr(annotation, "__name__") else str(annotation)
 
         if args:
             args_str = ", ".join(Tool._get_arg_annotations(arg) for arg in args)
@@ -79,112 +60,157 @@ class Tool(ABC, BaseModel):
 
         return origin.__name__
 
-    def _set_args_schema(self):
-        if self.args_schema is None:
-            class_name = f"{self.__class__.__name__}Schema"
-
-            self.args_schema = type(
-                class_name,
-                (BaseModel,),
-                {
-                    "__annotations__": {
-                        k: v
-                        for k, v in self._run.__annotations__.items()
-                        if k != "return"
-                    },
-                },
-            )
 
-    @classmethod
-    def from_composio(
-        cls, func: Callable = None, tool_name: str = "Composio tool"
-    ) -> "Tool":
+    def _parse_args(self, raw_args: str | dict) -> dict:
         """
-        Create a Pydantic BaseModel instance from Composio tools, ensuring the Tool instance has a func to be executed.
-        Refer to the `args_schema` from the func signature if any. Else, create an `args_schema`.
+        Parse and validate the input arguments against the schema
         """
+        if isinstance(raw_args, str):
+            try:
+                import json
+                raw_args = json.loads(raw_args)
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Failed to parse arguments as JSON: {e}")
+
+        try:
+            validated_args = self.args_schema.model_validate(raw_args)
+            return validated_args.model_dump()
 
-        if not func:
-            raise ValueError("Params must have a callable 'func' attribute.")
-
-        # args_schema = getattr(tool, "args_schema", None)
-        args_fields = {}
-        func_signature = signature(func)
-        annotations = func_signature.parameters
-        for name, param in annotations.items():
-            if name != "self":
-                param_annotation = (
-                    param.annotation if param.annotation != param.empty else Any
-                )
-                field_info = Field(default=..., description="")
-                args_fields[name] = (param_annotation, field_info)
-
-        args_schema = (
-            create_model(f"{tool_name}Input", **args_fields)
-            if args_fields
-            else create_model(f"{tool_name}Input", __base__=BaseModel)
+        except Exception as e:
+            raise ValueError(f"Arguments validation failed: {e}")
+
+
+    def _set_args_schema_from_func(self):
+        class_name = f"{self.__class__.__name__}Schema"
+        self.args_schema = type(
+            class_name,
+            (BaseModel,),
+            { "__annotations__": { k: v for k, v in self._run.__annotations__.items() if k != "return" } },
         )
+        return self
 
-        return cls(name=tool_name, func=func, args_schema=args_schema)
+
+    @property
+    def description(self) -> str:
+        args_schema = {
+            name: {
+                "description": field.description,
+                "type": self._get_arg_annotations(field.annotation),
+            }
+            for name, field in self.args_schema.model_fields.items()
+        }
+
+        return f"Tool Name: {self.name}\nTool Arguments: {args_schema}\nGoal: {self.goal}"
+
+
+
+class Tool(BaseTool):
+
+    function: Callable = Field(default=None)
+    tool_handler: Optional[Dict[str, Any]] = Field(
+        default=None,
+        description="store tool_handler to record the usage of this tool. to avoid circular import, set as Dict format",
+    )
+
+    @model_validator(mode="after")
+    def set_up_tool_handler(self):
+        from versionhq.tool.tool_handler import ToolHandler
+
+        if self.tool_handler:
+            ToolHandler(**self.tool_handler)
+        return self
+
+    @model_validator(mode="after")
+    def set_up_function(self):
+        if self.function is None:
+            self.function = self._run
+            self._set_args_schema_from_func()
+        return self
+
+
+    def _run(self, *args: Any, **kwargs: Any) -> Any:
+        return self.function(*args, **kwargs)
 
 
     def run(self, *args, **kwargs) -> Any:
         """
-        Use the tool.
-        When the tool has a func, execute the func and return any response from the func.
-        Else,
-
-        The response will be cascaded to the Task and stored in the TaskOutput.
+        Use tool
         """
+        from versionhq.tool.tool_handler import ToolHandler
 
         result = None
 
-        if self.func is not None:
-            result = self.func(
-                *args, **kwargs
-            )  #! REFINEME - format - json dict, pydantic, raw
+        if self.function is not None:
+            result = self.function(*args, **kwargs)
 
         else:
             acceptable_args = self.args_schema.model_json_schema()["properties"].keys()
-            arguments = {k: v for k, v in kwargs.items() if k in acceptable_args}
-            tool_called = ToolCalled(tool=self, arguments=arguments)
+            acceptable_kwargs = { k: v for k, v in kwargs.items() if k in acceptable_args }
+            tool_called = ToolSet(tool=self, kwargs=acceptable_kwargs)
 
             if self.tool_handler:
                 if self.tool_handler.has_called_before(tool_called):
-                    self.tool_handler.error = "Agent execution error."
+                    self.tool_handler.error = "Agent execution error"
 
                 elif self.tool_handler.cache:
-                    result = self.tools_handler.cache.read(
-                        tool=tool_called.tool.name, input=tool_called.arguments
-                    )
-                    # from_cache = result is not None
+                    result = self.tools_handler.cache.read(tool=tool_called.tool.name, input=tool_called.kwargs)
                     if result is None:
-                        result = self.invoke(input=arguments)
+                        parsed_kwargs = self._parse_args(input=acceptable_kwargs)
+                        result = self.function(**parsed_kwargs)
 
             else:
-                from versionhq.tool.tool_handler import ToolHandler
-
-                tool_handler = ToolHandler(
-                    last_used_tool=tool_called, cache=CacheHandler()
-                )
+                tool_handler = ToolHandler(last_used_tool=tool_called, cache_handler=CacheHandler())
                 self.tool_handler = tool_handler
-                result = self.invoke(input=arguments)
+                parsed_kwargs = self._parse_args(input=acceptable_kwargs)
+                result = self.function(**parsed_kwargs)
 
         return result
 
 
-class ToolCalled(BaseModel):
+    # @classmethod
+    # def from_composio(
+    #     cls, func: Callable = None, tool_name: str = "Composio tool"
+    # ) -> "Tool":
+    #     """
+    #     Create Tool from the composio tool, ensuring the Tool instance has a func to be executed.
+    #     Refer to the `args_schema` from the func signature if any. Else, create an `args_schema`.
+    #     """
+
+    #     if not func:
+    #         raise ValueError("Params must have a callable 'function' attribute.")
+
+    #     # args_schema = getattr(tool, "args_schema", None)
+    #     args_fields = {}
+    #     func_signature = signature(func)
+    #     annotations = func_signature.parameters
+    #     for name, param in annotations.items():
+    #         if name != "self":
+    #             param_annotation = (
+    #                 param.annotation if param.annotation != param.empty else Any
+    #             )
+    #             field_info = Field(default=..., description="")
+    #             args_fields[name] = (param_annotation, field_info)
+
+    #     args_schema = (
+    #         create_model(f"{tool_name}Input", **args_fields)
+    #         if args_fields
+    #         else create_model(f"{tool_name}Input", __base__=BaseModel)
+    #     )
+
+    #     return cls(name=tool_name, func=func, args_schema=args_schema)
+
+
+class ToolSet(BaseModel):
     """
     Store the tool called and any kwargs used.
     """
-
     tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
-    arguments: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
+    kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
-class InstructorToolCalled(BaseModel):
+class InstructorToolSet(BaseModel):
     tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
-    arguments: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
+    kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class CacheTool(BaseModel):

versionhq/tool/tool_handler.py

@@ -1,48 +1,43 @@
 from typing import Any, Optional
 from pydantic import InstanceOf
-from versionhq.tool.model import ToolCalled, InstructorToolCalled, CacheTool
+from versionhq.tool.model import ToolSet, InstructorToolSet, CacheTool
 from versionhq._utils.cache_handler import CacheHandler
 
 
 class ToolHandler:
     """
-    Record the tool usage by ToolCalled instance with cache and error recording.
-    Use as a callback function.
+    Record the tool usage by ToolSet instance with cache and error recording.
     """
 
-    last_used_tool: ToolCalled = {}
+    last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet]
     cache: Optional[CacheHandler]
     error: Optional[str]
 
-    def __init__(self, cache_handler: Optional[CacheHandler] = None):
-        """
-        Initialize the callback handler.
-        """
-
+    def __init__(
+            self,
+            last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet] = None,
+            cache_handler: Optional[CacheHandler] = None
+    ):
         self.cache = cache_handler
-        self.last_used_tool = {}
+        self.last_used_tool = last_used_tool
+
 
     def record_last_tool_used(
         self,
-        last_used_tool: InstanceOf[ToolCalled] | InstanceOf[InstructorToolCalled],
+        last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet],
         output: str,
         should_cache: bool = True,
     ) -> Any:
+
         self.last_used_tool = last_used_tool
 
         if self.cache and should_cache and last_used_tool.tool_name != CacheTool().name:
-            self.cache.add(
-                last_used_tool.tool_name,
-                input.last_used_tool.arguments,
-                output=output,
-            )
+            self.cache.add(last_used_tool.tool_name, input.last_used_tool.arguments, output=output)
+
 
-    def has_called_before(self, tool_called: ToolCalled = None) -> bool:
+    def has_called_before(self, tool_called: ToolSet = None) -> bool:
         if tool_called is None or not self.last_used_tool:
             return False
 
         if tool_called := self.last_used_tool:
-            return bool(
-                (tool_called.tool.name == self.last_used_tool.tool.name)
-                and (tool_called.arguments == self.last_used_tool.arguments)
-            )
+            return bool((tool_called.tool.name == self.last_used_tool.tool.name) and (tool_called.arguments == self.last_used_tool.arguments))

{versionhq-1.1.8.1.dist-info → versionhq-1.1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.8.1
+Version: 1.1.9.0
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -312,7 +312,7 @@ src/
 4. Test the features using the `tests` directory.
 
    - Add a test function to respective components in the `tests` directory.
-   - Add your `LITELLM_API_KEY` and `OPENAI_API_KEY` to the Github `repository secrets` @ settings > secrets & variables > Actions.
+   - Add your `LITELLM_API_KEY`, `OPENAI_API_KEY`, `COMPOSIO_API_KEY`, `DEFAULT_USER_ID` to the Github `repository secrets` @ settings > secrets & variables > Actions.
    - Run a test.
       ```
       uv run pytest tests -vv

{versionhq-1.1.8.1.dist-info → versionhq-1.1.9.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=vDnsppEwUlpBHeAcl8jCKzt8SaGylbfIND1PjgjY2s8,871
+versionhq/__init__.py,sha256=rtE16vRgpvQ78kBeWEl5kWQgGtGW0G5vHOgwC5hlu1w,931
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/_utils/cache_handler.py,sha256=zDQKzIn7vp-M2-uepHFxgJstjfftZS5mzXKL_-4uVvI,370
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
@@ -7,7 +7,7 @@ versionhq/_utils/process_config.py,sha256=UqoWD5IR4VLxEDGxIyVUylw_ppXwk8Wx1ynVuD
 versionhq/_utils/rpm_controller.py,sha256=T7waIGeblu5K58erY4lqVLcPsWM7W9UFdU3DG9Dsk0w,2214
 versionhq/_utils/usage_metrics.py,sha256=c33a_28y8ECUgflsKN3mkNm0fNkWgZmXwybMwIqoKXA,1098
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/model.py,sha256=tv14XkjrgsFsryFWzaw0w2h0X1T0ffipVK9l4kYbpIE,18598
+versionhq/agent/model.py,sha256=Sx4NJf3rElndcVzmPdgDgUFM3ATuvtXBwdM4AxB84UQ,18595
 versionhq/agent/parser.py,sha256=db5kfk-lR1Ph9-rsTvSeW1NjR6GJ00iaqTNYxJy3N8o,5487
 versionhq/agent/TEMPLATES/Backstory.py,sha256=cdngBx1GEv7nroR46FEhnysnBJ9mEVL763_9np6Skkc,395
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -18,7 +18,7 @@ versionhq/clients/customer/model.py,sha256=rQnCv_wdCdrYAsUjyB6X6ULiuWfqcBBoarXcQ
 versionhq/clients/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/product/model.py,sha256=HxiSv8zq5L0H210jXWfjX_Yg1oyWhi2YASR68JEtmDY,2408
 versionhq/clients/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/clients/workflow/model.py,sha256=YI6sNpdbizUOqPPXrTCtdmVt619uQ5hQgGS0BcA0njI,5834
+versionhq/clients/workflow/model.py,sha256=Suaih9odeAZOvNJ_wEy_iGAi8KnNJ1f_jIaXuhZTeAY,5833
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/llm/llm_vars.py,sha256=YZoXqFBW7XpclUZ14_AAz7WOjoyCXnGcI959GSpX2q0,5343
 versionhq/llm/model.py,sha256=mXzSuf1s6MebGT7_yqgNppde0NIlAF8bjIXAp2MZ9Uw,8247
@@ -27,16 +27,17 @@ versionhq/storage/task_output_storage.py,sha256=xoBJHeqUyQt6iJoR1WQTghP-fyxXL66q
 versionhq/task/__init__.py,sha256=g4mCATnn1mUXxsfQ5p6IpPawr8O421wVIT8kMKEcxQw,180
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
-versionhq/task/model.py,sha256=F6yd8oPJ6cjH0PcGZru7eska7Qu6lEtMDyjgn-ZnAfE,19394
+versionhq/task/model.py,sha256=Q2PqyepTLLeoAm7htHHtbc2j2ZXY0lrP2BVbhBCuPq4,19373
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=Liq0PUHncZAJyjjmqOL5mmt5E0Z0dBfhTmtRjUZQWiE,20369
+versionhq/team/model.py,sha256=gkw0rLkEcyAQqYk_fLA83oSvcl7p9dZSocWU0cKeHV4,20301
 versionhq/team/team_planner.py,sha256=uzX2yed7A7gNSs6qH5jIq2zXMVF5BwQQ4HPATsB9DSQ,3675
-versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/tool/decorator.py,sha256=Y-j4jkoujD5LUvpe8uf3p5Zagk2XVaRKC9rkIE-2geo,1189
-versionhq/tool/model.py,sha256=GjhQdlAyl2MGu4iiiFW7LqBWaaXhdlRQz2OGHhmr9FM,6828
-versionhq/tool/tool_handler.py,sha256=esUqGp8HoREesai8fmh2klAf04Sjpsacmb03C7F6sNQ,1541
-versionhq-1.1.8.1.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.8.1.dist-info/METADATA,sha256=7_hZDC_4H87AwyP_TtICbEv0XB_9DtUNI-80xjqqSBU,15919
-versionhq-1.1.8.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-versionhq-1.1.8.1.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.8.1.dist-info/RECORD,,
+versionhq/tool/__init__.py,sha256=oU2Y84b7vywWq1xmFaBdXdH8Y9lGv7dmk2LEcj4dL-s,1692
+versionhq/tool/composio.py,sha256=e-Vfr-eFm0ipiOerB_zAC1Sl90A39OD_k4QqgszWXWQ,5779
+versionhq/tool/decorator.py,sha256=W_WjzZy8y43AoiFjHLPUQfNipmpOPe-wQknCWloPwmY,1195
+versionhq/tool/model.py,sha256=ovoI3PaEuz9UvxLUKLidvSRdXDmaYxTMsZqpQPRugi0,7557
+versionhq/tool/tool_handler.py,sha256=r30Fwp32IX716pcERm67Z7kHWQ7eUa6EYBNSyWrPcjo,1485
+versionhq-1.1.9.0.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.9.0.dist-info/METADATA,sha256=qZaCrHOVr6y8nzrSNHtvDo0iHQSYtHqzE4LwKmZIpR8,15955
+versionhq-1.1.9.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+versionhq-1.1.9.0.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.9.0.dist-info/RECORD,,