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

versionhq/__init__.py

@@ -18,7 +18,7 @@ from versionhq.tool.model import Tool
 from versionhq.tool.composio import Composio
 
 
-__version__ = "1.1.9.0"
+__version__ = "1.1.9.1"
 __all__ = [
     "Agent",
     "Customer",

versionhq/_utils/cache_handler.py

@@ -6,8 +6,8 @@ from pydantic import BaseModel, PrivateAttr
 class CacheHandler(BaseModel):
     _cache: Dict[str, Any] = PrivateAttr(default_factory=dict)
 
-    def add(self, tool, input, output):
+    def add(self, tool: str, input: str, output: Any) -> None:
         self._cache[f"{tool}-{input}"] = output
 
-    def read(self, tool, input) -> Optional[str]:
+    def read(self, tool: str, input: str) -> Optional[str]:
         return self._cache.get(f"{tool}-{input}")

versionhq/_utils/rpm_controller.py

@@ -1,6 +1,7 @@
 import threading
 import time
 from typing import Optional
+from typing_extensions import Self
 
 from pydantic import BaseModel, Field, PrivateAttr, model_validator
 
@@ -16,14 +17,14 @@ class RPMController(BaseModel):
     _shutdown_flag: bool = PrivateAttr(default=False)
 
     @model_validator(mode="after")
-    def reset_counter(self):
+    def reset_counter(self) -> Self:
         if self.max_rpm is not None:
             if not self._shutdown_flag:
                 self._lock = threading.Lock()
                 self._reset_request_count()
         return self
 
-    def check_or_wait(self):
+    def check_or_wait(self) -> bool:
         if self.max_rpm is None:
             return True
 
@@ -46,16 +47,16 @@ class RPMController(BaseModel):
         else:
             return _check_and_increment()
 
-    def stop_rpm_counter(self):
+    def stop_rpm_counter(self) -> None:
         if self._timer:
             self._timer.cancel()
             self._timer = None
 
-    def _wait_for_next_minute(self):
+    def _wait_for_next_minute(self) -> None:
         time.sleep(60)
         self._current_rpm = 0
 
-    def _reset_request_count(self):
+    def _reset_request_count(self) -> None:
         def _reset():
             self._current_rpm = 0
             if not self._shutdown_flag:

versionhq/_utils/usage_metrics.py

@@ -12,7 +12,7 @@ class UsageMetrics(BaseModel):
     completion_tokens: int = Field(default=0, description="Number of tokens used in completions")
     successful_requests: int = Field(default=0, description="Number of successful requests made")
 
-    def add_usage_metrics(self, usage_metrics: "UsageMetrics"):
+    def add_usage_metrics(self, usage_metrics: "UsageMetrics") -> None:
         """
         Add the usage metrics from another UsageMetrics object.
         """

versionhq/agent/model.py

@@ -1,7 +1,7 @@
 import os
 import uuid
-from abc import ABC
 from typing import Any, Dict, List, Optional, TypeVar
+from typing_extensions import Self
 from dotenv import load_dotenv
 from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
 from pydantic_core import PydanticCustomError
@@ -16,7 +16,6 @@ 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, ToolSet
-from versionhq.tool.tool_handler import ToolHandler
 
 load_dotenv(override=True)
 T = TypeVar("T", bound="Agent")
@@ -51,18 +50,18 @@ class TokenProcess:
     completion_tokens: int = 0
     successful_requests: int = 0
 
-    def sum_prompt_tokens(self, tokens: int):
+    def sum_prompt_tokens(self, tokens: int) -> None:
         self.prompt_tokens = self.prompt_tokens + tokens
         self.total_tokens = self.total_tokens + tokens
 
-    def sum_completion_tokens(self, tokens: int):
+    def sum_completion_tokens(self, tokens: int) -> None:
         self.completion_tokens = self.completion_tokens + tokens
         self.total_tokens = self.total_tokens + tokens
 
-    def sum_cached_prompt_tokens(self, tokens: int):
+    def sum_cached_prompt_tokens(self, tokens: int) -> None:
         self.cached_prompt_tokens = self.cached_prompt_tokens + tokens
 
-    def sum_successful_requests(self, requests: int):
+    def sum_successful_requests(self, requests: int) -> None:
         self.successful_requests = self.successful_requests + requests
 
     def get_summary(self) -> UsageMetrics:
@@ -76,7 +75,7 @@ class TokenProcess:
 
 
 # @track_agent()
-class Agent(ABC, BaseModel):
+class Agent(BaseModel):
     """
     Agent class that run on LLM.
     Agents execute tasks alone or in the team, using RAG tools and knowledge base if any.
@@ -97,10 +96,7 @@ class Agent(ABC, BaseModel):
     backstory: Optional[str] = Field(default=None, description="system context passed to the LLM")
     knowledge: Optional[str] = Field(default=None, description="external knowledge fed to the agent")
     skillsets: Optional[List[str]] = Field(default_factory=list)
-
-    # tools
-    tools: Optional[List[Any]] = Field(default_factory=list)
-    tool_handler: InstanceOf[ToolHandler] = Field(default=None, description="handle tool cache and last used tool")
+    tools: Optional[List[Tool | Any]] = Field(default_factory=list)
 
     # team, task execution rules
     team: Optional[List[Any]] = Field(default=None, description="Team to which the agent belongs")
@@ -146,7 +142,7 @@ class Agent(ABC, BaseModel):
 
 
     @model_validator(mode="after")
-    def validate_required_fields(self):
+    def validate_required_fields(self) -> Self:
         required_fields = ["role", "goal"]
         for field in required_fields:
             if getattr(self, field) is None:
@@ -155,7 +151,7 @@ class Agent(ABC, BaseModel):
 
 
     @model_validator(mode="after")
-    def set_up_llm(self):
+    def set_up_llm(self) -> Self:
         """
         Set up the base model and function calling model (if any) using the LLM class.
         Pass the model config params: `llm`, `max_tokens`, `max_execution_time`, `step_callback`,`respect_context_window` to the LLM class.
@@ -270,31 +266,42 @@ class Agent(ABC, BaseModel):
 
 
     @model_validator(mode="after")
-    def set_up_tools(self):
+    def set_up_tools(self) -> Self:
         """
         Similar to the LLM set up, when the agent has tools, we will declare them using the Tool class.
         """
-
         if not self.tools:
             pass
 
         else:
-            tools_in_class_format = []
-            for tool in self.tools:
-                if isinstance(tool, Tool):
-                    tools_in_class_format.append(tool)
-                elif isinstance(tool, str):
-                    tool_to_add = Tool(name=tool)
-                    tools_in_class_format.append(tool_to_add)
+            tool_list = []
+            def empty_func():
+                return "empty function"
+
+            for item in self.tools:
+                if isinstance(item, Tool):
+                    tool_list.append(item)
+
+                elif isinstance(item, dict):
+                    if "function" not in item:
+                       setattr(item, "function", empty_func)
+                    tool = Tool(**item)
+                    tool_list.append(tool)
+
+                elif isinstance(item, str):
+                    tool = Tool(name=item, function=empty_func)
+                    tool_list.append(tool)
+
                 else:
-                    pass
-            self.tools = tools_in_class_format
+                    tool_list.append(item) # address custom tool
+
+            self.tools = tool_list
 
         return self
 
 
     @model_validator(mode="after")
-    def set_up_backstory(self):
+    def set_up_backstory(self) -> Self:
         """
         Set up the backstory using a templated BACKSTORY when the backstory is None
         """
@@ -305,7 +312,7 @@ class Agent(ABC, BaseModel):
                 role=self.role,
                 knowledge=self.knowledge if isinstance(self.knowledge, str) else None,
                 skillsets=", ".join([item for item in self.skillsets]),
-                rag_tool_overview=", ".join([item.name for item in self.tools]),
+                rag_tool_overview=", ".join([item.name for item in self.tools if hasattr(item, "name")]) if self.tools else "",
                 goal=self.goal,
             )
             self.backstory = backstory
@@ -313,9 +320,7 @@ class Agent(ABC, BaseModel):
         return self
 
 
-    def invoke(
-            self, prompts: str, output_formats: List[TaskOutputFormat], response_fields: List[ResponseField], **kwargs
-            ) -> Dict[str, Any]:
+    def invoke(self, prompts: str, output_formats: List[TaskOutputFormat], response_fields: List[ResponseField], **kwargs) -> Dict[str, Any]:
         """
         Receive the system prompt in string and create formatted prompts using the system prompt and the agent's backstory.
         Then call the base model.
@@ -358,11 +363,10 @@ class Agent(ABC, BaseModel):
         return {"output": response.output if hasattr(response, "output") else response}
 
 
-    def execute_task(self, task, context: Optional[str] = None, tools: Optional[str] = None) -> str:
+    def execute_task(self, task, context: Optional[str] = None) -> str:
         """
-        Execute the task and return the output in string.
-        To simplify, the tools are cascaded from the `tools_called` under the `task` Task instance if any.
-        When the tools are given, the agent must use them.
+        Execute the task and return the response in string.
+        The agent utilizes the tools in task or their own tools if the task.can_use_agent_tools is True.
         The agent must consider the context to excute the task as well when it is given.
         """
 
@@ -371,13 +375,29 @@ class Agent(ABC, BaseModel):
             task_prompt += context
 
         tool_results = []
-        if task.tools_called:
-            for tool_called in task.tools_called:
-                tool_result = tool_called.tool.run()
+        if task.tools:
+            for item in task.tools:
+                if isinstance(item, ToolSet):
+                    tool_result = item.tool.run(**item.kwargs)
+                    tool_results.append(tool_result)
+                elif isinstance(item, Tool):
+                    tool_result = item.run()
+                    tool_results.append(tool_result)
+                else:
+                    try:
+                        item.run()
+                    except:
+                        pass
+
+        if task.can_use_agent_tools is True and self.tools:
+            for tool in self.tools:
+                tool_result = tool.run()
                 tool_results.append(tool_result)
 
-            if task.take_tool_res_as_final:
-                return tool_results
+        if task.take_tool_res_as_final:
+            return tool_results
+
+
 
         # if self.team and self.team._train:
         #     task_prompt = self._training_handler(task_prompt=task_prompt)
@@ -395,9 +415,7 @@ class Agent(ABC, BaseModel):
             self._times_executed += 1
             if self._times_executed > self.max_retry_limit:
                 raise e
-            result = self.execute_task(
-                task, context, [tool_called.tool for tool_called in task.tools_called]
-            )
+            result = self.execute_task(task, context)
 
         if self.max_rpm and self._rpm_controller:
             self._rpm_controller.stop_rpm_counter()

versionhq/agent/parser.py

@@ -73,9 +73,7 @@ class AgentParser:
     def parse(self, text: str) -> AgentAction | AgentFinish:
         thought = self._extract_thought(text)
         includes_answer = FINAL_ANSWER_ACTION in text
-        regex = (
-            r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
-        )
+        regex = r"Action\s*\d*\s*:[\s]*(.*?)[\s]*Action\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
         action_match = re.search(regex, text, re.DOTALL)
         if action_match:
             if includes_answer:
@@ -127,18 +125,9 @@ class AgentParser:
     def _safe_repair_json(self, tool_input: str) -> str:
         UNABLE_TO_REPAIR_JSON_RESULTS = ['""', "{}"]
 
-        # Skip repair if the input starts and ends with square brackets
-        # Explanation: The JSON parser has issues handling inputs that are enclosed in square brackets ('[]').
-        # These are typically valid JSON arrays or strings that do not require repair. Attempting to repair such inputs
-        # might lead to unintended alterations, such as wrapping the entire input in additional layers or modifying
-        # the structure in a way that changes its meaning. By skipping the repair for inputs that start and end with
-        # square brackets, we preserve the integrity of these valid JSON structures and avoid unnecessary modifications.
         if tool_input.startswith("[") and tool_input.endswith("]"):
             return tool_input
 
-        # Before repair, handle common LLM issues:
-        # 1. Replace """ with " to avoid JSON parser errors
-
         tool_input = tool_input.replace('"""', '"')
 
         result = repair_json(tool_input)

versionhq/clients/customer/model.py

@@ -1,16 +1,7 @@
 import uuid
 from abc import ABC
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
-from pydantic import (
-    UUID4,
-    InstanceOf,
-    BaseModel,
-    ConfigDict,
-    Field,
-    create_model,
-    field_validator,
-    model_validator,
-)
+from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq.clients.product.model import Product, ProductProvider
@@ -23,18 +14,11 @@ class Customer(ABC, BaseModel):
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None, description="customer's name if any")
-    product_list: Optional[List[Product]] = Field(
-        default=list, description="store products that the customer is associated with"
-    )
-    analysis: str = Field(
-        default=None, description="store the latest analysis results on the customer"
-    )
-    on_workflow: bool = Field(
-        default=False, description="`True` if they are on some messaging workflows"
-    )
-    on: Optional[str] = Field(
-        default=None, description="destination service for this customer if any"
-    )
+    product_list: Optional[List[Product]] = Field(default=list, description="store products that the customer is associated with")
+    analysis: str = Field(default=None, description="store the latest analysis results on the customer")
+    on_workflow: bool = Field(default=False, description="`True` if they are on some messaging workflows")
+    on: Optional[str] = Field(default=None, description="destination service for this customer if any")
+
 
     @field_validator("id", mode="before")
     @classmethod

versionhq/clients/workflow/model.py

@@ -2,6 +2,7 @@ import uuid
 from abc import ABC
 from datetime import date, datetime, time, timedelta
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+from typing_extensions import Self
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
@@ -63,7 +64,7 @@ class MessagingComponent(ABC, BaseModel):
     condition: str = Field(default=None, max_length=128, description="condition to execute the next messaging component")
 
 
-    def store_scoring_result(self, scoring_subject: str, score_raw: int | Score | ScoreFormat = None):
+    def store_scoring_result(self, scoring_subject: str, score_raw: int | Score | ScoreFormat = None) -> Self:
         """
         Set up the `score` field
         """
@@ -154,7 +155,7 @@ class MessagingWorkflow(ABC, BaseModel):
 
 
     @property
-    def name(self):
+    def name(self) -> str:
         if self.customer.id:
             return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
         else:

versionhq/task/model.py

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

versionhq/team/model.py

@@ -1,7 +1,6 @@
 import uuid
 import warnings
 import json
-from abc import ABC
 from enum import Enum
 from dotenv import load_dotenv
 from concurrent.futures import Future
@@ -108,13 +107,14 @@ class TeamOutput(BaseModel):
         return res
 
 
-class TeamMember(ABC, BaseModel):
+class TeamMember(BaseModel):
     agent: Agent | None = Field(default=None, description="store the agent to be a member")
     is_manager: bool = Field(default=False)
     task: Optional[Task] = Field(default=None)
 
-    def update(self, task: Task):
-        self.task = task
+    @property
+    def is_idling(self):
+        return bool(self.task is None)
 
 
 class Team(BaseModel):
@@ -253,8 +253,8 @@ class Team(BaseModel):
         """
 
         team_planner = TeamPlanner(tasks=self.tasks, planner_llm=self.planning_llm)
-        idling_managers: List[TeamMember] = [member for member in self.members if member.task is None and member.is_manager is True]
-        idling_members: List[TeamMember] =  [member for member in self.members if member.task is None and member.is_manager is False]
+        idling_managers: List[TeamMember] = [member for member in self.members if member.is_idling and member.is_manager is True]
+        idling_members: List[TeamMember] =  [member for member in self.members if member.is_idling and member.is_manager is False]
         unassigned_tasks: List[Task] = self.member_tasks_without_agent
         new_team_members: List[TeamMember] = []
 
@@ -380,16 +380,15 @@ class Team(BaseModel):
                 if skipped_task_output:
                     continue
 
-            # self._prepare_agent_tools(task)
             # self._log_task_start(task, responsible_agent)
 
             if task.async_execution:
                 context = create_raw_outputs(tasks=[task, ], task_outputs=([last_sync_output,] if last_sync_output else []))
-                future = task.execute_async(agent=responsible_agent, context=context, tools=responsible_agent.tools)
+                future = task.execute_async(agent=responsible_agent, context=context)
                 futures.append((task, future, task_index))
             else:
                 context = create_raw_outputs(tasks=[task,], task_outputs=([last_sync_output,] if last_sync_output else [] ))
-                task_output = task.execute_sync(agent=responsible_agent, context=context, tools=responsible_agent.tools)
+                task_output = task.execute_sync(agent=responsible_agent, context=context)
                 if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 

versionhq/tool/model.py

@@ -1,20 +1,21 @@
 from abc import ABC, abstractmethod
 from inspect import signature
 from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin
+from typing_extensions import Self
 from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from versionhq._utils.cache_handler import CacheHandler
 
 
 class BaseTool(ABC, BaseModel):
+    """
+    Abstract class for Tool class.
+    """
 
     class _ArgsSchemaPlaceholder(BaseModel):
         pass
 
-    name: str = 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
 
 
     @field_validator("args_schema", mode="before")
@@ -26,11 +27,7 @@ class BaseTool(ABC, BaseModel):
         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" }},
         )
 
 
@@ -39,8 +36,32 @@ class BaseTool(ABC, BaseModel):
         """any handling"""
 
 
-    def run(self, *args: Any, **kwargs: Any) -> Any:
-        return self._run(*args, **kwargs)
+
+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(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
@@ -85,51 +106,15 @@ class BaseTool(ABC, BaseModel):
         self.args_schema = type(
             class_name,
             (BaseModel,),
-            { "__annotations__": { k: v for k, v in self._run.__annotations__.items() if k != "return" } },
+            { "__annotations__": {
+                k: v for k, v in self._run.__annotations__.items() if k != "return"
+            } },
         )
         return self
 
 
-    @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)
+        return self.run(*args, **kwargs)
 
 
     def run(self, *args, **kwargs) -> Any:
@@ -138,35 +123,47 @@ class Tool(BaseTool):
         """
         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.function is not None:
-            result = self.function(*args, **kwargs)
+            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()
-            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"
-
-                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(input=acceptable_kwargs)
-                        result = self.function(**parsed_kwargs)
-
-            else:
-                tool_handler = ToolHandler(last_used_tool=tool_called, cache_handler=CacheHandler())
-                self.tool_handler = tool_handler
-                parsed_kwargs = self._parse_args(input=acceptable_kwargs)
-                result = self.function(**parsed_kwargs)
+            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
 
 
+    @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"
@@ -204,12 +201,12 @@ class ToolSet(BaseModel):
     """
     Store the tool called and any kwargs used.
     """
-    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    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 InstructorToolSet(BaseModel):
-    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    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")
 
 

versionhq/tool/tool_handler.py

@@ -1,6 +1,7 @@
-from typing import Any, Optional
+from typing import Optional, Any
 from pydantic import InstanceOf
-from versionhq.tool.model import ToolSet, InstructorToolSet, CacheTool
+
+from versionhq.tool.model import ToolSet, InstructorToolSet
 from versionhq._utils.cache_handler import CacheHandler
 
 
@@ -14,9 +15,9 @@ class ToolHandler:
     error: Optional[str]
 
     def __init__(
-            self,
-            last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet] = None,
-            cache_handler: Optional[CacheHandler] = None
+        self,
+        last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet] = None,
+        cache_handler: Optional[CacheHandler] = None
     ):
         self.cache = cache_handler
         self.last_used_tool = last_used_tool
@@ -31,8 +32,9 @@ class ToolHandler:
 
         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: ToolSet = None) -> bool:
@@ -40,4 +42,4 @@ class ToolHandler:
             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.9.0.dist-info → versionhq-1.1.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.9.0
+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

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

@@ -1,24 +1,24 @@
-versionhq/__init__.py,sha256=rtE16vRgpvQ78kBeWEl5kWQgGtGW0G5vHOgwC5hlu1w,931
+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=Sx4NJf3rElndcVzmPdgDgUFM3ATuvtXBwdM4AxB84UQ,18595
-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=Suaih9odeAZOvNJ_wEy_iGAi8KnNJ1f_jIaXuhZTeAY,5833
+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,17 +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=Q2PqyepTLLeoAm7htHHtbc2j2ZXY0lrP2BVbhBCuPq4,19373
+versionhq/task/model.py,sha256=EbgYHLNq8l1zfRDnF-yEcuSZ0aNvzbRmHYgfVyJq84c,19910
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=gkw0rLkEcyAQqYk_fLA83oSvcl7p9dZSocWU0cKeHV4,20301
+versionhq/team/model.py,sha256=E52OUVzUtvR--51SFRJos3JdYKri1t2jbvvzoOvShQc,20181
 versionhq/team/team_planner.py,sha256=uzX2yed7A7gNSs6qH5jIq2zXMVF5BwQQ4HPATsB9DSQ,3675
 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,,
+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,,