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
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.pyindex 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.pyindex 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 asession-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 establishedconnected_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+ raisereturn 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.pyindex 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 tfrom concurrent.futures import ThreadPoolExecutorfrom dataclasses import dataclass-from composio_client import Omit, omit+from composio_client import BadRequestError, Omit, omitfrom 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_paramsfrom composio.client.types import Toolfrom 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 exceptionsfrom composio.client import HttpClientfrom composio.core.models.connected_accounts import ConnectionRequestfrom 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 uniqueper 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.pyindex 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):passdiff --git a/python/pyproject.toml b/python/pyproject.tomlindex 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.pyindex 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 pindiff --git a/uv.lock b/uv.lockindex 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" },