@devries-cameron20 / composio Mirror · read-only
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, 03:37 UTC

next
py 1,348 lines 46.3 KB
Raw
1 """Test provider functionality.
2
3 This test module verifies provider functionality including:
4 - Provider initialization
5 - execute_tool function setup and usage
6 - Provider helper methods
7 - Both agentic and non-agentic provider behavior
8 """
9
10 import importlib.util
11 from types import SimpleNamespace
12 from unittest.mock import Mock, call
13
14 import pytest
15 from pydantic import ValidationError
16
17 from composio.client.types import Tool, tool_list_response
18 from composio.core.models.base import allow_tracking
19 from composio.core.models.tools import Tools
20 from composio.core.provider import AgenticProvider, NonAgenticProvider
21 from tests.conftest import mock_http_client
22 from tests.fixtures.json_schema_conversion_corpus import find_case
23
24
25 @pytest.fixture(autouse=True)
26 def disable_telemetry():
27 """Disable telemetry for all tests to prevent thread issues."""
28 token = allow_tracking.set(False)
29 yield
30 allow_tracking.reset(token)
31
32
33 def create_mock_tool(
34 slug: str, toolkit_slug: str, version: str = "12012025_00"
35 ) -> Tool:
36 """Create a mock tool for testing."""
37 return Tool(
38 name=f"Test {slug}",
39 slug=slug,
40 description="Test tool for provider testing",
41 input_parameters={"type": "object", "properties": {}},
42 output_parameters={},
43 available_versions=[version],
44 version=version,
45 scopes=[],
46 toolkit=tool_list_response.ItemToolkit(
47 name=toolkit_slug.title(), slug=toolkit_slug, logo=""
48 ),
49 deprecated=tool_list_response.ItemDeprecated(
50 available_versions=[version],
51 displayName=f"Test {slug}",
52 version=version,
53 toolkit=tool_list_response.ItemDeprecatedToolkit(logo=""),
54 is_deprecated=False,
55 ),
56 is_deprecated=False,
57 no_auth=False,
58 tags=[],
59 )
60
61
62 class TestProviderInitialization:
63 """Test cases for provider initialization."""
64
65 def test_non_agentic_provider_initialization(self):
66 """Test that non-agentic providers initialize correctly."""
67 from composio.core.provider._openai import OpenAIProvider
68
69 provider = OpenAIProvider()
70
71 assert provider is not None
72 assert provider.name == "openai"
73 assert isinstance(provider, NonAgenticProvider)
74
75 def test_agentic_provider_initialization(self):
76 """Test that agentic providers initialize correctly."""
77
78 class TestAgenticProvider(AgenticProvider, name="test_agentic"):
79 def wrap_tool(self, tool, execute_tool):
80 return {"slug": tool.slug, "execute": execute_tool}
81
82 def wrap_tools(self, tools, execute_tool):
83 return [self.wrap_tool(tool, execute_tool) for tool in tools]
84
85 provider = TestAgenticProvider()
86
87 assert provider is not None
88 assert provider.name == "test_agentic"
89 assert isinstance(provider, AgenticProvider)
90
91
92 class TestProviderExecuteToolSetup:
93 """Test cases for execute_tool setup during initialization."""
94
95 def test_execute_tool_signature_matches_protocol(self):
96 """Test that execute_tool has the correct signature matching ExecuteToolFn protocol."""
97 mock_client = mock_http_client()
98 from composio.core.provider._openai import OpenAIProvider
99
100 provider = OpenAIProvider()
101
102 Tools(
103 client=mock_client,
104 provider=provider,
105 toolkit_versions={"github": "12012025_00"},
106 )
107
108 # Verify it's callable
109 assert callable(provider.execute_tool)
110
111 # Try calling it with the protocol signature
112 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
113 mock_client.tools.retrieve.return_value = github_tool
114
115 mock_execute_response = Mock()
116 mock_execute_response.model_dump.return_value = {
117 "data": {"success": True},
118 "error": None,
119 "successful": True,
120 }
121 mock_client.tools.execute.return_value = mock_execute_response
122
123 # Should accept slug, arguments, and keyword-only modifiers/user_id
124 result = provider.execute_tool(
125 slug="GITHUB_STAR_REPO",
126 arguments={"repo": "composio/composio"},
127 modifiers=None,
128 user_id="test-user",
129 )
130
131 assert result["successful"] is True
132
133
134 class TestProviderExecuteToolFunctionality:
135 """Test cases for execute_tool functionality."""
136
137 def test_execute_tool_executes_composio_tool(self):
138 """Test that provider.execute_tool executes Composio tools correctly."""
139 mock_client = mock_http_client()
140 from composio.core.provider._openai import OpenAIProvider
141
142 provider = OpenAIProvider()
143
144 Tools(
145 client=mock_client,
146 provider=provider,
147 toolkit_versions={"github": "12012025_00"},
148 )
149
150 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
151 mock_client.tools.retrieve.return_value = github_tool
152
153 mock_execute_response = Mock()
154 mock_execute_response.model_dump.return_value = {
155 "data": {"starred": True, "repo": "composio/composio"},
156 "error": None,
157 "successful": True,
158 }
159 mock_client.tools.execute.return_value = mock_execute_response
160
161 result = provider.execute_tool(
162 slug="GITHUB_STAR_REPO",
163 arguments={"repo": "composio/composio"},
164 )
165
166 assert result["successful"] is True
167 assert result["data"]["starred"] is True
168 assert result["data"]["repo"] == "composio/composio"
169 mock_client.tools.execute.assert_called_once()
170
171 def test_execute_tool_uses_dangerously_skip_version_check(self):
172 """Test that execute_tool automatically sets dangerously_skip_version_check=True."""
173 mock_client = mock_http_client()
174 from composio.core.provider._openai import OpenAIProvider
175
176 provider = OpenAIProvider()
177
178 # Create Tools without explicit toolkit versions (defaults to 'latest')
179 Tools(
180 client=mock_client,
181 provider=provider,
182 )
183
184 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "latest")
185 mock_client.tools.retrieve.return_value = github_tool
186
187 mock_execute_response = Mock()
188 mock_execute_response.model_dump.return_value = {
189 "data": {"starred": True},
190 "error": None,
191 "successful": True,
192 }
193 mock_client.tools.execute.return_value = mock_execute_response
194
195 # Should NOT raise ToolVersionRequiredError even with 'latest'
196 # because dangerously_skip_version_check=True is set automatically
197 result = provider.execute_tool(
198 slug="GITHUB_STAR_REPO",
199 arguments={"repo": "composio/composio"},
200 )
201
202 assert result["successful"] is True
203
204 def test_execute_tool_passes_user_id(self):
205 """Test that execute_tool correctly passes user_id parameter."""
206 mock_client = mock_http_client()
207 from composio.core.provider._openai import OpenAIProvider
208
209 provider = OpenAIProvider()
210
211 Tools(
212 client=mock_client,
213 provider=provider,
214 toolkit_versions={"github": "12012025_00"},
215 )
216
217 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
218 mock_client.tools.retrieve.return_value = github_tool
219
220 mock_execute_response = Mock()
221 mock_execute_response.model_dump.return_value = {
222 "data": {"success": True},
223 "error": None,
224 "successful": True,
225 }
226 mock_client.tools.execute.return_value = mock_execute_response
227
228 result = provider.execute_tool(
229 slug="GITHUB_STAR_REPO",
230 arguments={"repo": "composio/composio"},
231 user_id="user-123",
232 )
233
234 assert result["successful"] is True
235
236 call_args = mock_client.tools.execute.call_args
237 assert call_args.kwargs["user_id"] == "user-123"
238
239 def test_execute_tool_passes_modifiers(self):
240 """Test that execute_tool correctly passes modifiers."""
241 from composio.core.models._modifiers import before_execute
242
243 mock_client = mock_http_client()
244 from composio.core.provider._openai import OpenAIProvider
245
246 provider = OpenAIProvider()
247
248 Tools(
249 client=mock_client,
250 provider=provider,
251 toolkit_versions={"github": "12012025_00"},
252 )
253
254 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
255 mock_client.tools.retrieve.return_value = github_tool
256
257 mock_execute_response = Mock()
258 mock_execute_response.model_dump.return_value = {
259 "data": {"success": True},
260 "error": None,
261 "successful": True,
262 }
263 mock_client.tools.execute.return_value = mock_execute_response
264
265 def modify_arguments(tool, toolkit, params):
266 params["arguments"]["modified"] = True
267 return params
268
269 modifier = before_execute(modify_arguments)
270
271 result = provider.execute_tool(
272 slug="GITHUB_STAR_REPO",
273 arguments={"repo": "composio/composio"},
274 modifiers=[modifier],
275 )
276
277 assert result["successful"] is True
278
279 call_args = mock_client.tools.execute.call_args
280 assert call_args.kwargs["arguments"]["modified"] is True
281
282 def test_execute_tool_with_toolkit_versions(self):
283 """Test that execute_tool uses configured toolkit versions."""
284 mock_client = mock_http_client()
285 from composio.core.provider._openai import OpenAIProvider
286
287 provider = OpenAIProvider()
288
289 Tools(
290 client=mock_client,
291 provider=provider,
292 toolkit_versions={"github": "12012025_00", "slack": "12012025_01"},
293 )
294
295 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
296 mock_client.tools.retrieve.return_value = github_tool
297
298 mock_execute_response = Mock()
299 mock_execute_response.model_dump.return_value = {
300 "data": {"success": True},
301 "error": None,
302 "successful": True,
303 }
304 mock_client.tools.execute.return_value = mock_execute_response
305
306 result = provider.execute_tool(
307 slug="GITHUB_STAR_REPO",
308 arguments={"repo": "composio/composio"},
309 )
310
311 assert result["successful"] is True
312
313 call_args = mock_client.tools.execute.call_args
314 assert call_args.kwargs["version"] == "12012025_00"
315
316
317 class TestNonAgenticProviderHelperMethods:
318 """Test cases for non-agentic provider helper methods."""
319
320 def test_openai_provider_execute_tool_call(self):
321 """Test that OpenAIProvider.execute_tool_call uses provider.execute_tool."""
322 from openai.types.chat.chat_completion_message_tool_call import (
323 ChatCompletionMessageToolCall,
324 Function,
325 )
326
327 mock_client = mock_http_client()
328 from composio.core.provider._openai import OpenAIProvider
329
330 provider = OpenAIProvider()
331
332 Tools(
333 client=mock_client,
334 provider=provider,
335 toolkit_versions={"github": "12012025_00"},
336 )
337
338 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
339 mock_client.tools.retrieve.return_value = github_tool
340
341 mock_execute_response = Mock()
342 mock_execute_response.model_dump.return_value = {
343 "data": {"starred": True},
344 "error": None,
345 "successful": True,
346 }
347 mock_client.tools.execute.return_value = mock_execute_response
348
349 tool_call = ChatCompletionMessageToolCall(
350 id="call_123",
351 function=Function(
352 name="GITHUB_STAR_REPO",
353 arguments='{"repo": "composio/composio"}',
354 ),
355 type="function",
356 )
357
358 result = provider.execute_tool_call(
359 user_id="test-user",
360 tool_call=tool_call,
361 )
362
363 assert result["successful"] is True
364 assert result["data"]["starred"] is True
365
366 def test_openai_provider_handle_tool_calls(self):
367 """Test that OpenAIProvider.handle_tool_calls processes multiple tool calls."""
368 from openai.types.chat import ChatCompletion
369 from openai.types.chat.chat_completion import Choice
370 from openai.types.chat.chat_completion_message import ChatCompletionMessage
371 from openai.types.chat.chat_completion_message_tool_call import (
372 ChatCompletionMessageToolCall,
373 Function,
374 )
375
376 mock_client = mock_http_client()
377 from composio.core.provider._openai import OpenAIProvider
378
379 provider = OpenAIProvider()
380
381 Tools(
382 client=mock_client,
383 provider=provider,
384 toolkit_versions={"github": "12012025_00"},
385 )
386
387 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
388 mock_client.tools.retrieve.return_value = github_tool
389
390 mock_execute_response = Mock()
391 mock_execute_response.model_dump.return_value = {
392 "data": {"starred": True},
393 "error": None,
394 "successful": True,
395 }
396 mock_client.tools.execute.return_value = mock_execute_response
397
398 tool_call = ChatCompletionMessageToolCall(
399 id="call_123",
400 function=Function(
401 name="GITHUB_STAR_REPO",
402 arguments='{"repo": "composio/composio"}',
403 ),
404 type="function",
405 )
406
407 message = ChatCompletionMessage(
408 role="assistant",
409 content=None,
410 tool_calls=[tool_call],
411 )
412
413 choice = Choice(
414 finish_reason="tool_calls",
415 index=0,
416 message=message,
417 )
418
419 completion = ChatCompletion(
420 id="chatcmpl-123",
421 choices=[choice],
422 created=1234567890,
423 model="gpt-4",
424 object="chat.completion",
425 )
426
427 results = provider.handle_tool_calls(
428 user_id="test-user",
429 response=completion,
430 )
431
432 assert len(results) == 1
433 assert results[0]["successful"] is True
434 assert results[0]["data"]["starred"] is True
435
436 def test_openai_provider_routes_tool_calls_through_session(self):
437 """Session tools execute through their Tool Router session, not tools.execute."""
438 mock_client = mock_http_client()
439 from composio.core.provider._openai import OpenAIProvider
440
441 provider = OpenAIProvider()
442 Tools(client=mock_client, provider=provider)
443 session = Mock()
444 session.execute.return_value = SimpleNamespace(
445 data={"tools": ["GMAIL_SEND_EMAIL"]},
446 error=None,
447 log_id="log-session",
448 result_type="completed",
449 )
450 completion = SimpleNamespace(
451 choices=[
452 SimpleNamespace(
453 message=SimpleNamespace(
454 tool_calls=[
455 SimpleNamespace(
456 id="call-search",
457 type="function",
458 function=SimpleNamespace(
459 name="COMPOSIO_SEARCH_TOOLS",
460 arguments='{"queries":[{"use_case":"send email"}]}',
461 ),
462 )
463 ],
464 ),
465 )
466 ],
467 )
468
469 results = provider.handle_tool_calls(response=completion, session=session)
470
471 session.execute.assert_called_once_with(
472 tool_slug="COMPOSIO_SEARCH_TOOLS",
473 arguments={"queries": [{"use_case": "send email"}]},
474 )
475 mock_client.tools.execute.assert_not_called()
476 assert results == [
477 {
478 "data": {"tools": ["GMAIL_SEND_EMAIL"]},
479 "error": None,
480 "successful": True,
481 "log_id": "log-session",
482 "result_type": "completed",
483 }
484 ]
485
486 def test_openai_responses_provider_preserves_session_result_order(self):
487 """Responses helpers keep provider order and result shape for session calls."""
488 from openai.types.responses.response import Response
489 from openai.types.responses.response_function_tool_call import (
490 ResponseFunctionToolCall,
491 )
492
493 from composio.core.provider._openai_responses import OpenAIResponsesProvider
494
495 mock_client = mock_http_client()
496 provider = OpenAIResponsesProvider()
497 Tools(client=mock_client, provider=provider)
498 session = Mock()
499 session.execute.side_effect = [
500 SimpleNamespace(
501 data={"index": 1}, error=None, log_id="log-1", result_type="completed"
502 ),
503 SimpleNamespace(
504 data={"index": 2}, error="failed", log_id="log-2", result_type="failed"
505 ),
506 ]
507 response = Response.model_construct(
508 output=[
509 ResponseFunctionToolCall(
510 arguments='{"queries":[{"use_case":"first"}]}',
511 call_id="call-1",
512 name="COMPOSIO_SEARCH_TOOLS",
513 type="function_call",
514 ),
515 ResponseFunctionToolCall(
516 arguments='{"queries":[{"use_case":"second"}]}',
517 call_id="call-2",
518 name="COMPOSIO_SEARCH_TOOLS",
519 type="function_call",
520 ),
521 ]
522 )
523
524 results = provider.handle_tool_calls(response=response, session=session)
525
526 assert session.execute.call_args_list == [
527 call(
528 tool_slug="COMPOSIO_SEARCH_TOOLS",
529 arguments={"queries": [{"use_case": "first"}]},
530 ),
531 call(
532 tool_slug="COMPOSIO_SEARCH_TOOLS",
533 arguments={"queries": [{"use_case": "second"}]},
534 ),
535 ]
536 mock_client.tools.execute.assert_not_called()
537 assert results == [
538 {
539 "data": {"index": 1},
540 "error": None,
541 "successful": True,
542 "log_id": "log-1",
543 "result_type": "completed",
544 },
545 {
546 "data": {"index": 2},
547 "error": "failed",
548 "successful": False,
549 "log_id": "log-2",
550 "result_type": "failed",
551 },
552 ]
553
554 def test_openai_responses_provider_propagates_session_exceptions(self):
555 """Responses helpers preserve their existing exception propagation behavior."""
556 from openai.types.responses.response import Response
557 from openai.types.responses.response_function_tool_call import (
558 ResponseFunctionToolCall,
559 )
560
561 from composio.core.provider._openai_responses import OpenAIResponsesProvider
562
563 provider = OpenAIResponsesProvider()
564 session = Mock()
565 session.execute.side_effect = RuntimeError("session execution failed")
566 response = Response.model_construct(
567 output=[
568 ResponseFunctionToolCall(
569 arguments="{}",
570 call_id="call-1",
571 name="COMPOSIO_SEARCH_TOOLS",
572 type="function_call",
573 )
574 ]
575 )
576
577 with pytest.raises(RuntimeError, match="session execution failed"):
578 provider.handle_tool_calls(response=response, session=session)
579
580 def test_openai_provider_handle_tool_calls_only_first_choice(self):
581 """Only the first choice runs; n > 1 alternatives would orphan tool_call_ids."""
582 from openai.types.chat import ChatCompletion
583 from openai.types.chat.chat_completion import Choice
584 from openai.types.chat.chat_completion_message import ChatCompletionMessage
585 from openai.types.chat.chat_completion_message_tool_call import (
586 ChatCompletionMessageToolCall,
587 Function,
588 )
589
590 mock_client = mock_http_client()
591 from composio.core.provider._openai import OpenAIProvider
592
593 provider = OpenAIProvider()
594
595 Tools(
596 client=mock_client,
597 provider=provider,
598 toolkit_versions={"github": "12012025_00"},
599 )
600
601 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
602 mock_client.tools.retrieve.return_value = github_tool
603
604 mock_execute_response = Mock()
605 mock_execute_response.model_dump.return_value = {
606 "data": {"starred": True},
607 "error": None,
608 "successful": True,
609 }
610 mock_client.tools.execute.return_value = mock_execute_response
611
612 def make_choice(index: int, call_id: str) -> Choice:
613 return Choice(
614 finish_reason="tool_calls",
615 index=index,
616 message=ChatCompletionMessage(
617 role="assistant",
618 content=None,
619 tool_calls=[
620 ChatCompletionMessageToolCall(
621 id=call_id,
622 function=Function(
623 name="GITHUB_STAR_REPO",
624 arguments='{"repo": "composio/composio"}',
625 ),
626 type="function",
627 )
628 ],
629 ),
630 )
631
632 completion = ChatCompletion(
633 id="chatcmpl-123",
634 choices=[make_choice(0, "call_first"), make_choice(1, "call_second")],
635 created=1234567890,
636 model="gpt-4",
637 object="chat.completion",
638 )
639
640 results = provider.handle_tool_calls(
641 user_id="test-user",
642 response=completion,
643 )
644
645 assert len(results) == 1
646 assert mock_client.tools.execute.call_count == 1
647
648 def test_openai_provider_wrap_tools(self):
649 """Test that OpenAIProvider.wrap_tools creates proper tool definitions."""
650 from composio.core.provider._openai import OpenAIProvider
651
652 provider = OpenAIProvider()
653
654 tools_list = [
655 create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00"),
656 create_mock_tool("SLACK_SEND_MESSAGE", "slack", "12012025_01"),
657 ]
658
659 wrapped = provider.wrap_tools(tools_list)
660
661 assert len(wrapped) == 2
662 assert all(tool["type"] == "function" for tool in wrapped)
663 assert wrapped[0]["function"]["name"] == "GITHUB_STAR_REPO"
664 assert wrapped[1]["function"]["name"] == "SLACK_SEND_MESSAGE"
665
666
667 class TestAgenticProviderFunctionality:
668 """Test cases for agentic providers."""
669
670 def test_agentic_provider_execute_tool_works(self):
671 """Test that agentic provider's execute_tool executes tools correctly."""
672 mock_client = mock_http_client()
673
674 class TestAgenticProvider(AgenticProvider, name="test_agentic"):
675 def wrap_tool(self, tool, execute_tool):
676 return {"slug": tool.slug, "execute": execute_tool}
677
678 def wrap_tools(self, tools, execute_tool):
679 return [self.wrap_tool(tool, execute_tool) for tool in tools]
680
681 provider = TestAgenticProvider()
682
683 Tools(
684 client=mock_client,
685 provider=provider,
686 toolkit_versions={"github": "12012025_00"},
687 )
688
689 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
690 mock_client.tools.retrieve.return_value = github_tool
691
692 mock_execute_response = Mock()
693 mock_execute_response.model_dump.return_value = {
694 "data": {"starred": True},
695 "error": None,
696 "successful": True,
697 }
698 mock_client.tools.execute.return_value = mock_execute_response
699
700 result = provider.execute_tool(
701 slug="GITHUB_STAR_REPO",
702 arguments={"repo": "composio/composio"},
703 )
704
705 assert result["successful"] is True
706 assert result["data"]["starred"] is True
707
708 def test_agentic_provider_wrapped_tools_receive_execute_function(self):
709 """Test that wrapped tools from agentic providers receive the execute function."""
710 mock_client = mock_http_client()
711
712 class TestAgenticProvider(AgenticProvider, name="test_agentic"):
713 def wrap_tool(self, tool, execute_tool):
714 return {
715 "name": tool.slug,
716 "description": tool.description,
717 "executor": execute_tool,
718 }
719
720 def wrap_tools(self, tools, execute_tool):
721 return [self.wrap_tool(tool, execute_tool) for tool in tools]
722
723 provider = TestAgenticProvider()
724
725 tools = Tools(
726 client=mock_client,
727 provider=provider,
728 toolkit_versions={"github": "12012025_00"},
729 )
730
731 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
732 mock_client.tools.retrieve.return_value = github_tool
733
734 mock_list_response = Mock()
735 mock_list_response.items = [github_tool]
736 mock_client.tools.list.return_value = mock_list_response
737
738 mock_execute_response = Mock()
739 mock_execute_response.model_dump.return_value = {
740 "data": {"starred": True},
741 "error": None,
742 "successful": True,
743 }
744 mock_client.tools.execute.return_value = mock_execute_response
745
746 wrapped_tools = tools.get(
747 user_id="test-user",
748 slug="GITHUB_STAR_REPO",
749 )
750
751 assert len(wrapped_tools) == 1
752 wrapped_tool = wrapped_tools[0]
753 assert "executor" in wrapped_tool
754 assert callable(wrapped_tool["executor"])
755
756 # Call the executor
757 result = wrapped_tool["executor"](
758 slug="GITHUB_STAR_REPO",
759 arguments={"repo": "composio/composio"},
760 )
761
762 assert result["successful"] is True
763 assert result["data"]["starred"] is True
764
765 def test_agentic_provider_wrap_tools_receives_execute_function(self):
766 """Test that wrap_tools method receives the execute_tool function."""
767 mock_client = mock_http_client()
768
769 class TestAgenticProvider(AgenticProvider, name="test_agentic"):
770 def wrap_tool(self, tool, execute_tool):
771 return {"slug": tool.slug, "has_executor": callable(execute_tool)}
772
773 def wrap_tools(self, tools, execute_tool):
774 # Verify execute_tool is callable
775 assert callable(execute_tool)
776 return [self.wrap_tool(tool, execute_tool) for tool in tools]
777
778 provider = TestAgenticProvider()
779
780 tools = Tools(
781 client=mock_client,
782 provider=provider,
783 toolkit_versions={"github": "12012025_00"},
784 )
785
786 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
787
788 mock_list_response = Mock()
789 mock_list_response.items = [github_tool]
790 mock_client.tools.list.return_value = mock_list_response
791
792 wrapped = tools.get(user_id="test-user", slug="GITHUB_STAR_REPO")
793
794 assert len(wrapped) == 1
795 assert wrapped[0]["has_executor"] is True
796
797
798 @pytest.mark.skipif(
799 importlib.util.find_spec("composio_langchain") is None,
800 reason="LangChain provider package is not installed",
801 )
802 class TestLangchainReservedKeywords:
803 """Regression tests for PLEN-1671: ValueError when tool schema has Python reserved keywords as parameter names.
804
805 Tools from some toolkits (e.g. Intercom) have parameters named 'from',
806 which is a Python reserved keyword. The LangchainProvider must substitute
807 these names before building function signatures and reinstate them when
808 executing the tool.
809 """
810
811 def _make_tool_with_params(self, properties: dict, required: list | None = None):
812 """Helper: create a mock Tool whose input_parameters use the given properties."""
813 return Tool(
814 name="Test Tool",
815 slug="TEST_TOOL",
816 description="A tool for testing reserved keyword handling",
817 input_parameters={
818 "type": "object",
819 "title": "TestToolRequest",
820 "properties": properties,
821 "required": required or [],
822 },
823 output_parameters={},
824 available_versions=["12012025_00"],
825 version="12012025_00",
826 scopes=[],
827 toolkit=tool_list_response.ItemToolkit(name="Test", slug="test", logo=""),
828 deprecated=tool_list_response.ItemDeprecated(
829 available_versions=["12012025_00"],
830 displayName="Test Tool",
831 version="12012025_00",
832 toolkit=tool_list_response.ItemDeprecatedToolkit(logo=""),
833 is_deprecated=False,
834 ),
835 is_deprecated=False,
836 no_auth=False,
837 tags=[],
838 )
839
840 def test_wrap_tool_with_from_parameter(self):
841 """PLEN-1671: 'from' parameter must not raise ValueError."""
842 from composio_langchain import LangchainProvider
843
844 provider = LangchainProvider()
845 tool = self._make_tool_with_params(
846 properties={
847 "from": {
848 "type": "string",
849 "description": "Starting point for listing",
850 },
851 "limit": {
852 "type": "integer",
853 "description": "Max results",
854 "default": 20,
855 },
856 },
857 )
858
859 captured = {}
860
861 def mock_execute(slug, arguments):
862 captured.update(arguments)
863 return {"data": {}, "error": None, "successful": True}
864
865 # Must not raise ValueError: 'from' is not a valid parameter name
866 wrapped = provider.wrap_tool(tool, mock_execute)
867
868 assert wrapped.name == "TEST_TOOL"
869
870 # Invoke the tool and verify 'from' is reinstated in the arguments
871 wrapped.run({"from_rs": "2024-01-01", "limit": 10})
872 assert captured == {"from": "2024-01-01", "limit": 10}
873
874 def test_wrap_tool_with_multiple_reserved_keywords(self):
875 """All Python reserved keywords used as parameter names must be handled."""
876 from composio_langchain import LangchainProvider
877
878 provider = LangchainProvider()
879 tool = self._make_tool_with_params(
880 properties={
881 "from": {
882 "type": "string",
883 "description": "Start date",
884 },
885 "for": {
886 "type": "string",
887 "description": "Recipient",
888 },
889 "import": {
890 "type": "string",
891 "description": "Import source",
892 },
893 "class": {
894 "type": "string",
895 "description": "CSS class",
896 },
897 "async": {
898 "type": "boolean",
899 "description": "Async flag",
900 "default": False,
901 },
902 "normal_param": {
903 "type": "string",
904 "description": "A normal parameter",
905 },
906 },
907 )
908
909 captured = {}
910
911 def mock_execute(slug, arguments):
912 captured.update(arguments)
913 return {"data": {}, "error": None, "successful": True}
914
915 wrapped = provider.wrap_tool(tool, mock_execute)
916 assert wrapped.name == "TEST_TOOL"
917
918 # Invoke with renamed parameters and verify originals are reinstated
919 wrapped.run(
920 {
921 "from_rs": "2024-01-01",
922 "for_rs": "user@example.com",
923 "import_rs": "csv",
924 "class_rs": "primary",
925 "async_rs": True,
926 "normal_param": "hello",
927 }
928 )
929 assert captured == {
930 "from": "2024-01-01",
931 "for": "user@example.com",
932 "import": "csv",
933 "class": "primary",
934 "async": True,
935 "normal_param": "hello",
936 }
937
938 def test_wrap_tool_with_required_reserved_keyword_param(self):
939 """Reserved keywords that are also required params must work."""
940 from composio_langchain import LangchainProvider
941
942 provider = LangchainProvider()
943 tool = self._make_tool_with_params(
944 properties={
945 "from": {
946 "type": "string",
947 "description": "Required start date",
948 },
949 },
950 required=["from"],
951 )
952
953 captured = {}
954
955 def mock_execute(slug, arguments):
956 captured.update(arguments)
957 return {"data": {}, "error": None, "successful": True}
958
959 wrapped = provider.wrap_tool(tool, mock_execute)
960 wrapped.run({"from_rs": "2024-01-01"})
961 assert captured == {"from": "2024-01-01"}
962
963
964 @pytest.mark.skipif(
965 importlib.util.find_spec("composio_langchain") is None,
966 reason="LangChain provider package is not installed",
967 )
968 class TestLangchainFreeFormObjectArguments:
969 """Regression for issue #4064 at the Python provider boundary.
970
971 `LangchainProvider.wrap_tool` builds its `args_schema` from
972 `json_schema_to_model` and re-reads each argument with `getattr`, so a
973 property-less object that validates but drops its content never reaches
974 execution.
975 """
976
977 def _make_tool(self, properties: dict):
978 return Tool(
979 name="Metabase Create Card",
980 slug="METABASE_POST_API_CARD",
981 description="A tool with a free-form object argument",
982 input_parameters={
983 "type": "object",
984 "title": "MetabaseCreateCardRequest",
985 "properties": properties,
986 "required": list(properties),
987 },
988 output_parameters={},
989 available_versions=["12012025_00"],
990 version="12012025_00",
991 scopes=[],
992 toolkit=tool_list_response.ItemToolkit(
993 name="Metabase", slug="metabase", logo=""
994 ),
995 deprecated=tool_list_response.ItemDeprecated(
996 available_versions=["12012025_00"],
997 displayName="Metabase Create Card",
998 version="12012025_00",
999 toolkit=tool_list_response.ItemDeprecatedToolkit(logo=""),
1000 is_deprecated=False,
1001 ),
1002 is_deprecated=False,
1003 no_auth=False,
1004 tags=[],
1005 )
1006
1007 def test_free_form_object_reaches_execution_intact(self):
1008 from composio_langchain import LangchainProvider
1009
1010 case = find_case("nested-free-form-object")
1011 payload = case.instances[0].input
1012
1013 captured = {}
1014
1015 def mock_execute(slug, arguments):
1016 captured.update(arguments)
1017 return {"data": {}, "error": None, "successful": True}
1018
1019 wrapped = LangchainProvider().wrap_tool(
1020 self._make_tool(case.schema_["properties"]), mock_execute
1021 )
1022 wrapped.run(payload)
1023
1024 assert captured == payload
1025
1026 def test_unknown_keys_are_still_rejected_before_execution(self):
1027 from composio_langchain import LangchainProvider
1028
1029 executed = []
1030
1031 def mock_execute(slug, arguments):
1032 executed.append(arguments)
1033 return {"data": {}, "error": None, "successful": True}
1034
1035 wrapped = LangchainProvider().wrap_tool(
1036 self._make_tool({"name": {"type": "string"}}), mock_execute
1037 )
1038
1039 with pytest.raises(ValidationError):
1040 wrapped.args_schema.model_validate({"name": "a", "typo": 1})
1041 assert executed == []
1042
1043
1044 class TestProviderEdgeCases:
1045 """Test edge cases and error handling for providers."""
1046
1047 def test_execute_tool_with_none_parameters(self):
1048 """Test that execute_tool works when optional parameters are None."""
1049 mock_client = mock_http_client()
1050 from composio.core.provider._openai import OpenAIProvider
1051
1052 provider = OpenAIProvider()
1053
1054 Tools(
1055 client=mock_client,
1056 provider=provider,
1057 toolkit_versions={"github": "12012025_00"},
1058 )
1059
1060 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
1061 mock_client.tools.retrieve.return_value = github_tool
1062
1063 mock_execute_response = Mock()
1064 mock_execute_response.model_dump.return_value = {
1065 "data": {"success": True},
1066 "error": None,
1067 "successful": True,
1068 }
1069 mock_client.tools.execute.return_value = mock_execute_response
1070
1071 result = provider.execute_tool(
1072 slug="GITHUB_STAR_REPO",
1073 arguments={"repo": "composio/composio"},
1074 modifiers=None,
1075 user_id=None,
1076 )
1077
1078 assert result["successful"] is True
1079
1080 def test_execute_tool_with_multiple_toolkit_versions(self):
1081 """Test execute_tool with multiple configured toolkit versions."""
1082 mock_client = mock_http_client()
1083 from composio.core.provider._openai import OpenAIProvider
1084
1085 provider = OpenAIProvider()
1086
1087 toolkit_versions = {
1088 "github": "12012025_00",
1089 "slack": "12012025_01",
1090 "notion": "12012025_02",
1091 }
1092
1093 Tools(
1094 client=mock_client,
1095 provider=provider,
1096 toolkit_versions=toolkit_versions,
1097 )
1098
1099 # Test each toolkit uses its configured version
1100 for toolkit, version in toolkit_versions.items():
1101 tool = create_mock_tool(f"{toolkit.upper()}_TEST", toolkit, version)
1102 mock_client.tools.retrieve.return_value = tool
1103
1104 mock_execute_response = Mock()
1105 mock_execute_response.model_dump.return_value = {
1106 "data": {"success": True},
1107 "error": None,
1108 "successful": True,
1109 }
1110 mock_client.tools.execute.return_value = mock_execute_response
1111
1112 result = provider.execute_tool(
1113 slug=f"{toolkit.upper()}_TEST",
1114 arguments={"test": "data"},
1115 )
1116
1117 assert result["successful"] is True
1118
1119 call_args = mock_client.tools.execute.call_args
1120 assert call_args.kwargs["version"] == version
1121
1122
1123 class TestProviderIntegration:
1124 """Integration tests for provider functionality."""
1125
1126 def test_provider_workflow_non_agentic(self):
1127 """Test complete workflow with non-agentic provider."""
1128 mock_client = mock_http_client()
1129 from composio.core.provider._openai import OpenAIProvider
1130
1131 provider = OpenAIProvider()
1132
1133 # Initialize Tools
1134 tools = Tools(
1135 client=mock_client,
1136 provider=provider,
1137 toolkit_versions={"github": "12012025_00"},
1138 )
1139
1140 # Verify provider has execute_tool
1141 assert hasattr(provider, "execute_tool")
1142
1143 # Mock tool and response
1144 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
1145 mock_client.tools.retrieve.return_value = github_tool
1146
1147 mock_list_response = Mock()
1148 mock_list_response.items = [github_tool]
1149 mock_client.tools.list.return_value = mock_list_response
1150
1151 mock_execute_response = Mock()
1152 mock_execute_response.model_dump.return_value = {
1153 "data": {"starred": True},
1154 "error": None,
1155 "successful": True,
1156 }
1157 mock_client.tools.execute.return_value = mock_execute_response
1158
1159 # Get wrapped tools
1160 wrapped_tools = tools.get(user_id="test-user", slug="GITHUB_STAR_REPO")
1161
1162 # Verify wrapped tools are in OpenAI format
1163 assert len(wrapped_tools) == 1
1164 wrapped_tool = wrapped_tools[0]
1165 assert wrapped_tool["type"] == "function"
1166 assert wrapped_tool["function"]["name"] == "GITHUB_STAR_REPO"
1167
1168 # Execute tool directly via provider
1169 result = provider.execute_tool(
1170 slug="GITHUB_STAR_REPO",
1171 arguments={"repo": "composio/composio"},
1172 user_id="test-user",
1173 )
1174
1175 assert result["successful"] is True
1176 assert result["data"]["starred"] is True
1177
1178 def test_provider_workflow_agentic(self):
1179 """Test complete workflow with agentic provider."""
1180 mock_client = mock_http_client()
1181
1182 class TestAgenticProvider(AgenticProvider, name="test_agentic"):
1183 def wrap_tool(self, tool, execute_tool):
1184 return {
1185 "name": tool.slug,
1186 "description": tool.description,
1187 "parameters": tool.input_parameters,
1188 "executor": execute_tool,
1189 }
1190
1191 def wrap_tools(self, tools, execute_tool):
1192 return [self.wrap_tool(tool, execute_tool) for tool in tools]
1193
1194 provider = TestAgenticProvider()
1195
1196 # Initialize Tools
1197 tools = Tools(
1198 client=mock_client,
1199 provider=provider,
1200 toolkit_versions={"github": "12012025_00"},
1201 )
1202
1203 # Verify provider has execute_tool
1204 assert hasattr(provider, "execute_tool")
1205
1206 # Mock tool and response
1207 github_tool = create_mock_tool("GITHUB_STAR_REPO", "github", "12012025_00")
1208 mock_client.tools.retrieve.return_value = github_tool
1209
1210 mock_list_response = Mock()
1211 mock_list_response.items = [github_tool]
1212 mock_client.tools.list.return_value = mock_list_response
1213
1214 mock_execute_response = Mock()
1215 mock_execute_response.model_dump.return_value = {
1216 "data": {"starred": True},
1217 "error": None,
1218 "successful": True,
1219 }
1220 mock_client.tools.execute.return_value = mock_execute_response
1221
1222 # Get wrapped tools
1223 wrapped_tools = tools.get(user_id="test-user", slug="GITHUB_STAR_REPO")
1224
1225 # Verify wrapped tools have executor
1226 assert len(wrapped_tools) == 1
1227 wrapped_tool = wrapped_tools[0]
1228 assert "executor" in wrapped_tool
1229 assert callable(wrapped_tool["executor"])
1230
1231 # Execute via wrapped tool executor
1232 result = wrapped_tool["executor"](
1233 slug="GITHUB_STAR_REPO",
1234 arguments={"repo": "composio/composio"},
1235 )
1236
1237 assert result["successful"] is True
1238 assert result["data"]["starred"] is True
1239
1240 # Also test direct execution via provider
1241 result2 = provider.execute_tool(
1242 slug="GITHUB_STAR_REPO",
1243 arguments={"repo": "composio/composio"},
1244 user_id="test-user",
1245 )
1246
1247 assert result2["successful"] is True
1248 assert result2["data"]["starred"] is True
1249
1250
1251 class TestAgenticSkipDefaultsParity:
1252 """Regression: agentic providers must honor skip_defaults in __signature__.
1253
1254 The langchain and langgraph providers strip schema defaults from
1255 args_schema when schema_config={"skip_defaults": True}, but kept the
1256 defaults in the function __signature__, so the signature and args_schema
1257 disagreed about which optional params were required. They now pass the
1258 same skip_default to both, matching the sibling llamaindex provider.
1259
1260 autogen only builds __signature__ (no args_schema), so it never had the
1261 mismatch, but its signature likewise ignored skip_defaults; it is aligned
1262 too and checked on the signature alone.
1263
1264 Provider packages are optional. The shared unit-test job installs langchain
1265 and langgraph, while Autogen runs separately because their protobuf
1266 requirements conflict. Each case skips via importorskip when its provider
1267 is absent.
1268 """
1269
1270 def _make_tool_with_default(self):
1271 return Tool(
1272 name="Test Tool",
1273 slug="TEST_TOOL",
1274 description="A tool with a defaulted optional param",
1275 input_parameters={
1276 "type": "object",
1277 "title": "TestToolRequest",
1278 "properties": {
1279 "limit": {
1280 "type": "integer",
1281 "description": "Max results",
1282 "default": 5,
1283 },
1284 },
1285 "required": [],
1286 },
1287 output_parameters={},
1288 available_versions=["12012025_00"],
1289 version="12012025_00",
1290 scopes=[],
1291 toolkit=tool_list_response.ItemToolkit(name="Test", slug="test", logo=""),
1292 deprecated=tool_list_response.ItemDeprecated(
1293 available_versions=["12012025_00"],
1294 displayName="Test Tool",
1295 version="12012025_00",
1296 toolkit=tool_list_response.ItemDeprecatedToolkit(logo=""),
1297 is_deprecated=False,
1298 ),
1299 is_deprecated=False,
1300 no_auth=False,
1301 tags=[],
1302 )
1303
1304 def _provider(self, name, schema_config=None):
1305 module = pytest.importorskip(f"composio_{name}")
1306 provider_cls = getattr(module, f"{name.capitalize()}Provider")
1307 return (
1308 provider_cls(schema_config=schema_config)
1309 if schema_config
1310 else provider_cls()
1311 )
1312
1313 @pytest.mark.parametrize("name", ["langchain", "langgraph"])
1314 def test_skip_defaults_signature_matches_args_schema(self, name):
1315 from inspect import Parameter
1316
1317 provider = self._provider(name, {"skip_defaults": True})
1318 wrapped = provider.wrap_tool(self._make_tool_with_default(), Mock())
1319
1320 limit = wrapped.func.__signature__.parameters["limit"]
1321 assert limit.default is Parameter.empty
1322 assert wrapped.args_schema.model_fields["limit"].is_required()
1323
1324 @pytest.mark.parametrize("name", ["langchain", "langgraph"])
1325 def test_default_preserved_without_skip_defaults(self, name):
1326 provider = self._provider(name)
1327 wrapped = provider.wrap_tool(self._make_tool_with_default(), Mock())
1328
1329 limit = wrapped.func.__signature__.parameters["limit"]
1330 assert limit.default == 5
1331 assert not wrapped.args_schema.model_fields["limit"].is_required()
1332
1333 def test_autogen_signature_honors_skip_defaults(self):
1334 from inspect import Parameter
1335
1336 provider = self._provider("autogen", {"skip_defaults": True})
1337 wrapped = provider.wrap_tool(self._make_tool_with_default(), Mock())
1338
1339 # autogen exposes the wrapped function as `_func` and has no args_schema.
1340 limit = wrapped._func.__signature__.parameters["limit"]
1341 assert limit.default is Parameter.empty
1342
1343 def test_autogen_signature_preserves_default(self):
1344 provider = self._provider("autogen")
1345 wrapped = provider.wrap_tool(self._make_tool_with_default(), Mock())
1346
1347 limit = wrapped._func.__signature__.parameters["limit"]
1348 assert limit.default == 5