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