2
import { mockClient } from '../utils/mocks/client.mock';
3
import { toolMocks } from '../utils/mocks/data.mock';
4
import { Tool, ToolListParams, ToolExecuteParams } from '../../src/types/tool.types';
5
+import { ExecuteToolFn } from '../../src/types/provider.types';
6
import { Tools } from '../../src/models/Tools';
6
-import ComposioClient from '@composio/client';
7
import {
8
createTestContext,
9
setupTest,
13
import { MockProvider } from '../utils/mocks/provider.mock';
14
import { ValidationError } from '../../src/errors/ValidationErrors';
15
16
+// Minimal structural shape for a ComposioError-like value (possibly wrapping
17
+// another error as its `cause`), used to narrow `catch (error: unknown)`
18
+// blocks that assert on `.code` / `.message` / `.possibleFixes`.
19
+type ErrorWithPossibleFixes = {
20
+ code?: string;
21
+ message?: string;
22
+ possibleFixes?: string[];
23
+ cause?: {
24
+ code?: string;
25
+ message?: string;
26
+ possibleFixes?: string[];
27
+ };
28
+};
29
+
30
describe('Tools', () => {
31
const context = createTestContext();
32
setupTest(context);
33
34
describe('constructor', () => {
35
it('should throw an error if client is not provided', () => {
22
- expect(() => new Tools(null as any, { provider: context.mockProvider })).toThrow(
36
+ expect(() => new Tools(null as unknown, { provider: context.mockProvider })).toThrow(
37
'ComposioClient is required'
38
);
39
});
40
41
it('should throw an error if provider is not provided', () => {
28
- expect(() => new Tools(mockClient as unknown as ComposioClient, null as any)).toThrow(
42
+ expect(() => new Tools(mockClient, null as unknown)).toThrow(
43
'Provider not passed into Tools instance'
44
);
45
});
310
it('should throw a validation error when scopes are provided without toolkits', async () => {
311
const invalidQuery = {
312
scopes: ['task:add'],
299
- } as any;
313
+ } as unknown;
314
315
await expect(context.tools.getRawComposioTools(invalidQuery)).rejects.toThrow(
316
'Invalid tool list parameters'
349
});
350
351
it('should throw an error if schema modifier is not a function', async () => {
338
- const invalidModifier = 'not a function' as any;
352
+ const invalidModifier = 'not a function' as unknown;
353
354
mockClient.tools.list.mockResolvedValueOnce({
355
items: [toolMocks.rawTool],
370
const invalidQuery = {
371
tools: ['TOOL1'],
372
toolkits: ['github'],
359
- } as any;
373
+ } as unknown;
374
375
await expect(context.tools.getRawComposioTools(invalidQuery)).rejects.toThrow(
376
'Invalid tool list parameters'
378
});
379
380
it('should throw a validation error when no required parameters are provided', async () => {
367
- const emptyQuery = {} as any;
381
+ const emptyQuery = {} as unknown;
382
383
await expect(context.tools.getRawComposioTools(emptyQuery)).rejects.toThrow(ValidationError);
384
});
507
mockClient.tools.retrieve.mockResolvedValueOnce(toolMocks.rawTool);
508
509
// Create a Tools instance with SDK-level toolkitVersions as mapping object
496
- const toolsWithVersions = new Tools(mockClient as any, {
510
+ const toolsWithVersions = new Tools(mockClient, {
511
provider: context.mockProvider,
512
toolkitVersions: versionMapping,
513
});
547
const explicitVersion = '20250909_00';
548
549
// Create a Tools instance with SDK-level toolkitVersions
536
- const toolsWithVersions = new Tools(mockClient as any, {
550
+ const toolsWithVersions = new Tools(mockClient, {
551
provider: context.mockProvider,
552
toolkitVersions: { github: explicitVersion },
553
});
1240
it('should throw validation error for invalid parameters', async () => {
1241
const invalidProxyParams = {
1242
endpoint: '/api/test',
1229
- method: 'INVALID_METHOD' as any,
1243
+ method: 'INVALID_METHOD' as unknown,
1244
parameters: [
1245
{
1246
in: 'header' as const,
1336
const invalidBody = {
1337
// missing sessionId
1338
arguments: { query: 'test' },
1325
- } as any;
1339
+ } as unknown;
1340
1341
await expect(
1342
context.tools.executeSessionTool('COMPOSIO_TOOL', invalidBody)
1522
it('should create execute function that calls executeSessionTool', async () => {
1523
const tools = [toolMocks.transformedTool as unknown as Tool];
1524
1511
- let capturedExecuteFn: (toolSlug: string, input: Record<string, unknown>) => Promise<any>;
1525
+ let capturedExecuteFn: (
1526
+ toolSlug: string,
1527
+ input: Record<string, unknown>
1528
+ ) => Promise<unknown>;
1529
1530
context.mockProvider.wrapTools.mockImplementation((tools, executeFn) => {
1531
capturedExecuteFn = executeFn;
1569
})),
1570
};
1571
1555
- let capturedExecuteFn: (toolSlug: string, input: Record<string, unknown>) => Promise<any>;
1572
+ let capturedExecuteFn: (
1573
+ toolSlug: string,
1574
+ input: Record<string, unknown>
1575
+ ) => Promise<unknown>;
1576
1577
context.mockProvider.wrapTools.mockImplementation((tools, executeFn) => {
1578
capturedExecuteFn = executeFn;
1653
1654
it('should pass global version string when configured', async () => {
1655
const mockProvider = new MockProvider();
1636
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1656
+ const tools = new Tools(mockClient, {
1657
provider: mockProvider,
1638
- toolkitVersions: '20251201_03' as any,
1658
+ toolkitVersions: '20251201_03' as unknown,
1659
});
1660
1661
mockClient.tools.list.mockResolvedValueOnce({
1677
1678
it('should pass toolkit-specific versions when configured as object', async () => {
1679
const mockProvider = new MockProvider();
1660
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1680
+ const tools = new Tools(mockClient, {
1681
provider: mockProvider,
1682
toolkitVersions: {
1683
github: '20251201_01',
1709
1710
it('should pass versions when fetching tools by tool slugs', async () => {
1711
const mockProvider = new MockProvider();
1692
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1712
+ const tools = new Tools(mockClient, {
1713
provider: mockProvider,
1714
toolkitVersions: {
1715
github: '20251201_01',
1739
1740
it('should pass versions when searching tools', async () => {
1741
const mockProvider = new MockProvider();
1722
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1742
+ const tools = new Tools(mockClient, {
1743
provider: mockProvider,
1744
toolkitVersions: 'latest',
1745
});
1780
1781
it('should pass global version when retrieving single tool', async () => {
1782
const mockProvider = new MockProvider();
1763
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1783
+ const tools = new Tools(mockClient, {
1784
provider: mockProvider,
1765
- toolkitVersions: '20251201_03' as any,
1785
+ toolkitVersions: '20251201_03' as unknown,
1786
});
1787
1788
mockClient.tools.retrieve.mockResolvedValueOnce(toolMocks.rawTool);
1800
1801
it('should pass toolkit-specific versions when retrieving single tool', async () => {
1802
const mockProvider = new MockProvider();
1783
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1803
+ const tools = new Tools(mockClient, {
1804
provider: mockProvider,
1805
toolkitVersions: {
1806
github: '20251201_01',
1858
1859
it('should use global version when configured', async () => {
1860
const mockProvider = new MockProvider();
1841
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1861
+ const tools = new Tools(mockClient, {
1862
provider: mockProvider,
1843
- toolkitVersions: '20251201_03' as any,
1863
+ toolkitVersions: '20251201_03' as unknown,
1864
});
1865
const spies = await mockToolExecution(tools);
1866
1889
1890
it('should use toolkit-specific version when configured as object', async () => {
1891
const mockProvider = new MockProvider();
1872
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1892
+ const tools = new Tools(mockClient, {
1893
provider: mockProvider,
1894
toolkitVersions: {
1895
'test-toolkit': '20251201_01', // Use the actual toolkit slug from mock
1934
1935
it('should use fallback to "latest" when toolkit not in version mapping', async () => {
1936
const mockProvider = new MockProvider();
1917
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1937
+ const tools = new Tools(mockClient, {
1938
provider: mockProvider,
1939
toolkitVersions: {
1940
github: '20251201_01',
1977
1978
it('should prioritize explicit version parameter over configured versions', async () => {
1979
const mockProvider = new MockProvider();
1960
- const tools = new Tools(mockClient as unknown as ComposioClient, {
1980
+ const tools = new Tools(mockClient, {
1981
provider: mockProvider,
1982
toolkitVersions: {
1983
github: '20251201_01',
2013
2014
it('should handle tool without toolkit gracefully', async () => {
2015
const mockProvider = new MockProvider();
1996
- const tools = new Tools(mockClient as unknown as ComposioClient, {
2016
+ const tools = new Tools(mockClient, {
2017
provider: mockProvider,
2018
toolkitVersions: {
2019
github: '20251201_01',
2074
2075
const mockProvider = new MockProvider();
2076
// Pass the processed environment variables to the Tools constructor
2057
- const tools = new Tools(mockClient as unknown as ComposioClient, {
2077
+ const tools = new Tools(mockClient, {
2078
provider: mockProvider,
2079
toolkitVersions: {
2080
github: '20251201_08',
2108
process.env.COMPOSIO_TOOLKIT_VERSION_SLACK = 'latest';
2109
2110
const mockProvider = new MockProvider();
2091
- const tools = new Tools(mockClient as unknown as ComposioClient, {
2111
+ const tools = new Tools(mockClient, {
2112
provider: mockProvider,
2113
toolkitVersions: {
2114
github: '20251201_04', // should override env
2142
process.env.COMPOSIO_TOOLKIT_VERSION_SLACK = 'latest';
2143
2144
const mockProvider = new MockProvider();
2125
- const tools = new Tools(mockClient as unknown as ComposioClient, {
2145
+ const tools = new Tools(mockClient, {
2146
provider: mockProvider,
2127
- toolkitVersions: '20251201_09' as any, // global version overrides everything
2147
+ toolkitVersions: '20251201_09' as unknown, // global version overrides everything
2148
});
2149
2150
mockClient.tools.list.mockResolvedValueOnce({
2227
2228
it('should succeed when executing with a specific version (not "latest") without dangerouslySkipVersionCheck', async () => {
2229
const mockProvider = new MockProvider();
2210
- const tools = new Tools(mockClient as unknown as ComposioClient, {
2230
+ const tools = new Tools(mockClient, {
2231
provider: mockProvider,
2232
toolkitVersions: {
2233
'test-toolkit': '20251201_01',
2300
2301
it('should throw error when explicit version parameter is "latest" without dangerouslySkipVersionCheck', async () => {
2302
const mockProvider = new MockProvider();
2283
- const tools = new Tools(mockClient as unknown as ComposioClient, {
2303
+ const tools = new Tools(mockClient, {
2304
provider: mockProvider,
2305
toolkitVersions: {
2306
'test-toolkit': '20251201_01', // specific version in config
2339
try {
2340
await context.tools.execute('GITHUB_CREATE_ISSUE', executeParams);
2341
expect.fail('Should have thrown an error');
2322
- } catch (error: any) {
2342
+ } catch (rawError: unknown) {
2343
+ const error = rawError as unknown as ErrorWithPossibleFixes;
2344
// The error should be wrapped in ComposioToolExecutionError
2345
expect(error).toBeDefined();
2346
2385
);
2386
2387
// Mock provider wrapping
2367
- context.mockProvider.wrapTools.mockImplementation((tools, executeToolFn) => {
2368
- // Store the execute function so we can test it
2369
- (context as any).storedExecuteToolFn = executeToolFn;
2388
+ let storedExecuteToolFn: ExecuteToolFn | undefined;
2389
+ context.mockProvider.wrapTools.mockImplementation((_tools, executeToolFn) => {
2390
+ storedExecuteToolFn = executeToolFn;
2391
return 'wrapped-tools-collection';
2392
});
2393
2394
// Get the tool (this will internally create the execute tool function)
2395
await context.tools.get(userId, 'GITHUB_CREATE_ISSUE');
2396
2376
- // Now call the stored execute function (simulating agentic provider calling it)
2377
- const storedExecuteToolFn = (context as any).storedExecuteToolFn;
2397
expect(storedExecuteToolFn).toBeDefined();
2398
2399
// Setup mocks for the actual execution
2401
2402
// Call the execute function that was passed to the provider
2403
// This should succeed because createExecuteToolFn sets dangerouslySkipVersionCheck: true
2385
- const result = await storedExecuteToolFn('GITHUB_CREATE_ISSUE', { title: 'Test Issue' });
2404
+ const result = await storedExecuteToolFn!('GITHUB_CREATE_ISSUE', { title: 'Test Issue' });
2405
2406
expect(result).toEqual(toolMocks.toolExecuteResponse);
2407
expect(mockClient.tools.execute).toHaveBeenCalledWith(