versionhq 1.1.13.0__py3-none-any.whl → 1.2.0.1__py3-none-any.whl

versionhq/task/model.py

@@ -3,6 +3,7 @@ import threading
 import datetime
 import uuid
 import inspect
+import enum
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Callable, Type
@@ -11,18 +12,25 @@ from typing_extensions import Annotated, Self
 from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, InstanceOf, field_validator
 from pydantic_core import PydanticCustomError
 
-
+import versionhq as vhq
 from versionhq.task.log_handler import TaskOutputStorageHandler
 from versionhq.task.evaluate import Evaluation, EvaluationItem
 from versionhq.tool.model import Tool, ToolSet
 from versionhq._utils import process_config, Logger
 
 
+class TaskExecutionType(enum.Enum):
+    """
+    Enumeration to store task execution types of independent tasks without dependencies.
+    """
+    SYNC = 1
+    ASYNC = 2
+
+
 class ResponseField(BaseModel):
     """
-    A class to store the response format and schema that will cascade to the LLM.
-    The `config` field can store additional params:
-    https://community.openai.com/t/official-documentation-for-supported-schemas-for-response-format-parameter-in-calls-to-client-beta-chats-completions-parse/932422/3
+    A class to store a response format that will generate a JSON schema.
+    One layer of nested child is acceptable.
     """
 
     title: str = Field(default=None, description="title of the field")
@@ -31,7 +39,7 @@ class ResponseField(BaseModel):
     properties: Optional[List[BaseModel]] = Field(default=None, description="store dict items in ResponseField format")
     required: bool = Field(default=True)
     nullable: bool = Field(default=False)
-    config: Optional[Dict[str, Any]] = Field(default=None, description="additional rules")
+    config: Optional[Dict[str, Any]] = Field(default_factory=dict, description="additional rules")
 
 
     @model_validator(mode="after")
@@ -57,36 +65,44 @@ class ResponseField(BaseModel):
 
     def _format_props(self) -> Dict[str, Any]:
         """
-        Structure valid properties. We accept 2 nested objects.
+        Structure valid properties from the ResponseField object. 1 layer of nested child is accepted.
         """
         from versionhq.llm.llm_vars import SchemaType
 
         schema_type = SchemaType(type=self.data_type).convert()
         props: Dict[str, Any] = {}
 
-        if self.data_type is list and self.items is not dict:
-            props = {
-                "type": schema_type,
-                "items": { "type": SchemaType(type=self.items).convert() },
-            }
-
-        elif self.data_type is list and self.items is dict:
-            nested_p, nested_r = dict(), list()
+        if self.data_type is list:
+            if self.items is dict:
+                nested_p, nested_r = dict(), list()
+
+                if self.properties:
+                    for item in self.properties:
+                        nested_p.update(**item._format_props())
+                        nested_r.append(item.title)
+
+                props = {
+                    "type": schema_type,
+                    "items": {
+                        "type": SchemaType(type=self.items).convert(),
+                        "properties": nested_p,
+                        "required": nested_r,
+                        "additionalProperties": False
+                    }
+                }
 
-            if self.properties:
-                for item in self.properties:
-                    nested_p.update(**item._format_props())
-                    nested_r.append(item.title)
+            elif self.items is list:
+                props = {
+                    "type": schema_type,
+                    "items": { "type": SchemaType(type=self.items).convert(), "items": { "type": SchemaType(type=str).convert() }},
+                }
 
-            props = {
-                "type": schema_type,
-                "items": {
-                    "type": SchemaType(type=self.items).convert(),
-                    "properties": nested_p,
-                    "required": nested_r,
-                    "additionalProperties": False
+            else:
+                props = {
+                    "type": schema_type,
+                    "items": { "type": SchemaType(type=self.items).convert() },
                 }
-            }
+
 
         elif self.data_type is dict:
             p, r = dict(), list()
@@ -184,17 +200,16 @@ class TaskOutput(BaseModel):
         return json.dumps(self.json_dict) if self.json_dict else self.raw[0: 127]
 
 
-    def evaluate(self, task, latency: int | float = None, tokens: int = None) -> Evaluation:
+    def evaluate(self, task) -> Evaluation:
         """
         Evaluate the output based on the criteria, score each from 0 to 1 scale, and raise suggestions for future improvement.
         """
         from versionhq.task.TEMPLATES.Description import EVALUATE
 
-        if not self.evaluation:
-            self.evaluation = Evaluation()
+        self.evaluation = Evaluation() if not self.evaluation else self.evaluation
 
-        self.evaluation.latency = latency if latency is not None else task.latency
-        self.evaluation.tokens = tokens if tokens is not None else task.tokens
+        # self.evaluation.latency = latency if latency is not None else task.latency
+        # self.evaluation.tokens = tokens if tokens is not None else task.tokens
 
         eval_criteria = task.eval_criteria if task.eval_criteria else  ["Overall competitiveness", ]
 
@@ -203,7 +218,7 @@ class TaskOutput(BaseModel):
                 description=EVALUATE.format(task_description=task.description, task_output=self.raw, eval_criteria=str(item)),
                 pydantic_output=EvaluationItem
             )
-            res = task_eval.execute_sync(agent=self.evaluation.eval_by)
+            res = task_eval.execute(agent=self.evaluation.eval_by)
 
             if res.pydantic:
                 item = EvaluationItem(score=res.pydantic.score, suggestion=res.pydantic.suggestion, criteria=res.pydantic.criteria)
@@ -241,7 +256,7 @@ class TaskOutput(BaseModel):
 
 class Task(BaseModel):
     """
-    A class that stores independent task information.
+    A class that stores independent task information and handles task executions.
     """
 
     __hash__ = object.__hash__
@@ -255,8 +270,8 @@ class Task(BaseModel):
     description: str = Field(description="Description of the actual task")
 
     # output
-    pydantic_output: Optional[Any] = Field(default=None, description="store a custom Pydantic class as response format")
-    response_fields: List[ResponseField] = Field(default_factory=list, description="store the list of ResponseFields to create the response format")
+    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")
     output: Optional[TaskOutput] = Field(default=None, description="store the final task output in TaskOutput class")
 
     # task setup
@@ -269,8 +284,8 @@ class Task(BaseModel):
     tool_res_as_final: bool = Field(default=False, description="when set True, tools res will be stored in the `TaskOutput`")
 
     # execution rules
+    execution_type: TaskExecutionType = Field(default=TaskExecutionType.SYNC)
     allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
-    async_execution: bool = Field(default=False,description="whether the task should be executed asynchronously or not")
     callback: Optional[Callable] = Field(default=None, description="callback to be executed after the task is completed.")
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
@@ -408,11 +423,7 @@ Ref. Output image: {output_formats_to_follow}
                 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())
-
+                        properties.update(item._format_props())
                         required_fields.append(item.title)
 
                 response_schema = {
@@ -421,7 +432,6 @@ Ref. Output image: {output_formats_to_follow}
                     "required": required_fields,
                     "additionalProperties": False,
                 }
-
                 response_format = {
                     "type": "json_schema",
                     "json_schema": { "name": "outcome", "schema": response_schema }
@@ -429,7 +439,7 @@ Ref. Output image: {output_formats_to_follow}
 
 
             elif self.pydantic_output:
-                response_format = StructuredOutput(response_format=self.pydantic_output)._format()
+                response_format = StructuredOutput(response_format=self.pydantic_output, provider=model_provider)._format()
 
             return response_format
 
@@ -481,7 +491,6 @@ Ref. Output image: {output_formats_to_follow}
 
             for k, v in json_dict.items():
                 setattr(output_pydantic, k, v)
-
         except:
             pass
 
@@ -536,9 +545,35 @@ Ref. Output image: {output_formats_to_follow}
             self._logger.log(level="error", message=f"Failed to add to the memory: {str(e)}", color="red")
             pass
 
+    def _build_agent_from_task(self, task_description: str = None) -> InstanceOf["vhq.Agent"]:
+        task_description = task_description if task_description else self.description
+        if not task_description:
+            self._logger.log(level="error", message="Task is missing the description.", color="red")
+            pass
+
+        agent = vhq.Agent(goal=task_description, role=task_description, maxit=1) #! REFINEME
+        return agent
+
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str | List[Any]] = None) -> TaskOutput:
+    def execute(self, type: TaskExecutionType = None, agent: Optional[Any] = None, context: Optional[str] = None) -> TaskOutput | Future[TaskOutput]:
+        """
+        A main method to handle task execution. Build an agent when the agent is not given.
+        """
+        type = type if type else  self.execution_type if self.execution_type else TaskExecutionType.SYNC
+
+        if not agent:
+            agent = self._build_agent_from_task(task_description=self.description)
+
+        match type:
+            case TaskExecutionType.SYNC:
+                return self._execute_sync(agent=agent, context=context)
+
+            case TaskExecutionType.ASYNC:
+                return self._execute_async(agent=agent, context=context)
+
+
+    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.
@@ -553,7 +588,7 @@ Ref. Output image: {output_formats_to_follow}
         return self._execute_core(agent, context)
 
 
-    def execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
+    def _execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
         """
         Execute the task asynchronously.
         """
@@ -565,7 +600,7 @@ Ref. Output image: {output_formats_to_follow}
 
     def _execute_task_async(self, agent, context: Optional[str], future: Future[TaskOutput]) -> None:
         """
-        Execute the task asynchronously with context handling.
+        Executes the task asynchronously with context handling.
         """
 
         result = self._execute_core(agent, context)
@@ -574,8 +609,8 @@ Ref. Output image: {output_formats_to_follow}
 
     def _execute_core(self, agent, context: Optional[str]) -> TaskOutput:
         """
-        Execute the given task with the given agent.
-        Handle 1. agent delegation, 2. tools, 3. context to consider, and 4. callbacks
+        A core method for task execution.
+        Handles 1. agent delegation, 2. tools, 3. context to add to the prompt, and 4. callbacks
         """
 
         from versionhq.agent.model import Agent
@@ -634,13 +669,13 @@ Ref. Output image: {output_formats_to_follow}
                 json_dict=json_dict_output
             )
 
-
         self.latency = (ended_at - started_at).total_seconds()
+        task_output.evaluation = Evaluation(latency=self.latency, tokens=self.tokens)
         self.output = task_output
         self.processed_agents.add(agent.role)
 
         if self.should_evaluate:
-            task_output.evaluate(task=self, latency=self.latency, tokens=self.tokens)
+            task_output.evaluate(task=self)
 
         self._create_short_and_long_term_memories(agent=agent, task_output=task_output)
 
@@ -648,7 +683,7 @@ Ref. Output image: {output_formats_to_follow}
             kwargs = { **self.callback_kwargs, **task_output.json_dict }
             sig = inspect.signature(self.callback)
             valid_keys = [param.name for param in sig.parameters.values() if param.kind == param.POSITIONAL_OR_KEYWORD]
-            valid_kwargs = { k: kwargs[k] for k in valid_keys }
+            valid_kwargs = { k: kwargs[k] if  k in kwargs else None for k in valid_keys }
             callback_res = self.callback(**valid_kwargs)
             task_output.callback_output = callback_res
 
@@ -687,50 +722,49 @@ Task ID: {str(self.id)}
 
 
 
-class ConditionalTask(Task):
-    """
-    A task that can be conditionally executed based on the output of another task.
-    When the `condition` return True, execute the task, else skipped with `skipped task output`.
-    """
+# class ConditionalTask(Task):
+#     """
+#     A task that can be conditionally executed based on the output of another task.
+#     When the `condition` return True, execute the task, else skipped with `skipped task output`.
+#     """
 
-    condition: Callable[[TaskOutput], bool] = Field(
-        default=None,
-        description="max. number of retries for an agent to execute a task when an error occurs",
-    )
+#     condition: Callable[[TaskOutput], bool] = Field(
+#         default=None,
+#         description="max. number of retries for an agent to execute a task when an error occurs",
+#     )
 
 
-    def __init__(self, condition: Callable[[Any], bool], **kwargs):
-        super().__init__(**kwargs)
-        self.condition = condition
-        self._logger = Logger(verbose=True)
+#     def __init__(self, condition: Callable[[Any], bool], **kwargs):
+#         super().__init__(**kwargs)
+#         self.condition = condition
 
 
-    def should_execute(self, context: TaskOutput) -> bool:
-        """
-        Decide whether the conditional task should be executed based on the provided context.
-        Return `True` if it should be executed.
-        """
-        return self.condition(context)
+#     def should_execute(self, context: TaskOutput) -> bool:
+#         """
+#         Decide whether the conditional task should be executed based on the provided context.
+#         Return `True` if it should be executed.
+#         """
+#         return self.condition(context)
 
 
-    def get_skipped_task_output(self):
-        return TaskOutput(task_id=self.id, raw="", pydantic=None, json_dict={})
+#     def get_skipped_task_output(self):
+#         return TaskOutput(task_id=self.id, raw="", pydantic=None, json_dict={})
 
 
-    def _handle_conditional_task(self, task_outputs: List[TaskOutput], task_index: int, was_replayed: bool) -> Optional[TaskOutput]:
-        """
-        When the conditional task should be skipped, return `skipped_task_output` as task_output else return None
-        """
+#     def _handle_conditional_task(self, task_outputs: List[TaskOutput], task_index: int, was_replayed: bool) -> Optional[TaskOutput]:
+#         """
+#         When the conditional task should be skipped, return `skipped_task_output` as task_output else return None
+#         """
 
-        previous_output = task_outputs[task_index - 1] if task_outputs and len(task_outputs) > 1  else None
+#         previous_output = task_outputs[task_index - 1] if task_outputs and len(task_outputs) > 1  else None
 
-        if previous_output and not self.should_execute(previous_output):
-            self._logger.log(level="warning", message=f"Skipping conditional task: {self.description}", color="yellow")
-            skipped_task_output = self.get_skipped_task_output()
-            self.output = skipped_task_output
+#         if previous_output and not self.should_execute(previous_output):
+#             self._logger.log(level="warning", message=f"Skipping conditional task: {self.description}", color="yellow")
+#             skipped_task_output = self.get_skipped_task_output()
+#             self.output = skipped_task_output
 
-            if not was_replayed:
-                self._store_execution_log(self, task_index=task_index, was_replayed=was_replayed, inputs={})
-            return skipped_task_output
+#             if not was_replayed:
+#                 self._store_execution_log(self, task_index=task_index, was_replayed=was_replayed, inputs={})
+#             return skipped_task_output
 
-        return None
+#         return None

versionhq/task/structured_response.py

@@ -3,11 +3,11 @@ from typing import Dict, Type, List, Any
 from pydantic import BaseModel, Field, InstanceOf
 
 from versionhq.llm.llm_vars import SchemaType
-from versionhq.llm.model import LLM
+from versionhq.llm.model import LLM, DEFAULT_MODEL_PROVIDER_NAME
 
 
 """
-Structure a response schema (json schema) from the given Pydantic model.
+Generate a JSON schema from the given Pydantic model.
 """
 
 
@@ -15,7 +15,7 @@ class StructuredObject:
     """
     A class to store the structured dictionary.
     """
-    provider: str = "openai"
+    provider: str = None
     field: Type[Field]
 
     title: str
@@ -24,20 +24,21 @@ class StructuredObject:
     required: List[str] = list()
     additionalProperties: bool = False
 
-    def __init__(self, name, field: Type[Field], provider: str | InstanceOf[LLM] = "openai"):
+    def __init__(self, name, field: Type[Field], provider: str | InstanceOf[LLM] = None):
         self.title = name
         self.field = field
         self.dtype = "object"
         self.additionalProperties = False
-        self.provider = provider if isinstance(provider, str) else provider.provider
+        self.provider = provider if isinstance(provider, str) else provider.provider if isinstance(provider, LLM) else DEFAULT_MODEL_PROVIDER_NAME
 
     def _format(self):
         if not self.field:
             pass
         else:
             description = self.field.description if hasattr(self.field, "description") and self.field.description is not None else ""
-            self.properties.update({"item": { "type": SchemaType(self.field.annotation.__args__).convert() }})
-            self.required.append("item")
+            field_name = self.field.__name__ if hasattr(self.field, "__name__") and self.field.__name__ else self.title
+            self.properties.update({ field_name : { "type": SchemaType(self.field.annotation.__args__).convert() }})
+            self.required.append(field_name)
 
             return {
                 self.title: {
@@ -55,13 +56,13 @@ class StructuredList:
     """
     A class to store a structured list with 1 nested object.
     """
-    provider: str = "openai"
+    provider: str = DEFAULT_MODEL_PROVIDER_NAME
     field: Type[Field]
     title: str = ""
     dtype: str = "array"
     items: Dict[str, Dict[str, str]] = dict()
 
-    def __init__(self, name, field: Type[Field], provider: str | LLM = "openai"):
+    def __init__(self, name, field: Type[Field], provider: str | LLM = DEFAULT_MODEL_PROVIDER_NAME):
         self.provider = provider if isinstance(provider, str) else provider.provider
         self.field = field
         self.title = name
@@ -77,15 +78,15 @@ class StructuredList:
             description = "" if field.description is None else field.description
             props = {}
 
-            for item in field.annotation.__args__:
+            for i, item in enumerate(field.annotation.__args__):
                 nested_object_type = item.__origin__ if hasattr(item, "__origin__") else item
 
                 if nested_object_type == dict:
                     props.update({
                         # "nest":  {
                             "type": "object",
-                            "properties": { "item": { "type": "string"} }, #! REFINEME - field title <>`item`
-                            "required": ["item",],
+                            "properties": { f"{str(i)}": { "type": "string"} },
+                            "required": [f"{str(i)}",],
                             "additionalProperties": False
                         # }
                         })
@@ -94,13 +95,14 @@ class StructuredList:
                     props.update({
                         # "nest":  {
                             "type": "array",
-                            "items": { "type": "string" } , #! REFINEME - field title <>`item`
+                            "items": { "type": "string" },
                         # }
                         })
                 else:
                     props.update({ "type": SchemaType(nested_object_type).convert() })
 
             self.items = { **props }
+
             return {
                  self.title: {
                     "type": self.dtype,
@@ -112,7 +114,7 @@ class StructuredList:
 
 class StructuredOutput(BaseModel):
     response_format: Any = None # pydantic base model
-    provider: str = "openai"
+    provider: str = None
     applicable_models: List[InstanceOf[LLM] | str] = list()
     name: str = ""
     schema: Dict[str, Any] = dict(type="object", additionalProperties=False, properties=dict(), required=list())

versionhq/team/model.py

@@ -10,7 +10,7 @@ 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
+from versionhq.task.model import Task, TaskOutput, TaskExecutionType
 from versionhq.task.formatter import create_raw_outputs
 from versionhq.team.team_planner import TeamPlanner
 from versionhq._utils.logger import Logger
@@ -215,7 +215,7 @@ class Team(BaseModel):
         for task in reversed(self.tasks):
             if not task:
                 break
-            elif task.async_execution:
+            elif task.execution_type == TaskExecutionType.ASYNC:
                 async_task_count += 1
             else:
                 break
@@ -341,7 +341,7 @@ class Team(BaseModel):
         for task_index, task in enumerate(tasks):
             if start_index is not None and task_index < start_index:
                 if task.output:
-                    if task.async_execution:
+                    if task.execution_type == TaskExecutionType.ASYNC:
                         task_outputs.append(task.output)
                     else:
                         task_outputs = [task.output]
@@ -352,20 +352,21 @@ class Team(BaseModel):
             if responsible_agent is None:
                 self._assign_tasks()
 
-            if isinstance(task, ConditionalTask):
-                skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
-                if skipped_task_output:
-                    continue
+            ## commented out - this will be handled by node objects
+            # if isinstance(task, ConditionalTask):
+            #     skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
+            #     if skipped_task_output:
+            #         continue
 
             # self._log_task_start(task, responsible_agent)
 
-            if task.async_execution:
+            if task.execution_type == TaskExecutionType.ASYNC:
                 context = create_raw_outputs(tasks=[task, ], task_outputs=([last_sync_output,] if last_sync_output else []))
-                future = task.execute_async(agent=responsible_agent, context=context)
+                future = task._execute_async(agent=responsible_agent, context=context)
                 futures.append((task, future, task_index))
             else:
                 context = create_raw_outputs(tasks=[task,], task_outputs=([last_sync_output,] if last_sync_output else [] ))
-                task_output = task.execute_sync(agent=responsible_agent, context=context)
+                task_output = task.execute(agent=responsible_agent, context=context)
                 if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 

versionhq/team/team_planner.py

@@ -3,8 +3,6 @@ from typing import Any, List, Optional, Dict
 from pydantic import BaseModel, Field
 
 
-
-
 class TeamPlanner:
     """
     A class to handle agent formations based on the given task description.
@@ -50,7 +48,7 @@ class TeamPlanner:
                     ResponseField(title="role", data_type=str, required=True),
                 ],
             )
-            res = task.execute_sync(agent=agent_creator)
+            res = task.execute(agent=agent_creator)
             agent = Agent(
                 role=res.json_dict["role"] if "role" in res.json_dict else res.raw,
                 goal=res.json_dict["goal"] if "goal" in res.json_dict else task.description
@@ -90,5 +88,5 @@ class TeamPlanner:
             """,
             pydantic_output=TeamPlanIdea
         )
-        output = task.execute_sync(agent=team_planner, context=context, tools=tools)
+        output = task.execute(agent=team_planner, context=context, tools=tools)
         return output