versionhq 1.1.6.4__py3-none-any.whl → 1.1.7.1__py3-none-any.whl

versionhq/team/model.py

@@ -56,39 +56,29 @@ class TaskHandlingProcess(str, Enum):
     """
     Class representing the different processes that can be used to tackle multiple tasks.
     """
-
     sequential = "sequential"
     hierarchical = "hierarchical"
     consensual = "consensual"
 
 
 class TeamOutput(BaseModel):
-    """Class that represents the result of a team."""
+    """
+    Store outputs of the tasks handled by the team.
+    `json_dict` and `raw` store overall output of tasks that handled by the team,
+    while `task_output_list` stores each TaskOutput instance to the tasks handled by the team members.
+    Note that `raw` and `json_dict` will be prioritized as TeamOutput to refer over `task_output_list`.
+    """
 
-    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")
-    pydantic: Optional[BaseModel] = Field(default=None, description="pydantic output")
-    json_dict: Optional[Dict[str, Any]] = Field(
-        default=None, description="JSON dict output"
-    )
-    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"
-    )
+    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")
+    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")
 
     def __str__(self):
-        return (
-            str(self.pydantic)
-            if self.pydantic
-            else str(self.json_dict) if self.json_dict else self.raw
-        )
+        return (str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw)
+
 
     def __getitem__(self, key):
         if self.pydantic and hasattr(self.pydantic, key):
@@ -98,6 +88,7 @@ class TeamOutput(BaseModel):
         else:
             raise KeyError(f"Key '{key}' not found in the team output.")
 
+
     @property
     def json(self) -> Optional[str]:
         if self.tasks_output[-1].output_format != TaskOutputFormat.JSON:
@@ -106,32 +97,30 @@ class TeamOutput(BaseModel):
             )
         return json.dumps(self.json_dict)
 
+
     def to_dict(self) -> Dict[str, Any]:
         """
-        Convert json_output and pydantic_output to a dictionary.
+        Convert pydantic / raw output into dict and return the dict.
+        When we only have `raw` output, return `{ output: raw }` to avoid an error
         """
+
         output_dict = {}
         if self.json_dict:
             output_dict.update(self.json_dict)
         elif self.pydantic:
             output_dict.update(self.pydantic.model_dump())
         else:
-            output_dict.update({"raw", self.raw})
+            output_dict.upate({ "output": self.raw })
         return output_dict
 
-    def return_all_task_outputs(self) -> List[Dict[str, Any]]:
-        res = []
-        for output in self.task_output_list:
-            if output is not None:
-                res.append(output.to_dict())
 
+    def return_all_task_outputs(self) -> List[Dict[str, Any]]:
+        res = [output.json_dict for output in self.task_output_list]
         return res
 
 
 class TeamMember(ABC, BaseModel):
-    agent: Agent | None = Field(
-        default=None, description="store the agent to be a member"
-    )
+    agent: Agent | None = Field(default=None, description="store the agent to be a member")
     is_manager: bool = Field(default=False)
     task: Task | None = Field(default=None)
 
@@ -149,78 +138,50 @@ class Team(BaseModel):
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None)
-    members: List[TeamMember] = Field(
-        default_factory=list,
-        description="store agents' uuids and bool if it is manager",
-    )
+    members: List[TeamMember] = Field(default_factory=list, description="store agents' uuids and bool if it is manager")
 
     # work as a team
-    team_tasks: Optional[List[Task]] = Field(
-        default_factory=list, description="optional tasks for the team"
-    )
-    planning_llm: Optional[Any] = Field(
-        default=None,
-        description="llm to handle the planning of the team tasks (if any)",
-    )
-    function_calling_llm: Optional[Any] = Field(
-        default=None,
-        description="llm to execute func after all agent execution (if any)",
-    )
-    prompt_file: str = Field(
-        default="", description="path to the prompt json file to be used by the team."
-    )
+    team_tasks: Optional[List[Task]] = Field(default_factory=list, description="optional tasks for the team")
+    planning_llm: Optional[Any] = Field(default=None, description="llm to handle the planning of the team tasks (if any)")
+    function_calling_llm: Optional[Any] = Field(default=None, description="llm to execute func after all agent execution (if any)")
+    prompt_file: str = Field(default="", description="path to the prompt json file to be used by the team.")
     process: TaskHandlingProcess = Field(default=TaskHandlingProcess.sequential)
 
     # callbacks
-    before_kickoff_callbacks: List[
-        Callable[[Optional[Dict[str, Any]]], Optional[Dict[str, Any]]]
-    ] = Field(
+    before_kickoff_callbacks: List[Callable[[Optional[Dict[str, Any]]], Optional[Dict[str, Any]]]] = Field(
         default_factory=list,
-        description="list of callback functions to be executed before the team kickoff. i.e., adjust inputs",
+        description="list of callback functions to be executed before the team kickoff. i.e., adjust inputs"
     )
     after_kickoff_callbacks: List[Callable[[TeamOutput], TeamOutput]] = Field(
         default_factory=list,
-        description="list of callback functions to be executed after the team kickoff. i.e., store the result in repo",
-    )
-    task_callback: Optional[Any] = Field(
-        default=None,
-        description="callback to be executed after each task for all agents execution",
-    )
-    step_callback: Optional[Any] = Field(
-        default=None,
-        description="callback to be executed after each step for all agents execution",
+        description="list of callback functions to be executed after the team kickoff. i.e., store the result in repo"
     )
+    task_callback: Optional[Any] = Field(default=None, description="callback to be executed after each task for all agents execution")
+    step_callback: Optional[Any] = Field(default=None, description="callback to be executed after each step for all agents execution")
 
     verbose: bool = Field(default=True)
     cache: bool = Field(default=True)
-    memory: bool = Field(
-        default=False,
-        description="whether the team should use memory to store memories of its execution",
-    )
-    execution_logs: List[Dict[str, Any]] = Field(
-        default=[], description="list of execution logs for tasks"
-    )
-    usage_metrics: Optional[UsageMetrics] = Field(
-        default=None, description="usage metrics for all the llm executions"
-    )
+    memory: bool = Field(default=False, description="whether the team should use memory to store memories of its execution")
+    execution_logs: List[Dict[str, Any]] = Field(default=[], description="list of execution logs for tasks")
+    usage_metrics: Optional[UsageMetrics] = Field(default=None, description="usage metrics for all the llm executions")
+
 
     def __name__(self) -> str:
-        return self.name if self.name is not None else self.id
+        return self.name if self.name is not None else self.id.__str__
+
 
     @property
     def key(self) -> str:
-        source = [member.agent.key for member in self.members] + [
-            task.key for task in self.tasks
-        ]
+        source = [str(member.agent.id.__str__) for member in self.members] + [str(task.id.__str__) for task in self.tasks]
         return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
 
+
     @property
     def manager_agent(self) -> Agent:
-        manager_agent = [
-            member.agent for member in self.members if member.is_manager == True
-        ]
+        manager_agent = [member.agent for member in self.members if member.is_manager == True]
         return manager_agent[0] if len(manager_agent) > 0 else None
 
+
     @property
     def manager_task(self) -> Task:
         """
@@ -230,6 +191,7 @@ class Team(BaseModel):
         task = [member.task for member in self.members if member.is_manager == True]
         return task[0] if len(task) > 0 else None
 
+
     @property
     def tasks(self):
         """
@@ -253,9 +215,7 @@ class Team(BaseModel):
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
         """Prevent manual setting of the 'id' field by users."""
         if v:
-            raise PydanticCustomError(
-                "may_not_set_field", "The 'id' field cannot be set by the user.", {}
-            )
+            raise PydanticCustomError("may_not_set_field", "The 'id' field cannot be set by the user.", {})
 
     # @field_validator("config", mode="before")
     # @classmethod
@@ -286,12 +246,12 @@ class Team(BaseModel):
                 )
         return self
 
+
     @model_validator(mode="after")
     def validate_tasks(self):
         """
         Every team member should have a task to handle.
         """
-
         if self.process == TaskHandlingProcess.sequential:
             for member in self.members:
                 if member.task is None:
@@ -381,13 +341,16 @@ class Team(BaseModel):
             return skipped_task_output
         return None
 
-    def _create_team_output(self, task_outputs: List[TaskOutput]) -> TeamOutput:
-        if len(task_outputs) != 1:
-            raise ValueError(
-                "Something went wrong. Kickoff should return only one task output."
-            )
 
-        final_task_output = task_outputs[0]
+    def _create_team_output(self, task_outputs: List[TaskOutput], lead_task_output: TaskOutput = None) -> TeamOutput:
+        """
+        Take the output of the first task or the lead task output as the team output `raw` value.
+        Note that `tasks` are already sorted by the importance.
+        """
+        if len(task_outputs) < 1:
+            raise ValueError("Something went wrong. Kickoff should return only one task output.")
+
+        final_task_output = lead_task_output if lead_task_output is not None else task_outputs[0]
         # final_string_output = final_task_output.raw
         # self._finish_execution(final_string_output)
         token_usage = self._calculate_usage_metrics()
@@ -395,12 +358,13 @@ class Team(BaseModel):
         return TeamOutput(
             team_id=self.id,
             raw=final_task_output.raw,
-            pydantic=final_task_output.pydantic,
             json_dict=final_task_output.json_dict,
-            task_output_list=[task.output for task in self.tasks if task.output],
+            pydantic=final_task_output.pydantic,
+            task_output_list=task_outputs,
             token_usage=token_usage,
         )
 
+
     def _calculate_usage_metrics(self) -> UsageMetrics:
         """
         Calculate and return the usage metrics that consumed by the team.
@@ -420,12 +384,8 @@ class Team(BaseModel):
         self.usage_metrics = total_usage_metrics
         return total_usage_metrics
 
-    def _execute_tasks(
-        self,
-        tasks: List[Task],
-        start_index: Optional[int] = 0,
-        was_replayed: bool = False,
-    ) -> TeamOutput:
+
+    def _execute_tasks(self, tasks: List[Task], start_index: Optional[int] = 0, was_replayed: bool = False) -> TeamOutput:
         """
         Executes tasks sequentially and returns the final output in TeamOutput class.
         When we have a manager agent, we will start from executing manager agent's tasks.
@@ -434,6 +394,7 @@ class Team(BaseModel):
         """
 
         task_outputs: List[TaskOutput] = []
+        lead_task_output: TaskOutput = None
         futures: List[Tuple[Task, Future[TaskOutput], int]] = []
         last_sync_output: Optional[TaskOutput] = None
 
@@ -449,77 +410,44 @@ class Team(BaseModel):
 
             responsible_agent = self._get_responsible_agent(task)
             if responsible_agent is None:
-                responsible_agent = self.members[
-                    0
-                ].agent  #! REFINEME - select a suitable agent for the task
+                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 = self._handle_conditional_task(task, task_outputs, futures, task_index, was_replayed)
                 if skipped_task_output:
                     continue
 
             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,
-                )
+                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
+                                            )
                 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,
-                )
-                task_outputs = [
-                    task_output,
-                ]
+                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)
 
         # if futures:
         # task_outputs = self._process_async_tasks(futures, was_replayed)
+        return self._create_team_output(task_outputs, lead_task_output)
 
-        return self._create_team_output(task_outputs)
 
-    def kickoff(
-        self,
-        kwargs_before: Optional[Dict[str, str]] = None,
-        kwargs_after: Optional[Dict[str, Any]] = None,
-    ) -> TeamOutput:
+    def kickoff(self, kwargs_before: Optional[Dict[str, str]] = None, kwargs_after: Optional[Dict[str, Any]] = None) -> TeamOutput:
         """
         Kickoff the team:
         0. Plan the team action if we have `team_tasks` using `planning_llm`.
@@ -553,7 +481,6 @@ class Team(BaseModel):
 
         for member in self.members:
             agent = member.agent
-            # agent.i18n = i18n
             agent.team = self
 
             # add the team's common callbacks to each agent.
@@ -574,9 +501,7 @@ class Team(BaseModel):
         for after_callback in self.after_kickoff_callbacks:
             result = after_callback(result, **kwargs_after)
 
-        metrics += [
-            member.agent._token_process.get_summary() for member in self.members
-        ]
+        metrics += [member.agent._token_process.get_summary() for member in self.members]
 
         self.usage_metrics = UsageMetrics()
         for metric in metrics:

versionhq/team/team_planner.py

@@ -36,13 +36,13 @@ class TeamPlanner:
         task_to_handle = Task(
             description=f"""
                 Based on the following task summaries, create the most descriptive plan that the team can execute most efficiently. Take all the task summaries - task's description and tools available - into consideration. Your answer only contains a dictionary.
-                
+
                 Task summaries: {" ".join(task_summary_list)}
              """,
             expected_output_json=False,
             expected_output_pydantic=True,
             output_field_list=[
-                ResponseField(title=f"{task.id}", type="str", required=True)
+                ResponseField(title=f"{task.id}", type=str, required=True)
                 for task in self.tasks
             ],
         )

versionhq/tool/model.py

@@ -35,14 +35,12 @@ class Tool(ABC, BaseModel):
     @property
     def description(self):
         args_schema = {
-            name: {
-                "description": field.description,
-                "type": Tool._get_arg_annotations(field.annotation),
-            }
+            name: { "description": field.description,  "type": Tool._get_arg_annotations(field.annotation) }
             for name, field in self.args_schema.model_fields.items()
         }
         return f"Tool Name: {self.name}\nTool Arguments: {args_schema}\nTool Description: {self.description}"
 
+
     @field_validator("args_schema", mode="before")
     @classmethod
     def _default_args_schema(cls, v: Type[BaseModel]) -> Type[BaseModel]:
@@ -188,21 +186,13 @@ class ToolCalled(BaseModel):
     Store the tool called and any kwargs used.
     """
 
-    tool: InstanceOf[Tool] = Field(
-        ..., description="store the tool instance to be called."
-    )
-    arguments: Optional[Dict[str, Any]] = Field(
-        ..., description="kwargs passed to the tool"
-    )
+    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    arguments: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class InstructorToolCalled(BaseModel):
-    tool: InstanceOf[Tool] = Field(
-        ..., description="store the tool instance to be called."
-    )
-    arguments: Optional[Dict[str, Any]] = Field(
-        ..., description="kwargs passed to the tool"
-    )
+    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    arguments: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class CacheTool(BaseModel):

{versionhq-1.1.6.4.dist-info → versionhq-1.1.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.6.4
+Version: 1.1.7.1
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -52,8 +52,7 @@ Requires-Dist: wheel>=0.45.1
 
 # Overview
 
-![MIT license](https://img.shields.io/badge/License-MIT-green) ![PyPi](https://img.shields.io/badge/pypi-v1.1.6.3-blue)
-![python ver](https://img.shields.io/badge/Python-3.13.1-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.0-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)
 
 
 An LLM orchestration frameworks for multi-agent systems with RAG to autopilot outbound workflows.
@@ -70,6 +69,7 @@ Messaging workflows are created at individual level, and will be deployed on thi
 - [Orchestration frameworks](https://github.com/versionHQ/multi-agent-system)
 - [Test client app](https://github.com/versionHQ/test-client-app)
 
+<hr />
 
 ## Mindmap
 
@@ -86,10 +86,10 @@ LLM-powered `agent`s and `team`s use `tool`s and their own knowledge to complete
 <!-- DON'T EDIT THIS SECTION, INSTEAD RE-RUN doctoc TO UPDATE -->
 
 - [Key Features](#key-features)
+- [Usage](#usage)
 - [Technologies Used](#technologies-used)
 - [Project Structure](#project-structure)
 - [Setup](#setup)
-- [Usage](#usage)
 - [Contributing](#contributing)
   - [Customizing AI Agents](#customizing-ai-agents)
   - [Modifying RAG Functionality](#modifying-rag-functionality)
@@ -111,7 +111,7 @@ The `agent` is model agnostic. The default model is set Chat GTP 4o. We ask the
 Multiple `agents` can form a `team` to complete complex tasks together.
 
 **1. Analysis**
-- Professional `agents` handle the analysis `tasks` on each client, customer, and product. 
+- Professional `agents` handle the analysis `tasks` on each client, customer, and product.
 
 **2. Messaging Workflow Creation**
 - Several `teams` receive the analysis and design initial messaging workflow with several layers.
@@ -121,6 +121,52 @@ Multiple `agents` can form a `team` to complete complex tasks together.
 **3. Autopiloting**
 - Responsible `agents` or `teams` autopilot executing and refining the messaging workflow.
 
+<hr />
+
+## Usage
+
+1. Install `versionhq` package:
+   ```
+   uv pip install versionhq
+   ```
+
+2. You can use the `versionhq` module in your Python app.
+
+   - **i.e.,** Make LLM-based agent execute the task and return JSON dict.
+
+   ```
+   from versionhq.agent.model import Agent
+   from versionhq.task.model import Task, ResponseField
+
+   agent = Agent(
+      role="demo",
+      goal="amazing project goal",
+      skillsets=["skill_1", "skill_2", ],
+      llm="llm-of-choice"
+   )
+
+   task = Task(
+      description="Amazing task",
+      expected_output_json=True,
+      expected_output_pydantic=False,
+      output_field_list=[
+         ResponseField(title="test1", type=str, required=True),
+         ResponseField(title="test2", type=list, required=True),
+      ],
+      context=["amazing context",],
+      tools=["amazing tool"],
+      callback=None,
+   )
+
+   res = task.execute_sync(agent=agent)
+
+   return res.to_dict()
+
+   ```
+
+For more details:
+
+[PyPi package](https://pypi.org/project/versionhq/)
 
 <hr />
 
@@ -145,6 +191,7 @@ Multiple `agents` can form a `team` to complete complex tasks together.
    - [pre-commit](https://pre-commit.com/): Manage and maintain pre-commit hooks
    - [setuptools](https://pypi.org/project/setuptools/): Build python modules
 
+<hr />
 
 ## Project Structure
 
@@ -166,10 +213,10 @@ src/
 │      └── ...
 │
 └──tests/
-      └── cli/   
+      └── cli/
       └── team/
       └── ...
-      │        
+      │
       └── uploads/    # Uploaded files for the project
 
 ```
@@ -210,25 +257,6 @@ src/
 
 <hr />
 
-## Usage
-
-1. Install `versionhq` package:
-```
-uv pip install versionhq
-```
-
-2. You can use the `versionhq` module in your Python app.
-```
-from versionhq.agent.model import Agent
-agent = Agent(llm="your-llm", ...)
-```
-
-For more details:
-
-[PyPi package](https://pypi.org/project/versionhq/)
-
-<hr />
-
 ## Contributing
 
 1. Fork the repository
@@ -239,13 +267,17 @@ For more details:
 
 4. Test the features using the `tests` directory.
 
-   - Add a file to the `tests` directory.
+   - Add a test function to respective components in the `tests` directory.
+   - Add your `LITELLM_API_KEY` and `OPENAI_API_KEY` to the Github `repository secrets` @ settings > secrets & variables > Actions.
    - Run a test.
       ```
-      uv run <your file name>
+      uv run pytest tests -vv
       ```
 
-   * All the `.py` files' names in the `tests` have to be ended with `_test.py`.
+   **pytest**
+
+   * When adding a new file to `tests`, name the file ended with `_test.py`.
+   * When adding a new feature to the file, name the feature started with `test_`.
 
 5. Pull the latest version of source code from the main branch (`git pull origin main`) *Address conflicts if any.
 6. Commit your changes (`git add .` / `git commit -m 'Add your-amazing-feature'`)
@@ -321,9 +353,10 @@ Common issues and solutions:
 - API key errors: Ensure all API keys in the `.env` file are correct and up to date. Make sure to add `load_dotenv()` on the top of the python file to apply the latest environment values.
 - Database connection issues: Check if the Chroma DB is properly initialized and accessible.
 - Memory errors: If processing large contracts, you may need to increase the available memory for the Python process.
-- Issues related to dependencies:`rm -rf .venv uv.lock`, `uv cache clean`  and run `uv run pip install -r requirements.txt -v`.
+- Issues related to dependencies: `rm -rf uv.lock`, `uv cache clean`, `uv venv`, and run `uv pip install -r requirements.txt -v`.
 - Issues related to the AI agents or RAG system: Check the `output.log` file for detailed error messages and stack traces.
 - Issues related to `Python quit unexpectedly`: Check [this stackoverflow article](https://stackoverflow.com/questions/59888499/macos-catalina-python-quit-unexpectedly-error).
+- `reportMissingImports` error from pyright after installing the package: This might occur when installing new libraries while VSCode is running. Open the command pallete (ctrl + shift + p) and run the Python: Restart language server task.
 
 <hr />
 
@@ -354,17 +387,3 @@ Common issues and solutions:
 > **Simple tasks**: You have a straightforward, one-off task that doesn't require significant complexity or iteration.
 
 > **Human input**: You need to provide initial input or guidance to the agent, or you expect to review and refine the output.
-
-
-
-<--- Remaining tasks --->
-
-- llm handling - agent
-- more llms integration
-- simpler prompting
-- broader knowledge
-
-- utils - log
-- utils - time
-
-- end to end client app test