Skip to content

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

fix(python): address codex review round 3 findings + add e2e example

Dhawal Upadhyay7f55651b37ab
diff --git a/python/composio/core/models/session_context.py b/python/composio/core/models/session_context.py
index 938844abe..329e4863e 100644
--- a/python/composio/core/models/session_context.py
+++ b/python/composio/core/models/session_context.py
@@ -111,11 +111,17 @@ class SessionContextImpl:
if entry:
return execute_custom_tool(entry, arguments, self)
+ # Serialize any Pydantic model instances before sending to remote API
+ # (custom tools receive validated Pydantic inputs that may be forwarded)
+ from composio.core.models.tools import _serialize_arguments
+
+ serialized = _serialize_arguments(arguments)
+
# Fall back to remote execution
response = self._client.tool_router.session.execute(
session_id=self._session_id,
tool_slug=tool_slug,
- arguments=arguments,
+ arguments=serialized,
)
return {
"data": response.data if hasattr(response, "data") else {},
diff --git a/python/composio/core/models/tool_router_session.py b/python/composio/core/models/tool_router_session.py
index 104e19cb8..4845331e8 100644
--- a/python/composio/core/models/tool_router_session.py
+++ b/python/composio/core/models/tool_router_session.py
@@ -161,13 +161,45 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
tools_model: t.Any,
modifiers: t.Optional["Modifiers"],
) -> t.Callable[..., t.Any]:
- """Create an execute function that routes local/remote tools."""
+ """Create an execute function that routes local/remote tools.
+
+ Applies before_execute/after_execute modifiers around the overall
+ COMPOSIO_MULTI_EXECUTE_TOOL call, consistent with the standard path.
+ """
def routing_execute(slug: str, arguments: t.Dict) -> t.Dict:
if slug == COMPOSIO_MULTI_EXECUTE_TOOL:
- return self._route_multi_execute(
- arguments, tools_model, modifiers
+ # Apply before_execute modifiers
+ processed_arguments = arguments
+ if modifiers is not None:
+ from composio.core.models._modifiers import apply_modifier_by_type
+ from composio.core.models.tools import ToolExecuteParams
+
+ params: ToolExecuteParams = {"arguments": arguments}
+ modified = apply_modifier_by_type(
+ modifiers=modifiers,
+ toolkit="composio",
+ tool=slug,
+ type="before_execute",
+ request=params,
+ )
+ processed_arguments = modified.get("arguments", arguments)
+
+ result = self._route_multi_execute(
+ processed_arguments, tools_model, modifiers
)
+
+ # Apply after_execute modifiers
+ if modifiers is not None:
+ result = apply_modifier_by_type(
+ modifiers=modifiers,
+ toolkit="composio",
+ tool=slug,
+ type="after_execute",
+ response=result,
+ )
+
+ return result
# Non-multi-execute meta tools always go to backend
return tools_model._wrap_execute_tool_for_tool_router(
session_id=self.session_id,
@@ -325,13 +357,23 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
merged_data.update(remote_data)
merged_data["results"] = merged
+ # Build error message — include remote batch error if present
+ remote_batch_error = (
+ remote_result.get("error") if remote_result else None
+ )
+ if has_any_error:
+ parts = []
+ if failed_count > 0:
+ parts.append(f"{failed_count} out of {len(merged)} tools failed")
+ if remote_batch_error:
+ parts.append(f"remote batch error: {remote_batch_error}")
+ error_msg = "; ".join(parts) if parts else "execution failed"
+ else:
+ error_msg = None
+
return {
"data": merged_data,
- "error": (
- f"{failed_count} out of {len(merged)} tools failed"
- if has_any_error
- else None
- ),
+ "error": error_msg,
"successful": not has_any_error,
}
@@ -485,17 +527,13 @@ class ToolRouterSession(t.Generic[TTool, TToolCollection]):
"log_id": "",
}
- # Remote execution — normalize to dict for consistent return type
- response = self._client.tool_router.session.execute(
+ # Remote execution — return the SessionExecuteResponse model as-is
+ # to preserve backward compatibility for callers using attribute access
+ return self._client.tool_router.session.execute(
session_id=self.session_id,
tool_slug=tool_slug,
arguments=arguments if arguments is not None else omit,
)
- return {
- "data": response.data if hasattr(response, "data") else {},
- "error": response.error if hasattr(response, "error") else None,
- "log_id": response.log_id if hasattr(response, "log_id") else "",
- }
def custom_tools(
self, *, toolkit: t.Optional[str] = None
diff --git a/python/examples/custom_tools_v2.py b/python/examples/custom_tools_v2.py
new file mode 100644
index 000000000..028a04147
--- /dev/null
+++ b/python/examples/custom_tools_v2.py
@@ -0,0 +1,214 @@
+"""
+Custom Tools v2 — local tools + proxy execute with tool router sessions.
+
+Shows how to create custom tools that run in-process alongside
+remote Composio tools. Equivalent of ts/examples/tool-router/src/custom-tools.ts.
+
+Usage:
+ COMPOSIO_API_KEY=... python examples/custom_tools_v2.py
+"""
+
+import base64
+import sys
+
+from pydantic import BaseModel, Field
+
+from composio import Composio, experimental_create_tool, experimental_create_toolkit
+
+
+# ── Custom tools ────────────────────────────────────────────────
+
+
+class UserLookupInput(BaseModel):
+ user_id: str = Field(description="User ID (e.g. user-1)")
+
+
+USERS = {
+ "user-1": {"name": "Alice Johnson", "email": "[email protected]", "role": "admin"},
+ "user-2": {"name": "Bob Smith", "email": "[email protected]", "role": "developer"},
+}
+
+
+def get_user_fn(input: UserLookupInput, ctx):
+ """Look up an internal user by ID."""
+ user = USERS.get(input.user_id)
+ if not user:
+ raise ValueError(f'User "{input.user_id}" not found')
+ return user
+
+
+get_user = experimental_create_tool(
+ "GET_USER",
+ name="Get user",
+ description="Look up an internal user by ID",
+ input_params=UserLookupInput,
+ execute=get_user_fn,
+)
+
+
+class DraftInput(BaseModel):
+ to: str = Field(description="Recipient email address")
+ subject: str = Field(description="Email subject")
+ body: str = Field(description="Email body (plain text)")
+
+
+def create_draft_fn(input: DraftInput, ctx):
+ """Create a real Gmail draft via the Gmail API."""
+ raw_message = (
+ f"To: {input.to}\r\n"
+ f"Subject: {input.subject}\r\n"
+ f"Content-Type: text/plain; charset=UTF-8\r\n"
+ f"\r\n"
+ f"{input.body}"
+ )
+ raw = (
+ base64.urlsafe_b64encode(raw_message.encode("utf-8"))
+ .decode("ascii")
+ .rstrip("=")
+ )
+
+ res = ctx.proxy_execute(
+ toolkit="gmail",
+ endpoint="https://gmail.googleapis.com/gmail/v1/users/me/drafts",
+ method="POST",
+ body={"message": {"raw": raw}},
+ )
+
+ if res["status"] != 200:
+ raise RuntimeError(f"Gmail API error {res['status']}: {res.get('data')}")
+ data = res["data"]
+ return {
+ "draft_id": data["id"],
+ "message_id": data["message"]["id"],
+ "to": input.to,
+ "subject": input.subject,
+ }
+
+
+create_draft = experimental_create_tool(
+ "CREATE_DRAFT",
+ name="Create Gmail draft",
+ description="Create a real Gmail draft via the Gmail API. Appears in the user's drafts folder.",
+ extends_toolkit="gmail",
+ input_params=DraftInput,
+ execute=create_draft_fn,
+)
+
+
+class SetRoleInput(BaseModel):
+ user_id: str = Field(description="User ID")
+ role: str = Field(description="New role (admin, developer, viewer)")
+
+
+role_manager = experimental_create_toolkit(
+ "ROLE_MANAGER",
+ name="Role Manager",
+ description="Manage user roles",
+ tools=[
+ experimental_create_tool(
+ "SET_ROLE",
+ name="Set role",
+ description="Set a user's role",
+ input_params=SetRoleInput,
+ execute=lambda input, ctx: {
+ "user_id": input.user_id,
+ "role": input.role,
+ "updated": True,
+ },
+ ),
+ ],
+)
+
+
+# ── Session ─────────────────────────────────────────────────────
+
+
+def main():
+ composio = Composio()
+
+ print("Creating session with custom tools...")
+ session = composio.create(
+ user_id="default",
+ toolkits=["gmail"],
+ experimental={
+ "custom_tools": [get_user, create_draft],
+ "custom_toolkits": [role_manager],
+ },
+ )
+ print(f"Session ID: {session.session_id}")
+
+ # List registered custom tools
+ print("\n── Registered custom tools ──")
+ for tool in session.custom_tools():
+ print(f" {tool.slug} ({tool.toolkit or 'standalone'})")
+
+ print("\n── Registered custom toolkits ──")
+ for tk in session.custom_toolkits():
+ print(f" {tk.slug}: {[t.slug for t in tk.tools]}")
+
+ # Test 1: Execute standalone custom tool (local, no network)
+ print("\n── Test 1: Execute GET_USER (standalone, local) ──")
+ result = session.execute("GET_USER", arguments={"user_id": "user-1"})
+ print(f" Result: {result}")
+ assert result["data"]["name"] == "Alice Johnson", "GET_USER failed!"
+ assert result["error"] is None
+ print(" ✓ Passed")
+
+ # Test 2: Execute by final slug
+ print("\n── Test 2: Execute LOCAL_GET_USER (by final slug) ──")
+ result = session.execute("LOCAL_GET_USER", arguments={"user_id": "user-2"})
+ print(f" Result: {result}")
+ assert result["data"]["name"] == "Bob Smith", "LOCAL_GET_USER failed!"
+ print(" ✓ Passed")
+
+ # Test 3: Execute toolkit tool
+ print("\n── Test 3: Execute SET_ROLE (toolkit tool) ──")
+ result = session.execute(
+ "SET_ROLE", arguments={"user_id": "user-1", "role": "viewer"}
+ )
+ print(f" Result: {result}")
+ assert result["data"]["updated"] is True, "SET_ROLE failed!"
+ print(" ✓ Passed")
+
+ # Test 4: Validation error
+ print("\n── Test 4: Validation error (missing required field) ──")
+ result = session.execute("GET_USER", arguments={})
+ print(f" Result: error={result['error'][:80]}...")
+ assert result["error"] is not None, "Should have validation error!"
+ print(" ✓ Passed")
+
+ # Test 5: Execute error
+ print("\n── Test 5: Execute error (user not found) ──")
+ result = session.execute("GET_USER", arguments={"user_id": "nonexistent"})
+ print(f" Result: error={result['error']}")
+ assert result["error"] is not None, "Should have execution error!"
+ print(" ✓ Passed")
+
+ # Test 6: Pydantic defaults applied
+ print("\n── Test 6: Get tools (provider-wrapped) ──")
+ tools = session.tools()
+ print(f" Got {len(tools)} tools")
+ print(" ✓ Passed")
+
+ # Test 7: Proxy execute (if Gmail is connected)
+ if "--with-gmail" in sys.argv:
+ print("\n── Test 7: CREATE_DRAFT via proxy_execute ──")
+ result = session.execute(
+ "CREATE_DRAFT",
+ arguments={
+ "subject": "Test from Python custom tools",
+ "body": "Hello from the Python SDK custom tools e2e test!",
+ },
+ )
+ print(f" Result: {result}")
+ if result["error"]:
+ print(f" ⚠ Gmail draft failed (may need connection): {result['error']}")
+ else:
+ print(f" ✓ Draft created: {result['data']}")
+
+ print("\n══ All tests passed! ══")
+
+
+if __name__ == "__main__":
+ main()