1
// creating a custom tool with a toolkit
2
await composio.tools.createCustomTool({
3
  name: 'My Custom Tool',
4
  description: 'A custom tool that does something specific',
5
  slug: 'MY_CUSTOM_TOOL',
6
  userId: 'default',
7
  connectedAccountId: '123',
8
  toolkitSlug: 'github',
9
  inputParameters: z.object({
10
    param1: z.string().describe('First parameter'),
11
  }),
12
  execute: async (input, connectionConfig, executeToolRequest) => {
13
    // Custom logic here
14
    return { data: { result: 'Success!' } };
15
  }
16
});

1
// creating a custom tool without a toolkit
2
await composio.tools.createCustomTool({
3
  name: 'My Custom Tool',
4
  description: 'A custom tool that does something specific',
5
  slug: 'MY_CUSTOM_TOOL',
6
  inputParameters: z.object({
7
    param1: z.string().describe('First parameter'),
8
  }),
9
  execute: async (input) => {
10
    // Custom logic here
11
    return { data: { result: 'Success!' } };
12
  }
13
});
14
15
***
16
17
### execute()
18
19
> **execute**(`slug`, `body`, `modifiers?`): `Promise`\<\{ \}\>
20
21
Defined in: ts/packages/core/src/models/Tools.ts:724
22
23
Executes a given tool with the provided parameters.
24
25
This method calls the Composio API or a custom tool handler to execute the tool and returns the response.
26
It automatically determines whether to use a custom tool or a Composio API tool based on the slug.
27
28
**Version Control:**
29
By default, manual tool execution requires a specific toolkit version. If the version resolves to "latest",
30
the execution will throw a `ComposioToolVersionRequiredError` unless `dangerouslySkipVersionCheck` is set to `true`.
31
This helps prevent unexpected behavior when new toolkit versions are released.
32
33
#### Parameters
34
35
##### slug
36
37
`string`
38
39
The slug/ID of the tool to be executed
40
41
##### body
42
43
The parameters to be passed to the tool
44
45
##### modifiers?
46
47
`ExecuteToolModifiers`
48
49
Optional modifiers to transform the request or response
50
51
#### Returns
52
53
`Promise`\<\{ \}\>
54
55
- The response from the tool execution
56
57
#### Throws
58
59
If the CustomTools instance is not initialized
60
61
#### Throws
62
63
If the connected account is not found
64
65
#### Throws
66
67
If the tool with the given slug is not found
68
69
#### Throws
70
71
If version resolves to "latest" and dangerouslySkipVersionCheck is not true
72
73
#### Throws
74
75
If there is an error during tool execution
76
77
#### Examples
78
79
```typescript
80
const result = await composio.tools.execute('GITHUB_GET_REPOS', {
81
  userId: 'default',
82
  version: '20250909_00',
83
  arguments: { owner: 'composio' }
84
});

1
const result = await composio.tools.execute('HACKERNEWS_GET_USER', {
2
  userId: 'default',
3
  arguments: { userId: 'pg' },
4
  dangerouslySkipVersionCheck: true // Allows execution with "latest" version
5
});

1
// If toolkitVersions are set during Composio initialization, no need to pass version
2
const composio = new Composio({ toolkitVersions: { github: '20250909_00' } });
3
const result = await composio.tools.execute('GITHUB_GET_REPOS', {
4
  userId: 'default',
5
  arguments: { owner: 'composio' }
6
});

1
const result = await composio.tools.execute('GITHUB_GET_ISSUES', {
2
  userId: 'default',
3
  version: '20250909_00',
4
  arguments: { owner: 'composio', repo: 'sdk' }
5
}, {
6
  beforeExecute: ({ toolSlug, toolkitSlug, params }) => {
7
    console.log(`Executing ${toolSlug} from ${toolkitSlug}`);
8
    return params;
9
  },
10
  afterExecute: ({ toolSlug, toolkitSlug, result }) => {
11
    console.log(`Completed ${toolSlug}`);
12
    return result;
13
  }
14
});

1
// Get tools from the GitHub toolkit
2
const tools = await composio.tools.get('default', {
3
  toolkits: ['github'],
4
  limit: 10
5
});
6
7
// Get tools with search
8
const searchTools = await composio.tools.get('default', {
9
  search: 'user',
10
  limit: 10
11
});
12
13
// Get a specific tool by slug
14
const hackerNewsUserTool = await composio.tools.get('default', 'HACKERNEWS_GET_USER');
15
16
// Get a tool with schema modifications
17
const tool = await composio.tools.get('default', 'GITHUB_GET_REPOS', {
18
  modifySchema: (toolSlug, toolkitSlug, schema) => {
19
    // Customize the tool schema
20
    return {...schema, description: 'Custom description'};
21
  }
22
});

1
// Get a specific tool by slug
2
const hackerNewsUserTool = await composio.tools.get('default', 'HACKERNEWS_GET_USER');
3
4
// Get a tool with schema modifications
5
const tool = await composio.tools.get('default', 'GITHUB_GET_REPOS', {
6
  modifySchema: (toolSlug, toolkitSlug, schema) => {
7
    // Customize the tool schema
8
    return {...schema, description: 'Custom description'};
9
  }
10
});

1
// Get input parameters for a specific tool
2
const inputParams = await composio.tools.getInput('GITHUB_CREATE_ISSUE', {
3
  userId: 'default'
4
});
5
console.log(inputParams.schema);

1
// Get a tool by slug
2
const tool = await composio.tools.getRawComposioToolBySlug('GITHUB_GET_REPOS');
3
console.log(tool.name, tool.description);
4
5
// Get a tool with schema transformation
6
const customizedTool = await composio.tools.getRawComposioToolBySlug(
7
  'SLACK_SEND_MESSAGE',
8
  {
9
    modifySchema: ({ toolSlug, toolkitSlug, schema }) => {
10
      return {
11
        ...schema,
12
        description: `Enhanced ${schema.description} with custom modifications`,
13
        customMetadata: {
14
          lastModified: new Date().toISOString(),
15
          toolkit: toolkitSlug
16
        }
17
      };
18
    }
19
  }
20
);
21
22
// Get a custom tool (will check custom tools first)
23
const customTool = await composio.tools.getRawComposioToolBySlug('MY_CUSTOM_TOOL');
24
25
// Access tool properties
26
const githubTool = await composio.tools.getRawComposioToolBySlug('GITHUB_CREATE_ISSUE');
27
console.log({
28
  slug: githubTool.slug,
29
  name: githubTool.name,
30
  toolkit: githubTool.toolkit?.name,
31
  version: githubTool.version,
32
  availableVersions: githubTool.availableVersions,
33
  inputParameters: githubTool.inputParameters
34
});

1
// Get tools from specific toolkits
2
const githubTools = await composio.tools.getRawComposioTools({
3
  toolkits: ['github'],
4
  limit: 10
5
});
6
7
// Get specific tools by slug
8
const specificTools = await composio.tools.getRawComposioTools({
9
  tools: ['GITHUB_GET_REPOS', 'HACKERNEWS_GET_USER']
10
});
11
12
// Get tools from specific toolkits
13
const githubTools = await composio.tools.getRawComposioTools({
14
  toolkits: ['github'],
15
  limit: 10
16
});
17
18
// Get tools with schema transformation
19
const customizedTools = await composio.tools.getRawComposioTools({
20
  toolkits: ['github'],
21
  limit: 5
22
}, {
23
  modifySchema: ({ toolSlug, toolkitSlug, schema }) => {
24
    // Add custom properties to tool schema
25
    return {
26
      ...schema,
27
      customProperty: `Modified ${toolSlug} from ${toolkitSlug}`,
28
      tags: [...(schema.tags || []), 'customized']
29
    };
30
  }
31
});
32
33
// Search for tools
34
const searchResults = await composio.tools.getRawComposioTools({
35
  search: 'user management'
36
});
37
38
// Get tools by authentication config
39
const authSpecificTools = await composio.tools.getRawComposioTools({
40
  authConfigIds: ['auth_config_123']
41
});

1
// Get all available tools as an enum
2
const toolsEnum = await composio.tools.getToolsEnum();
3
console.log(toolsEnum.items);

1
// Send a custom request to a toolkit
2
const response = await composio.tools.proxyExecute({
3
  toolkitSlug: 'github',
4
  userId: 'default',
5
  data: {
6
    endpoint: '/repos/owner/repo/issues',
7
    method: 'GET'
8
  }
9
});
10
console.log(response.data);