versionhq 1.2.1.15__py3-none-any.whl → 1.2.1.16__py3-none-any.whl

versionhq/__init__.py

@@ -31,7 +31,7 @@ from versionhq.task.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.1.15"
+__version__ = "1.2.1.16"
 __all__ = [
     "Agent",
 

versionhq/agent/inhouse_agents.py

@@ -10,7 +10,7 @@ vhq_client_manager = Agent(
     role="vhq-Client Manager",
     goal="Efficiently communicate with the client on the task progress",
     llm=DEFAULT_MODEL_NAME,
-    use_memory=True,
+    with_memory=True,
 )
 
 
@@ -21,7 +21,7 @@ vhq_task_evaluator = Agent(
     llm_config=dict(top_p=0.8, top_k=30, max_tokens=5000, temperature=0.9),
     maxit=1,
     max_retry_limit=1,
-    use_memory=True # refer past eval records of similar tasks
+    with_memory=True # refer past eval records of similar tasks
 )
 
 

versionhq/agent/model.py

@@ -60,7 +60,6 @@ class Agent(BaseModel):
     """
 
     __hash__ = object.__hash__
-    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _rpm_controller: Optional[RPMController] = PrivateAttr(default=None)
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
@@ -76,39 +75,38 @@ class Agent(BaseModel):
 
     # knowledge
     knowledge_sources: Optional[List[BaseKnowledgeSource | Any]] = Field(default=None)
+    embedder_config: Optional[Dict[str, Any]] = Field(default=None, description="embedder configuration for knowledge sources")
     _knowledge: Optional[Knowledge] = PrivateAttr(default=None)
 
     # memory
-    use_memory: bool = Field(default=False, description="whether to store/use memory when executing the task")
-    memory_config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the memory. need to store user_id for UserMemory")
+    with_memory: bool = Field(default=False, description="whether to use memories during the task execution")
+    memory_config: Optional[Dict[str, Any]] = Field(default=None, description="memory config. needs to store user_id for UserMemory to work")
     short_term_memory: Optional[InstanceOf[ShortTermMemory]] = Field(default=None)
     long_term_memory: Optional[InstanceOf[LongTermMemory]] = Field(default=None)
     user_memory: Optional[InstanceOf[UserMemory]] = Field(default=None)
-    embedder_config: Optional[Dict[str, Any]] = Field(default=None, description="embedder configuration for the agent's knowledge")
 
     # prompting
     use_developer_prompt: Optional[bool] = Field(default=True, description="Use developer prompt when calling the llm")
-    developer_propmt_template: Optional[str] = Field(default=None, description="ddeveloper prompt template")
-    user_prompt_template: Optional[str] = Field(default=None, description="user prompt template")
+    developer_propmt_template: Optional[str] = Field(default=None, description="abs. file path to developer prompt template")
+    user_prompt_template: Optional[str] = Field(default=None, description="abs. file path to user prompt template")
 
     # task execution rules
     network: Optional[List[Any]] = Field(default=None, description="store a list of agent networks that the agent belong as a member")
-    allow_delegation: bool = Field(default=False,description="if the agent can delegate the task to another agent or ask some help")
-    max_retry_limit: int = Field(default=2 ,description="max. number of retry for the task execution when an error occurs")
-    maxit: Optional[int] = Field(default=25,description="max. number of total optimization loops conducted when an error occurs")
+    allow_delegation: bool = Field(default=False, description="whether to delegate the task to another agent")
+    max_retry_limit: int = Field(default=2, description="max. number of task retries when an error occurs")
+    maxit: Optional[int] = Field(default=25, description="max. number of total optimization loops conducted when an error occurs")
     callbacks: Optional[List[Callable]] = Field(default_factory=list, description="callback functions to execute after any task execution")
 
     # llm settings cascaded to the LLM model
     llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
-    function_calling_llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
-    respect_context_window: bool = Field(default=True,description="Keep messages under the context window size by summarizing content")
-    max_tokens: Optional[int] = Field(default=None, description="max. number of tokens for the agent's execution")
-    max_execution_time: Optional[int] = Field(default=None, description="max. execution time for an agent to execute a task")
+    func_calling_llm: str | InstanceOf[LLM] | Dict[str, Any] = Field(default=None)
+    respect_context_window: bool = Field(default=True,description="keep messages under the context window size")
+    max_execution_time: Optional[int] = Field(default=None, description="max. task execution time in seconds")
     max_rpm: Optional[int] = Field(default=None, description="max. number of requests per minute")
     llm_config: Optional[Dict[str, Any]] = Field(default=None, description="other llm config cascaded to the LLM model")
 
-    # cache, error, ops handling
-    formatting_errors: int = Field(default=0, description="number of formatting errors.")
+    # # cache, error, ops handling
+    # formatting_errors: int = Field(default=0, description="number of formatting errors.")
 
 
     @field_validator("id", mode="before")
@@ -136,18 +134,18 @@ class Agent(BaseModel):
     @model_validator(mode="after")
     def set_up_llm(self) -> Self:
         """
-        Set up `llm` and `function_calling_llm` as valid LLM objects using the given kwargs.
+        Set up `llm` and `func_calling_llm` as valid LLM objects using the given kwargs.
         """
         self.llm = self._convert_to_llm_object(llm=self.llm)
 
-        function_calling_llm = self.function_calling_llm if self.function_calling_llm else self.llm if self.llm else None
-        function_calling_llm = self._convert_to_llm_object(llm=function_calling_llm)
-        if function_calling_llm._supports_function_calling():
-            self.function_calling_llm = function_calling_llm
+        func_calling_llm = self.func_calling_llm if self.func_calling_llm else self.llm if self.llm else None
+        func_calling_llm = self._convert_to_llm_object(llm=func_calling_llm)
+        if func_calling_llm._supports_function_calling():
+            self.func_calling_llm = func_calling_llm
         elif self.llm._supports_function_calling():
-            self.function_calling_llm = self.llm
+            self.func_calling_llm = self.llm
         else:
-            self.function_calling_llm = self._convert_to_llm_object(llm=LLM(model=DEFAULT_MODEL_NAME))
+            self.func_calling_llm = self._convert_to_llm_object(llm=LLM(model=DEFAULT_MODEL_NAME))
         return self
 
 
@@ -179,7 +177,7 @@ class Agent(BaseModel):
                 model_name = (getattr(self.llm, "model_name") or getattr(self.llm, "deployment_name") or str(self.llm))
                 llm_obj = LLM(model=model_name if model_name else DEFAULT_MODEL_NAME)
                 llm_params = {
-                    "max_tokens": (getattr(llm, "max_tokens") or self.max_tokens or 3000),
+                    "max_tokens": (getattr(llm, "max_tokens") or 3000),
                     "timeout": getattr(llm, "timeout", self.max_execution_time),
                     "callbacks": getattr(llm, "callbacks", None),
                     "temperature": getattr(llm, "temperature", None),
@@ -222,7 +220,7 @@ class Agent(BaseModel):
 
 
         llm.timeout = self.max_execution_time if llm.timeout is None else llm.timeout
-        llm.max_tokens = self.max_tokens if self.max_tokens else llm.max_tokens
+        # llm.max_tokens = self.max_tokens if self.max_tokens else llm.max_tokens
 
         if llm.provider is None:
             provider_name = llm.model.split("/")[0]
@@ -262,7 +260,7 @@ class Agent(BaseModel):
                     tool_list.append(item)
 
                 else:
-                    self._logger.log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
+                    Logger().log(level="error", message=f"Tool {str(item)} is missing a function.", color="red")
                     raise PydanticCustomError("invalid_tool", f"The tool {str(item)} is missing a function.", {})
 
             self.tools = tool_list
@@ -346,7 +344,7 @@ class Agent(BaseModel):
                 self._knowledge = Knowledge(sources=knowledge_sources, embedder_config=self.embedder_config, collection_name=collection_name)
 
             except:
-                self._logger.log(level="warning", message="We cannot find the format for the source. Add BaseKnowledgeSource objects instead.", color="yellow")
+                Logger().log(level="warning", message="We cannot find the format for the source. Add BaseKnowledgeSource objects instead.", color="yellow")
 
         return self
 
@@ -357,7 +355,7 @@ class Agent(BaseModel):
         Set up memories: stm, ltm, and um
         """
 
-        # if self.use_memory == True:
+        # if self.with_memory == True:
         self.long_term_memory = self.long_term_memory if self.long_term_memory else LongTermMemory()
         self.short_term_memory = self.short_term_memory if self.short_term_memory else ShortTermMemory(agent=self, embedder_config=self.embedder_config)
 
@@ -371,21 +369,13 @@ class Agent(BaseModel):
         return self
 
 
-    def _train(self) -> Self:
-        """
-        Fine-tuned the base model using OpenAI train framework.
-        """
-        if not isinstance(self.llm, LLM):
-            pass
-
-
-    def update_llm(self, llm: Any = None, llm_config: Optional[Dict[str, Any]] = None) -> Self:
+    def _update_llm(self, llm: Any = None, llm_config: Optional[Dict[str, Any]] = None) -> Self:
         """
         Update llm and llm_config of the exsiting agent. (Other conditions will remain the same.)
         """
 
         if not llm and not llm_config:
-            self._logger.log(level="error", message="Missing llm or llm_config values to update", color="red")
+            Logger().log(level="error", message="Missing llm or llm_config values to update", color="red")
             pass
 
         self.llm = llm
@@ -398,59 +388,15 @@ class Agent(BaseModel):
         return self.set_up_llm()
 
 
-    def update(self, **kwargs) -> Self:
+    def _train(self) -> Self:
         """
-        Update the existing agent. Address variables that require runnning set_up_x methods first, then update remaining variables.
+        Fine-tuned the base model using OpenAI train framework.
         """
-
-        if not kwargs:
-            self._logger.log(level="error", message="Missing values to update", color="red")
-            return self
-
-        for k, v in kwargs.items():
-            match k:
-                case "tools":
-                    self.tools = kwargs.get(k, self.tools)
-                    self.set_up_tools()
-
-                case "role" | "goal":
-                    self.role = kwargs.get("role", self.role)
-                    self.goal = kwargs.get("goal", self.goal)
-                    if not self.backstory:
-                        self.set_up_backstory()
-
-                    if self.backstory:
-                        self.backstory += f"new role: {self.role}, new goal: {self.goal}"
-
-                case "max_rpm":
-                    self.max_rpm = kwargs.get(k, self.max_rpm)
-                    self.set_up_rpm()
-
-                case "knowledge_sources":
-                    self.knowledge_sources = kwargs.get("knowledge_sources", self.knowledge_sources)
-                    self.set_up_knowledge()
-
-                case "use_memory" | "memory_config":
-                    self.use_memory = kwargs.get("use_memory", self.use_memory)
-                    self.memory_config = kwargs.get("memory_config", self.memory_config)
-                    self.set_up_memory()
-
-                case "llm" | "llm_config":
-                    self.llm = kwargs.get("llm", self.llm)
-                    self.llm_config = kwargs.get("llm_config", self.llm_config)
-                    self.update_llm(llm=self.llm, llm_config=self.llm_config)
-
-                case _:
-                    try:
-                        setattr(self, k, v)
-                    except Exception as e:
-                        self._logger.log(level="error", message=f"Failed to update the key: {k} We'll skip. Error: {str(e)}", color="red")
-                        pass
-
-        return self
+        if not isinstance(self.llm, LLM):
+            pass
 
 
-    def invoke(
+    def _invoke(
         self,
         prompts: str,
         response_format: Optional[Dict[str, Any]] = None,
@@ -477,21 +423,21 @@ class Agent(BaseModel):
             if self._rpm_controller and self.max_rpm:
                 self._rpm_controller.check_or_wait()
 
-            self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
+            Logger().log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
             if tool_res_as_final:
-                raw_response = self.function_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
-                task.tokens = self.function_calling_llm._tokens
+                raw_response = self.func_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
+                task.tokens = self.func_calling_llm._tokens
             else:
                 raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
                 task.tokens = self.llm._tokens
 
             task_execution_counter += 1
-            self._logger.log(level="info", message=f"Agent response: {raw_response}", color="green")
+            Logger().log(level="info", message=f"Agent response: {raw_response}", color="green")
             return raw_response
 
         except Exception as e:
-            self._logger.log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
+            Logger().log(level="error", message=f"An error occured. The agent will retry: {str(e)}", color="red")
 
             while not raw_response and task_execution_counter <= self.max_retry_limit:
                 while (not raw_response or raw_response == "" or raw_response is None) and iterations < self.maxit:
@@ -503,14 +449,89 @@ class Agent(BaseModel):
                     iterations += 1
 
                 task_execution_counter += 1
-                self._logger.log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="green")
+                Logger().log(level="info", message=f"Agent #{task_execution_counter} response: {raw_response}", color="green")
                 return raw_response
 
             if not raw_response:
-                self._logger.log(level="error", message="Received None or empty response from the model", color="red")
+                Logger().log(level="error", message="Received None or empty response from the model", color="red")
                 raise ValueError("Invalid response from LLM call - None or empty.")
 
 
+    def update(self, **kwargs) -> Self:
+        """
+        Update the existing agent. Address variables that require runnning set_up_x methods first, then update remaining variables.
+        """
+
+        if not kwargs:
+            Logger().log(level="error", message="Missing values to update", color="red")
+            return self
+
+        for k, v in kwargs.items():
+            match k:
+                case "tools":
+                    self.tools = kwargs.get(k, self.tools)
+                    self.set_up_tools()
+
+                case "role" | "goal":
+                    self.role = kwargs.get("role", self.role)
+                    self.goal = kwargs.get("goal", self.goal)
+                    if not self.backstory:
+                        self.set_up_backstory()
+
+                    if self.backstory:
+                        self.backstory += f"new role: {self.role}, new goal: {self.goal}"
+
+                case "max_rpm":
+                    self.max_rpm = kwargs.get(k, self.max_rpm)
+                    self.set_up_rpm()
+
+                case "knowledge_sources":
+                    self.knowledge_sources = kwargs.get("knowledge_sources", self.knowledge_sources)
+                    self.set_up_knowledge()
+
+                case "with_memory" | "memory_config":
+                    self.with_memory = kwargs.get("with_memory", self.with_memory)
+                    self.memory_config = kwargs.get("memory_config", self.memory_config)
+                    self.set_up_memory()
+
+                case "llm" | "llm_config":
+                    self.llm = kwargs.get("llm", self.llm)
+                    self.llm_config = kwargs.get("llm_config", self.llm_config)
+                    self._update_llm(llm=self.llm, llm_config=self.llm_config)
+
+                case _:
+                    try:
+                        setattr(self, k, v)
+                    except Exception as e:
+                        Logger().log(level="error", message=f"Failed to update the field: {k} We'll skip it. Error: {str(e)}", color="red")
+                        pass
+
+        return self
+
+
+    def start(self, context: Any = None, tool_res_as_final: bool = False) -> Any | None:
+        """
+        Defines and executes a task when it is not given and returns TaskOutput object.
+        """
+
+        if not self.goal or not self.role:
+            return None
+
+        from versionhq.task.model import Task
+
+        class Output(BaseModel):
+            result: str
+            steps: list[str]
+
+        task = Task(
+            description=f"Generate a simple result in a sentence to achieve the goal: {self.goal}. If needed, list up necessary steps in concise manner.",
+            pydantic_output=Output,
+            tool_res_as_final=tool_res_as_final,
+        )
+        res = task.execute(agent=self, context=context)
+        return res
+
+
     def execute_task(self, task, context: Optional[Any] = None, task_tools: Optional[List[Tool | ToolSet]] = list()) -> str:
         """
         Format a task prompt, adding context from knowledge and memory (if given), and invoke LLM.
@@ -534,7 +555,7 @@ class Agent(BaseModel):
                 if agent_knowledge_context:
                     task_prompt += agent_knowledge_context
 
-        if self.use_memory == True:
+        if self.with_memory == True:
             contextual_memory = ContextualMemory(
                 memory_config=self.memory_config, stm=self.short_term_memory, ltm=self.long_term_memory, um=self.user_memory
             )
@@ -553,7 +574,7 @@ class Agent(BaseModel):
 
         try:
             self._times_executed += 1
-            raw_response = self.invoke(
+            raw_response = self._invoke(
                 prompts=task_prompt,
                 response_format=task._structure_response_format(model_provider=self.llm.provider),
                 tools=tools,
@@ -563,11 +584,11 @@ class Agent(BaseModel):
 
         except Exception as e:
             self._times_executed += 1
-            self._logger.log(level="error", message=f"The agent failed to execute the task. Error: {str(e)}", color="red")
+            Logger().log(level="error", message=f"The agent failed to execute the task. Error: {str(e)}", color="red")
             raw_response = self.execute_task(task, context, task_tools)
 
             if self._times_executed > self.max_retry_limit:
-                self._logger.log(level="error", message=f"Max retry limit has exceeded.", color="red")
+                Logger().log(level="error", message=f"Max retry limit has exceeded.", color="red")
                 raise e
 
         if self.max_rpm and self._rpm_controller:
@@ -576,27 +597,5 @@ class Agent(BaseModel):
         return raw_response
 
 
-    def start(self, context: Any = None) -> Any | None:
-        """
-        Defines and executes a task when it is not given and returns TaskOutput object.
-        """
-
-        if not self.goal or not self.role:
-            return None
-
-        from versionhq.task.model import Task, ResponseField
-
-        class Output(BaseModel):
-            result: str
-            steps: list[str]
-
-        task = Task(
-            description=f"Generate a simple result in a sentence to achieve the goal: {self.goal}. If needed, list up necessary steps in concise manner.",
-            pydantic_output=Output
-        )
-        res = task.execute(agent=self, context=context)
-        return res
-
-
     def __repr__(self):
         return f"Agent(role={self.role}, goal={self.goal}"

versionhq/task/model.py

@@ -530,9 +530,9 @@ Ref. Output image: {output_formats_to_follow}
         from versionhq.agent.model import Agent
         from versionhq.memory.model import ShortTermMemory, MemoryMetadata, LongTermMemory
 
-        agent = agent if isinstance(agent, Agent) else Agent(role=str(agent), goal=str(agent), use_memory=True)
+        agent = agent if isinstance(agent, Agent) else Agent(role=str(agent), goal=str(agent), with_memory=True)
 
-        if agent.use_memory == False:
+        if agent.with_memory == False:
             return None
 
         try:

versionhq/task_graph/draft.py

@@ -14,7 +14,7 @@ from versionhq.task_graph.model import TaskGraph, Task, DependencyType, Node
 from versionhq._utils.logger import Logger
 
 
-def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = False, use_memory: bool = False) -> TaskGraph | None:
+def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = False, with_memory: bool = False) -> TaskGraph | None:
     """
     Generate a TaskGraph object to generate the givne final_output most resource-efficiently.
     """
@@ -43,7 +43,7 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
             ", ".join([k for k in DependencyType._member_map_.keys()]),
         ],
         llm="gemini-2.0",
-        use_memory=use_memory,
+        with_memory=with_memory,
         maxit=1,
         max_retry_limit=1,
     )

versionhq/tool/composio_tool.py

@@ -2,14 +2,13 @@ import os
 import uuid
 from abc import ABC
 from dotenv import load_dotenv
-from typing import Any, Callable, Type, get_args, get_origin, Optional, Tuple, Dict
+from typing import Any, Optional, Tuple, Dict
 from typing_extensions import Self
 
 from pydantic import BaseModel, Field, model_validator, field_validator, UUID4, PrivateAttr
 from pydantic_core import PydanticCustomError
 
 from composio import ComposioToolSet
-from composio_langchain import action
 
 from versionhq.tool.composio_tool_vars import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
 from versionhq.tool.cache_handler import CacheHandler

{versionhq-1.2.1.15.dist-info → versionhq-1.2.1.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.1.15
+Version: 1.2.1.16
 Summary: An agentic orchestration framework for building agent networks that handle task automation.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

{versionhq-1.2.1.15.dist-info → versionhq-1.2.1.16.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=v49Zr8uA1uDecJ9sdBDmFy0oknWouJm4rn2oWP6QMQ8,2883
+versionhq/__init__.py,sha256=X8no15wt1eRD5MvPgotKJer6Zl8fu7CEm2X85NX0VMc,2883
 versionhq/_utils/__init__.py,sha256=dzoZr4cBlh-2QZuPzTdehPUCe9lP1dmRtauD7qTjUaA,158
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=zgogTwAY-ujDLrdryAKhdtoaNe1nOFajmEN0V8aMR34,3155
@@ -6,8 +6,8 @@ versionhq/_utils/process_config.py,sha256=jbPGXK2Kb4iyCugJ3FwRJuU0wL5Trq2x4xFQz2
 versionhq/_utils/usage_metrics.py,sha256=NXF18dn5NNvGK7EsQ4AAghpR8ppYOjMx6ABenLLHnmM,1066
 versionhq/_utils/vars.py,sha256=bZ5Dx_bFKlt3hi4-NNGXqdk7B23If_WaTIju2fiTyPQ,57
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/inhouse_agents.py,sha256=snDtgDmvZB2bZKH_RTcz5uFOMl3MTjLJwTQBebFt8hk,2532
-versionhq/agent/model.py,sha256=eFmkNuCJhXRhdYJR59J5PFxw5aghLvBrPRj4NXd7J0w,25873
+versionhq/agent/inhouse_agents.py,sha256=vupO1viYqVb7sKohIE1zThu6JArhh5JLo5LBeSnh0kM,2534
+versionhq/agent/model.py,sha256=ReuQLuLQZ87TyzMKdQaqfDX496waLascBt2Ebw69QAY,25593
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=IAhGnnt6VUMe3wO6IzeyZPDNu7XE7Uiu3VEXUreOcKs,532
@@ -47,22 +47,22 @@ versionhq/task/evaluate.py,sha256=WdUgjbZL62XrxyWe5MTz29scfzwmuAHGxJ7GvAB8Fmk,39
 versionhq/task/formation.py,sha256=WH604q9bRmWH7KQCrk2qKJwisCopYX5CjJvsj4TgFjI,6894
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
 versionhq/task/log_handler.py,sha256=LT7YnO7gcPR9IZS7eRvMjnHh8crMBFtqduxd8dxIbkk,1680
-versionhq/task/model.py,sha256=EcUW7nktGBd9CBenKLh-5HBRa02wrwYF6WeF8ju04tc,28538
+versionhq/task/model.py,sha256=i0MDTS9-htIygL7Q8CTOrG8Zt0gPcqQiS4wacmecqAc,28540
 versionhq/task/structured_response.py,sha256=4q-hQPu7oMMHHXEzh9YW4SJ7N5eCZ7OfZ65juyl_jCI,5000
 versionhq/task/TEMPLATES/Description.py,sha256=V-4kh8xpQTKOcDMi2xnuP-fcNk6kuoz1_5tYBlDLQWQ,420
 versionhq/task_graph/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/task_graph/colors.py,sha256=naJCx4Vho4iuJtbW8USUXb-M5uYvd5ds2p8qbjUfRus,669
-versionhq/task_graph/draft.py,sha256=gTEICHEoUwlka6TDc9Kw0pKnhdrKtNw5HKhkl9gjIYk,5128
+versionhq/task_graph/draft.py,sha256=AuQ2X-T5xuQ2ipMiAqeh9Pjm6I2fIf952pBQRYqdaog,5131
 versionhq/task_graph/model.py,sha256=njyHQyHrVTZP46iVkC6YvuMnGcS40vOy1wszRtf7DHY,23971
 versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/tool/cache_handler.py,sha256=iL8FH7X0G-cdT0uhJwzuhLDaadTXOdfybZcDy151-es,1085
-versionhq/tool/composio_tool.py,sha256=38mEiVvTkuw1BLD233Bl1Gwxbpss1yfQiZLTWwX6BdA,8648
+versionhq/tool/composio_tool.py,sha256=IATfsEnF_1RPJyGtPBmAtEJh5XPcgDHpyG3SUR461Og,8572
 versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
 versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
 versionhq/tool/model.py,sha256=PO4zNWBZcJhYVur381YL1dy6zqurio2jWjtbxOxZMGI,12194
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.2.1.15.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.1.15.dist-info/METADATA,sha256=bmi_7y_zYR9MIDpsD23IfdAGJ8YYs-ifo4xE1CJOFSE,22033
-versionhq-1.2.1.15.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-versionhq-1.2.1.15.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.1.15.dist-info/RECORD,,
+versionhq-1.2.1.16.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.1.16.dist-info/METADATA,sha256=hAoTlAANrgYU-5ybybIvcQsKn_q7XAQmljyWh6bnw4Y,22033
+versionhq-1.2.1.16.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.2.1.16.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.1.16.dist-info/RECORD,,