versionhq 1.1.9.0__py3-none-any.whl → 1.1.9.2__py3-none-any.whl

versionhq/task/model.py

@@ -4,7 +4,7 @@ import uuid
 from concurrent.futures import Future
 from hashlib import md5
 from typing import Any, Dict, List, Set, Optional, Tuple, Callable, Type
-from typing_extensions import Annotated
+from typing_extensions import Annotated, Self
 
 from pydantic import UUID4, BaseModel, Field, PrivateAttr, field_validator, model_validator, create_model, InstanceOf
 from pydantic_core import PydanticCustomError
@@ -72,6 +72,7 @@ class TaskOutput(BaseModel):
     raw: str = Field(default="", description="Raw output of the task")
     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")
+    tool_output: Optional[Any] = Field(default=None, description="store tool result when the task takes tool output as its final output")
 
     def __str__(self) -> str:
         return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
@@ -125,6 +126,7 @@ class Task(BaseModel):
     _original_description: str = PrivateAttr(default=None)
     _logger: Logger = PrivateAttr()
     _task_output_handler = TaskOutputStorageHandler()
+    config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the agent")
 
     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)
@@ -134,33 +136,35 @@ class Task(BaseModel):
     expected_output_json: bool = Field(default=True)
     expected_output_pydantic: bool = Field(default=False)
     output_field_list: List[ResponseField] = Field(
-        default=[ResponseField(title="output", type=str, required=False)],
+        default_factory=list,
         description="provide output key and data type. this will be cascaded to the agent via task.prompt()"
     )
     output: Optional[TaskOutput] = Field(default=None, description="store the final task output in TaskOutput class")
 
     # task setup
     context: Optional[List["Task"]] = Field(default=None, description="other tasks whose outputs should be used as context")
-    tools_called: Optional[List[ToolSet]] = Field(default_factory=list, description="tools that the agent can use for this task")
+    prompt_context: Optional[str] = Field(default=None)
+
+    # tool usage
+    tools: Optional[List[ToolSet | Tool | Any]] = Field(default_factory=list, description="tools that the agent can use aside from their tools")
+    can_use_agent_tools: bool = Field(default=False, description="whether the agent can use their own tools when executing the task")
     take_tool_res_as_final: bool = Field(default=False, description="when set True, tools res will be stored in the `TaskOutput`")
-    allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
 
-    prompt_context: Optional[str] = Field(default=None)
+    # execution rules
+    allow_delegation: bool = Field(default=False, description="ask other agents for help and run the task instead")
     async_execution: bool = Field(default=False,description="whether the task should be executed asynchronously or not")
-    config: Optional[Dict[str, Any]] = Field(default=None, description="configuration for the agent")
     callback: Optional[Any] = Field(default=None, description="callback to be executed after the task is completed.")
     callback_kwargs: Optional[Dict[str, Any]] = Field(default_factory=dict, description="kwargs for the callback when the callback is callable")
 
     # recording
     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
 
 
     @model_validator(mode="before")
     @classmethod
-    def process_model_config(cls, values: Dict[str, Any]):
+    def process_model_config(cls, values: Dict[str, Any]) -> None:
         return process_config(values_to_update=values, model_class=cls)
 
 
@@ -172,7 +176,7 @@ class Task(BaseModel):
 
 
     @model_validator(mode="after")
-    def validate_required_fields(self):
+    def validate_required_fields(self) -> Self:
         required_fields = ["description",]
         for field in required_fields:
             if getattr(self, field) is None:
@@ -181,7 +185,7 @@ class Task(BaseModel):
 
 
     @model_validator(mode="after")
-    def set_attributes_based_on_config(self) -> "Task":
+    def set_attributes_based_on_config(self) -> Self:
         """
         Set attributes based on the agent configuration.
         """
@@ -192,12 +196,21 @@ class Task(BaseModel):
         return self
 
 
-    ## comment out as we set raw as the default TaskOutputFormat
-    # @model_validator(mode="after")
-    # def validate_output_format(self):
-    #     if self.expected_output_json == False  and self.expected_output_pydantic == False:
-    #         raise PydanticCustomError("Need to choose at least one output format.")
-    #     return self
+    @model_validator(mode="after")
+    def set_up_tools(self) -> Self:
+        if not self.tools:
+            pass
+        else:
+            tool_list = []
+            for item in self.tools:
+                if isinstance(item, Tool) or isinstance(item, ToolSet):
+                    tool_list.append(item)
+                elif (isinstance(item, dict) and "function" not in item) or isinstance(item, str):
+                    pass
+                else:
+                    tool_list.append(item) # address custom tool
+            self.tools = tool_list
+        return self
 
 
     @model_validator(mode="after")
@@ -261,7 +274,6 @@ class Task(BaseModel):
         return output_json_dict
 
 
-
     def create_pydantic_output(self, output_json_dict: Dict[str, Any], raw_result: Any = None) -> Optional[Any]:
         """
         Create pydantic output from the `raw` result.
@@ -302,11 +314,10 @@ class Task(BaseModel):
         """
         if inputs:
             self.description = self._original_description.format(**inputs)
-            # self.expected_output = self._original_expected_output.format(**inputs)
 
 
     # task execution
-    def execute_sync(self, agent, context: Optional[str] = None, tools: Optional[List[Any]] = None) -> TaskOutput:
+    def execute_sync(self, agent, context: Optional[str] = None) -> TaskOutput:
         """
         Execute the task synchronously.
         When the task has context, make sure we have executed all the tasks in the context first.
@@ -320,26 +331,26 @@ class Task(BaseModel):
         return self._execute_core(agent, context)
 
 
-    def execute_async(self, agent, context: Optional[str] = None, tools: Optional[List[Any]] = None) -> Future[TaskOutput]:
+    def execute_async(self, agent, context: Optional[str] = None) -> Future[TaskOutput]:
         """
         Execute the task asynchronously.
         """
 
         future: Future[TaskOutput] = Future()
-        threading.Thread(daemon=True, target=self._execute_task_async, args=(agent, context, tools, future)).start()
+        threading.Thread(daemon=True, target=self._execute_task_async, args=(agent, context, future)).start()
         return future
 
 
-    def _execute_task_async(self, agent, context: Optional[str], tools: Optional[List[Any]], future: Future[TaskOutput]) -> None:
+    def _execute_task_async(self, agent, context: Optional[str], future: Future[TaskOutput]) -> None:
         """
         Execute the task asynchronously with context handling.
         """
 
-        result = self._execute_core(agent, context, tools)
+        result = self._execute_core(agent, context)
         future.set_result(result)
 
 
-    def _execute_core(self, agent, context: Optional[str], tools: Optional[List[Any]] = []) -> TaskOutput:
+    def _execute_core(self, agent, context: Optional[str]) -> 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.
@@ -349,13 +360,14 @@ class Task(BaseModel):
         from versionhq.team.model import Team
 
         self.prompt_context = context
+        task_output: InstanceOf[TaskOutput] = None
 
         if self.allow_delegation:
             agent_to_delegate = None
 
             if hasattr(agent, "team") and isinstance(agent.team, Team):
                 if agent.team.managers:
-                    idling_manager_agents = [manager.agent for manager in agent.team.managers if manager.task is None]
+                    idling_manager_agents = [manager.agent for manager in agent.team.managers if manager.is_idling]
                     agent_to_delegate = idling_manager_agents[0] if idling_manager_agents else agent.team.managers[0]
                 else:
                     peers = [member.agent for member in agent.team.members if member.is_manager == False and member.agent.id is not agent.id]
@@ -367,20 +379,26 @@ class Task(BaseModel):
             agent = agent_to_delegate
             self.delegations += 1
 
-        output_raw, output_json_dict, output_pydantic = agent.execute_task(task=self, context=context, tools=tools), None, None
+        if self.take_tool_res_as_final is True:
+            output = agent.execute_task(task=self, context=context)
+            task_output = TaskOutput(task_id=self.id, tool_output=output)
 
-        if self.expected_output_json:
-            output_json_dict = self.create_json_output(raw_result=output_raw)
+        else:
+            output_raw, output_json_dict, output_pydantic = agent.execute_task(task=self, context=context), None, None
 
-        if self.expected_output_pydantic:
-            output_pydantic = self.create_pydantic_output(output_json_dict=output_json_dict)
+            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,
+                pydantic=output_pydantic,
+                json_dict=output_json_dict
+            )
 
-        task_output = TaskOutput(
-            task_id=self.id,
-            raw=output_raw,
-            pydantic=output_pydantic,
-            json_dict=output_json_dict
-        )
         self.output = task_output
         self.processed_by_agents.add(agent.role)
 
@@ -400,6 +418,7 @@ class Task(BaseModel):
         #         else pydantic_output.model_dump_json() if pydantic_output else result
         #     )
         #     self._save_file(content)
+
         return task_output
 
 
@@ -463,7 +482,7 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         Task ID: {str(self.id)}
         "Description": {self.description}
         "Prompt": {self.output_prompt}
-        "Tools": {", ".join([tool_called.tool.name for tool_called in self.tools_called])}
+        "Tools": {", ".join([tool.name for tool in self.tools])}
         """
 
 

versionhq/team/model.py

@@ -1,7 +1,6 @@
 import uuid
 import warnings
 import json
-from abc import ABC
 from enum import Enum
 from dotenv import load_dotenv
 from concurrent.futures import Future
@@ -108,13 +107,14 @@ class TeamOutput(BaseModel):
         return res
 
 
-class TeamMember(ABC, BaseModel):
+class TeamMember(BaseModel):
     agent: Agent | None = Field(default=None, description="store the agent to be a member")
     is_manager: bool = Field(default=False)
     task: Optional[Task] = Field(default=None)
 
-    def update(self, task: Task):
-        self.task = task
+    @property
+    def is_idling(self):
+        return bool(self.task is None)
 
 
 class Team(BaseModel):
@@ -253,8 +253,8 @@ class Team(BaseModel):
         """
 
         team_planner = TeamPlanner(tasks=self.tasks, planner_llm=self.planning_llm)
-        idling_managers: List[TeamMember] = [member for member in self.members if member.task is None and member.is_manager is True]
-        idling_members: List[TeamMember] =  [member for member in self.members if member.task is None and member.is_manager is False]
+        idling_managers: List[TeamMember] = [member for member in self.members if member.is_idling and member.is_manager is True]
+        idling_members: List[TeamMember] =  [member for member in self.members if member.is_idling and member.is_manager is False]
         unassigned_tasks: List[Task] = self.member_tasks_without_agent
         new_team_members: List[TeamMember] = []
 
@@ -380,16 +380,15 @@ class Team(BaseModel):
                 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)
                 futures.append((task, future, task_index))
             else:
                 context = create_raw_outputs(tasks=[task,], task_outputs=([last_sync_output,] if last_sync_output else [] ))
-                task_output = task.execute_sync(agent=responsible_agent, context=context, tools=responsible_agent.tools)
+                task_output = task.execute_sync(agent=responsible_agent, context=context)
                 if self.managers and responsible_agent in [manager.agent for manager in self.managers]:
                     lead_task_output = task_output
 

versionhq/tool/composio.py

@@ -1,14 +1,17 @@
 import os
 import uuid
+from abc import ABC
 from dotenv import load_dotenv
 from typing import Any, Callable, Type, get_args, get_origin, Optional, Tuple
 
-from pydantic import BaseModel, Field, model_validator, field_validator, UUID4
+from pydantic import BaseModel, Field, model_validator, field_validator, UUID4, PrivateAttr
 from pydantic_core import PydanticCustomError
 
 from composio import ComposioToolSet, Action, App, action
 
 from versionhq.tool import ComposioAppName, ComposioAuthScheme, composio_app_set, COMPOSIO_STATUS
+from versionhq._utils.logger import Logger
+from versionhq._utils.cache_handler import CacheHandler
 
 load_dotenv(override=True)
 
@@ -16,11 +19,14 @@ DEFAULT_REDIRECT_URL = os.environ.get("DEFAULT_REDIRECT_URL", None)
 DEFAULT_USER_ID = os.environ.get("DEFAULT_USER_ID", None)
 
 
-class Composio(BaseModel):
+class Composio(ABC, BaseModel):
     """
     Class to handle composio tools.
     """
 
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
+    _cache: CacheHandler
+
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     app_name: str = Field(default=ComposioAppName.HUBSPOT)
     user_id: str = Field(default=DEFAULT_USER_ID)
@@ -125,6 +131,12 @@ class Composio(BaseModel):
             if connected_account.status is not COMPOSIO_STATUS.FAILED:
                 setattr(self.toolset, "entity_id", self.user_id)
 
+            else:
+                self._logger.log(level="error", message="The account is not valid.", color="red")
+
+        else:
+            self._logger.log(level="error", message="Connection to composio failed.", color="red")
+
         return connected_account, connected_account.status if connected_account else connection_request.connectionStatus
 
 

versionhq/tool/model.py

@@ -1,20 +1,21 @@
 from abc import ABC, abstractmethod
 from inspect import signature
 from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin
+from typing_extensions import Self
 from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from versionhq._utils.cache_handler import CacheHandler
 
 
 class BaseTool(ABC, BaseModel):
+    """
+    Abstract class for Tool class.
+    """
 
     class _ArgsSchemaPlaceholder(BaseModel):
         pass
 
-    name: str = Field(default=None)
-    goal: str = Field(default=None)
     args_schema: Type[BaseModel] = Field(default_factory=_ArgsSchemaPlaceholder)
-    cache_function: Callable = lambda _args=None, _result=None: True
 
 
     @field_validator("args_schema", mode="before")
@@ -26,11 +27,7 @@ class BaseTool(ABC, BaseModel):
         return type(
             f"{cls.__name__}Schema",
             (BaseModel,),
-            {
-                "__annotations__": {
-                    k: v for k, v in cls._run.__annotations__.items() if k != "return"
-                },
-            },
+            { "__annotations__": { k: v for k, v in cls._run.__annotations__.items() if k != "return" }},
         )
 
 
@@ -39,8 +36,36 @@ class BaseTool(ABC, BaseModel):
         """any handling"""
 
 
-    def run(self, *args: Any, **kwargs: Any) -> Any:
-        return self._run(*args, **kwargs)
+
+class Tool(BaseTool):
+    name: str = Field(default=None)
+    goal: str = Field(default=None)
+    function: Callable = Field(default=None)
+    tool_handler: Optional[Dict[str, Any] | Any] = Field(default=None, description="store tool_handler to record the usage of this tool")
+    should_cache: bool = Field(default=True, description="whether the tool usage should be cached")
+    cache_function: Callable = lambda _args=None, _result=None: True
+    cache_handler: Optional[InstanceOf[CacheHandler]] = Field(default=None)
+
+
+    @model_validator(mode="after")
+    def set_up_tool_handler(self) -> Self:
+        from versionhq.tool.tool_handler import ToolHandler
+
+        if self.tool_handler and not isinstance(self.tool_handler, ToolHandler):
+            ToolHandler(**self.tool_handler)
+
+        else:
+            self.tool_handler = ToolHandler(cache_handler=self.cache_handler, should_cache=self.should_cache)
+
+        return self
+
+
+    @model_validator(mode="after")
+    def set_up_function(self) -> Self:
+        if self.function is None:
+            self.function = self._run
+            self._set_args_schema_from_func()
+        return self
 
 
     @staticmethod
@@ -85,88 +110,71 @@ class BaseTool(ABC, BaseModel):
         self.args_schema = type(
             class_name,
             (BaseModel,),
-            { "__annotations__": { k: v for k, v in self._run.__annotations__.items() if k != "return" } },
+            { "__annotations__": {
+                k: v for k, v in self._run.__annotations__.items() if k != "return"
+            } },
         )
         return self
 
 
-    @property
-    def description(self) -> str:
-        args_schema = {
-            name: {
-                "description": field.description,
-                "type": self._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}\nGoal: {self.goal}"
-
-
-
-class Tool(BaseTool):
-
-    function: Callable = Field(default=None)
-    tool_handler: Optional[Dict[str, Any]] = Field(
-        default=None,
-        description="store tool_handler to record the usage of this tool. to avoid circular import, set as Dict format",
-    )
-
-    @model_validator(mode="after")
-    def set_up_tool_handler(self):
-        from versionhq.tool.tool_handler import ToolHandler
-
-        if self.tool_handler:
-            ToolHandler(**self.tool_handler)
-        return self
-
-    @model_validator(mode="after")
-    def set_up_function(self):
-        if self.function is None:
-            self.function = self._run
-            self._set_args_schema_from_func()
-        return self
-
-
     def _run(self, *args: Any, **kwargs: Any) -> Any:
-        return self.function(*args, **kwargs)
+        return self.run(*args, **kwargs)
 
 
     def run(self, *args, **kwargs) -> Any:
         """
-        Use tool
+        Use tool and record its usage if should_cache is True.
         """
         from versionhq.tool.tool_handler import ToolHandler
 
         result = None
+        tool_set = ToolSet(tool=self, kwargs={})
 
-        if self.function is not None:
+        if self.function:
             result = self.function(*args, **kwargs)
 
         else:
             acceptable_args = self.args_schema.model_json_schema()["properties"].keys()
             acceptable_kwargs = { k: v for k, v in kwargs.items() if k in acceptable_args }
-            tool_called = ToolSet(tool=self, kwargs=acceptable_kwargs)
+            tool_set = ToolSet(tool=self, kwargs=acceptable_kwargs)
 
             if self.tool_handler:
-                if self.tool_handler.has_called_before(tool_called):
+                if self.tool_handler.has_called_before(tool_set):
                     self.tool_handler.error = "Agent execution error"
 
                 elif self.tool_handler.cache:
-                    result = self.tools_handler.cache.read(tool=tool_called.tool.name, input=tool_called.kwargs)
+                    result = self.tools_handler.cache.read(tool=tool_set.tool.name, input=tool_set.kwargs)
                     if result is None:
-                        parsed_kwargs = self._parse_args(input=acceptable_kwargs)
-                        result = self.function(**parsed_kwargs)
+                        parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
+                        result = self.function(**parsed_kwargs) if self.function else None
 
             else:
-                tool_handler = ToolHandler(last_used_tool=tool_called, cache_handler=CacheHandler())
+                tool_handler = ToolHandler(last_used_tool=tool_set, cache_handler=self.cache_handler, should_cache=self.should_cache)
                 self.tool_handler = tool_handler
-                parsed_kwargs = self._parse_args(input=acceptable_kwargs)
-                result = self.function(**parsed_kwargs)
+                parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
+                result = self.function(**parsed_kwargs) if self.function else None
+
+
+        if self.should_cache is True:
+            self.tool_handler.record_last_tool_used(tool_set, result, self.should_cache)
 
         return result
 
 
+    @property
+    def description(self) -> str:
+        args_schema = {
+            name: {
+                "description": field.description,
+                "type": self._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}\nGoal: {self.goal}"
+
+
+
     # @classmethod
     # def from_composio(
     #     cls, func: Callable = None, tool_name: str = "Composio tool"
@@ -204,12 +212,12 @@ class ToolSet(BaseModel):
     """
     Store the tool called and any kwargs used.
     """
-    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    tool: InstanceOf[Tool] | Any = Field(..., description="store the tool instance to be called.")
     kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 
 class InstructorToolSet(BaseModel):
-    tool: InstanceOf[Tool] = Field(..., description="store the tool instance to be called.")
+    tool: InstanceOf[Tool] | Any = Field(..., description="store the tool instance to be called.")
     kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
 
 

versionhq/tool/tool_handler.py

@@ -1,6 +1,7 @@
-from typing import Any, Optional
+from typing import Optional, Any
 from pydantic import InstanceOf
-from versionhq.tool.model import ToolSet, InstructorToolSet, CacheTool
+
+from versionhq.tool.model import ToolSet, InstructorToolSet
 from versionhq._utils.cache_handler import CacheHandler
 
 
@@ -12,32 +13,33 @@ class ToolHandler:
     last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet]
     cache: Optional[CacheHandler]
     error: Optional[str]
+    should_cache: bool
 
     def __init__(
-            self,
-            last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet] = None,
-            cache_handler: Optional[CacheHandler] = None
+        self,
+        last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet] = None,
+        cache_handler: Optional[CacheHandler] = None,
+        should_cache: bool = True
     ):
         self.cache = cache_handler
         self.last_used_tool = last_used_tool
+        self.should_cache = should_cache
 
 
     def record_last_tool_used(
-        self,
-        last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet],
-        output: str,
-        should_cache: bool = True,
+        self, last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet], output: str, should_cache: bool = True
     ) -> Any:
+        from versionhq.tool.model import CacheTool
 
         self.last_used_tool = last_used_tool
 
-        if self.cache and should_cache and last_used_tool.tool_name != CacheTool().name:
-            self.cache.add(last_used_tool.tool_name, input.last_used_tool.arguments, output=output)
+        if self.cache and should_cache and last_used_tool.tool.name != CacheTool().name:
+            self.cache.add(tool=last_used_tool.tool.name, input=last_used_tool.kwargs, output=output)
 
 
-    def has_called_before(self, tool_called: ToolSet = None) -> bool:
-        if tool_called is None or not self.last_used_tool:
+    def has_called_before(self, tool_set: ToolSet = None) -> bool:
+        if tool_set is None or not self.last_used_tool:
             return False
 
-        if tool_called := self.last_used_tool:
-            return bool((tool_called.tool.name == self.last_used_tool.tool.name) and (tool_called.arguments == self.last_used_tool.arguments))
+        if tool_set := self.last_used_tool:
+            return bool((tool_set.tool.name == self.last_used_tool.tool.name) and (tool_set.kwargs == self.last_used_tool.kwargs))

{versionhq-1.1.9.0.dist-info → versionhq-1.1.9.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.9.0
+Version: 1.1.9.2
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License