versionhq 1.1.8.1__tar.gz → 1.1.9.0__tar.gz

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/.github/workflows/run_tests.yml

@@ -8,6 +8,9 @@ permissions:
 env:
   LITELLM_API_KEY: ${{ secrets.LITELLM_API_KEY }}
   OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+  DEFAULT_REDIRECT_URL:  ${{ secrets.DEFAULT_REDIRECT_URL }}
+  DEFAULT_USER_ID:  ${{ secrets.DEFAULT_USER_ID }}
+  COMPOSIO_API_KEY: ${{ secrets.COMPOSIO_API_KEY }}
 
 jobs:
   run_test:

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/.gitignore

@@ -1,7 +1,7 @@
 knowledge/
 memory/
 
-composio.py
+# composio.py
 memo.txt
 
 dist/

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.8.1
+Version: 1.1.9.0
 Summary: LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows
 Author-email: Kuriko Iwai <kuriko@versi0n.io>
 License: MIT License
@@ -312,7 +312,7 @@ src/
 4. Test the features using 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.
+   - Add your `LITELLM_API_KEY`, `OPENAI_API_KEY`, `COMPOSIO_API_KEY`, `DEFAULT_USER_ID` to the Github `repository secrets` @ settings > secrets & variables > Actions.
    - Run a test.
       ```
       uv run pytest tests -vv

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/README.md

@@ -257,7 +257,7 @@ src/
 4. Test the features using 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.
+   - Add your `LITELLM_API_KEY`, `OPENAI_API_KEY`, `COMPOSIO_API_KEY`, `DEFAULT_USER_ID` to the Github `repository secrets` @ settings > secrets & variables > Actions.
    - Run a test.
       ```
       uv run pytest tests -vv

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/pyproject.toml

@@ -15,7 +15,7 @@ exclude = ["test*", "__pycache__"]
 
 [project]
 name = "versionhq"
-version = "1.1.8.1"
+version = "1.1.9.0"
 authors = [{ name = "Kuriko Iwai", email = "kuriko@versi0n.io" }]
 description = "LLM orchestration frameworks for model-agnostic AI agents that handle complex outbound workflows"
 readme = "README.md"

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/src/versionhq/__init__.py

@@ -15,9 +15,10 @@ from versionhq.llm.model import LLM
 from versionhq.task.model import Task, TaskOutput
 from versionhq.team.model import Team, TeamOutput
 from versionhq.tool.model import Tool
+from versionhq.tool.composio import Composio
 
 
-__version__ = "1.1.8.1"
+__version__ = "1.1.9.0"
 __all__ = [
     "Agent",
     "Customer",
@@ -33,4 +34,5 @@ __all__ = [
     "Team",
     "TeamOutput",
     "Tool",
+    "Composio"
 ]

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/src/versionhq/agent/model.py

@@ -15,7 +15,7 @@ from versionhq.llm.llm_vars import LLM_VARS
 from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
 from versionhq.task import TaskOutputFormat
 from versionhq.task.model import ResponseField
-from versionhq.tool.model import Tool, ToolCalled
+from versionhq.tool.model import Tool, ToolSet
 from versionhq.tool.tool_handler import ToolHandler
 
 load_dotenv(override=True)

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/src/versionhq/clients/workflow/model.py

@@ -117,15 +117,6 @@ class MessagingWorkflow(ABC, BaseModel):
         description="store metrics that used to predict and track the performance of this workflow."
     )
 
-
-    @property
-    def name(self):
-        if self.customer.id:
-            return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
-        else:
-            return f"Workflow ID: {self.id} - on {self.product.id}"
-
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -160,3 +151,11 @@ class MessagingWorkflow(ABC, BaseModel):
         self.agents = agents
         self.team = team
         self.updated_at = datetime.datetime.now()
+
+
+    @property
+    def name(self):
+        if self.customer.id:
+            return f"Workflow ID: {self.id} - on {self.product.id} for {self.customer.id}"
+        else:
+            return f"Workflow ID: {self.id} - on {self.product.id}"

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/src/versionhq/task/model.py

@@ -12,7 +12,7 @@ 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.tool.model import Tool, ToolSet
 from versionhq._utils.logger import Logger
 
 
@@ -76,18 +76,6 @@ class TaskOutput(BaseModel):
     def __str__(self) -> str:
         return str(self.pydantic) if self.pydantic else str(self.json_dict) if self.json_dict else self.raw
 
-    @property
-    def json(self) -> Optional[str]:
-        if self.output_format != TaskOutputFormat.JSON:
-            raise ValueError(
-                """
-                Invalid output format requested.
-                If you would like to access the JSON output,
-                pleae make sure to set the output_json property for the task
-                """
-            )
-        return json.dumps(self.json_dict)
-
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -112,6 +100,19 @@ class TaskOutput(BaseModel):
         return json.dumps(self.json_dict) if self.json_dict else self.raw[0: 127]
 
 
+    @property
+    def json(self) -> Optional[str]:
+        if self.output_format != TaskOutputFormat.JSON:
+            raise ValueError(
+                """
+                Invalid output format requested.
+                If you would like to access the JSON output,
+                pleae make sure to set the output_json property for the task
+                """
+            )
+        return json.dumps(self.json_dict)
+
+
 
 class Task(BaseModel):
     """
@@ -140,7 +141,7 @@ class Task(BaseModel):
 
     # task setup
     context: Optional[List["Task"]] = Field(default=None, description="other tasks whose outputs should be used as context")
-    tools_called: Optional[List[ToolCalled]] = Field(default_factory=list, description="tools that the agent can use for this task")
+    tools_called: Optional[List[ToolSet]] = Field(default_factory=list, description="tools that the agent can use for this 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")
 
@@ -157,63 +158,6 @@ class Task(BaseModel):
     delegations: int = 0
 
 
-    @property
-    def output_prompt(self) -> str:
-        """
-        Draft prompts on the output format by converting `output_field_list` to dictionary.
-        """
-
-        output_prompt, output_formats_to_follow = "", dict()
-        for item in self.output_field_list:
-            output_formats_to_follow[item.title] = f"<Return your answer in {item.type.__name__}>"
-
-        output_prompt = f"""
-Your outputs MUST adhere to the following format and should NOT include any irrelevant elements:
-{output_formats_to_follow}
-        """
-        return output_prompt
-
-
-    @property
-    def expected_output_formats(self) -> List[TaskOutputFormat]:
-        """
-        Return output formats in list with the ENUM item.
-        `TaskOutputFormat.RAW` is set as default.
-        """
-        outputs = [TaskOutputFormat.RAW,]
-        if self.expected_output_json:
-            outputs.append(TaskOutputFormat.JSON)
-        if self.expected_output_pydantic:
-            outputs.append(TaskOutputFormat.PYDANTIC)
-        return outputs
-
-
-    @property
-    def key(self) -> str:
-        output_format = (
-            TaskOutputFormat.JSON
-            if self.expected_output_json == True
-            else (
-                TaskOutputFormat.PYDANTIC
-                if self.expected_output_pydantic == True
-                else TaskOutputFormat.RAW
-            )
-        )
-        source = [self.description, output_format]
-        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
-
-
-    @property
-    def summary(self) -> str:
-        return f"""
-        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])}
-        """
-
-
-    # validators
     @model_validator(mode="before")
     @classmethod
     def process_model_config(cls, values: Dict[str, Any]):
@@ -467,6 +411,63 @@ Your outputs MUST adhere to the following format and should NOT include any irre
         self._task_output_handler.update(task=self, task_index=task_index, was_replayed=was_replayed, inputs=inputs)
 
 
+    @property
+    def output_prompt(self) -> str:
+        """
+        Draft prompts on the output format by converting `output_field_list` to dictionary.
+        """
+
+        output_prompt, output_formats_to_follow = "", dict()
+        for item in self.output_field_list:
+            output_formats_to_follow[item.title] = f"<Return your answer in {item.type.__name__}>"
+
+        output_prompt = f"""
+Your outputs MUST adhere to the following format and should NOT include any irrelevant elements:
+{output_formats_to_follow}
+        """
+        return output_prompt
+
+
+    @property
+    def expected_output_formats(self) -> List[TaskOutputFormat]:
+        """
+        Return output formats in list with the ENUM item.
+        `TaskOutputFormat.RAW` is set as default.
+        """
+        outputs = [TaskOutputFormat.RAW,]
+        if self.expected_output_json:
+            outputs.append(TaskOutputFormat.JSON)
+        if self.expected_output_pydantic:
+            outputs.append(TaskOutputFormat.PYDANTIC)
+        return outputs
+
+
+    @property
+    def key(self) -> str:
+        output_format = (
+            TaskOutputFormat.JSON
+            if self.expected_output_json == True
+            else (
+                TaskOutputFormat.PYDANTIC
+                if self.expected_output_pydantic == True
+                else TaskOutputFormat.RAW
+            )
+        )
+        source = [self.description, output_format]
+        return md5("|".join(source).encode(), usedforsecurity=False).hexdigest()
+
+
+    @property
+    def summary(self) -> str:
+        return f"""
+        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])}
+        """
+
+
+
 
 class ConditionalTask(Task):
     """

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/src/versionhq/team/model.py

@@ -161,54 +161,6 @@ class Team(BaseModel):
         return self.name if self.name is not None else self.id.__str__
 
 
-    @property
-    def key(self) -> str:
-        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 managers(self) -> List[TeamMember] | None:
-        managers = [member for member in self.members if member.is_manager == True]
-        return managers if len(managers) > 0 else None
-
-
-    @property
-    def manager_tasks(self) -> List[Task] | None:
-        """
-        Tasks (incl. team tasks) handled by managers in the team.
-        """
-        if self.managers:
-            tasks = [manager.task for manager in self.managers if manager.task is not None]
-            return tasks if len(tasks) > 0 else None
-
-        return None
-
-
-    @property
-    def tasks(self):
-        """
-        Return all the tasks that the team needs to handle in order of priority:
-        1. team tasks, -> assigned to the member
-        2. manager_task,
-        3. members' tasks
-        """
-
-        team_tasks = self.team_tasks
-        manager_tasks = [member.task for member in self.members if member.is_manager == True and member.task is not None and member.task not in team_tasks]
-        member_tasks = [member.task for member in self.members if member.is_manager == False and member.task is not None and member.task not in team_tasks]
-
-        return team_tasks + manager_tasks + member_tasks
-
-
-    @property
-    def member_tasks_without_agent(self) -> List[Task] | None:
-        if self.members:
-            return [member.task for member in self.members if member.agent is None]
-
-        return None
-
-
     @field_validator("id", mode="before")
     @classmethod
     def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
@@ -218,7 +170,7 @@ class Team(BaseModel):
 
 
     @model_validator(mode="after")
-    def validate_tasks(self):
+    def assess_tasks(self):
         """
         Validates if the model recognize all tasks that the team needs to handle.
         """
@@ -261,7 +213,7 @@ class Team(BaseModel):
         if self.process == TaskHandlingProcess.sequential and self.team_tasks is None:
             for member in self.members:
                 if member.task is None:
-                    raise PydanticCustomError("missing_agent_in_task", f"Sequential process error: Agent is missing the task", {})
+                    raise PydanticCustomError("missing_agent_in_task", "Sequential process error: Agent is missing the task", {})
         return self
 
     @model_validator(mode="after")
@@ -280,11 +232,7 @@ class Team(BaseModel):
                 break
 
         if async_task_count > 1:
-            raise PydanticCustomError(
-                "async_task_count",
-                "The team must end with max. one asynchronous task.",
-                {},
-            )
+            raise PydanticCustomError("async_task_count", "The team must end with max. one asynchronous task.", {})
         return self
 
 
@@ -310,7 +258,6 @@ class Team(BaseModel):
         unassigned_tasks: List[Task] = self.member_tasks_without_agent
         new_team_members: List[TeamMember] = []
 
-
         if self.team_tasks:
             candidates = idling_managers + idling_members
             if candidates:
@@ -468,7 +415,6 @@ class Team(BaseModel):
 
         metrics: List[UsageMetrics] = []
 
-
         if self.team_tasks or self.member_tasks_without_agent:
             self._handle_team_planning()
 
@@ -511,3 +457,51 @@ class Team(BaseModel):
             self.usage_metrics.add_usage_metrics(metric)
 
         return result
+
+
+    @property
+    def key(self) -> str:
+        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 managers(self) -> List[TeamMember] | None:
+        managers = [member for member in self.members if member.is_manager == True]
+        return managers if len(managers) > 0 else None
+
+
+    @property
+    def manager_tasks(self) -> List[Task] | None:
+        """
+        Tasks (incl. team tasks) handled by managers in the team.
+        """
+        if self.managers:
+            tasks = [manager.task for manager in self.managers if manager.task is not None]
+            return tasks if len(tasks) > 0 else None
+
+        return None
+
+
+    @property
+    def tasks(self):
+        """
+        Return all the tasks that the team needs to handle in order of priority:
+        1. team tasks, -> assigned to the member
+        2. manager_task,
+        3. members' tasks
+        """
+
+        team_tasks = self.team_tasks
+        manager_tasks = [member.task for member in self.members if member.is_manager == True and member.task is not None and member.task not in team_tasks]
+        member_tasks = [member.task for member in self.members if member.is_manager == False and member.task is not None and member.task not in team_tasks]
+
+        return team_tasks + manager_tasks + member_tasks
+
+
+    @property
+    def member_tasks_without_agent(self) -> List[Task] | None:
+        if self.members:
+            return [member.task for member in self.members if member.agent is None]
+
+        return None

versionhq-1.1.9.0/src/versionhq/tool/__init__.py

@@ -0,0 +1,53 @@
+from enum import Enum
+
+DEFAULT_AUTH_SCHEME = "OAUTH2"
+
+class ComposioAuthScheme(str, Enum):
+    OAUTH2 = "OAUTH2"
+    BEARER_TOKEN = "BEARER_TOKEN"
+    API_KEY = "API_KEY"
+
+
+class ComposioAppName(str, Enum):
+    """
+    Enum to store app names that we can connect via Composio as data pipelines or destination services.
+    """
+
+    SALESFORCE = "salesforce"
+    AIRTABLE = "airtable"
+    MAILCHIMP = "mailchimp"
+    HUBSPOT = "hubspot"
+    KLAVIYO = "klaviyo"
+    GOOGLESHEET = "googlesheets"
+    GMAIL = "gmail"
+    FACEBOOK = "facebook"
+    TWITTER = "twitter"
+    TWITTER_MEDIA = "twitter_media"
+    LINKEDIN = "linkedin"
+
+
+composio_app_set = [
+    (ComposioAppName.SALESFORCE, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.AIRTABLE, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.MAILCHIMP, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.HUBSPOT, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.KLAVIYO, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.API_KEY),
+    (ComposioAppName.GOOGLESHEET, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.GMAIL, ComposioAuthScheme.OAUTH2, ComposioAuthScheme.BEARER_TOKEN),
+    (ComposioAppName.TWITTER, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.TWITTER_MEDIA, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.FACEBOOK, ComposioAuthScheme.OAUTH2),
+    (ComposioAppName.LINKEDIN, ComposioAuthScheme.OAUTH2),
+]
+
+class COMPOSIO_STATUS(str, Enum):
+    INITIATED = "initiated"
+    ACTIVE = "active"
+    FAILED = "failed"
+
+
+
+class ComposioAction(str, Enum):
+    """
+    Enum to store composio's action that can be called via `Actions.xxx`
+    """

versionhq-1.1.9.0/src/versionhq/tool/composio.py

@@ -0,0 +1,149 @@
+import os
+import uuid
+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_core import PydanticCustomError
+
+from composio import ComposioToolSet, Action, App, action
+
+from versionhq.tool import ComposioAppName, ComposioAuthScheme, composio_app_set, COMPOSIO_STATUS
+
+load_dotenv(override=True)
+
+DEFAULT_REDIRECT_URL = os.environ.get("DEFAULT_REDIRECT_URL", None)
+DEFAULT_USER_ID = os.environ.get("DEFAULT_USER_ID", None)
+
+
+class Composio(BaseModel):
+    """
+    Class to handle composio tools.
+    """
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    app_name: str = Field(default=ComposioAppName.HUBSPOT)
+    user_id: str = Field(default=DEFAULT_USER_ID)
+    auth_scheme: str = Field(default=ComposioAuthScheme.OAUTH2)
+    redirect_url: str = Field(default=DEFAULT_REDIRECT_URL, description="redirect url after successful oauth2 connection")
+    connect_request_id: str = Field(default=None, description="store the client's composio id to connect with the app")
+
+    @property
+    def toolset(self) -> ComposioToolSet:
+        return ComposioToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"))
+
+
+    def __name__(self):
+        return self.app_name
+
+
+    @field_validator("id", mode="before")
+    @classmethod
+    def _deny_user_set_id(cls, v: Optional[UUID4]) -> None:
+        if v:
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+
+
+    # @model_validator("user_id", mode="before")
+    # @classmethod
+    # def _deny_no_user_id(cls, v: Optional[str]) -> None:
+    #     if v is None:
+    #         raise PydanticCustomError("user_id_missing", "Need user_id to connect with the tool", {})
+
+
+    @model_validator(mode="after")
+    def validate_app_name(self):
+        if self.app_name not in ComposioAppName:
+            raise PydanticCustomError("no_app_name", f"The app name {self.app_name} is not valid.", {})
+
+        return self
+
+
+    @model_validator(mode="after")
+    def validate_auth_scheme(self):
+        """
+        Raise error when the client uses auth scheme unavailable for the app.
+        """
+        app_set = next(filter(lambda tup: self.app_name in tup, composio_app_set), None)
+        if not app_set:
+            raise  PydanticCustomError("no_app_set", f"The app set of {self.app_name} is missing.", {})
+
+        else:
+            acceptable_auth_scheme = next(filter(lambda item: self.auth_scheme in item, app_set), None)
+            if acceptable_auth_scheme is None:
+                raise  PydanticCustomError("invalid_auth_scheme", f"The app {self.app_name} must have different auth_scheme.", {})
+
+        return self
+
+
+    # connect with composio to use the tool
+    def connect(self, token: Optional[str] = None, api_key: Optional[str] = None) -> Tuple[str | Any]:
+        """
+        Connect with Composio, retrieve `connect_request_id`, and validate the connection.
+        """
+
+        if not self.user_id:
+            raise PydanticCustomError("user_id_missing", "Need user_id to connect with the tool", {})
+
+
+        connection_request, connected_account = None, None
+
+        if self.auth_scheme == ComposioAuthScheme.API_KEY:
+            collected_from_user = {}
+            collected_from_user["api_key"] = api_key
+            connection_request = self.toolset.initiate_connection(
+                connected_account_params = collected_from_user,
+                app=self.app_name,
+                entity_id=self.user_id,
+                auth_scheme=self.auth_scheme,
+            )
+
+        if self.auth_scheme == ComposioAuthScheme.BEARER_TOKEN:
+            collected_from_user = {}
+            collected_from_user["token"] = token
+            connection_request = self.toolset.initiate_connection(
+                connected_account_params = collected_from_user,
+                app=self.app_name,
+                entity_id=self.user_id,
+                auth_scheme=self.auth_scheme,
+            )
+
+        if self.auth_scheme == ComposioAuthScheme.OAUTH2:
+            connection_request = self.toolset.initiate_connection(
+                app=self.app_name,
+                redirect_url = self.redirect_url, # clients will be redirected to this url after successful auth.
+                entity_id=self.user_id,
+                auth_scheme=self.auth_scheme,
+            )
+
+        # connection_request.wait_until_active(self.toolset.client, timeout=60)
+
+        if connection_request.connectionStatus is not COMPOSIO_STATUS.FAILED:
+            self.connect_request_id = connection_request.connectedAccountId
+            connected_account = self.toolset.get_connected_account(id=self.connect_request_id)
+
+            if connected_account.status is not COMPOSIO_STATUS.FAILED:
+                setattr(self.toolset, "entity_id", self.user_id)
+
+        return connected_account, connected_account.status if connected_account else connection_request.connectionStatus
+
+
+
+
+    # @action(toolname=ComposioAppName.HUBSPOT)
+    # def deploy(self, param1: str, param2: str, execute_request: Callable) -> str:
+    #     """
+    #     Define custom actions
+    #     my custom action description which will be passed to llm
+
+    #     :param param1: param1 description which will be passed to llm
+    #     :param param2: param2 description which will be passed to llm
+    #     :return info: return description
+    #     """
+
+    #     response = execute_request(
+    #         "/my_action_endpoint",
+    #         "GET",
+    #         {} # body can be added here
+    #     )    # execute requests by appending credentials to the request
+    #     return str(response) # complete auth dict is available for local use if needed

{versionhq-1.1.8.1 → versionhq-1.1.9.0}/src/versionhq/tool/decorator.py

@@ -1,5 +1,6 @@
 from typing import Callable
 from pydantic import BaseModel
+
 from versionhq.tool.model import Tool
 
 
@@ -13,6 +14,7 @@ def tool(*args):
         def _make_tool(f: Callable) -> Tool:
             if f.__doc__ is None:
                 raise ValueError("Function must have a docstring")
+
             if f.__annotations__ is None:
                 raise ValueError("Function must have type annotations")
 
@@ -26,7 +28,7 @@ def tool(*args):
                     },
                 },
             )
-            return Tool(name=tool_name, func=f, args_schema=args_schema)
+            return Tool(name=tool_name, function=f, args_schema=args_schema)
 
         return _make_tool