versionhq 1.1.9.14__py3-none-any.whl → 1.1.10.3__py3-none-any.whl

versionhq/tool/model.py

@@ -1,10 +1,13 @@
 from abc import ABC, abstractmethod
 from inspect import signature
-from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin
+from typing import Any, Dict, Callable, Type, Optional, get_args, get_origin, get_type_hints
 from typing_extensions import Self
-from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator
+from pydantic import InstanceOf, BaseModel, ConfigDict, Field, field_validator, model_validator, PrivateAttr, create_model
+from pydantic_core import PydanticCustomError
 
-from versionhq._utils.cache_handler import CacheHandler
+from versionhq.llm.llm_vars import SchemaType
+from versionhq.tool.cache_handler import CacheHandler
+from versionhq._utils.logger import Logger
 
 
 class BaseTool(ABC, BaseModel):
@@ -12,16 +15,27 @@ class BaseTool(ABC, BaseModel):
     Abstract class for Tool class.
     """
 
-    class _ArgsSchemaPlaceholder(BaseModel):
+    class ArgsSchemaPlaceholder(BaseModel):
         pass
 
-    args_schema: Type[BaseModel] = Field(default_factory=_ArgsSchemaPlaceholder)
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
+
+    object_type: str = Field(default="function")
+    name: str = Field(default=None)
+    description: str = Field(default=None)
+    properties: Dict[str, Any] = Field(default_factory=dict, description="for llm func calling")
+    args_schema: Type[BaseModel] = Field(default_factory=ArgsSchemaPlaceholder)
+
+    tool_handler: Optional[Dict[str, Any] | Any] = Field(default=None, description="store tool_handler to record the tool usage")
+    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)
 
 
     @field_validator("args_schema", mode="before")
     @classmethod
     def _default_args_schema(cls, v: Type[BaseModel]) -> Type[BaseModel]:
-        if not isinstance(v, cls._ArgsSchemaPlaceholder):
+        if not isinstance(v, cls.ArgsSchemaPlaceholder):
             return v
 
         return type(
@@ -31,21 +45,29 @@ class BaseTool(ABC, BaseModel):
         )
 
 
-    @abstractmethod
-    def _run(self, *args: Any, **kwargs: Any,) -> Any:
-        """any handling"""
-
-
-
-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)
-
+    @field_validator("properties", mode="before")
+    @classmethod
+    def _default_properties(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        p, r = dict(), list()
+        for k, v in cls._run.__annotations__.items():
+            if k != "return":
+                p.update({ k: { "type": SchemaType(type(v)).convert(), "name": k, }} )
+                r.append(k)
+
+        return {
+            "type": cls.object_type,
+            "function": {
+                "name": cls.name.replace(" ", "_"),
+                "description": cls.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": p,
+                    "required": r,
+                    "additionalProperties": False
+                },
+                "strict": True
+            }
+        }
 
     @model_validator(mode="after")
     def set_up_tool_handler(self) -> Self:
@@ -59,13 +81,9 @@ class Tool(BaseTool):
 
         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
+    @abstractmethod
+    def _run(self, *args: Any, **kwargs: Any,) -> Any:
+        """any handling"""
 
 
     @staticmethod
@@ -95,108 +113,236 @@ class Tool(BaseTool):
                 import json
                 raw_args = json.loads(raw_args)
             except json.JSONDecodeError as e:
-                raise ValueError(f"Failed to parse arguments as JSON: {e}")
+                raise ValueError(f"Failed to parse arguments as JSON: {str(e)}")
 
         try:
             validated_args = self.args_schema.model_validate(raw_args)
             return validated_args.model_dump()
 
         except Exception as e:
-            raise ValueError(f"Arguments validation failed: {e}")
+            raise ValueError(f"Arguments validation failed: {str(e)}")
 
 
-    def _set_args_schema_from_func(self):
-        class_name = f"{self.__class__.__name__}Schema"
-        self.args_schema = type(
-            class_name,
-            (BaseModel,),
-            { "__annotations__": {
-                k: v for k, v in self._run.__annotations__.items() if k != "return"
-            } },
-        )
+    def _create_schema(self) -> type[BaseModel]:
+        """
+        Create a Pydantic schema from a function's signature
+        """
+        import inspect
+
+        sig = inspect.signature(self.func)
+        type_hints = get_type_hints(self.func)
+        fields = {}
+        for param_name, param in sig.parameters.items():
+            if param_name in ("self", "cls"):
+                continue
+
+            annotation = type_hints.get(param_name, Any)
+            default = ... if param.default == param.empty else param.default
+            fields[param_name] = (annotation, Field(default=default))
+
+        schema_name = f"{self.func.__name__.title()}Schema"
+        return create_model(schema_name, **fields)
+
+
+
+class Tool(BaseTool):
+    func: Callable = Field(default=None)
+
+
+    @model_validator(mode="after")
+    def validate_func(self) -> Self:
+        if not self.func and not self._run:
+            self._logger.log(level="error", message=f"Tool must have a function", color="red")
+            raise PydanticCustomError("function_missing", f"Function is missing in the tool.", {})
+
+        elif self.func and not isinstance(self.func, Callable):
+            self._logger.log(level="error", message=f"The tool is missing a valid function", color="red")
+            raise PydanticCustomError("invalid_function", f"The value in the function field must be callable.", {})
+
+        else:
+            try:
+                self.args_schema = self._create_schema_from_function()
+                self._validate_function_signature()
+
+            except Exception as e:
+                self._logger.log(level="error", message=f"The tool is missing a valid function: {str(e)}", color="red")
+                raise PydanticCustomError("invalid_function", f"Invalid function: {str(e)}", {})
+
+        return self
+
+
+    @model_validator(mode="after")
+    def set_up_name(self) -> Self:
+        if not self.name:
+            self.name = self.func.__name__ if self.func else ""
+
+        return self
+
+
+    @model_validator(mode="after")
+    def set_up_description(self) -> Self:
+        if not self.description:
+            if not self.args_schema:
+                self.args_schema = self._default_args_schema(self)
+
+            args_schema = {
+                name: {
+                    "description": field.description,
+                    "type": self._get_arg_annotations(field.annotation),
+                }
+                for name, field in self.args_schema.model_fields.items()
+            }
+            self.description = f"Tool: {self.name}\nArgs: {args_schema}"
+
+        return self
+
+
+    @model_validator(mode="after")
+    def set_up_args_schema(self) -> Self:
+        """
+        Set up args schema based on the given function.
+        """
+        if self.func:
+            self.args_schema = self._create_schema_from_function()
+        return self
+
+
+    @model_validator(mode="after")
+    def set_up_func_calling_properties(self) -> Self:
+        """
+        Format function_calling params from args_schema.
+        """
+
+        p, r = dict(), list()
+        if self.args_schema:
+            for name, field in self.args_schema.model_fields.items():
+                if name != "kwargs" and name != "args":
+                    p.update(
+                        {
+                            name: {
+                                "description": field.description if field.description else "",
+                                "type": SchemaType(self._get_arg_annotations(field.annotation)).convert(),
+                            }
+                        }
+                    )
+                    r.append(name)
+
+            properties = {
+                "type": self.object_type,
+                "function": {
+                    "name": self.name.replace(" ", "_"),
+                    "description": self.description if self.description else "a tool function to execute",
+                    "parameters": {
+                        "type": "object",
+                        "properties": p,
+                        "required": r,
+                        "additionalProperties": False
+                    },
+                    "strict": True,
+                },
+            }
+            self.properties = properties
         return self
 
 
+    def _create_schema_from_function(self) -> type[BaseModel]:
+        """
+        Create a Pydantic schema from a function's signature
+        """
+        import inspect
+
+        sig = inspect.signature(self.func)
+        type_hints = get_type_hints(self.func)
+        fields = {}
+        for param_name, param in sig.parameters.items():
+            if param_name in ("self", "cls"):
+                continue
+
+            annotation = type_hints.get(param_name, Any)
+            default = ... if param.default == param.empty else param.default
+            fields[param_name] = (annotation, Field(default=default))
+
+        schema_name = f"{self.func.__name__.title()}Schema"
+        return create_model(schema_name, **fields)
+
+
+    def _validate_function_signature(self) -> None:
+        """
+        Validate that the function signature matches the args schema.
+        """
+
+        import inspect
+
+        sig = inspect.signature(self.func)
+        schema_fields = self.args_schema.model_fields
+
+        for param_name, param in sig.parameters.items():
+            if param_name in ("self", "cls"):
+                continue
+
+            if param.kind in (inspect.Parameter.VAR_KEYWORD, inspect.Parameter.VAR_POSITIONAL):
+                continue
+
+            if param.default == inspect.Parameter.empty:
+                if param_name not in schema_fields:
+                    raise ValueError(f"Required function parameter '{param_name}' not found in args_schema")
+
+
     def _run(self, *args: Any, **kwargs: Any) -> Any:
-        return self.run(*args, **kwargs)
+        return self.func(*args, **kwargs)
 
 
-    def run(self, *args, **kwargs) -> Any:
+    def _handle_toolset(self, params: Dict[str, Any] = None) -> Any:
         """
-        Use tool and record its usage if should_cache is True.
+        Read the cache from the ToolHandler instance or execute _run() method.
         """
-        from versionhq.tool.tool_handler import ToolHandler
 
-        result = None
-        tool_set = ToolSet(tool=self, kwargs={})
+        from versionhq.tool.tool_handler import ToolHandler
 
-        if self.function:
-            result = self.function(*args, **kwargs)
+        if not self.args_schema:
+            self.args_schema = self._create_schema_from_function()
 
-        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_set = ToolSet(tool=self, kwargs=acceptable_kwargs)
+        result = None
+        acceptable_args = self.args_schema.model_json_schema()["properties"].keys()
+        acceptable_kwargs = { k: v for k, v in params.items() if k in acceptable_args } if params else dict()
+        parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
+        tool_set = ToolSet(tool=self, kwargs=acceptable_kwargs)
 
-            if self.tool_handler:
-                if self.tool_handler.has_called_before(tool_set):
-                    self.tool_handler.error = "Agent execution error"
+        if self.tool_handler and isinstance(self.tool_handler, ToolHandler):
+            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_set.tool.name, input=tool_set.kwargs)
-                    if result is None:
-                        parsed_kwargs = self._parse_args(raw_args=acceptable_kwargs)
-                        result = self.function(**parsed_kwargs) if self.function else None
+            elif self.tool_handler.cache:
+                result = self.tool_handler.cache.read(tool_name=tool_set.tool.name, input=str(tool_set.kwargs))
+                if not result:
+                    result = self.func(**parsed_kwargs)
 
             else:
-                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(raw_args=acceptable_kwargs)
-                result = self.function(**parsed_kwargs) if self.function else None
+                result = self.func(**parsed_kwargs)
+
+        else:
+            tool_handler = ToolHandler(last_used_tool=tool_set, cache_handler=self.cache_handler, should_cache=self.should_cache)
+            self.tool_handler = tool_handler
+            result = self.func(**parsed_kwargs)
 
 
         if self.should_cache is True:
-            self.tool_handler.record_last_tool_used(tool_set, result, self.should_cache)
+            self.tool_handler.record_last_tool_used(last_used_tool=tool_set, output=result, should_cache=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}"
+    def run(self, params: Dict[str, Any] = None) -> Any:
+        """
+        Execute a tool using a toolset and cached tools
+        """
+        result = self._handle_toolset(params)
+        return result
 
 
 class ToolSet(BaseModel):
     """
-    Store the tool called and any kwargs used.
+    Store the tool called and any kwargs used. (The tool name and kwargs will be stored in the cache.)
     """
-    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] | Any = Field(..., description="store the tool instance to be called.")
+    tool: InstanceOf[Tool] | Type[Tool] = Field(..., description="store the tool instance to be called.")
     kwargs: Optional[Dict[str, Any]] = Field(..., description="kwargs passed to the tool")
-
-
-class CacheTool(BaseModel):
-    """
-    Default tools to hit the cache.
-    """
-
-    name: str = "Hit Cache"
-    cache_handler: CacheHandler = Field(default_factory=CacheHandler)
-
-    def hit_cache(self, key):
-        split = key.split("tool:")
-        tool = split[1].split("|input:")[0].strip()
-        tool_input = split[1].split("|input:")[1].strip()
-        return self.cache_handler.read(tool, tool_input)

versionhq/tool/tool_handler.py

@@ -1,8 +1,8 @@
 from typing import Optional, Any
 from pydantic import InstanceOf
 
-from versionhq.tool.model import ToolSet, InstructorToolSet
-from versionhq._utils.cache_handler import CacheHandler
+from versionhq.tool.model import ToolSet
+from versionhq.tool.cache_handler import CacheHandler, CacheTool
 
 
 class ToolHandler:
@@ -10,34 +10,26 @@ class ToolHandler:
     Record the tool usage by ToolSet instance with cache and error recording.
     """
 
-    last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet]
-    cache: Optional[CacheHandler]
+    last_used_tool: InstanceOf[ToolSet]
+    cache: InstanceOf[CacheHandler] = CacheHandler()
     error: Optional[str]
     should_cache: bool
 
-    def __init__(
-        self,
-        last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet] = None,
-        cache_handler: Optional[CacheHandler] = None,
-        should_cache: bool = True
-    ):
-        self.cache = cache_handler
+    def __init__(self, last_used_tool: InstanceOf[ToolSet] = None, cache_handler: InstanceOf[CacheHandler] = None, should_cache: bool = True):
         self.last_used_tool = last_used_tool
+        self.cache = cache_handler if cache_handler else CacheHandler()
         self.should_cache = should_cache
 
 
-    def record_last_tool_used(
-        self, last_used_tool: InstanceOf[ToolSet] | InstanceOf[InstructorToolSet], output: str, should_cache: bool = True
-    ) -> Any:
-        from versionhq.tool.model import CacheTool
-
+    def record_last_tool_used(self, last_used_tool: InstanceOf[ToolSet], output: str, should_cache: bool = True) -> None:
         self.last_used_tool = last_used_tool
 
-        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)
+        if should_cache:
+            self.cache = CacheHandler()
+            self.cache.add(tool_name=last_used_tool.tool.name, input=str(last_used_tool.kwargs), output=output)
 
 
-    def has_called_before(self, tool_set: ToolSet = None) -> bool:
+    def has_called_before(self, tool_set: InstanceOf[ToolSet] = None) -> bool:
         if tool_set is None or not self.last_used_tool:
             return False
 

{versionhq-1.1.9.14.dist-info → versionhq-1.1.10.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: versionhq
-Version: 1.1.9.14
+Version: 1.1.10.3
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -26,6 +26,7 @@ License: MIT License
         SOFTWARE.
         
 Project-URL: Homepage, https://versi0n.io
+Project-URL: Documentation, https://chief-oxygen-8a2.notion.site/Documentation-17e923685cf98001a5fad5c4b2acd79b?pvs=73
 Project-URL: Repository, https://github.com/versionHQ/multi-agent-system
 Project-URL: Issues, https://github.com/versionHQ/multi-agent-system/issues
 Keywords: orchestration framework,orchestration,ai agent,multi-agent system,RAG,agent
@@ -60,7 +61,7 @@ Requires-Dist: composio-langchain>=0.6.12
 
 ![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.9-blue)
+![PyPI](https://img.shields.io/badge/PyPI->=v1.1.10-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)
 
@@ -76,8 +77,9 @@ Messaging workflows are created at individual level, and will be deployed on thi
 
 - [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)
+- [Doc](https://chief-oxygen-8a2.notion.site/Documentation-17e923685cf98001a5fad5c4b2acd79b?pvs=4)
+<!-- - [Github (Test client app)](https://github.com/versionHQ/test-client-app) -->
+- [Use case](https://versi0n.io/): Client web app for the outbound messaging automation
 
 
 <hr />
@@ -152,6 +154,9 @@ Multiple `agents` can form a `team` to complete complex tasks together.
    from versionhq.agent.model import Agent
    from versionhq.task.model import Task, ResponseField
 
+   def my_callback_func():
+      """callback func"""
+
    agent = Agent(
       role="demo",
       goal="amazing project goal",
@@ -162,13 +167,11 @@ Multiple `agents` can form a `team` to complete complex tasks together.
 
    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),
+      response_fields=[
+         ResponseField(title="test1", data_type=str, required=True),
+         ResponseField(title="test2", data_type=list, items=str, required=True),
       ],
-      callback=None,
+      callbacks=[my_callback_func]
    )
    res = task.execute_sync(agent=agent, context="amazing context to consider.")
    return res.to_dict()
@@ -192,13 +195,13 @@ This will return a dictionary with keys defined in the `ResponseField`.
 
    task_1 = Task(
       description="Analyze the client's business model.",
-      output_field_list=[ResponseField(title="test1", type=str, required=True),],
+      response_fields=[ResponseField(title="test1", data_type=str, required=True),],
       allow_delegation=True
    )
 
     task_2 = Task(
       description="Define the cohort.",
-      output_field_list=[ResponseField(title="test1", type=int, required=True),],
+      response_fields=[ResponseField(title="test1", data_type=int, required=True),],
       allow_delegation=False
    )
 
@@ -234,7 +237,7 @@ Tasks can be delegated to a team manager, peers in the team, or completely new a
    - [Composio](https://composio.dev/): Conect RAG agents with external tools, Apps, and APIs to perform actions and receive triggers. We use [tools](https://composio.dev/tools) and [RAG tools](https://app.composio.dev/app/ragtool) from Composio toolset.
 
 **Deployment**
-   - Python: Primary programming language. We use 3.12 in this project
+   - Python: Primary programming language. v3.13 is recommended.
    - [uv](https://docs.astral.sh/uv/): Python package installer and resolver
    - [pre-commit](https://pre-commit.com/): Manage and maintain pre-commit hooks
    - [setuptools](https://pypi.org/project/setuptools/): Build python modules
@@ -306,19 +309,17 @@ src/
 
 ## Contributing
 
-1. Fork the repository
-
-2. Create your feature branch (`git checkout -b feature/your-amazing-feature`)
+1. Create your feature branch (`git checkout -b feature/your-amazing-feature`)
 
-3. Create amazing features
+2. Create amazing features
 
-4. Test the features using the `tests` directory.
+3. Test the features using the `tests` directory.
 
    - Add a test function to respective components in the `tests` directory.
-   - Add your `LITELLM_API_KEY`, `OPENAI_API_KEY`, `COMPOSIO_API_KEY`, `DEFAULT_USER_ID` to the Github `repository secrets` @ settings > secrets & variables > Actions.
+   - Add your `LITELLM_API_KEY`, `OPENAI_API_KEY`, `COMPOSIO_API_KEY`, `DEFAULT_USER_ID` to the Github `repository secrets` located at settings > secrets & variables > Actions.
    - Run a test.
       ```
-      uv run pytest tests -vv
+      uv run pytest tests -vv --cache-clear
       ```
 
    **pytest**
@@ -326,10 +327,10 @@ src/
    * 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'`)
-7. Push to the branch (`git push origin feature/your-amazing-feature`)
-8. Open a pull request
+4. Pull the latest version of source code from the main branch (`git pull origin main`) *Address conflicts if any.
+5. Commit your changes (`git add .` / `git commit -m 'Add your-amazing-feature'`)
+6. Push to the branch (`git push origin feature/your-amazing-feature`)
+7. Open a pull request
 
 
 **Optional**
@@ -342,7 +343,7 @@ src/
    ```
    The frontend will be available at `http://localhost:3000`.
 
-* `production` is available at `https://versi0n.io`. Currently, we are running alpha test.
+* `production` use case is available at `https://versi0n.io`. Currently, we are running alpha test.
 
 
 

versionhq-1.1.10.3.dist-info/RECORD

@@ -0,0 +1,45 @@
+versionhq/__init__.py,sha256=lctzH-NkGs_wSYgbGkPFDcsPpGvFwE8UegxnHsiRp0E,951
+versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
+versionhq/_utils/logger.py,sha256=U-MpeGueA6YS8Ptfy0VnU_ePsZP-8Pvkvi0tZ4s_UMg,1438
+versionhq/_utils/process_config.py,sha256=jbPGXK2Kb4iyCugJ3FwRJuU0wL5Trq2x4xFQz2uOyFY,746
+versionhq/_utils/rpm_controller.py,sha256=dUgFd6JtdjiLLTRmrjsBHdTaLn73XFuKpLbJh7thf2A,2289
+versionhq/_utils/usage_metrics.py,sha256=hhq1OCW8Z4V93vwW2O2j528EyjOlF8wlTsX5IL-7asA,1106
+versionhq/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/agent/model.py,sha256=tdqrnSA212I-oG1GLDw_9AjymjYxbKLBmsXJrghIxhM,19592
+versionhq/agent/parser.py,sha256=Z_swUPO3piJQuYU8oVYwXWeR2zjmNb4PxbXZeR-GlIg,4694
+versionhq/agent/TEMPLATES/Backstory.py,sha256=Gub3SUbdrNAwV0ITLYdZFJ4VFZRDfDRPdBZrtlknrds,554
+versionhq/agent/TEMPLATES/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/clients/customer/__init__.py,sha256=-YXh1FQfvpfLacK8SUC7bD7Wx_eIEi4yrkCC_cUasFg,217
+versionhq/clients/customer/model.py,sha256=_AtaVVMm9MgCwrQ-HTRQ2oXUMKrSCEfZwE2JdRz3xTw,2508
+versionhq/clients/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/clients/product/model.py,sha256=hLTvvQsatNuq0DtyTqpP_gRKgnv6N4uRjavnGfk7b6Y,3695
+versionhq/clients/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/clients/workflow/model.py,sha256=FNftenLLoha0bkivrjId32awLHAkBwIT8iNljdic_bw,6003
+versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/llm/llm_vars.py,sha256=PO__b-h5e-6oQ-uoIgXx3lPSAUPUwXYfdVRW73fvX14,8761
+versionhq/llm/model.py,sha256=0vjFM_BC4B6URG2PRZLydmL8bE_hqsCYFyQHNt4GfGg,13408
+versionhq/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/storage/task_output_storage.py,sha256=xoBJHeqUyQt6iJoR1WQTghP-fyxXL66qslpX1QC2-4o,4827
+versionhq/task/__init__.py,sha256=l2r_g01i91JAGlOoHZP_Gh2WCk6mo9D19lcqt7sKMpQ,186
+versionhq/task/formatter.py,sha256=N8Kmk9vtrMtBdgJ8J7RmlKNMdZWSmV8O1bDexmCWgU0,643
+versionhq/task/log_handler.py,sha256=KJRrcNZgFSKhlNzvtYFnvtp6xukaF1s7ifX9u4zWrN8,1683
+versionhq/task/model.py,sha256=uBB98fIWoqHmnWzYYRgYeG1sw9yLrrwTjWsweMoRlf0,25231
+versionhq/task/structured_response.py,sha256=FbDDnTixghowYNr95FigzpxNIc_A6pPzVVCu8kDgruM,4790
+versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/team/model.py,sha256=NzcRXWwP0adWL9vsnsmI-A5dOcE3199FGmGgemUB2VA,20043
+versionhq/team/team_planner.py,sha256=XkM93ItI59cuEzMN1s1jJ-B4LyalSZnAlYBY5SUCbVs,3603
+versionhq/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+versionhq/tool/cache_handler.py,sha256=iL8FH7X0G-cdT0uhJwzuhLDaadTXOdfybZcDy151-es,1085
+versionhq/tool/composio_tool.py,sha256=38mEiVvTkuw1BLD233Bl1Gwxbpss1yfQiZLTWwX6BdA,8648
+versionhq/tool/composio_tool_vars.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
+versionhq/tool/decorator.py,sha256=C4ZM7Xi2gwtEMaSeRo-geo_g_MAkY77WkSLkAuY0AyI,1205
+versionhq/tool/model.py,sha256=5qG-OH7zohvepPDOjdjDulhEqmNUM4osiyk5LaxmSiU,12333
+versionhq/tool/tool_handler.py,sha256=2m41K8qo5bGCCbwMFferEjT-XZ-mE9F0mDUOBkgivOI,1416
+versionhq-1.1.10.3.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.10.3.dist-info/METADATA,sha256=HF7BiaGsEsAIlgHVlFq3IzIs5cpsOBzNqe56pv6teY4,16356
+versionhq-1.1.10.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+versionhq-1.1.10.3.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.10.3.dist-info/RECORD,,