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

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,63 +1,69 @@
-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 typing_extensions import Self
+from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from versionhq._utils.cache_handler import CacheHandler
 
 
-class Tool(ABC, BaseModel):
+class BaseTool(ABC, BaseModel):
     """
-    The function that will be executed when the tool is called.
+    Abstract class for Tool class.
     """
 
-    class ArgsSchema(BaseModel):
+    class _ArgsSchemaPlaceholder(BaseModel):
         pass
 
-    model_config = ConfigDict()
-    name: str = Field(default=None)
-    func: Callable = Field(default=None)
-    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}"
+    args_schema: Type[BaseModel] = Field(default_factory=_ArgsSchemaPlaceholder)
 
 
     @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(
             f"{cls.__name__}Schema",
             (BaseModel,),
-            {
-                "__annotations__": {
-                    k: v for k, v in cls._run.__annotations__.items() if k != "return"
-                },
-            },
+            { "__annotations__": { k: v for k, v in cls._run.__annotations__.items() if k != "return" }},
         )
 
+
+    @abstractmethod
+    def _run(self, *args: Any, **kwargs: Any,) -> Any:
+        """any handling"""
+
+
+
+class Tool(BaseTool):
+    name: str = Field(default=None)
+    goal: str = Field(default=None)
+    function: Callable = Field(default=None)
+    cache_function: Callable = lambda _args=None, _result=None: True
+    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_instance(self):
+    def set_up_tool_handler(self) -> 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) -> Self:
+        if self.function is None:
+            self.function = self._run
+            self._set_args_schema_from_func()
         return self
 
+
     @staticmethod
     def _get_arg_annotations(annotation: type[Any] | None) -> str:
         if annotation is None:
@@ -67,11 +73,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 +81,133 @@ 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}")
 
-        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)
+        try:
+            validated_args = self.args_schema.model_validate(raw_args)
+            return validated_args.model_dump()
+
+        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)
+    def _run(self, *args: Any, **kwargs: Any) -> Any:
+        return self.run(*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
+
+        if self.function:
+            return self.function(*args, **kwargs)
 
         result = None
+        acceptable_args = self.args_schema.model_json_schema()["properties"].keys()
+        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"
 
-        if self.func is not None:
-            result = self.func(
-                *args, **kwargs
-            )  #! REFINEME - format - json dict, pydantic, raw
+            elif self.tool_handler.cache:
+                result = self.tools_handler.cache.read(tool=tool_called.tool.name, input=tool_called.kwargs)
+                if result is None:
+                    parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
+                    result = self.function(**parsed_kwargs) if self.function else None
 
         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)
-
-            if self.tool_handler:
-                if self.tool_handler.has_called_before(tool_called):
-                    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
-                    if result is None:
-                        result = self.invoke(input=arguments)
-
-            else:
-                from versionhq.tool.tool_handler import ToolHandler
-
-                tool_handler = ToolHandler(
-                    last_used_tool=tool_called, cache=CacheHandler()
-                )
-                self.tool_handler = tool_handler
-                result = self.invoke(input=arguments)
+            tool_handler = ToolHandler(last_used_tool=tool_called, cache_handler=CacheHandler())
+            self.tool_handler = tool_handler
+            parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
+            result = self.function(**parsed_kwargs) if self.function else None
 
         return result
 
 
-class ToolCalled(BaseModel):
+    @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}"
+
+
+
+    # @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")
+    tool: InstanceOf[Tool] | Any = Field(..., description="store the tool instance to be called.")
+    kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
-class InstructorToolCalled(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")
+class InstructorToolSet(BaseModel):
+    tool: InstanceOf[Tool] | Any = Field(..., description="store the tool instance to be called.")
+    kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class CacheTool(BaseModel):

versionhq/tool/tool_handler.py

@@ -1,48 +1,45 @@
-from typing import Any, Optional
+from typing import Optional, Any
 from pydantic import InstanceOf
-from versionhq.tool.model import ToolCalled, InstructorToolCalled, CacheTool
+
+from versionhq.tool.model import ToolSet, InstructorToolSet
 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,
-            )
+        from versionhq.tool.model import CacheTool
+        if self.cache and should_cache and last_used_tool.tool.name != CacheTool().name:
+            self.cache.add(tool=last_used_tool.tool.name, input=last_used_tool.kwargs, 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.kwargs == self.last_used_tool.kwargs))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.8.1
+Version: 1.1.9.1
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -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.1.dist-info}/RECORD

@@ -1,24 +1,24 @@
-versionhq/__init__.py,sha256=vDnsppEwUlpBHeAcl8jCKzt8SaGylbfIND1PjgjY2s8,871
+versionhq/__init__.py,sha256=HIOFr73z0KeJs9qFVvW1DjRFj7JyiJcRGGxylbQT_bQ,931
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/_utils/cache_handler.py,sha256=zDQKzIn7vp-M2-uepHFxgJstjfftZS5mzXKL_-4uVvI,370
+versionhq/_utils/cache_handler.py,sha256=3-lw_5ZMWC8hnPAkSQULJ2V1FvZZ-wg9mQaUJGSOjI8,403
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=lqRYH45KHMQ4mwE1woa5xNmngYu4O749AYECsnWWpmA,1851
 versionhq/_utils/process_config.py,sha256=UqoWD5IR4VLxEDGxIyVUylw_ppXwk8Wx1ynVuD-pUSg,822
-versionhq/_utils/rpm_controller.py,sha256=T7waIGeblu5K58erY4lqVLcPsWM7W9UFdU3DG9Dsk0w,2214
-versionhq/_utils/usage_metrics.py,sha256=c33a_28y8ECUgflsKN3mkNm0fNkWgZmXwybMwIqoKXA,1098
+versionhq/_utils/rpm_controller.py,sha256=dUgFd6JtdjiLLTRmrjsBHdTaLn73XFuKpLbJh7thf2A,2289
+versionhq/_utils/usage_metrics.py,sha256=hhq1OCW8Z4V93vwW2O2j528EyjOlF8wlTsX5IL-7asA,1106
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/model.py,sha256=tv14XkjrgsFsryFWzaw0w2h0X1T0ffipVK9l4kYbpIE,18598
-versionhq/agent/parser.py,sha256=db5kfk-lR1Ph9-rsTvSeW1NjR6GJ00iaqTNYxJy3N8o,5487
+versionhq/agent/model.py,sha256=8QtZfbeys9cCujc4whKfXdoP0aQKMuvL2qN8WQmugew,19152
+versionhq/agent/parser.py,sha256=Z_swUPO3piJQuYU8oVYwXWeR2zjmNb4PxbXZeR-GlIg,4694
 versionhq/agent/TEMPLATES/Backstory.py,sha256=cdngBx1GEv7nroR46FEhnysnBJ9mEVL763_9np6Skkc,395
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/customer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/clients/customer/model.py,sha256=rQnCv_wdCdrYAsUjyB6X6ULiuWfqcBBoarXcQT5kj88,1762
+versionhq/clients/customer/model.py,sha256=ruxqSvjBHrSJnNq9Jj5Ko1CW6l8RLiPzhbC_F7tbOnM,1670
 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=LPet39sK7vUpBQ1mymdNX1xUPseGWv_5W7je_7sif_M,5883
 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=EbgYHLNq8l1zfRDnF-yEcuSZ0aNvzbRmHYgfVyJq84c,19910
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=Liq0PUHncZAJyjjmqOL5mmt5E0Z0dBfhTmtRjUZQWiE,20369
+versionhq/team/model.py,sha256=E52OUVzUtvR--51SFRJos3JdYKri1t2jbvvzoOvShQc,20181
 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=8A1x8gEdTuP5teUf6o3VqJhrPI5m-XBoBXxgHiWCKcI,7499
+versionhq/tool/tool_handler.py,sha256=rmm8snegwug4jl0Sbi_CteFajkbPAZ5koTQWDMwcIrQ,1510
+versionhq-1.1.9.1.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.9.1.dist-info/METADATA,sha256=-mFMCnD5q2XGVgaNyE8ddBpX8tgAR4sqlJ-Cmm0hBQA,15955
+versionhq-1.1.9.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+versionhq-1.1.9.1.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.9.1.dist-info/RECORD,,