versionhq 1.2.4.2__tar.gz → 1.2.4.3__tar.gz

{versionhq-1.2.4.2 → versionhq-1.2.4.3}/PKG-INFO

@@ -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 → versionhq-1.2.4.3}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__", "*.egg-info"]
 
 [project]
 name = "versionhq"
-version = "1.2.4.2"
+version = "1.2.4.3"
 authors = [{ name = "Kuriko Iwai", email = "kuriko@versi0n.io" }]
 description = "Autonomous agent networks for task automation with multi-step reasoning."
 readme = "README.md"

{versionhq-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.3/src/versionhq/_utils/usage_metrics.py

@@ -0,0 +1,72 @@
+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):
+    """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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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-1.2.4.2 → versionhq-1.2.4.3}/src/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 → versionhq-1.2.4.3}/src/versionhq.egg-info/PKG-INFO

@@ -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 → versionhq-1.2.4.3}/tests/_prompt/auto_feedback_test.py

@@ -7,7 +7,7 @@ from versionhq.agent.model import Agent
 from versionhq.task.model import Task, TaskOutput
 
 
-def test_create():
+def test_pfg():
     class Custom(BaseModel):
         schedule: str
         destination: str

{versionhq-1.2.4.2 → versionhq-1.2.4.3}/tests/agent/agent_test.py

@@ -329,6 +329,7 @@ def test_start_with_tools():
 
     res = agent.start(tool_res_as_final=True)
     assert res.tool_output == "demo"
+    assert res.raw == res.tool_output
 
 
 def test_self_learn():

{versionhq-1.2.4.2 → versionhq-1.2.4.3}/tests/agent_network/agent_network_test.py

@@ -293,5 +293,6 @@ def test_network_eval():
         network_tasks=[Task(description="draft a random poem")]
     )
 
-    res, _ = network.launch()
-    assert res._tokens and res.latency
+    res, tg = network.launch()
+    assert isinstance(res, vhq.TaskOutput)
+    assert isinstance(tg, vhq.TaskGraph)

{versionhq-1.2.4.2 → versionhq-1.2.4.3}/tests/task/doc_taskoutput_test.py

@@ -32,6 +32,5 @@ def test_doc_core_taskoutput_a():
     assert res.tool_output is None
     assert isinstance(res.evaluation, vhq.Evaluation)
     assert [isinstance(item, vhq.EvaluationItem) and item.criteria in task.eval_criteria for item in res.evaluation.items]
-    assert res.latency and res._tokens
     assert res.evaluation.aggregate_score is not None and res.evaluation.suggestion_summary
     assert res.final == res.callback_output