Skip to content

Composio powers 1000+ toolkits, tool search, context management, authentication, and a sandboxed workbench to help you build AI agents that turn intent into action.

Fix python sdk type issues (#1949)

Musthaq Ahamadb750b06c6055
diff --git a/.github/workflows/py.test.yml b/.github/workflows/py.test.yml
new file mode 100644
index 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__.py
index 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.py
index 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 url
connection_request = composio.connected_accounts.link('user_123', 'auth_config_123')
redirect_url = connection_request.redirect_url
print(f"Visit: {redirect_url} to authenticate your account")
-
+
# Wait for the connection to be established
connected_account = connection_request.wait_for_connection()
-
+
Example with callback URL:
# Create a connection request with callback URL
connection_request = composio.connected_accounts.link(
- 'user_123',
+ 'user_123',
'auth_config_123',
callback_url='https://your-app.com/callback'
)
redirect_url = connection_request.redirect_url
print(f"Visit: {redirect_url} to authenticate your account")
-
+
# Wait for the connection to be established
connected_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 provided
if callback_url is not None:
payload["callback_url"] = callback_url
-
+
# Call the link creation endpoint
response = 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.py
index 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 ToolkitVersionParam
from composio.exceptions import InvalidParams, NotFoundError
-from composio.types import ToolkitVersionParam
from composio.utils.toolkit_version import get_toolkit_version
from ._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_versions
self.custom_tool = self._custom_tools.register
self.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.py
new file mode 100644
index 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.py
index 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_tracking
from composio.core.provider import TProvider
from composio.core.provider._openai import OpenAIProvider
-from composio.types import ToolkitVersionParam
+from composio.core.types import ToolkitVersionParam
from composio.utils.logging import WithLogger
from 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 support
toolkit_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.py
index 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 Tool
from composio.core.models.connected_accounts import auth_scheme
from composio.core.models.custom_tools import ExecuteRequestFn
@@ -12,14 +8,12 @@ from composio.core.models.tools import (
)
from composio.core.models.triggers import TriggerEvent
from 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 types
diff --git a/python/composio/utils/toolkit_version.py b/python/composio/utils/toolkit_version.py
index 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 os
import typing as t
-from composio.types import ToolkitVersion, ToolkitVersionParam, ToolkitVersions
+from composio.core.types import ToolkitVersion, ToolkitVersionParam, ToolkitVersions
def get_toolkit_version(
diff --git a/python/providers/anthropic/pyproject.toml b/python/providers/anthropic/pyproject.toml
index 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.py
index 853a43d60..e64b64c27 100644
--- a/python/providers/anthropic/setup.py
+++ b/python/providers/anthropic/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 53b47a6c2..67595354d 100644
--- a/python/providers/autogen/setup.py
+++ b/python/providers/autogen/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index d30c3bbed..08bb3b771 100644
--- a/python/providers/crewai/setup.py
+++ b/python/providers/crewai/setup.py
@@ -6,7 +6,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index aea9a448d..f847dd90f 100644
--- a/python/providers/gemini/setup.py
+++ b/python/providers/gemini/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 43c67d511..0e57bd58c 100644
--- a/python/providers/google/setup.py
+++ b/python/providers/google/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 90bced3b9..c9b7aaf65 100644
--- a/python/providers/google_adk/setup.py
+++ b/python/providers/google_adk/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index cb20142a9..3e62f744a 100644
--- a/python/providers/langchain/setup.py
+++ b/python/providers/langchain/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 8178239c1..9326c9a1d 100644
--- a/python/providers/langgraph/setup.py
+++ b/python/providers/langgraph/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 83b7e87df..917338283 100644
--- a/python/providers/llamaindex/setup.py
+++ b/python/providers/llamaindex/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 62698e2dc..40c97b427 100644
--- a/python/providers/openai/setup.py
+++ b/python/providers/openai/setup.py
@@ -8,7 +8,7 @@ from setuptools import setup
setup(
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.toml
index 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.py
index 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, setup
setup(
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.toml
index 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.py
new file mode 100644
index 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 CoreToolkitVersions
diff --git a/python/tests/test_imports.py b/python/tests/test_imports.py
new file mode 100644
index 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.py
new file mode 100644
index 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 == expected
diff --git a/python/tests/test_tool_execution.py b/python/tests/test_tool_execution.py
new file mode 100644
index 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.py
new file mode 100644
index 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.Union
diff --git a/uv.lock b/uv.lock
index 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" },