versionhq 1.1.9.1__py3-none-any.whl → 1.1.9.3__py3-none-any.whl

versionhq/__init__.py

@@ -15,10 +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
+from versionhq.tool.composio_tool import ComposioHandler
 
 
-__version__ = "1.1.9.1"
+__version__ = "1.1.9.3"
 __all__ = [
     "Agent",
     "Customer",
@@ -34,5 +34,5 @@ __all__ = [
     "Team",
     "TeamOutput",
     "Tool",
-    "Composio"
+    "ComposioHandler"
 ]

versionhq/_utils/logger.py

@@ -10,23 +10,21 @@ class Printer:
             self._print_purple(content)
         elif color == "red":
             self._print_red(content)
-        elif color == "bold_green":
-            self._print_bold_green(content)
-        elif color == "bold_purple":
-            self._print_bold_purple(content)
-        elif color == "bold_blue":
-            self._print_bold_blue(content)
+        elif color == "green":
+            self._print_green(content)
+        elif color == "purple":
+            self._print_purple(content)
+        elif color == "blue":
+            self._print_blue(content)
         elif color == "yellow":
             self._print_yellow(content)
-        elif color == "bold_yellow":
-            self._print_bold_yellow(content)
         else:
             print(content)
 
-    def _print_bold_purple(self, content):
+    def _print_purple(self, content):
         print("\033[1m\033[95m {}\033[00m".format(content))
 
-    def _print_bold_green(self, content):
+    def _print_green(self, content):
         print("\033[1m\033[92m {}\033[00m".format(content))
 
     def _print_purple(self, content):
@@ -35,23 +33,18 @@ class Printer:
     def _print_red(self, content):
         print("\033[91m {}\033[00m".format(content))
 
-    def _print_bold_blue(self, content):
+    def _print_blue(self, content):
         print("\033[1m\033[94m {}\033[00m".format(content))
 
     def _print_yellow(self, content):
-        print("\033[93m {}\033[00m".format(content))
-
-    def _print_bold_yellow(self, content):
         print("\033[1m\033[93m {}\033[00m".format(content))
 
 
 class Logger(BaseModel):
-    verbose: bool = Field(default=False)
+    verbose: bool = Field(default=True)
     _printer: Printer = PrivateAttr(default_factory=Printer)
 
-    def log(self, level, message, color="bold_yellow"):
+    def log(self, level, message, color="yellow"):
         if self.verbose:
             timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            self._printer.print(
-                f"\n[{timestamp}][{level.upper()}]: {message}", color=color
-            )
+            self._printer.print(f"\n[{timestamp}][{level.upper()}]: {message}", color=color)

versionhq/agent/model.py

@@ -6,11 +6,9 @@ from dotenv import load_dotenv
 from pydantic import UUID4, BaseModel, Field, InstanceOf, PrivateAttr, model_validator, field_validator
 from pydantic_core import PydanticCustomError
 
-from versionhq._utils.cache_handler import CacheHandler
 from versionhq._utils.logger import Logger
 from versionhq._utils.rpm_controller import RPMController
 from versionhq._utils.usage_metrics import UsageMetrics
-from versionhq.agent.parser import AgentAction
 from versionhq.llm.llm_vars import LLM_VARS
 from versionhq.llm.model import LLM, DEFAULT_CONTEXT_WINDOW
 from versionhq.task import TaskOutputFormat
@@ -122,10 +120,7 @@ class Agent(BaseModel):
 
     # config, cache, error handling
     config: Optional[Dict[str, Any]] = Field(default=None, exclude=True, description="Configuration for the agent")
-    cache: bool = Field(default=True, description="Whether the agent should use a cache for tool usage.")
-    cache_handler: InstanceOf[CacheHandler] = Field(default=None, description="An instance of the CacheHandler class.")
     formatting_errors: int = Field(default=0, description="Number of formatting errors.")
-    verbose: bool = Field(default=True, description="Verbose mode for the Agent Execution")
     agent_ops_agent_name: str = None
     agent_ops_agent_id: str = None
 

versionhq/clients/customer/__init__.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+
+class Status(str, Enum):
+    ON_WORKFLOW = "on_workflow"

versionhq/clients/customer/model.py

@@ -1,41 +1,53 @@
 import uuid
-from abc import ABC
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
 from versionhq.clients.product.model import Product, ProductProvider
+from versionhq.clients.customer import Status
 
 
-class Customer(ABC, BaseModel):
+class BaseCustomer(ABC, BaseModel):
     """
-    Store the minimal information on the customer.
+    Abstract base class for the base customer
     """
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
     name: Optional[str] = Field(default=None, description="customer's name if any")
-    product_list: Optional[List[Product]] = Field(default=list, description="store products that the customer is associated with")
+    products: Optional[List[Product]] = Field(default=list, description="store products that the customer is associated with")
     analysis: str = Field(default=None, description="store the latest analysis results on the customer")
-    on_workflow: bool = Field(default=False, description="`True` if they are on some messaging workflows")
-    on: Optional[str] = Field(default=None, description="destination service for this customer if any")
+    status: str = Field(default=Status.ON_WORKFLOW)
 
 
     @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.", {}
-            )
+            raise PydanticCustomError("may_not_set_field", "This field is not to be set by the user.", {})
+
 
     def customer_to(self) -> List[ProductProvider]:
         """
         Return list of ProductProvider if the customer has `product_list`
         """
 
-        res = list
-        if self.product_list:
-            for item in self.product_list:
+        res = []
+        if self.products:
+            for item in self.products:
                 if item.provider not in res:
                     res.appned(item.provider)
         return res
+
+
+    @abstractmethod
+    def _deploy(self, *args, **kwargs) -> Any:
+        """Any method to deploy targeting the customer"""
+
+
+class Customer(BaseCustomer):
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    name: Optional[str] = Field(default=None, description="customer's name if any")
+    products: Optional[List[Product]] = Field(default=list, description="store products that the customer is associated with")
+    analysis: str = Field(default=None, description="store the latest analysis results on the customer")
+    status: str = Field(default=Status.ON_WORKFLOW)

versionhq/clients/product/model.py

@@ -1,22 +1,23 @@
 import uuid
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Callable, Type, Optional, get_args, get_origin
+
 from pydantic import UUID4, InstanceOf, BaseModel, ConfigDict, Field, create_model, field_validator, model_validator
 from pydantic_core import PydanticCustomError
 
+from versionhq.tool import ComposioAppName
+
 
-class ProductProvider(BaseModel):
+class ProductProvider(ABC, BaseModel):
     """
-    Store the minimal client information.
-    `data_pipeline` and `destinations` are for composio plug-in.
-    (!REFINEME) Create an Enum list for the options.
-    (!REFINEME) Create an Enum list for regions.
+    Abstract class for the product provider entity.
     """
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
-    name: Optional[str] = Field(default=None, description="client name")
+    name: Optional[str] = Field(default=None)
     region: Optional[str] = Field(default=None, description="region of client's main business operation")
-    data_pipeline: Optional[List[str]] = Field(default=None, description="store the data pipelines that the client is using")
-    destinations: Optional[List[str]] = Field(default=None,description="store the destination services that the client is using")
+    data_pipelines: Optional[List[ComposioAppName | str]] = Field(default_factory=list)
+    destination_services: Optional[List[ComposioAppName | str]] = Field(default=None)
 
     @field_validator("id", mode="before")
     @classmethod

versionhq/clients/workflow/model.py

@@ -10,6 +10,7 @@ from versionhq.clients.product.model import Product
 from versionhq.clients.customer.model import Customer
 from versionhq.agent.model import Agent
 from versionhq.team.model import Team
+from versionhq.tool import ComposioAppName
 
 
 class ScoreFormat:
@@ -57,14 +58,12 @@ class Score:
 class MessagingComponent(ABC, BaseModel):
     layer_id: int = Field(default=0, description="add id of the layer: 0, 1, 2")
     message: str = Field(default=None, max_length=1024, description="text message content to be sent")
-    interval: Optional[str] = Field(
-        default=None, description="interval to move on to the next layer. if this is the last layer, set as `None`"
-    )
-    score: float | InstanceOf[Score] = Field(default=None)
-    condition: str = Field(default=None, max_length=128, description="condition to execute the next messaging component")
+    score: InstanceOf[Score] = Field(default=None)
+    condition: str = Field(default=None, max_length=128, description="condition to execute the next component")
+    interval: Optional[str] = Field(default=None, description="ideal interval to set to assess the condition")
 
 
-    def store_scoring_result(self, scoring_subject: str, score_raw: int | Score | ScoreFormat = None) -> Self:
+    def store_scoring_result(self, subject: str, score_raw: int | Score | ScoreFormat = None) -> Self:
         """
         Set up the `score` field
         """
@@ -74,12 +73,12 @@ class MessagingComponent(ABC, BaseModel):
 
         elif isinstance(score_raw, ScoreFormat):
             score_instance = Score()
-            setattr(score_instance, scoring_subject, score_raw)
+            setattr(score_instance, subject, score_raw)
             setattr(self, "score", score_instance)
 
         elif isinstance(score_raw, int) or isinstance(score_raw, float):
             score_instance, score_format_instance = Score(), ScoreFormat(rate=score_raw, weight=1)
-            setattr(score_instance, "kwargs", { scoring_subject: score_format_instance })
+            setattr(score_instance, "kwargs", { subject: score_format_instance })
             setattr(self, "score", score_instance)
 
         else:
@@ -100,23 +99,17 @@ class MessagingWorkflow(ABC, BaseModel):
     model_config = ConfigDict()
 
     id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
-    components: List[MessagingComponent] = Field(default_factory=list, description="store messaging components in the workflow")
+    messaging_components: List[MessagingComponent] = Field(default_factory=list, description="store messaging components in the workflow")
 
     # responsible tean or agents
-    team: Optional[Team] = Field(default=None, description="store `Team` instance responsibile for autopiloting this workflow")
-    agents: Optional[List[Agent]] = Field(
-        default=None, description="store `Agent` instances responsible for autopiloting this workflow. if the team exsits, this field remains as `None`")
+    team: Optional[Team] = Field(default=None, description="store a responsibile team to autopilot the workflow")
+    agents: Optional[List[Agent]] = Field(default=None, description="store responsible agents. None when the team exists")
 
     # metrics
-    destination: Optional[str | None] = Field(default=None, description="destination service to launch this workflow")
+    destination: Optional[ComposioAppName | str] = Field(default=None, description="destination service to launch the workflow")
     product: InstanceOf[Product] = Field(default=None)
     customer: InstanceOf[Customer] = Field(default=None)
-
-    metrics: List[Dict[str, Any]] | List[str] = Field(
-        default=None,
-        max_length=256,
-        description="store metrics that used to predict and track the performance of this workflow."
-    )
+    performance_metrics: List[Dict[str, Any]] | List[str] = Field(default=None, max_length=256, description="performance metrics to track")
 
     @field_validator("id", mode="before")
     @classmethod
@@ -132,11 +125,11 @@ class MessagingWorkflow(ABC, BaseModel):
         Prioritize customer's destination to the product provider's destination list.
         """
         if self.destination is None:
-            if self.customer is not None:
-                self.destination = self.customer.on
+            # if self.customer is not None:
+            #     self.destination = self.customer.on
 
-            elif self.product.provider is not None and self.product.provider.destinations:
-                self.destination = self.product.provider.destinations[0]
+            if self.product.provider is not None and self.product.provider.destination_services:
+                self.destination = self.product.provider.destination_services[0]
 
         return self
 

versionhq/tool/__init__.py

@@ -40,10 +40,11 @@ composio_app_set = [
     (ComposioAppName.LINKEDIN, ComposioAuthScheme.OAUTH2),
 ]
 
-class COMPOSIO_STATUS(str, Enum):
-    INITIATED = "initiated"
-    ACTIVE = "active"
-    FAILED = "failed"
+class ComposioStatus(str, Enum):
+    INITIATED = "INITIATED"
+    ACTIVE = "ACTIVE"
+    FAILED = "FAILED"
+
 
 
 
@@ -51,3 +52,5 @@ class ComposioAction(str, Enum):
     """
     Enum to store composio's action that can be called via `Actions.xxx`
     """
+    # HUBSPOT_INITIATE_DATA_IMPORT_PROCESS = "hubspot_initate_date_import_process"
+    HUBSPOT_CREATE_PIPELINE_STAGE = "hubspot_create_pipeline_stage"

versionhq/tool/composio_tool.py

@@ -0,0 +1,191 @@
+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, Dict
+from typing_extensions import Self
+
+from pydantic import BaseModel, Field, model_validator, field_validator, UUID4, PrivateAttr
+from pydantic_core import PydanticCustomError
+
+from composio import ComposioToolSet
+from composio_langchain import action
+
+from versionhq.tool import ComposioAppName, ComposioAuthScheme, composio_app_set, ComposioStatus, ComposioAction
+from versionhq._utils.logger import Logger
+from versionhq._utils.cache_handler import CacheHandler
+
+load_dotenv(override=True)
+
+DEFAULT_REDIRECT_URL = os.environ.get("DEFAULT_REDIRECT_URL", None)
+DEFAULT_USER_ID = os.environ.get("DEFAULT_USER_ID", None)
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", None)
+
+
+class ComposioHandler(ABC, BaseModel):
+    """
+    A class to handle connecting account with Composio and executing actions using Composio ecosystem.
+    `connected_account_id` is set up per `app_name` to call the actions on the given app. i.e., salesforce
+    """
+
+    _logger: Logger = PrivateAttr(default_factory=lambda: Logger(verbose=True))
+    _cache: CacheHandler = PrivateAttr(default_factory=lambda: CacheHandler())
+
+    id: UUID4 = Field(default_factory=uuid.uuid4, frozen=True)
+    app_name: str = Field(default=ComposioAppName.HUBSPOT, max_length=128, description="app name defined by composio")
+    user_id: str = Field(default=DEFAULT_USER_ID, description="composio entity id")
+    auth_scheme: str = Field(default=ComposioAuthScheme.OAUTH2)
+    redirect_url: str = Field(default=DEFAULT_REDIRECT_URL, description="redirect url after successful oauth2 connection")
+    connected_account_id: str = Field(
+        default=None,
+        description="store the client id generated by composio after auth validation. use the id to connect with a given app and execute composio actions"
+    )
+    tools: Any = Field(default=None, descritpion="retrieved composio tools")
+
+    @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(mode="after")
+    def validate_app_name(self):
+        if self.app_name not in ComposioAppName:
+            raise PydanticCustomError("no_app_name", f"The given 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
+
+
+    def _setup_langchain_toolset(self, metadata: Dict[str, Any] = dict()):
+        """
+        Composio toolset on LangChain for action execution using LLM.
+        """
+        from composio_langchain import ComposioToolSet
+        return ComposioToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"), metadata={**metadata})
+
+
+    def _connect(
+            self, token: Optional[str] = None, api_key: Optional[str] = None, connected_account_id: str = None
+        ) -> Tuple[Self | str | Any]:
+        """
+        Send connection request to Composio, retrieve `connected_account_id`, and proceed with OAuth process of the given app to activate the connection.
+        """
+
+        connection_request, connected_account = None, None
+        connected_account_id = connected_account_id or self.connected_account_id
+        if connected_account_id:
+            connected_account = self.toolset.get_connected_account(id=connected_account_id)
+
+            if connected_account and connected_account.status == ComposioStatus.ACTIVE.value:
+                return self, ComposioStatus.ACTIVE.value
+
+        if not self.user_id:
+            raise PydanticCustomError("entity_id_missing", "Need entity_id to connect with the tool", {})
+
+        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,
+            )
+
+        if connection_request.connectionStatus == ComposioStatus.FAILED.value:
+            self._logger.log(level="error", message="Connection to composio failed.", color="red")
+            raise PydanticCustomError("connection_failed", "Connection to composio has failed", {})
+
+
+        connected_account = self.toolset.get_connected_account(id=connection_request.connectedAccountId)
+        # Note: connected_account.id === connection_request.connectedAccountId === self.connected_account_id
+
+        if connected_account.status == ComposioStatus.ACTIVE.value:
+            setattr(self.toolset, "entity_id", self.user_id)
+            self.connected_account_id = connection_request.connectedAccountId
+
+        elif connected_account.status == ComposioStatus.INITIATED.value:
+            setattr(self.toolset, "entity_id", self.user_id)
+            self.connected_account_id = connection_request.connectedAccountId
+
+            if connection_request.redirectUrl:
+                import webbrowser
+                webbrowser.open(connection_request.redirectUrl)
+
+        else:
+            self._logger.log(level="error", message="The account is invalid.", color="red")
+            raise PydanticCustomError("connection_failed", "Connection to composio has failed", {})
+
+        return self, connected_account.status if connected_account else connection_request.connectionStatus
+
+
+    def execute_composio_action_with_langchain(self, action_name: str | ComposioAction, task_in_natural_language: str) -> Tuple[Self, str]:
+        """
+        Execute Composio's Action using Langchain's agent ecosystem.
+        """
+        from langchain import hub
+        from langchain_openai import ChatOpenAI
+        from langchain.agents import create_openai_functions_agent, AgentExecutor
+        from composio_langchain import Action
+
+        action_name = action_name.value if isinstance(action_name, ComposioAction) else action_name
+        action = Action(action_name)
+        metadata = { action:  { "OPENAI_API_KEY": OPENAI_API_KEY } }
+        toolset = self._setup_langchain_toolset(metadata=metadata)
+        tools = toolset.get_tools(actions=[action_name,], entity_id=self.user_id)
+        if not tools:
+            self._logger.log(level="error", message=f"Tools related to {action_name} are not found on Langchain", color="red")
+            raise PydanticCustomError("tool_not_found", "Tools not found on Langchain", {})
+
+        self.tools = tools
+        llm = ChatOpenAI()
+        prompt = hub.pull("hwchase17/openai-functions-agent")
+        agent = create_openai_functions_agent(llm, tools, prompt)
+        agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
+        result = agent_executor.invoke(dict(input=task_in_natural_language))
+        return self, result["output"]
+
+
+    @property
+    def toolset(self) -> ComposioToolSet:
+        return ComposioToolSet(api_key=os.environ.get("COMPOSIO_API_KEY"))
+
+
+    def __name__(self):
+        return self.app_name

versionhq/tool/model.py

@@ -41,18 +41,22 @@ 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
-    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",
-    )
+    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:
+        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
 
 
@@ -119,33 +123,40 @@ class Tool(BaseTool):
 
     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:
-            return self.function(*args, **kwargs)
+            result = self.function(*args, **kwargs)
 
-        result = None
-        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)
+        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)
 
-        if self.tool_handler:
-            if self.tool_handler.has_called_before(tool_called):
-                self.tool_handler.error = "Agent execution error"
+            if self.tool_handler:
+                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)
-                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.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
 
-        else:
-            tool_handler = ToolHandler(last_used_tool=tool_called, cache_handler=CacheHandler())
-            self.tool_handler = tool_handler
-            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_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
+
+
+        if self.should_cache is True:
+            self.tool_handler.record_last_tool_used(tool_set, result, self.should_cache)
 
         return result
 

versionhq/tool/tool_handler.py

@@ -13,33 +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
+        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
 
-        from versionhq.tool.model import CacheTool
         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.kwargs == self.last_used_tool.kwargs))
+        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.1.dist-info → versionhq-1.1.9.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: versionhq
-Version: 1.1.9.1
+Version: 1.1.9.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
@@ -52,12 +52,15 @@ Requires-Dist: setuptools>=75.6.0
 Requires-Dist: wheel>=0.45.1
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: appdirs>=1.4.4
+Requires-Dist: langchain>=0.3.14
+Requires-Dist: langchain-openai>=0.2.14
+Requires-Dist: composio-langchain>=0.6.12
 
 # Overview
 
 ![MIT license](https://img.shields.io/badge/License-MIT-green)
 [![Publisher](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml/badge.svg)](https://github.com/versionHQ/multi-agent-system/actions/workflows/publish.yml)
-![PyPI](https://img.shields.io/badge/PyPI-v1.1.7.9-blue)
+![PyPI](https://img.shields.io/badge/PyPI-v1.1.9.3-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)
 

{versionhq-1.1.9.1.dist-info → versionhq-1.1.9.3.dist-info}/RECORD

@@ -1,24 +1,24 @@
-versionhq/__init__.py,sha256=HIOFr73z0KeJs9qFVvW1DjRFj7JyiJcRGGxylbQT_bQ,931
+versionhq/__init__.py,sha256=-0hi_ADxpAQM8is-cYDuL5N9F3c4CsqGFYC5txzYx0U,950
 versionhq/_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/_utils/cache_handler.py,sha256=3-lw_5ZMWC8hnPAkSQULJ2V1FvZZ-wg9mQaUJGSOjI8,403
 versionhq/_utils/i18n.py,sha256=TwA_PnYfDLA6VqlUDPuybdV9lgi3Frh_ASsb_X8jJo8,1483
-versionhq/_utils/logger.py,sha256=lqRYH45KHMQ4mwE1woa5xNmngYu4O749AYECsnWWpmA,1851
+versionhq/_utils/logger.py,sha256=cPxDz1YrMH4ZsLzLc11XrKBfQbLWNNXRUEVUgjAeeOE,1591
 versionhq/_utils/process_config.py,sha256=UqoWD5IR4VLxEDGxIyVUylw_ppXwk8Wx1ynVuD-pUSg,822
 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=8QtZfbeys9cCujc4whKfXdoP0aQKMuvL2qN8WQmugew,19152
+versionhq/agent/model.py,sha256=c5beL2iGx7Zpxla59JJPQPUjpBa3hJdeVqspYGsHTm8,18731
 versionhq/agent/parser.py,sha256=Z_swUPO3piJQuYU8oVYwXWeR2zjmNb4PxbXZeR-GlIg,4694
 versionhq/agent/TEMPLATES/Backstory.py,sha256=cdngBx1GEv7nroR46FEhnysnBJ9mEVL763_9np6Skkc,395
 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=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/clients/customer/model.py,sha256=ruxqSvjBHrSJnNq9Jj5Ko1CW6l8RLiPzhbC_F7tbOnM,1670
+versionhq/clients/customer/__init__.py,sha256=rVcesoCFFl46job8Ppf8tRpEWy8A4ArRElfVjWykcRo,81
+versionhq/clients/customer/model.py,sha256=Dl2dzo2FUdzqPEgoymeImM18InOmIhytmxAkjTiK_M8,2119
 versionhq/clients/product/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/clients/product/model.py,sha256=HxiSv8zq5L0H210jXWfjX_Yg1oyWhi2YASR68JEtmDY,2408
+versionhq/clients/product/model.py,sha256=N8_Oe7W20yYQuJ66owbLD_zNyiSSrYA7i7WI50UuKyQ,2228
 versionhq/clients/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-versionhq/clients/workflow/model.py,sha256=LPet39sK7vUpBQ1mymdNX1xUPseGWv_5W7je_7sif_M,5883
+versionhq/clients/workflow/model.py,sha256=ss-kXclc6ZRBjY4tGqAStIhEKezkBANR17n0yJNn8Ow,5717
 versionhq/llm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/llm/llm_vars.py,sha256=YZoXqFBW7XpclUZ14_AAz7WOjoyCXnGcI959GSpX2q0,5343
 versionhq/llm/model.py,sha256=mXzSuf1s6MebGT7_yqgNppde0NIlAF8bjIXAp2MZ9Uw,8247
@@ -31,13 +31,13 @@ versionhq/task/model.py,sha256=EbgYHLNq8l1zfRDnF-yEcuSZ0aNvzbRmHYgfVyJq84c,19910
 versionhq/team/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 versionhq/team/model.py,sha256=E52OUVzUtvR--51SFRJos3JdYKri1t2jbvvzoOvShQc,20181
 versionhq/team/team_planner.py,sha256=uzX2yed7A7gNSs6qH5jIq2zXMVF5BwQQ4HPATsB9DSQ,3675
-versionhq/tool/__init__.py,sha256=oU2Y84b7vywWq1xmFaBdXdH8Y9lGv7dmk2LEcj4dL-s,1692
-versionhq/tool/composio.py,sha256=e-Vfr-eFm0ipiOerB_zAC1Sl90A39OD_k4QqgszWXWQ,5779
+versionhq/tool/__init__.py,sha256=FvBuEXsOQUYnN7RTFxT20kAkiEYkxWKkiVtgpqOzKZQ,1843
+versionhq/tool/composio_tool.py,sha256=BJqaA1NhV0BT9AdY7OLCGpsAI3VEuCKnOS6D9vuU4zQ,8630
 versionhq/tool/decorator.py,sha256=W_WjzZy8y43AoiFjHLPUQfNipmpOPe-wQknCWloPwmY,1195
-versionhq/tool/model.py,sha256=8A1x8gEdTuP5teUf6o3VqJhrPI5m-XBoBXxgHiWCKcI,7499
-versionhq/tool/tool_handler.py,sha256=rmm8snegwug4jl0Sbi_CteFajkbPAZ5koTQWDMwcIrQ,1510
-versionhq-1.1.9.1.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
-versionhq-1.1.9.1.dist-info/METADATA,sha256=-mFMCnD5q2XGVgaNyE8ddBpX8tgAR4sqlJ-Cmm0hBQA,15955
-versionhq-1.1.9.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-versionhq-1.1.9.1.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
-versionhq-1.1.9.1.dist-info/RECORD,,
+versionhq/tool/model.py,sha256=cWfLQVjNkag5cYYqhABBK7-jcpl0UJQWuhDciG3MtPQ,8116
+versionhq/tool/tool_handler.py,sha256=A3zUkZkx4JEpFHI2uBkHDpzWfADw-bCYUQhgm6rpITM,1569
+versionhq-1.1.9.3.dist-info/LICENSE,sha256=7CCXuMrAjPVsUvZrsBq9DsxI2rLDUSYXR_qj4yO_ZII,1077
+versionhq-1.1.9.3.dist-info/METADATA,sha256=MiNTSV--oEyOAWcxDsqOMRvI37Ys8dmIuzI6gSg3p1s,16070
+versionhq-1.1.9.3.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+versionhq-1.1.9.3.dist-info/top_level.txt,sha256=DClQwxDWqIUGeRJkA8vBlgeNsYZs4_nJWMonzFt5Wj0,10
+versionhq-1.1.9.3.dist-info/RECORD,,

{versionhq-1.1.9.1.dist-info → versionhq-1.1.9.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (75.7.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

versionhq/tool/composio.py

@@ -1,149 +0,0 @@
-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