versionhq 1.2.4.2__py3-none-any.whl → 1.2.4.3__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.3"
 __all__ = [
     "Agent",
 

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/model.py

@@ -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:
@@ -526,6 +527,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

@@ -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], pydantic_output=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:

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)
 
@@ -319,7 +317,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,12 +382,11 @@ 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
 
 

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."""
 
@@ -225,7 +238,6 @@ class TaskOutput(BaseModel):
 
             task_eval = Task(description=description, pydantic_output=EvaluationItem)
             res = task_eval.execute(agent=self.evaluation.eval_by)
-            self._tokens += task_eval._tokens
 
             if res.pydantic:
                 item = EvaluationItem(
@@ -328,9 +340,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 +365,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
 
 
@@ -433,14 +445,15 @@ 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,12 +469,13 @@ 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
         except:
             output = self._sanitize_raw_output(raw=raw)
+            self._usage.record_errors(type=ErrorType.FORMAT)
             return output
 
 
@@ -592,13 +606,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 +636,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,17 +654,14 @@ 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"]))
@@ -671,8 +675,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 +708,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,22 +720,22 @@ 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

versionhq/task_graph/draft.py

@@ -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

@@ -15,7 +15,7 @@ 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._utils import Logger, UsageMetrics, ErrorType
 
 
 class ReformTriggerEvent(enum.Enum):
@@ -393,6 +393,8 @@ 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
@@ -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"""
 
@@ -635,6 +671,7 @@ class TaskGraph(Graph):
             self.concl = res
             self.concl_template = self.concl_template if self.concl_template 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.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.2.4.2
+Version: 1.2.4.3
 Summary: Autonomous agent networks for task automation with multi-step reasoning.
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License

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

@@ -1,25 +1,25 @@
-versionhq/__init__.py,sha256=m36KgpiM94kUCZJm-JA7gPWjb7gNgMHHXUAbxzKlIOs,3026
+versionhq/__init__.py,sha256=F0IUNu8UG7KfohEotN5MykEfCklxJjXe4c5kcaVIwlE,3026
 versionhq/_prompt/auto_feedback.py,sha256=iIa3ReiFqs-JA2Q4Y_VnLV-DbXPelEVSMHTw3tICVTE,3892
 versionhq/_prompt/constants.py,sha256=DOwUFnVVObEFqgnaMCDnW8fnw1oPMgS8JAqOiTuqleI,932
 versionhq/_prompt/model.py,sha256=GQPaC_Vj1wQ69ZHlzXWdtdif8UeF6WK1jN3JrFEcCt0,8662
-versionhq/_utils/__init__.py,sha256=llXOcGFlR9YF5iMI5uFb4twvM9wo-vmoMw8y1KzQVVc,233
+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/model.py,sha256=duB4qQDh3RIQZ6YyZovvBKUBdzMtgCFiel0qC0BGbzQ,24691
 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=XiGyjqsquTcKqyq6r2JR506wEH0uuD8HyBvWNdvz1Fg,7505
+versionhq/agent_network/model.py,sha256=65y4HTltfvgOuHnSUwDTydtt1qkq1xVk-AxF1ws1J9M,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
@@ -37,7 +37,7 @@ versionhq/knowledge/source_docling.py,sha256=XpavmLvh4dLcuTikj8MCE9KG52oQMafy7_w
 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/model.py,sha256=Hc_fYYmhM_HuYs4dBtZlHwGqVtqnEC_rvGXD1o6RB4A,17186
 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=ODcyS_lTT0NoVRA3MSuczbOVp03gpwmb5i48nVOe8jo,29069
 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=l8nRV39Rh5lLLQ_hHgbHyVLpoBqAzWk9QIXNaGiEbeE,4921
+versionhq/task_graph/model.py,sha256=bUptIXKe8fR9hbZRo81ns_nUMWYklWgTBgtW_4PS4bU,29214
 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.3.dist-info/LICENSE,sha256=cRoGGdM73IiDs6nDWKqPlgSv7aR4n-qBXYnJlCMHCeE,1082
+versionhq-1.2.4.3.dist-info/METADATA,sha256=4q8mpXgq7TcaXjvX26JIE0FsQ78hgJuuEPBhefJiknI,21146
+versionhq-1.2.4.3.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+versionhq-1.2.4.3.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.2.4.3.dist-info/RECORD,,