28
29
from composio.core.models.custom_tool import (
30
ExperimentalToolkit,
31
+ assert_no_custom_tool_slugs_in_preload,
32
build_custom_tools_map,
33
build_custom_tools_map_from_response,
34
serialize_custom_toolkits,
35
serialize_custom_tools,
36
)
37
from composio.core.models.custom_tool_execution import (
38
+ assert_unambiguous_custom_tool_slug,
39
execute_custom_tool,
40
find_custom_tool,
41
)
76
return grep
77
78
79
+@pytest.fixture
80
+def duplicate_slug_tools():
81
+ @exp.tool(slug="GREP")
82
+ def alpha_grep(input: GrepInput, ctx):
83
+ """Search Alpha."""
84
+ return {"toolkit": "alpha", "matches": [input.pattern]}
85
+
86
+ @exp.tool(slug="GREP")
87
+ def beta_grep(input: GrepInput, ctx):
88
+ """Search Beta."""
89
+ return {"toolkit": "beta", "matches": [input.pattern]}
90
+
91
+ return alpha_grep, beta_grep
92
+
93
+
94
@pytest.fixture
95
def email_tool():
96
@exp.tool(extends_toolkit="gmail")
476
m = build_custom_tools_map([], [role_toolkit])
477
assert "LOCAL_ROLE_MANAGER_SET_ROLE" in m.by_final_slug
478
479
+ def test_allows_same_slug_in_different_toolkits(self, duplicate_slug_tools):
480
+ alpha_tool, beta_tool = duplicate_slug_tools
481
+ alpha = ExperimentalToolkit(
482
+ slug="ALPHA", name="Alpha", description="Alpha tools"
483
+ )
484
+ alpha._tools.append(alpha_tool)
485
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
486
+ beta._tools.append(beta_tool)
487
+
488
+ m = build_custom_tools_map([], [alpha, beta])
489
+
490
+ assert set(m.by_final_slug) == {"LOCAL_ALPHA_GREP", "LOCAL_BETA_GREP"}
491
+ assert "GREP" not in m.by_original_slug
492
+ assert m.ambiguous_original_slugs == {"GREP"}
493
+
494
+ def test_ambiguous_original_slug_requires_final_slug(self, duplicate_slug_tools):
495
+ alpha_tool, beta_tool = duplicate_slug_tools
496
+ alpha = ExperimentalToolkit(
497
+ slug="ALPHA", name="Alpha", description="Alpha tools"
498
+ )
499
+ alpha._tools.append(alpha_tool)
500
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
501
+ beta._tools.append(beta_tool)
502
+ m = build_custom_tools_map([], [alpha, beta])
503
+
504
+ assert find_custom_tool(m, "LOCAL_ALPHA_GREP").toolkit == "ALPHA"
505
+ assert find_custom_tool(m, "LOCAL_BETA_GREP").toolkit == "BETA"
506
+ assert find_custom_tool(m, "GREP") is None
507
+ with pytest.raises(ValidationError, match="Ambiguous custom tool slug"):
508
+ assert_unambiguous_custom_tool_slug(m, "GREP")
509
+
510
+ def test_preload_rejects_ambiguous_original_slug(self, duplicate_slug_tools):
511
+ alpha_tool, beta_tool = duplicate_slug_tools
512
+ alpha = ExperimentalToolkit(
513
+ slug="ALPHA", name="Alpha", description="Alpha tools"
514
+ )
515
+ alpha._tools.append(alpha_tool)
516
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
517
+ beta._tools.append(beta_tool)
518
+ m = build_custom_tools_map([], [alpha, beta])
519
+
520
+ with pytest.raises(ValidationError, match="not supported in preload.tools"):
521
+ assert_no_custom_tool_slugs_in_preload(["grep"], m)
522
+
523
def test_collision_detection(self, grep_tool):
524
with pytest.raises(ValidationError, match="collision"):
525
build_custom_tools_map([grep_tool, grep_tool])
526
527
+ def test_rejects_standalone_and_toolkit_same_slug(self, duplicate_slug_tools):
528
+ alpha_tool, beta_tool = duplicate_slug_tools
529
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
530
+ beta._tools.append(beta_tool)
531
+
532
+ with pytest.raises(ValidationError, match="collision"):
533
+ build_custom_tools_map([alpha_tool], [beta])
534
+
535
536
class TestFindCustomTool:
537
def test_find_by_final_slug(self, grep_tool):
575
assert "LOCAL_GMAIL_GET_EMAILS" in m.by_final_slug
576
assert "LOCAL_ROLE_MANAGER_SET_ROLE" in m.by_final_slug
577
578
+ def test_allows_same_slug_in_different_toolkits(self, duplicate_slug_tools):
579
+ alpha_tool, beta_tool = duplicate_slug_tools
580
+ alpha = ExperimentalToolkit(
581
+ slug="ALPHA", name="Alpha", description="Alpha tools"
582
+ )
583
+ alpha._tools.append(alpha_tool)
584
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
585
+ beta._tools.append(beta_tool)
586
+ mock_exp = MagicMock()
587
+ mock_exp.custom_tools = []
588
+ mock_exp.custom_toolkits = [
589
+ MagicMock(
590
+ slug="ALPHA",
591
+ tools=[MagicMock(slug="LOCAL_ALPHA_GREP", original_slug="GREP")],
592
+ ),
593
+ MagicMock(
594
+ slug="BETA",
595
+ tools=[MagicMock(slug="LOCAL_BETA_GREP", original_slug="GREP")],
596
+ ),
597
+ ]
598
+
599
+ m = build_custom_tools_map_from_response([], [alpha, beta], mock_exp)
600
+
601
+ assert set(m.by_final_slug) == {"LOCAL_ALPHA_GREP", "LOCAL_BETA_GREP"}
602
+ assert m.by_final_slug["LOCAL_ALPHA_GREP"].toolkit == "ALPHA"
603
+ assert m.by_final_slug["LOCAL_BETA_GREP"].toolkit == "BETA"
604
+ assert m.ambiguous_original_slugs == {"GREP"}
605
+
606
+ def _duplicate_toolkits(self, duplicate_slug_tools):
607
+ alpha_tool, beta_tool = duplicate_slug_tools
608
+ alpha = ExperimentalToolkit(
609
+ slug="ALPHA", name="Alpha", description="Alpha tools"
610
+ )
611
+ alpha._tools.append(alpha_tool)
612
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
613
+ beta._tools.append(beta_tool)
614
+ return alpha, beta
615
+
616
+ def test_rejects_toolkit_child_without_exact_match(self, duplicate_slug_tools):
617
+ alpha, beta = self._duplicate_toolkits(duplicate_slug_tools)
618
+ mock_exp = MagicMock()
619
+ mock_exp.custom_tools = []
620
+ mock_exp.custom_toolkits = [
621
+ MagicMock(
622
+ slug="GAMMA",
623
+ tools=[MagicMock(slug="LOCAL_GAMMA_GREP", original_slug="GREP")],
624
+ ),
625
+ ]
626
+
627
+ with pytest.raises(ValidationError, match="no exact local match"):
628
+ build_custom_tools_map_from_response([], [alpha, beta], mock_exp)
629
+
630
+ def test_never_binds_toolkit_child_to_another_toolkit(self, duplicate_slug_tools):
631
+ alpha_tool, _ = duplicate_slug_tools
632
+ alpha = ExperimentalToolkit(
633
+ slug="ALPHA", name="Alpha", description="Alpha tools"
634
+ )
635
+ alpha._tools.append(alpha_tool)
636
+ mock_exp = MagicMock()
637
+ mock_exp.custom_tools = []
638
+ mock_exp.custom_toolkits = [
639
+ MagicMock(
640
+ slug="BETA",
641
+ tools=[MagicMock(slug="LOCAL_BETA_GREP", original_slug="GREP")],
642
+ ),
643
+ ]
644
+
645
+ with pytest.raises(ValidationError, match='for toolkit "BETA"'):
646
+ build_custom_tools_map_from_response([], [alpha], mock_exp)
647
+
648
+ def test_standalone_falls_back_to_unique_bare_match(self, email_tool):
649
+ mock_exp = MagicMock()
650
+ mock_exp.custom_tools = [
651
+ MagicMock(
652
+ slug="LOCAL_GMAIL_GET_EMAILS",
653
+ original_slug="GET_EMAILS",
654
+ extends_toolkit=None,
655
+ )
656
+ ]
657
+ mock_exp.custom_toolkits = []
658
+
659
+ m = build_custom_tools_map_from_response([email_tool], None, mock_exp)
660
+
661
+ assert m.by_final_slug["LOCAL_GMAIL_GET_EMAILS"].toolkit == "gmail"
662
+
663
+ def test_skips_response_tools_not_defined_locally(self, grep_tool):
664
+ mock_exp = MagicMock()
665
+ mock_exp.custom_tools = [
666
+ MagicMock(slug="LOCAL_GREP", original_slug="GREP", extends_toolkit=None),
667
+ MagicMock(slug="LOCAL_STALE", original_slug="STALE", extends_toolkit=None),
668
+ ]
669
+ mock_exp.custom_toolkits = []
670
+
671
+ m = build_custom_tools_map_from_response([grep_tool], None, mock_exp)
672
+
673
+ assert set(m.by_final_slug) == {"LOCAL_GREP"}
674
+
675
+ def test_ambiguity_follows_local_definitions(self, duplicate_slug_tools):
676
+ alpha, beta = self._duplicate_toolkits(duplicate_slug_tools)
677
+ mock_exp = MagicMock()
678
+ mock_exp.custom_tools = []
679
+ mock_exp.custom_toolkits = [
680
+ MagicMock(
681
+ slug="ALPHA",
682
+ tools=[MagicMock(slug="LOCAL_ALPHA_GREP", original_slug="GREP")],
683
+ ),
684
+ ]
685
+
686
+ m = build_custom_tools_map_from_response([], [alpha, beta], mock_exp)
687
+
688
+ assert set(m.by_final_slug) == {"LOCAL_ALPHA_GREP"}
689
+ assert "GREP" not in m.by_original_slug
690
+ assert m.ambiguous_original_slugs == {"GREP"}
691
+ assert find_custom_tool(m, "GREP") is None
692
+
693
+ def test_rejects_duplicate_qualified_response_entries(self, duplicate_slug_tools):
694
+ alpha, beta = self._duplicate_toolkits(duplicate_slug_tools)
695
+ mock_exp = MagicMock()
696
+ mock_exp.custom_tools = []
697
+ mock_exp.custom_toolkits = [
698
+ MagicMock(
699
+ slug="ALPHA",
700
+ tools=[
701
+ MagicMock(slug="LOCAL_ALPHA_GREP", original_slug="GREP"),
702
+ MagicMock(slug="LOCAL_ALPHA_GREP_2", original_slug="GREP"),
703
+ ],
704
+ ),
705
+ ]
706
+
707
+ with pytest.raises(ValidationError, match="already registered for toolkit"):
708
+ build_custom_tools_map_from_response([], [alpha, beta], mock_exp)
709
+
710
711
# ────────────────────────────────────────────────────────────────
712
# Execution tests
757
assert result.log_id == ""
758
assert result.data["matches"] == ["test"]
759
760
+ def test_sibling_routing_rejects_ambiguous_slug(self, duplicate_slug_tools):
761
+ alpha_tool, beta_tool = duplicate_slug_tools
762
+ alpha = ExperimentalToolkit(
763
+ slug="ALPHA", name="Alpha", description="Alpha tools"
764
+ )
765
+ alpha._tools.append(alpha_tool)
766
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
767
+ beta._tools.append(beta_tool)
768
+ m = build_custom_tools_map([], [alpha, beta])
769
+ mock_client = MagicMock()
770
+ ctx = SessionContextImpl(
771
+ client=mock_client, user_id="u", session_id="s", custom_tools_map=m
772
+ )
773
+
774
+ with pytest.raises(ValidationError, match="Ambiguous custom tool slug"):
775
+ ctx.execute("GREP", {"pattern": "x"})
776
+ mock_client.tool_router.session.execute.assert_not_called()
777
+
778
+ result = ctx.execute("LOCAL_BETA_GREP", {"pattern": "x"})
779
+ assert result.data["toolkit"] == "beta"
780
+
781
def test_remote_fallback(self, grep_tool):
782
m = build_custom_tools_map([grep_tool])
783
mock_client = MagicMock()
1060
assert len(tks) == 1
1061
assert tks[0].slug == "ROLE_MANAGER"
1062
1063
+ def test_custom_toolkits_list_uses_qualified_slugs(self, duplicate_slug_tools):
1064
+ alpha_tool, beta_tool = duplicate_slug_tools
1065
+ alpha = ExperimentalToolkit(
1066
+ slug="ALPHA", name="Alpha", description="Alpha tools"
1067
+ )
1068
+ alpha._tools.append(alpha_tool)
1069
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
1070
+ beta._tools.append(beta_tool)
1071
+ custom_tools_map = build_custom_tools_map([], [alpha, beta])
1072
+ s = ToolRouterSession(
1073
+ client=MagicMock(),
1074
+ provider=MagicMock(),
1075
+ dangerously_allow_auto_upload_download_files=True,
1076
+ session_id="s",
1077
+ mcp=MagicMock(),
1078
+ experimental=MagicMock(),
1079
+ custom_tools_map=custom_tools_map,
1080
+ user_id="u",
1081
+ )
1082
+
1083
+ toolkits = s.custom_toolkits()
1084
+
1085
+ assert [tk.tools[0].slug for tk in toolkits] == [
1086
+ "LOCAL_ALPHA_GREP",
1087
+ "LOCAL_BETA_GREP",
1088
+ ]
1089
+
1090
+ def test_custom_toolkits_list_never_borrows_other_toolkit_slug(
1091
+ self, duplicate_slug_tools
1092
+ ):
1093
+ alpha_tool, beta_tool = duplicate_slug_tools
1094
+ alpha = ExperimentalToolkit(
1095
+ slug="ALPHA", name="Alpha", description="Alpha tools"
1096
+ )
1097
+ alpha._tools.append(alpha_tool)
1098
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
1099
+ beta._tools.append(beta_tool)
1100
+ mock_exp = MagicMock()
1101
+ mock_exp.custom_tools = []
1102
+ mock_exp.custom_toolkits = [
1103
+ MagicMock(
1104
+ slug="ALPHA",
1105
+ tools=[MagicMock(slug="LOCAL_ALPHA_GREP", original_slug="GREP")],
1106
+ ),
1107
+ ]
1108
+ custom_tools_map = build_custom_tools_map_from_response(
1109
+ [], [alpha, beta], mock_exp
1110
+ )
1111
+ s = ToolRouterSession(
1112
+ client=MagicMock(),
1113
+ provider=MagicMock(),
1114
+ dangerously_allow_auto_upload_download_files=True,
1115
+ session_id="s",
1116
+ mcp=MagicMock(),
1117
+ experimental=MagicMock(),
1118
+ custom_tools_map=custom_tools_map,
1119
+ user_id="u",
1120
+ )
1121
+
1122
+ assert [tk.tools[0].slug for tk in s.custom_toolkits()] == [
1123
+ "LOCAL_ALPHA_GREP",
1124
+ "GREP",
1125
+ ]
1126
+
1127
+ def test_execute_rejects_ambiguous_original_slug(self, duplicate_slug_tools):
1128
+ alpha_tool, beta_tool = duplicate_slug_tools
1129
+ alpha = ExperimentalToolkit(
1130
+ slug="ALPHA", name="Alpha", description="Alpha tools"
1131
+ )
1132
+ alpha._tools.append(alpha_tool)
1133
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
1134
+ beta._tools.append(beta_tool)
1135
+ custom_tools_map = build_custom_tools_map([], [alpha, beta])
1136
+ client = MagicMock()
1137
+ s = ToolRouterSession(
1138
+ client=client,
1139
+ provider=MagicMock(),
1140
+ dangerously_allow_auto_upload_download_files=True,
1141
+ session_id="s",
1142
+ mcp=MagicMock(),
1143
+ experimental=MagicMock(),
1144
+ custom_tools_map=custom_tools_map,
1145
+ user_id="u",
1146
+ )
1147
+
1148
+ with pytest.raises(ValidationError, match="Ambiguous custom tool slug"):
1149
+ s.execute("GREP", arguments={"pattern": "x"})
1150
+ client.tool_router.session.execute.assert_not_called()
1151
+
1152
+ alpha_result = s.execute("LOCAL_ALPHA_GREP", arguments={"pattern": "x"})
1153
+ beta_result = s.execute("LOCAL_BETA_GREP", arguments={"pattern": "x"})
1154
+ assert alpha_result.data["toolkit"] == "alpha"
1155
+ assert beta_result.data["toolkit"] == "beta"
1156
+
1157
def test_empty_when_no_map(self):
1158
s = ToolRouterSession(
1159
client=MagicMock(),
1195
assert result["successful"] is True
1196
assert result["data"]["matches"] == ["x"]
1197
1198
+ def test_rejects_ambiguous_original_slug(self, duplicate_slug_tools):
1199
+ alpha_tool, beta_tool = duplicate_slug_tools
1200
+ alpha = ExperimentalToolkit(
1201
+ slug="ALPHA", name="Alpha", description="Alpha tools"
1202
+ )
1203
+ alpha._tools.append(alpha_tool)
1204
+ beta = ExperimentalToolkit(slug="BETA", name="Beta", description="Beta tools")
1205
+ beta._tools.append(beta_tool)
1206
+ s = ToolRouterSession(
1207
+ client=MagicMock(),
1208
+ provider=MagicMock(),
1209
+ dangerously_allow_auto_upload_download_files=True,
1210
+ session_id="s",
1211
+ mcp=MagicMock(),
1212
+ experimental=MagicMock(),
1213
+ custom_tools_map=build_custom_tools_map([], [alpha, beta]),
1214
+ user_id="u",
1215
+ )
1216
+ tm = MagicMock()
1217
+ backend = MagicMock()
1218
+ tm._wrap_execute_tool_for_tool_router.return_value = backend
1219
+
1220
+ with pytest.raises(ValidationError, match="Ambiguous custom tool slug"):
1221
+ s._route_multi_execute(
1222
+ {
1223
+ "tools": [
1224
+ {
1225
+ "tool_slug": "LOCAL_ALPHA_GREP",
1226
+ "arguments": {"pattern": "x"},
1227
+ },
1228
+ {"tool_slug": "GREP", "arguments": {"pattern": "x"}},
1229
+ ]
1230
+ },
1231
+ tm,
1232
+ )
1233
+ backend.assert_not_called()
1234
+
1235
def test_all_remote(self, grep_tool):
1236
s = self._make_session(grep_tool)
1237
tm = MagicMock()