@devries-cameron20 / composio Mirror · read-only / commits / a2db64a15
Fork 0

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

Mirrored from https://github.com/Camo67/composio.git

Synced Nov 21, 22:15 UTC

support preloaded custom tool schemas

Dhawal Upadhyay committed May 5, 2026 at 15:48 UTC a2db64a1503c10bd4961c14b473c0e57cd4e16d3
10 files changed +701 -28
python/composio/core/models/custom_tool.py
+42 -2
@@ -610,6 +610,7 @@ def build_custom_tools_map(
610 handle: CustomTool, final_slug: str, toolkit: t.Optional[str]
611 ) -> None:
612 original_slug = handle.slug.upper()
613 + final_slug_key = final_slug.upper()
614
615 if len(final_slug) > MAX_SLUG_LENGTH:
616 raise ValidationError(
@@ -617,7 +618,7 @@ def build_custom_tools_map(
618 f'"{final_slug}" which exceeds {MAX_SLUG_LENGTH} characters.'
619 )
620
620 - if final_slug in by_final_slug:
621 + if final_slug_key in by_final_slug:
622 raise ValidationError(
623 f'Custom tool slug collision: "{final_slug}" is already registered.'
624 )
@@ -634,7 +635,7 @@ def build_custom_tools_map(
635 entry = CustomToolsMapEntry(
636 handle=handle, final_slug=final_slug, toolkit=toolkit
637 )
637 - by_final_slug[final_slug] = entry
638 + by_final_slug[final_slug_key] = entry
639 by_original_slug[original_slug] = entry
640
641 # Process standalone tools
@@ -716,3 +717,42 @@ def build_custom_tools_map_from_response(
717 by_original_slug=by_original_slug,
718 toolkits=list(toolkits) if toolkits else None,
719 )
720 +
721 +
722 +def find_custom_tool_map_entry_by_final_slug(
723 + custom_tools_map: t.Optional[CustomToolsMap],
724 + slug: str,
725 +) -> t.Optional[CustomToolsMapEntry]:
726 + """Find a custom tool entry by final slug only."""
727 + if custom_tools_map is None:
728 + return None
729 + return custom_tools_map.by_final_slug.get(slug.upper())
730 +
731 +
732 +def get_preloaded_custom_tool_slugs(
733 + tool_router_tools: t.Optional[t.Iterable[str]],
734 + custom_tools_map: t.Optional[CustomToolsMap],
735 +) -> t.List[str]:
736 + """Return final custom tool slugs selected by the backend for preload."""
737 + if tool_router_tools is None or custom_tools_map is None:
738 + return []
739 +
740 + seen: t.Set[str] = set()
741 + custom_tool_slugs: t.List[str] = []
742 +
743 + for slug in tool_router_tools:
744 + entry = find_custom_tool_map_entry_by_final_slug(
745 + custom_tools_map,
746 + str(slug),
747 + )
748 + if entry is None:
749 + continue
750 +
751 + final_slug_key = entry.final_slug.upper()
752 + if final_slug_key in seen:
753 + continue
754 +
755 + seen.add(final_slug_key)
756 + custom_tool_slugs.append(entry.final_slug)
757 +
758 + return custom_tool_slugs
python/composio/core/models/tool_router.py
+64 -11
@@ -20,6 +20,7 @@ from composio.core.models.base import Resource
20 from composio.core.models.custom_tool import (
21 ExperimentalToolkit,
22 build_custom_tools_map_from_response,
23 + get_preloaded_custom_tool_slugs,
24 serialize_custom_tools,
25 serialize_custom_toolkits,
26 )
@@ -51,6 +52,7 @@ ToolRouterTag = t.Literal[
52 # +----------+------+------+
53 # Defaults to "standard" server-side when omitted.
54 SandboxSize = t.Literal["standard", "medium", "large", "xlarge"]
55 +SessionPreset = t.Literal["direct_tools"]
56
57
58 class ToolRouterToolkitsEnableConfig(te.TypedDict, total=False):
@@ -217,7 +219,34 @@ class ToolRouterPreloadConfig(te.TypedDict, total=False):
219 tool lists without first calling search.
220 """
221
220 - tools: t.List[str]
222 + tools: t.Union[t.List[str], str]
223 +
224 +
225 +def _session_preload_config(session: t.Any) -> ToolRouterSessionPreloadConfig:
226 + tools = session.config.preload.tools
227 + return ToolRouterSessionPreloadConfig(
228 + tools=tools if isinstance(tools, str) else list(tools or [])
229 + )
230 +
231 +
232 +def _apply_session_preset_defaults(
233 + session_preset: t.Optional[SessionPreset],
234 + manage_connections: t.Optional[t.Union[bool, ToolRouterManageConnectionsConfig]],
235 + workbench: t.Optional[ToolRouterWorkbenchConfig],
236 + preload: t.Optional[ToolRouterPreloadConfig],
237 +) -> t.Tuple[
238 + t.Optional[t.Union[bool, ToolRouterManageConnectionsConfig]],
239 + t.Optional[ToolRouterWorkbenchConfig],
240 + t.Optional[ToolRouterPreloadConfig],
241 +]:
242 + if session_preset != "direct_tools":
243 + return manage_connections, workbench, preload
244 +
245 + return (
246 + False if manage_connections is None else manage_connections,
247 + {"enable": False} if workbench is None else workbench,
248 + {"tools": "all"} if preload is None else preload,
249 + )
250
251
252 class ToolRouterAssistivePromptConfig(te.TypedDict, total=False):
@@ -497,6 +526,7 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
526 workbench: t.Optional[ToolRouterWorkbenchConfig] = None,
527 multi_account: t.Optional[ToolRouterMultiAccountConfig] = None,
528 preload: t.Optional[ToolRouterPreloadConfig] = None,
529 + session_preset: t.Optional[SessionPreset] = None,
530 experimental: t.Optional[ToolRouterExperimentalConfig] = None,
531 ) -> ToolRouterSession[TTool, TToolCollection]:
532 """
@@ -553,8 +583,7 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
583 Example: {'github': 'ac_xxx', 'slack': 'ac_yyy'}
584 :param connected_accounts: Optional mapping of toolkit slug to connected account ID.
585 Example: {'github': 'ca_xxx', 'slack': 'ca_yyy'}
556 - :param workbench: Optional workbench configuration (ToolRouterWorkbenchConfig).
557 - Dict with:
586 + :param workbench: Optional workbench configuration. Dict with:
587 - 'enable' (bool): Whether to enable the workbench entirely.
588 Defaults to True. When set to False, no code execution tools
589 (COMPOSIO_REMOTE_WORKBENCH, COMPOSIO_REMOTE_BASH_TOOL) are
@@ -579,9 +608,19 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
608 account selection when multiple accounts are connected.
609 Example: {'enable': True, 'max_accounts_per_toolkit': 3}
610 :param preload: Optional preload configuration. Dict with:
582 - - 'tools' (List[str]): Tool slugs to expose directly in
583 - session.tools() and MCP tool lists.
611 + - 'tools' (List[str] | 'all'): Tool slugs to expose directly in
612 + session.tools() and MCP tool lists. 'all' exposes every app
613 + tool allowed by positive session filters such as toolkits,
614 + tools, or tags; the backend validates and caps the final set.
615 Example: {'tools': ['GMAIL_FETCH_EMAILS']}
616 + :param session_preset: Optional session preset. 'direct_tools' exposes all tools
617 + allowed by the session filters directly in session.tools()
618 + and the MCP tool list, and disables meta tools by default
619 + (search, multi-execute, manage-connections, and workbench).
620 + Use when all needed tools are known upfront and helper/meta
621 + tools are not needed. Without this preset, ToolRouter uses
622 + the default configuration with meta tools enabled. Loading
623 + many tools can increase model context usage.
624 :param experimental: Optional experimental configuration (ToolRouterExperimentalConfig).
625 Note: These features are experimental and may change.
626 Dict with:
@@ -670,6 +709,14 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
709 ```
710 """
711
712 + direct_tools_preset = session_preset == "direct_tools"
713 + manage_connections, workbench, preload = _apply_session_preset_defaults(
714 + session_preset=session_preset,
715 + manage_connections=manage_connections,
716 + workbench=workbench,
717 + preload=preload,
718 + )
719 +
720 # Parse manage_connections config
721 manage_connections = (
722 manage_connections if manage_connections is not None else True
@@ -795,6 +842,10 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
842 if preload is not None:
843 create_params["preload"] = preload
844
845 + if direct_tools_preset:
846 + create_params["search"] = {"enable": False}
847 + create_params["execute"] = {"enable_multi_execute": False}
848 +
849 # Build experimental config
850 # Map SDK's experimental.assistive_prompt.user_timezone to API's
851 # experimental.assistive_prompt_config.user_timezone
@@ -845,6 +896,10 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
896 toolkits=custom_toolkits,
897 experimental=session.experimental,
898 )
899 + preloaded_custom_tool_slugs = get_preloaded_custom_tool_slugs(
900 + getattr(session, "tool_router_tools", None),
901 + custom_tools_map,
902 + )
903
904 # Transform experimental response:
905 # API's assistive_prompt -> SDK's assistive_prompt
@@ -873,9 +928,8 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
928 experimental=experimental_response,
929 custom_tools_map=custom_tools_map,
930 user_id=user_id,
876 - preload=ToolRouterSessionPreloadConfig(
877 - tools=list(session.config.preload.tools)
878 - ),
931 + preload=_session_preload_config(session),
932 + preloaded_custom_tool_slugs=preloaded_custom_tool_slugs,
933 )
934
935 def use(self, session_id: str) -> ToolRouterSession[TTool, TToolCollection]:
@@ -930,9 +984,7 @@ class ToolRouter(Resource, t.Generic[TTool, TToolCollection]):
984 url=session.mcp.url,
985 ),
986 experimental=experimental_response,
933 - preload=ToolRouterSessionPreloadConfig(
934 - tools=list(session.config.preload.tools)
935 - ),
987 + preload=_session_preload_config(session),
988 )
989
990
@@ -952,6 +1004,7 @@ __all__ = [
1004 "ToolRouterManageConnectionsConfig",
1005 "ToolRouterWorkbenchConfig",
1006 "SandboxSize",
1007 + "SessionPreset",
1008 "ToolRouterMultiAccountConfig",
1009 "ToolRouterPreloadConfig",
1010 "ToolRouterExperimentalConfig",
python/composio/core/models/tool_router_session.py
+103 -1
@@ -13,6 +13,12 @@ from concurrent.futures import ThreadPoolExecutor
13 from dataclasses import dataclass
14
15 from composio_client import omit
16 +from composio.client.types import Tool
17 +from composio_client.types.tool_list_response import (
18 + ItemDeprecated,
19 + ItemDeprecatedToolkit,
20 + ItemToolkit,
21 +)
22 from composio_client.types.tool_router.session_execute_response import (
23 SessionExecuteResponse,
24 )
@@ -25,6 +31,7 @@ from composio_client.types.tool_router.session_search_response import (
31
32 from composio.client import HttpClient
33 from composio.core.models.connected_accounts import ConnectionRequest
34 +from composio.core.models.custom_tool import find_custom_tool_map_entry_by_final_slug
35 from composio.core.models.custom_tool_execution import (
36 execute_custom_tool,
37 find_custom_tool,
@@ -48,6 +55,9 @@ if t.TYPE_CHECKING:
55 )
56
57 COMPOSIO_MULTI_EXECUTE_TOOL = "COMPOSIO_MULTI_EXECUTE_TOOL"
58 +DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX = (
59 + "[Direct tool - call directly, no search or connection check needed beforehand.]"
60 +)
61 MAX_PARALLEL_WORKERS = 5
62
63
@@ -55,7 +65,7 @@ MAX_PARALLEL_WORKERS = 5
65 class ToolRouterSessionPreloadConfig:
66 """Preloaded tools configured for a tool router session."""
67
58 - tools: t.List[str]
68 + tools: t.Union[t.List[str], str]
69
70
71 class ToolRouterSession(t.Generic[TTool, TToolCollection]):
@@ -94,6 +104,7 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
104 custom_tools_map: t.Optional[CustomToolsMap] = None,
105 user_id: t.Optional[str] = None,
106 preload: t.Optional[ToolRouterSessionPreloadConfig] = None,
107 + preloaded_custom_tool_slugs: t.Optional[t.List[str]] = None,
108 ) -> None:
109 self._client = client
110 self._provider = provider
@@ -107,6 +118,7 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
118 self.preload = preload or ToolRouterSessionPreloadConfig(tools=[])
119 self._custom_tools_map = custom_tools_map
120 self._user_id = user_id
121 + self._preloaded_custom_tool_slugs = preloaded_custom_tool_slugs or []
122
123 # Create singleton session context if custom tools are bound
124 self._session_context: t.Optional[SessionContextImpl] = None
@@ -168,6 +180,7 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
180 session_id=self.session_id,
181 modifiers=modifiers,
182 )
183 + router_tools = self._add_preloaded_custom_tools(router_tools, modifiers)
184
185 for tool in router_tools:
186 tool.input_parameters = (
@@ -201,6 +214,95 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
214 ),
215 )
216
217 + def _add_preloaded_custom_tools(
218 + self,
219 + tools: t.List[Tool],
220 + modifiers: t.Optional["Modifiers"],
221 + ) -> t.List[Tool]:
222 + custom_tools = self._get_preloaded_custom_tool_schemas(modifiers)
223 + if not custom_tools:
224 + return tools
225 +
226 + existing_slugs = {tool.slug.upper() for tool in tools}
227 + appended_tools = [
228 + tool for tool in custom_tools if tool.slug.upper() not in existing_slugs
229 + ]
230 + if not appended_tools:
231 + return tools
232 +
233 + return [*tools, *appended_tools]
234 +
235 + def _get_preloaded_custom_tool_schemas(
236 + self,
237 + modifiers: t.Optional["Modifiers"],
238 + ) -> t.List[Tool]:
239 + if not self._custom_tools_map or not self._preloaded_custom_tool_slugs:
240 + return []
241 +
242 + tools: t.List[Tool] = []
243 + for slug in self._preloaded_custom_tool_slugs:
244 + entry = find_custom_tool_map_entry_by_final_slug(
245 + self._custom_tools_map,
246 + slug,
247 + )
248 + if entry is None:
249 + continue
250 +
251 + tool = self._custom_tool_entry_to_tool(entry)
252 + if modifiers is not None:
253 + tool = t.cast(
254 + Tool,
255 + apply_modifier_by_type(
256 + modifiers=modifiers,
257 + toolkit=tool.toolkit.slug,
258 + tool=tool.slug,
259 + type="schema",
260 + schema=tool,
261 + ),
262 + )
263 + tools.append(tool)
264 +
265 + return tools
266 +
267 + def _custom_tool_entry_to_tool(self, entry: CustomToolsMapEntry) -> Tool:
268 + toolkit_slug = entry.toolkit or "custom"
269 + toolkit_name = (
270 + self._custom_toolkit_name(toolkit_slug) or entry.toolkit or "Custom"
271 + )
272 +
273 + return Tool(
274 + available_versions=[],
275 + deprecated=ItemDeprecated(
276 + available_versions=[],
277 + displayName=entry.handle.name,
278 + is_deprecated=False,
279 + toolkit=ItemDeprecatedToolkit(logo=""),
280 + version="latest",
281 + ),
282 + description=(
283 + f"{DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX}\n{entry.handle.description}"
284 + ),
285 + input_parameters=entry.handle.input_schema,
286 + is_deprecated=False,
287 + name=entry.handle.name,
288 + no_auth=entry.handle.extends_toolkit is None,
289 + output_parameters=entry.handle.output_schema or {},
290 + scopes=[],
291 + slug=entry.final_slug,
292 + tags=[],
293 + toolkit=ItemToolkit(logo="", name=toolkit_name, slug=toolkit_slug),
294 + version="latest",
295 + )
296 +
297 + def _custom_toolkit_name(self, toolkit_slug: str) -> t.Optional[str]:
298 + if self._custom_tools_map is None:
299 + return None
300 +
301 + for toolkit in self._custom_tools_map.toolkits or []:
302 + if toolkit.slug.lower() == toolkit_slug.lower():
303 + return toolkit.name
304 + return None
305 +
306 def _create_routing_execute_fn(
307 self,
308 tools_model: t.Any,
python/tests/test_tool_router.py
+122
@@ -3,7 +3,9 @@
3 from unittest.mock import MagicMock, patch
4
5 import pytest
6 +from pydantic import BaseModel, Field
7
8 +from composio.core.models.custom_tool import ExperimentalAPI
9 from composio.core.models.tool_router import (
10 ToolkitConnectionsDetails,
11 ToolkitConnectionState,
@@ -16,6 +18,15 @@ from composio.core.models.tool_router import (
18 ToolRouterToolkitsDisableConfig,
19 ToolRouterToolkitsEnableConfig,
20 )
21 +from composio.core.models.tool_router_session import (
22 + DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX,
23 +)
24 +
25 +experimental_api = ExperimentalAPI()
26 +
27 +
28 +class GrepInput(BaseModel):
29 + pattern: str = Field(description="Pattern to search for")
30
31
32 @pytest.fixture
@@ -604,6 +615,63 @@ class TestToolRouter:
615 assert kwargs["preload"] == {"tools": ["GMAIL_FETCH_EMAILS"]}
616 assert session.preload.tools == ["GMAIL_FETCH_EMAILS"]
617
618 + def test_create_session_with_preload_all(self, tool_router, mock_client):
619 + """preload tools='all' is forwarded and exposed on the session."""
620 + mock_client.tool_router.session.create.return_value.config.preload.tools = "all"
621 +
622 + session = tool_router.create(
623 + user_id="user_123",
624 + preload={"tools": "all"},
625 + )
626 +
627 + kwargs = mock_client.tool_router.session.create.call_args.kwargs
628 + assert kwargs["preload"] == {"tools": "all"}
629 + assert session.preload.tools == "all"
630 +
631 + def test_create_session_with_direct_tools_preset(self, tool_router, mock_client):
632 + """direct_tools applies SDK-side defaults for direct tool exposure."""
633 + mock_client.tool_router.session.create.return_value.config.preload.tools = "all"
634 +
635 + session = tool_router.create(
636 + user_id="user_123",
637 + session_preset="direct_tools",
638 + toolkits=["github"],
639 + )
640 +
641 + kwargs = mock_client.tool_router.session.create.call_args.kwargs
642 + assert kwargs["toolkits"] == {"enable": ["github"]}
643 + assert kwargs["manage_connections"] == {"enable": False}
644 + assert kwargs["workbench"] == {"enable": False}
645 + assert kwargs["preload"] == {"tools": "all"}
646 + assert kwargs["search"] == {"enable": False}
647 + assert kwargs["execute"] == {"enable_multi_execute": False}
648 + assert session.preload.tools == "all"
649 +
650 + def test_create_session_with_direct_tools_preset_overrides(
651 + self, tool_router, mock_client
652 + ):
653 + """Explicit user fields override direct_tools defaults."""
654 + mock_client.tool_router.session.create.return_value.config.preload.tools = [
655 + "GITHUB_CREATE_ISSUE"
656 + ]
657 +
658 + session = tool_router.create(
659 + user_id="user_123",
660 + session_preset="direct_tools",
661 + toolkits=["github"],
662 + manage_connections=True,
663 + workbench={"enable": True},
664 + preload={"tools": ["GITHUB_CREATE_ISSUE"]},
665 + )
666 +
667 + kwargs = mock_client.tool_router.session.create.call_args.kwargs
668 + assert kwargs["manage_connections"] == {"enable": True}
669 + assert kwargs["workbench"] == {"enable": True}
670 + assert kwargs["preload"] == {"tools": ["GITHUB_CREATE_ISSUE"]}
671 + assert kwargs["search"] == {"enable": False}
672 + assert kwargs["execute"] == {"enable_multi_execute": False}
673 + assert session.preload.tools == ["GITHUB_CREATE_ISSUE"]
674 +
675 def test_create_session_complex_config(self, tool_router, mock_client):
676 """Test creating a session with complex configuration."""
677 session = tool_router.create(
@@ -1073,6 +1141,60 @@ class TestToolRouter:
1141 assert [tool.slug for tool in wrapped_tools] == ["GMAIL_FETCH_EMAILS"]
1142 assert result == "mocked-wrapped-tools"
1143
1144 + @patch("composio.core.models.tools.Tools")
1145 + def test_tools_function_includes_preloaded_custom_tools(
1146 + self,
1147 + mock_tools_class,
1148 + tool_router,
1149 + mock_client,
1150 + mock_provider,
1151 + ):
1152 + """Custom tools preloaded by the create response are exposed locally."""
1153 +
1154 + @experimental_api.tool(
1155 + slug="GREP",
1156 + name="Grep",
1157 + description="Search local text",
1158 + )
1159 + def grep(input: GrepInput, ctx):
1160 + return {"matches": []}
1161 +
1162 + mock_response = mock_client.tool_router.session.create.return_value
1163 + mock_response.tool_router_tools = ["COMPOSIO_SEARCH_TOOLS", "server_grep"]
1164 + mock_response.experimental = MagicMock()
1165 + mock_response.experimental.assistive_prompt = None
1166 + mock_response.experimental.custom_toolkits = []
1167 + mock_custom_tool = MagicMock()
1168 + mock_custom_tool.slug = "SERVER_GREP"
1169 + mock_custom_tool.original_slug = "GREP"
1170 + mock_custom_tool.extends_toolkit = None
1171 + mock_response.experimental.custom_tools = [mock_custom_tool]
1172 +
1173 + mock_tools_instance = MagicMock()
1174 + mock_tool = MagicMock()
1175 + mock_tool.slug = "COMPOSIO_SEARCH_TOOLS"
1176 + mock_tool.toolkit.slug = "composio"
1177 + mock_tool.input_parameters = {}
1178 + mock_tools_instance.get_raw_tool_router_meta_tools.return_value = [mock_tool]
1179 + mock_tools_instance._file_helper.enhance_schema_descriptions.return_value = {}
1180 + mock_tools_class.return_value = mock_tools_instance
1181 + mock_provider.wrap_tools.return_value = "mocked-custom-tools"
1182 +
1183 + session = tool_router.create(
1184 + user_id="user_123",
1185 + experimental={"custom_tools": [grep]},
1186 + )
1187 + result = session.tools()
1188 +
1189 + wrapped_tools = mock_provider.wrap_tools.call_args.kwargs["tools"]
1190 + assert [tool.slug for tool in wrapped_tools] == [
1191 + "COMPOSIO_SEARCH_TOOLS",
1192 + "SERVER_GREP",
1193 + ]
1194 + assert DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX in wrapped_tools[1].description
1195 + assert wrapped_tools[1].toolkit.slug == "custom"
1196 + assert result == "mocked-custom-tools"
1197 +
1198 @patch("composio.core.models.tools.Tools")
1199 def test_tools_function_with_modifiers(
1200 self,
ts/packages/core/src/lib/toolRouterParams.ts
+1 -1
@@ -114,7 +114,7 @@ export const transformToolRouterManageConnectionsParams = (
114 export const transformToolRouterWorkbenchParams = (
115 params?: ToolRouterCreateSessionConfig['workbench']
116 ): SessionCreateParams.Workbench | undefined => {
117 - if (!params) {
117 + if (params === undefined) {
118 return undefined;
119 }
120
ts/packages/core/src/models/CustomTool.ts
+54 -3
@@ -284,6 +284,7 @@ export function buildCustomToolsMap(
284
285 const addEntry = (handle: CustomTool, finalSlug: string, toolkit?: string) => {
286 const originalSlug = handle.slug.toUpperCase();
287 + const finalSlugKey = finalSlug.toUpperCase();
288
289 // Length validated early in createCustomTool/createCustomToolkit, but check as safety net
290 if (finalSlug.length > MAX_SLUG_LENGTH) {
@@ -294,7 +295,7 @@ export function buildCustomToolsMap(
295 }
296
297 // Check cross-group collisions on final slug
297 - if (byFinalSlug.has(finalSlug)) {
298 + if (byFinalSlug.has(finalSlugKey)) {
299 throw new ValidationError(
300 `Custom tool slug collision: "${finalSlug}" is already registered.`
301 );
@@ -309,7 +310,7 @@ export function buildCustomToolsMap(
310 }
311
312 const entry: CustomToolsMapEntry = { handle, finalSlug, toolkit };
312 - byFinalSlug.set(finalSlug, entry);
313 + byFinalSlug.set(finalSlugKey, entry);
314 byOriginalSlug.set(originalSlug, entry);
315 };
316
@@ -415,7 +416,7 @@ export function buildCustomToolsMapFromResponse(
416 finalSlug,
417 toolkit: toolkit ?? match.toolkit,
418 };
418 - byFinalSlug.set(finalSlug, entry);
419 + byFinalSlug.set(finalSlug.toUpperCase(), entry);
420 byOriginalSlug.set(originalSlug.toUpperCase(), entry);
421 };
422
@@ -437,3 +438,53 @@ export function buildCustomToolsMapFromResponse(
438
439 return { byFinalSlug, byOriginalSlug, toolkits };
440 }
441 +
442 +/**
443 + * Find a custom tool entry by final slug only.
444 + *
445 + * @internal
446 + */
447 +export function findCustomToolMapEntryByFinalSlug(
448 + customToolsMap: CustomToolsMap | undefined,
449 + slug: string
450 +): CustomToolsMapEntry | undefined {
451 + return customToolsMap?.byFinalSlug.get(slug.toUpperCase());
452 +}
453 +
454 +/**
455 + * Resolve custom tools that the backend selected for direct preload.
456 + *
457 + * The backend is the source of truth for preload expansion, including "all".
458 + * The SDK only keeps the final custom slugs it can serve locally because
459 + * the session tools endpoint only returns backend-managed tool schemas.
460 + *
461 + * @internal
462 + */
463 +export function getPreloadedCustomToolSlugs(
464 + toolRouterTools: readonly string[] | undefined,
465 + customToolsMap: CustomToolsMap | undefined
466 +): string[] {
467 + if (!toolRouterTools?.length || !customToolsMap) {
468 + return [];
469 + }
470 +
471 + const seen = new Set<string>();
472 + const customToolSlugs: string[] = [];
473 +
474 + for (const slug of toolRouterTools) {
475 + const entry = findCustomToolMapEntryByFinalSlug(customToolsMap, slug);
476 + if (!entry) {
477 + continue;
478 + }
479 +
480 + const finalSlugKey = entry.finalSlug.toUpperCase();
481 + if (seen.has(finalSlugKey)) {
482 + continue;
483 + }
484 +
485 + seen.add(finalSlugKey);
486 + customToolSlugs.push(entry.finalSlug);
487 + }
488 +
489 + return customToolSlugs;
490 +}
ts/packages/core/src/models/ToolRouter.ts
+21 -1
@@ -46,6 +46,7 @@ import {
46 import { ToolRouterSession } from './ToolRouterSession';
47 import {
48 buildCustomToolsMapFromResponse,
49 + getPreloadedCustomToolSlugs,
50 serializeCustomTools,
51 serializeCustomToolkits,
52 } from './CustomTool';
@@ -109,6 +110,13 @@ export class ToolRouter<
110 * customToolkits: [myToolkit],
111 * },
112 * });
113 + *
114 + * // Expose all tools allowed by filters directly, without meta/helper tools.
115 + * // `preload.tools = "all"` requires a positive filter such as `toolkits`.
116 + * const directSession = await composio.create('user_123', {
117 + * sessionPreset: 'direct_tools',
118 + * toolkits: ['github'],
119 + * });
120 * ```
121 */
122 async create(
@@ -116,6 +124,7 @@ export class ToolRouter<
124 config?: ToolRouterCreateSessionConfig
125 ): Promise<Session<TToolCollection, TTool, TProvider>> {
126 const routerConfig = ToolRouterCreateSessionConfigSchema.parse(config ?? {});
127 + const isDirectToolsPreset = routerConfig.sessionPreset === 'direct_tools';
128
129 // Extract custom tools/toolkits from experimental config
130 const customTools = routerConfig.experimental?.customTools;
@@ -152,6 +161,10 @@ export class ToolRouter<
161 workbench: transformToolRouterWorkbenchParams(routerConfig.workbench),
162 multi_account: multiAccountPayload,
163 preload: routerConfig.preload,
164 + ...(isDirectToolsPreset && {
165 + search: { enable: false },
166 + execute: { enable_multi_execute: false },
167 + }),
168 experimental: Object.keys(experimentalPayload).length > 0 ? experimentalPayload : undefined,
169 };
170
@@ -167,6 +180,13 @@ export class ToolRouter<
180 session.experimental
181 );
182 }
183 + const metadata = {
184 + ...getSessionMetadata(session),
185 + preloadedCustomToolSlugs: getPreloadedCustomToolSlugs(
186 + session.tool_router_tools,
187 + customToolsMap
188 + ),
189 + };
190
191 const assistivePrompt = session.experimental?.assistive_prompt;
192
@@ -178,7 +198,7 @@ export class ToolRouter<
198 { assistivePrompt },
199 customToolsMap,
200 userId,
181 - getSessionMetadata(session)
201 + metadata
202 );
203 }
204
ts/packages/core/src/models/ToolRouterSession.ts
+78 -4
@@ -43,9 +43,12 @@ import type { SessionExecuteParams } from '@composio/client/resources/tool-route
43 import { SessionProxyExecuteParamsSchema } from '../types/toolRouter.types';
44 import { SessionContextImpl } from './SessionContext';
45 import { findCustomTool, executeCustomTool } from './customToolExecution';
46 +import { findCustomToolMapEntryByFinalSlug } from './CustomTool';
47 import { transformProxyParams } from './proxyParamsTransform';
48
49 const COMPOSIO_MULTI_EXECUTE_TOOL = 'COMPOSIO_MULTI_EXECUTE_TOOL';
50 +export const DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX =
51 + '[Direct tool - call directly, no search or connection check needed beforehand.]';
52
53 export class ToolRouterSession<
54 TToolCollection,
@@ -58,6 +61,7 @@ export class ToolRouterSession<
61 public readonly preload: ToolRouterSessionPreloadConfig;
62 public readonly configVersion?: number;
63 public readonly warnings: ToolRouterSessionWarning[];
64 + private readonly preloadedCustomToolSlugs: string[];
65
66 /** Singleton session context — shared across all custom tool executions */
67 private readonly sessionContext?: SessionContext;
@@ -84,6 +88,7 @@ export class ToolRouterSession<
88 this.preload = metadata?.preload ?? { tools: [] };
89 this.configVersion = metadata?.configVersion;
90 this.warnings = metadata?.warnings ?? [];
91 + this.preloadedCustomToolSlugs = metadata?.preloadedCustomToolSlugs ?? [];
92
93 // Create singleton session context if custom tools are bound
94 if (customToolsMap && userId) {
@@ -106,7 +111,8 @@ export class ToolRouterSession<
111 this.sessionId,
112 modifiers?.modifySchema ? { modifySchema: modifiers.modifySchema } : undefined
113 );
109 - const toolBySlug = new Map(tools.map(tool => [tool.slug.toUpperCase(), tool]));
114 + const sessionTools = await this.addPreloadedCustomTools(tools, modifiers);
115 + const toolBySlug = new Map(sessionTools.map(tool => [tool.slug.toUpperCase(), tool]));
116
117 if (this.hasCustomTools()) {
118 // Create an execute function that splits local/remote tools in COMPOSIO_MULTI_EXECUTE_TOOL
@@ -115,7 +121,7 @@ export class ToolRouterSession<
121 input: Record<string, unknown>
122 ): Promise<ToolExecuteResponse> => {
123 if (toolSlug === COMPOSIO_MULTI_EXECUTE_TOOL) {
118 - return this.routeMultiExecute(input, ToolsModel, tools, modifiers);
124 + return this.routeMultiExecute(input, ToolsModel, sessionTools, modifiers);
125 }
126 return ToolsModel.executeSessionTool(
127 toolSlug,
@@ -131,16 +137,84 @@ export class ToolRouterSession<
137 'Pass a provider in the Composio constructor.'
138 );
139 }
134 - return this.config.provider.wrapTools(tools, routingExecuteFn) as ReturnType<
140 + return this.config.provider.wrapTools(sessionTools, routingExecuteFn) as ReturnType<
141 TProvider['wrapTools']
142 >;
143 }
144
145 // Standard path (no local tools)
140 - const wrappedTools = ToolsModel.wrapToolsForToolRouter(this.sessionId, tools, modifiers);
146 + const wrappedTools = ToolsModel.wrapToolsForToolRouter(this.sessionId, sessionTools, modifiers);
147 return wrappedTools as ReturnType<TProvider['wrapTools']>;
148 }
149
150 + private async addPreloadedCustomTools(
151 + tools: Tool[],
152 + modifiers?: SessionMetaToolOptions
153 + ): Promise<Tool[]> {
154 + const customTools = await this.getPreloadedCustomToolSchemas(modifiers);
155 + if (!customTools.length) {
156 + return tools;
157 + }
158 +
159 + const existingSlugs = new Set(tools.map(tool => tool.slug.toUpperCase()));
160 + const appendedTools = customTools.filter(tool => !existingSlugs.has(tool.slug.toUpperCase()));
161 + if (!appendedTools.length) {
162 + return tools;
163 + }
164 +
165 + return [...tools, ...appendedTools];
166 + }
167 +
168 + private async getPreloadedCustomToolSchemas(modifiers?: SessionMetaToolOptions): Promise<Tool[]> {
169 + if (!this.customToolsMap || !this.preloadedCustomToolSlugs.length) {
170 + return [];
171 + }
172 +
173 + const tools: Tool[] = [];
174 + for (const slug of this.preloadedCustomToolSlugs) {
175 + const entry = findCustomToolMapEntryByFinalSlug(this.customToolsMap, slug);
176 + if (!entry) {
177 + continue;
178 + }
179 +
180 + let tool = this.customToolEntryToTool(entry);
181 + if (modifiers?.modifySchema) {
182 + tool = await modifiers.modifySchema({
183 + toolSlug: tool.slug,
184 + toolkitSlug: tool.toolkit?.slug ?? 'custom',
185 + schema: tool,
186 + });
187 + }
188 + tools.push(tool);
189 + }
190 + return tools;
191 + }
192 +
193 + private customToolEntryToTool(entry: CustomToolsMapEntry): Tool {
194 + const toolkitSlug = entry.toolkit ?? 'custom';
195 + const customToolkit = this.customToolsMap?.toolkits?.find(
196 + toolkit => toolkit.slug.toLowerCase() === toolkitSlug.toLowerCase()
197 + );
198 + const toolkitName = customToolkit?.name ?? entry.toolkit ?? 'Custom';
199 +
200 + return {
201 + slug: entry.finalSlug,
202 + name: entry.handle.name,
203 + description: `${DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX}\n${entry.handle.description}`,
204 + inputParameters: entry.handle.inputSchema as Tool['inputParameters'],
205 + outputParameters: entry.handle.outputSchema as Tool['outputParameters'],
206 + tags: [],
207 + toolkit: {
208 + slug: toolkitSlug,
209 + name: toolkitName,
210 + },
211 + isDeprecated: false,
212 + availableVersions: [],
213 + scopes: [],
214 + isNoAuth: !entry.handle.extendsToolkit,
215 + };
216 + }
217 +
218 /**
219 * List all custom tools registered in this session.
220 * Returns tools with their final slugs, schemas, and resolved toolkit.
ts/packages/core/src/types/toolRouter.types.ts
+36 -5
@@ -169,8 +169,15 @@ export const ToolRouterConfigToolsSchema = z
169 });
170 export type ToolRouterConfigTools = z.infer<typeof ToolRouterConfigToolsSchema>;
171
172 -export const ToolRouterCreateSessionConfigSchema = z
172 +const ToolRouterCreateSessionConfigBaseSchema = z
173 .object({
174 + sessionPreset: z
175 + .literal('direct_tools')
176 + .optional()
177 + .describe(
178 + 'Shortcut to expose every tool allowed by the session filters directly in session.tools() and the MCP tool list. This disables meta tools by default (search, multi-execute, manage-connections, and workbench). Use when all tools are known upfront and helper/meta tools are not needed. Without this preset, ToolRouter uses its default configuration with meta tools enabled.'
179 + ),
180 +
181 tools: z
182 .record(z.string(), z.union([ToolRouterToolsParamSchema, ToolRouterConfigToolsSchema]))
183 .optional()
@@ -225,7 +232,7 @@ export const ToolRouterCreateSessionConfigSchema = z
232 'The auto offload threshold in characters for the tool execution to be moved into workbench'
233 ),
234 sandboxSize: SandboxSizeSchema.optional().describe(
228 - 'Sandbox compute tier for the workbench. One of "standard" (1 vCPU / 1 GB), "medium" (2 vCPU / 2 GB), "large" (4 vCPU / 4 GB), or "xlarge" (8 vCPU / 8 GB). Defaults to "standard" server-side. Changing this on an existing session recreates the sandbox on next access; the session\'s in-memory FS is lost, but /mnt/files/ persists.'
235 + 'Sandbox compute tier for the workbench. One of "standard" (1 vCPU / 1 GB), "medium" (2 vCPU / 2 GB), "large" (4 vCPU / 4 GB), or "xlarge" (8 vCPU / 8 GB). Defaults to "standard" server-side. Changing this on an existing session recreates the session\'s workbench sandbox on next access; the in-memory FS is lost, but /mnt/files/ persists.'
236 ),
237 })
238 .optional()
@@ -258,10 +265,10 @@ export const ToolRouterCreateSessionConfigSchema = z
265 preload: z
266 .object({
267 tools: z
261 - .array(z.string())
268 + .union([z.array(z.string()), z.literal('all')])
269 .optional()
270 .describe(
264 - 'Tool slugs to preload into session.tools() and the MCP tool list. The backend validates slugs against the session filters.'
271 + 'Tool slugs to preload into session.tools() and the MCP tool list, or "all" to preload every app tool allowed by the session filters. "all" requires a positive filter such as toolkits, tools, or tags; the backend validates and caps the final tool set.'
272 ),
273 })
274 .strict()
@@ -299,9 +306,32 @@ export const ToolRouterCreateSessionConfigSchema = z
306 })
307 .partial()
308 .describe('The config for the tool router session');
309 +
310 +const applyDirectToolsPresetDefaults = (value: unknown): unknown => {
311 + if (!value || typeof value !== 'object' || Array.isArray(value)) {
312 + return value;
313 + }
314 +
315 + const config = value as Record<string, unknown>;
316 + if (config.sessionPreset !== 'direct_tools') {
317 + return value;
318 + }
319 +
320 + return {
321 + ...config,
322 + manageConnections: config.manageConnections === undefined ? false : config.manageConnections,
323 + workbench: config.workbench === undefined ? { enable: false } : config.workbench,
324 + preload: config.preload === undefined ? { tools: 'all' } : config.preload,
325 + };
326 +};
327 +
328 +export const ToolRouterCreateSessionConfigSchema = z
329 + .preprocess(applyDirectToolsPresetDefaults, ToolRouterCreateSessionConfigBaseSchema)
330 + .describe('The config for the tool router session');
331 /**
332 * The config for the tool router session.
333 *
334 + * @param {'direct_tools'} [sessionPreset] - Shortcut that exposes every tool allowed by the session filters directly in session.tools() and the MCP tool list. Disables search, multi-execute, manage-connections, and workbench by default; explicit overrides for supported fields still win. Without this preset, ToolRouter uses the default configuration with meta tools enabled.
335 * @param {ToolRouterToolkitsParamSchema | ToolRouterToolkitsDisabledConfigSchema | ToolRouterToolkitsEnabledConfigSchema} toolkits - The toolkits to use in the tool router session
336 * @param {Record<string, ToolRouterToolsParam | ToolRouterConfigTools>} tools - The tools to configure per toolkit (key is toolkit slug)
337 * @param {Array<'readOnlyHint' | 'destructiveHint' | 'idempotentHint' | 'openWorldHint'>} tags - Global tags to filter tools by behavior
@@ -320,7 +350,7 @@ export const ToolRouterCreateSessionConfigSchema = z
350 * @param {number} [multiAccount.maxAccountsPerToolkit] - Max connected accounts per toolkit (2-10, default 5)
351 * @param {boolean} [multiAccount.requireExplicitSelection] - When true, require explicit account selection when multiple accounts are connected
352 * @param {object} [preload] - Tools to preload into session.tools() and the MCP tool list
323 - * @param {string[]} [preload.tools] - Tool slugs to preload. Server-side validation ensures they exist and are allowed by the session filters.
353 + * @param {string[] | 'all'} [preload.tools] - Tool slugs to preload, or "all" to preload every app tool allowed by the session filters. "all" requires a positive filter such as toolkits, tools, or tags; the backend validates and caps the final tool set.
354 */
355 export type ToolRouterCreateSessionConfig = z.infer<typeof ToolRouterCreateSessionConfigSchema>;
356
@@ -544,6 +574,7 @@ export interface ToolRouterSessionMetadata {
574 preload?: ToolRouterSessionPreloadConfig;
575 configVersion?: number;
576 warnings?: ToolRouterSessionWarning[];
577 + preloadedCustomToolSlugs?: string[];
578 }
579
580 export const SessionProxyExecuteParamsSchema = z.object({
ts/packages/core/test/models/toolRouter.test.ts
+180
@@ -1,4 +1,5 @@
1 import { describe, it, expect, vi, beforeEach } from 'vitest';
2 +import { z } from 'zod/v3';
3 import { ToolRouter } from '../../src/models/ToolRouter';
4 import ComposioClient from '@composio/client';
5 import { telemetry } from '../../src/telemetry/Telemetry';
@@ -6,6 +7,8 @@ import { MockProvider } from '../utils/mocks/provider.mock';
7 import { Tools } from '../../src/models/Tools';
8 import { ConnectedAccountStatuses } from '../../src/types/connectedAccounts.types';
9 import { ToolRouterCreateSessionConfig, Session } from '../../src/types/toolRouter.types';
10 +import { createCustomTool } from '../../src/models/CustomTool';
11 +import { DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX } from '../../src/models/ToolRouterSession';
12
13 // Mock dependencies
14 vi.mock('../../src/telemetry/Telemetry', () => ({
@@ -262,6 +265,106 @@ describe('ToolRouter', () => {
265 expect(session.configVersion).toBe(2);
266 });
267
268 + it('should create a session with preload all', async () => {
269 + mockClient.toolRouter.session.create.mockResolvedValueOnce({
270 + ...mockSessionCreateResponse,
271 + config: {
272 + preload: { tools: 'all' },
273 + },
274 + config_version: 2,
275 + });
276 +
277 + const session = await toolRouter.create(userId, {
278 + toolkits: ['github'],
279 + preload: { tools: 'all' },
280 + });
281 +
282 + expect(mockClient.toolRouter.session.create).toHaveBeenCalledWith({
283 + user_id: userId,
284 + toolkits: {
285 + enable: ['github'],
286 + },
287 + auth_configs: undefined,
288 + connected_accounts: undefined,
289 + tools: undefined,
290 + tags: undefined,
291 + manage_connections: createExpectedManageConnections(),
292 + workbench: undefined,
293 + preload: { tools: 'all' },
294 + });
295 +
296 + expect(session.preload.tools).toBe('all');
297 + });
298 +
299 + it('should apply the direct_tools session preset defaults', async () => {
300 + mockClient.toolRouter.session.create.mockResolvedValueOnce({
301 + ...mockSessionCreateResponse,
302 + config: {
303 + preload: { tools: 'all' },
304 + },
305 + });
306 +
307 + const session = await toolRouter.create(userId, {
308 + sessionPreset: 'direct_tools',
309 + toolkits: ['github'],
310 + });
311 +
312 + expect(mockClient.toolRouter.session.create).toHaveBeenCalledWith({
313 + user_id: userId,
314 + toolkits: {
315 + enable: ['github'],
316 + },
317 + auth_configs: undefined,
318 + connected_accounts: undefined,
319 + tools: undefined,
320 + tags: undefined,
321 + manage_connections: { enable: false },
322 + workbench: { enable: false },
323 + multi_account: undefined,
324 + preload: { tools: 'all' },
325 + search: { enable: false },
326 + execute: { enable_multi_execute: false },
327 + experimental: undefined,
328 + });
329 + expect(session.preload.tools).toBe('all');
330 + });
331 +
332 + it('should respect explicit overrides with the direct_tools session preset', async () => {
333 + mockClient.toolRouter.session.create.mockResolvedValueOnce({
334 + ...mockSessionCreateResponse,
335 + config: {
336 + preload: { tools: ['GITHUB_CREATE_ISSUE'] },
337 + },
338 + });
339 +
340 + const session = await toolRouter.create(userId, {
341 + sessionPreset: 'direct_tools',
342 + toolkits: ['github'],
343 + manageConnections: true,
344 + workbench: { enable: true },
345 + preload: { tools: ['GITHUB_CREATE_ISSUE'] },
346 + });
347 +
348 + expect(mockClient.toolRouter.session.create).toHaveBeenCalledWith({
349 + user_id: userId,
350 + toolkits: {
351 + enable: ['github'],
352 + },
353 + auth_configs: undefined,
354 + connected_accounts: undefined,
355 + tools: undefined,
356 + tags: undefined,
357 + manage_connections: { enable: true },
358 + workbench: { enable: true },
359 + multi_account: undefined,
360 + preload: { tools: ['GITHUB_CREATE_ISSUE'] },
361 + search: { enable: false },
362 + execute: { enable_multi_execute: false },
363 + experimental: undefined,
364 + });
365 + expect(session.preload.tools).toEqual(['GITHUB_CREATE_ISSUE']);
366 + });
367 +
368 it('should create a session with user ID only and verify MCP type transformation', async () => {
369 mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
370
@@ -2240,6 +2343,83 @@ describe('ToolRouter', () => {
2343 expect(tools).toBe('mocked-wrapped-tools');
2344 });
2345
2346 + it('should include preloaded custom tools selected by the create response', async () => {
2347 + const grepTool = createCustomTool('GREP', {
2348 + name: 'Grep',
2349 + description: 'Search local text',
2350 + inputParams: z.object({
2351 + pattern: z.string().describe('Pattern to search for'),
2352 + }),
2353 + execute: vi.fn(async () => ({ matches: [] })),
2354 + });
2355 +
2356 + mockClient.toolRouter.session.create.mockResolvedValueOnce({
2357 + ...mockSessionCreateResponse,
2358 + tool_router_tools: ['COMPOSIO_SEARCH_TOOLS', 'server_grep'],
2359 + experimental: {
2360 + custom_tools: [
2361 + {
2362 + slug: 'SERVER_GREP',
2363 + original_slug: 'GREP',
2364 + extends_toolkit: null,
2365 + },
2366 + ],
2367 + },
2368 + });
2369 + mockProvider.wrapTools.mockReturnValue('mocked-custom-tools');
2370 +
2371 + const session = await toolRouter.create(userId, {
2372 + experimental: { customTools: [grepTool] },
2373 + });
2374 + const tools = await session.tools();
2375 +
2376 + expect(mockProvider.wrapTools).toHaveBeenCalledTimes(1);
2377 + const wrappedTools = mockProvider.wrapTools.mock.calls[0][0] as Array<{
2378 + slug: string;
2379 + description?: string;
2380 + toolkit?: { slug: string; name: string };
2381 + }>;
2382 + expect(wrappedTools.map(tool => tool.slug)).toEqual(['COMPOSIO_SEARCH_TOOLS', 'SERVER_GREP']);
2383 + expect(wrappedTools[1].description).toContain(DIRECT_CUSTOM_TOOL_DESCRIPTION_PREFIX);
2384 + expect(wrappedTools[1].toolkit).toEqual({ slug: 'custom', name: 'Custom' });
2385 + expect(tools).toBe('mocked-custom-tools');
2386 + });
2387 +
2388 + it('should not expose custom tools unless the backend preloaded them', async () => {
2389 + const grepTool = createCustomTool('GREP', {
2390 + name: 'Grep',
2391 + description: 'Search local text',
2392 + inputParams: z.object({
2393 + pattern: z.string(),
2394 + }),
2395 + execute: vi.fn(async () => ({ matches: [] })),
2396 + });
2397 +
2398 + mockClient.toolRouter.session.create.mockResolvedValueOnce({
2399 + ...mockSessionCreateResponse,
2400 + tool_router_tools: ['COMPOSIO_SEARCH_TOOLS'],
2401 + experimental: {
2402 + custom_tools: [
2403 + {
2404 + slug: 'LOCAL_GREP',
2405 + original_slug: 'GREP',
2406 + extends_toolkit: null,
2407 + },
2408 + ],
2409 + },
2410 + });
2411 + mockProvider.wrapTools.mockReturnValue('mocked-custom-tools');
2412 +
2413 + const session = await toolRouter.create(userId, {
2414 + preload: { tools: 'all' },
2415 + experimental: { customTools: [grepTool] },
2416 + });
2417 + await session.tools();
2418 +
2419 + const wrappedTools = mockProvider.wrapTools.mock.calls[0][0] as Array<{ slug: string }>;
2420 + expect(wrappedTools.map(tool => tool.slug)).toEqual(['COMPOSIO_SEARCH_TOOLS']);
2421 + });
2422 +
2423 it('should handle tools fetching errors', async () => {
2424 mockClient.toolRouter.session.create.mockResolvedValueOnce(mockSessionCreateResponse);
2425