versionhq 1.2.4.2__py3-none-any.whl → 1.2.4.5__py3-none-any.whl

versionhq/__init__.py

@@ -32,7 +32,7 @@ from versionhq.agent_network.formation import form_agent_network
 from versionhq.task_graph.draft import workflow
 
 
-__version__ = "1.2.4.2"
+__version__ = "1.2.4.5"
 __all__ = [
     "Agent",
 

versionhq/_prompt/auto_feedback.py

@@ -67,7 +67,7 @@ class PromptFeedbackGraph(TaskGraph):
         if not agents:
             return None
 
-        self.concl_template = base_task.pydantic_output if base_task.pydantic_output else base_task.response_fields if base_task.response_fields else None
+        self.concl_response_schema = base_task.response_schema
         base_agent.callbacks.append(self._reflect)
         init_node = Node(task=base_task, assigned_to=base_agent)
         self.add_node(init_node)

versionhq/_prompt/model.py

@@ -2,7 +2,7 @@
 from typing import Dict, List, Tuple, Any
 from textwrap import dedent
 
-from pydantic import InstanceOf
+from pydantic import InstanceOf, BaseModel
 
 from versionhq._utils import is_valid_url
 
@@ -25,34 +25,26 @@ class Prompt:
 
 
     def _draft_output_prompt(self) -> str:
-        """Drafts prompt for output either from `pydantic_output` or `response_fields`"""
+        """Drafts prompt for output format using `response_schema`."""
 
-        from versionhq.llm.model import DEFAULT_MODEL_PROVIDER_NAME
+        from versionhq.task.model import ResponseField
 
         output_prompt = ""
-        model_provider = self.agent.llm.provider if self.agent else DEFAULT_MODEL_PROVIDER_NAME
+        output_formats_to_follow = dict()
 
-        if self.task.pydantic_output:
-            output_prompt, output_formats_to_follow = "", dict()
-            response_format = str(self.task._structure_response_format(model_provider=model_provider))
-            for k, v in self.task.pydantic_output.model_fields.items():
-                output_formats_to_follow[k] = f"<Return your answer in {v.annotation}>"
+        if self.task.response_schema:
+            if isinstance(self.task.response_schema, list):
+                for item in self.task.response_schema:
+                    if isinstance(item, ResponseField):
+                        output_formats_to_follow[item.title] = f"<Return your answer in {item.data_type.__name__}>"
 
-            output_prompt = f"""Your response MUST be a valid JSON string that strictly follows the response format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or any other non-standard JSON syntax.
-Response format: {response_format}
-Ref. Output image: {output_formats_to_follow}
-"""
-        elif self.task.response_fields:
-            output_prompt, output_formats_to_follow = "", dict()
-            response_format = str(self.task._structure_response_format(model_provider=model_provider))
-            for item in self.task.response_fields:
-                if item:
-                    output_formats_to_follow[item.title] = f"<Return your answer in {item.data_type.__name__}>"
+            elif issubclass(self.task.response_schema, BaseModel):
+                for k, v in self.task.response_schema.model_fields.items():
+                    output_formats_to_follow[k] = f"<Return your answer in {v.annotation}>"
 
             output_prompt = f"""Your response MUST be a valid JSON string that strictly follows the response format. Use double quotes for all keys and string values. Do not use single quotes, trailing commas, or any other non-standard JSON syntax.
-Response format: {response_format}
 Ref. Output image: {output_formats_to_follow}
-"""
+    """
         else:
             output_prompt = "You MUST return your response as a valid JSON serializable string, enclosed in double quotes. Use double quotes for all keys and string values. Do NOT use single quotes, trailing commas, or other non-standard JSON syntax."
 

versionhq/_utils/__init__.py

@@ -2,3 +2,4 @@ from versionhq._utils.logger import Logger
 from versionhq._utils.process_config import process_config
 from versionhq._utils.vars import KNOWLEDGE_DIRECTORY, MAX_FILE_NAME_LENGTH
 from versionhq._utils.is_valid_url import is_valid_url
+from versionhq._utils.usage_metrics import UsageMetrics, ErrorType

versionhq/_utils/usage_metrics.py

@@ -1,55 +1,72 @@
-from pydantic import BaseModel, Field
+import uuid
+import enum
+import datetime
+from typing import Dict, List
+from typing_extensions import Self
+
+from pydantic import BaseModel, UUID4, InstanceOf
+
+
+class ErrorType(enum.Enum):
+    FORMAT = 1
+    TOOL = 2
+    API = 3
+    OVERFITTING = 4
+    HUMAN_INTERACTION = 5
 
 
 class UsageMetrics(BaseModel):
-    """
-    Model to track usage
-    """
-
-    total_tokens: int = Field(default=0, description="total number of tokens used")
-    prompt_tokens: int = Field(default=0, description="number of tokens used in prompts")
-    cached_prompt_tokens: int = Field(default=0, description="number of cached prompt tokens used")
-    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") -> None:
-        """
-        Add the usage metrics from another UsageMetrics object.
-        """
-        self.total_tokens += usage_metrics.total_tokens
-        self.prompt_tokens += usage_metrics.prompt_tokens
-        self.cached_prompt_tokens += usage_metrics.cached_prompt_tokens
-        self.completion_tokens += usage_metrics.completion_tokens
-        self.successful_requests += usage_metrics.successful_requests
-
-
-
-# class TokenProcess:
-#     total_tokens: int = 0
-#     prompt_tokens: int = 0
-#     cached_prompt_tokens: int = 0
-#     completion_tokens: int = 0
-#     successful_requests: int = 0
-
-#     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) -> None:
-#         self.completion_tokens = self.completion_tokens + tokens
-#         self.total_tokens = self.total_tokens + tokens
-
-#     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) -> None:
-#         self.successful_requests = self.successful_requests + requests
-
-#     def get_summary(self) -> UsageMetrics:
-#         return UsageMetrics(
-#             total_tokens=self.total_tokens,
-#             prompt_tokens=self.prompt_tokens,
-#             cached_prompt_tokens=self.cached_prompt_tokens,
-#             completion_tokens=self.completion_tokens,
-#             successful_requests=self.successful_requests,
-#         )
+    """A Pydantic model to manage token usage, errors, job latency."""
+
+    id: UUID4 = uuid.uuid4() # stores task id or task graph id
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    successful_requests: int = 0
+    total_errors: int = 0
+    error_breakdown: Dict[ErrorType, int] = dict()
+    latency: float = 0.0  # in ms
+
+    def record_token_usage(self, token_usages: List[Dict[str, int]]) -> None:
+        """Records usage metrics from the raw response of the model."""
+
+        if token_usages:
+            for item in token_usages:
+                self.total_tokens += int(item["total_tokens"]) if "total_tokens" in item else 0
+                self.completion_tokens += int(item["completion_tokens"])  if "completion_tokens" in item else 0
+                self.prompt_tokens += int(item["prompt_tokens"]) if "prompt_tokens" in item else 0
+
+
+    def record_errors(self, type: ErrorType = None) -> None:
+        self.total_errors += 1
+        if type:
+            if type in self.error_breakdown:
+                self.error_breakdown[type] += 1
+            else:
+                self.error_breakdown[type] = 1
+
+
+    def record_latency(self, start_dt: datetime.datetime, end_dt: datetime.datetime) -> None:
+        self.latency += round((end_dt - start_dt).total_seconds() * 1000, 3)
+
+
+    def aggregate(self, metrics: InstanceOf["UsageMetrics"]) -> Self:
+        if not metrics:
+            return self
+
+        self.total_tokens += metrics.total_tokens if metrics.total_tokens else 0
+        self.prompt_tokens += metrics.prompt_tokens if metrics.prompt_tokens else 0
+        self.completion_tokens += metrics.completion_tokens if metrics.completion_tokens else 0
+        self.successful_requests += metrics.successful_requests  if metrics.successful_requests else 0
+        self.total_errors += metrics.total_errors if metrics.total_errors else 0
+        self.latency += metrics.latency if metrics.latency else 0.0
+        self.latency = round(self.latency, 3)
+
+        if metrics.error_breakdown:
+            for k, v in metrics.error_breakdown.items():
+                if self.error_breakdown and k in self.error_breakdown:
+                    self.error_breakdown[k] += int(v)
+                else:
+                    self.error_breakdown.update({ k: v })
+
+        return self

versionhq/agent/inhouse_agents.py

@@ -30,7 +30,7 @@ vhq_task_evaluator = Agent(
 vhq_formation_planner = Agent(
     role="vhq-Formation Planner",
     goal="Plan a formation of agents based on the given task descirption.",
-    llm="gemini/gemini-2.0-flash-exp",
+    llm="gemini/gemini-2.0-flash",
     llm_config=dict(top_p=0.8, topK=40, temperature=0.9),
     maxit=1,
     max_retry_limit=1,
@@ -46,7 +46,7 @@ vhq_formation_planner = Agent(
 vhq_agent_creator = Agent(
     role="vhq-Agent Creator",
     goal="build an agent that can handle the given task",
-    llm="gemini/gemini-2.0-flash-exp",
+    llm="gemini/gemini-2.0-flash",
     maxit=1,
     max_retry_limit=1,
 )

versionhq/agent/model.py

@@ -1,6 +1,6 @@
 import os
 import uuid
-from typing import Any, Dict, List, Optional, TypeVar, Callable, Type
+from typing import Any, Dict, List, Optional, TypeVar, Callable, Type, Tuple
 from typing_extensions import Self
 from dotenv import load_dotenv
 
@@ -11,7 +11,7 @@ from versionhq.agent.rpm_controller import RPMController
 from versionhq.tool.model import Tool, ToolSet, BaseTool
 from versionhq.knowledge.model import BaseKnowledgeSource, Knowledge
 from versionhq.memory.model import ShortTermMemory, LongTermMemory, UserMemory
-from versionhq._utils import Logger, process_config, is_valid_url
+from versionhq._utils import Logger, process_config, is_valid_url, ErrorType
 
 
 load_dotenv(override=True)
@@ -373,16 +373,17 @@ class Agent(BaseModel):
 
             if tool_res_as_final:
                 raw_response = self.func_calling_llm.call(messages=messages, tools=tools, tool_res_as_final=True)
-                task._tokens = self.func_calling_llm._tokens
+                task._usage.record_token_usage(token_usages=self.func_calling_llm._usages)
             else:
                 raw_response = self.llm.call(messages=messages, response_format=response_format, tools=tools)
-                task._tokens = self.llm._tokens
+                task._usage.record_token_usage(token_usages=self.llm._usages)
 
             task_execution_counter += 1
             Logger(**self._logger_config, filename=self.key).log(level="info", message=f"Agent response: {raw_response}", color="green")
             return raw_response
 
         except Exception as e:
+            task._usage.record_errors(type=ErrorType.API)
             Logger(**self._logger_config, filename=self.key).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:
@@ -474,9 +475,16 @@ class Agent(BaseModel):
         return self
 
 
-    def start(self, context: Any = None, tool_res_as_final: bool = False, image: str = None, file: str = None, audio: str = None) -> Any | None:
+    def start(
+            self,
+            context: Any = None,
+            tool_res_as_final: bool = False,
+            image: str = None,
+            file: str = None,
+            audio: str = None
+        ) -> Tuple[Any | None, Any | None]:
         """
-        Defines and executes a task when it is not given and returns TaskOutput object.
+        Defines and executes a task, then returns TaskOutput object with the generated task.
         """
 
         if not self.role:
@@ -490,14 +498,14 @@ class Agent(BaseModel):
 
         task = Task(
             description=f"Generate a simple result in a sentence to achieve the goal: {self.goal if self.goal else self.role}. If needed, list up necessary steps in concise manner.",
-            pydantic_output=Output,
+            response_schema=Output,
             tool_res_as_final=tool_res_as_final,
             image=image, #REFINEME - query memory/knowledge or self create
             file=file,
             audio=audio,
         )
         res = task.execute(agent=self, context=context)
-        return res
+        return res, task
 
 
     def execute_task(self, task, context: Optional[Any] = None, task_tools: Optional[List[Tool | ToolSet]] = list()) -> str:
@@ -526,6 +534,8 @@ class Agent(BaseModel):
                 tool_res_as_final=task.tool_res_as_final,
                 task=task
             )
+            if raw_response:
+                task._usage.successful_requests += 1
 
         except Exception as e:
             self._times_executed += 1

versionhq/agent_network/formation.py

@@ -74,8 +74,8 @@ def form_agent_network(
         leader_agent: str
 
     vhq_task = Task(
-        description=f"Design a team of specialized agents to fully automate the following task and achieve the expected outcome. For each agent, define its role, task description, and expected outputs via the task with items in a list. Then specify the formation if the formation is not given. If you think SUPERVISING or HYBRID is the best formation, include a leader_agent role, else leave the leader_agent role blank.\nTask: {str(task)}\nExpected outcome: {prompt_expected_outcome}\nFormation: {prompt_formation}",
-        pydantic_output=Outcome
+        description=f"Design a team of specialized agents to fully automate the following task and deliver the expected outcome. For each agent, define its role, task description, and expected outputs via the task with items in a list. Then specify the formation if the formation is not given. If you think SUPERVISING or HYBRID is the best formation, include a leader_agent role, else leave the leader_agent role blank.\nTask: {str(task)}\nExpected outcome: {prompt_expected_outcome}\nFormation: {prompt_formation}",
+        response_schema=Outcome
     )
 
     if agents:
@@ -93,10 +93,11 @@ def form_agent_network(
 
     network_tasks = []
     members = []
-    leader = str(res.pydantic.leader_agent) if res.pydantic and hasattr(res.pydantic, "leader_agent") else str(res.json_dict["leader_agent"]) if "leader_agent" in res.json_dict else None
-
-    agent_roles = res.pydantic.agent_roles if res.pydantic else res.json_dict["agent_roles"]
-    created_agents = [Agent(role=str(item), goal=str(item)) for item in agent_roles]
+    leader = res._fetch_value_of(key="leader_agent")
+    agent_roles =  res._fetch_value_of(key="agent_roles")
+    created_agents = [Agent(role=str(item), goal=str(item)) for item in agent_roles] if agent_roles else []
+    task_descriptions = res._fetch_value_of(key="task_descriptions")
+    task_outcomes = res._fetch_value_of(key="task_outcomes")
 
     if agents:
         for i, agent in enumerate(created_agents):
@@ -108,9 +109,9 @@ def form_agent_network(
 
     created_tasks = []
 
-    if res.pydantic:
-        for i, item in enumerate(res.pydantic.task_outcomes):
-            if len(res.pydantic.task_descriptions) > i and res.pydantic.task_descriptions[i]:
+    if task_outcomes:
+        for i, item in enumerate(task_outcomes):
+            if len(task_descriptions) > i and task_descriptions[i]:
                 fields = {}
                 for ob in item:
                     try:
@@ -119,24 +120,9 @@ def form_agent_network(
                     except:
                         pass
                 output = create_model("Output", **fields) if fields else None
-                _task = Task(description=res.pydantic.task_descriptions[i], pydantic_output=output)
+                _task = Task(description=task_descriptions[i], response_schema=output)
                 created_tasks.append(_task)
 
-    elif res.json_dict:
-        for i, item in enumerate(res["task_outcomes"]):
-            if len(res["task_descriptions"]) > i and res["task_descriptions"][i]:
-                fields = {}
-                for ob in item:
-                    try:
-                        field_name = str(ob).lower().split(":")[0].replace(" ", "_")[0: 16]
-                        fields[field_name] = (str, Field(default=None))
-                    except:
-                        pass
-                output = create_model("Output", **fields) if fields else None
-                _task = Task(description=res["task_descriptions"][i], pydantic_output=output)
-                created_tasks.append(_task)
-
-
     if len(created_tasks) <= len(created_agents):
         for i in range(len(created_tasks)):
             is_manager = False if not leader else bool(created_agents[i].role.lower() == leader.lower())
@@ -159,7 +145,6 @@ def form_agent_network(
 
         network_tasks.extend(created_tasks[len(created_agents):len(created_tasks)])
 
-
     if _formation == Formation.SUPERVISING and not [member for member in members if member.is_manager]:
         role = leader if leader else "Leader"
         manager = Member(agent=Agent(role=role), is_manager=True)

versionhq/agent_network/model.py

@@ -90,7 +90,6 @@ class AgentNetwork(BaseModel):
 
     cache: bool = Field(default=True)
     execution_logs: List[Dict[str, Any]] = Field(default_factory=list, description="list of execution logs of the tasks handled by members")
-    # usage_metrics: Optional[UsageMetrics] = Field(default=None, description="usage metrics for all the llm executions")
 
 
     def __name__(self) -> str:
@@ -207,7 +206,7 @@ class AgentNetwork(BaseModel):
         for unassgined_task in unassigned_tasks:
             task = Task(
                 description=f"Based on the following task summary, draft an agent's role and goal in concise manner. Task summary: {unassgined_task.summary}",
-                response_fields=[
+                response_schema=[
                     ResponseField(title="goal", data_type=str, required=True),
                     ResponseField(title="role", data_type=str, required=True),
                 ],

versionhq/llm/llm_vars.py

@@ -27,8 +27,9 @@ MODELS = {
         "o1-preview",
     ],
     "gemini": [
-        "gemini/gemini-1.5-flash",
-        "gemini/gemini-1.5-pro",
+        "gemini/gemini-2.0-flash",
+        "gemini/gemini-2.0-flash-thinking-exp",
+        "gemini/gemini-2.0-flash-lite-preview-02-05",
         "gemini/gemini-2.0-flash-exp",
     ],
     "anthropic": [
@@ -75,6 +76,7 @@ ENV_VARS = {
     "huggingface": ["HUGGINGFACE_API_KEY", ],
     "bedrock": ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"],
     "sagemaker": ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_REGION_NAME"],
+    "azure_ai": ["AZURE_AI_API_KEY", "AZURE_AI_API_BASE"],
 }
 
 
@@ -90,9 +92,10 @@ LLM_CONTEXT_WINDOW_SIZES = {
     "o1-preview": 128000,
     "o1-mini": 128000,
 
-    "gemini/gemini-1.5-flash": 1048576,
-    "gemini/gemini-1.5-pro": 2097152,
     "gemini/gemini-2.0-flash-exp": 1048576,
+    "gemini/gemini-2.0-flash": 1048576,
+    "gemini/gemini-2.0-flash-thinking-exp": 1048576,
+    "gemini/gemini-2.0-flash-lite-preview-02-05": 1048576,
 
     "claude-3-7-sonnet-latest": 200000,
     "claude-3-5-haiku-latest": 200000,

versionhq/llm/model.py

@@ -69,7 +69,7 @@ class LLM(BaseModel):
 
     _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _init_model_name: str = PrivateAttr(default=None)
-    _tokens: int = PrivateAttr(default=0) # aggregate number of tokens consumed
+    _usages: list[Dict[str, int]] = PrivateAttr(default_factory=list)
 
     model: str = Field(default=None)
     provider: Optional[str] = Field(default=None, description="model provider")
@@ -181,8 +181,6 @@ class LLM(BaseModel):
         """
         litellm.drop_params = True
 
-        self._tokens = 0
-
         if self.callbacks:
             self._set_callbacks(self.callbacks)
 
@@ -230,6 +228,9 @@ class LLM(BaseModel):
             if self.context_window_size and valid_config["max_tokens"] > self.context_window_size:
                 valid_config["max_tokens"] = self.context_window_size
 
+        if "model" in valid_config:
+            self.model = valid_config.pop("model")
+
         self.llm_config = valid_config
         return valid_config
 
@@ -319,7 +320,7 @@ class LLM(BaseModel):
                 if not tools:
                     params = self._create_valid_params(config=config)
                     res = litellm.completion(model=self.model, messages=messages, stream=False, **params, **cred)
-                    self._tokens += int(res["usage"]["total_tokens"])
+                    self._usages.append(res["usage"])
                     return res["choices"][0]["message"]["content"]
 
                 else:
@@ -384,15 +385,13 @@ class LLM(BaseModel):
                         else:
                             pass
 
-
                 if tool_res_as_final:
                     return tool_res
                 else:
                     res = litellm.completion(model=self.model, messages=messages, **params, **cred)
-                    self._tokens += int(res["usage"]["total_tokens"])
+                    self._usages.append(res["usage"])
                     return res.choices[0].message.content
 
-
             except JSONSchemaValidationError as e:
                 self._logger.log(level="error", message="Raw Response: {}".format(e.raw_response), color="red")
                 raise e

versionhq/storage/task_output_storage.py

@@ -147,8 +147,8 @@ class TaskOutputStorageHandler:
             description=str(task.description),
             raw=str(task.output.raw),
             responsible_agents=str(task.processed_agents),
-            tokens=task.output._tokens,
-            latency=task.output.latency,
+            tokens=task._usage.total_tokens,
+            latency=task._usage.latency,
             score=task.output.aggregate_score if task.output.aggregate_score else "None",
         )
         self.storage.add(task=task, output=output_to_store, inputs=inputs)

versionhq/task/model.py

@@ -6,7 +6,7 @@ import inspect
 import enum
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, Set, Optional, Callable, Type, Tuple
+from typing import Any, Dict, List, Set, Optional, Callable, Type
 from typing_extensions import Annotated, Self
 
 from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, InstanceOf, field_validator
@@ -15,7 +15,7 @@ from pydantic_core import PydanticCustomError
 import versionhq as vhq
 from versionhq.task.evaluation import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
-from versionhq._utils import process_config, Logger
+from versionhq._utils import process_config, Logger, UsageMetrics, ErrorType
 
 
 class TaskExecutionType(enum.Enum):
@@ -175,18 +175,31 @@ class TaskOutput(BaseModel):
     A class to store the final output of the given task in raw (string), json_dict, and pydantic class formats.
     """
 
-    _tokens: int = PrivateAttr(default=0)
-
     task_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store Task ID")
     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)
     tool_output: Optional[Any] = Field(default=None, description="stores tool result when the task takes tool output as its final output")
     callback_output: Optional[Any] = Field(default=None, description="stores task or agent callback outcome")
-    latency: float = Field(default=None, description="job latency in ms")
     evaluation: Optional[InstanceOf[Evaluation]] = Field(default=None, description="stores overall evaluation of the task output. stored in ltm")
 
 
+    def _fetch_value_of(self, key: str = None) -> Any:
+        """Returns a value to the given key."""
+
+        if not key:
+            return None
+
+        if self.pydantic and hasattr(self.pydantic, key):
+            return getattr(self.pydantic, key)
+
+        elif self.json_dict and key in self.json_dict:
+            return self.json_dict[key]
+
+        else:
+            return None
+
+
     def _to_context_prompt(self) -> str:
         """Formats prompt context in text formats from the final response."""
 
@@ -223,9 +236,8 @@ class TaskOutput(BaseModel):
             description = EVALUATE.format(task_description=task.description, task_output=self.raw, eval_criteria=str(item))
             description = description + fsl_prompt if fsl_prompt else description
 
-            task_eval = Task(description=description, pydantic_output=EvaluationItem)
+            task_eval = Task(description=description, response_schema=EvaluationItem)
             res = task_eval.execute(agent=self.evaluation.eval_by)
-            self._tokens += task_eval._tokens
 
             if res.pydantic:
                 item = EvaluationItem(
@@ -296,11 +308,7 @@ class Task(BaseModel):
     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)
     description: str = Field(description="Description of the actual task")
-
-    # response format
-    response_schema: Optional[Type[BaseModel] | List[ResponseField]] = Field(default=None)
-    pydantic_output: Optional[Type[BaseModel]] = Field(default=None, description="store Pydantic class as structured response format")
-    response_fields: Optional[List[ResponseField]] = Field(default_factory=list, description="store list of ResponseField as structured response format")
+    response_schema: Optional[Type[BaseModel] | List[ResponseField]] = Field(default=None, description="stores response format")
 
     # tool usage
     tools: Optional[List[ToolSet | Tool | Any]] = Field(default_factory=list, description="tools that the agent can use aside from their tools")
@@ -328,9 +336,7 @@ class Task(BaseModel):
     fsls: Optional[list[str]] = Field(default=None, description="stores ideal/weak responses")
 
     # recording
-    _tokens: int = 0
-    _tool_errors: int = 0
-    _format_errors: int = 0
+    _usage: UsageMetrics = PrivateAttr(default=None)
     _delegations: int = 0
     processed_agents: Set[str] = Field(default_factory=set, description="store keys of the agents that executed the task")
     output: Optional[TaskOutput] = Field(default=None, description="store the final TaskOutput object")
@@ -355,6 +361,8 @@ class Task(BaseModel):
         for field in required_fields:
             if getattr(self, field) is None:
                 raise ValueError( f"{field} must be provided either directly or through config")
+
+        self._usage = UsageMetrics(id=self.id)
         return self
 
 
@@ -376,7 +384,7 @@ class Task(BaseModel):
 
 
     def _structure_response_format(self, data_type: str = "object", model_provider: str = "gemini") -> Dict[str, Any] | None:
-        """Structures `response_fields` or `pydantic_output` to a LLM response format."""
+        """Structures `response_schema` into the LLM response format."""
 
         from versionhq.task.structured_response import StructuredOutput
 
@@ -386,28 +394,29 @@ class Task(BaseModel):
             return response_format
 
         else:
-            if self.response_fields:
-                properties, required_fields = {}, []
-                for i, item in enumerate(self.response_fields):
-                    if item:
-                        properties.update(item._format_props())
-                        required_fields.append(item.title)
-
-                response_schema = {
-                    "type": data_type,
-                    "properties": properties,
-                    "required": required_fields,
-                    "additionalProperties": False,
-                }
-                response_format = {
-                    "type": "json_schema",
-                    "json_schema": { "name": "outcome", "schema": response_schema }
-                }
+            if self.response_schema:
+                if isinstance(self.response_schema, list):
+                    properties, required_fields = {}, []
+                    for i, item in enumerate(self.response_schema):
+                        if isinstance(item, ResponseField):
+                            properties.update(item._format_props())
+                            required_fields.append(item.title)
+
+                    response_schema = {
+                        "type": data_type,
+                        "properties": properties,
+                        "required": required_fields,
+                        "additionalProperties": False,
+                    }
+                    response_format = {
+                        "type": "json_schema",
+                        "json_schema": { "name": "outcome", "schema": response_schema }
+                    }
 
-            elif self.pydantic_output:
-                response_format = StructuredOutput(response_format=self.pydantic_output, provider=model_provider)._format()
+                elif issubclass(self.response_schema, BaseModel):
+                    response_format = StructuredOutput(response_format=self.response_schema, provider=model_provider)._format()
 
-            return response_format
+        return response_format
 
 
     def _sanitize_raw_output(self, raw: str) -> Dict[str, str]:
@@ -423,6 +432,7 @@ class Task(BaseModel):
         r = re.sub(r"'\b", '"', r)
         r = r.strip()
         r = r.replace("  ", "")
+
         try:
             output = json.loads(r)
         except:
@@ -433,14 +443,14 @@ class Task(BaseModel):
             output = json.loads(j)
 
         if isinstance(output, dict):
-            return output
+            return output["json_schema"] if "json_schema" in output else output
         else:
             try:
                 output = ast.literal_eval(j)
             except:
                 output = ast.literal_eval(r)
 
-            return output if isinstance(output, dict) else { "output": str(r) }
+            return output["json_schema"] if isinstance(output, dict) and "json_schema" in output else output if isinstance(output, dict) else { "output": str(r) }
 
 
     def _create_json_output(self, raw: str) -> Dict[str, Any]:
@@ -456,31 +466,34 @@ class Task(BaseModel):
         try:
             output = json.loads(raw)
             if isinstance(output, dict):
-                return output
+                return output["json_schema"] if "json_schema" in output else output
             else:
-               output = self._sanitize_raw_output(raw=raw)
-               return output
+                output = self._sanitize_raw_output(raw=raw)
+                return output
         except:
             output = self._sanitize_raw_output(raw=raw)
+            self._usage.record_errors(type=ErrorType.FORMAT)
             return output
 
 
-    def _create_pydantic_output(self, raw: str = None, json_dict: Dict[str, Any] = None) -> InstanceOf[BaseModel]:
+    def _create_pydantic_output(self, raw: str = None, json_dict: Dict[str, Any] = None) -> InstanceOf[BaseModel] | None:
         """
         Create pydantic output from raw or json_dict output.
         """
 
-        output_pydantic = self.pydantic_output
-
-        try:
-            json_dict = json_dict if json_dict else self._create_json_output(raw=raw)
+        if self.response_schema and not isinstance(self.response_schema, list):
+            output_pydantic = self.response_schema
+            try:
+                json_dict = json_dict if json_dict else self._create_json_output(raw=raw)
 
-            for k, v in json_dict.items():
-                setattr(output_pydantic, k, v)
-        except:
-            pass
+                for k, v in json_dict.items():
+                    setattr(output_pydantic, k, v)
+            except:
+                pass
+            return output_pydantic
 
-        return output_pydantic
+        else:
+            return None
 
 
     def interpolate_inputs(self, inputs: Dict[str, Any]) -> None:
@@ -592,13 +605,6 @@ class Task(BaseModel):
             res = self._test_time_computation(agent=agent, context=context)
             return res
 
-        # if self._pfg:
-        #     res, all_outputs = self.pfg.activate()
-        #     tokens, latency = self.pfg.usage
-        #     self._tokens = tokens
-        #     res.latency = latency
-        #     return res
-
         match type:
             case TaskExecutionType.SYNC:
                 res = self._execute_sync(agent=agent, context=context)
@@ -629,11 +635,11 @@ class Task(BaseModel):
     def _execute_core(self, agent, context: Optional[Any]) -> TaskOutput:
         """A core method to execute a single task."""
 
+        start_dt = datetime.datetime.now()
         task_output: InstanceOf[TaskOutput] = None
         raw_output: str = None
         tool_output: str | list = None
         task_tools: List[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = []
-        started_at, ended_at = datetime.datetime.now(), datetime.datetime.now()
         user_prompt, dev_prompt = None, None
 
         if self.tools:
@@ -647,22 +653,19 @@ class Task(BaseModel):
             self._delegations += 1
 
         if self.tool_res_as_final == True:
-            started_at = datetime.datetime.now()
             user_prompt, dev_prompt, tool_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
             raw_output = str(tool_output) if tool_output else ""
-            ended_at = datetime.datetime.now()
+            if not raw_output:
+                self._usage.record_errors(type=ErrorType.TOOL)
             task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=raw_output)
 
         else:
-            started_at = datetime.datetime.now()
             user_prompt, dev_prompt, raw_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
-            ended_at = datetime.datetime.now()
-
             json_dict_output = self._create_json_output(raw=raw_output)
             if "outcome" in json_dict_output:
                 json_dict_output = self._create_json_output(raw=str(json_dict_output["outcome"]))
 
-            pydantic_output = self._create_pydantic_output(raw=raw_output, json_dict=json_dict_output) if self.pydantic_output else None
+            pydantic_output = self._create_pydantic_output(raw=raw_output, json_dict=json_dict_output)
 
             task_output = TaskOutput(
                 task_id=self.id,
@@ -671,8 +674,6 @@ class Task(BaseModel):
                 json_dict=json_dict_output,
             )
 
-        task_output.latency = round((ended_at - started_at).total_seconds() * 1000, 3)
-        task_output._tokens = self._tokens
         self.output = task_output
         self.processed_agents.add(agent.key)
 
@@ -706,6 +707,8 @@ class Task(BaseModel):
                 self.output = task_output
             self._store_logs()
 
+        end_dt = datetime.datetime.now()
+        self._usage.record_latency(start_dt=start_dt, end_dt=end_dt)
         return task_output
 
 
@@ -716,27 +719,27 @@ class Task(BaseModel):
         from versionhq._prompt.model import Prompt
         from versionhq._prompt.auto_feedback import PromptFeedbackGraph
 
+        # self._usage = None
         prompt = Prompt(task=self, agent=agent, context=context)
         pfg = PromptFeedbackGraph(prompt=prompt, should_reform=self.human, reform_trigger_event=ReformTriggerEvent.USER_INPUT if self.human else None)
         pfg = pfg.set_up_graph()
         self._pfg = pfg
 
-        # try:
-        if self._pfg and self.output is None:
-            res, _ = self._pfg.activate()
-            tokens, latency = self._pfg.usage
-            self._tokens = tokens
-            res.latency = latency
-            return res
+        try:
+            if self._pfg and self.output is None:
+                res, all_outputs = self._pfg.activate()
+                if all_outputs: self._usage = self._pfg._usage
+                return res
 
-        # except:
-        #     Logger().log(level="error", message="Failed to execute the task.", color="red")
-        #     return None, None
+        except:
+            self._usage.record_errors(type=ErrorType.API)
+            Logger().log(level="error", message="Failed to execute the task.", color="red")
+            return None
 
 
     @property
     def key(self) -> str:
-        output_format = "json" if self.response_fields else "pydantic" if self.pydantic_output is not None else "raw"
+        output_format = "json" if self.response_schema else "raw"
         source = [self.description, output_format]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
 

versionhq/task_graph/draft.py

@@ -41,7 +41,7 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
             "https://www.geeksforgeeks.org/graph-and-its-representations/",
             ", ".join([k for k in DependencyType._member_map_.keys()]),
         ],
-        llm="gemini-2.0",
+        llm="gemini/gemini-2.0-flash",
         with_memory=with_memory,
         maxit=1,
         max_retry_limit=1,
@@ -49,7 +49,7 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
 
     task = Task(
         description=dedent(f"Design a resource-efficient workflow to achieve the following goal: {final_output_prompt}. The workflow should consist of a list of detailed tasks that represent decision making points, each with the following information:\nname: A concise name of the task\ndescription: A concise description of the task.\nconnections: A list of target tasks that this task connects to.\ndependency_types: The type of dependency between this task and each of its connected task. \noutput: key output from the task in a word.\n\nUse the following dependency types: {dep_type_prompt}.\n\nPrioritize minimizing resource consumption (computation, memory, and data transfer) when defining tasks, connections, and dependencies.  Consider how data is passed between tasks and aim to reduce unnecessary data duplication or transfer. Explain any design choices made to optimize resource usage."),
-        response_fields=[
+        response_schema=[
             ResponseField(title="tasks", data_type=list, items=dict, properties=[
                 ResponseField(title="name", data_type=str),
                 ResponseField(title="description", data_type=str),
@@ -73,13 +73,13 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
 
     for item in task_items:
         key = item["output"].lower().replace(" ", "_") if item["output"] else "output"
-        task = Task(name=item["name"], description=item["description"], response_fields=[ResponseField(title=key, data_type=str)])
+        task = Task(name=item["name"], description=item["description"], response_schema=[ResponseField(title=key, data_type=str)])
         tasks.append(task)
         nodes.append(Node(task=task))
 
     task_graph = TaskGraph(
         nodes={node.identifier: node for node in nodes},
-        concl_format=final_output,
+        concl_response_schema=final_output,
         concl=None,
         should_reform=human,
         reform_trigger_event=ReformTriggerEvent.USER_INPUT if human else None,
@@ -96,6 +96,6 @@ def workflow(final_output: Type[BaseModel], context: Any = None, human: bool = F
                 task_graph.add_dependency(
                     source=source.identifier, target=target.identifier, dependency_type=dependency_type)
 
-    task_graph.visualize()
+    # task_graph.visualize()
 
     return task_graph

versionhq/task_graph/model.py

@@ -14,8 +14,8 @@ from pydantic import BaseModel, InstanceOf, Field, UUID4, field_validator, model
 from pydantic_core import PydanticCustomError
 
 from versionhq.agent.model import Agent
-from versionhq.task.model import Task, TaskOutput, Evaluation
-from versionhq._utils import Logger
+from versionhq.task.model import Task, TaskOutput, Evaluation, ResponseField
+from versionhq._utils import Logger, UsageMetrics, ErrorType
 
 
 class ReformTriggerEvent(enum.Enum):
@@ -129,7 +129,7 @@ class Node(BaseModel):
         else:
             self.status = TaskStatus.IN_PROGRESS
             agent = agent if agent else self.assigned_to
-            self.task.pydantic_output = self.task.pydantic_output if self.task.pydantic_output else response_format if type(response_format) == BaseModel else None
+            self.task.response_schema = self.task.response_schema if self.task.response_schema else response_format if type(response_format) == BaseModel or isinstance(response_format, list) else None
             res = self.task.execute(agent=agent, context=context)
 
             if isinstance(res, Future): # activate async
@@ -393,11 +393,13 @@ class Graph(ABC, BaseModel):
 
 
 class TaskGraph(Graph):
+    _usage: Optional[UsageMetrics] = None
+
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     should_reform: bool = False
     reform_trigger_event: Optional[ReformTriggerEvent] = None
     outputs: Dict[str, TaskOutput] = Field(default_factory=dict, description="stores node identifier and TaskOutput")
-    concl_template: Optional[Dict[str, Any] | Type[BaseModel]] = Field(default=None, description="stores final response format in Pydantic class or JSON dict")
+    concl_response_schema: Optional[List[ResponseField] | Type[BaseModel]] = Field(default=None, description="stores final response schema in Pydantic class or response fields")
     concl: Optional[TaskOutput] = Field(default=None, description="stores the final or latest conclusion of the entire task graph")
 
 
@@ -418,6 +420,40 @@ class TaskGraph(Graph):
             Logger().log(level="error", message=f"Failed to save the graph {str(self.id)}: {str(e)}", color="red")
 
 
+    def _handle_usage(self) -> None:
+        """Returns total tokens and latency spended for the graph execution."""
+        if not self.nodes:
+            return None
+
+        self._usage = self._usage if self._usage else UsageMetrics(id=self.id)
+
+        for node in self.nodes.values():
+            if node.task and node.task._usage:
+                self._usage.aggregate(metrics=node.task._usage)
+
+
+    def _handle_human_input(self) -> str | None:
+        """Handles input from human."""
+        request = None
+
+        print('Proceed? Y/n:')
+        x = input()
+
+        if x.lower() == "y":
+            Logger().log(message="Ok, proceeding to the next graph execution.", level="info", color="blue")
+
+        else:
+            request = input("Request?")
+            if request:
+                Logger().log(message=f"Ok. regenerating the graph based on your input: ', {request}", level="info", color="blue")
+            else:
+                Logger().log(message="Cannot recognize your request.", level="error", color="red")
+                self._usage = self._usage if self._usage else UsageMetrics(id=self.id)
+                self._usage.record_errors(type=ErrorType.HUMAN_INTERACTION)
+
+        return request
+
+
     def add_task(self, task: Node | Task) -> Node:
         """Convert `task` to a Node object and add it to G"""
 
@@ -633,8 +669,9 @@ class TaskGraph(Graph):
                     res, _ = self.handle_reform(target=target)
 
             self.concl = res
-            self.concl_template = self.concl_template if self.concl_template else res.pydantic.__class__ if res.pydantic else None
+            self.concl_response_schema = self.concl_response_schema if self.concl_response_schema else res.pydantic.__class__ if res.pydantic else None
              # last_task_output = [v for v in self.outputs.values()][len([v for v in self.outputs.values()]) - 1] if [v for v in self.outputs.values()] else None
+            self._handle_usage()
             return res, self.outputs
 
 
@@ -657,27 +694,6 @@ class TaskGraph(Graph):
         return eval
 
 
-    def _handle_human_input(self) -> str | None:
-        """Handles input from human."""
-        request = None
-
-        print('Proceed? Y/n:')
-        x = input()
-
-        if x.lower() == "y":
-            Logger().log(message="Ok, proceeding to the next graph execution.", level="info", color="blue")
-
-        else:
-            request = input("Request?")
-
-            if request:
-                Logger().log(message=f"Ok. regenerating the graph based on your input: ', {request}", level="info", color="blue")
-            else:
-                Logger().log(message="Cannot recognize your request.", level="error", color="red")
-
-        return request
-
-
     def handle_reform(self, target: str = None) -> Self:
         task_description = "Improve the given output: "
         if target:
@@ -693,15 +709,3 @@ class TaskGraph(Graph):
         self.add_node(node=new_node)
         self.add_dependency(source=target, target=new_node.identifier)
         return self.activate(target=new_node.identifier)
-
-
-    @property
-    def usage(self) -> Tuple[int, float]:
-        """Returns aggregate number of consumed tokens and job latency in ms during the activation"""
-
-        tokens, latency = 0, 0
-        for v in self.outputs.values():
-            tokens += v._tokens
-            latency += v.latency
-
-        return tokens, latency

{versionhq-1.2.4.2.dist-info → versionhq-1.2.4.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.4.2
+Version: 1.2.4.5
 Summary: Autonomous agent networks for task automation with multi-step reasoning.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -295,7 +295,7 @@ def dummy_func(message: str, test1: str, test2: list[str]) -> str:
 
 task = vhq.Task(
    description="Amazing task",
-   pydantic_output=CustomOutput,
+   response_schema=CustomOutput,
    callback=dummy_func,
    callback_kwargs=dict(message="Hi! Here is the result: ")
 )
@@ -317,13 +317,13 @@ agent_b = vhq.Agent(role="Leader", llm="gemini-2.0")
 
 task_1 = vhq.Task(
    description="Analyze the client's business model.",
-   response_fields=[vhq.ResponseField(title="test1", data_type=str, required=True),],
+   response_schema=[vhq.ResponseField(title="test1", data_type=str, required=True),],
    allow_delegation=True
 )
 
 task_2 = vhq.Task(
    description="Define a cohort.",
-   response_fields=[vhq.ResponseField(title="test1", data_type=int, required=True),],
+   response_schema=[vhq.ResponseField(title="test1", data_type=int, required=True),],
    allow_delegation=False
 )
 

{versionhq-1.2.4.2.dist-info → versionhq-1.2.4.5.dist-info}/RECORD

@@ -1,25 +1,25 @@
-versionhq/__init__.py,sha256=m36KgpiM94kUCZJm-JA7gPWjb7gNgMHHXUAbxzKlIOs,3026
-versionhq/_prompt/auto_feedback.py,sha256=iIa3ReiFqs-JA2Q4Y_VnLV-DbXPelEVSMHTw3tICVTE,3892
+versionhq/__init__.py,sha256=8XLNCUY-3bjs8eI6mMUDBZLeY_Gj39QTut0tpzzyE3c,3026
+versionhq/_prompt/auto_feedback.py,sha256=QDYd8mKlluDaOjHIfL9B8Tr5tg40tsDVyBXqCuUdTCU,3800
 versionhq/_prompt/constants.py,sha256=DOwUFnVVObEFqgnaMCDnW8fnw1oPMgS8JAqOiTuqleI,932
-versionhq/_prompt/model.py,sha256=GQPaC_Vj1wQ69ZHlzXWdtdif8UeF6WK1jN3JrFEcCt0,8662
-versionhq/_utils/__init__.py,sha256=llXOcGFlR9YF5iMI5uFb4twvM9wo-vmoMw8y1KzQVVc,233
+versionhq/_prompt/model.py,sha256=kokH7axDDPEZKPBmrOKi5L0aZLtApdVOJDKsMjkJmvw,8020
+versionhq/_utils/__init__.py,sha256=UggL2r-idlWDh0cIPFLyJ7AvO17NLzhjheW4IBFLBj4,300
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/is_valid_url.py,sha256=m8Mswvb-90FJtx1Heq6hPFDbwGgrv_R3wSbZQmEPM9Q,379
 versionhq/_utils/llm_as_a_judge.py,sha256=RM0oYfoeanuUyUL3Ewl6_8Xn1F5Axd285UMH46kxG1I,2378
 versionhq/_utils/logger.py,sha256=iHxGjm3BvUo5dHKLU88_pc0Z45wzSHOjyJGQkb7OADk,3255
 versionhq/_utils/process_config.py,sha256=YTGY_erW335RfceQfzS18YAqq-AAb-iSvKSjN7noD2E,782
-versionhq/_utils/usage_metrics.py,sha256=xgYGRW3OTuK9EJyi3QYJeYcJl7dL27olcWaLo_7B3JE,2246
+versionhq/_utils/usage_metrics.py,sha256=zaoH6xjWX69UrQJmViBiX3sEUpnwSoHaapCPfWU2oM8,2632
 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=BPkvEyMH8VnZWsMeCwsGplDT_kLwlIejeRcr-6ItGqQ,2637
-versionhq/agent/model.py,sha256=Zom5G0ubq4TWGWF6PK631-6puCjcdHYKj0R355GS9T8,24480
+versionhq/agent/inhouse_agents.py,sha256=D2WAiXCYsnQK3_Fe7CbbtvXsHWOaN6vde6m_QoW7fH4,2629
+versionhq/agent/model.py,sha256=auIrSWqt4NnANgA2YOCS2l9kxPCWkZG7YUD22NjrkAA,24810
 versionhq/agent/parser.py,sha256=riG0dkdQCxH7uJ0AbdVdg7WvL0BXhUgJht0VtQvxJBc,4082
 versionhq/agent/rpm_controller.py,sha256=grezIxyBci_lDlwAlgWFRyR5KOocXeOhYkgN02dNFNE,2360
 versionhq/agent/TEMPLATES/Backstory.py,sha256=dkfuATUQ2g2WoUKkmgAIch-RB--bektGoQaUlsDOn0g,529
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/agent_network/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent_network/formation.py,sha256=WkAbmE2-Oqw8KWDcqqHU_s98QzGJWNQ_YCAls6ZuQbg,8260
-versionhq/agent_network/model.py,sha256=-vLBqPCtfLxTf17toJkE7Gkxg1SwlrA-Frf2Pc_uB50,16021
+versionhq/agent_network/formation.py,sha256=jXCc9dS9gOgjNoPNoqKaqKPrHqmcFIvR2JwKYTgiQW0,7505
+versionhq/agent_network/model.py,sha256=CYkIU1W1Ijh5DQD18vRcD1g8myZWmqAYNS0PlRnEX-o,15899
 versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/customer/__init__.py,sha256=-YXh1FQfvpfLacK8SUC7bD7Wx_eIEi4yrkCC_cUasFg,217
@@ -36,8 +36,8 @@ versionhq/knowledge/source.py,sha256=-hEUPtJUHHMx4rUKtiHl19J8xAMw-WVBw34zwa2jZ08
 versionhq/knowledge/source_docling.py,sha256=XpavmLvh4dLcuTikj8MCE9KG52oQMafy7_wBneliMK0,4994
 versionhq/knowledge/storage.py,sha256=Kd-4r6aWM5EDaoXrzKXbgi1hY6tysSQARPGXM95qMmU,8266
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/llm/llm_vars.py,sha256=qSG-_pYeWksdMmwASXpjQqf97fMovsY4lNTSCHQF88k,5694
-versionhq/llm/model.py,sha256=P4J6ZU0vY5HU7XHLelz7oznPmeEElHPFsAo-2Vd8DQ0,17255
+versionhq/llm/llm_vars.py,sha256=fl9MOjPzBEIymp99BNLD39VmB7rQ9L4YDnfLNXbUZws,5896
+versionhq/llm/model.py,sha256=m4OaFgGWKCZjmfN-OY3KoqG1K4T31UF7QVkYUcnpjdg,17273
 versionhq/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/memory/contextual_memory.py,sha256=QEMVvHuEXxY7M6-12S8HhyFKf108KfX8Zzt7paPW048,3882
 versionhq/memory/model.py,sha256=VQR1229t7GQPMItlGAHLtJrb6LrZfSoRA1DRW4z0SOU,8234
@@ -46,18 +46,18 @@ versionhq/storage/base.py,sha256=p-Jas0fXQan_qotnRD6seQxrT2lj-uw9-SmHQhdppcs,355
 versionhq/storage/ltm_sqlite_storage.py,sha256=LeJE4ZPUWjyY1E5nNCHoKujTHFDR2BO_LAMvAOX-WHg,3957
 versionhq/storage/mem0_storage.py,sha256=ZY8MELBWaINRv9YuRW5MxH7dj2cII-L0i3xSD6o1-2M,3781
 versionhq/storage/rag_storage.py,sha256=bS2eE874obarYl-4hT6ZWYWTRsqtfuGpKgKzERmM6Uo,7433
-versionhq/storage/task_output_storage.py,sha256=M8vInLJ5idGAq17w1juHKXtyPyF-B-rK_P8UcqD-Px8,5357
+versionhq/storage/task_output_storage.py,sha256=nkBNmBbrQeEgds3lAyKl4ugDWLtWRoCQUO6KiOmCIMU,5362
 versionhq/storage/utils.py,sha256=r5ghA_ktdR2IuzlzKqZYCjsNxztEMzyhWLneA4cFuWY,748
 versionhq/task/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/task/evaluation.py,sha256=qQSA5ZWTWA3he54ystsYpTKXJWv68gBL6DCq8ZW1bl8,3813
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
-versionhq/task/model.py,sha256=YsuxbohcXLwE1qB8-lPnl_sFWQJ7CPqKDbYbf8CeZww,28879
+versionhq/task/model.py,sha256=C5QttgJrfhx0UL82845ZBIhhc8oLiQkAWz2i6UkskMM,29023
 versionhq/task/structured_response.py,sha256=tqOHpch8CVmMj0aZXjdDWtPNcVmBW8DVZnBvPBwS4PM,5053
 versionhq/task/TEMPLATES/Description.py,sha256=hKhpbz0ztbkUMXz9KiL-P40fis9OB5ICOdL9jCtgAhU,864
 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=0zDRx1-PXIwuB_RkdKQTHgqjm-5VrJHhljBIlYRX6EM,4919
-versionhq/task_graph/model.py,sha256=T7-Rj05q9gKIXPNwPdr1cOjnxNQdNicEFg2WIApO9Og,28877
+versionhq/task_graph/draft.py,sha256=mVhCHDH-7N-SQRssE50KGIAgd9gdvdeWjt8ofm-SYI4,4943
+versionhq/task_graph/model.py,sha256=l4Alvdtdl-fwYG7eMo655HF0zx1HkKRiPiST_Ra7hzg,29305
 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=IATfsEnF_1RPJyGtPBmAtEJh5XPcgDHpyG3SUR461Og,8572
@@ -66,8 +66,8 @@ versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1
 versionhq/tool/model.py,sha256=ve9C4WyiRjQigOU0hRWVxtSUWAQNntlmeW-_DL0_lJY,12328
 versionhq/tool/rag_tool.py,sha256=dW5o-83V4bMFFJEj3PUm7XjblwrYJGmZVBlCpPj6CeM,3852
 versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
-versionhq-1.2.4.2.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
-versionhq-1.2.4.2.dist-info/METADATA,sha256=qQ2-yJwPEuN62-SfvREXpqf3dDJc3xkwMrACWx5JYm8,21146
-versionhq-1.2.4.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
-versionhq-1.2.4.2.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.2.4.2.dist-info/RECORD,,
+versionhq-1.2.4.5.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.4.5.dist-info/METADATA,sha256=gwFpoEsZC3Jfo5k2bvpZBPix_pWZCJ0h_UDDgRfrsBw,21146
+versionhq-1.2.4.5.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+versionhq-1.2.4.5.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.4.5.dist-info/RECORD,,