versionhq 1.1.7.5__py3-none-any.whl → 1.1.7.8__py3-none-any.whl

versionhq/__init__.py

@@ -17,7 +17,7 @@ from versionhq.team.model import Team, TeamOutput
 from versionhq.tool.model import Tool
 
 
-__version__ = "1.1.7.5"
+__version__ = "1.1.7.8"
 __all__ = [
     "Agent",
     "Customer",

versionhq/_utils/process_config.py

@@ -2,9 +2,7 @@ from typing import Any, Dict, Type
 from pydantic import BaseModel
 
 
-def process_config(
-    values_to_update: Dict[str, Any], model_class: Type[BaseModel]
-) -> Dict[str, Any]:
+def process_config(values_to_update: Dict[str, Any], model_class: Type[BaseModel]) -> Dict[str, Any]:
     """
     Process the config dictionary and update the values accordingly.
     Refer to the Pydantic model class for field validation.
@@ -15,7 +13,7 @@ def process_config(
     else:
         return values_to_update
 
-    # copy values from config to the model's attributes if the attribute isn't already set.
+
     for key, value in config.items():
         if key not in model_class.model_fields or values_to_update.get(key) is not None:
             continue

versionhq/agent/model.py

@@ -1,7 +1,7 @@
 import os
 import uuid
 from abc import ABC
-from typing import Any, Dict, List, Optional, TypeVar, Union
+from typing import Any, Dict, List, Optional, TypeVar
 from dotenv import load_dotenv
 from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
 from pydantic_core import PydanticCustomError
@@ -22,7 +22,7 @@ load_dotenv(override=True)
 T = TypeVar("T", bound="Agent")
 
 
-# def _format_answer(agent, answer: str) -> Union[AgentAction, AgentFinish]:
+# def _format_answer(agent, answer: str) -> AgentAction | AgentFinish:
 #     return AgentParser(agent=agent).parse(answer)
 
 # def mock_agent_ops_provider():
@@ -85,7 +85,7 @@ class Agent(ABC, BaseModel):
     """
 
     __hash__ = object.__hash__
-    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=False))
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
     _rpm_controller: Optional[RPMController] = PrivateAttr(default=None)
     _request_within_rpm_limit: Any = PrivateAttr(default=None)
     _token_process: TokenProcess = PrivateAttr(default_factory=TokenProcess)
@@ -111,8 +111,8 @@ class Agent(ABC, BaseModel):
     step_callback: Optional[Any] = Field(default=None,description="Callback to be executed after each step of the agent execution")
 
     # llm settings cascaded to the LLM model
-    llm: Union[str, InstanceOf[LLM], Any] = Field(default=None)
-    function_calling_llm: Union[str, InstanceOf[LLM], Any] = Field(default=None)
+    llm: str | InstanceOf[LLM] | Any = Field(default=None)
+    function_calling_llm: str | InstanceOf[LLM] | Any = Field(default=None)
     respect_context_window: bool = Field(default=True,description="Keep messages under the context window size by summarizing content")
     max_tokens: Optional[int] = Field(default=None, description="max. number of tokens for the agent's execution")
     max_execution_time: Optional[int] = Field(default=None, description="max. execution time for an agent to execute a task")
@@ -327,7 +327,7 @@ class Agent(ABC, BaseModel):
         messages = []
         messages.append({"role": "user", "content": prompts})  #! REFINEME
         messages.append({"role": "assistant", "content": self.backstory})
-        print("Messages sent to the model:", messages)
+        self._logger.log(level="info", message=f"Messages sent to the model: {messages}", color="blue")
 
         callbacks = kwargs.get("callbacks", None)
 
@@ -338,7 +338,7 @@ class Agent(ABC, BaseModel):
             callbacks=callbacks,
         )
         task_execution_counter += 1
-        print("Agent's #1 res: ", response)
+        self._logger.log(level="info", message=f"Agent's first response: {response}", color="blue")
 
         if (response is None or response == "") and task_execution_counter < self.max_retry_limit:
             while task_execution_counter <= self.max_retry_limit:
@@ -349,10 +349,10 @@ class Agent(ABC, BaseModel):
                     callbacks=callbacks,
                 )
                 task_execution_counter += 1
-                print(f"Agent's #{task_execution_counter} res: ", response)
+                self._logger.log(level="info", message=f"Agent's next response: {response}", color="blue")
 
         elif response is None or response == "":
-            print("Received None or empty response from LLM call.")
+            self._logger.log(level="error", message="Received None or empty response from the model", color="red")
             raise ValueError("Invalid response from LLM call - None or empty.")
 
         return {"output": response.output if hasattr(response, "output") else response}

versionhq/agent/parser.py

@@ -1,5 +1,5 @@
 import re
-from typing import Any, Union
+from typing import Any
 from json_repair import repair_json
 
 from versionhq._utils.i18n import I18N
@@ -70,7 +70,7 @@ class AgentParser:
     def __init__(self, agent: Any):
         self.agent = agent
 
-    def parse(self, text: str) -> Union[AgentAction, AgentFinish]:
+    def parse(self, text: str) -> AgentAction | AgentFinish:
         thought = self._extract_thought(text)
         includes_answer = FINAL_ANSWER_ACTION in text
         regex = (

versionhq/clients/workflow/model.py

@@ -1,8 +1,8 @@
 import uuid
 from abc import ABC
 from datetime import date, datetime, time, timedelta
-from typing import Any, Dict, List, Union, Callable, Type, Optional, get_args, get_origin
-from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
+from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq.clients.product.model import Product
@@ -12,7 +12,7 @@ from versionhq.team.model import Team
 
 
 class ScoreFormat:
-    def __init__(self, rate: Union[float, int] = 0, weight: int = 1):
+    def __init__(self, rate: float | int = 0, weight: int = 1):
         self.rate = rate
         self.weight = weight
         self.aggregate = rate * weight
@@ -39,7 +39,7 @@ class Score:
 
 
     def result(self) -> int:
-        aggregate_score = self.brand_tone.aggregate + self.audience.aggregate + self.track_record.aggregate
+        aggregate_score = int(self.brand_tone.aggregate) + int(self.audience.aggregate) + int(self.track_record.aggregate)
         denominator = self.brand_tone.weight + self.audience.weight + self.track_record.weight
 
         for k, v in self.kwargs.items():
@@ -57,11 +57,12 @@ class MessagingComponent(ABC, BaseModel):
     layer_id: int = Field(default=0, description="add id of the layer: 0, 1, 2")
     message: str = Field(default=None, max_length=1024, description="text message content to be sent")
     interval: Optional[str] = Field(
-        default=None,description="interval to move on to the next layer. if this is the last layer, set as `None`")
-    score: Union[float, InstanceOf[Score]] = Field(default=None)
+        default=None, description="interval to move on to the next layer. if this is the last layer, set as `None`"
+    )
+    score: float | InstanceOf[Score] = Field(default=None)
 
 
-    def store_scoring_result(self, scoring_subject: str, score_raw: Union[int, Score, ScoreFormat] = None):
+    def store_scoring_result(self, scoring_subject: str, score_raw: int | Score | ScoreFormat = None):
         """
         Set up the `score` field
         """
@@ -109,8 +110,11 @@ class MessagingWorkflow(ABC, BaseModel):
     product: InstanceOf[Product] = Field(default=None)
     customer: InstanceOf[Customer] = Field(default=None)
 
-    metrics: Union[List[Dict[str, Any]], List[str]] = Field(
-        default=None, max_length=256, description="store metrics that used to predict and track the performance of this workflow.")
+    metrics: List[Dict[str, Any]] | List[str] = Field(
+        default=None,
+        max_length=256,
+        description="store metrics that used to predict and track the performance of this workflow."
+    )
 
 
     @property

versionhq/llm/model.py

@@ -7,7 +7,7 @@ import litellm
 from dotenv import load_dotenv
 from litellm import get_supported_openai_params
 from contextlib import contextmanager
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional
 
 from versionhq.llm.llm_vars import LLM_CONTEXT_WINDOW_SIZES
 from versionhq.task import TaskOutputFormat
@@ -103,7 +103,7 @@ class LLM:
     def __init__(
         self,
         model: str,
-        timeout: Optional[Union[float, int]] = None,
+        timeout: Optional[float | int] = None,
         max_tokens: Optional[int] = None,
         max_completion_tokens: Optional[int] = None,
         context_window_size: Optional[int] = DEFAULT_CONTEXT_WINDOW,
@@ -111,7 +111,7 @@ class LLM:
         temperature: Optional[float] = None,
         top_p: Optional[float] = None,
         n: Optional[int] = None,
-        stop: Optional[Union[str, List[str]]] = None,
+        stop: Optional[str | List[str]] = None,
         presence_penalty: Optional[float] = None,
         frequency_penalty: Optional[float] = None,
         logit_bias: Optional[Dict[int, float]] = None,

versionhq/storage/task_output_storage.py

@@ -0,0 +1,141 @@
+import appdirs
+import os
+import json
+import sqlite3
+import datetime
+from typing import Any, Dict, List, Optional
+from dotenv import load_dotenv
+from pathlib import Path
+
+from versionhq._utils.logger import Logger
+
+load_dotenv(override=True)
+
+
+def fetch_db_storage_path():
+    project_directory_name = os.environ.get("STORAGE_DIR", Path.cwd().name)
+    app_author = "versionhq"
+    data_dir = Path(appdirs.user_data_dir(project_directory_name, app_author))
+    data_dir.mkdir(parents=True, exist_ok=True)
+    return data_dir
+
+storage_path = fetch_db_storage_path()
+default_db_name = "task_outputs"
+
+
+class TaskOutputSQLiteStorage:
+    """
+    An SQLite storage class to handle storing task outputs.
+    """
+
+    def __init__(self, db_path: str = f"{storage_path}/{default_db_name}.db") -> None:
+        self.db_path = db_path
+        self._logger = Logger(verbose=True)
+        self._initialize_db()
+
+
+    def _initialize_db(self):
+        """
+        Initializes the SQLite database and creates LTM table.
+        """
+
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS task_outputs (
+                        task_id TEXT PRIMARY KEY,
+                        output JSON,
+                        task_index INTEGER,
+                        inputs JSON,
+                        was_replayed BOOLEAN,
+                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    )
+                """
+                )
+                conn.commit()
+
+        except sqlite3.Error as e:
+            self._logger.log(level="error", message=f"DATABASE INITIALIZATION ERROR: {e}", color="red")
+
+
+    def add(self, task, output: Dict[str, Any], task_index: int, was_replayed: bool = False, inputs: Dict[str, Any] = {}):
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute(
+                        """INSERT OR REPLACE INTO task_outputs
+                            (task_id, output, task_index, inputs, was_replayed, timestamp)
+                            VALUES (?, ?, ?, ?, ?, ?)
+                        """,
+                     (str(task.id), json.dumps(output), task_index, json.dumps(inputs), was_replayed, datetime.datetime.now())
+                )
+                conn.commit()
+
+        except sqlite3.Error as e:
+            self._logger.log(level="error", message=f"SAVING TASK OUTPUTS ERROR: {e}", color="red")
+
+
+    def update(self, task_index: int, **kwargs):
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+
+                fields, values = [], []
+                for k, v in kwargs.items():
+                    fields.append(f"{k} = ?")
+                    values.append(json.dumps(v) if isinstance(v, dict) else v)
+
+                query = f"UPDATE latest_kickoff_task_outputs SET {', '.join(fields)} WHERE task_index = ?"  # nosec
+                values.append(task_index)
+                cursor.execute(query, tuple(values))
+                conn.commit()
+
+                if cursor.rowcount == 0:
+                    self._logger.log(
+                        level="info", message=f"No row found with task_index {task_index}. No update performed.", color="yellow",
+                    )
+
+        except sqlite3.Error as e:
+            self._logger.log(level="error", message=f"UPDATE TASK OUTPUTS ERROR: {e}", color="red")
+
+
+    def load(self) -> Optional[List[Dict[str, Any]]]:
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("""
+                SELECT *
+                FROM task_outputs
+                ORDER BY task_index
+                """)
+
+                rows = cursor.fetchall()
+                results = []
+                for row in rows:
+                    result = {
+                        "task_id": row[0],
+                        "output": json.loads(row[1]),
+                        "task_index": row[2],
+                        "inputs": json.loads(row[3]),
+                        "was_replayed": row[4],
+                        "timestamp": row[5],
+                    }
+                    results.append(result)
+                return results
+
+        except sqlite3.Error as e:
+            self._logger.log(level="error", message=f"LOADING TASK OUTPUTS ERROR: {e}", color="red")
+            return None
+
+
+    def delete_all(self):
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute("DELETE FROM task_outputs")
+                conn.commit()
+
+        except sqlite3.Error as e:
+            self._logger.log(level="error", message=f"ERROR: Failed to delete all: {e}", color="red")

versionhq/task/log_handler.py

@@ -0,0 +1,59 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+from versionhq.storage.task_output_storage import TaskOutputSQLiteStorage
+
+
+class ExecutionLog(BaseModel):
+    task_id: str
+    output: Dict[str, Any]
+    timestamp: datetime = Field(default_factory=datetime.now)
+    task_index: int
+    inputs: Dict[str, Any] = Field(default_factory=dict)
+    was_replayed: bool = False
+
+    def __getitem__(self, key: str) -> Any:
+        return getattr(self, key)
+
+
+
+class TaskOutputStorageHandler:
+
+    def __init__(self):
+        self.storage = TaskOutputSQLiteStorage()
+
+
+    def update(self, task, task_index: int, was_replayed: bool = False, inputs: Dict[str, Any] = {}) -> None:
+        """
+        task: task instance
+        """
+        saved_outputs = self.load()
+        if saved_outputs is None:
+            raise ValueError("Logs cannot be None")
+
+        self.add(task, task_index, was_replayed, inputs)
+
+
+    def add(self, task, task_index: int, was_replayed: bool = False, inputs: Dict[str, Any] = {}) -> None:
+        from versionhq.task.model import Task
+
+        output_to_store = dict()
+
+        if isinstance(task, Task):
+            output_to_store = dict(
+                description=str(task.description),
+                raw=str(task.output.raw),
+                responsible_agent=str(task.processed_by_agents),
+            )
+
+        self.storage.add(task=task, output=output_to_store, task_index=task_index, was_replayed=was_replayed, inputs=inputs)
+
+
+    def reset(self) -> None:
+        self.storage.delete_all()
+
+
+    def load(self) -> Optional[List[Dict[str, Any]]]:
+        return self.storage.load()

versionhq/task/model.py

@@ -3,15 +3,17 @@ import threading
 import uuid
 from concurrent.futures import Future
 from hashlib import md5
-from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Union, Type
+from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type
 from typing_extensions import Annotated
 
-from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model
+from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf
 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.tool.model import Tool, ToolCalled
+from versionhq._utils.logger import Logger
 
 
 class ResponseField(BaseModel):
@@ -47,7 +49,7 @@ class ResponseField(BaseModel):
             return value
 
 
-    def create_pydantic_model(self, result: Dict, base_model: Union[BaseModel | Any]) -> Any:
+    def create_pydantic_model(self, result: Dict, base_model: InstanceOf[BaseModel] | Any) -> Any:
         for k, v in result.items():
             if k is not self.title:
                 pass
@@ -59,20 +61,6 @@ class ResponseField(BaseModel):
         return base_model
 
 
-class AgentOutput(BaseModel):
-    """
-    Keep adding agents' learning and recommendation and store it in `pydantic` field of `TaskOutput` class.
-    Since the TaskOutput class has `agent` field, we don't add any info on the agent that handled the task.
-    """
-    customer_id: str = Field(default=None, max_length=126, description="customer uuid")
-    customer_analysis: str = Field(default=None, max_length=256, description="analysis of the customer")
-    product_overview: str = Field(default=None, max_length=256, description="analysis of the client's business")
-    usp: str = Field()
-    cohort_timeframe: int = Field(default=None, max_length=256, description="suitable cohort timeframe in days")
-    kpi_metrics: List[str] = Field(default=list, description="Ideal KPIs to be tracked")
-    assumptions: List[Dict[str, Any]] = Field(default=list, description="assumptions to test")
-
-
 
 class TaskOutput(BaseModel):
     """
@@ -82,7 +70,7 @@ class TaskOutput(BaseModel):
 
     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: Union[Dict[str, Any]] = Field(default=None, description="`raw` converted to dictionary")
+    json_dict: Dict[str, Any] = Field(default=None, description="`raw` converted to dictionary")
     pydantic: Optional[Any] = Field(default=None, description="`raw` converted to the abs. pydantic model")
 
     def __str__(self) -> str:
@@ -133,11 +121,13 @@ class Task(BaseModel):
     """
 
     __hash__ = object.__hash__
+    _original_description: str = PrivateAttr(default=None)
+    _logger: Logger = PrivateAttr()
+    _task_output_handler = TaskOutputStorageHandler()
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True, description="unique identifier for the object, not set by user")
     name: Optional[str] = Field(default=None)
     description: str = Field(description="Description of the actual task")
-    _original_description: str = PrivateAttr(default=None)
 
     # output
     expected_output_json: bool = Field(default=True)
@@ -161,7 +151,7 @@ class Task(BaseModel):
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
     # recording
-    processed_by_agents: Set[str] = Field(default_factory=set)
+    processed_by_agents: Set[str] = Field(default_factory=set, description="store responsible agents' roles")
     used_tools: int = 0
     tools_errors: int = 0
     delegations: int = 0
@@ -372,7 +362,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
 
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str] = None) -> TaskOutput:
+    def execute_sync(self, agent, context: Optional[str] = None, tools: Optional[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.
@@ -386,7 +376,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         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, tools: Optional[List[Any]] = None) -> Future[TaskOutput]:
         """
         Execute the task asynchronously.
         """
@@ -395,21 +385,21 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         threading.Thread(
             daemon=True,
             target=self._execute_task_async,
-            args=(agent, context, future),
+            args=(agent, context, tools, future),
         ).start()
         return future
 
 
-    def _execute_task_async(self, agent, context: Optional[str], future: Future[TaskOutput]) -> None:
+    def _execute_task_async(self, agent, context: Optional[str], tools: Optional[List[Any]], future: Future[TaskOutput]) -> None:
         """
         Execute the task asynchronously with context handling.
         """
 
-        result = self._execute_core(agent, context)
+        result = self._execute_core(agent, context, tools)
         future.set_result(result)
 
 
-    def _execute_core(self, agent, context: Optional[str]) -> TaskOutput:
+    def _execute_core(self, agent, context: Optional[str], tools: Optional[List[Any]] = []) -> TaskOutput:
         """
         Run the core execution logic of the task.
         To speed up the process, when the format is not expected to return, we will skip the conversion process.
@@ -436,7 +426,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
             agent = agent_to_delegate
             self.delegations += 1
 
-        output_raw, output_json_dict, output_pydantic = agent.execute_task(task=self, context=context), None, None
+        output_raw, output_json_dict, output_pydantic = agent.execute_task(task=self, context=context, tools=tools), None, None
 
         if self.expected_output_json:
             output_json_dict = self.create_json_output(raw_result=output_raw)
@@ -472,24 +462,32 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         return task_output
 
 
+    def _store_execution_log(self, task_index: int, was_replayed: bool = False, inputs: Optional[Dict[str, Any]] = {}) -> None:
+        """
+        Store the task execution log.
+        """
+
+        self._task_output_handler.update(task=self, task_index=task_index, was_replayed=was_replayed, inputs=inputs)
+
+
+
 class ConditionalTask(Task):
     """
     A task that can be conditionally executed based on the output of another task.
-    Use this with `Team`.
+    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.",
+        description="max. number of retries for an agent to execute a task when an error occurs",
     )
 
-    def __init__(
-        self,
-        condition: Callable[[Any], bool],
-        **kwargs,
-    ):
+
+    def __init__(self, condition: Callable[[Any], bool], **kwargs):
         super().__init__(**kwargs)
         self.condition = condition
+        self._logger = Logger(verbose=True)
+
 
     def should_execute(self, context: TaskOutput) -> bool:
         """
@@ -498,5 +496,25 @@ class ConditionalTask(Task):
         """
         return self.condition(context)
 
+
     def get_skipped_task_output(self):
-        return TaskOutput(task_id=self.id, raw="", pydantic=None, json_dict=None)
+        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
+        """
+
+        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="debug", 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
+
+        return None

versionhq/team/model.py

@@ -6,7 +6,7 @@ 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, Union
+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 pydantic._internal._generate_schema import GenerateSchema
 from pydantic_core import PydanticCustomError, core_schema
@@ -61,7 +61,7 @@ class TeamOutput(BaseModel):
     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: Union[Dict[str, Any]] = Field(default=None, description="`raw` converted to dictionary")
+    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")
     token_usage: UsageMetrics = Field(default=dict, description="processed token summary")
 
@@ -188,14 +188,9 @@ class Team(BaseModel):
         2. manager_task,
         3. members' tasks
         """
-        sorted_member_tasks = [
-            member.task for member in self.members if member.is_manager == True
-        ] + [member.task for member in self.members if member.is_manager == False]
-        return (
-            self.team_tasks + sorted_member_tasks
-            if len(self.team_tasks) > 0
-            else sorted_member_tasks
-        )
+        sorted_member_tasks = [member.task for member in self.members if member.is_manager == True] + [member.task for member in self.members if member.is_manager == False]
+        return self.team_tasks + sorted_member_tasks if len(self.team_tasks) > 0 else sorted_member_tasks
+
 
     # validators
     @field_validator("id", mode="before")
@@ -205,10 +200,6 @@ class Team(BaseModel):
         if v:
             raise PydanticCustomError("may_not_set_field", "The 'id' field cannot be set by the user.", {})
 
-    # @field_validator("config", mode="before")
-    # @classmethod
-    # def check_config_type(cls, v: Union[Json, Dict[str, Any]]) -> Union[Json, Dict[str, Any]]:
-    #     return json.loads(v) if isinstance(v, Json) else v
 
     @model_validator(mode="after")
     def check_manager_llm(self):
@@ -261,7 +252,7 @@ class Team(BaseModel):
             if task.async_execution:
                 async_task_count += 1
             else:
-                break  # stop traversing when a non-async task is found
+                break
 
         if async_task_count > 1:
             raise PydanticCustomError(
@@ -287,47 +278,23 @@ class Team(BaseModel):
                     result[task_id] if hasattr(result, str(task_id)) else result
                 )
 
+
     # task execution
     def _process_async_tasks(
-            self, futures: List[Tuple[Task, Future[TaskOutput], int]], was_replayed: bool = False
-        ) -> List[TaskOutput]:
+        self, futures: List[Tuple[Task, Future[TaskOutput], int]], was_replayed: bool = False
+    ) -> List[TaskOutput]:
+        """
+        When we have `Future` tasks, updated task outputs and task execution logs accordingly.
+        """
+
         task_outputs: List[TaskOutput] = []
+
         for future_task, future, task_index in futures:
             task_output = future.result()
             task_outputs.append(task_output)
-            self._process_task_result(future_task, task_output)
-            self._store_execution_log(
-                future_task, task_output, task_index, was_replayed
-            )
-        return task_outputs
-
-
-    def _handle_conditional_task(
-        self,
-        task: ConditionalTask,
-        task_outputs: List[TaskOutput],
-        futures: List[Tuple[Task, Future[TaskOutput], int]],
-        task_index: int,
-        was_replayed: bool,
-    ) -> Optional[TaskOutput]:
-
-        if futures:
-            task_outputs = self._process_async_tasks(futures, was_replayed)
-            futures.clear()
-
-        previous_output = task_outputs[task_index - 1] if task_outputs else None
-        if previous_output is not None and not task.should_execute(previous_output):
-            self._logger.log(
-                "debug",
-                f"Skipping conditional task: {task.description}",
-                color="yellow",
-            )
-            skipped_task_output = task.get_skipped_task_output()
+            future_task._store_execution_log(task_index, was_replayed)
 
-            if not was_replayed:
-                self._store_execution_log(task, skipped_task_output, task_index)
-            return skipped_task_output
-        return None
+        return task_outputs
 
 
     def _create_team_output(self, task_outputs: List[TaskOutput], lead_task_output: TaskOutput = None) -> TeamOutput:
@@ -401,38 +368,33 @@ class Team(BaseModel):
             if responsible_agent is None:
                 responsible_agent = self.manager_agent if self.manager_agent else self.members[0].agent
 
-            # self._prepare_agent_tools(task)
-            # self._log_task_start(task, responsible_agent)
-
             if isinstance(task, ConditionalTask):
-                skipped_task_output = self._handle_conditional_task(task, task_outputs, futures, task_index, was_replayed)
+                skipped_task_output = task._handle_conditional_task(task_outputs, futures, task_index, was_replayed)
                 if skipped_task_output:
                     continue
 
+            # self._prepare_agent_tools(task)
+            # self._log_task_start(task, responsible_agent)
+
             if task.async_execution:
                 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
-                                            # tools=responsible_agent.tools
-                                            )
+                future = task.execute_async(agent=responsible_agent, context=context, tools=responsible_agent.tools)
                 futures.append((task, future, task_index))
             else:
-                if futures:
-                    task_outputs = self._process_async_tasks(futures, was_replayed)
-                    futures.clear()
-
-                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
-                                                # tools=responsible_agent.tools
+                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, tools=responsible_agent.tools
                                                 )
                 if responsible_agent is self.manager_agent:
                     lead_task_output = task_output
 
                 task_outputs.append(task_output)
                 # self._process_task_result(task, task_output)
-                # self._store_execution_log(task, task_output, task_index, was_replayed)
+                task._store_execution_log(task_index, was_replayed)
+
+
+        if futures:
+            task_outputs = self._process_async_tasks(futures, was_replayed)
 
-        # if futures:
-        # task_outputs = self._process_async_tasks(futures, was_replayed)
         return self._create_team_output(task_outputs, lead_task_output)
 
 
@@ -458,10 +420,6 @@ class Team(BaseModel):
         # self._task_output_handler.reset()
         # self._logging_color = "bold_purple"
 
-        # if inputs is not None:
-        #     self._inputs = inputs
-        # self._interpolate_inputs(inputs)
-
 
         # i18n = I18N(prompt_file=self.prompt_file)
 
@@ -469,14 +427,13 @@ class Team(BaseModel):
             agent = member.agent
             agent.team = self
 
-            # add the team's common callbacks to each agent.
-            if not agent.function_calling_llm:
+            if not agent.function_calling_llm and self.function_calling_llm:
                 agent.function_calling_llm = self.function_calling_llm
 
             # if agent.allow_code_execution:
             #     agent.tools += agent.get_code_execution_tools()
 
-            if not agent.step_callback:
+            if not agent.step_callback and self.step_callback:
                 agent.step_callback = self.step_callback
 
         if self.process is None:

versionhq/tool/model.py

@@ -1,15 +1,7 @@
 from abc import ABC
 from inspect import signature
 from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin
-from pydantic import (
-    InstanceOf,
-    BaseModel,
-    ConfigDict,
-    Field,
-    create_model,
-    field_validator,
-    model_validator,
-)
+from pydantic import InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 
 from versionhq._utils.cache_handler import CacheHandler
 
@@ -135,6 +127,7 @@ class Tool(ABC, BaseModel):
 
         return cls(name=tool_name, func=func, args_schema=args_schema)
 
+
     def run(self, *args, **kwargs) -> Any:
         """
         Use the tool.

versionhq/tool/tool_handler.py

@@ -1,4 +1,5 @@
-from typing import Any, Optional, Union
+from typing import Any, Optional
+from pydantic import InstanceOf
 from versionhq.tool.model import ToolCalled, InstructorToolCalled, CacheTool
 from versionhq._utils.cache_handler import CacheHandler
 
@@ -23,7 +24,7 @@ class ToolHandler:
 
     def record_last_tool_used(
         self,
-        last_used_tool: Union[ToolCalled, InstructorToolCalled],
+        last_used_tool: InstanceOf[ToolCalled] | InstanceOf[InstructorToolCalled],
         output: str,
         should_cache: bool = True,
     ) -> Any:

{versionhq-1.1.7.5.dist-info → versionhq-1.1.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.7.5
+Version: 1.1.7.8
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -32,6 +32,9 @@ Keywords: orchestration framework,orchestration,ai agent,multi-agent system,RAG,
 Classifier: Programming Language :: Python
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -43,12 +46,12 @@ Requires-Dist: typing
 Requires-Dist: json-repair>=0.31.0
 Requires-Dist: litellm>=1.55.8
 Requires-Dist: openai>=1.57.0
-Requires-Dist: composio-openai>=0.6.0
-Requires-Dist: pre-commit>=4.0.1
-Requires-Dist: gunicorn>=23.0.0
+Requires-Dist: composio-openai>=0.6.9
 Requires-Dist: composio>=0.1.0
 Requires-Dist: setuptools>=75.6.0
 Requires-Dist: wheel>=0.45.1
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: appdirs>=1.4.4
 
 # Overview
 
@@ -56,7 +59,7 @@ Requires-Dist: wheel>=0.45.1
 [![Publisher](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml/badge.svg)](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml)
 ![PyPI](https://img.shields.io/badge/PyPI-v1.1.7.5-blue)
 ![python ver](https://img.shields.io/badge/Python-3.12/3.13-purple)
-![pyenv ver](https://img.shields.io/badge/pyenv-2.4.23-orange)
+![pyenv ver](https://img.shields.io/badge/pyenv-2.5.0-orange)
 
 
 An LLM orchestration frameworks for multi-agent systems with RAG to autopilot outbound workflows.
@@ -276,8 +279,7 @@ src/
    ```
    uv venv
    source .venv/bin/activate
-
-   uv pip install -r requirements.txt -v
+   uv pip sync
    ```
 
 * In case of AssertionError/module mismatch, run Python version control using `.pyenv`

{versionhq-1.1.7.5.dist-info → versionhq-1.1.7.8.dist-info}/RECORD

@@ -1,14 +1,14 @@
-versionhq/__init__.py,sha256=HUTPmQJfxelI9dE_8G3mSK6--29L_B9zbIs_adJ1SJI,871
+versionhq/__init__.py,sha256=KTM1HF1lTl5AiAuFQuGwltg4LEZjHnac9mz8h12MtGg,871
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/_utils/cache_handler.py,sha256=zDQKzIn7vp-M2-uepHFxgJstjfftZS5mzXKL_-4uVvI,370
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
 versionhq/_utils/logger.py,sha256=lqRYH45KHMQ4mwE1woa5xNmngYu4O749AYECsnWWpmA,1851
-versionhq/_utils/process_config.py,sha256=ogrhovLbwe0ocQlcohRgBBRtww7C3pk9hikjvgDzT5U,919
+versionhq/_utils/process_config.py,sha256=UqoWD5IR4VLxEDGxIyVUylw_ppXwk8Wx1ynVuD-pUSg,822
 versionhq/_utils/rpm_controller.py,sha256=T7waIGeblu5K58erY4lqVLcPsWM7W9UFdU3DG9Dsk0w,2214
 versionhq/_utils/usage_metrics.py,sha256=c33a_28y8ECUgflsKN3mkNm0fNkWgZmXwybMwIqoKXA,1098
 versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/agent/model.py,sha256=h9QHB-Hi_71JinPlfL_83kaB-Ks8npzIqE7BVHwn1Aw,18439
-versionhq/agent/parser.py,sha256=GhoNQo4WloVM3vGnAmt9lnEOTARX7nWMhJE55rF_5Rs,5500
+versionhq/agent/model.py,sha256=tv14XkjrgsFsryFWzaw0w2h0X1T0ffipVK9l4kYbpIE,18598
+versionhq/agent/parser.py,sha256=db5kfk-lR1Ph9-rsTvSeW1NjR6GJ00iaqTNYxJy3N8o,5487
 versionhq/agent/TEMPLATES/Backstory.py,sha256=cdngBx1GEv7nroR46FEhnysnBJ9mEVL763_9np6Skkc,395
 versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -18,22 +18,25 @@ versionhq/clients/customer/model.py,sha256=rQnCv_wdCdrYAsUjyB6X6ULiuWfqcBBoarXcQ
 versionhq/clients/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/clients/product/model.py,sha256=Us3UnzYlub6ipBislMN-JrvxZx0ocl9PtQJINJ8XtBA,2385
 versionhq/clients/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/clients/workflow/model.py,sha256=qpRCDwULhSLWDFkSYrvXW5m07bKDrwttTmqsYA9ZVP4,5727
+versionhq/clients/workflow/model.py,sha256=GI-cSw-7zOFzLC2Xa4YfCowu3MI0JyH33qDFTqbJLmg,5725
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/llm/llm_vars.py,sha256=YZoXqFBW7XpclUZ14_AAz7WOjoyCXnGcI959GSpX2q0,5343
-versionhq/llm/model.py,sha256=PdwisrlrsDqd6gXwXCyGbGTRTeGZ8SXpt_gfua8qunk,8266
+versionhq/llm/model.py,sha256=mXzSuf1s6MebGT7_yqgNppde0NIlAF8bjIXAp2MZ9Uw,8247
+versionhq/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/storage/task_output_storage.py,sha256=RxvF_lSRUuo2Af3zMAuc1aOymx1e6e_5VJ2y757_Hu0,4910
 versionhq/task/__init__.py,sha256=g4mCATnn1mUXxsfQ5p6IpPawr8O421wVIT8kMKEcxQw,180
 versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
-versionhq/task/model.py,sha256=4Uh0OBLUO_YXaejxHbOHtNa4vckgI3abSaPz80_s9X4,18519
+versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
+versionhq/task/model.py,sha256=bUmERE6AZfs8qh2Hb9LES5BLUlXrkrOUyWxCU27M1ic,19317
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=RyspmYVtXW3f4MKjWT1mnpM9XdE435d8HbEQms7LHMU,19821
+versionhq/team/model.py,sha256=T_71FarXEzAxrTn_8yYVWMwLS9p-UxSovexZtHYnYn0,18066
 versionhq/team/team_planner.py,sha256=B1UOn_DYVVterUn2CAd80jfO4sViJCCXPJA3abSSugg,2143
 versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/tool/decorator.py,sha256=Y-j4jkoujD5LUvpe8uf3p5Zagk2XVaRKC9rkIE-2geo,1189
-versionhq/tool/model.py,sha256=JZOEcZRIEfcrjL8DgrFYDt4YNgMF8rXS26RK6D2x9mc,6906
-versionhq/tool/tool_handler.py,sha256=e-2VfG9zFpfPG_oMoPXye93GDovs7FuUASWQwUTLrJ0,1498
-versionhq-1.1.7.5.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.7.5.dist-info/METADATA,sha256=g95oUiLVJPtABZEz1CLjq2opMbjWMLtD0XLXu3zG4Rw,15801
-versionhq-1.1.7.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-versionhq-1.1.7.5.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.7.5.dist-info/RECORD,,
+versionhq/tool/model.py,sha256=s-y8323ikd5m5U2HG59ATgFW6L7yIFiPLLdOpeXQ8RI,6874
+versionhq/tool/tool_handler.py,sha256=esUqGp8HoREesai8fmh2klAf04Sjpsacmb03C7F6sNQ,1541
+versionhq-1.1.7.8.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.7.8.dist-info/METADATA,sha256=xsI-HWU0_Rb0OLH_tSDvIk7E8SWP0U-SjTQfoomW6zU,15919
+versionhq-1.1.7.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+versionhq-1.1.7.8.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.7.8.dist-info/RECORD,,