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.

feat(connected-accounts-py): surface account_type + per-user ACL on SHARED connections

venkat82b283fbbccc17
diff --git a/python/composio/client/types.py b/python/composio/client/types.py
index 2c69e1579..cb25d07af 100644
--- a/python/composio/client/types.py
+++ b/python/composio/client/types.py
@@ -20,6 +20,7 @@ from composio_client.types import (
connected_account_patch_response,
connected_account_retrieve_response,
connected_account_update_status_response,
+ link_create_params,
tool_execute_params,
tool_execute_response,
tool_list_response,
@@ -78,6 +79,7 @@ __all__ = (
"connected_account_patch_response",
"connected_account_retrieve_response",
"connected_account_update_status_response",
+ "link_create_params",
"trigger_instance_upsert_response",
"tool_execute_params",
"tool_execute_response",
diff --git a/python/composio/core/models/connected_accounts.py b/python/composio/core/models/connected_accounts.py
index 877f7a0ba..2efeaae6e 100644
--- a/python/composio/core/models/connected_accounts.py
+++ b/python/composio/core/models/connected_accounts.py
@@ -17,6 +17,7 @@ from composio.client.types import (
connected_account_patch_response,
connected_account_retrieve_response,
connected_account_update_status_response,
+ link_create_params,
)
from .base import Resource
@@ -558,6 +559,8 @@ class ConnectedAccounts:
callback_url: t.Optional[str] = None,
alias: t.Optional[str] = None,
allow_multiple: bool = False,
+ account_type: t.Optional[t.Literal["PRIVATE", "SHARED"]] = None,
+ acl_config_for_shared: t.Optional[link_create_params.ACLConfigForShared] = None,
) -> ConnectionRequest:
"""
Create a Composio Connect Link for a user to connect their account to a given auth config.
@@ -574,6 +577,17 @@ class ConnectedAccounts:
``ComposioMultipleConnectedAccountsError`` if the user already has an
``ACTIVE`` connection on this auth config. Pair with ``alias`` and a
session-level ``multi_account`` config to disambiguate at execution time.
+ :param account_type: Sharing model for the new connection. ``PRIVATE``
+ (default) is usable only by the owning ``user_id``. ``SHARED`` is
+ reachable from a tool-router session by other users in the project,
+ but only when explicitly pinned and only when the requesting
+ ``user_id`` passes the connection's ACL. Set at create time only.
+ :param acl_config_for_shared: Per-user ACL for SHARED connections. Only
+ valid when ``account_type == 'SHARED'`` — the backend rejects ACL
+ on a PRIVATE connection with ``ComposioAclOnlyForSharedError``
+ (400). Pass an ``ACLConfigForShared`` dict with any combination of
+ ``allow_all_users``, ``allowed_user_ids``, ``not_allowed_user_ids``.
+ Omit to keep deny-by-default (only the creator can use).
:return: Connection request object.
Example:
@@ -597,6 +611,17 @@ class ConnectedAccounts:
# Wait for the connection to be established
connected_account = composio.connected_accounts.wait_for_connection(connection_request.id)
+
+ Example creating a SHARED connection with an ACL:
+ connection_request = composio.connected_accounts.link(
+ 'user_creator',
+ 'auth_config_123',
+ account_type='SHARED',
+ acl_config_for_shared={
+ 'allow_all_users': True,
+ 'not_allowed_user_ids': ['user_bob'],
+ },
+ )
"""
# Mirror ``initiate()``: guard against silently creating extra
# connections on the same auth config.
@@ -615,12 +640,25 @@ class ConnectedAccounts:
auth_config_id,
)
- response = self._client.link.create(
- auth_config_id=auth_config_id,
- user_id=user_id,
- callback_url=callback_url if callback_url is not None else omit,
- alias=alias if alias is not None else omit,
- )
+ try:
+ response = self._client.link.create(
+ auth_config_id=auth_config_id,
+ user_id=user_id,
+ callback_url=callback_url if callback_url is not None else omit,
+ alias=alias if alias is not None else omit,
+ account_type=account_type if account_type is not None else omit,
+ acl_config_for_shared=(
+ acl_config_for_shared if acl_config_for_shared is not None else omit
+ ),
+ )
+ except BadRequestError as error:
+ # Backend rejects ACL on PRIVATE rows with 400 +
+ # ``ConnectedAccount_AclOnlyForShared``. Surface it as a typed
+ # error so callers can ``except`` instead of grepping messages.
+ message = str(error)
+ if "acl_config_for_shared is only valid on SHARED" in message:
+ raise exceptions.ComposioAclOnlyForSharedError(message) from error
+ raise
return ConnectionRequest(
id=response.connected_account_id,
@@ -629,6 +667,96 @@ class ConnectedAccounts:
client=self._client,
)
+ def update_acl(
+ self,
+ nanoid: str,
+ *,
+ allow_all_users: t.Optional[bool] = None,
+ allowed_user_ids: t.Optional[t.List[str]] = None,
+ not_allowed_user_ids: t.Optional[t.List[str]] = None,
+ ) -> connected_account_patch_response.ConnectedAccountPatchResponse:
+ """
+ Update the per-user ACL on a SHARED connected account.
+
+ Only meaningful for SHARED connections — the backend rejects ACL
+ writes on PRIVATE rows with ``ComposioAclOnlyForSharedError`` (400).
+ Auth gate is creator-or-API-key (a non-creator project member
+ updating an alias on a SHARED row still works via :meth:`update`,
+ but ACL writes do not).
+
+ PATCH semantics: omit a parameter to leave it unchanged; pass an
+ empty list to clear an allow/deny list. At least one parameter must
+ be provided — calling with all three as ``None`` raises
+ :class:`composio.exceptions.ValidationError`.
+
+ Resolution rule (deny wins):
+ 1. requesting user_id in ``not_allowed_user_ids`` → DENY
+ 2. ``allow_all_users == True`` → ALLOW
+ 3. requesting user_id in ``allowed_user_ids`` → ALLOW
+ 4. otherwise → DENY
+
+ :param nanoid: The connected account ID (``ca_xxx``).
+ :param allow_all_users: Wildcard "any user_id in the project" allow.
+ :param allowed_user_ids: Explicit allow list. Pass ``[]`` to clear.
+ :param not_allowed_user_ids: Explicit deny list (wins over allow on
+ conflict). Pass ``[]`` to clear — note that clearing the deny
+ list silently re-grants access to previously-blocked users.
+ :return: PATCH response (``id``, ``status``, ``success``). To read
+ back the updated ``acl_config_for_shared`` block, call
+ :meth:`get` after this returns.
+
+ Example::
+
+ # Open access to everyone in the project
+ composio.connected_accounts.update_acl('ca_abc', allow_all_users=True)
+
+ # Everyone except a specific user
+ composio.connected_accounts.update_acl(
+ 'ca_abc',
+ allow_all_users=True,
+ not_allowed_user_ids=['user_bob'],
+ )
+
+ # Targeted allow
+ composio.connected_accounts.update_acl(
+ 'ca_abc',
+ allowed_user_ids=['user_alice', 'user_bob'],
+ )
+
+ # Revoke a previously-granted allow list (back to deny-by-default)
+ composio.connected_accounts.update_acl('ca_abc', allowed_user_ids=[])
+ """
+ if (
+ allow_all_users is None
+ and allowed_user_ids is None
+ and not_allowed_user_ids is None
+ ):
+ raise exceptions.ValidationError(
+ "update_acl requires at least one of allow_all_users, "
+ "allowed_user_ids, or not_allowed_user_ids"
+ )
+
+ acl: t.Dict[str, t.Any] = {}
+ if allow_all_users is not None:
+ acl["allow_all_users"] = allow_all_users
+ if allowed_user_ids is not None:
+ acl["allowed_user_ids"] = allowed_user_ids
+ if not_allowed_user_ids is not None:
+ acl["not_allowed_user_ids"] = not_allowed_user_ids
+
+ try:
+ return self._client.connected_accounts.patch(
+ nanoid,
+ acl_config_for_shared=t.cast(
+ connected_account_patch_params.ACLConfigForShared, acl
+ ),
+ )
+ except BadRequestError as error:
+ message = str(error)
+ if "acl_config_for_shared is only valid on SHARED" in message:
+ raise exceptions.ComposioAclOnlyForSharedError(message) from error
+ raise
+
def wait_for_connection(
self,
id: str,
diff --git a/python/composio/core/models/tool_router_session.py b/python/composio/core/models/tool_router_session.py
index b0eba3cf7..733775e0a 100644
--- a/python/composio/core/models/tool_router_session.py
+++ b/python/composio/core/models/tool_router_session.py
@@ -12,9 +12,9 @@ import typing as t
from concurrent.futures import ThreadPoolExecutor
from dataclasses import dataclass
-from composio_client import Omit, omit
+from composio_client import BadRequestError, Omit, omit
from composio_client._types import SequenceNotStr
-from composio_client.types.tool_router import session_patch_params
+from composio_client.types.tool_router import session_link_params, session_patch_params
from composio.client.types import Tool
from composio_client.types.tool_list_response import (
ItemDeprecated,
@@ -31,6 +31,7 @@ from composio_client.types.tool_router.session_search_response import (
SessionSearchResponse,
)
+from composio import exceptions
from composio.client import HttpClient
from composio.core.models.connected_accounts import ConnectionRequest
from composio.core.models.custom_tool import find_custom_tool_map_entry_by_final_slug
@@ -538,6 +539,8 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
*,
callback_url: t.Optional[str] = None,
alias: t.Optional[str] = None,
+ account_type: t.Optional[t.Literal["PRIVATE", "SHARED"]] = None,
+ acl_config_for_shared: t.Optional[session_link_params.ACLConfigForShared] = None,
) -> ConnectionRequest:
"""
Authorize a toolkit for the user and get a connection request.
@@ -546,13 +549,34 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
:param alias: Human-readable alias for the connection. Must be unique
per userId and toolkit within the project.
+ :param account_type: Sharing model for the new connection. ``PRIVATE``
+ (default) is usable only by the owning user. ``SHARED`` lets other
+ users in the project use the connection when pinned. Set at create
+ time only.
+ :param acl_config_for_shared: Per-user ACL for SHARED connections. Only
+ valid when ``account_type == 'SHARED'`` — the backend rejects ACL
+ on a PRIVATE connection with ``ComposioAclOnlyForSharedError``
+ (400).
"""
- response = self._client.tool_router.session.link(
- session_id=self.session_id,
- toolkit=toolkit,
- callback_url=callback_url if callback_url else omit,
- alias=alias if alias is not None else omit,
- )
+ try:
+ response = self._client.tool_router.session.link(
+ session_id=self.session_id,
+ toolkit=toolkit,
+ callback_url=callback_url if callback_url else omit,
+ alias=alias if alias is not None else omit,
+ account_type=account_type if account_type is not None else omit,
+ acl_config_for_shared=(
+ acl_config_for_shared if acl_config_for_shared is not None else omit
+ ),
+ )
+ except BadRequestError as error:
+ # Mirrors the mapper on ``composio.connected_accounts.link()`` —
+ # the same backend handler returns ``AclOnlyForShared`` here.
+ message = str(error)
+ if "acl_config_for_shared is only valid on SHARED" in message:
+ raise exceptions.ComposioAclOnlyForSharedError(message) from error
+ raise
+
return ConnectionRequest(
id=response.connected_account_id,
redirect_url=response.redirect_url,
diff --git a/python/composio/exceptions.py b/python/composio/exceptions.py
index 937895618..0ba1b676f 100644
--- a/python/composio/exceptions.py
+++ b/python/composio/exceptions.py
@@ -331,6 +331,61 @@ class ComposioLegacyConnectedAccountsEndpointRetiredError(ConnectedAccountError)
pass
+class ComposioAclOnlyForSharedError(ConnectedAccountError):
+ """Raised when ACL fields (``allow_all_users``, ``allowed_user_ids``,
+ ``not_allowed_user_ids``) are sent on a ``PRIVATE`` connection — at
+ create time or via PATCH.
+
+ ACL is only meaningful for ``SHARED`` connections; the matching layer
+ never reads it for PRIVATE. Backend rejects with 400 +
+ ``ConnectedAccount_AclOnlyForShared`` rather than silently ignoring the
+ ACL block, so developer misconfiguration surfaces loudly.
+
+ Fix: set ``account_type='SHARED'`` at create time, or omit the ACL
+ fields when creating/updating a PRIVATE connection.
+ """
+
+ pass
+
+
+class ComposioSharedAccessDeniedError(ConnectedAccountError):
+ """Raised when a tool execution attempts to use a SHARED connected
+ account but the requesting ``user_id`` is not allowed by the
+ connection's ACL.
+
+ Surfaces from the matching layer when a SHARED connection is reached
+ directly (e.g. via ``composio.tools.execute(slug, connected_account_id=...)``)
+ without going through a tool-router session that already pre-flighted
+ the ACL at session-create time.
+
+ Fix: ask the connection's creator to grant access via
+ ``composio.connected_accounts.update_acl()`` — set ``allow_all_users``,
+ add the ``user_id`` to ``allowed_user_ids``, or remove it from
+ ``not_allowed_user_ids``.
+
+ Backend response: 403 with code ``ConnectedAccount_SharedAccessDenied``.
+ """
+
+ pass
+
+
+class ComposioSharedConnectionNotAccessibleError(ConnectedAccountError):
+ """Raised by tool-router session create / PATCH when the session's
+ ``user_id`` cannot use a pinned SHARED connection — caught at
+ session-create time so the session never enters a state that 4xxs
+ mid-execution.
+
+ Fix: grant the session user access via
+ ``composio.connected_accounts.update_acl()`` on the pinned connection,
+ or pin a different connection the user can use.
+
+ Backend response: 400 with code
+ ``ToolRouterV2_SharedConnectionNotAccessible``.
+ """
+
+ pass
+
+
class ErrorProcessingToolExecutionRequest(PluginError):
pass
diff --git a/python/pyproject.toml b/python/pyproject.toml
index 65672f89c..0f5f32347 100644
--- a/python/pyproject.toml
+++ b/python/pyproject.toml
@@ -1,13 +1,13 @@
[project]
name = "composio"
-version = "0.13.0"
+version = "0.14.0"
description = "SDK for integrating Composio with your applications."
readme = "README.md"
requires-python = ">=3.10,<4"
dependencies = [
"pysher>=1.0.8",
"pydantic>=2.6.4",
- "composio-client==1.37.0",
+ "composio-client==1.38.0",
"typing-extensions>=4.0.0",
"openai",
"json-schema-to-pydantic>=0.4.8",
diff --git a/python/tests/test_connected_accounts.py b/python/tests/test_connected_accounts.py
index 5246f1e84..bf767dce8 100644
--- a/python/tests/test_connected_accounts.py
+++ b/python/tests/test_connected_accounts.py
@@ -284,6 +284,7 @@ class TestConnectedAccounts:
client.connected_accounts.update_status = Mock()
client.connected_accounts.refresh = Mock()
client.connected_accounts.create = Mock()
+ client.connected_accounts.patch = Mock()
client.link.create = Mock()
return client
@@ -525,6 +526,223 @@ class TestConnectedAccounts:
assert result == "connected"
+def _make_bad_request_error(message: str):
+ """Build a BadRequestError instance for testing the error mapper.
+
+ The composio_client BadRequestError constructor signature is internal —
+ rather than depend on it, we stub a minimal object that ``str(error)``
+ surfaces the message and which is recognized as the BadRequestError type
+ by ``isinstance``. This mirrors how production responses arrive: the
+ error class with a message body.
+ """
+ from composio_client import BadRequestError
+
+ error = BadRequestError.__new__(BadRequestError)
+ Exception.__init__(error, message)
+ return error
+
+
+class TestConnectedAccountsAcl:
+ """Tests for accountType + per-user ACL surfacing (Hermes #9860, #9902).
+
+ Mirrors the 12 behaviour tests in
+ ``ts/packages/core/test/connectedAccounts/connectedAccounts.test.ts``.
+ """
+
+ @pytest.fixture
+ def mock_client(self):
+ client = Mock()
+ client.connected_accounts.retrieve = Mock()
+ client.connected_accounts.list = Mock()
+ client.connected_accounts.delete = Mock()
+ client.connected_accounts.update_status = Mock()
+ client.connected_accounts.refresh = Mock()
+ client.connected_accounts.create = Mock()
+ client.connected_accounts.patch = Mock()
+ client.link.create = Mock()
+ # Default: no existing connections, so link() doesn't trip the guard.
+ no_accounts = Mock()
+ no_accounts.items = []
+ client.connected_accounts.list.return_value = no_accounts
+ # Default link.create response — overridden per test where the
+ # response shape matters.
+ default_link = Mock()
+ default_link.connected_account_id = "ca_test_shared"
+ default_link.redirect_url = "https://redirect"
+ client.link.create.return_value = default_link
+ return client
+
+ @pytest.fixture
+ def connected_accounts(self, mock_client):
+ return ConnectedAccounts(client=mock_client)
+
+ # -- link() with accountType + ACL forwarding ---------------------------
+
+ def test_link_forwards_account_type_and_nested_acl(
+ self, connected_accounts, mock_client
+ ):
+ connected_accounts.link(
+ user_id="user_creator",
+ auth_config_id="auth_config_123",
+ account_type="SHARED",
+ acl_config_for_shared={
+ "allow_all_users": True,
+ "not_allowed_user_ids": ["user_bob"],
+ },
+ )
+
+ call_kwargs = mock_client.link.create.call_args.kwargs
+ assert call_kwargs["account_type"] == "SHARED"
+ assert call_kwargs["acl_config_for_shared"] == {
+ "allow_all_users": True,
+ "not_allowed_user_ids": ["user_bob"],
+ }
+
+ def test_link_omits_acl_when_not_provided(
+ self, connected_accounts, mock_client
+ ):
+ connected_accounts.link(
+ user_id="user_creator",
+ auth_config_id="auth_config_123",
+ account_type="SHARED",
+ )
+
+ call_kwargs = mock_client.link.create.call_args.kwargs
+ assert call_kwargs["account_type"] == "SHARED"
+ assert call_kwargs["acl_config_for_shared"] is omit
+
+ def test_link_forwards_only_provided_acl_fields(
+ self, connected_accounts, mock_client
+ ):
+ connected_accounts.link(
+ user_id="user_creator",
+ auth_config_id="auth_config_123",
+ account_type="SHARED",
+ acl_config_for_shared={"allowed_user_ids": ["user_alice"]},
+ )
+
+ call_kwargs = mock_client.link.create.call_args.kwargs
+ assert call_kwargs["acl_config_for_shared"] == {
+ "allowed_user_ids": ["user_alice"]
+ }
+
+ def test_link_preserves_explicit_empty_lists(
+ self, connected_accounts, mock_client
+ ):
+ """An empty list is meaningful (clear the allow/deny list)."""
+ connected_accounts.link(
+ user_id="user_creator",
+ auth_config_id="auth_config_123",
+ account_type="SHARED",
+ acl_config_for_shared={
+ "allowed_user_ids": [],
+ "not_allowed_user_ids": [],
+ },
+ )
+
+ call_kwargs = mock_client.link.create.call_args.kwargs
+ assert call_kwargs["acl_config_for_shared"] == {
+ "allowed_user_ids": [],
+ "not_allowed_user_ids": [],
+ }
+
+ def test_link_maps_acl_only_for_shared_to_typed_error(
+ self, connected_accounts, mock_client
+ ):
+ mock_client.link.create.side_effect = _make_bad_request_error(
+ "acl_config_for_shared is only valid on SHARED connections."
+ )
+
+ with pytest.raises(exceptions.ComposioAclOnlyForSharedError):
+ connected_accounts.link(
+ user_id="user_creator",
+ auth_config_id="auth_config_123",
+ account_type="PRIVATE",
+ acl_config_for_shared={"allow_all_users": True},
+ )
+
+ def test_link_rethrows_non_acl_bad_request_errors(
+ self, connected_accounts, mock_client
+ ):
+ unrelated = _make_bad_request_error("auth_config_id is required")
+ mock_client.link.create.side_effect = unrelated
+
+ from composio_client import BadRequestError
+
+ with pytest.raises(BadRequestError):
+ connected_accounts.link(
+ user_id="user_creator", auth_config_id="auth_config_123"
+ )
+
+ # -- update_acl() body construction + mapper ----------------------------
+
+ def test_update_acl_serializes_nested_body(
+ self, connected_accounts, mock_client
+ ):
+ response = Mock()
+ response.id = "ca_abc"
+ response.status = "ACTIVE"
+ response.success = True
+ mock_client.connected_accounts.patch.return_value = response
+
+ result = connected_accounts.update_acl(
+ "ca_abc",
+ allow_all_users=True,
+ not_allowed_user_ids=["user_bob"],
+ )
+
+ mock_client.connected_accounts.patch.assert_called_once_with(
+ "ca_abc",
+ acl_config_for_shared={
+ "allow_all_users": True,
+ "not_allowed_user_ids": ["user_bob"],
+ },
+ )
+ assert result is response
+
+ def test_update_acl_omits_absent_fields(self, connected_accounts, mock_client):
+ connected_accounts.update_acl("ca_abc", allowed_user_ids=["user_alice"])
+
+ mock_client.connected_accounts.patch.assert_called_once_with(
+ "ca_abc",
+ acl_config_for_shared={"allowed_user_ids": ["user_alice"]},
+ )
+
+ def test_update_acl_preserves_empty_array(self, connected_accounts, mock_client):
+ connected_accounts.update_acl("ca_abc", allowed_user_ids=[])
+
+ mock_client.connected_accounts.patch.assert_called_once_with(
+ "ca_abc",
+ acl_config_for_shared={"allowed_user_ids": []},
+ )
+
+ def test_update_acl_rejects_all_none(self, connected_accounts, mock_client):
+ with pytest.raises(exceptions.ValidationError):
+ connected_accounts.update_acl("ca_abc")
+ mock_client.connected_accounts.patch.assert_not_called()
+
+ def test_update_acl_maps_acl_only_for_shared_to_typed_error(
+ self, connected_accounts, mock_client
+ ):
+ mock_client.connected_accounts.patch.side_effect = _make_bad_request_error(
+ "acl_config_for_shared is only valid on SHARED connections."
+ )
+
+ with pytest.raises(exceptions.ComposioAclOnlyForSharedError):
+ connected_accounts.update_acl("ca_abc", allow_all_users=True)
+
+ def test_update_acl_rethrows_non_acl_bad_request_errors(
+ self, connected_accounts, mock_client
+ ):
+ unrelated = _make_bad_request_error("some other 400")
+ mock_client.connected_accounts.patch.side_effect = unrelated
+
+ from composio_client import BadRequestError
+
+ with pytest.raises(BadRequestError):
+ connected_accounts.update_acl("ca_abc", allow_all_users=True)
+
+
# SEC-339: initiate() must gate its DeprecationWarning on the response
# `Deprecation` HTTP header (RFC 9745) that apollo emits only on the
# retiring branch (Composio-managed + redirectable OAuth). These tests pin
diff --git a/uv.lock b/uv.lock
index 8cf697707..9d596b004 100644
--- a/uv.lock
+++ b/uv.lock
@@ -591,7 +591,7 @@ wheels = [
[[package]]
name = "composio"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python" }
dependencies = [
{ name = "composio-client" },
@@ -621,7 +621,7 @@ dev = [
[package.metadata]
requires-dist = [
- { name = "composio-client", specifier = "==1.37.0" },
+ { name = "composio-client", specifier = "==1.38.0" },
{ name = "json-schema-to-pydantic", specifier = ">=0.4.8" },
{ name = "openai" },
{ name = "pydantic", specifier = ">=2.6.4" },
@@ -648,7 +648,7 @@ dev = [
[[package]]
name = "composio-anthropic"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/anthropic" }
dependencies = [
{ name = "anthropic" },
@@ -663,7 +663,7 @@ requires-dist = [
[[package]]
name = "composio-client"
-version = "1.37.0"
+version = "1.38.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "anyio" },
@@ -673,14 +673,14 @@ dependencies = [
{ name = "sniffio" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/75/14/d0a1cb2fb202357e4e49bdbd017d96131f0e821d136943074e9f9933436c/composio_client-1.37.0.tar.gz", hash = "sha256:b9f5c4b97863f98714634b88f61139aceef11274ee74a6fda59afc4095c5d094", size = 242029, upload-time = "2026-05-07T03:09:36.419Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/ea/c0/b0f452d153f5ecf807d7281110a1dea3ea3a6993efa1cdf82782e3daf1f4/composio_client-1.38.0.tar.gz", hash = "sha256:70f248f847f91473413353500862f3944baa829cc2740c32f31c631d755f7f9e", size = 248289, upload-time = "2026-05-11T18:16:11.167Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/49/98/cfc8d6c6208e00e015db59278855831d77b73730cb4e574c330fcfd53d4a/composio_client-1.37.0-py3-none-any.whl", hash = "sha256:bb228899c294c348cd982bcea9a33773bd65185108e863d41465e51890872bc5", size = 278188, upload-time = "2026-05-07T03:09:34.69Z" },
+ { url = "https://files.pythonhosted.org/packages/9e/62/7b5644d995f4d71477918dd6597366889700ba51f7f2fa09e1e557ce6ac2/composio_client-1.38.0-py3-none-any.whl", hash = "sha256:7c183bb9f4721786db532fcd1bd71636403752ba655cd980fa971f89ba59a664", size = 284169, upload-time = "2026-05-11T18:16:09.461Z" },
]
[[package]]
name = "composio-crewai"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/crewai" }
dependencies = [
{ name = "composio" },
@@ -695,7 +695,7 @@ requires-dist = [
[[package]]
name = "composio-gemini"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/gemini" }
dependencies = [
{ name = "composio" },
@@ -710,7 +710,7 @@ requires-dist = [
[[package]]
name = "composio-google"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/google" }
dependencies = [
{ name = "composio" },
@@ -725,7 +725,7 @@ requires-dist = [
[[package]]
name = "composio-google-adk"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/google_adk" }
dependencies = [
{ name = "composio" },
@@ -740,7 +740,7 @@ requires-dist = [
[[package]]
name = "composio-langchain"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/langchain" }
dependencies = [
{ name = "composio" },
@@ -755,7 +755,7 @@ requires-dist = [
[[package]]
name = "composio-openai"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/openai" }
dependencies = [
{ name = "composio" },
@@ -770,7 +770,7 @@ requires-dist = [
[[package]]
name = "composio-openai-agents"
-version = "0.12.0"
+version = "0.13.0"
source = { virtual = "python/providers/openai_agents" }
dependencies = [
{ name = "composio" },