Custom Tools and Toolkits (Experimental)

Custom tools let you define tools that run in-process alongside remote Composio tools within a session. There are three patterns:

• Standalone tools — for internal app logic that doesn't need Composio auth (DB lookups, in-memory data, business rules)
• Extension tools — wrap a Composio toolkit's API with custom business logic via extendsToolkit / extends_toolkit, using ctx.proxyExecute() / ctx.proxy_execute() for authenticated requests
• Custom toolkits — group related standalone tools under a namespace

The example below defines one of each and binds them to a session:

// ── Standalone tool ─────────────────────────────────────────────
// Internal data lookup — no Composio auth needed.
// ctx.userId identifies which user's session is running.
const profiles: Record<string, { name: string; email: string; tier: string }> = {
  "user_1": { name: "Alice Johnson", email: "alice@myapp.com", tier: "enterprise" },
  "user_2": { name: "Bob Smith", email: "bob@myapp.com", tier: "free" },
};

const getUserProfile = experimental_createTool("GET_USER_PROFILE", {
  name: "Get user profile",
  description: "Retrieve the current user's profile from the internal directory",
  inputParams: z.object({}),
  execute: async (_input, ctx) => {
    const profile = profiles[ctx.userId];
    if (!profile) throw new Error(`No profile found for user "${ctx.userId}"`);
    return profile;
  },
});

// ── Extension tool ──────────────────────────────────────────────
// Wraps Gmail API with business logic. Inherits auth via extendsToolkit,
// so ctx.proxyExecute() handles credentials automatically.
const sendPromoEmail = experimental_createTool("SEND_PROMO_EMAIL", {
  name: "Send promo email",
  description: "Send the standard promotional email to a recipient",
  extendsToolkit: "gmail",
  inputParams: z.object({
    to: z.string().describe("Recipient email address"),
  }),
  execute: async (input, ctx) => {
    const subject = "You're invited to try MyApp Pro";
    const body = "Hi there,\n\nWe'd love for you to try MyApp Pro — free for 14 days.\n\nBest,\nThe MyApp Team";
    const raw = btoa(`To: ${input.to}\r\nSubject: ${subject}\r\nContent-Type: text/plain; charset=UTF-8\r\n\r\n${body}`);

    const res = await ctx.proxyExecute({
      toolkit: "gmail",
      endpoint: "https://gmail.googleapis.com/gmail/v1/users/me/messages/send",
      method: "POST",
      body: { raw },
    });
    return { status: res.status, to: input.to };
  },
});

// ── Custom toolkit ──────────────────────────────────────────────
// Groups standalone tools that don't need Composio auth under a toolkit.
// Tools inside a toolkit cannot use extendsToolkit.
const userManagement = experimental_createToolkit("USER_MANAGEMENT", {
  name: "User management",
  description: "Manage user roles and permissions",
  tools: [
    experimental_createTool("ASSIGN_ROLE", {
      name: "Assign role",
      description: "Assign a role to a user in the internal system",
      inputParams: z.object({
        user_id: z.string().describe("Target user ID"),
        role: z.enum(["admin", "editor", "viewer"]).describe("Role to assign"),
      }),
      execute: async ({ user_id, role }) => ({ user_id, role, assigned: true }),
    }),
  ],
});

// ── Bind to session ─────────────────────────────────────────────
// Pass custom tools and toolkits via the experimental option.
// session.tools() returns both remote Composio tools and your custom tools.
const composio = new Composio({ apiKey: "your_api_key" });

const session = await composio.create("user_1", {
  toolkits: ["gmail"],
  experimental: {
    customTools: [getUserProfile, sendPromoEmail],
    customToolkits: [userManagement],
  },
});

const tools = await session.tools();

import base64

from pydantic import BaseModel, Field

from composio import Composio


composio = Composio(api_key="your_api_key")


class UserLookupInput(BaseModel):
    user_id: str = Field(description="User ID")


USERS = {
    "user_1": {"name": "Alice Johnson", "email": "alice@myapp.com", "tier": "enterprise"},
    "user_2": {"name": "Bob Smith", "email": "bob@myapp.com", "tier": "free"},
}


@composio.experimental.tool()
def get_user_profile(input: UserLookupInput, ctx):
    """Retrieve the current user's profile from the internal directory."""
    profile = USERS.get(input.user_id)
    if not profile:
        raise ValueError(f'No profile found for user "{input.user_id}"')
    return profile


class PromoEmailInput(BaseModel):
    to: str = Field(description="Recipient email address")


@composio.experimental.tool(extends_toolkit="gmail")
def send_promo_email(input: PromoEmailInput, ctx):
    """Send the standard promotional email to a recipient."""
    subject = "You're invited to try MyApp Pro"
    body = (
        "Hi there,\n\n"
        "We'd love for you to try MyApp Pro — free for 14 days.\n\n"
        "Best,\nThe MyApp Team"
    )
    raw_msg = (
        f"To: {input.to}\r\n"
        f"Subject: {subject}\r\n"
        "Content-Type: text/plain; charset=UTF-8\r\n\r\n"
        f"{body}"
    )
    raw = base64.urlsafe_b64encode(raw_msg.encode()).decode().rstrip("=")

    res = ctx.proxy_execute(
        toolkit="gmail",
        endpoint="https://gmail.googleapis.com/gmail/v1/users/me/messages/send",
        method="POST",
        body={"raw": raw},
    )
    return {"status": res.status, "to": input.to}


user_management = composio.experimental.Toolkit(
    slug="USER_MANAGEMENT",
    name="User management",
    description="Manage user roles and permissions",
)


class AssignRoleInput(BaseModel):
    user_id: str = Field(description="Target user ID")
    role: str = Field(description="Role to assign")


@user_management.tool()
def assign_role(input: AssignRoleInput, ctx):
    """Assign a role to a user in the internal system."""
    return {"user_id": input.user_id, "role": input.role, "assigned": True}


session = composio.create(
    user_id="user_1",
    toolkits=["gmail"],
    experimental={
        "custom_tools": [get_user_profile, send_promo_email],
        "custom_toolkits": [user_management],
    },
)

tools = session.tools()

How custom tools work with meta tools

Custom tools integrate seamlessly with Composio's meta tools:

• COMPOSIO_SEARCH_TOOLS automatically includes your custom tools and toolkits in search results, giving slight priority to tools that don't require auth or are already connected
• COMPOSIO_GET_TOOL_SCHEMAS returns schemas for custom tools alongside remote tools — the agent sees them as first-class tools
• COMPOSIO_MULTI_EXECUTE_TOOL intelligently splits execution — custom tools run in-process while remote tools go to the backend, results are merged transparently
• COMPOSIO_MANAGE_CONNECTIONS handles auth for extension tools — if a tool extends gmail, the agent can prompt the user to connect Gmail just like any other toolkit
• Custom tools are not supported in Workbench — the LLM is made aware of this and will not attempt to use them there

Best practices

• Descriptive names and slugs — The agent sees your tool's name and description to decide when to use it. Be specific: "Send weekly promo email" is better than "Send email". In TypeScript, define uppercase slugs like SEND_PROMO_EMAIL. In Python, inferred slugs come from the function name, so snake_case function names produce the cleanest defaults; or pass slug= / name= explicitly.
• Detailed descriptions — Include what the tool does, when to use it, and what it returns. The agent relies on this to pick the right tool.
• Use extendsToolkit / extends_toolkit for auth — If your tool needs Gmail/GitHub/etc. auth for ctx.proxyExecute() / ctx.proxy_execute() or ctx.execute(), set the toolkit extension so connection management is handled seamlessly via COMPOSIO_MANAGE_CONNECTIONS.
• In Python, annotations are the schema — The first parameter must be a Pydantic BaseModel, and its field descriptions become the input schema. Docstrings are used as the default tool description unless you pass description=.
• Tool names get prefixed — Slugs exposed to the agent are automatically prefixed with LOCAL_ and the toolkit name (if any). GET_USER_PROFILE becomes LOCAL_GET_USER_PROFILE, ASSIGN_ROLE in USER_MANAGEMENT becomes LOCAL_USER_MANAGEMENT_ASSIGN_ROLE. Your slugs cannot start with LOCAL_ — this prefix is reserved.

For more best practices, see How to Build Tools for AI Agents: A Field Guide.

Verifying registration

Use session.customTools() / session.customToolkits() in TypeScript or session.custom_tools() / session.custom_toolkits() in Python to list registered tools and toolkits. Registered tool slugs include their final LOCAL_ prefix, and toolkit-scoped tools also include the toolkit slug.

Reference: TypeScript ToolRouterSession · Python ToolRouterSession

Programmatic execution

Use session.execute() to run custom tools directly, outside of an agent loop (e.g. session.execute("GET_USER_PROFILE")). Custom tools execute in-process; remote tools are sent to the backend automatically.

Reference: TypeScript ToolRouterSession · Python ToolRouterSession

SessionContext

Every custom tool's execute function receives (input, ctx). The ctx object provides:

In Python, parameters dictionaries accept both in and type; this guide uses in to match the TypeScript examples.

Reference: TypeScript SessionContextImpl · Python SessionContextImpl