versionhq 1.1.11.8__py3-none-any.whl → 1.1.12.2__py3-none-any.whl

versionhq/task/model.py

@@ -5,18 +5,17 @@ import uuid
 import inspect
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type, TypeVar
+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, create_model, InstanceOf, field_validator
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, InstanceOf, field_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq._utils.process_config import process_config
-from versionhq.task import TaskOutputFormat
+
 from versionhq.task.log_handler import TaskOutputStorageHandler
 from versionhq.task.evaluate import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
-from versionhq._utils.logger import Logger
+from versionhq._utils import process_config, Logger
 
 
 class ResponseField(BaseModel):
@@ -77,9 +76,7 @@ class ResponseField(BaseModel):
             if self.properties:
                 for item in self.properties:
                     nested_p.update(**item._format_props())
-
-                    if item.required:
-                        nested_r.append(item.title)
+                    nested_r.append(item.title)
 
             props = {
                 "type": schema_type,
@@ -97,8 +94,6 @@ class ResponseField(BaseModel):
             if self.properties:
                 for item in self.properties:
                     p.update(**item._format_props())
-
-                    # if item.required:
                     r.append(item.title)
 
             props = {
@@ -204,12 +199,25 @@ class TaskOutput(BaseModel):
         eval_criteria = task.eval_criteria if task.eval_criteria else  ["Overall competitiveness", ]
 
         for item in eval_criteria:
-            task_1 = Task(
+            task_eval = Task(
                 description=EVALUATE.format(task_description=task.description, task_output=self.raw, eval_criteria=str(item)),
                 pydantic_output=EvaluationItem
             )
-            res_a = task_1.execute_sync(agent=self.evaluation.responsible_agent)
-            self.evaluation.items.append(EvaluationItem(**res_a.json_dict))
+            res = task_eval.execute_sync(agent=self.evaluation.responsible_agent)
+
+            if res.pydantic:
+                item = EvaluationItem(score=res.pydantic.score, suggestion=res.pydantic.suggestion, criteria=res.pydantic.criteria)
+                self.evaluation.items.append(item)
+
+            else:
+                try:
+                    item = EvaluationItem(
+                        score=float(res.json_dict["score"]), suggestion=res.json_dict["suggestion"], criteria=res.json_dict["criteria"]
+                    )
+                    self.evaluation.items.append(item)
+                except Exception as e:
+                    Logger(verbose=True).log(level="error", message=f"Failed to convert the evaluation items: {str(e)}", color="red")
+                    pass
 
         return self.evaluation
 
@@ -224,14 +232,6 @@ class TaskOutput(BaseModel):
 
     @property
     def json(self) -> Optional[str]:
-        if self.output_format != TaskOutputFormat.JSON:
-            raise ValueError(
-                """
-                Invalid output format requested.
-                If you would like to access the JSON output,
-                pleae make sure to set the output_json property for the task
-                """
-            )
         return json.dumps(self.json_dict)
 
 
@@ -239,7 +239,6 @@ class TaskOutput(BaseModel):
         return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
 
 
-
 class Task(BaseModel):
     """
     Task to be executed by agents or teams.
@@ -286,7 +285,7 @@ class Task(BaseModel):
     processed_by_agents: Set[str] = Field(default_factory=set, description="store responsible agents' roles")
     tools_errors: int = 0
     delegations: int = 0
-    latency: int | float = 0 # execution latency in sec
+    latency: int | float = 0 # job latency in sec
     tokens: int = 0 # tokens consumed
 
 
@@ -394,14 +393,6 @@ Ref. Output image: {output_formats_to_follow}
         return "\n".join(task_slices)
 
 
-    def _get_output_format(self) -> TaskOutputFormat:
-        if self.output_json == True:
-            return TaskOutputFormat.JSON
-        if self.output_pydantic == True:
-            return TaskOutputFormat.PYDANTIC
-        return TaskOutputFormat.RAW
-
-
     def _structure_response_format(self, data_type: str = "object", model_provider: str = "gemini") -> Dict[str, Any] | None:
         """
         Structure a response format either from`response_fields` or `pydantic_output`.
@@ -412,37 +403,38 @@ Ref. Output image: {output_formats_to_follow}
 
         response_format: Dict[str, Any] = None
 
-        # match model_provider:
-        #     case "openai":
-        if self.response_fields:
-            properties, required_fields = {}, []
-            for i, item in enumerate(self.response_fields):
-                if item:
-                    if item.data_type is dict:
-                        properties.update(item._format_props())
-                    else:
-                        properties.update(item._format_props())
-
-                    required_fields.append(item.title)
-
-            response_schema = {
-                "type": "object",
-                "properties": properties,
-                "required": required_fields,
-                "additionalProperties": False,
-            }
+        if model_provider == "openrouter":
+            return response_format
 
-            response_format = {
-                "type": "json_schema",
-                "json_schema": { "name": "outcome", "schema": response_schema }
-            }
+        else:
+            if self.response_fields:
+                properties, required_fields = {}, []
+                for i, item in enumerate(self.response_fields):
+                    if item:
+                        if item.data_type is dict:
+                            properties.update(item._format_props())
+                        else:
+                            properties.update(item._format_props())
+
+                        required_fields.append(item.title)
+
+                response_schema = {
+                    "type": "object",
+                    "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)._format()
+            elif self.pydantic_output:
+                response_format = StructuredOutput(response_format=self.pydantic_output)._format()
 
-            # case "gemini":
-        return response_format
+            return response_format
 
 
     def _create_json_output(self, raw: str) -> Dict[str, Any]:
@@ -507,75 +499,59 @@ Ref. Output image: {output_formats_to_follow}
             self.description = self._original_description.format(**inputs)
 
 
-    def _create_short_term_memory(self, agent, task_output: TaskOutput) -> None:
+    def _create_short_and_long_term_memories(self, agent: Any, task_output: TaskOutput) -> None:
         """
-        After the task execution, create and save short-term memory of the responsible agent.
+        After the task execution, create and save short-term/long-term memories in the storage.
         """
-
         from versionhq.agent.model import Agent
-        from versionhq.memory.model import ShortTermMemory
+        from versionhq.memory.model import ShortTermMemory, MemoryMetadata, LongTermMemory
 
-        try:
-            if isinstance(agent, Agent) and agent.use_memory == True:
-                if hasattr(agent, "short_term_memory"):
-                    agent.short_term_memory.save(value=task_output.raw, metadata={ "observation": self.description, }, agent=agent.role)
-                else:
-                    agent.short_term_memory = ShortTermMemory(agent=agent, embedder_config=agent.embedder_config)
-                    agent.short_term_memory.save(value=task_output.raw, metadata={ "observation": self.description, }, agent=agent.role)
+        agent = agent if isinstance(agent, Agent) else Agent(role=str(agent), goal=str(agent), use_memory=True)
 
-        except Exception as e:
-            self._logger.log(level="error", message=f"Failed to add to short term memory: {str(e)}", color="red")
-            pass
-
-
-    def _create_long_term_memory(self, agent, task_output: TaskOutput) -> None:
-        """
-        Create and save long-term and entity memory items based on evaluation.
-        """
-        from versionhq.agent.model import Agent
-        from versionhq.memory.model import LongTermMemory, LongTermMemoryItem
+        if agent.use_memory == False:
+            return None
 
         try:
-            if isinstance(agent, Agent) and agent.use_memory == True:
-                evaluation = task_output.evaluation if task_output.evaluation else task_output.evaluate(task=self)
-
-                long_term_memory_item = LongTermMemoryItem(
-                    agent=str(agent.role),
-                    task=str(self.description),
-                    datetime=str(datetime.datetime.now()),
-                    quality=evaluation.aggregate_score,
-                    metadata={
-                        "suggestions": evaluation.suggestion_summary,
-                        "quality": evaluation.aggregate_score,
-                    },
-                )
+            evaluation = task_output.evaluation if task_output.evaluation else None
+            memory_metadata = evaluation._create_memory_metadata() if evaluation else MemoryMetadata()
+
+            agent.short_term_memory = agent.short_term_memory if agent.short_term_memory else ShortTermMemory(agent=agent, embedder_config=agent.embedder_config)
+            agent.short_term_memory.save(
+                task_description=str(self.description),
+                task_output=str(task_output.raw),
+                agent=str(agent.role),
+                metadata=memory_metadata
+            )
 
-                if hasattr(agent, "long_term_memory"):
-                    agent.long_term_memory.save(item=long_term_memory_item)
-                else:
-                    agent.long_term_memory = LongTermMemory(agent=agent)
-                    agent.long_term_memory.save(item=long_term_memory_item)
+            agent.long_term_memory = agent.long_term_memory if agent.long_term_memory else LongTermMemory()
+            agent.long_term_memory.save(
+                task_description=str(self.description),
+                task_output=str(task_output.raw),
+                agent=str(agent.role),
+                metadata=memory_metadata
+                )
 
         except AttributeError as e:
             self._logger.log(level="error", message=f"Missing attributes for long term memory: {str(e)}", color="red")
             pass
 
         except Exception as e:
-            self._logger.log(level="error", message=f"Failed to add to long term memory: {str(e)}", color="red")
+            self._logger.log(level="error", message=f"Failed to add to the memory: {str(e)}", color="red")
             pass
 
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str] = None) -> TaskOutput:
+    def execute_sync(self, agent, context: Optional[str | List[Any]] = None) -> TaskOutput:
         """
         Execute the task synchronously.
         When the task has context, make sure we have executed all the tasks in the context first.
         """
 
         if self.context:
-            for task in self.context:
-                if task.output is None:
-                    task._execute_core(agent, context)
+            if isinstance(self.context, list):
+                for task in self.context:
+                    if isinstance(task, Task) and task.output is None:
+                        task._execute_core(agent, context)
 
         return self._execute_core(agent, context)
 
@@ -612,7 +588,7 @@ Ref. Output image: {output_formats_to_follow}
         task_output: InstanceOf[TaskOutput] = None
         tool_output: str | list = None
         task_tools: List[List[InstanceOf[Tool]| InstanceOf[ToolSet] | Type[Tool]]] = []
-        started_at = datetime.datetime.now()
+        started_at, ended_at = datetime.datetime.now(), datetime.datetime.now()
 
         if self.tools:
             for item in self.tools:
@@ -638,11 +614,16 @@ Ref. Output image: {output_formats_to_follow}
 
 
         if self.tool_res_as_final == True:
+            started_at = datetime.datetime.now()
             tool_output = agent.execute_task(task=self, context=context, task_tools=task_tools)
+            ended_at = datetime.datetime.now()
             task_output = TaskOutput(task_id=self.id, tool_output=tool_output, raw=str(tool_output) if tool_output else "")
 
         else:
+            started_at = datetime.datetime.now()
             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"]))
@@ -656,18 +637,15 @@ Ref. Output image: {output_formats_to_follow}
                 json_dict=json_dict_output
             )
 
-        ended_at = datetime.datetime.now()
-        self.latency = (ended_at - started_at).total_seconds()
 
+        self.latency = (ended_at - started_at).total_seconds()
         self.output = task_output
         self.processed_by_agents.add(agent.role)
 
         if self.should_evaluate:
             task_output.evaluate(task=self, latency=self.latency, tokens=self.tokens)
 
-        self._create_short_term_memory(agent=agent, task_output=task_output)
-        self._create_long_term_memory(agent=agent, task_output=task_output)
-
+        self._create_short_and_long_term_memories(agent=agent, task_output=task_output)
 
         if self.callback and isinstance(self.callback, Callable):
             kwargs = { **self.callback_kwargs, **task_output.json_dict }
@@ -697,7 +675,7 @@ Ref. Output image: {output_formats_to_follow}
 
     @property
     def key(self) -> str:
-        output_format = TaskOutputFormat.JSON if self.response_fields else TaskOutputFormat.PYDANTIC if self.pydantic_output is not None else TaskOutputFormat.RAW
+        output_format = "json" if self.response_fields else "pydantic" if self.pydantic_output is not None else "raw"
         source = [self.description, output_format]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
 

versionhq/task/structured_response.py

@@ -1,4 +1,4 @@
-from typing import Dict, Optional, Type, List, Any, TypeVar
+from typing import Dict, Type, List, Any
 
 from pydantic import BaseModel, Field, InstanceOf
 

versionhq/team/model.py

@@ -1,17 +1,16 @@
 import uuid
 import warnings
-import json
 from enum import Enum
 from dotenv import load_dotenv
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, TYPE_CHECKING, Callable, Optional, Tuple
-from pydantic import UUID4, InstanceOf, Json, BaseModel, Field, PrivateAttr, field_validator, model_validator
+from typing import Any, Dict, List, Callable, Optional, Tuple
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator
 from pydantic._internal._generate_schema import GenerateSchema
 from pydantic_core import PydanticCustomError, core_schema
 
 from versionhq.agent.model import Agent
-from versionhq.task.model import Task, TaskOutput, ConditionalTask, TaskOutputFormat
+from versionhq.task.model import Task, TaskOutput, ConditionalTask
 from versionhq.task.formatter import create_raw_outputs
 from versionhq.team.team_planner import TeamPlanner
 from versionhq._utils.logger import Logger
@@ -20,7 +19,6 @@ from versionhq._utils.usage_metrics import UsageMetrics
 
 initial_match_type = GenerateSchema.match_type
 
-
 def match_type(self, obj):
     if getattr(obj, "__name__", None) == "datetime":
         return core_schema.datetime_schema()
@@ -28,7 +26,6 @@ def match_type(self, obj):
 
 
 GenerateSchema.match_type = match_type
-
 warnings.filterwarnings("ignore", category=SyntaxWarning, module="pysbd")
 load_dotenv(override=True)
 
@@ -40,6 +37,16 @@ load_dotenv(override=True)
 #         pass
 
 
+
+class Formation(str, Enum):
+    SOLO = 1
+    SUPERVISING = 2
+    NETWORK = 3
+    RANDOM = 4
+    HYBRID = 10
+    UNDEFINED = 0
+
+
 class TaskHandlingProcess(str, Enum):
     """
     Class representing the different processes that can be used to tackle multiple tasks.
@@ -49,25 +56,25 @@ class TaskHandlingProcess(str, Enum):
     consensual = "consensual"
 
 
-class TeamOutput(BaseModel):
+class TeamOutput(TaskOutput):
     """
-    Store outputs of the tasks handled by the team.
-    `json_dict` and `raw` store overall output of tasks that handled by the team,
-    while `task_output_list` stores each TaskOutput instance to the tasks handled by the team members.
-    Note that `raw` and `json_dict` will be prioritized as TeamOutput to refer over `task_output_list`.
+    A class to store output from the team, inherited from TaskOutput class.
     """
 
     team_id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="store the team ID that generate the TeamOutput")
-    raw: str = Field(default="", description="raw output of the team lead task handled by the team leader")
-    pydantic: Optional[Any] = Field(default=None, description="`raw` converted to the abs. pydantic model")
-    json_dict: Dict[str, Any] = Field(default=None, description="`raw` converted to dictionary")
-    task_output_list: list[TaskOutput] = Field(default=list, description="store output of all the tasks that the team has executed")
+    task_description: str = Field(default=None, description="store initial request (task description) from the client")
+    task_outputs: list[TaskOutput] = Field(default=list, description="store outputs of all tasks that the team has executed")
     token_usage: UsageMetrics = Field(default=dict, description="processed token summary")
 
+
+    def return_all_task_outputs(self) -> List[Dict[str, Any]]:
+        res = [output.json_dict for output in self.task_outputs]
+        return res
+
+
     def __str__(self):
         return (str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw)
 
-
     def __getitem__(self, key):
         if self.pydantic and hasattr(self.pydantic, key):
             return getattr(self.pydantic, key)
@@ -77,40 +84,16 @@ class TeamOutput(BaseModel):
             raise KeyError(f"Key '{key}' not found in the team output.")
 
 
-    @property
-    def json(self) -> Optional[str]:
-        if self.tasks_output[-1].output_format != TaskOutputFormat.JSON:
-            raise ValueError(
-                "No JSON output found in the final task. Please make sure to set the output_json property in the final task in your team."
-            )
-        return json.dumps(self.json_dict)
-
-
-    def to_dict(self) -> Dict[str, Any]:
-        """
-        Convert pydantic / raw output into dict and return the dict.
-        When we only have `raw` output, return `{ output: raw }` to avoid an error
-        """
-
-        output_dict = {}
-        if self.json_dict:
-            output_dict.update(self.json_dict)
-        elif self.pydantic:
-            output_dict.update(self.pydantic.model_dump())
-        else:
-            output_dict.upate({ "output": self.raw })
-        return output_dict
-
-
-    def return_all_task_outputs(self) -> List[Dict[str, Any]]:
-        res = [output.json_dict for output in self.task_output_list]
-        return res
-
 
 class TeamMember(BaseModel):
-    agent: Agent | None = Field(default=None, description="store the agent to be a member")
+    """
+    A class to store a team member
+    """
+    agent: Agent | None = Field(default=None)
     is_manager: bool = Field(default=False)
-    task: Optional[Task] = Field(default=None)
+    can_share_knowledge: bool = Field(default=True, description="whether to share the agent's knowledge in the team")
+    can_share_memory: bool = Field(default=True, description="whether to share the agent's memory in the team")
+    task: Optional[Task] = Field(default=None, description="task assigned to the agent")
 
     @property
     def is_idling(self):
@@ -125,17 +108,19 @@ class Team(BaseModel):
 
     __hash__ = object.__hash__
     _execution_span: Any = PrivateAttr()
-    _logger: Logger = PrivateAttr()
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _inputs: Optional[Dict[str, Any]] = PrivateAttr(default=None)
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None)
-    members: List[TeamMember] = Field(default_factory=list, description="store agents' uuids and bool if it is manager")
+    members: List[TeamMember] = Field(default_factory=list)
+    formation: Optional[Formation] = Field(default=None)
+
+    # formation planning
+    planning_llm: Optional[Any] = Field(default=None, description="llm to generate formation")
+    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="optional tasks for the team. can be assigned to team members later")
 
-    # work as a team
-    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="optional tasks for the team")
-    planning_llm: Optional[Any] = Field(default=None, description="llm to handle the planning of the team tasks (if any)")
-    function_calling_llm: Optional[Any] = Field(default=None, description="llm to execute func after all agent execution (if any)")
+    # task execution rules
     prompt_file: str = Field(default="", description="path to the prompt json file to be used by the team.")
     process: TaskHandlingProcess = Field(default=TaskHandlingProcess.sequential)
 
@@ -150,7 +135,6 @@ class Team(BaseModel):
     )
     step_callback: Optional[Any] = Field(default=None, description="callback to be executed after each step for all agents execution")
 
-    verbose: bool = Field(default=True)
     cache: bool = Field(default=True)
     memory: bool = Field(default=False, description="whether the team should use memory to store memories of its execution")
     execution_logs: List[Dict[str, Any]] = Field(default=[], description="list of execution logs for tasks")
@@ -236,7 +220,7 @@ class Team(BaseModel):
         return self
 
 
-    def _get_responsible_agent(self, task: Task) -> Agent:
+    def _get_responsible_agent(self, task: Task) -> Agent | None:
         if task is None:
             return None
         else:
@@ -244,7 +228,7 @@ class Team(BaseModel):
             return None if len(res) == 0 else res[0]
 
 
-    def _handle_team_planning(self) -> None:
+    def _handle_agent_formation(self) -> None:
         """
         Form a team considering agents and tasks given, and update `self.members` field:
             1. Idling managers to take the team tasks.
@@ -321,7 +305,7 @@ class Team(BaseModel):
             raw=final_task_output.raw,
             json_dict=final_task_output.json_dict,
             pydantic=final_task_output.pydantic,
-            task_output_list=task_outputs,
+            task_outputs=task_outputs,
             token_usage=token_usage,
         )
 
@@ -373,7 +357,7 @@ class Team(BaseModel):
 
             responsible_agent = self._get_responsible_agent(task)
             if responsible_agent is None:
-                self._handle_team_planning()
+                self._handle_agent_formation()
 
             if isinstance(task, ConditionalTask):
                 skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
@@ -415,7 +399,7 @@ class Team(BaseModel):
         metrics: List[UsageMetrics] = []
 
         if self.team_tasks or self.member_tasks_without_agent:
-            self._handle_team_planning()
+            self._handle_agent_formation()
 
         if kwargs_before is not None:
             for before_callback in self.before_kickoff_callbacks:
@@ -432,9 +416,6 @@ class Team(BaseModel):
             agent = member.agent
             agent.team = self
 
-            if not agent.function_calling_llm and self.function_calling_llm:
-                agent.function_calling_llm = self.function_calling_llm
-
             if self.step_callback:
                 agent.callbacks.append(self.step_callback)
 

versionhq/team/team_planner.py

@@ -8,7 +8,11 @@ load_dotenv(override=True)
 
 class TeamPlanner:
     """
-    Assign agents to multiple tasks.
+    A class to handle agent formations based on the given task description.
+    1) complexity
+    2) agent built (or use given agents)
+    3) knowledge, memory sharing
+    4) form a team
     """
 
     from versionhq.task.model import Task, ResponseField, TaskOutput
@@ -59,7 +63,6 @@ class TeamPlanner:
         return new_member_list
 
 
-
     def _handle_task_planning(self, context: Optional[str] = None, tools: Optional[str] = None) -> TaskOutput:
         """
         Handles the team planning by creating detailed step-by-step plans for each task.

versionhq/tool/model.py

@@ -2,7 +2,7 @@ from abc import ABC, abstractmethod
 from inspect import signature
 from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin, get_type_hints
 from typing_extensions import Self
-from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator, PrivateAttr, create_model
+from pydantic import InstanceOf, BaseModel, Field, field_validator, model_validator, PrivateAttr, create_model
 from pydantic_core import PydanticCustomError
 
 from versionhq.llm.llm_vars import SchemaType

{versionhq-1.1.11.8.dist-info → versionhq-1.1.12.2.dist-info}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 Version IO Sdn. Bhd.
+Copyright (c) 2024-2025 Version IO Sdn. Bhd.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal