versionhq 1.1.7.4__py3-none-any.whl → 1.1.7.7__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.4"
+__version__ = "1.1.7.7"
 __all__ = [
     "Agent",
     "Customer",

versionhq/agent/model.py

@@ -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)
@@ -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/clients/workflow/model.py

@@ -61,21 +61,21 @@ class MessagingComponent(ABC, BaseModel):
     score: Union[float, InstanceOf[Score]] = Field(default=None)
 
 
-    def store_scoring_result(self, scoring_subject: str, score: Union[int, Score, ScoreFormat] = None):
+    def store_scoring_result(self, scoring_subject: str, score_raw: Union[int, Score, ScoreFormat] = None):
         """
         Set up the `score` field
         """
 
-        if isinstance(score, Score):
-            setattr(self, "score", score)
+        if isinstance(score_raw, Score):
+            setattr(self, "score", score_raw)
 
-        elif isinstance(score, ScoreFormat):
+        elif isinstance(score_raw, ScoreFormat):
             score_instance = Score()
-            setattr(score_instance, scoring_subject, score)
+            setattr(score_instance, scoring_subject, score_raw)
             setattr(self, "score", score_instance)
 
-        elif isinstance(score, int) or isinstance(score, float):
-            score_instance, score_format_instance = Score(), ScoreFormat(rate=score, weight=1)
+        elif isinstance(score_raw, int) or isinstance(score_raw, float):
+            score_instance, score_format_instance = Score(), ScoreFormat(rate=score_raw, weight=1)
             setattr(score_instance, "kwargs", { scoring_subject: score_format_instance })
             setattr(self, "score", score_instance)
 

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

@@ -11,7 +11,9 @@ 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):
@@ -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):
     """
@@ -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,9 +426,14 @@ Your outputs MUST adhere to the following format and should NOT include any irre
             agent = agent_to_delegate
             self.delegations += 1
 
-        output_raw = agent.execute_task(task=self, context=context)
-        output_json_dict = self.create_json_output(raw_result=output_raw) if self.expected_output_json is True else None
-        output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict) if self.expected_output_pydantic else 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)
+
+        if self.expected_output_pydantic:
+            output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict)
+
         task_output = TaskOutput(
             task_id=self.id,
             raw=output_raw,
@@ -451,10 +446,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         # self._set_end_execution_time(start_time)
 
         if self.callback:
-            if isinstance(self.callback, Callable):
-                self.callback(**self.callback_kwargs)
-            else:
-                self.callback(self.output)
+            self.callback({ **self.callback_kwargs, **self.output.__dict__ })
 
         # if self._execution_span:
         #     # self._telemetry.task_ended(self._execution_span, self, agent.team)
@@ -470,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:
         """
@@ -496,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

@@ -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")
@@ -261,7 +256,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 +282,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 +372,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 +424,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 +431,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-1.1.7.4.dist-info → versionhq-1.1.7.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.7.4
+Version: 1.1.7.7
 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,16 +46,20 @@ 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
 
-![MIT license](https://img.shields.io/badge/License-MIT-green) [![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.3-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)
+![MIT license](https://img.shields.io/badge/License-MIT-green)
+[![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.5.0-orange)
 
 
 An LLM orchestration frameworks for multi-agent systems with RAG to autopilot outbound workflows.
@@ -64,10 +71,11 @@ Messaging workflows are created at individual level, and will be deployed on thi
 
 **Visit:**
 
-- [Landing page](https://home.versi0n.io)
-- [Client app](https://versi0n.io/)
-- [Orchestration frameworks](https://github.com/versionHQ/multi-agent-system)
-- [Test client app](https://github.com/versionHQ/test-client-app)
+- [PyPI](https://pypi.org/project/versionhq/)
+- [Github (LLM orchestration)](https://github.com/versionHQ/multi-agent-system)
+- [Github (Test client app)](https://github.com/versionHQ/test-client-app)
+- [Use case](https://versi0n.io/) - client app (alpha)
+
 
 <hr />
 
@@ -87,6 +95,8 @@ LLM-powered `agent`s and `team`s use `tool`s and their own knowledge to complete
 
 - [Key Features](#key-features)
 - [Usage](#usage)
+  - [Case 1. Build an AI agent on LLM of your choice and execute a task:](#case-1-build-an-ai-agent-on-llm-of-your-choice-and-execute-a-task)
+  - [Case 2. Form a team to handle multiple tasks:](#case-2-form-a-team-to-handle-multiple-tasks)
 - [Technologies Used](#technologies-used)
 - [Project Structure](#project-structure)
 - [Setup](#setup)
@@ -132,7 +142,8 @@ Multiple `agents` can form a `team` to complete complex tasks together.
 
 2. You can use the `versionhq` module in your Python app.
 
-   - **i.e.,** Make LLM-based agent execute the task and return JSON dict.
+
+### Case 1. Build an AI agent on LLM of your choice and execute a task:
 
    ```
    from versionhq.agent.model import Agent
@@ -142,6 +153,7 @@ Multiple `agents` can form a `team` to complete complex tasks together.
       role="demo",
       goal="amazing project goal",
       skillsets=["skill_1", "skill_2", ],
+      tools=["amazing RAG tool",]
       llm="llm-of-your-choice"
    )
 
@@ -165,7 +177,41 @@ This will return a dictionary with keys defined in the `ResponseField`.
    { test1: "answer1", "test2": ["answer2-1", "answer2-2", "answer2-3",] }
    ```
 
-For more info: [PyPI package](https://pypi.org/project/versionhq/)
+### Case 2. Form a team to handle multiple tasks:
+
+   ```
+   from versionhq.agent.model import Agent
+   from versionhq.task.model import Task, ResponseField
+   from versionhq.team.model import Team, TeamMember
+
+   agent_a = Agent(role="agent a", goal="My amazing goals", llm="llm-of-your-choice")
+   agent_b = Agent(role="agent b", goal="My amazing goals", llm="llm-of-your-choice")
+
+   task_1 = Task(
+      description="Analyze the client's business model.",
+      output_field_list=[ResponseField(title="test1", type=str, required=True),],
+      allow_delegation=True
+   )
+
+    task_2 = Task(
+      description="Define the cohort.",
+      output_field_list=[ResponseField(title="test1", type=int, required=True),],
+      allow_delegation=False
+   )
+
+   team = Team(
+      members=[
+         TeamMember(agent=agent_a, is_manager=False, task=task_1),
+         TeamMember(agent=agent_b, is_manager=True, task=task_2),
+      ],
+   )
+   res = team.kickoff()
+   ```
+
+This will return a list with dictionaries with keys defined in the `ResponseField` of each task.
+
+Tasks can be delegated to a team manager, peers in the team, or completely new agent.
+
 
 <hr />
 
@@ -233,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.4.dist-info → versionhq-1.1.7.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-versionhq/__init__.py,sha256=HXgS9ZXHPzYzddtQdb7-MLMFjnrZQChOzfbGbl5ot_o,871
+versionhq/__init__.py,sha256=UNk3K1Icj6U6bX4hmcE-7PSzT3mYI9f_i_gXybscmWc,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
@@ -7,7 +7,7 @@ versionhq/_utils/process_config.py,sha256=ogrhovLbwe0ocQlcohRgBBRtww7C3pk9hikjvg
 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/model.py,sha256=fK7rb10IFrgDDCD78owNRdMsIQ_aj7nmIQdp1WbWJc8,18621
 versionhq/agent/parser.py,sha256=GhoNQo4WloVM3vGnAmt9lnEOTARX7nWMhJE55rF_5Rs,5500
 versionhq/agent/TEMPLATES/Backstory.py,sha256=cdngBx1GEv7nroR46FEhnysnBJ9mEVL763_9np6Skkc,395
 versionhq/agent/TEMPLATES/__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=8EbrUdS0vUhutx3_8M8A0Dw1BXpCqp5AFWbg4SGHj9M,5695
+versionhq/clients/workflow/model.py,sha256=qpRCDwULhSLWDFkSYrvXW5m07bKDrwttTmqsYA9ZVP4,5727
 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/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=LzB2E6s1ghmxRUG1gWjJs7DTcnBQFZUzCQ1l_90y2eo,18560
+versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
+versionhq/task/model.py,sha256=QCNRHulD4RdOVZAUWft4rAqlTIqcbZTqSA-lDUoSfpQ,19314
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/team/model.py,sha256=RyspmYVtXW3f4MKjWT1mnpM9XdE435d8HbEQms7LHMU,19821
+versionhq/team/model.py,sha256=M99sMAlKyS9jQsufH2xoGrv2dDIvaJWsmIQgW-0pT0M,18305
 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.4.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.7.4.dist-info/METADATA,sha256=x5wxp9x2KxtPRJQUudsm3UtbwElH5YlAslCYRWaI-TM,14413
-versionhq-1.1.7.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-versionhq-1.1.7.4.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.7.4.dist-info/RECORD,,
+versionhq-1.1.7.7.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.7.7.dist-info/METADATA,sha256=tHhEWrbEEt-NyUVKKQwMImjFByi5LJiCBVLzZc86L_E,15919
+versionhq-1.1.7.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+versionhq-1.1.7.7.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.7.7.dist-info/RECORD,,