Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.
TypeScript agentic-aiagentsaiai-agentsaiagentsdeveloper-toolsfunction-callinggpt-4javascriptjsllmllmopsmcppythonremote-mcp-serverssetypescript
Fix python sdk type issues (#1949)
Musthaq Ahamadb750b06c6055
diff --git a/.github/workflows/py.test.yml b/.github/workflows/py.test.ymlnew file mode 100644index 000000000..fd29f5bb1--- /dev/null+++ b/.github/workflows/py.test.yml@@ -0,0 +1,172 @@+name: Test Python SDK++on:+ push:+ branches: [main, next]+ paths:+ - "python/**/*.py"+ - ".github/workflows/py.test.yml"+ - "python/pyproject.toml"+ - "python/requirements*.txt"+ pull_request:+ branches: [main, next]+ paths:+ - "python/**/*.py"+ - ".github/workflows/py.test.yml"+ - "python/pyproject.toml"+ - "python/requirements*.txt"++jobs:+ test:+ name: Test Python SDK+ runs-on: ubuntu-latest+ strategy:+ matrix:+ python-version: ["3.10", "3.11", "3.12"]++ steps:+ - name: Checkout Code+ uses: actions/checkout@v4++ - name: Set up Python ${{ matrix.python-version }}+ uses: actions/setup-python@v5+ with:+ python-version: ${{ matrix.python-version }}++ - name: Cache pip dependencies+ uses: actions/cache@v4+ with:+ path: ~/.cache/pip+ key: pip-${{ matrix.python-version }}-${{ hashFiles('python/pyproject.toml') }}+ restore-keys: |+ pip-${{ matrix.python-version }}-++ - name: Install UV+ run: pip install uv++ - name: Install Dependencies+ run: |+ cd python/+ uv venv --python ${{ matrix.python-version }}+ source .venv/bin/activate+ uv pip install -e .+ uv pip install pytest pytest-mock++ - name: Run Import Tests+ run: |+ cd python/+ source .venv/bin/activate+ python -c "from composio import Composio; print('✓ Basic import successful')"++ - name: Run Unit Tests+ run: |+ cd python/+ source .venv/bin/activate+ python -m pytest tests/ -v --tb=short++ - name: Test Package Installation+ run: |+ cd python/+ # Test that the package can be installed and imported in a fresh environment+ uv venv test-env --python ${{ matrix.python-version }}+ source test-env/bin/activate+ uv pip install -e .+ python -c "+ from composio import Composio, ToolkitVersionParam+ from composio.types import Modifiers+ from composio.core.types import ToolkitVersion+ print('✓ All critical imports successful')+ "++ test-circular-imports:+ name: Test Circular Import Prevention+ runs-on: ubuntu-latest++ steps:+ - name: Checkout Code+ uses: actions/checkout@v4++ - name: Set up Python+ uses: actions/setup-python@v5+ with:+ python-version: "3.11"++ - name: Install UV+ run: pip install uv++ - name: Install Dependencies+ run: |+ cd python/+ uv venv --python 3.11+ source .venv/bin/activate+ uv pip install -e .++ - name: Test Circular Import Prevention+ run: |+ cd python/+ source .venv/bin/activate+ python -c "+ # Test various import combinations that previously caused circular imports+ import sys++ # Test 1: Basic imports+ from composio import Composio+ print('✓ Basic Composio import')++ # Test 2: Import toolkit version types+ from composio import ToolkitVersionParam+ from composio.core.types import ToolkitVersion+ print('✓ Toolkit version types import')++ # Test 3: Import from types module+ from composio.types import Modifiers+ print('✓ Types module import')++ # Test 4: Import core models+ from composio.core.models.tools import Tools+ print('✓ Core models import')++ # Test 5: Cross-module imports that caused the original circular import+ from composio.core.models.tools import Modifiers as CoreModifiers+ from composio.types import Modifiers as TypesModifiers+ assert CoreModifiers is TypesModifiers+ print('✓ Cross-module import consistency')++ print('✓ All circular import prevention tests passed!')+ "++ lint-and-format:+ name: Lint and Format Check+ runs-on: ubuntu-latest++ steps:+ - name: Checkout Code+ uses: actions/checkout@v4++ - name: Set up Python+ uses: actions/setup-python@v5+ with:+ python-version: "3.11"++ - name: Install UV+ run: pip install uv++ - name: Install Dependencies+ run: |+ cd python/+ uv venv --python 3.11+ source .venv/bin/activate+ uv pip install -e .+ uv pip install ruff++ - name: Run Ruff Linter+ run: |+ cd python/+ source .venv/bin/activate+ ruff check --config config/ruff.toml composio/ tests/++ - name: Run Ruff Formatter Check+ run: |+ cd python/+ source .venv/bin/activate+ ruff format --check --config config/ruff.toml composio/ tests/diff --git a/python/composio/__init__.py b/python/composio/__init__.pyindex d05c59572..033f38717 100644--- a/python/composio/__init__.py+++ b/python/composio/__init__.py@@ -4,13 +4,13 @@ from .core.models.tools import (before_execute,schema_modifier,)-from .sdk import Composio-from .types import (+from .core.types import (ToolkitLatestVersion,ToolkitVersion,ToolkitVersionParam,ToolkitVersions,)+from .sdk import Composio__all__ = ("Composio",diff --git a/python/composio/core/models/connected_accounts.py b/python/composio/core/models/connected_accounts.pyindex 1018ea93c..a8937e3a1 100644--- a/python/composio/core/models/connected_accounts.py+++ b/python/composio/core/models/connected_accounts.py@@ -351,7 +351,7 @@ class ConnectedAccounts:redirect_url=getattr(response.connection_data.val, "redirect_url", None),client=self._client,)-+def link(self,user_id: str,@@ -361,33 +361,33 @@ class ConnectedAccounts:) -> ConnectionRequest:"""Create a Composio Connect Link for a user to connect their account to a given auth config.-+This method will return an external link which you can use for the user to connect their account.:param user_id: The external user ID to create the connected account for.:param auth_config_id: The auth config ID to create the connected account for.:param callback_url: The URL to redirect the user to post connecting their account.:return: Connection request object.-+Example:# Create a connection request and redirect the user to the redirect urlconnection_request = composio.connected_accounts.link('user_123', 'auth_config_123')redirect_url = connection_request.redirect_urlprint(f"Visit: {redirect_url} to authenticate your account")-+# Wait for the connection to be establishedconnected_account = connection_request.wait_for_connection()-+Example with callback URL:# Create a connection request with callback URLconnection_request = composio.connected_accounts.link(- 'user_123',+ 'user_123','auth_config_123',callback_url='https://your-app.com/callback')redirect_url = connection_request.redirect_urlprint(f"Visit: {redirect_url} to authenticate your account")-+# Wait for the connection to be establishedconnected_account = composio.connected_accounts.wait_for_connection(connection_request.id)"""@@ -396,14 +396,14 @@ class ConnectedAccounts:"auth_config_id": auth_config_id,"user_id": user_id,}-+# Add callback_url only if providedif callback_url is not None:payload["callback_url"] = callback_url-+# Call the link creation endpointresponse = self._client.link.create(**payload)-+return ConnectionRequest(id=response.connected_account_id,status="INITIATED",diff --git a/python/composio/core/models/tools.py b/python/composio/core/models/tools.pyindex 4b91c6c28..5dca05d42 100644--- a/python/composio/core/models/tools.py+++ b/python/composio/core/models/tools.py@@ -23,8 +23,8 @@ from composio.core.provider.none_agentic import (NonAgenticProvider,NoneAgenticProviderExecuteFn,)+from composio.core.types import ToolkitVersionParamfrom composio.exceptions import InvalidParams, NotFoundError-from composio.types import ToolkitVersionParamfrom composio.utils.toolkit_version import get_toolkit_versionfrom ._modifiers import (@@ -72,7 +72,7 @@ class Tools(Resource, t.Generic[TProvider]):self._custom_tools = CustomTools(client)self._tool_schemas: t.Dict[str, Tool] = {}self._file_helper = FileHelper(client=self._client, outdir=file_download_dir)- self._toolkit_versions = toolkit_versions or "latest"+ self._toolkit_versions = toolkit_versionsself.custom_tool = self._custom_tools.registerself.provider = provider@@ -338,6 +338,15 @@ class Tools(Resource, t.Generic[TProvider]):toolkit_versions: t.Optional[ToolkitVersionParam] = None,) -> ToolExecutionResponse:"""Execute a tool"""+ # Get the tool to determine its toolkit+ tool = self.get_raw_composio_tool_by_slug(slug)++ # If version is not explicitly provided, resolve it from toolkit versions+ # This matches the TypeScript behavior+ if version is None and toolkit_versions is not None:+ toolkit_slug = tool.toolkit.slug if tool.toolkit else "unknown"+ version = get_toolkit_version(toolkit_slug, toolkit_versions)+return t.cast(ToolExecutionResponse,self._client.tools.execute(@@ -361,9 +370,7 @@ class Tools(Resource, t.Generic[TProvider]):user_id=user_id if user_id is not None else self._client.not_given,text=text if text is not None else self._client.not_given,version=version if version is not None else self._client.not_given,- toolkit_versions=toolkit_versions- if toolkit_versions is not None- else self._client.not_given,+ # Note: We don't pass toolkit_versions to the API, we resolve the specific version above).model_dump(exclude={"log_id",diff --git a/python/composio/core/types.py b/python/composio/core/types.pynew file mode 100644index 000000000..d6adc8e78--- /dev/null+++ b/python/composio/core/types.py@@ -0,0 +1,20 @@+"""Core types for Composio SDK."""++import typing as t++import typing_extensions as te++# Tool versioning types+ToolkitLatestVersion = te.Literal["latest"]+ToolkitVersion = str # Can be "latest" or any version string like "20250906_01"+ToolkitVersions = t.Dict[str, ToolkitVersion]+ToolkitVersionParam = t.Union[+ str, ToolkitVersions, None+] # String can be any global version++__all__ = [+ "ToolkitLatestVersion",+ "ToolkitVersion",+ "ToolkitVersions",+ "ToolkitVersionParam",+]diff --git a/python/composio/sdk.py b/python/composio/sdk.pyindex f89a01c3f..41ddd243d 100644--- a/python/composio/sdk.py+++ b/python/composio/sdk.py@@ -17,7 +17,7 @@ from composio.core.models import (from composio.core.models.base import allow_trackingfrom composio.core.provider import TProviderfrom composio.core.provider._openai import OpenAIProvider-from composio.types import ToolkitVersionParam+from composio.core.types import ToolkitVersionParamfrom composio.utils.logging import WithLoggerfrom composio.utils.toolkit_version import get_toolkit_versions@@ -66,7 +66,7 @@ class Composio(t.Generic[TProvider], WithLogger):if not api_key:raise exceptions.ApiKeyNotProvidedError()- # Process toolkit versions+ # Process toolkit versions with environment variable supporttoolkit_versions = get_toolkit_versions(kwargs.get("toolkit_versions"))allow_tracking.set(kwargs.get("allow_tracking", True))diff --git a/python/composio/types.py b/python/composio/types.pyindex 977c493c1..2a654e5d2 100644--- a/python/composio/types.py+++ b/python/composio/types.py@@ -1,7 +1,3 @@-import typing as t--import typing_extensions as te-from composio.client.types import Toolfrom composio.core.models.connected_accounts import auth_schemefrom composio.core.models.custom_tools import ExecuteRequestFn@@ -12,14 +8,12 @@ from composio.core.models.tools import ()from composio.core.models.triggers import TriggerEventfrom composio.core.provider.base import TTool, TToolCollection--# Tool versioning types-ToolkitLatestVersion = te.Literal["latest"]-ToolkitVersion = str # Can be "latest" or any version string like "20250906_01"-ToolkitVersions = t.Dict[str, ToolkitVersion]-ToolkitVersionParam = t.Union[- str, ToolkitVersions, None-] # String can be any global version+from composio.core.types import (+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+)__all__ = [# Existing typesdiff --git a/python/composio/utils/toolkit_version.py b/python/composio/utils/toolkit_version.pyindex 989da8557..06e92f604 100644--- a/python/composio/utils/toolkit_version.py+++ b/python/composio/utils/toolkit_version.py@@ -5,7 +5,7 @@ Utilities for handling toolkit versions.import osimport typing as t-from composio.types import ToolkitVersion, ToolkitVersionParam, ToolkitVersions+from composio.core.types import ToolkitVersion, ToolkitVersionParam, ToolkitVersionsdef get_toolkit_version(diff --git a/python/providers/anthropic/pyproject.toml b/python/providers/anthropic/pyproject.tomlindex 596456b49..5a3353e08 100644--- a/python/providers/anthropic/pyproject.toml+++ b/python/providers/anthropic/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-anthropic"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your Anthropic LLMs."readme = "README.md"requires-python = ">=3.10,<4"diff --git a/python/providers/anthropic/setup.py b/python/providers/anthropic/setup.pyindex 853a43d60..e64b64c27 100644--- a/python/providers/anthropic/setup.py+++ b/python/providers/anthropic/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_anthropic",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your Anthropic LLMs.",diff --git a/python/providers/autogen/pyproject.toml b/python/providers/autogen/pyproject.tomlindex 5d9544bb9..4b6f344cf 100644--- a/python/providers/autogen/pyproject.toml+++ b/python/providers/autogen/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-autogen"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your autogen agent."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/autogen/setup.py b/python/providers/autogen/setup.pyindex 53b47a6c2..67595354d 100644--- a/python/providers/autogen/setup.py+++ b/python/providers/autogen/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_autogen",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your Autogen agent.",diff --git a/python/providers/crewai/pyproject.toml b/python/providers/crewai/pyproject.tomlindex 176f96214..d496b9dbc 100644--- a/python/providers/crewai/pyproject.toml+++ b/python/providers/crewai/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-crewai"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your CrewAI agent."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/crewai/setup.py b/python/providers/crewai/setup.pyindex d30c3bbed..08bb3b771 100644--- a/python/providers/crewai/setup.py+++ b/python/providers/crewai/setup.py@@ -6,7 +6,7 @@ from setuptools import setupsetup(name="composio_crewai",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your CrewAI agent.",diff --git a/python/providers/gemini/pyproject.toml b/python/providers/gemini/pyproject.tomlindex 0883ea807..ad3e130c6 100644--- a/python/providers/gemini/pyproject.toml+++ b/python/providers/gemini/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-gemini"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your Gemini agent."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/gemini/setup.py b/python/providers/gemini/setup.pyindex aea9a448d..f847dd90f 100644--- a/python/providers/gemini/setup.py+++ b/python/providers/gemini/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_gemini",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your Gemini agent.",diff --git a/python/providers/google/pyproject.toml b/python/providers/google/pyproject.tomlindex cb7f44e30..99cde4f2c 100644--- a/python/providers/google/pyproject.toml+++ b/python/providers/google/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-google"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your Google AI Python Gemini model."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/google/setup.py b/python/providers/google/setup.pyindex 43c67d511..0e57bd58c 100644--- a/python/providers/google/setup.py+++ b/python/providers/google/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_google",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your Google AI Python Gemini model.",diff --git a/python/providers/google_adk/pyproject.toml b/python/providers/google_adk/pyproject.tomlindex ed108d8c3..f3b1e90f5 100644--- a/python/providers/google_adk/pyproject.toml+++ b/python/providers/google_adk/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-google-adk"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your Google AI Python Gemini model."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/google_adk/setup.py b/python/providers/google_adk/setup.pyindex 90bced3b9..c9b7aaf65 100644--- a/python/providers/google_adk/setup.py+++ b/python/providers/google_adk/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_google_adk",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your Google AI Python Gemini model.",diff --git a/python/providers/langchain/pyproject.toml b/python/providers/langchain/pyproject.tomlindex 862d8f39d..6cd6451b7 100644--- a/python/providers/langchain/pyproject.toml+++ b/python/providers/langchain/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-langchain"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your Langchain agent."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/langchain/setup.py b/python/providers/langchain/setup.pyindex cb20142a9..3e62f744a 100644--- a/python/providers/langchain/setup.py+++ b/python/providers/langchain/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_langchain",- version="0.8.11",+ version="0.8.12",author="composio",author_email="[email protected]",description="Use Composio to get an array of tools with your Langchain agent.",diff --git a/python/providers/langgraph/pyproject.toml b/python/providers/langgraph/pyproject.tomlindex 87a35be14..86bd4c1f9 100644--- a/python/providers/langgraph/pyproject.toml+++ b/python/providers/langgraph/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-langgraph"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get array of tools with LangGraph Agent Workflows."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/langgraph/setup.py b/python/providers/langgraph/setup.pyindex 8178239c1..9326c9a1d 100644--- a/python/providers/langgraph/setup.py+++ b/python/providers/langgraph/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_langgraph",- version="0.8.11",+ version="0.8.12",author="composio",author_email="[email protected]",description="Use Composio to get array of tools with LangGraph Agent Workflows",diff --git a/python/providers/llamaindex/pyproject.toml b/python/providers/llamaindex/pyproject.tomlindex d700dc131..a868ff680 100644--- a/python/providers/llamaindex/pyproject.toml+++ b/python/providers/llamaindex/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-llamaindex"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get array of tools with LlamaIndex Agent Workflows."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/llamaindex/setup.py b/python/providers/llamaindex/setup.pyindex 83b7e87df..917338283 100644--- a/python/providers/llamaindex/setup.py+++ b/python/providers/llamaindex/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_llamaindex",- version="0.8.11",+ version="0.8.12",author="composio",author_email="[email protected]",description="Use Composio to get array of tools with LlamaIndex Agent Workflows",diff --git a/python/providers/openai/pyproject.toml b/python/providers/openai/pyproject.tomlindex e1170524a..f494ee801 100644--- a/python/providers/openai/pyproject.toml+++ b/python/providers/openai/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-openai"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get an array of tools with your OpenAI Function Call."readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/openai/setup.py b/python/providers/openai/setup.pyindex 62698e2dc..40c97b427 100644--- a/python/providers/openai/setup.py+++ b/python/providers/openai/setup.py@@ -8,7 +8,7 @@ from setuptools import setupsetup(name="composio_openai",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get an array of tools with your OpenAI Function Call.",diff --git a/python/providers/openai_agents/pyproject.toml b/python/providers/openai_agents/pyproject.tomlindex 4fe64e0cb..8ea1fb191 100644--- a/python/providers/openai_agents/pyproject.toml+++ b/python/providers/openai_agents/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio-openai-agents"-version = "0.8.11"+version = "0.8.12"description = "Use Composio to get array of strongly typed tools for OpenAI Agents"readme = "README.md"requires-python = ">=3.9,<4"diff --git a/python/providers/openai_agents/setup.py b/python/providers/openai_agents/setup.pyindex e06c53561..a4b4806ef 100644--- a/python/providers/openai_agents/setup.py+++ b/python/providers/openai_agents/setup.py@@ -8,7 +8,7 @@ from setuptools import find_packages, setupsetup(name="composio_openai_agents",- version="0.8.11",+ version="0.8.12",author="Composio",author_email="[email protected]",description="Use Composio to get array of strongly typed tools for OpenAI Agents",diff --git a/python/pyproject.toml b/python/pyproject.tomlindex 49988e623..8fdbd0637 100644--- a/python/pyproject.toml+++ b/python/pyproject.toml@@ -1,6 +1,6 @@[project]name = "composio"-version = "0.8.13"+version = "0.8.14"description = "SDK for integrating Composio with your applications."readme = "README.md"requires-python = ">=3.10,<4"diff --git a/python/tests/test_core_types.py b/python/tests/test_core_types.pynew file mode 100644index 000000000..0827d167c--- /dev/null+++ b/python/tests/test_core_types.py@@ -0,0 +1,120 @@+"""Test core types module."""++from composio.core.types import (+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+)+++class TestCoreTypes:+ """Test cases for core types."""++ def test_toolkit_latest_version_literal(self):+ """Test ToolkitLatestVersion is a literal type."""+ # Should be a Literal["latest"]+ assert hasattr(ToolkitLatestVersion, "__origin__")++ def test_toolkit_version_is_string(self):+ """Test ToolkitVersion is string type."""+ assert ToolkitVersion is str++ def test_toolkit_versions_is_dict(self):+ """Test ToolkitVersions is dict type."""+ # Should be Dict[str, ToolkitVersion]+ assert hasattr(ToolkitVersions, "__origin__")+ assert ToolkitVersions.__origin__ is dict++ def test_toolkit_version_param_is_union(self):+ """Test ToolkitVersionParam is union type."""+ # Should be Union[str, ToolkitVersions, None]+ assert hasattr(ToolkitVersionParam, "__origin__")++ def test_toolkit_version_param_accepts_string(self):+ """Test ToolkitVersionParam accepts string."""+ version: ToolkitVersionParam = "latest"+ assert version == "latest"++ version = "v1.0.0"+ assert version == "v1.0.0"++ def test_toolkit_version_param_accepts_dict(self):+ """Test ToolkitVersionParam accepts dictionary."""+ version: ToolkitVersionParam = {"github": "v1.0.0", "slack": "latest"}+ assert isinstance(version, dict)+ assert version["github"] == "v1.0.0"+ assert version["slack"] == "latest"++ def test_toolkit_version_param_accepts_none(self):+ """Test ToolkitVersionParam accepts None."""+ version: ToolkitVersionParam = None+ assert version is None++ def test_all_types_exported(self):+ """Test that all types are properly exported."""+ from composio.core.types import __all__++ expected_exports = {+ "ToolkitLatestVersion",+ "ToolkitVersion",+ "ToolkitVersions",+ "ToolkitVersionParam",+ }++ assert set(__all__) == expected_exports++ def test_types_importable_from_main_package(self):+ """Test that types are importable from main package."""+ from composio import (+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+ )++ # Should be the same objects+ from composio.core.types import (+ ToolkitLatestVersion as CoreToolkitLatestVersion,+ )+ from composio.core.types import (+ ToolkitVersion as CoreToolkitVersion,+ )+ from composio.core.types import (+ ToolkitVersionParam as CoreToolkitVersionParam,+ )+ from composio.core.types import (+ ToolkitVersions as CoreToolkitVersions,+ )++ assert ToolkitLatestVersion is CoreToolkitLatestVersion+ assert ToolkitVersion is CoreToolkitVersion+ assert ToolkitVersionParam is CoreToolkitVersionParam+ assert ToolkitVersions is CoreToolkitVersions++ def test_types_importable_from_types_module(self):+ """Test that types are importable from types module."""+ # Should be the same objects as core types+ from composio.core.types import (+ ToolkitLatestVersion as CoreToolkitLatestVersion,+ )+ from composio.core.types import (+ ToolkitVersion as CoreToolkitVersion,+ )+ from composio.core.types import (+ ToolkitVersionParam as CoreToolkitVersionParam,+ )+ from composio.core.types import (+ ToolkitVersions as CoreToolkitVersions,+ )+ from composio.types import (+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+ )++ assert ToolkitLatestVersion is CoreToolkitLatestVersion+ assert ToolkitVersion is CoreToolkitVersion+ assert ToolkitVersionParam is CoreToolkitVersionParam+ assert ToolkitVersions is CoreToolkitVersionsdiff --git a/python/tests/test_imports.py b/python/tests/test_imports.pynew file mode 100644index 000000000..b60ada9ee--- /dev/null+++ b/python/tests/test_imports.py@@ -0,0 +1,130 @@+"""Test imports to ensure no circular import issues."""++import pytest+++def test_basic_import():+ """Test basic import of Composio class."""+ from composio import Composio++ assert Composio is not None+++def test_import_all_public_exports():+ """Test importing all public exports from composio package."""+ from composio import (+ Composio,+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+ __version__,+ after_execute,+ before_execute,+ schema_modifier,+ )++ assert Composio is not None+ assert after_execute is not None+ assert before_execute is not None+ assert schema_modifier is not None+ assert ToolkitLatestVersion is not None+ assert ToolkitVersion is not None+ assert ToolkitVersionParam is not None+ assert ToolkitVersions is not None+ assert __version__ is not None+++def test_import_types():+ """Test importing types from different modules."""+ from composio.types import (+ ExecuteRequestFn,+ Modifiers,+ Tool,+ ToolExecuteParams,+ ToolExecutionResponse,+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+ TriggerEvent,+ TTool,+ TToolCollection,+ auth_scheme,+ )++ assert Tool is not None+ assert TTool is not None+ assert TToolCollection is not None+ assert ToolExecuteParams is not None+ assert ToolExecutionResponse is not None+ assert ExecuteRequestFn is not None+ assert TriggerEvent is not None+ assert Modifiers is not None+ assert auth_scheme is not None+ assert ToolkitLatestVersion is not None+ assert ToolkitVersion is not None+ assert ToolkitVersions is not None+ assert ToolkitVersionParam is not None+++def test_import_core_types():+ """Test importing core types directly."""+ from composio.core.types import (+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersionParam,+ ToolkitVersions,+ )++ assert ToolkitLatestVersion is not None+ assert ToolkitVersion is not None+ assert ToolkitVersions is not None+ assert ToolkitVersionParam is not None+++def test_import_core_models():+ """Test importing core models."""+ from composio.core.models import (+ AuthConfigs,+ ConnectedAccounts,+ Toolkits,+ Tools,+ Triggers,+ )++ assert AuthConfigs is not None+ assert ConnectedAccounts is not None+ assert Toolkits is not None+ assert Tools is not None+ assert Triggers is not None+++def test_import_sdk():+ """Test importing SDK directly."""+ from composio.sdk import Composio++ assert Composio is not None+++def test_import_exceptions():+ """Test importing exceptions."""+ from composio import exceptions++ assert exceptions is not None+ assert hasattr(exceptions, "ApiKeyNotProvidedError")+++def test_circular_import_prevention():+ """Test that circular imports are prevented."""+ # This test passes if no ImportError is raised during import+ try:+ from composio import Composio # noqa: F401+ from composio.core.models.tools import Tools # noqa: F401+ from composio.core.types import ToolkitVersion # noqa: F401+ from composio.types import ToolkitVersionParam # noqa: F401++ # If we get here, no circular import occurred+ assert True+ except ImportError as e:+ pytest.fail(f"Circular import detected: {e}")diff --git a/python/tests/test_sdk.py b/python/tests/test_sdk.pynew file mode 100644index 000000000..fdaac40d2--- /dev/null+++ b/python/tests/test_sdk.py@@ -0,0 +1,207 @@+"""Test SDK functionality."""++import os+from unittest.mock import patch++import pytest++from composio import Composio, exceptions+from composio.core.types import ToolkitVersionParam+++class TestComposioSDK:+ """Test cases for Composio SDK."""++ def test_sdk_requires_api_key(self):+ """Test that SDK requires an API key."""+ with patch.dict(os.environ, {}, clear=True):+ with pytest.raises(exceptions.ApiKeyNotProvidedError):+ Composio()++ def test_sdk_accepts_api_key_from_env(self):+ """Test that SDK accepts API key from environment."""+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "test-key"}):+ with patch("composio.core.models.Tools"):+ with patch("composio.core.models.Toolkits"):+ with patch("composio.core.models.Triggers"):+ with patch("composio.core.models.AuthConfigs"):+ with patch("composio.core.models.ConnectedAccounts"):+ sdk = Composio()+ assert sdk is not None++ def test_sdk_accepts_api_key_as_parameter(self):+ """Test that SDK accepts API key as parameter."""+ with patch("composio.core.models.Tools"):+ with patch("composio.core.models.Toolkits"):+ with patch("composio.core.models.Triggers"):+ with patch("composio.core.models.AuthConfigs"):+ with patch("composio.core.models.ConnectedAccounts"):+ sdk = Composio(api_key="test-key")+ assert sdk is not None++ def test_sdk_config_types(self):+ """Test SDK configuration types."""+ from composio.sdk import SDKConfig++ # Test that SDKConfig is a TypedDict+ assert hasattr(SDKConfig, "__annotations__")++ # Test that all expected fields are present+ expected_fields = {+ "environment",+ "api_key",+ "base_url",+ "timeout",+ "max_retries",+ "allow_tracking",+ "file_download_dir",+ "toolkit_versions",+ }+ assert set(SDKConfig.__annotations__.keys()) == expected_fields++ def test_toolkit_version_param_types(self):+ """Test toolkit version parameter types."""+ from composio.core.types import (+ ToolkitLatestVersion,+ ToolkitVersion,+ ToolkitVersions,+ )++ # Test that types are defined correctly+ assert ToolkitLatestVersion is not None+ assert ToolkitVersion is not None+ assert ToolkitVersions is not None+ assert ToolkitVersionParam is not None++ def test_sdk_has_required_attributes(self):+ """Test that SDK has required attributes after initialization."""+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "test-key"}):+ with patch("composio.core.models.Tools"):+ with patch("composio.core.models.Toolkits"):+ with patch("composio.core.models.Triggers"):+ with patch("composio.core.models.AuthConfigs"):+ with patch("composio.core.models.ConnectedAccounts"):+ sdk = Composio()++ # Check that all required attributes are present+ assert hasattr(sdk, "tools")+ assert hasattr(sdk, "toolkits")+ assert hasattr(sdk, "triggers")+ assert hasattr(sdk, "auth_configs")+ assert hasattr(sdk, "connected_accounts")+ assert hasattr(sdk, "provider")+ assert hasattr(sdk, "client")++ def test_sdk_default_provider(self):+ """Test that SDK uses default provider."""+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "test-key"}):+ with patch("composio.core.models.Tools"):+ with patch("composio.core.models.Toolkits"):+ with patch("composio.core.models.Triggers"):+ with patch("composio.core.models.AuthConfigs"):+ with patch("composio.core.models.ConnectedAccounts"):+ sdk = Composio()++ # Check that provider is set+ assert sdk.provider is not None+ assert hasattr(sdk.provider, "name")++ def test_toolkit_versions_processing(self):+ """Test toolkit versions parameter processing."""+ with patch.dict(os.environ, {"COMPOSIO_API_KEY": "test-key"}):+ with patch("composio.core.models.Tools"):+ with patch("composio.core.models.Toolkits"):+ with patch("composio.core.models.Triggers"):+ with patch("composio.core.models.AuthConfigs"):+ with patch("composio.core.models.ConnectedAccounts"):+ with patch(+ "composio.sdk.get_toolkit_versions"+ ) as mock_get_versions:+ mock_get_versions.return_value = "latest"++ # Test with string version+ Composio(toolkit_versions="v1.0.0")+ mock_get_versions.assert_called_once()++ # Reset mock for next test+ mock_get_versions.reset_mock()++ # Test with dict version+ versions_dict = {+ "github": "v1.0.0",+ "slack": "latest",+ }+ Composio(toolkit_versions=versions_dict)+ mock_get_versions.assert_called_once()++ # Reset mock for next test+ mock_get_versions.reset_mock()++ # Test with None (default)+ Composio()+ mock_get_versions.assert_called_once()++ def test_sdk_env_var_integration(self):+ """Test that SDK properly integrates with environment variables for toolkit versions."""+ with patch.dict(+ os.environ,+ {+ "COMPOSIO_API_KEY": "test-key",+ "COMPOSIO_TOOLKIT_VERSION_GITHUB": "v1.0.0",+ "COMPOSIO_TOOLKIT_VERSION_SLACK": "v2.0.0",+ },+ ):+ with patch("composio.sdk.Tools") as mock_tools_class:+ with patch("composio.sdk.Toolkits"):+ with patch("composio.sdk.Triggers"):+ with patch("composio.sdk.AuthConfigs"):+ with patch("composio.sdk.ConnectedAccounts"):+ # Create SDK instance without explicit toolkit versions+ Composio()++ # Verify that Tools was initialized with processed versions+ mock_tools_class.assert_called_once()+ call_args = mock_tools_class.call_args++ # The toolkit_versions should be a dict from env vars+ toolkit_versions = call_args.kwargs.get(+ "toolkit_versions"+ )+ expected = {"github": "v1.0.0", "slack": "v2.0.0"}+ assert toolkit_versions == expected++ def test_sdk_user_override_env_vars(self):+ """Test that user-provided toolkit versions override environment variables."""+ with patch.dict(+ os.environ,+ {+ "COMPOSIO_API_KEY": "test-key",+ "COMPOSIO_TOOLKIT_VERSION_GITHUB": "env_version",+ "COMPOSIO_TOOLKIT_VERSION_SLACK": "env_slack",+ },+ ):+ with patch("composio.sdk.Tools") as mock_tools_class:+ with patch("composio.sdk.Toolkits"):+ with patch("composio.sdk.Triggers"):+ with patch("composio.sdk.AuthConfigs"):+ with patch("composio.sdk.ConnectedAccounts"):+ # User provides override+ user_versions = {+ "github": "user_override",+ "jira": "user_jira",+ }+ Composio(toolkit_versions=user_versions)++ # Verify Tools was initialized with merged versions+ mock_tools_class.assert_called_once()+ call_args = mock_tools_class.call_args++ toolkit_versions = call_args.kwargs.get(+ "toolkit_versions"+ )+ expected = {+ "github": "user_override", # User override+ "slack": "env_slack", # From env+ "jira": "user_jira", # User provided+ }+ assert toolkit_versions == expecteddiff --git a/python/tests/test_tool_execution.py b/python/tests/test_tool_execution.pynew file mode 100644index 000000000..a3a830bba--- /dev/null+++ b/python/tests/test_tool_execution.py@@ -0,0 +1,293 @@+"""Test tool execution with toolkit versions."""++from unittest.mock import Mock, patch++from composio.client.types import Tool, tool_list_response+from composio.core.models.tools import Tools+++class TestToolExecution:+ """Test cases for tool execution with toolkit versions."""++ def create_mock_tool(self, slug: str, toolkit_slug: str) -> Tool:+ """Create a mock tool for testing."""+ return Tool(+ name=f"Test {slug}",+ slug=slug,+ description="Test tool",+ input_parameters={},+ output_parameters={},+ available_versions=["v1.0.0"],+ version="v1.0.0",+ scopes=[],+ toolkit=tool_list_response.ItemToolkit(+ name=toolkit_slug.title(), slug=toolkit_slug, logo=""+ ),+ deprecated=tool_list_response.ItemDeprecated(+ available_versions=["v1.0.0"],+ displayName=f"Test {slug}",+ version="v1.0.0",+ toolkit=tool_list_response.ItemDeprecatedToolkit(logo=""),+ is_deprecated=False,+ ),+ no_auth=False,+ tags=[],+ )++ def test_tool_execution_uses_toolkit_version(self):+ """Test that tool execution resolves toolkit version correctly."""+ # Mock client and provider+ mock_client = Mock()+ mock_provider = Mock()+ mock_provider.name = "test_provider"++ # Create toolkit versions configuration+ toolkit_versions = {"github": "v2.0.0", "slack": "v1.5.0"}++ # Create Tools instance+ tools = Tools(+ client=mock_client,+ provider=mock_provider,+ toolkit_versions=toolkit_versions,+ )++ # Create a mock GitHub tool+ github_tool = self.create_mock_tool("GITHUB_GET_REPOS", "github")++ # Mock the get_raw_composio_tool_by_slug method+ with patch.object(+ tools, "get_raw_composio_tool_by_slug", return_value=github_tool+ ):+ # Mock the client's execute method+ mock_execute_response = Mock()+ mock_execute_response.model_dump.return_value = {+ "data": {"result": "success"},+ "error": None,+ "successful": True,+ }+ mock_client.tools.execute.return_value = mock_execute_response++ # Execute the tool+ tools._execute_tool(+ slug="GITHUB_GET_REPOS",+ arguments={"owner": "test", "repo": "test"},+ toolkit_versions=toolkit_versions,+ )++ # Verify that the client was called with the resolved version+ mock_client.tools.execute.assert_called_once()+ call_args = mock_client.tools.execute.call_args++ # Should have called with version="v2.0.0" (resolved from github toolkit)+ assert call_args.kwargs["version"] == "v2.0.0"++ def test_tool_execution_with_explicit_version(self):+ """Test that explicit version overrides toolkit version."""+ # Mock client and provider+ mock_client = Mock()+ mock_provider = Mock()+ mock_provider.name = "test_provider"++ # Create toolkit versions configuration+ toolkit_versions = {+ "github": "v2.0.0",+ }++ # Create Tools instance+ tools = Tools(+ client=mock_client,+ provider=mock_provider,+ toolkit_versions=toolkit_versions,+ )++ # Create a mock GitHub tool+ github_tool = self.create_mock_tool("GITHUB_GET_REPOS", "github")++ # Mock the get_raw_composio_tool_by_slug method+ with patch.object(+ tools, "get_raw_composio_tool_by_slug", return_value=github_tool+ ):+ # Mock the client's execute method+ mock_execute_response = Mock()+ mock_execute_response.model_dump.return_value = {+ "data": {"result": "success"},+ "error": None,+ "successful": True,+ }+ mock_client.tools.execute.return_value = mock_execute_response++ # Execute the tool with explicit version+ tools._execute_tool(+ slug="GITHUB_GET_REPOS",+ arguments={"owner": "test", "repo": "test"},+ version="v3.0.0", # Explicit version should take precedence+ toolkit_versions=toolkit_versions,+ )++ # Verify that the client was called with the explicit version+ mock_client.tools.execute.assert_called_once()+ call_args = mock_client.tools.execute.call_args++ # Should have called with explicit version, not resolved from toolkit+ assert call_args.kwargs["version"] == "v3.0.0"++ def test_tool_execution_unknown_toolkit_fallback(self):+ """Test that unknown toolkit falls back to 'latest'."""+ # Mock client and provider+ mock_client = Mock()+ mock_provider = Mock()+ mock_provider.name = "test_provider"++ # Create toolkit versions configuration that doesn't include the tool's toolkit+ toolkit_versions = {+ "slack": "v1.5.0" # No github version specified+ }++ # Create Tools instance+ tools = Tools(+ client=mock_client,+ provider=mock_provider,+ toolkit_versions=toolkit_versions,+ )++ # Create a mock GitHub tool (not in toolkit_versions)+ github_tool = self.create_mock_tool("GITHUB_GET_REPOS", "github")++ # Mock the get_raw_composio_tool_by_slug method+ with patch.object(+ tools, "get_raw_composio_tool_by_slug", return_value=github_tool+ ):+ # Mock the client's execute method+ mock_execute_response = Mock()+ mock_execute_response.model_dump.return_value = {+ "data": {"result": "success"},+ "error": None,+ "successful": True,+ }+ mock_client.tools.execute.return_value = mock_execute_response++ # Execute the tool+ tools._execute_tool(+ slug="GITHUB_GET_REPOS",+ arguments={"owner": "test", "repo": "test"},+ toolkit_versions=toolkit_versions,+ )++ # Verify that the client was called with "latest" (fallback)+ mock_client.tools.execute.assert_called_once()+ call_args = mock_client.tools.execute.call_args++ # Should have called with "latest" since github is not in toolkit_versions+ assert call_args.kwargs["version"] == "latest"++ def test_tool_execution_with_global_version_string(self):+ """Test that global version string is used for all toolkits."""+ # Mock client and provider+ mock_client = Mock()+ mock_provider = Mock()+ mock_provider.name = "test_provider"++ # Create global toolkit version (string)+ toolkit_versions = "v3.0.0"++ # Create Tools instance+ tools = Tools(+ client=mock_client,+ provider=mock_provider,+ toolkit_versions=toolkit_versions,+ )++ # Create a mock GitHub tool+ github_tool = self.create_mock_tool("GITHUB_GET_REPOS", "github")++ # Mock the get_raw_composio_tool_by_slug method+ with patch.object(+ tools, "get_raw_composio_tool_by_slug", return_value=github_tool+ ):+ # Mock the client's execute method+ mock_execute_response = Mock()+ mock_execute_response.model_dump.return_value = {+ "data": {"result": "success"},+ "error": None,+ "successful": True,+ }+ mock_client.tools.execute.return_value = mock_execute_response++ # Execute the tool+ tools._execute_tool(+ slug="GITHUB_GET_REPOS",+ arguments={"owner": "test", "repo": "test"},+ toolkit_versions=toolkit_versions,+ )++ # Verify that the client was called with the global version+ mock_client.tools.execute.assert_called_once()+ call_args = mock_client.tools.execute.call_args++ # Should have called with the global version string+ assert call_args.kwargs["version"] == "v3.0.0"++ def test_tool_execution_matches_typescript_behavior(self):+ """Test that Python execution matches TypeScript behavior exactly."""+ # This test verifies the same logic as TypeScript:+ # version: body.version ?? getToolkitVersion(tool.toolkit?.slug ?? 'unknown', this.toolkitVersions)++ # Mock client and provider+ mock_client = Mock()+ mock_provider = Mock()+ mock_provider.name = "test_provider"++ # Create toolkit versions like TypeScript would have+ toolkit_versions = {+ "github": "20250906_01",+ "slack": "latest",+ "notion": "20250901_05",+ }++ # Create Tools instance+ tools = Tools(+ client=mock_client,+ provider=mock_provider,+ toolkit_versions=toolkit_versions,+ )++ # Test cases matching TypeScript behavior+ test_cases = [+ ("GITHUB_GET_REPOS", "github", "20250906_01"),+ ("SLACK_SEND_MESSAGE", "slack", "latest"),+ ("NOTION_CREATE_PAGE", "notion", "20250901_05"),+ ("CUSTOM_TOOL", "unknown_toolkit", "latest"), # Unknown toolkit fallback+ ]++ for tool_slug, toolkit_slug, expected_version in test_cases:+ # Create mock tool+ mock_tool = self.create_mock_tool(tool_slug, toolkit_slug)++ # Mock the get_raw_composio_tool_by_slug method+ with patch.object(+ tools, "get_raw_composio_tool_by_slug", return_value=mock_tool+ ):+ # Mock the client's execute method+ mock_execute_response = Mock()+ mock_execute_response.model_dump.return_value = {+ "data": {"result": "success"},+ "error": None,+ "successful": True,+ }+ mock_client.tools.execute.return_value = mock_execute_response++ # Execute the tool+ tools._execute_tool(+ slug=tool_slug,+ arguments={"test": "data"},+ toolkit_versions=toolkit_versions,+ )++ # Verify the version matches expected+ call_args = mock_client.tools.execute.call_args+ assert call_args.kwargs["version"] == expected_version, (+ f"Tool {tool_slug} with toolkit {toolkit_slug} should use version {expected_version}"+ )++ # Reset mock for next iteration+ mock_client.tools.execute.reset_mock()diff --git a/python/tests/test_toolkit_version.py b/python/tests/test_toolkit_version.pynew file mode 100644index 000000000..2b19f89ba--- /dev/null+++ b/python/tests/test_toolkit_version.py@@ -0,0 +1,174 @@+"""Test toolkit version utilities."""++import pytest++from composio.core.types import ToolkitVersionParam+from composio.utils.toolkit_version import get_toolkit_version, get_toolkit_versions+++class TestToolkitVersion:+ """Test cases for toolkit version utilities."""++ def test_get_toolkit_version_with_string(self):+ """Test get_toolkit_version with string parameter."""+ result = get_toolkit_version("github", "v1.0.0")+ assert result == "v1.0.0"++ def test_get_toolkit_version_with_dict(self):+ """Test get_toolkit_version with dict parameter."""+ versions = {"github": "v1.0.0", "slack": "v2.0.0"}+ result = get_toolkit_version("github", versions)+ assert result == "v1.0.0"++ def test_get_toolkit_version_with_dict_missing_key(self):+ """Test get_toolkit_version with dict parameter missing key."""+ versions = {"slack": "v2.0.0"}+ result = get_toolkit_version("github", versions)+ assert result == "latest"++ def test_get_toolkit_version_with_none(self):+ """Test get_toolkit_version with None parameter."""+ result = get_toolkit_version("github", None)+ assert result == "latest"++ def test_get_toolkit_version_with_env_var(self):+ """Test get_toolkit_version with environment variable."""+ with pytest.MonkeyPatch().context():+ # The function doesn't directly use COMPOSIO_TOOLKIT_VERSION env var+ # It only looks at the toolkit_versions parameter+ result = get_toolkit_version("github", None)+ assert result == "latest"++ def test_get_toolkit_versions_with_string(self):+ """Test get_toolkit_versions with string parameter."""+ result = get_toolkit_versions("v1.0.0")+ assert result == "v1.0.0"++ def test_get_toolkit_versions_with_dict(self):+ """Test get_toolkit_versions with dict parameter."""+ versions = {"github": "v1.0.0", "slack": "v2.0.0"}+ result = get_toolkit_versions(versions)+ assert result == versions++ def test_get_toolkit_versions_with_none(self):+ """Test get_toolkit_versions with None parameter."""+ result = get_toolkit_versions(None)+ assert result == "latest"++ def test_get_toolkit_versions_with_env_toolkit_specific(self):+ """Test get_toolkit_versions with toolkit-specific environment variables."""+ with pytest.MonkeyPatch().context() as m:+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v2.0.0")+ m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v1.5.0")+ result = get_toolkit_versions(None)+ expected = {"github": "v2.0.0", "slack": "v1.5.0"}+ assert result == expected++ def test_get_toolkit_versions_env_and_user_override(self):+ """Test that user-provided versions override environment variables."""+ with pytest.MonkeyPatch().context() as m:+ # Set environment variables+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0")+ m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v2.0.0")++ # User overrides should take precedence+ user_versions = {"github": "v3.0.0", "jira": "v4.0.0"}+ result = get_toolkit_versions(user_versions)++ expected = {+ "github": "v3.0.0", # User override+ "slack": "v2.0.0", # From env+ "jira": "v4.0.0", # User provided+ }+ assert result == expected++ def test_get_toolkit_version_with_env_specific_toolkit(self):+ """Test get_toolkit_version works with environment-configured versions."""+ with pytest.MonkeyPatch().context() as m:+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v2.5.0")+ m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "v1.8.0")++ # Get versions from environment+ env_versions = get_toolkit_versions(None)++ # Test specific toolkit version retrieval+ github_version = get_toolkit_version("github", env_versions)+ slack_version = get_toolkit_version("slack", env_versions)+ unknown_version = get_toolkit_version("unknown", env_versions)++ assert github_version == "v2.5.0"+ assert slack_version == "v1.8.0"+ assert unknown_version == "latest"++ def test_mixed_case_env_vars_normalized(self):+ """Test that mixed case environment variable names are normalized."""+ with pytest.MonkeyPatch().context() as m:+ # Environment variables are typically uppercase+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0")+ m.setenv("COMPOSIO_TOOLKIT_VERSION_OPENAI", "v2.0.0")++ result = get_toolkit_versions(None)++ # Should be normalized to lowercase+ assert "github" in result+ assert "openai" in result+ assert result["github"] == "v1.0.0"+ assert result["openai"] == "v2.0.0"++ def test_user_dict_case_normalization(self):+ """Test that user-provided dictionary keys are normalized to lowercase."""+ user_versions = {"GitHub": "v1.0.0", "SLACK": "v2.0.0", "OpenAI": "v3.0.0"}++ result = get_toolkit_versions(user_versions)++ expected = {"github": "v1.0.0", "slack": "v2.0.0", "openai": "v3.0.0"}+ assert result == expected++ def test_priority_order_matches_typescript(self):+ """Test that priority order matches TypeScript implementation.++ Priority order should be:+ 1. String global version (overrides everything)+ 2. User-provided dict overrides env vars+ 3. Environment variables+ 4. Fallback to 'latest'+ """+ with pytest.MonkeyPatch().context() as m:+ # Test 1: String global version overrides everything+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "env_version")+ result = get_toolkit_versions("global_version")+ assert result == "global_version"++ # Test 2: User dict overrides env vars+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "env_version")+ m.setenv("COMPOSIO_TOOLKIT_VERSION_SLACK", "env_slack")+ user_dict = {"github": "user_override"}+ result = get_toolkit_versions(user_dict)+ expected = {+ "github": "user_override", # User override+ "slack": "env_slack", # From env+ }+ assert result == expected++ # Test 3: Environment variables when no user input+ result = get_toolkit_versions(None)+ expected = {"github": "env_version", "slack": "env_slack"}+ assert result == expected++ def test_empty_user_dict_uses_env_vars(self):+ """Test that empty user dict still uses environment variables."""+ with pytest.MonkeyPatch().context() as m:+ m.setenv("COMPOSIO_TOOLKIT_VERSION_GITHUB", "v1.0.0")++ # Empty dict should still use env vars+ result = get_toolkit_versions({})+ expected = {"github": "v1.0.0"}+ assert result == expected++ def test_toolkit_version_param_type_annotation(self):+ """Test ToolkitVersionParam type annotation."""+ import typing++ # Test that ToolkitVersionParam is a Union type+ assert hasattr(ToolkitVersionParam, "__origin__")+ assert ToolkitVersionParam.__origin__ is typing.Uniondiff --git a/uv.lock b/uv.lockindex 50470b001..a17be6164 100644--- a/uv.lock+++ b/uv.lock@@ -468,7 +468,7 @@ wheels = [[[package]]name = "composio"-version = "0.8.11"+version = "0.8.14"source = { virtual = "python" }dependencies = [{ name = "composio-client" },@@ -515,7 +515,7 @@ dev = [[[package]]name = "composio-anthropic"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/anthropic" }dependencies = [{ name = "anthropic" },@@ -547,7 +547,7 @@ wheels = [[[package]]name = "composio-crewai"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/crewai" }dependencies = [{ name = "composio" },@@ -562,7 +562,7 @@ requires-dist = [[[package]]name = "composio-gemini"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/gemini" }dependencies = [{ name = "composio" },@@ -577,7 +577,7 @@ requires-dist = [[[package]]name = "composio-google"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/google" }dependencies = [{ name = "composio" },@@ -592,7 +592,7 @@ requires-dist = [[[package]]name = "composio-google-adk"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/google_adk" }dependencies = [{ name = "composio" },@@ -607,7 +607,7 @@ requires-dist = [[[package]]name = "composio-langchain"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/langchain" }dependencies = [{ name = "composio" },@@ -622,7 +622,7 @@ requires-dist = [[[package]]name = "composio-openai"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/openai" }dependencies = [{ name = "composio" },@@ -637,7 +637,7 @@ requires-dist = [[[package]]name = "composio-openai-agents"-version = "0.8.9"+version = "0.8.12"source = { virtual = "python/providers/openai_agents" }dependencies = [{ name = "composio" },